""" Admin Wordsearch Router — конструктор уровней филвордов. Доступ: только для ADMIN_IDS. Логика: препод создаёт уровни вручную через админку. Эндпоинты: - GET /admin/wordsearch/words?level=A1 — слова из CSV + счётчики - GET /admin/wordsearch/levels?level=A1 — список созданных уровней - GET /admin/wordsearch/level/{id} — один уровень (для редактирования) - POST /admin/wordsearch/level — создать - PUT /admin/wordsearch/level/{id} — обновить - DELETE /admin/wordsearch/level/{id} — удалить - POST /admin/wordsearch/validate — проверить корректность уровня """ import json import logging 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/wordsearch", tags=["admin-wordsearch"]) LEVELS = ["A1", "A2", "B1", "B2", "C1", "C2"] MAX_GRID_SIZE = 15 def _json_or_value(v): """🔧 ФИКС (30.09.2026): asyncpg_jsonb_string — asyncpg возвращает JSONB как строку. Парсим, если строка.""" if isinstance(v, str): try: return json.loads(v) except (json.JSONDecodeError, TypeError): return v return v def _require_admin(telegram_id: int) -> None: if telegram_id not in ADMIN_IDS: raise HTTPException(403, "Access denied") # ============ СЛОВА ИЗ CSV ============ @router.get("/words") async def get_csv_words(request: Request, level: str = "A1"): """ Список слов из CSV для уровня с счётчиком использований. Сортировка: сначала неиспользованные, потом по алфавиту. """ 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 w.word_pl, w.translation_ru, w.translation_uk, w.translation_en, COALESCE(u.usage_count, 0) AS usage_count FROM csv_words w LEFT JOIN word_usage u ON u.word_pl = w.word_pl AND u.level_code = w.level_code WHERE w.level_code = $1 ORDER BY COALESCE(u.usage_count, 0) ASC, w.word_pl ASC """, level) return { "level": level, "total": len(rows), "words": [ { "word_pl": r["word_pl"], "translation_ru": r["translation_ru"] or "", "translation_uk": r["translation_uk"] or "", "translation_en": r["translation_en"] or "", "usage_count": r["usage_count"], } for r in rows ], } # ============ УРОВНИ ============ @router.get("/levels") async def list_levels(request: Request, level: Optional[str] = None): """Список созданных вручную уровней филвордов.""" telegram_id, _ = await require_auth(request) _require_admin(telegram_id) pool = await get_pool() async with pool.acquire() as conn: if level and level in LEVELS: rows = await conn.fetch(""" SELECT id, level_number, grid_size, level, is_active, created_at, jsonb_array_length(grid_letters) AS rows_count FROM levels WHERE created_by IS NOT NULL AND level = $1 ORDER BY level_number ASC, id ASC """, level) else: rows = await conn.fetch(""" SELECT id, level_number, grid_size, level, is_active, created_at, jsonb_array_length(grid_letters) AS rows_count FROM levels WHERE created_by IS NOT NULL ORDER BY level, level_number ASC, id ASC """) return { "total": len(rows), "levels": [ { "id": r["id"], "level": r["level"], "level_number": r["level_number"], "grid_size": r["grid_size"], "is_active": r["is_active"], "created_at": r["created_at"].isoformat() if r["created_at"] else None, } for r in rows ], } @router.get("/level/{level_id}") async def get_level(request: Request, level_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 id, level_number, grid_size, level, grid_letters, word_paths, is_active, created_by, created_at FROM levels WHERE id = $1 AND created_by IS NOT NULL """, level_id) if not row: raise HTTPException(404, "Level not found") # Слова уровня для списка размещённых words_rows = await conn.fetch(""" SELECT word_pl, translation_ru, translation_uk, translation_en FROM level_words WHERE level_id = $1 """, level_id) return { "id": row["id"], "level": row["level"], "level_number": row["level_number"], "grid_size": row["grid_size"], "grid_letters": _json_or_value(row["grid_letters"]), "word_paths": _json_or_value(row["word_paths"]), "is_active": row["is_active"], "created_at": row["created_at"].isoformat() if row["created_at"] else None, "words": [ { "word_pl": w["word_pl"], "translation_ru": w["translation_ru"] or "", "translation_uk": w["translation_uk"] or "", "translation_en": w["translation_en"] or "", } for w in words_rows ], } def _validate_payload(payload: dict) -> tuple[int, list, dict]: """ Валидация grid_letters и word_paths. Returns: (grid_size, grid_letters, word_paths) Raises: HTTPException(400, ...) """ grid_size = payload.get("grid_size") if not isinstance(grid_size, int) or grid_size < 3 or grid_size > MAX_GRID_SIZE: raise HTTPException(400, f"grid_size must be 3-{MAX_GRID_SIZE}") grid_letters = payload.get("grid_letters") if not isinstance(grid_letters, list) or len(grid_letters) != grid_size: raise HTTPException(400, "grid_letters must be a 2D array of size grid_size × grid_size") for row in grid_letters: if not isinstance(row, list) or len(row) != grid_size: raise HTTPException(400, "each row of grid_letters must have grid_size elements") for cell in row: # Разрешаем: null (неактивная), "", либо одна буква if cell is not None and (not isinstance(cell, str) or len(cell) > 1): raise HTTPException(400, "cell must be null, '', or a single character") word_paths = payload.get("word_paths") if not isinstance(word_paths, dict): raise HTTPException(400, "word_paths must be an object") # Проверяем, что каждое слово в word_paths имеет корректный путь for word, path in word_paths.items(): if not isinstance(word, str) or not word: raise HTTPException(400, "word must be a non-empty string") if not isinstance(path, list) or len(path) == 0: raise HTTPException(400, f"path for '{word}' must be a non-empty array") # Проверяем, что путь соседний (Manhattan distance 1) for i in range(1, len(path)): prev = path[i - 1] cur = path[i] if not (isinstance(prev, list) and len(prev) == 2 and isinstance(cur, list) and len(cur) == 2): raise HTTPException(400, f"path points for '{word}' must be [r, c]") dr = abs(prev[0] - cur[0]) dc = abs(prev[1] - cur[1]) if not (dr <= 1 and dc <= 1 and (dr + dc) > 0): raise HTTPException(400, f"path for '{word}' has non-adjacent cells") # Проверяем, что буквы в клетках совпадают со словом word_upper = word.upper() if len(path) != len(word_upper): raise HTTPException( 400, f"path length for '{word}' ({len(path)}) != word length ({len(word_upper)})" ) for i, (r, c) in enumerate(path): if r < 0 or r >= grid_size or c < 0 or c >= grid_size: raise HTTPException(400, f"path for '{word}' goes out of grid") cell = grid_letters[r][c] if cell != word_upper[i]: raise HTTPException( 400, f"grid[{r}][{c}] = {cell!r}, expected {word_upper[i]!r} for '{word}'" ) return grid_size, grid_letters, word_paths @router.post("/validate") async def validate_level(request: Request): """Проверяет корректность уровня без сохранения.""" telegram_id, _ = await require_auth(request) _require_admin(telegram_id) body = await request.json() try: _validate_payload(body) except HTTPException as e: return {"valid": False, "error": e.detail} return {"valid": True} # ============ СОЗДАНИЕ / ОБНОВЛЕНИЕ ============ async def _upsert_level_words(conn, level_id: int, level_code: str, word_paths: dict): """Обновляет level_words и word_usage для уровня.""" # Получаем переводы из csv_words words = list(word_paths.keys()) if not words: return rows = await conn.fetch(""" SELECT word_pl, translation_ru, translation_uk, translation_en FROM csv_words WHERE level_code = $1 AND word_pl = ANY($2::text[]) """, level_code, words) translations_map = {r["word_pl"]: r for r in rows} # Удаляем старые level_words await conn.execute("DELETE FROM level_words WHERE level_id = $1", level_id) # Вставляем новые for word in words: trans = translations_map.get(word, {}) await conn.execute(""" INSERT INTO level_words (level_id, word_pl, translation_ru, translation_uk, translation_en, level) VALUES ($1, $2, $3, $4, $5, $6) """, level_id, word, trans["translation_ru"] if trans else "", trans["translation_uk"] if trans else "", trans["translation_en"] if trans else "", level_code, ) @router.post("/level") async def create_level(request: Request): """Создать новый уровень.""" telegram_id, _ = await require_auth(request) _require_admin(telegram_id) body = await request.json() level_code = body.get("level", "A1") if level_code not in LEVELS: raise HTTPException(400, f"Invalid level: {level_code}") level_number = body.get("level_number") if not isinstance(level_number, int) or level_number < 1: raise HTTPException(400, "level_number must be a positive integer") is_active = bool(body.get("is_active", False)) grid_size, grid_letters, word_paths = _validate_payload(body) pool = await get_pool() async with pool.acquire() as conn: async with conn.transaction(): # 🔧 ФИКС (29.09.2026): проверяем только РУЧНЫЕ уровни. # Старые авто-сгенерированные (created_by IS NULL) не мешают. existing = await conn.fetchval(""" SELECT id FROM levels WHERE level = $1 AND level_number = $2 AND created_by IS NOT NULL """, level_code, level_number) if existing: raise HTTPException( 409, f"Level {level_code} #{level_number} already exists (id={existing})" ) # 🔧 ФИКС (30.09.2026): jsonb_double_encoding — # asyncpg сам сериализует dict/list в JSONB. # json.dumps() приводил к двойному кодированию (JSONB-строка вместо объекта). row = await conn.fetchrow(""" INSERT INTO levels (level_number, grid_size, game_type, level, grid_letters, word_paths, is_active, created_by, created_at) VALUES ($1, $2, 'wordsearch', $3, $4, $5, $6, $7, NOW()) RETURNING id """, level_number, grid_size, level_code, grid_letters, # ← передаём как есть, asyncpg сам сериализует в JSONB word_paths, # ← то же is_active, telegram_id, ) level_id = row["id"] # Обновляем level_words await _upsert_level_words(conn, level_id, level_code, word_paths) # Обновляем счётчики использований for word in word_paths.keys(): await conn.execute(""" INSERT INTO word_usage (level_code, word_pl, usage_count, last_used_at) VALUES ($1, $2, 1, NOW()) ON CONFLICT (level_code, word_pl) DO UPDATE SET usage_count = word_usage.usage_count + 1, last_used_at = NOW() """, level_code, word) logger.info( f"[admin_wordsearch] level created: {level_code} #{level_number} " f"(id={level_id}, {len(word_paths)} words, active={is_active}) " f"by admin {telegram_id}" ) return {"status": "ok", "level_id": level_id} @router.put("/level/{level_id}") async def update_level(request: Request, level_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, level, level_number FROM levels WHERE id = $1 AND created_by IS NOT NULL """, level_id) if not existing: raise HTTPException(404, "Level not found") level_code = existing["level"] grid_size, grid_letters, word_paths = _validate_payload(body) is_active = bool(body.get("is_active", False)) async with conn.transaction(): # 🔧 ФИКС (30.09.2026): jsonb_double_encoding — # убран json.dumps, asyncpg сам сериализует в JSONB. await conn.execute(""" UPDATE levels SET grid_size = $1, grid_letters = $2, word_paths = $3, is_active = $4 WHERE id = $5 """, grid_size, grid_letters, # ← передаём как есть word_paths, # ← то же is_active, level_id, ) await _upsert_level_words(conn, level_id, level_code, word_paths) # 🔧 ФИКС (30.09.2026): update_double_count — # при UPDATE не инкрементим счётчики. Слова, которые уже были — # считаем как «те же», новые — добавляем. # Сначала откатываем старые (убираем из word_usage, если их нет в новом) old_words_rows = await conn.fetch(""" SELECT word_pl FROM level_words WHERE level_id = $1 """, level_id) # (старые words уже удалены в _upsert_level_words выше) # Добавляем только те слова, которых ещё НЕ было в word_usage for word in word_paths.keys(): await conn.execute(""" INSERT INTO word_usage (level_code, word_pl, usage_count, last_used_at) VALUES ($1, $2, 1, NOW()) ON CONFLICT (level_code, word_pl) DO UPDATE SET last_used_at = NOW() """, level_code, word) logger.info( f"[admin_wordsearch] level updated: id={level_id} " f"({len(word_paths)} words, active={is_active}) " f"by admin {telegram_id}" ) return {"status": "ok", "level_id": level_id} @router.delete("/level/{level_id}") async def delete_level(request: Request, level_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 id, level, level_number FROM levels WHERE id = $1 AND created_by IS NOT NULL """, level_id) if not row: raise HTTPException(404, "Level not found") await conn.execute("DELETE FROM levels WHERE id = $1", level_id) logger.info( f"[admin_wordsearch] level deleted: id={level_id} " f"({row['level']} #{row['level_number']}) by admin {telegram_id}" ) return {"status": "ok", "level_id": level_id}