feat: XP foundation + waves + featured game + profile + leaderboard by total_xp

- 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
This commit is contained in:
2026-10-09 08:12:19 +00:00
parent a3f7d9521f
commit 84927b063f
13 changed files with 1800 additions and 278 deletions
+77 -35
View File
@@ -18,6 +18,12 @@ Telegram-юзеры сохраняют свои положительные teleg
- DELETE /me — удаление аккаунта (Apple требует)
🔧 НОВОЕ (07.10.2026): pleily_auth — первая версия.
🔧 ФИКС (07.10.2026): device_id_in_users —
теперь device_id пишется и в users.device_id, и в auth_identities.
Это нужно для SQL-запросов по device_id (админка, миграции).
🔧 НОВОЕ (08.10.2026): auth_me_xp_fields —
в /auth/me добавлены XP-поля: level, rank_key, rank_name,
xp_in_level, xp_needed, total_xp, weekly_xp, weekly_rank.
"""
import logging
import uuid
@@ -97,11 +103,14 @@ async def _create_app_user(conn, device_id: str) -> int:
uid_row = await conn.fetchrow("SELECT nextval('app_user_id_seq') AS uid")
uid = uid_row["uid"]
# Создаём юзера в users
# 🔧 ФИКС (07.10.2026): device_id_in_users —
# раньше device_id сохранялся только в auth_identities,
# а в users.device_id был NULL. Теперь — в обоих местах.
# Это нужно для SQL-запросов по device_id (админка, миграции).
await conn.execute("""
INSERT INTO users (telegram_id, username, source)
VALUES ($1, $2, 'app')
""", uid, f"app_user_{abs(uid)}")
INSERT INTO users (telegram_id, username, source, device_id)
VALUES ($1, $2, 'app', $3)
""", uid, f"app_user_{abs(uid)}", device_id)
# Создаём identity
await conn.execute("""
@@ -174,45 +183,78 @@ async def auth_device(request: Request):
@router.get("/me")
async def auth_me(request: Request):
"""
Возвращает данные текущего Pleily-юзера. Для тестов и отладки.
Требует Authorization: Bearer <JWT>.
Текущий юзер + XP-поля.
🔧 НОВОЕ (08.10.2026): добавлены level, rank_key, rank_name,
xp_in_level, xp_needed, total_xp, weekly_xp.
"""
user_id, _username = await require_auth(request)
telegram_id, _ = await require_auth(request)
pool = await get_pool()
async with pool.acquire() as conn:
row = await conn.fetchrow("""
SELECT telegram_id, username, source, app_language, current_level, created_at
user = await conn.fetchrow(
"""
SELECT telegram_id, username, app_language, current_level,
source, device_id, apple_id, created_at
FROM users WHERE telegram_id = $1
""", user_id)
""",
telegram_id,
)
if not user:
raise HTTPException(401, "User not found")
if not row:
raise HTTPException(404, "User not found")
profile = await conn.fetchrow(
"""
SELECT nickname, avatar_id, total_xp, weekly_xp, week_started_at
FROM user_profile WHERE user_id = $1
""",
telegram_id,
)
# Получаем identities юзера (для диагностики)
identities_rows = await conn.fetch("""
SELECT provider, provider_uid, created_at
FROM auth_identities WHERE user_id = $1
ORDER BY created_at
""", user_id)
# Weekly rank
weekly_rank = await conn.fetchval(
"""
SELECT COUNT(*) + 1
FROM user_profile
WHERE weekly_xp > COALESCE((
SELECT weekly_xp FROM user_profile WHERE user_id = $1
), 0)
""",
telegram_id,
)
return {
"user_id": row["telegram_id"],
"username": row["username"],
"source": row["source"],
"app_language": row["app_language"],
"current_level": row["current_level"],
"created_at": row["created_at"].isoformat() if row["created_at"] else None,
"identities": [
{
"provider": r["provider"],
"provider_uid": r["provider_uid"],
"created_at": r["created_at"].isoformat() if r["created_at"] else None,
}
for r in identities_rows
],
}
# Считаем уровень
from services.xp import level_for, rank_for
total_xp = int(profile["total_xp"]) if profile else 0
weekly_xp = int(profile["weekly_xp"]) if profile else 0
level, xp_in_level, xp_needed, rank_key = level_for(total_xp)
lang = (user["app_language"] or "ru").lower()
if lang not in ("pl", "ru", "uk", "en"):
lang = "ru"
return {
"user_id": user["telegram_id"],
"username": user["username"],
"nickname": profile["nickname"] if profile else None,
"avatar_id": int(profile["avatar_id"]) if profile and profile["avatar_id"] is not None else 0,
"app_language": user["app_language"],
"current_level": user["current_level"],
"source": user["source"],
"device_id": str(user["device_id"]) if user["device_id"] else None,
"apple_id": user["apple_id"],
"created_at": user["created_at"].isoformat() if user["created_at"] else None,
# --- XP ---
"total_xp": total_xp,
"weekly_xp": weekly_xp,
"level": level,
"rank_key": rank_key,
"rank_name": rank_for(level, lang),
"xp_in_level": xp_in_level,
"xp_needed": xp_needed,
"weekly_rank": int(weekly_rank) if weekly_rank else 0,
}
@router.delete("/me")
+44 -30
View File
@@ -171,13 +171,21 @@ async def get_next_bubble_level(request: Request):
@router.post("/complete")
async def complete_bubble_level(request: Request):
"""Завершение уровня пузырей, начисление очков и проверка достижений"""
"""Завершение уровня пузырей, начисление XP и проверка достижений.
🔧 НОВОЕ (08.10.2026): XP-система.
Штрафы:
-1 за открытие списка слов (один раз за уровень)
-1 за каждое неправильно собранное слово (макс 3)
-1 если time_ms > 60 сек
Минимум 1 звезда.
"""
telegram_id, _ = await require_auth(request)
body = await request.json()
words_count = body.get("words_count", 3)
completion_time = body.get("completion_time")
# 🔧 ФИКС (24.09.2026): client_controlled_hints_bubblewords —
# hints_used больше НЕ берём от клиента. Читаем из bubble_words_progress.current_hints_used.
list_opened = bool(body.get("list_opened", False))
wrong_words = int(body.get("wrong_words", 0) or 0)
pool = await get_pool()
async with pool.acquire() as conn:
@@ -187,19 +195,29 @@ async def complete_bubble_level(request: Request):
if not user_exists:
raise HTTPException(401, "User not registered")
# Получаем current_level пользователя
current_level = await conn.fetchval(
"SELECT current_level FROM users WHERE telegram_id = $1", telegram_id
) or "A1"
# 🔧 ФИКС (24.09.2026): client_controlled_hints_bubblewords —
# читаем серверный hints_used.
# Читаем серверный hints_used
hints_used = await conn.fetchval(
"SELECT current_hints_used FROM bubble_words_progress WHERE user_id = $1",
telegram_id
) or 0
hints_used = min(max(0, hints_used), 3)
score = max(10, 100 - hints_used * 10)
# 🆕 Расчёт звёзд
# Старт 5. Штрафы: hints(1) + wrong_words(до 3) + time(1)
time_penalty = 1 if (completion_time and completion_time > 60) else 0
wrong_penalty = min(max(0, wrong_words), 3)
hint_penalty = 1 if hints_used > 0 else 0
list_penalty = 1 if list_opened else 0
stars = max(1, 5 - time_penalty - wrong_penalty - hint_penalty - list_penalty)
# Начисляем XP
from services.xp import award_xp
xp_result = await award_xp(conn, telegram_id, "bubbles", stars)
score = xp_result["points"]
await conn.execute("""
INSERT INTO bubble_words_progress (user_id, levels_completed, total_score, level, current_hints_used)
@@ -211,42 +229,26 @@ async def complete_bubble_level(request: Request):
current_hints_used = 0
""", telegram_id, score, current_level)
# 🔧 ФИКС (23.09.2026): achievements_nested_pool_acquire_bubblewords —
# вызовы достижений вынесены за async with pool.acquire() (паттерн game.py).
# Данные для достижений
total_levels = await conn.fetchval(
"SELECT levels_completed FROM bubble_words_progress WHERE user_id = $1",
telegram_id
) or 0
wordsearch_score = 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
sentence_score = 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
wordquiz_score = await conn.fetchval(
"SELECT COALESCE(total_score, 0) FROM word_quiz_progress WHERE user_id = $1",
telegram_id
) or 0
bubblewords_score = await conn.fetchval(
"SELECT COALESCE(total_score, 0) FROM bubble_words_progress WHERE user_id = $1",
telegram_id
) or 0
grand_total = wordsearch_score + sentence_score + wordquiz_score + bubblewords_score
achievements_to_check = [
("bubble_levels", total_levels),
("total_score", grand_total),
("total_score", xp_result["total_xp"]),
]
if hints_used == 0:
achievements_to_check.append(("bubble_no_hints", 1))
if score == 100:
if stars == 5:
achievements_to_check.append(("bubble_perfect", 1))
if completion_time is not None and completion_time > 0 and int(completion_time) <= 45:
if completion_time is not None and 0 < completion_time <= 45:
achievements_to_check.append(("bubble_speed", 45))
if completion_time is not None and 0 < completion_time <= 30:
achievements_to_check.append(("bubble_speed_30", 30))
# 🔧 ФИКС (23.09.2026): вызовы достижений ВНЕ блока async with pool.acquire()
# Достижения — вне транзакции
from routers.achievements import check_and_award_achievements
new_achievements = []
for ach_type, value in achievements_to_check:
@@ -258,6 +260,18 @@ async def complete_bubble_level(request: Request):
"score": score,
"completion_time": completion_time,
"new_achievements": new_achievements,
# 🆕 XP-поля
"stars": xp_result["stars"],
"base_points": xp_result["base_points"],
"multiplier": xp_result["multiplier"],
"points": xp_result["points"],
"featured": xp_result["featured"],
"level_up": xp_result["level_up"],
"total_xp": xp_result["total_xp"],
"level": xp_result["level"],
"rank_key": xp_result["rank_key"],
"xp_in_level": xp_result["xp_in_level"],
"xp_needed": xp_result["xp_needed"],
}
+36
View File
@@ -0,0 +1,36 @@
"""GET /featured — игра дня + обратный отсчёт."""
from fastapi import APIRouter, Request
from auth import require_auth
from services.xp import featured_game, featured_seconds_left, GAMES
router = APIRouter(tags=["featured"])
# 🆕 Игры, которые реально работают в приложении.
# Пока не подключим все 4 — фильтруем.
PLAYABLE_GAMES = {"wordsearch"} # потом добавим choose, sentence, bubbles
@router.get("/featured")
async def get_featured(request: Request):
"""
Возвращает игру дня (глобально для всех) и секунды до смены.
🔧 (08.10.2026): если игра дня ещё не подключена в приложении —
отдаём ближайшую играбельную (для UI-подсказки ×1.5).
"""
await require_auth(request)
game = featured_game()
# Если featured не играбельная — отдаём первую играбельную
if game not in PLAYABLE_GAMES:
playable = [g for g in GAMES if g in PLAYABLE_GAMES]
if playable:
game = playable[0]
return {
"game": game,
"seconds_left": featured_seconds_left(),
"multiplier": 1.5,
"is_actually_featured": game == featured_game(),
}
+206 -70
View File
@@ -27,23 +27,12 @@ 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 = {}
# 🔧 ОБНОВЛЕНО (07.10.2026): единый счётчик progress.
# Раньше возвращали last_completed_for_current из per-level JSONB,
# но уровни теперь глобальные (level = 'common').
# Возвращаем users.last_completed_level — единый глобальный прогресс.
last_completed = user["last_completed_level"] or 0
last_completed_for_current = (
last_by_level.get(current_level, 0)
if isinstance(last_by_level, dict)
else 0
)
# Очки из филвордов
wordsearch_score = await conn.fetchval(
"SELECT COALESCE(SUM(score), 0) FROM user_progress WHERE user_id = $1",
@@ -71,8 +60,7 @@ 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": last_completed_for_current,
"last_completed_by_level": last_by_level,
"last_completed_level": last_completed,
"total_score": total_score,
"current_level": current_level
}
@@ -93,42 +81,26 @@ async def get_level(request: Request, level_number: int):
lang = user["app_language"] or "pl"
current_level = user["current_level"] or "A1"
# 🔧 ОБНОВЛЕНО (07.10.2026): единый счётчик (без per-level).
# Уровни глобальные (level = 'common'), поэтому прогресс —
# users.last_completed_level. last_completed_by_level оставлен
# в БД для совместимости, но больше не используется здесь.
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.")
# 🔧 ФИКС (29.09.2026): приоритет ручным уровням.
# Если есть уровень, созданный вручную (created_by IS NOT NULL) —
# показываем его. Иначе — fallback на авто (created_by IS NULL).
# 🔧 ОБНОВЛЕНО (07.10.2026): все уровни — common (автогенерированные).
# Ищем по level_number без created_by и без current_level.
# is_active = TRUE — чтобы черновики не показывались.
level = await conn.fetchrow("""
SELECT * FROM levels
WHERE level = $1 AND level_number = $2
AND created_by IS NOT NULL
WHERE level_number = $1
AND is_active = TRUE
LIMIT 1
""", current_level, level_number)
# Fallback на авто, если ручного нет
if not level:
level = await conn.fetchrow("""
SELECT * FROM levels
WHERE level = $1 AND level_number = $2
AND created_by IS NULL
LIMIT 1
""", current_level, level_number)
""", level_number)
if not level:
raise HTTPException(404, "Level not found")
@@ -312,6 +284,8 @@ async def complete_level(request: Request):
# 🔧 ФИКС (24.09.2026): client_controlled_hints_game —
# hints_used читаем из БД, не доверяем клиенту.
hints_used = 0
# 🔧 НОВОЕ (08.10.2026): XP-система — результат award_xp.
xp_result = None
async with pool.acquire() as conn:
user = await conn.fetchrow(
@@ -330,9 +304,10 @@ async def complete_level(request: Request):
current_level_number = level["level_number"]
level_name = level["level"] or "A1"
# Проверяем, что уровень принадлежит текущему уровню пользователя
if level_name != (user["current_level"] or "A1"):
raise HTTPException(403, "This level does not belong to your current level")
# 🔧 ОБНОВЛЕНО (07.10.2026): level = 'common'.
# Уровни глобальные, поэтому убираем проверку «уровень принадлежит
# твоему current_level». Оставляем только проверку прогресса выше.
# (Проверка не твоя-не твоя была актуальна, когда были A1/A2/B1.)
# 🔧 ФИКС (25.09.2026): already_completed_detects_hint_row —
# раньше already_completed = True при ЛЮБОЙ строке user_progress.
@@ -365,19 +340,41 @@ async def complete_level(request: Request):
telegram_id, level_id
) or 0
# 🔧 ФИКС (24.09.2026): client_controlled_hints_game —
# читаем hints_used из БД, не доверяем клиенту.
# 🔧 НОВОЕ (08.10.2026): XP-система.
# Читаем hints_used и list_opened из БД (не доверяем клиенту).
hints_used = await conn.fetchval(
"SELECT hints_used FROM user_progress WHERE user_id = $1 AND level_id = $2",
telegram_id, level_id
) or 0
hints_used = min(max(0, hints_used), 3)
score = max(10, 100 - hints_used * 10)
# 🔧 ФИКС (23.09.2026): client_controlled_achievement_values —
# сбрасываем current_streak в 0 при завершении уровня.
#
# 🆕 Штрафы (филворд):
# -1 за открытие списка слов (один раз за уровень)
# -1 за использование подсказки (один раз за уровень)
# -1 за превышение времени
list_opened = bool(body.get("list_opened", False))
# Лимит времени по размеру сетки
grid_size = level["grid_size"]
time_limits = {5: 45, 6: 60, 7: 90, 8: 120}
time_limit = time_limits.get(grid_size, 60)
completion_time_val = completion_time or 0
time_penalty = 1 if (completion_time_val > time_limit) else 0
hint_penalty = 1 if hints_used > 0 else 0
list_penalty = 1 if list_opened else 0
stars = max(
1,
5 - time_penalty - hint_penalty - list_penalty
)
# Начисляем XP через единую функцию
from services.xp import award_xp
xp_result = await award_xp(conn, telegram_id, "wordsearch", stars)
score = xp_result["points"] # для обратной совместимости
# 🔧 ФИКС (25.09.2026): complete_level_insert_overwrites_hints_used —
# раньше INSERT падал с unique violation, если строка user_progress
# уже была создана hints.py (юзер взял подсказку → уровень не завершится).
@@ -395,22 +392,15 @@ async def complete_level(request: Request):
current_streak = 0
""", telegram_id, level_id, hints_used, score, level_name)
# 🔧 ФИКС (30.09.2026): last_completed_by_level —
# обновляем per-level счётчик (JSONB) + старый last_completed_level.
# 🔧 ОБНОВЛЕНО (07.10.2026): единый счётчик progress.
# Обновляем только users.last_completed_level — глобальный.
# last_completed_by_level (JSONB) остаётся в БД для совместимости,
# но больше не пишется.
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
)
SET last_completed_level = GREATEST(COALESCE(last_completed_level, 0), $2)
WHERE telegram_id = $1
""", telegram_id, current_level_number, level_name)
""", telegram_id, current_level_number)
# Собираем данные для достижений внутри блока
levels_completed = await conn.fetchval(
@@ -471,8 +461,154 @@ async def complete_level(request: Request):
new_achievements.extend(ach)
return {
"status": "ok",
"status": "ok",
"score": score,
"already_completed": False,
"new_achievements": new_achievements
"new_achievements": new_achievements,
# 🆕 XP-поля
"stars": xp_result["stars"],
"base_points": xp_result["base_points"],
"multiplier": xp_result["multiplier"],
"points": xp_result["points"],
"featured": xp_result["featured"],
"level_up": xp_result["level_up"],
"total_xp": xp_result["total_xp"],
"level": xp_result["level"],
"rank_key": xp_result["rank_key"],
"xp_in_level": xp_result["xp_in_level"],
"xp_needed": xp_result["xp_needed"],
}
# ============================================================
# 🆕 (08.10.2026): Волновая выдача уровня.
# ============================================================
@router.post("/next")
async def get_next_level(request: Request):
"""
Выдаёт следующий уровень по волновой структуре.
Логика:
1. Смотрим user_game_progress.global_level_number.
2. Определяем волну и размер сетки через wave_plan.
3. Ищем непройденный уровень нужного размера (в user_seen_levels).
4. Помечаем как seen, обновляем user_game_progress.
5. Возвращаем level_number.
"""
telegram_id, _ = await require_auth(request)
pool = await get_pool()
async with pool.acquire() as conn:
# Читаем или создаём прогресс
row = await conn.fetchrow(
"""
SELECT global_level_number, session_number, session_level_number
FROM user_game_progress WHERE user_id = $1
""",
telegram_id,
)
if row is None:
await conn.execute(
"""
INSERT INTO user_game_progress
(user_id, global_level_number, session_number, session_level_number)
VALUES ($1, 1, 1, 1)
ON CONFLICT (user_id) DO NOTHING
""",
telegram_id,
)
global_level = 1
session_number = 1
session_level = 1
else:
global_level = int(row["global_level_number"] or 1)
session_number = int(row["session_number"] or 1)
session_level = int(row["session_level_number"] or 1)
# Определяем волну и размер
from services.waves import wave_for_level, level_in_wave, grid_size_for
wave = wave_for_level(global_level)
pos_in_wave = level_in_wave(global_level)
grid_size = grid_size_for(global_level)
# Ищем непройденный уровень нужного размера
# Исключаем те, что уже в user_seen_levels
level = await conn.fetchrow(
"""
SELECT l.id, l.level_number
FROM levels l
WHERE l.grid_size = $1
AND l.is_active = TRUE
AND l.id NOT IN (
SELECT level_id FROM user_seen_levels WHERE user_id = $2
)
ORDER BY RANDOM()
LIMIT 1
""",
grid_size, telegram_id,
)
# Fallback: если непройденных нет, берём самый давно виденный
if level is None:
level = await conn.fetchrow(
"""
SELECT l.id, l.level_number
FROM levels l
JOIN user_seen_levels usl ON usl.level_id = l.id
WHERE l.grid_size = $1
AND l.is_active = TRUE
AND usl.user_id = $2
ORDER BY usl.seen_at ASC
LIMIT 1
""",
grid_size, telegram_id,
)
if level is None:
raise HTTPException(404, "No levels available for this grid size")
level_id = level["id"]
level_number = level["level_number"]
# Помечаем как seen (обновляем seen_at если уже был)
await conn.execute(
"""
INSERT INTO user_seen_levels (user_id, level_id, seen_at)
VALUES ($1, $2, NOW())
ON CONFLICT (user_id, level_id) DO UPDATE
SET seen_at = NOW()
""",
telegram_id, level_id,
)
# Обновляем прогресс
next_global = global_level + 1
next_session_level = session_level + 1
next_session = session_number
if next_session_level > 20:
next_session_level = 1
next_session += 1
await conn.execute(
"""
UPDATE user_game_progress
SET global_level_number = $2,
session_number = $3,
session_level_number = $4,
updated_at = NOW()
WHERE user_id = $1
""",
telegram_id, next_global, next_session, next_session_level,
)
return {
"level_id": level_id,
"level_number": level_number,
"grid_size": grid_size,
"wave": wave,
"position_in_wave": pos_in_wave,
"session_number": session_number,
"session_level": session_level,
"global_level": global_level,
}
+171 -101
View File
@@ -10,7 +10,18 @@ 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:
@@ -28,17 +39,39 @@ async def get_leaderboard(request: Request, limit: int = 50):
current_level = user["current_level"] or "A1"
# Быстрое чтение из MATERIALIZED VIEW
# 🆕 Топ-N: matview + LEFT JOIN user_profile для XP.
# 🔧 ОБНОВЛЕНО (08.10.2026): сортировка по total_xp (weekly_xp убран).
rows = await conn.fetch("""
SELECT * FROM leaderboard_cache
ORDER BY total_score DESC
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)
leaderboard = []
for i, row in enumerate(rows):
leaderboard.append({
"rank": i + 1,
# Импорт 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"],
@@ -50,100 +83,131 @@ async def get_leaderboard(request: Request, limit: int = 50):
"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,
}
# 🔧 ФИКС (25.09.2026): leaderboard_rank_wrong_for_uncached_user —
# если пользователя нет в leaderboard_cache, подзапрос вернёт NULL,
# и COUNT(*) + 1 = 1 (юзер видит себя первым, хотя у него 0 очков).
# Теперь: если user нет в кэше — считаем его место по количеству
# записей с total_score > 0 + 1 (в конец списка).
my_total_in_cache = await conn.fetchval("""
SELECT total_score FROM leaderboard_cache WHERE telegram_id = $1
""", telegram_id)
leaderboard = [
_serialize_row(row, rank_num=i + 1)
for i, row in enumerate(rows)
]
if my_total_in_cache is None:
# Пользователя нет в кэше — считаем по количеству с > 0
user_rank = await conn.fetchval("""
SELECT COUNT(*) + 1 FROM leaderboard_cache
WHERE total_score > 0
""") or 1
else:
user_rank = await conn.fetchval("""
SELECT COUNT(*) + 1 FROM leaderboard_cache
WHERE total_score > $1
""", my_total_in_cache)
# Персональная статистика пользователя
# ============ Мой ранг ============
# Читаем мои XP + legacy-статистику.
my_row = await conn.fetchrow("""
SELECT * FROM leaderboard_cache WHERE telegram_id = $1
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)
if my_row:
# Если юзера нет в 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"]
else:
my_wordsearch = 0
my_sentence = 0
my_wordquiz = 0
my_words_guessed = 0
my_bubblewords = 0
my_bubble_levels = 0
my_total = my_wordsearch + my_sentence + my_wordquiz + my_bubblewords
# Считаем НАПРЯМУЮ из основных таблиц
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
# 🔧 ОБНОВЛЕНО (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_sentences_completed = await conn.fetchval(
"SELECT COUNT(*) FROM sentence_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
telegram_id
) or 0
# Если пользователя нет в кэше — считаем очки из основных таблиц
if not my_row:
my_wordsearch = await conn.fetchval(
"SELECT COALESCE(SUM(score), 0) FROM user_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
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
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_position = user_rank or 1
# 🔧 ФИКС N+1 (19.09.2026): 48 запросов → 5.
# Было: цикл по 6 уровням × 8 запросов = 48 round-trip к БД.
# Стало: 5 агрегированных запросов + сборка level_stats в Python.
# 1. Справочники (не зависят от юзера) — одним запросом
# ============ level_stats (legacy для Mini App) ============
ref_row = await conn.fetchrow("""
SELECT
(SELECT COUNT(*) FROM levels WHERE level = 'A1') AS a1_levels,
@@ -160,11 +224,8 @@ async def get_leaderboard(request: Request, limit: int = 50):
(SELECT COUNT(*) FROM sentences WHERE level = 'C2') AS c2_sent
""")
# 2. Очки и прогресс по всем уровням сразу — 4 запроса с GROUP BY
ws_rows = await conn.fetch("""
SELECT level,
COALESCE(SUM(score), 0) AS score,
COUNT(*) AS completed
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
@@ -172,9 +233,7 @@ async def get_leaderboard(request: Request, limit: int = 50):
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
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
@@ -183,23 +242,19 @@ async def get_leaderboard(request: Request, limit: int = 50):
wq_rows = await conn.fetch("""
SELECT level, COALESCE(total_score, 0) AS score
FROM word_quiz_progress
WHERE user_id = $1
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
FROM bubble_words_progress WHERE user_id = $1
""", telegram_id)
bw_by_level = {r["level"]: r for r in bw_rows}
# 3. Собираем level_stats в Python — без единого запроса
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
@@ -209,7 +264,6 @@ async def get_leaderboard(request: Request, limit: int = 50):
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
@@ -223,15 +277,20 @@ async def get_leaderboard(request: Request, limit: int = 50):
"bubblewords_score": bw_score,
}
# 🔧 ИСПРАВЛЕНО: вызов достижений ВНЕ блока async with pool.acquire()
# Достижения
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,
@@ -243,6 +302,17 @@ async def get_leaderboard(request: Request, limit: int = 50):
"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,
}
+34 -4
View File
@@ -160,6 +160,8 @@ async def check_sentence(request: Request):
raise HTTPException(400, "Too many words")
pool = await get_pool()
# 🔧 НОВОЕ (08.10.2026): XP-система — результат award_xp.
xp_result = None
async with pool.acquire() as conn:
user_exists = await conn.fetchval(
"SELECT 1 FROM users WHERE telegram_id = $1", telegram_id
@@ -207,12 +209,28 @@ async def check_sentence(request: Request):
if is_correct:
word_count = len(correct_words_original)
# 🆕 Расчёт звёзд для "Составь предложение"
# Старт 5. Штрафы:
# -1 за каждую неверную проверку (клиент шлёт wrong_checks)
# -1 если time > лимита (по длине: 3-4 → 30с, 5-6 → 45с, 7-8 → 60с)
wrong_checks = int(body.get("wrong_checks", 0) or 0)
if word_count <= 4:
score = 50
time_limit = 30
elif word_count <= 6:
score = 75
time_limit = 45
else:
score = 100
time_limit = 60
time_penalty = 1 if (completion_time and completion_time > time_limit) else 0
wrong_penalty = min(max(0, wrong_checks), 3)
stars = max(1, 5 - wrong_penalty - time_penalty)
# Начисляем XP
from services.xp import award_xp
xp_result = await award_xp(conn, telegram_id, "sentence", stars)
score = xp_result["points"]
await conn.execute(
"""INSERT INTO sentence_progress (user_id, sentence_id, completed_at, score, level)
@@ -267,7 +285,19 @@ async def check_sentence(request: Request):
"correct_words": [normalize_word_for_display(w) for w in correct_words_original],
"already_completed": False,
"score": score,
"new_achievements": new_achievements
"new_achievements": new_achievements,
# 🆕 XP
"stars": xp_result["stars"],
"base_points": xp_result["base_points"],
"multiplier": xp_result["multiplier"],
"points": xp_result["points"],
"featured": xp_result["featured"],
"level_up": xp_result["level_up"],
"total_xp": xp_result["total_xp"],
"level": xp_result["level"],
"rank_key": xp_result["rank_key"],
"xp_in_level": xp_result["xp_in_level"],
"xp_needed": xp_result["xp_needed"],
}
return {
+83 -1
View File
@@ -103,4 +103,86 @@ async def set_level(request: Request):
return {
"status": "ok",
"level": level,
}
}
# ============================================================
# 🆕 (08.10.2026): профиль — ник + аватар
# ============================================================
import re as _re
_FORBIDDEN_WORDS = {
"admin", "administrator", "root", "moderator", "mod",
"pleily", "filwords", "support", "help", "system",
"хуй", "пизда", "блядь", "сука", "ебать",
"kurwa", "chuj", "pizda", "jebac",
"fuck", "shit", "bitch", "ass",
}
_NICKNAME_RE = _re.compile(r'^[\w\s\.\-]+$', flags=_re.UNICODE)
def _clean_nickname(raw: str) -> str:
if not raw:
raise HTTPException(400, "Nickname is required")
nick = raw.strip()
if len(nick) < 2:
raise HTTPException(400, "Nickname must be at least 2 characters")
if len(nick) > 20:
raise HTTPException(400, "Nickname must be at most 20 characters")
lower = nick.lower()
for bad in _FORBIDDEN_WORDS:
if bad in lower:
raise HTTPException(400, "Nickname contains forbidden words")
if not _NICKNAME_RE.match(nick):
raise HTTPException(400, "Nickname contains invalid characters")
return nick
@router.post("/set-nickname")
async def set_nickname(request: Request):
"""Сохранить ник пользователя. Body: {"nickname": "Oleg"}"""
user_id, _ = await require_auth(request)
body = await request.json()
nickname = _clean_nickname(body.get("nickname", ""))
pool = await get_pool()
async with pool.acquire() as conn:
existing = await conn.fetchval(
"SELECT user_id FROM user_profile WHERE nickname = $1 AND user_id != $2",
nickname, user_id,
)
if existing:
raise HTTPException(409, "Nickname already taken")
await conn.execute("""
INSERT INTO user_profile (user_id, nickname, updated_at)
VALUES ($1, $2, NOW())
ON CONFLICT (user_id) DO UPDATE
SET nickname = $2, updated_at = NOW()
""", user_id, nickname)
return {"status": "ok", "nickname": nickname}
@router.post("/set-avatar")
async def set_avatar(request: Request):
"""Сохранить аватар. Body: {"avatar_id": 3}"""
user_id, _ = await require_auth(request)
body = await request.json()
avatar_id = body.get("avatar_id")
if not isinstance(avatar_id, int) or avatar_id < 0 or avatar_id > 7:
raise HTTPException(400, "avatar_id must be 0..7")
pool = await get_pool()
async with pool.acquire() as conn:
await conn.execute("""
INSERT INTO user_profile (user_id, avatar_id, updated_at)
VALUES ($1, $2, NOW())
ON CONFLICT (user_id) DO UPDATE
SET avatar_id = $2, updated_at = NOW()
""", user_id, avatar_id)
return {"status": "ok", "avatar_id": avatar_id}
+73 -37
View File
@@ -126,19 +126,26 @@ async def get_next_quiz(request: Request):
@router.post("/check")
async def check_quiz_answer(request: Request):
"""Проверяет ответ, начисляет очки и проверяет достижения"""
"""Проверяет ответ, начисляет XP и проверяет достижения.
🔧 НОВОЕ (08.10.2026): XP-система + серии.
Штрафы:
-1 за каждый неверный выбор (макс 3)
-1 если time_ms > 30 сек
Минимум 1 звезда.
Серия: correct_streak (best_streak хранится в choose_progress).
"""
telegram_id, _ = await require_auth(request)
body = await request.json()
correct_polish = body.get("correct_polish", "")
user_answer = body.get("answer", "")
completion_time = body.get("completion_time")
# 🔧 ФИКС (24.09.2026): client_controlled_mistakes_wordquiz —
# mistakes больше НЕ берём от клиента. Считаем на сервере.
# 🆕 wrong_count приходит с клиента для UI, но мы считаем на сервере
# 🔧 ФИКС: current_mistakes — серверный счётчик
if not correct_polish or not user_answer:
raise HTTPException(400, "correct_polish and answer required")
# Защита от читерства: минимальное время 1 секунда
if completion_time is not None and completion_time < 1:
return {
"correct": False,
@@ -147,25 +154,23 @@ async def check_quiz_answer(request: Request):
}
is_correct = user_answer.strip().lower() == correct_polish.strip().lower()
pool = await get_pool()
async with pool.acquire() as conn:
# Читаем серверный streak и mistakes
current_streak = await conn.fetchval(
"SELECT correct_streak FROM word_quiz_progress WHERE user_id = $1",
telegram_id
) or 0
# 🔧 ФИКС (24.09.2026): client_controlled_mistakes_wordquiz —
# читаем серверный current_mistakes.
mistakes = await conn.fetchval(
"SELECT current_mistakes FROM word_quiz_progress WHERE user_id = $1",
telegram_id
) or 0
if is_correct:
current_streak += 1
else:
current_streak = 0
# 🔧 Инкрементим mistakes на сервере
await conn.execute("""
INSERT INTO word_quiz_progress (user_id, current_mistakes)
VALUES ($1, 1)
@@ -173,14 +178,29 @@ async def check_quiz_answer(request: Request):
SET current_mistakes = word_quiz_progress.current_mistakes + 1
""", telegram_id)
mistakes += 1
xp_result = None
score = 0
if is_correct:
score = max(10, 50 - (mistakes * 20))
# 🔧 Сбрасываем mistakes при правильном ответе
# 🆕 Расчёт звёзд для "Выбери слово"
# Старт 5 звёзд. Штрафы:
# -1 за каждый неверный (макс 3)
# -1 если time > 30 сек
time_penalty = 1 if (completion_time and completion_time > 30) else 0
wrong_penalty = min(mistakes, 3)
stars = max(1, 5 - wrong_penalty - time_penalty)
# Начисляем XP
from services.xp import award_xp
xp_result = await award_xp(conn, telegram_id, "choose", stars)
score = xp_result["points"]
# Сбрасываем mistakes + обновляем серию
await conn.execute("""
UPDATE word_quiz_progress SET current_mistakes = 0 WHERE user_id = $1
""", telegram_id)
await conn.execute("""
INSERT INTO word_quiz_progress (user_id, words_guessed, total_score, correct_streak)
VALUES ($1, 1, $2, $3)
@@ -189,43 +209,35 @@ async def check_quiz_answer(request: Request):
total_score = word_quiz_progress.total_score + $2,
correct_streak = $3
""", telegram_id, score, current_streak)
# 🔧 ФИКС (23.09.2026): achievements_nested_pool_acquire_wordquiz —
# вызовы достижений вынесены за async with pool.acquire() (паттерн game.py).
# 🆕 Обновляем best_streak в choose_progress
await conn.execute("""
INSERT INTO choose_progress (user_id, current_streak, best_streak)
VALUES ($1, $2, $2)
ON CONFLICT (user_id) DO UPDATE
SET current_streak = $2,
best_streak = GREATEST(choose_progress.best_streak, $2),
updated_at = NOW()
""", telegram_id, current_streak)
# Собираем данные для достижений
total_guessed = await conn.fetchval(
"SELECT words_guessed FROM word_quiz_progress WHERE user_id = $1",
telegram_id
) or 0
wordsearch_score = 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
sentence_score = 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
wordquiz_score = await conn.fetchval(
"SELECT COALESCE(total_score, 0) FROM word_quiz_progress WHERE user_id = $1",
telegram_id
) or 0
bubblewords_score = await conn.fetchval(
"SELECT COALESCE(total_score, 0) FROM bubble_words_progress WHERE user_id = $1",
telegram_id
) or 0
grand_total = wordsearch_score + sentence_score + wordquiz_score + bubblewords_score
achievements_to_check = [
("quiz_guessed", total_guessed),
("total_score", grand_total),
("total_score", xp_result["total_xp"]),
]
if current_streak >= 10:
achievements_to_check.append(("quiz_perfect_streak", current_streak))
if mistakes == 0:
achievements_to_check.append(("quiz_no_mistakes", 1))
if completion_time is not None and completion_time > 0 and int(completion_time) <= 3:
if completion_time is not None and 0 < completion_time <= 3:
achievements_to_check.append(("quiz_speed", 3))
else:
# При 3 ошибках — начисляем утешительные 10 очков
# При 3 ошибках — утешительный XP (10)
if mistakes >= 3:
await conn.execute("""
INSERT INTO word_quiz_progress (user_id, words_guessed, total_score, correct_streak, current_mistakes)
@@ -242,7 +254,7 @@ async def check_quiz_answer(request: Request):
SET correct_streak = $2
""", telegram_id, current_streak)
# 🔧 ФИКС (23.09.2026): вызовы достижений ВНЕ блока async with pool.acquire()
# Достижения — вне транзакции
if is_correct:
from routers.achievements import check_and_award_achievements
new_achievements = []
@@ -255,6 +267,20 @@ async def check_quiz_answer(request: Request):
"score": score,
"correct_streak": current_streak,
"new_achievements": new_achievements,
# 🆕 XP-поля
"stars": xp_result["stars"],
"base_points": xp_result["base_points"],
"multiplier": xp_result["multiplier"],
"points": xp_result["points"],
"featured": xp_result["featured"],
"level_up": xp_result["level_up"],
"total_xp": xp_result["total_xp"],
"level": xp_result["level"],
"rank_key": xp_result["rank_key"],
"xp_in_level": xp_result["xp_in_level"],
"xp_needed": xp_result["xp_needed"],
# 🆕 Серия для UI
"streak_best": (await _get_best_streak(telegram_id)),
}
return {
@@ -264,6 +290,16 @@ async def check_quiz_answer(request: Request):
}
async def _get_best_streak(telegram_id: int) -> int:
"""Возвращает best_streak пользователя из choose_progress."""
pool = await get_pool()
async with pool.acquire() as conn:
return await conn.fetchval(
"SELECT best_streak FROM choose_progress WHERE user_id = $1",
telegram_id
) or 0
@router.get("/progress")
async def get_quiz_progress(request: Request):
"""Статистика пользователя в квизе"""