""" Admin Content Router — контент-менеджер для редактирования уроков, слов и текстов. Доступ: только для ADMIN_IDS. Логика: препод (ты) правит контент через дашборд, без захода в код. Разделы: - GET /admin/content/summary — сводка по уровням - GET /admin/content/words/levels — уровни слов (счётчики) - GET /admin/content/words/level/{level} — список слов уровня - GET /admin/content/words/word/{word_id} — одно слово - PUT /admin/content/words/word/{word_id} — обновить слово - POST /admin/content/words/level/{level} — добавить слово - GET /admin/content/texts/levels — уровни текстов - GET /admin/content/texts/level/{level} — список текстов - GET /admin/content/texts/text/{text_id} — один текст - PUT /admin/content/texts/text/{text_id} — обновить текст - DELETE /admin/content/texts/text/{text_id} — удалить текст - POST /admin/content/texts/level/{level} — добавить текст - GET /admin/content/texts/all — все тексты (для редактора) - GET /admin/content/lessons/levels — уровни уроков (счётчики тем) - GET /admin/content/lessons/level/{level}/topics — темы уровня - GET /admin/content/lessons/topic/{topic_id} — тема + уроки + тест - GET /admin/content/lessons/lesson/{lesson_id} — урок целиком (WYSIWYG) - PUT /admin/content/lessons/lesson/{lesson_id} — сохранить урок (Вариант B) - GET /admin/content/wrong-because — справочник wrong_because 🔧 ФИКС (19.09.2026): в words-эндпоинтах фильтруем только строки с level_id IS NULL. Причина: в level_words хранятся ДВЕ категории строк: 1. Слова уровня для Word Quiz / Bubble Words → level_id IS NULL. 2. Привязки слов к игровым уровням Филвордов → level_id != NULL. В дашборде преподу нужны только "чистые" слова уровня (level_id IS NULL). Строки с level_id != NULL используются игрой и остаются нетронутыми. При обновлении слова (PUT) — обновляем ВСЕ строки с этим (level, word_pl), чтобы Филворды получили актуальный перевод. 🔧 НОВОЕ (19.09.2026, вечер): раздел «Уроки» — 6 эндпоинтов для LessonsEditor. - Уровни → Темы → Уроки (иерархия как в словах/текстах). - WYSIWYG-модалка редактирует: title, objective, explanation, examples, questions, options. - Сохранение урока целиком (Вариант B) — одна транзакция. - option_key генерируется бэкендом: A, B, C, D... по порядку массива. - correct_answer в learning_questions = option_key того варианта, где is_correct=true. - test_order пересчитывается 1..N по порядку для теста темы (is_test_question=TRUE). - level_code НЕ трогаем — он вычисляется через topic_id → learning_topics.level_code. 🔧 ФИКС (30.09.2026): global_duplicate_warning в create_text — проверяем все уровни на дубликат sentence_pl. force=true пропускает проверку. 🔧 НОВОЕ (30.09.2026): DELETE /admin/content/texts/text/{text_id} — удаление текста из редактора. 🔧 ОБНОВЛЕНО (30.09.2026): /texts/all — пагинация + total. 🔧 НОВОЕ (02.10.2026): 6 эндпоинтов для LessonsEditor v2 — дерево, создание темы, создание урока, удаление урока, вопросы темы для генератора, генератор теста. 🔧 НОВОЕ (02.10.2026): POST /lessons/lesson/{lesson_id}/add-question — добавление ОДНОГО нового вопроса в существующий урок (edit-режим). 🔧 ОБНОВЛЕНО (04.10.2026): track — создание темы с выбором аудитории (pl / ru_uk / en). track включён в дерево /lessons/tree для фильтрации. topic_id теперь: {level}_{track}_{slug}. 🔧 НОВОЕ (04.10.2026): DELETE /lessons/topic/{topic_id} — удаление темы со всем содержимым (уроки, вопросы, опции, примеры). 🔧 НОВОЕ (04.10.2026): options_language — в create_lesson, update_lesson, add_question_to_lesson принимаем и сохраняем options_language ('pl' или 'user'). """ import logging import re from typing import Optional from fastapi import APIRouter, Request, HTTPException from auth import require_auth from database import get_pool from config import ADMIN_IDS logger = logging.getLogger(__name__) router = APIRouter(prefix="/admin/content", tags=["admin-content"]) LEVELS = ["A1", "A2", "B1", "B2", "C1", "C2"] def _require_admin(telegram_id: int) -> None: if telegram_id not in ADMIN_IDS: raise HTTPException(403, "Access denied") # ============ SUMMARY ============ @router.get("/summary") async def get_content_summary(request: Request): """ Сводка по всем уровням: темы, уроки, слова, тексты, последняя правка. Слова считаются только level_id IS NULL (чистые слова уровня). """ telegram_id, _ = await require_auth(request) _require_admin(telegram_id) pool = await get_pool() async with pool.acquire() as conn: level_rows = await conn.fetch(""" SELECT code, name_ru, sort_order FROM learning_levels WHERE is_active = TRUE ORDER BY sort_order """) # 🔧 ФИКС (24.09.2026): admin_content_summary_n_plus_1 — # раньше 6 уровней × 5 запросов = 30 round-trip. Теперь 5 GROUP BY. level_codes = [lvl["code"] for lvl in level_rows] # 1. Темы — GROUP BY level_code topics_rows = await conn.fetch(""" SELECT level_code, COUNT(*) as cnt FROM learning_topics WHERE level_code = ANY($1::text[]) GROUP BY level_code """, level_codes) topics_map = {r["level_code"]: r["cnt"] for r in topics_rows} # 2. Уроки — GROUP BY level_code (через JOIN) lessons_rows = await conn.fetch(""" SELECT t.level_code, COUNT(*) as cnt FROM learning_lessons l JOIN learning_topics t ON l.topic_id = t.topic_id WHERE t.level_code = ANY($1::text[]) GROUP BY t.level_code """, level_codes) lessons_map = {r["level_code"]: r["cnt"] for r in lessons_rows} # 3. Слова — GROUP BY level (level_id IS NULL) words_rows = await conn.fetch(""" SELECT level, COUNT(*) as cnt FROM level_words WHERE level = ANY($1::text[]) AND level_id IS NULL GROUP BY level """, level_codes) words_map = {r["level"]: r["cnt"] for r in words_rows} # 4. Тексты — GROUP BY level texts_rows = await conn.fetch(""" SELECT level, COUNT(*) as cnt FROM sentences WHERE level = ANY($1::text[]) GROUP BY level """, level_codes) texts_map = {r["level"]: r["cnt"] for r in texts_rows} # 5. Последняя правка — один запрос с UNION ALL + GROUP BY last_edited_rows = await conn.fetch(""" SELECT level_code, MAX(edited_at) as last_edited FROM ( SELECT level_code, edited_at FROM learning_topics WHERE level_code = ANY($1::text[]) UNION ALL SELECT t.level_code, l.edited_at FROM learning_lessons l JOIN learning_topics t ON l.topic_id = t.topic_id WHERE t.level_code = ANY($1::text[]) UNION ALL SELECT level, edited_at FROM level_words WHERE level = ANY($1::text[]) AND level_id IS NULL UNION ALL SELECT level, edited_at FROM sentences WHERE level = ANY($1::text[]) ) sub GROUP BY level_code """, level_codes) last_edited_map = {r["level_code"]: r["last_edited"] for r in last_edited_rows} # Собираем result result = [] for lvl in level_rows: code = lvl["code"] last_edited = last_edited_map.get(code) result.append({ "code": code, "name_ru": lvl["name_ru"], "topics_total": topics_map.get(code, 0), "lessons_total": lessons_map.get(code, 0), "words_total": words_map.get(code, 0), "texts_total": texts_map.get(code, 0), "last_edited": last_edited.isoformat() if last_edited else None, }) return {"levels": result} # ============ WORDS ============ @router.get("/words/levels") async def get_word_levels(request: Request): """Уровни A1–C2 с количеством слов (только level_id IS NULL).""" telegram_id, _ = await require_auth(request) _require_admin(telegram_id) pool = await get_pool() async with pool.acquire() as conn: level_rows = await conn.fetch(""" SELECT code, name_ru, sort_order FROM learning_levels WHERE is_active = TRUE ORDER BY sort_order """) if not level_rows: return {"levels": []} level_codes = [lvl["code"] for lvl in level_rows] # 🔧 ФИКС (25.09.2026): admin_content_get_word_levels_n_plus_1 — # раньше 6 уровней × 2 запроса = 12 round-trip. Теперь 1 GROUP BY. rows = await conn.fetch(""" SELECT level, COUNT(*) as cnt, MAX(edited_at) as last_edited FROM level_words WHERE level = ANY($1::text[]) AND level_id IS NULL GROUP BY level """, level_codes) stats_map = {r["level"]: r for r in rows} result = [] for lvl in level_rows: code = lvl["code"] stat = stats_map.get(code) last_edited = stat["last_edited"] if stat else None result.append({ "code": code, "name_ru": lvl["name_ru"], "words_count": stat["cnt"] if stat else 0, "last_edited": last_edited.isoformat() if last_edited else None, }) return {"levels": result} @router.get("/words/level/{level}") async def get_level_words( request: Request, level: str, q: Optional[str] = None, limit: int = 1000, ): """ Список слов уровня — только строки с level_id IS NULL. Поиск по word_pl / translation_ru / translation_uk / translation_en. """ telegram_id, _ = await require_auth(request) _require_admin(telegram_id) if level not in LEVELS: raise HTTPException(400, f"Invalid level: {level}") if limit < 1: limit = 1 elif limit > 2000: limit = 2000 pool = await get_pool() async with pool.acquire() as conn: if q and q.strip(): pattern = f"%{q.strip()}%" rows = await conn.fetch(""" SELECT id, word_pl, translation_ru, translation_uk, translation_en, edited_at FROM level_words WHERE level = $1 AND level_id IS NULL AND ( word_pl ILIKE $2 OR translation_ru ILIKE $2 OR translation_uk ILIKE $2 OR translation_en ILIKE $2 ) ORDER BY word_pl ASC LIMIT $3 """, level, pattern, limit) else: rows = await conn.fetch(""" SELECT id, word_pl, translation_ru, translation_uk, translation_en, edited_at FROM level_words WHERE level = $1 AND level_id IS NULL ORDER BY word_pl ASC LIMIT $2 """, level, limit) return { "level": level, "count": len(rows), "words": [ { "id": r["id"], "word_pl": r["word_pl"], "translation_ru": r["translation_ru"] or "", "translation_uk": r["translation_uk"] or "", "translation_en": r["translation_en"] or "", "edited_at": r["edited_at"].isoformat() if r["edited_at"] else None, } for r in rows ], } @router.get("/words/word/{word_id}") async def get_word(request: Request, word_id: int): """Одно слово по id.""" 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 id, word_pl, translation_ru, translation_uk, translation_en, level, edited_at FROM level_words WHERE id = $1 """, word_id) if not row: raise HTTPException(404, "Word not found") return { "id": row["id"], "word_pl": row["word_pl"], "translation_ru": row["translation_ru"] or "", "translation_uk": row["translation_uk"] or "", "translation_en": row["translation_en"] or "", "level": row["level"], "edited_at": row["edited_at"].isoformat() if row["edited_at"] else None, } @router.put("/words/word/{word_id}") async def update_word(request: Request, word_id: int): """ Обновить слово. Обновляем ВСЕ строки с этим (level, word_pl) — включая привязки к игровым уровням Филвордов (level_id != NULL), чтобы игра получила новый перевод. """ telegram_id, _ = await require_auth(request) _require_admin(telegram_id) body = await request.json() word_pl = (body.get("word_pl") or "").strip() translation_ru = (body.get("translation_ru") or "").strip() translation_uk = (body.get("translation_uk") or "").strip() translation_en = (body.get("translation_en") or "").strip() if not word_pl: raise HTTPException(400, "word_pl is required") pool = await get_pool() async with pool.acquire() as conn: existing = await conn.fetchrow(""" SELECT level, word_pl FROM level_words WHERE id = $1 """, word_id) if not existing: raise HTTPException(404, "Word not found") old_word_pl = existing["word_pl"] level = existing["level"] # 🔧 ФИКС: обновляем все строки с этим (level, old_word_pl) result = await conn.execute(""" UPDATE level_words SET word_pl = $1, translation_ru = $2, translation_uk = $3, translation_en = $4, edited_at = NOW() WHERE level = $5 AND word_pl = $6 """, word_pl, translation_ru, translation_uk, translation_en, level, old_word_pl) affected = int(result.split()[-1]) logger.info( f"[admin_content] word '{old_word_pl}' -> '{word_pl}' in {level}: " f"{affected} rows updated by admin {telegram_id}" ) return {"status": "ok", "word_id": word_id, "rows_updated": affected} @router.post("/words/level/{level}") async def create_word(request: Request, level: str): """Добавить слово в уровень (level_id = NULL).""" telegram_id, _ = await require_auth(request) _require_admin(telegram_id) if level not in LEVELS: raise HTTPException(400, f"Invalid level: {level}") body = await request.json() word_pl = (body.get("word_pl") or "").strip() translation_ru = (body.get("translation_ru") or "").strip() translation_uk = (body.get("translation_uk") or "").strip() translation_en = (body.get("translation_en") or "").strip() if not word_pl: raise HTTPException(400, "word_pl is required") pool = await get_pool() async with pool.acquire() as conn: existing = await conn.fetchval(""" SELECT id FROM level_words WHERE level = $1 AND level_id IS NULL AND LOWER(word_pl) = LOWER($2) """, level, word_pl) if existing: raise HTTPException(409, f"Word '{word_pl}' already exists in {level}") row = await conn.fetchrow(""" INSERT INTO level_words (level_id, word_pl, translation_ru, translation_uk, translation_en, level, edited_at) VALUES (NULL, $1, $2, $3, $4, $5, NOW()) RETURNING id """, word_pl, translation_ru, translation_uk, translation_en, level) logger.info( f"[admin_content] word created: #{row['id']} '{word_pl}' in {level} " f"by admin {telegram_id}" ) return {"status": "ok", "word_id": row["id"]} # ============ TEXTS (sentences) ============ @router.get("/texts/levels") async def get_text_levels(request: Request): """Уровни A1–C2 с количеством текстов и последней правкой.""" telegram_id, _ = await require_auth(request) _require_admin(telegram_id) pool = await get_pool() async with pool.acquire() as conn: level_rows = await conn.fetch(""" SELECT code, name_ru, sort_order FROM learning_levels WHERE is_active = TRUE ORDER BY sort_order """) if not level_rows: return {"levels": []} level_codes = [lvl["code"] for lvl in level_rows] # 🔧 ФИКС (25.09.2026): admin_content_text_levels_n_plus_1 — # 1 GROUP BY вместо 6×2 запросов. rows = await conn.fetch(""" SELECT level, COUNT(*) as cnt, MAX(edited_at) as last_edited FROM sentences WHERE level = ANY($1::text[]) GROUP BY level """, level_codes) stats_map = {r["level"]: r for r in rows} result = [] for lvl in level_rows: code = lvl["code"] stat = stats_map.get(code) last_edited = stat["last_edited"] if stat else None result.append({ "code": code, "name_ru": lvl["name_ru"], "texts_count": stat["cnt"] if stat else 0, "last_edited": last_edited.isoformat() if last_edited else None, }) return {"levels": result} @router.get("/texts/level/{level}") async def get_level_texts( request: Request, level: str, q: Optional[str] = None, limit: int = 1000, ): """Список текстов уровня с опциональным поиском.""" telegram_id, _ = await require_auth(request) _require_admin(telegram_id) if level not in LEVELS: raise HTTPException(400, f"Invalid level: {level}") if limit < 1: limit = 1 elif limit > 2000: limit = 2000 pool = await get_pool() async with pool.acquire() as conn: if q and q.strip(): pattern = f"%{q.strip()}%" rows = await conn.fetch(""" SELECT id, sentence_number, sentence_pl, translation_ru, translation_uk, translation_en, difficulty, edited_at FROM sentences WHERE level = $1 AND ( sentence_pl ILIKE $2 OR translation_ru ILIKE $2 OR translation_uk ILIKE $2 OR translation_en ILIKE $2 ) ORDER BY sentence_number ASC LIMIT $3 """, level, pattern, limit) else: rows = await conn.fetch(""" SELECT id, sentence_number, sentence_pl, translation_ru, translation_uk, translation_en, difficulty, edited_at FROM sentences WHERE level = $1 ORDER BY sentence_number ASC LIMIT $2 """, level, limit) return { "level": level, "count": len(rows), "texts": [ { "id": r["id"], "sentence_number": r["sentence_number"], "sentence_pl": r["sentence_pl"], "translation_ru": r["translation_ru"] or "", "translation_uk": r["translation_uk"] or "", "translation_en": r["translation_en"] or "", "difficulty": r["difficulty"], "edited_at": r["edited_at"].isoformat() if r["edited_at"] else None, } for r in rows ], } @router.get("/texts/text/{text_id}") async def get_text(request: Request, text_id: int): """Один текст по id.""" 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 id, sentence_number, sentence_pl, translation_ru, translation_uk, translation_en, difficulty, level, edited_at FROM sentences WHERE id = $1 """, text_id) if not row: raise HTTPException(404, "Text not found") return { "id": row["id"], "sentence_number": row["sentence_number"], "sentence_pl": row["sentence_pl"], "translation_ru": row["translation_ru"] or "", "translation_uk": row["translation_uk"] or "", "translation_en": row["translation_en"] or "", "difficulty": row["difficulty"], "level": row["level"], "edited_at": row["edited_at"].isoformat() if row["edited_at"] else None, } def _compute_difficulty(sentence_pl: str) -> int: """Пересчитывает difficulty по количеству слов (как в load_sentences.py).""" words_count = len(sentence_pl.split()) if words_count <= 4: return 1 elif words_count <= 6: return 2 return 3 @router.put("/texts/text/{text_id}") async def update_text(request: Request, text_id: int): """ Обновить текст. Difficulty пересчитывается автоматически по количеству слов в sentence_pl. """ telegram_id, _ = await require_auth(request) _require_admin(telegram_id) body = await request.json() sentence_pl = (body.get("sentence_pl") or "").strip() translation_ru = (body.get("translation_ru") or "").strip() translation_uk = (body.get("translation_uk") or "").strip() translation_en = (body.get("translation_en") or "").strip() if not sentence_pl: raise HTTPException(400, "sentence_pl is required") difficulty = _compute_difficulty(sentence_pl) pool = await get_pool() async with pool.acquire() as conn: exists = await conn.fetchval("SELECT 1 FROM sentences WHERE id = $1", text_id) if not exists: raise HTTPException(404, "Text not found") await conn.execute(""" UPDATE sentences SET sentence_pl = $1, translation_ru = $2, translation_uk = $3, translation_en = $4, difficulty = $5, edited_at = NOW() WHERE id = $6 """, sentence_pl, translation_ru, translation_uk, translation_en, difficulty, text_id) logger.info(f"[admin_content] text #{text_id} updated by admin {telegram_id}") return {"status": "ok", "text_id": text_id, "difficulty": difficulty} @router.delete("/texts/text/{text_id}") async def delete_text(request: Request, text_id: int): """Удалить текст.""" telegram_id, _ = await require_auth(request) _require_admin(telegram_id) pool = await get_pool() async with pool.acquire() as conn: exists = await conn.fetchval("SELECT 1 FROM sentences WHERE id = $1", text_id) if not exists: raise HTTPException(404, "Text not found") await conn.execute("DELETE FROM sentences WHERE id = $1", text_id) logger.info(f"[admin_content] text #{text_id} deleted by admin {telegram_id}") return {"status": "ok", "text_id": text_id} @router.post("/texts/level/{level}") async def create_text(request: Request, level: str): """ Добавить текст в уровень. Нумерация: max(sentence_number) + 1 для этого уровня. """ telegram_id, _ = await require_auth(request) _require_admin(telegram_id) if level not in LEVELS: raise HTTPException(400, f"Invalid level: {level}") body = await request.json() sentence_pl = (body.get("sentence_pl") or "").strip() translation_ru = (body.get("translation_ru") or "").strip() translation_uk = (body.get("translation_uk") or "").strip() translation_en = (body.get("translation_en") or "").strip() if not sentence_pl: raise HTTPException(400, "sentence_pl is required") # 🔧 ФИКС (30.09.2026): global_duplicate_warning — # проверяем все уровни. force=true пропускает проверку. force = bool(body.get("force", False)) difficulty = _compute_difficulty(sentence_pl) pool = await get_pool() async with pool.acquire() as conn: if not force: existing = await conn.fetchrow(""" SELECT id, level FROM sentences WHERE LOWER(sentence_pl) = LOWER($1) ORDER BY CASE level WHEN 'A1' THEN 1 WHEN 'A2' THEN 2 WHEN 'B1' THEN 3 WHEN 'B2' THEN 4 WHEN 'C1' THEN 5 WHEN 'C2' THEN 6 ELSE 7 END LIMIT 1 """, sentence_pl) if existing: existing_level = existing["level"] # Короткий текст для сообщения (не режем посреди слова) short_text = sentence_pl[:50] + ("…" if len(sentence_pl) > 50 else "") if existing_level == level: raise HTTPException( 409, f"DUPLICATE_SAME_LEVEL|{short_text}|{existing_level}" ) else: raise HTTPException( 409, f"DUPLICATE_OTHER_LEVEL|{short_text}|{existing_level}" ) next_num = await conn.fetchval(""" SELECT COALESCE(MAX(sentence_number), 0) + 1 FROM sentences WHERE level = $1 """, level) or 1 row = await conn.fetchrow(""" INSERT INTO sentences (sentence_number, sentence_pl, translation_ru, translation_uk, translation_en, difficulty, level, edited_at) VALUES ($1, $2, $3, $4, $5, $6, $7, NOW()) RETURNING id """, next_num, sentence_pl, translation_ru, translation_uk, translation_en, difficulty, level) logger.info( f"[admin_content] text created: #{row['id']} in {level} by admin {telegram_id}" ) return {"status": "ok", "text_id": row["id"], "sentence_number": next_num} @router.get("/texts/all") async def list_all_texts( request: Request, level: Optional[str] = None, q: Optional[str] = None, page: int = 1, limit: int = 50, ): """ 🔧 ОБНОВЛЕНО (30.09.2026): пагинация + total. Возвращает: { "total": 400, # всего под фильтром "page": 1, # текущая страница "limit": 50, # размер страницы "pages": 8, # всего страниц "texts": [...], # тексты текущей страницы } """ telegram_id, _ = await require_auth(request) _require_admin(telegram_id) if page < 1: page = 1 if limit < 1: limit = 1 elif limit > 500: limit = 500 offset = (page - 1) * limit pool = await get_pool() async with pool.acquire() as conn: conditions = [] params: list = [] idx = 1 if level and level in LEVELS: conditions.append(f"level = ${idx}") params.append(level) idx += 1 if q and q.strip(): conditions.append(f"""( sentence_pl ILIKE ${idx} OR translation_ru ILIKE ${idx} OR translation_uk ILIKE ${idx} OR translation_en ILIKE ${idx} )""") params.append(f"%{q.strip()}%") idx += 1 where = ("WHERE " + " AND ".join(conditions)) if conditions else "" # Total total = await conn.fetchval(f""" SELECT COUNT(*) FROM sentences {where} """, *params) or 0 # Page rows = await conn.fetch(f""" SELECT id, level, sentence_number, sentence_pl, translation_ru, translation_uk, translation_en, difficulty FROM sentences {where} ORDER BY level, sentence_number LIMIT ${idx} OFFSET ${idx + 1} """, *params, limit, offset) pages = (total + limit - 1) // limit if limit > 0 else 1 return { "total": total, "page": page, "limit": limit, "pages": pages, "texts": [ { "id": r["id"], "level": r["level"], "sentence_number": r["sentence_number"], "sentence_pl": r["sentence_pl"], "translation_ru": r["translation_ru"] or "", "translation_uk": r["translation_uk"] or "", "translation_en": r["translation_en"] or "", "difficulty": r["difficulty"], } for r in rows ], } # ============ LESSONS ============ @router.get("/lessons/levels") async def get_lesson_levels(request: Request): """ Уровни A1–C2 с количеством тем и последней правкой. Считаем только активные темы. """ telegram_id, _ = await require_auth(request) _require_admin(telegram_id) pool = await get_pool() async with pool.acquire() as conn: level_rows = await conn.fetch(""" SELECT code, name_ru, sort_order FROM learning_levels WHERE is_active = TRUE ORDER BY sort_order """) if not level_rows: return {"levels": []} level_codes = [lvl["code"] for lvl in level_rows] # 🔧 ФИКС (25.09.2026): admin_content_lesson_levels_n_plus_1 — # 3 GROUP BY запроса вместо 3×N. topics_rows = await conn.fetch(""" SELECT level_code, COUNT(*) as cnt FROM learning_topics WHERE level_code = ANY($1::text[]) AND is_active = TRUE GROUP BY level_code """, level_codes) topics_map = {r["level_code"]: r["cnt"] for r in topics_rows} lessons_rows = await conn.fetch(""" SELECT t.level_code, COUNT(*) as cnt FROM learning_lessons l JOIN learning_topics t ON l.topic_id = t.topic_id WHERE t.level_code = ANY($1::text[]) AND l.is_active = TRUE GROUP BY t.level_code """, level_codes) lessons_map = {r["level_code"]: r["cnt"] for r in lessons_rows} last_edited_rows = await conn.fetch(""" SELECT level_code, MAX(edited_at) as last_edited FROM ( SELECT t.level_code, t.edited_at FROM learning_topics t WHERE t.level_code = ANY($1::text[]) UNION ALL SELECT t.level_code, l.edited_at FROM learning_lessons l JOIN learning_topics t ON l.topic_id = t.topic_id WHERE t.level_code = ANY($1::text[]) ) sub GROUP BY level_code """, level_codes) last_edited_map = {r["level_code"]: r["last_edited"] for r in last_edited_rows} result = [] for lvl in level_rows: code = lvl["code"] last_edited = last_edited_map.get(code) result.append({ "code": code, "name_ru": lvl["name_ru"], "topics_count": topics_map.get(code, 0), "lessons_count": lessons_map.get(code, 0), "last_edited": last_edited.isoformat() if last_edited else None, }) return {"levels": result} @router.get("/lessons/level/{level}/topics") async def get_lesson_topics(request: Request, level: str): """ Темы уровня с количеством уроков и вопросов в тесте. Сортировка: order_number ASC. """ telegram_id, _ = await require_auth(request) _require_admin(telegram_id) if level not in LEVELS: raise HTTPException(400, f"Invalid level: {level}") pool = await get_pool() async with pool.acquire() as conn: rows = await conn.fetch(""" SELECT topic_id, order_number, name_pl, name_ru, name_uk, name_en, is_active FROM learning_topics WHERE level_code = $1 AND is_active = TRUE ORDER BY order_number ASC """, level) if not rows: return {"level": level, "topics": []} topic_ids = [r["topic_id"] for r in rows] # 🔧 ФИКС (25.09.2026): admin_content_lesson_topics_n_plus_1 — # 2 GROUP BY запроса вместо 2×N. lessons_rows = await conn.fetch(""" SELECT topic_id, COUNT(*) as cnt FROM learning_lessons WHERE topic_id = ANY($1::text[]) AND is_active = TRUE GROUP BY topic_id """, topic_ids) lessons_map = {r["topic_id"]: r["cnt"] for r in lessons_rows} test_rows = await conn.fetch(""" SELECT topic_id, COUNT(*) as cnt FROM learning_questions WHERE topic_id = ANY($1::text[]) AND is_test_question = TRUE GROUP BY topic_id """, topic_ids) test_map = {r["topic_id"]: r["cnt"] for r in test_rows} result = [] for r in rows: topic_id = r["topic_id"] result.append({ "topic_id": topic_id, "order_number": r["order_number"], "name_pl": r["name_pl"], "name_ru": r["name_ru"], "name_uk": r["name_uk"], "name_en": r["name_en"], "lessons_count": lessons_map.get(topic_id, 0), "test_questions_count": test_map.get(topic_id, 0), }) return {"level": level, "topics": result} @router.get("/lessons/topic/{topic_id}") async def get_lesson_topic(request: Request, topic_id: str): """ Тема целиком: инфо о теме + список уроков + информация о тесте темы. Уроки сортируются по order_number ASC. """ telegram_id, _ = await require_auth(request) _require_admin(telegram_id) pool = await get_pool() async with pool.acquire() as conn: topic = await conn.fetchrow(""" SELECT topic_id, level_code, order_number, name_pl, name_ru, name_uk, name_en, description_pl, description_ru, description_uk, description_en FROM learning_topics WHERE topic_id = $1 """, topic_id) if not topic: raise HTTPException(404, "Topic not found") lessons_rows = await conn.fetch(""" SELECT lesson_id, order_number, skill_tag, title_pl, title_ru, title_uk, title_en, is_active FROM learning_lessons WHERE topic_id = $1 AND is_active = TRUE ORDER BY order_number ASC """, topic_id) lessons = [] for l in lessons_rows: lessons.append({ "lesson_id": l["lesson_id"], "order_number": l["order_number"], "skill_tag": l["skill_tag"], "title_pl": l["title_pl"], "title_ru": l["title_ru"], "title_uk": l["title_uk"], "title_en": l["title_en"], }) # Считаем вопросы теста темы test_questions_count = await conn.fetchval(""" SELECT COUNT(*) FROM learning_questions WHERE topic_id = $1 AND is_test_question = TRUE """, topic_id) or 0 # Проверяем, есть ли вообще тест-вопросы has_test = test_questions_count > 0 return { "topic": { "topic_id": topic["topic_id"], "level_code": topic["level_code"], "order_number": topic["order_number"], "name_pl": topic["name_pl"], "name_ru": topic["name_ru"], "name_uk": topic["name_uk"], "name_en": topic["name_en"], "description_pl": topic["description_pl"], "description_ru": topic["description_ru"], "description_uk": topic["description_uk"], "description_en": topic["description_en"], }, "lessons": lessons, "has_test": has_test, "test_questions_count": test_questions_count, } @router.get("/lessons/lesson/{lesson_id}") async def get_lesson(request: Request, lesson_id: str): """ Урок целиком для WYSIWYG-редактора: - lesson: title, objective, explanation (4 языка) + метаданные - examples: список примеров (order_number ASC) - questions: список вопросов урока (is_test_question = FALSE) - options: список вариантов - wrong_because_text: человекочитаемый текст для неправильных вариантов """ telegram_id, _ = await require_auth(request) _require_admin(telegram_id) pool = await get_pool() async with pool.acquire() as conn: lesson = await conn.fetchrow(""" SELECT lesson_id, topic_id, order_number, skill_tag, title_pl, title_ru, title_uk, title_en, objective_pl, objective_ru, objective_uk, objective_en, explanation_pl, explanation_ru, explanation_uk, explanation_en, is_active FROM learning_lessons WHERE lesson_id = $1 """, lesson_id) if not lesson: raise HTTPException(404, "Lesson not found") # Примеры examples_rows = await conn.fetch(""" SELECT id, order_number, text_pl, text_ru, text_uk, text_en, audio_url FROM lesson_examples WHERE lesson_id = $1 ORDER BY order_number ASC """, lesson_id) examples = [ { "id": e["id"], "order_number": e["order_number"], "text_pl": e["text_pl"] or "", "text_ru": e["text_ru"] or "", "text_uk": e["text_uk"] or "", "text_en": e["text_en"] or "", "audio_url": e["audio_url"], } for e in examples_rows ] # Вопросы урока (не тест темы) questions_rows = await conn.fetch(""" SELECT question_id, context_type, question_type, skill_tag, difficulty, prompt_pl, prompt_ru, prompt_uk, prompt_en, correct_answer, hint_type, hint_value, options_language, is_test_question, test_order FROM learning_questions WHERE lesson_id = $1 AND is_test_question = FALSE ORDER BY id ASC """, lesson_id) # Справочник wrong_because → человекочитаемый текст (RU) wb_rows = await conn.fetch(""" SELECT wrong_because, explanation_ru FROM wrong_because_explanations """) wb_map = {w["wrong_because"]: w["explanation_ru"] for w in wb_rows} # 🔧 ФИКС (25.09.2026): admin_content_get_lesson_n_plus_1 — # один запрос ANY + группировка. question_ids = [q["question_id"] for q in questions_rows] all_options = [] if question_ids: all_options = await conn.fetch(""" SELECT question_id, option_key, text_pl, text_ru, text_uk, text_en, is_correct, wrong_because FROM question_options WHERE question_id = ANY($1::text[]) ORDER BY question_id, option_key ASC """, question_ids) options_by_q: dict = {} for o in all_options: options_by_q.setdefault(o["question_id"], []).append(o) questions = [] for q in questions_rows: options_rows = options_by_q.get(q["question_id"], []) options = [] for o in options_rows: wb_code = o["wrong_because"] options.append({ "option_key": o["option_key"], "text_pl": o["text_pl"] or "", "text_ru": o["text_ru"] or "", "text_uk": o["text_uk"] or "", "text_en": o["text_en"] or "", "is_correct": o["is_correct"], "wrong_because": wb_code, "wrong_because_text": wb_map.get(wb_code, "") if wb_code else "", }) questions.append({ "question_id": q["question_id"], "context_type": q["context_type"], "question_type": q["question_type"], "skill_tag": q["skill_tag"], "difficulty": q["difficulty"], "prompt_pl": q["prompt_pl"] or "", "prompt_ru": q["prompt_ru"] or "", "prompt_uk": q["prompt_uk"] or "", "prompt_en": q["prompt_en"] or "", "correct_answer": q["correct_answer"] or "", "hint_type": q["hint_type"], "hint_value": q["hint_value"], "options_language": q["options_language"] or "pl", "options": options, }) return { "lesson": { "lesson_id": lesson["lesson_id"], "topic_id": lesson["topic_id"], "order_number": lesson["order_number"], "skill_tag": lesson["skill_tag"], "title_pl": lesson["title_pl"] or "", "title_ru": lesson["title_ru"] or "", "title_uk": lesson["title_uk"] or "", "title_en": lesson["title_en"] or "", "objective_pl": lesson["objective_pl"] or "", "objective_ru": lesson["objective_ru"] or "", "objective_uk": lesson["objective_uk"] or "", "objective_en": lesson["objective_en"] or "", "explanation_pl": lesson["explanation_pl"] or "", "explanation_ru": lesson["explanation_ru"] or "", "explanation_uk": lesson["explanation_uk"] or "", "explanation_en": lesson["explanation_en"] or "", }, "examples": examples, "questions": questions, } @router.put("/lessons/lesson/{lesson_id}") async def update_lesson(request: Request, lesson_id: str): """ Сохранить урок целиком (Вариант B) — одна транзакция: 1. UPDATE learning_lessons (title, objective, explanation, edited_at). 2. DELETE + INSERT lesson_examples. 3. UPDATE learning_questions (prompt, correct_answer, hint_type, hint_value, edited_at). 4. DELETE + INSERT question_options (option_key генерируется A/B/C/D/...). Тело запроса: { "title_pl": "...", "title_en": "...", "title_ru": "...", "title_uk": "...", "objective_pl": "...", "objective_en": "...", "objective_ru": "...", "objective_uk": "...", "explanation_pl": "...", "explanation_en": "...", "explanation_ru": "...", "explanation_uk": "...", "examples": [ {"text_pl": "...", "text_en": "...", "text_ru": "...", "text_uk": "..."} ], "questions": [ { "question_id": "a1_greetings_l01_q1", "prompt_pl": "...", "prompt_en": "...", "prompt_ru": "...", "prompt_uk": "...", "hint_type": "first_letter" | null, "hint_value": "j" | null, "options_language": "pl" | "user", "options": [ {"text_pl": "...", "text_en": "...", "text_ru": "...", "text_uk": "...", "is_correct": true, "wrong_because": null}, {"text_pl": "...", "text_en": "...", "text_ru": "...", "text_uk": "...", "is_correct": false, "wrong_because": "wrong_case"} ] } ] } """ telegram_id, _ = await require_auth(request) _require_admin(telegram_id) body = await request.json() # ============ 1. Валидация ============ title_pl = (body.get("title_pl") or "").strip() title_ru = (body.get("title_ru") or "").strip() title_uk = (body.get("title_uk") or "").strip() title_en = (body.get("title_en") or "").strip() if not title_pl: raise HTTPException(400, "title_pl is required") objective_pl = (body.get("objective_pl") or "").strip() objective_ru = (body.get("objective_ru") or "").strip() objective_uk = (body.get("objective_uk") or "").strip() objective_en = (body.get("objective_en") or "").strip() explanation_pl = (body.get("explanation_pl") or "").strip() explanation_ru = (body.get("explanation_ru") or "").strip() explanation_uk = (body.get("explanation_uk") or "").strip() explanation_en = (body.get("explanation_en") or "").strip() examples_raw = body.get("examples") or [] if not isinstance(examples_raw, list): raise HTTPException(400, "examples must be a list") examples = [] for ex in examples_raw: text_pl = (ex.get("text_pl") or "").strip() if not text_pl: continue # пропускаем пустые примеры examples.append({ "text_pl": text_pl, "text_ru": (ex.get("text_ru") or "").strip(), "text_uk": (ex.get("text_uk") or "").strip(), "text_en": (ex.get("text_en") or "").strip(), }) questions_raw = body.get("questions") or [] if not isinstance(questions_raw, list): raise HTTPException(400, "questions must be a list") # Валидация вопросов questions = [] for q in questions_raw: question_id = (q.get("question_id") or "").strip() if not question_id: raise HTTPException(400, "question_id is required for every question") prompt_pl = (q.get("prompt_pl") or "").strip() if not prompt_pl: raise HTTPException(400, f"prompt_pl is required for question {question_id}") options_raw = q.get("options") or [] if not isinstance(options_raw, list) or len(options_raw) == 0: raise HTTPException(400, f"At least one option required for question {question_id}") # 🔧 ФИКС (25.09.2026): admin_content_option_key_overflow — # если >26 вариантов, chr(ord('A') + idx) даст '[' '\' ']' — # фронт не сопоставит correct_answer. Ограничиваем 26 (A-Z). if len(options_raw) > 26: raise HTTPException( 400, f"Question {question_id}: too many options (max 26, got {len(options_raw)})" ) # Проверка: ровно один правильный вариант correct_count = sum(1 for o in options_raw if o.get("is_correct") is True) if correct_count != 1: raise HTTPException( 400, f"Question {question_id}: exactly one option must be is_correct=true " f"(got {correct_count})" ) # Генерируем option_key A, B, C, D... options = [] correct_answer = None for idx, o in enumerate(options_raw): option_key = chr(ord('A') + idx) # A, B, C, D... text_pl_opt = (o.get("text_pl") or "").strip() if not text_pl_opt: raise HTTPException( 400, f"Option {option_key} of question {question_id}: text_pl is required" ) is_correct = bool(o.get("is_correct")) if is_correct: correct_answer = option_key wrong_because = o.get("wrong_because") if is_correct: wrong_because = None # у правильного wrong_because нет elif not wrong_because: wrong_because = None # оставляем None если пусто options.append({ "option_key": option_key, "text_pl": text_pl_opt, "text_ru": (o.get("text_ru") or "").strip(), "text_uk": (o.get("text_uk") or "").strip(), "text_en": (o.get("text_en") or "").strip(), "is_correct": is_correct, "wrong_because": wrong_because, }) hint_type = q.get("hint_type") if hint_type: hint_type = str(hint_type).strip() or None hint_value = q.get("hint_value") if hint_value: hint_value = str(hint_value).strip() or None # 🔧 НОВОЕ (04.10.2026): options_language — # 'pl' — варианты на польском (узнавание, грамматика) # 'user' — варианты на языке юзера (перевод) # Принимаем из тела, дефолт 'pl'. options_language = (q.get("options_language") or "pl").strip().lower() if options_language not in ("pl", "user"): options_language = "pl" questions.append({ "question_id": question_id, "prompt_pl": prompt_pl, "prompt_ru": (q.get("prompt_ru") or "").strip(), "prompt_uk": (q.get("prompt_uk") or "").strip(), "prompt_en": (q.get("prompt_en") or "").strip(), "correct_answer": correct_answer, "hint_type": hint_type, "hint_value": hint_value, "options_language": options_language, # 🔧 НОВОЕ "options": options, }) # ============ 2. Транзакция ============ pool = await get_pool() async with pool.acquire() as conn: async with conn.transaction(): # Проверяем, что урок существует exists = await conn.fetchval( "SELECT 1 FROM learning_lessons WHERE lesson_id = $1", lesson_id ) if not exists: raise HTTPException(404, "Lesson not found") # --- 2.1. UPDATE learning_lessons --- await conn.execute(""" UPDATE learning_lessons SET title_pl = $1, title_ru = $2, title_uk = $3, title_en = $4, objective_pl = $5, objective_ru = $6, objective_uk = $7, objective_en = $8, explanation_pl = $9, explanation_ru = $10, explanation_uk = $11, explanation_en = $12, edited_at = NOW() WHERE lesson_id = $13 """, title_pl, title_ru, title_uk, title_en, objective_pl, objective_ru, objective_uk, objective_en, explanation_pl, explanation_ru, explanation_uk, explanation_en, lesson_id, ) # --- 2.2. DELETE + INSERT lesson_examples --- await conn.execute( "DELETE FROM lesson_examples WHERE lesson_id = $1", lesson_id ) for idx, ex in enumerate(examples, start=1): await conn.execute(""" INSERT INTO lesson_examples (lesson_id, order_number, text_pl, text_ru, text_uk, text_en) VALUES ($1, $2, $3, $4, $5, $6) """, lesson_id, idx, ex["text_pl"], ex["text_ru"], ex["text_uk"], ex["text_en"], ) # --- 2.3. UPDATE learning_questions + DELETE + INSERT question_options --- for q in questions: # Проверяем, что вопрос принадлежит этому уроку q_exists = await conn.fetchval(""" SELECT 1 FROM learning_questions WHERE question_id = $1 AND lesson_id = $2 """, q["question_id"], lesson_id) if not q_exists: raise HTTPException( 400, f"Question {q['question_id']} does not belong to lesson {lesson_id}" ) await conn.execute(""" UPDATE learning_questions SET prompt_pl = $1, prompt_ru = $2, prompt_uk = $3, prompt_en = $4, correct_answer = $5, hint_type = $6, hint_value = $7, options_language = $8, edited_at = NOW() WHERE question_id = $9 """, q["prompt_pl"], q["prompt_ru"], q["prompt_uk"], q["prompt_en"], q["correct_answer"], q["hint_type"], q["hint_value"], q["options_language"], q["question_id"], ) # Удаляем старые опции await conn.execute( "DELETE FROM question_options WHERE question_id = $1", q["question_id"], ) # Вставляем новые for o in q["options"]: await conn.execute(""" INSERT INTO question_options (question_id, option_key, text_pl, text_ru, text_uk, text_en, is_correct, wrong_because) VALUES ($1, $2, $3, $4, $5, $6, $7, $8) """, q["question_id"], o["option_key"], o["text_pl"], o["text_ru"], o["text_uk"], o["text_en"], o["is_correct"], o["wrong_because"], ) logger.info( f"[admin_content] lesson '{lesson_id}' updated by admin {telegram_id}: " f"{len(examples)} examples, {len(questions)} questions" ) return { "status": "ok", "lesson_id": lesson_id, "examples_count": len(examples), "questions_count": len(questions), } # ============ WRONG BECAUSE (справочник) ============ @router.get("/wrong-because") async def get_wrong_because(request: Request): """ Справочник wrong_because — 7 записей. Отдаём код + 4 языка, чтобы фронт мог показать человекочитаемый текст на языке интерфейса препода. """ telegram_id, _ = await require_auth(request) _require_admin(telegram_id) pool = await get_pool() async with pool.acquire() as conn: rows = await conn.fetch(""" SELECT wrong_because, explanation_pl, explanation_ru, explanation_uk, explanation_en FROM wrong_because_explanations ORDER BY wrong_because ASC """) return { "items": [ { "wrong_because": r["wrong_because"], "explanation_pl": r["explanation_pl"] or "", "explanation_ru": r["explanation_ru"] or "", "explanation_uk": r["explanation_uk"] or "", "explanation_en": r["explanation_en"] or "", } for r in rows ] } # ============ LESSONS: TREE, CREATE, DELETE, TOPIC, TEST-GENERATE ============ @router.get("/lessons/tree") async def get_lessons_tree( request: Request, include_test_counts: bool = True, ): """ 🔧 НОВОЕ (02.10.2026): lessons_tree — дерево: уровни → темы → уроки. Один запрос вместо N+1. 🔧 ОБНОВЛЕНО (04.10.2026): track_include — каждая тема теперь содержит поле track ('pl' / 'ru_uk' / 'en'). Возвращает: { "levels": [ { "code": "A1", "name_ru": "...", "name_pl": "...", "topics_count": 2, "lessons_count": 20, "topics": [ { "topic_id": "a1_ru_uk_greetings", "name_ru": "Приветствия", "name_pl": "Powitania", "order_number": 1, "track": "ru_uk", "lessons_count": 10, "test_questions_count": 0, "lessons": [...] } ] } ] } """ telegram_id, _ = await require_auth(request) _require_admin(telegram_id) pool = await get_pool() async with pool.acquire() as conn: # Уровни levels = await conn.fetch(""" SELECT code, name_pl, name_ru, name_uk, name_en, sort_order FROM learning_levels WHERE is_active = TRUE ORDER BY sort_order """) if not levels: return {"levels": []} level_codes = [l["code"] for l in levels] # 🔧 ОБНОВЛЕНО (04.10.2026): track_include — # включаем track в дерево, чтобы фронт мог показать бейджи + фильтровать. topics = await conn.fetch(""" SELECT topic_id, level_code, order_number, track, name_pl, name_ru, name_uk, name_en FROM learning_topics WHERE level_code = ANY($1::text[]) AND is_active = TRUE ORDER BY level_code, order_number """, level_codes) if not topics: result = [] for lvl in levels: result.append({ "code": lvl["code"], "name_pl": lvl["name_pl"], "name_ru": lvl["name_ru"], "name_uk": lvl["name_uk"], "name_en": lvl["name_en"], "topics_count": 0, "lessons_count": 0, "topics": [], }) return {"levels": result} topic_ids = [t["topic_id"] for t in topics] # Уроки (одним запросом) lessons = await conn.fetch(""" SELECT lesson_id, topic_id, order_number, skill_tag, title_pl, title_ru, title_uk, title_en, is_active FROM learning_lessons WHERE topic_id = ANY($1::text[]) AND is_active = TRUE ORDER BY topic_id, order_number """, topic_ids) # Кол-во вопросов на урок (GROUP BY) q_counts = await conn.fetch(""" SELECT lesson_id, COUNT(*) as cnt FROM learning_questions WHERE lesson_id = ANY($1::text[]) AND is_test_question = FALSE GROUP BY lesson_id """, [les["lesson_id"] for les in lessons]) q_count_map = {r["lesson_id"]: r["cnt"] for r in q_counts} # Кол-во тестовых вопросов на тему test_counts = await conn.fetch(""" SELECT topic_id, COUNT(*) as cnt FROM learning_questions WHERE topic_id = ANY($1::text[]) AND is_test_question = TRUE GROUP BY topic_id """, topic_ids) test_count_map = {r["topic_id"]: r["cnt"] for r in test_counts} # Группируем уроки по topic_id lessons_by_topic: dict = {} for les in lessons: lessons_by_topic.setdefault(les["topic_id"], []).append({ "lesson_id": les["lesson_id"], "order_number": les["order_number"], "skill_tag": les["skill_tag"], "title_pl": les["title_pl"] or "", "title_ru": les["title_ru"] or "", "title_uk": les["title_uk"] or "", "title_en": les["title_en"] or "", "questions_count": q_count_map.get(les["lesson_id"], 0), "is_active": les["is_active"], }) # Группируем темы по level_code topics_by_level: dict = {} for t in topics: topics_by_level.setdefault(t["level_code"], []).append({ "topic_id": t["topic_id"], "order_number": t["order_number"], "track": t["track"] or "ru_uk", # 🔧 НОВОЕ "name_pl": t["name_pl"], "name_ru": t["name_ru"], "name_uk": t["name_uk"], "name_en": t["name_en"], "lessons_count": len(lessons_by_topic.get(t["topic_id"], [])), "test_questions_count": test_count_map.get(t["topic_id"], 0), "lessons": lessons_by_topic.get(t["topic_id"], []), }) # Финальный результат result = [] for lvl in levels: lvl_topics = topics_by_level.get(lvl["code"], []) total_lessons = sum(t["lessons_count"] for t in lvl_topics) result.append({ "code": lvl["code"], "name_pl": lvl["name_pl"], "name_ru": lvl["name_ru"], "name_uk": lvl["name_uk"], "name_en": lvl["name_en"], "topics_count": len(lvl_topics), "lessons_count": total_lessons, "topics": lvl_topics, }) return {"levels": result} @router.post("/lessons/topic") async def create_topic(request: Request): """ 🔧 НОВОЕ (02.10.2026): create_topic — создание новой темы. 🔧 ОБНОВЛЕНО (04.10.2026): track — аудитория темы (pl / ru_uk / en). Включён в topic_id. Тело: { "level_code": "A1", "track": "ru_uk", // опционально, по умолчанию 'ru_uk' "name_pl": "Powitania", "name_ru": "Приветствия", "name_uk": "Привітання", "name_en": "Greetings" } topic_id генерируется автоматически: {level}_{track}_{slug(name_pl)}. Пример: a1_ru_uk_powitania, a1_pl_powitania, a1_en_powitania. """ telegram_id, _ = await require_auth(request) _require_admin(telegram_id) body = await request.json() level_code = (body.get("level_code") or "").strip().upper() # 🔧 НОВОЕ (04.10.2026): track — аудитория темы. # 'pl' / 'ru_uk' / 'en'. По умолчанию 'ru_uk'. track = (body.get("track") or "ru_uk").strip().lower() name_pl = (body.get("name_pl") or "").strip() name_ru = (body.get("name_ru") or "").strip() name_uk = (body.get("name_uk") or "").strip() name_en = (body.get("name_en") or "").strip() if level_code not in LEVELS: raise HTTPException(400, f"Invalid level_code. Allowed: {LEVELS}") if track not in ("pl", "ru_uk", "en"): raise HTTPException(400, f"Invalid track. Allowed: pl, ru_uk, en") if not name_pl: raise HTTPException(400, "name_pl is required") if not name_ru: raise HTTPException(400, "name_ru is required") # Генерим topic_id: a1_ru_uk_greetings import re as _re slug = name_pl.lower() # Транслитерация польских букв translit = { 'ą': 'a', 'ć': 'c', 'ę': 'e', 'ł': 'l', 'ń': 'n', 'ó': 'o', 'ś': 's', 'ź': 'z', 'ż': 'z', } for pl, lat in translit.items(): slug = slug.replace(pl, lat) slug = _re.sub(r'[^a-z0-9]+', '_', slug).strip('_') if not slug: raise HTTPException(400, "Cannot generate topic_id from name_pl") # 🔧 НОВОЕ (04.10.2026): track_in_topic_id — # разные аудитории → разные topic_id, чтобы не было конфликтов. # Пример: a1_ru_uk_powitania, a1_pl_powitania, a1_en_powitania track_short = {"pl": "pl", "ru_uk": "ru_uk", "en": "en"}[track] topic_id = f"{level_code.lower()}_{track_short}_{slug[:40]}" pool = await get_pool() async with pool.acquire() as conn: # Проверка на дубликат existing = await conn.fetchval( "SELECT 1 FROM learning_topics WHERE topic_id = $1", topic_id ) if existing: raise HTTPException(409, f"Topic '{topic_id}' already exists") # Следующий order_number для этого уровня next_order = await conn.fetchval(""" SELECT COALESCE(MAX(order_number), 0) + 1 FROM learning_topics WHERE level_code = $1 """, level_code) or 1 await conn.execute(""" INSERT INTO learning_topics (topic_id, level_code, order_number, track, name_pl, name_ru, name_uk, name_en, is_active, edited_at) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, TRUE, NOW()) """, topic_id, level_code, next_order, track, name_pl, name_ru, name_uk, name_en) logger.info( f"[admin_content] topic created: '{topic_id}' in {level_code} " f"(track={track}) by admin {telegram_id}" ) return { "status": "ok", "topic_id": topic_id, "order_number": next_order, "track": track, } @router.post("/lessons/lesson") async def create_lesson(request: Request): """ 🔧 НОВОЕ (02.10.2026): create_lesson — создание урока с вопросами и опциями одной транзакцией. Тело: { "topic_id": "a1_greetings", "skill_tag": "podstawowe_powitania", "title_pl": "...", "title_ru": "...", "title_uk": "...", "title_en": "...", "explanation_pl": "...", "explanation_ru": "...", "explanation_uk": "...", "explanation_en": "...", "examples": [ {"text_pl": "...", "text_ru": "...", "text_uk": "...", "text_en": "..."} ], "questions": [ { "question_type": "recognition" | "production", "prompt_pl": "...", "prompt_ru": "...", "prompt_uk": "...", "prompt_en": "...", "difficulty": 1, "hint_type": "first_letter" | null, "hint_value": "D" | null, "options_language": "pl" | "user", "options": [ {"text_pl": "...", "text_ru": "...", "text_uk": "...", "text_en": "...", "is_correct": true, "wrong_because": null}, ... ] } ] } lesson_id генерируется: {topic_id}_l{order:02d}. question_id: {lesson_id}_q{n}. """ telegram_id, _ = await require_auth(request) _require_admin(telegram_id) body = await request.json() topic_id = (body.get("topic_id") or "").strip() skill_tag = (body.get("skill_tag") or "").strip() if not topic_id: raise HTTPException(400, "topic_id is required") if not skill_tag: raise HTTPException(400, "skill_tag is required") # Валидация skill_tag import re as _re if not _re.match(r'^[a-z][a-z0-9_]*$', skill_tag): raise HTTPException(400, "skill_tag must match ^[a-z][a-z0-9_]*$") title_pl = (body.get("title_pl") or "").strip() title_ru = (body.get("title_ru") or "").strip() title_uk = (body.get("title_uk") or "").strip() title_en = (body.get("title_en") or "").strip() if not title_pl: raise HTTPException(400, "title_pl is required") if not title_ru: raise HTTPException(400, "title_ru is required") explanation_pl = (body.get("explanation_pl") or "").strip() explanation_ru = (body.get("explanation_ru") or "").strip() explanation_uk = (body.get("explanation_uk") or "").strip() explanation_en = (body.get("explanation_en") or "").strip() examples_raw = body.get("examples") or [] examples = [] for ex in examples_raw: text_pl = (ex.get("text_pl") or "").strip() if not text_pl: continue examples.append({ "text_pl": text_pl, "text_ru": (ex.get("text_ru") or "").strip(), "text_uk": (ex.get("text_uk") or "").strip(), "text_en": (ex.get("text_en") or "").strip(), }) questions_raw = body.get("questions") or [] if not isinstance(questions_raw, list): raise HTTPException(400, "questions must be a list") # Валидация вопросов questions = [] for q in questions_raw: prompt_pl = (q.get("prompt_pl") or "").strip() if not prompt_pl: raise HTTPException(400, "prompt_pl is required for every question") q_type = (q.get("question_type") or "recognition").strip() if q_type not in ("recognition", "production"): raise HTTPException(400, f"Invalid question_type: {q_type}") options_raw = q.get("options") or [] if q_type == "recognition": if len(options_raw) < 2: raise HTTPException(400, "Recognition needs at least 2 options") correct_count = sum(1 for o in options_raw if o.get("is_correct") is True) if correct_count != 1: raise HTTPException( 400, f"Exactly one option must be is_correct=true (got {correct_count})" ) else: # production if not options_raw or not options_raw[0].get("text_pl"): raise HTTPException(400, "Production needs at least 1 correct answer") options = [] correct_answer = None for idx, o in enumerate(options_raw): option_key = chr(ord('A') + idx) text_pl_opt = (o.get("text_pl") or "").strip() if not text_pl_opt: raise HTTPException(400, f"Option {option_key}: text_pl is required") is_correct = bool(o.get("is_correct")) if is_correct: correct_answer = option_key wrong_because = o.get("wrong_because") if is_correct: wrong_because = None elif not wrong_because: # 🔧 wrong_because обязателен для неправильных raise HTTPException( 400, f"Option {option_key}: wrong_because is required for wrong options" ) options.append({ "option_key": option_key, "text_pl": text_pl_opt, "text_ru": (o.get("text_ru") or "").strip(), "text_uk": (o.get("text_uk") or "").strip(), "text_en": (o.get("text_en") or "").strip(), "is_correct": is_correct, "wrong_because": wrong_because, }) difficulty = int(q.get("difficulty") or 1) if difficulty < 1 or difficulty > 3: difficulty = 1 hint_type = q.get("hint_type") or None hint_value = q.get("hint_value") or None if hint_type: hint_type = str(hint_type).strip() or None if hint_value: hint_value = str(hint_value).strip() or None # 🔧 НОВОЕ (04.10.2026): options_language options_language = (q.get("options_language") or "pl").strip().lower() if options_language not in ("pl", "user"): options_language = "pl" questions.append({ "question_type": q_type, "prompt_pl": prompt_pl, "prompt_ru": (q.get("prompt_ru") or "").strip(), "prompt_uk": (q.get("prompt_uk") or "").strip(), "prompt_en": (q.get("prompt_en") or "").strip(), "correct_answer": correct_answer, "difficulty": difficulty, "hint_type": hint_type, "hint_value": hint_value, "options_language": options_language, # 🔧 НОВОЕ "options": options, }) # ============ Транзакция ============ pool = await get_pool() async with pool.acquire() as conn: async with conn.transaction(): # Проверка темы topic = await conn.fetchrow(""" SELECT topic_id, level_code FROM learning_topics WHERE topic_id = $1 """, topic_id) if not topic: raise HTTPException(404, f"Topic '{topic_id}' not found") # Следующий order_number next_order = await conn.fetchval(""" SELECT COALESCE(MAX(order_number), 0) + 1 FROM learning_lessons WHERE topic_id = $1 """, topic_id) or 1 # lesson_id: {topic_id}_l{order:02d} lesson_id = f"{topic_id}_l{next_order:02d}" # Проверка на дубликат exists = await conn.fetchval( "SELECT 1 FROM learning_lessons WHERE lesson_id = $1", lesson_id ) if exists: raise HTTPException(409, f"Lesson '{lesson_id}' already exists") # 1. INSERT learning_lessons await conn.execute(""" INSERT INTO learning_lessons (lesson_id, topic_id, order_number, skill_tag, title_pl, title_ru, title_uk, title_en, explanation_pl, explanation_ru, explanation_uk, explanation_en, is_active, edited_at) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, TRUE, NOW()) """, lesson_id, topic_id, next_order, skill_tag, title_pl, title_ru, title_uk, title_en, explanation_pl, explanation_ru, explanation_uk, explanation_en, ) # 2. INSERT lesson_examples for idx, ex in enumerate(examples, start=1): await conn.execute(""" INSERT INTO lesson_examples (lesson_id, order_number, text_pl, text_ru, text_uk, text_en) VALUES ($1, $2, $3, $4, $5, $6) """, lesson_id, idx, ex["text_pl"], ex["text_ru"], ex["text_uk"], ex["text_en"], ) # 3. INSERT learning_questions + question_options for idx, q in enumerate(questions, start=1): question_id = f"{lesson_id}_q{idx}" await conn.execute(""" INSERT INTO learning_questions (question_id, lesson_id, topic_id, context_type, question_type, skill_tag, difficulty, prompt_pl, prompt_ru, prompt_uk, prompt_en, correct_answer, hint_type, hint_value, is_test_question, options_language, edited_at) VALUES ($1, $2, $3, 'lesson_practice', $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, FALSE, $14, NOW()) """, question_id, lesson_id, topic_id, q["question_type"], skill_tag, q["difficulty"], q["prompt_pl"], q["prompt_ru"], q["prompt_uk"], q["prompt_en"], q["correct_answer"], q["hint_type"], q["hint_value"], q["options_language"], ) for o in q["options"]: await conn.execute(""" INSERT INTO question_options (question_id, option_key, text_pl, text_ru, text_uk, text_en, is_correct, wrong_because) VALUES ($1, $2, $3, $4, $5, $6, $7, $8) """, question_id, o["option_key"], o["text_pl"], o["text_ru"], o["text_uk"], o["text_en"], o["is_correct"], o["wrong_because"], ) logger.info( f"[admin_content] lesson created: '{lesson_id}' in topic '{topic_id}' " f"({len(questions)} questions) by admin {telegram_id}" ) return { "status": "ok", "lesson_id": lesson_id, "order_number": next_order, "questions_count": len(questions), } @router.delete("/lessons/lesson/{lesson_id}") async def delete_lesson(request: Request, lesson_id: str): """ 🔧 НОВОЕ (02.10.2026): delete_lesson — удаление урока с каскадом (примеры, вопросы, опции). ⚠️ CASCADE должен быть в схеме БД: learning_questions.lesson_id REFERENCES learning_lessons(lesson_id) lesson_examples.lesson_id REFERENCES learning_lessons(lesson_id) Если CASCADE нет — удаляем вручную. """ telegram_id, _ = await require_auth(request) _require_admin(telegram_id) pool = await get_pool() async with pool.acquire() as conn: async with conn.transaction(): exists = await conn.fetchval( "SELECT 1 FROM learning_lessons WHERE lesson_id = $1", lesson_id ) if not exists: raise HTTPException(404, "Lesson not found") # Удаляем опции вопросов await conn.execute(""" DELETE FROM question_options WHERE question_id IN ( SELECT question_id FROM learning_questions WHERE lesson_id = $1 ) """, lesson_id) # Удаляем вопросы await conn.execute( "DELETE FROM learning_questions WHERE lesson_id = $1", lesson_id ) # Удаляем примеры await conn.execute( "DELETE FROM lesson_examples WHERE lesson_id = $1", lesson_id ) # Удаляем сам урок await conn.execute( "DELETE FROM learning_lessons WHERE lesson_id = $1", lesson_id ) logger.info(f"[admin_content] lesson deleted: '{lesson_id}' by admin {telegram_id}") return {"status": "ok", "lesson_id": lesson_id} @router.get("/lessons/topic/{topic_id}/questions") async def get_topic_questions_for_test(request: Request, topic_id: str): """ 🔧 НОВОЕ (02.10.2026): get_topic_questions_for_test — все вопросы уроков темы для генератора теста. Возвращает список вопросов с опциями, сгруппированных по урокам. Используется в TestGeneratorModal для мультивыбора. """ telegram_id, _ = await require_auth(request) _require_admin(telegram_id) pool = await get_pool() async with pool.acquire() as conn: # Вопросы уроков этой темы (is_test_question=FALSE) questions = await conn.fetch(""" SELECT q.question_id, q.lesson_id, q.question_type, q.skill_tag, q.difficulty, q.prompt_pl, q.prompt_ru, q.prompt_uk, q.prompt_en, q.correct_answer, q.hint_type, q.hint_value, l.title_ru AS lesson_title_ru, l.title_pl AS lesson_title_pl, l.order_number AS lesson_order FROM learning_questions q JOIN learning_lessons l ON l.lesson_id = q.lesson_id WHERE q.topic_id = $1 AND q.is_test_question = FALSE ORDER BY l.order_number, q.question_id """, topic_id) if not questions: return { "topic_id": topic_id, "total": 0, "lessons": [], } question_ids = [q["question_id"] for q in questions] # Опции одним запросом options_rows = await conn.fetch(""" SELECT question_id, option_key, text_pl, text_ru, text_uk, text_en, is_correct, wrong_because FROM question_options WHERE question_id = ANY($1::text[]) ORDER BY question_id, option_key """, question_ids) options_by_q: dict = {} for o in options_rows: options_by_q.setdefault(o["question_id"], []).append({ "option_key": o["option_key"], "text_pl": o["text_pl"] or "", "text_ru": o["text_ru"] or "", "text_uk": o["text_uk"] or "", "text_en": o["text_en"] or "", "is_correct": o["is_correct"], "wrong_because": o["wrong_because"], }) # Группируем вопросы по урокам lessons_map: dict = {} for q in questions: lid = q["lesson_id"] if lid not in lessons_map: lessons_map[lid] = { "lesson_id": lid, "lesson_order": q["lesson_order"], "title_pl": q["lesson_title_pl"] or "", "title_ru": q["lesson_title_ru"] or "", "questions": [], } lessons_map[lid]["questions"].append({ "question_id": q["question_id"], "question_type": q["question_type"], "skill_tag": q["skill_tag"], "difficulty": q["difficulty"], "prompt_pl": q["prompt_pl"] or "", "prompt_ru": q["prompt_ru"] or "", "prompt_uk": q["prompt_uk"] or "", "prompt_en": q["prompt_en"] or "", "correct_answer": q["correct_answer"] or "", "hint_type": q["hint_type"], "hint_value": q["hint_value"], "options": options_by_q.get(q["question_id"], []), }) lessons_list = sorted(lessons_map.values(), key=lambda x: x["lesson_order"]) return { "topic_id": topic_id, "total": len(questions), "lessons": lessons_list, } @router.post("/lessons/test/generate") async def generate_topic_test(request: Request): """ 🔧 НОВОЕ (02.10.2026): generate_topic_test — генерирует тест темы из выбранных вопросов уроков. Тело: { "topic_id": "a1_greetings", "question_ids": ["a1_greetings_l01_q1", "a1_greetings_l01_q2", ...], "replace_existing": true — удалить старые тестовые вопросы темы } Логика: 1. Если replace_existing=true → удалить все существующие тестовые вопросы темы (is_test_question=TRUE). 2. Для каждого выбранного question_id — создать КОПИЮ: - новый question_id: {topic_id}_t{N} - is_test_question=TRUE, test_order=N - context_type='topic_test' - prompt и correct_answer скопированы - опции скопированы с ПЕРЕМЕШАННЫМИ option_key 3. Вернуть: {test_id_prefix, total_created} """ import random as _random telegram_id, _ = await require_auth(request) _require_admin(telegram_id) body = await request.json() topic_id = (body.get("topic_id") or "").strip() question_ids = body.get("question_ids") or [] replace_existing = bool(body.get("replace_existing", True)) if not topic_id: raise HTTPException(400, "topic_id is required") if not isinstance(question_ids, list) or len(question_ids) == 0: raise HTTPException(400, "question_ids must be a non-empty list") pool = await get_pool() async with pool.acquire() as conn: async with conn.transaction(): # Проверка темы topic = await conn.fetchrow(""" SELECT topic_id, level_code FROM learning_topics WHERE topic_id = $1 """, topic_id) if not topic: raise HTTPException(404, f"Topic '{topic_id}' not found") # Удаляем старые тестовые вопросы темы (если replace) if replace_existing: old_ids_rows = await conn.fetch(""" SELECT question_id FROM learning_questions WHERE topic_id = $1 AND is_test_question = TRUE """, topic_id) old_ids = [r["question_id"] for r in old_ids_rows] if old_ids: await conn.execute(""" DELETE FROM question_options WHERE question_id = ANY($1::text[]) """, old_ids) await conn.execute(""" DELETE FROM learning_questions WHERE question_id = ANY($1::text[]) """, old_ids) logger.info(f"[test_generate] deleted {len(old_ids)} old test questions") # Загружаем выбранные вопросы + опции questions = await conn.fetch(""" SELECT question_id, lesson_id, question_type, skill_tag, difficulty, prompt_pl, prompt_ru, prompt_uk, prompt_en, correct_answer, hint_type, hint_value, options_language FROM learning_questions WHERE question_id = ANY($1::text[]) AND topic_id = $2 """, question_ids, topic_id) if not questions: raise HTTPException(404, "No questions found for the given IDs") # Проверка: все запрошенные вопросы существуют found_ids = {q["question_id"] for q in questions} missing = set(question_ids) - found_ids if missing: raise HTTPException( 400, f"Questions not found in topic: {sorted(missing)[:5]}" ) # Опции для выбранных вопросов options_rows = await conn.fetch(""" SELECT question_id, option_key, text_pl, text_ru, text_uk, text_en, is_correct, wrong_because FROM question_options WHERE question_id = ANY($1::text[]) """, list(found_ids)) options_by_q: dict = {} for o in options_rows: options_by_q.setdefault(o["question_id"], []).append(dict(o)) # Создаём тестовые копии created = 0 for idx, q in enumerate(questions, start=1): test_question_id = f"{topic_id}_t{idx:02d}" # Проверка на дубликат dup = await conn.fetchval( "SELECT 1 FROM learning_questions WHERE question_id = $1", test_question_id, ) if dup: raise HTTPException( 409, f"Test question '{test_question_id}' already exists" ) # Новый correct_answer = option_key правильного варианта ПОСЛЕ перемешивания orig_options = options_by_q.get(q["question_id"], []) if not orig_options: continue # Находим правильную опцию orig_correct_key = None for o in orig_options: if o["is_correct"]: orig_correct_key = o["option_key"] break if not orig_correct_key: logger.warning( f"[test_generate] question {q['question_id']} has no correct option, skipped" ) continue # Перемешиваем порядок опций shuffled = list(orig_options) _random.shuffle(shuffled) # Переназначаем option_key A, B, C, D... new_options = [] new_correct_key = None for opt_idx, o in enumerate(shuffled): new_key = chr(ord('A') + opt_idx) if o["option_key"] == orig_correct_key: new_correct_key = new_key new_options.append({ "option_key": new_key, "text_pl": o["text_pl"] or "", "text_ru": o["text_ru"] or "", "text_uk": o["text_uk"] or "", "text_en": o["text_en"] or "", "is_correct": o["is_correct"], "wrong_because": o["wrong_because"] if not o["is_correct"] else None, }) # INSERT тестового вопроса await conn.execute(""" INSERT INTO learning_questions (question_id, lesson_id, topic_id, context_type, question_type, skill_tag, difficulty, prompt_pl, prompt_ru, prompt_uk, prompt_en, correct_answer, hint_type, hint_value, is_test_question, test_order, options_language, edited_at) VALUES ($1, NULL, $2, 'topic_test', $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, TRUE, $13, $14, NOW()) """, test_question_id, topic_id, q["question_type"], q["skill_tag"], q["difficulty"], q["prompt_pl"], q["prompt_ru"], q["prompt_uk"], q["prompt_en"], new_correct_key, q["hint_type"], q["hint_value"], idx, q["options_language"] or "pl", ) for o in new_options: await conn.execute(""" INSERT INTO question_options (question_id, option_key, text_pl, text_ru, text_uk, text_en, is_correct, wrong_because) VALUES ($1, $2, $3, $4, $5, $6, $7, $8) """, test_question_id, o["option_key"], o["text_pl"], o["text_ru"], o["text_uk"], o["text_en"], o["is_correct"], o["wrong_because"], ) created += 1 logger.info( f"[admin_content] test generated for topic '{topic_id}': " f"{created} questions by admin {telegram_id}" ) return { "status": "ok", "topic_id": topic_id, "total_created": created, } # ============ LESSONS: ADD QUESTION (edit-режим) ============ @router.post("/lessons/lesson/{lesson_id}/add-question") async def add_question_to_lesson(request: Request, lesson_id: str): """ 🔧 НОВОЕ (02.10.2026): add_question_to_lesson — добавляет ОДИН новый вопрос в существующий урок (edit-режим). Используется, когда админ в редакторе урока добавляет новое задание через «+ Добавить задание». Старые вопросы обновляются через PUT /lessons/lesson/{lesson_id}. Тело: { "question_type": "recognition" | "production", "difficulty": 1, "prompt_pl": "...", "prompt_ru": "...", "prompt_uk": "...", "prompt_en": "...", "hint_type": null, "hint_value": null, "options_language": "pl" | "user", "options": [ {"text_pl": "...", "text_ru": "...", "text_uk": "...", "text_en": "...", "is_correct": true, "wrong_because": null}, ... ] } Возвращает: {status, question_id, order_number} """ telegram_id, _ = await require_auth(request) _require_admin(telegram_id) body = await request.json() pool = await get_pool() async with pool.acquire() as conn: async with conn.transaction(): # Проверка урока lesson = await conn.fetchrow(""" SELECT lesson_id, topic_id, skill_tag FROM learning_lessons WHERE lesson_id = $1 """, lesson_id) if not lesson: raise HTTPException(404, "Lesson not found") topic_id = lesson["topic_id"] skill_tag = lesson["skill_tag"] # Валидация question_type q_type = (body.get("question_type") or "recognition").strip() if q_type not in ("recognition", "production"): raise HTTPException(400, f"Invalid question_type: {q_type}") prompt_pl = (body.get("prompt_pl") or "").strip() if not prompt_pl: raise HTTPException(400, "prompt_pl is required") difficulty = int(body.get("difficulty") or 1) if difficulty < 1 or difficulty > 3: difficulty = 1 hint_type = body.get("hint_type") if hint_type: hint_type = str(hint_type).strip() or None hint_value = body.get("hint_value") if hint_value: hint_value = str(hint_value).strip() or None # 🔧 НОВОЕ (04.10.2026): options_language options_language = (body.get("options_language") or "pl").strip().lower() if options_language not in ("pl", "user"): options_language = "pl" # Валидация options options_raw = body.get("options") or [] if not isinstance(options_raw, list) or len(options_raw) == 0: raise HTTPException(400, "At least one option is required") correct_count = sum(1 for o in options_raw if o.get("is_correct") is True) if correct_count != 1: raise HTTPException( 400, f"Exactly one option must be is_correct=true (got {correct_count})" ) # Следующий номер вопроса # Формат: {lesson_id}_q{N}, где N — последний + 1. # Ищем существующие вопросы урока и парсим числовой суффикс. existing_q = await conn.fetch(""" SELECT question_id FROM learning_questions WHERE lesson_id = $1 """, lesson_id) max_n = 0 for r in existing_q: qid = r["question_id"] # qid = "a1_greetings_l01_q3" parts = qid.rsplit("_q", 1) if len(parts) == 2: try: n = int(parts[1]) if n > max_n: max_n = n except ValueError: pass next_n = max_n + 1 question_id = f"{lesson_id}_q{next_n}" # Генерируем options (A, B, C, D...) new_options = [] correct_answer = None for idx, o in enumerate(options_raw): option_key = chr(ord('A') + idx) text_pl_opt = (o.get("text_pl") or "").strip() if not text_pl_opt: raise HTTPException(400, f"Option {option_key}: text_pl is required") is_correct = bool(o.get("is_correct")) if is_correct: correct_answer = option_key wrong_because = o.get("wrong_because") if is_correct: wrong_because = None elif not wrong_because: raise HTTPException( 400, f"Option {option_key}: wrong_because is required for wrong options" ) new_options.append({ "option_key": option_key, "text_pl": text_pl_opt, "text_ru": (o.get("text_ru") or "").strip(), "text_uk": (o.get("text_uk") or "").strip(), "text_en": (o.get("text_en") or "").strip(), "is_correct": is_correct, "wrong_because": wrong_because, }) # INSERT question await conn.execute(""" INSERT INTO learning_questions (question_id, lesson_id, topic_id, context_type, question_type, skill_tag, difficulty, prompt_pl, prompt_ru, prompt_uk, prompt_en, correct_answer, hint_type, hint_value, is_test_question, options_language, edited_at) VALUES ($1, $2, $3, 'lesson_practice', $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, FALSE, $14, NOW()) """, question_id, lesson_id, topic_id, q_type, skill_tag, difficulty, prompt_pl, (body.get("prompt_ru") or "").strip(), (body.get("prompt_uk") or "").strip(), (body.get("prompt_en") or "").strip(), correct_answer, hint_type, hint_value, options_language, ) # INSERT options for o in new_options: await conn.execute(""" INSERT INTO question_options (question_id, option_key, text_pl, text_ru, text_uk, text_en, is_correct, wrong_because) VALUES ($1, $2, $3, $4, $5, $6, $7, $8) """, question_id, o["option_key"], o["text_pl"], o["text_ru"], o["text_uk"], o["text_en"], o["is_correct"], o["wrong_because"], ) logger.info( f"[admin_content] question added: '{question_id}' to lesson '{lesson_id}' " f"by admin {telegram_id}" ) return { "status": "ok", "question_id": question_id, "order_number": next_n, } # ============ LESSONS: DELETE TOPIC ============ @router.delete("/lessons/topic/{topic_id}") async def delete_topic(request: Request, topic_id: str): """ 🔧 НОВОЕ (04.10.2026): delete_topic — удаляет тему со ВСЕМ содержимым (уроки, вопросы, опции, примеры). Каскад: 1. Опции вопросов темы 2. Вопросы темы 3. Примеры уроков темы 4. Уроки темы 5. Сама тема Всё в одной транзакции — если упадёт — откат. """ telegram_id, _ = await require_auth(request) _require_admin(telegram_id) pool = await get_pool() async with pool.acquire() as conn: async with conn.transaction(): # Проверка существования exists = await conn.fetchval( "SELECT 1 FROM learning_topics WHERE topic_id = $1", topic_id ) if not exists: raise HTTPException(404, "Topic not found") # 1. Опции вопросов темы await conn.execute(""" DELETE FROM question_options WHERE question_id IN ( SELECT question_id FROM learning_questions WHERE topic_id = $1 ) """, topic_id) # 2. Вопросы темы await conn.execute( "DELETE FROM learning_questions WHERE topic_id = $1", topic_id ) # 3. Примеры уроков темы await conn.execute(""" DELETE FROM lesson_examples WHERE lesson_id IN ( SELECT lesson_id FROM learning_lessons WHERE topic_id = $1 ) """, topic_id) # 4. Уроки темы await conn.execute( "DELETE FROM learning_lessons WHERE topic_id = $1", topic_id ) # 5. Сама тема await conn.execute( "DELETE FROM learning_topics WHERE topic_id = $1", topic_id ) logger.info( f"[admin_content] topic deleted: '{topic_id}' " f"(with all lessons, questions, options, examples) " f"by admin {telegram_id}" ) return {"status": "ok", "topic_id": topic_id}