mirror of
https://github.com/movixcorp/MovixOpenSource.git
synced 2026-07-26 20:42:08 +00:00
851 lines
31 KiB
JavaScript
851 lines
31 KiB
JavaScript
/**
|
|
* TMDB / IMDB routes module.
|
|
* Extracted from server.js -- handles TMDB lookups, IMDB/FrenchStream data,
|
|
* and related cache management.
|
|
*
|
|
* Mounted at /api (paths below are relative to that prefix).
|
|
*/
|
|
|
|
const express = require('express');
|
|
const router = express.Router();
|
|
const axios = require('axios');
|
|
const path = require('path');
|
|
const fsp = require('fs').promises;
|
|
const { CACHE_DIR, generateCacheKey } = require('../utils/cacheManager');
|
|
const { fetchTmdbDetails, searchTmdb } = require('../utils/tmdbCache');
|
|
const {
|
|
applyCloneUrlsToPlayerLinks,
|
|
syncCloneLinksForPlayerLinks
|
|
} = require('../utils/cloneLinks');
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Dependencies injected via configure()
|
|
// ---------------------------------------------------------------------------
|
|
let TMDB_API_KEY;
|
|
let TMDB_API_URL;
|
|
let getFromCacheNoExpiration;
|
|
let saveToCache;
|
|
let shouldUpdateCacheFrenchStream;
|
|
let shouldUpdateCacheLecteurVideo;
|
|
// Coflix helpers (from coflix.js)
|
|
let searchCoflixByTitle;
|
|
let getMovieDataFromCoflix;
|
|
let getTvDataFromCoflix;
|
|
let filterEmmmmbedReaders;
|
|
|
|
// FrenchStream helpers (from frenchstream.js)
|
|
let getFrenchStreamMovie;
|
|
let getFrenchStreamSeries;
|
|
let getFrenchStreamSeriesDetails;
|
|
let extractSeriesInfo;
|
|
let mergeSeriesParts;
|
|
let cleanTvCacheData;
|
|
|
|
/**
|
|
* Inject runtime dependencies that still live in server.js or sibling modules.
|
|
*/
|
|
function configure(deps) {
|
|
if (deps.TMDB_API_KEY) TMDB_API_KEY = deps.TMDB_API_KEY;
|
|
if (deps.TMDB_API_URL) TMDB_API_URL = deps.TMDB_API_URL;
|
|
if (deps.getFromCacheNoExpiration) getFromCacheNoExpiration = deps.getFromCacheNoExpiration;
|
|
if (deps.saveToCache) saveToCache = deps.saveToCache;
|
|
if (deps.shouldUpdateCacheFrenchStream) shouldUpdateCacheFrenchStream = deps.shouldUpdateCacheFrenchStream;
|
|
if (deps.shouldUpdateCacheLecteurVideo) shouldUpdateCacheLecteurVideo = deps.shouldUpdateCacheLecteurVideo;
|
|
// Coflix
|
|
if (deps.searchCoflixByTitle) searchCoflixByTitle = deps.searchCoflixByTitle;
|
|
if (deps.getMovieDataFromCoflix) getMovieDataFromCoflix = deps.getMovieDataFromCoflix;
|
|
if (deps.getTvDataFromCoflix) getTvDataFromCoflix = deps.getTvDataFromCoflix;
|
|
if (deps.filterEmmmmbedReaders) filterEmmmmbedReaders = deps.filterEmmmmbedReaders;
|
|
|
|
// FrenchStream
|
|
if (deps.getFrenchStreamMovie) getFrenchStreamMovie = deps.getFrenchStreamMovie;
|
|
if (deps.getFrenchStreamSeries) getFrenchStreamSeries = deps.getFrenchStreamSeries;
|
|
if (deps.getFrenchStreamSeriesDetails) getFrenchStreamSeriesDetails = deps.getFrenchStreamSeriesDetails;
|
|
if (deps.extractSeriesInfo) extractSeriesInfo = deps.extractSeriesInfo;
|
|
if (deps.mergeSeriesParts) mergeSeriesParts = deps.mergeSeriesParts;
|
|
if (deps.cleanTvCacheData) cleanTvCacheData = deps.cleanTvCacheData;
|
|
}
|
|
|
|
function getCloneScope(type, id, season, episode) {
|
|
return {
|
|
mediaType: type,
|
|
tmdbId: Number(id) || 0,
|
|
seasonNumber: type === 'tv' ? parseInt(season, 10) || 0 : 0,
|
|
episodeNumber: type === 'tv' ? parseInt(episode, 10) || 0 : 0
|
|
};
|
|
}
|
|
|
|
async function applyCloneUrlsToTmdbResult(result, type, id, season, episode) {
|
|
if (!result || typeof result !== 'object') {
|
|
return result;
|
|
}
|
|
|
|
const cloneScope = getCloneScope(type, id, season, episode);
|
|
|
|
if (type === 'movie' && Array.isArray(result.player_links)) {
|
|
return {
|
|
...result,
|
|
player_links: await applyCloneUrlsToPlayerLinks({
|
|
...cloneScope,
|
|
playerLinks: result.player_links
|
|
})
|
|
};
|
|
}
|
|
|
|
if (type === 'tv' && result.current_episode && Array.isArray(result.current_episode.player_links)) {
|
|
return {
|
|
...result,
|
|
current_episode: {
|
|
...result.current_episode,
|
|
player_links: await applyCloneUrlsToPlayerLinks({
|
|
...cloneScope,
|
|
playerLinks: result.current_episode.player_links
|
|
})
|
|
}
|
|
};
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
async function syncCloneUrlsOnTmdbResult(result, type, id, season, episode) {
|
|
if (!result || typeof result !== 'object') {
|
|
return result;
|
|
}
|
|
|
|
const cloneScope = getCloneScope(type, id, season, episode);
|
|
|
|
if (type === 'movie' && Array.isArray(result.player_links)) {
|
|
return {
|
|
...result,
|
|
player_links: await syncCloneLinksForPlayerLinks({
|
|
...cloneScope,
|
|
playerLinks: result.player_links
|
|
})
|
|
};
|
|
}
|
|
|
|
if (type === 'tv' && result.current_episode && Array.isArray(result.current_episode.player_links)) {
|
|
return {
|
|
...result,
|
|
current_episode: {
|
|
...result.current_episode,
|
|
player_links: await syncCloneLinksForPlayerLinks({
|
|
...cloneScope,
|
|
playerLinks: result.current_episode.player_links
|
|
})
|
|
}
|
|
};
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// getTMDBDetails -- fetch TMDB details for a given ID and type
|
|
// ---------------------------------------------------------------------------
|
|
async function getTMDBDetails(id, type) {
|
|
try {
|
|
const data = await fetchTmdbDetails(TMDB_API_URL, TMDB_API_KEY, id, type, 'fr-FR');
|
|
if (!data) return null;
|
|
|
|
return {
|
|
id: data.id,
|
|
title: type === 'movie' ? data.title : data.name,
|
|
original_title: type === 'movie' ? data.original_title : data.original_name,
|
|
release_date: type === 'movie' ? data.release_date : data.first_air_date,
|
|
poster_path: data.poster_path,
|
|
backdrop_path: data.backdrop_path,
|
|
overview: data.overview,
|
|
vote_average: data.vote_average
|
|
};
|
|
} catch (error) {
|
|
console.error(`Erreur lors de la recuperation des details TMDB pour ${id} (${type}):`, error);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// findTvSeriesOnTMDB -- search TMDB for TV series and find the best match
|
|
// ---------------------------------------------------------------------------
|
|
async function findTvSeriesOnTMDB(title, releaseYear, overview) {
|
|
try {
|
|
// Variables pour stocker les informations de saison speciales
|
|
let seasonOffset = 0;
|
|
let isSeasonPart = false;
|
|
let originalTitle = title;
|
|
|
|
// Remove "- Saison X" from the title
|
|
let cleanTitle = title.replace(/\s*-\s*Saison\s+\d+$/i, '');
|
|
|
|
// Handle special case for series like "Les Simpson Part 2 (Saison 1 - 29) - Saison 8"
|
|
const partMatch = cleanTitle.match(/Part\s+(\d+)\s*\(Saison\s+(\d+)\s*-\s*(\d+)\)/i);
|
|
if (partMatch) {
|
|
isSeasonPart = true;
|
|
const partNumber = parseInt(partMatch[1]);
|
|
const startSeason = parseInt(partMatch[2]);
|
|
const endSeason = parseInt(partMatch[3]);
|
|
|
|
// Si c'est la partie 2+, on doit calculer le numero de saison reel
|
|
if (partNumber > 1) {
|
|
// Chercher la saison mentionnee dans le titre
|
|
const seasonMatch = title.match(/Saison\s+(\d+)$/i);
|
|
if (seasonMatch) {
|
|
// On calcule le decalage a partir des informations de saison
|
|
seasonOffset = endSeason - startSeason + 1; // Nombre total de saisons dans la partie 1
|
|
}
|
|
}
|
|
|
|
// Remove the part and season range info
|
|
cleanTitle = cleanTitle.replace(/\s*Part\s+\d+\s*\(Saison\s+\d+\s*-\s*\d+\)/i, '');
|
|
}
|
|
|
|
// Clean up any remaining parentheses
|
|
cleanTitle = cleanTitle.replace(/\([^)]*\)/g, '').trim();
|
|
|
|
// Search for the TV series on TMDB (cached via Redis)
|
|
const searchData = await searchTmdb(TMDB_API_URL, TMDB_API_KEY, 'tv', cleanTitle,
|
|
releaseYear ? { first_air_date_year: releaseYear } : {});
|
|
|
|
if (!searchData || !searchData.results || searchData.results.length === 0) {
|
|
return null;
|
|
}
|
|
|
|
// Get the first few results
|
|
const potentialMatches = searchData.results.slice(0, 5);
|
|
|
|
// Function to calculate similarity between two strings
|
|
const calculateSimilarity = (str1, str2) => {
|
|
if (!str1 || !str2) return 0;
|
|
|
|
const s1 = str1.toLowerCase();
|
|
const s2 = str2.toLowerCase();
|
|
|
|
// Calculate percentage match
|
|
let matches = 0;
|
|
const words1 = s1.split(/\s+/);
|
|
const words2 = s2.split(/\s+/);
|
|
|
|
words1.forEach(word => {
|
|
if (words2.some(w => w.includes(word) || word.includes(w))) {
|
|
matches++;
|
|
}
|
|
});
|
|
|
|
return matches / Math.max(words1.length, 1);
|
|
};
|
|
|
|
// Find the best match by comparing title, release year, and overview
|
|
let bestMatch = null;
|
|
let highestScore = 0;
|
|
|
|
for (const series of potentialMatches) {
|
|
// Calculate match score based on title similarity
|
|
const titleSimilarity = calculateSimilarity(cleanTitle, series.name);
|
|
|
|
// Get detailed info for the series to compare overviews (cached via Redis)
|
|
const seriesDetails = await fetchTmdbDetails(TMDB_API_URL, TMDB_API_KEY, series.id, 'tv', 'en-US');
|
|
if (!seriesDetails) continue;
|
|
|
|
const overviewSimilarity = overview && seriesDetails.overview
|
|
? calculateSimilarity(overview, seriesDetails.overview)
|
|
: 0;
|
|
|
|
// Year match (exact match gives bonus)
|
|
const yearMatch = releaseYear && series.first_air_date ?
|
|
(parseInt(series.first_air_date.split('-')[0]) === parseInt(releaseYear) ? 1 : 0) : 0;
|
|
|
|
// Calculate total score (weighted)
|
|
const totalScore = (titleSimilarity * 0.7) + (overviewSimilarity * 0.2) + (yearMatch * 0.1);
|
|
|
|
if (totalScore > highestScore) {
|
|
highestScore = totalScore;
|
|
bestMatch = {
|
|
...seriesDetails,
|
|
match_score: totalScore
|
|
};
|
|
}
|
|
}
|
|
|
|
// Si on a trouve une correspondance et qu'il s'agit d'une saison speciale
|
|
if (bestMatch && isSeasonPart) {
|
|
// Ajouter les informations relatives a la saison dans les donnees TMDB
|
|
bestMatch.is_season_part = true;
|
|
bestMatch.season_offset = seasonOffset;
|
|
bestMatch.original_title = originalTitle;
|
|
|
|
// Si nous avons une saison specifique dans le titre
|
|
const seasonMatch = title.match(/Saison\s+(\d+)$/i);
|
|
if (seasonMatch) {
|
|
const titleSeason = parseInt(seasonMatch[1]);
|
|
bestMatch.title_season = titleSeason;
|
|
bestMatch.actual_season = seasonOffset + titleSeason - 1;
|
|
console.log(`Serie en parties: La saison ${titleSeason} dans le titre correspond a la saison ${bestMatch.actual_season} de la serie`);
|
|
}
|
|
}
|
|
|
|
// Consider it a match if score is above threshold
|
|
return highestScore >= 0.3 ? bestMatch : null;
|
|
} catch (error) {
|
|
console.error('Error finding TV series on TMDB:', error);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
// ===========================================================================
|
|
// ROUTES (mounted at /api, so paths are relative)
|
|
// ===========================================================================
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// GET /tmdb/:type/:id -- retrieve Coflix links via TMDB ID
|
|
// ---------------------------------------------------------------------------
|
|
router.get('/tmdb/:type/:id', async (req, res) => {
|
|
const { id, type } = req.params;
|
|
|
|
// Bloquer certains IDs TMDB specifiques
|
|
if (type === 'movie' && id === '771') {
|
|
return res.status(404).json({ error: 'Not found' });
|
|
}
|
|
if (type === 'movie' && id === '1159559') {
|
|
return res.status(200).json({ message: 'Contenu non disponible' });
|
|
}
|
|
const { season, episode } = req.query;
|
|
const cacheKey = generateCacheKey(`tmdb_links_${type}_${id}_${season || ''}_${episode || ''}`);
|
|
|
|
try {
|
|
// 1. Verifier le cache sans expiration (stale-while-revalidate)
|
|
const cachedData = await getFromCacheNoExpiration(CACHE_DIR.COFLIX, cacheKey);
|
|
let dataReturned = false;
|
|
if (cachedData) {
|
|
const cachedDataWithClones = await applyCloneUrlsToTmdbResult(cachedData, type, id, season, episode);
|
|
res.json(filterEmmmmbedReaders(cachedDataWithClones));
|
|
dataReturned = true;
|
|
|
|
// Lancer la mise a jour en arriere-plan si necessaire
|
|
(async () => {
|
|
try {
|
|
const cachedCloneSync = await syncCloneUrlsOnTmdbResult(cachedDataWithClones, type, id, season, episode);
|
|
await saveToCache(CACHE_DIR.COFLIX, cacheKey, cachedCloneSync);
|
|
|
|
// Verifier si le dernier vrai refresh Coflix date de plus de 2h
|
|
const refreshedAt = cachedCloneSync._coflixRefreshedAt || 0;
|
|
const twoHours = 2 * 60 * 60 * 1000;
|
|
if (Date.now() - refreshedAt < twoHours) {
|
|
return;
|
|
}
|
|
await updateCache();
|
|
} catch (err) {
|
|
console.error("Erreur non geree dans updateCache (TMDB):", err);
|
|
}
|
|
})();
|
|
}
|
|
|
|
// 3. Fonction pour recuperer les donnees fraiches et mettre a jour le cache
|
|
const updateCache = async () => {
|
|
try {
|
|
// Verifier que le type est valide
|
|
if (type !== 'movie' && type !== 'tv') {
|
|
if (!dataReturned) {
|
|
res.status(400).json({ message: 'Type de media non valide' });
|
|
}
|
|
return;
|
|
}
|
|
|
|
// Pour les series, verifier que la saison et l'episode sont fournis pour la mise a jour
|
|
if (type === 'tv' && (!season || !episode)) {
|
|
if (!dataReturned) {
|
|
res.status(400).json({ message: 'Parametres de saison/episode manquants' });
|
|
}
|
|
return;
|
|
}
|
|
|
|
// Recuperer les details TMDB
|
|
const tmdbDetails = await getTMDBDetails(id, type);
|
|
if (!tmdbDetails) {
|
|
if (!dataReturned) {
|
|
res.status(404).json({ message: 'Contenu non trouve sur TMDB' });
|
|
}
|
|
return;
|
|
}
|
|
|
|
// Extraire l'annee de la date de sortie
|
|
const releaseYear = tmdbDetails.release_date ? parseInt(tmdbDetails.release_date.split('-')[0]) : null;
|
|
|
|
// Rechercher sur Coflix avec le titre international d'abord
|
|
let coflixResults = await searchCoflixByTitle(tmdbDetails.title, type, releaseYear);
|
|
let bestResults = coflixResults;
|
|
|
|
// Si aucun resultat trouve avec le titre principal, essayer avec le titre original
|
|
if ((!coflixResults || !coflixResults.length || (coflixResults[0] && coflixResults[0].similarity < 0.8)) && tmdbDetails.original_title && tmdbDetails.original_title !== tmdbDetails.title) {
|
|
const originalResults = await searchCoflixByTitle(tmdbDetails.original_title, type, releaseYear);
|
|
|
|
if (originalResults && originalResults.length > 0) {
|
|
if (!bestResults || !bestResults.length) {
|
|
bestResults = originalResults;
|
|
} else {
|
|
const bestSimilarity = Math.max(
|
|
bestResults[0]?.similarity || 0,
|
|
originalResults[0]?.similarity || 0
|
|
);
|
|
if (bestSimilarity === (originalResults[0]?.similarity || 0)) {
|
|
bestResults = originalResults;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Si toujours pas de bon resultat, essayer avec le titre francais localise
|
|
if ((!bestResults || !bestResults.length || (bestResults[0] && bestResults[0].similarity < 0.8))) {
|
|
try {
|
|
const frenchData = await fetchTmdbDetails(TMDB_API_URL, TMDB_API_KEY, id, type, 'fr-FR');
|
|
|
|
if (frenchData) {
|
|
const frenchTitle = type === 'movie' ? frenchData.title : frenchData.name;
|
|
if (frenchTitle && frenchTitle !== tmdbDetails.title && frenchTitle !== tmdbDetails.original_title) {
|
|
const frenchResults = await searchCoflixByTitle(frenchTitle, type, releaseYear);
|
|
|
|
if (frenchResults && frenchResults.length > 0) {
|
|
if (!bestResults || !bestResults.length) {
|
|
bestResults = frenchResults;
|
|
} else {
|
|
const bestSimilarity = Math.max(
|
|
bestResults[0]?.similarity || 0,
|
|
frenchResults[0]?.similarity || 0
|
|
);
|
|
if (bestSimilarity === (frenchResults[0]?.similarity || 0)) {
|
|
bestResults = frenchResults;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} catch (error) {
|
|
console.log(`[TMDB API] Impossible de recuperer le titre francais pour ${id}`);
|
|
}
|
|
}
|
|
|
|
// Utiliser les meilleurs resultats trouves
|
|
coflixResults = bestResults;
|
|
|
|
// Gerer le cas ou aucun resultat n'est trouve sur Coflix
|
|
const similarityThreshold = 0.8;
|
|
|
|
if (!coflixResults || !coflixResults.length || (coflixResults[0] && coflixResults[0].similarity < similarityThreshold)) {
|
|
const unavailableResult = {
|
|
message: 'Contenu non disponible',
|
|
tmdb_id: id,
|
|
tmdb_details: tmdbDetails,
|
|
_coflixRefreshedAt: Date.now(),
|
|
};
|
|
await saveToCache(CACHE_DIR.COFLIX, cacheKey, unavailableResult);
|
|
if (!dataReturned) {
|
|
res.status(200).json(filterEmmmmbedReaders(unavailableResult));
|
|
}
|
|
return;
|
|
}
|
|
|
|
// Utiliser le premier resultat trouve
|
|
const coflixUrl = coflixResults[0].url;
|
|
|
|
let result = {
|
|
tmdb_details: tmdbDetails
|
|
};
|
|
|
|
// Recuperer les donnees specifiques selon le type
|
|
if (type === 'movie') {
|
|
const movieData = await getMovieDataFromCoflix(coflixUrl);
|
|
result = {
|
|
...result,
|
|
...movieData
|
|
};
|
|
} else if (type === 'tv') {
|
|
const seasonNum = parseInt(season);
|
|
const episodeNum = parseInt(episode);
|
|
const tvData = await getTvDataFromCoflix(coflixUrl, seasonNum, episodeNum);
|
|
result = {
|
|
...result,
|
|
...tvData
|
|
};
|
|
}
|
|
|
|
result = await syncCloneUrlsOnTmdbResult(result, type, id, season, episode);
|
|
result._coflixRefreshedAt = Date.now();
|
|
|
|
// 4. Verifier si les resultats sont valides avant de sauvegarder
|
|
const isEmptyResult = (type === 'movie' && (!result.player_links || result.player_links.length === 0)) ||
|
|
(type === 'tv' && (!result.seasons || result.seasons.length === 0));
|
|
|
|
if (!isEmptyResult || !dataReturned) {
|
|
await saveToCache(CACHE_DIR.COFLIX, cacheKey, result);
|
|
}
|
|
|
|
// Si les donnees n'avaient pas ete retournees initialement, les retourner maintenant
|
|
if (!dataReturned) {
|
|
res.json(filterEmmmmbedReaders(result));
|
|
}
|
|
|
|
} catch (updateError) {
|
|
if (updateError && updateError.isAxiosError) {
|
|
const url = updateError.config && updateError.config.url ? updateError.config.url : '';
|
|
console.error(
|
|
`Erreur lors de la mise a jour du cache TMDB ${id} (${type}): [AxiosError] ${updateError.code || ''} ${updateError.message} ${url}`
|
|
);
|
|
} else {
|
|
const msg = updateError && updateError.message
|
|
? updateError.message
|
|
: (typeof updateError === 'string'
|
|
? updateError
|
|
: JSON.stringify(updateError));
|
|
console.error(`Erreur lors de la mise a jour du cache TMDB ${id} (${type}): ${msg}`);
|
|
}
|
|
if (!dataReturned) {
|
|
res.status(200).json({
|
|
message: 'Contenu non disponible en raison d\'une erreur',
|
|
tmdb_id: id
|
|
});
|
|
}
|
|
}
|
|
};
|
|
|
|
// Si pas de donnees en cache, faire la requete normale
|
|
if (!dataReturned) {
|
|
await updateCache();
|
|
}
|
|
|
|
} catch (error) {
|
|
console.error(`Erreur lors de la recuperation des liens TMDB ${id} (${type}):`, error);
|
|
if (!res.headersSent) {
|
|
res.status(200).json({
|
|
message: 'Contenu non disponible en raison d\'une erreur',
|
|
tmdb_id: id
|
|
});
|
|
}
|
|
}
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// GET /imdb/:type/:id -- IMDB / FrenchStream data route
|
|
// ---------------------------------------------------------------------------
|
|
|
|
// Cache directory for FrenchCloud data
|
|
const FRENCHCLOUD_CACHE_DIR = path.join(__dirname, '..', 'cache', 'frenchcloud');
|
|
(async () => {
|
|
try {
|
|
await fsp.access(FRENCHCLOUD_CACHE_DIR);
|
|
} catch {
|
|
await fsp.mkdir(FRENCHCLOUD_CACHE_DIR, { recursive: true });
|
|
}
|
|
})();
|
|
|
|
// Consolidated cache directory for links
|
|
const LINK_CACHE_DIR = path.join(__dirname, '..', 'cache', 'links');
|
|
(async () => {
|
|
try {
|
|
await fsp.access(LINK_CACHE_DIR);
|
|
} catch {
|
|
await fsp.mkdir(LINK_CACHE_DIR, { recursive: true });
|
|
}
|
|
})();
|
|
const CACHE_EXPIRATION_6H = 6 * 60 * 60 * 1000; // 6 hours in milliseconds
|
|
|
|
router.get('/imdb/:type/:id', async (req, res) => {
|
|
const { id, type } = req.params;
|
|
// Return 404 for specific blocked IMDB ids
|
|
const blockedImdbIds = new Set([
|
|
'tt7069210',
|
|
'tt0325980',
|
|
'tt0383574',
|
|
'tt0449088',
|
|
'tt1298650',
|
|
'tt1790809',
|
|
'tt0099785'
|
|
]);
|
|
if (blockedImdbIds.has(id)) {
|
|
return res.status(404).json({ error: 'Not found' });
|
|
}
|
|
const cacheKey = type === 'movie' ?
|
|
generateCacheKey(`imdb_movie_${id}`) :
|
|
generateCacheKey(`frenchstream_${id}`);
|
|
const cacheDir = LINK_CACHE_DIR;
|
|
|
|
try {
|
|
// 1. Check cache without expiration
|
|
const cachedData = await getFromCacheNoExpiration(cacheDir, cacheKey);
|
|
let dataReturned = false;
|
|
if (cachedData) {
|
|
const dataToSend = type === 'tv' ? cleanTvCacheData(cachedData) : cachedData;
|
|
res.json(dataToSend);
|
|
dataReturned = true;
|
|
}
|
|
|
|
// 3. Function to fetch fresh data and update cache
|
|
const updateCache = async () => {
|
|
try {
|
|
// Verifier si le cache doit etre mis a jour (pour TV uniquement)
|
|
if (type === 'tv') {
|
|
const shouldUpdate = await shouldUpdateCacheFrenchStream(cacheDir, cacheKey);
|
|
if (!shouldUpdate) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
let responseData = {};
|
|
|
|
if (type === 'movie') {
|
|
// --- Handle Movies (using FrenchStream scraping) ---
|
|
const movieData = await getFrenchStreamMovie(id);
|
|
if (movieData.error) {
|
|
responseData = { message: 'Contenu non disponible', french_stream_id: id, details: movieData.error };
|
|
} else {
|
|
responseData = {
|
|
...movieData
|
|
};
|
|
}
|
|
|
|
} else if (type === 'tv') {
|
|
// --- Handle TV Series (using FrenchStream ID and FrenchStream logic) ---
|
|
const frenchStreamId = id;
|
|
const seriesList = await getFrenchStreamSeries(frenchStreamId);
|
|
|
|
if (!seriesList || (Array.isArray(seriesList) && seriesList.length === 0)) {
|
|
responseData = { message: 'Contenu non disponible', french_stream_id: frenchStreamId };
|
|
} else if (seriesList.error) {
|
|
if (seriesList.error.includes('404')) {
|
|
responseData = { message: 'Contenu non disponible', french_stream_id: frenchStreamId };
|
|
} else {
|
|
responseData = { error: 'Failed to retrieve series list from FrenchStream', details: seriesList.error, french_stream_id: frenchStreamId };
|
|
}
|
|
} else {
|
|
const MAX_SERIES = 10;
|
|
const seriesToProcess = seriesList.slice(0, MAX_SERIES);
|
|
|
|
await Promise.all(seriesToProcess.map(async (series) => {
|
|
if (series.link) {
|
|
try {
|
|
const seriesDetails = await getFrenchStreamSeriesDetails(series.link, series.title);
|
|
if (!seriesDetails.error) {
|
|
series.seasons = seriesDetails.seasons;
|
|
series.release_date = seriesDetails.release_date;
|
|
series.summary = seriesDetails.summary;
|
|
series.tmdb_data = seriesDetails.tmdb_data;
|
|
const { baseName, partNumber } = extractSeriesInfo(series.title);
|
|
series.baseName = baseName;
|
|
series.partNumber = partNumber;
|
|
} else {
|
|
console.warn(`Could not fetch details for series: ${series.title} (${series.link}), Error: ${seriesDetails.error}`);
|
|
series.seasons = [];
|
|
}
|
|
} catch (detailsError) {
|
|
console.error(`Exception fetching details for ${series.title} (${series.link}):`, detailsError);
|
|
series.seasons = [];
|
|
}
|
|
} else {
|
|
series.seasons = [];
|
|
}
|
|
}));
|
|
|
|
// Group and Merge Series Parts
|
|
const seriesGroups = {};
|
|
seriesToProcess.forEach(series => {
|
|
if (series.baseName) {
|
|
if (!seriesGroups[series.baseName]) {
|
|
seriesGroups[series.baseName] = [];
|
|
}
|
|
seriesGroups[series.baseName].push(series);
|
|
}
|
|
});
|
|
|
|
const mergedSeriesList = [];
|
|
for (const baseName in seriesGroups) {
|
|
const merged = mergeSeriesParts(seriesGroups[baseName]);
|
|
if (merged) {
|
|
mergedSeriesList.push(merged);
|
|
}
|
|
}
|
|
|
|
// Clean the merged list for the final result
|
|
const cleanedSeries = cleanTvCacheData({ series: mergedSeriesList });
|
|
|
|
responseData = {
|
|
type: 'tv',
|
|
series: cleanedSeries.series
|
|
};
|
|
}
|
|
} else {
|
|
console.error(`Type invalide pour la mise a jour du cache: ${type}`);
|
|
return;
|
|
}
|
|
|
|
// 4. Save to cache (only if no error occurred during fetch)
|
|
if (!responseData.error) {
|
|
await saveToCache(cacheDir, cacheKey, responseData);
|
|
}
|
|
|
|
// If data was not returned initially, return it now
|
|
if (!dataReturned) {
|
|
if (responseData.error) {
|
|
const statusCode = responseData.error.includes('No series found') ? 404 : 500;
|
|
res.status(statusCode).json(responseData);
|
|
} else if (responseData.message === 'Contenu non disponible') {
|
|
res.status(200).json(responseData);
|
|
} else {
|
|
res.json(responseData);
|
|
}
|
|
}
|
|
|
|
} catch (updateError) {
|
|
console.error(`Erreur lors de la mise a jour du cache ${type} ${id}:`, updateError);
|
|
if (!dataReturned && !res.headersSent) {
|
|
if (updateError.message && updateError.message.includes('404')) {
|
|
res.status(200).json({ message: 'Contenu non disponible', french_stream_id: id });
|
|
} else {
|
|
res.status(500).json({ error: 'Erreur lors de la mise a jour du cache', details: updateError.message });
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
// Run cache update in the background
|
|
updateCache().catch(err => console.error(`Erreur non geree dans updateCache (${type} ${id}):`, err));
|
|
|
|
} catch (error) {
|
|
console.error(`Erreur initiale dans /api/imdb/${type}/${id}:`, error);
|
|
if (!res.headersSent) {
|
|
if (error.message && error.message.includes('404')) {
|
|
res.status(200).json({ message: 'Contenu non disponible', french_stream_id: id });
|
|
} else {
|
|
res.status(500).json({ error: 'Erreur serveur interne lors du traitement initial', details: error.message });
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// GET /tmdb/cache/series/:id -- clear all Coflix cache for a TMDB series
|
|
// ---------------------------------------------------------------------------
|
|
router.get('/tmdb/cache/series/:id', async (req, res) => {
|
|
const { id } = req.params;
|
|
const cacheDir = CACHE_DIR.COFLIX;
|
|
|
|
try {
|
|
await fsp.mkdir(cacheDir, { recursive: true });
|
|
const files = await fsp.readdir(cacheDir);
|
|
|
|
let removed = 0;
|
|
const removedFiles = [];
|
|
|
|
for (const file of files) {
|
|
if (!file.endsWith('.json')) continue;
|
|
const fullPath = path.join(cacheDir, file);
|
|
|
|
try {
|
|
const content = await fsp.readFile(fullPath, 'utf-8');
|
|
const data = JSON.parse(content);
|
|
|
|
const isSameId = data && String(data.tmdb_id) === String(id);
|
|
const isTvSeries = data && data.tmdb_details && (typeof data.tmdb_details.title === 'string' || typeof data.tmdb_details.original_title === 'string');
|
|
|
|
if (isSameId && isTvSeries) {
|
|
await fsp.unlink(fullPath);
|
|
removed++;
|
|
removedFiles.push(file);
|
|
}
|
|
} catch (parseError) {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
console.log(`Cache Coflix supprime pour la serie TMDB ${id}: ${removed} fichiers`);
|
|
res.json({
|
|
message: `Cache Coflix supprime pour la serie TMDB ${id}`,
|
|
removed_files: removed,
|
|
files: removedFiles
|
|
});
|
|
|
|
} catch (error) {
|
|
console.error(`Erreur lors de la suppression du cache Coflix pour la serie ${id}: ${error.message}`);
|
|
res.status(500).json({
|
|
error: 'Erreur lors de la suppression du cache Coflix',
|
|
message: error.message
|
|
});
|
|
}
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// DELETE /tmdb/cache/:type/:id -- delete specific Coflix cache entry
|
|
// ---------------------------------------------------------------------------
|
|
router.delete('/tmdb/cache/:type/:id', async (req, res) => {
|
|
const { id, type } = req.params;
|
|
const cacheKey = generateCacheKey(`tmdb_links_${type}_${id}_${req.query.season || ''}_${req.query.episode || ''}`);
|
|
const cacheFile = path.join(CACHE_DIR.COFLIX, `${cacheKey}.json`);
|
|
|
|
try {
|
|
await fsp.unlink(cacheFile);
|
|
console.log(`Cache supprime pour TMDB ${type} ${id}`);
|
|
res.json({ message: `Cache supprime pour TMDB ${type} ${id}` });
|
|
} catch (error) {
|
|
if (error.code === 'ENOENT') {
|
|
res.json({ message: `Aucun cache trouve pour TMDB ${type} ${id}` });
|
|
} else {
|
|
console.error(`Erreur lors de la suppression du cache: ${error.message}`);
|
|
res.status(500).json({ error: 'Erreur lors de la suppression du cache' });
|
|
}
|
|
}
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// GET /SenpaiStream/tv/cache/:tmdbId -- clear SenpaiStream TV cache
|
|
// ---------------------------------------------------------------------------
|
|
router.get('/SenpaiStream/tv/cache/:tmdbId', async (req, res) => {
|
|
const { tmdbId } = req.params;
|
|
const cacheDir = path.join(__dirname, '..', 'cache', 'SenpaiStream');
|
|
|
|
try {
|
|
await fsp.mkdir(cacheDir, { recursive: true });
|
|
const files = await fsp.readdir(cacheDir);
|
|
|
|
let removed = 0;
|
|
for (const file of files) {
|
|
if (!file.endsWith('.json')) continue;
|
|
const fullPath = path.join(cacheDir, file);
|
|
try {
|
|
const content = await fsp.readFile(fullPath, 'utf-8');
|
|
const data = JSON.parse(content);
|
|
const isSameId = data && String(data.tmdb_id) === String(tmdbId);
|
|
const isTvByFields = data && data.tmdb_details && (typeof data.tmdb_details.name === 'string' || typeof data.tmdb_details.original_name === 'string');
|
|
const hasEpisodeFields = typeof data?.season !== 'undefined' && typeof data?.episode !== 'undefined';
|
|
if (isSameId && (hasEpisodeFields || isTvByFields)) {
|
|
await fsp.unlink(fullPath);
|
|
removed++;
|
|
}
|
|
} catch (err) {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
return res.json({
|
|
success: true,
|
|
tmdb_id: tmdbId,
|
|
removed,
|
|
cache_dir: cacheDir,
|
|
timestamp: new Date().toISOString()
|
|
});
|
|
} catch (error) {
|
|
console.error(`[SenpaiStream TV CACHE CLEAR] Erreur: ${error.message}`);
|
|
return res.status(500).json({
|
|
success: false,
|
|
error: 'Erreur lors de la suppression du cache SenpaiStream TV',
|
|
message: error.message,
|
|
tmdb_id: tmdbId,
|
|
timestamp: new Date().toISOString()
|
|
});
|
|
}
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Exports
|
|
// ---------------------------------------------------------------------------
|
|
module.exports = router;
|
|
module.exports.configure = configure;
|
|
module.exports.getTMDBDetails = getTMDBDetails;
|
|
module.exports.findTvSeriesOnTMDB = findTvSeriesOnTMDB;
|