Files

390 lines
13 KiB
Python

"""
Lectures Router — упрощённая версия.
Логика:
- Лекция = файл (PDF/HTML) + уровень + язык.
- Показывается пользователю, если:
- level_code == users.current_level
- lecture_language == users.app_language
- Название = имя файла (без расширения).
"""
import io
import logging
import uuid
from pathlib import Path
from typing import Optional
from fastapi import APIRouter, Request, HTTPException, UploadFile, File, Form
from fastapi.responses import FileResponse
from auth import require_auth
from database import get_pool
from config import ADMIN_IDS, UPLOADS_DIR
logger = logging.getLogger(__name__)
router = APIRouter(tags=["lectures"])
LEVELS = ["A1", "A2", "B1", "B2", "C1", "C2"]
LANGUAGES = ["pl", "ru", "uk", "en"]
ALLOWED_FILE_TYPES = {"pdf", "html", "docx", "txt", "md"}
MAX_FILE_SIZE_BYTES = 20 * 1024 * 1024
def _require_admin(telegram_id: int) -> None:
if telegram_id not in ADMIN_IDS:
raise HTTPException(403, "Access denied")
def _ext_from_filename(filename: str) -> str:
return filename.rsplit(".", 1)[-1].lower() if "." in filename else ""
def _title_from_filename(filename: str) -> str:
"""Убирает расширение + заменяет _ на пробелы."""
name = filename.rsplit(".", 1)[0] if "." in filename else filename
return name.replace("_", " ").strip()
def _extract_pdf_preview(content: bytes, max_lines: int = 15) -> str:
"""Извлекает первые строки текста из PDF."""
try:
import pdfplumber
with pdfplumber.open(io.BytesIO(content)) as pdf:
if not pdf.pages:
return "(PDF без страниц)"
text = pdf.pages[0].extract_text() or ""
lines = [line for line in text.split("\n") if line.strip()][:max_lines]
return "\n".join(lines)
except ImportError:
return "(pdfplumber не установлен на сервере)"
except Exception as e:
logger.error(f"PDF preview error: {e}")
return f"(не удалось извлечь текст: {e})"
def _extract_text_preview(content: bytes, max_chars: int = 800) -> str:
"""Извлекает первые символы из HTML/TXT/MD."""
try:
text = content.decode("utf-8", errors="ignore")
return text[:max_chars]
except Exception as e:
return f"(не удалось прочитать: {e})"
# ============ ПУБЛИЧНЫЕ ============
@router.get("/learning/lectures")
async def get_lectures(request: Request, level: Optional[str] = None):
"""Список лекций для уровня пользователя + его языка."""
telegram_id, _ = await require_auth(request)
pool = await get_pool()
async with pool.acquire() as conn:
user = await conn.fetchrow(
"SELECT current_level, app_language FROM users WHERE telegram_id = $1",
telegram_id,
)
if not level or level not in LEVELS:
level = (user["current_level"] if user else None) or "A1"
if level not in LEVELS:
level = "A1"
user_lang = (user["app_language"] if user else None) or "ru"
if user_lang not in LANGUAGES:
user_lang = "ru"
rows = await conn.fetch("""
SELECT id, level_code, lecture_language,
file_path, file_type, file_size_bytes,
order_number, created_at
FROM lectures
WHERE level_code = $1
AND lecture_language = $2
AND is_active = TRUE
ORDER BY order_number ASC, id ASC
""", level, user_lang)
return {
"level": level,
"language": user_lang,
"lectures": [
{
"id": r["id"],
"level_code": r["level_code"],
"lecture_language": r["lecture_language"],
"title": _title_from_filename(Path(r["file_path"]).name),
"file_type": r["file_type"],
"file_size_kb": round((r["file_size_bytes"] or 0) / 1024, 1),
"file_url": r["file_path"],
"order_number": r["order_number"],
"created_at": r["created_at"].isoformat() if r["created_at"] else None,
}
for r in rows
],
}
@router.get("/learning/lecture/{lecture_id}")
async def get_lecture(request: Request, lecture_id: int):
"""Метаданные одной лекции."""
await require_auth(request)
pool = await get_pool()
async with pool.acquire() as conn:
row = await conn.fetchrow("""
SELECT id, level_code, lecture_language,
file_path, file_type, file_size_bytes, order_number
FROM lectures
WHERE id = $1 AND is_active = TRUE
""", lecture_id)
if not row:
raise HTTPException(404, "Lecture not found")
return {
"id": row["id"],
"level_code": row["level_code"],
"lecture_language": row["lecture_language"],
"title": _title_from_filename(Path(row["file_path"]).name),
"file_type": row["file_type"],
"file_size_kb": round((row["file_size_bytes"] or 0) / 1024, 1),
"file_url": row["file_path"],
"order_number": row["order_number"],
}
@router.get("/learning/lecture/{lecture_id}/download")
async def download_lecture(request: Request, lecture_id: int):
"""Скачать файл лекции."""
await require_auth(request)
pool = await get_pool()
async with pool.acquire() as conn:
row = await conn.fetchrow("""
SELECT file_path, file_type
FROM lectures
WHERE id = $1 AND is_active = TRUE
""", lecture_id)
if not row:
raise HTTPException(404, "Lecture not found")
rel_path = row["file_path"].replace("/uploads/", "", 1).lstrip("/")
abs_path = Path(UPLOADS_DIR) / rel_path
if not abs_path.exists():
raise HTTPException(404, "File not found on disk")
return FileResponse(
path=str(abs_path),
filename=Path(row["file_path"]).name,
media_type="application/octet-stream",
)
# ============ АДМИНСКИЕ ============
@router.get("/admin/lectures/list")
async def admin_list_lectures(
request: Request,
level: Optional[str] = None,
lecture_language: Optional[str] = None,
):
"""Список всех лекций для админки."""
telegram_id, _ = await require_auth(request)
_require_admin(telegram_id)
pool = await get_pool()
async with pool.acquire() as conn:
conditions = ["is_active = TRUE"]
params = []
idx = 1
if level and level in LEVELS:
conditions.append(f"level_code = ${idx}")
params.append(level)
idx += 1
if lecture_language and lecture_language in LANGUAGES:
conditions.append(f"lecture_language = ${idx}")
params.append(lecture_language)
idx += 1
where = " AND ".join(conditions)
rows = await conn.fetch(f"""
SELECT id, level_code, lecture_language,
file_path, file_type, file_size_bytes, order_number, created_at
FROM lectures
WHERE {where}
ORDER BY level_code, order_number, id
""", *params)
return {
"total": len(rows),
"lectures": [
{
"id": r["id"],
"level_code": r["level_code"],
"lecture_language": r["lecture_language"],
"title": _title_from_filename(Path(r["file_path"]).name),
"file_type": r["file_type"],
"file_size_kb": round((r["file_size_bytes"] or 0) / 1024, 1),
"file_url": r["file_path"],
"order_number": r["order_number"],
"created_at": r["created_at"].isoformat() if r["created_at"] else None,
}
for r in rows
],
}
@router.post("/admin/lectures/preview")
async def admin_lecture_preview(
request: Request,
file: UploadFile = File(...),
):
"""Превью файла лекции — первые строки текста."""
telegram_id, _ = await require_auth(request)
_require_admin(telegram_id)
content = await file.read()
if len(content) == 0:
raise HTTPException(400, "Empty file")
ext = _ext_from_filename(file.filename or "")
if ext == "pdf":
preview_text = _extract_pdf_preview(content)
elif ext in ("html", "txt", "md"):
preview_text = _extract_text_preview(content)
else:
preview_text = f"(превью недоступно для формата .{ext})"
return {
"file_name": file.filename or "unknown",
"file_type": ext,
"file_size_kb": round(len(content) / 1024, 1),
"preview": preview_text[:1500],
}
@router.post("/admin/lectures/upload")
async def admin_upload_lecture(
request: Request,
level_code: str = Form(...),
lecture_language: str = Form("ru"),
order_number: int = Form(0),
file: UploadFile = File(...),
):
"""Загрузить лекцию (файл + уровень + язык)."""
telegram_id, _ = await require_auth(request)
_require_admin(telegram_id)
if level_code not in LEVELS:
raise HTTPException(400, f"Invalid level_code: {level_code}")
if lecture_language not in LANGUAGES:
raise HTTPException(400, f"Invalid lecture_language: {lecture_language}")
ext = _ext_from_filename(file.filename or "")
if ext not in ALLOWED_FILE_TYPES:
raise HTTPException(400, f"Invalid file type: {ext}")
content = await file.read()
if len(content) == 0:
raise HTTPException(400, "Empty file")
if len(content) > MAX_FILE_SIZE_BYTES:
raise HTTPException(400, f"File too large. Max: {MAX_FILE_SIZE_BYTES}")
lectures_dir = Path(UPLOADS_DIR) / "lectures"
lectures_dir.mkdir(parents=True, exist_ok=True)
original_name = (file.filename or "lecture").rsplit(".", 1)[0]
safe_name = "".join(c if c.isalnum() or c in "-_" else "_" for c in original_name)[:50]
filename = f"{level_code}_{lecture_language}_{safe_name}_{uuid.uuid4().hex[:8]}.{ext}"
file_path_disk = lectures_dir / filename
file_path_disk.write_bytes(content)
public_path = f"/uploads/lectures/{filename}"
pool = await get_pool()
async with pool.acquire() as conn:
row = await conn.fetchrow("""
INSERT INTO lectures
(level_code, lecture_language, display_language,
title_pl, file_path, file_type, file_size_bytes,
order_number, is_active)
VALUES ($1, $2, $2, $3, $4, $5, $6, $7, TRUE)
RETURNING id
""",
level_code,
lecture_language,
_title_from_filename(file.filename or "lecture"),
public_path,
ext,
len(content),
order_number,
)
logger.info(f"Lecture uploaded: #{row['id']} [{level_code}/{lecture_language}]")
return {"status": "ok", "lecture_id": row["id"]}
@router.put("/admin/lectures/{lecture_id}")
async def admin_update_lecture(request: Request, lecture_id: int):
"""Обновить метаданные лекции."""
telegram_id, _ = await require_auth(request)
_require_admin(telegram_id)
body = await request.json()
pool = await get_pool()
async with pool.acquire() as conn:
existing = await conn.fetchrow("SELECT id FROM lectures WHERE id = $1", lecture_id)
if not existing:
raise HTTPException(404, "Lecture not found")
await conn.execute("""
UPDATE lectures
SET lecture_language = COALESCE($1, lecture_language),
display_language = COALESCE($1, display_language),
order_number = COALESCE($2, order_number),
is_active = COALESCE($3, is_active),
edited_at = NOW()
WHERE id = $4
""",
body.get("lecture_language"),
body.get("order_number"),
body.get("is_active"),
lecture_id,
)
return {"status": "ok", "lecture_id": lecture_id}
@router.delete("/admin/lectures/{lecture_id}")
async def admin_delete_lecture(request: Request, lecture_id: int):
"""Удалить лекцию."""
telegram_id, _ = await require_auth(request)
_require_admin(telegram_id)
pool = await get_pool()
async with pool.acquire() as conn:
row = await conn.fetchrow("SELECT file_path FROM lectures WHERE id = $1", lecture_id)
if not row:
raise HTTPException(404, "Lecture not found")
await conn.execute("DELETE FROM lectures WHERE id = $1", lecture_id)
rel_path = row["file_path"].replace("/uploads/", "", 1).lstrip("/")
abs_path = Path(UPLOADS_DIR) / rel_path
try:
if abs_path.exists():
abs_path.unlink()
except Exception as e:
logger.error(f"Failed to delete file: {e}")
return {"status": "ok", "lecture_id": lecture_id}