feat: track episode availability from media servers scanners

Author: 0xSysR3ll

server/lib/availabilitySync.test.ts

@@ -54,6 +54,7 @@ interface ProcessOptions {
 export interface ProcessableEpisode {
   episodeNumber: number;
   hasFile: boolean;
+  hasFile4k?: boolean;
 }
 
 export interface ProcessableSeason {
@@ -711,16 +712,56 @@ class BaseScanner<T> {
         const existingEpisode = existingBySeasonAndNumber.get(key);
 
         if (existingEpisode) {
+          let changed = false;
+          const statusField = is4k ? 'status4k' : 'status';
+          const currentStatus = existingEpisode[statusField];
+
           if (episodeDetail.hasFile) {
-            existingEpisode[is4k ? 'status4k' : 'status'] =
-              MediaStatus.AVAILABLE;
+            existingEpisode[statusField] = MediaStatus.AVAILABLE;
+            changed = true;
+          } else if (
+            currentStatus !== MediaStatus.DELETED &&
+            currentStatus !== MediaStatus.UNKNOWN
+          ) {
+            existingEpisode[statusField] = MediaStatus.DELETED;
+            changed = true;
+          }
+
+          if (this.enable4kShow && episodeDetail.hasFile4k != null && !is4k) {
+            const currentStatus4k = existingEpisode.status4k;
+            if (episodeDetail.hasFile4k) {
+              existingEpisode.status4k = MediaStatus.AVAILABLE;
+              changed = true;
+            } else if (
+              currentStatus4k !== MediaStatus.DELETED &&
+              currentStatus4k !== MediaStatus.UNKNOWN
+            ) {
+              existingEpisode.status4k = MediaStatus.DELETED;
+              changed = true;
+            }
+          }
+
+          if (changed) {
             toSave.push(existingEpisode);
           }
-        } else if (episodeDetail.hasFile) {
+        } else if (
+          episodeDetail.hasFile ||
+          (this.enable4kShow && episodeDetail.hasFile4k)
+        ) {
+          // Only persist episodes that have a file on at least one tier.
           const newEpisode = new Episode({
             episodeNumber: episodeDetail.episodeNumber,
-            status: is4k ? MediaStatus.UNKNOWN : MediaStatus.AVAILABLE,
-            status4k: is4k ? MediaStatus.AVAILABLE : MediaStatus.UNKNOWN,
+            status: episodeDetail.hasFile
+              ? is4k
+                ? MediaStatus.UNKNOWN
+                : MediaStatus.AVAILABLE
+              : MediaStatus.UNKNOWN,
+            status4k:
+              this.enable4kShow && episodeDetail.hasFile4k
+                ? MediaStatus.AVAILABLE
+                : is4k && episodeDetail.hasFile
+                  ? MediaStatus.AVAILABLE
+                  : MediaStatus.UNKNOWN,
             season: Promise.resolve(dbSeason),
           });
           toSave.push(newEpisode);

server/lib/availabilitySync.ts

@@ -16,6 +16,7 @@ import { MediaServerType } from '@server/constants/server';
 import { getRepository } from '@server/datasource';
 import { User } from '@server/entity/User';
 import type {
+  ProcessableEpisode,
   ProcessableSeason,
   RunnableScanner,
   StatusBase,
@@ -310,6 +311,8 @@ class JellyfinScanner
             let totalStandard = 0;
             let total4k = 0;
 
+            let episodeDetails: ProcessableEpisode[] | undefined;
+
             if (!this.enable4kShow) {
               const episodes = await this.jfClient.getEpisodes(
                 Id,
@@ -330,6 +333,10 @@ class JellyfinScanner
 
                 totalStandard += episodeCount;
               }
+
+              if (settings.main.enableEpisodeAvailability) {
+                episodeDetails = this.toProcessableEpisodes(episodes);
+              }
             } else {
               // 4K detection enabled - request media info to check resolution
               const episodes = await this.jfClient.getEpisodes(
@@ -376,6 +383,19 @@ class JellyfinScanner
                 // See issue https://github.com/seerr-team/seerr/issues/1744 for details.
                 if (hasStandard) totalStandard += episodeCount;
                 if (has4k) total4k += episodeCount;
+
+                if (
+                  settings.main.enableEpisodeAvailability &&
+                  (hasStandard || has4k)
+                ) {
+                  episodeDetails ??= [];
+                  episodeDetails.push(
+                    ...this.toProcessableEpisodes([episode], {
+                      hasFile: !!hasStandard,
+                      hasFile4k: !!has4k,
+                    })
+                  );
+                }
               }
             }
 
@@ -400,6 +420,7 @@ class JellyfinScanner
               totalEpisodes: season.episode_count,
               episodes: totalStandard,
               episodes4k: total4k,
+              episodeDetails: tvdbSeasonFromAnidb ? undefined : episodeDetails,
             });
           } else {
             processableSeasons.push({
@@ -443,6 +464,32 @@ class JellyfinScanner
     }
   }
 
+  private toProcessableEpisodes(
+    episodes: JellyfinLibraryItem[],
+    availability: { hasFile: boolean; hasFile4k?: boolean } = { hasFile: true }
+  ): ProcessableEpisode[] {
+    return episodes.flatMap((episode) => {
+      if (episode.IndexNumber == null) {
+        return [];
+      }
+
+      const lastEpisodeNumber = episode.IndexNumberEnd ?? episode.IndexNumber;
+      const details: ProcessableEpisode[] = [];
+      for (
+        let episodeNumber = episode.IndexNumber;
+        episodeNumber <= lastEpisodeNumber;
+        episodeNumber++
+      ) {
+        details.push({
+          episodeNumber,
+          hasFile: availability.hasFile,
+          hasFile4k: availability.hasFile4k,
+        });
+      }
+      return details;
+    });
+  }
+
   private async processItem(item: JellyfinLibraryItem): Promise<void> {
     if (item.Type === 'Movie') {
       await this.processJellyfinMovie(item);