feat: last_completed_by_level (per-level прогресс) + полный total_score + пагинация

This commit is contained in:
2026-09-30 17:49:09 +00:00
parent aebeaa833f
commit daa79dd43e
4 changed files with 336 additions and 13 deletions
+242
View File
@@ -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,
}
+51 -11
View File
@@ -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
}