- services/xp.py: award_xp, level_for, RANKS (48), featured_game - services/waves.py: wave_plan, grid_size_for, wave_medal - routers/featured.py: GET /featured (игра дня ×1.5) - routers/users.py: POST /set-nickname, POST /set-avatar - routers/app_auth.py: /auth/me с XP-полями (level, rank_key, rank_name, xp) - routers/game.py: award_xp + 3 штрафа + POST /game/next (волны) - routers/wordquiz.py: award_xp + серии в choose_progress - routers/bubblewords.py: award_xp + 4 штрафа - routers/sentences.py: award_xp по длине предложения - routers/leaderboard.py: сортировка по total_xp, XP-поля в ответе - database.py: миграции user_profile, xp_log, choose_progress, user_seen_levels, user_game_progress, wave_results, bubble_levels, user_word_stats - main.py: подключение routers/featured Проверено: - /auth/me отдаёт level=1, rank_00, xp_in_level - /featured отдаёт wordsearch + seconds_left - /game/complete-level начисляет XP через award_xp - xp_log, user_profile заполняются - /game/next выдаёт уровень по волнам - /leaderboard сортирует по total_xp
419 lines
17 KiB
Python
419 lines
17 KiB
Python
from fastapi import APIRouter, Request, HTTPException
|
|
from auth import require_auth
|
|
from database import get_pool
|
|
from config import ADMIN_IDS
|
|
|
|
router = APIRouter(prefix="/leaderboard", tags=["leaderboard"])
|
|
|
|
LEVELS = ["A1", "A2", "B1", "B2", "C1", "C2"]
|
|
|
|
|
|
@router.get("")
|
|
async def get_leaderboard(request: Request, limit: int = 50):
|
|
"""
|
|
Рейтинг игроков.
|
|
|
|
🔧 ОБНОВЛЕНО (08.10.2026): XP-фундамент.
|
|
|
|
Сортировка: total_xp DESC → total_score DESC.
|
|
weekly_xp в БД остаётся, но больше НЕ используется в сортировке.
|
|
Legacy-поля (total_score, wordsearch_score, ...) сохранены для Mini App.
|
|
|
|
Новые поля в каждой строке: total_xp, level, rank_key, rank_name,
|
|
xp_in_level, xp_needed, avatar_id.
|
|
"""
|
|
telegram_id, _ = await require_auth(request)
|
|
|
|
if limit < 1:
|
|
limit = 1
|
|
elif limit > 100:
|
|
limit = 100
|
|
|
|
pool = await get_pool()
|
|
async with pool.acquire() as conn:
|
|
user = await conn.fetchrow(
|
|
"SELECT 1, current_level FROM users WHERE telegram_id = $1", telegram_id
|
|
)
|
|
if not user:
|
|
raise HTTPException(401, "User not registered")
|
|
|
|
current_level = user["current_level"] or "A1"
|
|
|
|
# 🆕 Топ-N: matview + LEFT JOIN user_profile для XP.
|
|
# 🔧 ОБНОВЛЕНО (08.10.2026): сортировка по total_xp (weekly_xp убран).
|
|
rows = await conn.fetch("""
|
|
SELECT
|
|
lc.*,
|
|
COALESCE(p.weekly_xp, 0) AS weekly_xp,
|
|
COALESCE(p.total_xp, 0) AS total_xp,
|
|
COALESCE(p.avatar_id, 0) AS avatar_id,
|
|
u.app_language
|
|
FROM leaderboard_cache lc
|
|
LEFT JOIN user_profile p ON p.user_id = lc.telegram_id
|
|
LEFT JOIN users u ON u.telegram_id = lc.telegram_id
|
|
ORDER BY COALESCE(p.total_xp, 0) DESC,
|
|
lc.total_score DESC,
|
|
lc.telegram_id ASC
|
|
LIMIT $1
|
|
""", limit)
|
|
|
|
# Импорт XP-хелперов
|
|
from services.xp import level_for, rank_for
|
|
|
|
def _serialize_row(row, rank_num):
|
|
"""Собирает строку рейтинга с legacy + XP-полями."""
|
|
weekly_xp = int(row["weekly_xp"] or 0)
|
|
total_xp = int(row["total_xp"] or 0)
|
|
level, xp_in_level, xp_needed, rank_key = level_for(total_xp)
|
|
lang = (row.get("app_language") or "ru").lower()
|
|
if lang not in ("pl", "ru", "uk", "en"):
|
|
lang = "ru"
|
|
|
|
return {
|
|
# Legacy (Mini App)
|
|
"rank": rank_num,
|
|
"telegram_id": row["telegram_id"],
|
|
"username": row["username"] or f"Player{row['telegram_id']}",
|
|
"total_score": row["total_score"],
|
|
"wordsearch_score": row["wordsearch_score"],
|
|
"sentence_score": row["sentence_score"],
|
|
"wordquiz_score": row["wordquiz_score"],
|
|
"words_guessed": row["words_guessed"],
|
|
"bubblewords_score": row["bubblewords_score"],
|
|
"bubble_levels_completed": row["bubble_levels_completed"],
|
|
"levels_completed": 0,
|
|
"sentences_completed": 0,
|
|
# 🆕 XP (Pleily)
|
|
"weekly_xp": weekly_xp, # оставлен для legacy Mini App
|
|
"total_xp": total_xp,
|
|
"level": level,
|
|
"rank_key": rank_key,
|
|
"rank_name": rank_for(level, lang),
|
|
"xp_in_level": xp_in_level,
|
|
"xp_needed": xp_needed,
|
|
"avatar_id": int(row["avatar_id"] or 0),
|
|
"app_language": lang,
|
|
}
|
|
|
|
leaderboard = [
|
|
_serialize_row(row, rank_num=i + 1)
|
|
for i, row in enumerate(rows)
|
|
]
|
|
|
|
# ============ Мой ранг ============
|
|
# Читаем мои XP + legacy-статистику.
|
|
my_row = await conn.fetchrow("""
|
|
SELECT
|
|
lc.*,
|
|
COALESCE(p.weekly_xp, 0) AS weekly_xp,
|
|
COALESCE(p.total_xp, 0) AS total_xp,
|
|
COALESCE(p.avatar_id, 0) AS avatar_id,
|
|
u.app_language
|
|
FROM leaderboard_cache lc
|
|
LEFT JOIN user_profile p ON p.user_id = lc.telegram_id
|
|
LEFT JOIN users u ON u.telegram_id = lc.telegram_id
|
|
WHERE lc.telegram_id = $1
|
|
""", telegram_id)
|
|
|
|
# Если юзера нет в matview — пробуем только user_profile.
|
|
if not my_row:
|
|
my_profile = await conn.fetchrow("""
|
|
SELECT
|
|
p.weekly_xp, p.total_xp, p.avatar_id,
|
|
u.username, u.app_language, u.current_level
|
|
FROM user_profile p
|
|
JOIN users u ON u.telegram_id = p.user_id
|
|
WHERE p.user_id = $1
|
|
""", telegram_id)
|
|
|
|
if my_profile:
|
|
my_weekly_xp = int(my_profile["weekly_xp"] or 0)
|
|
my_total_xp = int(my_profile["total_xp"] or 0)
|
|
my_avatar_id = int(my_profile["avatar_id"] or 0)
|
|
my_username = my_profile["username"]
|
|
my_lang = (my_profile["app_language"] or "ru").lower()
|
|
else:
|
|
my_weekly_xp = 0
|
|
my_total_xp = 0
|
|
my_avatar_id = 0
|
|
my_username = None
|
|
my_lang = "ru"
|
|
|
|
# 🔧 ОБНОВЛЕНО (08.10.2026): место по total_xp (не weekly_xp).
|
|
my_position = await conn.fetchval("""
|
|
SELECT COUNT(*) + 1
|
|
FROM user_profile
|
|
WHERE total_xp > $1
|
|
""", my_total_xp) or 1
|
|
|
|
# Legacy-статистика (для совместимости с Mini App)
|
|
my_wordsearch = await conn.fetchval(
|
|
"SELECT COALESCE(SUM(score), 0) FROM user_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
|
|
telegram_id
|
|
) or 0
|
|
my_sentence = await conn.fetchval(
|
|
"SELECT COALESCE(SUM(score), 0) FROM sentence_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
|
|
telegram_id
|
|
) or 0
|
|
my_wordquiz = await conn.fetchval(
|
|
"SELECT COALESCE(total_score, 0) FROM word_quiz_progress WHERE user_id = $1",
|
|
telegram_id
|
|
) or 0
|
|
my_words_guessed = await conn.fetchval(
|
|
"SELECT COALESCE(words_guessed, 0) FROM word_quiz_progress WHERE user_id = $1",
|
|
telegram_id
|
|
) or 0
|
|
my_bubblewords = await conn.fetchval(
|
|
"SELECT COALESCE(total_score, 0) FROM bubble_words_progress WHERE user_id = $1",
|
|
telegram_id
|
|
) or 0
|
|
my_bubble_levels = await conn.fetchval(
|
|
"SELECT COALESCE(levels_completed, 0) FROM bubble_words_progress WHERE user_id = $1",
|
|
telegram_id
|
|
) or 0
|
|
my_total = my_wordsearch + my_sentence + my_wordquiz + my_bubblewords
|
|
my_wordsearch_levels = 0
|
|
my_sentences_completed = 0
|
|
my_avatar_id_final = my_avatar_id
|
|
my_username_final = my_username
|
|
my_lang_final = my_lang
|
|
else:
|
|
my_weekly_xp = int(my_row["weekly_xp"] or 0)
|
|
my_total_xp = int(my_row["total_xp"] or 0)
|
|
my_avatar_id_final = int(my_row["avatar_id"] or 0)
|
|
my_username_final = my_row["username"]
|
|
my_lang_final = (my_row["app_language"] or "ru").lower()
|
|
my_wordsearch = my_row["wordsearch_score"]
|
|
my_sentence = my_row["sentence_score"]
|
|
my_wordquiz = my_row["wordquiz_score"]
|
|
my_words_guessed = my_row["words_guessed"]
|
|
my_bubblewords = my_row["bubblewords_score"]
|
|
my_bubble_levels = my_row["bubble_levels_completed"]
|
|
my_total = my_wordsearch + my_sentence + my_wordquiz + my_bubblewords
|
|
|
|
# 🔧 ОБНОВЛЕНО (08.10.2026): место по total_xp (не weekly_xp).
|
|
my_position = await conn.fetchval("""
|
|
SELECT COUNT(*) + 1
|
|
FROM user_profile
|
|
WHERE total_xp > $1
|
|
""", my_total_xp) or 1
|
|
|
|
my_wordsearch_levels = await conn.fetchval(
|
|
"SELECT COUNT(DISTINCT level_id) FROM user_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
|
|
telegram_id
|
|
) or 0
|
|
my_sentences_completed = await conn.fetchval(
|
|
"SELECT COUNT(*) FROM sentence_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
|
|
telegram_id
|
|
) or 0
|
|
|
|
# ============ level_stats (legacy для Mini App) ============
|
|
ref_row = await conn.fetchrow("""
|
|
SELECT
|
|
(SELECT COUNT(*) FROM levels WHERE level = 'A1') AS a1_levels,
|
|
(SELECT COUNT(*) FROM levels WHERE level = 'A2') AS a2_levels,
|
|
(SELECT COUNT(*) FROM levels WHERE level = 'B1') AS b1_levels,
|
|
(SELECT COUNT(*) FROM levels WHERE level = 'B2') AS b2_levels,
|
|
(SELECT COUNT(*) FROM levels WHERE level = 'C1') AS c1_levels,
|
|
(SELECT COUNT(*) FROM levels WHERE level = 'C2') AS c2_levels,
|
|
(SELECT COUNT(*) FROM sentences WHERE level = 'A1') AS a1_sent,
|
|
(SELECT COUNT(*) FROM sentences WHERE level = 'A2') AS a2_sent,
|
|
(SELECT COUNT(*) FROM sentences WHERE level = 'B1') AS b1_sent,
|
|
(SELECT COUNT(*) FROM sentences WHERE level = 'B2') AS b2_sent,
|
|
(SELECT COUNT(*) FROM sentences WHERE level = 'C1') AS c1_sent,
|
|
(SELECT COUNT(*) FROM sentences WHERE level = 'C2') AS c2_sent
|
|
""")
|
|
|
|
ws_rows = await conn.fetch("""
|
|
SELECT level, COALESCE(SUM(score), 0) AS score, COUNT(*) AS completed
|
|
FROM user_progress
|
|
WHERE user_id = $1 AND completed_at IS NOT NULL
|
|
GROUP BY level
|
|
""", telegram_id)
|
|
ws_by_level = {r["level"]: r for r in ws_rows}
|
|
|
|
s_rows = await conn.fetch("""
|
|
SELECT level, COALESCE(SUM(score), 0) AS score, COUNT(*) AS completed
|
|
FROM sentence_progress
|
|
WHERE user_id = $1 AND completed_at IS NOT NULL
|
|
GROUP BY level
|
|
""", telegram_id)
|
|
s_by_level = {r["level"]: r for r in s_rows}
|
|
|
|
wq_rows = await conn.fetch("""
|
|
SELECT level, COALESCE(total_score, 0) AS score
|
|
FROM word_quiz_progress WHERE user_id = $1
|
|
""", telegram_id)
|
|
wq_by_level = {r["level"]: r for r in wq_rows}
|
|
|
|
bw_rows = await conn.fetch("""
|
|
SELECT level, COALESCE(total_score, 0) AS score
|
|
FROM bubble_words_progress WHERE user_id = $1
|
|
""", telegram_id)
|
|
bw_by_level = {r["level"]: r for r in bw_rows}
|
|
|
|
level_stats = {}
|
|
for lvl in LEVELS:
|
|
lvl_lower = lvl.lower()
|
|
ws_score = ws_by_level.get(lvl, {}).get("score", 0) or 0
|
|
ws_completed = ws_by_level.get(lvl, {}).get("completed", 0) or 0
|
|
s_score = s_by_level.get(lvl, {}).get("score", 0) or 0
|
|
s_completed = s_by_level.get(lvl, {}).get("completed", 0) or 0
|
|
wq_score = wq_by_level.get(lvl, {}).get("score", 0) or 0
|
|
bw_score = bw_by_level.get(lvl, {}).get("score", 0) or 0
|
|
|
|
total_ws_levels = ref_row[f"{lvl_lower}_levels"] or 0
|
|
total_sentences = ref_row[f"{lvl_lower}_sent"] or 0
|
|
total_items = total_ws_levels + total_sentences
|
|
completed_items = ws_completed + s_completed
|
|
progress_percent = round((completed_items / total_items * 100), 1) if total_items > 0 else 0
|
|
|
|
level_stats[lvl] = {
|
|
"total_score": ws_score + s_score + wq_score + bw_score,
|
|
"progress_percent": progress_percent,
|
|
"wordsearch_score": ws_score,
|
|
"sentence_score": s_score,
|
|
"wordquiz_score": wq_score,
|
|
"bubblewords_score": bw_score,
|
|
}
|
|
|
|
# Достижения
|
|
from routers.achievements import check_and_award_achievements
|
|
if my_position <= 3:
|
|
await check_and_award_achievements(telegram_id, "rank_reached", my_position)
|
|
|
|
# ============ Мой ранг (XP) ============
|
|
my_level, my_xp_in_level, my_xp_needed, my_rank_key = level_for(my_total_xp)
|
|
my_rank_name = rank_for(my_level, my_lang_final)
|
|
|
|
return {
|
|
"leaderboard": leaderboard,
|
|
"current_level": current_level,
|
|
"my_rank": {
|
|
# Legacy
|
|
"rank": my_position,
|
|
"telegram_id": telegram_id,
|
|
"total_score": my_total,
|
|
"wordsearch_score": my_wordsearch,
|
|
"wordsearch_levels": my_wordsearch_levels,
|
|
"sentence_score": my_sentence,
|
|
"sentences_completed": my_sentences_completed,
|
|
"wordquiz_score": my_wordquiz,
|
|
"words_guessed": my_words_guessed,
|
|
"bubblewords_score": my_bubblewords,
|
|
"bubble_levels_completed": my_bubble_levels,
|
|
# 🆕 XP
|
|
"username": my_username_final,
|
|
"weekly_xp": my_weekly_xp, # оставлен для legacy Mini App
|
|
"total_xp": my_total_xp,
|
|
"level": my_level,
|
|
"rank_key": my_rank_key,
|
|
"rank_name": my_rank_name,
|
|
"xp_in_level": my_xp_in_level,
|
|
"xp_needed": my_xp_needed,
|
|
"avatar_id": my_avatar_id_final,
|
|
"app_language": my_lang_final,
|
|
},
|
|
"level_stats": level_stats,
|
|
}
|
|
|
|
|
|
@router.get("/admin/stats")
|
|
async def get_admin_stats(request: Request):
|
|
"""Админ-статистика: только для ADMIN_IDS"""
|
|
telegram_id, _ = await require_auth(request)
|
|
|
|
if telegram_id not in ADMIN_IDS:
|
|
raise HTTPException(403, "Access denied")
|
|
|
|
pool = await get_pool()
|
|
async with pool.acquire() as conn:
|
|
total_users = await conn.fetchval("SELECT COUNT(*) FROM users") or 0
|
|
|
|
new_today = await conn.fetchval(
|
|
"SELECT COUNT(*) FROM users WHERE created_at::date = CURRENT_DATE"
|
|
) or 0
|
|
|
|
online_now = await conn.fetchval("""
|
|
SELECT COUNT(DISTINCT user_id) FROM (
|
|
SELECT user_id FROM user_progress WHERE completed_at > NOW() - INTERVAL '30 minutes'
|
|
UNION
|
|
SELECT user_id FROM sentence_progress WHERE completed_at > NOW() - INTERVAL '30 minutes'
|
|
UNION
|
|
SELECT user_id FROM daily_logins WHERE login_date = CURRENT_DATE
|
|
) active
|
|
""") or 0
|
|
|
|
ws_players = await conn.fetchval(
|
|
"SELECT COUNT(DISTINCT user_id) FROM user_progress WHERE completed_at IS NOT NULL"
|
|
) or 0
|
|
|
|
s_players = await conn.fetchval(
|
|
"SELECT COUNT(DISTINCT user_id) FROM sentence_progress WHERE completed_at IS NOT NULL"
|
|
) or 0
|
|
|
|
wq_players = await conn.fetchval(
|
|
"SELECT COUNT(*) FROM word_quiz_progress WHERE words_guessed > 0"
|
|
) or 0
|
|
|
|
bw_players = await conn.fetchval(
|
|
"SELECT COUNT(*) FROM bubble_words_progress WHERE levels_completed > 0"
|
|
) or 0
|
|
|
|
# 🔧 ИСПРАВЛЕНО: 'open_flashcards' → 'open_teacher_menu'
|
|
# Раньше метрика всегда была 0, потому что такого кода достижения больше нет
|
|
teacher_menu_opened = await conn.fetchval("""
|
|
SELECT COUNT(*) FROM user_achievements ua
|
|
JOIN achievements a ON ua.achievement_id = a.id
|
|
WHERE a.code = 'open_teacher_menu'
|
|
""") or 0
|
|
|
|
# 🔧 ФИКС (25.09.2026): leaderboard_admin_stats_n_plus_1 —
|
|
# 1 GROUP BY вместо 6 COUNT-запросов.
|
|
level_rows = await conn.fetch("""
|
|
SELECT current_level, COUNT(*) as cnt
|
|
FROM users
|
|
WHERE current_level = ANY($1::text[])
|
|
GROUP BY current_level
|
|
""", LEVELS)
|
|
level_map = {r["current_level"]: r["cnt"] for r in level_rows}
|
|
level_counts = {lvl: level_map.get(lvl, 0) for lvl in LEVELS}
|
|
|
|
return {
|
|
"total_users": total_users,
|
|
"new_today": new_today,
|
|
"online_now": online_now,
|
|
"wordsearch_players": ws_players,
|
|
"sentence_players": s_players,
|
|
"wordquiz_players": wq_players,
|
|
"bubblewords_players": bw_players,
|
|
"teacher_menu_opened": teacher_menu_opened,
|
|
"level_counts": level_counts,
|
|
}
|
|
|
|
|
|
@router.get("/top")
|
|
async def get_top_players(request: Request):
|
|
"""Топ-3 игрока для главного экрана — из кэша"""
|
|
telegram_id, _ = await require_auth(request)
|
|
|
|
pool = await get_pool()
|
|
async with pool.acquire() as conn:
|
|
rows = await conn.fetch("""
|
|
SELECT telegram_id, username, total_score
|
|
FROM leaderboard_cache
|
|
ORDER BY total_score DESC
|
|
LIMIT 3
|
|
""")
|
|
|
|
top3 = []
|
|
medals = ["🥇", "🥈", "🥉"]
|
|
for i, row in enumerate(rows):
|
|
top3.append({
|
|
"rank": i + 1,
|
|
"medal": medals[i],
|
|
"username": row["username"] or f"Player{row['telegram_id']}",
|
|
"total_score": row["total_score"],
|
|
})
|
|
|
|
return {"top3": top3} |