Files
speaking-practice/backend/db.py
T

431 lines
14 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
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,
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);
"""
)
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 "",
"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,
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, 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),
),
)
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
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"])
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,
subtitles: list[dict[str, str]],
) -> dict[str, object] | None:
with get_connection() as connection:
existing = connection.execute(
"""
SELECT id, video_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"])
connection.execute(
"""
UPDATE videos
SET title = ?,
speaker = ?,
description = ?,
tags = ?,
video_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),
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]