feat: add tvdb indexer (#899)

* feat(tvdb): get tv seasons/episodes with tvdb

* fix: fix rate limiter index tvdb indexer

* fix(usersettings): remove unused column tvdbtoken

* refactor(tvdb): replace tvdb api by skyhook

* fix: error during get episodes

* fix: error if tmdb poster is null

* refactor: clean tvdb indexer code

* fix: wrong language with tmdb indexer

* style: replace avalaible to available

* style: tvdb.login to tvdb.test

* fix(test): fix  discover test

* fix(test): wrong url tv-details

* test(tvdb): add tvdb tests

* style(tvdb): rename pokemon to correct tv show

* refactor(indexer): remove unused getSeasonIdentifier method

* refactor(settings): replace tvdb object to boolean type

* refactor(tmdb): reduce still path condition

* test(tvdb): change 'use' to 'tvdb' condition check

* fix(tmdb): fix build

fix build after rebase

* fix(build): revert package.json

* fix(tvdb): ensure that seasons contain data

* refactor(swagger): fix /tvdb/test response

* fix(scanner): add tvdb indexer for scanner

* refactor(tvdb): remove skyhook api

* refactor(tvdb): use tvdb api

* fix(tvdb): rename tvdb to medatada

* refactor(medata): add tvdb settings

* refactor(metadata): rewrite metadata settings

* refactor(metadata): refactor metadata routes

* refactor(metadata): remove french comments

* refactor(metadata): refactor tvdb api calls

* style(prettier): run prettier

* fix(scanner): fix jellyfin scanner with tvdb provider

* fix(scanner): fix plex scanner tvdb provider

* style(provider): change provider name in info section

* style(provider): full provider name in select

* style(provider): remove french comment

* fix(tests): fix all cypress tests

* refactor(tvdb): fix apikey

* refactor(tmdb): apply prettier

* refactor(tvdb): remove logger info

* feat(metadata): replace fetch with axios for API calls

* feat(provider): replace indexer by provider

* fix(tests): fix cypress test

* chore: add project-wide apikey for tvdb

* chore: add correct application-wide key

* fix(test): fix test with default provider tmdb anime

* style(cypress): fix anime name variable

* chore(i18n): remove french translation + apply i18n:extract

* style(wording): standardize naming to "Metadata Provider" in UI text

* docs(comments): translate from French to English

* refactor(tvdb): remove unnecessary try/catch block

* feat(i18n): add missing translations

* fix(scanner): correct metadata provider ID from Tmdb to Tvdb

* style(settings): clarify navigation label from "Metadata" to "Metadata Providers"

* style(logs): update error log label from "Metadata" to "MetadataProvider"

* refactor(tvdb): replace indexer by metadata providers

* refactor(settings): remove metadata providers logo

* fix(config): restore missing config/db/.gitkeep file

---------

Co-authored-by: TOomaAh <ubuntu@PC>
Co-authored-by: fallenbagel <98979876+Fallenbagel@users.noreply.github.com>

server/api/externalapi.ts

@@ -10,7 +10,7 @@ const DEFAULT_TTL = 300;
 // 10 seconds default rolling buffer (in ms)
 const DEFAULT_ROLLING_BUFFER = 10000;
 
-interface ExternalAPIOptions {
+export interface ExternalAPIOptions {
   nodeCache?: NodeCache;
   headers?: Record<string, unknown>;
   rateLimit?: {

server/api/metadata.ts

@@ -0,0 +1,39 @@
+import type { TvShowProvider } from '@server/api/provider';
+import TheMovieDb from '@server/api/themoviedb';
+import Tvdb from '@server/api/tvdb';
+import { getSettings, MetadataProviderType } from '@server/lib/settings';
+import logger from '@server/logger';
+
+export const getMetadataProvider = async (
+  mediaType: 'movie' | 'tv' | 'anime'
+): Promise<TvShowProvider> => {
+  try {
+    const settings = await getSettings();
+
+    if (mediaType == 'movie') {
+      return new TheMovieDb();
+    }
+
+    if (
+      mediaType == 'tv' &&
+      settings.metadataSettings.tv == MetadataProviderType.TVDB
+    ) {
+      return await Tvdb.getInstance();
+    }
+
+    if (
+      mediaType == 'anime' &&
+      settings.metadataSettings.anime == MetadataProviderType.TVDB
+    ) {
+      return await Tvdb.getInstance();
+    }
+
+    return new TheMovieDb();
+  } catch (e) {
+    logger.error('Failed to get metadata provider', {
+      label: 'Metadata',
+      message: e.message,
+    });
+    return new TheMovieDb();
+  }
+};

server/api/provider.ts

@@ -0,0 +1,30 @@
+import type {
+  TmdbSeasonWithEpisodes,
+  TmdbTvDetails,
+} from '@server/api/themoviedb/interfaces';
+
+export interface TvShowProvider {
+  getTvShow({
+    tvId,
+    language,
+  }: {
+    tvId: number;
+    language?: string;
+  }): Promise<TmdbTvDetails>;
+  getTvSeason({
+    tvId,
+    seasonNumber,
+    language,
+  }: {
+    tvId: number;
+    seasonNumber: number;
+    language?: string;
+  }): Promise<TmdbSeasonWithEpisodes>;
+  getShowByTvdbId({
+    tvdbId,
+    language,
+  }: {
+    tvdbId: number;
+    language?: string;
+  }): Promise<TmdbTvDetails>;
+}

server/api/themoviedb/index.ts

@@ -1,4 +1,5 @@
 import ExternalAPI from '@server/api/externalapi';
+import type { TvShowProvider } from '@server/api/provider';
 import cacheManager from '@server/lib/cache';
 import { getSettings } from '@server/lib/settings';
 import { sortBy } from 'lodash';
@@ -120,7 +121,7 @@ interface DiscoverTvOptions {
   certificationCountry?: string;
 }
 
-class TheMovieDb extends ExternalAPI {
+class TheMovieDb extends ExternalAPI implements TvShowProvider {
   private locale: string;
   private discoverRegion?: string;
   private originalLanguage?: string;
@@ -341,6 +342,13 @@ class TheMovieDb extends ExternalAPI {
         }
       );
 
+      data.episodes = data.episodes.map((episode) => {
+        if (episode.still_path) {
+          episode.still_path = `https://image.tmdb.org/t/p/original/${episode.still_path}`;
+        }
+        return episode;
+      });
+
       return data;
     } catch (e) {
       throw new Error(`[TMDB] Failed to fetch TV show details: ${e.message}`);

server/api/themoviedb/interfaces.ts

@@ -220,7 +220,7 @@ export interface TmdbTvEpisodeResult {
   show_id: number;
   still_path: string;
   vote_average: number;
-  vote_cuont: number;
+  vote_count: number;
 }
 
 export interface TmdbTvSeasonResult {

server/api/tvdb/index.ts

@@ -0,0 +1,431 @@
+import ExternalAPI from '@server/api/externalapi';
+import type { TvShowProvider } from '@server/api/provider';
+import TheMovieDb from '@server/api/themoviedb';
+import type {
+  TmdbSeasonWithEpisodes,
+  TmdbTvDetails,
+  TmdbTvEpisodeResult,
+  TmdbTvSeasonResult,
+} from '@server/api/themoviedb/interfaces';
+import type {
+  TvdbBaseResponse,
+  TvdbEpisode,
+  TvdbLoginResponse,
+  TvdbSeasonDetails,
+  TvdbTvDetails,
+} from '@server/api/tvdb/interfaces';
+import cacheManager, { type AvailableCacheIds } from '@server/lib/cache';
+import logger from '@server/logger';
+
+interface TvdbConfig {
+  baseUrl: string;
+  maxRequestsPerSecond: number;
+  maxRequests: number;
+  cachePrefix: AvailableCacheIds;
+}
+
+const DEFAULT_CONFIG: TvdbConfig = {
+  baseUrl: 'https://api4.thetvdb.com/v4',
+  maxRequestsPerSecond: 50,
+  maxRequests: 20,
+  cachePrefix: 'tvdb' as const,
+};
+
+const enum TvdbIdStatus {
+  INVALID = -1,
+}
+
+type TvdbId = number;
+type ValidTvdbId = Exclude<TvdbId, TvdbIdStatus.INVALID>;
+
+class Tvdb extends ExternalAPI implements TvShowProvider {
+  static instance: Tvdb;
+  private readonly tmdb: TheMovieDb;
+  private static readonly DEFAULT_CACHE_TTL = 43200;
+  private static readonly DEFAULT_LANGUAGE = 'eng';
+  private token: string;
+  private pin?: string;
+
+  constructor(pin?: string) {
+    const finalConfig = { ...DEFAULT_CONFIG };
+    super(
+      finalConfig.baseUrl,
+      {},
+      {
+        nodeCache: cacheManager.getCache(finalConfig.cachePrefix).data,
+        rateLimit: {
+          maxRequests: finalConfig.maxRequests,
+          maxRPS: finalConfig.maxRequestsPerSecond,
+        },
+      }
+    );
+    this.pin = pin;
+    this.tmdb = new TheMovieDb();
+  }
+
+  public static async getInstance(): Promise<Tvdb> {
+    if (!this.instance) {
+      this.instance = new Tvdb();
+      await this.instance.login();
+    }
+
+    return this.instance;
+  }
+
+  private async refreshToken(): Promise<void> {
+    try {
+      if (!this.token) {
+        await this.login();
+        return;
+      }
+
+      const base64Url = this.token.split('.')[1];
+      const base64 = base64Url.replace(/-/g, '+').replace(/_/g, '/');
+      const payload = JSON.parse(Buffer.from(base64, 'base64').toString());
+
+      if (!payload.exp) {
+        await this.login();
+      }
+
+      const now = Math.floor(Date.now() / 1000);
+      const diff = payload.exp - now;
+
+      // refresh token 1 week before expiration
+      if (diff < 604800) {
+        await this.login();
+      }
+    } catch (error) {
+      this.handleError('Failed to refresh token', error);
+    }
+  }
+
+  public async test(): Promise<void> {
+    try {
+      await this.login();
+    } catch (error) {
+      this.handleError('Login failed', error);
+      throw error;
+    }
+  }
+
+  async login(): Promise<TvdbLoginResponse> {
+    let body: { apiKey: string; pin?: string } = {
+      apiKey: 'd00d9ecb-a9d0-4860-958a-74b14a041405',
+    };
+
+    if (this.pin) {
+      body = {
+        ...body,
+        pin: this.pin,
+      };
+    }
+
+    const response = await this.post<TvdbBaseResponse<TvdbLoginResponse>>(
+      '/login',
+      {
+        ...body,
+      }
+    );
+
+    this.token = response.data.token;
+
+    return response.data;
+  }
+
+  public async getShowByTvdbId({
+    tvdbId,
+    language,
+  }: {
+    tvdbId: number;
+    language?: string;
+  }): Promise<TmdbTvDetails> {
+    try {
+      const tmdbTvShow = await this.tmdb.getShowByTvdbId({
+        tvdbId: tvdbId,
+        language,
+      });
+
+      try {
+        await this.refreshToken();
+
+        const validTvdbId = this.getTvdbIdFromTmdb(tmdbTvShow);
+
+        if (this.isValidTvdbId(validTvdbId)) {
+          return this.enrichTmdbShowWithTvdbData(tmdbTvShow, validTvdbId);
+        }
+
+        return tmdbTvShow;
+      } catch (error) {
+        return tmdbTvShow;
+      }
+    } catch (error) {
+      this.handleError('Failed to fetch TV show details', error);
+      throw error;
+    }
+  }
+
+  public async getTvShow({
+    tvId,
+    language,
+  }: {
+    tvId: number;
+    language?: string;
+  }): Promise<TmdbTvDetails> {
+    try {
+      const tmdbTvShow = await this.tmdb.getTvShow({ tvId, language });
+
+      try {
+        await this.refreshToken();
+
+        const tvdbId = this.getTvdbIdFromTmdb(tmdbTvShow);
+
+        if (this.isValidTvdbId(tvdbId)) {
+          return await this.enrichTmdbShowWithTvdbData(tmdbTvShow, tvdbId);
+        }
+
+        return tmdbTvShow;
+      } catch (error) {
+        this.handleError('Failed to fetch TV show details', error);
+        return tmdbTvShow;
+      }
+    } catch (error) {
+      this.handleError('Failed to fetch TV show details', error);
+      return this.tmdb.getTvShow({ tvId, language });
+    }
+  }
+
+  public async getTvSeason({
+    tvId,
+    seasonNumber,
+    language = Tvdb.DEFAULT_LANGUAGE,
+  }: {
+    tvId: number;
+    seasonNumber: number;
+    language?: string;
+  }): Promise<TmdbSeasonWithEpisodes> {
+    if (seasonNumber === 0) {
+      return this.createEmptySeasonResponse(tvId);
+    }
+
+    try {
+      const tmdbTvShow = await this.tmdb.getTvShow({ tvId, language });
+
+      try {
+        await this.refreshToken();
+
+        const tvdbId = this.getTvdbIdFromTmdb(tmdbTvShow);
+
+        if (!this.isValidTvdbId(tvdbId)) {
+          return await this.tmdb.getTvSeason({ tvId, seasonNumber, language });
+        }
+
+        return await this.getTvdbSeasonData(tvdbId, seasonNumber, tvId);
+      } catch (error) {
+        this.handleError('Failed to fetch TV season details', error);
+        return await this.tmdb.getTvSeason({ tvId, seasonNumber, language });
+      }
+    } catch (error) {
+      logger.error(
+        `[TVDB] Failed to fetch TV season details: ${error.message}`
+      );
+      throw error;
+    }
+  }
+
+  private async enrichTmdbShowWithTvdbData(
+    tmdbTvShow: TmdbTvDetails,
+    tvdbId: ValidTvdbId
+  ): Promise<TmdbTvDetails> {
+    try {
+      await this.refreshToken();
+
+      const tvdbData = await this.fetchTvdbShowData(tvdbId);
+      const seasons = this.processSeasons(tvdbData);
+
+      if (!seasons.length) {
+        return tmdbTvShow;
+      }
+
+      return { ...tmdbTvShow, seasons };
+    } catch (error) {
+      logger.error(
+        `Failed to enrich TMDB show with TVDB data: ${error.message} token: ${this.token}`
+      );
+      return tmdbTvShow;
+    }
+  }
+
+  private async fetchTvdbShowData(tvdbId: number): Promise<TvdbTvDetails> {
+    const resp = await this.get<TvdbBaseResponse<TvdbTvDetails>>(
+      `/series/${tvdbId}/extended?meta=episodes&short=true`,
+      {
+        headers: {
+          Authorization: `Bearer ${this.token}`,
+        },
+      },
+      Tvdb.DEFAULT_CACHE_TTL
+    );
+
+    return resp.data;
+  }
+
+  private processSeasons(tvdbData: TvdbTvDetails): TmdbTvSeasonResult[] {
+    if (!tvdbData || !tvdbData.seasons || !tvdbData.episodes) {
+      return [];
+    }
+
+    const seasons = tvdbData.seasons
+      .filter(
+        (season) =>
+          season.number > 0 && season.type && season.type.type === 'official'
+      )
+      .sort((a, b) => a.number - b.number)
+      .map((season) => this.createSeasonData(season, tvdbData));
+
+    return seasons;
+  }
+
+  private createSeasonData(
+    season: TvdbSeasonDetails,
+    tvdbData: TvdbTvDetails
+  ): TmdbTvSeasonResult {
+    if (!season.number) {
+      return {
+        id: 0,
+        episode_count: 0,
+        name: '',
+        overview: '',
+        season_number: 0,
+        poster_path: '',
+        air_date: '',
+      };
+    }
+
+    const episodeCount = tvdbData.episodes.filter(
+      (episode) => episode.seasonNumber === season.number
+    ).length;
+
+    return {
+      id: tvdbData.id,
+      episode_count: episodeCount,
+      name: `${season.number}`,
+      overview: '',
+      season_number: season.number,
+      poster_path: '',
+      air_date: '',
+    };
+  }
+
+  private async getTvdbSeasonData(
+    tvdbId: number,
+    seasonNumber: number,
+    tvId: number
+    //language: string = Tvdb.DEFAULT_LANGUAGE
+  ): Promise<TmdbSeasonWithEpisodes> {
+    const tvdbData = await this.fetchTvdbShowData(tvdbId);
+
+    if (!tvdbData) {
+      logger.error(`Failed to fetch TVDB data for ID: ${tvdbId}`);
+      return this.createEmptySeasonResponse(tvId);
+    }
+
+    // get season id
+    const season = tvdbData.seasons.find(
+      (season) =>
+        season.number === seasonNumber &&
+        season.type.type &&
+        season.type.type === 'official'
+    );
+
+    if (!season) {
+      logger.error(
+        `Failed to find season ${seasonNumber} for TVDB ID: ${tvdbId}`
+      );
+      return this.createEmptySeasonResponse(tvId);
+    }
+
+    const resp = await this.get<TvdbBaseResponse<TvdbSeasonDetails>>(
+      `/seasons/${season.id}/extended`,
+      {
+        headers: {
+          Authorization: `Bearer ${this.token}`,
+        },
+      }
+    );
+
+    const seasons = resp.data;
+
+    const episodes = this.processEpisodes(seasons, seasonNumber, tvId);
+
+    return {
+      episodes,
+      external_ids: { tvdb_id: tvdbId },
+      name: '',
+      overview: '',
+      id: seasons.id,
+      air_date: seasons.firstAired,
+      season_number: episodes.length,
+    };
+  }
+
+  private processEpisodes(
+    tvdbSeason: TvdbSeasonDetails,
+    seasonNumber: number,
+    tvId: number
+  ): TmdbTvEpisodeResult[] {
+    if (!tvdbSeason || !tvdbSeason.episodes) {
+      logger.error('No episodes found in TVDB season data');
+      return [];
+    }
+
+    return tvdbSeason.episodes
+      .filter((episode) => episode.seasonNumber === seasonNumber)
+      .map((episode, index) => this.createEpisodeData(episode, index, tvId));
+  }
+
+  private createEpisodeData(
+    episode: TvdbEpisode,
+    index: number,
+    tvId: number
+  ): TmdbTvEpisodeResult {
+    return {
+      id: episode.id,
+      air_date: episode.aired,
+      episode_number: episode.number,
+      name: episode.name || `Episode ${index + 1}`,
+      overview: episode.overview || '',
+      season_number: episode.seasonNumber,
+      production_code: '',
+      show_id: tvId,
+      still_path: episode.image ? episode.image : '',
+      vote_average: 1,
+      vote_count: 1,
+    };
+  }
+
+  private createEmptySeasonResponse(tvId: number): TmdbSeasonWithEpisodes {
+    return {
+      episodes: [],
+      external_ids: { tvdb_id: tvId },
+      name: '',
+      overview: '',
+      id: 0,
+      air_date: '',
+      season_number: 0,
+    };
+  }
+
+  private getTvdbIdFromTmdb(tmdbTvShow: TmdbTvDetails): TvdbId {
+    return tmdbTvShow?.external_ids?.tvdb_id ?? TvdbIdStatus.INVALID;
+  }
+
+  private isValidTvdbId(tvdbId: TvdbId): tvdbId is ValidTvdbId {
+    return tvdbId !== TvdbIdStatus.INVALID;
+  }
+
+  private handleError(context: string, error: Error): void {
+    throw new Error(`[TVDB] ${context}: ${error.message}`);
+  }
+}
+
+export default Tvdb;

server/api/tvdb/interfaces.ts

@@ -0,0 +1,144 @@
+export interface TvdbBaseResponse<T> {
+  data: T;
+  errors: string;
+}
+
+export interface TvdbLoginResponse {
+  token: string;
+}
+
+interface TvDetailsAliases {
+  language: string;
+  name: string;
+}
+
+interface TvDetailsStatus {
+  id: number;
+  name: string;
+  recordType: string;
+  keepUpdated: boolean;
+}
+
+export interface TvdbTvDetails {
+  id: number;
+  name: string;
+  slug: string;
+  image: string;
+  nameTranslations: string[];
+  overwiewTranslations: string[];
+  aliases: TvDetailsAliases[];
+  firstAired: Date;
+  lastAired: Date;
+  nextAired: Date | string;
+  score: number;
+  status: TvDetailsStatus;
+  originalCountry: string;
+  originalLanguage: string;
+  defaultSeasonType: string;
+  isOrderRandomized: boolean;
+  lastUpdated: Date;
+  averageRuntime: number;
+  seasons: TvdbSeasonDetails[];
+  episodes: TvdbEpisode[];
+}
+
+interface TvdbCompanyType {
+  companyTypeId: number;
+  companyTypeName: string;
+}
+
+interface TvdbParentCompany {
+  id?: number;
+  name?: string;
+  relation?: {
+    id?: number;
+    typeName?: string;
+  };
+}
+
+interface TvdbCompany {
+  id: number;
+  name: string;
+  slug: string;
+  nameTranslations?: string[];
+  overviewTranslations?: string[];
+  aliases?: string[];
+  country: string;
+  primaryCompanyType: number;
+  activeDate: string;
+  inactiveDate?: string;
+  companyType: TvdbCompanyType;
+  parentCompany: TvdbParentCompany;
+  tagOptions?: string[];
+}
+
+interface TvdbType {
+  id: number;
+  name: string;
+  type: string;
+  alternateName?: string;
+}
+
+interface TvdbArtwork {
+  id: number;
+  image: string;
+  thumbnail: string;
+  language: string;
+  type: number;
+  score: number;
+  width: number;
+  height: number;
+  includesText: boolean;
+}
+
+export interface TvdbEpisode {
+  id: number;
+  seriesId: number;
+  name: string;
+  aired: string;
+  runtime: number;
+  nameTranslations: string[];
+  overview?: string;
+  overviewTranslations: string[];
+  image: string;
+  imageType: number;
+  isMovie: number;
+  seasons?: string[];
+  number: number;
+  absoluteNumber: number;
+  seasonNumber: number;
+  lastUpdated: string;
+  finaleType?: string;
+  year: string;
+}
+
+export interface TvdbSeasonDetails {
+  id: number;
+  seriesId: number;
+  type: TvdbType;
+  number: number;
+  nameTranslations: string[];
+  overviewTranslations: string[];
+  image: string;
+  imageType: number;
+  companies: {
+    studio: TvdbCompany[];
+    network: TvdbCompany[];
+    production: TvdbCompany[];
+    distributor: TvdbCompany[];
+    special_effects: TvdbCompany[];
+  };
+  lastUpdated: string;
+  year: string;
+  episodes: TvdbEpisode[];
+  trailers: string[];
+  artwork: TvdbArtwork[];
+  tagOptions?: string[];
+  firstAired: string;
+}
+
+export interface TvdbEpisodeTranslation {
+  name: string;
+  overview: string;
+  language: string;
+}

server/lib/cache.ts

@@ -9,7 +9,8 @@ export type AvailableCacheIds =
   | 'github'
   | 'plexguid'
   | 'plextv'
-  | 'plexwatchlist';
+  | 'plexwatchlist'
+  | 'tvdb';
 
 const DEFAULT_TTL = 300;
 const DEFAULT_CHECK_PERIOD = 120;
@@ -70,6 +71,10 @@ class CacheManager {
       checkPeriod: 60,
     }),
     plexwatchlist: new Cache('plexwatchlist', 'Plex Watchlist'),
+    tvdb: new Cache('tvdb', 'The TVDB API', {
+      stdTtl: 21600,
+      checkPeriod: 60 * 30,
+    }),
   };
 
   public getCache(id: AvailableCacheIds): Cache {

server/lib/scanners/jellyfin/index.ts

@@ -1,7 +1,12 @@
 import type { JellyfinLibraryItem } from '@server/api/jellyfin';
 import JellyfinAPI from '@server/api/jellyfin';
+import { getMetadataProvider } from '@server/api/metadata';
 import TheMovieDb from '@server/api/themoviedb';
-import type { TmdbTvDetails } from '@server/api/themoviedb/interfaces';
+import { ANIME_KEYWORD_ID } from '@server/api/themoviedb/constants';
+import type {
+  TmdbKeyword,
+  TmdbTvDetails,
+} from '@server/api/themoviedb/interfaces';
 import { MediaStatus, MediaType } from '@server/constants/media';
 import { MediaServerType } from '@server/constants/server';
 import { getRepository } from '@server/datasource';
@@ -43,6 +48,7 @@ class JellyfinScanner {
 
   constructor({ isRecentOnly }: { isRecentOnly?: boolean } = {}) {
     this.tmdb = new TheMovieDb();
+
     this.isRecentOnly = isRecentOnly ?? false;
   }
 
@@ -192,6 +198,42 @@ class JellyfinScanner {
     }
   }
 
+  private async getTvShow({
+    tmdbId,
+    tvdbId,
+  }: {
+    tmdbId?: number;
+    tvdbId?: number;
+  }): Promise<TmdbTvDetails> {
+    let tvShow;
+
+    if (tmdbId) {
+      tvShow = await this.tmdb.getTvShow({
+        tvId: Number(tmdbId),
+      });
+    } else if (tvdbId) {
+      tvShow = await this.tmdb.getShowByTvdbId({
+        tvdbId: Number(tvdbId),
+      });
+    } else {
+      throw new Error('No ID provided');
+    }
+
+    const metadataProvider = tvShow.keywords.results.some(
+      (keyword: TmdbKeyword) => keyword.id === ANIME_KEYWORD_ID
+    )
+      ? await getMetadataProvider('anime')
+      : await getMetadataProvider('tv');
+
+    if (!(metadataProvider instanceof TheMovieDb)) {
+      tvShow = await metadataProvider.getTvShow({
+        tvId: Number(tmdbId),
+      });
+    }
+
+    return tvShow;
+  }
+
   private async processShow(jellyfinitem: JellyfinLibraryItem) {
     const mediaRepository = getRepository(Media);
 
@@ -212,8 +254,8 @@ class JellyfinScanner {
 
       if (metadata.ProviderIds.Tmdb) {
         try {
-          tvShow = await this.tmdb.getTvShow({
-            tvId: Number(metadata.ProviderIds.Tmdb),
+          tvShow = await this.getTvShow({
+            tmdbId: Number(metadata.ProviderIds.Tmdb),
           });
         } catch {
           this.log('Unable to find TMDb ID for this title.', 'debug', {
@@ -223,7 +265,7 @@ class JellyfinScanner {
       }
       if (!tvShow && metadata.ProviderIds.Tvdb) {
         try {
-          tvShow = await this.tmdb.getShowByTvdbId({
+          tvShow = await this.getTvShow({
             tvdbId: Number(metadata.ProviderIds.Tvdb),
           });
         } catch {

server/lib/scanners/plex/index.ts

@@ -1,7 +1,13 @@
 import animeList from '@server/api/animelist';
+import { getMetadataProvider } from '@server/api/metadata';
 import type { PlexLibraryItem, PlexMetadata } from '@server/api/plexapi';
 import PlexAPI from '@server/api/plexapi';
-import type { TmdbTvDetails } from '@server/api/themoviedb/interfaces';
+import TheMovieDb from '@server/api/themoviedb';
+import { ANIME_KEYWORD_ID } from '@server/api/themoviedb/constants';
+import type {
+  TmdbKeyword,
+  TmdbTvDetails,
+} from '@server/api/themoviedb/interfaces';
 import { getRepository } from '@server/datasource';
 import { User } from '@server/entity/User';
 import cacheManager from '@server/lib/cache';
@@ -249,6 +255,42 @@ class PlexScanner
     });
   }
 
+  private async getTvShow({
+    tmdbId,
+    tvdbId,
+  }: {
+    tmdbId?: number;
+    tvdbId?: number;
+  }): Promise<TmdbTvDetails> {
+    let tvShow;
+
+    if (tmdbId) {
+      tvShow = await this.tmdb.getTvShow({
+        tvId: Number(tmdbId),
+      });
+    } else if (tvdbId) {
+      tvShow = await this.tmdb.getShowByTvdbId({
+        tvdbId: Number(tvdbId),
+      });
+    } else {
+      throw new Error('No ID provided');
+    }
+
+    const metadataProvider = tvShow.keywords.results.some(
+      (keyword: TmdbKeyword) => keyword.id === ANIME_KEYWORD_ID
+    )
+      ? await getMetadataProvider('anime')
+      : await getMetadataProvider('tv');
+
+    if (!(metadataProvider instanceof TheMovieDb)) {
+      tvShow = await metadataProvider.getTvShow({
+        tvId: Number(tmdbId),
+      });
+    }
+
+    return tvShow;
+  }
+
   private async processPlexShow(plexitem: PlexLibraryItem) {
     const ratingKey =
       plexitem.grandparentRatingKey ??
@@ -273,7 +315,9 @@ class PlexScanner
       await this.processHamaSpecials(metadata, mediaIds.tvdbId);
     }
 
-    const tvShow = await this.tmdb.getTvShow({ tvId: mediaIds.tmdbId });
+    const tvShow = await this.getTvShow({
+      tmdbId: mediaIds.tmdbId,
+    });
 
     const seasons = tvShow.seasons;
     const processableSeasons: ProcessableSeason[] = [];

server/lib/settings/index.ts

@@ -100,6 +100,27 @@ interface Quota {
   quotaDays?: number;
 }
 
+export enum MetadataProviderType {
+  TMDB = 'tmdb',
+  TVDB = 'tvdb',
+}
+
+export interface MetadataSettings {
+  tv: MetadataProviderType;
+  anime: MetadataProviderType;
+}
+
+export interface ProxySettings {
+  enabled: boolean;
+  hostname: string;
+  port: number;
+  useSsl: boolean;
+  user: string;
+  password: string;
+  bypassFilter: string;
+  bypassLocalAddresses: boolean;
+}
+
 export interface MainSettings {
   apiKey: string;
   applicationTitle: string;
@@ -339,6 +360,7 @@ export interface AllSettings {
   notifications: NotificationSettings;
   jobs: Record<JobId, JobSettings>;
   network: NetworkSettings;
+  metadataSettings: MetadataSettings;
 }
 
 const SETTINGS_PATH = process.env.CONFIG_DIRECTORY
@@ -399,6 +421,10 @@ class Settings {
         apiKey: '',
       },
       tautulli: {},
+      metadataSettings: {
+        tv: MetadataProviderType.TMDB,
+        anime: MetadataProviderType.TMDB,
+      },
       radarr: [],
       sonarr: [],
       public: {
@@ -593,6 +619,14 @@ class Settings {
     this.data.tautulli = data;
   }
 
+  get metadataSettings(): MetadataSettings {
+    return this.data.metadataSettings;
+  }
+
+  set metadataSettings(data: MetadataSettings) {
+    this.data.metadataSettings = data;
+  }
+
   get radarr(): RadarrSettings[] {
     return this.data.radarr;
   }

server/models/Tv.ts

@@ -124,7 +124,7 @@ const mapEpisodeResult = (episode: TmdbTvEpisodeResult): Episode => ({
   seasonNumber: episode.season_number,
   showId: episode.show_id,
   voteAverage: episode.vote_average,
-  voteCount: episode.vote_cuont,
+  voteCount: episode.vote_count,
   stillPath: episode.still_path,
 });
 

server/routes/settings/index.ts

@@ -39,6 +39,7 @@ import { rescheduleJob } from 'node-schedule';
 import path from 'path';
 import semver from 'semver';
 import { URL } from 'url';
+import metadataRoutes from './metadata';
 import notificationRoutes from './notifications';
 import radarrRoutes from './radarr';
 import sonarrRoutes from './sonarr';
@@ -49,6 +50,7 @@ settingsRoutes.use('/notifications', notificationRoutes);
 settingsRoutes.use('/radarr', radarrRoutes);
 settingsRoutes.use('/sonarr', sonarrRoutes);
 settingsRoutes.use('/discover', discoverSettingRoutes);
+settingsRoutes.use('/metadatas', metadataRoutes);
 
 const filteredMainSettings = (
   user: User,

server/routes/settings/metadata.ts

@@ -0,0 +1,153 @@
+import TheMovieDb from '@server/api/themoviedb';
+import Tvdb from '@server/api/tvdb';
+import {
+  getSettings,
+  MetadataProviderType,
+  type MetadataSettings,
+} from '@server/lib/settings';
+import logger from '@server/logger';
+import { Router } from 'express';
+
+function getTestResultString(testValue: number): string {
+  if (testValue === -1) return 'not tested';
+  if (testValue === 0) return 'failed';
+  return 'ok';
+}
+
+const metadataRoutes = Router();
+
+metadataRoutes.get('/', (_req, res) => {
+  const settings = getSettings();
+  res.status(200).json({
+    tv: settings.metadataSettings.tv,
+    anime: settings.metadataSettings.anime,
+  });
+});
+
+metadataRoutes.put('/', async (req, res) => {
+  const settings = getSettings();
+  const body = req.body as MetadataSettings;
+
+  let tvdbTest = -1;
+  let tmdbTest = -1;
+
+  try {
+    if (
+      body.tv === MetadataProviderType.TVDB ||
+      body.anime === MetadataProviderType.TVDB
+    ) {
+      tvdbTest = 0;
+      const tvdb = await Tvdb.getInstance();
+      await tvdb.test();
+      tvdbTest = 1;
+    }
+  } catch (e) {
+    logger.error('Failed to test metadata provider', {
+      label: 'Metadata',
+      message: e.message,
+    });
+  }
+
+  try {
+    if (
+      body.tv === MetadataProviderType.TMDB ||
+      body.anime === MetadataProviderType.TMDB
+    ) {
+      tmdbTest = 0;
+      const tmdb = new TheMovieDb();
+      await tmdb.getTvShow({ tvId: 1054 });
+      tmdbTest = 1;
+    }
+  } catch (e) {
+    logger.error('Failed to test metadata provider', {
+      label: 'MetadataProvider',
+      message: e.message,
+    });
+  }
+
+  // If a test failed, return the test results
+  if (tvdbTest === 0 || tmdbTest === 0) {
+    return res.status(500).json({
+      success: false,
+      tests: {
+        tvdb: getTestResultString(tvdbTest),
+        tmdb: getTestResultString(tmdbTest),
+      },
+    });
+  }
+
+  settings.metadataSettings = {
+    tv: body.tv,
+    anime: body.anime,
+  };
+  await settings.save();
+
+  res.status(200).json({
+    success: true,
+    tv: body.tv,
+    anime: body.anime,
+    tests: {
+      tvdb: getTestResultString(tvdbTest),
+      tmdb: getTestResultString(tmdbTest),
+    },
+  });
+});
+
+metadataRoutes.post('/test', async (req, res) => {
+  let tvdbTest = -1;
+  let tmdbTest = -1;
+
+  try {
+    const body = req.body as { tmdb: boolean; tvdb: boolean };
+
+    try {
+      if (body.tmdb) {
+        tmdbTest = 0;
+        const tmdb = new TheMovieDb();
+        await tmdb.getTvShow({ tvId: 1054 });
+        tmdbTest = 1;
+      }
+    } catch (e) {
+      logger.error('Failed to test metadata provider', {
+        label: 'MetadataProvider',
+        message: e.message,
+      });
+    }
+
+    try {
+      if (body.tvdb) {
+        tvdbTest = 0;
+        const tvdb = await Tvdb.getInstance();
+        await tvdb.test();
+        tvdbTest = 1;
+      }
+    } catch (e) {
+      logger.error('Failed to test metadata provider', {
+        label: 'MetadataProvider',
+        message: e.message,
+      });
+    }
+
+    const success = !(tvdbTest === 0 || tmdbTest === 0);
+    const statusCode = success ? 200 : 500;
+
+    return res.status(statusCode).json({
+      success: success,
+      tests: {
+        tmdb: getTestResultString(tmdbTest),
+        tvdb: getTestResultString(tvdbTest),
+      },
+    });
+  } catch (e) {
+    return res.status(500).json({
+      success: false,
+      tests: {
+        tmdb: getTestResultString(tmdbTest),
+        tvdb: getTestResultString(tvdbTest),
+      },
+      error: e.message,
+    });
+  }
+});
+
+export default metadataRoutes;

server/routes/tv.ts

@@ -1,5 +1,8 @@
+import { getMetadataProvider } from '@server/api/metadata';
 import RottenTomatoes from '@server/api/rating/rottentomatoes';
 import TheMovieDb from '@server/api/themoviedb';
+import { ANIME_KEYWORD_ID } from '@server/api/themoviedb/constants';
+import type { TmdbKeyword } from '@server/api/themoviedb/interfaces';
 import { MediaType } from '@server/constants/media';
 import { getRepository } from '@server/datasource';
 import Media from '@server/entity/Media';
@@ -13,12 +16,20 @@ const tvRoutes = Router();
 
 tvRoutes.get('/:id', async (req, res, next) => {
   const tmdb = new TheMovieDb();
+
   try {
-    const tv = await tmdb.getTvShow({
+    const tmdbTv = await tmdb.getTvShow({
+      tvId: Number(req.params.id),
+    });
+    const metadataProvider = tmdbTv.keywords.results.some(
+      (keyword: TmdbKeyword) => keyword.id === ANIME_KEYWORD_ID
+    )
+      ? await getMetadataProvider('anime')
+      : await getMetadataProvider('tv');
+    const tv = await metadataProvider.getTvShow({
       tvId: Number(req.params.id),
       language: (req.query.language as string) ?? req.locale,
     });
-
     const media = await Media.getMedia(tv.id, MediaType.TV);
 
     const onUserWatchlist = await getRepository(Watchlist).exist({
@@ -34,7 +45,9 @@ tvRoutes.get('/:id', async (req, res, next) => {
 
     // TMDB issue where it doesnt fallback to English when no overview is available in requested locale.
     if (!data.overview) {
-      const tvEnglish = await tmdb.getTvShow({ tvId: Number(req.params.id) });
+      const tvEnglish = await metadataProvider.getTvShow({
+        tvId: Number(req.params.id),
+      });
       data.overview = tvEnglish.overview;
     }
 
@@ -53,13 +66,20 @@ tvRoutes.get('/:id', async (req, res, next) => {
 });
 
 tvRoutes.get('/:id/season/:seasonNumber', async (req, res, next) => {
-  const tmdb = new TheMovieDb();
-
   try {
-    const season = await tmdb.getTvSeason({
+    const tmdb = new TheMovieDb();
+    const tmdbTv = await tmdb.getTvShow({
+      tvId: Number(req.params.id),
+    });
+    const metadataProvider = tmdbTv.keywords.results.some(
+      (keyword: TmdbKeyword) => keyword.id === ANIME_KEYWORD_ID
+    )
+      ? await getMetadataProvider('anime')
+      : await getMetadataProvider('tv');
+
+    const season = await metadataProvider.getTvSeason({
       tvId: Number(req.params.id),
       seasonNumber: Number(req.params.seasonNumber),
-      language: (req.query.language as string) ?? req.locale,
     });
 
     return res.status(200).json(mapSeasonWithEpisodes(season));