449 lines
14 KiB
Python
449 lines
14 KiB
Python
from pathlib import Path
|
||
import json
|
||
import sqlite3
|
||
|
||
|
||
BASE_DIR = Path(__file__).resolve().parent
|
||
DATABASE_PATH = BASE_DIR / "speaking_lab.sqlite"
|
||
MOJIBAKE_MARKERS = ("Ã", "Â", "â", "ä", "å", "æ", "ç", "è", "é")
|
||
|
||
|
||
def get_connection() -> sqlite3.Connection:
|
||
connection = sqlite3.connect(DATABASE_PATH)
|
||
connection.row_factory = sqlite3.Row
|
||
connection.execute("PRAGMA foreign_keys = ON")
|
||
return connection
|
||
|
||
|
||
def initialize_database() -> None:
|
||
BASE_DIR.mkdir(parents=True, exist_ok=True)
|
||
|
||
with get_connection() as connection:
|
||
connection.executescript(
|
||
"""
|
||
CREATE TABLE IF NOT EXISTS users (
|
||
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
||
email TEXT NOT NULL UNIQUE,
|
||
password_hash TEXT NOT NULL,
|
||
display_name TEXT,
|
||
role TEXT NOT NULL DEFAULT 'user',
|
||
created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
|
||
updated_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP
|
||
);
|
||
|
||
CREATE TABLE IF NOT EXISTS videos (
|
||
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
||
title TEXT NOT NULL,
|
||
speaker TEXT,
|
||
description TEXT,
|
||
tags TEXT,
|
||
video_url TEXT,
|
||
cover_url TEXT,
|
||
duration_seconds INTEGER,
|
||
status TEXT NOT NULL DEFAULT 'draft',
|
||
created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
|
||
updated_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP
|
||
);
|
||
|
||
CREATE TABLE IF NOT EXISTS subtitles (
|
||
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
||
video_id INTEGER NOT NULL,
|
||
language_code TEXT NOT NULL,
|
||
language_name TEXT,
|
||
format TEXT NOT NULL,
|
||
file_path TEXT,
|
||
content TEXT,
|
||
created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
|
||
updated_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
|
||
FOREIGN KEY (video_id) REFERENCES videos (id) ON DELETE CASCADE
|
||
);
|
||
|
||
CREATE TABLE IF NOT EXISTS user_interactions (
|
||
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
||
user_id INTEGER NOT NULL,
|
||
video_id INTEGER NOT NULL,
|
||
interaction_type TEXT NOT NULL,
|
||
current_time_ms INTEGER,
|
||
created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
|
||
updated_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
|
||
UNIQUE (user_id, video_id, interaction_type),
|
||
FOREIGN KEY (user_id) REFERENCES users (id) ON DELETE CASCADE,
|
||
FOREIGN KEY (video_id) REFERENCES videos (id) ON DELETE CASCADE
|
||
);
|
||
|
||
CREATE INDEX IF NOT EXISTS idx_videos_title ON videos (title);
|
||
CREATE INDEX IF NOT EXISTS idx_subtitles_video_id ON subtitles (video_id);
|
||
CREATE INDEX IF NOT EXISTS idx_user_interactions_user_id
|
||
ON user_interactions (user_id);
|
||
"""
|
||
)
|
||
video_columns = {
|
||
row["name"]
|
||
for row in connection.execute("PRAGMA table_info(videos)").fetchall()
|
||
}
|
||
if "cover_url" not in video_columns:
|
||
connection.execute("ALTER TABLE videos ADD COLUMN cover_url TEXT")
|
||
connection.execute(
|
||
"""
|
||
DELETE FROM subtitles
|
||
WHERE id NOT IN (
|
||
SELECT MAX(id)
|
||
FROM subtitles
|
||
GROUP BY video_id, language_code
|
||
)
|
||
"""
|
||
)
|
||
connection.execute(
|
||
"""
|
||
CREATE UNIQUE INDEX IF NOT EXISTS idx_subtitles_video_language
|
||
ON subtitles (video_id, language_code)
|
||
"""
|
||
)
|
||
|
||
|
||
def repair_mojibake_text(value: str | None) -> str:
|
||
if not value:
|
||
return ""
|
||
|
||
repaired = value
|
||
for _ in range(2):
|
||
if not any(marker in repaired for marker in MOJIBAKE_MARKERS):
|
||
break
|
||
try:
|
||
candidate = repaired.encode("latin1").decode("utf-8")
|
||
except UnicodeError:
|
||
break
|
||
if candidate == repaired:
|
||
break
|
||
repaired = candidate
|
||
return repaired
|
||
|
||
|
||
def parse_tags(tags_text: str | None) -> list[str]:
|
||
tags = [
|
||
tag.strip()
|
||
for tag in repair_mojibake_text(tags_text).replace(",", ",").split(",")
|
||
if tag.strip()
|
||
]
|
||
return tags or ["未分类"]
|
||
|
||
|
||
def row_to_video(row: sqlite3.Row, subtitle_rows: list[sqlite3.Row]) -> dict[str, object]:
|
||
subtitles: dict[str, dict[str, str]] = {}
|
||
for subtitle in subtitle_rows:
|
||
subtitles[subtitle["language_code"]] = {
|
||
"languageName": repair_mojibake_text(subtitle["language_name"] or subtitle["language_code"]),
|
||
"format": subtitle["format"],
|
||
"filePath": subtitle["file_path"],
|
||
"content": repair_mojibake_text(subtitle["content"] or ""),
|
||
}
|
||
|
||
try:
|
||
tags = json.loads(row["tags"] or "[]")
|
||
except json.JSONDecodeError:
|
||
tags = parse_tags(row["tags"])
|
||
tags = [repair_mojibake_text(str(tag)) for tag in tags] if isinstance(tags, list) else parse_tags(str(tags))
|
||
|
||
return {
|
||
"id": row["id"],
|
||
"title": repair_mojibake_text(row["title"]),
|
||
"speaker": repair_mojibake_text(row["speaker"] or "Unknown"),
|
||
"description": repair_mojibake_text(row["description"] or ""),
|
||
"tags": tags if isinstance(tags, list) and tags else ["未分类"],
|
||
"duration": row["duration_seconds"] or 0,
|
||
"videoUrl": row["video_url"] or "",
|
||
"coverUrl": row["cover_url"] or "",
|
||
"sourceType": "url" if str(row["video_url"] or "").startswith(("http://", "https://")) else "local-file",
|
||
"subtitles": subtitles,
|
||
}
|
||
|
||
|
||
def create_video(
|
||
*,
|
||
title: str,
|
||
speaker: str | None,
|
||
description: str | None,
|
||
tags: list[str],
|
||
video_url: str,
|
||
cover_url: str = "",
|
||
subtitles: list[dict[str, str]],
|
||
) -> dict[str, object]:
|
||
with get_connection() as connection:
|
||
cursor = connection.execute(
|
||
"""
|
||
INSERT INTO videos (
|
||
title, speaker, description, tags, video_url, cover_url, status
|
||
)
|
||
VALUES (?, ?, ?, ?, ?, ?, 'published')
|
||
""",
|
||
(
|
||
title,
|
||
repair_mojibake_text(speaker or "Unknown"),
|
||
repair_mojibake_text(description or ""),
|
||
json.dumps([repair_mojibake_text(tag) for tag in tags], ensure_ascii=False),
|
||
repair_mojibake_text(video_url),
|
||
repair_mojibake_text(cover_url),
|
||
),
|
||
)
|
||
video_id = int(cursor.lastrowid)
|
||
|
||
for subtitle in subtitles:
|
||
connection.execute(
|
||
"""
|
||
INSERT INTO subtitles (
|
||
video_id, language_code, language_name, format, file_path, content
|
||
)
|
||
VALUES (?, ?, ?, ?, ?, ?)
|
||
""",
|
||
(
|
||
video_id,
|
||
subtitle["language_code"],
|
||
repair_mojibake_text(subtitle["language_name"]),
|
||
subtitle["format"],
|
||
subtitle["file_path"],
|
||
repair_mojibake_text(subtitle["content"]),
|
||
),
|
||
)
|
||
|
||
video = get_video(video_id)
|
||
if video is None:
|
||
raise RuntimeError("Created video could not be loaded")
|
||
return video
|
||
|
||
|
||
def list_videos() -> list[dict[str, object]]:
|
||
with get_connection() as connection:
|
||
video_rows = connection.execute(
|
||
"""
|
||
SELECT *
|
||
FROM videos
|
||
WHERE status = 'published'
|
||
ORDER BY created_at DESC, id DESC
|
||
"""
|
||
).fetchall()
|
||
subtitle_rows = connection.execute(
|
||
"""
|
||
SELECT *
|
||
FROM subtitles
|
||
ORDER BY id ASC
|
||
"""
|
||
).fetchall()
|
||
|
||
subtitles_by_video: dict[int, list[sqlite3.Row]] = {}
|
||
for subtitle in subtitle_rows:
|
||
subtitles_by_video.setdefault(int(subtitle["video_id"]), []).append(subtitle)
|
||
|
||
return [
|
||
row_to_video(row, subtitles_by_video.get(int(row["id"]), []))
|
||
for row in video_rows
|
||
]
|
||
|
||
|
||
def get_video(video_id: int) -> dict[str, object] | None:
|
||
with get_connection() as connection:
|
||
row = connection.execute(
|
||
"""
|
||
SELECT *
|
||
FROM videos
|
||
WHERE id = ? AND status = 'published'
|
||
""",
|
||
(video_id,),
|
||
).fetchone()
|
||
if row is None:
|
||
return None
|
||
|
||
subtitle_rows = connection.execute(
|
||
"""
|
||
SELECT *
|
||
FROM subtitles
|
||
WHERE video_id = ?
|
||
ORDER BY id ASC
|
||
""",
|
||
(video_id,),
|
||
).fetchall()
|
||
|
||
return row_to_video(row, subtitle_rows)
|
||
|
||
|
||
def delete_video(video_id: int) -> dict[str, object] | None:
|
||
with get_connection() as connection:
|
||
video_row = connection.execute(
|
||
"""
|
||
SELECT id, video_url, cover_url
|
||
FROM videos
|
||
WHERE id = ?
|
||
""",
|
||
(video_id,),
|
||
).fetchone()
|
||
if video_row is None:
|
||
return None
|
||
|
||
subtitle_rows = connection.execute(
|
||
"""
|
||
SELECT file_path
|
||
FROM subtitles
|
||
WHERE video_id = ?
|
||
""",
|
||
(video_id,),
|
||
).fetchall()
|
||
|
||
upload_paths = []
|
||
if video_row["video_url"]:
|
||
upload_paths.append(video_row["video_url"])
|
||
if video_row["cover_url"]:
|
||
upload_paths.append(video_row["cover_url"])
|
||
upload_paths.extend(row["file_path"] for row in subtitle_rows if row["file_path"])
|
||
|
||
connection.execute("DELETE FROM videos WHERE id = ?", (video_id,))
|
||
|
||
return {
|
||
"deletedVideoId": video_id,
|
||
"uploadPaths": upload_paths,
|
||
}
|
||
|
||
|
||
def update_video(
|
||
video_id: int,
|
||
*,
|
||
title: str,
|
||
speaker: str | None,
|
||
description: str | None,
|
||
tags: list[str],
|
||
video_url: str | None,
|
||
cover_url: str | None = None,
|
||
subtitles: list[dict[str, str]],
|
||
) -> dict[str, object] | None:
|
||
with get_connection() as connection:
|
||
existing = connection.execute(
|
||
"""
|
||
SELECT id, video_url, cover_url
|
||
FROM videos
|
||
WHERE id = ?
|
||
""",
|
||
(video_id,),
|
||
).fetchone()
|
||
if existing is None:
|
||
return None
|
||
|
||
old_upload_paths = []
|
||
final_video_url = video_url if video_url is not None else existing["video_url"]
|
||
if video_url is not None and existing["video_url"] and existing["video_url"] != video_url:
|
||
old_upload_paths.append(existing["video_url"])
|
||
final_cover_url = cover_url if cover_url is not None else existing["cover_url"]
|
||
if cover_url is not None and existing["cover_url"] and existing["cover_url"] != cover_url:
|
||
old_upload_paths.append(existing["cover_url"])
|
||
|
||
connection.execute(
|
||
"""
|
||
UPDATE videos
|
||
SET title = ?,
|
||
speaker = ?,
|
||
description = ?,
|
||
tags = ?,
|
||
video_url = ?,
|
||
cover_url = ?,
|
||
updated_at = CURRENT_TIMESTAMP
|
||
WHERE id = ?
|
||
""",
|
||
(
|
||
title,
|
||
repair_mojibake_text(speaker or "Unknown"),
|
||
repair_mojibake_text(description or ""),
|
||
json.dumps([repair_mojibake_text(tag) for tag in tags], ensure_ascii=False),
|
||
repair_mojibake_text(final_video_url),
|
||
repair_mojibake_text(final_cover_url or ""),
|
||
video_id,
|
||
),
|
||
)
|
||
|
||
for subtitle in subtitles:
|
||
existing_subtitle = connection.execute(
|
||
"""
|
||
SELECT file_path
|
||
FROM subtitles
|
||
WHERE video_id = ? AND language_code = ?
|
||
""",
|
||
(video_id, subtitle["language_code"]),
|
||
).fetchone()
|
||
if existing_subtitle and existing_subtitle["file_path"] != subtitle["file_path"]:
|
||
old_upload_paths.append(existing_subtitle["file_path"])
|
||
|
||
connection.execute(
|
||
"""
|
||
INSERT INTO subtitles (
|
||
video_id, language_code, language_name, format, file_path, content
|
||
)
|
||
VALUES (?, ?, ?, ?, ?, ?)
|
||
ON CONFLICT(video_id, language_code) DO UPDATE SET
|
||
language_name = excluded.language_name,
|
||
format = excluded.format,
|
||
file_path = excluded.file_path,
|
||
content = excluded.content,
|
||
updated_at = CURRENT_TIMESTAMP
|
||
""",
|
||
(
|
||
video_id,
|
||
subtitle["language_code"],
|
||
repair_mojibake_text(subtitle["language_name"]),
|
||
subtitle["format"],
|
||
subtitle["file_path"],
|
||
repair_mojibake_text(subtitle["content"]),
|
||
),
|
||
)
|
||
|
||
video = get_video(video_id)
|
||
if video is None:
|
||
return None
|
||
return {
|
||
"video": video,
|
||
"oldUploadPaths": old_upload_paths,
|
||
}
|
||
|
||
|
||
def upsert_video_subtitle(
|
||
video_id: int,
|
||
*,
|
||
language_code: str,
|
||
language_name: str,
|
||
format: str,
|
||
file_path: str,
|
||
content: str,
|
||
) -> None:
|
||
with get_connection() as connection:
|
||
connection.execute(
|
||
"""
|
||
INSERT INTO subtitles (
|
||
video_id, language_code, language_name, format, file_path, content
|
||
)
|
||
VALUES (?, ?, ?, ?, ?, ?)
|
||
ON CONFLICT(video_id, language_code) DO UPDATE SET
|
||
language_name = excluded.language_name,
|
||
format = excluded.format,
|
||
file_path = excluded.file_path,
|
||
content = excluded.content,
|
||
updated_at = CURRENT_TIMESTAMP
|
||
""",
|
||
(
|
||
video_id,
|
||
language_code,
|
||
repair_mojibake_text(language_name),
|
||
format,
|
||
file_path,
|
||
repair_mojibake_text(content),
|
||
),
|
||
)
|
||
|
||
|
||
def table_names() -> list[str]:
|
||
with get_connection() as connection:
|
||
rows = connection.execute(
|
||
"""
|
||
SELECT name
|
||
FROM sqlite_master
|
||
WHERE type = 'table'
|
||
AND name NOT LIKE 'sqlite_%'
|
||
ORDER BY name
|
||
"""
|
||
).fetchall()
|
||
return [row["name"] for row in rows]
|