Move CI/CD reference docs from memory to in-repo docs/

Moves ci-cd.md (59 lines) from Claude memory into docs/ alongside
existing architecture docs. Slims MEMORY.md from 42 to 18 lines by
removing sections duplicated in CLAUDE.md (Tech Stack, Key Patterns,
Architecture Docs index).

Total memory load per session: 101 → 18 lines.

Fixes #7

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

.claude/skills/ersatztv/SKILL.md

@@ -0,0 +1,167 @@
+---
+name: ersatztv
+description: ErsatzTV custom IPTV channel management — REST API, SQLite DB, Jellyfin integration, FFmpeg profiles. Use when managing custom TV channels.
+---
+
+# ErsatzTV Channel Management
+
+Container: `ersatztv` | Port: `8409` | IP: `172.16.238.11` (may change on restart)
+Web UI: internal only (`http://localhost:8409` via SSH)
+SQLite DB: `~/downloadswarm/ersatztv/ersatztv.sqlite3` on jazz (owned by root — use `sudo sqlite3`)
+Image: `ghcr.io/ersatztv/ersatztv:latest` (v26.3.0, repo archived Feb 2026)
+
+## Architecture
+
+ErsatzTV uses **MediatR + Blazor** (not REST for mutations). The REST API is limited:
+- **GET endpoints**: channels, collections, schedules, playouts, shows, movies, artists, ffmpeg profiles, health, search, watermarks
+- **POST endpoints**: library scan, playout reset, show scan
+- **No REST CRUD for channels/collections/schedules** — must use SQLite DB directly
+
+## REST API
+
+```bash
+# Via docker exec
+docker exec ersatztv curl -s http://localhost:8409/api/ENDPOINT
+```
+
+### Read Endpoints (GET)
+```
+/api/channels              # List channels
+/api/collections            # List collections
+/api/schedules              # List schedules
+/api/playouts               # List playouts
+/api/shows                  # List shows
+/api/movies                 # List movies
+/api/artists                # List artists
+/api/search                 # Search items
+/api/ffmpeg/profiles        # FFmpeg profiles
+/api/watermarks             # Watermarks
+/iptv/channels.m3u          # M3U playlist (for Jellyfin)
+/iptv/xmltv.xml             # XMLTV guide data
+```
+
+### Mutation Endpoints (POST)
+```bash
+# Library scan
+POST /api/libraries/{id}/scan
+
+# Scan single show
+POST /api/libraries/{id}/scan-show \
+  -H "Content-Type: application/json" -d '{"ShowTitle":"Name","DeepScan":false}'
+
+# Reset channel playout (rebuilds schedule)
+POST /api/channels/{channelNumber}/playout/reset
+```
+
+## SQLite DB Operations
+
+```bash
+# Read queries (safe while running, WAL mode)
+sudo sqlite3 ~/downloadswarm/ersatztv/ersatztv.sqlite3 "QUERY"
+
+# Write queries — stop container first
+docker stop ersatztv
+sudo sqlite3 ~/downloadswarm/ersatztv/ersatztv.sqlite3 "QUERY"
+docker start ersatztv
+```
+
+### Key Queries
+```sql
+-- List channels
+SELECT Id, Number, Name FROM Channel ORDER BY CAST(Number AS INTEGER);
+
+-- List collections with item counts
+SELECT c.Id, c.Name, COUNT(ci.Id) as items FROM Collection c LEFT JOIN CollectionItem ci ON ci.CollectionId = c.Id GROUP BY c.Id;
+
+-- List schedules
+SELECT Id, Name FROM ProgramSchedule;
+
+-- Playout (channel-schedule links)
+SELECT p.Id, c.Number, c.Name, ps.Name as Schedule FROM Playout p JOIN Channel c ON p.ChannelId = c.Id LEFT JOIN ProgramSchedule ps ON p.ProgramScheduleId = ps.Id;
+
+-- Media counts
+SELECT 'Shows' as type, COUNT(*) FROM Show UNION ALL SELECT 'Movies', COUNT(*) FROM Movie UNION ALL SELECT 'Episodes', COUNT(*) FROM Episode UNION ALL SELECT 'MusicVideos', COUNT(*) FROM MusicVideo;
+
+-- Jellyfin source
+SELECT jms.Id, jc.Address, jms.ServerName FROM JellyfinMediaSource jms JOIN JellyfinConnection jc ON jc.JellyfinMediaSourceId = jms.Id;
+
+-- Library sync status
+SELECT l.Id, l.Name, l.MediaKind, jl.ShouldSyncItems FROM Library l JOIN JellyfinLibrary jl ON jl.Id = l.Id;
+```
+
+### Channel Setup Workflow (DB)
+
+**Show-specific channel** (single TV show, shuffled):
+```sql
+-- 1. Schedule
+INSERT INTO ProgramSchedule (Id, FixedStartTimeBehavior, KeepMultiPartEpisodesTogether, Name, RandomStartPoint, ShuffleScheduleItems, TreatCollectionsAsShows)
+VALUES (<id>, 0, 0, '<name>', 1, 0, 1);
+-- 2. Schedule item (CollectionType=1 for Show, PlaybackOrder=3 for Shuffle)
+INSERT INTO ProgramScheduleItem (Id, CollectionType, FillWithGroupMode, GuideMode, "Index", MarathonGroupBy, MarathonShuffleGroups, MarathonShuffleItems, MediaItemId, PlaybackOrder, ProgramScheduleId)
+VALUES (<id>, 1, 0, 0, 0, 0, 0, 0, <show_id>, 3, <schedule_id>);
+INSERT INTO ProgramScheduleOneItem (Id) VALUES (<item_id>);
+-- 3. Channel
+INSERT INTO Channel (Id, Categories, FFmpegProfileId, FallbackFillerId, "Group", IdleBehavior, IsEnabled, MirrorSourceChannelId, MusicVideoCreditsMode, MusicVideoCreditsTemplate, Name, Number, PlayoutMode, PlayoutOffset, PlayoutSource, PreferredAudioLanguageCode, PreferredAudioTitle, PreferredSubtitleLanguageCode, ShowInEpg, SongVideoMode, SortNumber, StreamSelector, StreamSelectorMode, StreamingMode, SubtitleMode, TranscodeMode, UniqueId, WatermarkId)
+VALUES (<id>, '', 1, NULL, '<category>', 0, 1, NULL, 0, NULL, '<name>', '<number>', 0, NULL, 0, NULL, NULL, 'eng', 1, 0, <number>.0, NULL, 0, 4, 2, 0, lower(hex(randomblob(4)))||'-'||lower(hex(randomblob(2)))||'-4'||substr(lower(hex(randomblob(2))),2)||'-'||lower(hex(randomblob(2)))||'-'||lower(hex(randomblob(6))), 1);
+-- 4. Playout
+INSERT INTO Playout (Id, ChannelId, ProgramScheduleId, ScheduleKind, Seed)
+VALUES (<id>, <channel_id>, <schedule_id>, 0, abs(random()) % 1000000);
+```
+
+**Collection-based channel** (multiple shows, shuffled):
+```sql
+-- 1. Collection + items (MediaItemId = Show.Id)
+INSERT INTO Collection (Id, Name, UseCustomPlaybackOrder) VALUES (<id>, '<name>', 0);
+INSERT INTO CollectionItem (CollectionId, MediaItemId) VALUES (<coll_id>, <show_id>);
+-- 2. Schedule (same as above but CollectionType=0, CollectionId set instead of MediaItemId)
+INSERT INTO ProgramScheduleItem (Id, CollectionId, CollectionType, ..., PlaybackOrder, ProgramScheduleId)
+VALUES (<id>, <coll_id>, 0, ..., 3, <schedule_id>);
+-- 3-4. Channel + Playout same as show-specific
+```
+
+After creating: `POST /api/channels/{number}/playout/reset`
+
+## Volume Mounts (matches Jellyfin)
+
+| Host Path | Container Path |
+|-----------|---------------|
+| `~/downloadswarm/ersatztv` | `/config` |
+| `/mnt/teramind/episodes` | `/data/tvshows` (ro) |
+| `/mnt/episodes` | `/data/episodes` (ro) |
+| `/mnt/media/movies` | `/data/movies` (ro) |
+| `/mnt/media/standup` | `/data/standup` (ro) |
+| `/mnt/media/music_videos` | `/data/music` (ro) |
+
+## FFmpeg & Hardware
+
+- QSV (Intel Quick Sync) hardware acceleration
+- Resolution: 1920x1080, H264, AAC stereo
+- Device: `/dev/dri` passed through
+- HardwareAccelerationKind: 0=None, 1=Qsv, 2=Nvenc, 3=Vaapi, 4=VideoToolbox, 5=Amf
+
+## Jellyfin Integration
+
+- Secrets: `/config/jellyfin-secrets.json` (`{"Address":"http://jellyfin:8096","ApiKey":"978033be716d46678a5d3c54ae0e0ff9"}`)
+- Libraries: Movies(10), TV Shows(11), Music Videos(8), Standup(9)
+- `JellyfinLibrary.ShouldSyncItems` must be `1` for scans to work
+
+## Gotchas
+
+- DB owned by root — always use `sudo sqlite3`
+- WAL mode: reads OK while running, stop container for writes
+- No REST API for channel/collection/schedule CRUD — DB scripting only
+- Secrets file uses PascalCase JSON (`Address`, `ApiKey`)
+- Scanner is separate binary (`ErsatzTV.Scanner`) — check with `docker top ersatztv | grep Scanner`
+- EF TPT inheritance: `ProgramScheduleItem` has subtype tables (`ProgramScheduleOneItem`, etc.) — MUST insert into subtype table
+- External URL logos work for M3U but NOT for watermark burn-in (code checks `File.Exists()`)
+- `/api/health` returns Blazor HTML, not JSON — use `/api/channels` to verify API
+- PlaybackOrder enum: 3=Shuffle, 6=SeasonEpisode (use 3 for all channels)
+- CollectionType enum: 0=Collection, 1=Show (direct show reference via MediaItemId)
+- SubtitleMode: 0=None, 2=Burn-in. Set to 2 with PreferredSubtitleLanguageCode='eng' for non-music channels
+- MediaItem.State: 0=Normal, 1=FileNotFound — clean up state=1 items by deleting cascading deps
+- ProgramSchedule required NOT NULL columns: FixedStartTimeBehavior, KeepMultiPartEpisodesTogether, RandomStartPoint, ShuffleScheduleItems, TreatCollectionsAsShows
+- Channel required NOT NULL columns: SongVideoMode (set 0), plus all standard columns (see Channel table schema)
+- After schedule changes, rebuild playout: `POST /api/channels/{number}/playout/reset`
+- Playout `ScheduleKind` must be `1` (not `0`/None) — `0` causes "Cannot build playout type None" error
+- M3U `tvg-logo` URLs hardcode `http://localhost:8409` — Jellyfin can't fetch these from inside its container. Fix by downloading logos from ETV and base64-uploading to Jellyfin (see `docs/Docker/ErsatzTV.md` for script). Tracked in issue #171
+- Repo archived Feb 2026, v26.3.0 is final stable version. Maintainer welcomes forks

.claude/skills/jellyfin/SKILL.md

@@ -0,0 +1,105 @@
+---
+name: jellyfin
+description: Jellyfin media server management — API for libraries, items, streaming, users. Use when managing media library or checking Jellyfin status.
+---
+
+# Jellyfin Management
+
+Container: `jellyfin` | Port: `8096` | IP: `172.16.238.20` (may change on restart)
+API Token: `978033be716d46678a5d3c54ae0e0ff9`
+Web UI: `https://jellyfin.tblindustries.be` (NO Authelia — native login, password: `coup1802`)
+Config: `/home/timothy/downloadswarm/jellyfin/` on jazz
+
+## Access Pattern
+
+```bash
+docker exec jellyfin curl -s 'http://localhost:8096/ENDPOINT' \
+  -H 'X-Emby-Token: 978033be716d46678a5d3c54ae0e0ff9'
+```
+
+## Volume Mounts
+
+| Host Path | Container Path | Content |
+|-----------|---------------|---------|
+| `/mnt/teramind/episodes` | `/data/tvshows` | TV shows |
+| `/mnt/episodes` | `/data/episodes` | More episodes |
+| `/mnt/media/movies` | `/data/movies` | Movies |
+| `/mnt/media/standup` | `/data/standup` | Standup |
+| `/mnt/media/music_videos` | `/data/music` | Music videos |
+| `/mnt/media/audio/music` | `/data/audio` | Music audio (ro) |
+
+## API Endpoints
+
+### System
+```
+GET  /System/Info                   # Server info, version
+GET  /System/Info/Public            # Public info (no auth needed)
+POST /System/Restart                # Restart server
+```
+
+### Items (Search & Browse)
+```bash
+# Search items
+GET /Items?includeItemTypes=Movie,Episode,Series&recursive=true&searchTerm=QUERY&fields=Path&limit=20
+
+# Get item details
+GET /Items?ids=ITEM_ID&fields=Path,MediaStreams,Overview
+
+# Get all movies
+GET /Items?includeItemTypes=Movie&recursive=true&fields=Path&limit=1000
+
+# Get series
+GET /Items?includeItemTypes=Series&recursive=true&fields=Path
+
+# Get episodes for a series
+GET /Shows/{seriesId}/Episodes?fields=Path,MediaStreams
+
+# Filter by library (parentId)
+GET /Items?parentId=LIBRARY_ID&recursive=true&fields=Path
+```
+
+### Libraries
+```
+GET  /Library/VirtualFolders        # List all libraries
+POST /Library/Refresh               # Trigger full library scan
+POST /Items/{id}/Refresh            # Refresh single item metadata
+```
+
+### Streaming
+```bash
+# Test stream URL
+GET /Videos/{itemId}/stream?static=true
+
+# Get playback info
+GET /Items/{itemId}/PlaybackInfo
+```
+
+### Users
+```
+GET  /Users                         # List users
+GET  /Users/{userId}                # User details
+```
+
+## Library IDs
+
+Check with: `curl -s -H "X-Emby-Token: TOKEN" http://localhost:8096/Library/VirtualFolders`
+
+## Live TV
+
+- **ErsatzTV** (channels <1000): M3U `http://ersatztv:8409/iptv/channels.m3u`, XMLTV `http://ersatztv:8409/iptv/xmltv.xml`
+- **Dispatcharr** (channels 1000+): IPTV stream manager on port 9191, separate tuner
+- Configured in Jellyfin Admin > Live TV
+- Guide refresh task ID: `bea9b218c97bbf98c5dc1303bdb9a0ca` — trigger via `POST /ScheduledTasks/Running/{id}`
+- **Logo fix after guide refresh**: ErsatzTV logos break (aspect ratio=0) because M3U uses `localhost:8409`. Fix script in `docs/Docker/ErsatzTV.md` downloads from ETV and base64-uploads to `POST /Items/{id}/Images/Primary` (body = base64, Content-Type = image/png)
+- **Image upload format**: Jellyfin expects base64-encoded body (NOT raw binary) for `POST /Items/{id}/Images/Primary`
+
+## Gotchas
+
+- **Passwords**: `coup1802` (NOT `ded89Lm4`) — Jellyfin has native auth, no Authelia
+- Auth header is `X-Emby-Token` (Jellyfin is an Emby fork)
+- Music videos are typed as "Movie" in Jellyfin
+- Music library at `/data/music` maps to `/mnt/media/music_videos` on host (not actual music)
+- Items return 404 on stream if source volume is unmounted
+- Jellyfin preserves item IDs across restarts unless files are renamed
+- Full library scan can take a long time — prefer targeted `/Items/{id}/Refresh`
+- `ffprobe` available in container for checking media streams: `docker exec jellyfin ffprobe -v quiet -print_format json -show_streams FILE`

.config/dotnet-tools.json

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

.editorconfig

@@ -1,9 +1,8 @@
-
 [*]
-charset=utf-8-bom
+charset=utf-8
 end_of_line=lf
-trim_trailing_whitespace=false
-insert_final_newline=false
+trim_trailing_whitespace=true
+insert_final_newline=true
 indent_style=space
 indent_size=4
 
@@ -15,7 +14,7 @@ csharp_style_expression_bodied_constructors=true:none
 csharp_style_expression_bodied_methods=true:none
 csharp_style_expression_bodied_properties=true:suggestion
 csharp_style_var_elsewhere=false:suggestion
-csharp_style_var_for_built_in_types=false:suggestion
+csharp_style_var_for_built_in_types=false:none
 csharp_style_var_when_type_is_apparent=true:suggestion
 dotnet_naming_rule.local_constants_rule.severity=warning
 dotnet_naming_rule.local_constants_rule.style=all_upper_style
@@ -42,6 +41,8 @@ resharper_braces_for_for=required
 resharper_braces_for_foreach=required
 resharper_braces_for_ifelse=required
 resharper_braces_for_while=required
+resharper_csharp_arguments_literal=positional
+resharper_csharp_arguments_named=positional
 resharper_csharp_insert_final_newline=true
 resharper_csharp_max_attribute_length_for_same_line=0
 resharper_csharp_place_accessorholder_attribute_on_same_line=never
@@ -66,7 +67,7 @@ resharper_built_in_type_reference_style_highlighting=hint
 resharper_redundant_base_qualifier_highlighting=warning
 resharper_suggest_var_or_type_built_in_types_highlighting=hint
 resharper_suggest_var_or_type_elsewhere_highlighting=hint
-resharper_suggest_var_or_type_simple_types_highlighting=hint
+resharper_suggest_var_or_type_simple_types_highlighting=none
 resharper_web_config_module_not_resolved_highlighting=warning
 resharper_web_config_type_not_resolved_highlighting=warning
 resharper_web_config_wrong_module_highlighting=warning
@@ -83,3 +84,23 @@ tab_width=4
 [*.yml]
 indent_style = space
 indent_size = 2
+
+[*.json]
+ij_json_array_wrapping = normal
+ij_json_keep_blank_lines_in_code = 0
+ij_json_keep_indents_on_empty_lines = false
+ij_json_keep_line_breaks = true
+ij_json_keep_trailing_comma = false
+ij_json_object_wrapping = normal
+ij_json_property_alignment = do_not_align
+ij_json_space_after_colon = true
+ij_json_space_after_comma = true
+ij_json_space_before_colon = false
+ij_json_space_before_comma = false
+ij_json_spaces_within_braces = true
+ij_json_spaces_within_brackets = true
+ij_json_wrap_long_lines = false
+
+[*.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/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,14 @@
+blank_issues_enabled: false
+contact_links:
+  - name: Feature Requests
+    url: https://features.ersatztv.org
+    about: Features
+  - name: Contact
+    url: https://ersatztv.org/contact
+    about: Chat Options
+  - name: Community
+    url: https://discuss.ersatztv.org
+    about: Forum
+  - name: Discussions
+    url: https://github.com/ErsatzTV/ErsatzTV/discussions
+    about: Discuss

.github/ISSUE_TEMPLATE/issue.yml

@@ -0,0 +1,77 @@
+name: Issue Report
+description: Report an issue
+type: Bug
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thanks for taking the time to fill out this form! Please make sure to fill all fields, including the Title above.
+  - type: checkboxes
+    id: before-posting
+    attributes:
+      label: "This issue respects the following points:"
+      description: All conditions are **required**. Failure to comply with any of these conditions may cause your issue to be closed without comment.
+      options:
+        - label: This is a **bug**, not a question or a configuration issue; Please visit our [forum](https://discuss.ersatztv.org) or [chat](https://ersatztv.org/contact) first to troubleshoot with volunteers before creating a report.
+          required: true
+        - label: This issue is **not** already reported on [GitHub](https://github.com/ErsatzTV/ErsatzTV/issues?q=is%3Aopen+is%3Aissue) _(I've searched it)_.
+          required: true
+        - label: I'm using an up to date version of ErsatzTV (full release or develop release); We generally do not support previous older versions. If possible, please update to the latest version before opening an issue.
+          required: true
+        - label: This report addresses only a single issue; If you encounter multiple issues, please create separate reports for each one.
+          required: true
+  - type: textarea
+    id: description
+    attributes:
+      label: Description
+      description: |
+        Description of the problem or issue here.
+    validations:
+      required: true
+  - type: textarea
+    id: repro-steps
+    attributes:
+      label: Steps to reproduce the problem.
+      description: |
+        1. Step 1
+        2. Step 2
+        3. Step 3
+
+        If this is a playback issue, follow these steps and post the resulting zip:
+          1. Search for the required content using the search bar.
+          2. Use the overflow/three dots menu on the content and select Troubleshoot Playback.
+          3. Select the appropriate Playback Settings that trigger the undesired behavior.
+          4. Click Play to start playback.
+          5. Repeat steps 3 and 4 until the undesired behavior is reproduced.
+          6. Click Download Results to have ErsatzTV collect relevant troubleshooting logs (ffmpeg log, ffmpeg profile, hardware capabilities, media info, etc) and compress them in a zip file.
+          7. Attach the zip to this field.
+    validations:
+      required: true
+  - type: textarea
+    id: actual-behavior
+    attributes:
+      label: What is the current _bug_ behavior?
+      description: Write down the incorrect behavior that currently happens after following the reproduction steps.
+    validations:
+      required: true
+  - type: textarea
+    id: expected-behavior
+    attributes:
+      label: What is the expected _correct_ behavior?
+      description: Write down the correct expected behavior that is supposed to happen after following the reproduction steps.
+    validations:
+      required: true
+  - type: input
+    id: version
+    attributes:
+      label: Specify full version
+      description: Provide the full version of ErsatzTV, which can be found below the left menu.
+      placeholder: |
+        25.5.0-bd695412-docker-amd64
+    validations:
+      required: true
+  - type: textarea
+    id: additional-information
+    attributes:
+      label: Additional information
+      description: Any additional information that might be useful to this issue.

.github/dependabot.yml

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

.github/workflows/artifacts.yml

@@ -0,0 +1,336 @@
+name: Build Artifacts
+on:
+  workflow_call:
+    inputs:
+      release_tag:
+        description: 'Release tag'
+        required: true
+        type: string
+      release_version:
+        description: 'Release version number (e.g. v0.3.7-alpha)'
+        required: true
+        type: string
+      info_version:
+        description: 'Informational version number (e.g. 0.3.7-alpha)'
+        required: true
+        type: string
+    secrets:
+      apple_developer_certificate_p12_base64:
+        required: true
+      apple_developer_certificate_password:
+        required: true
+      ac_username:
+        required: true
+      ac_password:
+        required: true
+      gh_token:
+        required: true
+      azure_client_id:
+        required: true
+      azure_tenant_id:
+        required: true
+      azure_subscription_id:
+        required: true
+permissions:
+  id-token: write
+  contents: write
+jobs:
+  build_and_upload_mac:
+    name: Mac Build & Upload
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        include:
+          - os: macos-14
+            kind: macOS
+            target: osx-x64
+          - os: macos-14
+            kind: macOS
+            target: osx-arm64
+    steps:
+      - name: Get the sources
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          submodules: true
+
+      - name: Setup dotnet
+        uses: actions/setup-dotnet@v4
+        with:
+          dotnet-version: '10.0.x'
+
+      - name: Clean
+        run: dotnet clean --configuration Release && dotnet nuget locals all --clear
+
+      - name: Install dependencies
+        run: dotnet restore -r "${{ matrix.target}}"
+
+      - name: Import Code-Signing Certificates
+        uses: Apple-Actions/import-codesign-certs@v2
+        with:
+          p12-file-base64: ${{ secrets.apple_developer_certificate_p12_base64 }}
+          p12-password: ${{ secrets.apple_developer_certificate_password }}
+
+      - name: Calculate Release Name
+        shell: bash
+        run: |
+          release_name="ErsatzTV-${{ inputs.release_version }}-${{ matrix.target }}"
+          echo "RELEASE_NAME=${release_name}" >> $GITHUB_ENV
+
+      - name: Build
+        shell: bash
+        run: |
+          sed -i '' '/Scanner/d' ErsatzTV/ErsatzTV.csproj
+          dotnet publish ErsatzTV.Scanner/ErsatzTV.Scanner.csproj --framework net10.0 --runtime "${{ matrix.target }}" -c Release -o publish -p:RestoreEnablePackagePruning=true -p:InformationalVersion="${{ inputs.release_version }}-${{ matrix.target }}" -p:EnableCompressionInSingleFile=false -p:DebugType=Embedded -p:PublishSingleFile=true --self-contained true
+          dotnet publish ErsatzTV/ErsatzTV.csproj --framework net10.0 --runtime "${{ matrix.target }}" -c Release -o publish -p:RestoreEnablePackagePruning=true -p:InformationalVersion="${{ inputs.release_version }}-${{ matrix.target }}" -p:EnableCompressionInSingleFile=false -p:DebugType=Embedded -p:PublishSingleFile=true --self-contained true
+
+      - name: Bundle
+        shell: bash
+        run: |
+          brew install coreutils
+          plutil -replace CFBundleShortVersionString -string "${{ inputs.info_version }}" ErsatzTV-macOS/ErsatzTV-macOS/Info.plist
+          plutil -replace CFBundleVersion -string "${{ inputs.info_version }}" ErsatzTV-macOS/ErsatzTV-macOS/Info.plist
+          scripts/macOS/bundle.sh
+
+      - name: Sign
+        shell: bash
+        run: scripts/macOS/sign.sh
+
+      - name: Create DMG
+        shell: bash
+        run: |
+          brew install create-dmg
+          create-dmg \
+            --volname "ErsatzTV" \
+            --volicon "artwork/ErsatzTV.icns" \
+            --window-pos 200 120 \
+            --window-size 800 400 \
+            --icon-size 100 \
+            --icon "ErsatzTV.app" 200 190 \
+            --hide-extension "ErsatzTV.app" \
+            --app-drop-link 600 185 \
+            --skip-jenkins \
+            --no-internet-enable \
+            "ErsatzTV.dmg" \
+            "ErsatzTV.app/"
+
+      - name: Notarize
+        shell: bash
+        run: |
+          xcrun notarytool submit ErsatzTV.dmg --apple-id "${{ secrets.ac_username }}" --password "${{ secrets.ac_password }}" --team-id 32MB98Q32R --wait
+          xcrun stapler staple ErsatzTV.dmg
+
+      - name: Cleanup
+        shell: bash
+        run: |
+          mv ErsatzTV.dmg "${{ env.RELEASE_NAME }}.dmg"
+          rm -r publish
+          rm -r ErsatzTV.app
+
+      - name: Delete old release assets
+        uses: mknejp/delete-release-assets@v1
+        if: ${{ inputs.release_tag == 'develop' }}
+        with:
+          token: ${{ secrets.gh_token }}
+          tag: ${{ inputs.release_tag }}
+          fail-if-no-assets: false
+          assets: "*${{ matrix.target }}.dmg"
+
+      - name: Publish
+        uses: softprops/action-gh-release@v1
+        with:
+          prerelease: false
+          tag_name: ${{ inputs.release_tag }}
+          files: "${{ env.RELEASE_NAME }}.dmg"
+        env:
+          GITHUB_TOKEN: ${{ secrets.gh_token }}
+
+  build_and_upload_linux:
+    name: Build & Upload Linux
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        include:
+          - os: ubuntu-latest
+            kind: linux
+            target: linux-x64
+          - os: ubuntu-latest
+            kind: linux
+            target: linux-musl-x64
+          - os: ubuntu-latest
+            kind: linux
+            target: linux-arm
+          - os: ubuntu-24.04-arm
+            kind: linux
+            target: linux-arm64
+    steps:
+      - name: Get the sources
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Setup dotnet
+        uses: actions/setup-dotnet@v4
+        with:
+          dotnet-version: '10.0.x'
+
+      - name: Clean
+        run: dotnet clean --configuration Release && dotnet nuget locals all --clear
+
+      - name: Install dependencies
+        run: dotnet restore -r "${{ matrix.target }}"
+
+      - name: Build
+        shell: bash
+        run: |
+          # Define some variables for things we need
+          release_name="ErsatzTV-${{ inputs.release_version }}-${{ matrix.target }}"
+          echo "RELEASE_NAME=${release_name}" >> $GITHUB_ENV
+
+          # Build everything
+          sed -i '/Scanner/d' ErsatzTV/ErsatzTV.csproj
+          dotnet publish ErsatzTV.Scanner/ErsatzTV.Scanner.csproj --framework net10.0 --runtime "${{ matrix.target }}" -c Release -o "scanner" -p:RestoreEnablePackagePruning=true -p:InformationalVersion="${{ inputs.release_version }}-${{ matrix.target }}" -p:EnableCompressionInSingleFile=true -p:DebugType=Embedded -p:PublishSingleFile=true --self-contained true
+          dotnet publish ErsatzTV/ErsatzTV.csproj --framework net10.0 --runtime "${{ matrix.target }}" -c Release -o "main" -p:RestoreEnablePackagePruning=true -p:InformationalVersion="${{ inputs.release_version }}-${{ matrix.target }}" -p:EnableCompressionInSingleFile=true -p:DebugType=Embedded -p:PublishSingleFile=true --self-contained true
+          mkdir "$release_name"
+          mv scanner/* "$release_name/"
+          mv main/* "$release_name/"
+          tar czvf "${release_name}.tar.gz" "$release_name"
+
+          # Delete output directory
+          rm -r "$release_name"
+
+      - name: Delete old release assets
+        uses: mknejp/delete-release-assets@v1
+        if: ${{ inputs.release_tag == 'develop' }}
+        with:
+          token: ${{ secrets.gh_token }}
+          tag: ${{ inputs.release_tag }}
+          fail-if-no-assets: false
+          assets: "*${{ matrix.target }}.tar.gz"
+
+      - name: Publish
+        uses: softprops/action-gh-release@v1
+        with:
+          prerelease: false
+          tag_name: ${{ inputs.release_tag }}
+          files: "${{ env.RELEASE_NAME }}.tar.gz"
+        env:
+          GITHUB_TOKEN: ${{ secrets.gh_token }}
+
+  build_dotnet_windows:
+    name: Build dotnet for Windows
+    runs-on: ubuntu-latest
+    steps:
+      - name: Get the sources
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Setup dotnet
+        uses: actions/setup-dotnet@v4
+        with:
+          dotnet-version: '10.0.x'
+
+      - name: Clean
+        run: dotnet clean --configuration Release && dotnet nuget locals all --clear
+
+      - name: Install dependencies
+        run: dotnet restore -r "win-x64"
+
+      - name: Build dotnet projects
+        shell: bash
+        run: |
+          sed -i '/Scanner/d' ErsatzTV/ErsatzTV.csproj
+          dotnet publish ErsatzTV.Scanner/ErsatzTV.Scanner.csproj --framework net10.0 --runtime "win-x64" -c Release -o "scanner" -p:RestoreEnablePackagePruning=true -p:InformationalVersion="${{ inputs.release_version }}-win-x64" -p:EnableCompressionInSingleFile=true -p:DebugType=Embedded -p:PublishSingleFile=true --self-contained true
+          dotnet publish ErsatzTV/ErsatzTV.csproj --framework net10.0 --runtime "win-x64" -c Release -o "main" -p:RestoreEnablePackagePruning=true -p:InformationalVersion="${{ inputs.release_version }}-win-x64" -p:EnableCompressionInSingleFile=true -p:DebugType=Embedded -p:PublishSingleFile=true --self-contained true
+
+      - name: Upload .NET Artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: dotnet-windows-build
+          path: |
+            scanner/
+            main/
+          retention-days: 1
+
+  package_and_upload_windows:
+    name: Package & Upload Windows
+    runs-on: windows-latest
+    needs: build_dotnet_windows
+    steps:
+      - name: Download dotnet artifacts
+        uses: actions/download-artifact@v4
+        with:
+          name: dotnet-windows-build
+          path: dotnet-build
+
+      - name: Azure login
+        uses: azure/login@v2
+        with:
+          client-id: ${{ secrets.azure_client_id }}
+          tenant-id: ${{ secrets.azure_tenant_id }}
+          subscription-id: ${{ secrets.azure_subscription_id }}
+          enable-AzPSSession: true
+
+      - name: Sign dotnet artifacts
+        uses: azure/trusted-signing-action@v0
+        with:
+          endpoint: https://eus.codesigning.azure.net/
+          trusted-signing-account-name: ArtifactSigning
+          certificate-profile-name: ErsatzTV
+          files-folder: ${{ github.workspace }}/dotnet-build
+          files-folder-recurse: true
+          files-folder-filter: ErsatzTV.exe,ErsatzTV.Scanner.exe
+          file-digest: SHA256
+          timestamp-rfc3161: http://timestamp.acs.microsoft.com
+          timestamp-digest: SHA256
+
+      - name: Download rust launcher
+        uses: suisei-cn/actions-download-file@v1.3.0
+        with:
+          url: "https://github.com/ErsatzTV/ErsatzTV-Windows/releases/download/v1.0.0/ErsatzTV-Windows.exe"
+          target: rust-build/
+
+      - name: Download ffmpeg
+        uses: suisei-cn/actions-download-file@v1.3.0
+        id: downloadffmpeg
+        with:
+          url: "https://github.com/ErsatzTV/ErsatzTV-ffmpeg/releases/download/7.1.1/ffmpeg-n7.1.1-56-gc2184b65d2-win64-gpl-7.1.zip"
+          target: ffmpeg/
+
+      - name: Package artifacts
+        shell: bash
+        run: |
+          release_name="ErsatzTV-${{ inputs.release_version }}-win-x64"
+          echo "RELEASE_NAME=${release_name}" >> $GITHUB_ENV
+          mkdir "$release_name"
+
+          mv dotnet-build/scanner/* "$release_name/"
+          mv dotnet-build/main/* "$release_name/"
+
+          # dotnet shouldn't copy the resources here, but it does
+          rm -rf "$release_name/Resources"
+
+          mv rust-build/ErsatzTV-Windows.exe "$release_name/ErsatzTV-Windows.exe"
+          7z e "ffmpeg/${{ steps.downloadffmpeg.outputs.filename }}" -o"$release_name" '*.exe' -r
+          rm -f "$release_name/ffplay.exe"
+
+          (cd "${release_name}" && 7z a "../${release_name}.zip" .)
+
+      - name: Delete old release assets
+        uses: mknejp/delete-release-assets@v1
+        if: ${{ inputs.release_tag == 'develop' }}
+        with:
+          token: ${{ secrets.gh_token }}
+          tag: ${{ inputs.release_tag }}
+          fail-if-no-assets: false
+          assets: "*win-x64.zip"
+
+      - name: Publish
+        uses: softprops/action-gh-release@v1
+        with:
+          prerelease: false
+          tag_name: ${{ inputs.release_tag }}
+          files: "${{ env.RELEASE_NAME }}.zip"
+        env:
+          GITHUB_TOKEN: ${{ secrets.gh_token }}

.github/workflows/ci.yml

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

.github/workflows/docker.yml

@@ -0,0 +1,141 @@
+name: Build & Publish to Docker Hub
+on:
+  workflow_call:
+    inputs:
+      base_version:
+        description: 'Base version (latest or develop)'
+        required: true
+        type: string
+      info_version:
+        description: 'Informational version number (e.g. 0.3.7-alpha)'
+        required: true
+        type: string
+      tag_version:
+        description: 'Docker tag version (e.g. v0.3.7)'
+        required: true
+        type: string
+    secrets:
+      docker_hub_username:
+        required: true
+      docker_hub_access_token:
+        required: true
+jobs:
+  build_images:
+    name: Build ${{ matrix.name }} image
+    runs-on: ${{ matrix.os }}
+    if: contains(github.event.head_commit.message, '[no build]') == false
+    strategy:
+      matrix:
+        include:
+          - name: amd64
+            os: ubuntu-latest
+            path: ''
+            suffix: '-amd64'
+            platform: 'linux/amd64'
+          - name: arm32v7
+            os: ubuntu-latest
+            path: 'arm32v7/'
+            suffix: '-arm'
+            platform: 'linux/arm/v7'
+          - name: arm64
+            os: ubuntu-24.04-arm
+            path: 'arm64/'
+            suffix: '-arm64'
+            platform: 'linux/arm64'
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Set up QEMU
+        if: ${{ matrix.name == 'arm32v7' }}
+        uses: docker/setup-qemu-action@v3
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Login to DockerHub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.docker_hub_username }}
+          password: ${{ secrets.docker_hub_access_token }}
+
+      - name: Log in to the Container registry
+        uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Build and push by digest
+        id: build
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          file: ./docker/${{ matrix.path }}Dockerfile
+          push: true
+          provenance: false
+          platforms: ${{ matrix.platform }}
+          build-args: |
+            INFO_VERSION=${{ inputs.info_version }}-docker${{ matrix.suffix }}
+          outputs: |
+            type=image,name=jasongdove/ersatztv,name-canonical=true,push-by-digest=true
+            type=image,name=ghcr.io/ersatztv/ersatztv,name-canonical=true,push-by-digest=true
+
+      - name: Save digest to artifact
+        run: echo ${{ steps.build.outputs.digest }} > digest.txt
+
+      - name: Upload digest artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: digest-${{ matrix.name }}
+          path: digest.txt
+
+  merge_manifests:
+    name: Merge Manifests
+    runs-on: ubuntu-latest
+    needs: build_images
+    steps:
+      - name: Login to DockerHub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.docker_hub_username }}
+          password: ${{ secrets.docker_hub_access_token }}
+
+      - name: Log in to the Container registry
+        uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Download all digest artifacts
+        uses: actions/download-artifact@v4
+        with:
+          path: digests/
+
+      - name: Read digests from artifacts
+        id: digests
+        run: |
+          AMD64_HASH=$(cat digests/digest-amd64/digest.txt)
+          ARM32V7_HASH=$(cat digests/digest-arm32v7/digest.txt)
+          ARM64_HASH=$(cat digests/digest-arm64/digest.txt)
+
+          DOCKER_HUB_DIGESTS="jasongdove/ersatztv@${AMD64_HASH} jasongdove/ersatztv@${ARM64_HASH} jasongdove/ersatztv@${ARM32V7_HASH}"
+          GHCR_DIGESTS="ghcr.io/ersatztv/ersatztv@${AMD64_HASH} ghcr.io/ersatztv/ersatztv@${ARM64_HASH} ghcr.io/ersatztv/ersatztv@${ARM32V7_HASH}"
+
+          echo "docker_hub_digests=${DOCKER_HUB_DIGESTS}" >> $GITHUB_OUTPUT
+          echo "ghcr_digests=${GHCR_DIGESTS}" >> $GITHUB_OUTPUT
+
+      - name: Create and push manifests
+        run: |
+          docker manifest create jasongdove/ersatztv:${{ inputs.base_version }} ${{ steps.digests.outputs.docker_hub_digests }}
+          docker manifest push jasongdove/ersatztv:${{ inputs.base_version }}
+          docker manifest create jasongdove/ersatztv:${{ inputs.tag_version }} ${{ steps.digests.outputs.docker_hub_digests }}
+          docker manifest push jasongdove/ersatztv:${{ inputs.tag_version }}
+
+          docker manifest create ghcr.io/ersatztv/ersatztv:${{ inputs.base_version }} ${{ steps.digests.outputs.ghcr_digests }}
+          docker manifest push ghcr.io/ersatztv/ersatztv:${{ inputs.base_version }}
+          docker manifest create ghcr.io/ersatztv/ersatztv:${{ inputs.tag_version }} ${{ steps.digests.outputs.ghcr_digests }}
+          docker manifest push ghcr.io/ersatztv/ersatztv:${{ inputs.tag_version }}

.github/workflows/docs.yml

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

.github/workflows/issue-stale.yml

@@ -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

@@ -0,0 +1,118 @@
+name: Pull Request
+on:
+  pull_request:
+jobs:
+  build_and_analyze:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Get the sources
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          submodules: true
+
+      - name: Setup dotnet
+        uses: actions/setup-dotnet@v4
+        with:
+          dotnet-version: '10.0.x'
+
+      - name: Clean
+        run: dotnet clean --configuration Release && dotnet nuget locals all --clear
+
+      - name: Install dependencies
+        run: dotnet restore
+
+      - name: Prep project file
+        run: sed -i '/Scanner/d' ErsatzTV/ErsatzTV.csproj
+
+      - name: Build
+        run: dotnet build --configuration Release --no-restore /p:EnableThreadingAnalyzers=true
+  build_and_test_windows:
+    runs-on: windows-latest
+    steps:
+      - name: Get the sources
+        uses: actions/checkout@v4
+
+      - name: Setup dotnet
+        uses: actions/setup-dotnet@v4
+        with:
+          dotnet-version: '10.0.x'
+
+      - name: Clean
+        run: dotnet clean --configuration Release && dotnet nuget locals all --clear
+
+      - name: Install dependencies
+        run: dotnet restore
+
+      - name: Prep project file
+        run: sed -i '/Scanner/d' ErsatzTV/ErsatzTV.csproj
+
+      - name: Build
+        run: dotnet build --configuration Release --no-restore
+
+      - name: Test
+        run: dotnet test --blame-hang-timeout "2m" --no-restore --verbosity normal
+  build_and_test_linux:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        include:
+          - os: ubuntu-latest
+            target: linux-x64
+          - os: ubuntu-latest
+            target: linux-musl-x64
+          - os: ubuntu-latest
+            target: linux-arm
+          - os: ubuntu-24.04-arm
+            target: linux-arm64
+    steps:
+      - name: Get the sources
+        uses: actions/checkout@v4
+
+      - name: Setup dotnet
+        uses: actions/setup-dotnet@v4
+        with:
+          dotnet-version: '10.0.x'
+
+      - name: Clean
+        run: dotnet clean --configuration Release && dotnet nuget locals all --clear
+
+      - name: Install dependencies
+        run: dotnet restore -p:RestoreEnablePackagePruning=true -r "${{ matrix.target }}"
+
+      - name: Prep project file
+        run: sed -i '/Scanner/d' ErsatzTV/ErsatzTV.csproj
+
+      - name: Build
+        run: dotnet build ErsatzTV/ErsatzTV.csproj --runtime "${{ matrix.target }}" --configuration Release --no-restore && dotnet build --configuration Release --no-restore
+
+      - name: Test
+        run: dotnet test --blame-hang-timeout "2m" --no-restore --verbosity normal
+  build_and_test_mac:
+    runs-on: macos-14
+    steps:
+      - name: Get the sources
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          submodules: true
+
+      - name: Setup dotnet
+        uses: actions/setup-dotnet@v4
+        with:
+          dotnet-version: '10.0.x'
+
+      - name: Clean
+        run: dotnet clean --configuration Release && dotnet nuget locals all --clear
+
+      - name: Install dependencies
+        run: dotnet restore
+
+      - name: Prep project file
+        run: sed -i '' '/Scanner/d' ErsatzTV/ErsatzTV.csproj
+
+      - name: Build
+        run: dotnet build --configuration Release --no-restore
+
+      - name: Test
+        run: dotnet test --blame-hang-timeout "2m" --no-restore --verbosity normal

.github/workflows/release.yml

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

.gitignore

@@ -3,6 +3,9 @@
 project.lock.json
 .DS_Store
 *.pyc
+
+# Claude Code
+.mcp/
 nupkg/
 
 # Visual Studio Code
@@ -40,6 +43,8 @@ msbuild.wrn
 core
 
 scripts/generate-api-sdk/swagger.json
+scripts/download-test-content.sh
 
 docker-compose.override.yml
 
+ErsatzTV/wwwroot/v2/

.gitmodules

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

.mcp.json

@@ -0,0 +1,56 @@
+{
+  "mcpServers": {
+    "docker-mcp": {
+      "command": "uvx",
+      "args": [
+        "mcp-server-docker"
+      ],
+      "env": {
+        "DOCKER_HOST": "ssh://timothy@192.168.1.99"
+      }
+    },
+    "ssh-mcp": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "ssh-mcp",
+        "--",
+        "--host=192.168.1.99",
+        "--user=timothy"
+      ],
+      "env": {}
+    },
+    "gitea": {
+      "command": "gitea-mcp-server",
+      "args": [
+        "-t", "stdio",
+        "-host", "http://192.168.1.95:3000",
+        "-token", "8341af0733ab9ce084ea7adf38b76aa9ebc3bd67"
+      ],
+      "env": {}
+    },
+    "csharp-lsp": {
+      "command": "/usr/local/share/dotnet/dotnet",
+      "args": [
+        "run",
+        "--project", "/Users/timothy/ersatztv/.mcp/csharp-lsp-mcp/csharp-lsp-mcp/src/CSharpLspMcp",
+        "-c", "Release"
+      ],
+      "env": {
+        "PATH": "/usr/local/share/dotnet:/Users/timothy/.dotnet/tools:/usr/bin:/bin:/usr/sbin:/sbin"
+      }
+    },
+    "nuget": {
+      "command": "/usr/local/share/dotnet/dotnet",
+      "args": [
+        "dnx",
+        "NuGet.Mcp.Server",
+        "--source", "https://api.nuget.org/v3/index.json",
+        "--yes"
+      ],
+      "env": {
+        "DOTNET_ROOT": "/usr/local/share/dotnet"
+      }
+    }
+  }
+}

CLAUDE.md

@@ -0,0 +1,91 @@
+# ErsatzTV Fork
+
+Custom IPTV channel server for Jellyfin. Forked from [ErsatzTV/ErsatzTV](https://github.com/ErsatzTV/ErsatzTV) after upstream archival (Feb 2026, v26.3.0). Our fork lives on [Gitea](http://192.168.1.95:3000/timothy/ersatztv).
+
+## Architecture
+
+- **Language**: C# / .NET 10, Blazor Server UI (MudBlazor)
+- **Pattern**: CQRS via MediatR — queries/commands in `ErsatzTV.Application/`
+- **Database**: EF Core (SQLite default, MySQL optional) — context in `ErsatzTV.Infrastructure/Data/TvContext.cs`
+- **Media**: FFmpeg via CliWrap, SkiaSharp for logo generation
+- **Functional C#**: Language Ext (Option, Either monads throughout)
+
+### Project Layout
+
+| Project | Role |
+|---------|------|
+| `ErsatzTV/` | ASP.NET Core host, Blazor pages, API controllers, DI setup |
+| `ErsatzTV.Application/` | MediatR handlers (business logic) |
+| `ErsatzTV.Core/` | Domain entities, interfaces, no infrastructure deps |
+| `ErsatzTV.Infrastructure/` | EF Core repos, data access |
+| `ErsatzTV.Infrastructure.Sqlite/` | SQLite-specific implementations |
+| `ErsatzTV.FFmpeg/` | FFmpeg process wrapper |
+| `ErsatzTV.Scanner/` | Media library scanning |
+
+### Key Files
+
+- **M3U generation**: `ErsatzTV.Core/Iptv/ChannelPlaylist.cs` → `ToM3U()`
+- **XMLTV generation**: `ErsatzTV.Application/Channels/Queries/GetChannelGuideHandler.cs`
+- **IPTV controller**: `ErsatzTV/Controllers/IptvController.cs` — `/iptv/*` routes
+- **Logo generation**: `ErsatzTV.Core/Images/ChannelLogoGenerator.cs`
+- **Channel entities**: `ErsatzTV.Core/Domain/Channel.cs`
+- **DB context**: `ErsatzTV.Infrastructure/Data/TvContext.cs`
+
+## Deployment
+
+- **Docker host**: jazz (192.168.1.99), container `ersatztv`, port 8409
+- **Config volume**: `~/downloadswarm/ersatztv/` on jazz → `/config` in container
+- **SQLite DB**: `/config/ersatztv.sqlite3` (WAL mode, root-owned)
+- **Image**: `ghcr.io/ersatztv/ersatztv:latest` (to be replaced with our fork's image)
+
+## Development
+
+```bash
+# Build
+dotnet build ErsatzTV.sln
+
+# Run locally (needs FFmpeg in PATH)
+dotnet run --project ErsatzTV
+
+# Docker build
+docker build -f docker/Dockerfile -t ersatztv:dev .
+```
+
+## Conventions
+
+- Follow existing MediatR CQRS pattern for new features
+- Domain logic in `ErsatzTV.Core`, infrastructure in `ErsatzTV.Infrastructure`
+- Keep Blazor pages thin — delegate to MediatR handlers
+- Test with xUnit (existing test projects)
+- Backlog tracked via [Gitea Issues](http://192.168.1.95:3000/timothy/ersatztv/issues)
+
+## Task Completion Protocol
+
+Every task that closes a Gitea issue MUST complete ALL of these before it is considered done. Use `/done <issue>` to run through this automatically.
+
+1. **Root cause** (bug fixes / incidents only): Document WHY the problem existed, not just what was changed. If root cause is unknown, say so explicitly and open a follow-up investigation issue. Fixing symptoms without understanding causes creates recurring problems.
+2. **Comment on issues** as you work — what you found, what approach you're taking, any deviations from the suggested fix.
+3. **Push changes**: `git push` all commits before closing. Use `fixes #N` in commit messages to auto-close where appropriate.
+4. **Close comment**: Add a structured closing comment on the issue covering: what was done, root cause (if applicable), files changed, anything deferred, follow-up issues created, and which docs were updated.
+5. **Close the issue** via API or `fixes #N` commit. Leave open with a comment only if partially addressed.
+6. **Update docs**: If the change affects operational behavior, update the relevant Obsidian docs (`~/homelab-docs/`), MEMORY.md, or CLAUDE.md inline — not as a follow-up.
+7. **Reply to reviewer** (if from adversarial review): Summary of done/deferred/questions. This triggers the next review cycle.
+
+## Project Boundaries
+
+**ersatztv OWNS**: ErsatzTV fork code (C#/.NET), channel/collection/schedule management, M3U/XMLTV generation, the ErsatzTV skill in server-management.
+
+**ersatztv does NOT own**:
+- Docker compose configs → server-management (`~/downloadswarm/stacks/ersatztv/`)
+- NFS mounts, Ansible, DNS, networking → server-management
+- Content sourcing (yt-dlp downloads, Sonarr/Radarr libraries) → media-management (planned)
+- Jellyfin skill → server-management (symlinked)
+
+**For infrastructure changes** (Docker, NFS, ports, Authelia): open an issue in `timothy/server-management`.
+
+**For content/media sourcing questions** (what goes into channels, yt-dlp pipelines): open an issue in `timothy/media-management` once it exists; for now, `timothy/server-management`.
+
+**For plan/audit reviews**: open `~/adversarial-reviewer` before significant architecture changes.
+
+**Full cross-project rules**: `~/homelab-docs/Operations/Project Boundaries.md` (https://docs.tblindustries.be).
+**ErsatzTV docs**: `~/homelab-docs/Docker/ErsatzTV.md` + project-local `docs/` (fork strategy, channels, M3U/XMLTV).

Directory.Build.props

@@ -1,5 +1,7 @@
 <Project>
     <PropertyGroup>
         <InformationalVersion>develop</InformationalVersion>
+        <IncludeSourceRevisionInInformationalVersion>false</IncludeSourceRevisionInInformationalVersion>
+        <AllowMissingPrunePackageData>true</AllowMissingPrunePackageData>
     </PropertyGroup>
-</Project>
+</Project>

Directory.Build.targets

@@ -0,0 +1,15 @@
+<Project>
+    <PropertyGroup>
+        <EnableThreadingAnalyzers Condition="'$(EnableThreadingAnalyzers)' == ''">false</EnableThreadingAnalyzers>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <PackageReference
+            Include="Microsoft.VisualStudio.Threading.Analyzers"
+            Version="17.14.15"
+            Condition="'$(EnableThreadingAnalyzers)' == 'true'">
+            <PrivateAssets>all</PrivateAssets>
+            <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+        </PackageReference>
+    </ItemGroup>
+</Project>

ErsatzTV.Application/.editorconfig

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

ErsatzTV.Application/Artists/ArtistViewModel.cs

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

ErsatzTV.Application/Artists/Mapper.cs

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

ErsatzTV.Application/Artists/Queries/GetAllArtists.cs

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

ErsatzTV.Application/Artists/Queries/GetAllArtistsHandler.cs

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

ErsatzTV.Application/Artists/Queries/GetArtistById.cs

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

ErsatzTV.Application/Artists/Queries/GetArtistByIdHandler.cs

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

ErsatzTV.Application/Artworks/ArtworkContentTypeModel.cs

@@ -0,0 +1,17 @@
+using System.Net;
+using ErsatzTV.Core.Domain;
+
+namespace ErsatzTV.Application.Artworks;
+
+public record ArtworkContentTypeModel(string Path, string ContentType)
+{
+    public static readonly ArtworkContentTypeModel None = new(string.Empty, string.Empty);
+
+    public bool IsExternalUrl => Artwork.IsExternalUrl(Path);
+
+    public bool HasContentType => !string.IsNullOrWhiteSpace(ContentType);
+
+    public string UrlWithContentType => string.IsNullOrWhiteSpace(ContentType)
+        ? Path
+        : $"{Path}?contentType={WebUtility.UrlEncode(ContentType)}";
+}

ErsatzTV.Application/Artworks/Queries/GetArtwork.cs

@@ -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, cancellationToken)
+                .MapT(Project);
+
+            return artwork.ToEither(BaseError.New("Artwork not found"));
+        }
+        catch (Exception ex)
+        {
+            return BaseError.New(ex.ToString());
+        }
+    }
+
+    private static Artwork Project(Artwork artwork) =>
+        new()
+        {
+            Id = artwork.Id,
+            Path = artwork.Path,
+            ArtworkKind = artwork.ArtworkKind
+        };
+}

ErsatzTV.Application/Channels/ChannelSortViewModel.cs

@@ -0,0 +1,10 @@
+namespace ErsatzTV.Application.Channels;
+
+public class ChannelSortViewModel
+{
+    public int Id { get; set; }
+    public string Number { get; set; }
+    public string Name { get; set; }
+    public string OriginalNumber { get; set; }
+    public bool HasChanged => OriginalNumber != Number;
+}

ErsatzTV.Application/Channels/ChannelStreamingSpecsViewModel.cs

@@ -0,0 +1,11 @@
+using ErsatzTV.Core.Domain;
+
+namespace ErsatzTV.Application.Channels;
+
+public record ChannelStreamingSpecsViewModel(
+    int Height,
+    int Width,
+    int Bitrate,
+    FFmpegProfileVideoFormat VideoFormat,
+    string VideoProfile,
+    FFmpegProfileAudioFormat AudioFormat);

ErsatzTV.Application/Channels/ChannelViewModel.cs

@@ -1,14 +1,39 @@
-using ErsatzTV.Core.Domain;
+using System.Net;
+using ErsatzTV.Application.Artworks;
+using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Application.Channels
+namespace ErsatzTV.Application.Channels;
+
+public record ChannelViewModel(
+    int Id,
+    string Number,
+    string Name,
+    string Group,
+    string Categories,
+    int FFmpegProfileId,
+    double? SlugSeconds,
+    ArtworkContentTypeModel Logo,
+    ChannelStreamSelectorMode StreamSelectorMode,
+    string StreamSelector,
+    string PreferredAudioLanguageCode,
+    string PreferredAudioTitle,
+    ChannelPlayoutSource PlayoutSource,
+    ChannelPlayoutMode PlayoutMode,
+    int? MirrorSourceChannelId,
+    TimeSpan? PlayoutOffset,
+    StreamingMode StreamingMode,
+    int? WatermarkId,
+    int? FallbackFillerId,
+    int PlayoutCount,
+    string PreferredSubtitleLanguageCode,
+    ChannelSubtitleMode SubtitleMode,
+    ChannelMusicVideoCreditsMode MusicVideoCreditsMode,
+    string MusicVideoCreditsTemplate,
+    ChannelSongVideoMode SongVideoMode,
+    ChannelTranscodeMode TranscodeMode,
+    ChannelIdleBehavior IdleBehavior,
+    bool IsEnabled,
+    bool ShowInEpg)
 {
-    public record ChannelViewModel(
-        int Id,
-        string Number,
-        string Name,
-        int FFmpegProfileId,
-        string Logo,
-        string PreferredLanguageCode,
-        StreamingMode StreamingMode,
-        int? WatermarkId);
+    public string WebEncodedName => WebUtility.UrlEncode(Name);
 }

ErsatzTV.Application/Channels/Commands/CreateChannel.cs

@@ -1,17 +1,34 @@
-using ErsatzTV.Core;
+using ErsatzTV.Application.Artworks;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.Channels.Commands
-{
-    public record CreateChannel
-    (
-        string Name,
-        string Number,
-        int FFmpegProfileId,
-        string Logo,
-        string PreferredLanguageCode,
-        StreamingMode StreamingMode,
-        int? WatermarkId) : IRequest<Either<BaseError, CreateChannelResult>>;
-}
+namespace ErsatzTV.Application.Channels;
+
+public record CreateChannel(
+    string Name,
+    string Number,
+    string Group,
+    string Categories,
+    int FFmpegProfileId,
+    double? SlugSeconds,
+    ArtworkContentTypeModel Logo,
+    ChannelStreamSelectorMode StreamSelectorMode,
+    string StreamSelector,
+    string PreferredAudioLanguageCode,
+    string PreferredAudioTitle,
+    ChannelPlayoutSource PlayoutSource,
+    ChannelPlayoutMode PlayoutMode,
+    int? MirrorSourceChannelId,
+    TimeSpan? PlayoutOffset,
+    StreamingMode StreamingMode,
+    int? WatermarkId,
+    int? FallbackFillerId,
+    string PreferredSubtitleLanguageCode,
+    ChannelSubtitleMode SubtitleMode,
+    ChannelMusicVideoCreditsMode MusicVideoCreditsMode,
+    string MusicVideoCreditsTemplate,
+    ChannelSongVideoMode SongVideoMode,
+    ChannelTranscodeMode TranscodeMode,
+    ChannelIdleBehavior IdleBehavior,
+    bool IsEnabled,
+    bool ShowInEpg) : IRequest<Either<BaseError, CreateChannelResult>>;

ErsatzTV.Application/Channels/Commands/CreateChannelHandler.cs

@@ -1,135 +1,242 @@
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-using System.Linq;
+using System.Globalization;
 using System.Text.RegularExpressions;
-using System.Threading;
-using System.Threading.Tasks;
+using System.Threading.Channels;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain.Filler;
+using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
-using LanguageExt;
-using MediatR;
 using Microsoft.EntityFrameworkCore;
-using static LanguageExt.Prelude;
+using Channel = ErsatzTV.Core.Domain.Channel;
 
-namespace ErsatzTV.Application.Channels.Commands
+namespace ErsatzTV.Application.Channels;
+
+public class CreateChannelHandler(
+    ChannelWriter<IBackgroundServiceRequest> workerChannel,
+    IDbContextFactory<TvContext> dbContextFactory,
+    ISearchTargets searchTargets)
+    : IRequestHandler<CreateChannel, Either<BaseError, CreateChannelResult>>
 {
-    public class CreateChannelHandler : IRequestHandler<CreateChannel, Either<BaseError, CreateChannelResult>>
+    public async Task<Either<BaseError, CreateChannelResult>> Handle(
+        CreateChannel request,
+        CancellationToken cancellationToken)
     {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
+        Validation<BaseError, Channel> validation = await Validate(dbContext, request, cancellationToken);
+        return await validation.Apply(c => PersistChannel(dbContext, c));
+    }
 
-        public CreateChannelHandler(IDbContextFactory<TvContext> dbContextFactory) => _dbContextFactory = dbContextFactory;
+    private async Task<CreateChannelResult> PersistChannel(TvContext dbContext, Channel channel)
+    {
+        await dbContext.Channels.AddAsync(channel);
+        await dbContext.SaveChangesAsync();
+        searchTargets.SearchTargetsChanged();
+        await workerChannel.WriteAsync(new RefreshChannelList());
+        return new CreateChannelResult(channel.Id);
+    }
 
-        public async Task<Either<BaseError, CreateChannelResult>> Handle(
-            CreateChannel request,
-            CancellationToken cancellationToken)
+    private static async Task<Validation<BaseError, Channel>> Validate(TvContext dbContext, CreateChannel request, CancellationToken cancellationToken) =>
+        (ValidateName(request), await ValidateNumber(dbContext, request, cancellationToken),
+            await FFmpegProfileMustExist(dbContext, request, cancellationToken),
+            await WatermarkMustExist(dbContext, request, cancellationToken),
+            await FillerPresetMustExist(dbContext, request, cancellationToken),
+            await MirrorSourceMustBeValid(dbContext, request, cancellationToken))
+        .Apply((
+            name,
+            number,
+            ffmpegProfileId,
+            watermarkId,
+            fillerPresetId,
+            _) =>
         {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            Validation<BaseError, Channel> validation = await Validate(dbContext, request);
-            return await validation.Apply(c => PersistChannel(dbContext, c));
-        }
-
-        private static async Task<CreateChannelResult> PersistChannel(TvContext dbContext, Channel channel)
-        {
-            await dbContext.Channels.AddAsync(channel);
-            await dbContext.SaveChangesAsync();
-            return new CreateChannelResult(channel.Id);
-        }
-
-        private static async Task<Validation<BaseError, Channel>> Validate(TvContext dbContext, CreateChannel request) =>
-            (ValidateName(request), await ValidateNumber(dbContext, request),
-                await FFmpegProfileMustExist(dbContext, request),
-                ValidatePreferredLanguage(request),
-                await WatermarkMustExist(dbContext, request))
-            .Apply(
-                (name, number, ffmpegProfileId, preferredLanguageCode, watermarkId) =>
-                {
-                    var artwork = new List<Artwork>();
-                    if (!string.IsNullOrWhiteSpace(request.Logo))
-                    {
-                        artwork.Add(
-                            new Artwork
-                            {
-                                Path = request.Logo,
-                                ArtworkKind = ArtworkKind.Logo,
-                                DateAdded = DateTime.UtcNow,
-                                DateUpdated = DateTime.UtcNow
-                            });
-                    }
-
-                    var channel = new Channel(Guid.NewGuid())
-                    {
-                        Name = name,
-                        Number = number,
-                        FFmpegProfileId = ffmpegProfileId,
-                        StreamingMode = request.StreamingMode,
-                        Artwork = artwork,
-                        PreferredLanguageCode = preferredLanguageCode
-                    };
-
-                    foreach (int id in watermarkId)
-                    {
-                        channel.WatermarkId = id;
-                    }
-
-                    return channel;
-                });
-
-        private static Validation<BaseError, string> ValidateName(CreateChannel createChannel) =>
-            createChannel.NotEmpty(c => c.Name)
-                .Bind(_ => createChannel.NotLongerThan(50)(c => c.Name));
-
-        private static Validation<BaseError, string> ValidatePreferredLanguage(CreateChannel createChannel) =>
-            Optional(createChannel.PreferredLanguageCode ?? string.Empty)
-                .Filter(
-                    lc => string.IsNullOrWhiteSpace(lc) || CultureInfo.GetCultures(CultureTypes.NeutralCultures).Any(
-                        ci => string.Equals(ci.ThreeLetterISOLanguageName, lc, StringComparison.OrdinalIgnoreCase)))
-                .ToValidation<BaseError>("Preferred language code is invalid");
-
-        private static async Task<Validation<BaseError, string>> ValidateNumber(TvContext dbContext, CreateChannel createChannel)
-        {
-            Option<Channel> maybeExistingChannel = await dbContext.Channels
-                .SelectOneAsync(c => c.Number, c => c.Number == createChannel.Number);
-            return maybeExistingChannel.Match<Validation<BaseError, string>>(
-                _ => BaseError.New("Channel number must be unique"),
-                () =>
-                {
-                    if (Regex.IsMatch(createChannel.Number, Channel.NumberValidator))
-                    {
-                        return createChannel.Number;
-                    }
-
-                    return BaseError.New("Invalid channel number; one decimal is allowed for subchannels");
-                });
-        }
-
-        private static Task<Validation<BaseError, int>> FFmpegProfileMustExist(
-            TvContext dbContext,
-            CreateChannel createChannel) =>
-            dbContext.FFmpegProfiles
-                .CountAsync(p => p.Id == createChannel.FFmpegProfileId)
-                .Map(Optional)
-                .Filter(c => c > 0)
-                .MapT(_ => createChannel.FFmpegProfileId)
-                .Map(o => o.ToValidation<BaseError>($"FFmpegProfile {createChannel.FFmpegProfileId} does not exist."));
-
-        private static async Task<Validation<BaseError, Option<int>>> WatermarkMustExist(
-            TvContext dbContext,
-            CreateChannel createChannel)
-        {
-            if (createChannel.WatermarkId is null)
+            var artwork = new List<Artwork>();
+            if (!string.IsNullOrWhiteSpace(request.Logo?.Path))
             {
-                return Option<int>.None;
+                string logo = request.Logo.Path;
+                if (logo.StartsWith("iptv/logos/", StringComparison.Ordinal))
+                {
+                    logo = logo.Replace("iptv/logos/", string.Empty);
+                }
+
+                artwork.Add(
+                    new Artwork
+                    {
+                        Path = logo,
+                        ArtworkKind = ArtworkKind.Logo,
+                        OriginalContentType = !string.IsNullOrEmpty(request.Logo.ContentType)
+                            ? request.Logo.ContentType
+                            : null,
+                        DateAdded = DateTime.UtcNow,
+                        DateUpdated = DateTime.UtcNow
+                    });
             }
 
-            return await dbContext.ChannelWatermarks
-                .CountAsync(w => w.Id == createChannel.WatermarkId)
-                .Map(Optional)
-                .Filter(c => c > 0)
-                .MapT(_ => Optional(createChannel.WatermarkId))
-                .Map(o => o.ToValidation<BaseError>($"Watermark {createChannel.WatermarkId} does not exist."));
+            var channel = new Channel(Guid.NewGuid())
+            {
+                Name = name,
+                Number = number,
+                SortNumber = double.Parse(number, CultureInfo.InvariantCulture),
+                Group = request.Group,
+                Categories = request.Categories,
+                FFmpegProfileId = ffmpegProfileId,
+                SlugSeconds = request.SlugSeconds,
+                PlayoutSource = request.PlayoutSource,
+                PlayoutMode = request.PlayoutMode,
+                MirrorSourceChannelId = request.MirrorSourceChannelId,
+                PlayoutOffset = request.PlayoutOffset,
+                StreamingMode = request.StreamingMode,
+                Artwork = artwork,
+                StreamSelectorMode = request.StreamSelectorMode,
+                StreamSelector = request.StreamSelector,
+                PreferredAudioLanguageCode = request.PreferredAudioLanguageCode,
+                PreferredAudioTitle = request.PreferredAudioTitle,
+                PreferredSubtitleLanguageCode = request.PreferredSubtitleLanguageCode,
+                SubtitleMode = request.SubtitleMode,
+                MusicVideoCreditsMode = request.MusicVideoCreditsMode,
+                MusicVideoCreditsTemplate = request.MusicVideoCreditsTemplate,
+                SongVideoMode = request.SongVideoMode,
+                TranscodeMode = request.TranscodeMode,
+                IdleBehavior = request.IdleBehavior,
+                IsEnabled = request.IsEnabled,
+                ShowInEpg = request.IsEnabled && request.ShowInEpg
+            };
+
+            if (channel.PlayoutSource is ChannelPlayoutSource.Mirror)
+            {
+                channel.PlayoutMode = ChannelPlayoutMode.Continuous;
+            }
+            else
+            {
+                channel.MirrorSourceChannelId = null;
+                channel.PlayoutOffset = null;
+            }
+
+            foreach (int id in watermarkId)
+            {
+                channel.WatermarkId = id;
+            }
+
+            foreach (int id in fillerPresetId)
+            {
+                channel.FallbackFillerId = id;
+            }
+
+            return channel;
+        });
+
+    private static Validation<BaseError, string> ValidateName(CreateChannel createChannel) =>
+        createChannel.NotEmpty(c => c.Name)
+            .Bind(_ => createChannel.NotLongerThan(50)(c => c.Name));
+
+    private static async Task<Validation<BaseError, string>> ValidateNumber(
+        TvContext dbContext,
+        CreateChannel createChannel,
+        CancellationToken cancellationToken)
+    {
+        Option<Channel> maybeExistingChannel = await dbContext.Channels
+            .SelectOneAsync(c => c.Number, c => c.Number == createChannel.Number, cancellationToken);
+        return maybeExistingChannel.Match<Validation<BaseError, string>>(
+            _ => BaseError.New("Channel number must be unique"),
+            () =>
+            {
+                if (Regex.IsMatch(createChannel.Number, Channel.NumberValidator))
+                {
+                    return createChannel.Number;
+                }
+
+                return BaseError.New("Invalid channel number; two decimals are allowed for subchannels");
+            });
+    }
+
+    private static Task<Validation<BaseError, int>> FFmpegProfileMustExist(
+        TvContext dbContext,
+        CreateChannel createChannel,
+        CancellationToken cancellationToken) =>
+        dbContext.FFmpegProfiles
+            .CountAsync(p => p.Id == createChannel.FFmpegProfileId, cancellationToken)
+            .Map(Optional)
+            .Filter(c => c > 0)
+            .MapT(_ => createChannel.FFmpegProfileId)
+            .Map(o => o.ToValidation<BaseError>($"FFmpegProfile {createChannel.FFmpegProfileId} does not exist."));
+
+    private static async Task<Validation<BaseError, Option<int>>> WatermarkMustExist(
+        TvContext dbContext,
+        CreateChannel createChannel,
+        CancellationToken cancellationToken)
+    {
+        if (createChannel.WatermarkId is null)
+        {
+            return Option<int>.None;
         }
+
+        return await dbContext.ChannelWatermarks
+            .CountAsync(w => w.Id == createChannel.WatermarkId, cancellationToken)
+            .Map(Optional)
+            .Filter(c => c > 0)
+            .MapT(_ => Optional(createChannel.WatermarkId))
+            .Map(o => o.ToValidation<BaseError>($"Watermark {createChannel.WatermarkId} does not exist."));
+    }
+
+    private static async Task<Validation<BaseError, Option<int>>> FillerPresetMustExist(
+        TvContext dbContext,
+        CreateChannel createChannel,
+        CancellationToken cancellationToken)
+    {
+        if (createChannel.FallbackFillerId is null)
+        {
+            return Option<int>.None;
+        }
+
+        return await dbContext.FillerPresets
+            .Filter(fp => fp.FillerKind == FillerKind.Fallback)
+            .CountAsync(w => w.Id == createChannel.FallbackFillerId, cancellationToken)
+            .Map(Optional)
+            .Filter(c => c > 0)
+            .MapT(_ => Optional(createChannel.FallbackFillerId))
+            .Map(o => o.ToValidation<BaseError>(
+                $"Fallback filler {createChannel.FallbackFillerId} does not exist."));
+    }
+
+    private static async Task<Validation<BaseError, Unit>> MirrorSourceMustBeValid(
+        TvContext dbContext,
+        CreateChannel createChannel,
+        CancellationToken cancellationToken)
+    {
+        if (createChannel.PlayoutSource is not ChannelPlayoutSource.Mirror)
+        {
+            return Unit.Default;
+        }
+
+        Option<Channel> maybeMirrorSource = await dbContext.Channels
+            .AsNoTracking()
+            .SelectOneAsync(
+                c => c.Id == createChannel.MirrorSourceChannelId,
+                c => c.Id == createChannel.MirrorSourceChannelId,
+                cancellationToken);
+
+        if (maybeMirrorSource.IsNone)
+        {
+            return BaseError.New("Mirror source channel does not exist.");
+        }
+
+        foreach (var mirrorSource in maybeMirrorSource)
+        {
+            if (mirrorSource.PlayoutSource is not ChannelPlayoutSource.Generated)
+            {
+                return BaseError.New(
+                    $"Mirror source channel {mirrorSource.Name} must use generated playout source");
+            }
+        }
+
+        foreach (TimeSpan playoutOffset in Optional(createChannel.PlayoutOffset))
+        {
+            if (playoutOffset < TimeSpan.FromHours(-12) || playoutOffset > TimeSpan.FromHours(12))
+            {
+                return BaseError.New("Playout offset must not be greater than 12 hours");
+            }
+        }
+
+        return Unit.Default;
     }
 }

ErsatzTV.Application/Channels/Commands/CreateChannelResult.cs

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

ErsatzTV.Application/Channels/Commands/DeleteChannel.cs

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

ErsatzTV.Application/Channels/Commands/DeleteChannelHandler.cs

@@ -1,28 +1,67 @@
-using System.Threading;
-using System.Threading.Tasks;
+using System.IO.Abstractions;
+using System.Threading.Channels;
 using ErsatzTV.Core;
-using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
-using MediatR;
+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.Commands
+namespace ErsatzTV.Application.Channels;
+
+public class DeleteChannelHandler : IRequestHandler<DeleteChannel, Either<BaseError, Unit>>
 {
-    public class DeleteChannelHandler : IRequestHandler<DeleteChannel, Either<BaseError, Task>>
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+    private readonly IFileSystem _fileSystem;
+    private readonly ISearchTargets _searchTargets;
+    private readonly ChannelWriter<IBackgroundServiceRequest> _workerChannel;
+
+    public DeleteChannelHandler(
+        ChannelWriter<IBackgroundServiceRequest> workerChannel,
+        IDbContextFactory<TvContext> dbContextFactory,
+        IFileSystem fileSystem,
+        ISearchTargets searchTargets)
     {
-        private readonly IChannelRepository _channelRepository;
+        _workerChannel = workerChannel;
+        _dbContextFactory = dbContextFactory;
+        _fileSystem = fileSystem;
+        _searchTargets = searchTargets;
+    }
 
-        public DeleteChannelHandler(IChannelRepository channelRepository) => _channelRepository = channelRepository;
+    public async Task<Either<BaseError, Unit>> Handle(DeleteChannel request, CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+        Validation<BaseError, Channel> validation = await ChannelMustExist(dbContext, request, cancellationToken);
+        return await validation.Apply(c => DoDeletion(dbContext, c, cancellationToken));
+    }
 
-        public async Task<Either<BaseError, Task>> Handle(DeleteChannel request, CancellationToken cancellationToken) =>
-            (await ChannelMustExist(request))
-            .Map(DoDeletion)
-            .ToEither<Task>();
+    private async Task<Unit> DoDeletion(TvContext dbContext, Channel channel, CancellationToken cancellationToken)
+    {
+        dbContext.Channels.Remove(channel);
+        await dbContext.SaveChangesAsync(cancellationToken);
 
-        private Task DoDeletion(int channelId) => _channelRepository.Delete(channelId);
+        _searchTargets.SearchTargetsChanged();
 
-        private async Task<Validation<BaseError, int>> ChannelMustExist(DeleteChannel deleteChannel) =>
-            (await _channelRepository.Get(deleteChannel.ChannelId))
-            .ToValidation<BaseError>($"Channel {deleteChannel.ChannelId} does not exist.")
-            .Map(c => c.Id);
+        // delete channel data from channel guide cache
+        string cacheFile = Path.Combine(FileSystemLayout.ChannelGuideCacheFolder, $"{channel.Number}.xml");
+        if (_fileSystem.File.Exists(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,
+        CancellationToken cancellationToken)
+    {
+        Option<Channel> maybeChannel = await dbContext.Channels
+            .SelectOneAsync(c => c.Id, c => c.Id == deleteChannel.ChannelId, cancellationToken);
+        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,151 @@
+using System.Data.Common;
+using System.IO.Abstractions;
+using System.Net;
+using System.Xml;
+using Dapper;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Metadata;
+using ErsatzTV.Core.Iptv;
+using ErsatzTV.Infrastructure.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using Microsoft.IO;
+using Scriban;
+using Scriban.Runtime;
+using WebMarkupMin.Core;
+
+namespace ErsatzTV.Application.Channels;
+
+public class RefreshChannelListHandler : IRequestHandler<RefreshChannelList>
+{
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+    private readonly IFileSystem _fileSystem;
+    private readonly ILocalFileSystem _localFileSystem;
+    private readonly ILogger<RefreshChannelListHandler> _logger;
+    private readonly RecyclableMemoryStreamManager _recyclableMemoryStreamManager;
+
+    public RefreshChannelListHandler(
+        RecyclableMemoryStreamManager recyclableMemoryStreamManager,
+        IDbContextFactory<TvContext> dbContextFactory,
+        IFileSystem fileSystem,
+        ILocalFileSystem localFileSystem,
+        ILogger<RefreshChannelListHandler> logger)
+    {
+        _recyclableMemoryStreamManager = recyclableMemoryStreamManager;
+        _dbContextFactory = dbContextFactory;
+        _fileSystem = fileSystem;
+        _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 (!_fileSystem.File.Exists(templateFileName))
+        {
+            templateFileName = Path.Combine(FileSystemLayout.ChannelGuideTemplatesFolder, "_channel.sbntxt");
+        }
+
+        // fail if file doesn't exist
+        if (!_fileSystem.File.Exists(templateFileName))
+        {
+            _logger.LogError(
+                "Unable to generate channel list without template file {File}; please restart ErsatzTV",
+                templateFileName);
+
+            return;
+        }
+
+        var minifier = new XmlMinifier(
+            new XmlMinificationSettings
+            {
+                MinifyWhitespace = true,
+                RemoveXmlComments = true,
+                CollapseTagsWithoutContent = true
+            });
+
+        string text = await File.ReadAllTextAsync(templateFileName, cancellationToken);
+        var template = Template.Parse(text, templateFileName);
+        var templateContext = new XmlTemplateContext();
+
+        await using RecyclableMemoryStream ms = _recyclableMemoryStreamManager.GetStream();
+        await using var xml = XmlWriter.Create(
+            ms,
+            new XmlWriterSettings { Async = true, ConformanceLevel = ConformanceLevel.Fragment });
+
+        await foreach (ChannelResult channel in GetChannels(dbContext).WithCancellation(cancellationToken))
+        {
+            bool hasLogo = !string.IsNullOrWhiteSpace(channel.ArtworkPath);
+            bool hasExternalLogo = hasLogo && Artwork.IsExternalUrl(channel.ArtworkPath);
+
+            var data = new
+            {
+                ChannelId = ChannelIdentifier.FromNumber(channel.Number),
+                ChannelIdLegacy = ChannelIdentifier.LegacyFromNumber(channel.Number),
+                ChannelNumber = channel.Number,
+                ChannelName = channel.Name,
+                ChannelCategories = GetCategories(channel.Categories),
+                ChannelHasExternalArtwork = hasExternalLogo,
+                ChannelHasArtwork = hasLogo,
+                ChannelArtworkPath = channel.ArtworkPath,
+                ChannelNameEncoded = WebUtility.UrlEncode(channel.Name)
+            };
+
+            var scriptObject = new ScriptObject();
+            scriptObject.Import(data);
+            templateContext.PushGlobal(scriptObject);
+
+            string result = await template.RenderAsync(templateContext);
+
+            MarkupMinificationResult minified = minifier.Minify(result);
+            await xml.WriteRawAsync(minified.MinifiedContent);
+        }
+
+        await xml.FlushAsync();
+
+        string tempFile = Path.GetTempFileName();
+        await File.WriteAllBytesAsync(tempFile, ms.ToArray(), cancellationToken);
+
+        string targetFile = Path.Combine(FileSystemLayout.ChannelGuideCacheFolder, "channels.xml");
+        File.Move(tempFile, targetFile, true);
+    }
+
+    private static async IAsyncEnumerable<ChannelResult> GetChannels(TvContext dbContext)
+    {
+        const string QUERY = @"select C.Number, C.Name, C.Categories, A.Path as ArtworkPath
+                               from Channel C
+                               left outer join Artwork A on C.Id = A.ChannelId and A.ArtworkKind = 2
+                               where (C.Id in (select ChannelId from Playout) or C.MirrorSourceChannelId in (select ChannelId from Playout)) and C.IsEnabled = 1 and C.ShowInEPG = 1
+                               order by CAST(C.Number as double)";
+        // TODO: this needs to be fixed for sqlite/mariadb
+
+        await using var reader = (DbDataReader)await dbContext.Connection.ExecuteReaderAsync(QUERY);
+        Func<DbDataReader, ChannelResult> rowParser = reader.GetRowParser<ChannelResult>();
+
+        while (await reader.ReadAsync())
+        {
+            yield return rowParser(reader);
+        }
+
+        while (await reader.NextResultAsync())
+        {
+        }
+    }
+
+    private static List<string> GetCategories(string categories) =>
+        (categories ?? string.Empty).Split(',')
+        .Map(s => s.Trim())
+        .Filter(s => !string.IsNullOrWhiteSpace(s))
+        .Distinct()
+        .ToList();
+
+    // ReSharper disable once ClassNeverInstantiated.Local
+    private sealed record ChannelResult(string Number, string Name, string Categories, string ArtworkPath);
+}

ErsatzTV.Application/Channels/Commands/UpdateChannel.cs

@@ -1,18 +1,35 @@
-using ErsatzTV.Core;
+using ErsatzTV.Application.Artworks;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.Channels.Commands
-{
-    public record UpdateChannel
-    (
-        int ChannelId,
-        string Name,
-        string Number,
-        int FFmpegProfileId,
-        string Logo,
-        string PreferredLanguageCode,
-        StreamingMode StreamingMode,
-        int? WatermarkId) : IRequest<Either<BaseError, ChannelViewModel>>;
-}
+namespace ErsatzTV.Application.Channels;
+
+public record UpdateChannel(
+    int ChannelId,
+    string Name,
+    string Number,
+    string Group,
+    string Categories,
+    int FFmpegProfileId,
+    double? SlugSeconds,
+    ArtworkContentTypeModel Logo,
+    ChannelStreamSelectorMode StreamSelectorMode,
+    string StreamSelector,
+    string PreferredAudioLanguageCode,
+    string PreferredAudioTitle,
+    ChannelPlayoutSource PlayoutSource,
+    ChannelPlayoutMode PlayoutMode,
+    int? MirrorSourceChannelId,
+    TimeSpan? PlayoutOffset,
+    StreamingMode StreamingMode,
+    int? WatermarkId,
+    int? FallbackFillerId,
+    string PreferredSubtitleLanguageCode,
+    ChannelSubtitleMode SubtitleMode,
+    ChannelMusicVideoCreditsMode MusicVideoCreditsMode,
+    string MusicVideoCreditsTemplate,
+    ChannelSongVideoMode SongVideoMode,
+    ChannelTranscodeMode TranscodeMode,
+    ChannelIdleBehavior IdleBehavior,
+    bool IsEnabled,
+    bool ShowInEpg) : IRequest<Either<BaseError, ChannelViewModel>>;

ErsatzTV.Application/Channels/Commands/UpdateChannelHandler.cs

@@ -1,121 +1,250 @@
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-using System.Linq;
+using System.Globalization;
 using System.Text.RegularExpressions;
-using System.Threading;
-using System.Threading.Tasks;
+using System.Threading.Channels;
+using ErsatzTV.Application.Subtitles;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
-using LanguageExt;
-using MediatR;
 using Microsoft.EntityFrameworkCore;
 using static ErsatzTV.Application.Channels.Mapper;
-using static LanguageExt.Prelude;
+using Channel = ErsatzTV.Core.Domain.Channel;
 
-namespace ErsatzTV.Application.Channels.Commands
+namespace ErsatzTV.Application.Channels;
+
+public class UpdateChannelHandler(
+    ChannelWriter<IBackgroundServiceRequest> workerChannel,
+    IDbContextFactory<TvContext> dbContextFactory,
+    ISearchTargets searchTargets)
+    : IRequestHandler<UpdateChannel, Either<BaseError, ChannelViewModel>>
 {
-    public class UpdateChannelHandler : IRequestHandler<UpdateChannel, Either<BaseError, ChannelViewModel>>
+    public async Task<Either<BaseError, ChannelViewModel>> Handle(
+        UpdateChannel request,
+        CancellationToken cancellationToken)
     {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
+        Validation<BaseError, Channel> validation = await Validate(dbContext, request, cancellationToken);
+        return await validation.Apply(c => ApplyUpdateRequest(dbContext, c, request, cancellationToken));
+    }
 
-        public UpdateChannelHandler(IDbContextFactory<TvContext> dbContextFactory) =>
-            _dbContextFactory = dbContextFactory;
-
-        public async Task<Either<BaseError, ChannelViewModel>> Handle(
-            UpdateChannel request,
-            CancellationToken cancellationToken)
+    private async Task<ChannelViewModel> ApplyUpdateRequest(
+        TvContext dbContext,
+        Channel c,
+        UpdateChannel update,
+        CancellationToken cancellationToken)
+    {
+        // don't save mirror when playout exists
+        if (c.Playouts.Count > 0)
         {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            Validation<BaseError, Channel> validation = await Validate(dbContext, request);
-            return await validation.Apply(c => ApplyUpdateRequest(dbContext, c, request));
+            update = update with
+            {
+                PlayoutSource = ChannelPlayoutSource.Generated,
+                MirrorSourceChannelId = null
+            };
         }
 
-        private async Task<ChannelViewModel> ApplyUpdateRequest(TvContext dbContext, Channel c, UpdateChannel update)
+        bool hasEpgChange = c.PlayoutSource != update.PlayoutSource || c.ShowInEpg != update.ShowInEpg;
+
+        c.Name = update.Name;
+        c.Number = update.Number;
+        c.SortNumber = double.Parse(update.Number, CultureInfo.InvariantCulture);
+        c.Group = update.Group;
+        c.Categories = update.Categories;
+        c.FFmpegProfileId = update.FFmpegProfileId;
+        c.SlugSeconds = update.SlugSeconds;
+        c.StreamSelectorMode = update.StreamSelectorMode;
+        c.StreamSelector = update.StreamSelector;
+        c.PreferredAudioLanguageCode = update.PreferredAudioLanguageCode;
+        c.PreferredAudioTitle = update.PreferredAudioTitle;
+        c.PreferredSubtitleLanguageCode = update.PreferredSubtitleLanguageCode;
+        c.SubtitleMode = update.SubtitleMode;
+        c.MusicVideoCreditsMode = update.MusicVideoCreditsMode;
+        c.MusicVideoCreditsTemplate = update.MusicVideoCreditsTemplate;
+        c.SongVideoMode = update.SongVideoMode;
+        c.TranscodeMode = update.TranscodeMode;
+        c.IdleBehavior = update.IdleBehavior;
+        c.IsEnabled = update.IsEnabled;
+        c.ShowInEpg = update.IsEnabled && update.ShowInEpg;
+        c.Artwork ??= [];
+
+        if (!string.IsNullOrWhiteSpace(update.Logo?.Path))
         {
-            c.Name = update.Name;
-            c.Number = update.Number;
-            c.FFmpegProfileId = update.FFmpegProfileId;
-            c.PreferredLanguageCode = update.PreferredLanguageCode;
-            c.Artwork ??= new List<Artwork>();
-
-            if (!string.IsNullOrWhiteSpace(update.Logo))
+            string logo = update.Logo.Path;
+            if (logo.StartsWith("iptv/logos/", StringComparison.Ordinal))
             {
-                Option<Artwork> maybeLogo =
-                    Optional(c.Artwork).Flatten().FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Logo);
-
-                maybeLogo.Match(
-                    artwork =>
-                    {
-                        artwork.Path = update.Logo;
-                        artwork.DateUpdated = DateTime.UtcNow;
-                    },
-                    () =>
-                    {
-                        var artwork = new Artwork
-                        {
-                            Path = update.Logo,
-                            DateAdded = DateTime.UtcNow,
-                            DateUpdated = DateTime.UtcNow,
-                            ArtworkKind = ArtworkKind.Logo
-                        };
-                        c.Artwork.Add(artwork);
-                    });
+                logo = logo.Replace("iptv/logos/", string.Empty);
             }
-            
-            c.StreamingMode = update.StreamingMode;
-            c.WatermarkId = update.WatermarkId;
-            await dbContext.SaveChangesAsync();
-            return ProjectToViewModel(c);
-        }
 
-        private async Task<Validation<BaseError, Channel>> Validate(TvContext dbContext, UpdateChannel request) =>
-            (await ChannelMustExist(dbContext, request), ValidateName(request),
-                await ValidateNumber(dbContext, request),
-                ValidatePreferredLanguage(request))
-            .Apply((channelToUpdate, _, _, _) => channelToUpdate);
-
-        private static Task<Validation<BaseError, Channel>> ChannelMustExist(
-            TvContext dbContext,
-            UpdateChannel updateChannel) =>
-            dbContext.Channels
-                .Include(c => c.Artwork)
-                .Include(c => c.Watermark)
-                .SelectOneAsync(c => c.Id, c => c.Id == updateChannel.ChannelId)
-                .Map(o => o.ToValidation<BaseError>("Channel does not exist."));
-
-        private static Validation<BaseError, string> ValidateName(UpdateChannel updateChannel) =>
-            updateChannel.NotEmpty(c => c.Name)
-                .Bind(_ => updateChannel.NotLongerThan(50)(c => c.Name));
-
-        private static async Task<Validation<BaseError, string>> ValidateNumber(
-            TvContext dbContext,
-            UpdateChannel updateChannel)
-        {
-            int matchId = await dbContext.Channels
-                .SelectOneAsync(c => c.Number, c => c.Number == updateChannel.Number)
-                .Match(c => c.Id, () => updateChannel.ChannelId);
-
-            if (matchId == updateChannel.ChannelId)
+            Option<Artwork> maybeLogo = c.Artwork.Where(a => a.ArtworkKind == ArtworkKind.Logo).HeadOrNone();
+            foreach (Artwork artwork in maybeLogo)
             {
-                if (Regex.IsMatch(updateChannel.Number, Channel.NumberValidator))
+                artwork.Path = logo;
+                artwork.OriginalContentType = !string.IsNullOrEmpty(update.Logo.ContentType)
+                    ? update.Logo.ContentType
+                    : null;
+                artwork.DateUpdated = DateTime.UtcNow;
+            }
+
+            if (maybeLogo.IsNone)
+            {
+                var artwork = new Artwork
                 {
-                    return updateChannel.Number;
-                }
-
-                return BaseError.New("Invalid channel number; one decimal is allowed for subchannels");
+                    Path = logo,
+                    OriginalContentType = !string.IsNullOrEmpty(update.Logo.ContentType)
+                        ? update.Logo.ContentType
+                        : null,
+                    DateAdded = DateTime.UtcNow,
+                    DateUpdated = DateTime.UtcNow,
+                    ArtworkKind = ArtworkKind.Logo
+                };
+                c.Artwork.Add(artwork);
             }
+        }
+        else
+        {
+            await dbContext.Entry(c)
+                .Collection(channel => channel.Artwork)
+                .LoadAsync(cancellationToken);
 
-            return BaseError.New("Channel number must be unique");
+            foreach (Artwork artwork in c.Artwork.Where(x => x.ArtworkKind is ArtworkKind.Logo).ToList())
+            {
+                c.Artwork.Remove(artwork);
+                dbContext.Artwork.Remove(artwork);
+            }
         }
 
-        private static Validation<BaseError, string> ValidatePreferredLanguage(UpdateChannel updateChannel) =>
-            Optional(updateChannel.PreferredLanguageCode ?? string.Empty)
-                .Filter(
-                    lc => string.IsNullOrWhiteSpace(lc) || CultureInfo.GetCultures(CultureTypes.NeutralCultures).Any(
-                        ci => string.Equals(ci.ThreeLetterISOLanguageName, lc, StringComparison.OrdinalIgnoreCase)))
-                .ToValidation<BaseError>("Preferred language code is invalid");
+        c.PlayoutSource = update.PlayoutSource;
+        c.PlayoutMode = update.PlayoutMode;
+
+        if (c.PlayoutSource is ChannelPlayoutSource.Mirror)
+        {
+            c.PlayoutMode = ChannelPlayoutMode.Continuous;
+            hasEpgChange |= c.MirrorSourceChannelId != update.MirrorSourceChannelId;
+            hasEpgChange |= c.PlayoutOffset != update.PlayoutOffset;
+        }
+        else
+        {
+            c.MirrorSourceChannelId = null;
+            c.PlayoutOffset = null;
+        }
+
+        c.MirrorSourceChannelId = update.MirrorSourceChannelId;
+        c.PlayoutOffset = update.PlayoutOffset;
+        c.StreamingMode = update.StreamingMode;
+        c.WatermarkId = update.WatermarkId;
+        c.FallbackFillerId = update.FallbackFillerId;
+
+        await dbContext.SaveChangesAsync(cancellationToken);
+
+        searchTargets.SearchTargetsChanged();
+
+        if (c.SubtitleMode != ChannelSubtitleMode.None)
+        {
+            Option<Playout> maybePlayout = await dbContext.Playouts
+                .SelectOneAsync(p => p.ChannelId, p => p.ChannelId == c.Id, cancellationToken);
+
+            foreach (Playout playout in maybePlayout)
+            {
+                await workerChannel.WriteAsync(new ExtractEmbeddedSubtitles(playout.Id), cancellationToken);
+            }
+        }
+
+        await workerChannel.WriteAsync(new RefreshChannelList(), cancellationToken);
+        if (hasEpgChange)
+        {
+            await workerChannel.WriteAsync(new RefreshChannelData(c.Number), cancellationToken);
+        }
+
+        return ProjectToViewModel(c, c.Playouts?.Count ?? 0);
+    }
+
+    private static async Task<Validation<BaseError, Channel>> Validate(
+        TvContext dbContext,
+        UpdateChannel request,
+        CancellationToken cancellationToken) =>
+        (await ChannelMustExist(dbContext, request, cancellationToken),
+            ValidateName(request),
+            await ValidateNumber(dbContext, request, cancellationToken),
+            await MirrorSourceMustBeValid(dbContext, request, cancellationToken))
+        .Apply((channelToUpdate, _, _, _) => channelToUpdate);
+
+    private static Task<Validation<BaseError, Channel>> ChannelMustExist(
+        TvContext dbContext,
+        UpdateChannel updateChannel,
+        CancellationToken cancellationToken) =>
+        dbContext.Channels
+            .Include(c => c.Artwork)
+            .Include(c => c.Watermark)
+            .Include(c => c.Playouts)
+            .SelectOneAsync(c => c.Id, c => c.Id == updateChannel.ChannelId, cancellationToken)
+            .Map(o => o.ToValidation<BaseError>("Channel does not exist."));
+
+    private static async Task<Validation<BaseError, Unit>> MirrorSourceMustBeValid(
+        TvContext dbContext,
+        UpdateChannel request,
+        CancellationToken cancellationToken)
+    {
+        if (request.PlayoutSource is not ChannelPlayoutSource.Mirror)
+        {
+            return Unit.Default;
+        }
+
+        Option<Channel> maybeMirrorSource = await dbContext.Channels
+            .AsNoTracking()
+            .SelectOneAsync(
+                c => c.Id == request.MirrorSourceChannelId,
+                c => c.Id == request.MirrorSourceChannelId,
+                cancellationToken);
+
+        if (maybeMirrorSource.IsNone)
+        {
+            return BaseError.New("Mirror source channel does not exist.");
+        }
+
+        foreach (var mirrorSource in maybeMirrorSource)
+        {
+            if (mirrorSource.PlayoutSource is not ChannelPlayoutSource.Generated)
+            {
+                return BaseError.New(
+                    $"Mirror source channel {mirrorSource.Name} must use generated playout source");
+            }
+        }
+
+        foreach (TimeSpan playoutOffset in Optional(request.PlayoutOffset))
+        {
+            if (playoutOffset < TimeSpan.FromHours(-12) || playoutOffset > TimeSpan.FromHours(12))
+            {
+                return BaseError.New("Playout offset must not be greater than 12 hours");
+            }
+        }
+
+        return Unit.Default;
+    }
+
+    private static Validation<BaseError, string> ValidateName(UpdateChannel updateChannel) =>
+        updateChannel.NotEmpty(c => c.Name)
+            .Bind(_ => updateChannel.NotLongerThan(50)(c => c.Name));
+
+    private static async Task<Validation<BaseError, string>> ValidateNumber(
+        TvContext dbContext,
+        UpdateChannel updateChannel,
+        CancellationToken cancellationToken)
+    {
+        int matchId = await dbContext.Channels
+            .SelectOneAsync(c => c.Number, c => c.Number == updateChannel.Number, cancellationToken)
+            .Match(c => c.Id, () => updateChannel.ChannelId);
+
+        if (matchId == updateChannel.ChannelId)
+        {
+            if (Regex.IsMatch(updateChannel.Number, Channel.NumberValidator))
+            {
+                return updateChannel.Number;
+            }
+
+            return BaseError.New("Invalid channel number; two decimals are allowed for subchannels");
+        }
+
+        return BaseError.New("Channel number must be unique");
     }
 }

ErsatzTV.Application/Channels/Commands/UpdateChannelNumbers.cs

@@ -0,0 +1,5 @@
+using ErsatzTV.Core;
+
+namespace ErsatzTV.Application.Channels;
+
+public record UpdateChannelNumbers(List<ChannelSortViewModel> Channels) : IRequest<Option<BaseError>>;

ErsatzTV.Application/Channels/Commands/UpdateChannelNumbersHandler.cs

@@ -0,0 +1,72 @@
+using System.Globalization;
+using System.Threading.Channels;
+using ErsatzTV.Core;
+using ErsatzTV.Infrastructure.Data;
+using Microsoft.EntityFrameworkCore;
+using Channel = ErsatzTV.Core.Domain.Channel;
+
+namespace ErsatzTV.Application.Channels;
+
+public class UpdateChannelNumbersHandler(
+    IDbContextFactory<TvContext> dbContextFactory,
+    ChannelWriter<IBackgroundServiceRequest> workerChannel)
+    : IRequestHandler<UpdateChannelNumbers, Option<BaseError>>
+{
+    public async Task<Option<BaseError>> Handle(UpdateChannelNumbers request, CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
+        await using var transaction = await dbContext.Database.BeginTransactionAsync(cancellationToken);
+
+        try
+        {
+            var numberUpdates = request.Channels.ToDictionary(c => c.Id, c => c.Number);
+            var channelIds = numberUpdates.Keys;
+
+            List<Channel> channelsToUpdate = await dbContext.Channels
+                .Where(c => channelIds.Contains(c.Id))
+                .ToListAsync(cancellationToken);
+
+            // give every channel a non-conflicting number
+            foreach (var channel in channelsToUpdate)
+            {
+                channel.Number = $"-{channel.Id}";
+            }
+
+            // save those changes
+            await dbContext.SaveChangesAsync(cancellationToken);
+
+            // give every channel the proper new number
+            foreach (var channel in channelsToUpdate)
+            {
+                channel.Number = numberUpdates[channel.Id];
+                if (double.TryParse(channel.Number, CultureInfo.InvariantCulture, out double sortNumber))
+                {
+                    channel.SortNumber = sortNumber;
+                }
+                else
+                {
+                    return BaseError.New($"Failed to parse channel number {channel.Number}");
+                }
+            }
+
+            // save those changes
+            await dbContext.SaveChangesAsync(cancellationToken);
+
+            // commit the transaction
+            await transaction.CommitAsync(cancellationToken);
+
+            // update channel list and xmltv
+            await workerChannel.WriteAsync(new RefreshChannelList(), cancellationToken);
+            foreach (var channel in channelsToUpdate)
+            {
+                await workerChannel.WriteAsync(new RefreshChannelData(channel.Number), cancellationToken);
+            }
+
+            return Option<BaseError>.None;
+        }
+        catch (Exception ex)
+        {
+            return BaseError.New("Failed to update channel numbers: " + ex.Message);
+        }
+    }
+}

ErsatzTV.Application/Channels/Mapper.cs

@@ -1,28 +1,87 @@
-using System.Linq;
+using ErsatzTV.Application.Artworks;
+using ErsatzTV.Core.Api.Channels;
 using ErsatzTV.Core.Domain;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Application.Channels
+namespace ErsatzTV.Application.Channels;
+
+internal static class Mapper
 {
-    internal static class Mapper
+    internal static ChannelViewModel ProjectToViewModel(Channel channel, int playoutCount) =>
+        new(
+            channel.Id,
+            channel.Number,
+            channel.Name,
+            channel.Group,
+            channel.Categories,
+            channel.FFmpegProfileId,
+            channel.SlugSeconds,
+            GetLogo(channel),
+            channel.StreamSelectorMode,
+            channel.StreamSelector,
+            channel.PreferredAudioLanguageCode,
+            channel.PreferredAudioTitle,
+            channel.PlayoutSource,
+            channel.PlayoutMode,
+            channel.MirrorSourceChannelId,
+            channel.PlayoutOffset,
+            channel.StreamingMode,
+            channel.WatermarkId,
+            channel.FallbackFillerId,
+            playoutCount,
+            channel.PreferredSubtitleLanguageCode,
+            channel.SubtitleMode,
+            channel.MusicVideoCreditsMode,
+            channel.MusicVideoCreditsTemplate,
+            channel.SongVideoMode,
+            channel.TranscodeMode,
+            channel.IdleBehavior,
+            channel.IsEnabled,
+            channel.ShowInEpg);
+
+    internal static ChannelResponseModel ProjectToResponseModel(Channel channel) =>
+        new(
+            channel.Id,
+            channel.Number,
+            channel.Name,
+            channel.FFmpegProfile.Name,
+            channel.PreferredAudioLanguageCode,
+            GetStreamingMode(channel));
+
+    internal static ResolutionViewModel ProjectToViewModel(Resolution resolution) =>
+        new(resolution.Height, resolution.Width);
+
+    internal static ChannelStreamingSpecsViewModel ProjectToSpecsViewModel(Channel channel) =>
+        new(
+            channel.FFmpegProfile.Resolution.Height,
+            channel.FFmpegProfile.Resolution.Width,
+            (int)((channel.FFmpegProfile.VideoBitrate * 1000 + channel.FFmpegProfile.AudioBitrate * 1000) * 1.2),
+            channel.FFmpegProfile.VideoFormat,
+            channel.FFmpegProfile.VideoProfile,
+            channel.FFmpegProfile.AudioFormat);
+
+    private static ArtworkContentTypeModel GetLogo(Channel channel)
     {
-        internal static ChannelViewModel ProjectToViewModel(Channel channel) =>
-            new(
-                channel.Id,
-                channel.Number,
-                channel.Name,
-                channel.FFmpegProfileId,
-                GetLogo(channel),
-                channel.PreferredLanguageCode,
-                channel.StreamingMode,
-                channel.WatermarkId);
+        Option<Artwork> maybeArtwork = channel.Artwork
+            .Where(a => a.ArtworkKind == ArtworkKind.Logo)
+            .HeadOrNone();
 
-        private static string GetLogo(Channel channel) =>
-            Optional(channel.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Logo))
-                .Match(a => a.Path, string.Empty);
+        foreach (Artwork artwork in maybeArtwork)
+        {
+            return artwork.IsExternalUrl()
+                ? new ArtworkContentTypeModel(artwork.Path, string.Empty)
+                : new ArtworkContentTypeModel($"iptv/logos/{artwork.Path}", artwork.OriginalContentType);
+        }
 
-        private static string GetWatermark(Channel channel) =>
-            Optional(channel.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Watermark))
-                .Match(a => a.Path, string.Empty);
+        return ArtworkContentTypeModel.None;
     }
+
+    private static string GetStreamingMode(Channel channel) =>
+        channel.StreamingMode switch
+        {
+            StreamingMode.TransportStream => "MPEG-TS (Legacy)",
+            StreamingMode.TransportStreamHybrid => "MPEG-TS",
+            StreamingMode.HttpLiveStreamingDirect => "HLS Direct",
+            StreamingMode.HttpLiveStreamingSegmenter => "HLS Segmenter",
+            _ => throw new ArgumentOutOfRangeException(nameof(channel))
+        };
 }

ErsatzTV.Application/Channels/Queries/GetAllChannels.cs

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

ErsatzTV.Application/Channels/Queries/GetAllChannelsForApi.cs

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

ErsatzTV.Application/Channels/Queries/GetAllChannelsForApiHandler.cs

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

ErsatzTV.Application/Channels/Queries/GetAllChannelsForSort.cs

@@ -0,0 +1,3 @@
+namespace ErsatzTV.Application.Channels;
+
+public record GetAllChannelsForSort : IRequest<List<ChannelSortViewModel>>;

ErsatzTV.Application/Channels/Queries/GetAllChannelsForSortHandler.cs

@@ -0,0 +1,31 @@
+using System.Globalization;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Infrastructure.Data;
+using Microsoft.EntityFrameworkCore;
+
+namespace ErsatzTV.Application.Channels;
+
+public class GetAllChannelsForSortHandler(IDbContextFactory<TvContext> dbContextFactory)
+    : IRequestHandler<GetAllChannelsForSort, List<ChannelSortViewModel>>
+{
+    public async Task<List<ChannelSortViewModel>> Handle(
+        GetAllChannelsForSort request,
+        CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
+        return await dbContext.Channels
+            .AsNoTracking()
+            .ToListAsync(cancellationToken)
+            .Map(list => list.Map(ProjectToSortViewModel)
+                .OrderBy(c => decimal.Parse(c.Number, CultureInfo.InvariantCulture)).ToList());
+    }
+
+    private static ChannelSortViewModel ProjectToSortViewModel(Channel channel)
+        => new()
+        {
+            Id = channel.Id,
+            Number = channel.Number,
+            Name = channel.Name,
+            OriginalNumber = channel.Number
+        };
+}

ErsatzTV.Application/Channels/Queries/GetAllChannelsHandler.cs

@@ -1,21 +1,31 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
-using MediatR;
 using static ErsatzTV.Application.Channels.Mapper;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Application.Channels.Queries
+namespace ErsatzTV.Application.Channels;
+
+public class GetAllChannelsHandler(IChannelRepository channelRepository)
+    : IRequestHandler<GetAllChannels, List<ChannelViewModel>>
 {
-    public class GetAllChannelsHandler : IRequestHandler<GetAllChannels, List<ChannelViewModel>>
+    public async Task<List<ChannelViewModel>> Handle(GetAllChannels request, CancellationToken cancellationToken) =>
+        await channelRepository.GetAll(cancellationToken)
+            .Map(list => list.Where(c => c.IsEnabled || request.ShowDisabled)
+                .Map(c => ProjectToViewModel(c, GetPlayoutsCount(c))).ToList());
+
+    private static int GetPlayoutsCount(Channel channel)
     {
-        private readonly IChannelRepository _channelRepository;
+        var result = 0;
 
-        public GetAllChannelsHandler(IChannelRepository channelRepository) => _channelRepository = channelRepository;
+        if (channel.Playouts != null)
+        {
+            result += channel.Playouts.Count;
+        }
 
-        public async Task<List<ChannelViewModel>> Handle(GetAllChannels request, CancellationToken cancellationToken) =>
-            Optional(await _channelRepository.GetAll()).Flatten().Map(ProjectToViewModel).ToList();
+        if (channel.PlayoutSource is ChannelPlayoutSource.Mirror && channel.MirrorSourceChannel?.Playouts != null)
+        {
+            result += channel.MirrorSourceChannel.Playouts.Count;
+        }
+
+        return result;
     }
 }

ErsatzTV.Application/Channels/Queries/GetChannelById.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelByIdHandler.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelByNumber.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelByNumberHandler.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelByPlayoutId.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelByPlayoutIdHandler.cs

@@ -0,0 +1,21 @@
+using ErsatzTV.Infrastructure.Data;
+using Microsoft.EntityFrameworkCore;
+using static ErsatzTV.Application.Channels.Mapper;
+
+namespace ErsatzTV.Application.Channels;
+
+public class GetChannelByPlayoutIdHandler(IDbContextFactory<TvContext> dbContextFactory)
+    : IRequestHandler<GetChannelByPlayoutId, Option<ChannelViewModel>>
+{
+    public async Task<Option<ChannelViewModel>> Handle(
+        GetChannelByPlayoutId request,
+        CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
+        return await dbContext.Playouts
+            .Include(p => p.Channel)
+            .ThenInclude(c => c.Artwork)
+            .SingleOrDefaultAsync(p => p.Id == request.PlayoutId, cancellationToken)
+            .Map(p => ProjectToViewModel(p.Channel, 1));
+    }
+}

ErsatzTV.Application/Channels/Queries/GetChannelFramerate.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelFramerateHandler.cs

@@ -0,0 +1,118 @@
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Extensions;
+using ErsatzTV.FFmpeg;
+using ErsatzTV.Infrastructure.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+
+namespace ErsatzTV.Application.Channels;
+
+public class GetChannelFramerateHandler(
+    IDbContextFactory<TvContext> dbContextFactory,
+    ILogger<GetChannelFramerateHandler> logger)
+    : IRequestHandler<GetChannelFramerate, Option<FrameRate>>
+{
+    public async Task<Option<FrameRate>> Handle(GetChannelFramerate request, CancellationToken cancellationToken)
+    {
+        try
+        {
+            await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
+
+            FFmpegProfile ffmpegProfile = await dbContext.Channels
+                .AsNoTracking()
+                .Filter(c => c.Number == request.ChannelNumber)
+                .Include(c => c.FFmpegProfile)
+                .Map(c => c.FFmpegProfile)
+                .SingleAsync(cancellationToken);
+
+            if (!ffmpegProfile.NormalizeFramerate)
+            {
+                return Option<FrameRate>.None;
+            }
+
+            // TODO: expand to check everything in collection rather than what's scheduled?
+            logger.LogDebug("Checking frame rates for channel {ChannelNumber}", request.ChannelNumber);
+
+            List<Playout> playouts = await dbContext.Playouts
+                .AsNoTracking()
+                .Include(p => p.Items)
+                .ThenInclude(pi => pi.MediaItem)
+                .ThenInclude(mi => (mi as Movie).MediaVersions)
+                .Include(p => p.Items)
+                .ThenInclude(pi => pi.MediaItem)
+                .ThenInclude(mi => (mi as Episode).MediaVersions)
+                .Include(p => p.Items)
+                .ThenInclude(pi => pi.MediaItem)
+                .ThenInclude(mi => (mi as Song).MediaVersions)
+                .Include(p => p.Items)
+                .ThenInclude(pi => pi.MediaItem)
+                .ThenInclude(mi => (mi as MusicVideo).MediaVersions)
+                .Include(p => p.Items)
+                .ThenInclude(pi => pi.MediaItem)
+                .ThenInclude(mi => (mi as OtherVideo).MediaVersions)
+                .Include(p => p.Items)
+                .ThenInclude(pi => pi.MediaItem)
+                .ThenInclude(mi => (mi as Image).MediaVersions)
+                .Include(p => p.Items)
+                .ThenInclude(pi => pi.MediaItem)
+                .ThenInclude(mi => (mi as RemoteStream).MediaVersions)
+                .Filter(p => p.Channel.Number == request.ChannelNumber)
+                .ToListAsync(cancellationToken);
+
+            var frameRates = playouts.Map(p => p.Items.Map(i => i.MediaItem.GetHeadVersion()))
+                .Flatten()
+                .Map(mv => new FrameRate(mv.RFrameRate))
+                .ToList();
+
+            var distinct = frameRates.Distinct().ToList();
+            if (distinct.Count > 1)
+            {
+                // TODO: something more intelligent than minimum framerate?
+                var validFrameRates = frameRates.Where(fr => fr.ParsedFrameRate > 23).ToList();
+                if (validFrameRates.Count > 0)
+                {
+                    FrameRate result = validFrameRates.MinBy(fr => fr.ParsedFrameRate);
+                    logger.LogInformation(
+                        "Normalizing frame rate for channel {ChannelNumber} from {Distinct} to {FrameRate}",
+                        request.ChannelNumber,
+                        distinct.Map(fr => fr.RFrameRate),
+                        result.RFrameRate);
+                    return result;
+                }
+
+                FrameRate minFrameRate = frameRates.MinBy(fr => fr.ParsedFrameRate);
+                logger.LogInformation(
+                    "Normalizing frame rate for channel {ChannelNumber} from {Distinct} to {FrameRate} instead of min value {MinFrameRate}",
+                    request.ChannelNumber,
+                    distinct.Map(fr => fr.RFrameRate),
+                    FrameRate.DefaultFrameRate.RFrameRate,
+                    minFrameRate.RFrameRate);
+
+                return FrameRate.DefaultFrameRate;
+            }
+
+            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].RFrameRate);
+            }
+            else
+            {
+                logger.LogInformation(
+                    "No content on channel {ChannelNumber} has frame rate information; will not normalize",
+                    request.ChannelNumber);
+            }
+        }
+        catch (Exception ex)
+        {
+            logger.LogWarning(
+                ex,
+                "Unexpected error checking frame rates on channel {ChannelNumber}",
+                request.ChannelNumber);
+        }
+
+        return None;
+    }
+}

ErsatzTV.Application/Channels/Queries/GetChannelGuide.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelGuideHandler.cs

@@ -1,20 +1,106 @@
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Interfaces.Repositories;
+using System.Collections.Immutable;
+using System.IO.Abstractions;
+using System.Text;
+using System.Text.RegularExpressions;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Iptv;
-using LanguageExt;
-using MediatR;
+using ErsatzTV.Infrastructure.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.IO;
 
-namespace ErsatzTV.Application.Channels.Queries
+namespace ErsatzTV.Application.Channels;
+
+public partial class GetChannelGuideHandler(
+    IDbContextFactory<TvContext> dbContextFactory,
+    RecyclableMemoryStreamManager recyclableMemoryStreamManager,
+    IFileSystem fileSystem,
+    ILocalFileSystem localFileSystem)
+    : IRequestHandler<GetChannelGuide, Either<BaseError, ChannelGuide>>
 {
-    public class GetChannelGuideHandler : IRequestHandler<GetChannelGuide, ChannelGuide>
+    public async Task<Either<BaseError, ChannelGuide>> Handle(
+        GetChannelGuide request,
+        CancellationToken cancellationToken)
     {
-        private readonly IChannelRepository _channelRepository;
+        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
+        var hiddenChannelNumbers = dbContext.Channels
+            .Where(c => c.ShowInEpg == false)
+            .Select(c => c.Number)
+            .AsEnumerable()
+            .Select(n => $"{n}.xml")
+            .ToImmutableHashSet();
 
-        public GetChannelGuideHandler(IChannelRepository channelRepository) => _channelRepository = channelRepository;
+        string channelsFile = fileSystem.Path.Combine(FileSystemLayout.ChannelGuideCacheFolder, "channels.xml");
+        if (!fileSystem.File.Exists(channelsFile))
+        {
+            return BaseError.New($"Required file {channelsFile} is missing");
+        }
 
-        public Task<ChannelGuide> Handle(GetChannelGuide request, CancellationToken cancellationToken) =>
-            _channelRepository.GetAllForGuide()
-                .Map(channels => new ChannelGuide(request.Scheme, request.Host, channels));
+        long mtime = fileSystem.File.GetLastWriteTime(channelsFile).Ticks;
+
+        var accessTokenUri = $"?v={mtime}";
+        if (!string.IsNullOrWhiteSpace(request.AccessToken))
+        {
+            accessTokenUri += $"&amp;access_token={request.AccessToken}";
+        }
+
+        string channelsFragment = await ReadAllTextShared(channelsFile, cancellationToken);
+
+        // TODO: is regex faster?
+        channelsFragment = channelsFragment
+            .Replace("{RequestBase}", $"{request.Scheme}://{request.Host}{request.BaseUrl}")
+            .Replace("{AccessTokenUri}", accessTokenUri);
+
+        var channelDataFragments = new Dictionary<string, string>();
+
+        foreach (string fileName in localFileSystem.ListFiles(FileSystemLayout.ChannelGuideCacheFolder))
+        {
+            if (fileName.Contains("channels"))
+            {
+                continue;
+            }
+
+            if (hiddenChannelNumbers.Contains(fileSystem.Path.GetFileName(fileName)))
+            {
+                continue;
+            }
+
+            try
+            {
+                string channelDataFragment = await ReadAllTextShared(fileName, cancellationToken);
+
+                channelDataFragment = channelDataFragment
+                    .Replace("{RequestBase}", $"{request.Scheme}://{request.Host}{request.BaseUrl}")
+                    .Replace("{AccessTokenUri}", accessTokenUri);
+
+                channelDataFragment = EtvTagRegex().Replace(channelDataFragment, string.Empty);
+
+                channelDataFragments.Add(fileSystem.Path.GetFileNameWithoutExtension(fileName), channelDataFragment);
+            }
+            catch (FileNotFoundException)
+            {
+                // ignore this channel fragment
+            }
+            catch (IOException)
+            {
+                // ignore this channel fragment
+            }
+        }
+
+        return new ChannelGuide(recyclableMemoryStreamManager, channelsFragment, channelDataFragments);
     }
+
+    private async Task<string> ReadAllTextShared(string fileName, CancellationToken cancellationToken)
+    {
+        await using var stream = fileSystem.FileStream.New(
+            fileName,
+            FileMode.Open,
+            FileAccess.Read,
+            FileShare.ReadWrite);
+        using var reader = new StreamReader(stream, Encoding.UTF8, leaveOpen: true);
+        return await reader.ReadToEndAsync(cancellationToken);
+    }
+
+    [GeneratedRegex(@"<etv:[^>]+?>.*?<\/etv:[^>]+?>|<etv:[^>]+?\/>", RegexOptions.Singleline)]
+    private static partial Regex EtvTagRegex();
 }

ErsatzTV.Application/Channels/Queries/GetChannelLineup.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelLineupHandler.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelNameByPlayoutId.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelNameByPlayoutIdHandler.cs

@@ -0,0 +1,18 @@
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Infrastructure.Extensions;
+using Microsoft.EntityFrameworkCore;
+
+namespace ErsatzTV.Application.Channels;
+
+public class GetChannelNameByPlayoutIdHandler(IDbContextFactory<TvContext> dbContextFactory)
+    : IRequestHandler<GetChannelNameByPlayoutId, Option<string>>
+{
+    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, cancellationToken)
+            .MapT(p => p.Channel.Name);
+    }
+}

ErsatzTV.Application/Channels/Queries/GetChannelPlaylist.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelPlaylistHandler.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelStreamSelectors.cs

@@ -0,0 +1,3 @@
+namespace ErsatzTV.Application.Channels;
+
+public record GetChannelStreamSelectors : IRequest<List<string>>;

ErsatzTV.Application/Channels/Queries/GetChannelStreamSelectorsHandler.cs

@@ -0,0 +1,14 @@
+using ErsatzTV.Core;
+using ErsatzTV.Core.Interfaces.Metadata;
+
+namespace ErsatzTV.Application.Channels;
+
+public class GetChannelStreamSelectorsHandler(ILocalFileSystem localFileSystem)
+    : IRequestHandler<GetChannelStreamSelectors, List<string>>
+{
+    public Task<List<string>> Handle(GetChannelStreamSelectors request, CancellationToken cancellationToken) =>
+        localFileSystem.ListFiles(FileSystemLayout.ChannelStreamSelectorsFolder)
+            .Map(Path.GetFileName)
+            .ToList()
+            .AsTask();
+}

ErsatzTV.Application/Channels/Queries/GetChannelStreamingSpecs.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelStreamingSpecsHandler.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 GetChannelStreamingSpecsHandler(IDbContextFactory<TvContext> dbContextFactory)
+    : IRequestHandler<GetChannelStreamingSpecs, Option<ChannelStreamingSpecsViewModel>>
+{
+    public async Task<Option<ChannelStreamingSpecsViewModel>> Handle(
+        GetChannelStreamingSpecs 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, cancellationToken);
+
+        return maybeChannel.Map(Mapper.ProjectToSpecsViewModel);
+    }
+}

ErsatzTV.Application/Channels/Queries/GetSlugSecondsByChannelNumber.cs

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

ErsatzTV.Application/Channels/Queries/GetSlugSecondsByChannelNumberHandler.cs

@@ -0,0 +1,17 @@
+using ErsatzTV.Infrastructure.Data;
+using Microsoft.EntityFrameworkCore;
+
+namespace ErsatzTV.Application.Channels;
+
+public class GetSlugSecondsByChannelNumberHandler(IDbContextFactory<TvContext> dbContextFactory)
+    : IRequestHandler<GetSlugSecondsByChannelNumber, Option<double>>
+{
+    public async Task<Option<double>> Handle(GetSlugSecondsByChannelNumber request, CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
+        return await dbContext.Channels
+            .AsNoTracking()
+            .SingleOrDefaultAsync(c => c.Number == request.ChannelNumber, cancellationToken)
+            .Map(c => Optional(c?.SlugSeconds));
+    }
+}

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

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

ErsatzTV.Application/Configuration/Commands/SaveConfigElementByKeyHandler.cs

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

ErsatzTV.Application/Configuration/Commands/UpdateLibraryRefreshInterval.cs

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

ErsatzTV.Application/Configuration/Commands/UpdateLibraryRefreshIntervalHandler.cs

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

ErsatzTV.Application/Configuration/Commands/UpdateLoggingSettings.cs

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

ErsatzTV.Application/Configuration/Commands/UpdateLoggingSettingsHandler.cs

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

ErsatzTV.Application/Configuration/Commands/UpdatePlayoutDaysToBuild.cs

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

ErsatzTV.Application/Configuration/Commands/UpdatePlayoutDaysToBuildHandler.cs

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

ErsatzTV.Application/Configuration/Commands/UpdatePlayoutSettings.cs

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

ErsatzTV.Application/Configuration/Commands/UpdatePlayoutSettingsHandler.cs

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

ErsatzTV.Application/Configuration/Commands/UpdateUiSettings.cs

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

ErsatzTV.Application/Configuration/Commands/UpdateUiSettingsHandler.cs

@@ -0,0 +1,28 @@
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+
+namespace ErsatzTV.Application.Configuration;
+
+public class UpdateUiSettingsHandler(IConfigElementRepository configElementRepository)
+    : IRequestHandler<UpdateUiSettings, Either<BaseError, Unit>>
+{
+    public async Task<Either<BaseError, Unit>> Handle(
+        UpdateUiSettings request,
+        CancellationToken cancellationToken)
+    {
+        return await ApplyUpdate(request.UiSettings, cancellationToken);
+    }
+
+    private async Task<Unit> ApplyUpdate(UiSettingsViewModel uiSettings, CancellationToken cancellationToken)
+    {
+        await configElementRepository.Upsert(
+            ConfigElementKey.PagesIsDarkMode,
+            uiSettings.IsDarkMode,
+            cancellationToken);
+
+        await configElementRepository.Upsert(ConfigElementKey.PagesLanguage, uiSettings.Language, cancellationToken);
+
+        return Unit.Default;
+    }
+}

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,50 @@
+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, cancellationToken)
+                .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, cancellationToken);
+    }
+
+    private async Task<Unit> ApplyUpdate(XmltvSettingsViewModel xmltvSettings, CancellationToken cancellationToken)
+    {
+        await configElementRepository.Upsert(ConfigElementKey.XmltvTimeZone, xmltvSettings.TimeZone, cancellationToken);
+        await configElementRepository.Upsert(ConfigElementKey.XmltvDaysToBuild, xmltvSettings.DaysToBuild, cancellationToken);
+        await configElementRepository.Upsert(ConfigElementKey.XmltvBlockBehavior, xmltvSettings.BlockBehavior, cancellationToken);
+
+        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
+
+        foreach (string channelNumber in await dbContext.Channels.Map(c => c.Number).ToListAsync(cancellationToken))
+        {
+            await workerChannel.WriteAsync(new RefreshChannelData(channelNumber), cancellationToken);
+        }
+
+        return Unit.Default;
+    }
+}

ErsatzTV.Application/Configuration/ConfigElementViewModel.cs

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

ErsatzTV.Application/Configuration/LoggingSettingsViewModel.cs

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

ErsatzTV.Application/Configuration/Mapper.cs

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

ErsatzTV.Application/Configuration/PlayoutSettingsViewModel.cs

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

ErsatzTV.Application/Configuration/Queries/GetConfigElementByKey.cs

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

ErsatzTV.Application/Configuration/Queries/GetConfigElementByKeyHandler.cs

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