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:
+189
@@ -1335,6 +1335,195 @@ async def init_db():
|
||||
""")
|
||||
logger.info("Table auth_identities initialized (Pleily)")
|
||||
|
||||
# ============================================================
|
||||
# 🔧 НОВОЕ (08.10.2026): XP-фундамент Pleily.
|
||||
# user_profile, xp_log, choose_progress, user_seen_levels,
|
||||
# user_game_progress, wave_results, bubble_levels,
|
||||
# user_seen_bubble_levels, user_word_stats.
|
||||
# + расширение sentences (tokens, alt_orders, word_count).
|
||||
# ============================================================
|
||||
|
||||
# ---------- user_profile ----------
|
||||
await conn.execute("""
|
||||
CREATE TABLE IF NOT EXISTS user_profile (
|
||||
user_id BIGINT PRIMARY KEY
|
||||
REFERENCES users(telegram_id) ON DELETE CASCADE,
|
||||
nickname TEXT,
|
||||
avatar_id INTEGER DEFAULT 0,
|
||||
total_xp INTEGER DEFAULT 0,
|
||||
weekly_xp INTEGER DEFAULT 0,
|
||||
week_started_at DATE DEFAULT CURRENT_DATE,
|
||||
updated_at TIMESTAMP DEFAULT NOW()
|
||||
)
|
||||
""")
|
||||
await conn.execute("""
|
||||
CREATE INDEX IF NOT EXISTS idx_user_profile_weekly
|
||||
ON user_profile(weekly_xp DESC)
|
||||
""")
|
||||
logger.info("Table user_profile initialized (XP)")
|
||||
|
||||
# ---------- xp_log ----------
|
||||
await conn.execute("""
|
||||
CREATE TABLE IF NOT EXISTS xp_log (
|
||||
id BIGSERIAL PRIMARY KEY,
|
||||
user_id BIGINT NOT NULL
|
||||
REFERENCES users(telegram_id) ON DELETE CASCADE,
|
||||
game TEXT NOT NULL,
|
||||
stars INTEGER NOT NULL,
|
||||
base_points INTEGER NOT NULL,
|
||||
multiplier NUMERIC(3,2) NOT NULL DEFAULT 1.0,
|
||||
points INTEGER NOT NULL,
|
||||
created_at TIMESTAMP DEFAULT NOW()
|
||||
)
|
||||
""")
|
||||
await conn.execute("""
|
||||
CREATE INDEX IF NOT EXISTS idx_xp_log_user_date
|
||||
ON xp_log(user_id, created_at DESC)
|
||||
""")
|
||||
logger.info("Table xp_log initialized (XP)")
|
||||
|
||||
# ---------- choose_progress (серии в "Выбери слово") ----------
|
||||
await conn.execute("""
|
||||
CREATE TABLE IF NOT EXISTS choose_progress (
|
||||
user_id BIGINT PRIMARY KEY
|
||||
REFERENCES users(telegram_id) ON DELETE CASCADE,
|
||||
current_streak INTEGER DEFAULT 0,
|
||||
best_streak INTEGER DEFAULT 0,
|
||||
updated_at TIMESTAMP DEFAULT NOW()
|
||||
)
|
||||
""")
|
||||
logger.info("Table choose_progress initialized")
|
||||
|
||||
# ---------- user_seen_levels (филворд: какие уровни видел) ----------
|
||||
await conn.execute("""
|
||||
CREATE TABLE IF NOT EXISTS user_seen_levels (
|
||||
user_id BIGINT NOT NULL
|
||||
REFERENCES users(telegram_id) ON DELETE CASCADE,
|
||||
level_id INTEGER NOT NULL
|
||||
REFERENCES levels(id) ON DELETE CASCADE,
|
||||
seen_at TIMESTAMP DEFAULT NOW(),
|
||||
PRIMARY KEY (user_id, level_id)
|
||||
)
|
||||
""")
|
||||
await conn.execute("""
|
||||
CREATE INDEX IF NOT EXISTS idx_user_seen_levels_user
|
||||
ON user_seen_levels(user_id, seen_at DESC)
|
||||
""")
|
||||
logger.info("Table user_seen_levels initialized")
|
||||
|
||||
# ---------- user_game_progress (сессии филворда) ----------
|
||||
await conn.execute("""
|
||||
CREATE TABLE IF NOT EXISTS user_game_progress (
|
||||
user_id BIGINT PRIMARY KEY
|
||||
REFERENCES users(telegram_id) ON DELETE CASCADE,
|
||||
session_number INTEGER DEFAULT 1,
|
||||
session_level_number INTEGER DEFAULT 1,
|
||||
global_level_number INTEGER DEFAULT 1,
|
||||
time_limit_seconds INTEGER,
|
||||
updated_at TIMESTAMP DEFAULT NOW()
|
||||
)
|
||||
""")
|
||||
logger.info("Table user_game_progress initialized")
|
||||
|
||||
# ---------- wave_results (итоги волны) ----------
|
||||
await conn.execute("""
|
||||
CREATE TABLE IF NOT EXISTS wave_results (
|
||||
id BIGSERIAL PRIMARY KEY,
|
||||
user_id BIGINT NOT NULL
|
||||
REFERENCES users(telegram_id) ON DELETE CASCADE,
|
||||
wave_number INTEGER NOT NULL,
|
||||
stars_earned INTEGER DEFAULT 0,
|
||||
medal TEXT DEFAULT 'none',
|
||||
completed_at TIMESTAMP DEFAULT NOW(),
|
||||
UNIQUE (user_id, wave_number)
|
||||
)
|
||||
""")
|
||||
await conn.execute("""
|
||||
CREATE INDEX IF NOT EXISTS idx_wave_results_user
|
||||
ON wave_results(user_id, wave_number DESC)
|
||||
""")
|
||||
logger.info("Table wave_results initialized")
|
||||
|
||||
# ---------- bubble_levels ----------
|
||||
await conn.execute("""
|
||||
CREATE TABLE IF NOT EXISTS bubble_levels (
|
||||
id BIGSERIAL PRIMARY KEY,
|
||||
word_ids INTEGER[] NOT NULL,
|
||||
difficulty INTEGER DEFAULT 1,
|
||||
created_at TIMESTAMP DEFAULT NOW()
|
||||
)
|
||||
""")
|
||||
logger.info("Table bubble_levels initialized")
|
||||
|
||||
# ---------- user_seen_bubble_levels ----------
|
||||
await conn.execute("""
|
||||
CREATE TABLE IF NOT EXISTS user_seen_bubble_levels (
|
||||
user_id BIGINT NOT NULL
|
||||
REFERENCES users(telegram_id) ON DELETE CASCADE,
|
||||
bubble_level_id BIGINT NOT NULL
|
||||
REFERENCES bubble_levels(id) ON DELETE CASCADE,
|
||||
seen_at TIMESTAMP DEFAULT NOW(),
|
||||
PRIMARY KEY (user_id, bubble_level_id)
|
||||
)
|
||||
""")
|
||||
logger.info("Table user_seen_bubble_levels initialized")
|
||||
|
||||
# ---------- user_word_stats (повторение слов) ----------
|
||||
await conn.execute("""
|
||||
CREATE TABLE IF NOT EXISTS user_word_stats (
|
||||
user_id BIGINT NOT NULL
|
||||
REFERENCES users(telegram_id) ON DELETE CASCADE,
|
||||
word_pl TEXT NOT NULL,
|
||||
correct INTEGER DEFAULT 0,
|
||||
wrong INTEGER DEFAULT 0,
|
||||
last_seen_at TIMESTAMP DEFAULT NOW(),
|
||||
PRIMARY KEY (user_id, word_pl)
|
||||
)
|
||||
""")
|
||||
await conn.execute("""
|
||||
CREATE INDEX IF NOT EXISTS idx_user_word_stats_user
|
||||
ON user_word_stats(user_id, last_seen_at DESC)
|
||||
""")
|
||||
logger.info("Table user_word_stats initialized")
|
||||
|
||||
# ---------- sentences: tokens, alt_orders, word_count ----------
|
||||
for col_name, col_type in (
|
||||
("tokens", "JSONB DEFAULT '[]'::jsonb"),
|
||||
("alt_orders", "JSONB DEFAULT '[]'::jsonb"),
|
||||
("word_count", "INTEGER DEFAULT 0"),
|
||||
):
|
||||
col_exists = await conn.fetchval("""
|
||||
SELECT 1 FROM information_schema.columns
|
||||
WHERE table_name = 'sentences' AND column_name = $1
|
||||
""", col_name)
|
||||
if not col_exists:
|
||||
await conn.execute(
|
||||
f"ALTER TABLE sentences ADD COLUMN {col_name} {col_type}"
|
||||
)
|
||||
logger.info(f"Added {col_name} column to sentences")
|
||||
|
||||
# Backfill: word_count для существующих предложений
|
||||
await conn.execute("""
|
||||
UPDATE sentences
|
||||
SET word_count = array_length(
|
||||
regexp_split_to_array(trim(sentence_pl), '\\s+'), 1
|
||||
)
|
||||
WHERE word_count = 0 OR word_count IS NULL
|
||||
""")
|
||||
logger.info("Backfilled sentences.word_count")
|
||||
|
||||
# ---------- Backfill: user_profile для существующих юзеров ----------
|
||||
await conn.execute("""
|
||||
INSERT INTO user_profile (user_id, total_xp, weekly_xp)
|
||||
SELECT u.telegram_id, 0, 0
|
||||
FROM users u
|
||||
WHERE NOT EXISTS (
|
||||
SELECT 1 FROM user_profile p WHERE p.user_id = u.telegram_id
|
||||
)
|
||||
ON CONFLICT (user_id) DO NOTHING
|
||||
""")
|
||||
logger.info("Backfilled user_profile for existing users")
|
||||
|
||||
await conn.execute("CREATE INDEX IF NOT EXISTS idx_sentences_level_number ON sentences(level, sentence_number)")
|
||||
# Оставляем score-индексы (не дубли)
|
||||
await conn.execute("CREATE INDEX IF NOT EXISTS idx_user_progress_score ON user_progress(score DESC)")
|
||||
|
||||
@@ -15,6 +15,7 @@ from routers import users, game, hints, leaderboard, sentences, achievements, wo
|
||||
from routers import lectures, admin_auth, admin_wordsearch, admin_users
|
||||
from routers import admin_ai # 🔧 НОВОЕ
|
||||
from routers import app_auth # 🆕 Pleily auth
|
||||
from routers import featured as featured_router # 🔧 НОВОЕ (08.10.2026)
|
||||
from routers.sentences import init_sentences
|
||||
from routers.achievements import init_achievements
|
||||
from routers.learning_data import init_learning_data
|
||||
@@ -375,6 +376,7 @@ app.include_router(admin_wordsearch.router)
|
||||
app.include_router(admin_users.router)
|
||||
app.include_router(admin_ai.router) # 🔧 НОВОЕ
|
||||
app.include_router(app_auth.router) # 🆕 Pleily
|
||||
app.include_router(featured_router.router) # 🔧 НОВОЕ (08.10.2026)
|
||||
|
||||
|
||||
# ============ Базовые эндпоинты ============
|
||||
|
||||
+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):
|
||||
"""Статистика пользователя в квизе"""
|
||||
|
||||
@@ -0,0 +1,516 @@
|
||||
"""
|
||||
generate_levels.py — генератор уровней филвордов (word search).
|
||||
|
||||
🔧 НОВОЕ (07.10.2026): Первая версия.
|
||||
Порт алгоритма с JS (filword-gen.js): слова-змейки,
|
||||
4 направления (вверх/вниз/влево/вправо), без диагоналей.
|
||||
Поле n×n полностью заполнено, слова не пересекаются.
|
||||
|
||||
Логика:
|
||||
1. Читает все слова из csv_words (A1+A2+B1), DISTINCT по word_pl.
|
||||
Фильтр: длина 3..10 Unicode-символов.
|
||||
2. Группирует по длине.
|
||||
3. Для каждого размера n в [4, 5, 6, 7, 8, 9, 10]:
|
||||
- генерирует 100 уровней;
|
||||
- level_number — сквозной, начиная с MAX(level_number)+1 из БД;
|
||||
- level = 'common' (не A1/A2/B1);
|
||||
- game_type = 'wordsearch';
|
||||
- is_active = TRUE;
|
||||
- created_by = NULL (автогенерированный).
|
||||
4. Сохраняет в levels + level_words.
|
||||
|
||||
🔧 ФИКС (07.10.2026): random_start_cell —
|
||||
раньше solve() всегда начинал с клетки (0,0), из-за чего во всех
|
||||
уровнях первое слово было "прибито" к верхнему левому углу.
|
||||
Теперь старт — случайная свободная клетка.
|
||||
|
||||
Запуск:
|
||||
cd ~/filwordspl/backend
|
||||
source venv/bin/activate
|
||||
python scripts/generate_levels.py
|
||||
|
||||
Требования:
|
||||
Python 3.12, asyncpg.
|
||||
Пишет прогресс в stdout.
|
||||
ON CONFLICT DO NOTHING на уровнях.
|
||||
Не трогает уровни с created_by IS NOT NULL.
|
||||
"""
|
||||
|
||||
import asyncio
|
||||
import logging
|
||||
import random
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
# Разрешаем запуск из scripts/ — добавляем корень backend в sys.path.
|
||||
BACKEND_ROOT = Path(__file__).resolve().parent.parent
|
||||
if str(BACKEND_ROOT) not in sys.path:
|
||||
sys.path.insert(0, str(BACKEND_ROOT))
|
||||
|
||||
from database import get_pool # noqa: E402
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
# ============ Конфигурация ============
|
||||
|
||||
LEVELS_PER_SIZE = 215
|
||||
GRID_SIZES = [4, 5, 6, 7, 8, 9, 10]
|
||||
LEVEL_NAME = "common"
|
||||
GAME_TYPE = "wordsearch"
|
||||
MIN_WORD_LEN = 3
|
||||
MAX_WORD_LEN = 10
|
||||
|
||||
# Максимальное количество попыток и шагов на один бэктрекинг.
|
||||
MAX_STEPS = 20000
|
||||
ATTEMPTS = 200
|
||||
|
||||
# Диапазон seed (воспроизводимость).
|
||||
SEED_BASE = 20261007
|
||||
|
||||
# Пул слов из БД: все треки, все уровни.
|
||||
WORD_LEVELS = ("A1", "A2", "B1")
|
||||
|
||||
|
||||
# ============ Утилиты ============
|
||||
|
||||
def shuffle(arr: list, rnd: random.Random) -> list:
|
||||
"""Fisher-Yates shuffle (как в JS)."""
|
||||
for i in range(len(arr) - 1, 0, -1):
|
||||
j = rnd.randrange(i + 1)
|
||||
arr[i], arr[j] = arr[j], arr[i]
|
||||
return arr
|
||||
|
||||
|
||||
def word_length(word: str) -> int:
|
||||
"""Длина слова в Unicode-символах (ą, ł, ś и т.д. = 1 буква)."""
|
||||
return len(word)
|
||||
|
||||
|
||||
def group_by_length(words: list[str]) -> dict[int, list[str]]:
|
||||
"""Группирует слова по длине. Возвращает {len: [words]}."""
|
||||
res: dict[int, list[str]] = {}
|
||||
seen = set()
|
||||
for raw in words:
|
||||
w = raw.strip().upper()
|
||||
if not w or w in seen:
|
||||
continue
|
||||
seen.add(w)
|
||||
ln = word_length(w)
|
||||
res.setdefault(ln, []).append(w)
|
||||
return res
|
||||
|
||||
|
||||
# ============ Ядро: разбиение поля на змейки ============
|
||||
|
||||
def partition_grid(
|
||||
n: int,
|
||||
available: dict[int, int],
|
||||
rnd: random.Random,
|
||||
max_steps: int = MAX_STEPS,
|
||||
attempts: int = ATTEMPTS,
|
||||
) -> list[list[list[int]]] | None:
|
||||
"""
|
||||
ШАГ 1. Разбивает n×n поле на пути-змейки.
|
||||
|
||||
available: {длина: сколько слов такой длины доступно}
|
||||
Возвращает массив путей [[[r,c], ...], ...] или None.
|
||||
"""
|
||||
lengths = [ln for ln, cnt in available.items() if cnt > 0 and ln >= 2]
|
||||
if not lengths:
|
||||
return None
|
||||
max_len = max(lengths)
|
||||
total = n * n
|
||||
|
||||
# ok[s] = можно ли набрать s клеток допустимыми длинами.
|
||||
ok = [False] * (total + 1)
|
||||
ok[0] = True
|
||||
for s in range(1, total + 1):
|
||||
ok[s] = any(s >= ln and ok[s - ln] for ln in lengths)
|
||||
if not ok[total]:
|
||||
return None
|
||||
|
||||
dirs = [(1, 0), (-1, 0), (0, 1), (0, -1)]
|
||||
|
||||
for _attempt in range(attempts):
|
||||
grid = [[-1] * n for _ in range(n)]
|
||||
left = dict(available)
|
||||
paths: list[list[list[int]]] = []
|
||||
steps = [0] # список, чтобы менять из вложенных функций
|
||||
|
||||
def is_free(r: int, c: int) -> bool:
|
||||
return 0 <= r < n and 0 <= c < n and grid[r][c] == -1
|
||||
|
||||
def free_count(r: int, c: int) -> int:
|
||||
return sum(1 for dr, dc in dirs if is_free(r + dr, c + dc))
|
||||
|
||||
def regions_ok() -> bool:
|
||||
"""Каждая связная область свободных клеток делится допустимыми длинами."""
|
||||
seen = [[False] * n for _ in range(n)]
|
||||
for r0 in range(n):
|
||||
for c0 in range(n):
|
||||
if not is_free(r0, c0) or seen[r0][c0]:
|
||||
continue
|
||||
size = 0
|
||||
stack = [(r0, c0)]
|
||||
seen[r0][c0] = True
|
||||
while stack:
|
||||
y, x = stack.pop()
|
||||
size += 1
|
||||
for dr, dc in dirs:
|
||||
a, b = y + dr, x + dc
|
||||
if is_free(a, b) and not seen[a][b]:
|
||||
seen[a][b] = True
|
||||
stack.append((a, b))
|
||||
if not ok[size]:
|
||||
return False
|
||||
return True
|
||||
|
||||
def solve() -> bool:
|
||||
# 🔧 ФИКС (07.10.2026): random_start_cell —
|
||||
# раньше всегда начинали с (0,0) → все уровни с верхнего левого угла.
|
||||
# Теперь — случайная свободная клетка.
|
||||
free_cells = [
|
||||
(r, c)
|
||||
for r in range(n)
|
||||
for c in range(n)
|
||||
if is_free(r, c)
|
||||
]
|
||||
if not free_cells:
|
||||
return True # всё поле покрыто
|
||||
start = rnd.choice(free_cells)
|
||||
|
||||
grid[start[0]][start[1]] = len(paths)
|
||||
target = lengths[rnd.randrange(len(lengths))]
|
||||
if extend([list(start)], target):
|
||||
return True
|
||||
grid[start[0]][start[1]] = -1
|
||||
return False
|
||||
|
||||
def extend(path: list[list[int]], target: int) -> bool:
|
||||
steps[0] += 1
|
||||
if steps[0] > max_steps:
|
||||
return False
|
||||
|
||||
ln = len(path)
|
||||
r, c = path[-1]
|
||||
|
||||
def try_close() -> bool:
|
||||
if not (left.get(ln, 0) > 0):
|
||||
return False
|
||||
left[ln] -= 1
|
||||
paths.append([list(p) for p in path])
|
||||
if regions_ok() and solve():
|
||||
return True
|
||||
paths.pop()
|
||||
left[ln] += 1
|
||||
return False
|
||||
|
||||
if ln >= target and try_close():
|
||||
return True
|
||||
if ln >= max_len:
|
||||
return False
|
||||
|
||||
# Соседи: сначала те, у которых меньше свободных соседей.
|
||||
nbs = []
|
||||
for dr, dc in dirs:
|
||||
a, b = r + dr, c + dc
|
||||
if is_free(a, b):
|
||||
k = free_count(a, b) + rnd.random() * 1.5
|
||||
nbs.append(((a, b), k))
|
||||
nbs.sort(key=lambda x: x[1])
|
||||
|
||||
for (a, b), _ in nbs:
|
||||
grid[a][b] = len(paths)
|
||||
path.append([a, b])
|
||||
if extend(path, target):
|
||||
return True
|
||||
path.pop()
|
||||
grid[a][b] = -1
|
||||
if steps[0] > max_steps:
|
||||
return False
|
||||
|
||||
if ln < target and try_close():
|
||||
return True
|
||||
return False
|
||||
|
||||
if solve():
|
||||
return paths
|
||||
|
||||
return None
|
||||
|
||||
|
||||
# ============ Ядро: строит уровень ============
|
||||
|
||||
def build_level(
|
||||
n: int,
|
||||
words_by_len: dict[int, list[str]],
|
||||
rnd: random.Random,
|
||||
) -> dict | None:
|
||||
"""
|
||||
ШАГ 2. Разбивает поле и вписывает слова в змейки.
|
||||
|
||||
Возвращает {size, letters: List[List[str]], words: [{word, cells}], }
|
||||
или None, если не удалось.
|
||||
"""
|
||||
available = {ln: len(words) for ln, words in words_by_len.items()}
|
||||
# Доступные длины ограничиваем 2..n*n, чтобы partition_grid не падал.
|
||||
max_cells = n * n
|
||||
available = {ln: cnt for ln, cnt in available.items() if 2 <= ln <= max_cells}
|
||||
if not available:
|
||||
return None
|
||||
|
||||
paths = partition_grid(n, available, rnd)
|
||||
if not paths:
|
||||
return None
|
||||
|
||||
pools: dict[int, list[str]] = {ln: shuffle(list(words), rnd) for ln, words in words_by_len.items()}
|
||||
|
||||
letters = [[""] * n for _ in range(n)]
|
||||
words_out: list[dict] = []
|
||||
for p in paths:
|
||||
pool = pools.get(len(p), [])
|
||||
if not pool:
|
||||
# Не должно случаться: partition_grid согласован с available.
|
||||
return None
|
||||
w = pool.pop()
|
||||
for i, ch in enumerate(w):
|
||||
r, c = p[i]
|
||||
letters[r][c] = ch
|
||||
words_out.append({"word": w, "cells": p})
|
||||
|
||||
return {"size": n, "letters": letters, "words": words_out}
|
||||
|
||||
|
||||
# ============ БД ============
|
||||
|
||||
async def fetch_words(pool) -> list[str]:
|
||||
"""
|
||||
Возвращает все слова из csv_words (A1+A2+B1), DISTINCT по word_pl.
|
||||
Фильтр: длина 3..10 Unicode-символов.
|
||||
"""
|
||||
async with pool.acquire() as conn:
|
||||
rows = await conn.fetch("""
|
||||
SELECT DISTINCT word_pl
|
||||
FROM csv_words
|
||||
WHERE level_code = ANY($1::text[])
|
||||
""", list(WORD_LEVELS))
|
||||
|
||||
raw_words = [r["word_pl"] for r in rows]
|
||||
|
||||
# Фильтр по длине.
|
||||
filtered: list[str] = []
|
||||
seen = set()
|
||||
for w in raw_words:
|
||||
if not w:
|
||||
continue
|
||||
wu = w.strip().upper()
|
||||
if not wu or wu in seen:
|
||||
continue
|
||||
ln = word_length(wu)
|
||||
if MIN_WORD_LEN <= ln <= MAX_WORD_LEN:
|
||||
filtered.append(wu)
|
||||
seen.add(wu)
|
||||
|
||||
return filtered
|
||||
|
||||
|
||||
async def fetch_translations(pool, words: list[str]) -> dict[str, dict[str, str]]:
|
||||
"""
|
||||
Возвращает переводы: {word_pl: {ru, uk, en}}.
|
||||
Берём первую строку по каждому слову (DISTINCT).
|
||||
"""
|
||||
if not words:
|
||||
return {}
|
||||
|
||||
async with pool.acquire() as conn:
|
||||
rows = await conn.fetch("""
|
||||
SELECT DISTINCT ON (word_pl)
|
||||
word_pl, translation_ru, translation_uk, translation_en
|
||||
FROM csv_words
|
||||
WHERE level_code = ANY($1::text[])
|
||||
AND word_pl = ANY($2::text[])
|
||||
ORDER BY word_pl
|
||||
""", list(WORD_LEVELS), words)
|
||||
|
||||
return {
|
||||
r["word_pl"]: {
|
||||
"ru": r["translation_ru"] or "",
|
||||
"uk": r["translation_uk"] or "",
|
||||
"en": r["translation_en"] or "",
|
||||
}
|
||||
for r in rows
|
||||
}
|
||||
|
||||
|
||||
async def fetch_max_level_number(pool) -> int:
|
||||
"""Возвращает MAX(level_number) из levels или 0."""
|
||||
async with pool.acquire() as conn:
|
||||
val = await conn.fetchval("SELECT COALESCE(MAX(level_number), 0) FROM levels")
|
||||
return int(val or 0)
|
||||
|
||||
|
||||
async def save_level(
|
||||
pool,
|
||||
level_number: int,
|
||||
grid_size: int,
|
||||
letters: list[list[str]],
|
||||
words: list[dict],
|
||||
translations: dict[str, dict[str, str]],
|
||||
) -> bool:
|
||||
"""
|
||||
Сохраняет уровень в levels + level_words.
|
||||
|
||||
level = 'common', game_type = 'wordsearch', is_active = TRUE,
|
||||
created_by = NULL.
|
||||
|
||||
ON CONFLICT DO NOTHING на levels (UNIQUE (level, level_number)).
|
||||
Возвращает True, если уровень реально создан.
|
||||
"""
|
||||
import json as _json
|
||||
|
||||
word_paths = {w["word"]: w["cells"] for w in words}
|
||||
|
||||
async with pool.acquire() as conn:
|
||||
async with conn.transaction():
|
||||
row = await conn.fetchrow("""
|
||||
INSERT INTO levels
|
||||
(level_number, grid_size, game_type, level,
|
||||
grid_letters, word_paths, is_active, created_by, created_at)
|
||||
VALUES ($1, $2, $3, $4, $5, $6, TRUE, NULL, NOW())
|
||||
ON CONFLICT (level, level_number) DO NOTHING
|
||||
RETURNING id
|
||||
""",
|
||||
level_number,
|
||||
grid_size,
|
||||
GAME_TYPE,
|
||||
LEVEL_NAME,
|
||||
_json.dumps(letters),
|
||||
_json.dumps(word_paths),
|
||||
)
|
||||
|
||||
if not row:
|
||||
return False
|
||||
|
||||
level_id = row["id"]
|
||||
|
||||
# level_words — вставляем построчно.
|
||||
for w in words:
|
||||
word_pl = w["word"]
|
||||
trans = translations.get(word_pl, {})
|
||||
await conn.execute("""
|
||||
INSERT INTO level_words
|
||||
(level_id, word_pl, translation_ru, translation_uk, translation_en, level)
|
||||
VALUES ($1, $2, $3, $4, $5, $6)
|
||||
""",
|
||||
level_id,
|
||||
word_pl,
|
||||
trans.get("ru", ""),
|
||||
trans.get("uk", ""),
|
||||
trans.get("en", ""),
|
||||
LEVEL_NAME,
|
||||
)
|
||||
|
||||
return True
|
||||
|
||||
|
||||
# ============ Main ============
|
||||
|
||||
async def main() -> None:
|
||||
logging.basicConfig(
|
||||
level=logging.INFO,
|
||||
format="%(asctime)s [%(levelname)s] %(message)s",
|
||||
datefmt="%H:%M:%S",
|
||||
)
|
||||
|
||||
logger.info("=== Генерация уровней филвордов ===")
|
||||
pool = await get_pool()
|
||||
|
||||
# 1. Слова
|
||||
logger.info("Читаю слова из csv_words...")
|
||||
all_words = await fetch_words(pool)
|
||||
logger.info(f"Всего слов 3..10 букв: {len(all_words)}")
|
||||
|
||||
if not all_words:
|
||||
logger.error("Нет слов для генерации. Проверь csv_words.")
|
||||
return
|
||||
|
||||
words_by_len = group_by_length(all_words)
|
||||
logger.info("Распределение по длинам:")
|
||||
for ln in sorted(words_by_len.keys()):
|
||||
logger.info(f" длина {ln}: {len(words_by_len[ln])} слов")
|
||||
|
||||
# 2. MAX(level_number)
|
||||
max_level_number = await fetch_max_level_number(pool)
|
||||
logger.info(f"MAX(level_number) в БД: {max_level_number}")
|
||||
|
||||
# 3. Переводы (берём все нужные слова сразу, чтобы не дёргать БД внутри цикла)
|
||||
logger.info("Читаю переводы...")
|
||||
translations = await fetch_translations(pool, all_words)
|
||||
logger.info(f"Переводов: {len(translations)}")
|
||||
|
||||
# 4. Генерация
|
||||
next_level_number = max_level_number + 1
|
||||
created_total = 0
|
||||
stats_by_size: dict[int, dict[str, int]] = {}
|
||||
|
||||
for n in GRID_SIZES:
|
||||
stats_by_size[n] = {"created": 0, "failed": 0}
|
||||
logger.info(f"\n--- Размер поля {n}×{n} ---")
|
||||
|
||||
# Проверим, хватает ли длин: на n×n нужны длины из words_by_len.
|
||||
# Слова длиннее n*n невозможны — отсекаем.
|
||||
candidate_lengths = [ln for ln in words_by_len.keys() if ln <= n * n]
|
||||
if not candidate_lengths:
|
||||
logger.warning(f"Размер {n}: нет слов подходящей длины, пропускаю")
|
||||
continue
|
||||
|
||||
for i in range(LEVELS_PER_SIZE):
|
||||
seed = SEED_BASE + next_level_number
|
||||
rnd = random.Random(seed)
|
||||
|
||||
# Копия words_by_len с только подходящими длинами.
|
||||
wbl = {ln: list(words_by_len[ln]) for ln in candidate_lengths}
|
||||
|
||||
level_data = build_level(n, wbl, rnd)
|
||||
|
||||
if level_data is None:
|
||||
stats_by_size[n]["failed"] += 1
|
||||
logger.warning(f" [{i+1}/{LEVELS_PER_SIZE}] размер {n}: не удалось сгенерировать")
|
||||
# level_number НЕ инкрементим — попробуем следующий seed.
|
||||
# Но чтобы не залипнуть, тоже увеличиваем счётчик.
|
||||
next_level_number += 1
|
||||
continue
|
||||
|
||||
# Сохраняем
|
||||
saved = await save_level(
|
||||
pool,
|
||||
next_level_number,
|
||||
level_data["size"],
|
||||
level_data["letters"],
|
||||
level_data["words"],
|
||||
translations,
|
||||
)
|
||||
|
||||
if saved:
|
||||
stats_by_size[n]["created"] += 1
|
||||
created_total += 1
|
||||
logger.info(
|
||||
f" [{i+1}/{LEVELS_PER_SIZE}] уровень #{next_level_number} "
|
||||
f"({n}×{n}) слов: {len(level_data['words'])}"
|
||||
)
|
||||
else:
|
||||
logger.warning(f" [{i+1}/{LEVELS_PER_SIZE}] уровень #{next_level_number} — конфликт, пропущен")
|
||||
|
||||
next_level_number += 1
|
||||
|
||||
# 5. Итоги
|
||||
logger.info("\n=== Итого ===")
|
||||
logger.info(f"Создано уровней всего: {created_total}")
|
||||
for n in GRID_SIZES:
|
||||
st = stats_by_size.get(n, {"created": 0, "failed": 0})
|
||||
logger.info(f" {n}×{n}: создано {st['created']}, не удалось {st['failed']}")
|
||||
logger.info(f"Следующий свободный level_number: {next_level_number}")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
asyncio.run(main())
|
||||
@@ -0,0 +1,64 @@
|
||||
"""
|
||||
Волновая структура филвордов.
|
||||
|
||||
Волна = 20 уровней (10 + 10). Волны бесконечные.
|
||||
|
||||
| Волна | Первые 10 | Следующие 10 |
|
||||
|-------|-----------|--------------|
|
||||
| 1 | 5×5 | 6×6 |
|
||||
| 2 | 5×5 | 6×6 |
|
||||
| 3 | 6×6 | 7×7 |
|
||||
| 4 | 6×6 | 7×7 |
|
||||
| 5+ | 7×7 | 8×8 |
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
|
||||
def wave_plan(wave: int) -> list[int]:
|
||||
"""Возвращает список из 20 размеров сетки для волны."""
|
||||
if wave in (1, 2):
|
||||
return [5] * 10 + [6] * 10
|
||||
if wave in (3, 4):
|
||||
return [6] * 10 + [7] * 10
|
||||
return [7] * 10 + [8] * 10
|
||||
|
||||
|
||||
def wave_for_level(global_level: int) -> int:
|
||||
"""Какая волна содержит этот глобальный уровень (1-based)."""
|
||||
if global_level < 1:
|
||||
return 1
|
||||
return (global_level - 1) // 20 + 1
|
||||
|
||||
|
||||
def level_in_wave(global_level: int) -> int:
|
||||
"""Позиция уровня внутри волны (1..20)."""
|
||||
return ((global_level - 1) % 20) + 1
|
||||
|
||||
|
||||
def grid_size_for(global_level: int) -> int:
|
||||
"""Размер сетки для глобального уровня."""
|
||||
wave = wave_for_level(global_level)
|
||||
pos = level_in_wave(global_level)
|
||||
plan = wave_plan(wave)
|
||||
return plan[pos - 1]
|
||||
|
||||
|
||||
def max_stars_for_wave() -> int:
|
||||
"""Максимум звёзд за волну (20 уровней × 5 звёзд)."""
|
||||
return 20 * 5
|
||||
|
||||
|
||||
def wave_medal(stars_earned: int) -> str:
|
||||
"""
|
||||
Медаль волны по доле звёзд.
|
||||
Пороги: gold >= 90%, silver >= 70%, bronze >= 50%, else 'none'.
|
||||
"""
|
||||
total = max_stars_for_wave()
|
||||
pct = stars_earned / total if total > 0 else 0
|
||||
if pct >= 0.90:
|
||||
return "gold"
|
||||
if pct >= 0.70:
|
||||
return "silver"
|
||||
if pct >= 0.50:
|
||||
return "bronze"
|
||||
return "none"
|
||||
+305
@@ -0,0 +1,305 @@
|
||||
"""
|
||||
XP-фундамент Pleily.
|
||||
|
||||
Единая точка начисления опыта:
|
||||
- RANKS — 48 званий × 4 языка
|
||||
- level_for(total_xp) → (level, xp_in_level, xp_needed, rank_key)
|
||||
- award_xp(conn, user_id, game, stars) → dict
|
||||
|
||||
XP-кривая (по решению от 08.10.2026):
|
||||
Ур.1 → нужно 1000 XP
|
||||
Ур.2 → нужно 1500 XP
|
||||
Ур.3 → нужно 2000 XP
|
||||
...
|
||||
Ур.N → нужно 1000 + (N-1) * 500
|
||||
Ур.47 → нужно 24000 XP (потолок, потом расширим до 100)
|
||||
|
||||
Множитель ×1.5: игра дня (определяется по Europe/Warsaw).
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import logging
|
||||
from datetime import datetime, timezone, timedelta
|
||||
from typing import Optional
|
||||
from zoneinfo import ZoneInfo
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
# ============ Константы ============
|
||||
|
||||
WARSAW_TZ = ZoneInfo("Europe/Warsaw")
|
||||
|
||||
# Игры по кругу (для featured)
|
||||
GAMES = ["wordsearch", "choose", "sentence", "bubbles"]
|
||||
|
||||
# Множитель игры дня
|
||||
FEATURED_MULTIPLIER = 1.5
|
||||
|
||||
# Базовая ставка: 1 звезда = 20 XP
|
||||
POINTS_PER_STAR = 20
|
||||
|
||||
# Максимум звёзд за уровень
|
||||
MAX_STARS = 5
|
||||
|
||||
# Минимум звёзд за пройденный уровень
|
||||
MIN_STARS = 1
|
||||
|
||||
# Коэффициенты баланса (настроить после первых 1000 сессий)
|
||||
# Применяются к base_points ДО множителя игры дня.
|
||||
GAME_XP_COEF: dict[str, float] = {
|
||||
"wordsearch": 1.0,
|
||||
"choose": 1.0,
|
||||
"sentence": 1.0,
|
||||
"bubbles": 1.0,
|
||||
}
|
||||
|
||||
# Максимальный уровень (потом расширим до 100)
|
||||
MAX_LEVEL = 47
|
||||
|
||||
|
||||
# ============ Звания (48 штук × 4 языка) ============
|
||||
|
||||
RANKS: list[dict] = [
|
||||
{"key": "rank_00", "pl": "Nowicjusz", "ru": "Новичок", "uk": "Новачок", "en": "Novice"},
|
||||
{"key": "rank_01", "pl": "Ciekawski", "ru": "Любопытный", "uk": "Допитливий", "en": "Curious"},
|
||||
{"key": "rank_02", "pl": "Uczeń", "ru": "Ученик", "uk": "Учень", "en": "Learner"},
|
||||
{"key": "rank_03", "pl": "Odkrywca", "ru": "Первооткрыватель", "uk": "Першовідкривач", "en": "Pioneer"},
|
||||
{"key": "rank_04", "pl": "Poszukiwacz", "ru": "Искатель", "uk": "Шукач", "en": "Seeker"},
|
||||
{"key": "rank_05", "pl": "Tropiciel", "ru": "Следопыт", "uk": "Слідопит", "en": "Pathfinder"},
|
||||
{"key": "rank_06", "pl": "Obserwator", "ru": "Наблюдатель", "uk": "Спостерігач", "en": "Observer"},
|
||||
{"key": "rank_07", "pl": "Czytelnik słów", "ru": "Читатель слов", "uk": "Читач слів", "en": "Word Reader"},
|
||||
{"key": "rank_08", "pl": "Rozmówca", "ru": "Собеседник", "uk": "Співрозмовник", "en": "Conversationalist"},
|
||||
{"key": "rank_09", "pl": "Praktyk", "ru": "Практик", "uk": "Практик", "en": "Practitioner"},
|
||||
{"key": "rank_10", "pl": "Gaduła", "ru": "Говорун", "uk": "Балакун", "en": "Chatterbox"},
|
||||
{"key": "rank_11", "pl": "Znawca liter", "ru": "Знаток букв", "uk": "Знавець літер", "en": "Letter Expert"},
|
||||
{"key": "rank_12", "pl": "Piśmienny", "ru": "Грамотей", "uk": "Грамотій", "en": "Literate"},
|
||||
{"key": "rank_13", "pl": "Badacz", "ru": "Исследователь", "uk": "Дослідник", "en": "Explorer"},
|
||||
{"key": "rank_14", "pl": "Podróżnik", "ru": "Путешественник", "uk": "Мандрівник", "en": "Traveler"},
|
||||
{"key": "rank_15", "pl": "Pewny siebie", "ru": "Уверенный", "uk": "Впевнений", "en": "Confident"},
|
||||
{"key": "rank_16", "pl": "Mól książkowy", "ru": "Книгочей", "uk": "Книголюб", "en": "Bookworm"},
|
||||
{"key": "rank_17", "pl": "Filolog", "ru": "Словесник", "uk": "Філолог", "en": "Wordsmith"},
|
||||
{"key": "rank_18", "pl": "Krasomówca", "ru": "Краснобай", "uk": "Красномовець", "en": "Smooth Talker"},
|
||||
{"key": "rank_19", "pl": "Znawca", "ru": "Знаток", "uk": "Знавець", "en": "Connoisseur"},
|
||||
{"key": "rank_20", "pl": "Mistrz podstaw", "ru": "Мастер азов", "uk": "Майстер основ", "en": "Master of Basics"},
|
||||
{"key": "rank_21", "pl": "Lingwista amator", "ru": "Лингвист-любитель", "uk": "Лінгвіст-аматор", "en": "Amateur Linguist"},
|
||||
{"key": "rank_22", "pl": "Tłumacz", "ru": "Переводчик", "uk": "Перекладач", "en": "Translator"},
|
||||
{"key": "rank_23", "pl": "Poliglota", "ru": "Полиглот", "uk": "Поліглот", "en": "Polyglot"},
|
||||
{"key": "rank_24", "pl": "Złotousty", "ru": "Златоуст", "uk": "Золотоустий", "en": "Golden Tongue"},
|
||||
{"key": "rank_25", "pl": "Mistrz słowa", "ru": "Мастер слов", "uk": "Майстер слова", "en": "Word Master"},
|
||||
{"key": "rank_26", "pl": "Ekspert", "ru": "Эксперт", "uk": "Експерт", "en": "Expert"},
|
||||
{"key": "rank_27", "pl": "Wirtuoz", "ru": "Виртуоз", "uk": "Віртуоз", "en": "Virtuoso"},
|
||||
{"key": "rank_28", "pl": "Mentor", "ru": "Наставник", "uk": "Наставник", "en": "Mentor"},
|
||||
{"key": "rank_29", "pl": "Mędrzec", "ru": "Мудрец", "uk": "Мудрець", "en": "Sage"},
|
||||
{"key": "rank_30", "pl": "Magister", "ru": "Магистр", "uk": "Магістр", "en": "Magister"},
|
||||
{"key": "rank_31", "pl": "Profesor", "ru": "Профессор", "uk": "Професор", "en": "Professor"},
|
||||
{"key": "rank_32", "pl": "Uczony", "ru": "Академик", "uk": "Академік", "en": "Academician"},
|
||||
{"key": "rank_33", "pl": "Arcymistrz", "ru": "Гроссмейстер", "uk": "Гросмейстер", "en": "Grandmaster"},
|
||||
{"key": "rank_34", "pl": "Strażnik słów", "ru": "Хранитель слов", "uk": "Хранитель слів", "en": "Keeper of Words"},
|
||||
{"key": "rank_35", "pl": "Wyrocznia", "ru": "Оракул", "uk": "Оракул", "en": "Oracle"},
|
||||
{"key": "rank_36", "pl": "Archiwista", "ru": "Архивариус", "uk": "Архіваріус", "en": "Archivist"},
|
||||
{"key": "rank_37", "pl": "Legenda", "ru": "Легенда", "uk": "Легенда", "en": "Legend"},
|
||||
{"key": "rank_38", "pl": "Tytan", "ru": "Титан", "uk": "Титан", "en": "Titan"},
|
||||
{"key": "rank_39", "pl": "Wielki Mistrz", "ru": "Великий мастер", "uk": "Великий майстер", "en": "Great Master"},
|
||||
{"key": "rank_40", "pl": "Patriarcha języka", "ru": "Патриарх языка", "uk": "Патріарх мови", "en": "Patriarch of Language"},
|
||||
{"key": "rank_41", "pl": "Gwiazda Pleily", "ru": "Звезда Pleily", "uk": "Зірка Pleily", "en": "Pleily Star"},
|
||||
{"key": "rank_42", "pl": "Supernowa", "ru": "Сверхновая", "uk": "Наднова", "en": "Supernova"},
|
||||
{"key": "rank_43", "pl": "Nieśmiertelny", "ru": "Бессмертный", "uk": "Безсмертний", "en": "Immortal"},
|
||||
{"key": "rank_44", "pl": "Najwyższy poliglota", "ru": "Верховный полиглот", "uk": "Верховний поліглот", "en": "Supreme Polyglot"},
|
||||
{"key": "rank_45", "pl": "Władca słów", "ru": "Повелитель слов", "uk": "Володар слів", "en": "Lord of Words"},
|
||||
{"key": "rank_46", "pl": "Żywa legenda", "ru": "Живая легенда", "uk": "Жива легенда", "en": "Living Legend"},
|
||||
{"key": "rank_47", "pl": "Wieczny poliglota", "ru": "Вечный полиглот", "uk": "Вічний поліглот", "en": "Eternal Polyglot"},
|
||||
]
|
||||
|
||||
# Быстрый доступ: rank_key → dict
|
||||
RANKS_BY_KEY: dict[str, dict] = {r["key"]: r for r in RANKS}
|
||||
|
||||
|
||||
# ============ Уровни ============
|
||||
|
||||
def xp_needed_for_level(level: int) -> int:
|
||||
"""Сколько XP нужно, чтобы перейти с уровня `level` на `level+1`."""
|
||||
return 1000 + (level - 1) * 500
|
||||
|
||||
|
||||
def level_for(total_xp: int) -> tuple[int, int, int, str]:
|
||||
"""
|
||||
Возвращает (level, xp_in_level, xp_needed_for_next, rank_key).
|
||||
|
||||
level — от 1 до MAX_LEVEL (47). Если XP больше, level=47, xp_in_level
|
||||
продолжает расти, но xp_needed фиксируется на 24000.
|
||||
"""
|
||||
if total_xp < 0:
|
||||
total_xp = 0
|
||||
|
||||
level = 1
|
||||
need = xp_needed_for_level(1)
|
||||
remaining = total_xp
|
||||
|
||||
while remaining >= need and level < MAX_LEVEL:
|
||||
remaining -= need
|
||||
level += 1
|
||||
need = xp_needed_for_level(level)
|
||||
|
||||
# rank_key — 0-based: level 1 → rank_00, level 2 → rank_01, ...
|
||||
rank_index = min(level - 1, len(RANKS) - 1)
|
||||
rank_key = RANKS[rank_index]["key"]
|
||||
|
||||
return level, remaining, need, rank_key
|
||||
|
||||
|
||||
def rank_for(level: int, lang: str = "ru") -> str:
|
||||
"""Название звания для уровня на языке lang."""
|
||||
idx = min(max(level - 1, 0), len(RANKS) - 1)
|
||||
rank = RANKS[idx]
|
||||
return rank.get(lang) or rank.get("en") or rank["key"]
|
||||
|
||||
|
||||
# ============ Игра дня ============
|
||||
|
||||
def featured_game(now: Optional[datetime] = None) -> str:
|
||||
"""
|
||||
Игра дня по кругу: wordsearch → choose → sentence → bubbles.
|
||||
Граница суток — Europe/Warsaw.
|
||||
"""
|
||||
if now is None:
|
||||
now = datetime.now(WARSAW_TZ)
|
||||
elif now.tzinfo is None:
|
||||
now = now.replace(tzinfo=WARSAW_TZ)
|
||||
else:
|
||||
now = now.astimezone(WARSAW_TZ)
|
||||
|
||||
return GAMES[now.date().toordinal() % 4]
|
||||
|
||||
|
||||
def featured_seconds_left(now: Optional[datetime] = None) -> int:
|
||||
"""Сколько секунд осталось до смены игры дня (до полуночи по Варшаве)."""
|
||||
if now is None:
|
||||
now = datetime.now(WARSAW_TZ)
|
||||
elif now.tzinfo is None:
|
||||
now = now.replace(tzinfo=WARSAW_TZ)
|
||||
else:
|
||||
now = now.astimezone(WARSAW_TZ)
|
||||
|
||||
tomorrow = (now + timedelta(days=1)).replace(
|
||||
hour=0, minute=0, second=0, microsecond=0
|
||||
)
|
||||
return int((tomorrow - now).total_seconds())
|
||||
|
||||
|
||||
# ============ Начисление XP ============
|
||||
|
||||
async def award_xp(
|
||||
conn,
|
||||
user_id: int,
|
||||
game: str,
|
||||
stars: int,
|
||||
) -> dict:
|
||||
"""
|
||||
Единая функция начисления опыта.
|
||||
|
||||
Args:
|
||||
conn: asyncpg connection (уже acquired)
|
||||
user_id: telegram_id (может быть отрицательным для Pleily)
|
||||
game: 'wordsearch' | 'choose' | 'sentence' | 'bubbles'
|
||||
stars: 1..5
|
||||
|
||||
Returns:
|
||||
{
|
||||
"stars": int,
|
||||
"base_points": int,
|
||||
"multiplier": float,
|
||||
"points": int,
|
||||
"featured": bool,
|
||||
"level_up": {"from": int, "to": int, "rank_key": str} | None,
|
||||
"total_xp": int, # после начисления
|
||||
"level": int, # после начисления
|
||||
"rank_key": str,
|
||||
"xp_in_level": int,
|
||||
"xp_needed": int,
|
||||
}
|
||||
"""
|
||||
# 1. Валидация
|
||||
stars = max(MIN_STARS, min(MAX_STARS, int(stars)))
|
||||
if game not in GAME_XP_COEF:
|
||||
raise ValueError(f"Unknown game: {game}")
|
||||
|
||||
# 2. База
|
||||
base = stars * POINTS_PER_STAR
|
||||
base = int(round(base * GAME_XP_COEF.get(game, 1.0)))
|
||||
|
||||
# 3. Множитель игры дня
|
||||
is_featured = (game == featured_game())
|
||||
multiplier = FEATURED_MULTIPLIER if is_featured else 1.0
|
||||
points = int(round(base * multiplier))
|
||||
|
||||
# 4. Читаем текущий total_xp
|
||||
row = await conn.fetchrow(
|
||||
"SELECT total_xp FROM user_profile WHERE user_id = $1",
|
||||
user_id,
|
||||
)
|
||||
if row is None:
|
||||
# Создаём профиль, если нет
|
||||
await conn.execute(
|
||||
"""
|
||||
INSERT INTO user_profile (user_id, total_xp, weekly_xp)
|
||||
VALUES ($1, 0, 0)
|
||||
ON CONFLICT (user_id) DO NOTHING
|
||||
""",
|
||||
user_id,
|
||||
)
|
||||
old_total = 0
|
||||
else:
|
||||
old_total = int(row["total_xp"] or 0)
|
||||
|
||||
old_level, _, _, _ = level_for(old_total)
|
||||
|
||||
# 5. Пишем в xp_log
|
||||
await conn.execute(
|
||||
"""
|
||||
INSERT INTO xp_log (user_id, game, stars, base_points, multiplier, points)
|
||||
VALUES ($1, $2, $3, $4, $5, $6)
|
||||
""",
|
||||
user_id, game, stars, base, multiplier, points,
|
||||
)
|
||||
|
||||
# 6. Обновляем user_profile
|
||||
new_total = old_total + points
|
||||
await conn.execute(
|
||||
"""
|
||||
UPDATE user_profile
|
||||
SET total_xp = total_xp + $2,
|
||||
weekly_xp = weekly_xp + $2,
|
||||
updated_at = NOW()
|
||||
WHERE user_id = $1
|
||||
""",
|
||||
user_id, points,
|
||||
)
|
||||
|
||||
# 7. Считаем новый уровень
|
||||
new_level, xp_in_level, xp_needed, rank_key = level_for(new_total)
|
||||
|
||||
level_up = None
|
||||
if new_level > old_level:
|
||||
level_up = {
|
||||
"from": old_level,
|
||||
"to": new_level,
|
||||
"rank_key": rank_key,
|
||||
}
|
||||
logger.info(
|
||||
"[xp] user=%s level_up %s → %s (%s), +%s xp",
|
||||
user_id, old_level, new_level, rank_key, points,
|
||||
)
|
||||
|
||||
return {
|
||||
"stars": stars,
|
||||
"base_points": base,
|
||||
"multiplier": multiplier,
|
||||
"points": points,
|
||||
"featured": is_featured,
|
||||
"level_up": level_up,
|
||||
"total_xp": new_total,
|
||||
"level": new_level,
|
||||
"rank_key": rank_key,
|
||||
"xp_in_level": xp_in_level,
|
||||
"xp_needed": xp_needed,
|
||||
}
|
||||
Reference in New Issue
Block a user