chore(release): 2.2.3

When the streaming region is set to another value than the default one, the setting starts toggling
itself from the default value to the new value and vice-versa constantly

fix #1200

CHANGELOG.md

@@ -1,3 +1,11 @@
+## [2.2.3](https://github.com/fallenbagel/jellyseerr/compare/v2.2.2...v2.2.3) (2024-12-30)
+
+
+### Bug Fixes
+
+* properly fetch sonarr/radarr specific override rules ([#1199](https://github.com/fallenbagel/jellyseerr/issues/1199)) ([814a735](https://github.com/fallenbagel/jellyseerr/commit/814a7357c0c7418091e8d3e911adc403811c9dfe))
+* **usersettings:** fix the streaming region setting toggling itself ([#1203](https://github.com/fallenbagel/jellyseerr/issues/1203)) ([7e94ad7](https://github.com/fallenbagel/jellyseerr/commit/7e94ad721026a03d3ae640ee2deb60e321cabf10)), closes [#1200](https://github.com/fallenbagel/jellyseerr/issues/1200)
+
 ## [2.2.2](https://github.com/fallenbagel/jellyseerr/compare/v2.2.1...v2.2.2) (2024-12-30)
 
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "jellyseerr",
-  "version": "2.2.2",
+  "version": "2.2.3",
   "private": true,
   "scripts": {
     "preinstall": "npx only-allow pnpm",

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
+    // Apply overrides if the user is not an admin or has the "advanced request" permission
-    const useOverrides = !user.hasPermission(
+    const useOverrides = !user.hasPermission([Permission.MANAGE_REQUESTS], {
-      [
+      type: 'or',
-        requestBody.is4k ? Permission.AUTO_APPROVE_4K : Permission.AUTO_APPROVE,
+    });
-        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 }
+            ? { radarrServiceId: defaultRadarrId }
-            : { sonarrServiceId: requestBody.serverId },
+            : { 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(
+      // hacky way to prioritize rules
-        (rule) => rule.rootFolder
+      // TODO: make this better
-      )?.rootFolder;
+      const prioritizedRule = appliedOverrideRules.sort((a, b) => {
-      if (overrideRootFolder) {
+        const keys: (keyof OverrideRule)[] = ['genre', 'language', 'keywords'];
-        rootFolder = overrideRootFolder;
-      }
 
-      const overrideProfileId = appliedOverrideRules.find(
+        const aSpecificity = keys.filter((key) => a[key] !== null).length;
-        (rule) => rule.profileId
+        const bSpecificity = keys.filter((key) => b[key] !== null).length;
-      )?.profileId;
-      if (overrideProfileId) {
-        profileId = overrideProfileId;
-      }
 
-      const overrideTags = appliedOverrideRules.find((rule) => rule.tags)?.tags;
+        // Take the rule with the most specific condition first
-      if (overrideTags) {
+        return bSpecificity - aSpecificity;
-        tags = [
+      })[0];
-          ...new Set([
+
-            ...(tags || []),
+      if (prioritizedRule) {
-            ...overrideTags.split(',').map((tag) => Number(tag)),
+        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,
+        });
       }
     }
 

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,
@@ -451,7 +451,7 @@ const SettingsMain = () => {
                   <div className="form-input-area">
                     <div className="form-input-field">
                       <RegionSelector
-                        value={values.streamingRegion || 'US'}
+                        value={values.streamingRegion}
                         name="streamingRegion"
                         onChange={setFieldValue}
                         regionType="streaming"