1339 lines
41 KiB
TypeScript
1339 lines
41 KiB
TypeScript
/* eslint-disable @typescript-eslint/no-explicit-any */
|
||
|
||
import { NextRequest, NextResponse } from 'next/server';
|
||
|
||
import { getAuthInfoFromCookie } from '@/lib/auth';
|
||
import { getAvailableApiSites, getCacheTime, getConfig } from '@/lib/config';
|
||
import { getDetailFromApiV2 } from '@/lib/downstream';
|
||
import { getProxyToken } from '@/lib/emby-token';
|
||
import { hasFeaturePermission } from '@/lib/permissions';
|
||
import {
|
||
createBaiduNetdiskSession,
|
||
getBaiduNetdiskSession,
|
||
parseBaiduNetdiskId,
|
||
refreshBaiduNetdiskSession,
|
||
} from '@/lib/netdisk/baidu-session-cache';
|
||
import {
|
||
createMobileNetdiskSession,
|
||
getMobileNetdiskSession,
|
||
parseMobileNetdiskId,
|
||
refreshMobileNetdiskSession,
|
||
} from '@/lib/netdisk/mobile-session-cache';
|
||
import {
|
||
createPan123NetdiskSession,
|
||
getPan123NetdiskSession,
|
||
parsePan123NetdiskId,
|
||
refreshPan123NetdiskSession,
|
||
} from '@/lib/netdisk/pan123-session-cache';
|
||
import {
|
||
createPan115NetdiskSession,
|
||
getPan115NetdiskSession,
|
||
parsePan115NetdiskId,
|
||
refreshPan115NetdiskSession,
|
||
} from '@/lib/netdisk/pan115-session-cache';
|
||
import {
|
||
createQuarkNetdiskSession,
|
||
getQuarkNetdiskSession,
|
||
parseQuarkNetdiskId,
|
||
refreshQuarkNetdiskSession,
|
||
} from '@/lib/netdisk/quark-session-cache';
|
||
import {
|
||
LEGACY_QUARK_TEMP_SOURCE,
|
||
NETDISK_115_SOURCE,
|
||
NETDISK_123_SOURCE,
|
||
NETDISK_BAIDU_SOURCE,
|
||
NETDISK_MOBILE_SOURCE,
|
||
NETDISK_QUARK_SOURCE,
|
||
NETDISK_TIANYI_SOURCE,
|
||
NETDISK_UC_SOURCE,
|
||
isNetdiskSource,
|
||
normalizeNetdiskSource,
|
||
} from '@/lib/netdisk/source';
|
||
import {
|
||
createTianyiNetdiskSession,
|
||
getTianyiNetdiskSession,
|
||
parseTianyiNetdiskId,
|
||
refreshTianyiNetdiskSession,
|
||
} from '@/lib/netdisk/tianyi-session-cache';
|
||
import {
|
||
createUCNetdiskSession,
|
||
getUCNetdiskSession,
|
||
parseUCNetdiskId,
|
||
refreshUCNetdiskSession,
|
||
} from '@/lib/netdisk/uc-session-cache';
|
||
import {
|
||
executeSavedSourceScript,
|
||
normalizeScriptDetailResult,
|
||
normalizeScriptSources,
|
||
parseScriptSourceValue,
|
||
} from '@/lib/source-script';
|
||
|
||
export const runtime = 'nodejs';
|
||
|
||
/**
|
||
* 解析站点 origin。
|
||
* 优先级：SITE_BASE（站点 url 环境变量）> NEXT_PUBLIC_SITE_URL > 请求头 Host。
|
||
*/
|
||
function getRequestSiteOrigin(request: NextRequest): string {
|
||
const fromEnv =
|
||
(process.env.SITE_BASE || '').trim() ||
|
||
(process.env.NEXT_PUBLIC_SITE_URL || '').trim();
|
||
|
||
if (fromEnv) {
|
||
return fromEnv.replace(/\/$/, '');
|
||
}
|
||
|
||
let host =
|
||
request.headers.get('host') || request.headers.get('x-forwarded-host');
|
||
|
||
if (host && !/^[a-zA-Z0-9.-]+(:\d+)?$/.test(host)) {
|
||
host = null;
|
||
}
|
||
|
||
if (!host) {
|
||
try {
|
||
host = new URL(request.url).host;
|
||
} catch {
|
||
host = 'localhost';
|
||
}
|
||
}
|
||
|
||
const proto =
|
||
request.headers.get('x-forwarded-proto') ||
|
||
(host.includes('localhost') || host.includes('127.0.0.1')
|
||
? 'http'
|
||
: 'https');
|
||
|
||
return `${proto}://${host}`.replace(/\/$/, '');
|
||
}
|
||
|
||
/**
|
||
* MoonTVPlus APP / OrionTV 客户端：对配置的视频源 m3u8 套一层去广告代理。
|
||
* UA 小写包含 "moontvplus app" 或 "oriontv" 时生效（不匹配仅含 moontvplus 的其它客户端）。
|
||
*/
|
||
function applyClientAdProxyToEpisodes(
|
||
request: NextRequest,
|
||
sourceCode: string,
|
||
episodes: string[] | undefined,
|
||
clientAdSourceApis: string[] | undefined
|
||
): string[] | undefined {
|
||
if (!episodes || episodes.length === 0) return episodes;
|
||
if (!clientAdSourceApis || !clientAdSourceApis.includes(sourceCode)) {
|
||
return episodes;
|
||
}
|
||
|
||
const ua = (request.headers.get('user-agent') || '').toLowerCase();
|
||
if (!ua.includes('moontvplus app') && !ua.includes('oriontv')) {
|
||
return episodes;
|
||
}
|
||
|
||
const origin = getRequestSiteOrigin(request);
|
||
return episodes.map((episode) => {
|
||
if (!episode || typeof episode !== 'string') return episode;
|
||
if (
|
||
episode.includes('/api/proxy-m3u8') ||
|
||
episode.includes('/api/proxy/vod/m3u8')
|
||
) {
|
||
return episode;
|
||
}
|
||
// 仅处理 http(s) 直链 m3u8，站内相对播放地址不改写
|
||
if (!/^https?:\/\//i.test(episode)) return episode;
|
||
return `${origin}/api/proxy-m3u8?url=${encodeURIComponent(episode)}`;
|
||
});
|
||
}
|
||
|
||
function formatNetdiskEpisodeTitle(
|
||
parsed: {
|
||
season?: number;
|
||
episode?: number;
|
||
},
|
||
fallback: string
|
||
) {
|
||
if (parsed.season && parsed.episode) {
|
||
const season = String(Math.trunc(parsed.season)).padStart(2, '0');
|
||
const episodeValue = parsed.episode;
|
||
const episode = Number.isInteger(episodeValue)
|
||
? String(Math.trunc(episodeValue)).padStart(2, '0')
|
||
: String(episodeValue);
|
||
return `S${season}E${episode}`;
|
||
}
|
||
|
||
if (parsed.episode) {
|
||
const episodeValue = parsed.episode;
|
||
return Number.isInteger(episodeValue)
|
||
? `第${Math.trunc(episodeValue)}集`
|
||
: `第${episodeValue}集`;
|
||
}
|
||
|
||
return fallback;
|
||
}
|
||
|
||
/**
|
||
* 根据 source 和 id 直接获取视频详情
|
||
* 这个API专门用于play页面快速获取当前源的详情
|
||
*/
|
||
export async function GET(request: NextRequest) {
|
||
const authInfo = getAuthInfoFromCookie(request);
|
||
if (!authInfo || !authInfo.username) {
|
||
return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
|
||
}
|
||
|
||
const { searchParams } = new URL(request.url);
|
||
const id = searchParams.get('id');
|
||
const sourceCode = normalizeNetdiskSource(searchParams.get('source'));
|
||
const fileName = searchParams.get('fileName'); // 小雅源：用户点击的文件名
|
||
const title = searchParams.get('title');
|
||
const includeSpecialSources = searchParams.get('special') === '1';
|
||
|
||
if (!id || !sourceCode) {
|
||
return NextResponse.json({ error: '缺少必要参数' }, { status: 400 });
|
||
}
|
||
|
||
if (isNetdiskSource(sourceCode)) {
|
||
const allowed = await hasFeaturePermission(
|
||
authInfo.username,
|
||
'netdisk_temp_play'
|
||
);
|
||
if (!allowed) {
|
||
return NextResponse.json(
|
||
{ error: '无权限使用临时播放' },
|
||
{ status: 403 }
|
||
);
|
||
}
|
||
}
|
||
|
||
const parsedScriptSource = parseScriptSourceValue(sourceCode);
|
||
if (parsedScriptSource) {
|
||
try {
|
||
const sourcesExecution = await executeSavedSourceScript({
|
||
key: parsedScriptSource.scriptKey,
|
||
hook: 'getSources',
|
||
payload: {},
|
||
});
|
||
const sources = normalizeScriptSources(sourcesExecution.result);
|
||
const sourceInfo = sources.find(
|
||
(item) => item.id === parsedScriptSource.sourceId
|
||
) || {
|
||
id: parsedScriptSource.sourceId,
|
||
name: parsedScriptSource.sourceId,
|
||
};
|
||
|
||
const detailExecution = await executeSavedSourceScript({
|
||
key: parsedScriptSource.scriptKey,
|
||
hook: 'detail',
|
||
payload: {
|
||
id,
|
||
sourceId: parsedScriptSource.sourceId,
|
||
},
|
||
});
|
||
|
||
const normalized = normalizeScriptDetailResult({
|
||
source: sourceCode,
|
||
scriptKey: parsedScriptSource.scriptKey,
|
||
scriptName: detailExecution.meta?.name || parsedScriptSource.scriptKey,
|
||
sourceId: parsedScriptSource.sourceId,
|
||
sourceName: sourceInfo.name,
|
||
detailId: id,
|
||
result: detailExecution.result,
|
||
});
|
||
|
||
return NextResponse.json(normalized);
|
||
} catch (error) {
|
||
return NextResponse.json(
|
||
{ error: (error as Error).message },
|
||
{ status: 500 }
|
||
);
|
||
}
|
||
}
|
||
|
||
// 特殊处理 emby 源（支持多源）
|
||
if (sourceCode === 'emby' || sourceCode.startsWith('emby_')) {
|
||
try {
|
||
const config = await getConfig();
|
||
|
||
// 检查是否有启用的 Emby 源
|
||
if (
|
||
!config.EmbyConfig?.Sources ||
|
||
config.EmbyConfig.Sources.length === 0
|
||
) {
|
||
throw new Error('Emby 未配置或未启用');
|
||
}
|
||
|
||
// 解析 embyKey
|
||
let embyKey: string | undefined;
|
||
if (sourceCode.startsWith('emby_')) {
|
||
embyKey = sourceCode.substring(5); // 'emby_'.length = 5
|
||
}
|
||
|
||
// 使用 EmbyManager 获取客户端和配置
|
||
const { embyManager } = await import('@/lib/emby-manager');
|
||
const sources = await embyManager.getEnabledSources();
|
||
const sourceConfig = sources.find((s) => s.key === embyKey);
|
||
const sourceName = sourceConfig?.name || 'Emby';
|
||
|
||
const client = await embyManager.getClient(embyKey);
|
||
|
||
// 获取代理 token（图片/字幕代理使用；没有 token 时会回退到登录态校验）
|
||
const proxyToken = await getProxyToken(request);
|
||
|
||
// 获取媒体详情
|
||
const item = await client.getItem(id);
|
||
|
||
// 根据类型处理
|
||
if (item.Type === 'Movie') {
|
||
// 电影
|
||
const subtitles = client.getSubtitles(item, proxyToken);
|
||
|
||
const result = {
|
||
source: sourceCode, // 保持与请求一致（emby 或 emby_key）
|
||
source_name: sourceName,
|
||
id: item.Id,
|
||
title: item.Name,
|
||
poster: client.getImageUrl(
|
||
item.Id,
|
||
'Primary',
|
||
undefined,
|
||
proxyToken || undefined
|
||
),
|
||
year: item.ProductionYear?.toString() || '',
|
||
douban_id: 0,
|
||
desc: item.Overview || '',
|
||
episodes: [await client.getStreamUrl(item.Id)],
|
||
episodes_titles: [item.Name],
|
||
subtitles: subtitles.length > 0 ? [subtitles] : [],
|
||
proxyMode: false,
|
||
};
|
||
|
||
return NextResponse.json(result);
|
||
} else if (item.Type === 'Series') {
|
||
// 剧集 - 获取所有季和集
|
||
const seasons = await client.getSeasons(item.Id);
|
||
const allEpisodes: any[] = [];
|
||
|
||
for (const season of seasons) {
|
||
const episodes = await client.getEpisodes(item.Id, season.Id);
|
||
allEpisodes.push(...episodes);
|
||
}
|
||
|
||
// 按季和集排序
|
||
allEpisodes.sort((a, b) => {
|
||
if (a.ParentIndexNumber !== b.ParentIndexNumber) {
|
||
return (a.ParentIndexNumber || 0) - (b.ParentIndexNumber || 0);
|
||
}
|
||
return (a.IndexNumber || 0) - (b.IndexNumber || 0);
|
||
});
|
||
|
||
const result = {
|
||
source: sourceCode, // 保持与请求一致（emby 或 emby_key）
|
||
source_name: sourceName,
|
||
id: item.Id,
|
||
title: item.Name,
|
||
poster: client.getImageUrl(
|
||
item.Id,
|
||
'Primary',
|
||
undefined,
|
||
proxyToken || undefined
|
||
),
|
||
year: item.ProductionYear?.toString() || '',
|
||
douban_id: 0,
|
||
desc: item.Overview || '',
|
||
episodes: await Promise.all(
|
||
allEpisodes.map((ep) => client.getStreamUrl(ep.Id))
|
||
),
|
||
episodes_titles: allEpisodes.map((ep) => {
|
||
const seasonNum = ep.ParentIndexNumber || 1;
|
||
const episodeNum = ep.IndexNumber || 1;
|
||
return `S${seasonNum.toString().padStart(2, '0')}E${episodeNum
|
||
.toString()
|
||
.padStart(2, '0')}`;
|
||
}),
|
||
subtitles: allEpisodes.map((ep) => client.getSubtitles(ep, proxyToken)),
|
||
proxyMode: false,
|
||
};
|
||
|
||
return NextResponse.json(result);
|
||
} else {
|
||
throw new Error('不支持的媒体类型');
|
||
}
|
||
} catch (error) {
|
||
return NextResponse.json(
|
||
{ error: (error as Error).message },
|
||
{ status: 500 }
|
||
);
|
||
}
|
||
}
|
||
|
||
// 特殊处理 xiaoya 源
|
||
if (sourceCode === 'xiaoya') {
|
||
try {
|
||
const config = await getConfig();
|
||
const xiaoyaConfig = config.XiaoyaConfig;
|
||
|
||
if (!xiaoyaConfig || !xiaoyaConfig.Enabled || !xiaoyaConfig.ServerURL) {
|
||
throw new Error('小雅未配置或未启用');
|
||
}
|
||
|
||
const { XiaoyaClient } = await import('@/lib/xiaoya.client');
|
||
const { getXiaoyaMetadata, getXiaoyaEpisodes } = await import(
|
||
'@/lib/xiaoya-metadata'
|
||
);
|
||
const { base58Decode, base58Encode } = await import('@/lib/utils');
|
||
|
||
const client = new XiaoyaClient(
|
||
xiaoyaConfig.ServerURL,
|
||
xiaoyaConfig.Username,
|
||
xiaoyaConfig.Password,
|
||
xiaoyaConfig.Token
|
||
);
|
||
|
||
// 对id进行base58解码得到目录路径
|
||
let decodedDirPath: string;
|
||
try {
|
||
decodedDirPath = base58Decode(id);
|
||
console.log('[xiaoya] 解码目录路径:', decodedDirPath);
|
||
} catch (decodeError) {
|
||
console.error('[xiaoya] Base58解码失败:', decodeError);
|
||
throw new Error('无效的视频ID');
|
||
}
|
||
|
||
// 验证解码后的路径
|
||
if (!decodedDirPath || decodedDirPath.trim() === '') {
|
||
throw new Error('解码后的路径为空');
|
||
}
|
||
|
||
// 如果有fileName参数，拼接完整文件路径
|
||
let clickedFilePath: string | undefined;
|
||
if (fileName) {
|
||
// 拼接目录路径和文件名
|
||
clickedFilePath = `${decodedDirPath}${
|
||
decodedDirPath.endsWith('/') ? '' : '/'
|
||
}${fileName}`;
|
||
console.log('[xiaoya] 用户点击的文件路径:', clickedFilePath);
|
||
}
|
||
|
||
// 获取元数据（使用目录路径或点击的文件路径）
|
||
const metadataPath = clickedFilePath || decodedDirPath;
|
||
const metadata = await getXiaoyaMetadata(
|
||
client,
|
||
metadataPath,
|
||
config.SiteConfig.TMDBApiKey,
|
||
config.SiteConfig.TMDBProxy,
|
||
config.SiteConfig.TMDBReverseProxy
|
||
);
|
||
|
||
// 获取集数列表（使用目录路径或点击的文件路径）
|
||
const episodes = await getXiaoyaEpisodes(client, metadataPath);
|
||
|
||
// 如果有点击的文件路径，找到对应的集数索引
|
||
let clickedFileIndex = -1;
|
||
if (clickedFilePath) {
|
||
clickedFileIndex = episodes.findIndex(
|
||
(ep) => ep.path === clickedFilePath
|
||
);
|
||
console.log('[xiaoya] 文件在集数列表中的索引:', clickedFileIndex);
|
||
}
|
||
|
||
const result = {
|
||
source: 'xiaoya',
|
||
source_name: '小雅',
|
||
id: id, // 保持编码后的目录id
|
||
title: metadata.title,
|
||
poster: metadata.poster || '',
|
||
year: metadata.year || '',
|
||
douban_id: 0,
|
||
desc: metadata.plot || '',
|
||
episodes: episodes.map(
|
||
(ep) =>
|
||
`/api/xiaoya/play?path=${encodeURIComponent(base58Encode(ep.path))}`
|
||
),
|
||
episodes_titles: episodes.map((ep) => ep.title),
|
||
subtitles: [],
|
||
proxyMode: false,
|
||
// 返回用户点击的文件索引（如果找到的话）
|
||
initialEpisodeIndex:
|
||
clickedFileIndex >= 0 ? clickedFileIndex : undefined,
|
||
// 返回元数据来源
|
||
metadataSource: metadata.source,
|
||
};
|
||
|
||
return NextResponse.json(result);
|
||
} catch (error) {
|
||
console.error('[xiaoya] 获取详情失败:', error);
|
||
return NextResponse.json(
|
||
{ error: (error as Error).message },
|
||
{ status: 500 }
|
||
);
|
||
}
|
||
}
|
||
|
||
if (sourceCode === NETDISK_MOBILE_SOURCE) {
|
||
try {
|
||
const config = await getConfig();
|
||
const mobileConfig = config.NetDiskConfig?.Mobile;
|
||
if (!mobileConfig?.Enabled || !mobileConfig.Authorization) {
|
||
throw new Error('移动云盘未配置或未启用');
|
||
}
|
||
|
||
let session =
|
||
refreshMobileNetdiskSession(id) || getMobileNetdiskSession(id);
|
||
if (!session) {
|
||
const payload = parseMobileNetdiskId(id);
|
||
const { listMobileShareVideos } = await import(
|
||
'@/lib/netdisk/mobile.client'
|
||
);
|
||
const result = await listMobileShareVideos(
|
||
payload.shareUrl,
|
||
mobileConfig.Authorization
|
||
);
|
||
session = createMobileNetdiskSession({
|
||
title: title || result.title,
|
||
shareUrl: payload.shareUrl,
|
||
passcode: payload.passcode,
|
||
files: result.files,
|
||
});
|
||
}
|
||
if (!session) {
|
||
throw new Error('移动云盘播放信息恢复失败');
|
||
}
|
||
const mobileSession = session;
|
||
const { parseVideoFileName } = await import('@/lib/video-parser');
|
||
const parsedFiles = mobileSession.files
|
||
.map((file, index) => {
|
||
const parsed = parseVideoFileName(file.name);
|
||
return {
|
||
...file,
|
||
originalIndex: index,
|
||
sortEpisode: parsed.episode || index + 1,
|
||
isOVA: parsed.isOVA,
|
||
displayTitle: formatNetdiskEpisodeTitle(parsed, file.name),
|
||
};
|
||
})
|
||
.sort((a, b) => {
|
||
if (a.isOVA && !b.isOVA) return 1;
|
||
if (!a.isOVA && b.isOVA) return -1;
|
||
return a.sortEpisode !== b.sortEpisode
|
||
? a.sortEpisode - b.sortEpisode
|
||
: a.name.localeCompare(b.name, 'zh-Hans-CN', {
|
||
numeric: true,
|
||
sensitivity: 'base',
|
||
});
|
||
});
|
||
|
||
const episodes = parsedFiles.map(
|
||
(file) =>
|
||
`/api/netdisk/mobile/play?id=${encodeURIComponent(
|
||
mobileSession.id
|
||
)}&episodeIndex=${file.originalIndex}`
|
||
);
|
||
|
||
return NextResponse.json({
|
||
source: NETDISK_MOBILE_SOURCE,
|
||
source_name: '移动云盘',
|
||
id: mobileSession.id,
|
||
title: title || mobileSession.title,
|
||
poster: '',
|
||
year: '',
|
||
douban_id: 0,
|
||
desc: `移动云盘分享：${mobileSession.shareUrl}`,
|
||
episodes,
|
||
episodes_titles: parsedFiles.map((file) => file.displayTitle),
|
||
proxyMode: false,
|
||
});
|
||
} catch (error) {
|
||
return NextResponse.json(
|
||
{ error: (error as Error).message },
|
||
{ status: 500 }
|
||
);
|
||
}
|
||
}
|
||
|
||
if (sourceCode === NETDISK_BAIDU_SOURCE) {
|
||
try {
|
||
const config = await getConfig();
|
||
const baiduConfig = config.NetDiskConfig?.Baidu;
|
||
if (!baiduConfig?.Enabled || !baiduConfig.Cookie) {
|
||
throw new Error('百度网盘未配置或未启用');
|
||
}
|
||
|
||
let session =
|
||
refreshBaiduNetdiskSession(id) || getBaiduNetdiskSession(id);
|
||
if (!session) {
|
||
const payload = parseBaiduNetdiskId(id);
|
||
const { listBaiduShareVideos } = await import(
|
||
'@/lib/netdisk/baidu.client'
|
||
);
|
||
const result = await listBaiduShareVideos(
|
||
payload.shareUrl,
|
||
baiduConfig.Cookie,
|
||
payload.passcode || ''
|
||
);
|
||
session = createBaiduNetdiskSession({
|
||
title: title || result.title,
|
||
shareUrl: payload.shareUrl,
|
||
passcode: payload.passcode,
|
||
files: result.files,
|
||
meta: result.meta,
|
||
cookie: result.cookie,
|
||
});
|
||
}
|
||
if (!session) {
|
||
throw new Error('百度网盘播放信息恢复失败');
|
||
}
|
||
const baiduSession = session;
|
||
const { parseVideoFileName } = await import('@/lib/video-parser');
|
||
const parsedFiles = baiduSession.files
|
||
.map((file, index) => {
|
||
const parsed = parseVideoFileName(file.name);
|
||
return {
|
||
...file,
|
||
originalIndex: index,
|
||
sortEpisode: parsed.episode || index + 1,
|
||
isOVA: parsed.isOVA,
|
||
displayTitle: formatNetdiskEpisodeTitle(parsed, file.name),
|
||
};
|
||
})
|
||
.sort((a, b) => {
|
||
if (a.isOVA && !b.isOVA) return 1;
|
||
if (!a.isOVA && b.isOVA) return -1;
|
||
return a.sortEpisode !== b.sortEpisode
|
||
? a.sortEpisode - b.sortEpisode
|
||
: a.name.localeCompare(b.name, 'zh-Hans-CN', {
|
||
numeric: true,
|
||
sensitivity: 'base',
|
||
});
|
||
});
|
||
|
||
return NextResponse.json({
|
||
source: NETDISK_BAIDU_SOURCE,
|
||
source_name: '百度网盘',
|
||
id: baiduSession.id,
|
||
title: title || baiduSession.title,
|
||
poster: '',
|
||
year: '',
|
||
douban_id: 0,
|
||
desc: `百度网盘分享：${baiduSession.shareUrl}`,
|
||
episodes: parsedFiles.map(
|
||
(file) =>
|
||
`/api/netdisk/baidu/play?id=${encodeURIComponent(
|
||
baiduSession.id
|
||
)}&episodeIndex=${file.originalIndex}`
|
||
),
|
||
episodes_titles: parsedFiles.map((file) => file.displayTitle),
|
||
proxyMode: false,
|
||
});
|
||
} catch (error) {
|
||
return NextResponse.json(
|
||
{ error: (error as Error).message },
|
||
{ status: 500 }
|
||
);
|
||
}
|
||
}
|
||
|
||
if (sourceCode === NETDISK_TIANYI_SOURCE) {
|
||
try {
|
||
const config = await getConfig();
|
||
const tianyiConfig = config.NetDiskConfig?.Tianyi;
|
||
if (
|
||
!tianyiConfig?.Enabled ||
|
||
!tianyiConfig.Account ||
|
||
!tianyiConfig.Password
|
||
) {
|
||
throw new Error('天翼云盘未配置或未启用');
|
||
}
|
||
|
||
let session =
|
||
refreshTianyiNetdiskSession(id) || getTianyiNetdiskSession(id);
|
||
if (!session) {
|
||
const payload = parseTianyiNetdiskId(id);
|
||
const { listTianyiShareVideos } = await import(
|
||
'@/lib/netdisk/tianyi.client'
|
||
);
|
||
const result = await listTianyiShareVideos(
|
||
payload.shareUrl,
|
||
tianyiConfig.Account,
|
||
tianyiConfig.Password,
|
||
payload.passcode || ''
|
||
);
|
||
session = createTianyiNetdiskSession({
|
||
title: title || result.title,
|
||
shareUrl: payload.shareUrl,
|
||
passcode: payload.passcode,
|
||
shareId: result.shareId,
|
||
shareMode: result.shareMode,
|
||
isFolder: result.isFolder,
|
||
accessCode: result.accessCode,
|
||
files: result.files,
|
||
});
|
||
}
|
||
if (!session) {
|
||
throw new Error('天翼云盘播放信息恢复失败');
|
||
}
|
||
|
||
const tianyiSession = session;
|
||
const { parseVideoFileName } = await import('@/lib/video-parser');
|
||
const parsedFiles = tianyiSession.files
|
||
.map((file, index) => {
|
||
const parsed = parseVideoFileName(file.name);
|
||
return {
|
||
...file,
|
||
originalIndex: index,
|
||
sortEpisode: parsed.episode || index + 1,
|
||
isOVA: parsed.isOVA,
|
||
displayTitle: formatNetdiskEpisodeTitle(parsed, file.name),
|
||
};
|
||
})
|
||
.sort((a, b) => {
|
||
if (a.isOVA && !b.isOVA) return 1;
|
||
if (!a.isOVA && b.isOVA) return -1;
|
||
return a.sortEpisode !== b.sortEpisode
|
||
? a.sortEpisode - b.sortEpisode
|
||
: a.name.localeCompare(b.name, 'zh-Hans-CN', {
|
||
numeric: true,
|
||
sensitivity: 'base',
|
||
});
|
||
});
|
||
|
||
return NextResponse.json({
|
||
source: NETDISK_TIANYI_SOURCE,
|
||
source_name: '天翼云盘',
|
||
id: tianyiSession.id,
|
||
title: title || tianyiSession.title,
|
||
poster: '',
|
||
year: '',
|
||
douban_id: 0,
|
||
desc: `天翼云盘分享：${tianyiSession.shareUrl}`,
|
||
episodes: parsedFiles.map(
|
||
(file) =>
|
||
`/api/netdisk/tianyi/play?id=${encodeURIComponent(
|
||
tianyiSession.id
|
||
)}&episodeIndex=${file.originalIndex}`
|
||
),
|
||
episodes_titles: parsedFiles.map((file) => file.displayTitle),
|
||
proxyMode: false,
|
||
});
|
||
} catch (error) {
|
||
return NextResponse.json(
|
||
{ error: (error as Error).message },
|
||
{ status: 500 }
|
||
);
|
||
}
|
||
}
|
||
|
||
if (sourceCode === NETDISK_123_SOURCE) {
|
||
try {
|
||
const config = await getConfig();
|
||
const pan123Config = config.NetDiskConfig?.Pan123;
|
||
if (
|
||
!pan123Config?.Enabled ||
|
||
!pan123Config.Account ||
|
||
!pan123Config.Password
|
||
) {
|
||
throw new Error('123网盘未配置或未启用');
|
||
}
|
||
|
||
let session =
|
||
refreshPan123NetdiskSession(id) || getPan123NetdiskSession(id);
|
||
if (!session) {
|
||
const payload = parsePan123NetdiskId(id);
|
||
const { listPan123ShareVideos } = await import(
|
||
'@/lib/netdisk/pan123.client'
|
||
);
|
||
const result = await listPan123ShareVideos(
|
||
payload.shareUrl,
|
||
payload.passcode || ''
|
||
);
|
||
session = createPan123NetdiskSession({
|
||
title: title || result.title,
|
||
shareUrl: payload.shareUrl,
|
||
passcode: payload.passcode,
|
||
files: result.files,
|
||
});
|
||
}
|
||
if (!session) {
|
||
throw new Error('123网盘播放信息恢复失败');
|
||
}
|
||
|
||
const pan123Session = session;
|
||
const { parseVideoFileName } = await import('@/lib/video-parser');
|
||
const parsedFiles = pan123Session.files
|
||
.map((file, index) => {
|
||
const parsed = parseVideoFileName(file.fileName);
|
||
return {
|
||
...file,
|
||
originalIndex: index,
|
||
sortEpisode: parsed.episode || index + 1,
|
||
isOVA: parsed.isOVA,
|
||
displayTitle: formatNetdiskEpisodeTitle(parsed, file.fileName),
|
||
};
|
||
})
|
||
.sort((a, b) => {
|
||
if (a.isOVA && !b.isOVA) return 1;
|
||
if (!a.isOVA && b.isOVA) return -1;
|
||
return a.sortEpisode !== b.sortEpisode
|
||
? a.sortEpisode - b.sortEpisode
|
||
: a.fileName.localeCompare(b.fileName, 'zh-Hans-CN', {
|
||
numeric: true,
|
||
sensitivity: 'base',
|
||
});
|
||
});
|
||
|
||
return NextResponse.json({
|
||
source: NETDISK_123_SOURCE,
|
||
source_name: '123网盘',
|
||
id: pan123Session.id,
|
||
title: title || pan123Session.title,
|
||
poster: '',
|
||
year: '',
|
||
douban_id: 0,
|
||
desc: `123网盘分享：${pan123Session.shareUrl}`,
|
||
episodes: parsedFiles.map(
|
||
(file) =>
|
||
`/api/netdisk/123/play?id=${encodeURIComponent(
|
||
pan123Session.id
|
||
)}&episodeIndex=${file.originalIndex}`
|
||
),
|
||
episodes_titles: parsedFiles.map((file) => file.displayTitle),
|
||
proxyMode: false,
|
||
});
|
||
} catch (error) {
|
||
console.error('[netdisk-123][source-detail] error', error);
|
||
return NextResponse.json(
|
||
{ error: (error as Error).message },
|
||
{ status: 500 }
|
||
);
|
||
}
|
||
}
|
||
|
||
if (sourceCode === NETDISK_115_SOURCE) {
|
||
try {
|
||
const config = await getConfig();
|
||
const pan115Config = config.NetDiskConfig?.Pan115;
|
||
if (!pan115Config?.Enabled || !pan115Config.Cookie) {
|
||
throw new Error('115网盘未配置或未启用');
|
||
}
|
||
|
||
let session =
|
||
refreshPan115NetdiskSession(id) || getPan115NetdiskSession(id);
|
||
if (!session) {
|
||
const payload = parsePan115NetdiskId(id);
|
||
const { listPan115ShareVideos } = await import(
|
||
'@/lib/netdisk/pan115.client'
|
||
);
|
||
const result = await listPan115ShareVideos(
|
||
payload.shareUrl,
|
||
payload.passcode || ''
|
||
);
|
||
session = createPan115NetdiskSession({
|
||
title: title || result.title,
|
||
shareUrl: payload.shareUrl,
|
||
passcode: payload.passcode,
|
||
files: result.files,
|
||
});
|
||
}
|
||
if (!session) {
|
||
throw new Error('115网盘播放信息恢复失败');
|
||
}
|
||
|
||
const pan115Session = session;
|
||
const { parseVideoFileName } = await import('@/lib/video-parser');
|
||
const parsedFiles = pan115Session.files
|
||
.map((file, index) => {
|
||
const parsed = parseVideoFileName(file.name);
|
||
return {
|
||
...file,
|
||
originalIndex: index,
|
||
sortEpisode: parsed.episode || index + 1,
|
||
isOVA: parsed.isOVA,
|
||
displayTitle: formatNetdiskEpisodeTitle(parsed, file.name),
|
||
};
|
||
})
|
||
.sort((a, b) => {
|
||
if (a.isOVA && !b.isOVA) return 1;
|
||
if (!a.isOVA && b.isOVA) return -1;
|
||
return a.sortEpisode !== b.sortEpisode
|
||
? a.sortEpisode - b.sortEpisode
|
||
: a.name.localeCompare(b.name, 'zh-Hans-CN', {
|
||
numeric: true,
|
||
sensitivity: 'base',
|
||
});
|
||
});
|
||
|
||
return NextResponse.json({
|
||
source: NETDISK_115_SOURCE,
|
||
source_name: '115网盘',
|
||
id: pan115Session.id,
|
||
title: title || pan115Session.title,
|
||
poster: '',
|
||
year: '',
|
||
douban_id: 0,
|
||
desc: `115网盘分享：${pan115Session.shareUrl}`,
|
||
episodes: parsedFiles.map(
|
||
(file) =>
|
||
`/api/netdisk/115/play?id=${encodeURIComponent(
|
||
pan115Session.id
|
||
)}&episodeIndex=${file.originalIndex}`
|
||
),
|
||
episodes_titles: parsedFiles.map((file) => file.displayTitle),
|
||
proxyMode: false,
|
||
});
|
||
} catch (error) {
|
||
return NextResponse.json(
|
||
{ error: (error as Error).message },
|
||
{ status: 500 }
|
||
);
|
||
}
|
||
}
|
||
|
||
if (
|
||
sourceCode === NETDISK_QUARK_SOURCE ||
|
||
sourceCode === LEGACY_QUARK_TEMP_SOURCE
|
||
) {
|
||
try {
|
||
const config = await getConfig();
|
||
const quarkConfig = config.NetDiskConfig?.Quark;
|
||
if (!quarkConfig?.Enabled || !quarkConfig.Cookie) {
|
||
throw new Error('夸克网盘未配置或未启用');
|
||
}
|
||
const { parseVideoFileName } = await import('@/lib/video-parser');
|
||
|
||
let session =
|
||
refreshQuarkNetdiskSession(id) || getQuarkNetdiskSession(id);
|
||
if (!session) {
|
||
const payload = parseQuarkNetdiskId(id);
|
||
const { listQuarkShareVideos } = await import(
|
||
'@/lib/netdisk/quark.client'
|
||
);
|
||
const result = await listQuarkShareVideos(
|
||
payload.shareUrl,
|
||
quarkConfig.Cookie,
|
||
payload.passcode || ''
|
||
);
|
||
session = createQuarkNetdiskSession({
|
||
title: title || result.title,
|
||
shareUrl: payload.shareUrl,
|
||
passcode: payload.passcode,
|
||
shareId: result.shareId,
|
||
shareToken: result.shareToken,
|
||
files: result.files,
|
||
});
|
||
}
|
||
if (!session) {
|
||
throw new Error('夸克网盘播放信息恢复失败');
|
||
}
|
||
|
||
const quarkSession = session;
|
||
const episodes = quarkSession.files
|
||
.map((file, index) => {
|
||
const parsed = parseVideoFileName(file.name);
|
||
return {
|
||
originalIndex: index,
|
||
fileName: file.name,
|
||
episode: parsed.episode || index + 1,
|
||
title: formatNetdiskEpisodeTitle(parsed, file.name),
|
||
isOVA: parsed.isOVA,
|
||
};
|
||
})
|
||
.sort((a, b) => {
|
||
if (a.isOVA && !b.isOVA) return 1;
|
||
if (!a.isOVA && b.isOVA) return -1;
|
||
return a.episode !== b.episode
|
||
? a.episode - b.episode
|
||
: a.fileName.localeCompare(b.fileName);
|
||
});
|
||
|
||
return NextResponse.json({
|
||
source: NETDISK_QUARK_SOURCE,
|
||
source_name: '夸克网盘',
|
||
id: quarkSession.id,
|
||
title: title || quarkSession.title,
|
||
poster: '',
|
||
year: '',
|
||
douban_id: 0,
|
||
desc: `夸克网盘分享：${quarkSession.shareUrl}`,
|
||
episodes: episodes.map(
|
||
(ep) =>
|
||
`/api/netdisk/quark/play?id=${encodeURIComponent(
|
||
quarkSession.id
|
||
)}&episodeIndex=${ep.originalIndex}`
|
||
),
|
||
episodes_titles: episodes.map((ep) => ep.title),
|
||
proxyMode: false,
|
||
});
|
||
} catch (error) {
|
||
return NextResponse.json(
|
||
{ error: (error as Error).message },
|
||
{ status: 500 }
|
||
);
|
||
}
|
||
}
|
||
|
||
if (sourceCode === NETDISK_UC_SOURCE) {
|
||
try {
|
||
const config = await getConfig();
|
||
const ucConfig = config.NetDiskConfig?.UC;
|
||
if (!ucConfig?.Enabled || !ucConfig.Cookie) {
|
||
throw new Error('UC网盘未配置或未启用');
|
||
}
|
||
const { parseVideoFileName } = await import('@/lib/video-parser');
|
||
|
||
let session = refreshUCNetdiskSession(id) || getUCNetdiskSession(id);
|
||
if (!session) {
|
||
const payload = parseUCNetdiskId(id);
|
||
const { listUCShareVideos } = await import('@/lib/netdisk/uc.client');
|
||
const result = await listUCShareVideos(
|
||
payload.shareUrl,
|
||
ucConfig.Cookie,
|
||
payload.passcode || ''
|
||
);
|
||
session = createUCNetdiskSession({
|
||
title: title || result.title,
|
||
shareUrl: payload.shareUrl,
|
||
passcode: payload.passcode,
|
||
shareId: result.shareId,
|
||
shareToken: result.shareToken,
|
||
files: result.files,
|
||
});
|
||
}
|
||
if (!session) {
|
||
throw new Error('UC网盘播放信息恢复失败');
|
||
}
|
||
|
||
const ucSession = session;
|
||
const episodes = ucSession.files
|
||
.map((file, index) => {
|
||
const parsed = parseVideoFileName(file.name);
|
||
return {
|
||
originalIndex: index,
|
||
fileName: file.name,
|
||
episode: parsed.episode || index + 1,
|
||
title: formatNetdiskEpisodeTitle(parsed, file.name),
|
||
isOVA: parsed.isOVA,
|
||
};
|
||
})
|
||
.sort((a, b) => {
|
||
if (a.isOVA && !b.isOVA) return 1;
|
||
if (!a.isOVA && b.isOVA) return -1;
|
||
return a.episode !== b.episode
|
||
? a.episode - b.episode
|
||
: a.fileName.localeCompare(b.fileName);
|
||
});
|
||
|
||
return NextResponse.json({
|
||
source: NETDISK_UC_SOURCE,
|
||
source_name: 'UC网盘',
|
||
id: ucSession.id,
|
||
title: title || ucSession.title,
|
||
poster: '',
|
||
year: '',
|
||
douban_id: 0,
|
||
desc: `UC网盘分享：${ucSession.shareUrl}`,
|
||
episodes: episodes.map(
|
||
(ep) =>
|
||
`/api/netdisk/uc/play?id=${encodeURIComponent(
|
||
ucSession.id
|
||
)}&episodeIndex=${ep.originalIndex}`
|
||
),
|
||
episodes_titles: episodes.map((ep) => ep.title),
|
||
proxyMode: false,
|
||
});
|
||
} catch (error) {
|
||
return NextResponse.json(
|
||
{ error: (error as Error).message },
|
||
{ status: 500 }
|
||
);
|
||
}
|
||
}
|
||
|
||
// 特殊处理 openlist 源 - 直接调用 /api/detail
|
||
if (sourceCode === 'openlist') {
|
||
try {
|
||
const config = await getConfig();
|
||
const openListConfig = config.OpenListConfig;
|
||
|
||
if (
|
||
!openListConfig ||
|
||
!openListConfig.Enabled ||
|
||
!openListConfig.URL ||
|
||
!openListConfig.Username ||
|
||
!openListConfig.Password
|
||
) {
|
||
throw new Error('OpenList 未配置或未启用');
|
||
}
|
||
|
||
const rootPath = openListConfig.RootPath || '/';
|
||
|
||
// 1. 读取 metainfo 获取元数据
|
||
let metaInfo: any = null;
|
||
let folderMeta: any = null;
|
||
try {
|
||
const { getCachedMetaInfo, setCachedMetaInfo } = await import(
|
||
'@/lib/openlist-cache'
|
||
);
|
||
const { db } = await import('@/lib/db');
|
||
|
||
metaInfo = getCachedMetaInfo();
|
||
|
||
if (!metaInfo) {
|
||
const metainfoJson = await db.getGlobalValue('video.metainfo');
|
||
if (metainfoJson) {
|
||
metaInfo = JSON.parse(metainfoJson);
|
||
setCachedMetaInfo(metaInfo);
|
||
}
|
||
}
|
||
|
||
// 使用 key 查找文件夹信息
|
||
folderMeta = metaInfo?.folders?.[id];
|
||
if (!folderMeta) {
|
||
throw new Error('未找到该视频信息');
|
||
}
|
||
} catch (error) {
|
||
throw new Error('读取视频信息失败: ' + (error as Error).message);
|
||
}
|
||
|
||
// 使用 folderName 构建实际路径
|
||
const folderName = folderMeta.folderName;
|
||
const folderPath = `${rootPath}${
|
||
rootPath.endsWith('/') ? '' : '/'
|
||
}${folderName}`;
|
||
|
||
// 2. 直接调用 OpenList 客户端获取视频列表
|
||
const { OpenListClient } = await import('@/lib/openlist.client');
|
||
const { getCachedVideoInfo, setCachedVideoInfo } = await import(
|
||
'@/lib/openlist-cache'
|
||
);
|
||
const { parseVideoFileName } = await import('@/lib/video-parser');
|
||
|
||
const client = new OpenListClient(
|
||
openListConfig.URL,
|
||
openListConfig.Username,
|
||
openListConfig.Password
|
||
);
|
||
|
||
let videoInfo = getCachedVideoInfo(folderPath);
|
||
|
||
// 获取所有分页的视频文件
|
||
const allFiles: any[] = [];
|
||
let currentPage = 1;
|
||
const pageSize = 100;
|
||
let total = 0;
|
||
let hasMore = true;
|
||
|
||
while (hasMore) {
|
||
const listResponse = await client.listDirectory(
|
||
folderPath,
|
||
currentPage,
|
||
pageSize
|
||
);
|
||
|
||
if (listResponse.code !== 200) {
|
||
throw new Error('OpenList 列表获取失败4');
|
||
}
|
||
|
||
total = listResponse.data.total;
|
||
allFiles.push(...listResponse.data.content);
|
||
|
||
hasMore = allFiles.length < total;
|
||
currentPage++;
|
||
}
|
||
|
||
const videoExtensions = [
|
||
'.mp4',
|
||
'.mkv',
|
||
'.avi',
|
||
'.m3u8',
|
||
'.flv',
|
||
'.ts',
|
||
'.mov',
|
||
'.wmv',
|
||
'.webm',
|
||
'.rmvb',
|
||
'.rm',
|
||
'.mpg',
|
||
'.mpeg',
|
||
'.3gp',
|
||
'.f4v',
|
||
'.m4v',
|
||
'.vob',
|
||
];
|
||
const videoFiles = allFiles.filter((item) => {
|
||
if (
|
||
item.is_dir ||
|
||
item.name.startsWith('.') ||
|
||
item.name.endsWith('.json')
|
||
)
|
||
return false;
|
||
return videoExtensions.some((ext) =>
|
||
item.name.toLowerCase().endsWith(ext)
|
||
);
|
||
});
|
||
|
||
if (!videoInfo) {
|
||
videoInfo = { episodes: {}, last_updated: Date.now() };
|
||
videoFiles.sort((a, b) => a.name.localeCompare(b.name));
|
||
for (let i = 0; i < videoFiles.length; i++) {
|
||
const file = videoFiles[i];
|
||
const parsed = parseVideoFileName(file.name);
|
||
videoInfo.episodes[file.name] = {
|
||
episode: parsed.episode || i + 1,
|
||
season: parsed.season,
|
||
title: parsed.title,
|
||
parsed_from: 'filename',
|
||
isOVA: parsed.isOVA,
|
||
};
|
||
}
|
||
setCachedVideoInfo(folderPath, videoInfo);
|
||
}
|
||
|
||
const episodes = videoFiles
|
||
.map((file, index) => {
|
||
const parsed = parseVideoFileName(file.name);
|
||
let episodeInfo;
|
||
if (parsed.episode) {
|
||
episodeInfo = {
|
||
episode: parsed.episode,
|
||
season: parsed.season,
|
||
title: parsed.title,
|
||
parsed_from: 'filename',
|
||
isOVA: parsed.isOVA,
|
||
};
|
||
} else {
|
||
episodeInfo = videoInfo!.episodes[file.name] || {
|
||
episode: index + 1,
|
||
season: undefined,
|
||
title: undefined,
|
||
parsed_from: 'filename',
|
||
};
|
||
}
|
||
let displayTitle = episodeInfo.title;
|
||
if (!displayTitle && episodeInfo.episode) {
|
||
displayTitle = episodeInfo.isOVA
|
||
? `OVA ${episodeInfo.episode}`
|
||
: `第${episodeInfo.episode}集`;
|
||
}
|
||
if (!displayTitle) {
|
||
displayTitle = file.name;
|
||
}
|
||
return {
|
||
fileName: file.name,
|
||
episode: episodeInfo.episode || 0,
|
||
season: episodeInfo.season,
|
||
title: displayTitle,
|
||
isOVA: episodeInfo.isOVA,
|
||
};
|
||
})
|
||
.sort((a, b) => {
|
||
// OVA 排在最后
|
||
if (a.isOVA && !b.isOVA) return 1;
|
||
if (!a.isOVA && b.isOVA) return -1;
|
||
// 都是 OVA 或都不是 OVA，按集数排序
|
||
return a.episode !== b.episode
|
||
? a.episode - b.episode
|
||
: a.fileName.localeCompare(b.fileName);
|
||
});
|
||
|
||
// 3. 从 metainfo 中获取元数据
|
||
const { getTMDBImageUrl } = await import('@/lib/tmdb.search');
|
||
const { resolvePathMeta } = await import('@/lib/openlist-path-meta');
|
||
// folderName 为 metainfo 完整路径，PathMeta 最长前缀匹配
|
||
const pathMetaResolved = resolvePathMeta(
|
||
folderName,
|
||
openListConfig.PathMeta
|
||
);
|
||
|
||
const result = {
|
||
source: 'openlist',
|
||
source_name: '私人影库',
|
||
id: id,
|
||
title: folderMeta?.title || folderName,
|
||
poster: folderMeta?.poster_path
|
||
? getTMDBImageUrl(folderMeta.poster_path)
|
||
: '',
|
||
year: folderMeta?.release_date
|
||
? folderMeta.release_date.split('-')[0]
|
||
: '',
|
||
douban_id: 0,
|
||
desc: folderMeta?.overview || '',
|
||
episodes: episodes.map(
|
||
(ep) =>
|
||
`/api/openlist/play?folder=${encodeURIComponent(
|
||
folderName
|
||
)}&fileName=${encodeURIComponent(ep.fileName)}`
|
||
),
|
||
episodes_titles: episodes.map((ep) => ep.title),
|
||
proxyMode: false, // openlist 源不使用代理模式
|
||
category: pathMetaResolved.category || undefined,
|
||
refresh14m: pathMetaResolved.refresh14m,
|
||
};
|
||
|
||
return NextResponse.json(result);
|
||
} catch (error) {
|
||
return NextResponse.json(
|
||
{ error: (error as Error).message },
|
||
{ status: 500 }
|
||
);
|
||
}
|
||
}
|
||
|
||
if (!/^[\w-]+$/.test(id)) {
|
||
return NextResponse.json({ error: '无效的视频ID格式' }, { status: 400 });
|
||
}
|
||
|
||
// 对于其他采集源，直接按 id 获取详情。
|
||
try {
|
||
const apiSites = await getAvailableApiSites(authInfo.username, includeSpecialSources);
|
||
const apiSite = apiSites.find((site) => site.key === sourceCode);
|
||
|
||
if (!apiSite) {
|
||
return NextResponse.json({ error: '无效的API来源' }, { status: 400 });
|
||
}
|
||
|
||
const result = await getDetailFromApiV2(apiSite, id);
|
||
|
||
// 添加 proxyMode 到返回结果
|
||
const resultWithProxy = {
|
||
...result,
|
||
proxyMode: apiSite.proxyMode || false,
|
||
};
|
||
|
||
// 客户端广告配置：指定源 + APP/OrionTV UA 时 m3u8 套 proxy-m3u8
|
||
const adminConfig = await getConfig();
|
||
const clientAdEnabled = (adminConfig.ClientAdSourceApis || []).includes(
|
||
sourceCode
|
||
);
|
||
resultWithProxy.episodes =
|
||
applyClientAdProxyToEpisodes(
|
||
request,
|
||
sourceCode,
|
||
resultWithProxy.episodes,
|
||
adminConfig.ClientAdSourceApis
|
||
) || resultWithProxy.episodes;
|
||
|
||
const cacheTime = await getCacheTime();
|
||
|
||
// 同一源在不同 UA 下 episodes 可能不同，避免 CDN/共享缓存串号
|
||
if (clientAdEnabled) {
|
||
return NextResponse.json(resultWithProxy, {
|
||
headers: {
|
||
'Cache-Control': 'private, no-store',
|
||
Vary: 'User-Agent',
|
||
'Netlify-Vary': 'query',
|
||
},
|
||
});
|
||
}
|
||
|
||
return NextResponse.json(resultWithProxy, {
|
||
headers: {
|
||
'Cache-Control': `public, max-age=${cacheTime}, s-maxage=${cacheTime}`,
|
||
'CDN-Cache-Control': `public, s-maxage=${cacheTime}`,
|
||
'Vercel-CDN-Cache-Control': `public, s-maxage=${cacheTime}`,
|
||
'Netlify-Vary': 'query',
|
||
},
|
||
});
|
||
} catch (error) {
|
||
return NextResponse.json(
|
||
{ error: (error as Error).message },
|
||
{ status: 500 }
|
||
);
|
||
}
|
||
}
|