390 lines
13 KiB
Python
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} |