diff --git a/database.py b/database.py index 1b1dc0e..69b47fe 100644 --- a/database.py +++ b/database.py @@ -38,6 +38,43 @@ async def init_db(): ) """) + # 🔧 ФИКС (30.09.2026): last_completed_by_level — + # per-level счётчик прогресса. Раньше был один last_completed_level, + # который смешивал A1+A2+B1 → юзер не мог открыть уровень выше max. + col_exists = await conn.fetchval(""" + SELECT 1 FROM information_schema.columns + WHERE table_name = 'users' AND column_name = 'last_completed_by_level' + """) + if not col_exists: + await conn.execute(""" + ALTER TABLE users ADD COLUMN last_completed_by_level JSONB DEFAULT '{}'::jsonb + """) + logger.info("Added last_completed_by_level column to users") + + # Backfill из user_progress + await conn.execute(""" + UPDATE users u + SET last_completed_by_level = COALESCE(sub.by_level, '{}'::jsonb) + FROM ( + SELECT + user_id, + jsonb_object_agg(level, max_num) AS by_level + FROM ( + SELECT + up.user_id, + up.level, + MAX(l.level_number) AS max_num + FROM user_progress up + JOIN levels l ON l.id = up.level_id + WHERE up.completed_at IS NOT NULL + GROUP BY up.user_id, up.level + ) inner_sub + GROUP BY user_id + ) sub + WHERE u.telegram_id = sub.user_id + """) + logger.info("Backfilled last_completed_by_level from user_progress") + # ============ Авто-миграция: добавляем current_level в users ============ col_exists = await conn.fetchval(""" SELECT 1 FROM information_schema.columns diff --git a/main.py b/main.py index 3150b39..55bff5e 100644 --- a/main.py +++ b/main.py @@ -14,7 +14,7 @@ from fastapi.staticfiles import StaticFiles from config import FRONTEND_ORIGINS, UPLOADS_DIR, CF_IPS from database import init_db from routers import users, game, hints, leaderboard, sentences, achievements, wordquiz, bubblewords, pronunciation, assistant, learning, tts, typing, teacher, support, admin, feed, admin_content -from routers import lectures, admin_auth, admin_wordsearch +from routers import lectures, admin_auth, admin_wordsearch, admin_users from routers.sentences import init_sentences from routers.achievements import init_achievements from routers.learning_data import init_learning_data @@ -69,7 +69,10 @@ class RateLimiter: "/game/check-word": {"max_requests": 30, "window": 60}, "/game/complete-level": {"max_requests": 10, "window": 60}, "/sentences/check": {"max_requests": 20, "window": 60}, - "/leaderboard": {"max_requests": 10, "window": 60}, + # 🔧 ФИКС (30.09.2026): leaderboard_rate_limit_too_low — + # Mini App делает несколько запросов подряд при загрузке страницы + # (аватар + данные + ре-рендер) → 429. Подняли до 30/мин. + "/leaderboard": {"max_requests": 30, "window": 60}, "/assistant/chat": {"max_requests": 20, "window": 60}, "/learning/answer": {"max_requests": 30, "window": 60}, "/tts": {"max_requests": 30, "window": 60}, @@ -366,6 +369,7 @@ app.include_router(admin_content.router) app.include_router(lectures.router) app.include_router(admin_auth.router) app.include_router(admin_wordsearch.router) +app.include_router(admin_users.router) # ============ Базовые эндпоинты ============ diff --git a/routers/admin_users.py b/routers/admin_users.py new file mode 100644 index 0000000..71bf605 --- /dev/null +++ b/routers/admin_users.py @@ -0,0 +1,242 @@ +""" +Admin Users Router — управление пользователями. + +Доступ: только для ADMIN_IDS. + +Эндпоинты: +- GET /admin/users?page=1&limit=50&level=&lang=&q=&active_24h= — список +- GET /admin/users/stats — сводка по уровням/языкам + +🔧 ФИКС (30.09.2026): total_score = сумма 4 игр (wordsearch + sentences + quiz + bubbles). +""" +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/users", tags=["admin-users"]) + +LEVELS = ["A1", "A2", "B1", "B2", "C1", "C2"] +LANGUAGES = ["pl", "ru", "uk", "en"] + + +def _require_admin(telegram_id: int) -> None: + if telegram_id not in ADMIN_IDS: + raise HTTPException(403, "Access denied") + + +@router.get("") +async def list_users( + request: Request, + page: int = 1, + limit: int = 50, + level: Optional[str] = None, + lang: Optional[str] = None, + q: Optional[str] = None, + active_24h: bool = False, +): + """ + 🔧 НОВОЕ (30.09.2026): список пользователей с пагинацией. + + Возвращает: + { + "total": 15, + "page": 1, + "limit": 50, + "pages": 1, + "users": [ + { + "telegram_id": 123, + "username": "user", + "app_language": "ru", + "current_level": "A1", + "last_completed_level": 5, + "last_completed_by_level": {"A1": 5, "A2": 3}, + "created_at": "...", + "last_login": "...", + "total_score": 1234, + "wordsearch_completed": 5, + "sentence_completed": 10, + "quiz_guessed": 20, + "bubble_completed": 8, + "levels_completed": 5 + } + ] + } + """ + telegram_id, _ = await require_auth(request) + _require_admin(telegram_id) + + if page < 1: + page = 1 + if limit < 1: + limit = 1 + elif limit > 200: + limit = 200 + + 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"u.current_level = ${idx}") + params.append(level) + idx += 1 + + if lang and lang in LANGUAGES: + conditions.append(f"u.app_language = ${idx}") + params.append(lang) + idx += 1 + + if q and q.strip(): + conditions.append(f"""( + CAST(u.telegram_id AS TEXT) ILIKE ${idx} OR + u.username ILIKE ${idx} + )""") + params.append(f"%{q.strip()}%") + idx += 1 + + if active_24h: + conditions.append(f""" + EXISTS ( + SELECT 1 FROM daily_logins dl + WHERE dl.user_id = u.telegram_id + AND dl.login_date >= CURRENT_DATE - INTERVAL '1 day' + ) + """) + + where = ("WHERE " + " AND ".join(conditions)) if conditions else "" + + # Total + total = await conn.fetchval(f""" + SELECT COUNT(*) FROM users u {where} + """, *params) or 0 + + # Page с агрегатами + rows = await conn.fetch(f""" + SELECT + u.telegram_id, + u.username, + u.app_language, + u.current_level, + u.last_completed_level, + u.last_completed_by_level, + u.created_at, + (SELECT MAX(login_date) FROM daily_logins WHERE user_id = u.telegram_id) AS last_login, + -- 🔧 ФИКС (30.09.2026): total_score теперь = сумма 4 игр + COALESCE((SELECT SUM(score) FROM user_progress + WHERE user_id = u.telegram_id AND completed_at IS NOT NULL), 0) + + COALESCE((SELECT SUM(score) FROM sentence_progress + WHERE user_id = u.telegram_id AND completed_at IS NOT NULL), 0) + + COALESCE((SELECT total_score FROM word_quiz_progress + WHERE user_id = u.telegram_id), 0) + + COALESCE((SELECT total_score FROM bubble_words_progress + WHERE user_id = u.telegram_id), 0) AS total_score, + -- Уровни по играм + COALESCE((SELECT COUNT(*) FROM user_progress + WHERE user_id = u.telegram_id AND completed_at IS NOT NULL), 0) AS wordsearch_completed, + COALESCE((SELECT COUNT(*) FROM sentence_progress + WHERE user_id = u.telegram_id AND completed_at IS NOT NULL), 0) AS sentence_completed, + COALESCE((SELECT words_guessed FROM word_quiz_progress + WHERE user_id = u.telegram_id), 0) AS quiz_guessed, + COALESCE((SELECT levels_completed FROM bubble_words_progress + WHERE user_id = u.telegram_id), 0) AS bubble_completed + FROM users u + {where} + ORDER BY u.created_at DESC + 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, + "users": [ + { + "telegram_id": r["telegram_id"], + "username": r["username"], + "app_language": r["app_language"] or "pl", + "current_level": r["current_level"] or "A1", + "last_completed_level": r["last_completed_level"] or 0, + "last_completed_by_level": r["last_completed_by_level"] or {}, + "created_at": r["created_at"].isoformat() if r["created_at"] else None, + "last_login": r["last_login"].isoformat() if r["last_login"] else None, + "total_score": r["total_score"] or 0, + "wordsearch_completed": r["wordsearch_completed"] or 0, + "sentence_completed": r["sentence_completed"] or 0, + "quiz_guessed": r["quiz_guessed"] or 0, + "bubble_completed": r["bubble_completed"] or 0, + "levels_completed": r["wordsearch_completed"] or 0, # backward compat + } + for r in rows + ], + } + + +@router.get("/stats") +async def users_stats(request: Request): + """ + Сводка: пользователи по уровням и языкам. + """ + telegram_id, _ = await require_auth(request) + _require_admin(telegram_id) + + pool = await get_pool() + async with pool.acquire() as conn: + # По уровням + by_level_rows = await conn.fetch(""" + SELECT COALESCE(current_level, 'A1') AS level, COUNT(*) AS cnt + FROM users + GROUP BY current_level + ORDER BY + CASE current_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 + """) + by_level = {r["level"]: r["cnt"] for r in by_level_rows} + + # По языкам + by_lang_rows = await conn.fetch(""" + SELECT COALESCE(app_language, 'pl') AS lang, COUNT(*) AS cnt + FROM users + GROUP BY app_language + ORDER BY cnt DESC + """) + by_lang = {r["lang"]: r["cnt"] for r in by_lang_rows} + + # Всего + total = await conn.fetchval("SELECT COUNT(*) FROM users") or 0 + + # Активных за 24ч + active_24h = await conn.fetchval(""" + SELECT COUNT(DISTINCT user_id) FROM daily_logins + WHERE login_date >= CURRENT_DATE - INTERVAL '1 day' + """) or 0 + + # Новых сегодня + new_today = await conn.fetchval(""" + SELECT COUNT(*) FROM users WHERE created_at >= CURRENT_DATE + """) or 0 + + return { + "total": total, + "by_level": by_level, + "by_lang": by_lang, + "active_24h": active_24h, + "new_today": new_today, + } \ No newline at end of file diff --git a/routers/game.py b/routers/game.py index 48bc8c8..7e746a7 100644 --- a/routers/game.py +++ b/routers/game.py @@ -13,7 +13,8 @@ async def get_progress(request: Request): pool = await get_pool() async with pool.acquire() as conn: user = await conn.fetchrow( - "SELECT last_completed_level, current_level FROM users WHERE telegram_id = $1", + """SELECT last_completed_level, current_level, last_completed_by_level + FROM users WHERE telegram_id = $1""", telegram_id ) @@ -25,6 +26,23 @@ async def get_progress(request: Request): } current_level = user["current_level"] or "A1" + + # 🔧 ФИКС (30.09.2026): progress_uses_per_level — + # возвращаем last_completed_level для ТЕКУЩЕГО уровня языка, + # а не глобальный счётчик (который смешивал A1+A2+B1). + last_by_level = user["last_completed_by_level"] or {} + if isinstance(last_by_level, str): + try: + import json as _json + last_by_level = _json.loads(last_by_level) + except Exception: + last_by_level = {} + + last_completed_for_current = ( + last_by_level.get(current_level, 0) + if isinstance(last_by_level, dict) + else 0 + ) # Очки из филвордов wordsearch_score = await conn.fetchval( @@ -53,7 +71,8 @@ async def get_progress(request: Request): total_score = (wordsearch_score or 0) + (sentence_score or 0) + (wordquiz_score or 0) + (bubblewords_score or 0) return { - "last_completed_level": user["last_completed_level"] or 0, + "last_completed_level": last_completed_for_current, + "last_completed_by_level": last_by_level, "total_score": total_score, "current_level": current_level } @@ -66,7 +85,7 @@ async def get_level(request: Request, level_number: int): pool = await get_pool() async with pool.acquire() as conn: user = await conn.fetchrow( - "SELECT app_language, current_level, last_completed_level FROM users WHERE telegram_id = $1", telegram_id + "SELECT app_language, current_level, last_completed_level, last_completed_by_level FROM users WHERE telegram_id = $1", telegram_id ) if not user: @@ -76,6 +95,18 @@ async def get_level(request: Request, level_number: int): current_level = user["current_level"] or "A1" last_completed = user["last_completed_level"] or 0 + # 🔧 ФИКС (30.09.2026): last_completed_by_level — + # используем per-level счётчик. Fallback на last_completed_level (старый). + last_completed_by_level = user["last_completed_by_level"] or {} + if isinstance(last_completed_by_level, str): + try: + import json as _json + last_completed_by_level = _json.loads(last_completed_by_level) + except Exception: + last_completed_by_level = {} + + last_completed = last_completed_by_level.get(current_level, 0) if isinstance(last_completed_by_level, dict) else 0 + # Проверяем, что уровень доступен (не дальше следующего за пройденным) if level_number > 1 and level_number > last_completed + 1: raise HTTPException(403, "Level not available yet. Complete previous level first.") @@ -364,13 +395,22 @@ async def complete_level(request: Request): current_streak = 0 """, telegram_id, level_id, hints_used, score, level_name) - # Обновляем last_completed_level (максимальный номер пройденного уровня) - await conn.execute( - """UPDATE users - SET last_completed_level = GREATEST(last_completed_level, $2) - WHERE telegram_id = $1""", - telegram_id, current_level_number, - ) + # 🔧 ФИКС (30.09.2026): last_completed_by_level — + # обновляем per-level счётчик (JSONB) + старый last_completed_level. + await conn.execute(""" + UPDATE users + SET last_completed_level = GREATEST(last_completed_level, $2), + last_completed_by_level = jsonb_set( + COALESCE(last_completed_by_level, '{}'::jsonb), + ARRAY[$3::text], + to_jsonb(GREATEST( + COALESCE((last_completed_by_level->>$3)::int, 0), + $2 + )), + true + ) + WHERE telegram_id = $1 + """, telegram_id, current_level_number, level_name) # Собираем данные для достижений внутри блока levels_completed = await conn.fetchval( @@ -432,7 +472,7 @@ async def complete_level(request: Request): return { "status": "ok", - "score": score, + "score": score, "already_completed": False, "new_achievements": new_achievements } \ No newline at end of file