channels-seerr/server/api/channelsdvr.ts

/* eslint-disable @typescript-eslint/no-explicit-any */
import ExternalAPI from '@server/api/externalapi';
import { getAppVersion } from '@server/utils/appVersion';
import logger from '@server/logger';

export interface ChannelsDVRShow {
  id: string;
  name: string;
  summary: string;
  image_url: string;
  release_year: number;
  release_date: string;
  genres: string[];
  categories: string[];
  labels: string[];
  cast: string[];
  episode_count: number;
  number_unwatched: number;
  favorited: boolean;
  last_watched_at?: number;
  last_recorded_at?: number;
  created_at: number;
  updated_at: number;
}

export interface ChannelsDVRMovie {
  id: string;
  program_id: string;
  path: string;
  channel: string;
  title: string;
  summary: string;
  full_summary: string;
  content_rating: string;
  image_url: string;
  thumbnail_url: string;
  duration: number;
  playback_time: number;
  release_year: number;
  release_date: string;
  genres: string[];
  tags: string[];
  labels: string[];
  categories: string[];
  cast: string[];
  directors: string[];
  watched: boolean;
  favorited: boolean;
  delayed: boolean;
  cancelled: boolean;
  corrupted: boolean;
  completed: boolean;
  processed: boolean;
  verified: boolean;
  last_watched_at?: number;
  created_at: number;
  updated_at: number;
}

export interface ChannelsDVREpisode {
  id: string;
  show_id: string;
  program_id: string;
  path: string;
  channel: string;
  season_number: number;
  episode_number: number;
  title: string;
  episode_title: string;
  summary: string;
  full_summary: string;
  content_rating: string;
  image_url: string;
  thumbnail_url: string;
  duration: number;
  playback_time: number;
  original_air_date: string;
  genres: string[];
  tags: string[];
  categories: string[];
  cast: string[];
  commercials: number[];
  watched: boolean;
  favorited: boolean;
  delayed: boolean;
  cancelled: boolean;
  corrupted: boolean;
  completed: boolean;
  processed: boolean;
  locked: boolean;
  verified: boolean;
  created_at: number;
  updated_at: number;
}

class ChannelsDVRAPI extends ExternalAPI {
  constructor(baseUrl: string) {
    super(
      baseUrl,
      {},
      {
        headers: {
          'User-Agent': `Seerr/${getAppVersion()}`,
        },
      }
    );
  }

  /**
   * Get all TV shows from Channels DVR library
   */
  public async getShows(): Promise<ChannelsDVRShow[]> {
    try {
      const data = await this.get<ChannelsDVRShow[]>('/api/v1/shows');
      return data;
    } catch (e) {
      logger.error('Failed to fetch shows from Channels DVR', {
        label: 'Channels DVR API',
        errorMessage: e.message,
      });
      throw new Error('Failed to fetch shows from Channels DVR');
    }
  }

  /**
   * Get a specific show by ID
   */
  public async getShow(showId: string): Promise<ChannelsDVRShow> {
    try {
      const data = await this.get<ChannelsDVRShow>(`/api/v1/shows/${showId}`);
      return data;
    } catch (e) {
      logger.error(
        `Failed to fetch show ${showId} from Channels DVR`,
        {
          label: 'Channels DVR API',
          errorMessage: e.message,
        }
      );
      throw new Error(`Failed to fetch show ${showId} from Channels DVR`);
    }
  }

  /**
   * Get all episodes for a specific show
   */
  public async getShowEpisodes(showId: string): Promise<ChannelsDVREpisode[]> {
    try {
      const data = await this.get<ChannelsDVREpisode[]>(
        `/api/v1/shows/${showId}/episodes`
      );
      return data;
    } catch (e) {
      logger.error(
        `Failed to fetch episodes for show ${showId} from Channels DVR`,
        {
          label: 'Channels DVR API',
          errorMessage: e.message,
        }
      );
      throw new Error(
        `Failed to fetch episodes for show ${showId} from Channels DVR`
      );
    }
  }

  /**
   * Get all movies from Channels DVR library
   */
  public async getMovies(): Promise<ChannelsDVRMovie[]> {
    try {
      const data = await this.get<ChannelsDVRMovie[]>('/api/v1/movies');
      return data;
    } catch (e) {
      logger.error('Failed to fetch movies from Channels DVR', {
        label: 'Channels DVR API',
        errorMessage: e.message,
      });
      throw new Error('Failed to fetch movies from Channels DVR');
    }
  }

  /**
   * Get a specific movie by ID
   */
  public async getMovie(movieId: string): Promise<ChannelsDVRMovie> {
    try {
      const data = await this.get<ChannelsDVRMovie>(`/api/v1/movies/${movieId}`);
      return data;
    } catch (e) {
      logger.error(
        `Failed to fetch movie ${movieId} from Channels DVR`,
        {
          label: 'Channels DVR API',
          errorMessage: e.message,
        }
      );
      throw new Error(`Failed to fetch movie ${movieId} from Channels DVR`);
    }
  }

  /**
   * Test connectivity to Channels DVR server
   */
  public async testConnection(): Promise<boolean> {
    try {
      // Try to fetch shows list as a connectivity test
      await this.getShows();
      return true;
    } catch (e) {
      logger.error('Channels DVR connection test failed', {
        label: 'Channels DVR API',
        errorMessage: e.message,
      });
      return false;
    }
  }
}

export default ChannelsDVRAPI;