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

* init

* minor naming change

* address to comments round 1

* update dependencies

* formatting

* make sure it rotates

* update changelog

---------

Co-authored-by: Jason Dove <1695733+jasongdove@users.noreply.github.com>

.config/dotnet-tools.json

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

.editorconfig

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

.gitattributes

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

.github/workflows/artifacts.yml

@@ -33,33 +33,21 @@ jobs:
     strategy:
       matrix:
         include:
-          - os: macos-latest
+          - os: macos-12
             kind: macOS
             target: osx-x64
-          - os: macos-latest
+          - os: macos-12
             kind: macOS
             target: osx-arm64
     steps:
       - name: Get the sources
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
           submodules: true
 
       - name: Setup .NET Core
-        uses: actions/setup-dotnet@v3
-        with:
-          dotnet-version: 7.0.x
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v3
-        with:
-          node-version: '14'
-
-      - name: Cache NPM dependencies
-        uses: bahmutov/npm-install@v1.4.5
-        with:
-          working-directory: ErsatzTV/client-app
+        uses: actions/setup-dotnet@v4
 
       - name: Clean
         run: dotnet clean --configuration Release && dotnet nuget locals all --clear
@@ -68,7 +56,7 @@ jobs:
         run: dotnet restore -r "${{ matrix.target}}"
 
       - name: Import Code-Signing Certificates
-        uses: Apple-Actions/import-codesign-certs@v1
+        uses: Apple-Actions/import-codesign-certs@v2
         with:
           p12-file-base64: ${{ secrets.apple_developer_certificate_p12_base64 }}
           p12-password: ${{ secrets.apple_developer_certificate_password }}
@@ -83,8 +71,8 @@ jobs:
         shell: bash
         run: |
           sed -i '' '/Scanner/d' ErsatzTV/ErsatzTV.csproj
-          dotnet publish ErsatzTV.Scanner/ErsatzTV.Scanner.csproj --framework net7.0 --runtime "${{ matrix.target }}" -c Release -o publish -p:InformationalVersion="${{ inputs.release_version }}-${{ matrix.target }}" -p:EnableCompressionInSingleFile=true -p:DebugType=Embedded -p:PublishSingleFile=true --self-contained true
-          dotnet publish ErsatzTV/ErsatzTV.csproj --framework net7.0 --runtime "${{ matrix.target }}" -c Release -o publish -p:InformationalVersion="${{ inputs.release_version }}-${{ matrix.target }}" -p:EnableCompressionInSingleFile=true -p:DebugType=Embedded -p:PublishSingleFile=true --self-contained true
+          dotnet publish ErsatzTV.Scanner/ErsatzTV.Scanner.csproj --framework net8.0 --runtime "${{ matrix.target }}" -c Release -o publish -p:InformationalVersion="${{ inputs.release_version }}-${{ matrix.target }}" -p:EnableCompressionInSingleFile=false -p:DebugType=Embedded -p:PublishSingleFile=true --self-contained true
+          dotnet publish ErsatzTV/ErsatzTV.csproj --framework net8.0 --runtime "${{ matrix.target }}" -c Release -o publish -p:InformationalVersion="${{ inputs.release_version }}-${{ matrix.target }}" -p:EnableCompressionInSingleFile=false -p:DebugType=Embedded -p:PublishSingleFile=true --self-contained true
 
       - name: Bundle
         shell: bash
@@ -97,7 +85,7 @@ jobs:
       - name: Sign
         shell: bash
         run: scripts/macOS/sign.sh
-      
+
       - name: Create DMG
         shell: bash
         run: |
@@ -112,18 +100,15 @@ jobs:
             --hide-extension "ErsatzTV.app" \
             --app-drop-link 600 185 \
             --skip-jenkins \
+            --no-internet-enable \
             "ErsatzTV.dmg" \
             "ErsatzTV.app/"
 
       - name: Notarize
         shell: bash
         run: |
-          brew tap mitchellh/gon
-          brew install mitchellh/gon/gon
-          gon -log-level=debug -log-json ./gon.json
-        env:
-          AC_USERNAME: ${{ secrets.ac_username }}
-          AC_PASSWORD: ${{ secrets.ac_password }}
+          xcrun notarytool submit ErsatzTV.dmg --apple-id "${{ secrets.ac_username }}" --password "${{ secrets.ac_password }}" --team-id 32MB98Q32R --wait
+          xcrun stapler staple ErsatzTV.dmg
 
       - name: Cleanup
         shell: bash
@@ -133,7 +118,7 @@ jobs:
           rm -r ErsatzTV.app
 
       - name: Delete old release assets
-        uses: asfernandes/delete-release-assets@update-libraries-and-node
+        uses: mknejp/delete-release-assets@v1
         if: ${{ inputs.release_tag == 'develop' }}
         with:
           token: ${{ secrets.gh_token }}
@@ -172,30 +157,12 @@ jobs:
             target: win-x64
     steps:
       - name: Get the sources
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
 
       - name: Setup .NET Core
-        uses: actions/setup-dotnet@v3
-        with:
-          dotnet-version: 7.0.x
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v3
-        with:
-          node-version: '14'
-
-      - name: Setup Rust
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-        if: ${{ matrix.kind == 'windows' }}
-
-      - name: Cache NPM dependencies
-        uses: bahmutov/npm-install@v1.4.5
-        with:
-          working-directory: ErsatzTV/client-app
+        uses: actions/setup-dotnet@v4
 
       - name: Clean
         run: dotnet clean --configuration Release && dotnet nuget locals all --clear
@@ -203,12 +170,12 @@ jobs:
       - name: Install dependencies
         run: dotnet restore -r "${{ matrix.target }}"
 
-      - uses: suisei-cn/actions-download-file@v1
+      - uses: suisei-cn/actions-download-file@v1.3.0
         if: ${{ matrix.kind == 'windows' }}
         id: downloadffmpeg
         name: Download ffmpeg
         with:
-          url: "https://github.com/GyanD/codexffmpeg/releases/download/5.1/ffmpeg-5.1-full_build.7z"
+          url: "https://github.com/ErsatzTV/ErsatzTV-ffmpeg/releases/download/6.1-working-cuvid/ffmpeg-6.1-working-cuvid.7z"
           target: ffmpeg/
 
       - name: Build
@@ -220,8 +187,11 @@ jobs:
 
           # Build everything
           sed -i '/Scanner/d' ErsatzTV/ErsatzTV.csproj
-          dotnet publish ErsatzTV.Scanner/ErsatzTV.Scanner.csproj --framework net7.0 --runtime "${{ matrix.target }}" -c Release -o "$release_name" -p:InformationalVersion="${{ inputs.release_version }}-${{ matrix.target }}" -p:EnableCompressionInSingleFile=true -p:DebugType=Embedded -p:PublishSingleFile=true --self-contained true
-          dotnet publish ErsatzTV/ErsatzTV.csproj --framework net7.0 --runtime "${{ matrix.target }}" -c Release -o "$release_name" -p:InformationalVersion="${{ inputs.release_version }}-${{ matrix.target }}" -p:EnableCompressionInSingleFile=true -p:DebugType=Embedded -p:PublishSingleFile=true --self-contained true
+          dotnet publish ErsatzTV.Scanner/ErsatzTV.Scanner.csproj --framework net8.0 --runtime "${{ matrix.target }}" -c Release -o "scanner" -p:InformationalVersion="${{ inputs.release_version }}-${{ matrix.target }}" -p:EnableCompressionInSingleFile=true -p:DebugType=Embedded -p:PublishSingleFile=true --self-contained true
+          dotnet publish ErsatzTV/ErsatzTV.csproj --framework net8.0 --runtime "${{ matrix.target }}" -c Release -o "main" -p:InformationalVersion="${{ inputs.release_version }}-${{ matrix.target }}" -p:EnableCompressionInSingleFile=true -p:DebugType=Embedded -p:PublishSingleFile=true --self-contained true
+          mkdir "$release_name"
+          mv scanner/* "$release_name/"
+          mv main/* "$release_name/"
 
           # Build Windows launcher
           if [ "${{ matrix.kind }}" == "windows" ]; then
@@ -245,12 +215,9 @@ jobs:
 
           # Delete output directory
           rm -r "$release_name"
-        env:
-          AC_USERNAME: ${{ secrets.ac_username }}
-          AC_PASSWORD: ${{ secrets.ac_password }}
 
       - name: Delete old release assets
-        uses: asfernandes/delete-release-assets@update-libraries-and-node
+        uses: mknejp/delete-release-assets@v1
         if: ${{ inputs.release_tag == 'develop' }}
         with:
           token: ${{ secrets.gh_token }}
@@ -259,6 +226,7 @@ jobs:
           assets: |
             *${{ matrix.target }}.zip
             *${{ matrix.target }}.tar.gz
+
       - name: Publish
         uses: softprops/action-gh-release@v1
         with:

.github/workflows/ci.yml

@@ -10,7 +10,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Get the sources
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
       - name: Extract Docker Tag
@@ -34,7 +34,7 @@ jobs:
       artifacts_version: ${{ env.ARTIFACTS_VERSION }}
       info_version: ${{ env.INFO_VERSION }}
   build_and_upload:
-    uses: jasongdove/ersatztv/.github/workflows/artifacts.yml@main
+    uses: ersatztv/ersatztv/.github/workflows/artifacts.yml@main
     needs: calculate_version
     with:
       release_tag: develop
@@ -47,7 +47,7 @@ jobs:
       ac_password: ${{ secrets.AC_PASSWORD }}
       gh_token: ${{ secrets.GITHUB_TOKEN }}
   build_and_push:
-    uses: jasongdove/ersatztv/.github/workflows/docker.yml@main
+    uses: ersatztv/ersatztv/.github/workflows/docker.yml@main
     needs: calculate_version
     with:
       base_version: develop

.github/workflows/code_quality.yml

@@ -0,0 +1,23 @@
+name: Qodana
+on:
+  workflow_dispatch:
+  push:
+    branches:
+      - main
+
+jobs:
+  qodana:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      pull-requests: write
+      checks: write
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          ref: ${{ github.event.pull_request.head.sha }}  # to check out the actual pull request commit, not the merge commit
+          fetch-depth: 0  # a full history is required for pull request analysis
+      - name: 'Qodana Scan'
+        uses: JetBrains/qodana-action@v2024.1
+        env:
+          QODANA_TOKEN: ${{ secrets.QODANA_TOKEN }}

.github/workflows/docker.yml

@@ -49,26 +49,26 @@ jobs:
             qemu: true
     steps:
       - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
 
       - name: Set up QEMU
-        uses: docker/setup-qemu-action@v2
+        uses: docker/setup-qemu-action@v3
         if: ${{ matrix.qemu == true }}
 
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v2
+        uses: docker/setup-buildx-action@v3
         id: docker-buildx
 
       - name: Login to DockerHub
-        uses: docker/login-action@v2
+        uses: docker/login-action@v3
         with:
           username: ${{ secrets.docker_hub_username }}
           password: ${{ secrets.docker_hub_access_token }}
 
       - name: Build and push
-        uses: docker/build-push-action@v3
+        uses: docker/build-push-action@v5
         with:
           builder: ${{ steps.docker-buildx.outputs.name }}
           context: .
@@ -82,7 +82,7 @@ jobs:
         if: ${{ matrix.name != 'arm64' && matrix.name != 'arm32v7' }}
 
       - name: Build and push
-        uses: docker/build-push-action@v3
+        uses: docker/build-push-action@v5
         with:
           builder: ${{ steps.docker-buildx.outputs.name }}
           context: .
@@ -97,7 +97,7 @@ jobs:
         if: ${{ matrix.name == 'arm64' }}
 
       - name: Build and push
-        uses: docker/build-push-action@v3
+        uses: docker/build-push-action@v5
         with:
           builder: ${{ steps.docker-buildx.outputs.name }}
           context: .

.github/workflows/docs.yml

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

.github/workflows/issue-stale.yml

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

.github/workflows/pr.yml

@@ -6,17 +6,10 @@ jobs:
     runs-on: windows-latest
     steps:
       - name: Get the sources
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
 
       - name: Setup .NET Core
-        uses: actions/setup-dotnet@v3
-        with:
-          dotnet-version: 7.0.x
-
-      - name: Setup Rust
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
+        uses: actions/setup-dotnet@v4
 
       - name: Clean
         run: dotnet clean --configuration Release && dotnet nuget locals all --clear
@@ -31,7 +24,7 @@ jobs:
         run: dotnet build --configuration Release --no-restore
 
       - name: Test
-        run: dotnet test --no-restore --verbosity normal
+        run: dotnet test --blame-hang-timeout "2m" --no-restore --verbosity normal
 
       - name: Build Windows
         run: |
@@ -41,12 +34,10 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Get the sources
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
 
       - name: Setup .NET Core
-        uses: actions/setup-dotnet@v3
-        with:
-          dotnet-version: 7.0.x
+        uses: actions/setup-dotnet@v4
 
       - name: Clean
         run: dotnet clean --configuration Release && dotnet nuget locals all --clear
@@ -61,20 +52,18 @@ jobs:
         run: dotnet build --configuration Release --no-restore
 
       - name: Test
-        run: dotnet test --no-restore --verbosity normal
+        run: dotnet test --blame-hang-timeout "2m" --no-restore --verbosity normal
   build_and_test_mac:
-    runs-on: macos-latest
+    runs-on: macos-12
     steps:
       - name: Get the sources
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
           submodules: true
 
       - name: Setup .NET Core
-        uses: actions/setup-dotnet@v3
-        with:
-          dotnet-version: 7.0.x
+        uses: actions/setup-dotnet@v4
 
       - name: Clean
         run: dotnet clean --configuration Release && dotnet nuget locals all --clear
@@ -89,4 +78,4 @@ jobs:
         run: dotnet build --configuration Release --no-restore
 
       - name: Test
-        run: dotnet test --no-restore --verbosity normal
+        run: dotnet test --blame-hang-timeout "2m" --no-restore --verbosity normal

.github/workflows/release.yml

@@ -8,7 +8,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Get the sources
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
       - name: Extract Docker Tag
@@ -29,7 +29,7 @@ jobs:
       artifacts_version: ${{ env.ARTIFACTS_VERSION }}
       info_version: ${{ env.INFO_VERSION }}
   build_and_upload:
-    uses: jasongdove/ersatztv/.github/workflows/artifacts.yml@main
+    uses: ersatztv/ersatztv/.github/workflows/artifacts.yml@main
     needs: calculate_version
     with:
       release_tag: ${{ needs.calculate_version.outputs.artifacts_version }}
@@ -42,7 +42,7 @@ jobs:
       ac_password: ${{ secrets.AC_PASSWORD }}
       gh_token: ${{ secrets.GITHUB_TOKEN }}
   build_and_push:
-    uses: jasongdove/ersatztv/.github/workflows/docker.yml@main
+    uses: ersatztv/ersatztv/.github/workflows/docker.yml@main
     needs: calculate_version
     with:
       base_version: latest

.github/workflows/vue-lint.yml

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

.gitmodules

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

Directory.Build.props

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

ErsatzTV-Windows/Cargo.lock

@@ -173,6 +173,7 @@ version = "0.1.0"
 dependencies = [
  "process_path",
  "special-folder",
+ "static_vcruntime",
  "tray-item",
  "windows",
  "windres",
@@ -769,6 +770,12 @@ dependencies = [
  "windows-sys",
 ]
 
+[[package]]
+name = "static_vcruntime"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "954e3e877803def9dc46075bf4060147c55cd70db97873077232eae0269dc89b"
+
 [[package]]
 name = "strum"
 version = "0.24.1"

ErsatzTV-Windows/Cargo.toml

@@ -17,3 +17,4 @@ features = [
 
 [build-dependencies]
 windres = "*"
+static_vcruntime = "2.0"

ErsatzTV-Windows/build.rs

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

ErsatzTV-Windows/src/main.rs

@@ -43,10 +43,7 @@ fn main() {
             None => {}
             Some(folder) => {
                 fs::create_dir_all(folder).unwrap();
-                let _ = Command::new("cmd")
-                    .creation_flags(CREATE_NO_WINDOW)
-                    .arg("/C")
-                    .arg("start")
+                let _ = Command::new("explorer.exe")
                     .arg(folder)
                     .stdin(Stdio::null())
                     .stdout(Stdio::null())

ErsatzTV.Application/.editorconfig

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

ErsatzTV.Application/Artists/Mapper.cs

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

ErsatzTV.Application/Artists/Queries/GetAllArtistsHandler.cs

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

ErsatzTV.Application/Artists/Queries/GetArtistByIdHandler.cs

@@ -24,7 +24,7 @@ public class GetArtistByIdHandler : IRequestHandler<GetArtistById, Option<Artist
             async artist =>
             {
                 List<string> mediaCodes = await _searchRepository.GetLanguagesForArtist(artist);
-                List<string> languageCodes = await _searchRepository.GetAllLanguageCodes(mediaCodes);
+                List<string> languageCodes = await _searchRepository.GetAllThreeLetterLanguageCodes(mediaCodes);
                 return ProjectToViewModel(artist, languageCodes);
             },
             () => Task.FromResult(Option<ArtistViewModel>.None));

ErsatzTV.Application/Artworks/Queries/GetArtwork.cs

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

ErsatzTV.Application/Artworks/Queries/GetArtworkHandler.cs

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

ErsatzTV.Application/Channels/ChannelViewModel.cs

@@ -1,4 +1,5 @@
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
+using System.Net;
 
 namespace ErsatzTV.Application.Channels;
 
@@ -12,6 +13,7 @@ public record ChannelViewModel(
     string Logo,
     string PreferredAudioLanguageCode,
     string PreferredAudioTitle,
+    ChannelProgressMode ProgressMode,
     StreamingMode StreamingMode,
     int? WatermarkId,
     int? FallbackFillerId,
@@ -19,4 +21,7 @@ public record ChannelViewModel(
     string PreferredSubtitleLanguageCode,
     ChannelSubtitleMode SubtitleMode,
     ChannelMusicVideoCreditsMode MusicVideoCreditsMode,
-    string MusicVideoCreditsTemplate);
+    string MusicVideoCreditsTemplate)
+{
+    public string WebEncodedName => WebUtility.UrlEncode(Name);
+}

ErsatzTV.Application/Channels/Commands/CreateChannel.cs

@@ -3,8 +3,7 @@ using ErsatzTV.Core.Domain;
 
 namespace ErsatzTV.Application.Channels;
 
-public record CreateChannel
-(
+public record CreateChannel(
     string Name,
     string Number,
     string Group,
@@ -13,6 +12,7 @@ public record CreateChannel
     string Logo,
     string PreferredAudioLanguageCode,
     string PreferredAudioTitle,
+    ChannelProgressMode ProgressMode,
     StreamingMode StreamingMode,
     int? WatermarkId,
     int? FallbackFillerId,

ErsatzTV.Application/Channels/Commands/CreateChannelHandler.cs

@@ -1,41 +1,43 @@
-using System.Globalization;
-using System.Text.RegularExpressions;
+using System.Text.RegularExpressions;
+using System.Threading.Channels;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Domain.Filler;
+using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
 using Microsoft.EntityFrameworkCore;
+using Channel = ErsatzTV.Core.Domain.Channel;
 
 namespace ErsatzTV.Application.Channels;
 
-public class CreateChannelHandler : IRequestHandler<CreateChannel, Either<BaseError, CreateChannelResult>>
+public class CreateChannelHandler(
+    ChannelWriter<IBackgroundServiceRequest> workerChannel,
+    IDbContextFactory<TvContext> dbContextFactory,
+    ISearchTargets searchTargets)
+    : 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)
     {
-        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
         Validation<BaseError, Channel> validation = await Validate(dbContext, request);
         return await validation.Apply(c => PersistChannel(dbContext, c));
     }
 
-    private static async Task<CreateChannelResult> PersistChannel(TvContext dbContext, Channel channel)
+    private async Task<CreateChannelResult> PersistChannel(TvContext dbContext, Channel channel)
     {
         await dbContext.Channels.AddAsync(channel);
         await dbContext.SaveChangesAsync();
+        searchTargets.SearchTargetsChanged();
+        await workerChannel.WriteAsync(new RefreshChannelList());
         return new CreateChannelResult(channel.Id);
     }
 
     private static async Task<Validation<BaseError, Channel>> Validate(TvContext dbContext, CreateChannel request) =>
         (ValidateName(request), await ValidateNumber(dbContext, request),
             await FFmpegProfileMustExist(dbContext, request),
-            ValidatePreferredAudioLanguage(request),
-            ValidatePreferredSubtitleLanguage(request),
             await WatermarkMustExist(dbContext, request),
             await FillerPresetMustExist(dbContext, request))
         .Apply(
@@ -43,8 +45,6 @@ public class CreateChannelHandler : IRequestHandler<CreateChannel, Either<BaseEr
                 name,
                 number,
                 ffmpegProfileId,
-                preferredAudioLanguageCode,
-                preferredSubtitleLanguageCode,
                 watermarkId,
                 fillerPresetId) =>
             {
@@ -68,11 +68,12 @@ public class CreateChannelHandler : IRequestHandler<CreateChannel, Either<BaseEr
                     Group = request.Group,
                     Categories = request.Categories,
                     FFmpegProfileId = ffmpegProfileId,
+                    ProgressMode = request.ProgressMode,
                     StreamingMode = request.StreamingMode,
                     Artwork = artwork,
-                    PreferredAudioLanguageCode = preferredAudioLanguageCode,
+                    PreferredAudioLanguageCode = request.PreferredAudioLanguageCode,
                     PreferredAudioTitle = request.PreferredAudioTitle,
-                    PreferredSubtitleLanguageCode = preferredSubtitleLanguageCode,
+                    PreferredSubtitleLanguageCode = request.PreferredSubtitleLanguageCode,
                     SubtitleMode = request.SubtitleMode,
                     MusicVideoCreditsMode = request.MusicVideoCreditsMode,
                     MusicVideoCreditsTemplate = request.MusicVideoCreditsTemplate
@@ -95,20 +96,6 @@ public class CreateChannelHandler : IRequestHandler<CreateChannel, Either<BaseEr
         createChannel.NotEmpty(c => c.Name)
             .Bind(_ => createChannel.NotLongerThan(50)(c => c.Name));
 
-    private static Validation<BaseError, string> ValidatePreferredAudioLanguage(CreateChannel createChannel) =>
-        Optional(createChannel.PreferredAudioLanguageCode ?? string.Empty)
-            .Filter(
-                lc => string.IsNullOrWhiteSpace(lc) || CultureInfo.GetCultures(CultureTypes.NeutralCultures).Any(
-                    ci => string.Equals(ci.ThreeLetterISOLanguageName, lc, StringComparison.OrdinalIgnoreCase)))
-            .ToValidation<BaseError>("Preferred audio language code is invalid");
-
-    private static Validation<BaseError, string> ValidatePreferredSubtitleLanguage(CreateChannel createChannel) =>
-        Optional(createChannel.PreferredSubtitleLanguageCode ?? string.Empty)
-            .Filter(
-                lc => string.IsNullOrWhiteSpace(lc) || CultureInfo.GetCultures(CultureTypes.NeutralCultures).Any(
-                    ci => string.Equals(ci.ThreeLetterISOLanguageName, lc, StringComparison.OrdinalIgnoreCase)))
-            .ToValidation<BaseError>("Preferred subtitle language code is invalid");
-
     private static async Task<Validation<BaseError, string>> ValidateNumber(
         TvContext dbContext,
         CreateChannel createChannel)

ErsatzTV.Application/Channels/Commands/DeleteChannel.cs

@@ -2,4 +2,4 @@
 
 namespace ErsatzTV.Application.Channels;
 
-public record DeleteChannel(int ChannelId) : IRequest<Either<BaseError, Task>>;
+public record DeleteChannel(int ChannelId) : IRequest<Either<BaseError, Unit>>;

ErsatzTV.Application/Channels/Commands/DeleteChannelHandler.cs

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

ErsatzTV.Application/Channels/Commands/RefreshChannelData.cs

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

ErsatzTV.Application/Channels/Commands/RefreshChannelList.cs

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

ErsatzTV.Application/Channels/Commands/RefreshChannelListHandler.cs

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

ErsatzTV.Application/Channels/Commands/UpdateChannel.cs

@@ -3,8 +3,7 @@ using ErsatzTV.Core.Domain;
 
 namespace ErsatzTV.Application.Channels;
 
-public record UpdateChannel
-(
+public record UpdateChannel(
     int ChannelId,
     string Name,
     string Number,
@@ -14,6 +13,7 @@ public record UpdateChannel
     string Logo,
     string PreferredAudioLanguageCode,
     string PreferredAudioTitle,
+    ChannelProgressMode ProgressMode,
     StreamingMode StreamingMode,
     int? WatermarkId,
     int? FallbackFillerId,

ErsatzTV.Application/Channels/Commands/UpdateChannelHandler.cs

@@ -4,6 +4,7 @@ using System.Threading.Channels;
 using ErsatzTV.Application.Subtitles;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
 using Microsoft.EntityFrameworkCore;
@@ -12,24 +13,17 @@ using Channel = ErsatzTV.Core.Domain.Channel;
 
 namespace ErsatzTV.Application.Channels;
 
-public class UpdateChannelHandler : IRequestHandler<UpdateChannel, Either<BaseError, ChannelViewModel>>
+public class UpdateChannelHandler(
+    ChannelWriter<IBackgroundServiceRequest> workerChannel,
+    IDbContextFactory<TvContext> dbContextFactory,
+    ISearchTargets searchTargets)
+    : IRequestHandler<UpdateChannel, Either<BaseError, ChannelViewModel>>
 {
-    private readonly IDbContextFactory<TvContext> _dbContextFactory;
-    private readonly ChannelWriter<ISubtitleWorkerRequest> _ffmpegWorkerChannel;
-
-    public UpdateChannelHandler(
-        ChannelWriter<ISubtitleWorkerRequest> ffmpegWorkerChannel,
-        IDbContextFactory<TvContext> dbContextFactory)
-    {
-        _ffmpegWorkerChannel = ffmpegWorkerChannel;
-        _dbContextFactory = dbContextFactory;
-    }
-
     public async Task<Either<BaseError, ChannelViewModel>> Handle(
         UpdateChannel request,
         CancellationToken cancellationToken)
     {
-        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
         Validation<BaseError, Channel> validation = await Validate(dbContext, request);
         return await validation.Apply(c => ApplyUpdateRequest(dbContext, c, request));
     }
@@ -73,11 +67,14 @@ public class UpdateChannelHandler : IRequestHandler<UpdateChannel, Either<BaseEr
                 });
         }
 
+        c.ProgressMode = update.ProgressMode;
         c.StreamingMode = update.StreamingMode;
         c.WatermarkId = update.WatermarkId;
         c.FallbackFillerId = update.FallbackFillerId;
         await dbContext.SaveChangesAsync();
 
+        searchTargets.SearchTargetsChanged();
+
         if (c.SubtitleMode != ChannelSubtitleMode.None)
         {
             Option<Playout> maybePlayout = await dbContext.Playouts
@@ -85,18 +82,19 @@ public class UpdateChannelHandler : IRequestHandler<UpdateChannel, Either<BaseEr
 
             foreach (Playout playout in maybePlayout)
             {
-                await _ffmpegWorkerChannel.WriteAsync(new ExtractEmbeddedSubtitles(playout.Id));
+                await workerChannel.WriteAsync(new ExtractEmbeddedSubtitles(playout.Id));
             }
         }
 
+        await workerChannel.WriteAsync(new RefreshChannelList());
+
         return ProjectToViewModel(c);
     }
 
-    private async Task<Validation<BaseError, Channel>> Validate(TvContext dbContext, UpdateChannel request) =>
+    private static async Task<Validation<BaseError, Channel>> Validate(TvContext dbContext, UpdateChannel request) =>
         (await ChannelMustExist(dbContext, request), ValidateName(request),
-            await ValidateNumber(dbContext, request),
-            ValidatePreferredAudioLanguage(request))
-        .Apply((channelToUpdate, _, _, _) => channelToUpdate);
+            await ValidateNumber(dbContext, request))
+        .Apply((channelToUpdate, _, _) => channelToUpdate);
 
     private static Task<Validation<BaseError, Channel>> ChannelMustExist(
         TvContext dbContext,
@@ -131,11 +129,4 @@ public class UpdateChannelHandler : IRequestHandler<UpdateChannel, Either<BaseEr
 
         return BaseError.New("Channel number must be unique");
     }
-
-    private static Validation<BaseError, string> ValidatePreferredAudioLanguage(UpdateChannel updateChannel) =>
-        Optional(updateChannel.PreferredAudioLanguageCode ?? string.Empty)
-            .Filter(
-                lc => string.IsNullOrWhiteSpace(lc) || CultureInfo.GetCultures(CultureTypes.NeutralCultures).Any(
-                    ci => string.Equals(ci.ThreeLetterISOLanguageName, lc, StringComparison.OrdinalIgnoreCase)))
-            .ToValidation<BaseError>("Preferred audio language code is invalid");
 }

ErsatzTV.Application/Channels/Mapper.cs

@@ -16,6 +16,7 @@ internal static class Mapper
             GetLogo(channel),
             channel.PreferredAudioLanguageCode,
             channel.PreferredAudioTitle,
+            channel.ProgressMode,
             channel.StreamingMode,
             channel.WatermarkId,
             channel.FallbackFillerId,
@@ -34,6 +35,9 @@ internal static class Mapper
             channel.PreferredAudioLanguageCode,
             GetStreamingMode(channel));
 
+    internal static ResolutionViewModel ProjectToViewModel(Resolution resolution) =>
+        new(resolution.Height, resolution.Width);
+
     private static string GetLogo(Channel channel) =>
         Optional(channel.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Logo))
             .Match(a => a.Path, string.Empty);
@@ -45,6 +49,7 @@ internal static class Mapper
             StreamingMode.TransportStreamHybrid => "MPEG-TS",
             StreamingMode.HttpLiveStreamingDirect => "HLS Direct",
             StreamingMode.HttpLiveStreamingSegmenter => "HLS Segmenter",
-            _ => throw new ArgumentOutOfRangeException()
+            StreamingMode.HttpLiveStreamingSegmenterV2 => "HLS Segmenter V2",
+            _ => throw new ArgumentOutOfRangeException(nameof(channel))
         };
 }

ErsatzTV.Application/Channels/Queries/GetChannelByIdHandler.cs

@@ -10,6 +10,6 @@ public class GetChannelByIdHandler : IRequestHandler<GetChannelById, Option<Chan
     public GetChannelByIdHandler(IChannelRepository channelRepository) => _channelRepository = channelRepository;
 
     public Task<Option<ChannelViewModel>> Handle(GetChannelById request, CancellationToken cancellationToken) =>
-        _channelRepository.Get(request.Id)
+        _channelRepository.GetChannel(request.Id)
             .MapT(ProjectToViewModel);
 }

ErsatzTV.Application/Channels/Queries/GetChannelFramerateHandler.cs

@@ -86,10 +86,20 @@ public class GetChannelFramerateHandler : IRequestHandler<GetChannelFramerate, O
             return result;
         }
 
-        _logger.LogInformation(
-            "All content on channel {ChannelNumber} has the same frame rate of {FrameRate}; will not normalize",
-            request.ChannelNumber,
-            distinct[0]);
+        if (distinct.Count != 0)
+        {
+            _logger.LogInformation(
+                "All content on channel {ChannelNumber} has the same frame rate of {FrameRate}; will not normalize",
+                request.ChannelNumber,
+                distinct[0]);
+        }
+        else
+        {
+            _logger.LogInformation(
+                "No content on channel {ChannelNumber} has frame rate information; will not normalize",
+                request.ChannelNumber);
+        }
+
         return None;
     }
 

ErsatzTV.Application/Channels/Queries/GetChannelGuide.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelGuideHandler.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelNameByPlayoutId.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelNameByPlayoutIdHandler.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelPlaylist.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelPlaylistHandler.cs

@@ -1,4 +1,4 @@
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Iptv;
 
@@ -14,7 +14,14 @@ public class GetChannelPlaylistHandler : IRequestHandler<GetChannelPlaylist, Cha
     public Task<ChannelPlaylist> Handle(GetChannelPlaylist request, CancellationToken cancellationToken) =>
         _channelRepository.GetAll()
             .Map(channels => EnsureMode(channels, request.Mode))
-            .Map(channels => new ChannelPlaylist(request.Scheme, request.Host, request.BaseUrl, channels));
+            .Map(
+                channels => new ChannelPlaylist(
+                    request.Scheme,
+                    request.Host,
+                    request.BaseUrl,
+                    channels,
+                    request.UserAgent,
+                    request.AccessToken));
 
     private static List<Channel> EnsureMode(IEnumerable<Channel> channels, string mode)
     {
@@ -27,6 +34,10 @@ public class GetChannelPlaylistHandler : IRequestHandler<GetChannelPlaylist, Cha
                     channel.StreamingMode = StreamingMode.HttpLiveStreamingSegmenter;
                     result.Add(channel);
                     break;
+                case "segmenter-v2":
+                    channel.StreamingMode = StreamingMode.HttpLiveStreamingSegmenterV2;
+                    result.Add(channel);
+                    break;
                 case "hls-direct":
                     channel.StreamingMode = StreamingMode.HttpLiveStreamingDirect;
                     result.Add(channel);

ErsatzTV.Application/Channels/Queries/GetChannelResolution.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelResolutionHandler.cs

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

ErsatzTV.Application/Channels/ResolutionViewModel.cs

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

ErsatzTV.Application/Channels/XmlTemplateContext.cs

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

ErsatzTV.Application/Configuration/Commands/SaveConfigElementByKey.cs

@@ -2,4 +2,4 @@
 
 namespace ErsatzTV.Application.Configuration;
 
-public record SaveConfigElementByKey(ConfigElementKey Key, string Value) : IRequest<Unit>;
+public record SaveConfigElementByKey(ConfigElementKey Key, string Value) : IRequest;

ErsatzTV.Application/Configuration/Commands/SaveConfigElementByKeyHandler.cs

@@ -2,16 +2,13 @@
 
 namespace ErsatzTV.Application.Configuration;
 
-public class SaveConfigElementByKeyHandler : IRequestHandler<SaveConfigElementByKey, Unit>
+public class SaveConfigElementByKeyHandler : IRequestHandler<SaveConfigElementByKey>
 {
     private readonly IConfigElementRepository _configElementRepository;
 
     public SaveConfigElementByKeyHandler(IConfigElementRepository configElementRepository) =>
         _configElementRepository = configElementRepository;
 
-    public async Task<Unit> Handle(SaveConfigElementByKey request, CancellationToken cancellationToken)
-    {
+    public async Task Handle(SaveConfigElementByKey request, CancellationToken cancellationToken) =>
         await _configElementRepository.Upsert(request.Key, request.Value);
-        return Unit.Default;
-    }
 }

ErsatzTV.Application/Configuration/Commands/UpdateGeneralSettingsHandler.cs

@@ -1,20 +1,19 @@
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
-using Serilog.Core;
 
 namespace ErsatzTV.Application.Configuration;
 
 public class UpdateGeneralSettingsHandler : IRequestHandler<UpdateGeneralSettings, Either<BaseError, Unit>>
 {
     private readonly IConfigElementRepository _configElementRepository;
-    private readonly LoggingLevelSwitch _loggingLevelSwitch;
+    private readonly LoggingLevelSwitches _loggingLevelSwitches;
 
     public UpdateGeneralSettingsHandler(
-        LoggingLevelSwitch loggingLevelSwitch,
+        LoggingLevelSwitches loggingLevelSwitches,
         IConfigElementRepository configElementRepository)
     {
-        _loggingLevelSwitch = loggingLevelSwitch;
+        _loggingLevelSwitches = loggingLevelSwitches;
         _configElementRepository = configElementRepository;
     }
 
@@ -24,8 +23,28 @@ public class UpdateGeneralSettingsHandler : IRequestHandler<UpdateGeneralSetting
 
     private async Task<Unit> ApplyUpdate(GeneralSettingsViewModel generalSettings)
     {
-        await _configElementRepository.Upsert(ConfigElementKey.MinimumLogLevel, generalSettings.MinimumLogLevel);
-        _loggingLevelSwitch.MinimumLevel = generalSettings.MinimumLogLevel;
+        await _configElementRepository.Upsert(ConfigElementKey.MinimumLogLevel, generalSettings.DefaultMinimumLogLevel);
+        _loggingLevelSwitches.DefaultLevelSwitch.MinimumLevel = generalSettings.DefaultMinimumLogLevel;
+
+        await _configElementRepository.Upsert(
+            ConfigElementKey.MinimumLogLevelScanning,
+            generalSettings.ScanningMinimumLogLevel);
+        _loggingLevelSwitches.ScanningLevelSwitch.MinimumLevel = generalSettings.ScanningMinimumLogLevel;
+
+        await _configElementRepository.Upsert(
+            ConfigElementKey.MinimumLogLevelScheduling,
+            generalSettings.SchedulingMinimumLogLevel);
+        _loggingLevelSwitches.SchedulingLevelSwitch.MinimumLevel = generalSettings.SchedulingMinimumLogLevel;
+
+        await _configElementRepository.Upsert(
+            ConfigElementKey.MinimumLogLevelStreaming,
+            generalSettings.StreamingMinimumLogLevel);
+        _loggingLevelSwitches.StreamingLevelSwitch.MinimumLevel = generalSettings.StreamingMinimumLogLevel;
+
+        await _configElementRepository.Upsert(
+            ConfigElementKey.MinimumLogLevelHttp,
+            generalSettings.HttpMinimumLogLevel);
+        _loggingLevelSwitches.HttpLevelSwitch.MinimumLevel = generalSettings.HttpMinimumLogLevel;
 
         return Unit.Default;
     }

ErsatzTV.Application/Configuration/Commands/UpdatePlayoutSettingsHandler.cs

@@ -1,4 +1,5 @@
-using System.Threading.Channels;
+using System.Globalization;
+using System.Threading.Channels;
 using ErsatzTV.Application.Playouts;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
@@ -45,7 +46,8 @@ public class UpdatePlayoutSettingsHandler : IRequestHandler<UpdatePlayoutSetting
         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))
+        foreach (int playoutId in playouts.OrderBy(p => decimal.Parse(p.Channel.Number, CultureInfo.InvariantCulture))
+                     .Map(p => p.Id))
         {
             await _workerChannel.WriteAsync(new BuildPlayout(playoutId, PlayoutBuildMode.Continue));
         }

ErsatzTV.Application/Configuration/Commands/UpdateXmltvSettings.cs

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

ErsatzTV.Application/Configuration/Commands/UpdateXmltvSettingsHandler.cs

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

ErsatzTV.Application/Configuration/GeneralSettingsViewModel.cs

@@ -4,5 +4,9 @@ namespace ErsatzTV.Application.Configuration;
 
 public class GeneralSettingsViewModel
 {
-    public LogEventLevel MinimumLogLevel { get; set; }
+    public LogEventLevel DefaultMinimumLogLevel { get; set; }
+    public LogEventLevel ScanningMinimumLogLevel { get; set; }
+    public LogEventLevel SchedulingMinimumLogLevel { get; set; }
+    public LogEventLevel StreamingMinimumLogLevel { get; set; }
+    public LogEventLevel HttpMinimumLogLevel { get; set; }
 }

ErsatzTV.Application/Configuration/Queries/GetConfigElementByKeyHandler.cs

@@ -13,5 +13,5 @@ public class GetConfigElementByKeyHandler : IRequestHandler<GetConfigElementByKe
     public Task<Option<ConfigElementViewModel>> Handle(
         GetConfigElementByKey request,
         CancellationToken cancellationToken) =>
-        _configElementRepository.Get(request.Key).MapT(ProjectToViewModel);
+        _configElementRepository.GetConfigElement(request.Key).MapT(ProjectToViewModel);
 }

ErsatzTV.Application/Configuration/Queries/GetGeneralSettingsHandler.cs

@@ -13,12 +13,28 @@ public class GetGeneralSettingsHandler : IRequestHandler<GetGeneralSettings, Gen
 
     public async Task<GeneralSettingsViewModel> Handle(GetGeneralSettings request, CancellationToken cancellationToken)
     {
-        Option<LogEventLevel> maybeLogLevel =
+        Option<LogEventLevel> maybeDefaultLevel =
             await _configElementRepository.GetValue<LogEventLevel>(ConfigElementKey.MinimumLogLevel);
 
+        Option<LogEventLevel> maybeScanningLevel =
+            await _configElementRepository.GetValue<LogEventLevel>(ConfigElementKey.MinimumLogLevelScanning);
+
+        Option<LogEventLevel> maybeSchedulingLevel =
+            await _configElementRepository.GetValue<LogEventLevel>(ConfigElementKey.MinimumLogLevelScheduling);
+
+        Option<LogEventLevel> maybeStreamingLevel =
+            await _configElementRepository.GetValue<LogEventLevel>(ConfigElementKey.MinimumLogLevelStreaming);
+
+        Option<LogEventLevel> maybeHttpLevel =
+            await _configElementRepository.GetValue<LogEventLevel>(ConfigElementKey.MinimumLogLevelHttp);
+
         return new GeneralSettingsViewModel
         {
-            MinimumLogLevel = await maybeLogLevel.IfNoneAsync(LogEventLevel.Information)
+            DefaultMinimumLogLevel = await maybeDefaultLevel.IfNoneAsync(LogEventLevel.Information),
+            ScanningMinimumLogLevel = await maybeScanningLevel.IfNoneAsync(LogEventLevel.Information),
+            SchedulingMinimumLogLevel = await maybeSchedulingLevel.IfNoneAsync(LogEventLevel.Information),
+            StreamingMinimumLogLevel = await maybeStreamingLevel.IfNoneAsync(LogEventLevel.Information),
+            HttpMinimumLogLevel = await maybeHttpLevel.IfNoneAsync(LogEventLevel.Information)
         };
     }
 }

ErsatzTV.Application/Configuration/Queries/GetXmltvSettings.cs

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

ErsatzTV.Application/Configuration/Queries/GetXmltvSettingsHandler.cs

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

ErsatzTV.Application/Configuration/XmltvSettingsViewModel.cs

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

ErsatzTV.Application/Configuration/XmltvTimeZone.cs

@@ -0,0 +1,7 @@
+namespace ErsatzTV.Application.Configuration;
+
+public enum XmltvTimeZone
+{
+    Local = 0,
+    Utc = 1
+}

ErsatzTV.Application/Emby/Commands/CallEmbyCollectionScannerHandler.cs

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

ErsatzTV.Application/Emby/Commands/CallEmbyLibraryScannerHandler.cs

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

ErsatzTV.Application/Emby/Commands/SaveEmbySecretsHandler.cs

@@ -52,5 +52,5 @@ public class SaveEmbySecretsHandler : IRequestHandler<SaveEmbySecrets, Either<Ba
         return Unit.Default;
     }
 
-    private record Parameters(EmbySecrets Secrets, EmbyServerInformation ServerInformation);
+    private sealed record Parameters(EmbySecrets Secrets, EmbyServerInformation ServerInformation);
 }

ErsatzTV.Application/Emby/Commands/SynchronizeEmbyCollections.cs

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

ErsatzTV.Application/Emby/Commands/SynchronizeEmbyLibraries.cs

@@ -3,4 +3,4 @@
 namespace ErsatzTV.Application.Emby;
 
 public record SynchronizeEmbyLibraries(int EmbyMediaSourceId) : IRequest<Either<BaseError, Unit>>,
-    IEmbyBackgroundServiceRequest;
+    IScannerBackgroundServiceRequest;

ErsatzTV.Application/Emby/Commands/SynchronizeEmbyLibrariesHandler.cs

@@ -92,7 +92,7 @@ public class SynchronizeEmbyLibrariesHandler : IRequestHandler<SynchronizeEmbyLi
                 toAdd,
                 toRemove,
                 toUpdate);
-            if (ids.Any())
+            if (ids.Count != 0)
             {
                 await _searchIndex.RemoveItems(ids);
                 _searchIndex.Commit();
@@ -102,9 +102,7 @@ public class SynchronizeEmbyLibrariesHandler : IRequestHandler<SynchronizeEmbyLi
         return Unit.Default;
     }
 
-    private record ConnectionParameters(
-        EmbyMediaSource EmbyMediaSource,
-        EmbyConnection ActiveConnection)
+    private sealed record ConnectionParameters(EmbyMediaSource EmbyMediaSource, EmbyConnection ActiveConnection)
     {
         public string ApiKey { get; set; }
     }

ErsatzTV.Application/Emby/Commands/SynchronizeEmbyLibraryById.cs

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

ErsatzTV.Application/Emby/Commands/SynchronizeEmbyMediaSourcesHandler.cs

@@ -8,15 +8,15 @@ namespace ErsatzTV.Application.Emby;
 public class SynchronizeEmbyMediaSourcesHandler : IRequestHandler<SynchronizeEmbyMediaSources,
     Either<BaseError, List<EmbyMediaSource>>>
 {
-    private readonly ChannelWriter<IEmbyBackgroundServiceRequest> _channel;
     private readonly IMediaSourceRepository _mediaSourceRepository;
+    private readonly ChannelWriter<IScannerBackgroundServiceRequest> _scannerWorkerChannel;
 
     public SynchronizeEmbyMediaSourcesHandler(
         IMediaSourceRepository mediaSourceRepository,
-        ChannelWriter<IEmbyBackgroundServiceRequest> channel)
+        ChannelWriter<IScannerBackgroundServiceRequest> scannerWorkerChannel)
     {
         _mediaSourceRepository = mediaSourceRepository;
-        _channel = channel;
+        _scannerWorkerChannel = scannerWorkerChannel;
     }
 
     public async Task<Either<BaseError, List<EmbyMediaSource>>> Handle(
@@ -27,7 +27,7 @@ public class SynchronizeEmbyMediaSourcesHandler : IRequestHandler<SynchronizeEmb
         foreach (EmbyMediaSource mediaSource in mediaSources)
         {
             // await _channel.WriteAsync(new SynchronizeEmbyAdminUserId(mediaSource.Id), cancellationToken);
-            await _channel.WriteAsync(new SynchronizeEmbyLibraries(mediaSource.Id), cancellationToken);
+            await _scannerWorkerChannel.WriteAsync(new SynchronizeEmbyLibraries(mediaSource.Id), cancellationToken);
         }
 
         return mediaSources;

ErsatzTV.Application/Emby/Commands/UpdateEmbyLibraryPreferences.cs

@@ -2,7 +2,6 @@
 
 namespace ErsatzTV.Application.Emby;
 
-public record UpdateEmbyLibraryPreferences
-    (List<EmbyLibraryPreference> Preferences) : IRequest<Either<BaseError, Unit>>;
+public record UpdateEmbyLibraryPreferences(List<EmbyLibraryPreference> Preferences) : IRequest<Either<BaseError, Unit>>;
 
 public record EmbyLibraryPreference(int Id, bool ShouldSyncItems);

ErsatzTV.Application/Emby/Commands/UpdateEmbyLibraryPreferencesHandler.cs

@@ -6,7 +6,7 @@ namespace ErsatzTV.Application.Emby;
 
 public class
     UpdateEmbyLibraryPreferencesHandler : IRequestHandler<UpdateEmbyLibraryPreferences,
-        Either<BaseError, Unit>>
+    Either<BaseError, Unit>>
 {
     private readonly IMediaSourceRepository _mediaSourceRepository;
     private readonly ISearchIndex _searchIndex;

ErsatzTV.Application/Emby/EmbyConnectionParametersViewModel.cs

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

ErsatzTV.Application/Emby/EmbyLibraryViewModel.cs

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

ErsatzTV.Application/Emby/Queries/GetEmbyConnectionParametersHandler.cs

@@ -1,5 +1,7 @@
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Emby;
+using ErsatzTV.Core.Interfaces.Emby;
 using ErsatzTV.Core.Interfaces.Repositories;
 using Microsoft.Extensions.Caching.Memory;
 
@@ -8,15 +10,18 @@ namespace ErsatzTV.Application.Emby;
 public class GetEmbyConnectionParametersHandler : IRequestHandler<GetEmbyConnectionParameters,
     Either<BaseError, EmbyConnectionParametersViewModel>>
 {
+    private readonly IEmbySecretStore _embySecretStore;
     private readonly IMediaSourceRepository _mediaSourceRepository;
     private readonly IMemoryCache _memoryCache;
 
     public GetEmbyConnectionParametersHandler(
         IMemoryCache memoryCache,
-        IMediaSourceRepository mediaSourceRepository)
+        IMediaSourceRepository mediaSourceRepository,
+        IEmbySecretStore embySecretStore)
     {
         _memoryCache = memoryCache;
         _mediaSourceRepository = mediaSourceRepository;
+        _embySecretStore = embySecretStore;
     }
 
     public async Task<Either<BaseError, EmbyConnectionParametersViewModel>> Handle(
@@ -30,7 +35,7 @@ public class GetEmbyConnectionParametersHandler : IRequestHandler<GetEmbyConnect
 
         Either<BaseError, EmbyConnectionParametersViewModel> maybeParameters =
             await Validate()
-                .MapT(cp => new EmbyConnectionParametersViewModel(cp.ActiveConnection.Address))
+                .MapT(cp => new EmbyConnectionParametersViewModel(cp.ActiveConnection.Address, cp.ApiKey))
                 .Map(v => v.ToEither<EmbyConnectionParametersViewModel>());
 
         return maybeParameters.Match(
@@ -44,7 +49,8 @@ public class GetEmbyConnectionParametersHandler : IRequestHandler<GetEmbyConnect
 
     private Task<Validation<BaseError, ConnectionParameters>> Validate() =>
         EmbyMediaSourceMustExist()
-            .BindT(MediaSourceMustHaveActiveConnection);
+            .BindT(MediaSourceMustHaveActiveConnection)
+            .BindT(MediaSourceMustHaveApiKey);
 
     private Task<Validation<BaseError, EmbyMediaSource>> EmbyMediaSourceMustExist() =>
         _mediaSourceRepository.GetAllEmby().Map(list => list.HeadOrNone())
@@ -60,7 +66,20 @@ public class GetEmbyConnectionParametersHandler : IRequestHandler<GetEmbyConnect
             .ToValidation<BaseError>("Emby media source requires an active connection");
     }
 
-    private record ConnectionParameters(
+    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 sealed record ConnectionParameters(
         EmbyMediaSource EmbyMediaSource,
-        EmbyConnection ActiveConnection);
+        EmbyConnection ActiveConnection)
+    {
+        public string ApiKey { get; set; }
+    }
 }

ErsatzTV.Application/Emby/Queries/GetEmbyPathReplacementsBySourceId.cs

@@ -1,4 +1,3 @@
 namespace ErsatzTV.Application.Emby;
 
-public record GetEmbyPathReplacementsBySourceId
-    (int EmbyMediaSourceId) : IRequest<List<EmbyPathReplacementViewModel>>;
+public record GetEmbyPathReplacementsBySourceId(int EmbyMediaSourceId) : IRequest<List<EmbyPathReplacementViewModel>>;

ErsatzTV.Application/ErsatzTV.Application.csproj

@@ -1,24 +1,28 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
     <PropertyGroup>
-        <TargetFramework>net7.0</TargetFramework>
+        <TargetFramework>net8.0</TargetFramework>
         <NoWarn>VSTHRD200</NoWarn>
         <ImplicitUsings>enable</ImplicitUsings>
+        <AnalysisLevel>latest-Recommended</AnalysisLevel>
+        <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
     </PropertyGroup>
 
     <ItemGroup>
       <PackageReference Include="Bugsnag" Version="3.1.0" />
-      <PackageReference Include="CliWrap" Version="3.6.0" />
+      <PackageReference Include="CliWrap" Version="3.6.6" />
       <PackageReference Include="Humanizer.Core" Version="2.14.1" />
-      <PackageReference Include="MediatR" Version="11.1.0" />
-      <PackageReference Include="Microsoft.Extensions.Caching.Abstractions" Version="7.0.0" />
-      <PackageReference Include="Microsoft.VisualStudio.Threading.Analyzers" Version="17.4.27">
+      <PackageReference Include="MediatR" Version="12.4.1" />
+      <PackageReference Include="Microsoft.Extensions.Caching.Abstractions" Version="8.0.0" />
+      <PackageReference Include="Microsoft.Extensions.Hosting.Abstractions" Version="8.0.0" />
+      <PackageReference Include="Microsoft.VisualStudio.Threading.Analyzers" Version="17.11.20">
         <PrivateAssets>all</PrivateAssets>
         <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       </PackageReference>
-      <PackageReference Include="Newtonsoft.Json" Version="13.0.2" />
-      <PackageReference Include="Serilog.Formatting.Compact.Reader" Version="2.0.0" />
-      <PackageReference Include="Winista.MimeDetect" Version="1.0.1" />
+      <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
+      <PackageReference Include="Serilog.Formatting.Compact.Reader" Version="4.0.0" />
+      <PackageReference Include="WebMarkupMin.Core" Version="2.17.0" />
+      <PackageReference Include="Winista.MimeDetect" Version="1.1.0" />
     </ItemGroup>
 
     <ItemGroup>

ErsatzTV.Application/ErsatzTV.Application.csproj.DotSettings

@@ -33,7 +33,10 @@
 	<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_005Ccommands/@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/=scheduling_005Ccommands/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=scheduling_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>

ErsatzTV.Application/FFmpegProfiles/Commands/CopyFFmpegProfile.cs

@@ -2,5 +2,4 @@
 
 namespace ErsatzTV.Application.FFmpegProfiles;
 
-public record CopyFFmpegProfile
-    (int FFmpegProfileId, string Name) : IRequest<Either<BaseError, FFmpegProfileViewModel>>;
+public record CopyFFmpegProfile(int FFmpegProfileId, string Name) : IRequest<Either<BaseError, FFmpegProfileViewModel>>;

ErsatzTV.Application/FFmpegProfiles/Commands/CopyFFmpegProfileHandler.cs

@@ -1,5 +1,7 @@
 using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Interfaces.Search;
 using static ErsatzTV.Application.FFmpegProfiles.Mapper;
 
 namespace ErsatzTV.Application.FFmpegProfiles;
@@ -8,9 +10,13 @@ public class
     CopyFFmpegProfileHandler : IRequestHandler<CopyFFmpegProfile, Either<BaseError, FFmpegProfileViewModel>>
 {
     private readonly IFFmpegProfileRepository _ffmpegProfileRepository;
+    private readonly ISearchTargets _searchTargets;
 
-    public CopyFFmpegProfileHandler(IFFmpegProfileRepository ffmpegProfileRepository) =>
+    public CopyFFmpegProfileHandler(IFFmpegProfileRepository ffmpegProfileRepository, ISearchTargets searchTargets)
+    {
         _ffmpegProfileRepository = ffmpegProfileRepository;
+        _searchTargets = searchTargets;
+    }
 
     public Task<Either<BaseError, FFmpegProfileViewModel>> Handle(
         CopyFFmpegProfile request,
@@ -19,14 +25,17 @@ public class
             .MapT(PerformCopy)
             .Bind(v => v.ToEitherAsync());
 
-    private Task<FFmpegProfileViewModel> PerformCopy(CopyFFmpegProfile request) =>
-        _ffmpegProfileRepository.Copy(request.FFmpegProfileId, request.Name)
-            .Map(ProjectToViewModel);
+    private async Task<FFmpegProfileViewModel> PerformCopy(CopyFFmpegProfile request)
+    {
+        FFmpegProfile copy = await _ffmpegProfileRepository.Copy(request.FFmpegProfileId, request.Name);
+        _searchTargets.SearchTargetsChanged();
+        return ProjectToViewModel(copy);
+    }
 
-    private Task<Validation<BaseError, CopyFFmpegProfile>> Validate(CopyFFmpegProfile request) =>
+    private static Task<Validation<BaseError, CopyFFmpegProfile>> Validate(CopyFFmpegProfile request) =>
         ValidateName(request).AsTask().MapT(_ => request);
 
-    private Validation<BaseError, string> ValidateName(CopyFFmpegProfile request) =>
+    private static Validation<BaseError, string> ValidateName(CopyFFmpegProfile request) =>
         request.NotEmpty(x => x.Name)
             .Bind(_ => request.NotLongerThan(50)(x => x.Name));
 }

ErsatzTV.Application/FFmpegProfiles/Commands/CreateFFmpegProfile.cs

@@ -12,14 +12,18 @@ public record CreateFFmpegProfile(
     string VaapiDevice,
     int? QsvExtraHardwareFrames,
     int ResolutionId,
+    ScalingBehavior ScalingBehavior,
     FFmpegProfileVideoFormat VideoFormat,
+    string VideoProfile,
+    string VideoPreset,
+    bool AllowBFrames,
     FFmpegProfileBitDepth BitDepth,
     int VideoBitrate,
     int VideoBufferSize,
     FFmpegProfileAudioFormat AudioFormat,
     int AudioBitrate,
     int AudioBufferSize,
-    bool NormalizeLoudness,
+    NormalizeLoudnessMode NormalizeLoudnessMode,
     int AudioChannels,
     int AudioSampleRate,
     bool NormalizeFramerate,

ErsatzTV.Application/FFmpegProfiles/Commands/CreateFFmpegProfileHandler.cs

@@ -1,5 +1,6 @@
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
 using Microsoft.EntityFrameworkCore;
@@ -10,9 +11,13 @@ public class CreateFFmpegProfileHandler :
     IRequestHandler<CreateFFmpegProfile, Either<BaseError, CreateFFmpegProfileResult>>
 {
     private readonly IDbContextFactory<TvContext> _dbContextFactory;
+    private readonly ISearchTargets _searchTargets;
 
-    public CreateFFmpegProfileHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+    public CreateFFmpegProfileHandler(IDbContextFactory<TvContext> dbContextFactory, ISearchTargets searchTargets)
+    {
         _dbContextFactory = dbContextFactory;
+        _searchTargets = searchTargets;
+    }
 
     public async Task<Either<BaseError, CreateFFmpegProfileResult>> Handle(
         CreateFFmpegProfile request,
@@ -23,16 +28,17 @@ public class CreateFFmpegProfileHandler :
         return await validation.Apply(profile => PersistFFmpegProfile(dbContext, profile));
     }
 
-    private static async Task<CreateFFmpegProfileResult> PersistFFmpegProfile(
+    private async Task<CreateFFmpegProfileResult> PersistFFmpegProfile(
         TvContext dbContext,
         FFmpegProfile ffmpegProfile)
     {
         await dbContext.FFmpegProfiles.AddAsync(ffmpegProfile);
         await dbContext.SaveChangesAsync();
+        _searchTargets.SearchTargetsChanged();
         return new CreateFFmpegProfileResult(ffmpegProfile.Id);
     }
 
-    private async Task<Validation<BaseError, FFmpegProfile>> Validate(
+    private static async Task<Validation<BaseError, FFmpegProfile>> Validate(
         TvContext dbContext,
         CreateFFmpegProfile request) =>
         (ValidateName(request), ValidateThreadCount(request), await ResolutionMustExist(dbContext, request))
@@ -46,14 +52,18 @@ public class CreateFFmpegProfileHandler :
                 VaapiDevice = request.VaapiDevice,
                 QsvExtraHardwareFrames = request.QsvExtraHardwareFrames,
                 ResolutionId = resolutionId,
+                ScalingBehavior = request.ScalingBehavior,
                 VideoFormat = request.VideoFormat,
+                VideoProfile = request.VideoProfile,
+                VideoPreset = request.VideoPreset,
+                AllowBFrames = request.AllowBFrames,
                 BitDepth = request.BitDepth,
                 VideoBitrate = request.VideoBitrate,
                 VideoBufferSize = request.VideoBufferSize,
                 AudioFormat = request.AudioFormat,
                 AudioBitrate = request.AudioBitrate,
                 AudioBufferSize = request.AudioBufferSize,
-                NormalizeLoudness = request.NormalizeLoudness,
+                NormalizeLoudnessMode = request.NormalizeLoudnessMode,
                 AudioChannels = request.AudioChannels,
                 AudioSampleRate = request.AudioSampleRate,
                 NormalizeFramerate = request.NormalizeFramerate,

ErsatzTV.Application/FFmpegProfiles/Commands/DeleteFFmpegProfileHandler.cs

@@ -1,5 +1,6 @@
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
 using Microsoft.EntityFrameworkCore;
@@ -9,23 +10,28 @@ namespace ErsatzTV.Application.FFmpegProfiles;
 public class DeleteFFmpegProfileHandler : IRequestHandler<DeleteFFmpegProfile, Either<BaseError, Unit>>
 {
     private readonly IDbContextFactory<TvContext> _dbContextFactory;
+    private readonly ISearchTargets _searchTargets;
 
-    public DeleteFFmpegProfileHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+    public DeleteFFmpegProfileHandler(IDbContextFactory<TvContext> dbContextFactory, ISearchTargets searchTargets)
+    {
         _dbContextFactory = dbContextFactory;
+        _searchTargets = searchTargets;
+    }
 
     public async Task<Either<BaseError, Unit>> Handle(
         DeleteFFmpegProfile request,
         CancellationToken cancellationToken)
     {
-        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
         Validation<BaseError, FFmpegProfile> validation = await FFmpegProfileMustExist(dbContext, request);
-        return await LanguageExtensions.Apply(validation, p => DoDeletion(dbContext, p));
+        return await validation.Apply(p => DoDeletion(dbContext, p));
     }
 
-    private static async Task<Unit> DoDeletion(TvContext dbContext, FFmpegProfile ffmpegProfile)
+    private async Task<Unit> DoDeletion(TvContext dbContext, FFmpegProfile ffmpegProfile)
     {
         dbContext.FFmpegProfiles.Remove(ffmpegProfile);
         await dbContext.SaveChangesAsync();
+        _searchTargets.SearchTargetsChanged();
         return Unit.Default;
     }
 

ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegProfile.cs

@@ -13,14 +13,18 @@ public record UpdateFFmpegProfile(
     string VaapiDevice,
     int? QsvExtraHardwareFrames,
     int ResolutionId,
+    ScalingBehavior ScalingBehavior,
     FFmpegProfileVideoFormat VideoFormat,
+    string VideoProfile,
+    string VideoPreset,
+    bool AllowBFrames,
     FFmpegProfileBitDepth BitDepth,
     int VideoBitrate,
     int VideoBufferSize,
     FFmpegProfileAudioFormat AudioFormat,
     int AudioBitrate,
     int AudioBufferSize,
-    bool NormalizeLoudness,
+    NormalizeLoudnessMode NormalizeLoudnessMode,
     int AudioChannels,
     int AudioSampleRate,
     bool NormalizeFramerate,

ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegProfileHandler.cs

@@ -1,5 +1,6 @@
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
 using Microsoft.EntityFrameworkCore;
@@ -10,9 +11,13 @@ public class
     UpdateFFmpegProfileHandler : IRequestHandler<UpdateFFmpegProfile, Either<BaseError, UpdateFFmpegProfileResult>>
 {
     private readonly IDbContextFactory<TvContext> _dbContextFactory;
+    private readonly ISearchTargets _searchTargets;
 
-    public UpdateFFmpegProfileHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+    public UpdateFFmpegProfileHandler(IDbContextFactory<TvContext> dbContextFactory, ISearchTargets searchTargets)
+    {
         _dbContextFactory = dbContextFactory;
+        _searchTargets = searchTargets;
+    }
 
     public async Task<Either<BaseError, UpdateFFmpegProfileResult>> Handle(
         UpdateFFmpegProfile request,
@@ -35,19 +40,31 @@ public class
         p.VaapiDevice = update.VaapiDevice;
         p.QsvExtraHardwareFrames = update.QsvExtraHardwareFrames;
         p.ResolutionId = update.ResolutionId;
+        p.ScalingBehavior = update.ScalingBehavior;
         p.VideoFormat = update.VideoFormat;
-        p.BitDepth = update.BitDepth;
+        p.VideoProfile = update.VideoProfile;
+        p.VideoPreset = update.VideoPreset;
+        p.AllowBFrames = update.AllowBFrames;
+
+        // mpeg2video only supports 8-bit content
+        p.BitDepth = update.VideoFormat == FFmpegProfileVideoFormat.Mpeg2Video
+            ? FFmpegProfileBitDepth.EightBit
+            : update.BitDepth;
+
         p.VideoBitrate = update.VideoBitrate;
         p.VideoBufferSize = update.VideoBufferSize;
         p.AudioFormat = update.AudioFormat;
         p.AudioBitrate = update.AudioBitrate;
         p.AudioBufferSize = update.AudioBufferSize;
-        p.NormalizeLoudness = update.NormalizeLoudness;
+        p.NormalizeLoudnessMode = update.NormalizeLoudnessMode;
         p.AudioChannels = update.AudioChannels;
         p.AudioSampleRate = update.AudioSampleRate;
         p.NormalizeFramerate = update.NormalizeFramerate;
         p.DeinterlaceVideo = update.DeinterlaceVideo;
         await dbContext.SaveChangesAsync();
+
+        _searchTargets.SearchTargetsChanged();
+
         return new UpdateFFmpegProfileResult(p.Id);
     }
 

ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegSettingsHandler.cs

@@ -1,4 +1,7 @@
 using System.Diagnostics;
+using System.Globalization;
+using System.Threading.Channels;
+using ErsatzTV.Application.Subtitles;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Metadata;
@@ -10,13 +13,16 @@ public class UpdateFFmpegSettingsHandler : IRequestHandler<UpdateFFmpegSettings,
 {
     private readonly IConfigElementRepository _configElementRepository;
     private readonly ILocalFileSystem _localFileSystem;
+    private readonly ChannelWriter<IBackgroundServiceRequest> _workerChannel;
 
     public UpdateFFmpegSettingsHandler(
         IConfigElementRepository configElementRepository,
-        ILocalFileSystem localFileSystem)
+        ILocalFileSystem localFileSystem,
+        ChannelWriter<IBackgroundServiceRequest> workerChannel)
     {
         _configElementRepository = configElementRepository;
         _localFileSystem = localFileSystem;
+        _workerChannel = workerChannel;
     }
 
     public Task<Either<BaseError, Unit>> Handle(
@@ -52,10 +58,8 @@ public class UpdateFFmpegSettingsHandler : IRequestHandler<UpdateFFmpegSettings,
             UseShellExecute = false
         };
 
-        var test = new Process
-        {
-            StartInfo = startInfo
-        };
+        using var test = new Process();
+        test.StartInfo = startInfo;
 
         test.Start();
         string output = await test.StandardOutput.ReadToEndAsync();
@@ -71,10 +75,13 @@ public class UpdateFFmpegSettingsHandler : IRequestHandler<UpdateFFmpegSettings,
         await _configElementRepository.Upsert(ConfigElementKey.FFprobePath, request.Settings.FFprobePath);
         await _configElementRepository.Upsert(
             ConfigElementKey.FFmpegDefaultProfileId,
-            request.Settings.DefaultFFmpegProfileId.ToString());
+            request.Settings.DefaultFFmpegProfileId.ToString(CultureInfo.InvariantCulture));
         await _configElementRepository.Upsert(
             ConfigElementKey.FFmpegSaveReports,
             request.Settings.SaveReports.ToString());
+        await _configElementRepository.Upsert(
+            ConfigElementKey.FFmpegHlsDirectOutputFormat,
+            request.Settings.HlsDirectOutputFormat);
 
         if (request.Settings.SaveReports && !Directory.Exists(FileSystemLayout.FFmpegReportsFolder))
         {
@@ -85,6 +92,26 @@ public class UpdateFFmpegSettingsHandler : IRequestHandler<UpdateFFmpegSettings,
             ConfigElementKey.FFmpegPreferredLanguageCode,
             request.Settings.PreferredAudioLanguageCode);
 
+        await _configElementRepository.Upsert(
+            ConfigElementKey.FFmpegUseEmbeddedSubtitles,
+            request.Settings.UseEmbeddedSubtitles);
+
+        // do not extract when subtitles are not used
+        if (request.Settings.UseEmbeddedSubtitles == false)
+        {
+            request.Settings.ExtractEmbeddedSubtitles = false;
+        }
+
+        await _configElementRepository.Upsert(
+            ConfigElementKey.FFmpegExtractEmbeddedSubtitles,
+            request.Settings.ExtractEmbeddedSubtitles);
+
+        // queue extracting all embedded subtitles
+        if (request.Settings.ExtractEmbeddedSubtitles)
+        {
+            await _workerChannel.WriteAsync(new ExtractEmbeddedSubtitles(Option<int>.None));
+        }
+
         if (request.Settings.GlobalWatermarkId is not null)
         {
             await _configElementRepository.Upsert(

ErsatzTV.Application/FFmpegProfiles/FFmpegProfileViewModel.cs

@@ -13,14 +13,18 @@ public record FFmpegProfileViewModel(
     string VaapiDevice,
     int? QsvExtraHardwareFrames,
     ResolutionViewModel Resolution,
+    ScalingBehavior ScalingBehavior,
     FFmpegProfileVideoFormat VideoFormat,
+    string VideoProfile,
+    string VideoPreset,
+    bool AllowBFrames,
     FFmpegProfileBitDepth BitDepth,
     int VideoBitrate,
     int VideoBufferSize,
     FFmpegProfileAudioFormat AudioFormat,
     int AudioBitrate,
     int AudioBufferSize,
-    bool NormalizeLoudness,
+    NormalizeLoudnessMode NormalizeLoudnessMode,
     int AudioChannels,
     int AudioSampleRate,
     bool NormalizeFramerate,

ErsatzTV.Application/FFmpegProfiles/FFmpegSettingsViewModel.cs

@@ -1,4 +1,6 @@
-namespace ErsatzTV.Application.FFmpegProfiles;
+using ErsatzTV.FFmpeg.OutputFormat;
+
+namespace ErsatzTV.Application.FFmpegProfiles;
 
 public class FFmpegSettingsViewModel
 {
@@ -6,10 +8,13 @@ public class FFmpegSettingsViewModel
     public string FFprobePath { get; set; }
     public int DefaultFFmpegProfileId { get; set; }
     public string PreferredAudioLanguageCode { get; set; }
+    public bool UseEmbeddedSubtitles { get; set; }
+    public bool ExtractEmbeddedSubtitles { get; set; }
     public bool SaveReports { get; set; }
     public int? GlobalWatermarkId { get; set; }
     public int? GlobalFallbackFillerId { get; set; }
     public int HlsSegmenterIdleTimeout { get; set; }
     public int WorkAheadSegmenterLimit { get; set; }
     public int InitialSegmentCount { get; set; }
+    public OutputFormatKind HlsDirectOutputFormat { get; set; }
 }

ErsatzTV.Application/FFmpegProfiles/Mapper.cs

@@ -1,5 +1,4 @@
-using ErsatzTV.Application.Resolutions;
-using ErsatzTV.Core.Api.FFmpegProfiles;
+using ErsatzTV.Core.Api.FFmpegProfiles;
 using ErsatzTV.Core.Domain;
 
 namespace ErsatzTV.Application.FFmpegProfiles;
@@ -15,15 +14,19 @@ internal static class Mapper
             profile.VaapiDriver,
             profile.VaapiDevice,
             profile.QsvExtraHardwareFrames,
-            Project(profile.Resolution),
+            Resolutions.Mapper.ProjectToViewModel(profile.Resolution),
+            profile.ScalingBehavior,
             profile.VideoFormat,
+            profile.VideoProfile,
+            profile.VideoPreset ?? string.Empty,
+            profile.AllowBFrames,
             profile.BitDepth,
             profile.VideoBitrate,
             profile.VideoBufferSize,
             profile.AudioFormat,
             profile.AudioBitrate,
             profile.AudioBufferSize,
-            profile.NormalizeLoudness,
+            profile.NormalizeLoudnessMode,
             profile.AudioChannels,
             profile.AudioSampleRate,
             profile.NormalizeFramerate,
@@ -52,12 +55,9 @@ internal static class Mapper
             (int)ffmpegProfile.AudioFormat,
             ffmpegProfile.AudioBitrate,
             ffmpegProfile.AudioBufferSize,
-            ffmpegProfile.NormalizeLoudness,
+            (int)ffmpegProfile.NormalizeLoudnessMode,
             ffmpegProfile.AudioChannels,
             ffmpegProfile.AudioSampleRate,
             ffmpegProfile.NormalizeFramerate,
             ffmpegProfile.DeinterlaceVideo);
-
-    private static ResolutionViewModel Project(Resolution resolution) =>
-        new(resolution.Id, resolution.Name, resolution.Width, resolution.Height);
 }

ErsatzTV.Application/FFmpegProfiles/Queries/GetAllFFmpegProfilesHandler.cs

@@ -15,7 +15,7 @@ public class GetAllFFmpegProfilesHandler : IRequestHandler<GetAllFFmpegProfiles,
         GetAllFFmpegProfiles request,
         CancellationToken cancellationToken)
     {
-        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
         return await dbContext.FFmpegProfiles
             .Include(p => p.Resolution)
             .ToListAsync(cancellationToken)

ErsatzTV.Application/FFmpegProfiles/Queries/GetFFmpegProfileByIdForApiHandler.cs

@@ -8,7 +8,7 @@ namespace ErsatzTV.Application.FFmpegProfiles;
 
 public class
     GetFFmpegProfileByIdForApiHandler : IRequestHandler<GetFFmpegFullProfileByIdForApi,
-        Option<FFmpegFullProfileResponseModel>>
+    Option<FFmpegFullProfileResponseModel>>
 {
     private readonly IDbContextFactory<TvContext> _dbContextFactory;
 

ErsatzTV.Application/FFmpegProfiles/Queries/GetFFmpegSettingsHandler.cs

@@ -1,5 +1,6 @@
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.FFmpeg.OutputFormat;
 
 namespace ErsatzTV.Application.FFmpegProfiles;
 
@@ -22,6 +23,10 @@ public class GetFFmpegSettingsHandler : IRequestHandler<GetFFmpegSettings, FFmpe
             await _configElementRepository.GetValue<bool>(ConfigElementKey.FFmpegSaveReports);
         Option<string> preferredAudioLanguageCode =
             await _configElementRepository.GetValue<string>(ConfigElementKey.FFmpegPreferredLanguageCode);
+        Option<bool> useEmbeddedSubtitles =
+            await _configElementRepository.GetValue<bool>(ConfigElementKey.FFmpegUseEmbeddedSubtitles);
+        Option<bool> extractEmbeddedSubtitles =
+            await _configElementRepository.GetValue<bool>(ConfigElementKey.FFmpegExtractEmbeddedSubtitles);
         Option<int> watermark =
             await _configElementRepository.GetValue<int>(ConfigElementKey.FFmpegGlobalWatermarkId);
         Option<int> fallbackFiller =
@@ -32,6 +37,8 @@ public class GetFFmpegSettingsHandler : IRequestHandler<GetFFmpegSettings, FFmpe
             await _configElementRepository.GetValue<int>(ConfigElementKey.FFmpegWorkAheadSegmenters);
         Option<int> initialSegmentCount =
             await _configElementRepository.GetValue<int>(ConfigElementKey.FFmpegInitialSegmentCount);
+        Option<OutputFormatKind> outputFormatKind =
+            await _configElementRepository.GetValue<OutputFormatKind>(ConfigElementKey.FFmpegHlsDirectOutputFormat);
 
         var result = new FFmpegSettingsViewModel
         {
@@ -39,10 +46,13 @@ public class GetFFmpegSettingsHandler : IRequestHandler<GetFFmpegSettings, FFmpe
             FFprobePath = await ffprobePath.IfNoneAsync(string.Empty),
             DefaultFFmpegProfileId = await defaultFFmpegProfileId.IfNoneAsync(0),
             SaveReports = await saveReports.IfNoneAsync(false),
+            UseEmbeddedSubtitles = await useEmbeddedSubtitles.IfNoneAsync(true),
+            ExtractEmbeddedSubtitles = await extractEmbeddedSubtitles.IfNoneAsync(false),
             PreferredAudioLanguageCode = await preferredAudioLanguageCode.IfNoneAsync("eng"),
             HlsSegmenterIdleTimeout = await hlsSegmenterIdleTimeout.IfNoneAsync(60),
             WorkAheadSegmenterLimit = await workAheadSegmenterLimit.IfNoneAsync(1),
-            InitialSegmentCount = await initialSegmentCount.IfNoneAsync(1)
+            InitialSegmentCount = await initialSegmentCount.IfNoneAsync(1),
+            HlsDirectOutputFormat = await outputFormatKind.IfNoneAsync(OutputFormatKind.MpegTs)
         };
 
         foreach (int watermarkId in watermark)

ErsatzTV.Application/FFmpegProfiles/Queries/GetSupportedHardwareAccelerationKinds.cs

@@ -0,0 +1,5 @@
+using ErsatzTV.Core.Domain;
+
+namespace ErsatzTV.Application.FFmpegProfiles;
+
+public record GetSupportedHardwareAccelerationKinds : IRequest<List<HardwareAccelerationKind>>;

ErsatzTV.Application/FFmpegProfiles/Queries/GetSupportedHardwareAccelerationKindsHandler.cs

@@ -0,0 +1,79 @@
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.FFmpeg;
+using ErsatzTV.FFmpeg.Capabilities;
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Infrastructure.Extensions;
+using Microsoft.EntityFrameworkCore;
+
+namespace ErsatzTV.Application.FFmpegProfiles;
+
+public class
+    GetSupportedHardwareAccelerationKindsHandler : IRequestHandler<GetSupportedHardwareAccelerationKinds,
+    List<HardwareAccelerationKind>>
+{
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+    private readonly IHardwareCapabilitiesFactory _hardwareCapabilitiesFactory;
+
+    public GetSupportedHardwareAccelerationKindsHandler(
+        IDbContextFactory<TvContext> dbContextFactory,
+        IHardwareCapabilitiesFactory hardwareCapabilitiesFactory)
+    {
+        _dbContextFactory = dbContextFactory;
+        _hardwareCapabilitiesFactory = hardwareCapabilitiesFactory;
+    }
+
+    public async Task<List<HardwareAccelerationKind>> Handle(
+        GetSupportedHardwareAccelerationKinds request,
+        CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+        Validation<BaseError, string> validation = await Validate(dbContext);
+
+        return await validation.Match(
+            GetHardwareAccelerationKinds,
+            _ => Task.FromResult(new List<HardwareAccelerationKind> { HardwareAccelerationKind.None }));
+    }
+
+    private async Task<List<HardwareAccelerationKind>> GetHardwareAccelerationKinds(string ffmpegPath)
+    {
+        var result = new List<HardwareAccelerationKind> { HardwareAccelerationKind.None };
+
+        IFFmpegCapabilities ffmpegCapabilities = await _hardwareCapabilitiesFactory.GetFFmpegCapabilities(ffmpegPath);
+
+        if (ffmpegCapabilities.HasHardwareAcceleration(HardwareAccelerationMode.Nvenc))
+        {
+            result.Add(HardwareAccelerationKind.Nvenc);
+        }
+
+        if (ffmpegCapabilities.HasHardwareAcceleration(HardwareAccelerationMode.Qsv))
+        {
+            result.Add(HardwareAccelerationKind.Qsv);
+        }
+
+        if (ffmpegCapabilities.HasHardwareAcceleration(HardwareAccelerationMode.Vaapi))
+        {
+            result.Add(HardwareAccelerationKind.Vaapi);
+        }
+
+        if (ffmpegCapabilities.HasHardwareAcceleration(HardwareAccelerationMode.VideoToolbox))
+        {
+            result.Add(HardwareAccelerationKind.VideoToolbox);
+        }
+
+        if (ffmpegCapabilities.HasHardwareAcceleration(HardwareAccelerationMode.Amf))
+        {
+            result.Add(HardwareAccelerationKind.Amf);
+        }
+
+        return result;
+    }
+
+    private static async Task<Validation<BaseError, string>> Validate(TvContext dbContext) =>
+        await FFmpegPathMustExist(dbContext);
+
+    private static Task<Validation<BaseError, string>> FFmpegPathMustExist(TvContext dbContext) =>
+        dbContext.ConfigElements.GetValue<string>(ConfigElementKey.FFmpegPath)
+            .FilterT(File.Exists)
+            .Map(maybePath => maybePath.ToValidation<BaseError>("FFmpeg path does not exist on filesystem"));
+}

ErsatzTV.Application/Filler/Commands/DeleteFillerPresetHandler.cs

@@ -17,9 +17,9 @@ public class DeleteFillerPresetHandler : IRequestHandler<DeleteFillerPreset, Eit
         DeleteFillerPreset request,
         CancellationToken cancellationToken)
     {
-        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
         Validation<BaseError, FillerPreset> validation = await FillerPresetMustExist(dbContext, request);
-        return await LanguageExtensions.Apply(validation, ps => DoDeletion(dbContext, ps));
+        return await validation.Apply(ps => DoDeletion(dbContext, ps));
     }
 
     private static Task<Unit> DoDeletion(TvContext dbContext, FillerPreset fillerPreset)
@@ -28,7 +28,7 @@ public class DeleteFillerPresetHandler : IRequestHandler<DeleteFillerPreset, Eit
         return dbContext.SaveChangesAsync().ToUnit();
     }
 
-    private Task<Validation<BaseError, FillerPreset>> FillerPresetMustExist(
+    private static Task<Validation<BaseError, FillerPreset>> FillerPresetMustExist(
         TvContext dbContext,
         DeleteFillerPreset request) =>
         dbContext.FillerPresets

ErsatzTV.Application/Filler/Commands/UpdateFillerPresetHandler.cs

@@ -17,10 +17,10 @@ public class UpdateFillerPresetHandler : IRequestHandler<UpdateFillerPreset, Eit
     {
         await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
         Validation<BaseError, FillerPreset> validation = await FillerPresetMustExist(dbContext, request);
-        return await LanguageExtensions.Apply(validation, ps => ApplyUpdateRequest(dbContext, ps, request));
+        return await validation.Apply(ps => ApplyUpdateRequest(dbContext, ps, request));
     }
 
-    private async Task<Unit> ApplyUpdateRequest(
+    private static async Task<Unit> ApplyUpdateRequest(
         TvContext dbContext,
         FillerPreset existing,
         UpdateFillerPreset request)

ErsatzTV.Application/Filler/Queries/GetAllFillerPresetsHandler.cs

@@ -15,7 +15,7 @@ public class GetAllFillerPresetsHandler : IRequestHandler<GetAllFillerPresets, L
         GetAllFillerPresets request,
         CancellationToken cancellationToken)
     {
-        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
         return await dbContext.FillerPresets.ToListAsync(cancellationToken)
             .Map(presets => presets.Map(ProjectToViewModel).ToList());
     }

ErsatzTV.Application/Filler/Queries/GetPagedFillerPresetsHandler.cs

@@ -1,5 +1,4 @@
-using Dapper;
-using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Infrastructure.Data;
 using Microsoft.EntityFrameworkCore;
 using static ErsatzTV.Application.Filler.Mapper;
 
@@ -17,14 +16,12 @@ public class GetPagedFillerPresetsHandler : IRequestHandler<GetPagedFillerPreset
         CancellationToken cancellationToken)
     {
         await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
-        int count = await dbContext.Connection.QuerySingleAsync<int>(@"SELECT COUNT (*) FROM FillerPreset");
-        List<FillerPresetViewModel> page = await dbContext.FillerPresets.FromSqlRaw(
-                @"SELECT * FROM FillerPreset
-                    ORDER BY Name
-                    COLLATE NOCASE
-                    LIMIT {0} OFFSET {1}",
-                request.PageSize,
-                request.PageNum * request.PageSize)
+        int count = await dbContext.FillerPresets.CountAsync(cancellationToken);
+        List<FillerPresetViewModel> page = await dbContext.FillerPresets
+            .AsNoTracking()
+            .OrderBy(f => EF.Functions.Collate(f.Name, TvContext.CaseInsensitiveCollation))
+            .Skip(request.PageNum * request.PageSize)
+            .Take(request.PageSize)
             .ToListAsync(cancellationToken)
             .Map(list => list.Map(ProjectToViewModel).ToList());
 

ErsatzTV.Application/HDHR/Commands/UpdateHDHRTunerCountHandler.cs

@@ -1,4 +1,5 @@
-using ErsatzTV.Core;
+using System.Globalization;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
 
@@ -15,7 +16,10 @@ public class UpdateHDHRTunerCountHandler : IRequestHandler<UpdateHDHRTunerCount,
         UpdateHDHRTunerCount request,
         CancellationToken cancellationToken) =>
         Validate(request)
-            .MapT(_ => _configElementRepository.Upsert(ConfigElementKey.HDHRTunerCount, request.TunerCount.ToString()))
+            .MapT(
+                _ => _configElementRepository.Upsert(
+                    ConfigElementKey.HDHRTunerCount,
+                    request.TunerCount.ToString(CultureInfo.InvariantCulture)))
             .Bind(v => v.ToEitherAsync());
 
     private static Task<Validation<BaseError, Unit>> Validate(UpdateHDHRTunerCount request) =>