Compare commits
145
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
ccd733ba36 | ||
|
|
b7c6bd9ebe | ||
|
|
b25f27fcfe | ||
|
|
69224b546b | ||
|
|
d375a1e1ac | ||
|
|
739cda7eb8 | ||
|
|
8f96c61f29 | ||
|
|
96abab9883 | ||
|
|
689a2258c0 | ||
|
|
cc8e0e01f0 | ||
|
|
7d5e3a7d8f | ||
|
|
934e81a55a | ||
|
|
7e8c0e132e | ||
|
|
af3c634bfd | ||
|
|
7ddfc2e451 | ||
|
|
34bae9bb6a | ||
|
|
175691136e | ||
|
|
7f5fc8311c | ||
|
|
edf29cb806 | ||
|
|
279fc5f313 | ||
|
|
07eebf6fed | ||
|
|
c60f9a39c2 | ||
|
|
ced4cd1c8e | ||
|
|
25b1437e0b | ||
|
|
d77d9bdaef | ||
|
|
85a168e8d7 | ||
|
|
7204111ad6 | ||
|
|
214567383e | ||
|
|
3257b5da3b | ||
|
|
92780b247d | ||
|
|
eeb5a382c9 | ||
|
|
ab45d026dd | ||
|
|
b6a8783ad0 | ||
|
|
8918309501 | ||
|
|
1afc7a1654 | ||
|
|
5fc49d086d | ||
|
|
5a6b81da1d | ||
|
|
abc3a8ae7d | ||
|
|
7c43812475 | ||
|
|
3f7e7ef8d6 | ||
|
|
e7c512e50e | ||
|
|
0d6b56e5c9 | ||
|
|
4bbaa0030f | ||
|
|
99dd3765d0 | ||
|
|
929420a284 | ||
|
|
3c60cfed31 | ||
|
|
6399d3931c | ||
|
|
07d2d197fd | ||
|
|
1f7ac86ef5 | ||
|
|
16b8956b87 | ||
|
|
959b9c4e3f | ||
|
|
4355b94291 | ||
|
|
bd45071142 | ||
|
|
13fcc8240d | ||
|
|
118345f701 | ||
|
|
4159d6265a | ||
|
|
741d1799e7 | ||
|
|
5644b5be16 | ||
|
|
e65bd5db43 | ||
|
|
6786acb126 | ||
|
|
6fc8c83322 | ||
|
|
bffcb4387c | ||
|
|
01ce5dfa2d | ||
|
|
ec9108f2a3 | ||
|
|
938d674b09 | ||
|
|
556c11fc95 | ||
|
|
aa7679c49b | ||
|
|
9db00df88f | ||
|
|
4333aa62a6 | ||
|
|
bd743e4c48 | ||
|
|
f83fcc0e1c | ||
|
|
78d40364bf | ||
|
|
20b1cdc464 | ||
|
|
26442db954 | ||
|
|
e3bc3e8456 | ||
|
|
a6fe755fdb | ||
|
|
959f789f24 | ||
|
|
d181e43ee3 | ||
|
|
6f89336a02 | ||
|
|
f78a1fa19f | ||
|
|
2b5ef446c1 | ||
|
|
50c02b7707 | ||
|
|
6e02303ea8 | ||
|
|
22e4eed3f5 | ||
|
|
5e2de6f7e4 | ||
|
|
2dedec5972 | ||
|
|
8b98655716 | ||
|
|
da7182fb6b | ||
|
|
b62311d3ed | ||
|
|
6f341a7f33 | ||
|
|
981e65e57c | ||
|
|
9c975dde79 | ||
|
|
df3d32ecd5 | ||
|
|
437921d9dd | ||
|
|
bcc01a0fe8 | ||
|
|
5ee5614fdf | ||
|
|
8338d6b3c8 | ||
|
|
7efa54e455 | ||
|
|
6e4701aecd | ||
|
|
32a4a68f92 | ||
|
|
12c6bbca51 | ||
|
|
5983a4767e | ||
|
|
794daad69c | ||
|
|
154ae25772 | ||
|
|
5e9cd0c901 | ||
|
|
22decc1bc3 | ||
|
|
ea297b2179 | ||
|
|
1733b657b5 | ||
|
|
791adfeee9 | ||
|
|
8d6a9886e1 | ||
|
|
0a4c0c5d23 | ||
|
|
731aaccf28 | ||
|
|
11a1803b91 | ||
|
|
9a3bd6d7c6 | ||
|
|
77d822a777 | ||
|
|
c8ae20184b | ||
|
|
d30bd4956d | ||
|
|
0be17d54a0 | ||
|
|
1215a68eb3 | ||
|
|
a237572ba2 | ||
|
|
8d83022679 | ||
|
|
7969ff750a | ||
|
|
e86719b36d | ||
|
|
295cf1ebee | ||
|
|
735d9f51bc | ||
|
|
c2c7366445 | ||
|
|
ae63b61003 | ||
|
|
84927b063f | ||
|
|
a3f7d9521f | ||
|
|
5ed0de765d | ||
|
|
02b3eb7b40 | ||
|
|
b0308acb1f | ||
|
|
a730ef87f5 | ||
|
|
80b7f6b419 | ||
|
|
98ac403675 | ||
|
|
8c46a78aed | ||
|
|
75b10c536b | ||
|
|
daa79dd43e | ||
|
|
aebeaa833f | ||
|
|
0755533ae1 | ||
|
|
7bbce67cc4 | ||
|
|
6d0d1b5001 | ||
|
|
2d82d615c7 | ||
|
|
247eca55d1 | ||
|
|
7dbfcbe760 |
@@ -9,3 +9,6 @@ uploads/
|
|||||||
.DS_Store
|
.DS_Store
|
||||||
.env.save
|
.env.save
|
||||||
.env.*
|
.env.*
|
||||||
|
*.backup_*
|
||||||
|
*.sql
|
||||||
|
*.backup*
|
||||||
|
|||||||
+1
-2
@@ -10,9 +10,8 @@
|
|||||||
import asyncio
|
import asyncio
|
||||||
import asyncpg
|
import asyncpg
|
||||||
import json
|
import json
|
||||||
import os
|
|
||||||
import logging
|
import logging
|
||||||
from datetime import datetime, timedelta, timezone
|
from datetime import datetime
|
||||||
from decimal import Decimal
|
from decimal import Decimal
|
||||||
from pathlib import Path
|
from pathlib import Path
|
||||||
from config import DB_CONFIG
|
from config import DB_CONFIG
|
||||||
|
|||||||
@@ -89,15 +89,12 @@ async def verify_telegram_initdata(init_data: str):
|
|||||||
async def require_auth(request: Request):
|
async def require_auth(request: Request):
|
||||||
"""Извлекает и проверяет авторизацию из запроса.
|
"""Извлекает и проверяет авторизацию из запроса.
|
||||||
|
|
||||||
Два режима:
|
Пять режимов (в порядке приоритета):
|
||||||
1. X-Admin-Token: <jwt> — админка через браузер (26.09.2026)
|
1. X-Admin-Token: <jwt> — админка через браузер (26.09.2026)
|
||||||
2. Authorization: tma <initData> — Telegram Mini App
|
2. Authorization: Bearer <jwt> — Pleily (07.10.2026)
|
||||||
|
3. Authorization: tma <initData> — Telegram Mini App
|
||||||
Приоритет:
|
4. X-Telegram-InitData — старый способ
|
||||||
1. X-Admin-Token — если есть, проверяем JWT.
|
5. query-параметр initData — fallback для deleteFeedPost
|
||||||
2. Authorization: tma <initData> — основной для Mini App.
|
|
||||||
3. X-Telegram-InitData — старый способ.
|
|
||||||
4. query-параметр initData — fallback для deleteFeedPost.
|
|
||||||
"""
|
"""
|
||||||
# ============ Режим 1: админ-токен ============
|
# ============ Режим 1: админ-токен ============
|
||||||
admin_token = request.headers.get('X-Admin-Token', '').strip()
|
admin_token = request.headers.get('X-Admin-Token', '').strip()
|
||||||
@@ -112,19 +109,30 @@ async def require_auth(request: Request):
|
|||||||
logger.warning(f"Admin token invalid: {e}")
|
logger.warning(f"Admin token invalid: {e}")
|
||||||
raise HTTPException(401, "Invalid admin token")
|
raise HTTPException(401, "Invalid admin token")
|
||||||
|
|
||||||
# ============ Режим 2: Telegram initData ============
|
# ============ Режим 2: Bearer JWT (Pleily) ============
|
||||||
|
# 🔧 НОВОЕ (07.10.2026): app_jwt_auth —
|
||||||
|
# мобильное приложение Pleily ходит с Authorization: Bearer <JWT>.
|
||||||
|
# verify_app_jwt возвращает payload с user_id (отрицательный для Pleily).
|
||||||
|
auth_header = request.headers.get('Authorization', '')
|
||||||
|
if auth_header.startswith('Bearer '):
|
||||||
|
from routers.app_auth import verify_app_jwt
|
||||||
|
token = auth_header[7:].strip()
|
||||||
|
payload = verify_app_jwt(token)
|
||||||
|
user_id = int(payload.get('user_id'))
|
||||||
|
return user_id, f"app_{user_id}"
|
||||||
|
|
||||||
|
# ============ Режим 3: Telegram initData ============
|
||||||
init_data = ''
|
init_data = ''
|
||||||
|
|
||||||
# 2.1. Authorization: tma <initData>
|
# 3.1. Authorization: tma <initData>
|
||||||
auth_header = request.headers.get('Authorization', '')
|
|
||||||
if auth_header.startswith('tma '):
|
if auth_header.startswith('tma '):
|
||||||
init_data = auth_header[4:].strip()
|
init_data = auth_header[4:].strip()
|
||||||
|
|
||||||
# 2.2. X-Telegram-InitData (старый способ)
|
# 3.2. X-Telegram-InitData (старый способ)
|
||||||
if not init_data:
|
if not init_data:
|
||||||
init_data = request.headers.get('X-Telegram-InitData', '')
|
init_data = request.headers.get('X-Telegram-InitData', '')
|
||||||
|
|
||||||
# 2.3. Query-параметр (fallback, нужен для deleteFeedPost)
|
# 3.3. Query-параметр (fallback, нужен для deleteFeedPost)
|
||||||
if not init_data:
|
if not init_data:
|
||||||
init_data = request.query_params.get('initData', '')
|
init_data = request.query_params.get('initData', '')
|
||||||
|
|
||||||
|
|||||||
@@ -93,4 +93,7 @@ FEED_TARGET_LANGUAGES = ["pl", "ru", "uk", "en"]
|
|||||||
# Логин/пароль для входа в админку через браузер.
|
# Логин/пароль для входа в админку через браузер.
|
||||||
ADMIN_LOGIN = os.getenv("ADMIN_LOGIN", "admin")
|
ADMIN_LOGIN = os.getenv("ADMIN_LOGIN", "admin")
|
||||||
ADMIN_PASSWORD_HASH = os.getenv("ADMIN_PASSWORD_HASH", "")
|
ADMIN_PASSWORD_HASH = os.getenv("ADMIN_PASSWORD_HASH", "")
|
||||||
ADMIN_JWT_SECRET = os.getenv("ADMIN_JWT_SECRET", "")
|
ADMIN_JWT_SECRET = os.getenv("ADMIN_JWT_SECRET", "")
|
||||||
|
|
||||||
|
# 🔧 НОВОЕ (07.10.2026): app_jwt_secret — JWT для Pleily
|
||||||
|
APP_JWT_SECRET = os.getenv("APP_JWT_SECRET", "")
|
||||||
+577
@@ -38,6 +38,43 @@ async def init_db():
|
|||||||
)
|
)
|
||||||
""")
|
""")
|
||||||
|
|
||||||
|
# 🔧 ФИКС (30.09.2026): last_completed_by_level —
|
||||||
|
# per-level счётчик прогресса. Раньше был один last_completed_level,
|
||||||
|
# который смешивал A1+A2+B1 → юзер не мог открыть уровень выше max.
|
||||||
|
col_exists = await conn.fetchval("""
|
||||||
|
SELECT 1 FROM information_schema.columns
|
||||||
|
WHERE table_name = 'users' AND column_name = 'last_completed_by_level'
|
||||||
|
""")
|
||||||
|
if not col_exists:
|
||||||
|
await conn.execute("""
|
||||||
|
ALTER TABLE users ADD COLUMN last_completed_by_level JSONB DEFAULT '{}'::jsonb
|
||||||
|
""")
|
||||||
|
logger.info("Added last_completed_by_level column to users")
|
||||||
|
|
||||||
|
# Backfill из user_progress
|
||||||
|
await conn.execute("""
|
||||||
|
UPDATE users u
|
||||||
|
SET last_completed_by_level = COALESCE(sub.by_level, '{}'::jsonb)
|
||||||
|
FROM (
|
||||||
|
SELECT
|
||||||
|
user_id,
|
||||||
|
jsonb_object_agg(level, max_num) AS by_level
|
||||||
|
FROM (
|
||||||
|
SELECT
|
||||||
|
up.user_id,
|
||||||
|
up.level,
|
||||||
|
MAX(l.level_number) AS max_num
|
||||||
|
FROM user_progress up
|
||||||
|
JOIN levels l ON l.id = up.level_id
|
||||||
|
WHERE up.completed_at IS NOT NULL
|
||||||
|
GROUP BY up.user_id, up.level
|
||||||
|
) inner_sub
|
||||||
|
GROUP BY user_id
|
||||||
|
) sub
|
||||||
|
WHERE u.telegram_id = sub.user_id
|
||||||
|
""")
|
||||||
|
logger.info("Backfilled last_completed_by_level from user_progress")
|
||||||
|
|
||||||
# ============ Авто-миграция: добавляем current_level в users ============
|
# ============ Авто-миграция: добавляем current_level в users ============
|
||||||
col_exists = await conn.fetchval("""
|
col_exists = await conn.fetchval("""
|
||||||
SELECT 1 FROM information_schema.columns
|
SELECT 1 FROM information_schema.columns
|
||||||
@@ -192,6 +229,21 @@ async def init_db():
|
|||||||
""")
|
""")
|
||||||
logger.info("Added current_streak column to user_progress")
|
logger.info("Added current_streak column to user_progress")
|
||||||
|
|
||||||
|
# ============ Авто-миграция: добавляем wave в user_progress ============
|
||||||
|
# 🔧 НОВОЕ (13.10.2026): wave — номер волны, к которой относится
|
||||||
|
# пройденный уровень. Нужен для подсчёта wave_points (сумма очков
|
||||||
|
# за 10 уровней волны) в модалке итогов волны.
|
||||||
|
col_exists = await conn.fetchval("""
|
||||||
|
SELECT 1 FROM information_schema.columns
|
||||||
|
WHERE table_name = 'user_progress' AND column_name = 'wave'
|
||||||
|
""")
|
||||||
|
if not col_exists:
|
||||||
|
await conn.execute("""
|
||||||
|
ALTER TABLE user_progress
|
||||||
|
ADD COLUMN wave INTEGER
|
||||||
|
""")
|
||||||
|
logger.info("Added wave column to user_progress")
|
||||||
|
|
||||||
# ============ sentences ============
|
# ============ sentences ============
|
||||||
await conn.execute("""
|
await conn.execute("""
|
||||||
CREATE TABLE IF NOT EXISTS sentences (
|
CREATE TABLE IF NOT EXISTS sentences (
|
||||||
@@ -305,12 +357,17 @@ async def init_db():
|
|||||||
""")
|
""")
|
||||||
|
|
||||||
# ============ learning_topics ============
|
# ============ learning_topics ============
|
||||||
|
# 🔧 ОБНОВЛЕНО (04.10.2026): track — разделение аудиторий.
|
||||||
|
# 'pl' — для поляков (учёба на польском)
|
||||||
|
# 'ru_uk' — для славян (RU/UK ↔ PL, ОБЩИЙ track)
|
||||||
|
# 'en' — для англоязычных
|
||||||
await conn.execute("""
|
await conn.execute("""
|
||||||
CREATE TABLE IF NOT EXISTS learning_topics (
|
CREATE TABLE IF NOT EXISTS learning_topics (
|
||||||
id SERIAL PRIMARY KEY,
|
id SERIAL PRIMARY KEY,
|
||||||
topic_id VARCHAR(100) UNIQUE NOT NULL,
|
topic_id VARCHAR(100) UNIQUE NOT NULL,
|
||||||
level_code VARCHAR(10) NOT NULL,
|
level_code VARCHAR(10) NOT NULL,
|
||||||
order_number INT NOT NULL,
|
order_number INT NOT NULL,
|
||||||
|
track VARCHAR(10) NOT NULL DEFAULT 'ru_uk', -- 🔧 НОВОЕ
|
||||||
name_pl TEXT NOT NULL,
|
name_pl TEXT NOT NULL,
|
||||||
name_ru TEXT NOT NULL,
|
name_ru TEXT NOT NULL,
|
||||||
name_uk TEXT NOT NULL,
|
name_uk TEXT NOT NULL,
|
||||||
@@ -324,6 +381,27 @@ async def init_db():
|
|||||||
)
|
)
|
||||||
""")
|
""")
|
||||||
|
|
||||||
|
# 🔧 НОВОЕ (04.10.2026): track_auto_migration —
|
||||||
|
# для существующих БД добавляем колонку, если её нет.
|
||||||
|
col_exists = await conn.fetchval("""
|
||||||
|
SELECT 1 FROM information_schema.columns
|
||||||
|
WHERE table_name = 'learning_topics' AND column_name = 'track'
|
||||||
|
""")
|
||||||
|
if not col_exists:
|
||||||
|
await conn.execute("""
|
||||||
|
ALTER TABLE learning_topics
|
||||||
|
ADD COLUMN track VARCHAR(10) NOT NULL DEFAULT 'ru_uk'
|
||||||
|
""")
|
||||||
|
logger.info("Added track column to learning_topics")
|
||||||
|
|
||||||
|
# Backfill: все существующие темы → 'ru_uk' (славянский track)
|
||||||
|
await conn.execute("""
|
||||||
|
UPDATE learning_topics
|
||||||
|
SET track = 'ru_uk'
|
||||||
|
WHERE track IS NULL OR track = ''
|
||||||
|
""")
|
||||||
|
logger.info("Backfilled track='ru_uk' for existing topics")
|
||||||
|
|
||||||
# ============ learning_lessons ============
|
# ============ learning_lessons ============
|
||||||
await conn.execute("""
|
await conn.execute("""
|
||||||
CREATE TABLE IF NOT EXISTS learning_lessons (
|
CREATE TABLE IF NOT EXISTS learning_lessons (
|
||||||
@@ -430,6 +508,8 @@ async def init_db():
|
|||||||
""")
|
""")
|
||||||
|
|
||||||
# ============ user_learning_answers ============
|
# ============ user_learning_answers ============
|
||||||
|
# 🔧 ОБНОВЛЕНО (02.10.2026): добавлены revised и revision_of_id
|
||||||
|
# прямо в определение — на свежих БД создаются сразу.
|
||||||
await conn.execute("""
|
await conn.execute("""
|
||||||
CREATE TABLE IF NOT EXISTS user_learning_answers (
|
CREATE TABLE IF NOT EXISTS user_learning_answers (
|
||||||
id BIGSERIAL PRIMARY KEY,
|
id BIGSERIAL PRIMARY KEY,
|
||||||
@@ -450,10 +530,46 @@ async def init_db():
|
|||||||
hint_used BOOLEAN DEFAULT FALSE,
|
hint_used BOOLEAN DEFAULT FALSE,
|
||||||
wrong_because VARCHAR(100),
|
wrong_because VARCHAR(100),
|
||||||
is_final_answer BOOLEAN DEFAULT TRUE,
|
is_final_answer BOOLEAN DEFAULT TRUE,
|
||||||
|
revised BOOLEAN DEFAULT FALSE, -- 🔧 НОВОЕ
|
||||||
|
revision_of_id BIGINT, -- 🔧 НОВОЕ
|
||||||
created_at TIMESTAMP DEFAULT NOW()
|
created_at TIMESTAMP DEFAULT NOW()
|
||||||
)
|
)
|
||||||
""")
|
""")
|
||||||
|
|
||||||
|
# 🔧 НОВОЕ (02.10.2026): revised — фиксируем, что ученик
|
||||||
|
# поменял ответ после «Повторить урок».
|
||||||
|
col_exists = await conn.fetchval("""
|
||||||
|
SELECT 1 FROM information_schema.columns
|
||||||
|
WHERE table_name = 'user_learning_answers' AND column_name = 'revised'
|
||||||
|
""")
|
||||||
|
if not col_exists:
|
||||||
|
await conn.execute("""
|
||||||
|
ALTER TABLE user_learning_answers
|
||||||
|
ADD COLUMN revised BOOLEAN DEFAULT FALSE
|
||||||
|
""")
|
||||||
|
logger.info("Added revised column to user_learning_answers")
|
||||||
|
|
||||||
|
# 🔧 НОВОЕ (02.10.2026): revision_of_id — ссылка на предыдущий
|
||||||
|
# ответ этого же вопроса в этой же сессии. Позволяет строить
|
||||||
|
# цепочку: первый ответ → второй (после повтора) → третий.
|
||||||
|
col_exists = await conn.fetchval("""
|
||||||
|
SELECT 1 FROM information_schema.columns
|
||||||
|
WHERE table_name = 'user_learning_answers' AND column_name = 'revision_of_id'
|
||||||
|
""")
|
||||||
|
if not col_exists:
|
||||||
|
await conn.execute("""
|
||||||
|
ALTER TABLE user_learning_answers
|
||||||
|
ADD COLUMN revision_of_id BIGINT
|
||||||
|
""")
|
||||||
|
logger.info("Added revision_of_id column to user_learning_answers")
|
||||||
|
|
||||||
|
# Индекс для быстрого поиска цепочек повторов
|
||||||
|
await conn.execute("""
|
||||||
|
CREATE INDEX IF NOT EXISTS idx_learning_answers_revision
|
||||||
|
ON user_learning_answers(revision_of_id)
|
||||||
|
WHERE revision_of_id IS NOT NULL
|
||||||
|
""")
|
||||||
|
|
||||||
# ============ user_lesson_progress ============
|
# ============ user_lesson_progress ============
|
||||||
await conn.execute("""
|
await conn.execute("""
|
||||||
CREATE TABLE IF NOT EXISTS user_lesson_progress (
|
CREATE TABLE IF NOT EXISTS user_lesson_progress (
|
||||||
@@ -747,6 +863,20 @@ async def init_db():
|
|||||||
""")
|
""")
|
||||||
logger.info("Added current_mistakes column to word_quiz_progress")
|
logger.info("Added current_mistakes column to word_quiz_progress")
|
||||||
|
|
||||||
|
# 🔧 НОВОЕ (15.10.2026): no_mistakes_streak — серия раундов без ошибок
|
||||||
|
# в «Выбери слово». +1 если раунд пройден без ошибок, иначе сброс в 0.
|
||||||
|
# Нужен для достижения quiz_no_mistakes_streak.
|
||||||
|
col_exists = await conn.fetchval("""
|
||||||
|
SELECT 1 FROM information_schema.columns
|
||||||
|
WHERE table_name = 'word_quiz_progress' AND column_name = 'no_mistakes_streak'
|
||||||
|
""")
|
||||||
|
if not col_exists:
|
||||||
|
await conn.execute("""
|
||||||
|
ALTER TABLE word_quiz_progress
|
||||||
|
ADD COLUMN no_mistakes_streak INTEGER DEFAULT 0
|
||||||
|
""")
|
||||||
|
logger.info("Added no_mistakes_streak column to word_quiz_progress")
|
||||||
|
|
||||||
# ============ bubble_words_progress ============
|
# ============ bubble_words_progress ============
|
||||||
await conn.execute("""
|
await conn.execute("""
|
||||||
CREATE TABLE IF NOT EXISTS bubble_words_progress (
|
CREATE TABLE IF NOT EXISTS bubble_words_progress (
|
||||||
@@ -782,6 +912,87 @@ async def init_db():
|
|||||||
""")
|
""")
|
||||||
logger.info("Added current_hints_used column to bubble_words_progress")
|
logger.info("Added current_hints_used column to bubble_words_progress")
|
||||||
|
|
||||||
|
# 🔧 НОВОЕ (14.10.2026): current_list_opened — серверный счётчик
|
||||||
|
# «показать слова» для текущего уровня пузырей. Medium — 1 раз.
|
||||||
|
col_exists = await conn.fetchval("""
|
||||||
|
SELECT 1 FROM information_schema.columns
|
||||||
|
WHERE table_name = 'bubble_words_progress' AND column_name = 'current_list_opened'
|
||||||
|
""")
|
||||||
|
if not col_exists:
|
||||||
|
await conn.execute("""
|
||||||
|
ALTER TABLE bubble_words_progress
|
||||||
|
ADD COLUMN current_list_opened INT DEFAULT 0
|
||||||
|
""")
|
||||||
|
logger.info("Added current_list_opened column to bubble_words_progress")
|
||||||
|
|
||||||
|
# 🔧 НОВОЕ (14.10.2026): current_level_words — состояние текущего
|
||||||
|
# уровня пузырей (слова + части + переводы). Нужно для подсказок,
|
||||||
|
# т.к. уровень генерируется на лету в /next и нигде не хранится.
|
||||||
|
col_exists = await conn.fetchval("""
|
||||||
|
SELECT 1 FROM information_schema.columns
|
||||||
|
WHERE table_name = 'bubble_words_progress' AND column_name = 'current_level_words'
|
||||||
|
""")
|
||||||
|
if not col_exists:
|
||||||
|
await conn.execute("""
|
||||||
|
ALTER TABLE bubble_words_progress
|
||||||
|
ADD COLUMN current_level_words JSONB DEFAULT '[]'::jsonb
|
||||||
|
""")
|
||||||
|
logger.info("Added current_level_words column to bubble_words_progress")
|
||||||
|
|
||||||
|
# 🔧 НОВОЕ (14.10.2026): hinted_words — какие слова уже получили
|
||||||
|
# подсказку «первая часть» (для «каждый раз разное слово»).
|
||||||
|
col_exists = await conn.fetchval("""
|
||||||
|
SELECT 1 FROM information_schema.columns
|
||||||
|
WHERE table_name = 'bubble_words_progress' AND column_name = 'hinted_words'
|
||||||
|
""")
|
||||||
|
if not col_exists:
|
||||||
|
await conn.execute("""
|
||||||
|
ALTER TABLE bubble_words_progress
|
||||||
|
ADD COLUMN hinted_words TEXT[] DEFAULT '{}'
|
||||||
|
""")
|
||||||
|
logger.info("Added hinted_words column to bubble_words_progress")
|
||||||
|
|
||||||
|
# 🔧 НОВОЕ (15.10.2026): words_collected — суммарно собранных слов
|
||||||
|
# в пузырях. Нужен для достижения bubble_words (собрать N слов).
|
||||||
|
col_exists = await conn.fetchval("""
|
||||||
|
SELECT 1 FROM information_schema.columns
|
||||||
|
WHERE table_name = 'bubble_words_progress' AND column_name = 'words_collected'
|
||||||
|
""")
|
||||||
|
if not col_exists:
|
||||||
|
await conn.execute("""
|
||||||
|
ALTER TABLE bubble_words_progress
|
||||||
|
ADD COLUMN words_collected INTEGER DEFAULT 0
|
||||||
|
""")
|
||||||
|
logger.info("Added words_collected column to bubble_words_progress")
|
||||||
|
|
||||||
|
# 🔧 НОВОЕ (15.10.2026): no_hints_streak — серия уровней БЕЗ подсказок
|
||||||
|
# и без «показать слова». +1 если hints_used == 0 и not list_opened,
|
||||||
|
# иначе сброс в 0. Нужен для достижения bubble_streak.
|
||||||
|
col_exists = await conn.fetchval("""
|
||||||
|
SELECT 1 FROM information_schema.columns
|
||||||
|
WHERE table_name = 'bubble_words_progress' AND column_name = 'no_hints_streak'
|
||||||
|
""")
|
||||||
|
if not col_exists:
|
||||||
|
await conn.execute("""
|
||||||
|
ALTER TABLE bubble_words_progress
|
||||||
|
ADD COLUMN no_hints_streak INTEGER DEFAULT 0
|
||||||
|
""")
|
||||||
|
logger.info("Added no_hints_streak column to bubble_words_progress")
|
||||||
|
|
||||||
|
# 🔧 НОВОЕ (15.10.2026): perfect_streak — серия идеальных уровней
|
||||||
|
# (без подсказок + без списка + без ошибок). +1 если всё чисто,
|
||||||
|
# иначе сброс в 0. Нужен для достижения bubble_perfect_streak.
|
||||||
|
col_exists = await conn.fetchval("""
|
||||||
|
SELECT 1 FROM information_schema.columns
|
||||||
|
WHERE table_name = 'bubble_words_progress' AND column_name = 'perfect_streak'
|
||||||
|
""")
|
||||||
|
if not col_exists:
|
||||||
|
await conn.execute("""
|
||||||
|
ALTER TABLE bubble_words_progress
|
||||||
|
ADD COLUMN perfect_streak INTEGER DEFAULT 0
|
||||||
|
""")
|
||||||
|
logger.info("Added perfect_streak column to bubble_words_progress")
|
||||||
|
|
||||||
# ============ wrong_because_explanations ============
|
# ============ wrong_because_explanations ============
|
||||||
await conn.execute("""
|
await conn.execute("""
|
||||||
CREATE TABLE IF NOT EXISTS wrong_because_explanations (
|
CREATE TABLE IF NOT EXISTS wrong_because_explanations (
|
||||||
@@ -1068,6 +1279,372 @@ async def init_db():
|
|||||||
await conn.execute("CREATE INDEX IF NOT EXISTS idx_levels_level_number ON levels(level, level_number)")
|
await conn.execute("CREATE INDEX IF NOT EXISTS idx_levels_level_number ON levels(level, level_number)")
|
||||||
await conn.execute("CREATE INDEX IF NOT EXISTS idx_level_words_level_id ON level_words(level_id)")
|
await conn.execute("CREATE INDEX IF NOT EXISTS idx_level_words_level_id ON level_words(level_id)")
|
||||||
await conn.execute("CREATE INDEX IF NOT EXISTS idx_level_words_level ON level_words(level)")
|
await conn.execute("CREATE INDEX IF NOT EXISTS idx_level_words_level ON level_words(level)")
|
||||||
|
|
||||||
|
# ============ Авто-миграция: wordsearch builder (29.09.2026) ============
|
||||||
|
# is_active — черновик (FALSE) / опубликован (TRUE)
|
||||||
|
# created_by — telegram_id админа, создавшего вручную
|
||||||
|
# created_at — когда создан
|
||||||
|
col_exists = await conn.fetchval("""
|
||||||
|
SELECT 1 FROM information_schema.columns
|
||||||
|
WHERE table_name = 'levels' AND column_name = 'is_active'
|
||||||
|
""")
|
||||||
|
if not col_exists:
|
||||||
|
await conn.execute("""
|
||||||
|
ALTER TABLE levels ADD COLUMN is_active BOOLEAN DEFAULT TRUE
|
||||||
|
""")
|
||||||
|
logger.info("Added is_active column to levels")
|
||||||
|
|
||||||
|
col_exists = await conn.fetchval("""
|
||||||
|
SELECT 1 FROM information_schema.columns
|
||||||
|
WHERE table_name = 'levels' AND column_name = 'created_by'
|
||||||
|
""")
|
||||||
|
if not col_exists:
|
||||||
|
await conn.execute("""
|
||||||
|
ALTER TABLE levels ADD COLUMN created_by BIGINT
|
||||||
|
""")
|
||||||
|
logger.info("Added created_by column to levels")
|
||||||
|
|
||||||
|
col_exists = await conn.fetchval("""
|
||||||
|
SELECT 1 FROM information_schema.columns
|
||||||
|
WHERE table_name = 'levels' AND column_name = 'created_at'
|
||||||
|
""")
|
||||||
|
if not col_exists:
|
||||||
|
await conn.execute("""
|
||||||
|
ALTER TABLE levels ADD COLUMN created_at TIMESTAMP DEFAULT NOW()
|
||||||
|
""")
|
||||||
|
logger.info("Added created_at column to levels")
|
||||||
|
|
||||||
|
# Индекс для быстрого поиска опубликованных ручных уровней
|
||||||
|
await conn.execute("""
|
||||||
|
CREATE INDEX IF NOT EXISTS idx_levels_active_manual
|
||||||
|
ON levels(level, is_active, created_by)
|
||||||
|
WHERE is_active = TRUE AND created_by IS NOT NULL
|
||||||
|
""")
|
||||||
|
|
||||||
|
# ============ csv_words — слова из CSV для конструктора ============
|
||||||
|
await conn.execute("""
|
||||||
|
CREATE TABLE IF NOT EXISTS csv_words (
|
||||||
|
id SERIAL PRIMARY KEY,
|
||||||
|
level_code VARCHAR(10) NOT NULL,
|
||||||
|
word_pl TEXT NOT NULL,
|
||||||
|
translation_ru TEXT DEFAULT '',
|
||||||
|
translation_uk TEXT DEFAULT '',
|
||||||
|
translation_en TEXT DEFAULT '',
|
||||||
|
UNIQUE(level_code, word_pl)
|
||||||
|
)
|
||||||
|
""")
|
||||||
|
await conn.execute("""
|
||||||
|
CREATE INDEX IF NOT EXISTS idx_csv_words_level
|
||||||
|
ON csv_words(level_code)
|
||||||
|
""")
|
||||||
|
logger.info("Table csv_words initialized")
|
||||||
|
|
||||||
|
# ============ word_usage — счётчик использований слов ============
|
||||||
|
await conn.execute("""
|
||||||
|
CREATE TABLE IF NOT EXISTS word_usage (
|
||||||
|
id SERIAL PRIMARY KEY,
|
||||||
|
level_code VARCHAR(10) NOT NULL,
|
||||||
|
word_pl TEXT NOT NULL,
|
||||||
|
usage_count INT DEFAULT 0,
|
||||||
|
last_used_at TIMESTAMP DEFAULT NOW(),
|
||||||
|
UNIQUE(level_code, word_pl)
|
||||||
|
)
|
||||||
|
""")
|
||||||
|
await conn.execute("""
|
||||||
|
CREATE INDEX IF NOT EXISTS idx_word_usage_level_word
|
||||||
|
ON word_usage(level_code, word_pl)
|
||||||
|
""")
|
||||||
|
logger.info("Table word_usage initialized")
|
||||||
|
|
||||||
|
# ============ 🔧 НОВОЕ (07.10.2026): pleily_auth —
|
||||||
|
# поддержка авторизации мобильного приложения Pleily.
|
||||||
|
# - source: откуда пришёл юзер ('telegram' | 'pleily_device' | 'pleily_apple')
|
||||||
|
# - device_id: UUID устройства (анонимный вход)
|
||||||
|
# - apple_id: Apple ID (потом, для привязки прогресса)
|
||||||
|
# - app_user_id_seq: sequence для отрицательных user_id (Pleily-юзеры)
|
||||||
|
# - auth_identities: связка provider+provider_uid → user_id
|
||||||
|
# ============================================================
|
||||||
|
|
||||||
|
# source
|
||||||
|
col_exists = await conn.fetchval("""
|
||||||
|
SELECT 1 FROM information_schema.columns
|
||||||
|
WHERE table_name = 'users' AND column_name = 'source'
|
||||||
|
""")
|
||||||
|
if not col_exists:
|
||||||
|
await conn.execute("""
|
||||||
|
ALTER TABLE users ADD COLUMN source TEXT DEFAULT 'telegram'
|
||||||
|
""")
|
||||||
|
await conn.execute("""
|
||||||
|
UPDATE users SET source = 'telegram' WHERE source IS NULL
|
||||||
|
""")
|
||||||
|
logger.info("Added source column to users (Pleily)")
|
||||||
|
|
||||||
|
# device_id
|
||||||
|
col_exists = await conn.fetchval("""
|
||||||
|
SELECT 1 FROM information_schema.columns
|
||||||
|
WHERE table_name = 'users' AND column_name = 'device_id'
|
||||||
|
""")
|
||||||
|
if not col_exists:
|
||||||
|
await conn.execute("""
|
||||||
|
ALTER TABLE users ADD COLUMN device_id UUID
|
||||||
|
""")
|
||||||
|
await conn.execute("""
|
||||||
|
CREATE UNIQUE INDEX IF NOT EXISTS idx_users_device_id
|
||||||
|
ON users(device_id) WHERE device_id IS NOT NULL
|
||||||
|
""")
|
||||||
|
logger.info("Added device_id column to users (Pleily)")
|
||||||
|
|
||||||
|
# apple_id
|
||||||
|
col_exists = await conn.fetchval("""
|
||||||
|
SELECT 1 FROM information_schema.columns
|
||||||
|
WHERE table_name = 'users' AND column_name = 'apple_id'
|
||||||
|
""")
|
||||||
|
if not col_exists:
|
||||||
|
await conn.execute("""
|
||||||
|
ALTER TABLE users ADD COLUMN apple_id TEXT
|
||||||
|
""")
|
||||||
|
await conn.execute("""
|
||||||
|
CREATE UNIQUE INDEX IF NOT EXISTS idx_users_apple_id
|
||||||
|
ON users(apple_id) WHERE apple_id IS NOT NULL
|
||||||
|
""")
|
||||||
|
logger.info("Added apple_id column to users (Pleily)")
|
||||||
|
|
||||||
|
# difficulty
|
||||||
|
col_exists = await conn.fetchval("""
|
||||||
|
SELECT 1 FROM information_schema.columns
|
||||||
|
WHERE table_name = 'users' AND column_name = 'difficulty'
|
||||||
|
""")
|
||||||
|
if not col_exists:
|
||||||
|
await conn.execute("""
|
||||||
|
ALTER TABLE users ADD COLUMN difficulty TEXT DEFAULT 'medium'
|
||||||
|
""")
|
||||||
|
logger.info("Added difficulty column to users (Pleily)")
|
||||||
|
|
||||||
|
# app_user_id_seq — sequence для отрицательных user_id
|
||||||
|
await conn.execute("""
|
||||||
|
CREATE SEQUENCE IF NOT EXISTS app_user_id_seq
|
||||||
|
START -1
|
||||||
|
INCREMENT -1
|
||||||
|
MINVALUE -9223372036854775808
|
||||||
|
MAXVALUE -1
|
||||||
|
""")
|
||||||
|
logger.info("Table app_user_id_seq initialized (Pleily)")
|
||||||
|
|
||||||
|
# auth_identities — связка provider+provider_uid → user_id
|
||||||
|
await conn.execute("""
|
||||||
|
CREATE TABLE IF NOT EXISTS auth_identities (
|
||||||
|
id BIGSERIAL PRIMARY KEY,
|
||||||
|
user_id BIGINT NOT NULL REFERENCES users(telegram_id) ON DELETE CASCADE,
|
||||||
|
provider TEXT NOT NULL,
|
||||||
|
provider_uid TEXT NOT NULL,
|
||||||
|
created_at TIMESTAMP DEFAULT NOW(),
|
||||||
|
UNIQUE(provider, provider_uid)
|
||||||
|
)
|
||||||
|
""")
|
||||||
|
await conn.execute("""
|
||||||
|
CREATE INDEX IF NOT EXISTS idx_auth_identities_user
|
||||||
|
ON auth_identities(user_id)
|
||||||
|
""")
|
||||||
|
|
||||||
|
# Backfill: для существующих telegram-юзеров создаём identity
|
||||||
|
await conn.execute("""
|
||||||
|
INSERT INTO auth_identities (user_id, provider, provider_uid)
|
||||||
|
SELECT telegram_id, 'telegram', telegram_id::text
|
||||||
|
FROM users
|
||||||
|
WHERE telegram_id > 0
|
||||||
|
ON CONFLICT DO NOTHING
|
||||||
|
""")
|
||||||
|
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)")
|
await conn.execute("CREATE INDEX IF NOT EXISTS idx_sentences_level_number ON sentences(level, sentence_number)")
|
||||||
# Оставляем score-индексы (не дубли)
|
# Оставляем score-индексы (не дубли)
|
||||||
await conn.execute("CREATE INDEX IF NOT EXISTS idx_user_progress_score ON user_progress(score DESC)")
|
await conn.execute("CREATE INDEX IF NOT EXISTS idx_user_progress_score ON user_progress(score DESC)")
|
||||||
|
|||||||
@@ -523,6 +523,7 @@
|
|||||||
| last_completed_level | integer | YES | 0 |
|
| last_completed_level | integer | YES | 0 |
|
||||||
| id | integer | NO | nextval('users_id_seq'::regclass) |
|
| id | integer | NO | nextval('users_id_seq'::regclass) |
|
||||||
| current_level | text | YES | 'A1'::text |
|
| current_level | text | YES | 'A1'::text |
|
||||||
|
| difficulty | text | YES | 'medium'::text |
|
||||||
|
|
||||||
## voice_usage
|
## voice_usage
|
||||||
|
|
||||||
|
|||||||
@@ -4,7 +4,7 @@
|
|||||||
|
|
||||||
Что делает:
|
Что делает:
|
||||||
1. Проверяет, есть ли фраза на сегодня в daily_phrases
|
1. Проверяет, есть ли фраза на сегодня в daily_phrases
|
||||||
2. Если нет — генерирует через AI (MiniMax-M3)
|
2. Если нет — генерирует через AI (DeepSeek V4 Pro)
|
||||||
3. Пишет в daily_phrases с phrase_date = CURRENT_DATE
|
3. Пишет в daily_phrases с phrase_date = CURRENT_DATE
|
||||||
|
|
||||||
Fallback: если AI упал — пишет запасную фразу.
|
Fallback: если AI упал — пишет запасную фразу.
|
||||||
@@ -25,7 +25,7 @@ logging.basicConfig(
|
|||||||
logger = logging.getLogger(__name__)
|
logger = logging.getLogger(__name__)
|
||||||
|
|
||||||
TOGETHER_API_URL = "https://api.together.xyz/v1/chat/completions"
|
TOGETHER_API_URL = "https://api.together.xyz/v1/chat/completions"
|
||||||
TEACHER_MODEL = "MiniMaxAI/MiniMax-M3"
|
TEACHER_MODEL = "deepseek-ai/DeepSeek-V4-Pro-0813"
|
||||||
|
|
||||||
# Список тем для фразы дня
|
# Список тем для фразы дня
|
||||||
TOPICS_LIST = [
|
TOPICS_LIST = [
|
||||||
@@ -119,7 +119,7 @@ EN_GRAMMAR: [грамматический разбор на английском
|
|||||||
|
|
||||||
user_prompt = f"Создай фразу дня на тему: {selected_topic}."
|
user_prompt = f"Создай фразу дня на тему: {selected_topic}."
|
||||||
|
|
||||||
ai_response = await call_ai(system_prompt, user_prompt, max_tokens=1000)
|
ai_response = await call_ai(system_prompt, user_prompt, max_tokens=3000)
|
||||||
|
|
||||||
if not ai_response:
|
if not ai_response:
|
||||||
logger.warning("AI returned empty response, using fallback")
|
logger.warning("AI returned empty response, using fallback")
|
||||||
|
|||||||
@@ -2,19 +2,20 @@ import asyncio
|
|||||||
import ipaddress
|
import ipaddress
|
||||||
import logging
|
import logging
|
||||||
import os
|
import os
|
||||||
import re
|
|
||||||
import time
|
import time
|
||||||
from collections import defaultdict
|
from collections import defaultdict
|
||||||
from contextlib import asynccontextmanager
|
from contextlib import asynccontextmanager
|
||||||
from pathlib import Path
|
from fastapi import FastAPI, Request
|
||||||
from fastapi import FastAPI, Request, HTTPException
|
|
||||||
from fastapi.middleware.cors import CORSMiddleware
|
from fastapi.middleware.cors import CORSMiddleware
|
||||||
from fastapi.responses import JSONResponse
|
from fastapi.responses import JSONResponse
|
||||||
from fastapi.staticfiles import StaticFiles
|
from fastapi.staticfiles import StaticFiles
|
||||||
from config import FRONTEND_ORIGINS, UPLOADS_DIR, CF_IPS
|
from config import FRONTEND_ORIGINS, UPLOADS_DIR, CF_IPS
|
||||||
from database import init_db
|
from database import init_db
|
||||||
from routers import users, game, hints, leaderboard, sentences, achievements, wordquiz, bubblewords, pronunciation, assistant, learning, tts, typing, teacher, support, admin, feed, admin_content
|
from routers import users, game, hints, leaderboard, sentences, achievements, wordquiz, bubblewords, pronunciation, assistant, learning, tts, typing, teacher, support, admin, feed, admin_content
|
||||||
from routers import lectures, admin_auth
|
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.sentences import init_sentences
|
||||||
from routers.achievements import init_achievements
|
from routers.achievements import init_achievements
|
||||||
from routers.learning_data import init_learning_data
|
from routers.learning_data import init_learning_data
|
||||||
@@ -69,7 +70,10 @@ class RateLimiter:
|
|||||||
"/game/check-word": {"max_requests": 30, "window": 60},
|
"/game/check-word": {"max_requests": 30, "window": 60},
|
||||||
"/game/complete-level": {"max_requests": 10, "window": 60},
|
"/game/complete-level": {"max_requests": 10, "window": 60},
|
||||||
"/sentences/check": {"max_requests": 20, "window": 60},
|
"/sentences/check": {"max_requests": 20, "window": 60},
|
||||||
"/leaderboard": {"max_requests": 10, "window": 60},
|
# 🔧 ФИКС (30.09.2026): leaderboard_rate_limit_too_low —
|
||||||
|
# Mini App делает несколько запросов подряд при загрузке страницы
|
||||||
|
# (аватар + данные + ре-рендер) → 429. Подняли до 30/мин.
|
||||||
|
"/leaderboard": {"max_requests": 30, "window": 60},
|
||||||
"/assistant/chat": {"max_requests": 20, "window": 60},
|
"/assistant/chat": {"max_requests": 20, "window": 60},
|
||||||
"/learning/answer": {"max_requests": 30, "window": 60},
|
"/learning/answer": {"max_requests": 30, "window": 60},
|
||||||
"/tts": {"max_requests": 30, "window": 60},
|
"/tts": {"max_requests": 30, "window": 60},
|
||||||
@@ -89,6 +93,9 @@ class RateLimiter:
|
|||||||
# 🔧 ФИКС (22.09.2026): дорогой AI-эндпоинт без лимита выжигал бюджет.
|
# 🔧 ФИКС (22.09.2026): дорогой AI-эндпоинт без лимита выжигал бюджет.
|
||||||
"/learning/analytics": {"max_requests": 5, "window": 60},
|
"/learning/analytics": {"max_requests": 5, "window": 60},
|
||||||
"/learning/practice/start": {"max_requests": 10, "window": 60},
|
"/learning/practice/start": {"max_requests": 10, "window": 60},
|
||||||
|
# 🆕 Pleily (07.10.2026): лимит на вход по device_id.
|
||||||
|
# Защищает от спама создания новых юзеров.
|
||||||
|
"/auth/device": {"max_requests": 5, "window": 60},
|
||||||
}
|
}
|
||||||
self._cleanup_task = None
|
self._cleanup_task = None
|
||||||
|
|
||||||
@@ -365,6 +372,11 @@ app.include_router(feed.router)
|
|||||||
app.include_router(admin_content.router)
|
app.include_router(admin_content.router)
|
||||||
app.include_router(lectures.router)
|
app.include_router(lectures.router)
|
||||||
app.include_router(admin_auth.router)
|
app.include_router(admin_auth.router)
|
||||||
|
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)
|
||||||
|
|
||||||
|
|
||||||
# ============ Базовые эндпоинты ============
|
# ============ Базовые эндпоинты ============
|
||||||
|
|||||||
@@ -37,3 +37,4 @@ urllib3==2.7.0
|
|||||||
uvicorn==0.51.0
|
uvicorn==0.51.0
|
||||||
yarl==1.24.5
|
yarl==1.24.5
|
||||||
pdfplumber==0.11.10
|
pdfplumber==0.11.10
|
||||||
|
PyJWT==2.15.1
|
||||||
|
|||||||
+191
-46
@@ -1,6 +1,6 @@
|
|||||||
import logging
|
import logging
|
||||||
|
|
||||||
from fastapi import APIRouter, Request, HTTPException
|
from fastapi import APIRouter, Request
|
||||||
from auth import require_auth
|
from auth import require_auth
|
||||||
from database import get_pool
|
from database import get_pool
|
||||||
|
|
||||||
@@ -8,7 +8,7 @@ logger = logging.getLogger(__name__)
|
|||||||
|
|
||||||
router = APIRouter(prefix="/achievements", tags=["achievements"])
|
router = APIRouter(prefix="/achievements", tags=["achievements"])
|
||||||
|
|
||||||
# ============ Данные 52 достижений ============
|
# ============ Данные 55 достижений ============
|
||||||
ACHIEVEMENTS_DATA = [
|
ACHIEVEMENTS_DATA = [
|
||||||
# ===== Word Search (11) =====
|
# ===== Word Search (11) =====
|
||||||
{"code": "first_level", "category": "wordsearch", "icon": "🔰",
|
{"code": "first_level", "category": "wordsearch", "icon": "🔰",
|
||||||
@@ -66,6 +66,52 @@ ACHIEVEMENTS_DATA = [
|
|||||||
"desc_pl": "Znajdź 5 słów bez błędu", "desc_ru": "Найти 5 слов подряд без ошибок", "desc_uk": "Знайти 5 слів без помилки", "desc_en": "Find 5 words without mistakes",
|
"desc_pl": "Znajdź 5 słów bez błędu", "desc_ru": "Найти 5 слов подряд без ошибок", "desc_uk": "Знайти 5 слів без помилки", "desc_en": "Find 5 words without mistakes",
|
||||||
"type": "perfect_words", "value": 5},
|
"type": "perfect_words", "value": 5},
|
||||||
|
|
||||||
|
# ===== Word Search — волны (9 новых, 11.10.2026) =====
|
||||||
|
{"code": "ws_wave_1", "category": "wordsearch", "icon": "🌊",
|
||||||
|
"name_pl": "Pierwsza fala", "name_ru": "Первая волна", "name_uk": "Перша хвиля", "name_en": "First Wave",
|
||||||
|
"desc_pl": "Ukończ pierwszą falę (10 poziomów)", "desc_ru": "Пройти первую волну (10 уровней)", "desc_uk": "Пройти першу хвилю (10 рівнів)", "desc_en": "Complete your first wave (10 levels)",
|
||||||
|
"type": "waves_completed", "value": 1},
|
||||||
|
|
||||||
|
{"code": "ws_wave_5", "category": "wordsearch", "icon": "🌊",
|
||||||
|
"name_pl": "Pięć fal", "name_ru": "Пять волн", "name_uk": "П'ять хвиль", "name_en": "Five Waves",
|
||||||
|
"desc_pl": "Ukończ 5 fal", "desc_ru": "Пройти 5 волн", "desc_uk": "Пройти 5 хвиль", "desc_en": "Complete 5 waves",
|
||||||
|
"type": "waves_completed", "value": 5},
|
||||||
|
|
||||||
|
{"code": "ws_wave_10", "category": "wordsearch", "icon": "🌊",
|
||||||
|
"name_pl": "Dziesięć fal", "name_ru": "Десять волн", "name_uk": "Десять хвиль", "name_en": "Ten Waves",
|
||||||
|
"desc_pl": "Ukończ 10 fal", "desc_ru": "Пройти 10 волн", "desc_uk": "Пройти 10 хвиль", "desc_en": "Complete 10 waves",
|
||||||
|
"type": "waves_completed", "value": 10},
|
||||||
|
|
||||||
|
{"code": "ws_wave_25", "category": "wordsearch", "icon": "🌊",
|
||||||
|
"name_pl": "Dwadzieścia pięć fal", "name_ru": "Двадцать пять волн", "name_uk": "Двадцять п'ять хвиль", "name_en": "Twenty-Five Waves",
|
||||||
|
"desc_pl": "Ukończ 25 fal", "desc_ru": "Пройти 25 волн", "desc_uk": "Пройти 25 хвиль", "desc_en": "Complete 25 waves",
|
||||||
|
"type": "waves_completed", "value": 25},
|
||||||
|
|
||||||
|
{"code": "ws_wave_50", "category": "wordsearch", "icon": "🌊",
|
||||||
|
"name_pl": "Pięćdziesiąt fal", "name_ru": "Пятьдесят волн", "name_uk": "П'ятдесят хвиль", "name_en": "Fifty Waves",
|
||||||
|
"desc_pl": "Ukończ 50 fal", "desc_ru": "Пройти 50 волн", "desc_uk": "Пройти 50 хвиль", "desc_en": "Complete 50 waves",
|
||||||
|
"type": "waves_completed", "value": 50},
|
||||||
|
|
||||||
|
{"code": "ws_speed_run_3", "category": "wordsearch", "icon": "⚡",
|
||||||
|
"name_pl": "Szybka seria", "name_ru": "Быстрая серия", "name_uk": "Швидка серія", "name_en": "Speed Run",
|
||||||
|
"desc_pl": "Ukończ 3 poziomy z rzędu, każdy w mniej niż 30 sekund", "desc_ru": "Пройти 3 уровня подряд, каждый быстрее 30 секунд", "desc_uk": "Пройти 3 рівні поспіль, кожен швидше 30 секунд", "desc_en": "Complete 3 levels in a row, each under 30 seconds",
|
||||||
|
"type": "ws_speed_run", "value": 3},
|
||||||
|
|
||||||
|
{"code": "ws_wave_no_hints", "category": "wordsearch", "icon": "🎯",
|
||||||
|
"name_pl": "Fala bez podpowiedzi", "name_ru": "Волна без подсказок", "name_uk": "Хвиля без підказок", "name_en": "Flawless Wave",
|
||||||
|
"desc_pl": "Ukończ całą falę (10 poziomów) bez podpowiedzi", "desc_ru": "Пройти всю волну (10 уровней) без подсказок", "desc_uk": "Пройти всю хвилю (10 рівнів) без підказок", "desc_en": "Complete a whole wave (10 levels) without hints",
|
||||||
|
"type": "ws_no_hints_streak", "value": 10},
|
||||||
|
|
||||||
|
{"code": "ws_words_1000", "category": "wordsearch", "icon": "📚",
|
||||||
|
"name_pl": "Tysiąc słów", "name_ru": "Тысяча слов", "name_uk": "Тисяча слів", "name_en": "Thousand Words",
|
||||||
|
"desc_pl": "Znajdź 1000 słów w filwordach", "desc_ru": "Найти 1000 слов в филвордах", "desc_uk": "Знайти 1000 слів у філвордах", "desc_en": "Find 1000 words in word searches",
|
||||||
|
"type": "wordsearch_words", "value": 1000},
|
||||||
|
|
||||||
|
{"code": "ws_xp_10000", "category": "wordsearch", "icon": "💎",
|
||||||
|
"name_pl": "Diament filwordów", "name_ru": "Бриллиант филвордов", "name_uk": "Діамант філвордів", "name_en": "Word Search Diamond",
|
||||||
|
"desc_pl": "Zdobądź 10 000 XP w filwordach", "desc_ru": "Набрать 10 000 XP в филвордах", "desc_uk": "Набрати 10 000 XP у філвордах", "desc_en": "Earn 10,000 XP in word searches",
|
||||||
|
"type": "wordsearch_xp", "value": 10000},
|
||||||
|
|
||||||
# ===== Sentence Builder (10) =====
|
# ===== Sentence Builder (10) =====
|
||||||
{"code": "first_sentence", "category": "sentence", "icon": "📝",
|
{"code": "first_sentence", "category": "sentence", "icon": "📝",
|
||||||
"name_pl": "Debiutant", "name_ru": "Дебютант", "name_uk": "Дебютант", "name_en": "Debutant",
|
"name_pl": "Debiutant", "name_ru": "Дебютант", "name_uk": "Дебютант", "name_en": "Debutant",
|
||||||
@@ -117,7 +163,7 @@ ACHIEVEMENTS_DATA = [
|
|||||||
"desc_pl": "Ułóż zdanie w mniej niż 5 sekund", "desc_ru": "Составить предложение быстрее 5 секунд", "desc_uk": "Скласти речення швидше 5 секунд", "desc_en": "Build a sentence in under 5 seconds",
|
"desc_pl": "Ułóż zdanie w mniej niż 5 sekund", "desc_ru": "Составить предложение быстрее 5 секунд", "desc_uk": "Скласти речення швидше 5 секунд", "desc_en": "Build a sentence in under 5 seconds",
|
||||||
"type": "speed_sentence", "value": 5},
|
"type": "speed_sentence", "value": 5},
|
||||||
|
|
||||||
# ===== Word Quiz (8) =====
|
# ===== Word Quiz (20) =====
|
||||||
{"code": "quiz_10", "category": "wordquiz", "icon": "🧠",
|
{"code": "quiz_10", "category": "wordquiz", "icon": "🧠",
|
||||||
"name_pl": "Myśliciel", "name_ru": "Мыслитель", "name_uk": "Мислитель", "name_en": "Thinker",
|
"name_pl": "Myśliciel", "name_ru": "Мыслитель", "name_uk": "Мислитель", "name_en": "Thinker",
|
||||||
"desc_pl": "Odgadnij 10 słów w Quiz słownym", "desc_ru": "Угадать 10 слов в Квизе слов", "desc_uk": "Відгадати 10 слів у Квізі слів", "desc_en": "Guess 10 words in Word Quiz",
|
"desc_pl": "Odgadnij 10 słów w Quiz słownym", "desc_ru": "Угадать 10 слов в Квизе слов", "desc_uk": "Відгадати 10 слів у Квізі слів", "desc_en": "Guess 10 words in Word Quiz",
|
||||||
@@ -136,29 +182,89 @@ ACHIEVEMENTS_DATA = [
|
|||||||
{"code": "quiz_perfect_10", "category": "wordquiz", "icon": "💎",
|
{"code": "quiz_perfect_10", "category": "wordquiz", "icon": "💎",
|
||||||
"name_pl": "Idealny wynik", "name_ru": "Идеальный результат", "name_uk": "Ідеальний результат", "name_en": "Perfect Score",
|
"name_pl": "Idealny wynik", "name_ru": "Идеальный результат", "name_uk": "Ідеальний результат", "name_en": "Perfect Score",
|
||||||
"desc_pl": "Odgadnij 10 słów bez pomyłki", "desc_ru": "Угадать 10 слов без ошибок", "desc_uk": "Відгадати 10 слів без помилок", "desc_en": "Guess 10 words without mistakes",
|
"desc_pl": "Odgadnij 10 słów bez pomyłki", "desc_ru": "Угадать 10 слов без ошибок", "desc_uk": "Відгадати 10 слів без помилок", "desc_en": "Guess 10 words without mistakes",
|
||||||
"type": "quiz_perfect_streak", "value": 10},
|
"type": "quiz_correct_streak", "value": 10},
|
||||||
|
|
||||||
{"code": "quiz_streak_20", "category": "wordquiz", "icon": "🔥",
|
{"code": "quiz_streak_20", "category": "wordquiz", "icon": "🔥",
|
||||||
"name_pl": "Niepowstrzymany", "name_ru": "Неудержимый", "name_uk": "Невтримний", "name_en": "Unstoppable",
|
"name_pl": "Niepowstrzymany", "name_ru": "Неудержимый", "name_uk": "Невтримний", "name_en": "Unstoppable",
|
||||||
"desc_pl": "Odgadnij 20 słów z rzędu", "desc_ru": "Угадать 20 слов подряд", "desc_uk": "Відгадати 20 слів поспіль", "desc_en": "Guess 20 words in a row",
|
"desc_pl": "Odgadnij 20 słów z rzędu", "desc_ru": "Угадать 20 слов подряд", "desc_uk": "Відгадати 20 слів поспіль", "desc_en": "Guess 20 words in a row",
|
||||||
"type": "quiz_perfect_streak", "value": 20},
|
"type": "quiz_correct_streak", "value": 20},
|
||||||
|
|
||||||
{"code": "quiz_speed", "category": "wordquiz", "icon": "⚡",
|
{"code": "quiz_speed", "category": "wordquiz", "icon": "⚡",
|
||||||
"name_pl": "Błyskawica", "name_ru": "Молния", "name_uk": "Блискавка", "name_en": "Lightning",
|
"name_pl": "Błyskawica", "name_ru": "Молния", "name_uk": "Блискавка", "name_en": "Lightning",
|
||||||
"desc_pl": "Odgadnij słowo w mniej niż 3 sekundy", "desc_ru": "Угадать слово быстрее 3 секунд", "desc_uk": "Відгадати слово швидше 3 секунд", "desc_en": "Guess a word in under 3 seconds",
|
"desc_pl": "Odgadnij słowo w mniej niż 3 sekundy", "desc_ru": "Угадать слово быстрее 3 секунд", "desc_uk": "Відгадати слово швидше 3 секунд", "desc_en": "Guess a word in under 3 seconds",
|
||||||
"type": "quiz_speed", "value": 3},
|
"type": "quiz_speed_3", "value": 3},
|
||||||
|
|
||||||
{"code": "quiz_speed_2", "category": "wordquiz", "icon": "🚀",
|
{"code": "quiz_speed_2", "category": "wordquiz", "icon": "🚀",
|
||||||
"name_pl": "Super szybki", "name_ru": "Супер быстрый", "name_uk": "Супер швидкий", "name_en": "Super Fast",
|
"name_pl": "Super szybki", "name_ru": "Супер быстрый", "name_uk": "Супер швидкий", "name_en": "Super Fast",
|
||||||
"desc_pl": "Odgadnij słowo w mniej niż 2 sekundy", "desc_ru": "Угадать слово быстрее 2 секунд", "desc_uk": "Відгадати слово швидше 2 секунд", "desc_en": "Guess a word in under 2 seconds",
|
"desc_pl": "Odgadnij słowo w mniej niż 2 sekundy", "desc_ru": "Угадать слово быстрее 2 секунд", "desc_uk": "Відгадати слово швидше 2 секунд", "desc_en": "Guess a word in under 2 seconds",
|
||||||
"type": "quiz_speed", "value": 2},
|
"type": "quiz_speed_2", "value": 2},
|
||||||
|
|
||||||
{"code": "quiz_no_mistakes", "category": "wordquiz", "icon": "🏆",
|
{"code": "quiz_no_mistakes", "category": "wordquiz", "icon": "🏆",
|
||||||
"name_pl": "Bezbłędny", "name_ru": "Безошибочный", "name_uk": "Безпомилковий", "name_en": "Flawless",
|
"name_pl": "Bezbłędny", "name_ru": "Безошибочный", "name_uk": "Безпомилковий", "name_en": "Flawless",
|
||||||
"desc_pl": "Odgadnij słowo bez żadnej pomyłki", "desc_ru": "Угадать слово без единой ошибки", "desc_uk": "Відгадати слово без жодної помилки", "desc_en": "Guess a word without any mistakes",
|
"desc_pl": "Odgadnij słowo bez żadnej pomyłki", "desc_ru": "Угадать слово без единой ошибки", "desc_uk": "Відгадати слово без жодної помилки", "desc_en": "Guess a word without any mistakes",
|
||||||
"type": "quiz_no_mistakes", "value": 1},
|
"type": "quiz_no_mistakes", "value": 1},
|
||||||
|
|
||||||
# ===== Bubble Words (8) =====
|
{"code": "quiz_1", "category": "wordquiz", "icon": "🎯",
|
||||||
|
"name_pl": "Pierwszy krok", "name_ru": "Первый шаг", "name_uk": "Перший крок", "name_en": "First Step",
|
||||||
|
"desc_pl": "Odgadnij 1 słowo", "desc_ru": "Угадать 1 слово", "desc_uk": "Вгадати 1 слово", "desc_en": "Guess 1 word",
|
||||||
|
"type": "quiz_guessed", "value": 1},
|
||||||
|
|
||||||
|
{"code": "quiz_25", "category": "wordquiz", "icon": "🎓",
|
||||||
|
"name_pl": "Uczeń", "name_ru": "Ученик", "name_uk": "Учень", "name_en": "Student",
|
||||||
|
"desc_pl": "Odgadnij 25 słów", "desc_ru": "Угадать 25 слов", "desc_uk": "Вгадати 25 слів", "desc_en": "Guess 25 words",
|
||||||
|
"type": "quiz_guessed", "value": 25},
|
||||||
|
|
||||||
|
{"code": "quiz_200", "category": "wordquiz", "icon": "📚",
|
||||||
|
"name_pl": "Erudyta", "name_ru": "Эрудит", "name_uk": "Ерудит", "name_en": "Erudite",
|
||||||
|
"desc_pl": "Odgadnij 200 słów", "desc_ru": "Угадать 200 слов", "desc_uk": "Вгадати 200 слів", "desc_en": "Guess 200 words",
|
||||||
|
"type": "quiz_guessed", "value": 200},
|
||||||
|
|
||||||
|
{"code": "quiz_500", "category": "wordquiz", "icon": "🌟",
|
||||||
|
"name_pl": "Legenda", "name_ru": "Легенда", "name_uk": "Легенда", "name_en": "Legend",
|
||||||
|
"desc_pl": "Odgadnij 500 słów", "desc_ru": "Угадать 500 слов", "desc_uk": "Вгадати 500 слів", "desc_en": "Guess 500 words",
|
||||||
|
"type": "quiz_guessed", "value": 500},
|
||||||
|
|
||||||
|
{"code": "quiz_1000", "category": "wordquiz", "icon": "👑",
|
||||||
|
"name_pl": "Guru", "name_ru": "Гуру", "name_uk": "Гуру", "name_en": "Guru",
|
||||||
|
"desc_pl": "Odgadnij 1000 słów", "desc_ru": "Угадать 1000 слов", "desc_uk": "Вгадати 1000 слів", "desc_en": "Guess 1000 words",
|
||||||
|
"type": "quiz_guessed", "value": 1000},
|
||||||
|
|
||||||
|
{"code": "quiz_correct_streak_5", "category": "wordquiz", "icon": "🔥",
|
||||||
|
"name_pl": "Seria", "name_ru": "Серия", "name_uk": "Серія", "name_en": "Streak",
|
||||||
|
"desc_pl": "5 poprawnych z rzędu", "desc_ru": "5 правильных подряд", "desc_uk": "5 правильних поспіль", "desc_en": "5 correct in a row",
|
||||||
|
"type": "quiz_correct_streak", "value": 5},
|
||||||
|
|
||||||
|
{"code": "quiz_streak_30", "category": "wordquiz", "icon": "💪",
|
||||||
|
"name_pl": "Na fali", "name_ru": "На волне", "name_uk": "На хвилі", "name_en": "On Fire",
|
||||||
|
"desc_pl": "30 poprawnych z rzędu", "desc_ru": "30 правильных подряд", "desc_uk": "30 правильних поспіль", "desc_en": "30 correct in a row",
|
||||||
|
"type": "quiz_correct_streak", "value": 30},
|
||||||
|
|
||||||
|
{"code": "quiz_streak_50", "category": "wordquiz", "icon": "🏆",
|
||||||
|
"name_pl": "Niezwyciężony", "name_ru": "Непобедимый", "name_uk": "Непереможний", "name_en": "Invincible",
|
||||||
|
"desc_pl": "50 poprawnych z rzędu", "desc_ru": "50 правильных подряд", "desc_uk": "50 правильних поспіль", "desc_en": "50 correct in a row",
|
||||||
|
"type": "quiz_correct_streak", "value": 50},
|
||||||
|
|
||||||
|
{"code": "quiz_no_mistakes_3", "category": "wordquiz", "icon": "✨",
|
||||||
|
"name_pl": "Czysta trójka", "name_ru": "Чистая тройка", "name_uk": "Чиста трійка", "name_en": "Clean Three",
|
||||||
|
"desc_pl": "3 rundy bez błędu z rzędu", "desc_ru": "3 раунда без ошибок подряд", "desc_uk": "3 раунди без помилок поспіль", "desc_en": "3 rounds without mistakes in a row",
|
||||||
|
"type": "quiz_no_mistakes_streak", "value": 3},
|
||||||
|
|
||||||
|
{"code": "quiz_perfect_25", "category": "wordquiz", "icon": "💎",
|
||||||
|
"name_pl": "Perfekcjonista", "name_ru": "Перфекционист", "name_uk": "Перфекціоніст", "name_en": "Perfectionist",
|
||||||
|
"desc_pl": "25 rund bez błędu z rzędu", "desc_ru": "25 раундов без ошибок подряд", "desc_uk": "25 раундів без помилок поспіль", "desc_en": "25 rounds without mistakes in a row",
|
||||||
|
"type": "quiz_no_mistakes_streak", "value": 25},
|
||||||
|
|
||||||
|
{"code": "quiz_speed_5", "category": "wordquiz", "icon": "⚡",
|
||||||
|
"name_pl": "Szybki", "name_ru": "Быстрый", "name_uk": "Швидкий", "name_en": "Fast",
|
||||||
|
"desc_pl": "Odgadnij słowo w mniej niż 5 sekund", "desc_ru": "Угадать слово быстрее 5 секунд", "desc_uk": "Вгадати слово швидше 5 секунд", "desc_en": "Guess a word in under 5 seconds",
|
||||||
|
"type": "quiz_speed_5", "value": 5},
|
||||||
|
|
||||||
|
{"code": "quiz_speed_1", "category": "wordquiz", "icon": "🚀",
|
||||||
|
"name_pl": "Błyskawica", "name_ru": "Молния", "name_uk": "Блискавка", "name_en": "Lightning",
|
||||||
|
"desc_pl": "Odgadnij słowo w mniej niż 1 sekundę", "desc_ru": "Угадать слово быстрее 1 секунды", "desc_uk": "Вгадати слово швидше 1 секунди", "desc_en": "Guess a word in under 1 second",
|
||||||
|
"type": "quiz_speed_1", "value": 1},
|
||||||
|
|
||||||
|
# ===== Bubble Words (20) =====
|
||||||
{"code": "bubble_5", "category": "bubblewords", "icon": "🫧",
|
{"code": "bubble_5", "category": "bubblewords", "icon": "🫧",
|
||||||
"name_pl": "Początkujący", "name_ru": "Начинающий", "name_uk": "Початківець", "name_en": "Beginner",
|
"name_pl": "Początkujący", "name_ru": "Начинающий", "name_uk": "Початківець", "name_en": "Beginner",
|
||||||
"desc_pl": "Ukończ 5 poziomów w Bąbelkach słów", "desc_ru": "Пройти 5 уровней в Пузырях слов", "desc_uk": "Пройти 5 рівнів у Бульбашках слів", "desc_en": "Complete 5 levels in Bubble Words",
|
"desc_pl": "Ukończ 5 poziomów w Bąbelkach słów", "desc_ru": "Пройти 5 уровней в Пузырях слов", "desc_uk": "Пройти 5 рівнів у Бульбашках слів", "desc_en": "Complete 5 levels in Bubble Words",
|
||||||
@@ -192,14 +298,74 @@ ACHIEVEMENTS_DATA = [
|
|||||||
{"code": "bubble_speed", "category": "bubblewords", "icon": "🚀",
|
{"code": "bubble_speed", "category": "bubblewords", "icon": "🚀",
|
||||||
"name_pl": "Szybki bańki", "name_ru": "Быстрые пузыри", "name_uk": "Швидкі бульбашки", "name_en": "Fast Bubbles",
|
"name_pl": "Szybki bańki", "name_ru": "Быстрые пузыри", "name_uk": "Швидкі бульбашки", "name_en": "Fast Bubbles",
|
||||||
"desc_pl": "Ukończ poziom w mniej niż 45 sekund", "desc_ru": "Пройти уровень быстрее 45 секунд", "desc_uk": "Пройти рівень швидше 45 секунд", "desc_en": "Complete a level in under 45 seconds",
|
"desc_pl": "Ukończ poziom w mniej niż 45 sekund", "desc_ru": "Пройти уровень быстрее 45 секунд", "desc_uk": "Пройти рівень швидше 45 секунд", "desc_en": "Complete a level in under 45 seconds",
|
||||||
"type": "bubble_speed", "value": 45},
|
"type": "bubble_speed_45", "value": 45},
|
||||||
|
|
||||||
{"code": "bubble_speed_30", "category": "bubblewords", "icon": "⚡",
|
{"code": "bubble_speed_30", "category": "bubblewords", "icon": "⚡",
|
||||||
"name_pl": "Bąbelkowa błyskawica", "name_ru": "Пузырьковая молния", "name_uk": "Бульбашкова блискавка", "name_en": "Bubble Lightning",
|
"name_pl": "Bąbelkowa błyskawica", "name_ru": "Пузырьковая молния", "name_uk": "Бульбашкова блискавка", "name_en": "Bubble Lightning",
|
||||||
"desc_pl": "Ukończ poziom w mniej niż 30 sekund", "desc_ru": "Пройти уровень быстрее 30 секунд", "desc_uk": "Пройти рівень швидше 30 секунд", "desc_en": "Complete a level in under 30 seconds",
|
"desc_pl": "Ukończ poziom w mniej niż 30 sekund", "desc_ru": "Пройти уровень быстрее 30 секунд", "desc_uk": "Пройти рівень швидше 30 секунд", "desc_en": "Complete a level in under 30 seconds",
|
||||||
"type": "bubble_speed", "value": 30},
|
"type": "bubble_speed_30", "value": 30},
|
||||||
|
|
||||||
# ===== General (15) =====
|
{"code": "bubble_1", "category": "bubblewords", "icon": "🫧",
|
||||||
|
"name_pl": "Pierwszy bąbelek", "name_ru": "Первый пузырь", "name_uk": "Перша бульбашка", "name_en": "First Bubble",
|
||||||
|
"desc_pl": "Ukończ 1 poziom w Bąbelkach słów", "desc_ru": "Пройти 1 уровень в Пузырях слов", "desc_uk": "Пройти 1 рівень у Бульбашках слів", "desc_en": "Complete 1 level in Bubble Words",
|
||||||
|
"type": "bubble_levels", "value": 1},
|
||||||
|
|
||||||
|
{"code": "bubble_10", "category": "bubblewords", "icon": "🫧",
|
||||||
|
"name_pl": "Dziesięć bąbelków", "name_ru": "Десять пузырей", "name_uk": "Десять бульбашок", "name_en": "Ten Bubbles",
|
||||||
|
"desc_pl": "Ukończ 10 poziomów w Bąbelkach słów", "desc_ru": "Пройти 10 уровней в Пузырях слов", "desc_uk": "Пройти 10 рівнів у Бульбашках слів", "desc_en": "Complete 10 levels in Bubble Words",
|
||||||
|
"type": "bubble_levels", "value": 10},
|
||||||
|
|
||||||
|
{"code": "bubble_words_25", "category": "bubblewords", "icon": "📚",
|
||||||
|
"name_pl": "Kolekcjoner", "name_ru": "Собиратель", "name_uk": "Колекціонер", "name_en": "Collector",
|
||||||
|
"desc_pl": "Zbierz 25 słów", "desc_ru": "Собрать 25 слов", "desc_uk": "Зібрати 25 слів", "desc_en": "Collect 25 words",
|
||||||
|
"type": "bubble_words", "value": 25},
|
||||||
|
|
||||||
|
{"code": "bubble_no_mistakes", "category": "bubblewords", "icon": "✨",
|
||||||
|
"name_pl": "Bezbłędny", "name_ru": "Без ошибок", "name_uk": "Без помилок", "name_en": "No Mistakes",
|
||||||
|
"desc_pl": "Ukończ poziom bez żadnej pomyłki", "desc_ru": "Пройти уровень без единой ошибки", "desc_uk": "Пройти рівень без жодної помилки", "desc_en": "Complete a level without any mistakes",
|
||||||
|
"type": "bubble_no_mistakes", "value": 1},
|
||||||
|
|
||||||
|
{"code": "bubble_streak_3", "category": "bubblewords", "icon": "🔥",
|
||||||
|
"name_pl": "Seria", "name_ru": "Серия", "name_uk": "Серія", "name_en": "Streak",
|
||||||
|
"desc_pl": "Ukończ 3 poziomy z rzędu bez podpowiedzi", "desc_ru": "Пройти 3 уровня подряд без подсказок", "desc_uk": "Пройти 3 рівні поспіль без підказок", "desc_en": "Complete 3 levels in a row without hints",
|
||||||
|
"type": "bubble_streak", "value": 3},
|
||||||
|
|
||||||
|
{"code": "bubble_streak_10", "category": "bubblewords", "icon": "💪",
|
||||||
|
"name_pl": "Niepowstrzymany", "name_ru": "Неудержимый", "name_uk": "Невтримний", "name_en": "Unstoppable",
|
||||||
|
"desc_pl": "Ukończ 10 poziomów z rzędu bez podpowiedzi", "desc_ru": "Пройти 10 уровней подряд без подсказок", "desc_uk": "Пройти 10 рівнів поспіль без підказок", "desc_en": "Complete 10 levels in a row without hints",
|
||||||
|
"type": "bubble_streak", "value": 10},
|
||||||
|
|
||||||
|
{"code": "bubble_words_100", "category": "bubblewords", "icon": "📖",
|
||||||
|
"name_pl": "Sto słów", "name_ru": "Сто слов", "name_uk": "Сто слів", "name_en": "Hundred Words",
|
||||||
|
"desc_pl": "Zbierz 100 słów", "desc_ru": "Собрать 100 слов", "desc_uk": "Зібрати 100 слів", "desc_en": "Collect 100 words",
|
||||||
|
"type": "bubble_words", "value": 100},
|
||||||
|
|
||||||
|
{"code": "bubble_xp_1000", "category": "bubblewords", "icon": "💎",
|
||||||
|
"name_pl": "Bąbelkowy XP", "name_ru": "Пузырьковый XP", "name_uk": "Бульбашковий XP", "name_en": "Bubble XP",
|
||||||
|
"desc_pl": "Zdobądź 1000 XP w Bąbelkach", "desc_ru": "Набрать 1000 XP в пузырях", "desc_uk": "Набрати 1000 XP у бульбашках", "desc_en": "Earn 1000 XP in Bubbles",
|
||||||
|
"type": "bubble_xp", "value": 1000},
|
||||||
|
|
||||||
|
{"code": "bubble_200", "category": "bubblewords", "icon": "👑",
|
||||||
|
"name_pl": "Dwustu poziomów", "name_ru": "Двести уровней", "name_uk": "Двісті рівнів", "name_en": "Two Hundred Levels",
|
||||||
|
"desc_pl": "Ukończ 200 poziomów w Bąbelkach słów", "desc_ru": "Пройти 200 уровней в Пузырях слов", "desc_uk": "Пройти 200 рівнів у Бульбашках слів", "desc_en": "Complete 200 levels in Bubble Words",
|
||||||
|
"type": "bubble_levels", "value": 200},
|
||||||
|
|
||||||
|
{"code": "bubble_speed_15", "category": "bubblewords", "icon": "⚡",
|
||||||
|
"name_pl": "Błyskawica", "name_ru": "Молния", "name_uk": "Блискавка", "name_en": "Lightning",
|
||||||
|
"desc_pl": "Ukończ poziom w mniej niż 15 sekund", "desc_ru": "Пройти уровень быстрее 15 секунд", "desc_uk": "Пройти рівень швидше 15 секунд", "desc_en": "Complete a level in under 15 seconds",
|
||||||
|
"type": "bubble_speed_15", "value": 15},
|
||||||
|
|
||||||
|
{"code": "bubble_perfect_10", "category": "bubblewords", "icon": "🌟",
|
||||||
|
"name_pl": "Perfekcyjna seria", "name_ru": "Идеальная серия", "name_uk": "Ідеальна серія", "name_en": "Perfect Streak",
|
||||||
|
"desc_pl": "Ukończ 10 idealnych poziomów z rzędu", "desc_ru": "Пройти 10 идеальных уровней подряд", "desc_uk": "Пройти 10 ідеальних рівнів поспіль", "desc_en": "Complete 10 perfect levels in a row",
|
||||||
|
"type": "bubble_perfect_streak", "value": 10},
|
||||||
|
|
||||||
|
{"code": "bubble_words_500", "category": "bubblewords", "icon": "🏆",
|
||||||
|
"name_pl": "Pięćset słów", "name_ru": "Пятьсот слов", "name_uk": "П'ятсот слів", "name_en": "Five Hundred Words",
|
||||||
|
"desc_pl": "Zbierz 500 słów", "desc_ru": "Собрать 500 слов", "desc_uk": "Зібрати 500 слів", "desc_en": "Collect 500 words",
|
||||||
|
"type": "bubble_words", "value": 500},
|
||||||
|
|
||||||
|
# ===== General (9) =====
|
||||||
{"code": "score_1000", "category": "general", "icon": "🌟",
|
{"code": "score_1000", "category": "general", "icon": "🌟",
|
||||||
"name_pl": "Wschodząca gwiazda", "name_ru": "Восходящая звезда", "name_uk": "Висхідна зірка", "name_en": "Rising Star",
|
"name_pl": "Wschodząca gwiazda", "name_ru": "Восходящая звезда", "name_uk": "Висхідна зірка", "name_en": "Rising Star",
|
||||||
"desc_pl": "Zdobądź 1000 punktów", "desc_ru": "Набрать 1000 очков", "desc_uk": "Набрати 1000 балів", "desc_en": "Earn 1000 points",
|
"desc_pl": "Zdobądź 1000 punktów", "desc_ru": "Набрать 1000 очков", "desc_uk": "Набрати 1000 балів", "desc_en": "Earn 1000 points",
|
||||||
@@ -245,42 +411,7 @@ ACHIEVEMENTS_DATA = [
|
|||||||
"desc_pl": "Zmień język interfejsu", "desc_ru": "Сменить язык интерфейса", "desc_uk": "Змінити мову інтерфейсу", "desc_en": "Change interface language",
|
"desc_pl": "Zmień język interfejsu", "desc_ru": "Сменить язык интерфейса", "desc_uk": "Змінити мову інтерфейсу", "desc_en": "Change interface language",
|
||||||
"type": "language_changed", "value": 1},
|
"type": "language_changed", "value": 1},
|
||||||
|
|
||||||
# 🔧 ИСПРАВЛЕНО: Заменено достижение "Открой Грамматику" на "Открой меню учителя"
|
|
||||||
{"code": "open_teacher_menu", "category": "general", "icon": "🎓",
|
|
||||||
"name_pl": "Uczeń", "name_ru": "Ученик", "name_uk": "Учень", "name_en": "Student",
|
|
||||||
"desc_pl": "Otwórz menu nauczyciela", "desc_ru": "Открыть меню учителя", "desc_uk": "Відкрити меню вчителя", "desc_en": "Open the teacher menu",
|
|
||||||
"type": "teacher_menu_opened", "value": 1},
|
|
||||||
|
|
||||||
{"code": "open_cheatsheets", "category": "general", "icon": "📝",
|
|
||||||
"name_pl": "Ciekawski", "name_ru": "Любознательный", "name_uk": "Допитливий", "name_en": "Curious",
|
|
||||||
"desc_pl": "Otwórz sekcję Ściągi", "desc_ru": "Открыть раздел Шпаргалки", "desc_uk": "Відкрити розділ Шпаргалки", "desc_en": "Open the Cheatsheets section",
|
|
||||||
"type": "cheatsheets_opened", "value": 1},
|
|
||||||
|
|
||||||
{"code": "open_pronunciation", "category": "general", "icon": "🔊",
|
|
||||||
"name_pl": "Słuchacz", "name_ru": "Слушатель", "name_uk": "Слухач", "name_en": "Listener",
|
|
||||||
"desc_pl": "Otwórz sekcję Wymowa", "desc_ru": "Открыть раздел Произношение", "desc_uk": "Відкрити розділ Вимова", "desc_en": "Open the Pronunciation section",
|
|
||||||
"type": "pronunciation_opened", "value": 1},
|
|
||||||
|
|
||||||
{"code": "open_ai_assistant", "category": "general", "icon": "🤖",
|
|
||||||
"name_pl": "Asystent AI", "name_ru": "AI-помощник", "name_uk": "AI-помічник", "name_en": "AI Assistant",
|
|
||||||
"desc_pl": "Otwórz Asystenta AI", "desc_ru": "Открыть AI-помощника", "desc_uk": "Відкрити AI-помічника", "desc_en": "Open the AI Assistant",
|
|
||||||
"type": "ai_assistant_opened", "value": 1},
|
|
||||||
|
|
||||||
{"code": "open_alphabet", "category": "general", "icon": "🔤",
|
|
||||||
"name_pl": "Alfabetysta", "name_ru": "Алфавитист", "name_uk": "Алфавітист", "name_en": "Alphabetist",
|
|
||||||
"desc_pl": "Otwórz sekcję Alfabet", "desc_ru": "Открыть раздел Алфавит", "desc_uk": "Відкрити розділ Алфавіт", "desc_en": "Open the Alphabet section",
|
|
||||||
"type": "alphabet_opened", "value": 1},
|
|
||||||
|
|
||||||
{"code": "open_rules", "category": "general", "icon": "📐",
|
|
||||||
"name_pl": "Gramatyk", "name_ru": "Грамматик", "name_uk": "Граматик", "name_en": "Grammarian",
|
|
||||||
"desc_pl": "Otwórz sekcję Zasady", "desc_ru": "Открыть раздел Правила", "desc_uk": "Відкрити розділ Правила", "desc_en": "Open the Rules section",
|
|
||||||
"type": "rules_opened", "value": 1},
|
|
||||||
|
|
||||||
# 🔧 НОВОЕ: Достижение за открытие Прогресса
|
|
||||||
{"code": "open_progress", "category": "general", "icon": "📊",
|
|
||||||
"name_pl": "Planista", "name_ru": "Планировщик", "name_uk": "Планувальник", "name_en": "Planner",
|
|
||||||
"desc_pl": "Otwórz sekcję Postęp", "desc_ru": "Открыть раздел Прогресс", "desc_uk": "Відкрити розділ Прогрес", "desc_en": "Open the Progress section",
|
|
||||||
"type": "progress_opened", "value": 1},
|
|
||||||
]
|
]
|
||||||
|
|
||||||
|
|
||||||
@@ -323,6 +454,20 @@ async def init_achievements():
|
|||||||
requirement_value = EXCLUDED.requirement_value
|
requirement_value = EXCLUDED.requirement_value
|
||||||
""", rows)
|
""", rows)
|
||||||
|
|
||||||
|
# 🔧 Удаление осиротевших достижений (которых больше нет в ACHIEVEMENTS_DATA)
|
||||||
|
await conn.execute("""
|
||||||
|
DELETE FROM user_achievements
|
||||||
|
WHERE achievement_id IN (
|
||||||
|
SELECT id FROM achievements
|
||||||
|
WHERE code NOT IN (SELECT unnest($1::text[]))
|
||||||
|
)
|
||||||
|
""", [a["code"] for a in ACHIEVEMENTS_DATA])
|
||||||
|
|
||||||
|
await conn.execute("""
|
||||||
|
DELETE FROM achievements
|
||||||
|
WHERE code NOT IN (SELECT unnest($1::text[]))
|
||||||
|
""", [a["code"] for a in ACHIEVEMENTS_DATA])
|
||||||
|
|
||||||
logger.info(f"[achievements] init: upserted {len(rows)} achievements")
|
logger.info(f"[achievements] init: upserted {len(rows)} achievements")
|
||||||
|
|
||||||
|
|
||||||
|
|||||||
+131
-11
@@ -2,9 +2,15 @@
|
|||||||
Admin Router — админ-панель с реальной статистикой проекта.
|
Admin Router — админ-панель с реальной статистикой проекта.
|
||||||
1. /admin/dashboard — общая статистика (юзеры, онлайн, по уровням)
|
1. /admin/dashboard — общая статистика (юзеры, онлайн, по уровням)
|
||||||
2. /admin/sentry-errors — ошибки из Sentry (через API)
|
2. /admin/sentry-errors — ошибки из Sentry (через API)
|
||||||
|
3. /admin/sentry-stats — сводка по ошибкам Sentry
|
||||||
|
|
||||||
|
🔧 ОБНОВЛЕНО (01.10.2026):
|
||||||
|
- /sentry-errors: расширенные фильтры (period, status, level, q, limit)
|
||||||
|
- /sentry-stats: новый эндпоинт для сводки
|
||||||
"""
|
"""
|
||||||
import os
|
import os
|
||||||
import logging
|
import logging
|
||||||
|
from typing import Optional
|
||||||
import httpx
|
import httpx
|
||||||
from fastapi import APIRouter, Request, HTTPException
|
from fastapi import APIRouter, Request, HTTPException
|
||||||
from auth import require_auth
|
from auth import require_auth
|
||||||
@@ -102,10 +108,23 @@ async def get_admin_dashboard(request: Request):
|
|||||||
|
|
||||||
|
|
||||||
@router.get("/sentry-errors")
|
@router.get("/sentry-errors")
|
||||||
async def get_sentry_errors(request: Request):
|
async def get_sentry_errors(
|
||||||
|
request: Request,
|
||||||
|
period: str = "24h",
|
||||||
|
status: str = "unresolved",
|
||||||
|
level: Optional[str] = None,
|
||||||
|
q: Optional[str] = None,
|
||||||
|
limit: int = 50,
|
||||||
|
):
|
||||||
"""
|
"""
|
||||||
Последние ошибки из Sentry.
|
🔧 ОБНОВЛЕНО (01.10.2026): расширенные фильтры для Sentry.
|
||||||
Возвращает только unresolved (нерешённые) за последние 24 часа.
|
|
||||||
|
Параметры:
|
||||||
|
- period: '1h', '24h', '7d', '14d', '30d' (по умолчанию 24h)
|
||||||
|
- status: 'unresolved', 'resolved', 'all' (по умолчанию unresolved)
|
||||||
|
- level: 'error', 'warning', 'info', 'debug' (опционально)
|
||||||
|
- q: поиск по title
|
||||||
|
- limit: 1-100 (по умолчанию 50)
|
||||||
"""
|
"""
|
||||||
telegram_id, _ = await require_auth(request)
|
telegram_id, _ = await require_auth(request)
|
||||||
_require_admin(telegram_id)
|
_require_admin(telegram_id)
|
||||||
@@ -113,15 +132,47 @@ async def get_sentry_errors(request: Request):
|
|||||||
if not SENTRY_AUTH_TOKEN:
|
if not SENTRY_AUTH_TOKEN:
|
||||||
return {"errors": [], "error": "SENTRY_AUTH_TOKEN not configured"}
|
return {"errors": [], "error": "SENTRY_AUTH_TOKEN not configured"}
|
||||||
|
|
||||||
|
# Валидация
|
||||||
|
# 🔧 ФИКС (01.10.2026): sentry_free_plan_periods —
|
||||||
|
# Free plan Sentry поддерживает ТОЛЬКО '', '24h', '14d'.
|
||||||
|
# Остальные → 400 Bad Request.
|
||||||
|
if period not in ("", "24h", "14d"):
|
||||||
|
period = "24h"
|
||||||
|
if status not in ("unresolved", "resolved", "all"):
|
||||||
|
status = "unresolved"
|
||||||
|
if level and level not in ("error", "warning", "info", "debug", "fatal"):
|
||||||
|
level = None
|
||||||
|
if limit < 1:
|
||||||
|
limit = 1
|
||||||
|
elif limit > 100:
|
||||||
|
limit = 100
|
||||||
|
|
||||||
|
# Собираем query для Sentry
|
||||||
|
query_parts = []
|
||||||
|
if status == "unresolved":
|
||||||
|
query_parts.append("is:unresolved")
|
||||||
|
elif status == "resolved":
|
||||||
|
query_parts.append("is:resolved")
|
||||||
|
# 'all' — без фильтра статуса
|
||||||
|
|
||||||
|
if level:
|
||||||
|
query_parts.append(f"level:{level}")
|
||||||
|
|
||||||
|
if q and q.strip():
|
||||||
|
query_parts.append(q.strip())
|
||||||
|
|
||||||
|
query = " ".join(query_parts) if query_parts else ""
|
||||||
|
|
||||||
url = f"{SENTRY_API_BASE}/projects/{SENTRY_ORG_SLUG}/{SENTRY_PROJECT_SLUG}/issues/"
|
url = f"{SENTRY_API_BASE}/projects/{SENTRY_ORG_SLUG}/{SENTRY_PROJECT_SLUG}/issues/"
|
||||||
params = {
|
params = {
|
||||||
"query": "is:unresolved",
|
"statsPeriod": period,
|
||||||
"statsPeriod": "24h",
|
"limit": limit,
|
||||||
"limit": 20,
|
"sort": "freq", # сортировка по частоте
|
||||||
}
|
|
||||||
headers = {
|
|
||||||
"Authorization": f"Bearer {SENTRY_AUTH_TOKEN}",
|
|
||||||
}
|
}
|
||||||
|
if query:
|
||||||
|
params["query"] = query
|
||||||
|
|
||||||
|
headers = {"Authorization": f"Bearer {SENTRY_AUTH_TOKEN}"}
|
||||||
|
|
||||||
try:
|
try:
|
||||||
async with httpx.AsyncClient(timeout=10.0) as client:
|
async with httpx.AsyncClient(timeout=10.0) as client:
|
||||||
@@ -147,13 +198,82 @@ async def get_sentry_errors(request: Request):
|
|||||||
"last_seen": issue.get("lastSeen"),
|
"last_seen": issue.get("lastSeen"),
|
||||||
"permalink": issue.get("permalink"),
|
"permalink": issue.get("permalink"),
|
||||||
"priority": issue.get("priority"),
|
"priority": issue.get("priority"),
|
||||||
|
"status": issue.get("status"), # unresolved / resolved
|
||||||
|
"metadata": issue.get("metadata", {}),
|
||||||
})
|
})
|
||||||
|
|
||||||
return {"errors": errors, "count": len(errors)}
|
return {"errors": errors, "count": len(errors), "query": query or "(no filter)"}
|
||||||
|
|
||||||
except httpx.TimeoutException:
|
except httpx.TimeoutException:
|
||||||
logger.error("Sentry API timeout")
|
logger.error("Sentry API timeout")
|
||||||
return {"errors": [], "error": "Sentry API timeout"}
|
return {"errors": [], "error": "Sentry API timeout"}
|
||||||
except Exception as e:
|
except Exception as e:
|
||||||
logger.error(f"Sentry API unexpected error: {e}")
|
logger.error(f"Sentry API unexpected error: {e}")
|
||||||
return {"errors": [], "error": str(e)}
|
return {"errors": [], "error": str(e)}
|
||||||
|
|
||||||
|
|
||||||
|
@router.get("/sentry-stats")
|
||||||
|
async def get_sentry_stats(request: Request, period: str = "24h"):
|
||||||
|
"""
|
||||||
|
🔧 НОВОЕ (01.10.2026): сводка по ошибкам Sentry.
|
||||||
|
|
||||||
|
Возвращает:
|
||||||
|
- total_unresolved: всего нерешённых
|
||||||
|
- total_24h: новых за 24ч
|
||||||
|
- by_level: распределение по уровням (error / warning / info)
|
||||||
|
- top_culprits: топ-5 проблемных файлов
|
||||||
|
"""
|
||||||
|
telegram_id, _ = await require_auth(request)
|
||||||
|
_require_admin(telegram_id)
|
||||||
|
|
||||||
|
if not SENTRY_AUTH_TOKEN:
|
||||||
|
return {"error": "SENTRY_AUTH_TOKEN not configured"}
|
||||||
|
|
||||||
|
# 🔧 ФИКС (01.10.2026): sentry_free_plan_periods — только '', '24h', '14d'.
|
||||||
|
if period not in ("", "24h", "14d"):
|
||||||
|
period = "24h"
|
||||||
|
|
||||||
|
url = f"{SENTRY_API_BASE}/projects/{SENTRY_ORG_SLUG}/{SENTRY_PROJECT_SLUG}/issues/"
|
||||||
|
params = {
|
||||||
|
"query": "is:unresolved",
|
||||||
|
"statsPeriod": period,
|
||||||
|
"limit": 100,
|
||||||
|
}
|
||||||
|
headers = {"Authorization": f"Bearer {SENTRY_AUTH_TOKEN}"}
|
||||||
|
|
||||||
|
try:
|
||||||
|
async with httpx.AsyncClient(timeout=10.0) as client:
|
||||||
|
response = await client.get(url, params=params, headers=headers)
|
||||||
|
|
||||||
|
if response.status_code != 200:
|
||||||
|
return {"error": f"Sentry API: {response.status_code}"}
|
||||||
|
|
||||||
|
raw_issues = response.json()
|
||||||
|
|
||||||
|
# Считаем
|
||||||
|
by_level: dict = {}
|
||||||
|
culprits: dict = {}
|
||||||
|
|
||||||
|
for issue in raw_issues:
|
||||||
|
lvl = issue.get("level", "error")
|
||||||
|
by_level[lvl] = by_level.get(lvl, 0) + 1
|
||||||
|
|
||||||
|
culprit = issue.get("culprit", "unknown")
|
||||||
|
culprits[culprit] = culprits.get(culprit, 0) + int(issue.get("count", 0))
|
||||||
|
|
||||||
|
top_culprits = sorted(
|
||||||
|
[{"culprit": k, "count": v} for k, v in culprits.items()],
|
||||||
|
key=lambda x: x["count"],
|
||||||
|
reverse=True,
|
||||||
|
)[:5]
|
||||||
|
|
||||||
|
return {
|
||||||
|
"total_unresolved": len(raw_issues),
|
||||||
|
"by_level": by_level,
|
||||||
|
"top_culprits": top_culprits,
|
||||||
|
"period": period,
|
||||||
|
}
|
||||||
|
|
||||||
|
except Exception as e:
|
||||||
|
logger.error(f"Sentry stats error: {e}")
|
||||||
|
return {"error": str(e)}
|
||||||
@@ -0,0 +1,321 @@
|
|||||||
|
"""
|
||||||
|
Admin AI Router — универсальный AI-помощник в админке.
|
||||||
|
|
||||||
|
🔧 НОВОЕ (02.10.2026): floating AI widget в admin frontend.
|
||||||
|
|
||||||
|
Использует DeepSeek V4 Pro 0813 через Together AI:
|
||||||
|
- Модель: deepseek-ai/DeepSeek-V4-Pro-0813
|
||||||
|
- Reasoning: отключён для скорости (можно включить через body)
|
||||||
|
- Rate limit: 60 запросов/час на админа
|
||||||
|
"""
|
||||||
|
import logging
|
||||||
|
import time
|
||||||
|
from collections import defaultdict
|
||||||
|
|
||||||
|
import httpx
|
||||||
|
from fastapi import APIRouter, Request, HTTPException
|
||||||
|
from auth import require_auth
|
||||||
|
from config import TOGETHER_API_KEY, ADMIN_IDS
|
||||||
|
|
||||||
|
logger = logging.getLogger(__name__)
|
||||||
|
|
||||||
|
router = APIRouter(prefix="/admin/ai", tags=["admin-ai"])
|
||||||
|
|
||||||
|
TOGETHER_API_URL = "https://api.together.xyz/v1/chat/completions"
|
||||||
|
|
||||||
|
# 🔧 НОВОЕ (02.10.2026): DeepSeek V4 Pro — flagship, 1M контекст, 30+ языков
|
||||||
|
DEFAULT_MODEL = "deepseek-ai/DeepSeek-V4-Pro-0813"
|
||||||
|
|
||||||
|
# In-memory rate limit (60/час на юзера)
|
||||||
|
_admin_ai_usage: dict[int, list[float]] = defaultdict(list)
|
||||||
|
_ADMIN_AI_RATE_LIMIT = 60
|
||||||
|
_ADMIN_AI_RATE_WINDOW = 3600 # 1 час
|
||||||
|
|
||||||
|
|
||||||
|
DEFAULT_SYSTEM_PROMPT = """Ты — помощник преподавателя польского языка в приложении Filwords PL (Telegram Mini App для изучения польского).
|
||||||
|
|
||||||
|
Помогаешь создавать учебный контент:
|
||||||
|
- Задания для уроков (recognition — выбор варианта A/B/C/D)
|
||||||
|
- Дистракторы (неправильные, но похожие по смыслу варианты)
|
||||||
|
- Переводы на польский, русский, украинский, английский
|
||||||
|
- Грамматические пояснения
|
||||||
|
|
||||||
|
ПРАВИЛА:
|
||||||
|
1. Отвечай на языке пользователя (по умолчанию — русский).
|
||||||
|
2. Не используй markdown. Просто текст.
|
||||||
|
3. Для заданий-recognition: дай РОВНО 4 варианта (A, B, C, D).
|
||||||
|
4. Один вариант — правильный (отметь явно).
|
||||||
|
5. Три других — похожие по смыслу (та же часть речи, тот же контекст).
|
||||||
|
6. Указывай wrong_because для неправильных: wrong_word, wrong_case, wrong_context, wrong_gender, wrong_sentence_type, wrong_translation.
|
||||||
|
7. Если просят перевод — дай на все 4 языка (PL, RU, UK, EN).
|
||||||
|
8. Если просят контекст из БД — используй его, не выдумывай."""
|
||||||
|
|
||||||
|
|
||||||
|
def _check_rate_limit(user_id: int) -> bool:
|
||||||
|
"""Проверка: не превысил ли админ лимит."""
|
||||||
|
now = time.time()
|
||||||
|
# Чистим старые записи
|
||||||
|
_admin_ai_usage[user_id] = [
|
||||||
|
t for t in _admin_ai_usage[user_id]
|
||||||
|
if now - t < _ADMIN_AI_RATE_WINDOW
|
||||||
|
]
|
||||||
|
return len(_admin_ai_usage[user_id]) < _ADMIN_AI_RATE_LIMIT
|
||||||
|
|
||||||
|
|
||||||
|
def _increment_usage(user_id: int) -> None:
|
||||||
|
_admin_ai_usage[user_id].append(time.time())
|
||||||
|
|
||||||
|
|
||||||
|
@router.post("/chat")
|
||||||
|
async def admin_ai_chat(request: Request):
|
||||||
|
"""
|
||||||
|
🔧 НОВОЕ (02.10.2026): admin_ai_chat —
|
||||||
|
универсальный AI-помощник в админке.
|
||||||
|
|
||||||
|
Тело:
|
||||||
|
{
|
||||||
|
"message": "Придумай 4 варианта к заданию: ...",
|
||||||
|
"system_prompt": "опционально, переопределить дефолт",
|
||||||
|
"model": "deepseek-ai/DeepSeek-V4-Pro-0813", // опционально
|
||||||
|
"reasoning": false, // опционально, по умолчанию false
|
||||||
|
"context": "опционально, длинный контекст" // например, вся тема целиком
|
||||||
|
}
|
||||||
|
|
||||||
|
Возвращает:
|
||||||
|
{
|
||||||
|
"response": "...",
|
||||||
|
"model_used": "deepseek-ai/DeepSeek-V4-Pro-0813",
|
||||||
|
"tokens_used": 123
|
||||||
|
}
|
||||||
|
"""
|
||||||
|
telegram_id, _ = await require_auth(request)
|
||||||
|
|
||||||
|
if telegram_id not in ADMIN_IDS:
|
||||||
|
raise HTTPException(403, "Access denied")
|
||||||
|
|
||||||
|
if not _check_rate_limit(telegram_id):
|
||||||
|
raise HTTPException(429, f"Rate limit exceeded ({_ADMIN_AI_RATE_LIMIT}/hour)")
|
||||||
|
|
||||||
|
if not TOGETHER_API_KEY:
|
||||||
|
raise HTTPException(500, "TOGETHER_API_KEY not configured")
|
||||||
|
|
||||||
|
body = await request.json()
|
||||||
|
message = (body.get("message") or "").strip()
|
||||||
|
system_prompt = (body.get("system_prompt") or "").strip() or DEFAULT_SYSTEM_PROMPT
|
||||||
|
model = (body.get("model") or "").strip() or DEFAULT_MODEL
|
||||||
|
reasoning_enabled = bool(body.get("reasoning", False))
|
||||||
|
context = (body.get("context") or "").strip()
|
||||||
|
|
||||||
|
if not message:
|
||||||
|
raise HTTPException(400, "message is required")
|
||||||
|
|
||||||
|
if len(message) > 4000:
|
||||||
|
raise HTTPException(400, "message too long (max 4000)")
|
||||||
|
|
||||||
|
# Собираем user content: context + message
|
||||||
|
user_content = message
|
||||||
|
if context:
|
||||||
|
user_content = f"Контекст из БД:\n{context}\n\nЗадача:\n{message}"
|
||||||
|
|
||||||
|
# Отправляем в Together
|
||||||
|
try:
|
||||||
|
async with httpx.AsyncClient(timeout=120.0) as client:
|
||||||
|
response = await client.post(
|
||||||
|
TOGETHER_API_URL,
|
||||||
|
headers={
|
||||||
|
"Authorization": f"Bearer {TOGETHER_API_KEY}",
|
||||||
|
"Content-Type": "application/json",
|
||||||
|
},
|
||||||
|
json={
|
||||||
|
"model": model,
|
||||||
|
"messages": [
|
||||||
|
{"role": "system", "content": system_prompt},
|
||||||
|
{"role": "user", "content": user_content},
|
||||||
|
],
|
||||||
|
"max_tokens": 2000,
|
||||||
|
"temperature": 1.0, # 🔧 DeepSeek рекомендует 1.0
|
||||||
|
"reasoning": {"enabled": reasoning_enabled},
|
||||||
|
},
|
||||||
|
)
|
||||||
|
except httpx.TimeoutException:
|
||||||
|
raise HTTPException(504, "AI timeout (120s)")
|
||||||
|
|
||||||
|
if response.status_code != 200:
|
||||||
|
logger.error(f"[admin_ai] Together error: {response.status_code} {response.text[:300]}")
|
||||||
|
raise HTTPException(500, f"AI error: {response.status_code}")
|
||||||
|
|
||||||
|
data = response.json()
|
||||||
|
|
||||||
|
# Извлекаем ответ
|
||||||
|
try:
|
||||||
|
message_obj = data["choices"][0]["message"]
|
||||||
|
ai_response = message_obj.get("content") or message_obj.get("reasoning_content") or ""
|
||||||
|
except (KeyError, IndexError, TypeError) as e:
|
||||||
|
logger.error(f"[admin_ai] parse error: {e}")
|
||||||
|
raise HTTPException(500, "AI returned invalid response")
|
||||||
|
|
||||||
|
if not ai_response:
|
||||||
|
raise HTTPException(500, "AI returned empty response")
|
||||||
|
|
||||||
|
# Считаем токены
|
||||||
|
usage = data.get("usage", {})
|
||||||
|
tokens_used = usage.get("total_tokens", 0)
|
||||||
|
|
||||||
|
_increment_usage(telegram_id)
|
||||||
|
|
||||||
|
logger.info(
|
||||||
|
f"[admin_ai] user={telegram_id} model={model} tokens={tokens_used}"
|
||||||
|
)
|
||||||
|
|
||||||
|
return {
|
||||||
|
"response": ai_response.strip(),
|
||||||
|
"model_used": model,
|
||||||
|
"tokens_used": tokens_used,
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
@router.post("/translate")
|
||||||
|
async def admin_ai_translate(request: Request):
|
||||||
|
"""
|
||||||
|
🔧 НОВОЕ (02.10.2026): admin_ai_translate —
|
||||||
|
перевод текста на 4 языка (PL, RU, UK, EN).
|
||||||
|
|
||||||
|
Тело:
|
||||||
|
{
|
||||||
|
"text": "Podstawowe powitania",
|
||||||
|
"source_lang": "pl",
|
||||||
|
"target_langs": ["ru", "uk", "en"] // опционально, по умолчанию все кроме source
|
||||||
|
}
|
||||||
|
|
||||||
|
Возвращает:
|
||||||
|
{
|
||||||
|
"translations": {"ru": "...", "uk": "...", "en": "..."},
|
||||||
|
"source_lang": "pl"
|
||||||
|
}
|
||||||
|
"""
|
||||||
|
telegram_id, _ = await require_auth(request)
|
||||||
|
|
||||||
|
if telegram_id not in ADMIN_IDS:
|
||||||
|
raise HTTPException(403, "Access denied")
|
||||||
|
|
||||||
|
if not _check_rate_limit(telegram_id):
|
||||||
|
raise HTTPException(429, f"Rate limit exceeded ({_ADMIN_AI_RATE_LIMIT}/hour)")
|
||||||
|
|
||||||
|
if not TOGETHER_API_KEY:
|
||||||
|
raise HTTPException(500, "TOGETHER_API_KEY not configured")
|
||||||
|
|
||||||
|
body = await request.json()
|
||||||
|
text = (body.get("text") or "").strip()
|
||||||
|
source_lang = (body.get("source_lang") or "pl").strip().lower()
|
||||||
|
target_langs = body.get("target_langs") or ["ru", "uk", "en"]
|
||||||
|
|
||||||
|
if not text:
|
||||||
|
raise HTTPException(400, "text is required")
|
||||||
|
|
||||||
|
if len(text) > 3000:
|
||||||
|
raise HTTPException(400, "text too long (max 3000)")
|
||||||
|
|
||||||
|
if source_lang not in ("pl", "ru", "uk", "en"):
|
||||||
|
raise HTTPException(400, f"Invalid source_lang: {source_lang}")
|
||||||
|
|
||||||
|
# Валидация target_langs
|
||||||
|
valid_langs = {"pl", "ru", "uk", "en"}
|
||||||
|
target_langs = [l for l in target_langs if l in valid_langs and l != source_lang]
|
||||||
|
|
||||||
|
if not target_langs:
|
||||||
|
raise HTTPException(400, "No valid target_langs")
|
||||||
|
|
||||||
|
lang_names = {
|
||||||
|
"pl": "Polish", "ru": "Russian", "uk": "Ukrainian", "en": "English",
|
||||||
|
}
|
||||||
|
|
||||||
|
source_name = lang_names[source_lang]
|
||||||
|
targets_str = ", ".join([f'"{l}": "{lang_names[l]}"' for l in target_langs])
|
||||||
|
|
||||||
|
system_prompt = f"""Ты — переводчик. Переведи текст с {source_name} на указанные языки.
|
||||||
|
|
||||||
|
Верни СТРОГО JSON (без markdown, без пояснений) в формате:
|
||||||
|
{{
|
||||||
|
{targets_str}
|
||||||
|
}}
|
||||||
|
|
||||||
|
ПРАВИЛА:
|
||||||
|
- Переводи ТОЧНО, сохраняя смысл и стиль.
|
||||||
|
- Для терминов и названий — используй общепринятые варианты.
|
||||||
|
- Если текст — название урока/темы, переводи как название (с заглавной буквы).
|
||||||
|
- Если текст — объяснение, сохраняй переносы строк и форматирование.
|
||||||
|
- Не добавляй ничего кроме JSON."""
|
||||||
|
|
||||||
|
user_prompt = f"Текст для перевода:\n{text}"
|
||||||
|
|
||||||
|
try:
|
||||||
|
async with httpx.AsyncClient(timeout=60.0) as client:
|
||||||
|
response = await client.post(
|
||||||
|
TOGETHER_API_URL,
|
||||||
|
headers={
|
||||||
|
"Authorization": f"Bearer {TOGETHER_API_KEY}",
|
||||||
|
"Content-Type": "application/json",
|
||||||
|
},
|
||||||
|
json={
|
||||||
|
"model": DEFAULT_MODEL,
|
||||||
|
"messages": [
|
||||||
|
{"role": "system", "content": system_prompt},
|
||||||
|
{"role": "user", "content": user_prompt},
|
||||||
|
],
|
||||||
|
"max_tokens": 1500,
|
||||||
|
"temperature": 0.3, # Для перевода — низкая
|
||||||
|
"reasoning": {"enabled": False},
|
||||||
|
},
|
||||||
|
)
|
||||||
|
except httpx.TimeoutException:
|
||||||
|
raise HTTPException(504, "AI timeout")
|
||||||
|
|
||||||
|
if response.status_code != 200:
|
||||||
|
logger.error(f"[admin_ai] translate error: {response.status_code} {response.text[:300]}")
|
||||||
|
raise HTTPException(500, f"AI error: {response.status_code}")
|
||||||
|
|
||||||
|
data = response.json()
|
||||||
|
|
||||||
|
try:
|
||||||
|
message_obj = data["choices"][0]["message"]
|
||||||
|
raw = (message_obj.get("content") or "").strip()
|
||||||
|
except (KeyError, IndexError, TypeError):
|
||||||
|
raise HTTPException(500, "AI returned invalid response")
|
||||||
|
|
||||||
|
# Парсим JSON (снимаем ```json ... ``` если AI обернул)
|
||||||
|
import re as _re
|
||||||
|
import json as _json
|
||||||
|
|
||||||
|
if raw.startswith("```"):
|
||||||
|
raw = _re.sub(r'^```(?:json)?\s*', '', raw)
|
||||||
|
raw = _re.sub(r'\s*```$', '', raw)
|
||||||
|
|
||||||
|
json_match = _re.search(r'\{.*\}', raw, _re.DOTALL)
|
||||||
|
if not json_match:
|
||||||
|
logger.error(f"[admin_ai] no JSON in response: {raw[:200]}")
|
||||||
|
raise HTTPException(500, "AI returned no JSON")
|
||||||
|
|
||||||
|
try:
|
||||||
|
parsed = _json.loads(json_match.group(0))
|
||||||
|
except _json.JSONDecodeError as e:
|
||||||
|
logger.error(f"[admin_ai] JSON parse error: {e}, raw={raw[:300]}")
|
||||||
|
raise HTTPException(500, "AI returned invalid JSON")
|
||||||
|
|
||||||
|
translations = {}
|
||||||
|
for lang in target_langs:
|
||||||
|
value = parsed.get(lang, "")
|
||||||
|
translations[lang] = str(value).strip() if value else ""
|
||||||
|
|
||||||
|
tokens_used = data.get("usage", {}).get("total_tokens", 0)
|
||||||
|
_increment_usage(telegram_id)
|
||||||
|
|
||||||
|
logger.info(
|
||||||
|
f"[admin_ai] translate user={telegram_id} "
|
||||||
|
f"{source_lang} → {target_langs} tokens={tokens_used}"
|
||||||
|
)
|
||||||
|
|
||||||
|
return {
|
||||||
|
"translations": translations,
|
||||||
|
"source_lang": source_lang,
|
||||||
|
"tokens_used": tokens_used,
|
||||||
|
}
|
||||||
+1310
-8
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,242 @@
|
|||||||
|
"""
|
||||||
|
Admin Users Router — управление пользователями.
|
||||||
|
|
||||||
|
Доступ: только для ADMIN_IDS.
|
||||||
|
|
||||||
|
Эндпоинты:
|
||||||
|
- GET /admin/users?page=1&limit=50&level=&lang=&q=&active_24h= — список
|
||||||
|
- GET /admin/users/stats — сводка по уровням/языкам
|
||||||
|
|
||||||
|
🔧 ФИКС (30.09.2026): total_score = сумма 4 игр (wordsearch + sentences + quiz + bubbles).
|
||||||
|
"""
|
||||||
|
import logging
|
||||||
|
from typing import Optional
|
||||||
|
|
||||||
|
from fastapi import APIRouter, Request, HTTPException
|
||||||
|
from auth import require_auth
|
||||||
|
from database import get_pool
|
||||||
|
from config import ADMIN_IDS
|
||||||
|
|
||||||
|
logger = logging.getLogger(__name__)
|
||||||
|
|
||||||
|
router = APIRouter(prefix="/admin/users", tags=["admin-users"])
|
||||||
|
|
||||||
|
LEVELS = ["A1", "A2", "B1", "B2", "C1", "C2"]
|
||||||
|
LANGUAGES = ["pl", "ru", "uk", "en"]
|
||||||
|
|
||||||
|
|
||||||
|
def _require_admin(telegram_id: int) -> None:
|
||||||
|
if telegram_id not in ADMIN_IDS:
|
||||||
|
raise HTTPException(403, "Access denied")
|
||||||
|
|
||||||
|
|
||||||
|
@router.get("")
|
||||||
|
async def list_users(
|
||||||
|
request: Request,
|
||||||
|
page: int = 1,
|
||||||
|
limit: int = 50,
|
||||||
|
level: Optional[str] = None,
|
||||||
|
lang: Optional[str] = None,
|
||||||
|
q: Optional[str] = None,
|
||||||
|
active_24h: bool = False,
|
||||||
|
):
|
||||||
|
"""
|
||||||
|
🔧 НОВОЕ (30.09.2026): список пользователей с пагинацией.
|
||||||
|
|
||||||
|
Возвращает:
|
||||||
|
{
|
||||||
|
"total": 15,
|
||||||
|
"page": 1,
|
||||||
|
"limit": 50,
|
||||||
|
"pages": 1,
|
||||||
|
"users": [
|
||||||
|
{
|
||||||
|
"telegram_id": 123,
|
||||||
|
"username": "user",
|
||||||
|
"app_language": "ru",
|
||||||
|
"current_level": "A1",
|
||||||
|
"last_completed_level": 5,
|
||||||
|
"last_completed_by_level": {"A1": 5, "A2": 3},
|
||||||
|
"created_at": "...",
|
||||||
|
"last_login": "...",
|
||||||
|
"total_score": 1234,
|
||||||
|
"wordsearch_completed": 5,
|
||||||
|
"sentence_completed": 10,
|
||||||
|
"quiz_guessed": 20,
|
||||||
|
"bubble_completed": 8,
|
||||||
|
"levels_completed": 5
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
"""
|
||||||
|
telegram_id, _ = await require_auth(request)
|
||||||
|
_require_admin(telegram_id)
|
||||||
|
|
||||||
|
if page < 1:
|
||||||
|
page = 1
|
||||||
|
if limit < 1:
|
||||||
|
limit = 1
|
||||||
|
elif limit > 200:
|
||||||
|
limit = 200
|
||||||
|
|
||||||
|
offset = (page - 1) * limit
|
||||||
|
|
||||||
|
pool = await get_pool()
|
||||||
|
async with pool.acquire() as conn:
|
||||||
|
conditions = []
|
||||||
|
params: list = []
|
||||||
|
idx = 1
|
||||||
|
|
||||||
|
if level and level in LEVELS:
|
||||||
|
conditions.append(f"u.current_level = ${idx}")
|
||||||
|
params.append(level)
|
||||||
|
idx += 1
|
||||||
|
|
||||||
|
if lang and lang in LANGUAGES:
|
||||||
|
conditions.append(f"u.app_language = ${idx}")
|
||||||
|
params.append(lang)
|
||||||
|
idx += 1
|
||||||
|
|
||||||
|
if q and q.strip():
|
||||||
|
conditions.append(f"""(
|
||||||
|
CAST(u.telegram_id AS TEXT) ILIKE ${idx} OR
|
||||||
|
u.username ILIKE ${idx}
|
||||||
|
)""")
|
||||||
|
params.append(f"%{q.strip()}%")
|
||||||
|
idx += 1
|
||||||
|
|
||||||
|
if active_24h:
|
||||||
|
conditions.append(f"""
|
||||||
|
EXISTS (
|
||||||
|
SELECT 1 FROM daily_logins dl
|
||||||
|
WHERE dl.user_id = u.telegram_id
|
||||||
|
AND dl.login_date >= CURRENT_DATE - INTERVAL '1 day'
|
||||||
|
)
|
||||||
|
""")
|
||||||
|
|
||||||
|
where = ("WHERE " + " AND ".join(conditions)) if conditions else ""
|
||||||
|
|
||||||
|
# Total
|
||||||
|
total = await conn.fetchval(f"""
|
||||||
|
SELECT COUNT(*) FROM users u {where}
|
||||||
|
""", *params) or 0
|
||||||
|
|
||||||
|
# Page с агрегатами
|
||||||
|
rows = await conn.fetch(f"""
|
||||||
|
SELECT
|
||||||
|
u.telegram_id,
|
||||||
|
u.username,
|
||||||
|
u.app_language,
|
||||||
|
u.current_level,
|
||||||
|
u.last_completed_level,
|
||||||
|
u.last_completed_by_level,
|
||||||
|
u.created_at,
|
||||||
|
(SELECT MAX(login_date) FROM daily_logins WHERE user_id = u.telegram_id) AS last_login,
|
||||||
|
-- 🔧 ФИКС (30.09.2026): total_score теперь = сумма 4 игр
|
||||||
|
COALESCE((SELECT SUM(score) FROM user_progress
|
||||||
|
WHERE user_id = u.telegram_id AND completed_at IS NOT NULL), 0)
|
||||||
|
+ COALESCE((SELECT SUM(score) FROM sentence_progress
|
||||||
|
WHERE user_id = u.telegram_id AND completed_at IS NOT NULL), 0)
|
||||||
|
+ COALESCE((SELECT total_score FROM word_quiz_progress
|
||||||
|
WHERE user_id = u.telegram_id), 0)
|
||||||
|
+ COALESCE((SELECT total_score FROM bubble_words_progress
|
||||||
|
WHERE user_id = u.telegram_id), 0) AS total_score,
|
||||||
|
-- Уровни по играм
|
||||||
|
COALESCE((SELECT COUNT(*) FROM user_progress
|
||||||
|
WHERE user_id = u.telegram_id AND completed_at IS NOT NULL), 0) AS wordsearch_completed,
|
||||||
|
COALESCE((SELECT COUNT(*) FROM sentence_progress
|
||||||
|
WHERE user_id = u.telegram_id AND completed_at IS NOT NULL), 0) AS sentence_completed,
|
||||||
|
COALESCE((SELECT words_guessed FROM word_quiz_progress
|
||||||
|
WHERE user_id = u.telegram_id), 0) AS quiz_guessed,
|
||||||
|
COALESCE((SELECT levels_completed FROM bubble_words_progress
|
||||||
|
WHERE user_id = u.telegram_id), 0) AS bubble_completed
|
||||||
|
FROM users u
|
||||||
|
{where}
|
||||||
|
ORDER BY u.created_at DESC
|
||||||
|
LIMIT ${idx} OFFSET ${idx + 1}
|
||||||
|
""", *params, limit, offset)
|
||||||
|
|
||||||
|
pages = (total + limit - 1) // limit if limit > 0 else 1
|
||||||
|
|
||||||
|
return {
|
||||||
|
"total": total,
|
||||||
|
"page": page,
|
||||||
|
"limit": limit,
|
||||||
|
"pages": pages,
|
||||||
|
"users": [
|
||||||
|
{
|
||||||
|
"telegram_id": r["telegram_id"],
|
||||||
|
"username": r["username"],
|
||||||
|
"app_language": r["app_language"] or "pl",
|
||||||
|
"current_level": r["current_level"] or "A1",
|
||||||
|
"last_completed_level": r["last_completed_level"] or 0,
|
||||||
|
"last_completed_by_level": r["last_completed_by_level"] or {},
|
||||||
|
"created_at": r["created_at"].isoformat() if r["created_at"] else None,
|
||||||
|
"last_login": r["last_login"].isoformat() if r["last_login"] else None,
|
||||||
|
"total_score": r["total_score"] or 0,
|
||||||
|
"wordsearch_completed": r["wordsearch_completed"] or 0,
|
||||||
|
"sentence_completed": r["sentence_completed"] or 0,
|
||||||
|
"quiz_guessed": r["quiz_guessed"] or 0,
|
||||||
|
"bubble_completed": r["bubble_completed"] or 0,
|
||||||
|
"levels_completed": r["wordsearch_completed"] or 0, # backward compat
|
||||||
|
}
|
||||||
|
for r in rows
|
||||||
|
],
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
@router.get("/stats")
|
||||||
|
async def users_stats(request: Request):
|
||||||
|
"""
|
||||||
|
Сводка: пользователи по уровням и языкам.
|
||||||
|
"""
|
||||||
|
telegram_id, _ = await require_auth(request)
|
||||||
|
_require_admin(telegram_id)
|
||||||
|
|
||||||
|
pool = await get_pool()
|
||||||
|
async with pool.acquire() as conn:
|
||||||
|
# По уровням
|
||||||
|
by_level_rows = await conn.fetch("""
|
||||||
|
SELECT COALESCE(current_level, 'A1') AS level, COUNT(*) AS cnt
|
||||||
|
FROM users
|
||||||
|
GROUP BY current_level
|
||||||
|
ORDER BY
|
||||||
|
CASE current_level
|
||||||
|
WHEN 'A1' THEN 1 WHEN 'A2' THEN 2
|
||||||
|
WHEN 'B1' THEN 3 WHEN 'B2' THEN 4
|
||||||
|
WHEN 'C1' THEN 5 WHEN 'C2' THEN 6
|
||||||
|
ELSE 7
|
||||||
|
END
|
||||||
|
""")
|
||||||
|
by_level = {r["level"]: r["cnt"] for r in by_level_rows}
|
||||||
|
|
||||||
|
# По языкам
|
||||||
|
by_lang_rows = await conn.fetch("""
|
||||||
|
SELECT COALESCE(app_language, 'pl') AS lang, COUNT(*) AS cnt
|
||||||
|
FROM users
|
||||||
|
GROUP BY app_language
|
||||||
|
ORDER BY cnt DESC
|
||||||
|
""")
|
||||||
|
by_lang = {r["lang"]: r["cnt"] for r in by_lang_rows}
|
||||||
|
|
||||||
|
# Всего
|
||||||
|
total = await conn.fetchval("SELECT COUNT(*) FROM users") or 0
|
||||||
|
|
||||||
|
# Активных за 24ч
|
||||||
|
active_24h = await conn.fetchval("""
|
||||||
|
SELECT COUNT(DISTINCT user_id) FROM daily_logins
|
||||||
|
WHERE login_date >= CURRENT_DATE - INTERVAL '1 day'
|
||||||
|
""") or 0
|
||||||
|
|
||||||
|
# Новых сегодня
|
||||||
|
new_today = await conn.fetchval("""
|
||||||
|
SELECT COUNT(*) FROM users WHERE created_at >= CURRENT_DATE
|
||||||
|
""") or 0
|
||||||
|
|
||||||
|
return {
|
||||||
|
"total": total,
|
||||||
|
"by_level": by_level,
|
||||||
|
"by_lang": by_lang,
|
||||||
|
"active_24h": active_24h,
|
||||||
|
"new_today": new_today,
|
||||||
|
}
|
||||||
@@ -0,0 +1,738 @@
|
|||||||
|
"""
|
||||||
|
Admin Wordsearch Router — конструктор уровней филвордов.
|
||||||
|
|
||||||
|
Доступ: только для ADMIN_IDS.
|
||||||
|
Логика: препод создаёт уровни вручную через админку.
|
||||||
|
|
||||||
|
Эндпоинты:
|
||||||
|
- GET /admin/wordsearch/words?level=A1 — слова из CSV + счётчики
|
||||||
|
- GET /admin/wordsearch/levels?level=A1 — список созданных уровней
|
||||||
|
- GET /admin/wordsearch/level/{id} — один уровень (для редактирования)
|
||||||
|
- POST /admin/wordsearch/level — создать
|
||||||
|
- PUT /admin/wordsearch/level/{id} — обновить
|
||||||
|
- DELETE /admin/wordsearch/level/{id} — удалить
|
||||||
|
- POST /admin/wordsearch/validate — проверить корректность уровня
|
||||||
|
|
||||||
|
CRUD слов:
|
||||||
|
- GET /admin/wordsearch/words/all — полный список слов (с id)
|
||||||
|
- POST /admin/wordsearch/words — добавить слово
|
||||||
|
- PUT /admin/wordsearch/words/{word_id} — обновить слово
|
||||||
|
- DELETE /admin/wordsearch/words/{word_id} — удалить слово
|
||||||
|
|
||||||
|
🔧 ОБНОВЛЕНО (30.09.2026): /words/all — пагинация + total.
|
||||||
|
|
||||||
|
🔧 ОБНОВЛЕНО (03.10.2026): exclude_maxed_words —
|
||||||
|
/words не отдаёт слова с usage_count >= 5 (MAX_USAGE_COUNT).
|
||||||
|
"""
|
||||||
|
import json
|
||||||
|
import logging
|
||||||
|
from typing import Optional
|
||||||
|
|
||||||
|
from fastapi import APIRouter, Request, HTTPException
|
||||||
|
from auth import require_auth
|
||||||
|
from database import get_pool
|
||||||
|
from config import ADMIN_IDS
|
||||||
|
|
||||||
|
logger = logging.getLogger(__name__)
|
||||||
|
|
||||||
|
router = APIRouter(prefix="/admin/wordsearch", tags=["admin-wordsearch"])
|
||||||
|
|
||||||
|
LEVELS = ["A1", "A2", "B1", "B2", "C1", "C2"]
|
||||||
|
MAX_GRID_SIZE = 15
|
||||||
|
|
||||||
|
# 🔧 НОВОЕ (03.10.2026): MAX_USAGE_COUNT —
|
||||||
|
# слово считается «выгоревшим» после 5 использований и не отдаётся
|
||||||
|
# в конструктор. Хардкод, но легко вынести в конфиг.
|
||||||
|
MAX_USAGE_COUNT = 5
|
||||||
|
|
||||||
|
|
||||||
|
def _json_or_value(v):
|
||||||
|
"""🔧 ФИКС (30.09.2026): asyncpg_jsonb_string —
|
||||||
|
asyncpg возвращает JSONB как строку. Парсим, если строка."""
|
||||||
|
if isinstance(v, str):
|
||||||
|
try:
|
||||||
|
return json.loads(v)
|
||||||
|
except (json.JSONDecodeError, TypeError):
|
||||||
|
return v
|
||||||
|
return v
|
||||||
|
|
||||||
|
|
||||||
|
def _require_admin(telegram_id: int) -> None:
|
||||||
|
if telegram_id not in ADMIN_IDS:
|
||||||
|
raise HTTPException(403, "Access denied")
|
||||||
|
|
||||||
|
|
||||||
|
# ============ СЛОВА ИЗ CSV ============
|
||||||
|
|
||||||
|
@router.get("/words")
|
||||||
|
async def get_csv_words(request: Request, level: str = "A1"):
|
||||||
|
"""
|
||||||
|
Список слов из CSV для уровня с счётчиком использований.
|
||||||
|
|
||||||
|
Сортировка: сначала неиспользованные, потом по алфавиту.
|
||||||
|
|
||||||
|
🔧 ОБНОВЛЕНО (03.10.2026): exclude_maxed_words —
|
||||||
|
слова с usage_count >= MAX_USAGE_COUNT (5) «выгорели» (использованы
|
||||||
|
слишком много раз). Не отдаём их в конструктор, чтобы админ не мог
|
||||||
|
использовать повторно.
|
||||||
|
"""
|
||||||
|
telegram_id, _ = await require_auth(request)
|
||||||
|
_require_admin(telegram_id)
|
||||||
|
|
||||||
|
if level not in LEVELS:
|
||||||
|
raise HTTPException(400, f"Invalid level: {level}")
|
||||||
|
|
||||||
|
pool = await get_pool()
|
||||||
|
async with pool.acquire() as conn:
|
||||||
|
# 🔧 ОБНОВЛЕНО (03.10.2026): exclude_maxed_words —
|
||||||
|
# слова с usage_count >= 5 «выгорели» (использованы 5 раз).
|
||||||
|
# Не отдаём их в конструктор, чтобы админ не мог использовать
|
||||||
|
# повторно. Хардкод 5 = MAX_USAGE_COUNT.
|
||||||
|
rows = await conn.fetch("""
|
||||||
|
SELECT
|
||||||
|
w.word_pl,
|
||||||
|
w.translation_ru,
|
||||||
|
w.translation_uk,
|
||||||
|
w.translation_en,
|
||||||
|
COALESCE(u.usage_count, 0) AS usage_count
|
||||||
|
FROM csv_words w
|
||||||
|
LEFT JOIN word_usage u
|
||||||
|
ON u.word_pl = w.word_pl AND u.level_code = w.level_code
|
||||||
|
WHERE w.level_code = $1
|
||||||
|
AND COALESCE(u.usage_count, 0) < 5
|
||||||
|
ORDER BY COALESCE(u.usage_count, 0) ASC, w.word_pl ASC
|
||||||
|
""", level)
|
||||||
|
|
||||||
|
return {
|
||||||
|
"level": level,
|
||||||
|
"total": len(rows),
|
||||||
|
"words": [
|
||||||
|
{
|
||||||
|
"word_pl": r["word_pl"],
|
||||||
|
"translation_ru": r["translation_ru"] or "",
|
||||||
|
"translation_uk": r["translation_uk"] or "",
|
||||||
|
"translation_en": r["translation_en"] or "",
|
||||||
|
"usage_count": r["usage_count"],
|
||||||
|
}
|
||||||
|
for r in rows
|
||||||
|
],
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
# ============ УРОВНИ ============
|
||||||
|
|
||||||
|
@router.get("/levels")
|
||||||
|
async def list_levels(request: Request, level: Optional[str] = None):
|
||||||
|
"""Список созданных вручную уровней филвордов."""
|
||||||
|
telegram_id, _ = await require_auth(request)
|
||||||
|
_require_admin(telegram_id)
|
||||||
|
|
||||||
|
pool = await get_pool()
|
||||||
|
async with pool.acquire() as conn:
|
||||||
|
if level and level in LEVELS:
|
||||||
|
rows = await conn.fetch("""
|
||||||
|
SELECT id, level_number, grid_size, level, is_active, created_at,
|
||||||
|
jsonb_array_length(grid_letters) AS rows_count
|
||||||
|
FROM levels
|
||||||
|
WHERE created_by IS NOT NULL AND level = $1
|
||||||
|
ORDER BY level_number ASC, id ASC
|
||||||
|
""", level)
|
||||||
|
else:
|
||||||
|
rows = await conn.fetch("""
|
||||||
|
SELECT id, level_number, grid_size, level, is_active, created_at,
|
||||||
|
jsonb_array_length(grid_letters) AS rows_count
|
||||||
|
FROM levels
|
||||||
|
WHERE created_by IS NOT NULL
|
||||||
|
ORDER BY level, level_number ASC, id ASC
|
||||||
|
""")
|
||||||
|
|
||||||
|
return {
|
||||||
|
"total": len(rows),
|
||||||
|
"levels": [
|
||||||
|
{
|
||||||
|
"id": r["id"],
|
||||||
|
"level": r["level"],
|
||||||
|
"level_number": r["level_number"],
|
||||||
|
"grid_size": r["grid_size"],
|
||||||
|
"is_active": r["is_active"],
|
||||||
|
"created_at": r["created_at"].isoformat() if r["created_at"] else None,
|
||||||
|
}
|
||||||
|
for r in rows
|
||||||
|
],
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
@router.get("/level/{level_id}")
|
||||||
|
async def get_level(request: Request, level_id: int):
|
||||||
|
"""Один уровень целиком — для редактирования в конструкторе."""
|
||||||
|
telegram_id, _ = await require_auth(request)
|
||||||
|
_require_admin(telegram_id)
|
||||||
|
|
||||||
|
pool = await get_pool()
|
||||||
|
async with pool.acquire() as conn:
|
||||||
|
row = await conn.fetchrow("""
|
||||||
|
SELECT id, level_number, grid_size, level, grid_letters, word_paths,
|
||||||
|
is_active, created_by, created_at
|
||||||
|
FROM levels
|
||||||
|
WHERE id = $1 AND created_by IS NOT NULL
|
||||||
|
""", level_id)
|
||||||
|
|
||||||
|
if not row:
|
||||||
|
raise HTTPException(404, "Level not found")
|
||||||
|
|
||||||
|
# Слова уровня для списка размещённых
|
||||||
|
words_rows = await conn.fetch("""
|
||||||
|
SELECT word_pl, translation_ru, translation_uk, translation_en
|
||||||
|
FROM level_words
|
||||||
|
WHERE level_id = $1
|
||||||
|
""", level_id)
|
||||||
|
|
||||||
|
return {
|
||||||
|
"id": row["id"],
|
||||||
|
"level": row["level"],
|
||||||
|
"level_number": row["level_number"],
|
||||||
|
"grid_size": row["grid_size"],
|
||||||
|
"grid_letters": _json_or_value(row["grid_letters"]),
|
||||||
|
"word_paths": _json_or_value(row["word_paths"]),
|
||||||
|
"is_active": row["is_active"],
|
||||||
|
"created_at": row["created_at"].isoformat() if row["created_at"] else None,
|
||||||
|
"words": [
|
||||||
|
{
|
||||||
|
"word_pl": w["word_pl"],
|
||||||
|
"translation_ru": w["translation_ru"] or "",
|
||||||
|
"translation_uk": w["translation_uk"] or "",
|
||||||
|
"translation_en": w["translation_en"] or "",
|
||||||
|
}
|
||||||
|
for w in words_rows
|
||||||
|
],
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
def _validate_payload(payload: dict) -> tuple[int, list, dict]:
|
||||||
|
"""
|
||||||
|
Валидация grid_letters и word_paths.
|
||||||
|
|
||||||
|
Returns: (grid_size, grid_letters, word_paths)
|
||||||
|
Raises: HTTPException(400, ...)
|
||||||
|
"""
|
||||||
|
grid_size = payload.get("grid_size")
|
||||||
|
if not isinstance(grid_size, int) or grid_size < 3 or grid_size > MAX_GRID_SIZE:
|
||||||
|
raise HTTPException(400, f"grid_size must be 3-{MAX_GRID_SIZE}")
|
||||||
|
|
||||||
|
grid_letters = payload.get("grid_letters")
|
||||||
|
if not isinstance(grid_letters, list) or len(grid_letters) != grid_size:
|
||||||
|
raise HTTPException(400, "grid_letters must be a 2D array of size grid_size × grid_size")
|
||||||
|
|
||||||
|
for row in grid_letters:
|
||||||
|
if not isinstance(row, list) or len(row) != grid_size:
|
||||||
|
raise HTTPException(400, "each row of grid_letters must have grid_size elements")
|
||||||
|
for cell in row:
|
||||||
|
# Разрешаем: null (неактивная), "", либо одна буква
|
||||||
|
if cell is not None and (not isinstance(cell, str) or len(cell) > 1):
|
||||||
|
raise HTTPException(400, "cell must be null, '', or a single character")
|
||||||
|
|
||||||
|
word_paths = payload.get("word_paths")
|
||||||
|
if not isinstance(word_paths, dict):
|
||||||
|
raise HTTPException(400, "word_paths must be an object")
|
||||||
|
|
||||||
|
# Проверяем, что каждое слово в word_paths имеет корректный путь
|
||||||
|
for word, path in word_paths.items():
|
||||||
|
if not isinstance(word, str) or not word:
|
||||||
|
raise HTTPException(400, "word must be a non-empty string")
|
||||||
|
if not isinstance(path, list) or len(path) == 0:
|
||||||
|
raise HTTPException(400, f"path for '{word}' must be a non-empty array")
|
||||||
|
|
||||||
|
# Проверяем, что путь соседний (Manhattan distance 1)
|
||||||
|
for i in range(1, len(path)):
|
||||||
|
prev = path[i - 1]
|
||||||
|
cur = path[i]
|
||||||
|
if not (isinstance(prev, list) and len(prev) == 2 and
|
||||||
|
isinstance(cur, list) and len(cur) == 2):
|
||||||
|
raise HTTPException(400, f"path points for '{word}' must be [r, c]")
|
||||||
|
|
||||||
|
dr = abs(prev[0] - cur[0])
|
||||||
|
dc = abs(prev[1] - cur[1])
|
||||||
|
if not (dr <= 1 and dc <= 1 and (dr + dc) > 0):
|
||||||
|
raise HTTPException(400, f"path for '{word}' has non-adjacent cells")
|
||||||
|
|
||||||
|
# Проверяем, что буквы в клетках совпадают со словом
|
||||||
|
word_upper = word.upper()
|
||||||
|
if len(path) != len(word_upper):
|
||||||
|
raise HTTPException(
|
||||||
|
400,
|
||||||
|
f"path length for '{word}' ({len(path)}) != word length ({len(word_upper)})"
|
||||||
|
)
|
||||||
|
|
||||||
|
for i, (r, c) in enumerate(path):
|
||||||
|
if r < 0 or r >= grid_size or c < 0 or c >= grid_size:
|
||||||
|
raise HTTPException(400, f"path for '{word}' goes out of grid")
|
||||||
|
|
||||||
|
cell = grid_letters[r][c]
|
||||||
|
if cell != word_upper[i]:
|
||||||
|
raise HTTPException(
|
||||||
|
400,
|
||||||
|
f"grid[{r}][{c}] = {cell!r}, expected {word_upper[i]!r} for '{word}'"
|
||||||
|
)
|
||||||
|
|
||||||
|
return grid_size, grid_letters, word_paths
|
||||||
|
|
||||||
|
|
||||||
|
@router.post("/validate")
|
||||||
|
async def validate_level(request: Request):
|
||||||
|
"""Проверяет корректность уровня без сохранения."""
|
||||||
|
telegram_id, _ = await require_auth(request)
|
||||||
|
_require_admin(telegram_id)
|
||||||
|
|
||||||
|
body = await request.json()
|
||||||
|
try:
|
||||||
|
_validate_payload(body)
|
||||||
|
except HTTPException as e:
|
||||||
|
return {"valid": False, "error": e.detail}
|
||||||
|
return {"valid": True}
|
||||||
|
|
||||||
|
|
||||||
|
# ============ СОЗДАНИЕ / ОБНОВЛЕНИЕ ============
|
||||||
|
|
||||||
|
async def _upsert_level_words(conn, level_id: int, level_code: str, word_paths: dict):
|
||||||
|
"""Обновляет level_words и word_usage для уровня."""
|
||||||
|
# Получаем переводы из csv_words
|
||||||
|
words = list(word_paths.keys())
|
||||||
|
if not words:
|
||||||
|
return
|
||||||
|
|
||||||
|
rows = await conn.fetch("""
|
||||||
|
SELECT word_pl, translation_ru, translation_uk, translation_en
|
||||||
|
FROM csv_words
|
||||||
|
WHERE level_code = $1 AND word_pl = ANY($2::text[])
|
||||||
|
""", level_code, words)
|
||||||
|
|
||||||
|
translations_map = {r["word_pl"]: r for r in rows}
|
||||||
|
|
||||||
|
# Удаляем старые level_words
|
||||||
|
await conn.execute("DELETE FROM level_words WHERE level_id = $1", level_id)
|
||||||
|
|
||||||
|
# Вставляем новые
|
||||||
|
for word in words:
|
||||||
|
trans = translations_map.get(word, {})
|
||||||
|
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,
|
||||||
|
trans["translation_ru"] if trans else "",
|
||||||
|
trans["translation_uk"] if trans else "",
|
||||||
|
trans["translation_en"] if trans else "",
|
||||||
|
level_code,
|
||||||
|
)
|
||||||
|
|
||||||
|
|
||||||
|
@router.post("/level")
|
||||||
|
async def create_level(request: Request):
|
||||||
|
"""Создать новый уровень."""
|
||||||
|
telegram_id, _ = await require_auth(request)
|
||||||
|
_require_admin(telegram_id)
|
||||||
|
|
||||||
|
body = await request.json()
|
||||||
|
|
||||||
|
level_code = body.get("level", "A1")
|
||||||
|
if level_code not in LEVELS:
|
||||||
|
raise HTTPException(400, f"Invalid level: {level_code}")
|
||||||
|
|
||||||
|
level_number = body.get("level_number")
|
||||||
|
if not isinstance(level_number, int) or level_number < 1:
|
||||||
|
raise HTTPException(400, "level_number must be a positive integer")
|
||||||
|
|
||||||
|
is_active = bool(body.get("is_active", False))
|
||||||
|
|
||||||
|
grid_size, grid_letters, word_paths = _validate_payload(body)
|
||||||
|
|
||||||
|
pool = await get_pool()
|
||||||
|
async with pool.acquire() as conn:
|
||||||
|
async with conn.transaction():
|
||||||
|
# 🔧 ФИКС (29.09.2026): проверяем только РУЧНЫЕ уровни.
|
||||||
|
# Старые авто-сгенерированные (created_by IS NULL) не мешают.
|
||||||
|
existing = await conn.fetchval("""
|
||||||
|
SELECT id FROM levels
|
||||||
|
WHERE level = $1 AND level_number = $2 AND created_by IS NOT NULL
|
||||||
|
""", level_code, level_number)
|
||||||
|
if existing:
|
||||||
|
raise HTTPException(
|
||||||
|
409,
|
||||||
|
f"Level {level_code} #{level_number} already exists (id={existing})"
|
||||||
|
)
|
||||||
|
|
||||||
|
# 🔧 ФИКС (30.09.2026): asyncpg_jsonb_str —
|
||||||
|
# asyncpg требует json.dumps() для JSONB. Без него — DataError.
|
||||||
|
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, 'wordsearch', $3, $4, $5, $6, $7, NOW())
|
||||||
|
RETURNING id
|
||||||
|
""",
|
||||||
|
level_number, grid_size, level_code,
|
||||||
|
json.dumps(grid_letters), # 🔧 ФИКС (30.09.2026): asyncpg требует str для JSONB
|
||||||
|
json.dumps(word_paths), # 🔧 ФИКС (30.09.2026): то же
|
||||||
|
is_active, telegram_id,
|
||||||
|
)
|
||||||
|
level_id = row["id"]
|
||||||
|
|
||||||
|
# Обновляем level_words
|
||||||
|
await _upsert_level_words(conn, level_id, level_code, word_paths)
|
||||||
|
|
||||||
|
# Обновляем счётчики использований
|
||||||
|
for word in word_paths.keys():
|
||||||
|
await conn.execute("""
|
||||||
|
INSERT INTO word_usage (level_code, word_pl, usage_count, last_used_at)
|
||||||
|
VALUES ($1, $2, 1, NOW())
|
||||||
|
ON CONFLICT (level_code, word_pl)
|
||||||
|
DO UPDATE SET
|
||||||
|
usage_count = word_usage.usage_count + 1,
|
||||||
|
last_used_at = NOW()
|
||||||
|
""", level_code, word)
|
||||||
|
|
||||||
|
logger.info(
|
||||||
|
f"[admin_wordsearch] level created: {level_code} #{level_number} "
|
||||||
|
f"(id={level_id}, {len(word_paths)} words, active={is_active}) "
|
||||||
|
f"by admin {telegram_id}"
|
||||||
|
)
|
||||||
|
|
||||||
|
return {"status": "ok", "level_id": level_id}
|
||||||
|
|
||||||
|
|
||||||
|
@router.put("/level/{level_id}")
|
||||||
|
async def update_level(request: Request, level_id: int):
|
||||||
|
"""Обновить уровень."""
|
||||||
|
telegram_id, _ = await require_auth(request)
|
||||||
|
_require_admin(telegram_id)
|
||||||
|
|
||||||
|
body = await request.json()
|
||||||
|
|
||||||
|
pool = await get_pool()
|
||||||
|
async with pool.acquire() as conn:
|
||||||
|
existing = await conn.fetchrow("""
|
||||||
|
SELECT id, level, level_number, word_paths FROM levels
|
||||||
|
WHERE id = $1 AND created_by IS NOT NULL
|
||||||
|
""", level_id)
|
||||||
|
if not existing:
|
||||||
|
raise HTTPException(404, "Level not found")
|
||||||
|
|
||||||
|
level_code = existing["level"]
|
||||||
|
|
||||||
|
# 🔧 ФИКС (30.09.2026): usage_count_reflects_current —
|
||||||
|
# читаем старые слова, чтобы откатить их счётчики при замене.
|
||||||
|
old_word_paths_raw = existing["word_paths"]
|
||||||
|
old_word_paths = json.loads(old_word_paths_raw) if isinstance(old_word_paths_raw, str) else old_word_paths_raw
|
||||||
|
old_words = set(old_word_paths.keys())
|
||||||
|
|
||||||
|
grid_size, grid_letters, word_paths = _validate_payload(body)
|
||||||
|
|
||||||
|
is_active = bool(body.get("is_active", False))
|
||||||
|
|
||||||
|
async with conn.transaction():
|
||||||
|
# 🔧 ФИКС (30.09.2026): asyncpg_jsonb_str —
|
||||||
|
# asyncpg требует json.dumps() для JSONB. Без него — DataError.
|
||||||
|
await conn.execute("""
|
||||||
|
UPDATE levels
|
||||||
|
SET grid_size = $1,
|
||||||
|
grid_letters = $2,
|
||||||
|
word_paths = $3,
|
||||||
|
is_active = $4
|
||||||
|
WHERE id = $5
|
||||||
|
""",
|
||||||
|
grid_size,
|
||||||
|
json.dumps(grid_letters), # 🔧 ФИКС (30.09.2026): asyncpg требует str для JSONB
|
||||||
|
json.dumps(word_paths), # 🔧 ФИКС (30.09.2026): то же
|
||||||
|
is_active,
|
||||||
|
level_id,
|
||||||
|
)
|
||||||
|
|
||||||
|
await _upsert_level_words(conn, level_id, level_code, word_paths)
|
||||||
|
|
||||||
|
# 🔧 ФИКС (30.09.2026): usage_count_reflects_current —
|
||||||
|
# 1) Откатываем счётчики для слов, которых НЕТ в новом уровне.
|
||||||
|
# 2) Добавляем/инкрементим для новых слов.
|
||||||
|
# 3) Пересечение — не трогаем (last_used_at обновляем).
|
||||||
|
new_words = set(word_paths.keys())
|
||||||
|
words_added = new_words - old_words # новые слова
|
||||||
|
words_removed = old_words - new_words # убранные слова
|
||||||
|
|
||||||
|
# Откатываем счётчики для убранных
|
||||||
|
for word in words_removed:
|
||||||
|
await conn.execute("""
|
||||||
|
UPDATE word_usage
|
||||||
|
SET usage_count = GREATEST(0, usage_count - 1)
|
||||||
|
WHERE level_code = $1 AND word_pl = $2
|
||||||
|
""", level_code, word)
|
||||||
|
|
||||||
|
# Если счётчик = 0 — удаляем строку (чтобы не мусорить)
|
||||||
|
await conn.execute("""
|
||||||
|
DELETE FROM word_usage
|
||||||
|
WHERE level_code = $1 AND word_pl = $2 AND usage_count <= 0
|
||||||
|
""", level_code, word)
|
||||||
|
|
||||||
|
# Инкрементим для новых
|
||||||
|
for word in words_added:
|
||||||
|
await conn.execute("""
|
||||||
|
INSERT INTO word_usage (level_code, word_pl, usage_count, last_used_at)
|
||||||
|
VALUES ($1, $2, 1, NOW())
|
||||||
|
ON CONFLICT (level_code, word_pl)
|
||||||
|
DO UPDATE SET
|
||||||
|
usage_count = word_usage.usage_count + 1,
|
||||||
|
last_used_at = NOW()
|
||||||
|
""", level_code, word)
|
||||||
|
|
||||||
|
# Для пересечения — обновляем только last_used_at
|
||||||
|
for word in new_words & old_words:
|
||||||
|
await conn.execute("""
|
||||||
|
UPDATE word_usage
|
||||||
|
SET last_used_at = NOW()
|
||||||
|
WHERE level_code = $1 AND word_pl = $2
|
||||||
|
""", level_code, word)
|
||||||
|
|
||||||
|
logger.info(
|
||||||
|
f"[admin_wordsearch] level updated: id={level_id} "
|
||||||
|
f"({len(word_paths)} words, active={is_active}) "
|
||||||
|
f"by admin {telegram_id}"
|
||||||
|
)
|
||||||
|
|
||||||
|
return {"status": "ok", "level_id": level_id}
|
||||||
|
|
||||||
|
|
||||||
|
@router.delete("/level/{level_id}")
|
||||||
|
async def delete_level(request: Request, level_id: int):
|
||||||
|
"""Удалить уровень (только созданные вручную)."""
|
||||||
|
telegram_id, _ = await require_auth(request)
|
||||||
|
_require_admin(telegram_id)
|
||||||
|
|
||||||
|
pool = await get_pool()
|
||||||
|
async with pool.acquire() as conn:
|
||||||
|
row = await conn.fetchrow("""
|
||||||
|
SELECT id, level, level_number FROM levels
|
||||||
|
WHERE id = $1 AND created_by IS NOT NULL
|
||||||
|
""", level_id)
|
||||||
|
if not row:
|
||||||
|
raise HTTPException(404, "Level not found")
|
||||||
|
|
||||||
|
await conn.execute("DELETE FROM levels WHERE id = $1", level_id)
|
||||||
|
|
||||||
|
logger.info(
|
||||||
|
f"[admin_wordsearch] level deleted: id={level_id} "
|
||||||
|
f"({row['level']} #{row['level_number']}) by admin {telegram_id}"
|
||||||
|
)
|
||||||
|
|
||||||
|
return {"status": "ok", "level_id": level_id}
|
||||||
|
|
||||||
|
|
||||||
|
# ============ CRUD СЛОВ (csv_words) ============
|
||||||
|
|
||||||
|
@router.post("/words")
|
||||||
|
async def create_csv_word(request: Request):
|
||||||
|
"""Добавить слово в csv_words."""
|
||||||
|
telegram_id, _ = await require_auth(request)
|
||||||
|
_require_admin(telegram_id)
|
||||||
|
|
||||||
|
body = await request.json()
|
||||||
|
level_code = (body.get("level_code") or "").strip()
|
||||||
|
word_pl = (body.get("word_pl") or "").strip().lower()
|
||||||
|
translation_ru = (body.get("translation_ru") or "").strip()
|
||||||
|
translation_uk = (body.get("translation_uk") or "").strip()
|
||||||
|
translation_en = (body.get("translation_en") or "").strip()
|
||||||
|
|
||||||
|
if level_code not in LEVELS:
|
||||||
|
raise HTTPException(400, f"Invalid level: {level_code}")
|
||||||
|
if not word_pl:
|
||||||
|
raise HTTPException(400, "word_pl is required")
|
||||||
|
|
||||||
|
# 🔧 ФИКС (30.09.2026): global_duplicate_warning —
|
||||||
|
# проверяем все уровни. Если есть — возвращаем 409 с уровнем.
|
||||||
|
# Фронт покажет предупреждение + кнопку "Всё равно добавить".
|
||||||
|
# С флагом `force=true` — пропускаем проверку.
|
||||||
|
force = bool(body.get("force", False))
|
||||||
|
|
||||||
|
pool = await get_pool()
|
||||||
|
async with pool.acquire() as conn:
|
||||||
|
if not force:
|
||||||
|
existing = await conn.fetchrow("""
|
||||||
|
SELECT id, level_code FROM csv_words
|
||||||
|
WHERE LOWER(word_pl) = LOWER($1)
|
||||||
|
ORDER BY
|
||||||
|
CASE level_code
|
||||||
|
WHEN 'A1' THEN 1 WHEN 'A2' THEN 2
|
||||||
|
WHEN 'B1' THEN 3 WHEN 'B2' THEN 4
|
||||||
|
WHEN 'C1' THEN 5 WHEN 'C2' THEN 6
|
||||||
|
ELSE 7
|
||||||
|
END
|
||||||
|
LIMIT 1
|
||||||
|
""", word_pl)
|
||||||
|
|
||||||
|
if existing:
|
||||||
|
existing_level = existing["level_code"]
|
||||||
|
if existing_level == level_code:
|
||||||
|
raise HTTPException(
|
||||||
|
409,
|
||||||
|
f"DUPLICATE_SAME_LEVEL|{word_pl}|{existing_level}"
|
||||||
|
)
|
||||||
|
else:
|
||||||
|
raise HTTPException(
|
||||||
|
409,
|
||||||
|
f"DUPLICATE_OTHER_LEVEL|{word_pl}|{existing_level}"
|
||||||
|
)
|
||||||
|
|
||||||
|
row = await conn.fetchrow("""
|
||||||
|
INSERT INTO csv_words (level_code, word_pl, translation_ru, translation_uk, translation_en)
|
||||||
|
VALUES ($1, $2, $3, $4, $5)
|
||||||
|
RETURNING id
|
||||||
|
""", level_code, word_pl, translation_ru, translation_uk, translation_en)
|
||||||
|
|
||||||
|
logger.info(f"[admin_wordsearch] csv_word created: #{row['id']} '{word_pl}' in {level_code} by admin {telegram_id}")
|
||||||
|
return {"status": "ok", "word_id": row["id"]}
|
||||||
|
|
||||||
|
|
||||||
|
@router.put("/words/{word_id}")
|
||||||
|
async def update_csv_word(request: Request, word_id: int):
|
||||||
|
"""Обновить слово в csv_words."""
|
||||||
|
telegram_id, _ = await require_auth(request)
|
||||||
|
_require_admin(telegram_id)
|
||||||
|
|
||||||
|
body = await request.json()
|
||||||
|
word_pl = (body.get("word_pl") or "").strip().lower()
|
||||||
|
translation_ru = (body.get("translation_ru") or "").strip()
|
||||||
|
translation_uk = (body.get("translation_uk") or "").strip()
|
||||||
|
translation_en = (body.get("translation_en") or "").strip()
|
||||||
|
|
||||||
|
if not word_pl:
|
||||||
|
raise HTTPException(400, "word_pl is required")
|
||||||
|
|
||||||
|
pool = await get_pool()
|
||||||
|
async with pool.acquire() as conn:
|
||||||
|
existing = await conn.fetchrow("SELECT level_code, word_pl FROM csv_words WHERE id = $1", word_id)
|
||||||
|
if not existing:
|
||||||
|
raise HTTPException(404, "Word not found")
|
||||||
|
|
||||||
|
await conn.execute("""
|
||||||
|
UPDATE csv_words
|
||||||
|
SET word_pl = $1,
|
||||||
|
translation_ru = $2,
|
||||||
|
translation_uk = $3,
|
||||||
|
translation_en = $4
|
||||||
|
WHERE id = $5
|
||||||
|
""", word_pl, translation_ru, translation_uk, translation_en, word_id)
|
||||||
|
|
||||||
|
# 🔧 Синхронизируем с level_words (для филвордов)
|
||||||
|
await conn.execute("""
|
||||||
|
UPDATE level_words
|
||||||
|
SET word_pl = $1, translation_ru = $2, translation_uk = $3, translation_en = $4
|
||||||
|
WHERE word_pl = $5
|
||||||
|
""", word_pl, translation_ru, translation_uk, translation_en, existing["word_pl"])
|
||||||
|
|
||||||
|
logger.info(f"[admin_wordsearch] csv_word updated: #{word_id} '{existing['word_pl']}' -> '{word_pl}' by admin {telegram_id}")
|
||||||
|
return {"status": "ok", "word_id": word_id}
|
||||||
|
|
||||||
|
|
||||||
|
@router.delete("/words/{word_id}")
|
||||||
|
async def delete_csv_word(request: Request, word_id: int):
|
||||||
|
"""Удалить слово из csv_words."""
|
||||||
|
telegram_id, _ = await require_auth(request)
|
||||||
|
_require_admin(telegram_id)
|
||||||
|
|
||||||
|
pool = await get_pool()
|
||||||
|
async with pool.acquire() as conn:
|
||||||
|
existing = await conn.fetchrow("SELECT level_code, word_pl FROM csv_words WHERE id = $1", word_id)
|
||||||
|
if not existing:
|
||||||
|
raise HTTPException(404, "Word not found")
|
||||||
|
|
||||||
|
await conn.execute("DELETE FROM csv_words WHERE id = $1", word_id)
|
||||||
|
|
||||||
|
logger.info(f"[admin_wordsearch] csv_word deleted: #{word_id} '{existing['word_pl']}' by admin {telegram_id}")
|
||||||
|
return {"status": "ok", "word_id": word_id}
|
||||||
|
|
||||||
|
|
||||||
|
@router.get("/words/all")
|
||||||
|
async def list_all_csv_words(
|
||||||
|
request: Request,
|
||||||
|
level: Optional[str] = None,
|
||||||
|
q: Optional[str] = None,
|
||||||
|
page: int = 1,
|
||||||
|
limit: int = 50,
|
||||||
|
):
|
||||||
|
"""
|
||||||
|
🔧 ОБНОВЛЕНО (30.09.2026): пагинация + total.
|
||||||
|
|
||||||
|
Возвращает:
|
||||||
|
{
|
||||||
|
"total": 2446, # всего под фильтром
|
||||||
|
"page": 1, # текущая страница
|
||||||
|
"limit": 50, # размер страницы
|
||||||
|
"pages": 49, # всего страниц
|
||||||
|
"words": [...], # слова текущей страницы
|
||||||
|
}
|
||||||
|
"""
|
||||||
|
telegram_id, _ = await require_auth(request)
|
||||||
|
_require_admin(telegram_id)
|
||||||
|
|
||||||
|
if page < 1:
|
||||||
|
page = 1
|
||||||
|
if limit < 1:
|
||||||
|
limit = 1
|
||||||
|
elif limit > 500:
|
||||||
|
limit = 500
|
||||||
|
|
||||||
|
offset = (page - 1) * limit
|
||||||
|
|
||||||
|
pool = await get_pool()
|
||||||
|
async with pool.acquire() as conn:
|
||||||
|
# Условия
|
||||||
|
conditions = []
|
||||||
|
params: list = []
|
||||||
|
idx = 1
|
||||||
|
|
||||||
|
if level and level in LEVELS:
|
||||||
|
conditions.append(f"level_code = ${idx}")
|
||||||
|
params.append(level)
|
||||||
|
idx += 1
|
||||||
|
|
||||||
|
if q and q.strip():
|
||||||
|
conditions.append(f"""(
|
||||||
|
word_pl ILIKE ${idx} OR
|
||||||
|
translation_ru ILIKE ${idx} OR
|
||||||
|
translation_uk ILIKE ${idx} OR
|
||||||
|
translation_en ILIKE ${idx}
|
||||||
|
)""")
|
||||||
|
params.append(f"%{q.strip()}%")
|
||||||
|
idx += 1
|
||||||
|
|
||||||
|
where = ("WHERE " + " AND ".join(conditions)) if conditions else ""
|
||||||
|
|
||||||
|
# Общее количество
|
||||||
|
total = await conn.fetchval(f"""
|
||||||
|
SELECT COUNT(*) FROM csv_words {where}
|
||||||
|
""", *params) or 0
|
||||||
|
|
||||||
|
# Страница
|
||||||
|
rows = await conn.fetch(f"""
|
||||||
|
SELECT id, level_code, word_pl, translation_ru, translation_uk, translation_en
|
||||||
|
FROM csv_words
|
||||||
|
{where}
|
||||||
|
ORDER BY level_code, word_pl
|
||||||
|
LIMIT ${idx} OFFSET ${idx + 1}
|
||||||
|
""", *params, limit, offset)
|
||||||
|
|
||||||
|
pages = (total + limit - 1) // limit if limit > 0 else 1
|
||||||
|
|
||||||
|
return {
|
||||||
|
"total": total,
|
||||||
|
"page": page,
|
||||||
|
"limit": limit,
|
||||||
|
"pages": pages,
|
||||||
|
"words": [
|
||||||
|
{
|
||||||
|
"id": r["id"],
|
||||||
|
"level_code": r["level_code"],
|
||||||
|
"word_pl": r["word_pl"],
|
||||||
|
"translation_ru": r["translation_ru"] or "",
|
||||||
|
"translation_uk": r["translation_uk"] or "",
|
||||||
|
"translation_en": r["translation_en"] or "",
|
||||||
|
}
|
||||||
|
for r in rows
|
||||||
|
],
|
||||||
|
}
|
||||||
@@ -0,0 +1,287 @@
|
|||||||
|
"""
|
||||||
|
App Auth Router — авторизация мобильного приложения Pleily.
|
||||||
|
|
||||||
|
Поддерживает:
|
||||||
|
- Анонимный вход по device_id (UUID) → выдаёт JWT на 365 дней.
|
||||||
|
- Привязка Apple ID (позже).
|
||||||
|
- Удаление аккаунта (требование Apple App Store).
|
||||||
|
|
||||||
|
Pleily-юзеры имеют ОТРИЦАТЕЛЬНЫЙ telegram_id (из sequence app_user_id_seq).
|
||||||
|
Telegram-юзеры сохраняют свои положительные telegram_id.
|
||||||
|
|
||||||
|
Все Pleily-юзеры изолированы в auth_identities: связка (provider, provider_uid)
|
||||||
|
указывает на users.telegram_id. Так один юзер может иметь несколько способов входа.
|
||||||
|
|
||||||
|
Эндпоинты:
|
||||||
|
- POST /auth/device — вход по device_id
|
||||||
|
- GET /auth/me — текущий юзер (для тестов)
|
||||||
|
- 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
|
||||||
|
from datetime import datetime, timezone, timedelta
|
||||||
|
from typing import Optional
|
||||||
|
|
||||||
|
import asyncpg
|
||||||
|
import jwt
|
||||||
|
from fastapi import APIRouter, Request, HTTPException, Depends
|
||||||
|
|
||||||
|
from auth import require_auth
|
||||||
|
from database import get_pool
|
||||||
|
from config import APP_JWT_SECRET
|
||||||
|
|
||||||
|
logger = logging.getLogger(__name__)
|
||||||
|
|
||||||
|
router = APIRouter(prefix="/auth", tags=["app-auth"])
|
||||||
|
|
||||||
|
# JWT настройки
|
||||||
|
JWT_ALGORITHM = "HS256"
|
||||||
|
JWT_TTL_DAYS = 365
|
||||||
|
JWT_TTL = timedelta(days=JWT_TTL_DAYS)
|
||||||
|
|
||||||
|
|
||||||
|
# ============ JWT HELPERS ============
|
||||||
|
|
||||||
|
def make_app_jwt(user_id: int) -> str:
|
||||||
|
"""Создаёт JWT для Pleily-юзера. Payload: {user_id, exp, iat}."""
|
||||||
|
if not APP_JWT_SECRET:
|
||||||
|
raise RuntimeError("APP_JWT_SECRET not configured")
|
||||||
|
|
||||||
|
now = datetime.now(timezone.utc)
|
||||||
|
payload = {
|
||||||
|
"user_id": int(user_id),
|
||||||
|
"iat": int(now.timestamp()),
|
||||||
|
"exp": int((now + JWT_TTL).timestamp()),
|
||||||
|
}
|
||||||
|
return jwt.encode(payload, APP_JWT_SECRET, algorithm=JWT_ALGORITHM)
|
||||||
|
|
||||||
|
|
||||||
|
def verify_app_jwt(token: str) -> dict:
|
||||||
|
"""Проверяет JWT, возвращает payload. Бросает ValueError если невалиден."""
|
||||||
|
if not APP_JWT_SECRET:
|
||||||
|
raise ValueError("APP_JWT_SECRET not configured")
|
||||||
|
|
||||||
|
try:
|
||||||
|
payload = jwt.decode(token, APP_JWT_SECRET, algorithms=[JWT_ALGORITHM])
|
||||||
|
except jwt.ExpiredSignatureError:
|
||||||
|
raise ValueError("Token expired")
|
||||||
|
except jwt.InvalidTokenError as e:
|
||||||
|
raise ValueError(f"Invalid token: {e}")
|
||||||
|
|
||||||
|
if "user_id" not in payload:
|
||||||
|
raise ValueError("user_id missing in token payload")
|
||||||
|
|
||||||
|
return payload
|
||||||
|
|
||||||
|
|
||||||
|
# ============ ВСПОМОГАТЕЛЬНЫЕ ============
|
||||||
|
|
||||||
|
async def _find_user_by_device(conn, device_id: str) -> Optional[int]:
|
||||||
|
"""Ищет user_id по (provider='device', provider_uid=device_id)."""
|
||||||
|
row = await conn.fetchrow("""
|
||||||
|
SELECT user_id FROM auth_identities
|
||||||
|
WHERE provider = 'device' AND provider_uid = $1
|
||||||
|
""", device_id)
|
||||||
|
return row["user_id"] if row else None
|
||||||
|
|
||||||
|
|
||||||
|
async def _create_app_user(conn, device_id: str) -> int:
|
||||||
|
"""
|
||||||
|
Создаёт нового Pleily-юзера с отрицательным telegram_id
|
||||||
|
(из sequence app_user_id_seq) и связкой auth_identities.
|
||||||
|
Возвращает telegram_id (отрицательный).
|
||||||
|
"""
|
||||||
|
# nextval из sequence app_user_id_seq даёт -1, -2, -3, ...
|
||||||
|
uid_row = await conn.fetchrow("SELECT nextval('app_user_id_seq') AS uid")
|
||||||
|
uid = uid_row["uid"]
|
||||||
|
|
||||||
|
# 🔧 ФИКС (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, device_id)
|
||||||
|
VALUES ($1, $2, 'app', $3)
|
||||||
|
""", uid, f"app_user_{abs(uid)}", device_id)
|
||||||
|
|
||||||
|
# Создаём identity
|
||||||
|
await conn.execute("""
|
||||||
|
INSERT INTO auth_identities (user_id, provider, provider_uid)
|
||||||
|
VALUES ($1, 'device', $2)
|
||||||
|
""", uid, device_id)
|
||||||
|
|
||||||
|
logger.info(f"[app_auth] created Pleily user: telegram_id={uid}, device={device_id}")
|
||||||
|
return uid
|
||||||
|
|
||||||
|
|
||||||
|
# ============ ЭНДПОИНТЫ ============
|
||||||
|
|
||||||
|
@router.post("/device")
|
||||||
|
async def auth_device(request: Request):
|
||||||
|
"""
|
||||||
|
Вход по device_id.
|
||||||
|
Body: {"device_id": "uuid-string"}
|
||||||
|
|
||||||
|
Если юзер с таким device_id уже есть — выдаёт новый JWT.
|
||||||
|
Если нет — создаёт нового Pleily-юзера и выдаёт JWT.
|
||||||
|
|
||||||
|
Returns: {"status": "ok", "token": "...", "user_id": -1}
|
||||||
|
"""
|
||||||
|
body = await request.json()
|
||||||
|
device_id_raw = (body.get("device_id") or "").strip()
|
||||||
|
|
||||||
|
if not device_id_raw:
|
||||||
|
raise HTTPException(400, "device_id is required")
|
||||||
|
|
||||||
|
# Валидация UUID
|
||||||
|
try:
|
||||||
|
device_uuid = uuid.UUID(device_id_raw)
|
||||||
|
except (ValueError, AttributeError, TypeError):
|
||||||
|
raise HTTPException(400, "device_id must be a valid UUID")
|
||||||
|
|
||||||
|
device_id_str = str(device_uuid)
|
||||||
|
|
||||||
|
pool = await get_pool()
|
||||||
|
async with pool.acquire() as conn:
|
||||||
|
# Пытаемся найти существующего юзера
|
||||||
|
user_id = await _find_user_by_device(conn, device_id_str)
|
||||||
|
|
||||||
|
if user_id is None:
|
||||||
|
# Создаём нового — в транзакции, чтобы nextval + INSERT были атомарны
|
||||||
|
try:
|
||||||
|
async with conn.transaction():
|
||||||
|
user_id = await _create_app_user(conn, device_id_str)
|
||||||
|
except asyncpg.UniqueViolationError:
|
||||||
|
# 🔧 Гонка: два параллельных запроса с одним device_id.
|
||||||
|
# Один вставил, второй словил UniqueViolation на (provider, provider_uid).
|
||||||
|
# Просто перечитываем — юзер уже есть.
|
||||||
|
logger.warning(
|
||||||
|
f"[app_auth] race on device_id={device_id_str}, retrying SELECT"
|
||||||
|
)
|
||||||
|
user_id = await _find_user_by_device(conn, device_id_str)
|
||||||
|
if user_id is None:
|
||||||
|
raise HTTPException(500, "Failed to create or find user")
|
||||||
|
|
||||||
|
token = make_app_jwt(user_id)
|
||||||
|
logger.info(f"[app_auth] login device={device_id_str} → user_id={user_id}")
|
||||||
|
|
||||||
|
return {
|
||||||
|
"status": "ok",
|
||||||
|
"token": token,
|
||||||
|
"user_id": user_id,
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
@router.get("/me")
|
||||||
|
async def auth_me(request: Request):
|
||||||
|
"""
|
||||||
|
Текущий юзер + XP-поля.
|
||||||
|
|
||||||
|
🔧 НОВОЕ (08.10.2026): добавлены level, rank_key, rank_name,
|
||||||
|
xp_in_level, xp_needed, total_xp, weekly_xp.
|
||||||
|
"""
|
||||||
|
telegram_id, _ = await require_auth(request)
|
||||||
|
|
||||||
|
pool = await get_pool()
|
||||||
|
async with pool.acquire() as conn:
|
||||||
|
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
|
||||||
|
""",
|
||||||
|
telegram_id,
|
||||||
|
)
|
||||||
|
if not user:
|
||||||
|
raise HTTPException(401, "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,
|
||||||
|
)
|
||||||
|
|
||||||
|
# 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,
|
||||||
|
)
|
||||||
|
|
||||||
|
# Считаем уровень
|
||||||
|
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")
|
||||||
|
async def auth_delete_me(request: Request):
|
||||||
|
"""
|
||||||
|
Удаление аккаунта Pleily-юзера.
|
||||||
|
Требуется Apple App Store (право на удаление внутри приложения).
|
||||||
|
|
||||||
|
Требует Authorization: Bearer <JWT>.
|
||||||
|
Удаляем users по telegram_id — FK CASCADE подчистит все связанные
|
||||||
|
таблицы (auth_identities, learning_sessions, user_learning_answers и т.д.).
|
||||||
|
"""
|
||||||
|
user_id, _username = await require_auth(request)
|
||||||
|
|
||||||
|
pool = await get_pool()
|
||||||
|
async with pool.acquire() as conn:
|
||||||
|
# Проверяем существование
|
||||||
|
exists = await conn.fetchval(
|
||||||
|
"SELECT 1 FROM users WHERE telegram_id = $1", user_id
|
||||||
|
)
|
||||||
|
if not exists:
|
||||||
|
raise HTTPException(404, "User not found")
|
||||||
|
|
||||||
|
# Удаляем юзера — каскад подчистит auth_identities и остальное
|
||||||
|
await conn.execute(
|
||||||
|
"DELETE FROM users WHERE telegram_id = $1", user_id
|
||||||
|
)
|
||||||
|
|
||||||
|
logger.info(f"[app_auth] deleted Pleily user: telegram_id={user_id}")
|
||||||
|
return {"status": "ok", "user_id": user_id}
|
||||||
@@ -5,7 +5,6 @@ AI Assistant Router — чат-помощник с историей, конте
|
|||||||
"""
|
"""
|
||||||
import logging
|
import logging
|
||||||
import time
|
import time
|
||||||
import json
|
|
||||||
import httpx
|
import httpx
|
||||||
from fastapi import APIRouter, Request, HTTPException
|
from fastapi import APIRouter, Request, HTTPException
|
||||||
from auth import require_auth
|
from auth import require_auth
|
||||||
|
|||||||
+285
-56
@@ -1,6 +1,6 @@
|
|||||||
import random
|
import random
|
||||||
import time
|
|
||||||
import hashlib # 🔧 НОВОЕ: импорт hashlib для стабильного хэширования
|
import hashlib # 🔧 НОВОЕ: импорт hashlib для стабильного хэширования
|
||||||
|
import json
|
||||||
from fastapi import APIRouter, Request, HTTPException
|
from fastapi import APIRouter, Request, HTTPException
|
||||||
from auth import require_auth
|
from auth import require_auth
|
||||||
from database import get_pool
|
from database import get_pool
|
||||||
@@ -101,7 +101,7 @@ async def get_next_bubble_level(request: Request):
|
|||||||
pool = await get_pool()
|
pool = await get_pool()
|
||||||
async with pool.acquire() as conn:
|
async with pool.acquire() as conn:
|
||||||
user = await conn.fetchrow(
|
user = await conn.fetchrow(
|
||||||
"SELECT app_language, current_level FROM users WHERE telegram_id = $1", telegram_id
|
"SELECT app_language, current_level, difficulty FROM users WHERE telegram_id = $1", telegram_id
|
||||||
)
|
)
|
||||||
if not user:
|
if not user:
|
||||||
raise HTTPException(401, "User not registered")
|
raise HTTPException(401, "User not registered")
|
||||||
@@ -115,22 +115,17 @@ async def get_next_bubble_level(request: Request):
|
|||||||
)
|
)
|
||||||
current_bubble_level = (progress["levels_completed"] if progress else 0) + 1
|
current_bubble_level = (progress["levels_completed"] if progress else 0) + 1
|
||||||
|
|
||||||
# Прогрессия по количеству слов на уровне
|
# Количество слов по сложности
|
||||||
if current_bubble_level <= 10:
|
difficulty = user["difficulty"] if "difficulty" in user.keys() else "medium"
|
||||||
num_words = random.choice([3, 4])
|
num_words = {"easy": 3, "medium": 4, "hard": 5}.get(difficulty, 4)
|
||||||
elif current_bubble_level <= 25:
|
|
||||||
num_words = random.choice([5, 6])
|
|
||||||
else:
|
|
||||||
num_words = random.choice([7, 8])
|
|
||||||
|
|
||||||
# Запрос слов с фильтром по уровню и level_id IS NULL
|
# 🔧 ФИКС (30.09.2026): csv_words_source —
|
||||||
|
# источник слов переехал с level_words (старая схема level_id IS NULL)
|
||||||
|
# на csv_words (level_code). Один источник — CSV-база.
|
||||||
words = await conn.fetch("""
|
words = await conn.fetch("""
|
||||||
SELECT word_pl, translation_ru, translation_uk, translation_en
|
SELECT word_pl, translation_ru, translation_uk, translation_en
|
||||||
FROM (
|
FROM csv_words
|
||||||
SELECT DISTINCT ON (word_pl) word_pl, translation_ru, translation_uk, translation_en
|
WHERE level_code = $1
|
||||||
FROM level_words
|
|
||||||
WHERE level = $1 AND level_id IS NULL
|
|
||||||
) AS unique_words
|
|
||||||
ORDER BY RANDOM()
|
ORDER BY RANDOM()
|
||||||
LIMIT $2
|
LIMIT $2
|
||||||
""", current_level, num_words)
|
""", current_level, num_words)
|
||||||
@@ -164,22 +159,191 @@ async def get_next_bubble_level(request: Request):
|
|||||||
|
|
||||||
random.shuffle(all_parts)
|
random.shuffle(all_parts)
|
||||||
|
|
||||||
|
# 🔧 НОВОЕ (14.10.2026): сохраняем состояние уровня для подсказок
|
||||||
|
# и сбрасываем счётчики подсказок/списка при новом уровне.
|
||||||
|
level_state = [
|
||||||
|
{
|
||||||
|
"word_pl": w["word_pl"],
|
||||||
|
"translation": w["translation"],
|
||||||
|
"parts": w["parts"],
|
||||||
|
}
|
||||||
|
for w in result_words
|
||||||
|
]
|
||||||
|
await conn.execute("""
|
||||||
|
INSERT INTO bubble_words_progress
|
||||||
|
(user_id, levels_completed, total_score, level,
|
||||||
|
current_hints_used, current_list_opened, current_level_words, hinted_words)
|
||||||
|
VALUES ($1, 0, 0, $2, 0, 0, $3::jsonb, '{}')
|
||||||
|
ON CONFLICT (user_id) DO UPDATE
|
||||||
|
SET current_hints_used = 0,
|
||||||
|
current_list_opened = 0,
|
||||||
|
current_level_words = $3::jsonb,
|
||||||
|
hinted_words = '{}'
|
||||||
|
""", telegram_id, current_level, json.dumps(level_state))
|
||||||
|
|
||||||
return {
|
return {
|
||||||
"words": result_words,
|
"words": result_words,
|
||||||
"bubbles": all_parts,
|
"bubbles": all_parts,
|
||||||
"level": current_bubble_level,
|
"level": current_bubble_level,
|
||||||
|
"difficulty": user["difficulty"] or "medium",
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
@router.post("/first-part-hint")
|
||||||
|
async def first_part_hint(request: Request):
|
||||||
|
"""Подсказка «первая часть слова» — возвращает первый пузырь одного из несобранных слов.
|
||||||
|
|
||||||
|
🔧 НОВОЕ (14.10.2026): аналог GET /hints/first-letter/{level_id} из филворда.
|
||||||
|
Лимит 3 подсказки, штраф −20 (учитывается в /complete через current_hints_used).
|
||||||
|
Hard — запрещено (400).
|
||||||
|
"""
|
||||||
|
telegram_id, _ = await require_auth(request)
|
||||||
|
body = await request.json()
|
||||||
|
found_words = set(body.get("found_words", []) or [])
|
||||||
|
|
||||||
|
pool = await get_pool()
|
||||||
|
async with pool.acquire() as conn:
|
||||||
|
user = await conn.fetchrow(
|
||||||
|
"SELECT difficulty FROM users WHERE telegram_id = $1", telegram_id
|
||||||
|
)
|
||||||
|
if not user:
|
||||||
|
raise HTTPException(401, "User not registered")
|
||||||
|
|
||||||
|
difficulty = user["difficulty"] or "medium"
|
||||||
|
if difficulty == "hard":
|
||||||
|
raise HTTPException(400, "Hints are disabled on Hard difficulty")
|
||||||
|
|
||||||
|
progress = await conn.fetchrow(
|
||||||
|
"SELECT current_hints_used, current_level_words, hinted_words "
|
||||||
|
"FROM bubble_words_progress WHERE user_id = $1",
|
||||||
|
telegram_id
|
||||||
|
)
|
||||||
|
if not progress:
|
||||||
|
raise HTTPException(404, "No active level")
|
||||||
|
|
||||||
|
hints_used = progress["current_hints_used"] or 0
|
||||||
|
if hints_used >= 3:
|
||||||
|
raise HTTPException(400, "All hints used")
|
||||||
|
|
||||||
|
raw = progress["current_level_words"]
|
||||||
|
if isinstance(raw, str):
|
||||||
|
level_words = json.loads(raw) if raw else []
|
||||||
|
else:
|
||||||
|
level_words = raw or []
|
||||||
|
|
||||||
|
raw_hinted = progress["hinted_words"]
|
||||||
|
if isinstance(raw_hinted, str):
|
||||||
|
hinted = set(json.loads(raw_hinted)) if raw_hinted else set()
|
||||||
|
else:
|
||||||
|
hinted = set(raw_hinted or [])
|
||||||
|
|
||||||
|
# Слова, которые ещё не собраны и которым ещё не давали подсказку
|
||||||
|
candidates = [
|
||||||
|
w for w in level_words
|
||||||
|
if w.get("word_pl") not in found_words and w.get("word_pl") not in hinted
|
||||||
|
]
|
||||||
|
|
||||||
|
if not candidates:
|
||||||
|
raise HTTPException(400, "All words already hinted")
|
||||||
|
|
||||||
|
chosen = random.choice(candidates)
|
||||||
|
word_pl = chosen["word_pl"]
|
||||||
|
parts = chosen.get("parts") or []
|
||||||
|
first_part = parts[0] if parts else word_pl
|
||||||
|
|
||||||
|
new_hints = hints_used + 1
|
||||||
|
new_hinted = sorted(hinted | {word_pl})
|
||||||
|
|
||||||
|
await conn.execute("""
|
||||||
|
UPDATE bubble_words_progress
|
||||||
|
SET current_hints_used = $2,
|
||||||
|
hinted_words = $3
|
||||||
|
WHERE user_id = $1
|
||||||
|
""", telegram_id, new_hints, new_hinted)
|
||||||
|
|
||||||
|
return {
|
||||||
|
"word_pl": word_pl,
|
||||||
|
"first_part": first_part,
|
||||||
|
"hints_used_total": new_hints,
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
@router.post("/show-words")
|
||||||
|
async def show_words(request: Request):
|
||||||
|
"""Подсказка «показать слова» — возвращает все загаданные слова с переводами.
|
||||||
|
|
||||||
|
🔧 НОВОЕ (14.10.2026): аналог show-words из филворда.
|
||||||
|
Easy — без лимита. Medium — 1 раз (−20). Hard — запрещено (400).
|
||||||
|
"""
|
||||||
|
telegram_id, _ = await require_auth(request)
|
||||||
|
|
||||||
|
pool = await get_pool()
|
||||||
|
async with pool.acquire() as conn:
|
||||||
|
user = await conn.fetchrow(
|
||||||
|
"SELECT difficulty FROM users WHERE telegram_id = $1", telegram_id
|
||||||
|
)
|
||||||
|
if not user:
|
||||||
|
raise HTTPException(401, "User not registered")
|
||||||
|
|
||||||
|
difficulty = user["difficulty"] or "medium"
|
||||||
|
if difficulty == "hard":
|
||||||
|
raise HTTPException(400, "Word list is disabled on Hard difficulty")
|
||||||
|
|
||||||
|
progress = await conn.fetchrow(
|
||||||
|
"SELECT current_list_opened, current_level_words "
|
||||||
|
"FROM bubble_words_progress WHERE user_id = $1",
|
||||||
|
telegram_id
|
||||||
|
)
|
||||||
|
if not progress:
|
||||||
|
raise HTTPException(404, "No active level")
|
||||||
|
|
||||||
|
list_opened = progress["current_list_opened"] or 0
|
||||||
|
|
||||||
|
# Medium — список можно открыть только 1 раз
|
||||||
|
if difficulty == "medium" and list_opened >= 1:
|
||||||
|
raise HTTPException(400, "Word list already used on Medium difficulty")
|
||||||
|
|
||||||
|
raw = progress["current_level_words"]
|
||||||
|
if isinstance(raw, str):
|
||||||
|
level_words = json.loads(raw) if raw else []
|
||||||
|
else:
|
||||||
|
level_words = raw or []
|
||||||
|
|
||||||
|
words = [
|
||||||
|
{"word_pl": w.get("word_pl"), "translation": w.get("translation")}
|
||||||
|
for w in level_words
|
||||||
|
]
|
||||||
|
|
||||||
|
# Инкремент счётчика для Easy и Medium (Hard сюда не доходит)
|
||||||
|
new_list_opened = list_opened + 1
|
||||||
|
await conn.execute("""
|
||||||
|
UPDATE bubble_words_progress
|
||||||
|
SET current_list_opened = $2
|
||||||
|
WHERE user_id = $1
|
||||||
|
""", telegram_id, new_list_opened)
|
||||||
|
|
||||||
|
return {
|
||||||
|
"words": words,
|
||||||
|
"list_opened_total": new_list_opened,
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
@router.post("/complete")
|
@router.post("/complete")
|
||||||
async def complete_bubble_level(request: Request):
|
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)
|
telegram_id, _ = await require_auth(request)
|
||||||
body = await request.json()
|
body = await request.json()
|
||||||
words_count = body.get("words_count", 3)
|
words_count = body.get("words_count", 3)
|
||||||
completion_time = body.get("completion_time")
|
completion_time = body.get("completion_time")
|
||||||
# 🔧 ФИКС (24.09.2026): client_controlled_hints_bubblewords —
|
wrong_words = int(body.get("wrong_words", 0) or 0)
|
||||||
# hints_used больше НЕ берём от клиента. Читаем из bubble_words_progress.current_hints_used.
|
|
||||||
|
|
||||||
pool = await get_pool()
|
pool = await get_pool()
|
||||||
async with pool.acquire() as conn:
|
async with pool.acquire() as conn:
|
||||||
@@ -189,66 +353,120 @@ async def complete_bubble_level(request: Request):
|
|||||||
if not user_exists:
|
if not user_exists:
|
||||||
raise HTTPException(401, "User not registered")
|
raise HTTPException(401, "User not registered")
|
||||||
|
|
||||||
# Получаем current_level пользователя
|
user = await conn.fetchrow(
|
||||||
current_level = await conn.fetchval(
|
"SELECT current_level, difficulty FROM users WHERE telegram_id = $1", telegram_id
|
||||||
"SELECT current_level FROM users WHERE telegram_id = $1", telegram_id
|
)
|
||||||
) or "A1"
|
current_level = user["current_level"] or "A1"
|
||||||
|
difficulty = user["difficulty"] or "medium"
|
||||||
|
|
||||||
# 🔧 ФИКС (24.09.2026): client_controlled_hints_bubblewords —
|
# Читаем серверные счётчики (не из body)
|
||||||
# читаем серверный hints_used.
|
progress = await conn.fetchrow(
|
||||||
hints_used = await conn.fetchval(
|
"SELECT current_hints_used, current_list_opened "
|
||||||
"SELECT current_hints_used FROM bubble_words_progress WHERE user_id = $1",
|
"FROM bubble_words_progress WHERE user_id = $1",
|
||||||
telegram_id
|
telegram_id
|
||||||
) or 0
|
)
|
||||||
|
hints_used = (progress["current_hints_used"] if progress else 0) or 0
|
||||||
hints_used = min(max(0, hints_used), 3)
|
hints_used = min(max(0, hints_used), 3)
|
||||||
score = max(10, 100 - hints_used * 10)
|
list_opened = (progress["current_list_opened"] if progress else 0) or 0
|
||||||
|
|
||||||
|
# 🔧 НОВОЕ (14.10.2026): очки по формуле филворда.
|
||||||
|
# Hard — фикс 110. Easy/Medium — 100 − 20×hints − 20×list + bonus.
|
||||||
|
if difficulty == "hard":
|
||||||
|
if hints_used > 0 or list_opened:
|
||||||
|
raise HTTPException(
|
||||||
|
status_code=400,
|
||||||
|
detail="Hints and word list are disabled on Hard difficulty"
|
||||||
|
)
|
||||||
|
points = 110
|
||||||
|
else:
|
||||||
|
bonus = 10 if hints_used == 0 else 0
|
||||||
|
penalty_hints = 20 * hints_used
|
||||||
|
penalty_list = 0 if difficulty == "easy" else 20 * (1 if list_opened else 0)
|
||||||
|
points = max(20, min(110, 100 - penalty_hints - penalty_list + bonus))
|
||||||
|
|
||||||
|
# Начисляем XP
|
||||||
|
from services.xp import award_xp
|
||||||
|
xp_result = await award_xp(conn, telegram_id, "bubbles", points)
|
||||||
|
score = xp_result["points"]
|
||||||
|
|
||||||
|
# 🔧 НОВОЕ (15.10.2026): флаги для накопления серий.
|
||||||
|
no_hints_clean = 1 if (hints_used == 0 and not list_opened) else 0
|
||||||
|
perfect_clean = 1 if (hints_used == 0 and not list_opened and wrong_words == 0) else 0
|
||||||
|
|
||||||
await conn.execute("""
|
await conn.execute("""
|
||||||
INSERT INTO bubble_words_progress (user_id, levels_completed, total_score, level, current_hints_used)
|
INSERT INTO bubble_words_progress
|
||||||
VALUES ($1, 1, $2, $3, 0)
|
(user_id, levels_completed, total_score, level,
|
||||||
|
current_hints_used, current_list_opened, current_level_words, hinted_words,
|
||||||
|
words_collected, no_hints_streak, perfect_streak)
|
||||||
|
VALUES ($1, 1, $2, $3, 0, 0, '[]'::jsonb, '{}', $4, $5, $6)
|
||||||
ON CONFLICT (user_id) DO UPDATE
|
ON CONFLICT (user_id) DO UPDATE
|
||||||
SET levels_completed = bubble_words_progress.levels_completed + 1,
|
SET levels_completed = bubble_words_progress.levels_completed + 1,
|
||||||
total_score = bubble_words_progress.total_score + $2,
|
total_score = bubble_words_progress.total_score + $2,
|
||||||
level = $3,
|
level = $3,
|
||||||
current_hints_used = 0
|
current_hints_used = 0,
|
||||||
""", telegram_id, score, current_level)
|
current_list_opened = 0,
|
||||||
|
current_level_words = '[]'::jsonb,
|
||||||
|
hinted_words = '{}',
|
||||||
|
words_collected = COALESCE(bubble_words_progress.words_collected, 0) + $4,
|
||||||
|
no_hints_streak = CASE WHEN $5 = 1
|
||||||
|
THEN COALESCE(bubble_words_progress.no_hints_streak, 0) + 1 ELSE 0 END,
|
||||||
|
perfect_streak = CASE WHEN $6 = 1
|
||||||
|
THEN COALESCE(bubble_words_progress.perfect_streak, 0) + 1 ELSE 0 END
|
||||||
|
""", telegram_id, score, current_level, words_count, no_hints_clean, perfect_clean)
|
||||||
|
|
||||||
# 🔧 ФИКС (23.09.2026): achievements_nested_pool_acquire_bubblewords —
|
# 🔧 НОВОЕ (15.10.2026): читаем актуальные счётчики для проверки достижений.
|
||||||
# вызовы достижений вынесены за async with pool.acquire() (паттерн game.py).
|
stats = await conn.fetchrow("""
|
||||||
|
SELECT words_collected, no_hints_streak, perfect_streak, total_score
|
||||||
|
FROM bubble_words_progress WHERE user_id = $1
|
||||||
|
""", telegram_id)
|
||||||
|
words_collected = stats["words_collected"] or 0
|
||||||
|
no_hints_streak = stats["no_hints_streak"] or 0
|
||||||
|
perfect_streak = stats["perfect_streak"] or 0
|
||||||
|
bubble_total_score = stats["total_score"] or 0
|
||||||
|
|
||||||
|
# Данные для достижений
|
||||||
total_levels = await conn.fetchval(
|
total_levels = await conn.fetchval(
|
||||||
"SELECT levels_completed FROM bubble_words_progress WHERE user_id = $1",
|
"SELECT levels_completed FROM bubble_words_progress WHERE user_id = $1",
|
||||||
telegram_id
|
telegram_id
|
||||||
) or 0
|
) 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 = [
|
achievements_to_check = [
|
||||||
("bubble_levels", total_levels),
|
("bubble_levels", total_levels),
|
||||||
("total_score", grand_total),
|
("total_score", xp_result["total_xp"]),
|
||||||
]
|
]
|
||||||
if hints_used == 0:
|
if hints_used == 0:
|
||||||
achievements_to_check.append(("bubble_no_hints", 1))
|
achievements_to_check.append(("bubble_no_hints", 1))
|
||||||
if score == 100:
|
if hints_used == 0 and not list_opened and wrong_words == 0:
|
||||||
achievements_to_check.append(("bubble_perfect", 1))
|
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))
|
achievements_to_check.append(("bubble_speed_45", 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()
|
# 🔧 НОВОЕ (15.10.2026): триггеры новых достижений.
|
||||||
|
# bubble_words — всего слов собрано
|
||||||
|
achievements_to_check.append(("bubble_words", words_collected))
|
||||||
|
|
||||||
|
# bubble_no_mistakes — уровень без ошибок
|
||||||
|
if wrong_words == 0:
|
||||||
|
achievements_to_check.append(("bubble_no_mistakes", 1))
|
||||||
|
|
||||||
|
# bubble_streak — серия без подсказок (если > 0)
|
||||||
|
if no_hints_streak > 0:
|
||||||
|
achievements_to_check.append(("bubble_streak", no_hints_streak))
|
||||||
|
|
||||||
|
# bubble_xp — XP в пузырях (total_score — очки именно пузырей)
|
||||||
|
achievements_to_check.append(("bubble_xp", bubble_total_score))
|
||||||
|
|
||||||
|
# bubble_speed_15 — быстрее 15 сек
|
||||||
|
if completion_time is not None and 0 < completion_time <= 15:
|
||||||
|
achievements_to_check.append(("bubble_speed_15", 15))
|
||||||
|
|
||||||
|
# bubble_perfect_streak — серия идеальных (если > 0)
|
||||||
|
if perfect_streak > 0:
|
||||||
|
achievements_to_check.append(("bubble_perfect_streak", perfect_streak))
|
||||||
|
|
||||||
|
# Достижения — вне транзакции
|
||||||
from routers.achievements import check_and_award_achievements
|
from routers.achievements import check_and_award_achievements
|
||||||
new_achievements = []
|
new_achievements = []
|
||||||
for ach_type, value in achievements_to_check:
|
for ach_type, value in achievements_to_check:
|
||||||
@@ -260,6 +478,17 @@ async def complete_bubble_level(request: Request):
|
|||||||
"score": score,
|
"score": score,
|
||||||
"completion_time": completion_time,
|
"completion_time": completion_time,
|
||||||
"new_achievements": new_achievements,
|
"new_achievements": new_achievements,
|
||||||
|
# 🆕 XP-поля
|
||||||
|
"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(),
|
||||||
|
}
|
||||||
+180
-6
@@ -11,6 +11,8 @@ Feed Router — посты для карусели (новости / партн
|
|||||||
- POST /admin/feed/post/{id}/delete — удалить (вложения удалит CASCADE)
|
- POST /admin/feed/post/{id}/delete — удалить (вложения удалит CASCADE)
|
||||||
- POST /admin/feed/upload-image — загрузить картинку (multipart, до 3 на пост)
|
- POST /admin/feed/upload-image — загрузить картинку (multipart, до 3 на пост)
|
||||||
- POST /admin/feed/translate — перевести title+body вручную (без сохранения)
|
- POST /admin/feed/translate — перевести title+body вручную (без сохранения)
|
||||||
|
- GET /admin/feed/list — список постов для админки (пагинация, все 4 языка)
|
||||||
|
- GET /admin/feed/stats — быстрая статистика (total/drafts/published/pinned)
|
||||||
|
|
||||||
Логика локализации:
|
Логика локализации:
|
||||||
- В БД хранятся 4 версии поста (title_pl/ru/uk/en, body_pl/ru/uk/en).
|
- В БД хранятся 4 версии поста (title_pl/ru/uk/en, body_pl/ru/uk/en).
|
||||||
@@ -21,9 +23,8 @@ import logging
|
|||||||
import json
|
import json
|
||||||
import re
|
import re
|
||||||
import uuid
|
import uuid
|
||||||
import os
|
|
||||||
from pathlib import Path
|
from pathlib import Path
|
||||||
from typing import Optional, Any
|
from typing import Optional
|
||||||
|
|
||||||
import httpx
|
import httpx
|
||||||
from fastapi import APIRouter, Request, HTTPException, UploadFile, File, Form
|
from fastapi import APIRouter, Request, HTTPException, UploadFile, File, Form
|
||||||
@@ -45,7 +46,7 @@ logger = logging.getLogger(__name__)
|
|||||||
router = APIRouter(tags=["feed"])
|
router = APIRouter(tags=["feed"])
|
||||||
|
|
||||||
TOGETHER_API_URL = "https://api.together.xyz/v1/chat/completions"
|
TOGETHER_API_URL = "https://api.together.xyz/v1/chat/completions"
|
||||||
TRANSLATE_MODEL = "MiniMaxAI/MiniMax-M3"
|
TRANSLATE_MODEL = "deepseek-ai/DeepSeek-V4-Pro-0813"
|
||||||
|
|
||||||
# 🔧 ФИКС: бэк отдаёт полный URL картинки, чтобы фронт не гадал,
|
# 🔧 ФИКС: бэк отдаёт полный URL картинки, чтобы фронт не гадал,
|
||||||
# куда склеивать относительный путь /uploads/feed/...
|
# куда склеивать относительный путь /uploads/feed/...
|
||||||
@@ -252,7 +253,7 @@ async def translate_to_all_languages(
|
|||||||
{"role": "system", "content": system_prompt},
|
{"role": "system", "content": system_prompt},
|
||||||
{"role": "user", "content": user_prompt},
|
{"role": "user", "content": user_prompt},
|
||||||
],
|
],
|
||||||
"max_tokens": 2000,
|
"max_tokens": 4000,
|
||||||
"temperature": 0.3,
|
"temperature": 0.3,
|
||||||
},
|
},
|
||||||
)
|
)
|
||||||
@@ -322,7 +323,7 @@ async def admin_create_feed_post(request: Request):
|
|||||||
"expires_at": "2026-10-15T23:59:59Z" (опционально, для partners)
|
"expires_at": "2026-10-15T23:59:59Z" (опционально, для partners)
|
||||||
}
|
}
|
||||||
|
|
||||||
Backend автоматически переведёт title/body на 4 языка через MiniMax-M3.
|
Backend автоматически переведёт title/body на 4 языка через DeepSeek V4 Pro.
|
||||||
Если перевод упал — сохраняем source_language для всех языков (fallback).
|
Если перевод упал — сохраняем source_language для всех языков (fallback).
|
||||||
"""
|
"""
|
||||||
telegram_id, _ = await require_auth(request)
|
telegram_id, _ = await require_auth(request)
|
||||||
@@ -788,4 +789,177 @@ async def admin_translate_feed(request: Request):
|
|||||||
if not translations:
|
if not translations:
|
||||||
raise HTTPException(500, "Translation failed (AI unavailable or invalid response)")
|
raise HTTPException(500, "Translation failed (AI unavailable or invalid response)")
|
||||||
|
|
||||||
return translations
|
return translations
|
||||||
|
|
||||||
|
|
||||||
|
# ============ ADMIN: СПИСОК ПОСТОВ (с пагинацией) ============
|
||||||
|
|
||||||
|
@router.get("/admin/feed/list")
|
||||||
|
async def admin_list_feed_posts(
|
||||||
|
request: Request,
|
||||||
|
section: Optional[str] = None,
|
||||||
|
page: int = 1,
|
||||||
|
limit: int = 50,
|
||||||
|
include_drafts: bool = True,
|
||||||
|
q: Optional[str] = None,
|
||||||
|
):
|
||||||
|
"""
|
||||||
|
🔧 НОВОЕ (01.10.2026): admin_feed_list —
|
||||||
|
список постов для админки со ВСЕМИ 4 языками + пагинация.
|
||||||
|
|
||||||
|
Query:
|
||||||
|
section — news|partners|contacts|apps (опционально)
|
||||||
|
page — страница (с 1)
|
||||||
|
limit — размер страницы (по умолчанию 50, макс 100)
|
||||||
|
include_drafts — включать is_published=FALSE (по умолчанию True)
|
||||||
|
q — поиск по title_pl / body_pl (ILIKE)
|
||||||
|
|
||||||
|
Ответ:
|
||||||
|
{ total, page, limit, pages, posts: [...] }
|
||||||
|
"""
|
||||||
|
telegram_id, _ = await require_auth(request)
|
||||||
|
_require_admin(telegram_id)
|
||||||
|
|
||||||
|
# Валидация
|
||||||
|
if section and section not in FEED_SECTIONS:
|
||||||
|
raise HTTPException(400, f"Invalid section: {section}")
|
||||||
|
|
||||||
|
# Защита от дурака
|
||||||
|
page = max(1, page)
|
||||||
|
limit = max(1, min(100, limit))
|
||||||
|
|
||||||
|
pool = await get_pool()
|
||||||
|
async with pool.acquire() as conn:
|
||||||
|
where = []
|
||||||
|
params = []
|
||||||
|
idx = 1
|
||||||
|
|
||||||
|
if section:
|
||||||
|
where.append(f"section = ${idx}")
|
||||||
|
params.append(section)
|
||||||
|
idx += 1
|
||||||
|
|
||||||
|
if not include_drafts:
|
||||||
|
where.append("is_published = TRUE")
|
||||||
|
|
||||||
|
if q:
|
||||||
|
where.append(f"(title_pl ILIKE ${idx} OR body_pl ILIKE ${idx} OR title_ru ILIKE ${idx} OR body_ru ILIKE ${idx})")
|
||||||
|
params.append(f"%{q}%")
|
||||||
|
idx += 1
|
||||||
|
|
||||||
|
where_sql = "WHERE " + " AND ".join(where) if where else ""
|
||||||
|
|
||||||
|
# Общее количество
|
||||||
|
total = await conn.fetchval(
|
||||||
|
f"SELECT COUNT(*) FROM feed_posts {where_sql}",
|
||||||
|
*params,
|
||||||
|
) or 0
|
||||||
|
|
||||||
|
# Страница
|
||||||
|
offset = (page - 1) * limit
|
||||||
|
rows = await conn.fetch(f"""
|
||||||
|
SELECT * FROM feed_posts
|
||||||
|
{where_sql}
|
||||||
|
ORDER BY section, is_pinned DESC, created_at DESC
|
||||||
|
LIMIT ${idx} OFFSET ${idx + 1}
|
||||||
|
""", *params, limit, offset)
|
||||||
|
|
||||||
|
if not rows:
|
||||||
|
return {
|
||||||
|
"total": total,
|
||||||
|
"page": page,
|
||||||
|
"limit": limit,
|
||||||
|
"pages": (total + limit - 1) // limit,
|
||||||
|
"posts": [],
|
||||||
|
}
|
||||||
|
|
||||||
|
# Вложения одним запросом (без N+1)
|
||||||
|
post_ids = [r["id"] for r in rows]
|
||||||
|
att_rows = await conn.fetch("""
|
||||||
|
SELECT post_id, file_path, order_number
|
||||||
|
FROM feed_attachments
|
||||||
|
WHERE post_id = ANY($1::bigint[])
|
||||||
|
ORDER BY post_id, order_number ASC
|
||||||
|
""", post_ids)
|
||||||
|
|
||||||
|
att_by_post: dict[int, list] = {}
|
||||||
|
for a in att_rows:
|
||||||
|
att_by_post.setdefault(a["post_id"], []).append(dict(a))
|
||||||
|
|
||||||
|
# Собираем результат
|
||||||
|
posts = []
|
||||||
|
for r in rows:
|
||||||
|
row = dict(r)
|
||||||
|
attachments = att_by_post.get(r["id"], [])
|
||||||
|
images = [
|
||||||
|
f"{API_PUBLIC_URL}{a['file_path']}" if a["file_path"].startswith("/") else a["file_path"]
|
||||||
|
for a in attachments
|
||||||
|
]
|
||||||
|
posts.append({
|
||||||
|
"id": row["id"],
|
||||||
|
"section": row["section"],
|
||||||
|
"source_language": row.get("source_language"),
|
||||||
|
"is_pinned": bool(row.get("is_pinned")),
|
||||||
|
"is_published": bool(row.get("is_published")),
|
||||||
|
"link_url": row.get("link_url"),
|
||||||
|
"telegram_url": row.get("telegram_url"),
|
||||||
|
"created_at": row["created_at"].isoformat() if row.get("created_at") else None,
|
||||||
|
"updated_at": row["updated_at"].isoformat() if row.get("updated_at") else None,
|
||||||
|
"expires_at": row["expires_at"].isoformat() if row.get("expires_at") else None,
|
||||||
|
"images": images,
|
||||||
|
# все 4 языка
|
||||||
|
"title_pl": row.get("title_pl") or "",
|
||||||
|
"title_ru": row.get("title_ru") or "",
|
||||||
|
"title_uk": row.get("title_uk") or "",
|
||||||
|
"title_en": row.get("title_en") or "",
|
||||||
|
"body_pl": row.get("body_pl") or "",
|
||||||
|
"body_ru": row.get("body_ru") or "",
|
||||||
|
"body_uk": row.get("body_uk") or "",
|
||||||
|
"body_en": row.get("body_en") or "",
|
||||||
|
})
|
||||||
|
|
||||||
|
return {
|
||||||
|
"total": total,
|
||||||
|
"page": page,
|
||||||
|
"limit": limit,
|
||||||
|
"pages": (total + limit - 1) // limit,
|
||||||
|
"posts": posts,
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
# ============ ADMIN: СТАТИСТИКА ДЛЯ БЕЙДЖА ============
|
||||||
|
|
||||||
|
@router.get("/admin/feed/stats")
|
||||||
|
async def admin_feed_stats(request: Request):
|
||||||
|
"""
|
||||||
|
🔧 НОВОЕ (01.10.2026): admin_feed_stats —
|
||||||
|
быстрая статистика для бейджа в сайдбаре.
|
||||||
|
|
||||||
|
Ответ:
|
||||||
|
{
|
||||||
|
"total": 42, — всего постов
|
||||||
|
"drafts": 2, — черновиков (is_published=FALSE)
|
||||||
|
"published": 40, — опубликованных
|
||||||
|
"pinned": 3 — закреплённых
|
||||||
|
}
|
||||||
|
"""
|
||||||
|
telegram_id, _ = await require_auth(request)
|
||||||
|
_require_admin(telegram_id)
|
||||||
|
|
||||||
|
pool = await get_pool()
|
||||||
|
async with pool.acquire() as conn:
|
||||||
|
row = await conn.fetchrow("""
|
||||||
|
SELECT
|
||||||
|
COUNT(*) AS total,
|
||||||
|
COUNT(*) FILTER (WHERE is_published = FALSE) AS drafts,
|
||||||
|
COUNT(*) FILTER (WHERE is_published = TRUE) AS published,
|
||||||
|
COUNT(*) FILTER (WHERE is_pinned = TRUE) AS pinned
|
||||||
|
FROM feed_posts
|
||||||
|
""")
|
||||||
|
|
||||||
|
return {
|
||||||
|
"total": int(row["total"] or 0),
|
||||||
|
"drafts": int(row["drafts"] or 0),
|
||||||
|
"published": int(row["published"] or 0),
|
||||||
|
"pinned": int(row["pinned"] or 0),
|
||||||
|
}
|
||||||
+481
-43
@@ -13,7 +13,8 @@ async def get_progress(request: Request):
|
|||||||
pool = await get_pool()
|
pool = await get_pool()
|
||||||
async with pool.acquire() as conn:
|
async with pool.acquire() as conn:
|
||||||
user = await conn.fetchrow(
|
user = await conn.fetchrow(
|
||||||
"SELECT last_completed_level, current_level FROM users WHERE telegram_id = $1",
|
"""SELECT last_completed_level, current_level, last_completed_by_level
|
||||||
|
FROM users WHERE telegram_id = $1""",
|
||||||
telegram_id
|
telegram_id
|
||||||
)
|
)
|
||||||
|
|
||||||
@@ -25,7 +26,13 @@ async def get_progress(request: Request):
|
|||||||
}
|
}
|
||||||
|
|
||||||
current_level = user["current_level"] or "A1"
|
current_level = user["current_level"] or "A1"
|
||||||
|
|
||||||
|
# 🔧 ОБНОВЛЕНО (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
|
||||||
|
|
||||||
# Очки из филвордов
|
# Очки из филвордов
|
||||||
wordsearch_score = await conn.fetchval(
|
wordsearch_score = await conn.fetchval(
|
||||||
"SELECT COALESCE(SUM(score), 0) FROM user_progress WHERE user_id = $1",
|
"SELECT COALESCE(SUM(score), 0) FROM user_progress WHERE user_id = $1",
|
||||||
@@ -53,7 +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)
|
total_score = (wordsearch_score or 0) + (sentence_score or 0) + (wordquiz_score or 0) + (bubblewords_score or 0)
|
||||||
|
|
||||||
return {
|
return {
|
||||||
"last_completed_level": user["last_completed_level"] or 0,
|
"last_completed_level": last_completed,
|
||||||
"total_score": total_score,
|
"total_score": total_score,
|
||||||
"current_level": current_level
|
"current_level": current_level
|
||||||
}
|
}
|
||||||
@@ -66,7 +73,7 @@ async def get_level(request: Request, level_number: int):
|
|||||||
pool = await get_pool()
|
pool = await get_pool()
|
||||||
async with pool.acquire() as conn:
|
async with pool.acquire() as conn:
|
||||||
user = await conn.fetchrow(
|
user = await conn.fetchrow(
|
||||||
"SELECT app_language, current_level, last_completed_level FROM users WHERE telegram_id = $1", telegram_id
|
"SELECT app_language, current_level, last_completed_level, last_completed_by_level, difficulty FROM users WHERE telegram_id = $1", telegram_id
|
||||||
)
|
)
|
||||||
|
|
||||||
if not user:
|
if not user:
|
||||||
@@ -74,20 +81,43 @@ async def get_level(request: Request, level_number: int):
|
|||||||
|
|
||||||
lang = user["app_language"] or "pl"
|
lang = user["app_language"] or "pl"
|
||||||
current_level = user["current_level"] or "A1"
|
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
|
last_completed = user["last_completed_level"] or 0
|
||||||
|
|
||||||
# Проверяем, что уровень доступен (не дальше следующего за пройденным)
|
# 🔧 ОБНОВЛЕНО (07.10.2026): все уровни — common (автогенерированные).
|
||||||
if level_number > 1 and level_number > last_completed + 1:
|
# Ищем по level_number без created_by и без current_level.
|
||||||
raise HTTPException(403, "Level not available yet. Complete previous level first.")
|
# is_active = TRUE — чтобы черновики не показывались.
|
||||||
|
level = await conn.fetchrow("""
|
||||||
|
SELECT * FROM levels
|
||||||
|
WHERE level_number = $1
|
||||||
|
AND is_active = TRUE
|
||||||
|
LIMIT 1
|
||||||
|
""", level_number)
|
||||||
|
|
||||||
# Получаем уровень по его номеру ВНУТРИ выбранного уровня
|
|
||||||
level = await conn.fetchrow(
|
|
||||||
"SELECT * FROM levels WHERE level = $1 AND level_number = $2", current_level, level_number
|
|
||||||
)
|
|
||||||
|
|
||||||
if not level:
|
if not level:
|
||||||
raise HTTPException(404, "Level not found")
|
raise HTTPException(404, "Level not found")
|
||||||
|
|
||||||
|
# 🔧 ФИКС (10.10.2026): доступ к уровню по user_seen_levels.
|
||||||
|
# Раньше проверяли level_number > last_completed + 1 — это ломало
|
||||||
|
# волновую выдачу, где уровни идут вперемешку (5×5 → 6×6 → ...).
|
||||||
|
# Теперь уровень доступен, если игрок получил его через /game/next
|
||||||
|
# (есть в user_seen_levels) или уже прошёл (completed_at IS NOT NULL).
|
||||||
|
# Проверка идёт ПОСЛЕ загрузки уровня, т.к. нужен level["id"].
|
||||||
|
already_completed = await conn.fetchval(
|
||||||
|
"SELECT 1 FROM user_progress WHERE user_id = $1 AND level_id = $2 AND completed_at IS NOT NULL",
|
||||||
|
telegram_id, level["id"]
|
||||||
|
)
|
||||||
|
seen = await conn.fetchval(
|
||||||
|
"SELECT 1 FROM user_seen_levels WHERE user_id = $1 AND level_id = $2",
|
||||||
|
telegram_id, level["id"]
|
||||||
|
)
|
||||||
|
if not seen and not already_completed:
|
||||||
|
raise HTTPException(403, "Level not available. Get it via /game/next.")
|
||||||
|
|
||||||
words = await conn.fetch(
|
words = await conn.fetch(
|
||||||
"SELECT * FROM level_words WHERE level_id = $1", level["id"]
|
"SELECT * FROM level_words WHERE level_id = $1", level["id"]
|
||||||
)
|
)
|
||||||
@@ -97,12 +127,43 @@ async def get_level(request: Request, level_number: int):
|
|||||||
telegram_id, level["id"],
|
telegram_id, level["id"],
|
||||||
)
|
)
|
||||||
|
|
||||||
|
# 🔧 ФИКС (10.10.2026): wave_off_by_one —
|
||||||
|
# wave/pos хранятся в момент выдачи. Если NULL — fallback.
|
||||||
|
wave_pos = await conn.fetchrow(
|
||||||
|
"SELECT current_wave, current_position_in_wave FROM user_game_progress WHERE user_id = $1",
|
||||||
|
telegram_id,
|
||||||
|
)
|
||||||
|
if wave_pos and wave_pos["current_wave"] and wave_pos["current_position_in_wave"]:
|
||||||
|
current_wave = int(wave_pos["current_wave"])
|
||||||
|
current_pos = int(wave_pos["current_position_in_wave"])
|
||||||
|
else:
|
||||||
|
global_level = await conn.fetchval(
|
||||||
|
"SELECT global_level_number FROM user_game_progress WHERE user_id = $1",
|
||||||
|
telegram_id,
|
||||||
|
)
|
||||||
|
global_level = int(global_level or 1)
|
||||||
|
from services.waves import wave_for_level, level_in_wave
|
||||||
|
current_wave = wave_for_level(global_level)
|
||||||
|
current_pos = level_in_wave(global_level)
|
||||||
|
|
||||||
|
# 🔧 ОБНОВЛЕНО (09.10.2026): отдаём ВСЕ 4 перевода.
|
||||||
|
# Flutter сам выбирает, какой показать по context.lang.
|
||||||
|
# Старое поле 'translation' оставлено для совместимости (legacy).
|
||||||
word_list = []
|
word_list = []
|
||||||
for w in words:
|
for w in words:
|
||||||
translation = w.get(f"translation_{lang}", "") or w.get("translation_pl", "") or w.get("translation_en", "")
|
legacy_translation = (
|
||||||
|
w.get(f"translation_{lang}", "")
|
||||||
|
or w.get("translation_en", "")
|
||||||
|
or ""
|
||||||
|
)
|
||||||
word_list.append({
|
word_list.append({
|
||||||
"word_pl": w["word_pl"],
|
"word_pl": w["word_pl"],
|
||||||
"translation": translation,
|
# Legacy (для старого Flutter)
|
||||||
|
"translation": legacy_translation,
|
||||||
|
# 🆕 Все переводы (Flutter сам выбирает)
|
||||||
|
"translation_ru": w.get("translation_ru") or "",
|
||||||
|
"translation_uk": w.get("translation_uk") or "",
|
||||||
|
"translation_en": w.get("translation_en") or "",
|
||||||
})
|
})
|
||||||
|
|
||||||
grid_letters = level["grid_letters"]
|
grid_letters = level["grid_letters"]
|
||||||
@@ -125,6 +186,10 @@ async def get_level(request: Request, level_number: int):
|
|||||||
)
|
)
|
||||||
)
|
)
|
||||||
|
|
||||||
|
# 🔧 ФИКС (10.10.2026): wave/pos из зафиксированных значений.
|
||||||
|
wave = current_wave
|
||||||
|
pos_in_wave = current_pos
|
||||||
|
|
||||||
return {
|
return {
|
||||||
"level": {
|
"level": {
|
||||||
"id": level["id"],
|
"id": level["id"],
|
||||||
@@ -140,6 +205,10 @@ async def get_level(request: Request, level_number: int):
|
|||||||
"hints_used": progress["hints_used"] if progress else 0,
|
"hints_used": progress["hints_used"] if progress else 0,
|
||||||
"score": progress["score"] if progress else 0,
|
"score": progress["score"] if progress else 0,
|
||||||
},
|
},
|
||||||
|
# 🆕 (10.10.2026): волна и позиция в волне.
|
||||||
|
"wave": wave,
|
||||||
|
"position_in_wave": pos_in_wave,
|
||||||
|
"difficulty": user["difficulty"] or "medium",
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
@@ -184,8 +253,18 @@ async def check_word(request: Request):
|
|||||||
continue
|
continue
|
||||||
selected_word = selected_word.lower()
|
selected_word = selected_word.lower()
|
||||||
|
|
||||||
for word in word_paths.keys():
|
# 🔧 ФИКС (11.10.2026): word_matched_by_letters_only —
|
||||||
if word.lower() == selected_word:
|
# раньше слово зачислялось только по буквам. Если те же буквы
|
||||||
|
# встречаются в другом месте сетки (например NOS вверху и внизу),
|
||||||
|
# сервер зачислял слово, хотя игрок собрал его не там.
|
||||||
|
# Теперь проверяем координаты: selected_cells должны точно
|
||||||
|
# совпасть с word_paths[word].
|
||||||
|
selected_path = [[int(cell[0]), int(cell[1])] for cell in selected_cells]
|
||||||
|
for word, path in word_paths.items():
|
||||||
|
if word.lower() != selected_word:
|
||||||
|
continue
|
||||||
|
expected_path = [[int(p[0]), int(p[1])] for p in path]
|
||||||
|
if selected_path == expected_path:
|
||||||
found_word = word
|
found_word = word
|
||||||
break
|
break
|
||||||
|
|
||||||
@@ -230,7 +309,7 @@ async def check_word(request: Request):
|
|||||||
"new_achievements": new_achievements
|
"new_achievements": new_achievements
|
||||||
}
|
}
|
||||||
|
|
||||||
return {"status": "ok", "found": False, "server_streak": 0}
|
return {"status": "ok", "found": False, "server_streak": 0, "reason": "wrong_path"}
|
||||||
|
|
||||||
|
|
||||||
@router.post("/complete-level")
|
@router.post("/complete-level")
|
||||||
@@ -267,14 +346,31 @@ async def complete_level(request: Request):
|
|||||||
# 🔧 ФИКС (24.09.2026): client_controlled_hints_game —
|
# 🔧 ФИКС (24.09.2026): client_controlled_hints_game —
|
||||||
# hints_used читаем из БД, не доверяем клиенту.
|
# hints_used читаем из БД, не доверяем клиенту.
|
||||||
hints_used = 0
|
hints_used = 0
|
||||||
|
# 🔧 НОВОЕ (08.10.2026): XP-система — результат award_xp.
|
||||||
|
xp_result = None
|
||||||
|
# 🆕 (11.10.2026): волновые счётчики для достижений.
|
||||||
|
waves_completed = 0
|
||||||
|
wordsearch_xp = 0
|
||||||
|
fast_streak = 0
|
||||||
|
no_hints_streak = 0
|
||||||
|
words_found = 0
|
||||||
|
# 🆕 (13.10.2026): итоги волны для модалки.
|
||||||
|
wave_completed = False
|
||||||
|
wave_points = 0
|
||||||
|
wave_max_points = 0
|
||||||
|
wave_medal_result = "none"
|
||||||
|
current_wave = 1
|
||||||
|
current_position_in_wave = 1
|
||||||
|
|
||||||
async with pool.acquire() as conn:
|
async with pool.acquire() as conn:
|
||||||
user = await conn.fetchrow(
|
user = await conn.fetchrow(
|
||||||
"SELECT id, telegram_id, last_completed_level, current_level FROM users WHERE telegram_id = $1",
|
"SELECT id, telegram_id, last_completed_level, current_level, difficulty FROM users WHERE telegram_id = $1",
|
||||||
telegram_id
|
telegram_id
|
||||||
)
|
)
|
||||||
if not user:
|
if not user:
|
||||||
raise HTTPException(401, "User not registered")
|
raise HTTPException(401, "User not registered")
|
||||||
|
|
||||||
|
difficulty = user["difficulty"] or "medium"
|
||||||
|
|
||||||
level = await conn.fetchrow(
|
level = await conn.fetchrow(
|
||||||
"SELECT id, level_number, grid_size, level FROM levels WHERE id = $1", level_id
|
"SELECT id, level_number, grid_size, level FROM levels WHERE id = $1", level_id
|
||||||
@@ -285,9 +381,10 @@ async def complete_level(request: Request):
|
|||||||
current_level_number = level["level_number"]
|
current_level_number = level["level_number"]
|
||||||
level_name = level["level"] or "A1"
|
level_name = level["level"] or "A1"
|
||||||
|
|
||||||
# Проверяем, что уровень принадлежит текущему уровню пользователя
|
# 🔧 ОБНОВЛЕНО (07.10.2026): level = 'common'.
|
||||||
if level_name != (user["current_level"] or "A1"):
|
# Уровни глобальные, поэтому убираем проверку «уровень принадлежит
|
||||||
raise HTTPException(403, "This level does not belong to your current level")
|
# твоему current_level». Оставляем только проверку прогресса выше.
|
||||||
|
# (Проверка не твоя-не твоя была актуальна, когда были A1/A2/B1.)
|
||||||
|
|
||||||
# 🔧 ФИКС (25.09.2026): already_completed_detects_hint_row —
|
# 🔧 ФИКС (25.09.2026): already_completed_detects_hint_row —
|
||||||
# раньше already_completed = True при ЛЮБОЙ строке user_progress.
|
# раньше already_completed = True при ЛЮБОЙ строке user_progress.
|
||||||
@@ -320,43 +417,104 @@ async def complete_level(request: Request):
|
|||||||
telegram_id, level_id
|
telegram_id, level_id
|
||||||
) or 0
|
) or 0
|
||||||
|
|
||||||
# 🔧 ФИКС (24.09.2026): client_controlled_hints_game —
|
# 🔧 НОВОЕ (08.10.2026): XP-система.
|
||||||
# читаем hints_used из БД, не доверяем клиенту.
|
# Читаем hints_used и list_opened из БД (не доверяем клиенту).
|
||||||
hints_used = await conn.fetchval(
|
hints_used = await conn.fetchval(
|
||||||
"SELECT hints_used FROM user_progress WHERE user_id = $1 AND level_id = $2",
|
"SELECT hints_used FROM user_progress WHERE user_id = $1 AND level_id = $2",
|
||||||
telegram_id, level_id
|
telegram_id, level_id
|
||||||
) or 0
|
) or 0
|
||||||
hints_used = min(max(0, hints_used), 3)
|
hints_used = min(max(0, hints_used), 3)
|
||||||
|
|
||||||
score = max(10, 100 - hints_used * 10)
|
# 🆕 Штрафы (филворд):
|
||||||
|
# -20 за открытие списка слов (один раз за уровень)
|
||||||
# 🔧 ФИКС (23.09.2026): client_controlled_achievement_values —
|
# -20 за каждую подсказку
|
||||||
# сбрасываем current_streak в 0 при завершении уровня.
|
list_opened = bool(body.get("list_opened", False))
|
||||||
#
|
|
||||||
|
# 🔧 НОВОЕ (13.10.2026): на Hard подсказки и список слов недоступны.
|
||||||
|
if difficulty == "hard" and (hints_used > 0 or list_opened):
|
||||||
|
raise HTTPException(
|
||||||
|
status_code=400,
|
||||||
|
detail="Hints and word list are disabled on Hard difficulty"
|
||||||
|
)
|
||||||
|
|
||||||
|
# Очки в зависимости от сложности
|
||||||
|
if difficulty == "hard":
|
||||||
|
# Hard: фикс 110 (без подсказок и списка)
|
||||||
|
points = 110
|
||||||
|
else:
|
||||||
|
# Easy / Medium
|
||||||
|
bonus = 10 if hints_used == 0 else 0
|
||||||
|
penalty_hints = 20 * hints_used
|
||||||
|
penalty_list = 0 if difficulty == "easy" else 20 * (1 if list_opened else 0)
|
||||||
|
points = max(20, min(110, 100 - penalty_hints - penalty_list + bonus))
|
||||||
|
|
||||||
|
# Начисляем XP через единую функцию
|
||||||
|
from services.xp import award_xp
|
||||||
|
xp_result = await award_xp(conn, telegram_id, "wordsearch", points)
|
||||||
|
|
||||||
|
score = xp_result["points"] # для обратной совместимости
|
||||||
|
|
||||||
# 🔧 ФИКС (25.09.2026): complete_level_insert_overwrites_hints_used —
|
# 🔧 ФИКС (25.09.2026): complete_level_insert_overwrites_hints_used —
|
||||||
# раньше INSERT падал с unique violation, если строка user_progress
|
# раньше INSERT падал с unique violation, если строка user_progress
|
||||||
# уже была создана hints.py (юзер взял подсказку → уровень не завершится).
|
# уже была создана hints.py (юзер взял подсказку → уровень не завершится).
|
||||||
# Теперь UPSERT с ON CONFLICT DO UPDATE.
|
# Теперь UPSERT с ON CONFLICT DO UPDATE.
|
||||||
# hints_used уже прочитан из БД выше (не доверяем клиенту).
|
# hints_used уже прочитан из БД выше (не доверяем клиенту).
|
||||||
|
# 🔧 ФИКС (13.10.2026): wave_off_by_one —
|
||||||
|
# session_level_number хранит позицию СЛЕДУЮЩЕГО уровня
|
||||||
|
# (уже увеличенную при выдаче), поэтому модалка волны
|
||||||
|
# срабатывала на 9-м уровне. Читаем current_wave /
|
||||||
|
# current_position_in_wave — позицию именно завершаемого уровня.
|
||||||
|
wave_row = await conn.fetchrow(
|
||||||
|
"SELECT current_wave, current_position_in_wave FROM user_game_progress WHERE user_id = $1",
|
||||||
|
telegram_id,
|
||||||
|
)
|
||||||
|
if wave_row and wave_row["current_wave"] and wave_row["current_position_in_wave"]:
|
||||||
|
current_wave = int(wave_row["current_wave"])
|
||||||
|
current_position_in_wave = int(wave_row["current_position_in_wave"])
|
||||||
|
else:
|
||||||
|
# Fallback для старых записей без current_* полей.
|
||||||
|
global_level = await conn.fetchval(
|
||||||
|
"SELECT global_level_number FROM user_game_progress WHERE user_id = $1",
|
||||||
|
telegram_id,
|
||||||
|
)
|
||||||
|
global_level = int(global_level or 1)
|
||||||
|
from services.waves import wave_for_level, level_in_wave
|
||||||
|
current_wave = wave_for_level(global_level)
|
||||||
|
current_position_in_wave = level_in_wave(global_level)
|
||||||
|
|
||||||
await conn.execute("""
|
await conn.execute("""
|
||||||
INSERT INTO user_progress
|
INSERT INTO user_progress
|
||||||
(user_id, level_id, completed_at, hints_used, score, level, current_streak)
|
(user_id, level_id, completed_at, hints_used, score, level, current_streak, wave)
|
||||||
VALUES ($1, $2, NOW(), $3, $4, $5, 0)
|
VALUES ($1, $2, NOW(), $3, $4, $5, 0, $6)
|
||||||
ON CONFLICT (user_id, level_id) DO UPDATE
|
ON CONFLICT (user_id, level_id) DO UPDATE
|
||||||
SET completed_at = NOW(),
|
SET completed_at = NOW(),
|
||||||
hints_used = $3,
|
hints_used = $3,
|
||||||
score = $4,
|
score = $4,
|
||||||
level = $5,
|
level = $5,
|
||||||
current_streak = 0
|
current_streak = 0,
|
||||||
""", telegram_id, level_id, hints_used, score, level_name)
|
wave = $6
|
||||||
|
""", telegram_id, level_id, hints_used, score, level_name, current_wave)
|
||||||
|
|
||||||
# Обновляем last_completed_level (максимальный номер пройденного уровня)
|
# 🔧 ОБНОВЛЕНО (07.10.2026): единый счётчик progress.
|
||||||
await conn.execute(
|
# Обновляем только users.last_completed_level — глобальный.
|
||||||
"""UPDATE users
|
# last_completed_by_level (JSONB) остаётся в БД для совместимости,
|
||||||
SET last_completed_level = GREATEST(last_completed_level, $2)
|
# но больше не пишется.
|
||||||
WHERE telegram_id = $1""",
|
await conn.execute("""
|
||||||
telegram_id, current_level_number,
|
UPDATE users
|
||||||
)
|
SET last_completed_level = GREATEST(COALESCE(last_completed_level, 0), $2)
|
||||||
|
WHERE telegram_id = $1
|
||||||
|
""", telegram_id, current_level_number)
|
||||||
|
|
||||||
|
# 🔧 ФИКС (10.10.2026): game_next_reuse_active_level —
|
||||||
|
# уровень пройден → сбрасываем активный уровень, чтобы
|
||||||
|
# следующий /game/next выдал новый. Сбрасываем только если
|
||||||
|
# активный уровень совпадает с завершённым.
|
||||||
|
await conn.execute("""
|
||||||
|
UPDATE user_game_progress
|
||||||
|
SET current_level_id = NULL,
|
||||||
|
updated_at = NOW()
|
||||||
|
WHERE user_id = $1 AND current_level_id = $2
|
||||||
|
""", telegram_id, level_id)
|
||||||
|
|
||||||
# Собираем данные для достижений внутри блока
|
# Собираем данные для достижений внутри блока
|
||||||
levels_completed = await conn.fetchval(
|
levels_completed = await conn.fetchval(
|
||||||
@@ -382,6 +540,49 @@ async def complete_level(request: Request):
|
|||||||
) or 0
|
) or 0
|
||||||
grand_total = total_score + sentence_score + wordquiz_score + bubblewords_score
|
grand_total = total_score + sentence_score + wordquiz_score + bubblewords_score
|
||||||
|
|
||||||
|
# 🆕 (11.10.2026): волновые счётчики.
|
||||||
|
words_in_level = await conn.fetchval(
|
||||||
|
"SELECT COUNT(*) FROM level_words WHERE level_id = $1", level_id
|
||||||
|
) or 0
|
||||||
|
|
||||||
|
# Пройдено волн = current_wave - 1; если только что завершили
|
||||||
|
# 10-й уровень волны — волна пройдена (+1).
|
||||||
|
waves_completed = current_wave - 1
|
||||||
|
if current_position_in_wave == 10:
|
||||||
|
waves_completed += 1
|
||||||
|
|
||||||
|
# 🆕 (13.10.2026): итоги волны для модалки.
|
||||||
|
from services.waves import max_points_for_wave, wave_medal
|
||||||
|
wave_completed = (current_position_in_wave == 10)
|
||||||
|
wave_points = await conn.fetchval(
|
||||||
|
"SELECT COALESCE(SUM(score), 0) FROM user_progress WHERE user_id = $1 AND wave = $2",
|
||||||
|
telegram_id, current_wave,
|
||||||
|
) or 0
|
||||||
|
wave_max_points = max_points_for_wave()
|
||||||
|
wave_medal_result = wave_medal(wave_points, wave_max_points)
|
||||||
|
|
||||||
|
# XP филворда = сумма score по user_progress (уже посчитана как total_score).
|
||||||
|
wordsearch_xp = total_score
|
||||||
|
|
||||||
|
# Обновляем счётчики серий.
|
||||||
|
is_fast = completion_time is not None and int(completion_time) <= 30
|
||||||
|
await conn.execute("""
|
||||||
|
UPDATE user_game_progress
|
||||||
|
SET fast_streak = CASE WHEN $2 THEN COALESCE(fast_streak, 0) + 1 ELSE 0 END,
|
||||||
|
no_hints_streak = CASE WHEN $3 THEN COALESCE(no_hints_streak, 0) + 1 ELSE 0 END,
|
||||||
|
words_found = COALESCE(words_found, 0) + $4,
|
||||||
|
updated_at = NOW()
|
||||||
|
WHERE user_id = $1
|
||||||
|
""", telegram_id, is_fast, hints_used == 0, words_in_level)
|
||||||
|
|
||||||
|
counters = await conn.fetchrow(
|
||||||
|
"SELECT fast_streak, no_hints_streak, words_found FROM user_game_progress WHERE user_id = $1",
|
||||||
|
telegram_id,
|
||||||
|
)
|
||||||
|
fast_streak = int(counters["fast_streak"] or 0) if counters else 0
|
||||||
|
no_hints_streak = int(counters["no_hints_streak"] or 0) if counters else 0
|
||||||
|
words_found = int(counters["words_found"] or 0) if counters else 0
|
||||||
|
|
||||||
# Если уровень уже был пройден — просто возвращаем результат
|
# Если уровень уже был пройден — просто возвращаем результат
|
||||||
if already_completed:
|
if already_completed:
|
||||||
return {
|
return {
|
||||||
@@ -416,9 +617,246 @@ async def complete_level(request: Request):
|
|||||||
ach = await check_and_award_achievements(telegram_id, "perfect_words", server_perfect_streak)
|
ach = await check_and_award_achievements(telegram_id, "perfect_words", server_perfect_streak)
|
||||||
new_achievements.extend(ach)
|
new_achievements.extend(ach)
|
||||||
|
|
||||||
|
# 🆕 (11.10.2026): волновые достижения.
|
||||||
|
ach = await check_and_award_achievements(telegram_id, "waves_completed", waves_completed)
|
||||||
|
new_achievements.extend(ach)
|
||||||
|
|
||||||
|
ach = await check_and_award_achievements(telegram_id, "wordsearch_xp", wordsearch_xp)
|
||||||
|
new_achievements.extend(ach)
|
||||||
|
|
||||||
|
if fast_streak >= 3:
|
||||||
|
ach = await check_and_award_achievements(telegram_id, "ws_speed_run", fast_streak)
|
||||||
|
new_achievements.extend(ach)
|
||||||
|
|
||||||
|
if no_hints_streak >= 10:
|
||||||
|
ach = await check_and_award_achievements(telegram_id, "ws_no_hints_streak", no_hints_streak)
|
||||||
|
new_achievements.extend(ach)
|
||||||
|
|
||||||
|
if words_found >= 1000:
|
||||||
|
ach = await check_and_award_achievements(telegram_id, "wordsearch_words", words_found)
|
||||||
|
new_achievements.extend(ach)
|
||||||
|
|
||||||
return {
|
return {
|
||||||
"status": "ok",
|
"status": "ok",
|
||||||
"score": score,
|
"score": score,
|
||||||
"already_completed": False,
|
"already_completed": False,
|
||||||
"new_achievements": new_achievements
|
"new_achievements": new_achievements,
|
||||||
}
|
# 🆕 XP-поля
|
||||||
|
"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"],
|
||||||
|
# 🆕 (13.10.2026): итоги волны для модалки.
|
||||||
|
"wave_completed": wave_completed,
|
||||||
|
"wave_number": current_wave,
|
||||||
|
"wave_points": wave_points,
|
||||||
|
"wave_max_points": wave_max_points,
|
||||||
|
"wave_medal": wave_medal_result,
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
# ============================================================
|
||||||
|
# 🆕 (08.10.2026): Волновая выдача уровня.
|
||||||
|
# ============================================================
|
||||||
|
|
||||||
|
@router.post("/next")
|
||||||
|
async def get_next_level(request: Request):
|
||||||
|
"""
|
||||||
|
Выдаёт следующий уровень по волновой структуре.
|
||||||
|
|
||||||
|
Логика:
|
||||||
|
1. Если есть активный уровень (выдан, но ещё не пройден) — возвращаем его.
|
||||||
|
2. Иначе смотрим user_game_progress.global_level_number.
|
||||||
|
3. Определяем волну и размер сетки через wave_plan.
|
||||||
|
4. Ищем непройденный уровень нужного размера (в user_seen_levels).
|
||||||
|
5. Помечаем как seen, обновляем user_game_progress, ставим current_level_id.
|
||||||
|
6. Возвращаем level_number.
|
||||||
|
|
||||||
|
🔧 ФИКС (10.10.2026): game_next_reuse_active_level —
|
||||||
|
раньше /game/next при каждом заходе выдавал НОВЫЙ уровень и
|
||||||
|
инкрементил global_level_number, даже если предыдущий не был пройден.
|
||||||
|
Из-за этого при повторном открытии Filwords уровень менялся
|
||||||
|
(5×5 → 6×6). Теперь сначала проверяем current_level_id:
|
||||||
|
если уровень выдан и ещё не пройден — возвращаем его же.
|
||||||
|
"""
|
||||||
|
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,
|
||||||
|
current_level_id, current_wave, current_position_in_wave
|
||||||
|
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
|
||||||
|
current_level_id = None
|
||||||
|
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)
|
||||||
|
current_level_id = row["current_level_id"]
|
||||||
|
|
||||||
|
from services.waves import wave_for_level, level_in_wave, grid_size_for
|
||||||
|
|
||||||
|
# 🔧 ФИКС (10.10.2026): сначала проверяем активный уровень.
|
||||||
|
# Если он выдан и ещё не пройден — возвращаем его же,
|
||||||
|
# не двигая счётчики и не помечая новый уровень как seen.
|
||||||
|
if current_level_id is not None:
|
||||||
|
active = await conn.fetchrow(
|
||||||
|
"""
|
||||||
|
SELECT id, level_number, grid_size
|
||||||
|
FROM levels
|
||||||
|
WHERE id = $1 AND is_active = TRUE
|
||||||
|
""",
|
||||||
|
current_level_id,
|
||||||
|
)
|
||||||
|
if active is not None:
|
||||||
|
done = await conn.fetchval(
|
||||||
|
"""
|
||||||
|
SELECT 1 FROM user_progress
|
||||||
|
WHERE user_id = $1 AND level_id = $2
|
||||||
|
AND (completed_at IS NOT NULL OR COALESCE(score, 0) > 0)
|
||||||
|
""",
|
||||||
|
telegram_id, active["id"],
|
||||||
|
)
|
||||||
|
if not done:
|
||||||
|
# 🔧 ФИКС (10.10.2026): off-by-one в reuse-ветке —
|
||||||
|
# global_level уже инкрементнут при первой выдаче,
|
||||||
|
# поэтому wave/pos считаем от зафиксированных значений
|
||||||
|
# current_wave / current_position_in_wave. Fallback —
|
||||||
|
# старый расчёт для записей без этих полей.
|
||||||
|
return {
|
||||||
|
"level_id": active["id"],
|
||||||
|
"level_number": active["level_number"],
|
||||||
|
"grid_size": active["grid_size"],
|
||||||
|
"wave": int(row["current_wave"]) if row["current_wave"] else wave_for_level(global_level),
|
||||||
|
"position_in_wave": int(row["current_position_in_wave"]) if row["current_position_in_wave"] else level_in_wave(global_level),
|
||||||
|
"session_number": session_number,
|
||||||
|
"session_level": session_level,
|
||||||
|
"global_level": global_level,
|
||||||
|
"reused": True,
|
||||||
|
}
|
||||||
|
|
||||||
|
# Уровень пройден или удалён/неактивен — сбрасываем активный.
|
||||||
|
await conn.execute(
|
||||||
|
"""
|
||||||
|
UPDATE user_game_progress
|
||||||
|
SET current_level_id = NULL, updated_at = NOW()
|
||||||
|
WHERE user_id = $1
|
||||||
|
""",
|
||||||
|
telegram_id,
|
||||||
|
)
|
||||||
|
|
||||||
|
# Определяем волну и размер
|
||||||
|
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 > 10:
|
||||||
|
next_session_level = 1
|
||||||
|
next_session += 1
|
||||||
|
|
||||||
|
# 🔧 ФИКС (10.10.2026): запоминаем выданный уровень как активный.
|
||||||
|
await conn.execute(
|
||||||
|
"""
|
||||||
|
UPDATE user_game_progress
|
||||||
|
SET global_level_number = $2,
|
||||||
|
session_number = $3,
|
||||||
|
session_level_number = $4,
|
||||||
|
current_level_id = $5,
|
||||||
|
current_wave = $6,
|
||||||
|
current_position_in_wave = $7,
|
||||||
|
updated_at = NOW()
|
||||||
|
WHERE user_id = $1
|
||||||
|
""",
|
||||||
|
telegram_id, next_global, next_session, next_session_level, level_id,
|
||||||
|
wave, pos_in_wave,
|
||||||
|
)
|
||||||
|
|
||||||
|
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,
|
||||||
|
"reused": False,
|
||||||
|
}
|
||||||
|
|||||||
+34
-35
@@ -1,3 +1,5 @@
|
|||||||
|
import random
|
||||||
|
|
||||||
from fastapi import APIRouter, Request, HTTPException
|
from fastapi import APIRouter, Request, HTTPException
|
||||||
from auth import require_auth
|
from auth import require_auth
|
||||||
from database import get_pool
|
from database import get_pool
|
||||||
@@ -6,7 +8,7 @@ router = APIRouter(prefix="/hints", tags=["hints"])
|
|||||||
|
|
||||||
|
|
||||||
@router.get("/first-letter/{level_id}")
|
@router.get("/first-letter/{level_id}")
|
||||||
async def get_first_letter_hint(request: Request, level_id: int):
|
async def get_first_letter_hint(request: Request, level_id: int, found: str = ""):
|
||||||
"""Подсказка: показывает первую букву случайного ненайденного слова"""
|
"""Подсказка: показывает первую букву случайного ненайденного слова"""
|
||||||
telegram_id, _ = await require_auth(request)
|
telegram_id, _ = await require_auth(request)
|
||||||
|
|
||||||
@@ -53,25 +55,33 @@ async def get_first_letter_hint(request: Request, level_id: int):
|
|||||||
import json
|
import json
|
||||||
word_paths = json.loads(word_paths)
|
word_paths = json.loads(word_paths)
|
||||||
|
|
||||||
# Находим первое слово, у которого есть путь
|
# Слова уровня, у которых есть путь в word_paths
|
||||||
all_level_words = [w["word_pl"] for w in words]
|
all_level_words = [w["word_pl"] for w in words]
|
||||||
|
words_with_paths = [
|
||||||
|
w for w in all_level_words
|
||||||
|
if w in word_paths and word_paths[w]
|
||||||
|
]
|
||||||
|
|
||||||
# Ищем слово с путём (сначала основные, потом filler-слова)
|
if not words_with_paths:
|
||||||
found_word = None
|
|
||||||
first_cell = None
|
|
||||||
|
|
||||||
for word in all_level_words:
|
|
||||||
if word in word_paths and word_paths[word]:
|
|
||||||
found_word = word
|
|
||||||
first_cell = word_paths[word][0]
|
|
||||||
break
|
|
||||||
|
|
||||||
# 🔧 ФИКС (25.09.2026): hint_fake_first_cell —
|
|
||||||
# если ни у одного слова нет пути в word_paths, подсказка
|
|
||||||
# бессмысленна. Возвращаем 404, а не фейковую координату [0,0].
|
|
||||||
if not found_word:
|
|
||||||
raise HTTPException(404, "No word paths found for this level")
|
raise HTTPException(404, "No word paths found for this level")
|
||||||
|
|
||||||
|
# 🔧 ФИКС (12.10.2026): hint_shows_found_word —
|
||||||
|
# подсказка показывала уже найденное слово. Теперь фронт передаёт
|
||||||
|
# найденные слова в query-параметре found (через запятую), и мы
|
||||||
|
# исключаем их из кандидатов.
|
||||||
|
found_words = {w.strip() for w in found.split(",") if w.strip()}
|
||||||
|
remaining_words = [w for w in words_with_paths if w not in found_words]
|
||||||
|
|
||||||
|
if not remaining_words:
|
||||||
|
raise HTTPException(404, "All words found")
|
||||||
|
|
||||||
|
# 🔧 ФИКС (11.10.2026): hint_always_first_word —
|
||||||
|
# раньше всегда возвращалось первое слово списка, поэтому
|
||||||
|
# повторные нажатия давали одну и ту же букву. Теперь слово
|
||||||
|
# выбирается случайно из ещё не найденных.
|
||||||
|
found_word = random.choice(remaining_words)
|
||||||
|
first_cell = word_paths[found_word][0]
|
||||||
|
|
||||||
# 🔧 ФИКС (25.09.2026): hint_consumed_before_word_paths_check —
|
# 🔧 ФИКС (25.09.2026): hint_consumed_before_word_paths_check —
|
||||||
# инкрементим hints_used ТОЛЬКО после всех проверок.
|
# инкрементим hints_used ТОЛЬКО после всех проверок.
|
||||||
# Раньше при 404 (нет word_paths) подсказка уже была потрачена.
|
# Раньше при 404 (нет word_paths) подсказка уже была потрачена.
|
||||||
@@ -115,7 +125,7 @@ async def get_word_list(request: Request, level_id: int):
|
|||||||
if not user_exists:
|
if not user_exists:
|
||||||
raise HTTPException(401, "User not registered")
|
raise HTTPException(401, "User not registered")
|
||||||
|
|
||||||
# Получаем прогресс пользователя
|
# Получаем прогресс пользователя (для информации в ответе)
|
||||||
progress = await conn.fetchrow(
|
progress = await conn.fetchrow(
|
||||||
"SELECT hints_used FROM user_progress WHERE user_id = $1 AND level_id = $2",
|
"SELECT hints_used FROM user_progress WHERE user_id = $1 AND level_id = $2",
|
||||||
telegram_id, level_id
|
telegram_id, level_id
|
||||||
@@ -123,14 +133,11 @@ async def get_word_list(request: Request, level_id: int):
|
|||||||
|
|
||||||
hints_already_used = progress["hints_used"] if progress else 0
|
hints_already_used = progress["hints_used"] if progress else 0
|
||||||
|
|
||||||
# 🔧 ФИКС (23.09.2026): hints_not_incremented — лимит 3 подсказки не работал,
|
# 🔧 ФИКС (01.10.2026): word_list_is_not_hint —
|
||||||
# hints_used никогда не рос. Теперь проверяем лимит и инкрементим в той же транзакции.
|
# «Показать слова» — базовая функция (в UI написано ∞),
|
||||||
MAX_HINTS = 3
|
# НЕ расходует лимит подсказок и НЕ уменьшает очки.
|
||||||
if hints_already_used >= MAX_HINTS:
|
# Раньше зря инкрементился hints_used → минус 10 очков за уровень.
|
||||||
raise HTTPException(403, "Hint limit reached")
|
# Лимит 3 остаётся ТОЛЬКО для «Первой буквы».
|
||||||
|
|
||||||
# 🔧 ФИКС (25.09.2026): word_list_hint_consumed_on_empty —
|
|
||||||
# сначала получаем слова, проверяем что они есть, только потом инкрементим.
|
|
||||||
words = await conn.fetch(
|
words = await conn.fetch(
|
||||||
"SELECT * FROM level_words WHERE level_id = $1 ORDER BY word_pl", level_id
|
"SELECT * FROM level_words WHERE level_id = $1 ORDER BY word_pl", level_id
|
||||||
)
|
)
|
||||||
@@ -138,15 +145,7 @@ async def get_word_list(request: Request, level_id: int):
|
|||||||
if not words:
|
if not words:
|
||||||
raise HTTPException(404, "No words found for this level")
|
raise HTTPException(404, "No words found for this level")
|
||||||
|
|
||||||
# 🔧 ФИКС (25.09.2026): hints_used_never_incremented_actually —
|
# hints_used НЕ инкрементим. hints_already_used читаем из БД для информации.
|
||||||
# тот же UPSERT, что и в get_first_letter_hint.
|
|
||||||
await conn.execute("""
|
|
||||||
INSERT INTO user_progress (user_id, level_id, hints_used)
|
|
||||||
VALUES ($1, $2, 1)
|
|
||||||
ON CONFLICT (user_id, level_id) DO UPDATE
|
|
||||||
SET hints_used = user_progress.hints_used + 1
|
|
||||||
""", telegram_id, level_id)
|
|
||||||
hints_already_used += 1
|
|
||||||
|
|
||||||
# Определяем язык пользователя
|
# Определяем язык пользователя
|
||||||
user = await conn.fetchrow(
|
user = await conn.fetchrow(
|
||||||
@@ -197,4 +196,4 @@ async def get_remaining_hints(request: Request, level_id: int):
|
|||||||
"max_hints": max_hints,
|
"max_hints": max_hints,
|
||||||
"hints_used": hints_used,
|
"hints_used": hints_used,
|
||||||
"remaining": remaining,
|
"remaining": remaining,
|
||||||
}
|
}
|
||||||
|
|||||||
+171
-101
@@ -10,7 +10,18 @@ LEVELS = ["A1", "A2", "B1", "B2", "C1", "C2"]
|
|||||||
|
|
||||||
@router.get("")
|
@router.get("")
|
||||||
async def get_leaderboard(request: Request, limit: int = 50):
|
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)
|
telegram_id, _ = await require_auth(request)
|
||||||
|
|
||||||
if limit < 1:
|
if limit < 1:
|
||||||
@@ -28,17 +39,39 @@ async def get_leaderboard(request: Request, limit: int = 50):
|
|||||||
|
|
||||||
current_level = user["current_level"] or "A1"
|
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("""
|
rows = await conn.fetch("""
|
||||||
SELECT * FROM leaderboard_cache
|
SELECT
|
||||||
ORDER BY total_score DESC
|
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 $1
|
||||||
""", limit)
|
""", limit)
|
||||||
|
|
||||||
leaderboard = []
|
# Импорт XP-хелперов
|
||||||
for i, row in enumerate(rows):
|
from services.xp import level_for, rank_for
|
||||||
leaderboard.append({
|
|
||||||
"rank": i + 1,
|
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"],
|
"telegram_id": row["telegram_id"],
|
||||||
"username": row["username"] or f"Player{row['telegram_id']}",
|
"username": row["username"] or f"Player{row['telegram_id']}",
|
||||||
"total_score": row["total_score"],
|
"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"],
|
"bubble_levels_completed": row["bubble_levels_completed"],
|
||||||
"levels_completed": 0,
|
"levels_completed": 0,
|
||||||
"sentences_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 = [
|
||||||
# если пользователя нет в leaderboard_cache, подзапрос вернёт NULL,
|
_serialize_row(row, rank_num=i + 1)
|
||||||
# и COUNT(*) + 1 = 1 (юзер видит себя первым, хотя у него 0 очков).
|
for i, row in enumerate(rows)
|
||||||
# Теперь: если user нет в кэше — считаем его место по количеству
|
]
|
||||||
# записей с total_score > 0 + 1 (в конец списка).
|
|
||||||
my_total_in_cache = await conn.fetchval("""
|
|
||||||
SELECT total_score FROM leaderboard_cache WHERE telegram_id = $1
|
|
||||||
""", telegram_id)
|
|
||||||
|
|
||||||
if my_total_in_cache is None:
|
# ============ Мой ранг ============
|
||||||
# Пользователя нет в кэше — считаем по количеству с > 0
|
# Читаем мои XP + legacy-статистику.
|
||||||
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)
|
|
||||||
|
|
||||||
# Персональная статистика пользователя
|
|
||||||
my_row = await conn.fetchrow("""
|
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)
|
""", 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_wordsearch = my_row["wordsearch_score"]
|
||||||
my_sentence = my_row["sentence_score"]
|
my_sentence = my_row["sentence_score"]
|
||||||
my_wordquiz = my_row["wordquiz_score"]
|
my_wordquiz = my_row["wordquiz_score"]
|
||||||
my_words_guessed = my_row["words_guessed"]
|
my_words_guessed = my_row["words_guessed"]
|
||||||
my_bubblewords = my_row["bubblewords_score"]
|
my_bubblewords = my_row["bubblewords_score"]
|
||||||
my_bubble_levels = my_row["bubble_levels_completed"]
|
my_bubble_levels = my_row["bubble_levels_completed"]
|
||||||
else:
|
my_total = my_wordsearch + my_sentence + my_wordquiz + my_bubblewords
|
||||||
my_wordsearch = 0
|
|
||||||
my_sentence = 0
|
|
||||||
my_wordquiz = 0
|
|
||||||
my_words_guessed = 0
|
|
||||||
my_bubblewords = 0
|
|
||||||
my_bubble_levels = 0
|
|
||||||
|
|
||||||
# Считаем НАПРЯМУЮ из основных таблиц
|
# 🔧 ОБНОВЛЕНО (08.10.2026): место по total_xp (не weekly_xp).
|
||||||
my_wordsearch_levels = await conn.fetchval(
|
my_position = await conn.fetchval("""
|
||||||
"SELECT COUNT(DISTINCT level_id) FROM user_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
|
SELECT COUNT(*) + 1
|
||||||
telegram_id
|
FROM user_profile
|
||||||
) or 0
|
WHERE total_xp > $1
|
||||||
|
""", my_total_xp) or 1
|
||||||
|
|
||||||
my_sentences_completed = await conn.fetchval(
|
my_wordsearch_levels = await conn.fetchval(
|
||||||
"SELECT COUNT(*) FROM sentence_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
|
"SELECT COUNT(DISTINCT level_id) FROM user_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
|
||||||
telegram_id
|
telegram_id
|
||||||
) or 0
|
) or 0
|
||||||
|
my_sentences_completed = await conn.fetchval(
|
||||||
# Если пользователя нет в кэше — считаем очки из основных таблиц
|
"SELECT COUNT(*) FROM sentence_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
|
||||||
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",
|
|
||||||
telegram_id
|
telegram_id
|
||||||
) or 0
|
) or 0
|
||||||
|
|
||||||
my_sentence = await conn.fetchval(
|
# ============ level_stats (legacy для Mini App) ============
|
||||||
"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. Справочники (не зависят от юзера) — одним запросом
|
|
||||||
ref_row = await conn.fetchrow("""
|
ref_row = await conn.fetchrow("""
|
||||||
SELECT
|
SELECT
|
||||||
(SELECT COUNT(*) FROM levels WHERE level = 'A1') AS a1_levels,
|
(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
|
(SELECT COUNT(*) FROM sentences WHERE level = 'C2') AS c2_sent
|
||||||
""")
|
""")
|
||||||
|
|
||||||
# 2. Очки и прогресс по всем уровням сразу — 4 запроса с GROUP BY
|
|
||||||
ws_rows = await conn.fetch("""
|
ws_rows = await conn.fetch("""
|
||||||
SELECT level,
|
SELECT level, COALESCE(SUM(score), 0) AS score, COUNT(*) AS completed
|
||||||
COALESCE(SUM(score), 0) AS score,
|
|
||||||
COUNT(*) AS completed
|
|
||||||
FROM user_progress
|
FROM user_progress
|
||||||
WHERE user_id = $1 AND completed_at IS NOT NULL
|
WHERE user_id = $1 AND completed_at IS NOT NULL
|
||||||
GROUP BY level
|
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}
|
ws_by_level = {r["level"]: r for r in ws_rows}
|
||||||
|
|
||||||
s_rows = await conn.fetch("""
|
s_rows = await conn.fetch("""
|
||||||
SELECT level,
|
SELECT level, COALESCE(SUM(score), 0) AS score, COUNT(*) AS completed
|
||||||
COALESCE(SUM(score), 0) AS score,
|
|
||||||
COUNT(*) AS completed
|
|
||||||
FROM sentence_progress
|
FROM sentence_progress
|
||||||
WHERE user_id = $1 AND completed_at IS NOT NULL
|
WHERE user_id = $1 AND completed_at IS NOT NULL
|
||||||
GROUP BY level
|
GROUP BY level
|
||||||
@@ -183,23 +242,19 @@ async def get_leaderboard(request: Request, limit: int = 50):
|
|||||||
|
|
||||||
wq_rows = await conn.fetch("""
|
wq_rows = await conn.fetch("""
|
||||||
SELECT level, COALESCE(total_score, 0) AS score
|
SELECT level, COALESCE(total_score, 0) AS score
|
||||||
FROM word_quiz_progress
|
FROM word_quiz_progress WHERE user_id = $1
|
||||||
WHERE user_id = $1
|
|
||||||
""", telegram_id)
|
""", telegram_id)
|
||||||
wq_by_level = {r["level"]: r for r in wq_rows}
|
wq_by_level = {r["level"]: r for r in wq_rows}
|
||||||
|
|
||||||
bw_rows = await conn.fetch("""
|
bw_rows = await conn.fetch("""
|
||||||
SELECT level, COALESCE(total_score, 0) AS score
|
SELECT level, COALESCE(total_score, 0) AS score
|
||||||
FROM bubble_words_progress
|
FROM bubble_words_progress WHERE user_id = $1
|
||||||
WHERE user_id = $1
|
|
||||||
""", telegram_id)
|
""", telegram_id)
|
||||||
bw_by_level = {r["level"]: r for r in bw_rows}
|
bw_by_level = {r["level"]: r for r in bw_rows}
|
||||||
|
|
||||||
# 3. Собираем level_stats в Python — без единого запроса
|
|
||||||
level_stats = {}
|
level_stats = {}
|
||||||
for lvl in LEVELS:
|
for lvl in LEVELS:
|
||||||
lvl_lower = lvl.lower()
|
lvl_lower = lvl.lower()
|
||||||
|
|
||||||
ws_score = ws_by_level.get(lvl, {}).get("score", 0) or 0
|
ws_score = ws_by_level.get(lvl, {}).get("score", 0) or 0
|
||||||
ws_completed = ws_by_level.get(lvl, {}).get("completed", 0) or 0
|
ws_completed = ws_by_level.get(lvl, {}).get("completed", 0) or 0
|
||||||
s_score = s_by_level.get(lvl, {}).get("score", 0) or 0
|
s_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_ws_levels = ref_row[f"{lvl_lower}_levels"] or 0
|
||||||
total_sentences = ref_row[f"{lvl_lower}_sent"] or 0
|
total_sentences = ref_row[f"{lvl_lower}_sent"] or 0
|
||||||
|
|
||||||
total_items = total_ws_levels + total_sentences
|
total_items = total_ws_levels + total_sentences
|
||||||
completed_items = ws_completed + s_completed
|
completed_items = ws_completed + s_completed
|
||||||
progress_percent = round((completed_items / total_items * 100), 1) if total_items > 0 else 0
|
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,
|
"bubblewords_score": bw_score,
|
||||||
}
|
}
|
||||||
|
|
||||||
# 🔧 ИСПРАВЛЕНО: вызов достижений ВНЕ блока async with pool.acquire()
|
# Достижения
|
||||||
from routers.achievements import check_and_award_achievements
|
from routers.achievements import check_and_award_achievements
|
||||||
if my_position <= 3:
|
if my_position <= 3:
|
||||||
await check_and_award_achievements(telegram_id, "rank_reached", my_position)
|
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 {
|
return {
|
||||||
"leaderboard": leaderboard,
|
"leaderboard": leaderboard,
|
||||||
"current_level": current_level,
|
"current_level": current_level,
|
||||||
"my_rank": {
|
"my_rank": {
|
||||||
|
# Legacy
|
||||||
"rank": my_position,
|
"rank": my_position,
|
||||||
"telegram_id": telegram_id,
|
"telegram_id": telegram_id,
|
||||||
"total_score": my_total,
|
"total_score": my_total,
|
||||||
@@ -243,6 +302,17 @@ async def get_leaderboard(request: Request, limit: int = 50):
|
|||||||
"words_guessed": my_words_guessed,
|
"words_guessed": my_words_guessed,
|
||||||
"bubblewords_score": my_bubblewords,
|
"bubblewords_score": my_bubblewords,
|
||||||
"bubble_levels_completed": my_bubble_levels,
|
"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,
|
"level_stats": level_stats,
|
||||||
}
|
}
|
||||||
|
|||||||
+348
-53
@@ -13,7 +13,6 @@ from fastapi import APIRouter, Request, HTTPException
|
|||||||
from auth import require_auth
|
from auth import require_auth
|
||||||
from database import get_pool
|
from database import get_pool
|
||||||
from config import TOGETHER_API_KEY
|
from config import TOGETHER_API_KEY
|
||||||
from .learning_data import init_learning_data
|
|
||||||
from .learning_profile import get_weak_skills, get_strong_skills
|
from .learning_profile import get_weak_skills, get_strong_skills
|
||||||
|
|
||||||
logger = logging.getLogger(__name__)
|
logger = logging.getLogger(__name__)
|
||||||
@@ -21,7 +20,7 @@ logger = logging.getLogger(__name__)
|
|||||||
router = APIRouter(prefix="/learning", tags=["learning"])
|
router = APIRouter(prefix="/learning", tags=["learning"])
|
||||||
|
|
||||||
TOGETHER_API_URL = "https://api.together.xyz/v1/chat/completions"
|
TOGETHER_API_URL = "https://api.together.xyz/v1/chat/completions"
|
||||||
ANALYTICS_MODEL = "MiniMaxAI/MiniMax-M3"
|
ANALYTICS_MODEL = "deepseek-ai/DeepSeek-V4-Pro-0813"
|
||||||
|
|
||||||
# Доступные функции приложения (для AI — чтобы не галлюцинировал)
|
# Доступные функции приложения (для AI — чтобы не галлюцинировал)
|
||||||
AVAILABLE_FEATURES = [
|
AVAILABLE_FEATURES = [
|
||||||
@@ -444,12 +443,41 @@ async def get_learning_levels(request: Request):
|
|||||||
|
|
||||||
@router.get("/topics")
|
@router.get("/topics")
|
||||||
async def get_topics(request: Request, level: str = "A1"):
|
async def get_topics(request: Request, level: str = "A1"):
|
||||||
"""Получить темы для уровня"""
|
"""
|
||||||
await require_auth(request)
|
Получить темы для уровня.
|
||||||
|
|
||||||
|
🔧 ОБНОВЛЕНО (04.10.2026): track_filter —
|
||||||
|
фильтруем темы по языку юзера:
|
||||||
|
- pl → track='pl'
|
||||||
|
- ru/uk → track='ru_uk' (общий для славян)
|
||||||
|
- en → track='en'
|
||||||
|
"""
|
||||||
|
telegram_id, _ = await require_auth(request)
|
||||||
pool = await get_pool()
|
pool = await get_pool()
|
||||||
async with pool.acquire() as conn:
|
async with pool.acquire() as conn:
|
||||||
rows = await conn.fetch("SELECT * FROM learning_topics WHERE level_code = $1 AND is_active = TRUE ORDER BY order_number", level)
|
# Определяем track из app_language юзера
|
||||||
return {"topics": [dict(row) for row in rows]}
|
user_lang = await conn.fetchval(
|
||||||
|
"SELECT app_language FROM users WHERE telegram_id = $1",
|
||||||
|
telegram_id,
|
||||||
|
) or "ru"
|
||||||
|
|
||||||
|
if user_lang == "pl":
|
||||||
|
track = "pl"
|
||||||
|
elif user_lang == "en":
|
||||||
|
track = "en"
|
||||||
|
else:
|
||||||
|
# ru, uk → общий track
|
||||||
|
track = "ru_uk"
|
||||||
|
|
||||||
|
rows = await conn.fetch("""
|
||||||
|
SELECT * FROM learning_topics
|
||||||
|
WHERE level_code = $1
|
||||||
|
AND is_active = TRUE
|
||||||
|
AND track = $2
|
||||||
|
ORDER BY order_number
|
||||||
|
""", level, track)
|
||||||
|
|
||||||
|
return {"topics": [dict(row) for row in rows], "track": track}
|
||||||
|
|
||||||
|
|
||||||
@router.get("/topics/{topic_id}")
|
@router.get("/topics/{topic_id}")
|
||||||
@@ -594,9 +622,29 @@ async def start_session(request: Request):
|
|||||||
return {"session_id": row["id"]}
|
return {"session_id": row["id"]}
|
||||||
|
|
||||||
|
|
||||||
|
# 🔧 ОБНОВЛЕНО (02.10.2026): attempt_number + revised —
|
||||||
|
# если ученик отвечает на вопрос повторно (после «Повторить урок»),
|
||||||
|
# создаётся НОВАЯ запись с attempt_number+1, revised=TRUE,
|
||||||
|
# revision_of_id=предыдущий ответ. История сохраняется полностью.
|
||||||
@router.post("/answer")
|
@router.post("/answer")
|
||||||
async def save_answer(request: Request):
|
async def save_answer(request: Request):
|
||||||
"""Сохранить ответ пользователя"""
|
"""
|
||||||
|
Сохранить ответ пользователя.
|
||||||
|
|
||||||
|
🔧 ОБНОВЛЕНО (02.10.2026): attempt_number + revised —
|
||||||
|
если ученик отвечает на вопрос повторно (после «Повторить урок»),
|
||||||
|
создаётся НОВАЯ запись с attempt_number+1, revised=TRUE,
|
||||||
|
revision_of_id=предыдущий ответ. История сохраняется полностью.
|
||||||
|
|
||||||
|
Возвращает:
|
||||||
|
{
|
||||||
|
"correct": bool,
|
||||||
|
"wrong_because": str | None,
|
||||||
|
"attempt_number": int, # какая это попытка
|
||||||
|
"show_correct_answer": bool, # TRUE только если attempt >= 3
|
||||||
|
"correct_answer": str | None # только при show_correct_answer
|
||||||
|
}
|
||||||
|
"""
|
||||||
telegram_id, _ = await require_auth(request)
|
telegram_id, _ = await require_auth(request)
|
||||||
body = await request.json()
|
body = await request.json()
|
||||||
session_id = body.get("session_id")
|
session_id = body.get("session_id")
|
||||||
@@ -604,20 +652,39 @@ async def save_answer(request: Request):
|
|||||||
selected_answer = body.get("answer", "")
|
selected_answer = body.get("answer", "")
|
||||||
time_taken_ms = body.get("time_taken_ms", 0)
|
time_taken_ms = body.get("time_taken_ms", 0)
|
||||||
is_final = body.get("is_final_answer", True)
|
is_final = body.get("is_final_answer", True)
|
||||||
# 🔧 ФИКС (22.09.2026): раньше hint_used был захардкожен False,
|
|
||||||
# поэтому подсказки не попадали в аналитику (hint_dependency всегда 0).
|
|
||||||
hint_used = body.get("hint_used", False)
|
hint_used = body.get("hint_used", False)
|
||||||
|
# 🔧 НОВОЕ: клиент сообщает, что это повторная попытка
|
||||||
|
is_retry = body.get("is_retry", False)
|
||||||
|
|
||||||
if not session_id or not question_id:
|
if not session_id or not question_id:
|
||||||
raise HTTPException(400, "session_id and question_id required")
|
raise HTTPException(400, "session_id and question_id required")
|
||||||
|
|
||||||
pool = await get_pool()
|
pool = await get_pool()
|
||||||
async with pool.acquire() as conn:
|
async with pool.acquire() as conn:
|
||||||
question = await conn.fetchrow("SELECT * FROM learning_questions WHERE question_id = $1", question_id)
|
question = await conn.fetchrow(
|
||||||
|
"SELECT * FROM learning_questions WHERE question_id = $1", question_id
|
||||||
|
)
|
||||||
if not question:
|
if not question:
|
||||||
raise HTTPException(404, "Question not found")
|
raise HTTPException(404, "Question not found")
|
||||||
|
|
||||||
correct = selected_answer.strip().lower() == (question["correct_answer"] or "").strip().lower()
|
# 🔧 НОВОЕ: считаем текущее количество попыток по этому вопросу в сессии
|
||||||
|
prev_attempts = await conn.fetch(
|
||||||
|
"""
|
||||||
|
SELECT id, attempt_number, correct
|
||||||
|
FROM user_learning_answers
|
||||||
|
WHERE session_id = $1 AND question_id = $2
|
||||||
|
ORDER BY attempt_number ASC
|
||||||
|
""",
|
||||||
|
session_id, question_id,
|
||||||
|
)
|
||||||
|
|
||||||
|
next_attempt = (prev_attempts[-1]["attempt_number"] + 1) if prev_attempts else 1
|
||||||
|
prev_id = prev_attempts[-1]["id"] if prev_attempts else None
|
||||||
|
|
||||||
|
correct = (
|
||||||
|
selected_answer.strip().lower()
|
||||||
|
== (question["correct_answer"] or "").strip().lower()
|
||||||
|
)
|
||||||
|
|
||||||
wrong_because = None
|
wrong_because = None
|
||||||
if not correct:
|
if not correct:
|
||||||
@@ -628,58 +695,212 @@ async def save_answer(request: Request):
|
|||||||
if option:
|
if option:
|
||||||
wrong_because = option["wrong_because"]
|
wrong_because = option["wrong_because"]
|
||||||
|
|
||||||
session = await conn.fetchrow("SELECT * FROM learning_sessions WHERE id = $1", session_id)
|
session = await conn.fetchrow(
|
||||||
|
"SELECT * FROM learning_sessions WHERE id = $1", session_id
|
||||||
# 🔧 ФИКС (23.09.2026): learning_save_answer_missing_session_check —
|
)
|
||||||
# раньше при несуществующем session_id падало с TypeError → 500.
|
|
||||||
# Теперь честная 404 + проверка владельца сессии.
|
|
||||||
if not session:
|
if not session:
|
||||||
raise HTTPException(404, "Session not found")
|
raise HTTPException(404, "Session not found")
|
||||||
if session["user_id"] != telegram_id:
|
if session["user_id"] != telegram_id:
|
||||||
raise HTTPException(403, "Session belongs to another user")
|
raise HTTPException(403, "Session belongs to another user")
|
||||||
|
|
||||||
await conn.execute("""
|
# 🔧 Логика revised: если это повторная попытка — фиксируем
|
||||||
INSERT INTO user_learning_answers (user_id, session_id, level_code, topic_id, lesson_id, question_id, selected_answer, correct, skill_tag, question_type, context_type, difficulty, time_taken_ms, hint_used, wrong_because, is_final_answer)
|
revised = is_retry or next_attempt > 1
|
||||||
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16)
|
|
||||||
""", telegram_id, session_id, session["level_code"], session["topic_id"], question["lesson_id"], question_id, selected_answer, correct, question["skill_tag"], question["question_type"], question["context_type"], question["difficulty"], time_taken_ms, hint_used, wrong_because, is_final)
|
|
||||||
|
|
||||||
return {"correct": correct, "wrong_because": wrong_because}
|
# 🔧 is_final_answer: только ПОСЛЕДНЯЯ попытка считается финальной
|
||||||
|
# (для статистики). Промежуточные — revision-записи, не идут в total.
|
||||||
|
# Если клиент сказал is_final=False (подсказка) — уважаем.
|
||||||
|
if is_retry:
|
||||||
|
# Сначала снимаем флаг is_final_answer у предыдущей записи
|
||||||
|
await conn.execute(
|
||||||
|
"""
|
||||||
|
UPDATE user_learning_answers
|
||||||
|
SET is_final_answer = FALSE
|
||||||
|
WHERE session_id = $1 AND question_id = $2
|
||||||
|
""",
|
||||||
|
session_id, question_id,
|
||||||
|
)
|
||||||
|
|
||||||
|
await conn.execute(
|
||||||
|
"""
|
||||||
|
INSERT INTO user_learning_answers (
|
||||||
|
user_id, session_id, level_code, topic_id, lesson_id,
|
||||||
|
question_id, selected_answer, correct, skill_tag,
|
||||||
|
question_type, context_type, difficulty, time_taken_ms,
|
||||||
|
attempt_number, hint_used, wrong_because, is_final_answer,
|
||||||
|
revised, revision_of_id
|
||||||
|
)
|
||||||
|
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13,
|
||||||
|
$14, $15, $16, $17, $18, $19)
|
||||||
|
""",
|
||||||
|
telegram_id, session_id, session["level_code"], session["topic_id"],
|
||||||
|
question["lesson_id"], question_id, selected_answer, correct,
|
||||||
|
question["skill_tag"], question["question_type"], question["context_type"],
|
||||||
|
question["difficulty"], time_taken_ms, next_attempt, hint_used,
|
||||||
|
wrong_because, is_final, revised, prev_id,
|
||||||
|
)
|
||||||
|
|
||||||
|
# 🔧 Решаем, показывать ли правильный ответ
|
||||||
|
# Первая попытка — НЕ показываем
|
||||||
|
# Вторая — НЕ показываем
|
||||||
|
# Третья и выше — показываем
|
||||||
|
show_correct_answer = next_attempt >= 3
|
||||||
|
|
||||||
|
# Правильный ответ — текст варианта (для recognition)
|
||||||
|
correct_answer_text = None
|
||||||
|
if show_correct_answer:
|
||||||
|
correct_option = await conn.fetchrow(
|
||||||
|
"""
|
||||||
|
SELECT option_key, text_pl, text_ru, text_uk, text_en
|
||||||
|
FROM question_options
|
||||||
|
WHERE question_id = $1 AND is_correct = TRUE
|
||||||
|
LIMIT 1
|
||||||
|
""",
|
||||||
|
question_id,
|
||||||
|
)
|
||||||
|
if correct_option:
|
||||||
|
correct_answer_text = (
|
||||||
|
f"{correct_option['option_key']} — {correct_option['text_pl']}"
|
||||||
|
)
|
||||||
|
else:
|
||||||
|
# Для production — просто correct_answer из вопроса
|
||||||
|
correct_answer_text = question["correct_answer"]
|
||||||
|
|
||||||
|
return {
|
||||||
|
"correct": correct,
|
||||||
|
"wrong_because": wrong_because,
|
||||||
|
"attempt_number": next_attempt,
|
||||||
|
"show_correct_answer": show_correct_answer,
|
||||||
|
"correct_answer": correct_answer_text,
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
# 🔧 ОБНОВЛЕНО (02.10.2026): session_report —
|
||||||
|
# без AI формируем человеческий отчёт для экрана «Тема пройдена»:
|
||||||
|
# - total / correct / percent
|
||||||
|
# - message («Отлично!» / «Стоит повторить»)
|
||||||
|
# - weak_skills этой темы (с понятными названиями)
|
||||||
|
# - next_topic
|
||||||
@router.post("/session/complete")
|
@router.post("/session/complete")
|
||||||
async def complete_session(request: Request):
|
async def complete_session(request: Request):
|
||||||
"""Завершить сессию: обновляет прогресс урока/теста, мастерство навыков, прогресс темы и AI-контекст"""
|
"""
|
||||||
|
Завершить сессию: обновляет прогресс, мастерство, AI-контекст
|
||||||
|
и возвращает отчёт для экрана «Тема пройдена».
|
||||||
|
|
||||||
|
🔧 ОБНОВЛЕНО (02.10.2026): session_report —
|
||||||
|
без AI формируем человеческий отчёт:
|
||||||
|
- total / correct / percent
|
||||||
|
- message («Отлично!» / «Стоит повторить»)
|
||||||
|
- weak_skills этой темы (с понятными названиями)
|
||||||
|
- next_topic
|
||||||
|
"""
|
||||||
telegram_id, _ = await require_auth(request)
|
telegram_id, _ = await require_auth(request)
|
||||||
body = await request.json()
|
body = await request.json()
|
||||||
session_id = body.get("session_id")
|
session_id = body.get("session_id")
|
||||||
|
# 🔧 НОВОЕ: язык для формирования отчёта
|
||||||
|
lang = body.get("lang", "ru")
|
||||||
|
|
||||||
pool = await get_pool()
|
pool = await get_pool()
|
||||||
async with pool.acquire() as conn:
|
async with pool.acquire() as conn:
|
||||||
session = await conn.fetchrow("SELECT * FROM learning_sessions WHERE id = $1 AND user_id = $2", session_id, telegram_id)
|
session = await conn.fetchrow(
|
||||||
|
"SELECT * FROM learning_sessions WHERE id = $1 AND user_id = $2",
|
||||||
|
session_id, telegram_id,
|
||||||
|
)
|
||||||
if not session:
|
if not session:
|
||||||
raise HTTPException(404, "Session not found")
|
raise HTTPException(404, "Session not found")
|
||||||
|
|
||||||
await conn.execute("UPDATE learning_sessions SET is_completed = TRUE, completed_at = NOW() WHERE id = $1", session_id)
|
await conn.execute(
|
||||||
|
"UPDATE learning_sessions SET is_completed = TRUE, completed_at = NOW() WHERE id = $1",
|
||||||
|
session_id,
|
||||||
|
)
|
||||||
|
|
||||||
stats = await conn.fetchrow("""
|
# 🔧 Считаем только ПОСЛЕДНИЕ (is_final_answer=TRUE) ответы на каждый вопрос
|
||||||
SELECT COUNT(*) as total, COALESCE(SUM(CASE WHEN correct THEN 1 ELSE 0 END), 0) as correct_count
|
stats = await conn.fetchrow(
|
||||||
FROM user_learning_answers WHERE session_id = $1 AND is_final_answer = TRUE
|
"""
|
||||||
""", session_id)
|
WITH last_answers AS (
|
||||||
|
SELECT DISTINCT ON (question_id) question_id, correct, wrong_because, skill_tag
|
||||||
|
FROM user_learning_answers
|
||||||
|
WHERE session_id = $1
|
||||||
|
ORDER BY question_id, attempt_number DESC
|
||||||
|
)
|
||||||
|
SELECT
|
||||||
|
COUNT(*) AS total,
|
||||||
|
COALESCE(SUM(CASE WHEN correct THEN 1 ELSE 0 END), 0) AS correct_count
|
||||||
|
FROM last_answers
|
||||||
|
""",
|
||||||
|
session_id,
|
||||||
|
)
|
||||||
|
|
||||||
|
# Слабые навыки этой темы (те, где были ошибки)
|
||||||
|
weak_rows = await conn.fetch(
|
||||||
|
"""
|
||||||
|
WITH last_answers AS (
|
||||||
|
SELECT DISTINCT ON (question_id) question_id, correct, skill_tag
|
||||||
|
FROM user_learning_answers
|
||||||
|
WHERE session_id = $1
|
||||||
|
ORDER BY question_id, attempt_number DESC
|
||||||
|
)
|
||||||
|
SELECT
|
||||||
|
la.skill_tag,
|
||||||
|
COUNT(*) FILTER (WHERE NOT la.correct) AS errors,
|
||||||
|
COALESCE(ll.title_ru, la.skill_tag) AS name_ru,
|
||||||
|
COALESCE(ll.title_pl, la.skill_tag) AS name_pl,
|
||||||
|
COALESCE(ll.title_uk, la.skill_tag) AS name_uk,
|
||||||
|
COALESCE(ll.title_en, la.skill_tag) AS name_en
|
||||||
|
FROM last_answers la
|
||||||
|
LEFT JOIN learning_lessons ll ON ll.skill_tag = la.skill_tag
|
||||||
|
WHERE NOT la.correct
|
||||||
|
GROUP BY la.skill_tag, ll.title_ru, ll.title_pl, ll.title_uk, ll.title_en
|
||||||
|
HAVING COUNT(*) FILTER (WHERE NOT la.correct) > 0
|
||||||
|
ORDER BY errors DESC
|
||||||
|
LIMIT 5
|
||||||
|
""",
|
||||||
|
session_id,
|
||||||
|
)
|
||||||
|
|
||||||
|
# Информация о теме
|
||||||
topic_id = session["topic_id"]
|
topic_id = session["topic_id"]
|
||||||
|
topic_row = await conn.fetchrow(
|
||||||
|
"SELECT * FROM learning_topics WHERE topic_id = $1", topic_id
|
||||||
|
)
|
||||||
|
|
||||||
|
# Следующая тема того же уровня
|
||||||
|
next_topic = None
|
||||||
|
if topic_row:
|
||||||
|
next_topic = await conn.fetchrow(
|
||||||
|
"""
|
||||||
|
SELECT topic_id, name_ru, name_pl, name_uk, name_en
|
||||||
|
FROM learning_topics
|
||||||
|
WHERE level_code = $1
|
||||||
|
AND order_number > $2
|
||||||
|
AND is_active = TRUE
|
||||||
|
ORDER BY order_number
|
||||||
|
LIMIT 1
|
||||||
|
""",
|
||||||
|
topic_row["level_code"], topic_row["order_number"],
|
||||||
|
)
|
||||||
|
|
||||||
|
# ============ Обновляем прогресс ============
|
||||||
|
# (всё что было — оставляем)
|
||||||
|
|
||||||
# Обновляем прогресс урока
|
|
||||||
if session["session_type"] == "lesson":
|
if session["session_type"] == "lesson":
|
||||||
lesson_row = await conn.fetchrow("""
|
lesson_row = await conn.fetchrow(
|
||||||
SELECT DISTINCT lesson_id FROM user_learning_answers WHERE session_id = $1 AND lesson_id IS NOT NULL
|
"""
|
||||||
""", session_id)
|
SELECT DISTINCT lesson_id FROM user_learning_answers
|
||||||
|
WHERE session_id = $1 AND lesson_id IS NOT NULL
|
||||||
|
""",
|
||||||
|
session_id,
|
||||||
|
)
|
||||||
if lesson_row and lesson_row["lesson_id"]:
|
if lesson_row and lesson_row["lesson_id"]:
|
||||||
lesson_id = lesson_row["lesson_id"]
|
lesson_id = lesson_row["lesson_id"]
|
||||||
score = (stats["correct_count"] / stats["total"] * 100) if stats["total"] > 0 else 0
|
score = (
|
||||||
|
stats["correct_count"] / stats["total"] * 100
|
||||||
await conn.execute("""
|
) if stats["total"] > 0 else 0
|
||||||
INSERT INTO user_lesson_progress (user_id, lesson_id, started_at, completed_at, attempts_count, correct_count, best_score, completed)
|
await conn.execute(
|
||||||
|
"""
|
||||||
|
INSERT INTO user_lesson_progress (
|
||||||
|
user_id, lesson_id, started_at, completed_at,
|
||||||
|
attempts_count, correct_count, best_score, completed
|
||||||
|
)
|
||||||
VALUES ($1, $2, NOW(), NOW(), 1, $3, $4, TRUE)
|
VALUES ($1, $2, NOW(), NOW(), 1, $3, $4, TRUE)
|
||||||
ON CONFLICT (user_id, lesson_id) DO UPDATE
|
ON CONFLICT (user_id, lesson_id) DO UPDATE
|
||||||
SET completed_at = NOW(),
|
SET completed_at = NOW(),
|
||||||
@@ -687,37 +908,111 @@ async def complete_session(request: Request):
|
|||||||
correct_count = user_lesson_progress.correct_count + $3,
|
correct_count = user_lesson_progress.correct_count + $3,
|
||||||
best_score = GREATEST(user_lesson_progress.best_score, $4),
|
best_score = GREATEST(user_lesson_progress.best_score, $4),
|
||||||
completed = TRUE
|
completed = TRUE
|
||||||
""", telegram_id, lesson_id, stats["correct_count"], score)
|
""",
|
||||||
|
telegram_id, lesson_id, stats["correct_count"], score,
|
||||||
|
)
|
||||||
|
|
||||||
# Обновляем прогресс темы если это тест
|
|
||||||
if session["session_type"] == "topic_test":
|
if session["session_type"] == "topic_test":
|
||||||
test_score = (stats["correct_count"] / stats["total"] * 100) if stats["total"] > 0 else 0
|
test_score = (
|
||||||
|
stats["correct_count"] / stats["total"] * 100
|
||||||
await conn.execute("""
|
) if stats["total"] > 0 else 0
|
||||||
INSERT INTO user_topic_progress (user_id, topic_id, test_started, test_completed, test_score, completed_at)
|
await conn.execute(
|
||||||
|
"""
|
||||||
|
INSERT INTO user_topic_progress (
|
||||||
|
user_id, topic_id, test_started, test_completed, test_score, completed_at
|
||||||
|
)
|
||||||
VALUES ($1, $2, TRUE, TRUE, $3, NOW())
|
VALUES ($1, $2, TRUE, TRUE, $3, NOW())
|
||||||
ON CONFLICT (user_id, topic_id) DO UPDATE
|
ON CONFLICT (user_id, topic_id) DO UPDATE
|
||||||
SET test_completed = TRUE,
|
SET test_completed = TRUE,
|
||||||
test_score = $3,
|
test_score = $3,
|
||||||
completed_at = NOW()
|
completed_at = NOW()
|
||||||
""", telegram_id, topic_id, test_score)
|
""",
|
||||||
|
telegram_id, topic_id, test_score,
|
||||||
|
)
|
||||||
|
|
||||||
# Обновляем мастерство по всем навыкам из этой сессии
|
skill_tags = await conn.fetch(
|
||||||
skill_tags = await conn.fetch("""
|
"SELECT DISTINCT skill_tag FROM user_learning_answers WHERE session_id = $1",
|
||||||
SELECT DISTINCT skill_tag FROM user_learning_answers WHERE session_id = $1
|
session_id,
|
||||||
""", session_id)
|
)
|
||||||
|
|
||||||
for st in skill_tags:
|
for st in skill_tags:
|
||||||
await update_skill_mastery(conn, telegram_id, st["skill_tag"])
|
await update_skill_mastery(conn, telegram_id, st["skill_tag"])
|
||||||
|
|
||||||
# Обновляем прогресс темы ТОЛЬКО для lesson и topic_test
|
|
||||||
if session["session_type"] in ("lesson", "topic_test") and topic_id:
|
if session["session_type"] in ("lesson", "topic_test") and topic_id:
|
||||||
await update_topic_progress(conn, telegram_id, topic_id)
|
await update_topic_progress(conn, telegram_id, topic_id)
|
||||||
|
|
||||||
# Обновляем AI-контекст (всегда)
|
|
||||||
await update_ai_context(conn, telegram_id)
|
await update_ai_context(conn, telegram_id)
|
||||||
|
|
||||||
return {"status": "ok", "total": stats["total"], "correct_count": stats["correct_count"]}
|
# ============ Формируем отчёт ============
|
||||||
|
total = stats["total"] or 0
|
||||||
|
correct_count = stats["correct_count"] or 0
|
||||||
|
percent = round(correct_count / total * 100) if total > 0 else 0
|
||||||
|
|
||||||
|
# Человеческое сообщение (без AI, чистая математика)
|
||||||
|
if percent >= 90:
|
||||||
|
message = {
|
||||||
|
"ru": "Отлично! Ты прекрасно усвоил тему! 🎉",
|
||||||
|
"pl": "Świetnie! Doskonale opanowałeś temat! 🎉",
|
||||||
|
"uk": "Чудово! Ти чудово засвоїв тему! 🎉",
|
||||||
|
"en": "Excellent! You've mastered this topic! 🎉",
|
||||||
|
}.get(lang, "Отлично! 🎉")
|
||||||
|
elif percent >= 75:
|
||||||
|
message = {
|
||||||
|
"ru": "Хороший результат! Так держать! 💪",
|
||||||
|
"pl": "Dobry wynik! Tak trzymaj! 💪",
|
||||||
|
"uk": "Гарний результат! Так тримати! 💪",
|
||||||
|
"en": "Good result! Keep it up! 💪",
|
||||||
|
}.get(lang, "Хороший результат! 💪")
|
||||||
|
elif percent >= 60:
|
||||||
|
message = {
|
||||||
|
"ru": "Неплохо! Но есть над чем поработать.",
|
||||||
|
"pl": "Nieźle! Ale jest nad czym popracować.",
|
||||||
|
"uk": "Непогано! Але є над чим попрацювати.",
|
||||||
|
"en": "Not bad! But there's room to improve.",
|
||||||
|
}.get(lang, "Неплохо!")
|
||||||
|
else:
|
||||||
|
message = {
|
||||||
|
"ru": "Стоит пройти тему ещё раз — много ошибок.",
|
||||||
|
"pl": "Warto powtórzyć temat — dużo błędów.",
|
||||||
|
"uk": "Варто пройти тему ще раз — багато помилок.",
|
||||||
|
"en": "Worth repeating this topic — many mistakes.",
|
||||||
|
}.get(lang, "Стоит повторить.")
|
||||||
|
|
||||||
|
# Слабые навыки на нужном языке
|
||||||
|
name_field = f"name_{lang}"
|
||||||
|
weak_skills_out = []
|
||||||
|
for w in weak_rows:
|
||||||
|
weak_skills_out.append({
|
||||||
|
"skill_tag": w["skill_tag"],
|
||||||
|
"name": w.get(name_field) or w["name_ru"],
|
||||||
|
"errors": w["errors"],
|
||||||
|
})
|
||||||
|
|
||||||
|
# Информация о следующей теме
|
||||||
|
next_out = None
|
||||||
|
if next_topic:
|
||||||
|
next_out = {
|
||||||
|
"topic_id": next_topic["topic_id"],
|
||||||
|
"name": next_topic.get(name_field) or next_topic["name_ru"],
|
||||||
|
}
|
||||||
|
|
||||||
|
# Название текущей темы
|
||||||
|
topic_name = None
|
||||||
|
if topic_row:
|
||||||
|
topic_name = topic_row.get(name_field) or topic_row["name_ru"]
|
||||||
|
|
||||||
|
return {
|
||||||
|
"status": "ok",
|
||||||
|
"total": total,
|
||||||
|
"correct_count": correct_count,
|
||||||
|
"report": {
|
||||||
|
"topic_id": topic_id,
|
||||||
|
"topic_name": topic_name,
|
||||||
|
"percent": percent,
|
||||||
|
"message": message,
|
||||||
|
"weak_skills": weak_skills_out,
|
||||||
|
"next_topic": next_out,
|
||||||
|
},
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
@router.get("/progress")
|
@router.get("/progress")
|
||||||
@@ -820,7 +1115,7 @@ async def get_analytics(request: Request):
|
|||||||
{"role": "system", "content": system_prompt},
|
{"role": "system", "content": system_prompt},
|
||||||
{"role": "user", "content": user_prompt},
|
{"role": "user", "content": user_prompt},
|
||||||
],
|
],
|
||||||
"max_tokens": 1000,
|
"max_tokens": 3000,
|
||||||
"temperature": 0.7,
|
"temperature": 0.7,
|
||||||
},
|
},
|
||||||
)
|
)
|
||||||
|
|||||||
@@ -1,8 +1,27 @@
|
|||||||
"""
|
"""
|
||||||
Learning Data Package — данные всех уровней.
|
Learning Data Package — данные всех уровней.
|
||||||
Каждый уровень в отдельном файле.
|
Каждый уровень в отдельном файле.
|
||||||
|
|
||||||
|
🔧 ОБНОВЛЕНО (02.10.2026): seed_data_only_if_empty —
|
||||||
|
файлы level_*.py остаются в репозитории как АРХИВ,
|
||||||
|
но при старте бэкенда контент НЕ перезаписывается, если
|
||||||
|
в БД уже есть данные.
|
||||||
|
|
||||||
|
Причины:
|
||||||
|
- Контент правится через админку → правки в БД.
|
||||||
|
- Если seed запускать всегда — правки затираются.
|
||||||
|
- Уровни (learning_levels) гарантированно создаются — они статичны.
|
||||||
|
|
||||||
|
Управление:
|
||||||
|
- Переменная окружения SEED_LEARNING_DATA=true в .env → заливаем файлы.
|
||||||
|
- По умолчанию false → пропускаем seed, если данные уже есть.
|
||||||
|
|
||||||
|
Для fresh install (пустая БД): seed запустится автоматически,
|
||||||
|
т.к. проверка «learning_topics пуст» проходит.
|
||||||
"""
|
"""
|
||||||
import logging
|
import logging
|
||||||
|
import os
|
||||||
|
|
||||||
from database import get_pool
|
from database import get_pool
|
||||||
from . import level_a1, level_a2, level_b1, level_b2, level_c1, level_c2
|
from . import level_a1, level_a2, level_b1, level_b2, level_c1, level_c2
|
||||||
|
|
||||||
@@ -10,10 +29,10 @@ logger = logging.getLogger(__name__)
|
|||||||
|
|
||||||
|
|
||||||
async def init_learning_data():
|
async def init_learning_data():
|
||||||
"""Инициализирует уровни и все темы"""
|
"""Инициализирует уровни и (опционально) контент из файлов."""
|
||||||
pool = await get_pool()
|
pool = await get_pool()
|
||||||
async with pool.acquire() as conn:
|
async with pool.acquire() as conn:
|
||||||
# ============ УРОВНИ ============
|
# ============ УРОВНИ (всегда, они статичны) ============
|
||||||
levels = [
|
levels = [
|
||||||
("A1", "Poziom A1", "Уровень A1", "Рівень A1", "Level A1", 1),
|
("A1", "Poziom A1", "Уровень A1", "Рівень A1", "Level A1", 1),
|
||||||
("A2", "Poziom A2", "Уровень A2", "Рівень A2", "Level A2", 2),
|
("A2", "Poziom A2", "Уровень A2", "Рівень A2", "Level A2", 2),
|
||||||
@@ -29,7 +48,29 @@ async def init_learning_data():
|
|||||||
ON CONFLICT (code) DO NOTHING
|
ON CONFLICT (code) DO NOTHING
|
||||||
""", code, pl, ru, uk, en, sort)
|
""", code, pl, ru, uk, en, sort)
|
||||||
|
|
||||||
# Загружаем данные каждого уровня
|
logger.info("[seed] learning_levels ensured (A1-C2)")
|
||||||
|
|
||||||
|
# ============ ПРОВЕРКА: нужен ли seed контента? ============
|
||||||
|
force_seed = os.getenv("SEED_LEARNING_DATA", "false").lower() == "true"
|
||||||
|
|
||||||
|
topics_count = await conn.fetchval("""
|
||||||
|
SELECT COUNT(*) FROM learning_topics
|
||||||
|
""") or 0
|
||||||
|
|
||||||
|
if topics_count > 0 and not force_seed:
|
||||||
|
logger.info(
|
||||||
|
f"[seed] learning_topics not empty ({topics_count} topics) — "
|
||||||
|
f"skipping content seed. Установи SEED_LEARNING_DATA=true в .env "
|
||||||
|
f"для принудительной перезаливки."
|
||||||
|
)
|
||||||
|
return
|
||||||
|
|
||||||
|
# ============ SEED КОНТЕНТА (fresh install ИЛИ force) ============
|
||||||
|
if force_seed:
|
||||||
|
logger.warning("[seed] SEED_LEARNING_DATA=true — принудительная перезаливка контента")
|
||||||
|
else:
|
||||||
|
logger.info("[seed] Empty DB detected — seeding content from level_*.py files")
|
||||||
|
|
||||||
await level_a1.init_level_a1(conn)
|
await level_a1.init_level_a1(conn)
|
||||||
await level_a2.init_level_a2(conn)
|
await level_a2.init_level_a2(conn)
|
||||||
await level_b1.init_level_b1(conn)
|
await level_b1.init_level_b1(conn)
|
||||||
@@ -37,4 +78,4 @@ async def init_learning_data():
|
|||||||
await level_c1.init_level_c1(conn)
|
await level_c1.init_level_c1(conn)
|
||||||
await level_c2.init_level_c2(conn)
|
await level_c2.init_level_c2(conn)
|
||||||
|
|
||||||
logger.info("Learning data fully initialized")
|
logger.info("[seed] Learning content initialized from files")
|
||||||
+70
-36
@@ -6,6 +6,9 @@ Orchestrator — мозг чат-учителя.
|
|||||||
3. Иначе → следующий урок по порядку
|
3. Иначе → следующий урок по порядку
|
||||||
|
|
||||||
Никакого AI — только детерминированная логика.
|
Никакого AI — только детерминированная логика.
|
||||||
|
|
||||||
|
🔧 ОБНОВЛЕНО (04.10.2026): track_filter —
|
||||||
|
учитель уважает аудиторию юзера (pl / ru_uk / en).
|
||||||
"""
|
"""
|
||||||
import logging
|
import logging
|
||||||
from typing import Optional, Dict, Any
|
from typing import Optional, Dict, Any
|
||||||
@@ -16,7 +19,7 @@ logger = logging.getLogger(__name__)
|
|||||||
async def get_next_lesson(conn, user_id: int) -> Dict[str, Any]:
|
async def get_next_lesson(conn, user_id: int) -> Dict[str, Any]:
|
||||||
"""
|
"""
|
||||||
Выбирает следующий урок для пользователя.
|
Выбирает следующий урок для пользователя.
|
||||||
|
|
||||||
Возвращает:
|
Возвращает:
|
||||||
{
|
{
|
||||||
"type": "new" | "review" | "test",
|
"type": "new" | "review" | "test",
|
||||||
@@ -24,13 +27,34 @@ async def get_next_lesson(conn, user_id: int) -> Dict[str, Any]:
|
|||||||
"reason": str,
|
"reason": str,
|
||||||
"skill_tag": str | None
|
"skill_tag": str | None
|
||||||
}
|
}
|
||||||
|
|
||||||
|
🔧 ОБНОВЛЕНО (04.10.2026): track_filter —
|
||||||
|
учитель уважает аудиторию юзера:
|
||||||
|
- pl → track='pl'
|
||||||
|
- ru/uk → track='ru_uk'
|
||||||
|
- en → track='en'
|
||||||
|
Все SQL-запросы фильтруют по track, чтобы не подсовывать
|
||||||
|
RU/UK-уроки польскому или английскому юзеру.
|
||||||
"""
|
"""
|
||||||
|
|
||||||
# Получаем текущий уровень пользователя
|
# Получаем текущий уровень пользователя
|
||||||
current_level = await conn.fetchval("""
|
current_level = await conn.fetchval("""
|
||||||
SELECT current_level FROM users WHERE telegram_id = $1
|
SELECT current_level FROM users WHERE telegram_id = $1
|
||||||
""", user_id) or "A1"
|
""", user_id) or "A1"
|
||||||
|
|
||||||
|
# 🔧 НОВОЕ (04.10.2026): track_filter —
|
||||||
|
# определяем track по app_language юзера.
|
||||||
|
user_lang = await conn.fetchval("""
|
||||||
|
SELECT app_language FROM users WHERE telegram_id = $1
|
||||||
|
""", user_id) or "ru"
|
||||||
|
|
||||||
|
if user_lang == "pl":
|
||||||
|
track = "pl"
|
||||||
|
elif user_lang == "en":
|
||||||
|
track = "en"
|
||||||
|
else:
|
||||||
|
track = "ru_uk"
|
||||||
|
|
||||||
# ============ ШАГ 1: Проверяем retention_status ============
|
# ============ ШАГ 1: Проверяем retention_status ============
|
||||||
# Если есть навыки, которые давно не повторяли — повторяем их
|
# Если есть навыки, которые давно не повторяли — повторяем их
|
||||||
overdue_skill = await conn.fetchrow("""
|
overdue_skill = await conn.fetchrow("""
|
||||||
@@ -42,26 +66,30 @@ async def get_next_lesson(conn, user_id: int) -> Dict[str, Any]:
|
|||||||
ORDER BY days_since_last_attempt DESC
|
ORDER BY days_since_last_attempt DESC
|
||||||
LIMIT 1
|
LIMIT 1
|
||||||
""", user_id)
|
""", user_id)
|
||||||
|
|
||||||
if overdue_skill:
|
if overdue_skill:
|
||||||
|
# 🔧 НОВОЕ (04.10.2026): track_filter_lesson — ищем урок по skill_tag
|
||||||
|
# ТОЛЬКО в темах нужного track.
|
||||||
lesson = await conn.fetchrow("""
|
lesson = await conn.fetchrow("""
|
||||||
SELECT l.lesson_id, l.topic_id, l.skill_tag, l.title_pl, l.title_ru, l.title_uk, l.title_en
|
SELECT l.lesson_id, l.topic_id, l.skill_tag, l.title_pl, l.title_ru, l.title_uk, l.title_en
|
||||||
FROM learning_lessons l
|
FROM learning_lessons l
|
||||||
|
JOIN learning_topics t ON l.topic_id = t.topic_id
|
||||||
WHERE l.skill_tag = $1
|
WHERE l.skill_tag = $1
|
||||||
AND l.is_active = TRUE
|
AND l.is_active = TRUE
|
||||||
|
AND t.track = $2
|
||||||
ORDER BY l.order_number
|
ORDER BY l.order_number
|
||||||
LIMIT 1
|
LIMIT 1
|
||||||
""", overdue_skill["skill_tag"])
|
""", overdue_skill["skill_tag"], track)
|
||||||
|
|
||||||
if lesson:
|
if lesson:
|
||||||
logger.info(f"Orchestrator: review (overdue) for user={user_id}, skill={overdue_skill['skill_tag']}")
|
logger.info(f"Orchestrator: review (overdue) for user={user_id}, skill={overdue_skill['skill_tag']}, track={track}")
|
||||||
return {
|
return {
|
||||||
"type": "review",
|
"type": "review",
|
||||||
"lesson": dict(lesson),
|
"lesson": dict(lesson),
|
||||||
"reason": "overdue",
|
"reason": "overdue",
|
||||||
"skill_tag": overdue_skill["skill_tag"],
|
"skill_tag": overdue_skill["skill_tag"],
|
||||||
}
|
}
|
||||||
|
|
||||||
# ============ ШАГ 2: Проверяем mastery < 75 ============
|
# ============ ШАГ 2: Проверяем mastery < 75 ============
|
||||||
weak_skill = await conn.fetchrow("""
|
weak_skill = await conn.fetchrow("""
|
||||||
SELECT skill_tag, mastery_score, repeated_error_count, trend
|
SELECT skill_tag, mastery_score, repeated_error_count, trend
|
||||||
@@ -72,50 +100,55 @@ async def get_next_lesson(conn, user_id: int) -> Dict[str, Any]:
|
|||||||
ORDER BY mastery_score ASC
|
ORDER BY mastery_score ASC
|
||||||
LIMIT 1
|
LIMIT 1
|
||||||
""", user_id)
|
""", user_id)
|
||||||
|
|
||||||
if weak_skill:
|
if weak_skill:
|
||||||
|
# 🔧 НОВОЕ (04.10.2026): track_filter_lesson
|
||||||
lesson = await conn.fetchrow("""
|
lesson = await conn.fetchrow("""
|
||||||
SELECT l.lesson_id, l.topic_id, l.skill_tag, l.title_pl, l.title_ru, l.title_uk, l.title_en
|
SELECT l.lesson_id, l.topic_id, l.skill_tag, l.title_pl, l.title_ru, l.title_uk, l.title_en
|
||||||
FROM learning_lessons l
|
FROM learning_lessons l
|
||||||
|
JOIN learning_topics t ON l.topic_id = t.topic_id
|
||||||
WHERE l.skill_tag = $1
|
WHERE l.skill_tag = $1
|
||||||
AND l.is_active = TRUE
|
AND l.is_active = TRUE
|
||||||
|
AND t.track = $2
|
||||||
ORDER BY l.order_number
|
ORDER BY l.order_number
|
||||||
LIMIT 1
|
LIMIT 1
|
||||||
""", weak_skill["skill_tag"])
|
""", weak_skill["skill_tag"], track)
|
||||||
|
|
||||||
if lesson:
|
if lesson:
|
||||||
logger.info(f"Orchestrator: review (weak) for user={user_id}, skill={weak_skill['skill_tag']}, mastery={weak_skill['mastery_score']}")
|
logger.info(f"Orchestrator: review (weak) for user={user_id}, skill={weak_skill['skill_tag']}, mastery={weak_skill['mastery_score']}, track={track}")
|
||||||
return {
|
return {
|
||||||
"type": "review",
|
"type": "review",
|
||||||
"lesson": dict(lesson),
|
"lesson": dict(lesson),
|
||||||
"reason": "weak_mastery",
|
"reason": "weak_mastery",
|
||||||
"skill_tag": weak_skill["skill_tag"],
|
"skill_tag": weak_skill["skill_tag"],
|
||||||
}
|
}
|
||||||
|
|
||||||
# ============ ШАГ 3: Проверяем, нужно ли пройти тест темы ============
|
# ============ ШАГ 3: Проверяем, нужно ли пройти тест темы ============
|
||||||
# Если пользователь завершил все уроки темы, но не прошёл тест
|
# 🔧 НОВОЕ (04.10.2026): track_filter_test — только темы нужного track.
|
||||||
topic_for_test = await conn.fetchrow("""
|
topic_for_test = await conn.fetchrow("""
|
||||||
SELECT tp.topic_id, tp.lessons_total, tp.lessons_completed, tp.test_completed
|
SELECT tp.topic_id, tp.lessons_total, tp.lessons_completed, tp.test_completed
|
||||||
FROM user_topic_progress tp
|
FROM user_topic_progress tp
|
||||||
|
JOIN learning_topics t ON tp.topic_id = t.topic_id
|
||||||
WHERE tp.user_id = $1
|
WHERE tp.user_id = $1
|
||||||
AND tp.lessons_completed >= tp.lessons_total
|
AND tp.lessons_completed >= tp.lessons_total
|
||||||
AND tp.lessons_total > 0
|
AND tp.lessons_total > 0
|
||||||
AND tp.test_completed = FALSE
|
AND tp.test_completed = FALSE
|
||||||
|
AND t.track = $2
|
||||||
ORDER BY tp.topic_id
|
ORDER BY tp.topic_id
|
||||||
LIMIT 1
|
LIMIT 1
|
||||||
""", user_id)
|
""", user_id, track)
|
||||||
|
|
||||||
if topic_for_test:
|
if topic_for_test:
|
||||||
logger.info(f"Orchestrator: test for user={user_id}, topic={topic_for_test['topic_id']}")
|
logger.info(f"Orchestrator: test for user={user_id}, topic={topic_for_test['topic_id']}, track={track}")
|
||||||
return {
|
return {
|
||||||
"type": "test",
|
"type": "test",
|
||||||
"lesson": None,
|
"lesson": None,
|
||||||
"reason": "topic_completed_no_test",
|
"reason": "topic_completed_no_test",
|
||||||
"topic_id": topic_for_test["topic_id"],
|
"topic_id": topic_for_test["topic_id"],
|
||||||
}
|
}
|
||||||
|
|
||||||
# ============ ШАГ 4: Следующий урок по порядку ============
|
# ============ ШАГ 4: Следующий урок по порядку ============
|
||||||
# Находим первый непройденный урок в текущем уровне
|
# 🔧 НОВОЕ (04.10.2026): track_filter_next — только уроки нужного track.
|
||||||
next_lesson = await conn.fetchrow("""
|
next_lesson = await conn.fetchrow("""
|
||||||
SELECT l.lesson_id, l.topic_id, l.skill_tag, l.title_pl, l.title_ru, l.title_uk, l.title_en,
|
SELECT l.lesson_id, l.topic_id, l.skill_tag, l.title_pl, l.title_ru, l.title_uk, l.title_en,
|
||||||
t.topic_id as topic_id, t.order_number as topic_order
|
t.topic_id as topic_id, t.order_number as topic_order
|
||||||
@@ -123,25 +156,26 @@ async def get_next_lesson(conn, user_id: int) -> Dict[str, Any]:
|
|||||||
JOIN learning_topics t ON l.topic_id = t.topic_id
|
JOIN learning_topics t ON l.topic_id = t.topic_id
|
||||||
WHERE t.level_code = $1
|
WHERE t.level_code = $1
|
||||||
AND l.is_active = TRUE
|
AND l.is_active = TRUE
|
||||||
|
AND t.track = $3
|
||||||
AND l.lesson_id NOT IN (
|
AND l.lesson_id NOT IN (
|
||||||
SELECT lesson_id FROM user_lesson_progress
|
SELECT lesson_id FROM user_lesson_progress
|
||||||
WHERE user_id = $2 AND completed = TRUE
|
WHERE user_id = $2 AND completed = TRUE
|
||||||
)
|
)
|
||||||
ORDER BY t.order_number, l.order_number
|
ORDER BY t.order_number, l.order_number
|
||||||
LIMIT 1
|
LIMIT 1
|
||||||
""", current_level, user_id)
|
""", current_level, user_id, track)
|
||||||
|
|
||||||
if next_lesson:
|
if next_lesson:
|
||||||
logger.info(f"Orchestrator: new lesson for user={user_id}, lesson={next_lesson['lesson_id']}")
|
logger.info(f"Orchestrator: new lesson for user={user_id}, lesson={next_lesson['lesson_id']}, track={track}")
|
||||||
return {
|
return {
|
||||||
"type": "new",
|
"type": "new",
|
||||||
"lesson": dict(next_lesson),
|
"lesson": dict(next_lesson),
|
||||||
"reason": "next_in_order",
|
"reason": "next_in_order",
|
||||||
"skill_tag": next_lesson["skill_tag"],
|
"skill_tag": next_lesson["skill_tag"],
|
||||||
}
|
}
|
||||||
|
|
||||||
# ============ ШАГ 5: Всё пройдено ============
|
# ============ ШАГ 5: Всё пройдено ============
|
||||||
logger.info(f"Orchestrator: all completed for user={user_id}")
|
logger.info(f"Orchestrator: all completed for user={user_id}, track={track}")
|
||||||
return {
|
return {
|
||||||
"type": "completed",
|
"type": "completed",
|
||||||
"lesson": None,
|
"lesson": None,
|
||||||
@@ -152,18 +186,18 @@ async def get_next_lesson(conn, user_id: int) -> Dict[str, Any]:
|
|||||||
|
|
||||||
async def get_lesson_by_id(conn, lesson_id: str) -> Optional[Dict[str, Any]]:
|
async def get_lesson_by_id(conn, lesson_id: str) -> Optional[Dict[str, Any]]:
|
||||||
"""Получает урок по ID со всеми данными: объяснение, примеры, вопросы."""
|
"""Получает урок по ID со всеми данными: объяснение, примеры, вопросы."""
|
||||||
|
|
||||||
lesson = await conn.fetchrow("""
|
lesson = await conn.fetchrow("""
|
||||||
SELECT * FROM learning_lessons WHERE lesson_id = $1 AND is_active = TRUE
|
SELECT * FROM learning_lessons WHERE lesson_id = $1 AND is_active = TRUE
|
||||||
""", lesson_id)
|
""", lesson_id)
|
||||||
|
|
||||||
if not lesson:
|
if not lesson:
|
||||||
return None
|
return None
|
||||||
|
|
||||||
examples = await conn.fetch("""
|
examples = await conn.fetch("""
|
||||||
SELECT * FROM lesson_examples WHERE lesson_id = $1 ORDER BY order_number
|
SELECT * FROM lesson_examples WHERE lesson_id = $1 ORDER BY order_number
|
||||||
""", lesson_id)
|
""", lesson_id)
|
||||||
|
|
||||||
questions = await conn.fetch("""
|
questions = await conn.fetch("""
|
||||||
SELECT * FROM learning_questions
|
SELECT * FROM learning_questions
|
||||||
WHERE lesson_id = $1 AND is_test_question = FALSE
|
WHERE lesson_id = $1 AND is_test_question = FALSE
|
||||||
@@ -200,7 +234,7 @@ async def get_lesson_by_id(conn, lesson_id: str) -> Optional[Dict[str, Any]]:
|
|||||||
|
|
||||||
async def get_lesson_questions(conn, lesson_id: str) -> list:
|
async def get_lesson_questions(conn, lesson_id: str) -> list:
|
||||||
"""Получает только вопросы урока (без объяснения)."""
|
"""Получает только вопросы урока (без объяснения)."""
|
||||||
|
|
||||||
questions = await conn.fetch("""
|
questions = await conn.fetch("""
|
||||||
SELECT * FROM learning_questions
|
SELECT * FROM learning_questions
|
||||||
WHERE lesson_id = $1 AND is_test_question = FALSE
|
WHERE lesson_id = $1 AND is_test_question = FALSE
|
||||||
@@ -231,7 +265,7 @@ async def get_lesson_questions(conn, lesson_id: str) -> list:
|
|||||||
|
|
||||||
async def get_test_questions(conn, topic_id: str) -> list:
|
async def get_test_questions(conn, topic_id: str) -> list:
|
||||||
"""Получает вопросы финального теста по теме."""
|
"""Получает вопросы финального теста по теме."""
|
||||||
|
|
||||||
questions = await conn.fetch("""
|
questions = await conn.fetch("""
|
||||||
SELECT * FROM learning_questions
|
SELECT * FROM learning_questions
|
||||||
WHERE topic_id = $1 AND is_test_question = TRUE
|
WHERE topic_id = $1 AND is_test_question = TRUE
|
||||||
@@ -262,7 +296,7 @@ async def get_test_questions(conn, topic_id: str) -> list:
|
|||||||
|
|
||||||
async def get_random_reaction(conn, reaction_type: str, lang: str) -> str:
|
async def get_random_reaction(conn, reaction_type: str, lang: str) -> str:
|
||||||
"""Получает случайную реакцию из банка по типу."""
|
"""Получает случайную реакцию из банка по типу."""
|
||||||
|
|
||||||
row = await conn.fetchrow("""
|
row = await conn.fetchrow("""
|
||||||
SELECT text_pl, text_ru, text_uk, text_en
|
SELECT text_pl, text_ru, text_uk, text_en
|
||||||
FROM teacher_reactions
|
FROM teacher_reactions
|
||||||
@@ -270,7 +304,7 @@ async def get_random_reaction(conn, reaction_type: str, lang: str) -> str:
|
|||||||
ORDER BY RANDOM()
|
ORDER BY RANDOM()
|
||||||
LIMIT 1
|
LIMIT 1
|
||||||
""", reaction_type)
|
""", reaction_type)
|
||||||
|
|
||||||
if not row:
|
if not row:
|
||||||
# Запасные реакции, если таблица пуста
|
# Запасные реакции, если таблица пуста
|
||||||
fallbacks = {
|
fallbacks = {
|
||||||
@@ -294,22 +328,22 @@ async def get_random_reaction(conn, reaction_type: str, lang: str) -> str:
|
|||||||
},
|
},
|
||||||
}
|
}
|
||||||
return fallbacks.get(reaction_type, {}).get(lang, "OK")
|
return fallbacks.get(reaction_type, {}).get(lang, "OK")
|
||||||
|
|
||||||
field = f"text_{lang}"
|
field = f"text_{lang}"
|
||||||
return row.get(field) or row.get("text_en") or "OK"
|
return row.get(field) or row.get("text_en") or "OK"
|
||||||
|
|
||||||
|
|
||||||
async def get_wrong_because_explanation(conn, wrong_because: str, lang: str) -> str:
|
async def get_wrong_because_explanation(conn, wrong_because: str, lang: str) -> str:
|
||||||
"""Получает объяснение ошибки по тегу wrong_because."""
|
"""Получает объяснение ошибки по тегу wrong_because."""
|
||||||
|
|
||||||
row = await conn.fetchrow("""
|
row = await conn.fetchrow("""
|
||||||
SELECT explanation_pl, explanation_ru, explanation_uk, explanation_en
|
SELECT explanation_pl, explanation_ru, explanation_uk, explanation_en
|
||||||
FROM wrong_because_explanations
|
FROM wrong_because_explanations
|
||||||
WHERE wrong_because = $1
|
WHERE wrong_because = $1
|
||||||
""", wrong_because)
|
""", wrong_because)
|
||||||
|
|
||||||
if not row:
|
if not row:
|
||||||
return ""
|
return ""
|
||||||
|
|
||||||
field = f"explanation_{lang}"
|
field = f"explanation_{lang}"
|
||||||
return row.get(field) or row.get("explanation_en") or ""
|
return row.get(field) or row.get("explanation_en") or ""
|
||||||
@@ -1,4 +1,3 @@
|
|||||||
import random
|
|
||||||
from fastapi import APIRouter, Request, HTTPException
|
from fastapi import APIRouter, Request, HTTPException
|
||||||
from auth import require_auth
|
from auth import require_auth
|
||||||
from database import get_pool
|
from database import get_pool
|
||||||
@@ -21,14 +20,19 @@ async def get_next_word(request: Request):
|
|||||||
|
|
||||||
lang = user["app_language"] or "pl"
|
lang = user["app_language"] or "pl"
|
||||||
|
|
||||||
# Берём случайное слово из всех уровней (без привязки к конкретному уровню)
|
# 🔧 ФИКС (30.09.2026): csv_words_source —
|
||||||
|
# источник слов переехал с level_words (старая схема level_id IS NULL)
|
||||||
|
# на csv_words. В csv_words нет колонки level — только level_code.
|
||||||
|
# Фронт ожидает поле "level", поэтому используем алиас level_code AS level.
|
||||||
|
# DISTINCT ON (word_pl) больше не нужен — в csv_words
|
||||||
|
# есть UNIQUE(level_code, word_pl), дубликатов по word_pl на одном
|
||||||
|
# уровне нет, но между уровнями могут быть. Поэтому слово может
|
||||||
|
# попасться несколько раз с разным level_code — оставляем как есть
|
||||||
|
# (для произношения уровень не критичен).
|
||||||
word = await conn.fetchrow("""
|
word = await conn.fetchrow("""
|
||||||
SELECT word_pl, translation_ru, translation_uk, translation_en, level
|
SELECT word_pl, translation_ru, translation_uk, translation_en,
|
||||||
FROM (
|
level_code AS level
|
||||||
SELECT DISTINCT ON (word_pl) word_pl, translation_ru, translation_uk, translation_en, level
|
FROM csv_words
|
||||||
FROM level_words
|
|
||||||
WHERE level_id IS NULL
|
|
||||||
) AS unique_words
|
|
||||||
ORDER BY RANDOM()
|
ORDER BY RANDOM()
|
||||||
LIMIT 1
|
LIMIT 1
|
||||||
""")
|
""")
|
||||||
|
|||||||
+34
-4
@@ -160,6 +160,8 @@ async def check_sentence(request: Request):
|
|||||||
raise HTTPException(400, "Too many words")
|
raise HTTPException(400, "Too many words")
|
||||||
|
|
||||||
pool = await get_pool()
|
pool = await get_pool()
|
||||||
|
# 🔧 НОВОЕ (08.10.2026): XP-система — результат award_xp.
|
||||||
|
xp_result = None
|
||||||
async with pool.acquire() as conn:
|
async with pool.acquire() as conn:
|
||||||
user_exists = await conn.fetchval(
|
user_exists = await conn.fetchval(
|
||||||
"SELECT 1 FROM users WHERE telegram_id = $1", telegram_id
|
"SELECT 1 FROM users WHERE telegram_id = $1", telegram_id
|
||||||
@@ -207,12 +209,28 @@ async def check_sentence(request: Request):
|
|||||||
|
|
||||||
if is_correct:
|
if is_correct:
|
||||||
word_count = len(correct_words_original)
|
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:
|
if word_count <= 4:
|
||||||
score = 50
|
time_limit = 30
|
||||||
elif word_count <= 6:
|
elif word_count <= 6:
|
||||||
score = 75
|
time_limit = 45
|
||||||
else:
|
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(
|
await conn.execute(
|
||||||
"""INSERT INTO sentence_progress (user_id, sentence_id, completed_at, score, level)
|
"""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],
|
"correct_words": [normalize_word_for_display(w) for w in correct_words_original],
|
||||||
"already_completed": False,
|
"already_completed": False,
|
||||||
"score": score,
|
"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 {
|
return {
|
||||||
|
|||||||
+5
-5
@@ -1,7 +1,7 @@
|
|||||||
"""
|
"""
|
||||||
Support Router — система поддержки пользователей.
|
Support Router — система поддержки пользователей.
|
||||||
Пользователи пишут админу о багах, неточностях и предложениях.
|
Пользователи пишут админу о багах, неточностях и предложениях.
|
||||||
Админ отвечает. Обе стороны могут переводить сообщения через AI (MiniMax-M3).
|
Админ отвечает. Обе стороны могут переводить сообщения через AI (DeepSeek V4 Pro).
|
||||||
"""
|
"""
|
||||||
import logging
|
import logging
|
||||||
import httpx
|
import httpx
|
||||||
@@ -16,11 +16,11 @@ logger = logging.getLogger(__name__)
|
|||||||
router = APIRouter(prefix="/support", tags=["support"])
|
router = APIRouter(prefix="/support", tags=["support"])
|
||||||
|
|
||||||
TOGETHER_API_URL = "https://api.together.xyz/v1/chat/completions"
|
TOGETHER_API_URL = "https://api.together.xyz/v1/chat/completions"
|
||||||
SUPPORT_MODEL = "MiniMaxAI/MiniMax-M3"
|
SUPPORT_MODEL = "deepseek-ai/DeepSeek-V4-Pro-0813"
|
||||||
|
|
||||||
|
|
||||||
async def call_ai_translate(text: str, target_lang: str) -> str:
|
async def call_ai_translate(text: str, target_lang: str) -> str:
|
||||||
"""Переводит текст через AI (MiniMax-M3)."""
|
"""Переводит текст через AI (DeepSeek V4 Pro)."""
|
||||||
if not TOGETHER_API_KEY:
|
if not TOGETHER_API_KEY:
|
||||||
return ""
|
return ""
|
||||||
|
|
||||||
@@ -38,7 +38,7 @@ async def call_ai_translate(text: str, target_lang: str) -> str:
|
|||||||
{"role": "system", "content": f"Ты — переводчик. Переведи текст на язык: {target_lang}. Отвечай только переводом без пояснений. Не используй markdown."},
|
{"role": "system", "content": f"Ты — переводчик. Переведи текст на язык: {target_lang}. Отвечай только переводом без пояснений. Не используй markdown."},
|
||||||
{"role": "user", "content": text},
|
{"role": "user", "content": text},
|
||||||
],
|
],
|
||||||
"max_tokens": 500,
|
"max_tokens": 1500,
|
||||||
"temperature": 0.3,
|
"temperature": 0.3,
|
||||||
},
|
},
|
||||||
)
|
)
|
||||||
@@ -334,7 +334,7 @@ async def get_unread_count(request: Request):
|
|||||||
@router.post("/translate")
|
@router.post("/translate")
|
||||||
async def translate_message(request: Request):
|
async def translate_message(request: Request):
|
||||||
"""
|
"""
|
||||||
Перевод сообщения через AI (MiniMax-M3).
|
Перевод сообщения через AI (DeepSeek V4 Pro).
|
||||||
Доступно и пользователю, и админу.
|
Доступно и пользователю, и админу.
|
||||||
"""
|
"""
|
||||||
telegram_id, _ = await require_auth(request)
|
telegram_id, _ = await require_auth(request)
|
||||||
|
|||||||
+28
-7
@@ -1,3 +1,13 @@
|
|||||||
|
# 🔧 ФИКС (05.10.2026): max_tokens_for_v4_pro —
|
||||||
|
# DeepSeek V4 Pro — reasoning-модель, ~80% токенов уходит в reasoning_content,
|
||||||
|
# только 20% — в content. Увеличили max_tokens в 3 раза, чтобы избежать
|
||||||
|
# обрезки (finish_reason='length') и пустого content.
|
||||||
|
#
|
||||||
|
# 🔧 ФИКС (05.10.2026): disable_reasoning_for_fast_tasks —
|
||||||
|
# Для простых задач (переводы, объяснения, примеры) reasoning не нужен,
|
||||||
|
# добавляем reasoning_effort="none" в call_ai. Это экономит токены
|
||||||
|
# и ускоряет ответ в 3-4 раза.
|
||||||
|
|
||||||
"""
|
"""
|
||||||
Teacher Router — гибридный чат-учитель.
|
Teacher Router — гибридный чат-учитель.
|
||||||
Контент из БД (бесплатно), AI только для реакций и пробелов.
|
Контент из БД (бесплатно), AI только для реакций и пробелов.
|
||||||
@@ -43,7 +53,7 @@ logger = logging.getLogger(__name__)
|
|||||||
router = APIRouter(prefix="/teacher", tags=["teacher"])
|
router = APIRouter(prefix="/teacher", tags=["teacher"])
|
||||||
|
|
||||||
TOGETHER_API_URL = "https://api.together.xyz/v1/chat/completions"
|
TOGETHER_API_URL = "https://api.together.xyz/v1/chat/completions"
|
||||||
TEACHER_MODEL = "MiniMaxAI/MiniMax-M3"
|
TEACHER_MODEL = "deepseek-ai/DeepSeek-V4-Pro-0813"
|
||||||
|
|
||||||
TEACHER_AI_DAILY_LIMIT = 5
|
TEACHER_AI_DAILY_LIMIT = 5
|
||||||
|
|
||||||
@@ -232,6 +242,11 @@ async def call_ai(prompt: str, system_prompt: str, max_tokens: int = 500) -> str
|
|||||||
],
|
],
|
||||||
"max_tokens": max_tokens,
|
"max_tokens": max_tokens,
|
||||||
"temperature": 0.7,
|
"temperature": 0.7,
|
||||||
|
# 🔧 ФИКС (05.10.2026): disable_reasoning_for_fast_tasks —
|
||||||
|
# V4 Pro — reasoning-модель, тратит 80% токенов на «мысли»
|
||||||
|
# (reasoning_content) и 20-30 секунд на ответ.
|
||||||
|
# Для фразы дня и переводов reasoning не нужен → отключаем.
|
||||||
|
"reasoning_effort": "none",
|
||||||
},
|
},
|
||||||
)
|
)
|
||||||
|
|
||||||
@@ -282,7 +297,8 @@ async def get_wrong_answer_ai_explanation(telegram_id: int, lang: str, prompt_te
|
|||||||
system_prompt = f"""Ты — Марек, учитель польского языка. Объясняй ошибки кратко и понятно.
|
system_prompt = f"""Ты — Марек, учитель польского языка. Объясняй ошибки кратко и понятно.
|
||||||
Отвечай на языке: {lang}. Не используй markdown."""
|
Отвечай на языке: {lang}. Не используй markdown."""
|
||||||
|
|
||||||
ai_response = await call_ai(ai_prompt, system_prompt, max_tokens=200)
|
# 🔧 ФИКС (05.10.2026): max_tokens_for_v4_pro — 200 → 600
|
||||||
|
ai_response = await call_ai(ai_prompt, system_prompt, max_tokens=600)
|
||||||
|
|
||||||
if ai_response:
|
if ai_response:
|
||||||
async with pool.acquire() as conn:
|
async with pool.acquire() as conn:
|
||||||
@@ -376,7 +392,8 @@ EN_GRAMMAR: [грамматический разбор на английском
|
|||||||
|
|
||||||
user_prompt = f"Создай фразу дня на тему: {selected_topic}."
|
user_prompt = f"Создай фразу дня на тему: {selected_topic}."
|
||||||
|
|
||||||
ai_response = await call_ai(user_prompt, system_prompt, max_tokens=1000)
|
# 🔧 ФИКС (05.10.2026): max_tokens_for_v4_pro — 1000 → 3000
|
||||||
|
ai_response = await call_ai(user_prompt, system_prompt, max_tokens=3000)
|
||||||
|
|
||||||
# Fallback значения
|
# Fallback значения
|
||||||
phrase_pl = "Lepiej późno niż wcale."
|
phrase_pl = "Lepiej późno niż wcale."
|
||||||
@@ -878,7 +895,8 @@ async def teacher_explain(request: Request):
|
|||||||
system_prompt = f"""Ты — учитель польского языка. Объясни материал простыми словами.
|
system_prompt = f"""Ты — учитель польского языка. Объясни материал простыми словами.
|
||||||
Отвечай на языке: {lang}. Не используй markdown."""
|
Отвечай на языке: {lang}. Не используй markdown."""
|
||||||
|
|
||||||
ai_response = await call_ai(content, system_prompt)
|
# 🔧 ФИКС (05.10.2026): max_tokens_for_v4_pro — добавляем 1500
|
||||||
|
ai_response = await call_ai(content, system_prompt, max_tokens=1500)
|
||||||
|
|
||||||
if ai_response:
|
if ai_response:
|
||||||
async with pool.acquire() as conn:
|
async with pool.acquire() as conn:
|
||||||
@@ -953,7 +971,8 @@ async def teacher_examples(request: Request):
|
|||||||
|
|
||||||
Верни только 5 примеров, без вступлений и пояснений."""
|
Верни только 5 примеров, без вступлений и пояснений."""
|
||||||
|
|
||||||
ai_response = await call_ai(topic, system_prompt, max_tokens=500)
|
# 🔧 ФИКС (05.10.2026): max_tokens_for_v4_pro — 500 → 1500
|
||||||
|
ai_response = await call_ai(topic, system_prompt, max_tokens=1500)
|
||||||
|
|
||||||
if ai_response:
|
if ai_response:
|
||||||
async with pool.acquire() as conn:
|
async with pool.acquire() as conn:
|
||||||
@@ -1015,7 +1034,8 @@ async def teacher_free_message(request: Request):
|
|||||||
Ученик может спросить что угодно: объяснить тему, перевести фразу, дать пример.
|
Ученик может спросить что угодно: объяснить тему, перевести фразу, дать пример.
|
||||||
Отвечай кратко (1-3 предложения) и по делу."""
|
Отвечай кратко (1-3 предложения) и по делу."""
|
||||||
|
|
||||||
ai_response = await call_ai(user_message, system_prompt, max_tokens=300)
|
# 🔧 ФИКС (05.10.2026): max_tokens_for_v4_pro — 300 → 900
|
||||||
|
ai_response = await call_ai(user_message, system_prompt, max_tokens=900)
|
||||||
|
|
||||||
if ai_response:
|
if ai_response:
|
||||||
async with pool.acquire() as conn:
|
async with pool.acquire() as conn:
|
||||||
@@ -1112,7 +1132,8 @@ async def teacher_translate_to_polish(request: Request):
|
|||||||
system_prompt = f"""Ты — переводчик польского языка. Переведи текст на польский.
|
system_prompt = f"""Ты — переводчик польского языка. Переведи текст на польский.
|
||||||
Отвечай только переводом без пояснений. Не используй markdown."""
|
Отвечай только переводом без пояснений. Не используй markdown."""
|
||||||
|
|
||||||
ai_response = await call_ai(text, system_prompt, max_tokens=300)
|
# 🔧 ФИКС (05.10.2026): max_tokens_for_v4_pro — 300 → 900
|
||||||
|
ai_response = await call_ai(text, system_prompt, max_tokens=900)
|
||||||
|
|
||||||
if ai_response:
|
if ai_response:
|
||||||
async with pool.acquire() as conn:
|
async with pool.acquire() as conn:
|
||||||
|
|||||||
@@ -3,7 +3,6 @@ Typing Router — раздел "Печать".
|
|||||||
Пользователь печатает польские предложения, система проверяет.
|
Пользователь печатает польские предложения, система проверяет.
|
||||||
Без AI — просто сравнение с правильным ответом из БД.
|
Без AI — просто сравнение с правильным ответом из БД.
|
||||||
"""
|
"""
|
||||||
import random
|
|
||||||
from fastapi import APIRouter, Request, HTTPException
|
from fastapi import APIRouter, Request, HTTPException
|
||||||
from auth import require_auth
|
from auth import require_auth
|
||||||
from database import get_pool
|
from database import get_pool
|
||||||
|
|||||||
+103
-1
@@ -76,6 +76,26 @@ async def set_language(request: Request):
|
|||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
|
@router.post("/set-difficulty")
|
||||||
|
async def set_difficulty(request: Request):
|
||||||
|
"""Устанавливает уровень сложности (easy/medium/hard)."""
|
||||||
|
user_id, _ = await require_auth(request)
|
||||||
|
body = await request.json()
|
||||||
|
difficulty = body.get("difficulty", "medium")
|
||||||
|
|
||||||
|
if difficulty not in {"easy", "medium", "hard"}:
|
||||||
|
raise HTTPException(400, "Unsupported difficulty")
|
||||||
|
|
||||||
|
pool = await get_pool()
|
||||||
|
async with pool.acquire() as conn:
|
||||||
|
await conn.execute(
|
||||||
|
"UPDATE users SET difficulty = $1 WHERE telegram_id = $2",
|
||||||
|
difficulty, user_id,
|
||||||
|
)
|
||||||
|
|
||||||
|
return {"status": "ok", "difficulty": difficulty}
|
||||||
|
|
||||||
|
|
||||||
@router.post("/set-level")
|
@router.post("/set-level")
|
||||||
async def set_level(request: Request):
|
async def set_level(request: Request):
|
||||||
"""Устанавливает текущий уровень пользователя (A1, A2, B1, B2, C1, C2)"""
|
"""Устанавливает текущий уровень пользователя (A1, A2, B1, B2, C1, C2)"""
|
||||||
@@ -103,4 +123,86 @@ async def set_level(request: Request):
|
|||||||
return {
|
return {
|
||||||
"status": "ok",
|
"status": "ok",
|
||||||
"level": level,
|
"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}
|
||||||
+137
-77
@@ -14,7 +14,7 @@ async def get_next_quiz(request: Request):
|
|||||||
pool = await get_pool()
|
pool = await get_pool()
|
||||||
async with pool.acquire() as conn:
|
async with pool.acquire() as conn:
|
||||||
user = await conn.fetchrow(
|
user = await conn.fetchrow(
|
||||||
"SELECT app_language, current_level FROM users WHERE telegram_id = $1", telegram_id
|
"SELECT app_language, current_level, difficulty FROM users WHERE telegram_id = $1", telegram_id
|
||||||
)
|
)
|
||||||
if not user:
|
if not user:
|
||||||
raise HTTPException(401, "User not registered")
|
raise HTTPException(401, "User not registered")
|
||||||
@@ -22,6 +22,12 @@ async def get_next_quiz(request: Request):
|
|||||||
lang = user["app_language"] or "pl"
|
lang = user["app_language"] or "pl"
|
||||||
current_level = user["current_level"] or "A1"
|
current_level = user["current_level"] or "A1"
|
||||||
|
|
||||||
|
if lang == 'pl':
|
||||||
|
raise HTTPException(403, "ChooseWord не поддерживает польский язык. Используйте другой язык.")
|
||||||
|
|
||||||
|
difficulty = user.get("difficulty") or "medium"
|
||||||
|
wrong_count = {"easy": 2, "medium": 3, "hard": 4}.get(difficulty, 3)
|
||||||
|
|
||||||
progress = await conn.fetchrow(
|
progress = await conn.fetchrow(
|
||||||
"SELECT words_guessed, recent_words FROM word_quiz_progress WHERE user_id = $1",
|
"SELECT words_guessed, recent_words FROM word_quiz_progress WHERE user_id = $1",
|
||||||
telegram_id
|
telegram_id
|
||||||
@@ -32,23 +38,20 @@ async def get_next_quiz(request: Request):
|
|||||||
async def pick_word(exclude, respect_exclude=True):
|
async def pick_word(exclude, respect_exclude=True):
|
||||||
if respect_exclude and exclude:
|
if respect_exclude and exclude:
|
||||||
placeholders = ",".join([f"${i+2}" for i in range(len(exclude))])
|
placeholders = ",".join([f"${i+2}" for i in range(len(exclude))])
|
||||||
|
# 🔧 ФИКС (30.09.2026): csv_words_source —
|
||||||
|
# источник слов переехал с level_words (старая схема level_id IS NULL)
|
||||||
|
# на csv_words (level_code). Один источник — CSV-база.
|
||||||
return await conn.fetchrow(f"""
|
return await conn.fetchrow(f"""
|
||||||
SELECT word_pl, translation_ru, translation_uk, translation_en
|
SELECT word_pl, translation_ru, translation_uk, translation_en
|
||||||
FROM (
|
FROM csv_words
|
||||||
SELECT DISTINCT ON (word_pl) word_pl, translation_ru, translation_uk, translation_en
|
WHERE level_code = $1 AND word_pl NOT IN ({placeholders})
|
||||||
FROM level_words
|
|
||||||
WHERE level = $1 AND level_id IS NULL AND word_pl NOT IN ({placeholders})
|
|
||||||
) AS unique_words
|
|
||||||
ORDER BY RANDOM()
|
ORDER BY RANDOM()
|
||||||
LIMIT 1
|
LIMIT 1
|
||||||
""", current_level, *exclude)
|
""", current_level, *exclude)
|
||||||
return await conn.fetchrow("""
|
return await conn.fetchrow("""
|
||||||
SELECT word_pl, translation_ru, translation_uk, translation_en
|
SELECT word_pl, translation_ru, translation_uk, translation_en
|
||||||
FROM (
|
FROM csv_words
|
||||||
SELECT DISTINCT ON (word_pl) word_pl, translation_ru, translation_uk, translation_en
|
WHERE level_code = $1
|
||||||
FROM level_words
|
|
||||||
WHERE level = $1 AND level_id IS NULL
|
|
||||||
) AS unique_words
|
|
||||||
ORDER BY RANDOM()
|
ORDER BY RANDOM()
|
||||||
LIMIT 1
|
LIMIT 1
|
||||||
""", current_level)
|
""", current_level)
|
||||||
@@ -67,27 +70,23 @@ async def get_next_quiz(request: Request):
|
|||||||
# Ищем неправильные варианты
|
# Ищем неправильные варианты
|
||||||
exclude_for_wrong = recent_words + [correct_polish]
|
exclude_for_wrong = recent_words + [correct_polish]
|
||||||
placeholders = ",".join([f"${i+3}" for i in range(len(exclude_for_wrong))])
|
placeholders = ",".join([f"${i+3}" for i in range(len(exclude_for_wrong))])
|
||||||
|
# 🔧 ФИКС (30.09.2026): csv_words_source — источник переведён на csv_words.
|
||||||
wrong_words = await conn.fetch(f"""
|
wrong_words = await conn.fetch(f"""
|
||||||
SELECT word_pl
|
SELECT word_pl
|
||||||
FROM (
|
FROM csv_words
|
||||||
SELECT DISTINCT ON (word_pl) word_pl
|
WHERE level_code = $1 AND word_pl != $2 AND word_pl NOT IN ({placeholders})
|
||||||
FROM level_words
|
|
||||||
WHERE level = $1 AND level_id IS NULL AND word_pl != $2 AND word_pl NOT IN ({placeholders})
|
|
||||||
) AS unique_wrong
|
|
||||||
ORDER BY RANDOM()
|
ORDER BY RANDOM()
|
||||||
LIMIT 5
|
LIMIT (wrong_count + 1)
|
||||||
""", current_level, correct_polish, *exclude_for_wrong)
|
""", current_level, correct_polish, *exclude_for_wrong)
|
||||||
|
|
||||||
if len(wrong_words) < 2:
|
if len(wrong_words) < wrong_count:
|
||||||
|
# 🔧 ФИКС (30.09.2026): csv_words_source — fallback тоже на csv_words.
|
||||||
wrong_words = await conn.fetch("""
|
wrong_words = await conn.fetch("""
|
||||||
SELECT word_pl
|
SELECT word_pl
|
||||||
FROM (
|
FROM csv_words
|
||||||
SELECT DISTINCT ON (word_pl) word_pl
|
WHERE level_code = $1 AND word_pl != $2
|
||||||
FROM level_words
|
|
||||||
WHERE level = $1 AND level_id IS NULL AND word_pl != $2
|
|
||||||
) AS unique_wrong
|
|
||||||
ORDER BY RANDOM()
|
ORDER BY RANDOM()
|
||||||
LIMIT 5
|
LIMIT (wrong_count + 1)
|
||||||
""", current_level, correct_polish)
|
""", current_level, correct_polish)
|
||||||
|
|
||||||
wrong_options = []
|
wrong_options = []
|
||||||
@@ -97,7 +96,7 @@ async def get_next_quiz(request: Request):
|
|||||||
if wl not in seen:
|
if wl not in seen:
|
||||||
wrong_options.append(w["word_pl"])
|
wrong_options.append(w["word_pl"])
|
||||||
seen.add(wl)
|
seen.add(wl)
|
||||||
if len(wrong_options) >= 2:
|
if len(wrong_options) >= wrong_count:
|
||||||
break
|
break
|
||||||
|
|
||||||
recent_words = recent_words + [correct_polish] + wrong_options
|
recent_words = recent_words + [correct_polish] + wrong_options
|
||||||
@@ -114,38 +113,39 @@ async def get_next_quiz(request: Request):
|
|||||||
options = wrong_options + [correct_polish]
|
options = wrong_options + [correct_polish]
|
||||||
random.shuffle(options)
|
random.shuffle(options)
|
||||||
|
|
||||||
if total_guessed <= 10:
|
time_limit = 10 if difficulty == "hard" else None
|
||||||
difficulty = "easy"
|
|
||||||
elif total_guessed <= 30:
|
|
||||||
difficulty = "medium"
|
|
||||||
elif total_guessed <= 60:
|
|
||||||
difficulty = "hard"
|
|
||||||
else:
|
|
||||||
difficulty = "expert"
|
|
||||||
|
|
||||||
return {
|
return {
|
||||||
"correct_polish": correct_polish,
|
"correct_polish": correct_polish,
|
||||||
"translation": translation,
|
"translation": translation,
|
||||||
"options": options,
|
"options": options,
|
||||||
"difficulty": difficulty,
|
"difficulty": difficulty,
|
||||||
|
"time_limit": time_limit,
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
@router.post("/check")
|
@router.post("/check")
|
||||||
async def check_quiz_answer(request: Request):
|
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)
|
telegram_id, _ = await require_auth(request)
|
||||||
body = await request.json()
|
body = await request.json()
|
||||||
correct_polish = body.get("correct_polish", "")
|
correct_polish = body.get("correct_polish", "")
|
||||||
user_answer = body.get("answer", "")
|
user_answer = body.get("answer", "")
|
||||||
completion_time = body.get("completion_time")
|
completion_time = body.get("completion_time")
|
||||||
# 🔧 ФИКС (24.09.2026): client_controlled_mistakes_wordquiz —
|
# 🆕 wrong_count приходит с клиента для UI, но мы считаем на сервере
|
||||||
# mistakes больше НЕ берём от клиента. Считаем на сервере.
|
# 🔧 ФИКС: current_mistakes — серверный счётчик
|
||||||
|
|
||||||
if not correct_polish or not user_answer:
|
if not correct_polish or not user_answer:
|
||||||
raise HTTPException(400, "correct_polish and answer required")
|
raise HTTPException(400, "correct_polish and answer required")
|
||||||
|
|
||||||
# Защита от читерства: минимальное время 1 секунда
|
|
||||||
if completion_time is not None and completion_time < 1:
|
if completion_time is not None and completion_time < 1:
|
||||||
return {
|
return {
|
||||||
"correct": False,
|
"correct": False,
|
||||||
@@ -154,25 +154,38 @@ async def check_quiz_answer(request: Request):
|
|||||||
}
|
}
|
||||||
|
|
||||||
is_correct = user_answer.strip().lower() == correct_polish.strip().lower()
|
is_correct = user_answer.strip().lower() == correct_polish.strip().lower()
|
||||||
|
|
||||||
pool = await get_pool()
|
pool = await get_pool()
|
||||||
async with pool.acquire() as conn:
|
async with pool.acquire() as conn:
|
||||||
|
# Проверка языка
|
||||||
|
lang = await conn.fetchval(
|
||||||
|
"SELECT app_language FROM users WHERE telegram_id = $1", telegram_id
|
||||||
|
) or "pl"
|
||||||
|
if lang == 'pl':
|
||||||
|
raise HTTPException(403, "ChooseWord не поддерживает польский язык.")
|
||||||
|
|
||||||
|
difficulty = await conn.fetchval(
|
||||||
|
"SELECT difficulty FROM users WHERE telegram_id = $1", telegram_id
|
||||||
|
) or "medium"
|
||||||
|
|
||||||
|
# Читаем серверный streak и mistakes
|
||||||
current_streak = await conn.fetchval(
|
current_streak = await conn.fetchval(
|
||||||
"SELECT correct_streak FROM word_quiz_progress WHERE user_id = $1",
|
"SELECT correct_streak FROM word_quiz_progress WHERE user_id = $1",
|
||||||
telegram_id
|
telegram_id
|
||||||
) or 0
|
) or 0
|
||||||
# 🔧 ФИКС (24.09.2026): client_controlled_mistakes_wordquiz —
|
|
||||||
# читаем серверный current_mistakes.
|
|
||||||
mistakes = await conn.fetchval(
|
mistakes = await conn.fetchval(
|
||||||
"SELECT current_mistakes FROM word_quiz_progress WHERE user_id = $1",
|
"SELECT current_mistakes FROM word_quiz_progress WHERE user_id = $1",
|
||||||
telegram_id
|
telegram_id
|
||||||
) or 0
|
) or 0
|
||||||
|
no_mistakes_streak = await conn.fetchval(
|
||||||
|
"SELECT no_mistakes_streak FROM word_quiz_progress WHERE user_id = $1",
|
||||||
|
telegram_id
|
||||||
|
) or 0
|
||||||
|
|
||||||
if is_correct:
|
if is_correct:
|
||||||
current_streak += 1
|
current_streak += 1
|
||||||
else:
|
else:
|
||||||
current_streak = 0
|
current_streak = 0
|
||||||
# 🔧 Инкрементим mistakes на сервере
|
|
||||||
await conn.execute("""
|
await conn.execute("""
|
||||||
INSERT INTO word_quiz_progress (user_id, current_mistakes)
|
INSERT INTO word_quiz_progress (user_id, current_mistakes)
|
||||||
VALUES ($1, 1)
|
VALUES ($1, 1)
|
||||||
@@ -180,59 +193,83 @@ async def check_quiz_answer(request: Request):
|
|||||||
SET current_mistakes = word_quiz_progress.current_mistakes + 1
|
SET current_mistakes = word_quiz_progress.current_mistakes + 1
|
||||||
""", telegram_id)
|
""", telegram_id)
|
||||||
mistakes += 1
|
mistakes += 1
|
||||||
|
|
||||||
|
xp_result = None
|
||||||
|
score = 0
|
||||||
|
|
||||||
if is_correct:
|
if is_correct:
|
||||||
score = max(10, 50 - (mistakes * 20))
|
# 🆕 Фиксированные очки по сложности (ChooseWord)
|
||||||
# 🔧 Сбрасываем mistakes при правильном ответе
|
if difficulty == "easy":
|
||||||
|
points = max(20, min(60, 60 - 20 * mistakes))
|
||||||
|
elif difficulty == "medium":
|
||||||
|
points = max(20, min(80, 80 - 20 * mistakes))
|
||||||
|
else: # hard
|
||||||
|
points = max(20, min(110, 110 - 20 * mistakes))
|
||||||
|
if completion_time is not None and completion_time > 10:
|
||||||
|
points = 20
|
||||||
|
|
||||||
|
# Начисляем XP
|
||||||
|
from services.xp import award_xp
|
||||||
|
xp_result = await award_xp(conn, telegram_id, "choose", points)
|
||||||
|
score = xp_result["points"]
|
||||||
|
|
||||||
|
# no_mistakes_streak: +1 если раунд чистый, иначе сброс
|
||||||
|
if mistakes == 0:
|
||||||
|
no_mistakes_streak += 1
|
||||||
|
else:
|
||||||
|
no_mistakes_streak = 0
|
||||||
|
|
||||||
|
# Сбрасываем mistakes + обновляем серию
|
||||||
await conn.execute("""
|
await conn.execute("""
|
||||||
UPDATE word_quiz_progress SET current_mistakes = 0 WHERE user_id = $1
|
UPDATE word_quiz_progress SET current_mistakes = 0 WHERE user_id = $1
|
||||||
""", telegram_id)
|
""", telegram_id)
|
||||||
|
|
||||||
await conn.execute("""
|
await conn.execute("""
|
||||||
INSERT INTO word_quiz_progress (user_id, words_guessed, total_score, correct_streak)
|
INSERT INTO word_quiz_progress (user_id, words_guessed, total_score, correct_streak, no_mistakes_streak)
|
||||||
VALUES ($1, 1, $2, $3)
|
VALUES ($1, 1, $2, $3, $4)
|
||||||
ON CONFLICT (user_id) DO UPDATE
|
ON CONFLICT (user_id) DO UPDATE
|
||||||
SET words_guessed = word_quiz_progress.words_guessed + 1,
|
SET words_guessed = word_quiz_progress.words_guessed + 1,
|
||||||
total_score = word_quiz_progress.total_score + $2,
|
total_score = word_quiz_progress.total_score + $2,
|
||||||
correct_streak = $3
|
correct_streak = $3,
|
||||||
""", telegram_id, score, current_streak)
|
no_mistakes_streak = $4
|
||||||
|
""", telegram_id, score, current_streak, no_mistakes_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(
|
total_guessed = await conn.fetchval(
|
||||||
"SELECT words_guessed FROM word_quiz_progress WHERE user_id = $1",
|
"SELECT words_guessed FROM word_quiz_progress WHERE user_id = $1",
|
||||||
telegram_id
|
telegram_id
|
||||||
) or 0
|
) 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 = [
|
achievements_to_check = [
|
||||||
("quiz_guessed", total_guessed),
|
("quiz_guessed", total_guessed),
|
||||||
("total_score", grand_total),
|
("total_score", xp_result["total_xp"]),
|
||||||
]
|
]
|
||||||
if current_streak >= 10:
|
if current_streak >= 5:
|
||||||
achievements_to_check.append(("quiz_perfect_streak", current_streak))
|
achievements_to_check.append(("quiz_correct_streak", current_streak))
|
||||||
|
if no_mistakes_streak > 0:
|
||||||
|
achievements_to_check.append(("quiz_no_mistakes_streak", no_mistakes_streak))
|
||||||
if mistakes == 0:
|
if mistakes == 0:
|
||||||
achievements_to_check.append(("quiz_no_mistakes", 1))
|
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 <= 5:
|
||||||
achievements_to_check.append(("quiz_speed", 3))
|
achievements_to_check.append(("quiz_speed_5", 5))
|
||||||
|
if completion_time is not None and 0 < completion_time <= 3:
|
||||||
|
achievements_to_check.append(("quiz_speed_3", 3))
|
||||||
|
if completion_time is not None and 0 < completion_time <= 2:
|
||||||
|
achievements_to_check.append(("quiz_speed_2", 2))
|
||||||
|
if completion_time is not None and 0 < completion_time <= 1:
|
||||||
|
achievements_to_check.append(("quiz_speed_1", 1))
|
||||||
else:
|
else:
|
||||||
# При 3 ошибках — начисляем утешительные 10 очков
|
# При 3 ошибках — утешительный XP (10)
|
||||||
if mistakes >= 3:
|
if mistakes >= 3:
|
||||||
await conn.execute("""
|
await conn.execute("""
|
||||||
INSERT INTO word_quiz_progress (user_id, words_guessed, total_score, correct_streak, current_mistakes)
|
INSERT INTO word_quiz_progress (user_id, words_guessed, total_score, correct_streak, current_mistakes)
|
||||||
@@ -249,7 +286,7 @@ async def check_quiz_answer(request: Request):
|
|||||||
SET correct_streak = $2
|
SET correct_streak = $2
|
||||||
""", telegram_id, current_streak)
|
""", telegram_id, current_streak)
|
||||||
|
|
||||||
# 🔧 ФИКС (23.09.2026): вызовы достижений ВНЕ блока async with pool.acquire()
|
# Достижения — вне транзакции
|
||||||
if is_correct:
|
if is_correct:
|
||||||
from routers.achievements import check_and_award_achievements
|
from routers.achievements import check_and_award_achievements
|
||||||
new_achievements = []
|
new_achievements = []
|
||||||
@@ -262,6 +299,19 @@ async def check_quiz_answer(request: Request):
|
|||||||
"score": score,
|
"score": score,
|
||||||
"correct_streak": current_streak,
|
"correct_streak": current_streak,
|
||||||
"new_achievements": new_achievements,
|
"new_achievements": new_achievements,
|
||||||
|
# 🆕 XP-поля
|
||||||
|
"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 {
|
return {
|
||||||
@@ -271,6 +321,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")
|
@router.get("/progress")
|
||||||
async def get_quiz_progress(request: Request):
|
async def get_quiz_progress(request: Request):
|
||||||
"""Статистика пользователя в квизе"""
|
"""Статистика пользователя в квизе"""
|
||||||
|
|||||||
+39
-71
@@ -60,6 +60,17 @@ Backend слишком большой (~440K символов) для одног
|
|||||||
а не молча терять вклад второй модели.
|
а не молча терять вклад второй модели.
|
||||||
→ Паки не трогаем — routers_admin (97k) пока терпит, но если
|
→ Паки не трогаем — routers_admin (97k) пока терпит, но если
|
||||||
начнёт терять secondary — раздробим.
|
начнёт терять secondary — раздробим.
|
||||||
|
(05.10.2026) ФИКС single_model_v4_pro:
|
||||||
|
→ Отказались от dual-model (DeepSeek Flash + GLM Flash).
|
||||||
|
Причина: GLM добавлял мусор, Flash-версии ошибались на сложных файлах.
|
||||||
|
→ Теперь: только DeepSeek V4 Pro 0813 — флагман, reasoning, 1M контекст.
|
||||||
|
Один промпт → один ответ → один фильтр → меньше мусора.
|
||||||
|
→ MIN_CONFIDENCE: 0.75 → 0.80 — V4 Pro увереннее, но подняли порог,
|
||||||
|
чтобы отсеять спорные находки.
|
||||||
|
→ reasoning_effort="low" — V4 Pro: reasoning_effort="none"
|
||||||
|
игнорируется (тест 05.10.2026), "low" даёт минимальный reasoning
|
||||||
|
(~70 токенов на простой запрос).
|
||||||
|
→ MAX_OUTPUT_TOKENS: 8000 → 16000 — reasoning (~80%) + JSON (~20%).
|
||||||
"""
|
"""
|
||||||
|
|
||||||
import json
|
import json
|
||||||
@@ -79,34 +90,20 @@ GITEA_BOT_TOKEN = os.environ.get("BOT_TOKEN")
|
|||||||
GITEA_INSTANCE = os.environ.get("GITEA_INSTANCE", "https://git.filwordspl.com")
|
GITEA_INSTANCE = os.environ.get("GITEA_INSTANCE", "https://git.filwordspl.com")
|
||||||
GITEA_REPO = os.environ.get("GITEA_REPO", "Drobysh/filwordspl-backend")
|
GITEA_REPO = os.environ.get("GITEA_REPO", "Drobysh/filwordspl-backend")
|
||||||
|
|
||||||
# 🔧 ФИКС (26.09.2026, ночь): ai_review_glm_flash —
|
# 🔧 ФИКС (05.10.2026): single_model_v4_pro —
|
||||||
# Флагман GLM-5.3 ($1.40 in / $4.40 out) заменён на GLM-5.3-Flash
|
# Отказались от dual-model (DeepSeek Flash + GLM Flash).
|
||||||
# ($0.15 in / $0.50 out) — та же линейка модели (Z.ai), но кодинг-версия
|
# Причина: GLM добавлял мусор, Flash-версии ошибались на сложных файлах.
|
||||||
# попроще и в ~9 раз дешевле. Для point-by-point ревью одного пака
|
# Теперь: только DeepSeek V4 Pro 0813 — флагман, reasoning, 1M контекст.
|
||||||
# флагманская "глубина" не нужна, а бюджет 80 центов/аудит с флагманом
|
# Один промпт → один ответ → один фильтр → меньше мусора.
|
||||||
# на большом фронтенде почти исчерпывался.
|
MODEL_PRIMARY = "deepseek-ai/DeepSeek-V4-Pro-0813"
|
||||||
MODEL_PRIMARY = "deepseek-ai/DeepSeek-V4.1-Flash"
|
|
||||||
MODEL_SECONDARY = "zai-org/GLM-5.3-Flash"
|
|
||||||
MODEL = MODEL_PRIMARY # backward compat
|
|
||||||
|
|
||||||
# 🔧 ФИКС (26.09.2026, вечер): secondary_model_enabled —
|
USE_SECONDARY_MODEL = False
|
||||||
# если True — гоняем обе модели, объединяем по пересечению.
|
|
||||||
USE_SECONDARY_MODEL = True
|
|
||||||
|
|
||||||
# 🔧 ФИКС (26.09.2026): ai_review_overshoot —
|
# V4 Pro: reasoning полностью НЕ отключается (тест 05.10.2026:
|
||||||
# 32000 токенов = модель пишет "Ок" на каждую функцию.
|
# reasoning_effort="none" игнорируется, "low" даёт ~70 токенов).
|
||||||
# 10 находок × ~500 токенов = 5000. 8000 — с запасом.
|
# max_tokens увеличен с 8000 до 16000 — reasoning (~80%) + JSON (~20%).
|
||||||
# Актуально только для DeepSeek (у GLM свой лимит, см. GLM_MAX_OUTPUT_TOKENS).
|
MAX_OUTPUT_TOKENS = 16000
|
||||||
MAX_OUTPUT_TOKENS = 8000
|
REASONING_EFFORT = "low"
|
||||||
|
|
||||||
# 🔧 ФИКС (26.09.2026, ночь): ai_review_glm_reasoning_budget —
|
|
||||||
# У GLM-5.3(-Flash) thinking НЕЛЬЗЯ выключить полностью (только
|
|
||||||
# reasoning_effort="low"/"medium"/"high"/"max"), и трейс мышления
|
|
||||||
# делит один и тот же max_tokens с финальным JSON-ответом.
|
|
||||||
# Раньше при max_tokens=8000 весь бюджет у GLM уходил в reasoning,
|
|
||||||
# content оставался пустым. Даём больше запаса именно для GLM.
|
|
||||||
GLM_MAX_OUTPUT_TOKENS = 12000
|
|
||||||
GLM_REASONING_EFFORT = "low"
|
|
||||||
|
|
||||||
# Что игнорировать при сборе кода
|
# Что игнорировать при сборе кода
|
||||||
IGNORE_DIRS = {
|
IGNORE_DIRS = {
|
||||||
@@ -127,8 +124,10 @@ INCLUDE_EXTENSIONS = {".py"}
|
|||||||
MAX_FILE_SIZE = 100_000
|
MAX_FILE_SIZE = 100_000
|
||||||
|
|
||||||
# Фильтр находок
|
# Фильтр находок
|
||||||
# 🔧 ФИКС (26.09.2026): MIN_CONFIDENCE 0.7 → 0.75.
|
# 🔧 ФИКС (05.10.2026): filter_more_strict —
|
||||||
MIN_CONFIDENCE = 0.75
|
# V4 Pro увереннее, но подняли порог с 0.75 до 0.80,
|
||||||
|
# чтобы отсеять спорные находки.
|
||||||
|
MIN_CONFIDENCE = 0.80
|
||||||
ALLOWED_SEVERITY = {"user_impact", "data_risk", "maintainability"}
|
ALLOWED_SEVERITY = {"user_impact", "data_risk", "maintainability"}
|
||||||
|
|
||||||
# 🔧 ФИКС (26.09.2026): overshoot guard.
|
# 🔧 ФИКС (26.09.2026): overshoot guard.
|
||||||
@@ -343,22 +342,12 @@ USER_PROMPT_TEMPLATE = """Проанализируй часть кода про
|
|||||||
|
|
||||||
# ============ Запрос к Together AI ============
|
# ============ Запрос к Together AI ============
|
||||||
|
|
||||||
def _is_glm(model_name: str) -> bool:
|
|
||||||
return "GLM-5.3" in model_name or "glm-5.3" in model_name.lower()
|
|
||||||
|
|
||||||
|
|
||||||
def call_together_model(code: str, pack: dict, model_name: str) -> str:
|
def call_together_model(code: str, pack: dict, model_name: str) -> str:
|
||||||
"""Отправляет код пака в указанную модель.
|
"""Отправляет код пака в указанную модель.
|
||||||
|
|
||||||
🔧 ФИКС (26.09.2026, ночь): ai_review_reasoning_per_model —
|
🔧 ФИКС (05.10.2026): reasoning_effort_low —
|
||||||
у DeepSeek reasoning реально выключается через
|
V4 Pro: reasoning_effort="none" игнорируется (тест 05.10.2026),
|
||||||
"reasoning": {"enabled": False}. У GLM-5.3(-Flash) это НЕ работает
|
"low" даёт минимальный reasoning.
|
||||||
(thinking у GLM-5.3 нельзя отключить полностью, см. доки Together) —
|
|
||||||
там единственный рычаг: reasoning_effort="low" + больший max_tokens,
|
|
||||||
т.к. reasoning-трейс делит бюджет токенов с финальным ответом.
|
|
||||||
Раньше общий "reasoning": {"enabled": False} для GLM тихо
|
|
||||||
игнорировался → весь max_tokens=8000 уходил в мышление →
|
|
||||||
content пустой → "Формат ответа: пусто" на всех GLM-паках.
|
|
||||||
"""
|
"""
|
||||||
print(f" 🤖 Отправляю пак '{pack['name']}' в {model_name}...")
|
print(f" 🤖 Отправляю пак '{pack['name']}' в {model_name}...")
|
||||||
|
|
||||||
@@ -375,19 +364,13 @@ def call_together_model(code: str, pack: dict, model_name: str) -> str:
|
|||||||
{"role": "user", "content": user_prompt},
|
{"role": "user", "content": user_prompt},
|
||||||
],
|
],
|
||||||
"temperature": 0.2,
|
"temperature": 0.2,
|
||||||
|
"max_tokens": MAX_OUTPUT_TOKENS,
|
||||||
|
# 🔧 ФИКС (05.10.2026): reasoning_effort_low —
|
||||||
|
# V4 Pro: reasoning_effort="none" игнорируется (тест 05.10.2026),
|
||||||
|
# "low" даёт минимальный reasoning (~70 токенов на простой запрос).
|
||||||
|
"reasoning_effort": REASONING_EFFORT,
|
||||||
}
|
}
|
||||||
|
|
||||||
if _is_glm(model_name):
|
|
||||||
# GLM-5.3 / GLM-5.3-Flash: thinking нельзя выключить полностью,
|
|
||||||
# только снизить через reasoning_effort. Даём больше max_tokens,
|
|
||||||
# т.к. трейс мышления делит бюджет с JSON-ответом.
|
|
||||||
payload["reasoning_effort"] = GLM_REASONING_EFFORT
|
|
||||||
payload["max_tokens"] = GLM_MAX_OUTPUT_TOKENS
|
|
||||||
else:
|
|
||||||
# DeepSeek: reasoning реально выключается этим флагом.
|
|
||||||
payload["reasoning"] = {"enabled": False}
|
|
||||||
payload["max_tokens"] = MAX_OUTPUT_TOKENS
|
|
||||||
|
|
||||||
response = httpx.post(
|
response = httpx.post(
|
||||||
"https://api.together.xyz/v1/chat/completions",
|
"https://api.together.xyz/v1/chat/completions",
|
||||||
headers={
|
headers={
|
||||||
@@ -627,10 +610,7 @@ def format_issue_body(
|
|||||||
lines.append("# 🤖 AI Code Review (Backend)")
|
lines.append("# 🤖 AI Code Review (Backend)")
|
||||||
lines.append("")
|
lines.append("")
|
||||||
lines.append(f"**Дата:** {date_str}")
|
lines.append(f"**Дата:** {date_str}")
|
||||||
if USE_SECONDARY_MODEL:
|
lines.append(f"**Модель:** `{MODEL_PRIMARY}`")
|
||||||
lines.append(f"**Модели:** `{MODEL_PRIMARY}` + `{MODEL_SECONDARY}`")
|
|
||||||
else:
|
|
||||||
lines.append(f"**Модель:** `{MODEL_PRIMARY}`")
|
|
||||||
lines.append(f"**Репозиторий:** `{GITEA_REPO}`")
|
lines.append(f"**Репозиторий:** `{GITEA_REPO}`")
|
||||||
lines.append("")
|
lines.append("")
|
||||||
lines.append("## 📊 По пакам")
|
lines.append("## 📊 По пакам")
|
||||||
@@ -735,21 +715,9 @@ def main() -> None:
|
|||||||
continue
|
continue
|
||||||
|
|
||||||
primary_raw = call_together_model(code, pack, MODEL_PRIMARY)
|
primary_raw = call_together_model(code, pack, MODEL_PRIMARY)
|
||||||
|
# 🔧 ФИКС (05.10.2026): single_model —
|
||||||
if USE_SECONDARY_MODEL:
|
# только V4 Pro, без merge.
|
||||||
secondary_raw = call_together_model(code, pack, MODEL_SECONDARY)
|
findings = extract_json(primary_raw)
|
||||||
# 🔧 ФИКС (27.09.2026): secondary_empty_log —
|
|
||||||
# если GLM вернул пусто (весь бюджет ушёл в reasoning),
|
|
||||||
# пишем это явно, чтобы видеть потери второй модели в логах.
|
|
||||||
if not secondary_raw:
|
|
||||||
print(
|
|
||||||
f" ⚠️ Secondary ({MODEL_SECONDARY}) вернул ПУСТО для пака "
|
|
||||||
f"'{pack['name']}' — пак потерян для второй модели",
|
|
||||||
file=sys.stderr,
|
|
||||||
)
|
|
||||||
findings = merge_dual_findings(primary_raw, secondary_raw)
|
|
||||||
else:
|
|
||||||
findings = extract_json(primary_raw)
|
|
||||||
|
|
||||||
filtered, stats = validate_and_filter(findings, files_map)
|
filtered, stats = validate_and_filter(findings, files_map)
|
||||||
|
|
||||||
|
|||||||
@@ -0,0 +1,572 @@
|
|||||||
|
"""
|
||||||
|
generate_levels.py — генератор уровней филвордов (word search).
|
||||||
|
|
||||||
|
🔧 НОВОЕ (07.10.2026): Первая версия.
|
||||||
|
Порт алгоритма с JS (filword-gen.js): слова-змейки,
|
||||||
|
4 направления (вверх/вниз/влево/вправо), без диагоналей.
|
||||||
|
Поле n×n полностью заполнено, слова не пересекаются.
|
||||||
|
|
||||||
|
🔧 ОБНОВЛЕНО (09.10.2026): пересоздание 5–8.
|
||||||
|
• GRID_SIZES = [5, 6, 7, 8] — 4×4, 9×9, 10×10 не трогаем.
|
||||||
|
• LEVELS_PER_SIZE — dict: {5: 25, 6: 50, 7: 200, 8: 300}.
|
||||||
|
• Перед генерацией удаляем все уровни размеров 5–8.
|
||||||
|
|
||||||
|
🔧 ФИКС (10.10.2026): регистр слов — работаем в lowercase,
|
||||||
|
grid_letters остаются UPPERCASE для UI.
|
||||||
|
Раньше скрипт сохранял слова в UPPERCASE, а csv_words хранит
|
||||||
|
их в lowercase → переводы не находились (ANY case-sensitive),
|
||||||
|
а в level_words появлялись дубли-близнецы по регистру.
|
||||||
|
Теперь: fetch_words/group_by_length/save_level — lowercase,
|
||||||
|
fetch_translations ищет через LOWER(word_pl),
|
||||||
|
а в grid_letters буквы пишем .upper() (только для отображения).
|
||||||
|
|
||||||
|
Логика:
|
||||||
|
1. Читает все слова из csv_words (A1+A2+B1), DISTINCT по word_pl.
|
||||||
|
Фильтр: длина 3..10 Unicode-символов.
|
||||||
|
2. Группирует по длине.
|
||||||
|
3. Для каждого размера n в [5, 6, 7, 8]:
|
||||||
|
- удаляет существующие уровни этого размера;
|
||||||
|
- генерирует LEVELS_PER_SIZE[n] уровней;
|
||||||
|
- 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__)
|
||||||
|
|
||||||
|
# ============ Конфигурация ============
|
||||||
|
|
||||||
|
# 🔧 ОБНОВЛЕНО (09.10.2026): пересоздаём только размеры 5–8.
|
||||||
|
# 4×4, 9×9, 10×10 не трогаем.
|
||||||
|
GRID_SIZES = [5, 6, 7, 8]
|
||||||
|
|
||||||
|
# 🔧 ОБНОВЛЕНО (09.10.2026): своё количество уровней на каждый размер.
|
||||||
|
LEVELS_PER_SIZE = {5: 25, 6: 50, 7: 200, 8: 300}
|
||||||
|
|
||||||
|
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:
|
||||||
|
# 🔧 ФИКС (10.10.2026): работаем в lowercase (было .upper()).
|
||||||
|
w = raw.strip().lower()
|
||||||
|
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]
|
||||||
|
# 🔧 ФИКС (10.10.2026): в grid_letters пишем UPPERCASE —
|
||||||
|
# только для отображения на поле. В БД слова остаются lowercase.
|
||||||
|
letters[r][c] = ch.upper()
|
||||||
|
words_out.append({"word": w, "cells": p})
|
||||||
|
|
||||||
|
return {"size": n, "letters": letters, "words": words_out}
|
||||||
|
|
||||||
|
|
||||||
|
# ============ БД ============
|
||||||
|
|
||||||
|
# 🔧 НОВОЕ (09.10.2026): удаляем только уровни размеров 5–8.
|
||||||
|
async def delete_levels_for_sizes(pool, sizes: list[int]) -> int:
|
||||||
|
"""Удаляет уровни указанных размеров. Возвращает число удалённых уровней."""
|
||||||
|
async with pool.acquire() as conn:
|
||||||
|
async with conn.transaction():
|
||||||
|
deleted = await conn.fetchval("""
|
||||||
|
WITH del AS (
|
||||||
|
DELETE FROM levels
|
||||||
|
WHERE grid_size = ANY($1::int[])
|
||||||
|
RETURNING 1
|
||||||
|
)
|
||||||
|
SELECT COUNT(*) FROM del
|
||||||
|
""", sizes)
|
||||||
|
return int(deleted or 0)
|
||||||
|
|
||||||
|
|
||||||
|
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
|
||||||
|
# 🔧 ФИКС (10.10.2026): работаем в lowercase (было .upper()).
|
||||||
|
wl = w.strip().lower()
|
||||||
|
if not wl or wl in seen:
|
||||||
|
continue
|
||||||
|
ln = word_length(wl)
|
||||||
|
if MIN_WORD_LEN <= ln <= MAX_WORD_LEN:
|
||||||
|
filtered.append(wl)
|
||||||
|
seen.add(wl)
|
||||||
|
|
||||||
|
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:
|
||||||
|
# 🔧 ФИКС (10.10.2026): ищем без учёта регистра через LOWER(word_pl),
|
||||||
|
# иначе UPPERCASE-слова не находили переводы в csv_words (lowercase).
|
||||||
|
rows = await conn.fetch("""
|
||||||
|
SELECT DISTINCT ON (LOWER(word_pl))
|
||||||
|
LOWER(word_pl) AS word_pl,
|
||||||
|
translation_ru, translation_uk, translation_en
|
||||||
|
FROM csv_words
|
||||||
|
WHERE level_code = ANY($1::text[])
|
||||||
|
AND LOWER(word_pl) = ANY($2::text[])
|
||||||
|
ORDER BY LOWER(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:
|
||||||
|
# 🔧 ФИКС (10.10.2026): слово и ключ перевода — в lowercase.
|
||||||
|
word_pl = w["word"].lower()
|
||||||
|
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. 🔧 НОВОЕ (09.10.2026): удаляем старые уровни размеров 5–8
|
||||||
|
# (прогресс по ним неважен).
|
||||||
|
logger.info(f"Удаляю старые уровни размеров {GRID_SIZES}...")
|
||||||
|
deleted = await delete_levels_for_sizes(pool, GRID_SIZES)
|
||||||
|
logger.info(f"Удалено уровней: {deleted}")
|
||||||
|
|
||||||
|
# 5. Генерация
|
||||||
|
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
|
||||||
|
|
||||||
|
# 🔧 ОБНОВЛЕНО (09.10.2026): своё количество уровней на размер.
|
||||||
|
levels_count = LEVELS_PER_SIZE.get(n, 0)
|
||||||
|
if levels_count <= 0:
|
||||||
|
logger.warning(f"Размер {n}: LEVELS_PER_SIZE = 0, пропускаю")
|
||||||
|
continue
|
||||||
|
|
||||||
|
for i in range(levels_count):
|
||||||
|
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_count}] размер {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_count}] уровень #{next_level_number} "
|
||||||
|
f"({n}×{n}) слов: {len(level_data['words'])}"
|
||||||
|
)
|
||||||
|
else:
|
||||||
|
logger.warning(f" [{i+1}/{levels_count}] уровень #{next_level_number} — конфликт, пропущен")
|
||||||
|
|
||||||
|
next_level_number += 1
|
||||||
|
|
||||||
|
# 6. Итоги
|
||||||
|
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,76 @@
|
|||||||
|
"""
|
||||||
|
Импорт слов из CSV в таблицу csv_words.
|
||||||
|
|
||||||
|
Запуск:
|
||||||
|
python scripts/import_csv_words.py
|
||||||
|
|
||||||
|
Читает: words_a1.csv, words_a2.csv, words_b1.csv
|
||||||
|
Пишет: csv_words (level_code, word_pl, translation_ru, translation_uk, translation_en)
|
||||||
|
"""
|
||||||
|
import asyncio
|
||||||
|
import csv
|
||||||
|
import logging
|
||||||
|
import sys
|
||||||
|
from pathlib import Path
|
||||||
|
|
||||||
|
sys.path.insert(0, str(Path(__file__).parent.parent))
|
||||||
|
|
||||||
|
from database import get_pool
|
||||||
|
|
||||||
|
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
|
||||||
|
logger = logging.getLogger(__name__)
|
||||||
|
|
||||||
|
BACKEND_DIR = Path(__file__).parent.parent
|
||||||
|
|
||||||
|
CSV_FILES = [
|
||||||
|
("A1", "words_a1.csv"),
|
||||||
|
("A2", "words_a2.csv"),
|
||||||
|
("B1", "words_b1.csv"),
|
||||||
|
]
|
||||||
|
|
||||||
|
|
||||||
|
async def import_level(conn, level_code: str, filename: str) -> int:
|
||||||
|
"""Импортирует один CSV. Возвращает количество добавленных слов."""
|
||||||
|
path = BACKEND_DIR / filename
|
||||||
|
if not path.exists():
|
||||||
|
logger.warning(f"⚠️ Файл не найден: {path} — пропускаю")
|
||||||
|
return 0
|
||||||
|
|
||||||
|
count = 0
|
||||||
|
with open(path, 'r', encoding='utf-8') as f:
|
||||||
|
reader = csv.DictReader(f)
|
||||||
|
for row in reader:
|
||||||
|
word_pl = (row.get('polish') or '').strip().lower()
|
||||||
|
if not word_pl:
|
||||||
|
continue
|
||||||
|
|
||||||
|
translation_en = (row.get('english') or '').strip()
|
||||||
|
translation_ru = (row.get('russian') or '').strip()
|
||||||
|
translation_uk = (row.get('ukrainian') or '').strip()
|
||||||
|
|
||||||
|
await conn.execute("""
|
||||||
|
INSERT INTO csv_words (level_code, word_pl, translation_ru, translation_uk, translation_en)
|
||||||
|
VALUES ($1, $2, $3, $4, $5)
|
||||||
|
ON CONFLICT (level_code, word_pl) DO UPDATE
|
||||||
|
SET translation_ru = EXCLUDED.translation_ru,
|
||||||
|
translation_uk = EXCLUDED.translation_uk,
|
||||||
|
translation_en = EXCLUDED.translation_en
|
||||||
|
""", level_code, word_pl, translation_ru, translation_uk, translation_en)
|
||||||
|
count += 1
|
||||||
|
|
||||||
|
logger.info(f"✅ {level_code} ({filename}): {count} слов импортировано")
|
||||||
|
return count
|
||||||
|
|
||||||
|
|
||||||
|
async def main():
|
||||||
|
pool = await get_pool()
|
||||||
|
total = 0
|
||||||
|
async with pool.acquire() as conn:
|
||||||
|
for level_code, filename in CSV_FILES:
|
||||||
|
total += await import_level(conn, level_code, filename)
|
||||||
|
|
||||||
|
logger.info(f"🎉 Готово! Всего импортировано: {total} слов")
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
asyncio.run(main())
|
||||||
@@ -0,0 +1,62 @@
|
|||||||
|
"""Волновая структура филвордов.
|
||||||
|
|
||||||
|
Волна = 10 уровней. Волны бесконечные.
|
||||||
|
|
||||||
|
Размер сетки:
|
||||||
|
- Волна 1: 5×5 (уровни 1–5), 6×6 (уровни 6–10).
|
||||||
|
- Волна 2: 6×6 (уровни 1–5), 7×7 (уровни 6–10).
|
||||||
|
- Волна 3+: 7×7 (уровни 1–5), 8×8 (уровни 6–10).
|
||||||
|
|
||||||
|
Позже (когда добавим режимы сложности):
|
||||||
|
- Easy: всегда 5×5 (1–5) + 6×6 (6–10).
|
||||||
|
- Hard: всегда 8×8.
|
||||||
|
"""
|
||||||
|
from __future__ import annotations
|
||||||
|
|
||||||
|
|
||||||
|
WAVE_SIZE = 10
|
||||||
|
HALF_WAVE = 5
|
||||||
|
|
||||||
|
|
||||||
|
def wave_for_level(global_level: int) -> int:
|
||||||
|
"""Какая волна содержит этот глобальный уровень (1-based)."""
|
||||||
|
if global_level < 1:
|
||||||
|
return 1
|
||||||
|
return (global_level - 1) // WAVE_SIZE + 1
|
||||||
|
|
||||||
|
|
||||||
|
def level_in_wave(global_level: int) -> int:
|
||||||
|
"""Позиция уровня внутри волны (1..10)."""
|
||||||
|
return ((global_level - 1) % WAVE_SIZE) + 1
|
||||||
|
|
||||||
|
|
||||||
|
def grid_size_for(global_level: int) -> int:
|
||||||
|
"""Размер сетки для глобального уровня."""
|
||||||
|
wave = wave_for_level(global_level)
|
||||||
|
pos = level_in_wave(global_level)
|
||||||
|
|
||||||
|
if wave == 1:
|
||||||
|
sizes = (5, 6)
|
||||||
|
elif wave == 2:
|
||||||
|
sizes = (6, 7)
|
||||||
|
else:
|
||||||
|
sizes = (7, 8)
|
||||||
|
|
||||||
|
return sizes[0] if pos <= HALF_WAVE else sizes[1]
|
||||||
|
|
||||||
|
|
||||||
|
def max_points_for_wave() -> int:
|
||||||
|
"""Максимум очков за волну: 10 уровней × 110 = 1100."""
|
||||||
|
return 10 * 110
|
||||||
|
|
||||||
|
|
||||||
|
def wave_medal(points: int, max_points: int) -> str:
|
||||||
|
"""Медаль за волну: gold ≥90%, silver ≥70%, bronze ≥50%, иначе none."""
|
||||||
|
pct = 100 * points / max_points if max_points > 0 else 0
|
||||||
|
if pct >= 90:
|
||||||
|
return "gold"
|
||||||
|
if pct >= 70:
|
||||||
|
return "silver"
|
||||||
|
if pct >= 50:
|
||||||
|
return "bronze"
|
||||||
|
return "none"
|
||||||
+292
@@ -0,0 +1,292 @@
|
|||||||
|
"""
|
||||||
|
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
|
||||||
|
|
||||||
|
# Коэффициенты баланса (настроить после первых 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,
|
||||||
|
points: int,
|
||||||
|
) -> dict:
|
||||||
|
"""
|
||||||
|
Единая функция начисления опыта.
|
||||||
|
|
||||||
|
Args:
|
||||||
|
conn: asyncpg connection (уже acquired)
|
||||||
|
user_id: telegram_id (может быть отрицательным для Pleily)
|
||||||
|
game: 'wordsearch' | 'choose' | 'sentence' | 'bubbles'
|
||||||
|
points: готовые очки за уровень (20–110), формула считается до вызова
|
||||||
|
|
||||||
|
Returns:
|
||||||
|
{
|
||||||
|
"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. Валидация
|
||||||
|
if game not in GAME_XP_COEF:
|
||||||
|
raise ValueError(f"Unknown game: {game}")
|
||||||
|
|
||||||
|
# 2. База с коэффициентом игры (для баланса)
|
||||||
|
base_points = int(round(points * GAME_XP_COEF.get(game, 1.0)))
|
||||||
|
|
||||||
|
# 3. Множитель игры дня
|
||||||
|
is_featured = (game == featured_game())
|
||||||
|
multiplier = FEATURED_MULTIPLIER if is_featured else 1.0
|
||||||
|
final_points = int(round(base_points * 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, 0, base_points, multiplier, final_points,
|
||||||
|
)
|
||||||
|
|
||||||
|
# 6. Обновляем user_profile
|
||||||
|
new_total = old_total + final_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, final_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, final_points,
|
||||||
|
)
|
||||||
|
|
||||||
|
return {
|
||||||
|
"base_points": base_points,
|
||||||
|
"multiplier": multiplier,
|
||||||
|
"points": final_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