1
0
Fork 0
mirror of https://github.com/sussy-code/smov.git synced 2025-01-01 16:37:39 +01:00

Media Item Error Fixed

This commit is contained in:
Abdullah Khan 2024-06-19 01:23:52 -04:00 committed by GitHub
parent d607f01238
commit 42d12cfb96
No known key found for this signature in database
GPG key ID: B5690EEEBB952194

View file

@ -1,289 +1,309 @@
export enum TMDBContentTypes { import slugify from "slugify";
MOVIE = "movie",
TV = "tv", import { conf } from "@/setup/config";
import { MediaItem } from "@/utils/mediaTypes";
import { MWMediaMeta, MWMediaType, MWSeasonMeta } from "./types/mw";
import {
ExternalIdMovieSearchResult,
TMDBContentTypes,
TMDBEpisodeShort,
TMDBMediaResult,
TMDBMovieData,
TMDBMovieSearchResult,
TMDBSearchResult,
TMDBSeason,
TMDBSeasonMetaResult,
TMDBShowData,
TMDBShowSearchResult,
} from "./types/tmdb";
import { mwFetch } from "../helpers/fetch";
export function mediaTypeToTMDB(type: MWMediaType): TMDBContentTypes {
if (type === MWMediaType.MOVIE) return TMDBContentTypes.MOVIE;
if (type === MWMediaType.SERIES) return TMDBContentTypes.TV;
throw new Error("unsupported type");
} }
export type TMDBSeasonShort = { export function mediaItemTypeToMediaType(type: MediaItem["type"]): MWMediaType {
title: string; if (type === "movie") return MWMediaType.MOVIE;
id: number; if (type === "show") return MWMediaType.SERIES;
season_number: number; throw new Error("unsupported type");
}; }
export type TMDBEpisodeShort = { export function TMDBMediaToMediaType(type: TMDBContentTypes): MWMediaType {
title: string; if (type === TMDBContentTypes.MOVIE) return MWMediaType.MOVIE;
id: number; if (type === TMDBContentTypes.TV) return MWMediaType.SERIES;
episode_number: number; throw new Error("unsupported type");
air_date: string; }
};
export type TMDBMediaResult = { export function TMDBMediaToMediaItemType(
title: string; type: TMDBContentTypes,
poster?: string; ): MediaItem["type"] {
id: number; if (type === TMDBContentTypes.MOVIE) return "movie";
original_release_date?: Date; if (type === TMDBContentTypes.TV) return "show";
object_type: TMDBContentTypes; throw new Error("unsupported type");
seasons?: TMDBSeasonShort[]; }
};
export type TMDBSeasonMetaResult = { export function formatTMDBMeta(
title: string; media: TMDBMediaResult,
id: string; season?: TMDBSeasonMetaResult,
season_number: number; ): MWMediaMeta {
episodes: TMDBEpisodeShort[]; const type = TMDBMediaToMediaType(media.object_type);
}; let seasons: undefined | MWSeasonMeta[];
if (type === MWMediaType.SERIES) {
seasons = media.seasons
?.sort((a, b) => a.season_number - b.season_number)
.map(
(v): MWSeasonMeta => ({
title: v.title,
id: v.id.toString(),
number: v.season_number,
}),
);
}
export interface TMDBShowData { return {
adult: boolean; title: media.title,
backdrop_path: string | null; id: media.id.toString(),
created_by: { year: media.original_release_date?.getFullYear()?.toString(),
id: number; poster: media.poster,
credit_id: string; type,
name: string; seasons: seasons as any,
gender: number; seasonData: season
profile_path: string | null; ? {
}[]; id: season.id.toString(),
episode_run_time: number[]; number: season.season_number,
first_air_date: string; title: season.title,
genres: { episodes: season.episodes
id: number; .sort((a, b) => a.episode_number - b.episode_number)
name: string; .map((v) => ({
}[]; id: v.id.toString(),
homepage: string; number: v.episode_number,
id: number; title: v.title,
in_production: boolean; air_date: v.air_date,
languages: string[]; })),
last_air_date: string; }
last_episode_to_air: { : (undefined as any),
id: number;
name: string;
overview: string;
vote_average: number;
vote_count: number;
air_date: string;
episode_number: number;
production_code: string;
runtime: number | null;
season_number: number;
show_id: number;
still_path: string | null;
} | null;
name: string;
next_episode_to_air: {
id: number;
name: string;
overview: string;
vote_average: number;
vote_count: number;
air_date: string;
episode_number: number;
production_code: string;
runtime: number | null;
season_number: number;
show_id: number;
still_path: string | null;
} | null;
networks: {
id: number;
logo_path: string;
name: string;
origin_country: string;
}[];
number_of_episodes: number;
number_of_seasons: number;
origin_country: string[];
original_language: string;
original_name: string;
overview: string;
popularity: number;
poster_path: string | null;
production_companies: {
id: number;
logo_path: string | null;
name: string;
origin_country: string;
}[];
production_countries: {
iso_3166_1: string;
name: string;
}[];
seasons: {
air_date: string;
episode_count: number;
id: number;
name: string;
overview: string;
poster_path: string | null;
season_number: number;
}[];
spoken_languages: {
english_name: string;
iso_639_1: string;
name: string;
}[];
status: string;
tagline: string;
type: string;
vote_average: number;
vote_count: number;
external_ids: {
imdb_id: string | null;
}; };
} }
export interface TMDBMovieData { export function formatTMDBMetaToMediaItem(media: TMDBMediaResult): MediaItem {
adult: boolean; const type = TMDBMediaToMediaItemType(media.object_type);
backdrop_path: string | null;
belongs_to_collection: { // Define the basic structure of MediaItem
id: number; const mediaItem: MediaItem = {
name: string; title: media.title,
poster_path: string | null; id: media.id.toString(),
backdrop_path: string | null; year: media.original_release_date?.getFullYear() ?? 0,
} | null; release_date: media.original_release_date,
budget: number; poster: media.poster,
genres: { type,
id: number; seasons: undefined,
name: string; };
}[];
homepage: string | null; // If it's a TV show, include the seasons information
id: number; if (type === "show") {
imdb_id: string | null; const seasons = media.seasons?.map((season) => ({
original_language: string; title: season.title,
original_title: string; id: season.id.toString(),
overview: string | null; number: season.season_number,
popularity: number; }));
poster_path: string | null; mediaItem.seasons = seasons as MWSeasonMeta[];
production_companies: { }
id: number;
logo_path: string | null; return mediaItem;
name: string; }
origin_country: string;
}[]; export function TMDBIdToUrlId(
production_countries: { type: MWMediaType,
iso_3166_1: string; tmdbId: string,
name: string; title: string,
}[]; ) {
release_date: string; return [
revenue: number; "tmdb",
runtime: number | null; mediaTypeToTMDB(type),
spoken_languages: { tmdbId,
english_name: string; slugify(title, { lower: true, strict: true }),
iso_639_1: string; ].join("-");
name: string; }
}[];
status: string; export function TMDBMediaToId(media: MWMediaMeta): string {
tagline: string | null; return TMDBIdToUrlId(media.type, media.id, media.title);
title: string; }
video: boolean;
vote_average: number; export function mediaItemToId(media: MediaItem): string {
vote_count: number; return TMDBIdToUrlId(
external_ids: { mediaItemTypeToMediaType(media.type),
imdb_id: string | null; media.id,
media.title,
);
}
export function decodeTMDBId(
paramId: string,
): { id: string; type: MWMediaType } | null {
const [prefix, type, id] = paramId.split("-", 3);
if (prefix !== "tmdb") return null;
let mediaType;
try {
mediaType = TMDBMediaToMediaType(type as TMDBContentTypes);
} catch {
return null;
}
return {
type: mediaType,
id,
}; };
} }
export interface TMDBEpisodeResult { const tmdbBaseUrl1 = "https://api.themoviedb.org/3";
season: number; const tmdbBaseUrl2 = "https://api.tmdb.org/3";
number: number;
title: string; const apiKey = conf().TMDB_READ_API_KEY;
ids: {
trakt: number; const tmdbHeaders = {
tvdb: number; accept: "application/json",
imdb: string; Authorization: `Bearer ${apiKey}`,
tmdb: number; };
function abortOnTimeout(timeout: number): AbortSignal {
const controller = new AbortController();
setTimeout(() => controller.abort(), timeout);
return controller.signal;
}
export async function get<T>(url: string, params?: object): Promise<T> {
if (!apiKey) throw new Error("TMDB API key not set");
try {
return await mwFetch<T>(encodeURI(url), {
headers: tmdbHeaders,
baseURL: tmdbBaseUrl1,
params: {
...params,
},
signal: abortOnTimeout(5000),
});
} catch (err) {
return mwFetch<T>(encodeURI(url), {
headers: tmdbHeaders,
baseURL: tmdbBaseUrl2,
params: {
...params,
},
signal: abortOnTimeout(30000),
});
}
}
export async function multiSearch(
query: string,
): Promise<(TMDBMovieSearchResult | TMDBShowSearchResult)[]> {
const data = await get<TMDBSearchResult>("search/multi", {
query,
include_adult: false,
language: "en-US",
page: 1,
});
// filter out results that aren't movies or shows
const results = data.results.filter(
(r) =>
r.media_type === TMDBContentTypes.MOVIE ||
r.media_type === TMDBContentTypes.TV,
);
return results;
}
export async function generateQuickSearchMediaUrl(
query: string,
): Promise<string | undefined> {
const data = await multiSearch(query);
if (data.length === 0) return undefined;
const result = data[0];
const title =
result.media_type === TMDBContentTypes.MOVIE ? result.title : result.name;
return `/media/${TMDBIdToUrlId(
TMDBMediaToMediaType(result.media_type),
result.id.toString(),
title,
)}`;
}
// Conditional type which for inferring the return type based on the content type
type MediaDetailReturn<T extends TMDBContentTypes> =
T extends TMDBContentTypes.MOVIE
? TMDBMovieData
: T extends TMDBContentTypes.TV
? TMDBShowData
: never;
export function getMediaDetails<
T extends TMDBContentTypes,
TReturn = MediaDetailReturn<T>,
>(id: string, type: T): Promise<TReturn> {
if (type === TMDBContentTypes.MOVIE) {
return get<TReturn>(`/movie/${id}`, { append_to_response: "external_ids" });
}
if (type === TMDBContentTypes.TV) {
return get<TReturn>(`/tv/${id}`, { append_to_response: "external_ids" });
}
throw new Error("Invalid media type");
}
export function getMediaPoster(posterPath: string | null): string | undefined {
if (posterPath) return `https://image.tmdb.org/t/p/w342/${posterPath}`;
}
export async function getEpisodes(
id: string,
season: number,
): Promise<TMDBEpisodeShort[]> {
const data = await get<TMDBSeason>(`/tv/${id}/season/${season}`);
return data.episodes.map((e) => ({
id: e.id,
episode_number: e.episode_number,
title: e.name,
air_date: e.air_date,
}));
}
export async function getMovieFromExternalId(
imdbId: string,
): Promise<string | undefined> {
const data = await get<ExternalIdMovieSearchResult>(`/find/${imdbId}`, {
external_source: "imdb_id",
});
const movie = data.movie_results[0];
if (!movie) return undefined;
return movie.id.toString();
}
export function formatTMDBSearchResult(
result: TMDBMovieSearchResult | TMDBShowSearchResult,
mediatype: TMDBContentTypes,
): TMDBMediaResult {
const type = TMDBMediaToMediaType(mediatype);
if (type === MWMediaType.SERIES) {
const show = result as TMDBShowSearchResult;
return {
title: show.name,
poster: getMediaPoster(show.poster_path),
id: show.id,
original_release_date: new Date(show.first_air_date),
object_type: mediatype,
};
}
const movie = result as TMDBMovieSearchResult;
return {
title: movie.title,
poster: getMediaPoster(movie.poster_path),
id: movie.id,
original_release_date: new Date(movie.release_date),
object_type: mediatype,
}; };
} }
export interface TMDBEpisode {
air_date: string;
episode_number: number;
id: number;
name: string;
overview: string;
production_code: string;
runtime: number;
season_number: number;
show_id: number;
still_path: string | null;
vote_average: number;
vote_count: number;
crew: any[];
guest_stars: any[];
}
export interface TMDBSeason {
_id: string;
air_date: string;
episodes: TMDBEpisode[];
name: string;
overview: string;
id: number;
poster_path: string | null;
season_number: number;
}
export interface ExternalIdMovieSearchResult {
movie_results: {
adult: boolean;
backdrop_path: string;
id: number;
title: string;
original_language: string;
original_title: string;
overview: string;
poster_path: string;
media_type: string;
genre_ids: number[];
popularity: number;
release_date: string;
video: boolean;
vote_average: number;
vote_count: number;
}[];
person_results: any[];
tv_results: any[];
tv_episode_results: any[];
tv_season_results: any[];
}
export interface TMDBMovieSearchResult {
adult: boolean;
backdrop_path: string;
id: number;
title: string;
original_language: string;
original_title: string;
overview: string;
poster_path: string;
media_type: TMDBContentTypes.MOVIE;
genre_ids: number[];
popularity: number;
release_date: string;
video: boolean;
vote_average: number;
vote_count: number;
}
export interface TMDBShowSearchResult {
adult: boolean;
backdrop_path: string;
id: number;
name: string;
original_language: string;
original_name: string;
overview: string;
poster_path: string;
media_type: TMDBContentTypes.TV;
genre_ids: number[];
popularity: number;
first_air_date: string;
vote_average: number;
vote_count: number;
origin_country: string[];
}
export interface TMDBSearchResult {
page: number;
results: (TMDBMovieSearchResult | TMDBShowSearchResult)[];
total_pages: number;
total_results: number;
}