feat: radarr/sonarr tag support (#1366)

server/api/servarr/base.ts

@@ -0,0 +1,169 @@
+import cacheManager, { AvailableCacheIds } from '../../lib/cache';
+import { DVRSettings } from '../../lib/settings';
+import ExternalAPI from '../externalapi';
+
+export interface RootFolder {
+  id: number;
+  path: string;
+  freeSpace: number;
+  totalSpace: number;
+  unmappedFolders: {
+    name: string;
+    path: string;
+  }[];
+}
+
+export interface QualityProfile {
+  id: number;
+  name: string;
+}
+
+interface QueueItem {
+  size: number;
+  title: string;
+  sizeleft: number;
+  timeleft: string;
+  estimatedCompletionTime: string;
+  status: string;
+  trackedDownloadStatus: string;
+  trackedDownloadState: string;
+  downloadId: string;
+  protocol: string;
+  downloadClient: string;
+  indexer: string;
+  id: number;
+}
+
+export interface Tag {
+  id: number;
+  label: string;
+}
+
+interface QueueResponse<QueueItemAppendT> {
+  page: number;
+  pageSize: number;
+  sortKey: string;
+  sortDirection: string;
+  totalRecords: number;
+  records: (QueueItem & QueueItemAppendT)[];
+}
+
+class ServarrBase<QueueItemAppendT> extends ExternalAPI {
+  static buildUrl(settings: DVRSettings, path?: string): string {
+    return `${settings.useSsl ? 'https' : 'http'}://${settings.hostname}:${
+      settings.port
+    }${settings.baseUrl ?? ''}${path}`;
+  }
+
+  protected apiName: string;
+
+  constructor({
+    url,
+    apiKey,
+    cacheName,
+    apiName,
+  }: {
+    url: string;
+    apiKey: string;
+    cacheName: AvailableCacheIds;
+    apiName: string;
+  }) {
+    super(
+      url,
+      {
+        apikey: apiKey,
+      },
+      {
+        nodeCache: cacheManager.getCache(cacheName).data,
+      }
+    );
+
+    this.apiName = apiName;
+  }
+
+  public getProfiles = async (): Promise<QualityProfile[]> => {
+    try {
+      const data = await this.getRolling<QualityProfile[]>(
+        `/qualityProfile`,
+        undefined,
+        3600
+      );
+
+      return data;
+    } catch (e) {
+      throw new Error(
+        `[${this.apiName}] Failed to retrieve profiles: ${e.message}`
+      );
+    }
+  };
+
+  public getRootFolders = async (): Promise<RootFolder[]> => {
+    try {
+      const data = await this.getRolling<RootFolder[]>(
+        `/rootfolder`,
+        undefined,
+        3600
+      );
+
+      return data;
+    } catch (e) {
+      throw new Error(
+        `[${this.apiName}] Failed to retrieve root folders: ${e.message}`
+      );
+    }
+  };
+
+  public getQueue = async (): Promise<(QueueItem & QueueItemAppendT)[]> => {
+    try {
+      const response = await this.axios.get<QueueResponse<QueueItemAppendT>>(
+        `/queue`
+      );
+
+      return response.data.records;
+    } catch (e) {
+      throw new Error(
+        `[${this.apiName}] Failed to retrieve queue: ${e.message}`
+      );
+    }
+  };
+
+  public getTags = async (): Promise<Tag[]> => {
+    try {
+      const response = await this.axios.get<Tag[]>(`/tag`);
+
+      return response.data;
+    } catch (e) {
+      throw new Error(
+        `[${this.apiName}] Failed to retrieve tags: ${e.message}`
+      );
+    }
+  };
+
+  public createTag = async ({ label }: { label: string }): Promise<Tag> => {
+    try {
+      const response = await this.axios.post<Tag>(`/tag`, {
+        label,
+      });
+
+      return response.data;
+    } catch (e) {
+      throw new Error(`[${this.apiName}] Failed to create tag: ${e.message}`);
+    }
+  };
+
+  protected async runCommand(
+    commandName: string,
+    options: Record<string, unknown>
+  ): Promise<void> {
+    try {
+      await this.axios.post(`/command`, {
+        name: commandName,
+        ...options,
+      });
+    } catch (e) {
+      throw new Error(`[${this.apiName}] Failed to run command: ${e.message}`);
+    }
+  }
+}
+
+export default ServarrBase;

server/api/servarr/radarr.ts

@@ -0,0 +1,188 @@
+import logger from '../../logger';
+import ServarrBase from './base';
+
+interface RadarrMovieOptions {
+  title: string;
+  qualityProfileId: number;
+  minimumAvailability: string;
+  tags: number[];
+  profileId: number;
+  year: number;
+  rootFolderPath: string;
+  tmdbId: number;
+  monitored?: boolean;
+  searchNow?: boolean;
+}
+
+export interface RadarrMovie {
+  id: number;
+  title: string;
+  isAvailable: boolean;
+  monitored: boolean;
+  tmdbId: number;
+  imdbId: string;
+  titleSlug: string;
+  folderName: string;
+  path: string;
+  profileId: number;
+  qualityProfileId: number;
+  added: string;
+  downloaded: boolean;
+  hasFile: boolean;
+}
+
+class RadarrAPI extends ServarrBase<{ movieId: number }> {
+  constructor({ url, apiKey }: { url: string; apiKey: string }) {
+    super({ url, apiKey, cacheName: 'radarr', apiName: 'Radarr' });
+  }
+
+  public getMovies = async (): Promise<RadarrMovie[]> => {
+    try {
+      const response = await this.axios.get<RadarrMovie[]>('/movie');
+
+      return response.data;
+    } catch (e) {
+      throw new Error(`[Radarr] Failed to retrieve movies: ${e.message}`);
+    }
+  };
+
+  public getMovie = async ({ id }: { id: number }): Promise<RadarrMovie> => {
+    try {
+      const response = await this.axios.get<RadarrMovie>(`/movie/${id}`);
+
+      return response.data;
+    } catch (e) {
+      throw new Error(`[Radarr] Failed to retrieve movie: ${e.message}`);
+    }
+  };
+
+  public async getMovieByTmdbId(id: number): Promise<RadarrMovie> {
+    try {
+      const response = await this.axios.get<RadarrMovie[]>('/movie/lookup', {
+        params: {
+          term: `tmdb:${id}`,
+        },
+      });
+
+      if (!response.data[0]) {
+        throw new Error('Movie not found');
+      }
+
+      return response.data[0];
+    } catch (e) {
+      logger.error('Error retrieving movie by TMDb ID', {
+        label: 'Radarr API',
+        message: e.message,
+      });
+      throw new Error('Movie not found');
+    }
+  }
+
+  public addMovie = async (
+    options: RadarrMovieOptions
+  ): Promise<RadarrMovie> => {
+    try {
+      const movie = await this.getMovieByTmdbId(options.tmdbId);
+
+      if (movie.downloaded) {
+        logger.info(
+          'Title already exists and is available. Skipping add and returning success',
+          {
+            label: 'Radarr',
+          }
+        );
+        return movie;
+      }
+
+      // movie exists in radarr but is neither downloaded nor monitored
+      if (movie.id && !movie.monitored) {
+        const response = await this.axios.put<RadarrMovie>(`/movie`, {
+          ...movie,
+          title: options.title,
+          qualityProfileId: options.qualityProfileId,
+          profileId: options.profileId,
+          titleSlug: options.tmdbId.toString(),
+          minimumAvailability: options.minimumAvailability,
+          tmdbId: options.tmdbId,
+          year: options.year,
+          tags: options.tags,
+          rootFolderPath: options.rootFolderPath,
+          monitored: options.monitored,
+          addOptions: {
+            searchForMovie: options.searchNow,
+          },
+        });
+
+        if (response.data.monitored) {
+          logger.info(
+            'Found existing title in Radarr and set it to monitored. Returning success',
+            { label: 'Radarr' }
+          );
+          logger.debug('Radarr update details', {
+            label: 'Radarr',
+            movie: response.data,
+          });
+          return response.data;
+        } else {
+          logger.error('Failed to update existing movie in Radarr', {
+            label: 'Radarr',
+            options,
+          });
+          throw new Error('Failed to update existing movie in Radarr');
+        }
+      }
+
+      if (movie.id) {
+        logger.info(
+          'Movie is already monitored in Radarr. Skipping add and returning success',
+          { label: 'Radarr' }
+        );
+        return movie;
+      }
+
+      const response = await this.axios.post<RadarrMovie>(`/movie`, {
+        title: options.title,
+        qualityProfileId: options.qualityProfileId,
+        profileId: options.profileId,
+        titleSlug: options.tmdbId.toString(),
+        minimumAvailability: options.minimumAvailability,
+        tmdbId: options.tmdbId,
+        year: options.year,
+        rootFolderPath: options.rootFolderPath,
+        monitored: options.monitored,
+        tags: options.tags,
+        addOptions: {
+          searchForMovie: options.searchNow,
+        },
+      });
+
+      if (response.data.id) {
+        logger.info('Radarr accepted request', { label: 'Radarr' });
+        logger.debug('Radarr add details', {
+          label: 'Radarr',
+          movie: response.data,
+        });
+      } else {
+        logger.error('Failed to add movie to Radarr', {
+          label: 'Radarr',
+          options,
+        });
+        throw new Error('Failed to add movie to Radarr');
+      }
+      return response.data;
+    } catch (e) {
+      logger.error(
+        'Failed to add movie to Radarr. This might happen if the movie already exists, in which case you can safely ignore this error.',
+        {
+          label: 'Radarr',
+          errorMessage: e.message,
+          options,
+          response: e?.response?.data,
+        }
+      );
+      throw new Error('Failed to add movie to Radarr');
+    }
+  };
+}
+
+export default RadarrAPI;

server/api/servarr/sonarr.ts

@@ -0,0 +1,289 @@
+import logger from '../../logger';
+import ServarrBase from './base';
+
+interface SonarrSeason {
+  seasonNumber: number;
+  monitored: boolean;
+  statistics?: {
+    previousAiring?: string;
+    episodeFileCount: number;
+    episodeCount: number;
+    totalEpisodeCount: number;
+    sizeOnDisk: number;
+    percentOfEpisodes: number;
+  };
+}
+
+export interface SonarrSeries {
+  title: string;
+  sortTitle: string;
+  seasonCount: number;
+  status: string;
+  overview: string;
+  network: string;
+  airTime: string;
+  images: {
+    coverType: string;
+    url: string;
+  }[];
+  remotePoster: string;
+  seasons: SonarrSeason[];
+  year: number;
+  path: string;
+  profileId: number;
+  languageProfileId: number;
+  seasonFolder: boolean;
+  monitored: boolean;
+  useSceneNumbering: boolean;
+  runtime: number;
+  tvdbId: number;
+  tvRageId: number;
+  tvMazeId: number;
+  firstAired: string;
+  lastInfoSync?: string;
+  seriesType: 'standard' | 'daily' | 'anime';
+  cleanTitle: string;
+  imdbId: string;
+  titleSlug: string;
+  certification: string;
+  genres: string[];
+  tags: number[];
+  added: string;
+  ratings: {
+    votes: number;
+    value: number;
+  };
+  qualityProfileId: number;
+  id?: number;
+  rootFolderPath?: string;
+  addOptions?: {
+    ignoreEpisodesWithFiles?: boolean;
+    ignoreEpisodesWithoutFiles?: boolean;
+    searchForMissingEpisodes?: boolean;
+  };
+}
+
+interface AddSeriesOptions {
+  tvdbid: number;
+  title: string;
+  profileId: number;
+  languageProfileId?: number;
+  seasons: number[];
+  seasonFolder: boolean;
+  rootFolderPath: string;
+  tags?: number[];
+  seriesType: SonarrSeries['seriesType'];
+  monitored?: boolean;
+  searchNow?: boolean;
+}
+
+export interface LanguageProfile {
+  id: number;
+  name: string;
+}
+
+class SonarrAPI extends ServarrBase<{ seriesId: number; episodeId: number }> {
+  constructor({ url, apiKey }: { url: string; apiKey: string }) {
+    super({ url, apiKey, apiName: 'Sonarr', cacheName: 'sonarr' });
+  }
+
+  public async getSeries(): Promise<SonarrSeries[]> {
+    try {
+      const response = await this.axios.get<SonarrSeries[]>('/series');
+
+      return response.data;
+    } catch (e) {
+      throw new Error(`[Sonarr] Failed to retrieve series: ${e.message}`);
+    }
+  }
+
+  public async getSeriesByTitle(title: string): Promise<SonarrSeries[]> {
+    try {
+      const response = await this.axios.get<SonarrSeries[]>('/series/lookup', {
+        params: {
+          term: title,
+        },
+      });
+
+      if (!response.data[0]) {
+        throw new Error('No series found');
+      }
+
+      return response.data;
+    } catch (e) {
+      logger.error('Error retrieving series by series title', {
+        label: 'Sonarr API',
+        message: e.message,
+      });
+      throw new Error('No series found');
+    }
+  }
+
+  public async getSeriesByTvdbId(id: number): Promise<SonarrSeries> {
+    try {
+      const response = await this.axios.get<SonarrSeries[]>('/series/lookup', {
+        params: {
+          term: `tvdb:${id}`,
+        },
+      });
+
+      if (!response.data[0]) {
+        throw new Error('Series not found');
+      }
+
+      return response.data[0];
+    } catch (e) {
+      logger.error('Error retrieving series by tvdb ID', {
+        label: 'Sonarr API',
+        message: e.message,
+      });
+      throw new Error('Series not found');
+    }
+  }
+
+  public async addSeries(options: AddSeriesOptions): Promise<SonarrSeries> {
+    try {
+      const series = await this.getSeriesByTvdbId(options.tvdbid);
+
+      // If the series already exists, we will simply just update it
+      if (series.id) {
+        series.tags = options.tags ?? series.tags;
+        series.seasons = this.buildSeasonList(options.seasons, series.seasons);
+
+        const newSeriesResponse = await this.axios.put<SonarrSeries>(
+          '/series',
+          series
+        );
+
+        if (newSeriesResponse.data.id) {
+          logger.info('Sonarr accepted request. Updated existing series', {
+            label: 'Sonarr',
+          });
+          logger.debug('Sonarr update details', {
+            label: 'Sonarr',
+            movie: newSeriesResponse.data,
+          });
+          if (options.searchNow) {
+            this.searchSeries(newSeriesResponse.data.id);
+          }
+        } else {
+          logger.error('Failed to update series in Sonarr', {
+            label: 'Sonarr',
+            options,
+          });
+          throw new Error('Failed to update series in Sonarr');
+        }
+
+        return newSeriesResponse.data;
+      }
+
+      const createdSeriesResponse = await this.axios.post<SonarrSeries>(
+        '/series',
+        {
+          tvdbId: options.tvdbid,
+          title: options.title,
+          qualityProfileId: options.profileId,
+          languageProfileId: options.languageProfileId,
+          seasons: this.buildSeasonList(
+            options.seasons,
+            series.seasons.map((season) => ({
+              seasonNumber: season.seasonNumber,
+              // We force all seasons to false if its the first request
+              monitored: false,
+            }))
+          ),
+          tags: options.tags,
+          seasonFolder: options.seasonFolder,
+          monitored: options.monitored,
+          rootFolderPath: options.rootFolderPath,
+          seriesType: options.seriesType,
+          addOptions: {
+            ignoreEpisodesWithFiles: true,
+            searchForMissingEpisodes: options.searchNow,
+          },
+        } as Partial<SonarrSeries>
+      );
+
+      if (createdSeriesResponse.data.id) {
+        logger.info('Sonarr accepted request', { label: 'Sonarr' });
+        logger.debug('Sonarr add details', {
+          label: 'Sonarr',
+          movie: createdSeriesResponse.data,
+        });
+      } else {
+        logger.error('Failed to add movie to Sonarr', {
+          label: 'Sonarr',
+          options,
+        });
+        throw new Error('Failed to add series to Sonarr');
+      }
+
+      return createdSeriesResponse.data;
+    } catch (e) {
+      logger.error('Something went wrong while adding a series to Sonarr.', {
+        label: 'Sonarr API',
+        errorMessage: e.message,
+        error: e,
+        response: e?.response?.data,
+      });
+      throw new Error('Failed to add series');
+    }
+  }
+
+  public async getLanguageProfiles(): Promise<LanguageProfile[]> {
+    try {
+      const data = await this.getRolling<LanguageProfile[]>(
+        '/languageprofile',
+        undefined,
+        3600
+      );
+
+      return data;
+    } catch (e) {
+      logger.error(
+        'Something went wrong while retrieving Sonarr language profiles.',
+        {
+          label: 'Sonarr API',
+          message: e.message,
+        }
+      );
+
+      throw new Error('Failed to get language profiles');
+    }
+  }
+
+  public async searchSeries(seriesId: number): Promise<void> {
+    logger.info('Executing series search command', {
+      label: 'Sonarr API',
+      seriesId,
+    });
+    await this.runCommand('SeriesSearch', { seriesId });
+  }
+
+  private buildSeasonList(
+    seasons: number[],
+    existingSeasons?: SonarrSeason[]
+  ): SonarrSeason[] {
+    if (existingSeasons) {
+      const newSeasons = existingSeasons.map((season) => {
+        if (seasons.includes(season.seasonNumber)) {
+          season.monitored = true;
+        }
+        return season;
+      });
+
+      return newSeasons;
+    }
+
+    const newSeasons = seasons.map(
+      (seasonNumber): SonarrSeason => ({
+        seasonNumber,
+        monitored: true,
+      })
+    );
+
+    return newSeasons;
+  }
+}
+
+export default SonarrAPI;