fix: optimize media status update to avoid lifecycle hook triggers

This change optimises the media updates to avoid unneccessary lifecycle hook executions which
results in potential recursion for POSTGRESQL compatibility. This should prevent an issue where
after a TV request, the tv request would get sent to sonarr and notification for it would get sent
over and over and over again

README.md

@@ -15,7 +15,7 @@
 <!-- ALL-CONTRIBUTORS-BADGE:END -->
 
 **Jellyseerr** is a free and open source software application for managing requests for your media library.
-It is a fork of [Overseerr](https://github.com/sct/overseerr) built to bring support for [Jellyfin](https://github.com/jellyfin/jellyfin) & [Emby](https://github.com/MediaBrowser/Emby) media servers!
+It is a fork of [Overseerr](https://github.com/sct/overseerr) built to bring additional support for [Jellyfin](https://github.com/jellyfin/jellyfin) & [Emby](https://github.com/MediaBrowser/Emby) media servers!
 
 ## Current Features
 

server/api/externalapi.ts

@@ -293,6 +293,14 @@ class ExternalAPI {
     return data;
   }
 
+  protected removeCache(endpoint: string, params?: Record<string, string>) {
+    const cacheKey = this.serializeCacheKey(endpoint, {
+      ...this.params,
+      ...params,
+    });
+    this.cache?.del(cacheKey);
+  }
+
   private formatUrl(
     endpoint: string,
     params?: Record<string, string>,

server/api/servarr/radarr.ts

@@ -230,6 +230,23 @@ class RadarrAPI extends ServarrBase<{ movieId: number }> {
       throw new Error(`[Radarr] Failed to remove movie: ${e.message}`);
     }
   };
+
+  public clearCache = ({
+    tmdbId,
+    externalId,
+  }: {
+    tmdbId?: number | null;
+    externalId?: number | null;
+  }) => {
+    if (tmdbId) {
+      this.removeCache('/movie/lookup', {
+        term: `tmdb:${tmdbId}`,
+      });
+    }
+    if (externalId) {
+      this.removeCache(`/movie/${externalId}`);
+    }
+  };
 }
 
 export default RadarrAPI;

server/api/servarr/sonarr.ts

@@ -353,6 +353,30 @@ class SonarrAPI extends ServarrBase<{
       throw new Error(`[Radarr] Failed to remove serie: ${e.message}`);
     }
   };
+
+  public clearCache = ({
+    tvdbId,
+    externalId,
+    title,
+  }: {
+    tvdbId?: number | null;
+    externalId?: number | null;
+    title?: string | null;
+  }) => {
+    if (tvdbId) {
+      this.removeCache('/series/lookup', {
+        term: `tvdb:${tvdbId}`,
+      });
+    }
+    if (externalId) {
+      this.removeCache(`/series/${externalId}`);
+    }
+    if (title) {
+      this.removeCache('/series/lookup', {
+        term: title,
+      });
+    }
+  };
 }
 
 export default SonarrAPI;

server/constants/error.ts

@@ -4,6 +4,7 @@ export enum ApiErrorCode {
   InvalidAuthToken = 'INVALID_AUTH_TOKEN',
   InvalidEmail = 'INVALID_EMAIL',
   NotAdmin = 'NOT_ADMIN',
+  NoAdminUser = 'NO_ADMIN_USER',
   SyncErrorGroupedFolders = 'SYNC_ERROR_GROUPED_FOLDERS',
   SyncErrorNoLibraries = 'SYNC_ERROR_NO_LIBRARIES',
   Unknown = 'UNKNOWN',

server/entity/MediaRequest.ts

@@ -7,6 +7,7 @@ import type {
 import SonarrAPI from '@server/api/servarr/sonarr';
 import TheMovieDb from '@server/api/themoviedb';
 import { ANIME_KEYWORD_ID } from '@server/api/themoviedb/constants';
+import type { TmdbKeyword } from '@server/api/themoviedb/interfaces';
 import {
   MediaRequestStatus,
   MediaStatus,
@@ -207,28 +208,50 @@ export class MediaRequest {
       }
     }
 
-    // Apply overrides if the user is not an admin or has the "auto approve" permission
-    const useOverrides = !user.hasPermission(
-      [
-        requestBody.is4k ? Permission.AUTO_APPROVE_4K : Permission.AUTO_APPROVE,
-        Permission.MANAGE_REQUESTS,
-      ],
-      { type: 'or' }
-    );
+    // Apply overrides if the user is not an admin or has the "advanced request" permission
+    const useOverrides = !user.hasPermission([Permission.MANAGE_REQUESTS], {
+      type: 'or',
+    });
 
     let rootFolder = requestBody.rootFolder;
     let profileId = requestBody.profileId;
     let tags = requestBody.tags;
 
     if (useOverrides) {
+      const defaultRadarrId = requestBody.is4k
+        ? settings.radarr.findIndex((r) => r.is4k && r.isDefault)
+        : settings.radarr.findIndex((r) => !r.is4k && r.isDefault);
+      const defaultSonarrId = requestBody.is4k
+        ? settings.sonarr.findIndex((s) => s.is4k && s.isDefault)
+        : settings.sonarr.findIndex((s) => !s.is4k && s.isDefault);
+
       const overrideRuleRepository = getRepository(OverrideRule);
       const overrideRules = await overrideRuleRepository.find({
         where:
           requestBody.mediaType === MediaType.MOVIE
-            ? { radarrServiceId: requestBody.serverId }
-            : { sonarrServiceId: requestBody.serverId },
+            ? { radarrServiceId: defaultRadarrId }
+            : { sonarrServiceId: defaultSonarrId },
       });
+
       const appliedOverrideRules = overrideRules.filter((rule) => {
+        const hasAnimeKeyword =
+          'results' in tmdbMedia.keywords &&
+          tmdbMedia.keywords.results.some(
+            (keyword: TmdbKeyword) => keyword.id === ANIME_KEYWORD_ID
+          );
+
+        // Skip override rules if the media is an anime TV show as anime TV
+        // is handled by default and override rules do not explicitly include
+        // the anime keyword
+        if (
+          requestBody.mediaType === MediaType.TV &&
+          hasAnimeKeyword &&
+          (!rule.keywords ||
+            !rule.keywords.split(',').map(Number).includes(ANIME_KEYWORD_ID))
+        ) {
+          return false;
+        }
+
         if (
           rule.users &&
           !rule.users
@@ -257,31 +280,59 @@ export class MediaRequest {
         ) {
           return false;
         }
+        if (
+          rule.keywords &&
+          !rule.keywords.split(',').some((keywordId) => {
+            let keywordList: TmdbKeyword[] = [];
+
+            if ('keywords' in tmdbMedia.keywords) {
+              keywordList = tmdbMedia.keywords.keywords;
+            } else if ('results' in tmdbMedia.keywords) {
+              keywordList = tmdbMedia.keywords.results;
+            }
+
+            return keywordList
+              .map((keyword: TmdbKeyword) => keyword.id)
+              .includes(Number(keywordId));
+          })
+        ) {
+          return false;
+        }
         return true;
       });
 
-      const overrideRootFolder = appliedOverrideRules.find(
-        (rule) => rule.rootFolder
-      )?.rootFolder;
-      if (overrideRootFolder) {
-        rootFolder = overrideRootFolder;
-      }
+      // hacky way to prioritize rules
+      // TODO: make this better
+      const prioritizedRule = appliedOverrideRules.sort((a, b) => {
+        const keys: (keyof OverrideRule)[] = ['genre', 'language', 'keywords'];
 
-      const overrideProfileId = appliedOverrideRules.find(
-        (rule) => rule.profileId
-      )?.profileId;
-      if (overrideProfileId) {
-        profileId = overrideProfileId;
-      }
+        const aSpecificity = keys.filter((key) => a[key] !== null).length;
+        const bSpecificity = keys.filter((key) => b[key] !== null).length;
 
-      const overrideTags = appliedOverrideRules.find((rule) => rule.tags)?.tags;
-      if (overrideTags) {
-        tags = [
-          ...new Set([
-            ...(tags || []),
-            ...overrideTags.split(',').map((tag) => Number(tag)),
-          ]),
-        ];
+        // Take the rule with the most specific condition first
+        return bSpecificity - aSpecificity;
+      })[0];
+
+      if (prioritizedRule) {
+        if (prioritizedRule.rootFolder) {
+          rootFolder = prioritizedRule.rootFolder;
+        }
+        if (prioritizedRule.profileId) {
+          profileId = prioritizedRule.profileId;
+        }
+        if (prioritizedRule.tags) {
+          tags = [
+            ...new Set([
+              ...(tags || []),
+              ...prioritizedRule.tags.split(',').map((tag) => Number(tag)),
+            ]),
+          ];
+        }
+
+        logger.debug('Override rule applied.', {
+          label: 'Media Request',
+          overrides: prioritizedRule,
+        });
       }
     }
 
@@ -335,14 +386,14 @@ export class MediaRequest {
       const tmdbMediaShow = tmdbMedia as Awaited<
         ReturnType<typeof tmdb.getTvShow>
       >;
-      const requestedSeasons =
+      let requestedSeasons =
         requestBody.seasons === 'all'
-          ? settings.main.enableSpecialEpisodes
-            ? tmdbMediaShow.seasons.map((season) => season.season_number)
-            : tmdbMediaShow.seasons
-                .map((season) => season.season_number)
-                .filter((sn) => sn > 0)
+          ? tmdbMediaShow.seasons.map((season) => season.season_number)
           : (requestBody.seasons as number[]);
+      if (!settings.main.enableSpecialEpisodes) {
+        requestedSeasons = requestedSeasons.filter((sn) => sn > 0);
+      }
+
       let existingSeasons: number[] = [];
 
       // We need to check existing requests on this title to make sure we don't double up on seasons that were
@@ -668,10 +719,15 @@ export class MediaRequest {
       // Do not update the status if the item is already partially available or available
       media[this.is4k ? 'status4k' : 'status'] !== MediaStatus.AVAILABLE &&
       media[this.is4k ? 'status4k' : 'status'] !==
-        MediaStatus.PARTIALLY_AVAILABLE
+        MediaStatus.PARTIALLY_AVAILABLE &&
+      media[this.is4k ? 'status4k' : 'status'] !== MediaStatus.PROCESSING
     ) {
-      media[this.is4k ? 'status4k' : 'status'] = MediaStatus.PROCESSING;
-      mediaRepository.save(media);
+      const statusField = this.is4k ? 'status4k' : 'status';
+
+      await mediaRepository.update(
+        { id: this.media.id },
+        { [statusField]: MediaStatus.PROCESSING }
+      );
     }
 
     if (
@@ -954,6 +1010,14 @@ export class MediaRequest {
             );
 
             this.sendNotification(media, Notification.MEDIA_FAILED);
+          })
+          .finally(() => {
+            radarr.clearCache({
+              tmdbId: movie.id,
+              externalId: this.is4k
+                ? media.externalServiceId4k
+                : media.externalServiceId,
+            });
           });
         logger.info('Sent request to Radarr', {
           label: 'Media Request',
@@ -1211,19 +1275,23 @@ export class MediaRequest {
               throw new Error('Media data not found');
             }
 
-            media[this.is4k ? 'externalServiceId4k' : 'externalServiceId'] =
-              sonarrSeries.id;
-            media[this.is4k ? 'externalServiceSlug4k' : 'externalServiceSlug'] =
-              sonarrSeries.titleSlug;
-            media[this.is4k ? 'serviceId4k' : 'serviceId'] = sonarrSettings?.id;
+            const updateFields = {
+              [this.is4k ? 'externalServiceId4k' : 'externalServiceId']:
+                sonarrSeries.id,
+              [this.is4k ? 'externalServiceSlug4k' : 'externalServiceSlug']:
+                sonarrSeries.titleSlug,
+              [this.is4k ? 'serviceId4k' : 'serviceId']: sonarrSettings?.id,
+            };
 
-            await mediaRepository.save(media);
+            await mediaRepository.update({ id: this.media.id }, updateFields);
           })
           .catch(async () => {
             const requestRepository = getRepository(MediaRequest);
 
-            this.status = MediaRequestStatus.FAILED;
-            await requestRepository.save(this);
+            await requestRepository.update(
+              { id: this.id },
+              { status: MediaRequestStatus.FAILED }
+            );
 
             logger.warn(
               'Something went wrong sending series request to Sonarr, marking status as FAILED',
@@ -1236,6 +1304,15 @@ export class MediaRequest {
             );
 
             this.sendNotification(media, Notification.MEDIA_FAILED);
+          })
+          .finally(() => {
+            sonarr.clearCache({
+              tvdbId,
+              externalId: this.is4k
+                ? media.externalServiceId4k
+                : media.externalServiceId,
+              title: series.name,
+            });
           });
         logger.info('Sent request to Sonarr', {
           label: 'Media Request',

server/lib/scanners/sonarr/index.ts

@@ -107,7 +107,7 @@ class SonarrScanner
       const filteredSeasons = sonarrSeries.seasons.filter(
         (sn) =>
           tvShow.seasons.find((s) => s.season_number === sn.seasonNumber) &&
-          (!settings.main.partialRequestsEnabled ? sn.seasonNumber !== 0 : true)
+          (!settings.main.enableSpecialEpisodes ? sn.seasonNumber !== 0 : true)
       );
 
       for (const season of filteredSeasons) {

server/routes/auth.ts

@@ -313,7 +313,7 @@ authRoutes.post('/jellyfin', async (req, res, next) => {
         body.serverType !== MediaServerType.JELLYFIN &&
         body.serverType !== MediaServerType.EMBY
       ) {
-        throw new Error('select_server_type');
+        throw new ApiError(500, ApiErrorCode.NoAdminUser);
       }
       settings.main.mediaServerType = body.serverType;
 
@@ -533,6 +533,22 @@ authRoutes.post('/jellyfin', async (req, res, next) => {
           message: e.errorCode,
         });
 
+      case ApiErrorCode.NoAdminUser:
+        logger.warn(
+          'Failed login attempt from user without admin permissions and no admin user exists',
+          {
+            label: 'Auth',
+            account: {
+              ip: req.ip,
+              email: body.username,
+            },
+          }
+        );
+        return next({
+          status: e.statusCode,
+          message: e.errorCode,
+        });
+
       default:
         logger.error(e.message, { label: 'Auth' });
         return next({

server/routes/user/index.ts

@@ -70,11 +70,11 @@ router.get('/', async (req, res, next) => {
         query = query
           .addSelect((subQuery) => {
             return subQuery
-              .select('COUNT(request.id)', 'requestCount')
+              .select('COUNT(request.id)', 'request_count')
               .from(MediaRequest, 'request')
               .where('request.requestedBy.id = user.id');
-          }, 'requestCount')
-          .orderBy('requestCount', 'DESC');
+          }, 'request_count')
+          .orderBy('request_count', 'DESC');
         break;
       default:
         query = query.orderBy('user.id', 'ASC');

src/components/Login/JellyfinLogin.tsx

@@ -34,6 +34,7 @@ const messages = defineMessages('components.Login', {
   validationUrlBaseTrailingSlash: 'URL base must not end in a trailing slash',
   loginerror: 'Something went wrong while trying to sign in.',
   adminerror: 'You must use an admin account to sign in.',
+  noadminerror: 'No admin user found on the server.',
   credentialerror: 'The username or password is incorrect.',
   invalidurlerror: 'Unable to connect to {mediaServerName} server.',
   signingin: 'Signing in…',
@@ -157,6 +158,9 @@ const JellyfinLogin: React.FC<JellyfinLoginProps> = ({
               case ApiErrorCode.NotAdmin:
                 errorMessage = messages.adminerror;
                 break;
+              case ApiErrorCode.NoAdminUser:
+                errorMessage = messages.noadminerror;
+                break;
               default:
                 errorMessage = messages.loginerror;
                 break;
@@ -388,14 +392,35 @@ const JellyfinLogin: React.FC<JellyfinLoginProps> = ({
                   email: values.username,
                 }),
               });
-              if (!res.ok) throw new Error();
+              if (!res.ok) throw new Error(res.statusText, { cause: res });
             } catch (e) {
+              let errorData;
+              try {
+                errorData = await e.cause?.text();
+                errorData = JSON.parse(errorData);
+              } catch {
+                /* empty */
+              }
+              let errorMessage = null;
+              switch (errorData?.message) {
+                case ApiErrorCode.InvalidUrl:
+                  errorMessage = messages.invalidurlerror;
+                  break;
+                case ApiErrorCode.InvalidCredentials:
+                  errorMessage = messages.credentialerror;
+                  break;
+                case ApiErrorCode.NotAdmin:
+                  errorMessage = messages.adminerror;
+                  break;
+                case ApiErrorCode.NoAdminUser:
+                  errorMessage = messages.noadminerror;
+                  break;
+                default:
+                  errorMessage = messages.loginerror;
+                  break;
+              }
               toasts.addToast(
-                intl.formatMessage(
-                  e.message == 'Request failed with status code 401'
-                    ? messages.credentialerror
-                    : messages.loginerror
-                ),
+                intl.formatMessage(errorMessage, mediaServerFormatValues),
                 {
                   autoDismiss: true,
                   appearance: 'error',

src/components/RequestList/index.tsx

@@ -220,8 +220,8 @@ const RequestList = () => {
             </select>
             <Tooltip content={intl.formatMessage(messages.sortDirection)}>
               <Button
-                buttonType="ghost"
-                className="z-40 mr-2 rounded-l-none"
+                buttonType="default"
+                className="z-40 mr-2 rounded-l-none border !border-gray-500 !bg-gray-800 !px-3 !text-gray-500 hover:!bg-gray-400 hover:!text-white"
                 buttonSize="md"
                 onClick={() =>
                   setCurrentSortDirection(
@@ -230,9 +230,9 @@ const RequestList = () => {
                 }
               >
                 {currentSortDirection === 'asc' ? (
-                  <ArrowUpIcon className="h-3" />
+                  <ArrowUpIcon className="h-6 w-6" />
                 ) : (
-                  <ArrowDownIcon className="h-3" />
+                  <ArrowDownIcon className="h-6 w-6" />
                 )}
               </Button>
             </Tooltip>

src/components/RequestModal/TvRequestModal.tsx

@@ -256,8 +256,8 @@ const TvRequestModal = ({
     let allSeasons = (data?.seasons ?? []).filter(
       (season) => season.episodeCount !== 0
     );
-    if (!settings.currentSettings.partialRequestsEnabled) {
-      allSeasons = allSeasons.filter((season) => season.seasonNumber !== 0);
+    if (!settings.currentSettings.enableSpecialEpisodes) {
+      allSeasons = allSeasons.filter((season) => season.seasonNumber > 0);
     }
     return allSeasons.map((season) => season.seasonNumber);
   };

src/components/Settings/SettingsMain/index.tsx

@@ -157,7 +157,7 @@ const SettingsMain = () => {
             locale: data?.locale ?? 'en',
             discoverRegion: data?.discoverRegion,
             originalLanguage: data?.originalLanguage,
-            streamingRegion: data?.streamingRegion,
+            streamingRegion: data?.streamingRegion || 'US',
             partialRequestsEnabled: data?.partialRequestsEnabled,
             enableSpecialEpisodes: data?.enableSpecialEpisodes,
             trustProxy: data?.trustProxy,
@@ -433,7 +433,7 @@ const SettingsMain = () => {
                     </span>
                   </label>
                   <div className="form-input-area">
-                    <div className="form-input-field">
+                    <div className="form-input-field relative z-30">
                       <LanguageSelector
                         setFieldValue={setFieldValue}
                         value={values.originalLanguage}
@@ -449,9 +449,9 @@ const SettingsMain = () => {
                     </span>
                   </label>
                   <div className="form-input-area">
-                    <div className="form-input-field">
+                    <div className="form-input-field relative z-20">
                       <RegionSelector
-                        value={values.streamingRegion || 'US'}
+                        value={values.streamingRegion}
                         name="streamingRegion"
                         onChange={setFieldValue}
                         regionType="streaming"

src/components/TvDetails/index.tsx

@@ -303,7 +303,7 @@ const TvDetails = ({ tv }: TvDetailsProps) => {
   const showHasSpecials = data.seasons.some(
     (season) =>
       season.seasonNumber === 0 &&
-      settings.currentSettings.partialRequestsEnabled
+      settings.currentSettings.enableSpecialEpisodes
   );
 
   const isComplete =