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:
+77
-35
@@ -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
@@ -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"],
|
||||
}
|
||||
|
||||
|
||||
|
||||
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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):
|
||||
"""Статистика пользователя в квизе"""
|
||||
|
||||
Reference in New Issue
Block a user