1457 lines
66 KiB
TypeScript
1457 lines
66 KiB
TypeScript
import { Injectable } from '@angular/core';
|
|
import { HttpClient, HttpHeaders } from '@angular/common/http';
|
|
import { Observable, of, BehaviorSubject, forkJoin } from 'rxjs';
|
|
import { catchError, map, switchMap, shareReplay, first } from 'rxjs/operators';
|
|
import { Video, VideoDetail, Comment } from '../models/video.model';
|
|
import { InstanceService, Provider } from './instance.service';
|
|
import { I18nService } from './i18n.service';
|
|
|
|
export interface PagedResult<T> {
|
|
items: T[];
|
|
nextCursor?: string | null;
|
|
}
|
|
|
|
@Injectable({ providedIn: 'root' })
|
|
export class YoutubeApiService {
|
|
private twitchAuthToken$ = new BehaviorSubject<string | null>(null);
|
|
// Client ID renvoyé par le serveur avec le token (source de vérité côté back)
|
|
private twitchServerClientId: string | null = null;
|
|
// Quota exceeded flag to surface to UI components
|
|
public quotaExceeded$ = new BehaviorSubject<boolean>(false);
|
|
|
|
// Lightweight in-memory caches (session scope)
|
|
private readonly CACHE_TTL_MS = 10 * 60 * 1000; // 10 minutes
|
|
private searchCache = new Map<string, { ts: number; data: PagedResult<Video> }>();
|
|
private trendingCache = new Map<string, { ts: number; data: PagedResult<Video> }>();
|
|
|
|
// ---- YouTube multi-key rotation ----
|
|
private ytKeys: string[] = [];
|
|
private ytKeyIndex = 0;
|
|
private ytKeyBans = new Map<string, number>(); // key -> bannedUntil epoch ms
|
|
// Ban duration (default 6h) can be overridden via window.YT_KEY_BAN_MS
|
|
private readonly YT_KEY_BAN_MS = (() => {
|
|
try { const v = Number((globalThis as any)?.YT_KEY_BAN_MS); return Number.isFinite(v) && v > 0 ? v : 6 * 60 * 60 * 1000; } catch { return 6 * 60 * 60 * 1000; }
|
|
})();
|
|
|
|
constructor(private http: HttpClient, private instances: InstanceService, private i18n: I18nService) {
|
|
this.getTwitchAuthToken().subscribe(this.twitchAuthToken$);
|
|
this.ytKeys = this.loadYouTubeKeys();
|
|
}
|
|
|
|
private normalizeDuration(raw: any): number {
|
|
if (typeof raw === 'number' && Number.isFinite(raw)) {
|
|
return raw > 0 ? Math.round(raw) : 0;
|
|
}
|
|
|
|
if (typeof raw === 'string') {
|
|
const value = raw.trim();
|
|
if (!value) return 0;
|
|
|
|
const numeric = Number(value);
|
|
if (Number.isFinite(numeric)) {
|
|
return numeric > 0 ? Math.round(numeric) : 0;
|
|
}
|
|
|
|
const spaced = value.replace(/[,]/g, '').trim();
|
|
const spaceMatch = spaced.match(/^(\d+)[\s]+(\d{1,2}):(\d{2})$/);
|
|
if (spaceMatch) {
|
|
const hours = Number(spaceMatch[1]);
|
|
const minutes = Number(spaceMatch[2]);
|
|
const seconds = Number(spaceMatch[3]);
|
|
const total = hours * 3600 + minutes * 60 + seconds;
|
|
if (total > 0) return total;
|
|
}
|
|
|
|
const colonized = value.replace(/[^0-9:]/g, '');
|
|
if (colonized.includes(':')) {
|
|
const segments = colonized.split(':').filter(Boolean).map(part => Number(part));
|
|
if (segments.length >= 2 && segments.every(segment => Number.isFinite(segment))) {
|
|
while (segments.length < 3) segments.unshift(0);
|
|
const [hours, minutes, seconds] = segments.slice(-3);
|
|
const total = hours * 3600 + minutes * 60 + seconds;
|
|
if (total > 0) return total;
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
// Some Odysee API responses return thumbnail URLs on hosts like "thumbs.odycdn.com"
|
|
// that can be flaky or blocked by the browser. Prefer the canonical
|
|
// "thumbnails.odycdn.com" host and ensure https scheme.
|
|
private normalizeOdyseeThumb(url?: string): string {
|
|
if (!url) return '';
|
|
try {
|
|
let u = String(url).trim();
|
|
if (!u) return '';
|
|
// Ensure protocol
|
|
if (u.startsWith('//')) u = 'https:' + u;
|
|
if (!/^https?:\/\//i.test(u)) u = 'https://' + u.replace(/^\/*/, '');
|
|
// Replace non-canonical host variants
|
|
try {
|
|
const parsed = new URL(u);
|
|
const host = parsed.hostname.toLowerCase();
|
|
if (host === 'thumbs.odycdn.com' || host === 'thumb.odycdn.com') {
|
|
parsed.hostname = 'thumbnails.odycdn.com';
|
|
return parsed.toString();
|
|
}
|
|
// Already canonical
|
|
return parsed.toString();
|
|
} catch {
|
|
// Fallback simple replace
|
|
return u.replace('thumbs.odycdn.com', 'thumbnails.odycdn.com');
|
|
}
|
|
} catch {
|
|
return url || '';
|
|
}
|
|
}
|
|
|
|
// Build a proxied URL through our backend to avoid ORB/CORS on Odysee CDN
|
|
private proxiedOdyseeThumb(url?: string): string {
|
|
const norm = this.normalizeOdyseeThumb(url);
|
|
if (!norm) return '';
|
|
try {
|
|
return `/proxy/api/img/odysee?u=${encodeURIComponent(norm)}`;
|
|
} catch {
|
|
return `/proxy/api/img/odysee?u=${encodeURIComponent(String(norm))}`;
|
|
}
|
|
}
|
|
|
|
// ... (rest of the code remains the same)
|
|
|
|
// ===================== Twitch Search Helpers =====================
|
|
/** Chaînes Twitch (lives + hors-ligne) pour une requête, façon directory. */
|
|
public searchTwitchAllChannelsPage(query: string, cursor?: string | null, limit = 20): Observable<PagedResult<Video>> {
|
|
return this.getTwitchAuthToken().pipe(
|
|
switchMap(token => {
|
|
if (!token) return of({ items: [], nextCursor: null });
|
|
const headers = new HttpHeaders({ 'Client-ID': this.resolveTwitchClientId()!, 'Authorization': `Bearer ${token}` });
|
|
const after = cursor ? `&after=${encodeURIComponent(cursor)}` : '';
|
|
const primary = `/api/twitch-api/helix/search/channels?query=${encodeURIComponent(query)}&first=${limit}${after}`;
|
|
const fallback = `/proxy/twitch-api/helix/search/channels?query=${encodeURIComponent(query)}&first=${limit}${after}`;
|
|
return this.http.get<any>(primary, { headers }).pipe(
|
|
catchError(() => this.http.get<any>(fallback, { headers })),
|
|
map(res => ({
|
|
items: (Array.isArray(res?.data) ? res.data : []).map((i: any) => this.mapTwitchChannelToVideo(i)),
|
|
nextCursor: res?.pagination?.cursor || null,
|
|
} as PagedResult<Video>)),
|
|
catchError((e) => { console.error('Twitch search channels error', e); return of({ items: [], nextCursor: null }); })
|
|
);
|
|
})
|
|
);
|
|
}
|
|
|
|
/** Catégorie Twitch la plus pertinente (ex. "sports" -> Sports + box-art). */
|
|
public searchTwitchCategory(query: string): Observable<{ id: string; name: string; boxArtUrl?: string } | null> {
|
|
return this.getTwitchAuthToken().pipe(
|
|
switchMap(token => {
|
|
if (!token) return of(null);
|
|
const q = String(query || '').trim();
|
|
if (!q) return of(null);
|
|
const headers = new HttpHeaders({ 'Client-ID': this.resolveTwitchClientId()!, 'Authorization': `Bearer ${token}` });
|
|
const primary = `/api/twitch-api/helix/search/categories?query=${encodeURIComponent(q)}&first=5`;
|
|
const fallback = `/proxy/twitch-api/helix/search/categories?query=${encodeURIComponent(q)}&first=5`;
|
|
return this.http.get<any>(primary, { headers }).pipe(
|
|
catchError(() => this.http.get<any>(fallback, { headers })),
|
|
map(res => {
|
|
const list: any[] = Array.isArray(res?.data) ? res.data : [];
|
|
if (!list.length) return null;
|
|
const needle = q.toLowerCase();
|
|
const exact = list.find(c => String(c?.name || '').toLowerCase() === needle);
|
|
const best = exact || list[0];
|
|
return best?.id ? { id: String(best.id), name: String(best.name || ''), boxArtUrl: best.box_art_url || undefined } : null;
|
|
}),
|
|
catchError(() => of(null))
|
|
);
|
|
})
|
|
);
|
|
}
|
|
|
|
/** Top streams d'une catégorie Twitch (directory/category façon twitch.tv). */
|
|
public getTwitchGameStreamsPage(gameId: string, cursor?: string | null, limit = 24): Observable<PagedResult<Video>> {
|
|
return this.getTwitchAuthToken().pipe(
|
|
switchMap(token => {
|
|
if (!token) return of({ items: [], nextCursor: null });
|
|
const headers = new HttpHeaders({ 'Client-ID': this.resolveTwitchClientId()!, 'Authorization': `Bearer ${token}` });
|
|
const after = cursor ? `&after=${encodeURIComponent(cursor)}` : '';
|
|
const primary = `/api/twitch-api/helix/streams?game_id=${encodeURIComponent(gameId)}&first=${limit}${after}`;
|
|
const fallback = `/proxy/twitch-api/helix/streams?game_id=${encodeURIComponent(gameId)}&first=${limit}${after}`;
|
|
return this.http.get<any>(primary, { headers }).pipe(
|
|
catchError(() => this.http.get<any>(fallback, { headers })),
|
|
map(res => ({
|
|
items: (res.data || []).map((i: any) => this.mapTwitchStreamToVideo(i)),
|
|
nextCursor: res.pagination?.cursor || null,
|
|
} as PagedResult<Video>)),
|
|
catchError((e) => { console.error('Twitch game streams error', e); return of({ items: [], nextCursor: null }); })
|
|
);
|
|
})
|
|
);
|
|
}
|
|
|
|
/** Search live channels matching query (around 20), with pagination cursor. */
|
|
public searchTwitchChannelsPage(query: string, cursor?: string | null): Observable<PagedResult<Video>> {
|
|
return this.getTwitchAuthToken().pipe(
|
|
switchMap(token => {
|
|
if (!token) return of({ items: [], nextCursor: null });
|
|
const headers = new HttpHeaders({ 'Client-ID': this.resolveTwitchClientId()!, 'Authorization': `Bearer ${token}` });
|
|
const after = cursor ? `&after=${encodeURIComponent(cursor)}` : '';
|
|
const primary = `/api/twitch-api/helix/search/channels?query=${encodeURIComponent(query)}&first=20&live_only=true${after}`;
|
|
const fallback = `/proxy/twitch-api/helix/search/channels?query=${encodeURIComponent(query)}&first=20&live_only=true${after}`;
|
|
return this.http.get<any>(primary, { headers }).pipe(
|
|
catchError(() => this.http.get<any>(fallback, { headers })),
|
|
switchMap(res => {
|
|
const data = Array.isArray(res?.data) ? res.data : [];
|
|
const live = data.filter((i: any) => i?.is_live === true).slice(0, 20);
|
|
const baseItems = live.map((i: any) => this.mapTwitchChannelToVideo(i));
|
|
const logins: string[] = live.map((i: any) => i?.broadcaster_login || i?.user_login).filter(Boolean);
|
|
if (logins.length === 0) {
|
|
return of({ items: baseItems, nextCursor: res?.pagination?.cursor || null } as PagedResult<Video>);
|
|
}
|
|
// Fetch viewer counts for these channels
|
|
const queryLogins = logins.map(l => `user_login=${encodeURIComponent(l)}`).join('&');
|
|
const sPrimary = `/api/twitch-api/helix/streams?${queryLogins}`;
|
|
const sFallback = `/proxy/twitch-api/helix/streams?${queryLogins}`;
|
|
return this.http.get<any>(sPrimary, { headers }).pipe(
|
|
catchError(() => this.http.get<any>(sFallback, { headers })),
|
|
map((sres: any) => {
|
|
const streams: any[] = Array.isArray(sres?.data) ? sres.data : [];
|
|
const vc = new Map<string, number>();
|
|
for (const s of streams) {
|
|
const login = s?.user_login || s?.broadcaster_login;
|
|
if (login) vc.set(String(login).toLowerCase(), Number(s?.viewer_count || 0));
|
|
}
|
|
const items = baseItems.map((v: Video) => {
|
|
const key = String(v.videoId || '').toLowerCase();
|
|
const views = vc.get(key);
|
|
return typeof views === 'number' ? { ...v, views } : v;
|
|
});
|
|
return { items, nextCursor: res?.pagination?.cursor || null } as PagedResult<Video>;
|
|
}),
|
|
catchError(() => of({ items: baseItems, nextCursor: res?.pagination?.cursor || null } as PagedResult<Video>))
|
|
);
|
|
}),
|
|
catchError((e) => { console.error('Twitch search channels error', e); return of({ items: [], nextCursor: null }); })
|
|
);
|
|
})
|
|
);
|
|
}
|
|
|
|
/** Search VODs: find channels by query then fetch recent videos per channel; flatten to ~20. */
|
|
public searchTwitchVodsPage(query: string, cursor?: string | null): Observable<PagedResult<Video>> {
|
|
return this.getTwitchAuthToken().pipe(
|
|
switchMap(token => {
|
|
if (!token) return of({ items: [], nextCursor: null });
|
|
const headers = new HttpHeaders({ 'Client-ID': this.resolveTwitchClientId()!, 'Authorization': `Bearer ${token}` });
|
|
const after = cursor ? `&after=${encodeURIComponent(cursor)}` : '';
|
|
const chPrimary = `/api/twitch-api/helix/search/channels?query=${encodeURIComponent(query)}&first=10${after}`;
|
|
const chFallback = `/proxy/twitch-api/helix/search/channels?query=${encodeURIComponent(query)}&first=10${after}`;
|
|
const fetchChannels$ = this.http.get<any>(chPrimary, { headers }).pipe(
|
|
catchError(() => this.http.get<any>(chFallback, { headers }))
|
|
);
|
|
return fetchChannels$.pipe(
|
|
switchMap((chRes: any) => {
|
|
const channels = Array.isArray(chRes?.data) ? chRes.data : [];
|
|
const userIds: string[] = channels.map((c: any) => c?.id).filter(Boolean).slice(0, 10);
|
|
if (userIds.length === 0) return of({ items: [], nextCursor: null } as PagedResult<Video>);
|
|
const perUserRequests = userIds.map(uid => {
|
|
// type=all to include archive, upload, highlight; fetch a few more to increase hit rate
|
|
const vPrimary = `/api/twitch-api/helix/videos?user_id=${encodeURIComponent(uid)}&first=10&type=all`;
|
|
const vFallback = `/proxy/twitch-api/helix/videos?user_id=${encodeURIComponent(uid)}&first=10&type=all`;
|
|
return this.http.get<any>(vPrimary, { headers }).pipe(
|
|
catchError(() => this.http.get<any>(vFallback, { headers })),
|
|
map(vres => Array.isArray(vres?.data) ? vres.data : [])
|
|
);
|
|
});
|
|
return forkJoin(perUserRequests).pipe(
|
|
map((lists: any[][]) => lists.flat().slice(0, 20)),
|
|
map((videos: any[]) => ({
|
|
items: videos.map((i: any) => this.mapTwitchItemToVideo(i)),
|
|
nextCursor: chRes?.pagination?.cursor || null,
|
|
} as PagedResult<Video>))
|
|
);
|
|
}),
|
|
catchError((e) => { console.error('Twitch search VODs error', e); return of({ items: [], nextCursor: null }); })
|
|
);
|
|
})
|
|
);
|
|
}
|
|
|
|
private fetchOdysee(body: any) {
|
|
const prod = `/api/odysee/api/v1/proxy`;
|
|
const dev = `/proxy/odysee/api/v1/proxy`;
|
|
return this.http.post<any>(prod, body).pipe(
|
|
catchError(() => this.http.post<any>(dev, body))
|
|
);
|
|
}
|
|
|
|
private lbryToOdyseeUrl(lbryUrl: string): string {
|
|
if (!lbryUrl || typeof lbryUrl !== 'string') return '';
|
|
// Convert lbry://@Channel#id/Video#id => https://odysee.com/@Channel:id/Video:id
|
|
try {
|
|
const noScheme = lbryUrl.replace('lbry://', '');
|
|
const parts = noScheme.split('/');
|
|
const segs = parts.map(seg => seg.replace('#', ':'));
|
|
return `https://odysee.com/${segs.join('/')}`;
|
|
} catch {
|
|
return '';
|
|
}
|
|
}
|
|
|
|
getTrendingVideos(): Observable<Video[]> {
|
|
return this.getTrendingPage().pipe(map(r => r.items));
|
|
}
|
|
|
|
searchVideos(query: string): Observable<Video[]> {
|
|
return this.searchVideosPage(query).pipe(map(r => r.items));
|
|
}
|
|
|
|
getVideoDetails(id: string): Observable<VideoDetail | null> {
|
|
// Not implemented yet per-provider; return null so Watch page shows fallback.
|
|
return of(null);
|
|
}
|
|
|
|
// Pagination-enabled APIs
|
|
getTrendingPage(cursor?: string | null, providerOverride?: Provider | null): Observable<PagedResult<Video>> {
|
|
const provider = providerOverride || this.instances.selectedProvider();
|
|
const region = this.instances.region();
|
|
switch (provider) {
|
|
case 'youtube': {
|
|
const key = this.getActiveYouTubeKey();
|
|
if (!key) {
|
|
console.warn('YOUTUBE_API_KEY not found. Set it to enable YouTube trending.');
|
|
return of({ items: [], nextCursor: null });
|
|
}
|
|
const params = new URLSearchParams({
|
|
chart: 'mostPopular',
|
|
regionCode: String(region),
|
|
maxResults: '24',
|
|
// Optimize quota usage: only get essential parts
|
|
part: 'snippet,contentDetails,statistics',
|
|
// Add safeSearch for better content filtering
|
|
safeSearch: 'moderate',
|
|
// Video category for trending (Music = 10, Gaming = 20, etc.)
|
|
videoCategoryId: '0', // All categories
|
|
key: String(key),
|
|
});
|
|
|
|
if (cursor) params.set('pageToken', cursor);
|
|
// Cache key: provider|chart|region|cursor
|
|
const cacheKey = `yt:trending|${region}|${cursor || ''}`;
|
|
const cached = this.trendingCache.get(cacheKey);
|
|
const now = Date.now();
|
|
if (cached && (now - cached.ts) < this.CACHE_TTL_MS) {
|
|
return of(cached.data);
|
|
}
|
|
const path = `/youtube/v3/videos`;
|
|
return this.fetchYouTube(path, params, key).pipe(
|
|
map(res => ({
|
|
items: (res.items || []).map((i: any) => this.mapYouTubeItemToVideo(i)),
|
|
nextCursor: res.nextPageToken || null,
|
|
} as PagedResult<Video>)),
|
|
map((out) => {
|
|
this.trendingCache.set(cacheKey, { ts: now, data: out });
|
|
return out;
|
|
}),
|
|
catchError((e) => {
|
|
// Surface quotaExceeded if present + ban dead keys (quota ou clé expirée/invalide)
|
|
try {
|
|
const reason = e?.error?.error?.errors?.[0]?.reason || '';
|
|
const msg = String(e?.error?.error?.message || e?.message || '');
|
|
if (e?.status === 403 && (reason === 'quotaExceeded' || /quota/i.test(msg))) {
|
|
this.quotaExceeded$.next(true);
|
|
this.banYouTubeKey(key);
|
|
} else if (e?.status === 400 && (reason === 'API_KEY_INVALID' || /api key (expired|invalid)/i.test(msg))) {
|
|
this.banYouTubeKey(key);
|
|
}
|
|
} catch {}
|
|
console.error('YouTube trending error', e);
|
|
return of({ items: [], nextCursor: null });
|
|
})
|
|
);
|
|
}
|
|
case 'odysee': {
|
|
// Use LBRY/Odysee claim_search with trending order
|
|
const page = cursor ? Number(cursor) : 1;
|
|
const body = {
|
|
method: 'claim_search',
|
|
params: {
|
|
page: page,
|
|
page_size: 24,
|
|
no_totals: true,
|
|
claim_type: 'stream',
|
|
stream_types: ['video'],
|
|
order_by: ['trending_group', 'trending_mixed']
|
|
}
|
|
};
|
|
return this.fetchOdysee(body).pipe(
|
|
map(res => {
|
|
const items = (res?.result?.items || res?.result?.claims || res?.items || []) as any[];
|
|
return {
|
|
items: items.map(i => this.mapOdyseeItemToVideo(i)),
|
|
nextCursor: items.length > 0 ? String(page + 1) : null,
|
|
} as PagedResult<Video>;
|
|
}),
|
|
catchError((e) => { console.error('Odysee trending error', e); return of({ items: [], nextCursor: null }); })
|
|
);
|
|
}
|
|
case 'dailymotion': {
|
|
const page = cursor ? String(cursor) : '1';
|
|
const limit = 24;
|
|
const params = new URLSearchParams({
|
|
sort: 'trending',
|
|
limit: String(limit),
|
|
page: String(page),
|
|
country: String(region).toLowerCase(),
|
|
fields: 'id,title,thumbnail_url,thumbnail_480_url,thumbnail_720_url,duration,views_total,owner.id,owner.screenname,owner.avatar_80_url,created_time',
|
|
});
|
|
return this.fetchDailymotion('/videos', params).pipe(
|
|
map(res => {
|
|
const list = (res.list || res.result || res.items || res.data || []) as any[];
|
|
const currentPage = Number(page) || 1;
|
|
const hasMore = typeof res.has_more === 'boolean' ? res.has_more : (list.length === limit);
|
|
return {
|
|
items: list.map((i: any) => this.mapDailymotionItemToVideo(i)),
|
|
nextCursor: hasMore ? String(currentPage + 1) : null,
|
|
} as PagedResult<Video>;
|
|
}),
|
|
catchError((e) => { console.error('Dailymotion trending error', e); return of({ items: [], nextCursor: null }); })
|
|
);
|
|
}
|
|
case 'twitch': {
|
|
// Use Helix Streams for a "trending" like experience (popular live streams)
|
|
return this.getTwitchTopStreamsPage(cursor);
|
|
}
|
|
case 'rumble': {
|
|
// Rumble utilise maintenant le web scraping côté serveur, pas d'API key requise
|
|
const page = cursor ? Number(cursor) : 1;
|
|
const params = new URLSearchParams({
|
|
sort: 'trending',
|
|
limit: '24',
|
|
page: String(page),
|
|
});
|
|
return this.fetchRumble('/browse', params).pipe(
|
|
map(res => {
|
|
const list = (res?.items || res?.result || res?.data || []) as any[];
|
|
const backendCursor = res?.nextCursor != null ? String(res.nextCursor) : null;
|
|
const next = backendCursor ?? (list.length > 0 ? String(page + 1) : null);
|
|
return {
|
|
items: list.map(i => this.mapRumbleItemToVideo(i)),
|
|
nextCursor: next,
|
|
} as PagedResult<Video>;
|
|
}),
|
|
catchError((e) => { console.error('Rumble trending error', e); return of({ items: [], nextCursor: null }); })
|
|
);
|
|
}
|
|
case 'peertube': {
|
|
const instance = this.instances.activePeerTubeInstance();
|
|
const start = cursor ? Number(cursor) : 0;
|
|
const primary = `/api/peertube/${instance}/api/v1/videos?sort=-trending&count=24&start=${start}`;
|
|
const fallback = `/proxy/api/peertube/${instance}/api/v1/videos?sort=-trending&count=24&start=${start}`;
|
|
return this.http.get<any>(primary).pipe(
|
|
catchError(() => this.http.get<any>(fallback)),
|
|
map(res => ({
|
|
items: (res.data || []).map((i: any) => this.mapPeerTubeItemToVideo(i, instance)),
|
|
nextCursor: res.data?.length > 0 ? String(start + 24) : null,
|
|
} as PagedResult<Video>)),
|
|
catchError((e) => { console.error(`PeerTube (${instance}) trending error`, e); return of({ items: [], nextCursor: null }); })
|
|
);
|
|
}
|
|
default:
|
|
console.warn('Provider not yet implemented for trending:', provider);
|
|
return of({ items: [], nextCursor: null });
|
|
}
|
|
}
|
|
|
|
searchVideosPage(query: string, cursor?: string | null, providerOverride?: Provider | null): Observable<PagedResult<Video>> {
|
|
const provider = providerOverride || this.instances.selectedProvider();
|
|
const region = this.instances.region();
|
|
if (!query) return of({ items: [], nextCursor: null });
|
|
switch (provider) {
|
|
case 'youtube': {
|
|
const key = this.getActiveYouTubeKey();
|
|
if (!key) return of({ items: [], nextCursor: null });
|
|
const params = new URLSearchParams({
|
|
type: 'video',
|
|
// search.list only supports 'snippet'
|
|
part: 'snippet',
|
|
// Optimize for quota usage: reduce initial results
|
|
maxResults: '25',
|
|
q: String(query),
|
|
regionCode: String(region),
|
|
// Add safeSearch for better content filtering
|
|
safeSearch: 'moderate',
|
|
// Only return videos playable in an iframe (avoids player error 153).
|
|
videoEmbeddable: 'true',
|
|
key: String(key),
|
|
});
|
|
// Prefer results matching user's language when available
|
|
try {
|
|
const lang = String(this.i18n.lang()).toLowerCase();
|
|
if (lang) params.set('relevanceLanguage', lang);
|
|
} catch {}
|
|
if (cursor) params.set('pageToken', cursor);
|
|
// Cache key: provider|search|region|query|cursor
|
|
const cacheKey = `yt:search|${region}|${query}|${cursor || ''}`;
|
|
const cached = this.searchCache.get(cacheKey);
|
|
const now = Date.now();
|
|
if (cached && (now - cached.ts) < this.CACHE_TTL_MS) {
|
|
return of(cached.data);
|
|
}
|
|
const path = `/youtube/v3/search`;
|
|
return this.fetchYouTube(path, params, key).pipe(
|
|
map(res => ({
|
|
items: (res.items || []).map((i: any) => this.mapYouTubeSearchItemToVideo(i)),
|
|
nextCursor: res.nextPageToken || null,
|
|
} as PagedResult<Video>)),
|
|
// Enrich with durations and view counts
|
|
switchMap((out) => {
|
|
const ids = out.items.map(v => v.videoId).filter(Boolean);
|
|
if (!ids.length) return of(out);
|
|
return this.getYouTubeContentAndStats(ids).pipe(
|
|
map((stats) => {
|
|
const enriched = out.items.map(v => {
|
|
const s = stats[v.videoId];
|
|
if (!s) return v;
|
|
// duration -1 = non-embeddable (erreur 153) : on garde la
|
|
// vidéo en recherche (avec durée 0) mais les Shorts la filtrent.
|
|
const duration = typeof s.duration === 'number' && s.duration >= 0 ? s.duration : 0;
|
|
return { ...v, duration, views: s.views };
|
|
});
|
|
const next = { ...out, items: enriched } as PagedResult<Video>;
|
|
this.searchCache.set(cacheKey, { ts: now, data: next });
|
|
return next;
|
|
})
|
|
);
|
|
}),
|
|
catchError((e) => {
|
|
// Surface quotaExceeded if present + ban dead keys (quota ou clé expirée/invalide)
|
|
try {
|
|
const reason = e?.error?.error?.errors?.[0]?.reason || '';
|
|
const msg = String(e?.error?.error?.message || e?.message || '');
|
|
if (e?.status === 403 && (reason === 'quotaExceeded' || /quota/i.test(msg))) {
|
|
this.quotaExceeded$.next(true);
|
|
this.banYouTubeKey(key);
|
|
} else if (e?.status === 400 && (reason === 'API_KEY_INVALID' || /api key (expired|invalid)/i.test(msg))) {
|
|
this.banYouTubeKey(key);
|
|
}
|
|
} catch {}
|
|
console.error('YouTube search error', e);
|
|
return of({ items: [], nextCursor: null });
|
|
})
|
|
);
|
|
}
|
|
case 'odysee': {
|
|
const page = cursor ? Number(cursor) : 1;
|
|
const body = {
|
|
method: 'claim_search',
|
|
params: {
|
|
page: page,
|
|
page_size: 24,
|
|
no_totals: true,
|
|
claim_type: 'stream',
|
|
stream_types: ['video'],
|
|
text: String(query),
|
|
order_by: ['trending_group', 'trending_mixed']
|
|
}
|
|
};
|
|
return this.fetchOdysee(body).pipe(
|
|
map(res => {
|
|
const items = (res?.result?.items || res?.result?.claims || res?.items || []) as any[];
|
|
return {
|
|
items: items.map(i => this.mapOdyseeItemToVideo(i)),
|
|
nextCursor: items.length > 0 ? String(page + 1) : null,
|
|
} as PagedResult<Video>;
|
|
}),
|
|
catchError((e) => { console.error('Odysee search error', e); return of({ items: [], nextCursor: null }); })
|
|
);
|
|
}
|
|
case 'dailymotion': {
|
|
const page = cursor ? String(cursor) : '1';
|
|
const limit = 24;
|
|
const params = new URLSearchParams({
|
|
limit: String(limit),
|
|
page: String(page),
|
|
country: String(region).toLowerCase(),
|
|
fields: 'id,title,thumbnail_url,thumbnail_480_url,thumbnail_720_url,duration,views_total,owner.screenname,owner.avatar_80_url,created_time',
|
|
search: String(query),
|
|
});
|
|
return this.fetchDailymotion('/videos', params).pipe(
|
|
map(res => {
|
|
const list = (res.list || res.result || res.items || res.data || []) as any[];
|
|
const currentPage = Number(page) || 1;
|
|
const hasMore = typeof res.has_more === 'boolean' ? res.has_more : (list.length === limit);
|
|
return {
|
|
items: list.map((i: any) => this.mapDailymotionItemToVideo(i)),
|
|
nextCursor: hasMore ? String(currentPage + 1) : null,
|
|
} as PagedResult<Video>;
|
|
}),
|
|
catchError((e) => { console.error('Dailymotion search error', e); return of({ items: [], nextCursor: null }); })
|
|
);
|
|
}
|
|
case 'rumble': {
|
|
// Rumble utilise maintenant le web scraping côté serveur, pas d'API key requise
|
|
const limit = 24;
|
|
const offset = cursor ? Number(cursor) : 0;
|
|
const params = new URLSearchParams({
|
|
q: String(query),
|
|
limit: String(limit),
|
|
offset: String(offset),
|
|
});
|
|
return this.fetchRumble('/search', params).pipe(
|
|
map(res => {
|
|
const list = (res?.items || res?.result || res?.data || []) as any[];
|
|
// Prefer backend-provided nextCursor if present (page-based). Translate it to offset-based cursor for the frontend.
|
|
let next: string | null = null;
|
|
if (res?.nextCursor != null && res?.page != null && res?.limit != null) {
|
|
try {
|
|
const nextPage = Number(res.nextCursor);
|
|
const perPage = Number(res.limit);
|
|
if (!isNaN(nextPage) && !isNaN(perPage)) next = String((nextPage - 1) * perPage);
|
|
} catch {}
|
|
}
|
|
if (next == null) {
|
|
const hasMore = list.length === limit;
|
|
next = hasMore ? String(offset + limit) : null;
|
|
}
|
|
return {
|
|
items: list.map(i => this.mapRumbleItemToVideo(i)),
|
|
nextCursor: next,
|
|
} as PagedResult<Video>;
|
|
}),
|
|
// Si la recherche est vide (scraper challengé / page changée),
|
|
// repli sur le flux trending pour ne jamais afficher un bloc vide.
|
|
switchMap(out => {
|
|
if ((out?.items?.length || 0) > 0) return of(out);
|
|
const page = 1;
|
|
const bParams = new URLSearchParams({ sort: 'trending', limit: '24', page: String(page) });
|
|
return this.fetchRumble('/browse', bParams).pipe(
|
|
map(res => {
|
|
const list = (res?.items || res?.result || res?.data || []) as any[];
|
|
return { items: list.map(i => this.mapRumbleItemToVideo(i)), nextCursor: null } as PagedResult<Video>;
|
|
}),
|
|
catchError(() => of(out))
|
|
);
|
|
}),
|
|
catchError((e) => { console.error('Rumble search error', e); return of({ items: [], nextCursor: null }); })
|
|
);
|
|
}
|
|
case 'twitch': {
|
|
// Recherche thématique robuste : chaînes live d'abord, puis VODs +
|
|
// clips, avec fallback top streams (évite les blocs vides sur les
|
|
// pages de thèmes où la recherche Helix pure ne matche rien).
|
|
return this.getTwitchAuthToken().pipe(
|
|
switchMap(token => {
|
|
if (!token) return of({ items: [], nextCursor: null });
|
|
const headers = new HttpHeaders({ 'Client-ID': this.resolveTwitchClientId()!, 'Authorization': `Bearer ${token}` });
|
|
const primary = `/api/twitch-api/helix/search/channels?query=${encodeURIComponent(query)}&first=24&after=${cursor || ''}&live_only=true`;
|
|
const fallback = `/proxy/twitch-api/helix/search/channels?query=${encodeURIComponent(query)}&first=24&after=${cursor || ''}&live_only=true`;
|
|
return this.http.get<any>(primary, { headers }).pipe(
|
|
catchError(() => this.http.get<any>(fallback, { headers })),
|
|
map(res => {
|
|
const data = Array.isArray(res?.data) ? res.data : [];
|
|
const live = data.filter((i: any) => i?.is_live === true);
|
|
return {
|
|
items: live.map((i: any) => this.mapTwitchChannelToVideo(i)),
|
|
nextCursor: res.pagination?.cursor || null,
|
|
} as PagedResult<Video>;
|
|
}),
|
|
// Si la recherche live est vide/maigre, compléter avec VODs+clips puis top streams.
|
|
switchMap(liveRes => {
|
|
if ((liveRes?.items?.length || 0) >= 4) return of(liveRes);
|
|
return this.searchTwitchThemePage(query, cursor).pipe(
|
|
map(themeRes => {
|
|
const seen = new Set((liveRes.items || []).map(v => v.videoId));
|
|
const extra = (themeRes?.items || []).filter(v => !seen.has(v.videoId));
|
|
return { items: [...(liveRes.items || []), ...extra], nextCursor: themeRes?.nextCursor || liveRes.nextCursor } as PagedResult<Video>;
|
|
}),
|
|
catchError(() => of(liveRes))
|
|
);
|
|
}),
|
|
catchError((e) => { console.error('Twitch search error', e); return of({ items: [], nextCursor: null }); })
|
|
);
|
|
})
|
|
);
|
|
}
|
|
case 'peertube': {
|
|
const instance = this.instances.activePeerTubeInstance();
|
|
const start = cursor ? Number(cursor) : 0;
|
|
const primary = `/api/peertube/${instance}/api/v1/search/videos?search=${encodeURIComponent(query)}&count=24&start=${start}`;
|
|
const fallback = `/proxy/api/peertube/${instance}/api/v1/search/videos?search=${encodeURIComponent(query)}&count=24&start=${start}`;
|
|
return this.http.get<any>(primary).pipe(
|
|
catchError(() => this.http.get<any>(fallback)),
|
|
map(res => ({
|
|
items: (res.data || []).map((i: any) => this.mapPeerTubeItemToVideo(i, instance)),
|
|
nextCursor: res.data?.length > 0 ? String(start + 24) : null,
|
|
} as PagedResult<Video>)),
|
|
catchError((e) => { console.error(`PeerTube (${instance}) search error`, e); return of({ items: [], nextCursor: null }); })
|
|
);
|
|
}
|
|
default:
|
|
return of({ items: [], nextCursor: null });
|
|
}
|
|
}
|
|
|
|
// YouTube mappers
|
|
private mapYouTubeItemToVideo = (i: any): Video => {
|
|
const id = i.id;
|
|
const sn = i.snippet || {};
|
|
const stats = i.statistics || {};
|
|
const cd = i.contentDetails || {};
|
|
const thumb = sn.thumbnails?.high?.url || sn.thumbnails?.medium?.url || sn.thumbnails?.default?.url || '';
|
|
const publishedAt = sn.publishedAt || '';
|
|
const channelId = sn.channelId || '';
|
|
return {
|
|
url: `/watch/${id}`,
|
|
videoId: id,
|
|
type: 'video',
|
|
provider: 'youtube',
|
|
title: sn.title || '',
|
|
thumbnail: thumb,
|
|
uploaderName: sn.channelTitle || '',
|
|
uploaderUrl: channelId ? `https://www.youtube.com/channel/${channelId}` : '',
|
|
// Ne jamais utiliser la miniature vidéo comme avatar chaîne : la page /watch
|
|
// résout le vrai avatar via /api/details puis /api/channels, avec fallback initiales.
|
|
uploaderAvatar: '',
|
|
channelId: channelId || undefined,
|
|
channelExternalId: channelId || undefined,
|
|
channelAvatarUrl: undefined,
|
|
uploadedDate: publishedAt,
|
|
duration: this.parseISODurationToSeconds(cd.duration || 'PT0S'),
|
|
views: Number(stats.viewCount || 0),
|
|
uploaded: publishedAt ? Date.parse(publishedAt) : 0,
|
|
} as Video;
|
|
};
|
|
|
|
private mapYouTubeSearchItemToVideo = (i: any, live = false): Video => {
|
|
const id = i.id?.videoId || i.id;
|
|
const sn = i.snippet || {};
|
|
const thumb = sn.thumbnails?.high?.url || sn.thumbnails?.medium?.url || sn.thumbnails?.default?.url || '';
|
|
const publishedAt = sn.publishedAt || '';
|
|
const channelId = sn.channelId || '';
|
|
// liveBroadcastContent === 'live' => réellement en direct ; 'upcoming' => à venir
|
|
const broadcast = String(sn?.liveBroadcastContent || '').toLowerCase();
|
|
const isLive = live || broadcast === 'live';
|
|
return {
|
|
url: `/watch/${id}`,
|
|
videoId: id,
|
|
type: isLive ? 'live' : 'video',
|
|
provider: 'youtube',
|
|
title: sn.title || '',
|
|
thumbnail: thumb,
|
|
uploaderName: sn.channelTitle || '',
|
|
uploaderUrl: channelId ? `https://www.youtube.com/channel/${channelId}` : '',
|
|
uploaderAvatar: '',
|
|
channelId: channelId || undefined,
|
|
channelExternalId: channelId || undefined,
|
|
channelAvatarUrl: undefined,
|
|
uploadedDate: publishedAt,
|
|
duration: 0,
|
|
views: 0,
|
|
uploaded: publishedAt ? Date.parse(publishedAt) : 0,
|
|
isLive,
|
|
} as Video;
|
|
};
|
|
|
|
/**
|
|
* Recherche de directs YouTube (search.list eventType=live + type=video).
|
|
* Contrairement à une recherche textuelle "live", ne retourne que des
|
|
* diffusions réellement en direct. `query` optionnel : sans requête on
|
|
* cherche "live" avec le filtre live pour garantir des résultats.
|
|
*/
|
|
public searchYouTubeLivePage(query?: string, cursor?: string | null): Observable<PagedResult<Video>> {
|
|
const region = this.instances.region();
|
|
const key = this.getActiveYouTubeKey();
|
|
if (!key) return of({ items: [], nextCursor: null });
|
|
const q = String(query || '').trim() || 'live';
|
|
const params = new URLSearchParams({
|
|
type: 'video',
|
|
part: 'snippet',
|
|
maxResults: '25',
|
|
q,
|
|
regionCode: String(region),
|
|
safeSearch: 'moderate',
|
|
videoEmbeddable: 'true',
|
|
eventType: 'live',
|
|
order: 'viewCount',
|
|
key: String(key),
|
|
});
|
|
if (cursor) params.set('pageToken', cursor);
|
|
const cacheKey = `yt:live|${region}|${q}|${cursor || ''}`;
|
|
const cached = this.searchCache.get(cacheKey);
|
|
const now = Date.now();
|
|
if (cached && (now - cached.ts) < this.CACHE_TTL_MS) {
|
|
return of(cached.data);
|
|
}
|
|
const path = `/youtube/v3/search`;
|
|
return this.fetchYouTube(path, params, key).pipe(
|
|
map(res => ({
|
|
items: (res.items || []).map((i: any) => this.mapYouTubeSearchItemToVideo(i, true)),
|
|
nextCursor: res.nextPageToken || null,
|
|
} as PagedResult<Video>)),
|
|
switchMap((out) => {
|
|
const ids = out.items.map(v => v.videoId).filter(Boolean);
|
|
if (!ids.length) return of(out);
|
|
return this.getYouTubeContentAndStats(ids).pipe(
|
|
map((stats) => {
|
|
const enriched = out.items.map(v => {
|
|
const s = stats[v.videoId];
|
|
if (!s) return v;
|
|
const duration = typeof s.duration === 'number' && s.duration >= 0 ? s.duration : 0;
|
|
return { ...v, duration, views: s.views, type: 'live', isLive: true };
|
|
});
|
|
const next = { ...out, items: enriched } as PagedResult<Video>;
|
|
this.searchCache.set(cacheKey, { ts: now, data: next });
|
|
return next;
|
|
})
|
|
);
|
|
}),
|
|
catchError((e) => {
|
|
try {
|
|
const reason = e?.error?.error?.errors?.[0]?.reason || '';
|
|
const msg = String(e?.error?.error?.message || e?.message || '');
|
|
if (e?.status === 403 && (reason === 'quotaExceeded' || /quota/i.test(msg))) {
|
|
this.quotaExceeded$.next(true);
|
|
this.banYouTubeKey(key);
|
|
} else if (e?.status === 400 && (reason === 'API_KEY_INVALID' || /api key (expired|invalid)/i.test(msg))) {
|
|
this.banYouTubeKey(key);
|
|
}
|
|
} catch {}
|
|
console.error('YouTube live search error', e);
|
|
return of({ items: [], nextCursor: null });
|
|
})
|
|
);
|
|
}
|
|
|
|
// Dailymotion mapper
|
|
private mapDailymotionItemToVideo = (i: any): Video => ({
|
|
url: `/watch/${i.id}`,
|
|
videoId: i.id || '',
|
|
type: 'video',
|
|
provider: 'dailymotion',
|
|
title: i.title || '',
|
|
thumbnail: i.thumbnail_720_url || i.thumbnail_480_url || i.thumbnail_url || '',
|
|
uploaderName: i['owner.screenname'] || '',
|
|
uploaderUrl: '',
|
|
uploaderAvatar: i['owner.avatar_80_url'] || i.thumbnail_480_url || i.thumbnail_url || '',
|
|
channelId: i['owner.id'] || undefined,
|
|
channelExternalId: i['owner.id'] || undefined,
|
|
channelAvatarUrl: i['owner.avatar_80_url'] || undefined,
|
|
uploadedDate: i.created_time ? new Date(i.created_time * 1000).toISOString() : '',
|
|
duration: Number(i.duration || 0),
|
|
views: Number(i.views_total || 0),
|
|
uploaded: i.created_time ? i.created_time * 1000 : 0,
|
|
});
|
|
|
|
// PeerTube mapper (robust handling for thumbnail/avatar fields across instances)
|
|
private mapPeerTubeItemToVideo = (i: any, instance: string): Video => {
|
|
const abs = (p?: string) => {
|
|
if (!p) return '';
|
|
const s = String(p);
|
|
return s.startsWith('http') ? s : `https://${instance}${s.startsWith('/') ? s : '/' + s}`;
|
|
};
|
|
const thumbnail = abs(i.thumbnailUrl) || abs(i.thumbnailPath) || abs(i.previewPath) || '';
|
|
const uploaderAvatar = abs(i.account?.avatar?.path) || abs(i.account?.avatars?.[0]?.path) || abs(i.channel?.avatar?.path) || '';
|
|
const uploaderName = i.account?.displayName || i.account?.name || i.channel?.displayName || '';
|
|
const uploaderUrl = i.account?.url || i.channel?.url || '';
|
|
|
|
return {
|
|
url: `https://${instance}/w/${i.uuid}`,
|
|
videoId: i.uuid || '',
|
|
type: 'video',
|
|
provider: 'peertube',
|
|
title: i.name || '',
|
|
thumbnail,
|
|
uploaderName,
|
|
uploaderUrl,
|
|
uploaderAvatar: uploaderAvatar || thumbnail,
|
|
channelId: i.account?.name || i.channel?.name || undefined,
|
|
channelExternalId: i.account?.name || i.channel?.name || undefined,
|
|
channelAvatarUrl: uploaderAvatar || undefined,
|
|
uploadedDate: i.publishedAt || '',
|
|
duration: Number(i.duration || 0),
|
|
views: Number(i.views || 0),
|
|
uploaded: i.publishedAt ? Date.parse(i.publishedAt) : 0,
|
|
} as Video;
|
|
};
|
|
|
|
// Odysee mapper
|
|
private mapOdyseeItemToVideo = (i: any): Video => {
|
|
const val = i?.value || {};
|
|
const channel = i?.signing_channel || {};
|
|
const channelVal = channel?.value || {};
|
|
const lbryUrl = i?.permanent_url || i?.canonical_url || '';
|
|
const webUrl = this.lbryToOdyseeUrl(lbryUrl) || (i?.name ? `https://odysee.com/${i.name}` : '');
|
|
const thumbRaw = val?.thumbnail?.url || '';
|
|
const thumb = this.proxiedOdyseeThumb(thumbRaw);
|
|
const publishedAt = val?.release_time ? new Date(val.release_time * 1000).toISOString() : '';
|
|
const rawDuration = val?.video?.duration
|
|
?? i?.duration
|
|
?? val?.duration
|
|
?? i?.meta?.duration
|
|
?? (typeof i?.value?.duration !== 'undefined' ? i.value.duration : undefined);
|
|
const duration = this.normalizeDuration(rawDuration);
|
|
const views = (i?.meta?.view_count != null) ? Number(i.meta.view_count) : 0;
|
|
const uploaderName = channelVal?.title || channel?.name || '';
|
|
const channelClaimId = channel?.claim_id || channel?.claimId || '';
|
|
const channelHandle = channel?.name || '';
|
|
const channelExternalId = channelClaimId || channelHandle.replace(/^@/, '') || '';
|
|
|
|
return {
|
|
url: webUrl,
|
|
videoId: i?.claim_id || i?.txid || i?.claimId || i?.id || '',
|
|
type: 'video',
|
|
provider: 'odysee',
|
|
title: val?.title || i?.name || '',
|
|
thumbnail: thumb,
|
|
uploaderName,
|
|
uploaderUrl: channel?.permanent_url ? this.lbryToOdyseeUrl(channel.permanent_url) : '',
|
|
uploaderAvatar: this.proxiedOdyseeThumb(channelVal?.thumbnail?.url) || thumb,
|
|
channelId: channelClaimId || undefined,
|
|
channelHandle: channelHandle || undefined,
|
|
channelExternalId: channelExternalId || undefined,
|
|
channelAvatarUrl: this.proxiedOdyseeThumb(channelVal?.thumbnail?.url) || undefined,
|
|
uploadedDate: publishedAt,
|
|
duration,
|
|
views: views,
|
|
uploaded: publishedAt ? Date.parse(publishedAt) : 0,
|
|
} as Video;
|
|
};
|
|
|
|
// Rumble mapper (best-effort over common fields)
|
|
private mapRumbleItemToVideo = (i: any): Video => {
|
|
let id = i?.id || i?.video_id || i?.videoId || i?.hash || '';
|
|
const title = i?.title || i?.name || '';
|
|
let thumb = i?.thumbnail || i?.thumbnail_url || i?.image || '';
|
|
const uploaderName = i?.author || i?.uploader || i?.channel?.name || i?.uploaderName || '';
|
|
const uploaderAvatar = i?.author_avatar || i?.uploader_avatar || i?.channel?.avatar || i?.uploaderAvatar || thumb || '';
|
|
const channelSlug = i?.channel?.slug || i?.channel_slug || (i?.channel?.url ? i.channel.url.replace(/^https?:\/\/rumble.com\//, '').replace(/\/$/, '') : '') || '';
|
|
const channelExternalId = channelSlug || (uploaderName ? uploaderName.replace(/\s+/g, '').toLowerCase() : '');
|
|
const uploadedDate = i?.published_at || i?.created_at || i?.uploadedDate || '';
|
|
const views = Number(i?.views || i?.view_count || 0);
|
|
const duration = this.normalizeDuration(
|
|
i?.duration ?? i?.durationSeconds ?? i?.duration_seconds ?? i?.video_duration ?? i?.length ?? i?.meta?.duration
|
|
);
|
|
const url = i?.url || (id ? `https://rumble.com/${id}` : '');
|
|
if (!id && url) {
|
|
try {
|
|
const u = new URL(url);
|
|
const m = u.pathname.match(/\/v[\w]+/) || u.pathname.match(/\/video\/([\w]+)/);
|
|
if (m) id = Array.isArray(m) ? (m[1] ? `v${m[1]}` : m[0].replace(/^\//, '')) : id;
|
|
} catch {}
|
|
}
|
|
if (!thumb && url) {
|
|
// Best-effort: construct a thumbnail CDN path if present in URL pattern (fallback to uploader avatar)
|
|
thumb = uploaderAvatar || '';
|
|
}
|
|
const nativeShort = (i as any)?.isShort === true;
|
|
return {
|
|
url,
|
|
videoId: id,
|
|
type: 'video',
|
|
provider: 'rumble',
|
|
title,
|
|
thumbnail: thumb,
|
|
uploaderName,
|
|
uploaderUrl: i?.channel_url || '',
|
|
uploaderAvatar,
|
|
channelId: channelExternalId || undefined,
|
|
channelExternalId: channelExternalId || undefined,
|
|
channelAvatarUrl: uploaderAvatar || undefined,
|
|
uploadedDate,
|
|
duration,
|
|
views,
|
|
uploaded: uploadedDate ? Date.parse(uploadedDate) : 0,
|
|
// Flag natif propagé du scraper serveur ; sinon durée courte ⇒ Short.
|
|
isShort: nativeShort || (duration > 0 && duration <= 75),
|
|
} as Video;
|
|
};
|
|
|
|
// Twitch Mappers
|
|
private mapTwitchItemToVideo = (i: any): Video => ({
|
|
url: `/watch/${i.id}`,
|
|
videoId: i.id || '',
|
|
type: 'video',
|
|
provider: 'twitch',
|
|
kind: 'vod',
|
|
title: i.title || '',
|
|
thumbnail: i.thumbnail_url?.replace('%{width}', '640').replace('%{height}', '360') || '',
|
|
uploaderName: i.user_name || i.broadcaster_name || '',
|
|
uploaderUrl: i.user_login ? `https://www.twitch.tv/${i.user_login}` : '',
|
|
uploaderAvatar: '', // Requires another API call
|
|
channelId: i.user_id || i.broadcaster_id || undefined,
|
|
channelHandle: i.user_login || undefined,
|
|
channelExternalId: i.user_login || undefined,
|
|
channelAvatarUrl: undefined,
|
|
uploadedDate: i.created_at || '',
|
|
duration: this.parseTwitchDurationToSeconds(i.duration || '0s'),
|
|
views: Number(i.view_count || i.viewer_count || 0),
|
|
uploaded: i.created_at ? Date.parse(i.created_at) : 0,
|
|
isLive: false,
|
|
});
|
|
|
|
// Twitch Streams mapper (for trending popular live streams)
|
|
// Les streams Helix sont TOUJOURS en direct : type normalisé 'live' + isLive.
|
|
// Le thumbnail Helix utilise le motif "{width}x{height}" (ex. ...-{width}x{height}.jpg).
|
|
private mapTwitchStreamToVideo = (i: any): Video => {
|
|
const rawThumb: string = String(i.thumbnail_url || '');
|
|
const resolvedThumb = rawThumb
|
|
.replace('{width}x{height}', '640x360')
|
|
.replace('{width}', '640')
|
|
.replace('{height}', '360')
|
|
|| 'https://static-cdn.jtvnw.net/ttv-static/404_preview-640x360.jpg';
|
|
const avatar = rawThumb
|
|
.replace('{width}x{height}', '70x70')
|
|
.replace('{width}', '70')
|
|
.replace('{height}', '70');
|
|
return {
|
|
url: `https://www.twitch.tv/${i.user_login}`,
|
|
videoId: i.user_login || i.id || '',
|
|
type: 'live',
|
|
provider: 'twitch',
|
|
title: i.title || '',
|
|
thumbnail: resolvedThumb,
|
|
uploaderName: i.user_name || '',
|
|
uploaderUrl: `https://www.twitch.tv/${i.user_login}`,
|
|
uploaderAvatar: avatar,
|
|
channelId: i.user_id || undefined,
|
|
channelHandle: i.user_login || undefined,
|
|
channelExternalId: i.user_login || undefined,
|
|
channelAvatarUrl: avatar || undefined,
|
|
uploadedDate: i.started_at || '',
|
|
duration: 0,
|
|
views: Number(i.viewer_count || 0),
|
|
uploaded: i.started_at ? Date.parse(i.started_at) : 0,
|
|
isLive: true,
|
|
} as Video;
|
|
};
|
|
|
|
private mapTwitchChannelToVideo = (i: any): Video => {
|
|
// /search/channels : thumbnail_url = image de profil (carrée), PAS une miniature 16:9.
|
|
// On la garde comme avatar + miniature (object-cover côté template) et on
|
|
// distingue bien les chaînes hors-ligne (type 'channel') des directs.
|
|
const rawThumb: string = String(i.thumbnail_url || '');
|
|
const login: string = String(i.broadcaster_login || i.user_login || '');
|
|
const display: string = String(i.display_name || i.broadcaster_name || i.user_name || login || '');
|
|
const live = i?.is_live === true;
|
|
const thumb = rawThumb || 'https://static-cdn.jtvnw.net/ttv-static/404_preview-640x360.jpg';
|
|
return {
|
|
url: `https://www.twitch.tv/${login}`,
|
|
videoId: login || String(i.id || ''),
|
|
type: live ? 'live' : 'channel',
|
|
provider: 'twitch',
|
|
title: (live && i.title) ? String(i.title) : display,
|
|
thumbnail: thumb,
|
|
uploaderName: display,
|
|
uploaderUrl: login ? `https://www.twitch.tv/${login}` : '',
|
|
uploaderAvatar: rawThumb || '',
|
|
channelId: i.id || undefined,
|
|
channelHandle: login || undefined,
|
|
channelExternalId: login || undefined,
|
|
channelAvatarUrl: rawThumb || undefined,
|
|
uploadedDate: live ? (i.started_at || '') : '',
|
|
duration: 0,
|
|
views: 0,
|
|
uploaded: live && i.started_at ? Date.parse(i.started_at) : 0,
|
|
isLive: live,
|
|
} as Video;
|
|
};
|
|
|
|
// Twitch Clips mapper (Shorts-equivalent)
|
|
private mapTwitchClipToVideo = (i: any): Video => ({
|
|
url: i.url || `https://clips.twitch.tv/${i.id}`,
|
|
videoId: i.id || '',
|
|
type: 'video',
|
|
provider: 'twitch',
|
|
kind: 'clip',
|
|
title: i.title || '',
|
|
// Clip thumbnails often have width/height placeholders or fixed preview sizes
|
|
thumbnail: (i.thumbnail_url || '').replace('%{width}', '640').replace('%{height}', '360'),
|
|
uploaderName: i.broadcaster_name || i.creator_name || '',
|
|
uploaderUrl: i.broadcaster_name ? `https://www.twitch.tv/${i.broadcaster_name}` : '',
|
|
uploaderAvatar: '',
|
|
channelId: i.broadcaster_id || undefined,
|
|
channelHandle: undefined,
|
|
channelExternalId: undefined,
|
|
channelAvatarUrl: undefined,
|
|
uploadedDate: i.created_at || '',
|
|
duration: Number(i.duration || 0),
|
|
views: Number(i.view_count || 0),
|
|
uploaded: i.created_at ? Date.parse(i.created_at) : 0,
|
|
isLive: false,
|
|
});
|
|
|
|
/**
|
|
* Search Twitch Clips by first finding channels for a query (or recent popular channels when empty),
|
|
* then fetching recent clips per broadcaster. Returns up to ~24 clips with pagination via channel search cursor.
|
|
*/
|
|
public searchTwitchClipsPage(query: string, cursor?: string | null): Observable<PagedResult<Video>> {
|
|
return this.getTwitchAuthToken().pipe(
|
|
switchMap(token => {
|
|
if (!token) return of({ items: [], nextCursor: null });
|
|
const headers = new HttpHeaders({ 'Client-ID': this.resolveTwitchClientId()!, 'Authorization': `Bearer ${token}` });
|
|
const after = cursor ? `&after=${encodeURIComponent(cursor)}` : '';
|
|
const q = String(query || '');
|
|
const chPrimary = `/api/twitch-api/helix/search/channels?query=${encodeURIComponent(q)}&first=10${after}`;
|
|
const chFallback = `/proxy/twitch-api/helix/search/channels?query=${encodeURIComponent(q)}&first=10${after}`;
|
|
return this.http.get<any>(chPrimary, { headers }).pipe(
|
|
catchError(() => this.http.get<any>(chFallback, { headers })),
|
|
switchMap(chRes => {
|
|
const channels = Array.isArray(chRes?.data) ? chRes.data : [];
|
|
const userIds: string[] = channels.map((c: any) => c?.id).filter(Boolean).slice(0, 10);
|
|
if (userIds.length === 0) return of({ items: [], nextCursor: null } as PagedResult<Video>);
|
|
const since = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString();
|
|
const perUserRequests = userIds.map(uid => {
|
|
const cPrimary = `/api/twitch-api/helix/clips?broadcaster_id=${encodeURIComponent(uid)}&first=5&started_at=${encodeURIComponent(since)}`;
|
|
const cFallback = `/proxy/twitch-api/helix/clips?broadcaster_id=${encodeURIComponent(uid)}&first=5&started_at=${encodeURIComponent(since)}`;
|
|
return this.http.get<any>(cPrimary, { headers }).pipe(
|
|
catchError(() => this.http.get<any>(cFallback, { headers })),
|
|
map(res => Array.isArray(res?.data) ? res.data : [])
|
|
);
|
|
});
|
|
return forkJoin(perUserRequests).pipe(
|
|
map((lists: any[][]) => lists.flat().slice(0, 24)),
|
|
map((clips: any[]) => ({
|
|
items: clips.map((i: any) => this.mapTwitchClipToVideo(i)),
|
|
nextCursor: chRes?.pagination?.cursor || null,
|
|
} as PagedResult<Video>)),
|
|
catchError(() => of({ items: [], nextCursor: null } as PagedResult<Video>))
|
|
);
|
|
}),
|
|
catchError((e) => { console.error('Twitch clips search error', e); return of({ items: [], nextCursor: null }); })
|
|
);
|
|
})
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Top live streams Twitch (Helix /streams) — utilisé comme "trending" Twitch
|
|
* et comme filet de sécurité quand une recherche thématique ne retourne rien
|
|
* (la recherche de chaînes Helix exige des noms proches de la requête et
|
|
* filtre souvent tout pour des thèmes génériques comme "sports" ou "tech").
|
|
*/
|
|
public getTwitchTopStreamsPage(cursor?: string | null, limit = 24): Observable<PagedResult<Video>> {
|
|
return this.getTwitchAuthToken().pipe(
|
|
switchMap(token => {
|
|
if (!token) return of({ items: [], nextCursor: null });
|
|
const headers = new HttpHeaders({ 'Client-ID': this.resolveTwitchClientId()!, 'Authorization': `Bearer ${token}` });
|
|
const after = cursor ? `&after=${encodeURIComponent(cursor)}` : '';
|
|
const primary = `/api/twitch-api/helix/streams?first=${limit}${after}`;
|
|
const fallback = `/proxy/twitch-api/helix/streams?first=${limit}${after}`;
|
|
return this.http.get<any>(primary, { headers }).pipe(
|
|
catchError(() => this.http.get<any>(fallback, { headers })),
|
|
map(res => ({
|
|
items: (res.data || []).map((i: any) => this.mapTwitchStreamToVideo(i)),
|
|
nextCursor: res.pagination?.cursor || null,
|
|
} as PagedResult<Video>)),
|
|
catchError((e) => { console.error('Twitch top streams error', e); return of({ items: [], nextCursor: null }); })
|
|
);
|
|
})
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Recherche thématique Twitch robuste : VODs puis clips, avec fallback vers
|
|
* les top streams live si les deux sont quasi vides (évite les blocs vides
|
|
* sur les pages de thèmes). `minResults` = seuil sous lequel on complète.
|
|
*/
|
|
public searchTwitchThemePage(query: string, cursor?: string | null, minResults = 4): Observable<PagedResult<Video>> {
|
|
return this.searchTwitchVodsPage(query, cursor).pipe(
|
|
switchMap(vods => {
|
|
if ((vods?.items?.length || 0) >= minResults) return of(vods);
|
|
return this.searchTwitchClipsPage(query, cursor).pipe(
|
|
map(clips => ({
|
|
items: [...(vods?.items || []), ...(clips?.items || [])],
|
|
nextCursor: clips?.nextCursor || vods?.nextCursor || null,
|
|
} as PagedResult<Video>)),
|
|
switchMap(merged => {
|
|
if ((merged?.items?.length || 0) >= minResults) return of(merged);
|
|
// Filet de sécurité : top streams live (jamais vide quand Twitch est configuré)
|
|
return this.getTwitchTopStreamsPage(cursor).pipe(
|
|
map(top => {
|
|
if (!top.items.length) return merged;
|
|
const seen = new Set((merged.items || []).map(v => v.videoId));
|
|
const extra = top.items.filter(v => !seen.has(v.videoId));
|
|
return { items: [...(merged.items || []), ...extra], nextCursor: top.nextCursor } as PagedResult<Video>;
|
|
}),
|
|
catchError(() => of(merged))
|
|
);
|
|
})
|
|
);
|
|
})
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Clips Twitch sans requête (page Shorts) : la recherche de chaînes Helix
|
|
* rejette les requêtes vides, on part donc des top streams pour obtenir des
|
|
* broadcaster_id valides puis on récupère leurs clips récents.
|
|
*/
|
|
public getTwitchClipsFeed(cursor?: string | null): Observable<PagedResult<Video>> {
|
|
return this.getTwitchAuthToken().pipe(
|
|
switchMap(token => {
|
|
if (!token) return of({ items: [], nextCursor: null });
|
|
const headers = new HttpHeaders({ 'Client-ID': this.resolveTwitchClientId()!, 'Authorization': `Bearer ${token}` });
|
|
const after = cursor ? `&after=${encodeURIComponent(cursor)}` : '';
|
|
const sPrimary = `/api/twitch-api/helix/streams?first=10${after}`;
|
|
const sFallback = `/proxy/twitch-api/helix/streams?first=10${after}`;
|
|
return this.http.get<any>(sPrimary, { headers }).pipe(
|
|
catchError(() => this.http.get<any>(sFallback, { headers })),
|
|
switchMap(sRes => {
|
|
const streams = Array.isArray(sRes?.data) ? sRes.data : [];
|
|
const userIds: string[] = streams.map((s: any) => s?.user_id).filter(Boolean).slice(0, 10);
|
|
if (!userIds.length) return of({ items: [], nextCursor: null } as PagedResult<Video>);
|
|
const since = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString();
|
|
const perUser = userIds.map(uid => {
|
|
const cPrimary = `/api/twitch-api/helix/clips?broadcaster_id=${encodeURIComponent(uid)}&first=5&started_at=${encodeURIComponent(since)}`;
|
|
const cFallback = `/proxy/twitch-api/helix/clips?broadcaster_id=${encodeURIComponent(uid)}&first=5&started_at=${encodeURIComponent(since)}`;
|
|
return this.http.get<any>(cPrimary, { headers }).pipe(
|
|
catchError(() => this.http.get<any>(cFallback, { headers })),
|
|
map(res => Array.isArray(res?.data) ? res.data : [])
|
|
);
|
|
});
|
|
return forkJoin(perUser).pipe(
|
|
map((lists: any[][]) => lists.flat().slice(0, 24)),
|
|
map((clips: any[]) => ({
|
|
items: clips.map((i: any) => this.mapTwitchClipToVideo(i)),
|
|
nextCursor: sRes?.pagination?.cursor || null,
|
|
} as PagedResult<Video>)),
|
|
catchError(() => of({ items: [], nextCursor: null } as PagedResult<Video>))
|
|
);
|
|
}),
|
|
catchError((e) => { console.error('Twitch clips feed error', e); return of({ items: [], nextCursor: null }); })
|
|
);
|
|
})
|
|
);
|
|
}
|
|
|
|
private parseISODurationToSeconds(iso: string): number {
|
|
// ... (rest of the code remains the same)
|
|
const m = /^PT(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)S)?$/i.exec(iso || '');
|
|
if (!m) return 0;
|
|
const h = parseInt(m[1] || '0', 10);
|
|
const mn = parseInt(m[2] || '0', 10);
|
|
const s = parseInt(m[3] || '0', 10);
|
|
return h * 3600 + mn * 60 + s;
|
|
}
|
|
|
|
private resolveYouTubeApiKey(): string | undefined {
|
|
const g: any = globalThis as any;
|
|
const fromGlobal = g?.YOUTUBE_API_KEY;
|
|
const fromImportMeta = (typeof import.meta !== 'undefined' && (import.meta as any).env)
|
|
? ((import.meta as any).env.YOUTUBE_API_KEY || (import.meta as any).env.NG_APP_YOUTUBE_API_KEY)
|
|
: undefined;
|
|
const fromProcess = (g?.process?.env) ? (g.process.env.YOUTUBE_API_KEY || g.process.env.NG_APP_YOUTUBE_API_KEY) : undefined;
|
|
return fromGlobal || fromImportMeta || fromProcess || undefined;
|
|
}
|
|
|
|
// ---- Multi-key helpers ----
|
|
private loadYouTubeKeys(): string[] {
|
|
const g: any = globalThis as any;
|
|
const keys: string[] = [];
|
|
try {
|
|
// Prefer explicit array window.YOUTUBE_API_KEYS
|
|
const arr = Array.isArray(g?.YOUTUBE_API_KEYS) ? g.YOUTUBE_API_KEYS : null;
|
|
if (arr && arr.length) keys.push(...arr.map((s: any) => String(s).trim()).filter(Boolean));
|
|
} catch {}
|
|
try {
|
|
// Comma-separated string support
|
|
const csv = g?.YOUTUBE_API_KEYS;
|
|
if (!Array.isArray(csv) && typeof csv === 'string' && csv.includes(',')) {
|
|
keys.push(...csv.split(',').map((s: string) => s.trim()).filter(Boolean));
|
|
}
|
|
} catch {}
|
|
try {
|
|
// Env-based multi-keys
|
|
const im: any = (typeof import.meta !== 'undefined' && (import.meta as any).env) ? (import.meta as any).env : undefined;
|
|
const fromEnvCsv = im?.YOUTUBE_API_KEYS || im?.NG_APP_YOUTUBE_API_KEYS || (globalThis as any)?.process?.env?.YOUTUBE_API_KEYS || (globalThis as any)?.process?.env?.NG_APP_YOUTUBE_API_KEYS;
|
|
if (typeof fromEnvCsv === 'string' && fromEnvCsv.includes(',')) {
|
|
keys.push(...fromEnvCsv.split(',').map((s: string) => s.trim()).filter(Boolean));
|
|
}
|
|
} catch {}
|
|
// Fallback single key
|
|
const single = this.resolveYouTubeApiKey();
|
|
if (single) keys.push(String(single));
|
|
// De-duplicate and return
|
|
const uniq = Array.from(new Set(keys.filter(Boolean)));
|
|
return uniq;
|
|
}
|
|
|
|
private isKeyBanned(k: string): boolean {
|
|
const until = this.ytKeyBans.get(k) || 0;
|
|
return Date.now() < until;
|
|
}
|
|
|
|
private banYouTubeKey(k: string) {
|
|
if (!k) return;
|
|
const until = Date.now() + this.YT_KEY_BAN_MS;
|
|
this.ytKeyBans.set(k, until);
|
|
}
|
|
|
|
private getActiveYouTubeKey(): string | undefined {
|
|
// If no keys loaded, attempt to load once
|
|
if (!this.ytKeys || this.ytKeys.length === 0) this.ytKeys = this.loadYouTubeKeys();
|
|
const n = this.ytKeys.length;
|
|
if (!n) return undefined;
|
|
// Round-robin until we find a non-banned key
|
|
for (let i = 0; i < n; i++) {
|
|
const idx = (this.ytKeyIndex + i) % n;
|
|
const candidate = this.ytKeys[idx];
|
|
if (!this.isKeyBanned(candidate)) {
|
|
this.ytKeyIndex = (idx + 1) % n; // advance pointer for next call
|
|
return candidate;
|
|
}
|
|
}
|
|
// All keys currently banned
|
|
return undefined;
|
|
}
|
|
|
|
private resolveTwitchClientId(): string | undefined {
|
|
const g: any = globalThis as any;
|
|
return this.twitchServerClientId || g?.TWITCH_CLIENT_ID || (typeof import.meta !== 'undefined' && (import.meta as any).env?.TWITCH_CLIENT_ID) || g?.process?.env?.TWITCH_CLIENT_ID;
|
|
}
|
|
|
|
private getTwitchAuthToken(): Observable<string | null> {
|
|
// Le token applicatif est obtenu via notre serveur (/api/twitch-token) :
|
|
// TWITCH_CLIENT_SECRET ne quitte jamais le backend.
|
|
return this.http.get<any>('/api/twitch-token').pipe(
|
|
map(res => {
|
|
if (res?.accessToken) {
|
|
if (res?.clientId) this.twitchServerClientId = String(res.clientId);
|
|
return String(res.accessToken);
|
|
}
|
|
return null;
|
|
}),
|
|
shareReplay(1),
|
|
catchError(() => of(null))
|
|
);
|
|
}
|
|
|
|
private parseTwitchDurationToSeconds(duration: string): number {
|
|
let totalSeconds = 0;
|
|
if (duration.includes('h')) {
|
|
totalSeconds += parseInt(duration.split('h')[0]) * 3600;
|
|
duration = duration.split('h')[1];
|
|
}
|
|
if (duration.includes('m')) {
|
|
totalSeconds += parseInt(duration.split('m')[0]) * 60;
|
|
duration = duration.split('m')[1];
|
|
}
|
|
if (duration.includes('s')) {
|
|
totalSeconds += parseInt(duration.split('s')[0]);
|
|
}
|
|
return totalSeconds;
|
|
}
|
|
|
|
// Dev proxy helpers with fallback to direct URLs (returns Observable<any>)
|
|
private fetchYouTube(path: string, params: URLSearchParams, _activeKey?: string) {
|
|
const qs = params.toString();
|
|
const cachedProd = `/api/yt${path}?${qs}`; // server cache in prod
|
|
const cachedDev = `/proxy/api/yt${path}?${qs}`; // dev proxy to server cache
|
|
const direct = `https://www.googleapis.com${path}?${qs}`;
|
|
const proxied = `/proxy/yt${path}?${qs}`;
|
|
// Try prod server cache → dev server cache → direct → dev proxy
|
|
return this.http.get<any>(cachedProd).pipe(
|
|
catchError(() => this.http.get<any>(cachedDev).pipe(
|
|
catchError((_e1) => this.http.get<any>(direct).pipe(
|
|
catchError((err) => {
|
|
console.warn('YouTube direct call failed, trying /proxy/yt...', err);
|
|
return this.http.get<any>(proxied);
|
|
})
|
|
))
|
|
))
|
|
);
|
|
}
|
|
|
|
private fetchDailymotion(path: string, params: URLSearchParams) {
|
|
const prod = `/api/dm${path}?${params.toString()}`;
|
|
const proxied = `/proxy/dm${path}?${params.toString()}`;
|
|
const direct = `https://api.dailymotion.com${path}?${params.toString()}`;
|
|
return this.http.get<any>(prod).pipe(
|
|
catchError(() => this.http.get<any>(proxied).pipe(
|
|
catchError(() => this.http.get<any>(direct))
|
|
))
|
|
);
|
|
}
|
|
|
|
private fetchRumble(path: string, params: URLSearchParams) {
|
|
const url = `/api/rumble${path}?${params.toString()}`;
|
|
return this.http.get<any>(url).pipe(
|
|
catchError((err) => {
|
|
console.error('Rumble API call via proxy failed', err);
|
|
return of({ items: [], total: 0 });
|
|
})
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Fetch durations (in seconds) for a list of YouTube video IDs.
|
|
* Non-embeddable videos (status.embeddable === false) are excluded via
|
|
* a -1 marker so Shorts/feed callers can drop them (player error 153).
|
|
*/
|
|
public getYouTubeDurations(ids: string[]): Observable<Record<string, number>> {
|
|
const apiKey = this.getActiveYouTubeKey();
|
|
if (!apiKey || !ids.length) {
|
|
return of({});
|
|
}
|
|
|
|
const params = new URLSearchParams({
|
|
key: apiKey,
|
|
part: 'contentDetails,status',
|
|
id: ids.join(','),
|
|
});
|
|
|
|
return this.fetchYouTube('/youtube/v3/videos', params, apiKey).pipe(
|
|
map((res: any) => Array.isArray(res?.items) ? res.items : []),
|
|
map((items: any[]) => items.reduce((acc: Record<string, number>, item: any) => {
|
|
const duration = item?.contentDetails?.duration || 'PT0S';
|
|
const id = String(item?.id || '');
|
|
if (!id) return acc;
|
|
// -1 = non-embeddable (à exclure côté Shorts pour éviter l'erreur 153)
|
|
if (item?.status && item.status.embeddable === false) {
|
|
acc[id] = -1;
|
|
return acc;
|
|
}
|
|
acc[id] = this.parseISODurationToSeconds(duration);
|
|
return acc;
|
|
}, {} as Record<string, number>)),
|
|
catchError(() => of({}))
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Fetch minimal details (duration seconds + viewCount) for a list of YouTube IDs.
|
|
* Non-embeddable entries get duration -1 so callers can drop them (error 153).
|
|
*/
|
|
private getYouTubeContentAndStats(ids: string[]): Observable<Record<string, { duration: number; views: number }>> {
|
|
const apiKey = this.getActiveYouTubeKey();
|
|
if (!apiKey || !ids.length) return of({});
|
|
const params = new URLSearchParams({
|
|
key: apiKey,
|
|
part: 'contentDetails,statistics,status',
|
|
id: ids.join(','),
|
|
maxResults: String(Math.min(50, ids.length)),
|
|
// Add safeSearch for consistency
|
|
safeSearch: 'moderate',
|
|
});
|
|
return this.fetchYouTube('/youtube/v3/videos', params, apiKey).pipe(
|
|
map((res: any) => Array.isArray(res?.items) ? res.items : []),
|
|
map((items: any[]) => {
|
|
const out: Record<string, { duration: number; views: number }> = {};
|
|
for (const it of items) {
|
|
const id = String(it?.id || '');
|
|
if (!id) continue;
|
|
if (it?.status && it.status.embeddable === false) {
|
|
out[id] = { duration: -1, views: Number(it?.statistics?.viewCount || 0) };
|
|
continue;
|
|
}
|
|
const duration = this.parseISODurationToSeconds(it?.contentDetails?.duration || 'PT0S');
|
|
const views = Number(it?.statistics?.viewCount || 0);
|
|
out[id] = { duration, views };
|
|
}
|
|
return out;
|
|
}),
|
|
catchError(() => of({} as Record<string, { duration: number; views: number }>))
|
|
);
|
|
}
|
|
} |