MoviePilot/app/api/endpoints/download.py

from typing import Any, List, Annotated, Optional, Union

from fastapi import Depends, Body

from app.schemas.common import ServiceClientInfo as _SchemaServiceClientInfo
from app.schemas.download import DownloadAddedData as _SchemaDownloadAddedData
from app.schemas.download import DownloadDirectory as _SchemaDownloadDirectory
from app.schemas.download import SubtitleDownloadData as _SchemaSubtitleDownloadData
from app.schemas.file import FileURI as _SchemaFileURI
from app.schemas.response import Response as _SchemaResponse
from app.schemas.search import SubtitleInfo as _SchemaSubtitleInfo
from app.schemas.system import TorrentInfo as _SchemaTorrentInfo
from app.schemas.token import TokenPayload as _SchemaTokenPayload
from app.schemas.transfer import DownloaderTorrent as _SchemaDownloaderTorrent
from app.schemas.transfer import MusicInfo as _SchemaMusicInfo
from app.schemas.workflow import MediaInfo as _SchemaMediaInfo
from app.api.response import ResponseAPIRouter
from app.chain.download import DownloadChain
from app.chain.media import MediaChain
from app.domain.context import Context, MediaInfo, MusicInfo, SubtitleInfo, TorrentInfo
from app.domain.meta.metamusic import MetaMusic
from app.domain.metainfo import MetaInfo
from app.adapters.web.security.access import verify_token
from app.api.principal import ApiPrincipal
from app.application.configuration import get_configured_system_config
from app.application.site.query import (
    SiteQueryService,
    get_configured_site_query_service,
)
from app.api.deps import get_current_active_user, get_site_sync_query_service
from app.application.directory import DirectoryHelper
from app.schemas.types import (
    MUSIC_ENTITY_RECORDING,
    MediaSource,
    MediaType,
    MusicTargetEntityType,
    SystemConfigKey,
)
from app.domain.media import is_music_media_source, normalize_music_type
from app.application.security.url import SecurityUtils

router = ResponseAPIRouter()


def _prepare_subtitle_download(
    subtitle: SubtitleInfo,
    query: SiteQueryService | None = None,
) -> tuple[bool, str]:
    """
    校验字幕下载签名，并用服务端站点配置覆盖请求凭据。
    """
    if subtitle.site is None:
        return False, "字幕站点信息为空"

    clean_url = SecurityUtils.verify_signed_url(
        subtitle.enclosure,
        purpose=SecurityUtils.subtitle_download_purpose(subtitle.site),
    )
    if not clean_url:
        return False, "字幕下载链接签名无效"

    site_query = query or get_configured_site_query_service()
    site = site_query.get_sync(subtitle.site)
    if not site:
        return False, "字幕站点信息不存在"

    subtitle.enclosure = clean_url
    subtitle.site_cookie = site.cookie
    subtitle.site_ua = site.ua
    subtitle.site_proxy = bool(site.proxy)
    return True, ""


@router.get("/", summary="正在下载", response_model=List[_SchemaDownloaderTorrent])
def current(
    name: Optional[str] = None, _: _SchemaTokenPayload = Depends(verify_token)
) -> Any:
    """
    查询正在下载的任务
    """
    return DownloadChain().downloading(name)


@router.post(
    "/",
    summary="添加下载（含媒体信息）",
    response_model=_SchemaResponse[_SchemaDownloadAddedData],
)
def download(
    media_in: Union[_SchemaMusicInfo, _SchemaMediaInfo],
    torrent_in: _SchemaTorrentInfo,
    downloader: Annotated[str | None, Body()] = None,
    save_path: Annotated[str | None, Body()] = None,
    current_user: ApiPrincipal = Depends(get_current_active_user),
) -> Any:
    """
    添加下载任务（含媒体信息）
    """
    if isinstance(media_in, _SchemaMusicInfo):
        mediainfo = MusicInfo.from_dict(media_in.model_dump())
        metainfo = MetaMusic.from_music_info(mediainfo)
        metainfo.org_string = torrent_in.title
    else:
        metainfo = MetaInfo(title=torrent_in.title, subtitle=torrent_in.description)
        mediainfo = MediaInfo()
        mediainfo.from_dict(media_in.model_dump())
    # 种子信息
    torrentinfo = TorrentInfo()
    torrentinfo.from_dict(torrent_in.model_dump())
    # 手动下载始终使用选择的下载器
    torrentinfo.site_downloader = downloader
    # 上下文
    context = Context(
        meta_info=metainfo, media_info=mediainfo, torrent_info=torrentinfo
    )
    did = DownloadChain().download_single(
        context=context,
        username=current_user.name,
        save_path=save_path,
        source="Manual",
    )
    if not did:
        return _SchemaResponse(success=False, message="任务添加失败")
    return _SchemaResponse(success=True, data={"download_id": did})


@router.post(
    "/add",
    summary="添加下载（不含媒体信息）",
    response_model=_SchemaResponse[_SchemaDownloadAddedData],
)
def add(
    torrent_in: _SchemaTorrentInfo,
    media_source: Annotated[MediaSource | None, Body()] = None,
    media_id: Annotated[str | None, Body()] = None,
    music_type: Annotated[MusicTargetEntityType | None, Body()] = None,
    downloader: Annotated[str | None, Body()] = None,
    # 保存路径, 支持<storage>:<path>, 如rclone:/MP, smb:/server/share/Movies等
    save_path: Annotated[str | None, Body()] = None,
    current_user: ApiPrincipal = Depends(get_current_active_user),
) -> Any:
    """
    添加下载任务（不含媒体信息）
    """
    normalized_music_type = normalize_music_type(music_type, allow_artist=False)
    if music_type is not None and not normalized_music_type:
        return _SchemaResponse(
            success=False,
            message="音乐实体类型无效，仅支持 recording 或 album",
        )
    if (media_source is None) != (media_id is None):
        return _SchemaResponse(
            success=False,
            message="媒体来源和媒体 ID 必须同时提供",
        )
    is_music = (
        torrent_in.category in (MediaType.MUSIC, MediaType.MUSIC.value, "music")
        or is_music_media_source(media_source)
        or normalized_music_type is not None
    )
    if is_music and media_source and not is_music_media_source(media_source):
        return _SchemaResponse(
            success=False,
            message="音乐下载只能使用音乐元数据源",
        )
    if is_music and not normalized_music_type:
        normalized_music_type = MUSIC_ENTITY_RECORDING
    # 元数据
    metainfo = (
        MetaMusic.parse_query(torrent_in.title)
        if is_music
        else MetaInfo(title=torrent_in.title, subtitle=torrent_in.description)
    )
    # 媒体信息
    if media_source and media_id:
        mediainfo = MediaChain().recognize_media(
            meta=metainfo,
            media_source=media_source,
            media_id=media_id,
            mtype=MediaType.MUSIC if is_music else None,
            music_type=normalized_music_type,
        )
    else:
        mediainfo = MediaChain().recognize_by_meta(
            metainfo,
            media_source=media_source,
            obtain_images=False,
            mtype=MediaType.MUSIC if is_music else None,
            music_type=normalized_music_type,
        )
    if not mediainfo:
        return _SchemaResponse(success=False, message="无法识别媒体信息")
    # 种子信息
    torrentinfo = TorrentInfo()
    torrentinfo.from_dict(torrent_in.model_dump())
    # 上下文
    context = Context(
        meta_info=metainfo, media_info=mediainfo, torrent_info=torrentinfo
    )

    did = DownloadChain().download_single(
        context=context,
        username=current_user.name,
        downloader=downloader,
        save_path=save_path,
        source="Manual",
    )
    if not did:
        return _SchemaResponse(success=False, message="任务添加失败")
    return _SchemaResponse(success=True, data={"download_id": did})


@router.post(
    "/subtitle",
    summary="下载字幕",
    response_model=_SchemaResponse[_SchemaSubtitleDownloadData],
)
def download_subtitle(
    subtitle_in: _SchemaSubtitleInfo,
    media_source: Annotated[MediaSource, Body()],
    media_id: Annotated[str, Body()],
    save_path: Annotated[str | None, Body()] = None,
    current_user: ApiPrincipal = Depends(get_current_active_user),
    query: SiteQueryService = Depends(get_site_sync_query_service),
) -> Any:
    """
    下载字幕资源。
    """
    subtitle_info = SubtitleInfo()
    subtitle_info.from_dict(subtitle_in.model_dump())
    # 直接调用 endpoint 的旧测试/插件入口不会经过 FastAPI 依赖解析；此时让
    # 应用查询端口自行提供服务，仍保留真实请求中的注入对象。
    if not hasattr(query, "get_sync"):
        valid, message = _prepare_subtitle_download(subtitle_info)
    else:
        valid, message = _prepare_subtitle_download(subtitle_info, query)
    if not valid:
        return _SchemaResponse(success=False, message=message)

    success, message, saved_files = DownloadChain().download_subtitle(
        subtitle=subtitle_info,
        media_source=media_source,
        media_id=media_id,
        save_path=save_path,
        username=current_user.name,
    )
    return _SchemaResponse(
        success=success,
        message=message,
        data={"files": saved_files} if saved_files else None,
    )


@router.get("/start/{hashString}", summary="开始任务", response_model=_SchemaResponse[None])
def start(
    hashString: str,
    name: Optional[str] = None,
    _: _SchemaTokenPayload = Depends(verify_token),
) -> Any:
    """
    开如下载任务
    """
    ret = DownloadChain().set_downloading(hashString, "start", name=name)
    return _SchemaResponse(success=True if ret else False)


@router.get("/stop/{hashString}", summary="暂停任务", response_model=_SchemaResponse[None])
def stop(
    hashString: str,
    name: Optional[str] = None,
    _: _SchemaTokenPayload = Depends(verify_token),
) -> Any:
    """
    暂停下载任务
    """
    ret = DownloadChain().set_downloading(hashString, "stop", name=name)
    return _SchemaResponse(success=True if ret else False)


@router.get(
    "/clients",
    summary="查询可用下载器",
    response_model=List[_SchemaServiceClientInfo],
)
async def clients(_: _SchemaTokenPayload = Depends(verify_token)) -> Any:
    """
    查询可用下载器
    """
    downloaders: List[dict] = get_configured_system_config().get(SystemConfigKey.Downloaders)
    if downloaders:
        return [
            {"name": d.get("name"), "type": d.get("type")}
            for d in downloaders
            if d.get("enabled")
        ]
    return []


@router.get(
    "/paths", summary="查询可用下载路径", response_model=List[_SchemaDownloadDirectory]
)
def paths(_: _SchemaTokenPayload = Depends(verify_token)) -> Any:
    """
    查询可直接用于下载接口 save_path 参数的下载路径
    """
    return [
        _SchemaDownloadDirectory(
            name=dir_info.name,
            storage=dir_info.storage or "local",
            download_path=dir_info.download_path,
            save_path=_SchemaFileURI(
                storage=dir_info.storage or "local",
                path=dir_info.download_path,
            ).uri,
            priority=dir_info.priority,
            media_type=dir_info.media_type,
            media_category=dir_info.media_category,
        )
        for dir_info in DirectoryHelper().get_download_dirs()
        if dir_info.download_path
    ]


@router.delete("/{hashString}", summary="删除下载任务", response_model=_SchemaResponse[None])
def delete(
    hashString: str,
    name: Optional[str] = None,
    _: _SchemaTokenPayload = Depends(verify_token),
) -> Any:
    """
    删除下载任务
    """
    ret = DownloadChain().remove_downloading(hashString, name=name)
    return _SchemaResponse(success=True if ret else False)