Files
2026-06-03 00:34:42 +08:00

357 lines
12 KiB
Python

from pathlib import Path
from urllib.parse import urlparse
from uuid import uuid4
from fastapi import FastAPI, File, Form, HTTPException, UploadFile
from fastapi.responses import FileResponse
from fastapi.staticfiles import StaticFiles
from .db import (
DATABASE_PATH,
create_video,
delete_video,
initialize_database,
list_videos,
parse_tags,
table_names,
get_video,
update_video,
)
PROJECT_DIR = Path(__file__).resolve().parent.parent
UPLOADS_DIR = PROJECT_DIR / "uploads"
VIDEO_EXTENSIONS = {".mp4", ".webm", ".mov", ".m4v"}
SUBTITLE_EXTENSIONS = {".srt", ".vtt"}
UPLOAD_CHUNK_SIZE = 1024 * 1024
def ensure_upload_directories() -> None:
UPLOADS_DIR.mkdir(parents=True, exist_ok=True)
(UPLOADS_DIR / "videos").mkdir(parents=True, exist_ok=True)
(UPLOADS_DIR / "subtitles").mkdir(parents=True, exist_ok=True)
def extension_for_upload(upload: UploadFile) -> str:
return Path(upload.filename or "").suffix.lower()
def safe_upload_name(upload: UploadFile) -> str:
extension = extension_for_upload(upload)
return f"{uuid4().hex}{extension}"
async def save_upload(upload: UploadFile, target_dir: Path) -> tuple[str, str]:
target_dir.mkdir(parents=True, exist_ok=True)
filename = safe_upload_name(upload)
target_path = target_dir / filename
content = await upload.read()
try:
target_path.write_bytes(content)
except OSError as exc:
target_path.unlink(missing_ok=True)
raise HTTPException(status_code=500, detail="保存文件失败,请重试") from exc
return filename, content.decode("utf-8-sig", errors="replace")
async def save_binary_upload(upload: UploadFile, target_dir: Path) -> str:
target_dir.mkdir(parents=True, exist_ok=True)
filename = safe_upload_name(upload)
target_path = target_dir / filename
try:
with target_path.open("wb") as target_file:
while chunk := await upload.read(UPLOAD_CHUNK_SIZE):
target_file.write(chunk)
except OSError as exc:
target_path.unlink(missing_ok=True)
raise HTTPException(status_code=500, detail="保存文件失败,请重试") from exc
return filename
def cleanup_saved_files(paths: list[Path]) -> None:
for path in paths:
try:
path.unlink(missing_ok=True)
except OSError:
pass
def upload_url_to_path(value: str) -> Path | None:
if not value.startswith("/uploads/"):
return None
relative_parts = value.removeprefix("/uploads/").split("/")
if any(part in {"", ".", ".."} for part in relative_parts):
return None
candidate = (UPLOADS_DIR / Path(*relative_parts)).resolve()
uploads_root = UPLOADS_DIR.resolve()
try:
candidate.relative_to(uploads_root)
except ValueError:
return None
return candidate
def is_supported_video_url(value: str) -> bool:
parsed = urlparse(value)
return parsed.scheme in {"http", "https"} and bool(parsed.netloc)
def cleanup_upload_urls(upload_urls: list[str]) -> list[str]:
warnings: list[str] = []
for upload_url in upload_urls:
path = upload_url_to_path(str(upload_url))
if path is None:
continue
try:
path.unlink(missing_ok=True)
except OSError:
warnings.append(f"无法删除文件: {path}")
return warnings
ensure_upload_directories()
app = FastAPI(title="Speaking Lab API")
@app.on_event("startup")
def on_startup() -> None:
initialize_database()
ensure_upload_directories()
app.mount("/uploads", StaticFiles(directory=UPLOADS_DIR), name="uploads")
@app.get("/api/health")
def health_check() -> dict[str, object]:
return {
"ok": True,
"database": str(DATABASE_PATH),
"tables": table_names(),
}
@app.get("/api/videos")
def api_list_videos() -> list[dict[str, object]]:
return list_videos()
@app.get("/api/videos/{video_id}")
def api_get_video(video_id: int) -> dict[str, object]:
video = get_video(video_id)
if video is None:
raise HTTPException(status_code=404, detail="视频不存在")
return video
@app.post("/api/videos")
async def api_create_video(
title: str = Form(...),
speaker: str = Form(""),
description: str = Form(""),
tags: str = Form(""),
video_url: str = Form(""),
video_file: UploadFile | None = File(None),
subtitle_en: UploadFile | None = File(None),
subtitle_zh: UploadFile | None = File(None),
) -> dict[str, object]:
clean_title = title.strip()
if not clean_title:
raise HTTPException(status_code=400, detail="标题不能为空")
clean_video_url = video_url.strip()
if video_file is None and not clean_video_url:
raise HTTPException(status_code=400, detail="请上传视频文件或填写视频地址")
if video_file is None and not is_supported_video_url(clean_video_url):
raise HTTPException(status_code=400, detail="视频地址必须以 http:// 或 https:// 开头")
if video_file is not None:
if extension_for_upload(video_file) not in VIDEO_EXTENSIONS:
raise HTTPException(status_code=400, detail="视频文件格式不支持")
subtitle_uploads: list[tuple[UploadFile, str, str, str]] = []
for upload, language_code, language_name in (
(subtitle_en, "en", "English"),
(subtitle_zh, "zh", "中文"),
):
if upload is None:
continue
extension = extension_for_upload(upload)
if extension not in SUBTITLE_EXTENSIONS:
raise HTTPException(status_code=400, detail="字幕只支持 .srt 或 .vtt")
subtitle_uploads.append((upload, language_code, language_name, extension))
saved_paths: list[Path] = []
try:
final_video_url = clean_video_url
if video_file is not None:
video_filename = await save_binary_upload(video_file, UPLOADS_DIR / "videos")
saved_paths.append(UPLOADS_DIR / "videos" / video_filename)
final_video_url = f"/uploads/videos/{video_filename}"
subtitles: list[dict[str, str]] = []
for upload, language_code, language_name, extension in subtitle_uploads:
subtitle_filename, subtitle_text = await save_upload(upload, UPLOADS_DIR / "subtitles")
saved_paths.append(UPLOADS_DIR / "subtitles" / subtitle_filename)
subtitles.append(
{
"language_code": language_code,
"language_name": language_name,
"format": extension.removeprefix("."),
"file_path": f"/uploads/subtitles/{subtitle_filename}",
"content": subtitle_text,
}
)
return create_video(
title=clean_title,
speaker=speaker.strip(),
description=description.strip(),
tags=parse_tags(tags),
video_url=final_video_url,
subtitles=subtitles,
)
except Exception:
cleanup_saved_files(saved_paths)
raise
@app.patch("/api/videos/{video_id}")
async def api_update_video(
video_id: int,
title: str = Form(...),
speaker: str = Form(""),
description: str = Form(""),
tags: str = Form(""),
video_url: str = Form(""),
subtitle_en_content: str | None = Form(None),
subtitle_zh_content: str | None = Form(None),
video_file: UploadFile | None = File(None),
subtitle_en: UploadFile | None = File(None),
subtitle_zh: UploadFile | None = File(None),
) -> dict[str, object]:
existing = get_video(video_id)
if existing is None:
raise HTTPException(status_code=404, detail="视频不存在")
clean_title = title.strip()
if not clean_title:
raise HTTPException(status_code=400, detail="标题不能为空")
clean_video_url = video_url.strip()
final_video_url: str | None = None
if video_file is None and clean_video_url:
if not is_supported_video_url(clean_video_url) and not clean_video_url.startswith("/uploads/"):
raise HTTPException(status_code=400, detail="视频地址必须以 http:// 或 https:// 开头")
final_video_url = clean_video_url
if video_file is not None and extension_for_upload(video_file) not in VIDEO_EXTENSIONS:
raise HTTPException(status_code=400, detail="视频文件格式不支持")
subtitle_uploads: list[tuple[UploadFile, str, str, str]] = []
for upload, language_code, language_name in (
(subtitle_en, "en", "English"),
(subtitle_zh, "zh", "中文"),
):
if upload is None:
continue
extension = extension_for_upload(upload)
if extension not in SUBTITLE_EXTENSIONS:
raise HTTPException(status_code=400, detail="字幕只支持 .srt 或 .vtt")
subtitle_uploads.append((upload, language_code, language_name, extension))
saved_paths: list[Path] = []
try:
if video_file is not None:
video_filename = await save_binary_upload(video_file, UPLOADS_DIR / "videos")
saved_paths.append(UPLOADS_DIR / "videos" / video_filename)
final_video_url = f"/uploads/videos/{video_filename}"
subtitles: list[dict[str, str]] = []
for upload, language_code, language_name, extension in subtitle_uploads:
subtitle_filename, subtitle_text = await save_upload(upload, UPLOADS_DIR / "subtitles")
saved_paths.append(UPLOADS_DIR / "subtitles" / subtitle_filename)
subtitles.append(
{
"language_code": language_code,
"language_name": language_name,
"format": extension.removeprefix("."),
"file_path": f"/uploads/subtitles/{subtitle_filename}",
"content": subtitle_text,
}
)
uploaded_language_codes = {language_code for _, language_code, _, _ in subtitle_uploads}
existing_subtitles = existing.get("subtitles", {})
for language_code, language_name, content in (
("en", "English", subtitle_en_content),
("zh", "中文", subtitle_zh_content),
):
if content is None or language_code in uploaded_language_codes:
continue
existing_subtitle = existing_subtitles.get(language_code, {})
subtitles.append(
{
"language_code": language_code,
"language_name": existing_subtitle.get("languageName") or language_name,
"format": existing_subtitle.get("format") or "vtt",
"file_path": existing_subtitle.get("filePath") or "",
"content": content,
}
)
updated = update_video(
video_id,
title=clean_title,
speaker=speaker.strip(),
description=description.strip(),
tags=parse_tags(tags),
video_url=final_video_url,
subtitles=subtitles,
)
if updated is None:
cleanup_saved_files(saved_paths)
raise HTTPException(status_code=404, detail="视频不存在")
warnings = cleanup_upload_urls([str(path) for path in updated["oldUploadPaths"]])
return {
"ok": True,
"video": updated["video"],
"warnings": warnings,
}
except HTTPException:
cleanup_saved_files(saved_paths)
raise
except Exception:
cleanup_saved_files(saved_paths)
raise
@app.delete("/api/videos/{video_id}")
def api_delete_video(video_id: int) -> dict[str, object]:
deleted = delete_video(video_id)
if deleted is None:
raise HTTPException(status_code=404, detail="视频不存在")
warnings = cleanup_upload_urls([str(path) for path in deleted["uploadPaths"]])
return {
"ok": True,
"deletedVideoId": deleted["deletedVideoId"],
"warnings": warnings,
}
@app.get("/")
def read_index() -> FileResponse:
return FileResponse(PROJECT_DIR / "index.html")
app.mount("/", StaticFiles(directory=PROJECT_DIR), name="static")