ci: fix pipeline, update readme and anonymize ZT references

2026-06-12 12:30:18 +02:00
commit d1bd1a9ba9
68 changed files with 10353 additions and 0 deletions
@@ -0,0 +1,135 @@
+import { ISource, SearchResult, MediaType, SelectionData, ContentLinks } from '../../src/types/source.js';
+import { CONFIG } from '../../src/utils/config.js';
+import { sourceRegistry } from '../../src/core/registry.js';
+import { fetchSearch, fetchTrending, fetchPage } from './api.js';
+import { parseListingHTML, parseContentHTML, parseOtherVersions } from './parser.js';
+
+function isSeriesIdentifier(identifier: string): boolean {
+    return /[?&]p=serie\b|telecharger-serie/i.test(identifier);
+}
+
+function normalizeTitle(title: string): string {
+    return title
+        .toLowerCase()
+        .normalize('NFD')
+        .replace(/[\u0300-\u036f]/g, '')
+        .replace(/-\s*saison\s*\d+/gi, '')
+        .replace(/\(\s*\d{4}\s*\)/g, '')
+        .replace(/[^a-z0-9]/g, '');
+}
+
+function deduplicateByTitle(results: SearchResult[]): SearchResult[] {
+    const seen = new Set<string>();
+    return results.filter(r => {
+        const key = normalizeTitle(r.title);
+        if (seen.has(key)) return false;
+        seen.add(key);
+        return true;
+    });
+}
+
+export class ZtTeamAPI implements ISource {
+    name = 'ztteam';
+    displayName = 'ZT (Team)';
+    private baseUrl: string | undefined;
+
+    constructor(baseUrl?: string) {
+        this.baseUrl = baseUrl?.replace(/\/$/, '');
+    }
+
+    async healthCheck(): Promise<boolean> {
+        if (!this.baseUrl) {
+            console.warn('[ztnews] ⚠️ ZTTEAM_URL non définie.');
+            return false;
+        }
+        return true;
+    }
+
+    async search(query: string, mediaType: MediaType = 'movie'): Promise<SearchResult[]> {
+        if (!this.baseUrl) throw new Error('ZTTEAM_URL non configurée.');
+        if (!query || query.length < 3) throw new Error('La recherche nécessite au moins 3 caractères.');
+        const html = await fetchSearch(this.baseUrl, query);
+        let results = parseListingHTML(html, this.baseUrl);
+        if (mediaType === 'movie') {
+            results = results.filter(r => r.type === 'movie' || r.type === 'anime');
+        } else {
+            results = results.filter(r => r.type === 'series' || r.type === 'anime');
+        }
+        return deduplicateByTitle(results);
+    }
+
+    async getTrending(mediaType: MediaType): Promise<SearchResult[]> {
+        if (!this.baseUrl) return [];
+        try {
+            const html = await fetchTrending(this.baseUrl, mediaType === 'series' ? 'series' : 'films');
+            const results = parseListingHTML(html, this.baseUrl);
+            return deduplicateByTitle(results).slice(0, 20);
+        } catch (e: any) {
+            console.error(`[ztnews] Erreur trending ${mediaType}:`, e.message);
+            return [];
+        }
+    }
+
+    async getRecent(): Promise<SearchResult[]> {
+        if (!this.baseUrl) return [];
+        try {
+            const html = await fetchPage(this.baseUrl);
+            const results = parseListingHTML(html, this.baseUrl);
+            return deduplicateByTitle(results).slice(0, 20);
+        } catch (e: any) {
+            console.error(`[ztnews] Erreur getRecent:`, e.message);
+            return [];
+        }
+    }
+
+    async getContentLinks(identifier: string): Promise<ContentLinks> {
+        if (!this.baseUrl) throw new Error('ZTTEAM_URL non configurée.');
+        const url = identifier.startsWith('http') ? identifier : `${this.baseUrl}/${identifier.replace(/^\//, '')}`;
+        const html = await fetchPage(url);
+        return parseContentHTML(html, isSeriesIdentifier(identifier));
+    }
+
+    async getSelection(identifier: string, type?: string, seasonValue?: string | number): Promise<SelectionData> {
+        if (!this.baseUrl) throw new Error('ZTTEAM_URL non configurée.');
+        const targetIdentifier = seasonValue ? String(seasonValue) : identifier;
+        const isSeries = isSeriesIdentifier(targetIdentifier);
+        const url = targetIdentifier.startsWith('http') ? targetIdentifier : `${this.baseUrl}/${targetIdentifier.replace(/^\//, '')}`;
+        const html = await fetchPage(url);
+        const content = parseContentHTML(html, isSeries);
+
+        const allLinks = [...content.links];
+        let seasons: { label: string; value: string }[] = [];
+        
+        if (!isSeries) {
+            const otherVersions = parseOtherVersions(html, this.baseUrl);
+            if (otherVersions.length > 0) {
+                console.log(`[ztnews] Fetching ${otherVersions.length} other qualities concurrently...`);
+                const qualityPromises = otherVersions.map(async (q) => {
+                    try {
+                        const qHtml = await fetchPage(q.value);
+                        const qContent = parseContentHTML(qHtml, isSeries);
+                        return qContent.links;
+                    } catch (e) {
+                        console.error(`[ztnews] Error fetching quality page ${q.value}:`, e);
+                        return [];
+                    }
+                });
+                const otherQualitiesLinks = await Promise.all(qualityPromises);
+                otherQualitiesLinks.forEach(links => allLinks.push(...links));
+            }
+        }
+
+        return {
+            links: allLinks,
+            seasons,
+            isSeries,
+        };
+    }
+
+    async resolveLink(linkId: string): Promise<string | null> {
+        console.log(`[ztTeam] 🔗 Renvoi du lien dl-protect brut (résolution via navigateur ou JDownloader requise) : ${linkId}`);
+        return linkId || null;
+    }
+}
+
+sourceRegistry.register(new ZtTeamAPI(CONFIG.ZTTEAM_URL));