Compare commits
209
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
a679ca4e77 | ||
|
|
871d7167e2 | ||
|
|
8fce00f1e1 | ||
|
|
17f7ed7370 | ||
|
|
361e2d9b61 | ||
|
|
73c88678dc | ||
|
|
e8a8d9f11e | ||
|
|
7d52b0232b | ||
|
|
95058b2d3c | ||
|
|
8a78368458 | ||
|
|
20674f0823 | ||
|
|
3d379c8357 | ||
|
|
ba9a43dcfa | ||
|
|
3c9548540c | ||
|
|
5810eccde1 | ||
|
|
1df1119d11 | ||
|
|
bcf4db0ddb | ||
|
|
965d5d2503 | ||
|
|
a313c08b95 | ||
|
|
ce9f68ae51 | ||
|
|
400cf375be | ||
|
|
11ef94a9bf | ||
|
|
ed60a54e0c | ||
|
|
2d687904b0 | ||
|
|
c7ca0c97c2 | ||
|
|
3dfe34f18a | ||
|
|
61fbbe55e8 | ||
|
|
7cbde183ff | ||
|
|
da3f1567a8 | ||
|
|
82eb9208d8 | ||
|
|
5b2dbc0d42 | ||
|
|
3548654d6a | ||
|
|
4e78c32c18 | ||
|
|
5be242aafd | ||
|
|
10242f89b3 | ||
|
|
299c4e2fd5 | ||
|
|
38e0c2fe80 | ||
|
|
d669b37397 | ||
|
|
d334bc958d | ||
|
|
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 | ||
|
|
f2c7be8451 | ||
|
|
c4814d8442 | ||
|
|
9642d73cf1 | ||
|
|
453db5b91c | ||
|
|
f7859783d3 | ||
|
|
d6231b7b0f | ||
|
|
ccfe31b9fa | ||
|
|
42db922c4d | ||
|
|
ffec374a74 | ||
|
|
7b50e5ba92 | ||
|
|
7141b73c58 | ||
|
|
eef9c393ca | ||
|
|
b883cd50bf | ||
|
|
571139f364 | ||
|
|
b650adc05c | ||
|
|
9791d33b3a | ||
|
|
fa2f4e1500 | ||
|
|
8de309bca9 | ||
|
|
54ae48f193 | ||
|
|
c3c0521ae4 | ||
|
|
f7a4bf5c71 | ||
|
|
eda9bbd92c | ||
|
|
6ce33b0ce1 | ||
|
|
cceea8acf8 | ||
|
|
36cf226397 |
@@ -9,3 +9,6 @@ uploads/
|
||||
.DS_Store
|
||||
.env.save
|
||||
.env.*
|
||||
*.backup_*
|
||||
*.sql
|
||||
*.backup*
|
||||
|
||||
+1
-2
@@ -10,9 +10,8 @@
|
||||
import asyncio
|
||||
import asyncpg
|
||||
import json
|
||||
import os
|
||||
import logging
|
||||
from datetime import datetime, timedelta, timezone
|
||||
from datetime import datetime
|
||||
from decimal import Decimal
|
||||
from pathlib import Path
|
||||
from config import DB_CONFIG
|
||||
|
||||
@@ -19,116 +19,130 @@ async def verify_telegram_initdata(init_data: str):
|
||||
if '=' in chunk:
|
||||
key, value = chunk.split('=', 1)
|
||||
data[key] = unquote(value)
|
||||
|
||||
|
||||
# Извлекаем hash
|
||||
received_hash = data.pop('hash', '')
|
||||
|
||||
|
||||
if not received_hash:
|
||||
raise HTTPException(401, "Hash not found in initData")
|
||||
|
||||
|
||||
# Проверяем auth_date (не старше MAX_INITDATA_AGE из config)
|
||||
auth_date_str = data.get('auth_date', '0')
|
||||
try:
|
||||
auth_date = int(auth_date_str)
|
||||
current_time = int(time.time())
|
||||
|
||||
|
||||
if current_time - auth_date > MAX_INITDATA_AGE:
|
||||
raise HTTPException(401, "initData expired")
|
||||
|
||||
|
||||
if auth_date > current_time + 60:
|
||||
raise HTTPException(401, "initData from future")
|
||||
|
||||
|
||||
except ValueError:
|
||||
raise HTTPException(401, "Invalid auth_date")
|
||||
|
||||
|
||||
# Сортируем ключи и создаем строку для проверки
|
||||
check_arr = []
|
||||
for key in sorted(data.keys()):
|
||||
check_arr.append(f"{key}={data[key]}")
|
||||
check_string = '\n'.join(check_arr)
|
||||
|
||||
|
||||
# Создаем секретный ключ
|
||||
secret_key = hmac.new(
|
||||
'WebAppData'.encode(),
|
||||
BOT_TOKEN.encode(),
|
||||
'WebAppData'.encode(),
|
||||
BOT_TOKEN.encode(),
|
||||
hashlib.sha256
|
||||
).digest()
|
||||
|
||||
|
||||
# Вычисляем hash
|
||||
calculated_hash = hmac.new(
|
||||
secret_key,
|
||||
check_string.encode(),
|
||||
secret_key,
|
||||
check_string.encode(),
|
||||
hashlib.sha256
|
||||
).hexdigest()
|
||||
|
||||
|
||||
if not hmac.compare_digest(calculated_hash, received_hash):
|
||||
raise HTTPException(401, "Invalid initData signature")
|
||||
|
||||
|
||||
# Извлекаем данные пользователя
|
||||
user_data_str = data.get('user', '{}')
|
||||
try:
|
||||
user_data = json.loads(user_data_str)
|
||||
except json.JSONDecodeError:
|
||||
raise HTTPException(401, "Invalid user data JSON")
|
||||
|
||||
|
||||
user_id = user_data.get('id')
|
||||
username = user_data.get('username', '')
|
||||
# 🔧 ФИКС (25.09.2026): unused_first_name — удалена мёртвая переменная.
|
||||
|
||||
if not user_id:
|
||||
raise HTTPException(401, "User ID not found in initData")
|
||||
|
||||
return user_id, username
|
||||
|
||||
|
||||
except HTTPException:
|
||||
raise
|
||||
except Exception as e:
|
||||
# 🔧 ФИКС (23.09.2026): auth_error_leak — раньше в 401 утекали
|
||||
# внутренние детали (str(e)). Теперь логируем на сервере,
|
||||
# клиенту — обобщённое сообщение.
|
||||
logger.error(f"Auth error: {str(e)}", exc_info=True)
|
||||
raise HTTPException(401, "Invalid initData")
|
||||
|
||||
|
||||
async def require_auth(request: Request):
|
||||
"""Извлекает и проверяет initData из запроса.
|
||||
"""Извлекает и проверяет авторизацию из запроса.
|
||||
|
||||
🔧 ФИКС (23.09.2026): INIT_DATA_IN_URL — поддержка Authorization: tma <initData>.
|
||||
Приоритет источников:
|
||||
1. Authorization: tma <initData> — новый способ (фронт 23.09+)
|
||||
2. X-Telegram-InitData — старый способ (фронт до 23.09)
|
||||
3. query-параметр initData — fallback для deleteFeedPost
|
||||
(осознанное исключение из-за
|
||||
Cloudflare preflight-кеша)
|
||||
|
||||
Zero-downtime: старые и новые клиенты работают одновременно.
|
||||
Пять режимов (в порядке приоритета):
|
||||
1. X-Admin-Token: <jwt> — админка через браузер (26.09.2026)
|
||||
2. Authorization: Bearer <jwt> — Pleily (07.10.2026)
|
||||
3. Authorization: tma <initData> — Telegram Mini App
|
||||
4. X-Telegram-InitData — старый способ
|
||||
5. query-параметр initData — fallback для deleteFeedPost
|
||||
"""
|
||||
# ============ Режим 1: админ-токен ============
|
||||
admin_token = request.headers.get('X-Admin-Token', '').strip()
|
||||
if admin_token:
|
||||
try:
|
||||
from routers.admin_auth import verify_jwt
|
||||
from config import ADMIN_TOKEN_USER_ID
|
||||
payload = verify_jwt(admin_token)
|
||||
# Возвращаем специальный ID для admin-токена
|
||||
return ADMIN_TOKEN_USER_ID, payload.get('login', 'admin')
|
||||
except ValueError as e:
|
||||
logger.warning(f"Admin token invalid: {e}")
|
||||
raise HTTPException(401, "Invalid admin token")
|
||||
|
||||
# ============ Режим 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 = ''
|
||||
|
||||
# 1. Authorization: tma <initData> (новый способ)
|
||||
auth_header = request.headers.get('Authorization', '')
|
||||
# 3.1. Authorization: tma <initData>
|
||||
if auth_header.startswith('tma '):
|
||||
init_data = auth_header[4:].strip()
|
||||
|
||||
# 2. X-Telegram-InitData (старый способ)
|
||||
# 3.2. X-Telegram-InitData (старый способ)
|
||||
if not init_data:
|
||||
init_data = request.headers.get('X-Telegram-InitData', '')
|
||||
|
||||
# 3. Query-параметр (fallback, нужен для deleteFeedPost)
|
||||
# 3.3. Query-параметр (fallback, нужен для deleteFeedPost)
|
||||
if not init_data:
|
||||
init_data = request.query_params.get('initData', '')
|
||||
|
||||
if not init_data:
|
||||
raise HTTPException(
|
||||
401,
|
||||
"initData required. Pass as Authorization header 'tma <initData>' "
|
||||
"or 'X-Telegram-InitData' or query parameter 'initData'"
|
||||
"Authorization required. Pass 'X-Admin-Token' or "
|
||||
"'Authorization: tma <initData>' or 'X-Telegram-InitData' "
|
||||
"or query parameter 'initData'"
|
||||
)
|
||||
|
||||
# 🔧 ФИКС (23.09.2026): double_unquote_initdata — убран повторный unquote.
|
||||
# Starlette уже декодирует query_params. Повторный unquote ломал auth,
|
||||
# если в initData был символ '%' (например в first_name).
|
||||
# Декодирование значений происходит внутри verify_telegram_initdata.
|
||||
|
||||
user_id, username = await verify_telegram_initdata(init_data)
|
||||
return user_id, username
|
||||
@@ -26,7 +26,16 @@ DB_CONFIG = {
|
||||
# дефолтом был конкретный telegram_id (6694989403), который получал админку.
|
||||
# Теперь дефолт пустой — админов нет, пока не задан ADMIN_IDS.
|
||||
ADMIN_IDS = [int(id_str) for id_str in os.getenv("ADMIN_IDS", "").split(",") if id_str.strip()]
|
||||
FRONTEND_ORIGIN = os.getenv("FRONTEND_ORIGIN", "https://filwordspl.com")
|
||||
# Маркер для admin-токена (авторизация через браузер)
|
||||
ADMIN_TOKEN_USER_ID = -1
|
||||
if ADMIN_TOKEN_USER_ID not in ADMIN_IDS:
|
||||
ADMIN_IDS.append(ADMIN_TOKEN_USER_ID)
|
||||
|
||||
# 🔧 ФИКС (26.09.2026): admin_cors — добавляем admin-домен для CORS
|
||||
FRONTEND_ORIGINS = [
|
||||
"https://filwordspl.com",
|
||||
"https://admin.filwordspl.com",
|
||||
]
|
||||
|
||||
# 🔧 ФИКС (23.09.2026): initdata_age_24h — 24 часа слишком долго,
|
||||
# окно для replay-атак. Grok рекомендовал 4-6ч (компромисс между UX и безопасностью).
|
||||
@@ -78,4 +87,13 @@ FEED_ALLOWED_IMAGE_TYPES = {
|
||||
}
|
||||
|
||||
# Языки, на которые переводим feed-посты (используется в admin_feed translate)
|
||||
FEED_TARGET_LANGUAGES = ["pl", "ru", "uk", "en"]
|
||||
FEED_TARGET_LANGUAGES = ["pl", "ru", "uk", "en"]
|
||||
|
||||
# ============ ADMIN PANEL (26.09.2026) ============
|
||||
# Логин/пароль для входа в админку через браузер.
|
||||
ADMIN_LOGIN = os.getenv("ADMIN_LOGIN", "admin")
|
||||
ADMIN_PASSWORD_HASH = os.getenv("ADMIN_PASSWORD_HASH", "")
|
||||
ADMIN_JWT_SECRET = os.getenv("ADMIN_JWT_SECRET", "")
|
||||
|
||||
# 🔧 НОВОЕ (07.10.2026): app_jwt_secret — JWT для Pleily
|
||||
APP_JWT_SECRET = os.getenv("APP_JWT_SECRET", "")
|
||||
+787
-9
@@ -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 ============
|
||||
col_exists = await conn.fetchval("""
|
||||
SELECT 1 FROM information_schema.columns
|
||||
@@ -192,6 +229,21 @@ async def init_db():
|
||||
""")
|
||||
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 ============
|
||||
await conn.execute("""
|
||||
CREATE TABLE IF NOT EXISTS sentences (
|
||||
@@ -206,20 +258,31 @@ async def init_db():
|
||||
)
|
||||
""")
|
||||
|
||||
# ============ Убираем старый UNIQUE constraint с sentences.sentence_number ============
|
||||
# ============ Убираем составной UNIQUE (level, sentence_number) ============
|
||||
await conn.execute("""
|
||||
ALTER TABLE sentences DROP CONSTRAINT IF EXISTS sentences_sentence_number_key
|
||||
ALTER TABLE sentences DROP CONSTRAINT IF EXISTS sentences_sentence_number_unique
|
||||
""")
|
||||
|
||||
# ============ Добавляем составной UNIQUE (level, sentence_number) ============
|
||||
# ============ Пересчёт номеров: единый пул 1..N ============
|
||||
await conn.execute("""
|
||||
UPDATE sentences s
|
||||
SET sentence_number = sub.rn
|
||||
FROM (
|
||||
SELECT id, ROW_NUMBER() OVER (ORDER BY id) AS rn
|
||||
FROM sentences
|
||||
) sub
|
||||
WHERE s.id = sub.id
|
||||
""")
|
||||
|
||||
# ============ Добавляем UNIQUE (sentence_number) ============
|
||||
await conn.execute("""
|
||||
DO $$
|
||||
BEGIN
|
||||
IF NOT EXISTS (
|
||||
SELECT 1 FROM pg_constraint
|
||||
WHERE conname = 'sentences_sentence_number_unique'
|
||||
WHERE conname = 'sentences_sentence_number_key'
|
||||
) THEN
|
||||
ALTER TABLE sentences ADD CONSTRAINT sentences_sentence_number_unique UNIQUE (level, sentence_number);
|
||||
ALTER TABLE sentences ADD CONSTRAINT sentences_sentence_number_key UNIQUE (sentence_number);
|
||||
END IF;
|
||||
END $$;
|
||||
""")
|
||||
@@ -248,6 +311,60 @@ async def init_db():
|
||||
""")
|
||||
logger.info("Added level column to sentence_progress")
|
||||
|
||||
# 🔧 НОВОЕ (16.10.2026): list_opened — счётчик «показать предложение»
|
||||
# для текущего предложения. Medium — лимит 2, Easy — ∞, Hard — 0.
|
||||
col_exists = await conn.fetchval("""
|
||||
SELECT 1 FROM information_schema.columns
|
||||
WHERE table_name = 'sentence_progress' AND column_name = 'list_opened'
|
||||
""")
|
||||
if not col_exists:
|
||||
await conn.execute("""
|
||||
ALTER TABLE sentence_progress
|
||||
ADD COLUMN list_opened INTEGER DEFAULT 0
|
||||
""")
|
||||
logger.info("Added list_opened column to sentence_progress")
|
||||
|
||||
# 🔧 НОВОЕ (16.10.2026): no_mistakes_streak — серия предложений без ошибок.
|
||||
# +1 если предложение собрано без ошибок, иначе сброс в 0.
|
||||
# Нужен для достижения sentence_no_mistakes.
|
||||
col_exists = await conn.fetchval("""
|
||||
SELECT 1 FROM information_schema.columns
|
||||
WHERE table_name = 'sentence_progress' AND column_name = 'no_mistakes_streak'
|
||||
""")
|
||||
if not col_exists:
|
||||
await conn.execute("""
|
||||
ALTER TABLE sentence_progress
|
||||
ADD COLUMN no_mistakes_streak INTEGER DEFAULT 0
|
||||
""")
|
||||
logger.info("Added no_mistakes_streak column to sentence_progress")
|
||||
|
||||
# 🔧 НОВОЕ (16.10.2026): perfect_streak — серия идеальных предложений
|
||||
# (без ошибок + без показов). +1 если всё чисто, иначе сброс в 0.
|
||||
# Нужен для достижения sentence_perfect_streak.
|
||||
col_exists = await conn.fetchval("""
|
||||
SELECT 1 FROM information_schema.columns
|
||||
WHERE table_name = 'sentence_progress' AND column_name = 'perfect_streak'
|
||||
""")
|
||||
if not col_exists:
|
||||
await conn.execute("""
|
||||
ALTER TABLE sentence_progress
|
||||
ADD COLUMN perfect_streak INTEGER DEFAULT 0
|
||||
""")
|
||||
logger.info("Added perfect_streak column to sentence_progress")
|
||||
|
||||
# 🔧 НОВОЕ (16.10.2026): completion_time — время прохождения последнего
|
||||
# предложения (сек). Для статистики и бонуса Hard (≤15 сек).
|
||||
col_exists = await conn.fetchval("""
|
||||
SELECT 1 FROM information_schema.columns
|
||||
WHERE table_name = 'sentence_progress' AND column_name = 'completion_time'
|
||||
""")
|
||||
if not col_exists:
|
||||
await conn.execute("""
|
||||
ALTER TABLE sentence_progress
|
||||
ADD COLUMN completion_time INTEGER DEFAULT 0
|
||||
""")
|
||||
logger.info("Added completion_time column to sentence_progress")
|
||||
|
||||
# ============ typing_progress ============
|
||||
await conn.execute("""
|
||||
CREATE TABLE IF NOT EXISTS typing_progress (
|
||||
@@ -305,12 +422,17 @@ async def init_db():
|
||||
""")
|
||||
|
||||
# ============ learning_topics ============
|
||||
# 🔧 ОБНОВЛЕНО (04.10.2026): track — разделение аудиторий.
|
||||
# 'pl' — для поляков (учёба на польском)
|
||||
# 'ru_uk' — для славян (RU/UK ↔ PL, ОБЩИЙ track)
|
||||
# 'en' — для англоязычных
|
||||
await conn.execute("""
|
||||
CREATE TABLE IF NOT EXISTS learning_topics (
|
||||
id SERIAL PRIMARY KEY,
|
||||
topic_id VARCHAR(100) UNIQUE NOT NULL,
|
||||
level_code VARCHAR(10) NOT NULL,
|
||||
order_number INT NOT NULL,
|
||||
track VARCHAR(10) NOT NULL DEFAULT 'ru_uk', -- 🔧 НОВОЕ
|
||||
name_pl TEXT NOT NULL,
|
||||
name_ru TEXT NOT NULL,
|
||||
name_uk TEXT NOT NULL,
|
||||
@@ -324,6 +446,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 ============
|
||||
await conn.execute("""
|
||||
CREATE TABLE IF NOT EXISTS learning_lessons (
|
||||
@@ -430,6 +573,8 @@ async def init_db():
|
||||
""")
|
||||
|
||||
# ============ user_learning_answers ============
|
||||
# 🔧 ОБНОВЛЕНО (02.10.2026): добавлены revised и revision_of_id
|
||||
# прямо в определение — на свежих БД создаются сразу.
|
||||
await conn.execute("""
|
||||
CREATE TABLE IF NOT EXISTS user_learning_answers (
|
||||
id BIGSERIAL PRIMARY KEY,
|
||||
@@ -450,10 +595,46 @@ async def init_db():
|
||||
hint_used BOOLEAN DEFAULT FALSE,
|
||||
wrong_because VARCHAR(100),
|
||||
is_final_answer BOOLEAN DEFAULT TRUE,
|
||||
revised BOOLEAN DEFAULT FALSE, -- 🔧 НОВОЕ
|
||||
revision_of_id BIGINT, -- 🔧 НОВОЕ
|
||||
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 ============
|
||||
await conn.execute("""
|
||||
CREATE TABLE IF NOT EXISTS user_lesson_progress (
|
||||
@@ -747,6 +928,20 @@ async def init_db():
|
||||
""")
|
||||
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 ============
|
||||
await conn.execute("""
|
||||
CREATE TABLE IF NOT EXISTS bubble_words_progress (
|
||||
@@ -782,6 +977,151 @@ async def init_db():
|
||||
""")
|
||||
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")
|
||||
|
||||
# ============ sentence_stats ============
|
||||
# 🔧 НОВОЕ (16.10.2026): глобальная статистика игры «Составь предложение».
|
||||
# PK = user_id (одна строка на юзера), по образцу word_quiz_progress.
|
||||
# total_score — суммарные очки; no_mistakes_streak / perfect_streak —
|
||||
# серии для достижений sentence_no_mistakes / sentence_perfect_streak.
|
||||
await conn.execute("""
|
||||
CREATE TABLE IF NOT EXISTS sentence_stats (
|
||||
user_id BIGINT PRIMARY KEY
|
||||
REFERENCES users(telegram_id) ON DELETE CASCADE,
|
||||
total_score INTEGER DEFAULT 0,
|
||||
no_mistakes_streak INTEGER DEFAULT 0,
|
||||
perfect_streak INTEGER DEFAULT 0,
|
||||
updated_at TIMESTAMP DEFAULT NOW()
|
||||
)
|
||||
""")
|
||||
|
||||
# ============ Авто-миграция: total_score ============
|
||||
col_exists = await conn.fetchval("""
|
||||
SELECT 1 FROM information_schema.columns
|
||||
WHERE table_name = 'sentence_stats' AND column_name = 'total_score'
|
||||
""")
|
||||
if not col_exists:
|
||||
await conn.execute("""
|
||||
ALTER TABLE sentence_stats
|
||||
ADD COLUMN total_score INTEGER DEFAULT 0
|
||||
""")
|
||||
logger.info("Added total_score column to sentence_stats")
|
||||
|
||||
# ============ Авто-миграция: no_mistakes_streak ============
|
||||
col_exists = await conn.fetchval("""
|
||||
SELECT 1 FROM information_schema.columns
|
||||
WHERE table_name = 'sentence_stats' AND column_name = 'no_mistakes_streak'
|
||||
""")
|
||||
if not col_exists:
|
||||
await conn.execute("""
|
||||
ALTER TABLE sentence_stats
|
||||
ADD COLUMN no_mistakes_streak INTEGER DEFAULT 0
|
||||
""")
|
||||
logger.info("Added no_mistakes_streak column to sentence_stats")
|
||||
|
||||
# ============ Авто-миграция: perfect_streak ============
|
||||
col_exists = await conn.fetchval("""
|
||||
SELECT 1 FROM information_schema.columns
|
||||
WHERE table_name = 'sentence_stats' AND column_name = 'perfect_streak'
|
||||
""")
|
||||
if not col_exists:
|
||||
await conn.execute("""
|
||||
ALTER TABLE sentence_stats
|
||||
ADD COLUMN perfect_streak INTEGER DEFAULT 0
|
||||
""")
|
||||
logger.info("Added perfect_streak column to sentence_stats")
|
||||
|
||||
# ============ Авто-миграция: updated_at ============
|
||||
col_exists = await conn.fetchval("""
|
||||
SELECT 1 FROM information_schema.columns
|
||||
WHERE table_name = 'sentence_stats' AND column_name = 'updated_at'
|
||||
""")
|
||||
if not col_exists:
|
||||
await conn.execute("""
|
||||
ALTER TABLE sentence_stats
|
||||
ADD COLUMN updated_at TIMESTAMP DEFAULT NOW()
|
||||
""")
|
||||
logger.info("Added updated_at column to sentence_stats")
|
||||
|
||||
# ============ wrong_because_explanations ============
|
||||
await conn.execute("""
|
||||
CREATE TABLE IF NOT EXISTS wrong_because_explanations (
|
||||
@@ -830,6 +1170,70 @@ async def init_db():
|
||||
)
|
||||
""")
|
||||
|
||||
# ============ lectures — лекции (архивы) ============
|
||||
# 🔧 ОБНОВЛЕНО (27.09.2026): добавлены lecture_language и display_language.
|
||||
# title_pl и title_ru/uk/en теперь nullable — фронт забирает заголовок
|
||||
# из display_language, а не из title_pl.
|
||||
await conn.execute("""
|
||||
CREATE TABLE IF NOT EXISTS lectures (
|
||||
id BIGSERIAL PRIMARY KEY,
|
||||
level_code VARCHAR(10) NOT NULL,
|
||||
lecture_language VARCHAR(10) NOT NULL DEFAULT 'ru',
|
||||
display_language VARCHAR(10) NOT NULL DEFAULT 'ru',
|
||||
title_pl TEXT,
|
||||
title_ru TEXT,
|
||||
title_uk TEXT,
|
||||
title_en TEXT,
|
||||
description_pl TEXT,
|
||||
description_ru TEXT,
|
||||
description_uk TEXT,
|
||||
description_en TEXT,
|
||||
file_path TEXT NOT NULL,
|
||||
file_type VARCHAR(20) NOT NULL,
|
||||
file_size_bytes INT,
|
||||
order_number INT NOT NULL DEFAULT 0,
|
||||
is_active BOOLEAN DEFAULT TRUE,
|
||||
created_at TIMESTAMP DEFAULT NOW(),
|
||||
edited_at TIMESTAMP
|
||||
)
|
||||
""")
|
||||
|
||||
# ============ Авто-миграция: lecture_language + display_language ============
|
||||
col_exists = await conn.fetchval("""
|
||||
SELECT 1 FROM information_schema.columns
|
||||
WHERE table_name = 'lectures' AND column_name = 'lecture_language'
|
||||
""")
|
||||
if not col_exists:
|
||||
await conn.execute("""
|
||||
ALTER TABLE lectures
|
||||
ADD COLUMN lecture_language VARCHAR(10) DEFAULT 'ru'
|
||||
""")
|
||||
logger.info("Added lecture_language column to lectures")
|
||||
|
||||
col_exists = await conn.fetchval("""
|
||||
SELECT 1 FROM information_schema.columns
|
||||
WHERE table_name = 'lectures' AND column_name = 'display_language'
|
||||
""")
|
||||
if not col_exists:
|
||||
await conn.execute("""
|
||||
ALTER TABLE lectures
|
||||
ADD COLUMN display_language VARCHAR(10) DEFAULT 'ru'
|
||||
""")
|
||||
logger.info("Added display_language column to lectures")
|
||||
|
||||
await conn.execute("""
|
||||
CREATE INDEX IF NOT EXISTS idx_lectures_level
|
||||
ON lectures(level_code, order_number)
|
||||
""")
|
||||
|
||||
# 🔧 НОВОЕ (27.09.2026): составной индекс по языкам лекции/отображения.
|
||||
await conn.execute("""
|
||||
CREATE INDEX IF NOT EXISTS idx_lectures_lang
|
||||
ON lectures(level_code, lecture_language, order_number)
|
||||
""")
|
||||
|
||||
logger.info("Table lectures initialized")
|
||||
|
||||
# ============ daily_phrases — фраза дня ============
|
||||
await conn.execute("""
|
||||
CREATE TABLE IF NOT EXISTS daily_phrases (
|
||||
@@ -989,13 +1393,387 @@ async def init_db():
|
||||
# - idx_skill_mastery_user (user_id+skill_tag уже UNIQUE)
|
||||
# - idx_user_progress_user (user_id+level_id уже PK)
|
||||
# - idx_sentence_progress_user (user_id+sentence_id уже PK)
|
||||
await conn.execute("CREATE INDEX IF NOT EXISTS idx_levels_number ON levels(level_number)")
|
||||
await conn.execute("CREATE INDEX IF NOT EXISTS idx_levels_level ON levels(level)")
|
||||
#
|
||||
# 🔧 ФИКС (25.09.2026): redundant_indexes_levels_sentences —
|
||||
# составной индекс (level, level_number) покрывает и level,
|
||||
# и level_number. Убраны дубли:
|
||||
# idx_levels_number, idx_levels_level,
|
||||
# idx_sentences_number, idx_sentences_level.
|
||||
# DROP на случай, если они уже созданы в предыдущих деплоях.
|
||||
await conn.execute("DROP INDEX IF EXISTS idx_levels_number")
|
||||
await conn.execute("DROP INDEX IF EXISTS idx_levels_level")
|
||||
await conn.execute("DROP INDEX IF EXISTS idx_sentences_number")
|
||||
await conn.execute("DROP INDEX IF EXISTS idx_sentences_level")
|
||||
|
||||
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 ON level_words(level)")
|
||||
await conn.execute("CREATE INDEX IF NOT EXISTS idx_sentences_number ON sentences(sentence_number)")
|
||||
await conn.execute("CREATE INDEX IF NOT EXISTS idx_sentences_level ON sentences(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)")
|
||||
# Оставляем score-индексы (не дубли)
|
||||
await conn.execute("CREATE INDEX IF NOT EXISTS idx_user_progress_score ON user_progress(score DESC)")
|
||||
|
||||
@@ -0,0 +1,558 @@
|
||||
# 🗄 Схема базы данных
|
||||
|
||||
## achievements
|
||||
|
||||
| Колонка | Тип | NULL | Default |
|
||||
|---------|-----|------|---------|
|
||||
| id | integer | NO | nextval('achievements_id_seq'::regclass) |
|
||||
| code | text | NO | |
|
||||
| category | text | YES | 'general'::text |
|
||||
| name_pl | text | NO | |
|
||||
| name_ru | text | NO | |
|
||||
| name_uk | text | NO | |
|
||||
| name_en | text | NO | |
|
||||
| description_pl | text | YES | ''::text |
|
||||
| description_ru | text | YES | ''::text |
|
||||
| description_uk | text | YES | ''::text |
|
||||
| description_en | text | YES | ''::text |
|
||||
| icon | text | YES | '🏆'::text |
|
||||
| requirement_type | text | NO | |
|
||||
| requirement_value | integer | YES | 0 |
|
||||
|
||||
## ai_user_context
|
||||
|
||||
| Колонка | Тип | NULL | Default |
|
||||
|---------|-----|------|---------|
|
||||
| user_id | bigint | NO | |
|
||||
| current_level | character varying | YES | |
|
||||
| completed_topics | integer | YES | 0 |
|
||||
| completed_lessons | integer | YES | 0 |
|
||||
| overall_mastery | numeric | YES | |
|
||||
| strong_skills | jsonb | YES | '[]'::jsonb |
|
||||
| weak_skills | jsonb | YES | '[]'::jsonb |
|
||||
| uncertain_skills | jsonb | YES | '[]'::jsonb |
|
||||
| recurring_errors | jsonb | YES | '[]'::jsonb |
|
||||
| recommended_topics | jsonb | YES | '[]'::jsonb |
|
||||
| recommended_lessons | jsonb | YES | '[]'::jsonb |
|
||||
| last_analysis_at | timestamp without time zone | YES | |
|
||||
| analytics_enabled | boolean | YES | false |
|
||||
| level_topics_total | integer | YES | 0 |
|
||||
| level_completion_percent | numeric | YES | 0 |
|
||||
|
||||
## bubble_words_progress
|
||||
|
||||
| Колонка | Тип | NULL | Default |
|
||||
|---------|-----|------|---------|
|
||||
| user_id | bigint | NO | |
|
||||
| levels_completed | integer | YES | 0 |
|
||||
| total_score | integer | YES | 0 |
|
||||
| recent_words | ARRAY | YES | '{}'::text[] |
|
||||
| level | text | YES | 'A1'::text |
|
||||
| current_hints_used | integer | YES | 0 |
|
||||
|
||||
## chat_history
|
||||
|
||||
| Колонка | Тип | NULL | Default |
|
||||
|---------|-----|------|---------|
|
||||
| id | integer | NO | nextval('chat_history_id_seq'::regclass) |
|
||||
| user_id | bigint | YES | |
|
||||
| message | text | NO | |
|
||||
| is_user | boolean | YES | true |
|
||||
| created_at | timestamp without time zone | YES | now() |
|
||||
|
||||
## chat_usage
|
||||
|
||||
| Колонка | Тип | NULL | Default |
|
||||
|---------|-----|------|---------|
|
||||
| id | integer | NO | nextval('chat_usage_id_seq'::regclass) |
|
||||
| user_id | bigint | YES | |
|
||||
| usage_date | date | YES | CURRENT_DATE |
|
||||
| message_count | integer | YES | 0 |
|
||||
|
||||
## daily_logins
|
||||
|
||||
| Колонка | Тип | NULL | Default |
|
||||
|---------|-----|------|---------|
|
||||
| user_id | bigint | NO | |
|
||||
| login_date | date | NO | CURRENT_DATE |
|
||||
|
||||
## daily_phrases
|
||||
|
||||
| Колонка | Тип | NULL | Default |
|
||||
|---------|-----|------|---------|
|
||||
| id | integer | NO | nextval('daily_phrases_id_seq'::regclass) |
|
||||
| phrase_date | date | NO | |
|
||||
| phrase_pl | text | NO | |
|
||||
| translations | jsonb | NO | '{}'::jsonb |
|
||||
| grammar_breakdowns | jsonb | NO | '{}'::jsonb |
|
||||
| created_at | timestamp without time zone | YES | now() |
|
||||
|
||||
## feed_attachments
|
||||
|
||||
| Колонка | Тип | NULL | Default |
|
||||
|---------|-----|------|---------|
|
||||
| id | bigint | NO | nextval('feed_attachments_id_seq'::regclass) |
|
||||
| post_id | bigint | NO | |
|
||||
| file_path | text | NO | |
|
||||
| file_type | text | YES | 'image'::text |
|
||||
| order_number | integer | NO | 0 |
|
||||
| created_at | timestamp without time zone | YES | now() |
|
||||
|
||||
## feed_posts
|
||||
|
||||
| Колонка | Тип | NULL | Default |
|
||||
|---------|-----|------|---------|
|
||||
| id | bigint | NO | nextval('feed_posts_id_seq'::regclass) |
|
||||
| section | text | NO | |
|
||||
| source_language | text | NO | 'ru'::text |
|
||||
| title_pl | text | YES | |
|
||||
| title_ru | text | YES | |
|
||||
| title_uk | text | YES | |
|
||||
| title_en | text | YES | |
|
||||
| body_pl | text | YES | |
|
||||
| body_ru | text | YES | |
|
||||
| body_uk | text | YES | |
|
||||
| body_en | text | YES | |
|
||||
| link_url | text | YES | |
|
||||
| telegram_url | text | YES | |
|
||||
| author_id | bigint | NO | |
|
||||
| is_pinned | boolean | YES | false |
|
||||
| is_published | boolean | YES | true |
|
||||
| created_at | timestamp without time zone | YES | now() |
|
||||
| updated_at | timestamp without time zone | YES | now() |
|
||||
| edited_at | timestamp without time zone | YES | |
|
||||
| expires_at | timestamp without time zone | YES | |
|
||||
|
||||
## learning_lessons
|
||||
|
||||
| Колонка | Тип | NULL | Default |
|
||||
|---------|-----|------|---------|
|
||||
| id | integer | NO | nextval('learning_lessons_id_seq'::regclass) |
|
||||
| lesson_id | character varying | NO | |
|
||||
| topic_id | character varying | NO | |
|
||||
| order_number | integer | NO | |
|
||||
| skill_tag | character varying | NO | |
|
||||
| title_pl | text | NO | |
|
||||
| title_ru | text | NO | |
|
||||
| title_uk | text | NO | |
|
||||
| title_en | text | NO | |
|
||||
| objective_pl | text | YES | |
|
||||
| objective_ru | text | YES | |
|
||||
| objective_uk | text | YES | |
|
||||
| objective_en | text | YES | |
|
||||
| explanation_pl | text | YES | |
|
||||
| explanation_ru | text | YES | |
|
||||
| explanation_uk | text | YES | |
|
||||
| explanation_en | text | YES | |
|
||||
| is_active | boolean | YES | true |
|
||||
| edited_at | timestamp without time zone | YES | |
|
||||
|
||||
## learning_levels
|
||||
|
||||
| Колонка | Тип | NULL | Default |
|
||||
|---------|-----|------|---------|
|
||||
| id | integer | NO | nextval('learning_levels_id_seq'::regclass) |
|
||||
| code | character varying | NO | |
|
||||
| name_pl | text | NO | |
|
||||
| name_ru | text | NO | |
|
||||
| name_uk | text | NO | |
|
||||
| name_en | text | NO | |
|
||||
| sort_order | integer | NO | |
|
||||
| is_active | boolean | YES | true |
|
||||
|
||||
## learning_questions
|
||||
|
||||
| Колонка | Тип | NULL | Default |
|
||||
|---------|-----|------|---------|
|
||||
| id | integer | NO | nextval('learning_questions_id_seq'::regclass) |
|
||||
| question_id | character varying | NO | |
|
||||
| lesson_id | character varying | YES | |
|
||||
| topic_id | character varying | NO | |
|
||||
| context_type | character varying | NO | |
|
||||
| question_type | character varying | NO | |
|
||||
| skill_tag | character varying | NO | |
|
||||
| difficulty | integer | NO | |
|
||||
| prompt_pl | text | YES | |
|
||||
| prompt_ru | text | YES | |
|
||||
| prompt_uk | text | YES | |
|
||||
| prompt_en | text | YES | |
|
||||
| correct_answer | text | YES | |
|
||||
| hint_type | character varying | YES | |
|
||||
| hint_value | text | YES | |
|
||||
| is_test_question | boolean | YES | false |
|
||||
| test_order | integer | YES | |
|
||||
| options_language | text | YES | 'pl'::text |
|
||||
| edited_at | timestamp without time zone | YES | |
|
||||
|
||||
## learning_sessions
|
||||
|
||||
| Колонка | Тип | NULL | Default |
|
||||
|---------|-----|------|---------|
|
||||
| id | bigint | NO | nextval('learning_sessions_id_seq'::regclass) |
|
||||
| user_id | bigint | NO | |
|
||||
| level_code | character varying | NO | |
|
||||
| topic_id | character varying | NO | |
|
||||
| session_type | character varying | NO | |
|
||||
| started_at | timestamp without time zone | NO | now() |
|
||||
| completed_at | timestamp without time zone | YES | |
|
||||
| is_completed | boolean | YES | false |
|
||||
|
||||
## learning_topics
|
||||
|
||||
| Колонка | Тип | NULL | Default |
|
||||
|---------|-----|------|---------|
|
||||
| id | integer | NO | nextval('learning_topics_id_seq'::regclass) |
|
||||
| topic_id | character varying | NO | |
|
||||
| level_code | character varying | NO | |
|
||||
| order_number | integer | NO | |
|
||||
| name_pl | text | NO | |
|
||||
| name_ru | text | NO | |
|
||||
| name_uk | text | NO | |
|
||||
| name_en | text | NO | |
|
||||
| description_pl | text | YES | |
|
||||
| description_ru | text | YES | |
|
||||
| description_uk | text | YES | |
|
||||
| description_en | text | YES | |
|
||||
| is_active | boolean | YES | true |
|
||||
| edited_at | timestamp without time zone | YES | |
|
||||
|
||||
## lesson_examples
|
||||
|
||||
| Колонка | Тип | NULL | Default |
|
||||
|---------|-----|------|---------|
|
||||
| id | integer | NO | nextval('lesson_examples_id_seq'::regclass) |
|
||||
| lesson_id | character varying | NO | |
|
||||
| order_number | integer | NO | |
|
||||
| text_pl | text | NO | |
|
||||
| text_ru | text | YES | |
|
||||
| text_uk | text | YES | |
|
||||
| text_en | text | YES | |
|
||||
| audio_url | text | YES | |
|
||||
| edited_at | timestamp without time zone | YES | |
|
||||
|
||||
## lesson_progress
|
||||
|
||||
| Колонка | Тип | NULL | Default |
|
||||
|---------|-----|------|---------|
|
||||
| id | integer | NO | nextval('lesson_progress_id_seq'::regclass) |
|
||||
| user_id | bigint | YES | |
|
||||
| level | text | YES | 'A1'::text |
|
||||
| topic | text | YES | ''::text |
|
||||
| correct_count | integer | YES | 0 |
|
||||
| total_questions | integer | YES | 0 |
|
||||
| created_at | timestamp without time zone | YES | now() |
|
||||
|
||||
## level_words
|
||||
|
||||
| Колонка | Тип | NULL | Default |
|
||||
|---------|-----|------|---------|
|
||||
| id | integer | NO | nextval('level_words_id_seq'::regclass) |
|
||||
| level_id | integer | YES | |
|
||||
| word_pl | text | NO | |
|
||||
| translation_ru | text | YES | ''::text |
|
||||
| translation_uk | text | YES | ''::text |
|
||||
| translation_en | text | YES | ''::text |
|
||||
| level | text | YES | 'A1'::text |
|
||||
| edited_at | timestamp without time zone | YES | |
|
||||
|
||||
## levels
|
||||
|
||||
| Колонка | Тип | NULL | Default |
|
||||
|---------|-----|------|---------|
|
||||
| id | integer | NO | nextval('levels_id_seq'::regclass) |
|
||||
| level_number | integer | NO | |
|
||||
| grid_size | integer | NO | |
|
||||
| game_type | text | YES | 'wordsearch'::text |
|
||||
| theme | text | YES | ''::text |
|
||||
| grid_letters | jsonb | NO | '[]'::jsonb |
|
||||
| word_paths | jsonb | NO | '{}'::jsonb |
|
||||
| level | text | YES | 'A1'::text |
|
||||
|
||||
## question_options
|
||||
|
||||
| Колонка | Тип | NULL | Default |
|
||||
|---------|-----|------|---------|
|
||||
| id | integer | NO | nextval('question_options_id_seq'::regclass) |
|
||||
| question_id | character varying | NO | |
|
||||
| option_key | character varying | NO | |
|
||||
| text_pl | text | YES | |
|
||||
| text_ru | text | YES | |
|
||||
| text_uk | text | YES | |
|
||||
| text_en | text | YES | |
|
||||
| is_correct | boolean | NO | |
|
||||
| wrong_because | character varying | YES | |
|
||||
| edited_at | timestamp without time zone | YES | |
|
||||
|
||||
## sentence_hints_used ⚠️ устаревшая (не используется)
|
||||
|
||||
| Колонка | Тип | NULL | Default |
|
||||
|---------|-----|------|---------|
|
||||
| user_id | bigint | NO | |
|
||||
| sentence_id | integer | NO | |
|
||||
| used_at | timestamp without time zone | YES | now() |
|
||||
|
||||
## sentence_progress
|
||||
|
||||
| Колонка | Тип | NULL | Default |
|
||||
|---------|-----|------|---------|
|
||||
| user_id | bigint | NO | |
|
||||
| sentence_id | integer | NO | |
|
||||
| completed_at | timestamp without time zone | YES | |
|
||||
| score | integer | YES | 0 |
|
||||
| level | text | YES | 'A1'::text |
|
||||
|
||||
## sentences
|
||||
|
||||
| Колонка | Тип | NULL | Default |
|
||||
|---------|-----|------|---------|
|
||||
| id | integer | NO | nextval('sentences_id_seq'::regclass) |
|
||||
| sentence_number | integer | NO | |
|
||||
| theme | text | YES | ''::text |
|
||||
| sentence_pl | text | NO | |
|
||||
| translation_ru | text | YES | ''::text |
|
||||
| translation_uk | text | YES | ''::text |
|
||||
| translation_en | text | YES | ''::text |
|
||||
| difficulty | integer | YES | 1 |
|
||||
| level | text | YES | 'A1'::text |
|
||||
| edited_at | timestamp without time zone | YES | |
|
||||
|
||||
## support_messages
|
||||
|
||||
| Колонка | Тип | NULL | Default |
|
||||
|---------|-----|------|---------|
|
||||
| id | bigint | NO | nextval('support_messages_id_seq'::regclass) |
|
||||
| ticket_id | bigint | NO | |
|
||||
| sender_id | bigint | NO | |
|
||||
| message | text | NO | |
|
||||
| is_read | boolean | YES | false |
|
||||
| created_at | timestamp without time zone | YES | now() |
|
||||
|
||||
## support_tickets
|
||||
|
||||
| Колонка | Тип | NULL | Default |
|
||||
|---------|-----|------|---------|
|
||||
| id | bigint | NO | nextval('support_tickets_id_seq'::regclass) |
|
||||
| user_id | bigint | NO | |
|
||||
| status | text | YES | 'open'::text |
|
||||
| created_at | timestamp without time zone | YES | now() |
|
||||
| updated_at | timestamp without time zone | YES | now() |
|
||||
|
||||
## teacher_ai_usage
|
||||
|
||||
| Колонка | Тип | NULL | Default |
|
||||
|---------|-----|------|---------|
|
||||
| id | bigint | NO | nextval('teacher_ai_usage_id_seq'::regclass) |
|
||||
| user_id | bigint | NO | |
|
||||
| usage_date | date | YES | CURRENT_DATE |
|
||||
| command_count | integer | YES | 0 |
|
||||
|
||||
## teacher_chat_history
|
||||
|
||||
| Колонка | Тип | NULL | Default |
|
||||
|---------|-----|------|---------|
|
||||
| id | bigint | NO | nextval('teacher_chat_history_id_seq'::regclass) |
|
||||
| user_id | bigint | NO | |
|
||||
| messages | jsonb | NO | '[]'::jsonb |
|
||||
| updated_at | timestamp without time zone | YES | now() |
|
||||
|
||||
## teacher_reactions
|
||||
|
||||
| Колонка | Тип | NULL | Default |
|
||||
|---------|-----|------|---------|
|
||||
| id | integer | NO | nextval('teacher_reactions_id_seq'::regclass) |
|
||||
| reaction_type | character varying | NO | |
|
||||
| text_pl | text | NO | |
|
||||
| text_ru | text | NO | |
|
||||
| text_uk | text | NO | |
|
||||
| text_en | text | NO | |
|
||||
|
||||
## typing_hints_used
|
||||
|
||||
| Колонка | Тип | NULL | Default |
|
||||
|---------|-----|------|---------|
|
||||
| user_id | bigint | NO | |
|
||||
| sentence_id | integer | NO | |
|
||||
| used_at | timestamp without time zone | YES | now() |
|
||||
|
||||
## typing_progress
|
||||
|
||||
| Колонка | Тип | NULL | Default |
|
||||
|---------|-----|------|---------|
|
||||
| user_id | bigint | NO | |
|
||||
| sentence_id | integer | NO | |
|
||||
| completed_at | timestamp without time zone | YES | now() |
|
||||
|
||||
## user_achievements
|
||||
|
||||
| Колонка | Тип | NULL | Default |
|
||||
|---------|-----|------|---------|
|
||||
| user_id | bigint | NO | |
|
||||
| achievement_id | integer | NO | |
|
||||
| unlocked_at | timestamp without time zone | YES | now() |
|
||||
|
||||
## user_learning_answers
|
||||
|
||||
| Колонка | Тип | NULL | Default |
|
||||
|---------|-----|------|---------|
|
||||
| id | bigint | NO | nextval('user_learning_answers_id_seq'::regclass) |
|
||||
| user_id | bigint | NO | |
|
||||
| session_id | bigint | NO | |
|
||||
| level_code | character varying | NO | |
|
||||
| topic_id | character varying | NO | |
|
||||
| lesson_id | character varying | YES | |
|
||||
| question_id | character varying | NO | |
|
||||
| selected_answer | text | YES | |
|
||||
| correct | boolean | YES | |
|
||||
| skill_tag | character varying | NO | |
|
||||
| question_type | character varying | NO | |
|
||||
| context_type | character varying | NO | |
|
||||
| difficulty | integer | NO | |
|
||||
| time_taken_ms | integer | YES | |
|
||||
| attempt_number | integer | YES | 1 |
|
||||
| hint_used | boolean | YES | false |
|
||||
| wrong_because | character varying | YES | |
|
||||
| is_final_answer | boolean | YES | true |
|
||||
| created_at | timestamp without time zone | YES | now() |
|
||||
|
||||
## user_learning_answers_archive
|
||||
|
||||
| Колонка | Тип | NULL | Default |
|
||||
|---------|-----|------|---------|
|
||||
| id | bigint | NO | nextval('user_learning_answers_archive_id_seq'::re |
|
||||
| user_id | bigint | NO | |
|
||||
| skill_tag | character varying | NO | |
|
||||
| correct | boolean | YES | |
|
||||
| wrong_because | character varying | YES | |
|
||||
| created_at | date | YES | |
|
||||
| archived_at | timestamp without time zone | YES | now() |
|
||||
|
||||
## user_lesson_progress
|
||||
|
||||
| Колонка | Тип | NULL | Default |
|
||||
|---------|-----|------|---------|
|
||||
| id | bigint | NO | nextval('user_lesson_progress_id_seq'::regclass) |
|
||||
| user_id | bigint | NO | |
|
||||
| lesson_id | character varying | NO | |
|
||||
| started_at | timestamp without time zone | YES | |
|
||||
| completed_at | timestamp without time zone | YES | |
|
||||
| attempts_count | integer | YES | 0 |
|
||||
| correct_count | integer | YES | 0 |
|
||||
| best_score | numeric | YES | |
|
||||
| average_time_ms | integer | YES | |
|
||||
| completed | boolean | YES | false |
|
||||
|
||||
## user_progress
|
||||
|
||||
| Колонка | Тип | NULL | Default |
|
||||
|---------|-----|------|---------|
|
||||
| user_id | bigint | NO | |
|
||||
| level_id | integer | NO | |
|
||||
| completed_at | timestamp without time zone | YES | |
|
||||
| hints_used | integer | YES | 0 |
|
||||
| score | integer | YES | 0 |
|
||||
| level | text | YES | 'A1'::text |
|
||||
| current_streak | integer | YES | 0 |
|
||||
|
||||
## user_skill_mastery
|
||||
|
||||
| Колонка | Тип | NULL | Default |
|
||||
|---------|-----|------|---------|
|
||||
| id | bigint | NO | nextval('user_skill_mastery_id_seq'::regclass) |
|
||||
| user_id | bigint | NO | |
|
||||
| skill_tag | character varying | NO | |
|
||||
| attempts_count | integer | YES | 0 |
|
||||
| correct_count | integer | YES | 0 |
|
||||
| recognition_score | numeric | YES | |
|
||||
| production_score | numeric | YES | |
|
||||
| application_score | numeric | YES | |
|
||||
| retention_score | numeric | YES | |
|
||||
| hint_dependency | numeric | YES | |
|
||||
| average_time_ms | integer | YES | |
|
||||
| recent_accuracy | numeric | YES | |
|
||||
| long_term_accuracy | numeric | YES | |
|
||||
| mastery_score | numeric | YES | |
|
||||
| confidence | numeric | YES | |
|
||||
| last_attempt_at | timestamp without time zone | YES | |
|
||||
| median_time_ms | integer | YES | 0 |
|
||||
| recognition_attempts | integer | YES | 0 |
|
||||
| recognition_correct | integer | YES | 0 |
|
||||
| production_attempts | integer | YES | 0 |
|
||||
| production_correct | integer | YES | 0 |
|
||||
| application_attempts | integer | YES | 0 |
|
||||
| application_correct | integer | YES | 0 |
|
||||
| median_correct_time_ms | integer | YES | 0 |
|
||||
| median_wrong_time_ms | integer | YES | 0 |
|
||||
| last_3_accuracy | numeric | YES | |
|
||||
| last_5_accuracy | numeric | YES | |
|
||||
| last_10_accuracy | numeric | YES | |
|
||||
| error_count | integer | YES | 0 |
|
||||
| repeated_error_count | integer | YES | 0 |
|
||||
| days_since_last_attempt | integer | YES | 0 |
|
||||
| previous_mastery_score | numeric | YES | 0 |
|
||||
| mastery_delta | numeric | YES | 0 |
|
||||
| trend | text | YES | 'insufficient_data'::text |
|
||||
| retention_status | text | YES | 'fresh'::text |
|
||||
| fluency_score | numeric | YES | 0 |
|
||||
| passive_knowledge_score | numeric | YES | 0 |
|
||||
| active_knowledge_score | numeric | YES | 0 |
|
||||
|
||||
## user_topic_progress
|
||||
|
||||
| Колонка | Тип | NULL | Default |
|
||||
|---------|-----|------|---------|
|
||||
| id | bigint | NO | nextval('user_topic_progress_id_seq'::regclass) |
|
||||
| user_id | bigint | NO | |
|
||||
| topic_id | character varying | NO | |
|
||||
| lessons_total | integer | YES | 0 |
|
||||
| lessons_completed | integer | YES | 0 |
|
||||
| test_started | boolean | YES | false |
|
||||
| test_completed | boolean | YES | false |
|
||||
| test_score | numeric | YES | |
|
||||
| topic_mastery | numeric | YES | |
|
||||
| confidence | numeric | YES | |
|
||||
| completed_at | timestamp without time zone | YES | |
|
||||
|
||||
## users
|
||||
|
||||
| Колонка | Тип | NULL | Default |
|
||||
|---------|-----|------|---------|
|
||||
| telegram_id | bigint | NO | |
|
||||
| username | text | YES | |
|
||||
| app_language | text | YES | 'pl'::text |
|
||||
| created_at | timestamp without time zone | YES | now() |
|
||||
| last_completed_level | integer | YES | 0 |
|
||||
| id | integer | NO | nextval('users_id_seq'::regclass) |
|
||||
| current_level | text | YES | 'A1'::text |
|
||||
| difficulty | text | YES | 'medium'::text |
|
||||
|
||||
## voice_usage
|
||||
|
||||
| Колонка | Тип | NULL | Default |
|
||||
|---------|-----|------|---------|
|
||||
| id | integer | NO | nextval('voice_usage_id_seq'::regclass) |
|
||||
| user_id | bigint | YES | |
|
||||
| usage_date | date | YES | CURRENT_DATE |
|
||||
| voice_count | integer | YES | 0 |
|
||||
|
||||
## word_quiz_progress
|
||||
|
||||
| Колонка | Тип | NULL | Default |
|
||||
|---------|-----|------|---------|
|
||||
| user_id | bigint | NO | |
|
||||
| words_guessed | integer | YES | 0 |
|
||||
| total_score | integer | YES | 0 |
|
||||
| correct_streak | integer | YES | 0 |
|
||||
| recent_words | ARRAY | YES | '{}'::text[] |
|
||||
| level | text | YES | 'A1'::text |
|
||||
| current_mistakes | integer | YES | 0 |
|
||||
|
||||
## wrong_because_explanations
|
||||
|
||||
| Колонка | Тип | NULL | Default |
|
||||
|---------|-----|------|---------|
|
||||
| id | integer | NO | nextval('wrong_because_explanations_id_seq'::regcl |
|
||||
| wrong_because | character varying | NO | |
|
||||
| explanation_pl | text | NO | |
|
||||
| explanation_ru | text | NO | |
|
||||
| explanation_uk | text | NO | |
|
||||
| explanation_en | text | NO | |
|
||||
@@ -0,0 +1,174 @@
|
||||
# 🛣 Все эндпоинты проекта
|
||||
|
||||
## achievements.py
|
||||
**Префикс:** `/achievements`
|
||||
|
||||
- `GET /achievements/user`
|
||||
- `POST /achievements/track-login`
|
||||
- `POST /achievements/track-teacher-menu`
|
||||
- `POST /achievements/track-progress`
|
||||
- `POST /achievements/track-cheatsheets`
|
||||
- `POST /achievements/track-pronunciation`
|
||||
- `POST /achievements/track-ai-assistant`
|
||||
- `POST /achievements/track-alphabet`
|
||||
- `POST /achievements/track-rules`
|
||||
|
||||
## admin.py
|
||||
**Префикс:** `/admin`
|
||||
|
||||
- `GET /admin/dashboard`
|
||||
- `GET /admin/sentry-errors`
|
||||
|
||||
## admin_content.py
|
||||
**Префикс:** `/admin/content`
|
||||
|
||||
- `GET /admin/content/summary`
|
||||
- `GET /admin/content/words/levels`
|
||||
- `GET /admin/content/words/level/{level}`
|
||||
- `GET /admin/content/words/word/{word_id}`
|
||||
- `PUT /admin/content/words/word/{word_id}`
|
||||
- `POST /admin/content/words/level/{level}`
|
||||
- `GET /admin/content/texts/levels`
|
||||
- `GET /admin/content/texts/level/{level}`
|
||||
- `GET /admin/content/texts/text/{text_id}`
|
||||
- `PUT /admin/content/texts/text/{text_id}`
|
||||
- `POST /admin/content/texts/level/{level}`
|
||||
- `GET /admin/content/lessons/levels`
|
||||
- `GET /admin/content/lessons/level/{level}/topics`
|
||||
- `GET /admin/content/lessons/topic/{topic_id}`
|
||||
- `GET /admin/content/lessons/lesson/{lesson_id}`
|
||||
- `PUT /admin/content/lessons/lesson/{lesson_id}`
|
||||
- `GET /admin/content/wrong-because`
|
||||
|
||||
## assistant.py
|
||||
**Префикс:** `/assistant`
|
||||
|
||||
- `POST /assistant/chat`
|
||||
- `POST /assistant/save-analytics`
|
||||
- `GET /assistant/stats/personal`
|
||||
- `GET /assistant/stats/admin`
|
||||
- `GET /assistant/limit`
|
||||
- `GET /assistant/history`
|
||||
- `POST /assistant/history/clear`
|
||||
|
||||
## bubblewords.py
|
||||
**Префикс:** `/bubblewords`
|
||||
|
||||
- `GET /bubblewords/next`
|
||||
- `POST /bubblewords/complete`
|
||||
- `GET /bubblewords/progress`
|
||||
|
||||
## feed.py
|
||||
**Префикс:** ``
|
||||
|
||||
- `GET /feed/{section}`
|
||||
- `GET /feed/post/{post_id}`
|
||||
- `POST /admin/feed/post`
|
||||
- `PUT /admin/feed/post/{post_id}`
|
||||
- `POST /admin/feed/post/{post_id}/delete`
|
||||
- `POST /admin/feed/upload-image`
|
||||
- `POST /admin/feed/translate`
|
||||
|
||||
## game.py
|
||||
**Префикс:** `/game`
|
||||
|
||||
- `GET /game/progress`
|
||||
- `GET /game/level/{level_number}`
|
||||
- `POST /game/check-word`
|
||||
- `POST /game/complete-level`
|
||||
|
||||
## hints.py
|
||||
**Префикс:** `/hints`
|
||||
|
||||
- `GET /hints/first-letter/{level_id}`
|
||||
- `GET /hints/word-list/{level_id}`
|
||||
- `GET /hints/remaining/{level_id}`
|
||||
|
||||
## leaderboard.py
|
||||
**Префикс:** `/leaderboard`
|
||||
|
||||
- `GET /leaderboard/admin/stats`
|
||||
- `GET /leaderboard/top`
|
||||
|
||||
## learning.py
|
||||
**Префикс:** `/learning`
|
||||
|
||||
- `GET /learning/levels`
|
||||
- `GET /learning/topics`
|
||||
- `GET /learning/topics/{topic_id}`
|
||||
- `GET /learning/lessons/{lesson_id}`
|
||||
- `GET /learning/test/{topic_id}`
|
||||
- `POST /learning/session/start`
|
||||
- `POST /learning/answer`
|
||||
- `POST /learning/session/complete`
|
||||
- `GET /learning/progress`
|
||||
- `POST /learning/analytics`
|
||||
- `GET /learning/ai/context`
|
||||
- `POST /learning/practice/start`
|
||||
|
||||
## pronunciation.py
|
||||
**Префикс:** `/pronunciation`
|
||||
|
||||
- `GET /pronunciation/next`
|
||||
|
||||
## sentences.py
|
||||
**Префикс:** `/sentences`
|
||||
|
||||
- `GET /sentences/{sentence_id}/hint`
|
||||
- `GET /sentences/next`
|
||||
- `POST /sentences/check`
|
||||
- `GET /sentences/stats`
|
||||
|
||||
## support.py
|
||||
**Префикс:** `/support`
|
||||
|
||||
- `POST /support/send`
|
||||
- `GET /support/user-tickets`
|
||||
- `GET /support/user-messages/{ticket_id}`
|
||||
- `GET /support/user-unread-count`
|
||||
- `POST /support/delete-ticket/{ticket_id}`
|
||||
- `GET /support/admin-tickets`
|
||||
- `GET /support/admin-messages/{ticket_id}`
|
||||
- `POST /support/admin-reply`
|
||||
- `GET /support/unread-count`
|
||||
- `POST /support/translate`
|
||||
|
||||
## teacher.py
|
||||
**Префикс:** `/teacher`
|
||||
|
||||
- `GET /teacher/phrase-of-day`
|
||||
- `POST /teacher/resume`
|
||||
- `POST /teacher/start`
|
||||
- `POST /teacher/answer`
|
||||
- `POST /teacher/explain`
|
||||
- `POST /teacher/examples`
|
||||
- `POST /teacher/free-message`
|
||||
- `POST /teacher/diagnostic-test`
|
||||
- `POST /teacher/translate-to-polish`
|
||||
- `GET /teacher/progress`
|
||||
- `POST /teacher/history/save`
|
||||
- `GET /teacher/history/load`
|
||||
- `POST /teacher/history/clear`
|
||||
|
||||
## typing.py
|
||||
**Префикс:** `/typing`
|
||||
|
||||
- `GET /typing/next`
|
||||
- `POST /typing/check`
|
||||
- `GET /typing/hint/{sentence_id}`
|
||||
- `GET /typing/progress`
|
||||
|
||||
## users.py
|
||||
**Префикс:** `/users`
|
||||
|
||||
- `POST /users/register`
|
||||
- `GET /users/me/is-admin`
|
||||
- `POST /users/set-language`
|
||||
- `POST /users/set-level`
|
||||
|
||||
## wordquiz.py
|
||||
**Префикс:** `/wordquiz`
|
||||
|
||||
- `GET /wordquiz/next`
|
||||
- `POST /wordquiz/check`
|
||||
- `GET /wordquiz/progress`
|
||||
@@ -4,7 +4,7 @@
|
||||
|
||||
Что делает:
|
||||
1. Проверяет, есть ли фраза на сегодня в daily_phrases
|
||||
2. Если нет — генерирует через AI (MiniMax-M3)
|
||||
2. Если нет — генерирует через AI (DeepSeek V4 Pro)
|
||||
3. Пишет в daily_phrases с phrase_date = CURRENT_DATE
|
||||
|
||||
Fallback: если AI упал — пишет запасную фразу.
|
||||
@@ -25,7 +25,7 @@ logging.basicConfig(
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
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 = [
|
||||
@@ -119,7 +119,7 @@ EN_GRAMMAR: [грамматический разбор на английском
|
||||
|
||||
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:
|
||||
logger.warning("AI returned empty response, using fallback")
|
||||
|
||||
@@ -2,18 +2,20 @@ import asyncio
|
||||
import ipaddress
|
||||
import logging
|
||||
import os
|
||||
import re
|
||||
import time
|
||||
from collections import defaultdict
|
||||
from contextlib import asynccontextmanager
|
||||
from pathlib import Path
|
||||
from fastapi import FastAPI, Request, HTTPException
|
||||
from fastapi import FastAPI, Request
|
||||
from fastapi.middleware.cors import CORSMiddleware
|
||||
from fastapi.responses import JSONResponse
|
||||
from fastapi.staticfiles import StaticFiles
|
||||
from config import FRONTEND_ORIGIN, UPLOADS_DIR, CF_IPS
|
||||
from config import FRONTEND_ORIGINS, UPLOADS_DIR, CF_IPS
|
||||
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 lectures, admin_auth, admin_wordsearch, admin_users
|
||||
from routers import admin_ai # 🔧 НОВОЕ
|
||||
from routers import app_auth # 🆕 Pleily auth
|
||||
from routers import featured as featured_router # 🔧 НОВОЕ (08.10.2026)
|
||||
from routers.sentences import init_sentences
|
||||
from routers.achievements import init_achievements
|
||||
from routers.learning_data import init_learning_data
|
||||
@@ -68,7 +70,10 @@ class RateLimiter:
|
||||
"/game/check-word": {"max_requests": 30, "window": 60},
|
||||
"/game/complete-level": {"max_requests": 10, "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},
|
||||
"/learning/answer": {"max_requests": 30, "window": 60},
|
||||
"/tts": {"max_requests": 30, "window": 60},
|
||||
@@ -88,13 +93,21 @@ class RateLimiter:
|
||||
# 🔧 ФИКС (22.09.2026): дорогой AI-эндпоинт без лимита выжигал бюджет.
|
||||
"/learning/analytics": {"max_requests": 5, "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
|
||||
|
||||
def _cleanup(self):
|
||||
# 🔧 ФИКС (25.09.2026): rate_limiter_cleanup_hardcoded_window —
|
||||
# раньше жёстко 60с. Если добавить лимит с window > 60,
|
||||
# записи удалялись бы раньше времени, и лимит не работал.
|
||||
# Теперь: max(window) из self.limits.
|
||||
now = time.time()
|
||||
max_window = max(cfg["window"] for cfg in self.limits.values())
|
||||
for key in list(self.requests.keys()):
|
||||
self.requests[key] = [t for t in self.requests[key] if now - t < 60]
|
||||
self.requests[key] = [t for t in self.requests[key] if now - t < max_window]
|
||||
if not self.requests[key]:
|
||||
del self.requests[key]
|
||||
|
||||
@@ -317,9 +330,11 @@ async def rate_limit_middleware(request: Request, call_next):
|
||||
|
||||
|
||||
# ============ CORS ============
|
||||
# 🔧 ФИКС (26.09.2026): admin_cors — добавлен admin.filwordspl.com в origins.
|
||||
# Также добавлен X-Admin-Token в allow_headers для админ-авторизации.
|
||||
app.add_middleware(
|
||||
CORSMiddleware,
|
||||
allow_origins=[FRONTEND_ORIGIN],
|
||||
allow_origins=FRONTEND_ORIGINS,
|
||||
allow_credentials=False,
|
||||
allow_methods=["GET", "POST", "PUT", "DELETE", "OPTIONS"],
|
||||
# 🔧 ФИКС (23.09.2026): INIT_DATA_IN_URL — добавлен Authorization в явный список.
|
||||
@@ -329,6 +344,7 @@ app.add_middleware(
|
||||
"Authorization",
|
||||
"Content-Type",
|
||||
"X-Telegram-InitData",
|
||||
"X-Admin-Token",
|
||||
],
|
||||
)
|
||||
|
||||
@@ -354,6 +370,13 @@ app.include_router(support.router)
|
||||
app.include_router(admin.router)
|
||||
app.include_router(feed.router)
|
||||
app.include_router(admin_content.router)
|
||||
app.include_router(lectures.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)
|
||||
|
||||
|
||||
# ============ Базовые эндпоинты ============
|
||||
|
||||
@@ -36,3 +36,5 @@ typing_extensions==4.16.0
|
||||
urllib3==2.7.0
|
||||
uvicorn==0.51.0
|
||||
yarl==1.24.5
|
||||
pdfplumber==0.11.10
|
||||
PyJWT==2.15.1
|
||||
|
||||
+259
-63
@@ -1,6 +1,6 @@
|
||||
import logging
|
||||
|
||||
from fastapi import APIRouter, Request, HTTPException
|
||||
from fastapi import APIRouter, Request
|
||||
from auth import require_auth
|
||||
from database import get_pool
|
||||
|
||||
@@ -8,7 +8,7 @@ logger = logging.getLogger(__name__)
|
||||
|
||||
router = APIRouter(prefix="/achievements", tags=["achievements"])
|
||||
|
||||
# ============ Данные 52 достижений ============
|
||||
# ============ Данные 55 достижений ============
|
||||
ACHIEVEMENTS_DATA = [
|
||||
# ===== Word Search (11) =====
|
||||
{"code": "first_level", "category": "wordsearch", "icon": "🔰",
|
||||
@@ -66,7 +66,53 @@ ACHIEVEMENTS_DATA = [
|
||||
"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},
|
||||
|
||||
# ===== Sentence Builder (10) =====
|
||||
# ===== 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 (20) =====
|
||||
{"code": "first_sentence", "category": "sentence", "icon": "📝",
|
||||
"name_pl": "Debiutant", "name_ru": "Дебютант", "name_uk": "Дебютант", "name_en": "Debutant",
|
||||
"desc_pl": "Ułóż 1 zdanie", "desc_ru": "Составить 1 предложение", "desc_uk": "Скласти 1 речення", "desc_en": "Build 1 sentence",
|
||||
@@ -92,20 +138,16 @@ ACHIEVEMENTS_DATA = [
|
||||
"desc_pl": "Ułóż 200 zdań", "desc_ru": "Составить 200 предложений", "desc_uk": "Скласти 200 речень", "desc_en": "Build 200 sentences",
|
||||
"type": "sentences_completed", "value": 200},
|
||||
|
||||
{"code": "perfect_sentence_5", "category": "sentence", "icon": "✨",
|
||||
"name_pl": "Perfekcjonista", "name_ru": "Перфекционист", "name_uk": "Перфекціоніст", "name_en": "Perfectionist",
|
||||
"desc_pl": "Ułóż 5 zdań bez błędu", "desc_ru": "Составить 5 предложений без единой ошибки", "desc_uk": "Скласти 5 речень без жодної помилки", "desc_en": "Build 5 sentences without mistakes",
|
||||
"type": "perfect_sentences", "value": 5},
|
||||
{"code": "sentence_500", "category": "sentence", "icon": "🌟",
|
||||
"name_pl": "Legenda zdań", "name_ru": "Легенда предложений", "name_uk": "Легенда речень", "name_en": "Sentence Legend",
|
||||
"desc_pl": "Ułóż 500 zdań", "desc_ru": "Составить 500 предложений", "desc_uk": "Скласти 500 речень", "desc_en": "Build 500 sentences",
|
||||
"type": "sentences_completed", "value": 500},
|
||||
|
||||
{"code": "sentence_perfect_10", "category": "sentence", "icon": "💎",
|
||||
"name_pl": "Mistrz zdań", "name_ru": "Мастер предложений", "name_uk": "Майстер речень", "name_en": "Sentence Master",
|
||||
"desc_pl": "Ułóż 10 zdań bez błędu", "desc_ru": "Составить 10 предложений без ошибок", "desc_uk": "Скласти 10 речень без помилок", "desc_en": "Build 10 sentences without mistakes",
|
||||
"type": "perfect_sentences", "value": 10},
|
||||
{"code": "sentence_1000", "category": "sentence", "icon": "👑",
|
||||
"name_pl": "Guru zdań", "name_ru": "Гуру предложений", "name_uk": "Гуру речень", "name_en": "Sentence Guru",
|
||||
"desc_pl": "Ułóż 1000 zdań", "desc_ru": "Составить 1000 предложений", "desc_uk": "Скласти 1000 речень", "desc_en": "Build 1000 sentences",
|
||||
"type": "sentences_completed", "value": 1000},
|
||||
|
||||
{"code": "sentence_streak_10", "category": "sentence", "icon": "💪",
|
||||
"name_pl": "Nieomylny", "name_ru": "Безошибочный", "name_uk": "Безпомилковий", "name_en": "Flawless",
|
||||
"desc_pl": "Ułóż 10 zdań z rzędu bez błędu", "desc_ru": "Составить 10 предложений подряд без ошибок", "desc_uk": "Скласти 10 речень поспіль без помилок", "desc_en": "Build 10 sentences in a row without mistakes",
|
||||
"type": "sentence_streak", "value": 10},
|
||||
|
||||
{"code": "speed_10", "category": "sentence", "icon": "🚀",
|
||||
"name_pl": "Turbo", "name_ru": "Турбо", "name_uk": "Турбо", "name_en": "Turbo",
|
||||
@@ -116,8 +158,63 @@ ACHIEVEMENTS_DATA = [
|
||||
"name_pl": "Ekspres", "name_ru": "Экспресс", "name_uk": "Експрес", "name_en": "Express",
|
||||
"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},
|
||||
|
||||
{"code": "sentence_speed_3", "category": "sentence", "icon": "⚡",
|
||||
"name_pl": "Błyskawica", "name_ru": "Молния", "name_uk": "Блискавка", "name_en": "Lightning",
|
||||
"desc_pl": "Ułóż zdanie w mniej niż 3 sekundy", "desc_ru": "Составить предложение быстрее 3 секунд", "desc_uk": "Скласти речення швидше 3 секунд", "desc_en": "Build a sentence in under 3 seconds",
|
||||
"type": "speed_sentence", "value": 3},
|
||||
|
||||
{"code": "sentence_no_mistakes_5", "category": "sentence", "icon": "✨",
|
||||
"name_pl": "Bezbłędny", "name_ru": "Безошибочный", "name_uk": "Безпомилковий", "name_en": "Flawless",
|
||||
"desc_pl": "Ułóż 5 zdań bez błędu z rzędu", "desc_ru": "Составить 5 предложений без ошибок подряд", "desc_uk": "Скласти 5 речень без помилок поспіль", "desc_en": "Build 5 sentences without mistakes in a row",
|
||||
"type": "sentence_no_mistakes", "value": 5},
|
||||
|
||||
{"code": "sentence_no_mistakes_10", "category": "sentence", "icon": "💎",
|
||||
"name_pl": "Nieomylny", "name_ru": "Безошибочный", "name_uk": "Безпомилковий", "name_en": "Infallible",
|
||||
"desc_pl": "Ułóż 10 zdań bez błędu z rzędu", "desc_ru": "Составить 10 предложений без ошибок подряд", "desc_uk": "Скласти 10 речень без помилок поспіль", "desc_en": "Build 10 sentences without mistakes in a row",
|
||||
"type": "sentence_no_mistakes", "value": 10},
|
||||
|
||||
{"code": "sentence_no_mistakes_25", "category": "sentence", "icon": "🏆",
|
||||
"name_pl": "Mistrz czystości", "name_ru": "Мастер чистоты", "name_uk": "Майстер чистоти", "name_en": "Pure Master",
|
||||
"desc_pl": "Ułóż 25 zdań bez błędu z rzędu", "desc_ru": "Составить 25 предложений без ошибок подряд", "desc_uk": "Скласти 25 речень без помилок поспіль", "desc_en": "Build 25 sentences without mistakes in a row",
|
||||
"type": "sentence_no_mistakes", "value": 25},
|
||||
|
||||
{"code": "sentence_no_mistakes_50", "category": "sentence", "icon": "👑",
|
||||
"name_pl": "Król czystości", "name_ru": "Король чистоты", "name_uk": "Король чистоти", "name_en": "Pure King",
|
||||
"desc_pl": "Ułóż 50 zdań bez błędu z rzędu", "desc_ru": "Составить 50 предложений без ошибок подряд", "desc_uk": "Скласти 50 речень без помилок поспіль", "desc_en": "Build 50 sentences without mistakes in a row",
|
||||
"type": "sentence_no_mistakes", "value": 50},
|
||||
|
||||
{"code": "sentence_perfect_streak_5", "category": "sentence", "icon": "✨",
|
||||
"name_pl": "Perfekcyjna seria", "name_ru": "Идеальная серия", "name_uk": "Ідеальна серія", "name_en": "Perfect Streak",
|
||||
"desc_pl": "Ułóż 5 idealnych zdań z rzędu", "desc_ru": "Составить 5 идеальных предложений подряд", "desc_uk": "Скласти 5 ідеальних речень поспіль", "desc_en": "Build 5 perfect sentences in a row",
|
||||
"type": "sentence_perfect_streak", "value": 5},
|
||||
|
||||
{"code": "sentence_perfect_streak_10", "category": "sentence", "icon": "💎",
|
||||
"name_pl": "Mistrz perfekcji", "name_ru": "Мастер идеала", "name_uk": "Майстер ідеалу", "name_en": "Perfection Master",
|
||||
"desc_pl": "Ułóż 10 idealnych zdań z rzędu", "desc_ru": "Составить 10 идеальных предложений подряд", "desc_uk": "Скласти 10 ідеальних речень поспіль", "desc_en": "Build 10 perfect sentences in a row",
|
||||
"type": "sentence_perfect_streak", "value": 10},
|
||||
|
||||
{"code": "sentence_perfect_streak_25", "category": "sentence", "icon": "🏆",
|
||||
"name_pl": "Perfekcjonista", "name_ru": "Перфекционист", "name_uk": "Перфекціоніст", "name_en": "Perfectionist",
|
||||
"desc_pl": "Ułóż 25 idealnych zdań z rzędu", "desc_ru": "Составить 25 идеальных предложений подряд", "desc_uk": "Скласти 25 ідеальних речень поспіль", "desc_en": "Build 25 perfect sentences in a row",
|
||||
"type": "sentence_perfect_streak", "value": 25},
|
||||
|
||||
{"code": "sentence_perfect_streak_50", "category": "sentence", "icon": "👑",
|
||||
"name_pl": "Idealny król", "name_ru": "Идеальный король", "name_uk": "Ідеальний король", "name_en": "Perfect King",
|
||||
"desc_pl": "Ułóż 50 idealnych zdań z rzędu", "desc_ru": "Составить 50 идеальных предложений подряд", "desc_uk": "Скласти 50 ідеальних речень поспіль", "desc_en": "Build 50 perfect sentences in a row",
|
||||
"type": "sentence_perfect_streak", "value": 50},
|
||||
|
||||
{"code": "sentence_xp_1000", "category": "sentence", "icon": "💎",
|
||||
"name_pl": "Zdaniowy XP", "name_ru": "XP предложений", "name_uk": "XP речень", "name_en": "Sentence XP",
|
||||
"desc_pl": "Zdobądź 1000 punktów w zdaniach", "desc_ru": "Набрать 1000 очков в предложениях", "desc_uk": "Набрати 1000 балів у реченнях", "desc_en": "Earn 1000 points in sentences",
|
||||
"type": "sentence_xp", "value": 1000},
|
||||
|
||||
{"code": "sentence_xp_5000", "category": "sentence", "icon": "👑",
|
||||
"name_pl": "Zdaniowy diament", "name_ru": "Бриллиант предложений", "name_uk": "Діамант речень", "name_en": "Sentence Diamond",
|
||||
"desc_pl": "Zdobądź 5000 punktów w zdaniach", "desc_ru": "Набрать 5000 очков в предложениях", "desc_uk": "Набрати 5000 балів у реченнях", "desc_en": "Earn 5000 points in sentences",
|
||||
"type": "sentence_xp", "value": 5000},
|
||||
|
||||
# ===== Word Quiz (8) =====
|
||||
# ===== Word Quiz (20) =====
|
||||
{"code": "quiz_10", "category": "wordquiz", "icon": "🧠",
|
||||
"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",
|
||||
@@ -136,29 +233,89 @@ ACHIEVEMENTS_DATA = [
|
||||
{"code": "quiz_perfect_10", "category": "wordquiz", "icon": "💎",
|
||||
"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",
|
||||
"type": "quiz_perfect_streak", "value": 10},
|
||||
"type": "quiz_correct_streak", "value": 10},
|
||||
|
||||
{"code": "quiz_streak_20", "category": "wordquiz", "icon": "🔥",
|
||||
"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",
|
||||
"type": "quiz_perfect_streak", "value": 20},
|
||||
"type": "quiz_correct_streak", "value": 20},
|
||||
|
||||
{"code": "quiz_speed", "category": "wordquiz", "icon": "⚡",
|
||||
"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",
|
||||
"type": "quiz_speed", "value": 3},
|
||||
"type": "quiz_speed_3", "value": 3},
|
||||
|
||||
{"code": "quiz_speed_2", "category": "wordquiz", "icon": "🚀",
|
||||
"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",
|
||||
"type": "quiz_speed", "value": 2},
|
||||
"type": "quiz_speed_2", "value": 2},
|
||||
|
||||
{"code": "quiz_no_mistakes", "category": "wordquiz", "icon": "🏆",
|
||||
"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",
|
||||
"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": "🫧",
|
||||
"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",
|
||||
@@ -184,22 +341,82 @@ ACHIEVEMENTS_DATA = [
|
||||
"desc_pl": "Ukończ poziom bez podpowiedzi", "desc_ru": "Пройти уровень без подсказок", "desc_uk": "Пройти рівень без підказок", "desc_en": "Complete a level without hints",
|
||||
"type": "bubble_no_hints", "value": 1},
|
||||
|
||||
{"code": "bubble_perfect", "category": "bubblewords", "icon": "✨",
|
||||
"name_pl": "Perfekcyjny", "name_ru": "Идеальный", "name_uk": "Ідеальний", "name_en": "Perfect",
|
||||
"desc_pl": "Ukończ poziom z maksymalną punktacją (100)", "desc_ru": "Пройти уровень с максимальным счётом (100)", "desc_uk": "Пройти рівень з максимальним рахунком (100)", "desc_en": "Complete a level with maximum score (100)",
|
||||
"type": "bubble_perfect", "value": 1},
|
||||
{"code": "bubble_streak_25", "category": "bubblewords", "icon": "🔥",
|
||||
"name_pl": "Dwadzieścia pięć z rzędu", "name_ru": "Двадцать пять подряд", "name_uk": "Двадцять п'ять поспіль", "name_en": "Twenty-Five in a Row",
|
||||
"desc_pl": "Ukończ 25 poziomów z rzędu bez podpowiedzi", "desc_ru": "Пройти 25 уровней подряд без подсказок", "desc_uk": "Пройти 25 рівнів поспіль без підказок", "desc_en": "Complete 25 levels in a row without hints",
|
||||
"type": "bubble_streak", "value": 25},
|
||||
|
||||
{"code": "bubble_speed", "category": "bubblewords", "icon": "🚀",
|
||||
"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",
|
||||
"type": "bubble_speed", "value": 45},
|
||||
"type": "bubble_speed_45", "value": 45},
|
||||
|
||||
{"code": "bubble_speed_30", "category": "bubblewords", "icon": "⚡",
|
||||
"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",
|
||||
"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_words_1000", "category": "bubblewords", "icon": "📚",
|
||||
"name_pl": "Tysiąc słów", "name_ru": "Тысяча слов", "name_uk": "Тисяча слів", "name_en": "Thousand Words",
|
||||
"desc_pl": "Zbierz 1000 słów", "desc_ru": "Собрать 1000 слов", "desc_uk": "Зібрати 1000 слів", "desc_en": "Collect 1000 words",
|
||||
"type": "bubble_words", "value": 1000},
|
||||
|
||||
{"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_speed_10", "category": "bubblewords", "icon": "⚡",
|
||||
"name_pl": "Mgnienie", "name_ru": "Мгновение", "name_uk": "Миттєвість", "name_en": "Blink",
|
||||
"desc_pl": "Ukończ poziom w mniej niż 10 sekund", "desc_ru": "Пройти уровень быстрее 10 секунд", "desc_uk": "Пройти рівень швидше 10 секунд", "desc_en": "Complete a level in under 10 seconds",
|
||||
"type": "bubble_speed_10", "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": "🌟",
|
||||
"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",
|
||||
@@ -245,42 +462,7 @@ ACHIEVEMENTS_DATA = [
|
||||
"desc_pl": "Zmień język interfejsu", "desc_ru": "Сменить язык интерфейса", "desc_uk": "Змінити мову інтерфейсу", "desc_en": "Change interface language",
|
||||
"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 +505,20 @@ async def init_achievements():
|
||||
requirement_value = EXCLUDED.requirement_value
|
||||
""", 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")
|
||||
|
||||
|
||||
|
||||
+131
-11
@@ -2,9 +2,15 @@
|
||||
Admin Router — админ-панель с реальной статистикой проекта.
|
||||
1. /admin/dashboard — общая статистика (юзеры, онлайн, по уровням)
|
||||
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 logging
|
||||
from typing import Optional
|
||||
import httpx
|
||||
from fastapi import APIRouter, Request, HTTPException
|
||||
from auth import require_auth
|
||||
@@ -102,10 +108,23 @@ async def get_admin_dashboard(request: Request):
|
||||
|
||||
|
||||
@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.
|
||||
Возвращает только unresolved (нерешённые) за последние 24 часа.
|
||||
🔧 ОБНОВЛЕНО (01.10.2026): расширенные фильтры для Sentry.
|
||||
|
||||
Параметры:
|
||||
- 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)
|
||||
_require_admin(telegram_id)
|
||||
@@ -113,15 +132,47 @@ async def get_sentry_errors(request: Request):
|
||||
if not SENTRY_AUTH_TOKEN:
|
||||
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/"
|
||||
params = {
|
||||
"query": "is:unresolved",
|
||||
"statsPeriod": "24h",
|
||||
"limit": 20,
|
||||
}
|
||||
headers = {
|
||||
"Authorization": f"Bearer {SENTRY_AUTH_TOKEN}",
|
||||
"statsPeriod": period,
|
||||
"limit": limit,
|
||||
"sort": "freq", # сортировка по частоте
|
||||
}
|
||||
if query:
|
||||
params["query"] = query
|
||||
|
||||
headers = {"Authorization": f"Bearer {SENTRY_AUTH_TOKEN}"}
|
||||
|
||||
try:
|
||||
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"),
|
||||
"permalink": issue.get("permalink"),
|
||||
"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:
|
||||
logger.error("Sentry API timeout")
|
||||
return {"errors": [], "error": "Sentry API timeout"}
|
||||
except Exception as 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,
|
||||
}
|
||||
@@ -0,0 +1,124 @@
|
||||
"""
|
||||
Admin Auth Router — авторизация админки через логин/пароль.
|
||||
|
||||
Отдаёт JWT-токен. Токен используется для доступа к /admin/* эндпоинтам
|
||||
через заголовок X-Admin-Token.
|
||||
"""
|
||||
import hashlib
|
||||
import hmac
|
||||
import json
|
||||
import time
|
||||
import base64
|
||||
import logging
|
||||
from fastapi import APIRouter, Request, HTTPException
|
||||
from config import ADMIN_LOGIN, ADMIN_PASSWORD_HASH, ADMIN_JWT_SECRET
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
router = APIRouter(prefix="/admin", tags=["admin-auth"])
|
||||
|
||||
# Время жизни токена — 24 часа
|
||||
TOKEN_TTL_SECONDS = 24 * 60 * 60
|
||||
|
||||
|
||||
def _base64url_encode(data: bytes) -> str:
|
||||
return base64.urlsafe_b64encode(data).rstrip(b"=").decode("ascii")
|
||||
|
||||
|
||||
def _base64url_decode(data: str) -> bytes:
|
||||
padding = "=" * (4 - len(data) % 4)
|
||||
return base64.urlsafe_b64decode(data + padding)
|
||||
|
||||
|
||||
def create_jwt(payload: dict) -> str:
|
||||
"""Создаёт JWT-токен с HMAC-SHA256 подписью."""
|
||||
header = {"alg": "HS256", "typ": "JWT"}
|
||||
|
||||
header_b64 = _base64url_encode(json.dumps(header, separators=(",", ":")).encode())
|
||||
payload_b64 = _base64url_encode(json.dumps(payload, separators=(",", ":")).encode())
|
||||
|
||||
message = f"{header_b64}.{payload_b64}"
|
||||
signature = hmac.new(
|
||||
ADMIN_JWT_SECRET.encode(),
|
||||
message.encode(),
|
||||
hashlib.sha256,
|
||||
).digest()
|
||||
signature_b64 = _base64url_encode(signature)
|
||||
|
||||
return f"{message}.{signature_b64}"
|
||||
|
||||
|
||||
def verify_jwt(token: str) -> dict:
|
||||
"""Проверяет JWT-токен. Возвращает payload или бросает исключение."""
|
||||
try:
|
||||
parts = token.split(".")
|
||||
if len(parts) != 3:
|
||||
raise ValueError("Invalid token format")
|
||||
|
||||
header_b64, payload_b64, signature_b64 = parts
|
||||
message = f"{header_b64}.{payload_b64}"
|
||||
|
||||
expected_signature = hmac.new(
|
||||
ADMIN_JWT_SECRET.encode(),
|
||||
message.encode(),
|
||||
hashlib.sha256,
|
||||
).digest()
|
||||
actual_signature = _base64url_decode(signature_b64)
|
||||
|
||||
if not hmac.compare_digest(expected_signature, actual_signature):
|
||||
raise ValueError("Invalid signature")
|
||||
|
||||
payload = json.loads(_base64url_decode(payload_b64))
|
||||
|
||||
# Проверяем срок действия
|
||||
if payload.get("exp", 0) < time.time():
|
||||
raise ValueError("Token expired")
|
||||
|
||||
return payload
|
||||
except Exception as e:
|
||||
raise ValueError(f"Invalid token: {e}")
|
||||
|
||||
|
||||
@router.post("/login")
|
||||
async def admin_login(request: Request):
|
||||
"""
|
||||
Логин админа. Принимает {login, password}, отдаёт JWT-токен.
|
||||
"""
|
||||
if not ADMIN_PASSWORD_HASH or not ADMIN_JWT_SECRET:
|
||||
raise HTTPException(500, "Admin auth not configured")
|
||||
|
||||
body = await request.json()
|
||||
login = (body.get("login") or "").strip()
|
||||
password = body.get("password") or ""
|
||||
|
||||
if not login or not password:
|
||||
raise HTTPException(400, "login and password required")
|
||||
|
||||
# Проверяем логин
|
||||
if login != ADMIN_LOGIN:
|
||||
logger.warning(f"Admin login failed: wrong login '{login}'")
|
||||
raise HTTPException(401, "Invalid credentials")
|
||||
|
||||
# Проверяем пароль (sha256-хэш)
|
||||
password_hash = hashlib.sha256(password.encode()).hexdigest()
|
||||
if not hmac.compare_digest(password_hash, ADMIN_PASSWORD_HASH):
|
||||
logger.warning(f"Admin login failed: wrong password for '{login}'")
|
||||
raise HTTPException(401, "Invalid credentials")
|
||||
|
||||
# Создаём JWT
|
||||
now = int(time.time())
|
||||
payload = {
|
||||
"sub": "admin",
|
||||
"login": login,
|
||||
"iat": now,
|
||||
"exp": now + TOKEN_TTL_SECONDS,
|
||||
}
|
||||
token = create_jwt(payload)
|
||||
|
||||
logger.info(f"Admin login successful: {login}")
|
||||
|
||||
return {
|
||||
"status": "ok",
|
||||
"token": token,
|
||||
"expires_in": TOKEN_TTL_SECONDS,
|
||||
}
|
||||
+1339
-16
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 time
|
||||
import json
|
||||
import httpx
|
||||
from fastapi import APIRouter, Request, HTTPException
|
||||
from auth import require_auth
|
||||
|
||||
+280
-57
@@ -1,6 +1,6 @@
|
||||
import random
|
||||
import time
|
||||
import hashlib # 🔧 НОВОЕ: импорт hashlib для стабильного хэширования
|
||||
import json
|
||||
from fastapi import APIRouter, Request, HTTPException
|
||||
from auth import require_auth
|
||||
from database import get_pool
|
||||
@@ -101,7 +101,7 @@ async def get_next_bubble_level(request: Request):
|
||||
pool = await get_pool()
|
||||
async with pool.acquire() as conn:
|
||||
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:
|
||||
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
|
||||
|
||||
# Прогрессия по количеству слов на уровне
|
||||
if current_bubble_level <= 10:
|
||||
num_words = random.choice([3, 4])
|
||||
elif current_bubble_level <= 25:
|
||||
num_words = random.choice([5, 6])
|
||||
else:
|
||||
num_words = random.choice([7, 8])
|
||||
# Количество слов по сложности
|
||||
difficulty = user["difficulty"] if "difficulty" in user.keys() else "medium"
|
||||
num_words = {"easy": 3, "medium": 4, "hard": 5}.get(difficulty, 4)
|
||||
|
||||
# Запрос слов с фильтром по уровню и 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("""
|
||||
SELECT word_pl, translation_ru, translation_uk, translation_en
|
||||
FROM (
|
||||
SELECT DISTINCT ON (word_pl) word_pl, translation_ru, translation_uk, translation_en
|
||||
FROM level_words
|
||||
WHERE level = $1 AND level_id IS NULL
|
||||
) AS unique_words
|
||||
FROM csv_words
|
||||
WHERE level_code = $1
|
||||
ORDER BY RANDOM()
|
||||
LIMIT $2
|
||||
""", current_level, num_words)
|
||||
@@ -164,22 +159,191 @@ async def get_next_bubble_level(request: Request):
|
||||
|
||||
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 {
|
||||
"words": result_words,
|
||||
"bubbles": all_parts,
|
||||
"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")
|
||||
async def complete_bubble_level(request: Request):
|
||||
"""Завершение уровня пузырей, начисление очков и проверка достижений"""
|
||||
"""Завершение уровня пузырей, начисление XP и проверка достижений.
|
||||
|
||||
🔧 НОВОЕ (08.10.2026): XP-система.
|
||||
Штрафы:
|
||||
-1 за открытие списка слов (один раз за уровень)
|
||||
-1 за каждое неправильно собранное слово (макс 3)
|
||||
-1 если time_ms > 60 сек
|
||||
Минимум 1 звезда.
|
||||
"""
|
||||
telegram_id, _ = await require_auth(request)
|
||||
body = await request.json()
|
||||
words_count = body.get("words_count", 3)
|
||||
completion_time = body.get("completion_time")
|
||||
# 🔧 ФИКС (24.09.2026): client_controlled_hints_bubblewords —
|
||||
# hints_used больше НЕ берём от клиента. Читаем из bubble_words_progress.current_hints_used.
|
||||
wrong_words = int(body.get("wrong_words", 0) or 0)
|
||||
|
||||
pool = await get_pool()
|
||||
async with pool.acquire() as conn:
|
||||
@@ -189,66 +353,114 @@ async def complete_bubble_level(request: Request):
|
||||
if not user_exists:
|
||||
raise HTTPException(401, "User not registered")
|
||||
|
||||
# Получаем current_level пользователя
|
||||
current_level = await conn.fetchval(
|
||||
"SELECT current_level FROM users WHERE telegram_id = $1", telegram_id
|
||||
) or "A1"
|
||||
user = await conn.fetchrow(
|
||||
"SELECT current_level, difficulty FROM users WHERE telegram_id = $1", telegram_id
|
||||
)
|
||||
current_level = user["current_level"] or "A1"
|
||||
difficulty = user["difficulty"] or "medium"
|
||||
|
||||
# 🔧 ФИКС (24.09.2026): client_controlled_hints_bubblewords —
|
||||
# читаем серверный hints_used.
|
||||
hints_used = await conn.fetchval(
|
||||
"SELECT current_hints_used FROM bubble_words_progress WHERE user_id = $1",
|
||||
# Читаем серверные счётчики (не из body)
|
||||
progress = await conn.fetchrow(
|
||||
"SELECT current_hints_used, current_list_opened "
|
||||
"FROM bubble_words_progress WHERE user_id = $1",
|
||||
telegram_id
|
||||
) or 0
|
||||
)
|
||||
hints_used = (progress["current_hints_used"] if progress else 0) or 0
|
||||
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("""
|
||||
INSERT INTO bubble_words_progress (user_id, levels_completed, total_score, level, current_hints_used)
|
||||
VALUES ($1, 1, $2, $3, 0)
|
||||
INSERT INTO bubble_words_progress
|
||||
(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
|
||||
SET levels_completed = bubble_words_progress.levels_completed + 1,
|
||||
total_score = bubble_words_progress.total_score + $2,
|
||||
level = $3,
|
||||
current_hints_used = 0
|
||||
""", telegram_id, score, current_level)
|
||||
current_hints_used = 0,
|
||||
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 —
|
||||
# вызовы достижений вынесены за async with pool.acquire() (паттерн game.py).
|
||||
# 🔧 НОВОЕ (15.10.2026): читаем актуальные счётчики для проверки достижений.
|
||||
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(
|
||||
"SELECT levels_completed FROM bubble_words_progress WHERE user_id = $1",
|
||||
telegram_id
|
||||
) or 0
|
||||
wordsearch_score = await conn.fetchval(
|
||||
"SELECT COALESCE(SUM(score), 0) FROM user_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
|
||||
telegram_id
|
||||
) or 0
|
||||
sentence_score = await conn.fetchval(
|
||||
"SELECT COALESCE(SUM(score), 0) FROM sentence_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
|
||||
telegram_id
|
||||
) or 0
|
||||
wordquiz_score = await conn.fetchval(
|
||||
"SELECT COALESCE(total_score, 0) FROM word_quiz_progress WHERE user_id = $1",
|
||||
telegram_id
|
||||
) or 0
|
||||
bubblewords_score = await conn.fetchval(
|
||||
"SELECT COALESCE(total_score, 0) FROM bubble_words_progress WHERE user_id = $1",
|
||||
telegram_id
|
||||
) or 0
|
||||
grand_total = wordsearch_score + sentence_score + wordquiz_score + bubblewords_score
|
||||
|
||||
achievements_to_check = [
|
||||
("bubble_levels", total_levels),
|
||||
("total_score", grand_total),
|
||||
("total_score", xp_result["total_xp"]),
|
||||
]
|
||||
if hints_used == 0:
|
||||
achievements_to_check.append(("bubble_no_hints", 1))
|
||||
if score == 100:
|
||||
achievements_to_check.append(("bubble_perfect", 1))
|
||||
if completion_time is not None and completion_time > 0 and int(completion_time) <= 45:
|
||||
achievements_to_check.append(("bubble_speed", 45))
|
||||
if completion_time is not None and 0 < completion_time <= 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_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_speed_10 — быстрее 10 сек
|
||||
if completion_time is not None and 0 < completion_time <= 10:
|
||||
achievements_to_check.append(("bubble_speed_10", 10))
|
||||
|
||||
# Достижения — вне транзакции
|
||||
from routers.achievements import check_and_award_achievements
|
||||
new_achievements = []
|
||||
for ach_type, value in achievements_to_check:
|
||||
@@ -260,6 +472,17 @@ async def complete_bubble_level(request: Request):
|
||||
"score": score,
|
||||
"completion_time": completion_time,
|
||||
"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/upload-image — загрузить картинку (multipart, до 3 на пост)
|
||||
- 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).
|
||||
@@ -21,9 +23,8 @@ import logging
|
||||
import json
|
||||
import re
|
||||
import uuid
|
||||
import os
|
||||
from pathlib import Path
|
||||
from typing import Optional, Any
|
||||
from typing import Optional
|
||||
|
||||
import httpx
|
||||
from fastapi import APIRouter, Request, HTTPException, UploadFile, File, Form
|
||||
@@ -45,7 +46,7 @@ logger = logging.getLogger(__name__)
|
||||
router = APIRouter(tags=["feed"])
|
||||
|
||||
TOGETHER_API_URL = "https://api.together.xyz/v1/chat/completions"
|
||||
TRANSLATE_MODEL = "MiniMaxAI/MiniMax-M3"
|
||||
TRANSLATE_MODEL = "deepseek-ai/DeepSeek-V4-Pro-0813"
|
||||
|
||||
# 🔧 ФИКС: бэк отдаёт полный URL картинки, чтобы фронт не гадал,
|
||||
# куда склеивать относительный путь /uploads/feed/...
|
||||
@@ -252,7 +253,7 @@ async def translate_to_all_languages(
|
||||
{"role": "system", "content": system_prompt},
|
||||
{"role": "user", "content": user_prompt},
|
||||
],
|
||||
"max_tokens": 2000,
|
||||
"max_tokens": 4000,
|
||||
"temperature": 0.3,
|
||||
},
|
||||
)
|
||||
@@ -322,7 +323,7 @@ async def admin_create_feed_post(request: Request):
|
||||
"expires_at": "2026-10-15T23:59:59Z" (опционально, для partners)
|
||||
}
|
||||
|
||||
Backend автоматически переведёт title/body на 4 языка через MiniMax-M3.
|
||||
Backend автоматически переведёт title/body на 4 языка через DeepSeek V4 Pro.
|
||||
Если перевод упал — сохраняем source_language для всех языков (fallback).
|
||||
"""
|
||||
telegram_id, _ = await require_auth(request)
|
||||
@@ -788,4 +789,177 @@ async def admin_translate_feed(request: Request):
|
||||
if not translations:
|
||||
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),
|
||||
}
|
||||
+522
-45
@@ -13,7 +13,8 @@ async def get_progress(request: Request):
|
||||
pool = await get_pool()
|
||||
async with pool.acquire() as conn:
|
||||
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
|
||||
)
|
||||
|
||||
@@ -25,7 +26,13 @@ async def get_progress(request: Request):
|
||||
}
|
||||
|
||||
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(
|
||||
"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)
|
||||
|
||||
return {
|
||||
"last_completed_level": user["last_completed_level"] or 0,
|
||||
"last_completed_level": last_completed,
|
||||
"total_score": total_score,
|
||||
"current_level": current_level
|
||||
}
|
||||
@@ -66,7 +73,7 @@ async def get_level(request: Request, level_number: int):
|
||||
pool = await get_pool()
|
||||
async with pool.acquire() as conn:
|
||||
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:
|
||||
@@ -74,20 +81,43 @@ async def get_level(request: Request, level_number: int):
|
||||
|
||||
lang = user["app_language"] or "pl"
|
||||
current_level = user["current_level"] or "A1"
|
||||
|
||||
# 🔧 ОБНОВЛЕНО (07.10.2026): единый счётчик (без per-level).
|
||||
# Уровни глобальные (level = 'common'), поэтому прогресс —
|
||||
# users.last_completed_level. last_completed_by_level оставлен
|
||||
# в БД для совместимости, но больше не используется здесь.
|
||||
last_completed = user["last_completed_level"] or 0
|
||||
|
||||
# Проверяем, что уровень доступен (не дальше следующего за пройденным)
|
||||
if level_number > 1 and level_number > last_completed + 1:
|
||||
raise HTTPException(403, "Level not available yet. Complete previous level first.")
|
||||
# 🔧 ОБНОВЛЕНО (07.10.2026): все уровни — common (автогенерированные).
|
||||
# Ищем по level_number без created_by и без current_level.
|
||||
# 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:
|
||||
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(
|
||||
"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"],
|
||||
)
|
||||
|
||||
# 🔧 ФИКС (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 = []
|
||||
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_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"]
|
||||
@@ -113,6 +174,22 @@ async def get_level(request: Request, level_number: int):
|
||||
if isinstance(word_paths, str):
|
||||
word_paths = json.loads(word_paths)
|
||||
|
||||
# 🔧 ФИКС (25.09.2026): completed_detects_hint_row —
|
||||
# раньше completed = progress is not None. Но hints.py создаёт
|
||||
# строку при подсказке (score=0, completed_at=NULL) — это НЕ завершение.
|
||||
# Теперь: completed = completed_at IS NOT NULL OR score > 0.
|
||||
is_completed = (
|
||||
progress is not None
|
||||
and (
|
||||
progress["completed_at"] is not None
|
||||
or (progress["score"] or 0) > 0
|
||||
)
|
||||
)
|
||||
|
||||
# 🔧 ФИКС (10.10.2026): wave/pos из зафиксированных значений.
|
||||
wave = current_wave
|
||||
pos_in_wave = current_pos
|
||||
|
||||
return {
|
||||
"level": {
|
||||
"id": level["id"],
|
||||
@@ -124,10 +201,14 @@ async def get_level(request: Request, level_number: int):
|
||||
},
|
||||
"words": word_list,
|
||||
"progress": {
|
||||
"completed": progress is not None,
|
||||
"completed": is_completed,
|
||||
"hints_used": progress["hints_used"] 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",
|
||||
}
|
||||
|
||||
|
||||
@@ -172,8 +253,18 @@ async def check_word(request: Request):
|
||||
continue
|
||||
selected_word = selected_word.lower()
|
||||
|
||||
for word in word_paths.keys():
|
||||
if word.lower() == selected_word:
|
||||
# 🔧 ФИКС (11.10.2026): word_matched_by_letters_only —
|
||||
# раньше слово зачислялось только по буквам. Если те же буквы
|
||||
# встречаются в другом месте сетки (например 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
|
||||
break
|
||||
|
||||
@@ -218,7 +309,7 @@ async def check_word(request: Request):
|
||||
"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")
|
||||
@@ -255,14 +346,31 @@ async def complete_level(request: Request):
|
||||
# 🔧 ФИКС (24.09.2026): client_controlled_hints_game —
|
||||
# hints_used читаем из БД, не доверяем клиенту.
|
||||
hints_used = 0
|
||||
# 🔧 НОВОЕ (08.10.2026): XP-система — результат award_xp.
|
||||
xp_result = None
|
||||
# 🆕 (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:
|
||||
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
|
||||
)
|
||||
if not user:
|
||||
raise HTTPException(401, "User not registered")
|
||||
|
||||
difficulty = user["difficulty"] or "medium"
|
||||
|
||||
level = await conn.fetchrow(
|
||||
"SELECT id, level_number, grid_size, level FROM levels WHERE id = $1", level_id
|
||||
@@ -273,16 +381,32 @@ async def complete_level(request: Request):
|
||||
current_level_number = level["level_number"]
|
||||
level_name = level["level"] or "A1"
|
||||
|
||||
# Проверяем, что уровень принадлежит текущему уровню пользователя
|
||||
if level_name != (user["current_level"] or "A1"):
|
||||
raise HTTPException(403, "This level does not belong to your current level")
|
||||
# 🔧 ОБНОВЛЕНО (07.10.2026): level = 'common'.
|
||||
# Уровни глобальные, поэтому убираем проверку «уровень принадлежит
|
||||
# твоему current_level». Оставляем только проверку прогресса выше.
|
||||
# (Проверка не твоя-не твоя была актуальна, когда были A1/A2/B1.)
|
||||
|
||||
# 🔧 ФИКС (25.09.2026): already_completed_detects_hint_row —
|
||||
# раньше already_completed = True при ЛЮБОЙ строке user_progress.
|
||||
# Но hints.py создаёт строку при подсказке (score=0,
|
||||
# completed_at=NULL) — это НЕ завершение. Тогда complete_level
|
||||
# считал уровень пройденным и НЕ обновлял last_completed_level.
|
||||
# Теперь: уже пройден только если completed_at IS NOT NULL
|
||||
# ИЛИ score > 0.
|
||||
existing_progress = await conn.fetchrow(
|
||||
"SELECT score FROM user_progress WHERE user_id = $1 AND level_id = $2",
|
||||
"SELECT score, completed_at FROM user_progress WHERE user_id = $1 AND level_id = $2",
|
||||
telegram_id, level_id
|
||||
)
|
||||
|
||||
if existing_progress:
|
||||
is_really_completed = (
|
||||
existing_progress is not None
|
||||
and (
|
||||
existing_progress["completed_at"] is not None
|
||||
or (existing_progress["score"] or 0) > 0
|
||||
)
|
||||
)
|
||||
|
||||
if is_really_completed:
|
||||
already_completed = True
|
||||
existing_score = existing_progress["score"]
|
||||
else:
|
||||
@@ -293,31 +417,104 @@ async def complete_level(request: Request):
|
||||
telegram_id, level_id
|
||||
) or 0
|
||||
|
||||
# 🔧 ФИКС (24.09.2026): client_controlled_hints_game —
|
||||
# читаем hints_used из БД, не доверяем клиенту.
|
||||
# 🔧 НОВОЕ (08.10.2026): XP-система.
|
||||
# Читаем hints_used и list_opened из БД (не доверяем клиенту).
|
||||
hints_used = await conn.fetchval(
|
||||
"SELECT hints_used FROM user_progress WHERE user_id = $1 AND level_id = $2",
|
||||
telegram_id, level_id
|
||||
) or 0
|
||||
hints_used = min(max(0, hints_used), 3)
|
||||
|
||||
score = max(10, 100 - hints_used * 10)
|
||||
|
||||
# 🔧 ФИКС (23.09.2026): client_controlled_achievement_values —
|
||||
# сбрасываем current_streak в 0 при завершении уровня.
|
||||
await conn.execute(
|
||||
"""INSERT INTO user_progress (user_id, level_id, completed_at, hints_used, score, level, current_streak)
|
||||
VALUES ($1, $2, NOW(), $3, $4, $5, 0)""",
|
||||
telegram_id, level_id, hints_used, score, level_name,
|
||||
# 🆕 Штрафы (филворд):
|
||||
# -20 за открытие списка слов (один раз за уровень)
|
||||
# -20 за каждую подсказку
|
||||
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 —
|
||||
# раньше INSERT падал с unique violation, если строка user_progress
|
||||
# уже была создана hints.py (юзер взял подсказку → уровень не завершится).
|
||||
# Теперь UPSERT с ON CONFLICT DO UPDATE.
|
||||
# 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("""
|
||||
INSERT INTO user_progress
|
||||
(user_id, level_id, completed_at, hints_used, score, level, current_streak, wave)
|
||||
VALUES ($1, $2, NOW(), $3, $4, $5, 0, $6)
|
||||
ON CONFLICT (user_id, level_id) DO UPDATE
|
||||
SET completed_at = NOW(),
|
||||
hints_used = $3,
|
||||
score = $4,
|
||||
level = $5,
|
||||
current_streak = 0,
|
||||
wave = $6
|
||||
""", telegram_id, level_id, hints_used, score, level_name, current_wave)
|
||||
|
||||
# Обновляем last_completed_level (максимальный номер пройденного уровня)
|
||||
await conn.execute(
|
||||
"""UPDATE users
|
||||
SET last_completed_level = GREATEST(last_completed_level, $2)
|
||||
WHERE telegram_id = $1""",
|
||||
telegram_id, current_level_number,
|
||||
)
|
||||
# 🔧 ОБНОВЛЕНО (07.10.2026): единый счётчик progress.
|
||||
# Обновляем только users.last_completed_level — глобальный.
|
||||
# last_completed_by_level (JSONB) остаётся в БД для совместимости,
|
||||
# но больше не пишется.
|
||||
await conn.execute("""
|
||||
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(
|
||||
@@ -343,6 +540,49 @@ async def complete_level(request: Request):
|
||||
) or 0
|
||||
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:
|
||||
return {
|
||||
@@ -377,9 +617,246 @@ async def complete_level(request: Request):
|
||||
ach = await check_and_award_achievements(telegram_id, "perfect_words", server_perfect_streak)
|
||||
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 {
|
||||
"status": "ok",
|
||||
"score": score,
|
||||
"status": "ok",
|
||||
"score": score,
|
||||
"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,
|
||||
}
|
||||
|
||||
+45
-48
@@ -1,3 +1,5 @@
|
||||
import random
|
||||
|
||||
from fastapi import APIRouter, Request, HTTPException
|
||||
from auth import require_auth
|
||||
from database import get_pool
|
||||
@@ -6,7 +8,7 @@ router = APIRouter(prefix="/hints", tags=["hints"])
|
||||
|
||||
|
||||
@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)
|
||||
|
||||
@@ -53,38 +55,47 @@ async def get_first_letter_hint(request: Request, level_id: int):
|
||||
import json
|
||||
word_paths = json.loads(word_paths)
|
||||
|
||||
# Находим первое слово, у которого есть путь
|
||||
# Слова уровня, у которых есть путь в word_paths
|
||||
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-слова)
|
||||
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:
|
||||
if not words_with_paths:
|
||||
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 —
|
||||
# инкрементим hints_used ТОЛЬКО после всех проверок.
|
||||
# Раньше при 404 (нет word_paths) подсказка уже была потрачена.
|
||||
if progress:
|
||||
await conn.execute(
|
||||
"UPDATE user_progress SET hints_used = hints_used + 1 WHERE user_id = $1 AND level_id = $2",
|
||||
telegram_id, level_id
|
||||
)
|
||||
else:
|
||||
await conn.execute(
|
||||
"INSERT INTO user_progress (user_id, level_id, hints_used) VALUES ($1, $2, 1)",
|
||||
telegram_id, level_id
|
||||
)
|
||||
#
|
||||
# 🔧 ФИКС (25.09.2026): hints_used_never_incremented_actually —
|
||||
# раньше при отсутствии строки user_progress UPDATE затрагивал 0 строк,
|
||||
# и лимит 3 подсказки не работал для новых юзеров.
|
||||
# Теперь UPSERT: INSERT с ON CONFLICT DO UPDATE.
|
||||
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
|
||||
|
||||
return {
|
||||
@@ -114,7 +125,7 @@ async def get_word_list(request: Request, level_id: int):
|
||||
if not user_exists:
|
||||
raise HTTPException(401, "User not registered")
|
||||
|
||||
# Получаем прогресс пользователя
|
||||
# Получаем прогресс пользователя (для информации в ответе)
|
||||
progress = await conn.fetchrow(
|
||||
"SELECT hints_used FROM user_progress WHERE user_id = $1 AND level_id = $2",
|
||||
telegram_id, level_id
|
||||
@@ -122,14 +133,11 @@ async def get_word_list(request: Request, level_id: int):
|
||||
|
||||
hints_already_used = progress["hints_used"] if progress else 0
|
||||
|
||||
# 🔧 ФИКС (23.09.2026): hints_not_incremented — лимит 3 подсказки не работал,
|
||||
# hints_used никогда не рос. Теперь проверяем лимит и инкрементим в той же транзакции.
|
||||
MAX_HINTS = 3
|
||||
if hints_already_used >= MAX_HINTS:
|
||||
raise HTTPException(403, "Hint limit reached")
|
||||
|
||||
# 🔧 ФИКС (25.09.2026): word_list_hint_consumed_on_empty —
|
||||
# сначала получаем слова, проверяем что они есть, только потом инкрементим.
|
||||
# 🔧 ФИКС (01.10.2026): word_list_is_not_hint —
|
||||
# «Показать слова» — базовая функция (в UI написано ∞),
|
||||
# НЕ расходует лимит подсказок и НЕ уменьшает очки.
|
||||
# Раньше зря инкрементился hints_used → минус 10 очков за уровень.
|
||||
# Лимит 3 остаётся ТОЛЬКО для «Первой буквы».
|
||||
words = await conn.fetch(
|
||||
"SELECT * FROM level_words WHERE level_id = $1 ORDER BY word_pl", level_id
|
||||
)
|
||||
@@ -137,18 +145,7 @@ async def get_word_list(request: Request, level_id: int):
|
||||
if not words:
|
||||
raise HTTPException(404, "No words found for this level")
|
||||
|
||||
# Теперь безопасно инкрементим счётчик
|
||||
if progress:
|
||||
await conn.execute(
|
||||
"UPDATE user_progress SET hints_used = hints_used + 1 WHERE user_id = $1 AND level_id = $2",
|
||||
telegram_id, level_id
|
||||
)
|
||||
else:
|
||||
await conn.execute(
|
||||
"INSERT INTO user_progress (user_id, level_id, hints_used) VALUES ($1, $2, 1)",
|
||||
telegram_id, level_id
|
||||
)
|
||||
hints_already_used += 1
|
||||
# hints_used НЕ инкрементим. hints_already_used читаем из БД для информации.
|
||||
|
||||
# Определяем язык пользователя
|
||||
user = await conn.fetchrow(
|
||||
@@ -199,4 +196,4 @@ async def get_remaining_hints(request: Request, level_id: int):
|
||||
"max_hints": max_hints,
|
||||
"hints_used": hints_used,
|
||||
"remaining": remaining,
|
||||
}
|
||||
}
|
||||
|
||||
+171
-101
@@ -10,7 +10,18 @@ LEVELS = ["A1", "A2", "B1", "B2", "C1", "C2"]
|
||||
|
||||
@router.get("")
|
||||
async def get_leaderboard(request: Request, limit: int = 50):
|
||||
"""Рейтинг игроков — быстрое чтение из кэша"""
|
||||
"""
|
||||
Рейтинг игроков.
|
||||
|
||||
🔧 ОБНОВЛЕНО (08.10.2026): XP-фундамент.
|
||||
|
||||
Сортировка: total_xp DESC → total_score DESC.
|
||||
weekly_xp в БД остаётся, но больше НЕ используется в сортировке.
|
||||
Legacy-поля (total_score, wordsearch_score, ...) сохранены для Mini App.
|
||||
|
||||
Новые поля в каждой строке: total_xp, level, rank_key, rank_name,
|
||||
xp_in_level, xp_needed, avatar_id.
|
||||
"""
|
||||
telegram_id, _ = await require_auth(request)
|
||||
|
||||
if limit < 1:
|
||||
@@ -28,17 +39,39 @@ async def get_leaderboard(request: Request, limit: int = 50):
|
||||
|
||||
current_level = user["current_level"] or "A1"
|
||||
|
||||
# Быстрое чтение из MATERIALIZED VIEW
|
||||
# 🆕 Топ-N: matview + LEFT JOIN user_profile для XP.
|
||||
# 🔧 ОБНОВЛЕНО (08.10.2026): сортировка по total_xp (weekly_xp убран).
|
||||
rows = await conn.fetch("""
|
||||
SELECT * FROM leaderboard_cache
|
||||
ORDER BY total_score DESC
|
||||
SELECT
|
||||
lc.*,
|
||||
COALESCE(p.weekly_xp, 0) AS weekly_xp,
|
||||
COALESCE(p.total_xp, 0) AS total_xp,
|
||||
COALESCE(p.avatar_id, 0) AS avatar_id,
|
||||
u.app_language
|
||||
FROM leaderboard_cache lc
|
||||
LEFT JOIN user_profile p ON p.user_id = lc.telegram_id
|
||||
LEFT JOIN users u ON u.telegram_id = lc.telegram_id
|
||||
ORDER BY COALESCE(p.total_xp, 0) DESC,
|
||||
lc.total_score DESC,
|
||||
lc.telegram_id ASC
|
||||
LIMIT $1
|
||||
""", limit)
|
||||
|
||||
leaderboard = []
|
||||
for i, row in enumerate(rows):
|
||||
leaderboard.append({
|
||||
"rank": i + 1,
|
||||
# Импорт XP-хелперов
|
||||
from services.xp import level_for, rank_for
|
||||
|
||||
def _serialize_row(row, rank_num):
|
||||
"""Собирает строку рейтинга с legacy + XP-полями."""
|
||||
weekly_xp = int(row["weekly_xp"] or 0)
|
||||
total_xp = int(row["total_xp"] or 0)
|
||||
level, xp_in_level, xp_needed, rank_key = level_for(total_xp)
|
||||
lang = (row.get("app_language") or "ru").lower()
|
||||
if lang not in ("pl", "ru", "uk", "en"):
|
||||
lang = "ru"
|
||||
|
||||
return {
|
||||
# Legacy (Mini App)
|
||||
"rank": rank_num,
|
||||
"telegram_id": row["telegram_id"],
|
||||
"username": row["username"] or f"Player{row['telegram_id']}",
|
||||
"total_score": row["total_score"],
|
||||
@@ -50,100 +83,131 @@ async def get_leaderboard(request: Request, limit: int = 50):
|
||||
"bubble_levels_completed": row["bubble_levels_completed"],
|
||||
"levels_completed": 0,
|
||||
"sentences_completed": 0,
|
||||
})
|
||||
# 🆕 XP (Pleily)
|
||||
"weekly_xp": weekly_xp, # оставлен для legacy Mini App
|
||||
"total_xp": total_xp,
|
||||
"level": level,
|
||||
"rank_key": rank_key,
|
||||
"rank_name": rank_for(level, lang),
|
||||
"xp_in_level": xp_in_level,
|
||||
"xp_needed": xp_needed,
|
||||
"avatar_id": int(row["avatar_id"] or 0),
|
||||
"app_language": lang,
|
||||
}
|
||||
|
||||
# 🔧 ФИКС (25.09.2026): leaderboard_rank_wrong_for_uncached_user —
|
||||
# если пользователя нет в leaderboard_cache, подзапрос вернёт NULL,
|
||||
# и COUNT(*) + 1 = 1 (юзер видит себя первым, хотя у него 0 очков).
|
||||
# Теперь: если user нет в кэше — считаем его место по количеству
|
||||
# записей с total_score > 0 + 1 (в конец списка).
|
||||
my_total_in_cache = await conn.fetchval("""
|
||||
SELECT total_score FROM leaderboard_cache WHERE telegram_id = $1
|
||||
""", telegram_id)
|
||||
leaderboard = [
|
||||
_serialize_row(row, rank_num=i + 1)
|
||||
for i, row in enumerate(rows)
|
||||
]
|
||||
|
||||
if my_total_in_cache is None:
|
||||
# Пользователя нет в кэше — считаем по количеству с > 0
|
||||
user_rank = await conn.fetchval("""
|
||||
SELECT COUNT(*) + 1 FROM leaderboard_cache
|
||||
WHERE total_score > 0
|
||||
""") or 1
|
||||
else:
|
||||
user_rank = await conn.fetchval("""
|
||||
SELECT COUNT(*) + 1 FROM leaderboard_cache
|
||||
WHERE total_score > $1
|
||||
""", my_total_in_cache)
|
||||
|
||||
# Персональная статистика пользователя
|
||||
# ============ Мой ранг ============
|
||||
# Читаем мои XP + legacy-статистику.
|
||||
my_row = await conn.fetchrow("""
|
||||
SELECT * FROM leaderboard_cache WHERE telegram_id = $1
|
||||
SELECT
|
||||
lc.*,
|
||||
COALESCE(p.weekly_xp, 0) AS weekly_xp,
|
||||
COALESCE(p.total_xp, 0) AS total_xp,
|
||||
COALESCE(p.avatar_id, 0) AS avatar_id,
|
||||
u.app_language
|
||||
FROM leaderboard_cache lc
|
||||
LEFT JOIN user_profile p ON p.user_id = lc.telegram_id
|
||||
LEFT JOIN users u ON u.telegram_id = lc.telegram_id
|
||||
WHERE lc.telegram_id = $1
|
||||
""", telegram_id)
|
||||
|
||||
if my_row:
|
||||
# Если юзера нет в matview — пробуем только user_profile.
|
||||
if not my_row:
|
||||
my_profile = await conn.fetchrow("""
|
||||
SELECT
|
||||
p.weekly_xp, p.total_xp, p.avatar_id,
|
||||
u.username, u.app_language, u.current_level
|
||||
FROM user_profile p
|
||||
JOIN users u ON u.telegram_id = p.user_id
|
||||
WHERE p.user_id = $1
|
||||
""", telegram_id)
|
||||
|
||||
if my_profile:
|
||||
my_weekly_xp = int(my_profile["weekly_xp"] or 0)
|
||||
my_total_xp = int(my_profile["total_xp"] or 0)
|
||||
my_avatar_id = int(my_profile["avatar_id"] or 0)
|
||||
my_username = my_profile["username"]
|
||||
my_lang = (my_profile["app_language"] or "ru").lower()
|
||||
else:
|
||||
my_weekly_xp = 0
|
||||
my_total_xp = 0
|
||||
my_avatar_id = 0
|
||||
my_username = None
|
||||
my_lang = "ru"
|
||||
|
||||
# 🔧 ОБНОВЛЕНО (08.10.2026): место по total_xp (не weekly_xp).
|
||||
my_position = await conn.fetchval("""
|
||||
SELECT COUNT(*) + 1
|
||||
FROM user_profile
|
||||
WHERE total_xp > $1
|
||||
""", my_total_xp) or 1
|
||||
|
||||
# Legacy-статистика (для совместимости с Mini App)
|
||||
my_wordsearch = await conn.fetchval(
|
||||
"SELECT COALESCE(SUM(score), 0) FROM user_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
|
||||
telegram_id
|
||||
) or 0
|
||||
my_sentence = await conn.fetchval(
|
||||
"SELECT COALESCE(SUM(score), 0) FROM sentence_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
|
||||
telegram_id
|
||||
) or 0
|
||||
my_wordquiz = await conn.fetchval(
|
||||
"SELECT COALESCE(total_score, 0) FROM word_quiz_progress WHERE user_id = $1",
|
||||
telegram_id
|
||||
) or 0
|
||||
my_words_guessed = await conn.fetchval(
|
||||
"SELECT COALESCE(words_guessed, 0) FROM word_quiz_progress WHERE user_id = $1",
|
||||
telegram_id
|
||||
) or 0
|
||||
my_bubblewords = await conn.fetchval(
|
||||
"SELECT COALESCE(total_score, 0) FROM bubble_words_progress WHERE user_id = $1",
|
||||
telegram_id
|
||||
) or 0
|
||||
my_bubble_levels = await conn.fetchval(
|
||||
"SELECT COALESCE(levels_completed, 0) FROM bubble_words_progress WHERE user_id = $1",
|
||||
telegram_id
|
||||
) or 0
|
||||
my_total = my_wordsearch + my_sentence + my_wordquiz + my_bubblewords
|
||||
my_wordsearch_levels = 0
|
||||
my_sentences_completed = 0
|
||||
my_avatar_id_final = my_avatar_id
|
||||
my_username_final = my_username
|
||||
my_lang_final = my_lang
|
||||
else:
|
||||
my_weekly_xp = int(my_row["weekly_xp"] or 0)
|
||||
my_total_xp = int(my_row["total_xp"] or 0)
|
||||
my_avatar_id_final = int(my_row["avatar_id"] or 0)
|
||||
my_username_final = my_row["username"]
|
||||
my_lang_final = (my_row["app_language"] or "ru").lower()
|
||||
my_wordsearch = my_row["wordsearch_score"]
|
||||
my_sentence = my_row["sentence_score"]
|
||||
my_wordquiz = my_row["wordquiz_score"]
|
||||
my_words_guessed = my_row["words_guessed"]
|
||||
my_bubblewords = my_row["bubblewords_score"]
|
||||
my_bubble_levels = my_row["bubble_levels_completed"]
|
||||
else:
|
||||
my_wordsearch = 0
|
||||
my_sentence = 0
|
||||
my_wordquiz = 0
|
||||
my_words_guessed = 0
|
||||
my_bubblewords = 0
|
||||
my_bubble_levels = 0
|
||||
my_total = my_wordsearch + my_sentence + my_wordquiz + my_bubblewords
|
||||
|
||||
# Считаем НАПРЯМУЮ из основных таблиц
|
||||
my_wordsearch_levels = await conn.fetchval(
|
||||
"SELECT COUNT(DISTINCT level_id) FROM user_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
|
||||
telegram_id
|
||||
) or 0
|
||||
# 🔧 ОБНОВЛЕНО (08.10.2026): место по total_xp (не weekly_xp).
|
||||
my_position = await conn.fetchval("""
|
||||
SELECT COUNT(*) + 1
|
||||
FROM user_profile
|
||||
WHERE total_xp > $1
|
||||
""", my_total_xp) or 1
|
||||
|
||||
my_sentences_completed = await conn.fetchval(
|
||||
"SELECT COUNT(*) FROM sentence_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
|
||||
telegram_id
|
||||
) or 0
|
||||
|
||||
# Если пользователя нет в кэше — считаем очки из основных таблиц
|
||||
if not my_row:
|
||||
my_wordsearch = await conn.fetchval(
|
||||
"SELECT COALESCE(SUM(score), 0) FROM user_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
|
||||
my_wordsearch_levels = await conn.fetchval(
|
||||
"SELECT COUNT(DISTINCT level_id) FROM user_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
|
||||
telegram_id
|
||||
) or 0
|
||||
my_sentences_completed = await conn.fetchval(
|
||||
"SELECT COUNT(*) FROM sentence_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
|
||||
telegram_id
|
||||
) or 0
|
||||
|
||||
my_sentence = await conn.fetchval(
|
||||
"SELECT COALESCE(SUM(score), 0) FROM sentence_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
|
||||
telegram_id
|
||||
) or 0
|
||||
|
||||
my_wordquiz = await conn.fetchval(
|
||||
"SELECT COALESCE(total_score, 0) FROM word_quiz_progress WHERE user_id = $1",
|
||||
telegram_id
|
||||
) or 0
|
||||
|
||||
my_words_guessed = await conn.fetchval(
|
||||
"SELECT COALESCE(words_guessed, 0) FROM word_quiz_progress WHERE user_id = $1",
|
||||
telegram_id
|
||||
) or 0
|
||||
|
||||
my_bubblewords = await conn.fetchval(
|
||||
"SELECT COALESCE(total_score, 0) FROM bubble_words_progress WHERE user_id = $1",
|
||||
telegram_id
|
||||
) or 0
|
||||
|
||||
my_bubble_levels = await conn.fetchval(
|
||||
"SELECT COALESCE(levels_completed, 0) FROM bubble_words_progress WHERE user_id = $1",
|
||||
telegram_id
|
||||
) or 0
|
||||
|
||||
my_total = my_wordsearch + my_sentence + my_wordquiz + my_bubblewords
|
||||
my_position = user_rank or 1
|
||||
|
||||
# 🔧 ФИКС N+1 (19.09.2026): 48 запросов → 5.
|
||||
# Было: цикл по 6 уровням × 8 запросов = 48 round-trip к БД.
|
||||
# Стало: 5 агрегированных запросов + сборка level_stats в Python.
|
||||
|
||||
# 1. Справочники (не зависят от юзера) — одним запросом
|
||||
# ============ level_stats (legacy для Mini App) ============
|
||||
ref_row = await conn.fetchrow("""
|
||||
SELECT
|
||||
(SELECT COUNT(*) FROM levels WHERE level = 'A1') AS a1_levels,
|
||||
@@ -160,11 +224,8 @@ async def get_leaderboard(request: Request, limit: int = 50):
|
||||
(SELECT COUNT(*) FROM sentences WHERE level = 'C2') AS c2_sent
|
||||
""")
|
||||
|
||||
# 2. Очки и прогресс по всем уровням сразу — 4 запроса с GROUP BY
|
||||
ws_rows = await conn.fetch("""
|
||||
SELECT level,
|
||||
COALESCE(SUM(score), 0) AS score,
|
||||
COUNT(*) AS completed
|
||||
SELECT level, COALESCE(SUM(score), 0) AS score, COUNT(*) AS completed
|
||||
FROM user_progress
|
||||
WHERE user_id = $1 AND completed_at IS NOT NULL
|
||||
GROUP BY level
|
||||
@@ -172,9 +233,7 @@ async def get_leaderboard(request: Request, limit: int = 50):
|
||||
ws_by_level = {r["level"]: r for r in ws_rows}
|
||||
|
||||
s_rows = await conn.fetch("""
|
||||
SELECT level,
|
||||
COALESCE(SUM(score), 0) AS score,
|
||||
COUNT(*) AS completed
|
||||
SELECT level, COALESCE(SUM(score), 0) AS score, COUNT(*) AS completed
|
||||
FROM sentence_progress
|
||||
WHERE user_id = $1 AND completed_at IS NOT NULL
|
||||
GROUP BY level
|
||||
@@ -183,23 +242,19 @@ async def get_leaderboard(request: Request, limit: int = 50):
|
||||
|
||||
wq_rows = await conn.fetch("""
|
||||
SELECT level, COALESCE(total_score, 0) AS score
|
||||
FROM word_quiz_progress
|
||||
WHERE user_id = $1
|
||||
FROM word_quiz_progress WHERE user_id = $1
|
||||
""", telegram_id)
|
||||
wq_by_level = {r["level"]: r for r in wq_rows}
|
||||
|
||||
bw_rows = await conn.fetch("""
|
||||
SELECT level, COALESCE(total_score, 0) AS score
|
||||
FROM bubble_words_progress
|
||||
WHERE user_id = $1
|
||||
FROM bubble_words_progress WHERE user_id = $1
|
||||
""", telegram_id)
|
||||
bw_by_level = {r["level"]: r for r in bw_rows}
|
||||
|
||||
# 3. Собираем level_stats в Python — без единого запроса
|
||||
level_stats = {}
|
||||
for lvl in LEVELS:
|
||||
lvl_lower = lvl.lower()
|
||||
|
||||
ws_score = ws_by_level.get(lvl, {}).get("score", 0) or 0
|
||||
ws_completed = ws_by_level.get(lvl, {}).get("completed", 0) or 0
|
||||
s_score = s_by_level.get(lvl, {}).get("score", 0) or 0
|
||||
@@ -209,7 +264,6 @@ async def get_leaderboard(request: Request, limit: int = 50):
|
||||
|
||||
total_ws_levels = ref_row[f"{lvl_lower}_levels"] or 0
|
||||
total_sentences = ref_row[f"{lvl_lower}_sent"] or 0
|
||||
|
||||
total_items = total_ws_levels + total_sentences
|
||||
completed_items = ws_completed + s_completed
|
||||
progress_percent = round((completed_items / total_items * 100), 1) if total_items > 0 else 0
|
||||
@@ -223,15 +277,20 @@ async def get_leaderboard(request: Request, limit: int = 50):
|
||||
"bubblewords_score": bw_score,
|
||||
}
|
||||
|
||||
# 🔧 ИСПРАВЛЕНО: вызов достижений ВНЕ блока async with pool.acquire()
|
||||
# Достижения
|
||||
from routers.achievements import check_and_award_achievements
|
||||
if my_position <= 3:
|
||||
await check_and_award_achievements(telegram_id, "rank_reached", my_position)
|
||||
|
||||
# ============ Мой ранг (XP) ============
|
||||
my_level, my_xp_in_level, my_xp_needed, my_rank_key = level_for(my_total_xp)
|
||||
my_rank_name = rank_for(my_level, my_lang_final)
|
||||
|
||||
return {
|
||||
"leaderboard": leaderboard,
|
||||
"current_level": current_level,
|
||||
"my_rank": {
|
||||
# Legacy
|
||||
"rank": my_position,
|
||||
"telegram_id": telegram_id,
|
||||
"total_score": my_total,
|
||||
@@ -243,6 +302,17 @@ async def get_leaderboard(request: Request, limit: int = 50):
|
||||
"words_guessed": my_words_guessed,
|
||||
"bubblewords_score": my_bubblewords,
|
||||
"bubble_levels_completed": my_bubble_levels,
|
||||
# 🆕 XP
|
||||
"username": my_username_final,
|
||||
"weekly_xp": my_weekly_xp, # оставлен для legacy Mini App
|
||||
"total_xp": my_total_xp,
|
||||
"level": my_level,
|
||||
"rank_key": my_rank_key,
|
||||
"rank_name": my_rank_name,
|
||||
"xp_in_level": my_xp_in_level,
|
||||
"xp_needed": my_xp_needed,
|
||||
"avatar_id": my_avatar_id_final,
|
||||
"app_language": my_lang_final,
|
||||
},
|
||||
"level_stats": level_stats,
|
||||
}
|
||||
|
||||
+360
-53
@@ -13,7 +13,6 @@ from fastapi import APIRouter, Request, HTTPException
|
||||
from auth import require_auth
|
||||
from database import get_pool
|
||||
from config import TOGETHER_API_KEY
|
||||
from .learning_data import init_learning_data
|
||||
from .learning_profile import get_weak_skills, get_strong_skills
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
@@ -21,7 +20,7 @@ logger = logging.getLogger(__name__)
|
||||
router = APIRouter(prefix="/learning", tags=["learning"])
|
||||
|
||||
TOGETHER_API_URL = "https://api.together.xyz/v1/chat/completions"
|
||||
ANALYTICS_MODEL = "MiniMaxAI/MiniMax-M3"
|
||||
ANALYTICS_MODEL = "deepseek-ai/DeepSeek-V4-Pro-0813"
|
||||
|
||||
# Доступные функции приложения (для AI — чтобы не галлюцинировал)
|
||||
AVAILABLE_FEATURES = [
|
||||
@@ -444,12 +443,41 @@ async def get_learning_levels(request: Request):
|
||||
|
||||
@router.get("/topics")
|
||||
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()
|
||||
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)
|
||||
return {"topics": [dict(row) for row in rows]}
|
||||
# Определяем track из app_language юзера
|
||||
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}")
|
||||
@@ -574,6 +602,18 @@ async def start_session(request: Request):
|
||||
|
||||
pool = await get_pool()
|
||||
async with pool.acquire() as conn:
|
||||
# 🔧 ФИКС (25.09.2026): hardcoded_a1_level_from_client —
|
||||
# клиент присылает 'A1' хардкодом (LessonViewPage, TestViewPage).
|
||||
# Сервер должен сам достать level_code из темы, а не доверять клиенту.
|
||||
# Если тема не найдена (например, practice без topic_id) — оставляем
|
||||
# клиентский level_code как fallback.
|
||||
if topic_id:
|
||||
real_level = await conn.fetchval("""
|
||||
SELECT level_code FROM learning_topics WHERE topic_id = $1
|
||||
""", topic_id)
|
||||
if real_level:
|
||||
level_code = real_level
|
||||
|
||||
row = await conn.fetchrow("""
|
||||
INSERT INTO learning_sessions (user_id, level_code, topic_id, session_type)
|
||||
VALUES ($1, $2, $3, $4) RETURNING id
|
||||
@@ -582,9 +622,29 @@ async def start_session(request: Request):
|
||||
return {"session_id": row["id"]}
|
||||
|
||||
|
||||
# 🔧 ОБНОВЛЕНО (02.10.2026): attempt_number + revised —
|
||||
# если ученик отвечает на вопрос повторно (после «Повторить урок»),
|
||||
# создаётся НОВАЯ запись с attempt_number+1, revised=TRUE,
|
||||
# revision_of_id=предыдущий ответ. История сохраняется полностью.
|
||||
@router.post("/answer")
|
||||
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)
|
||||
body = await request.json()
|
||||
session_id = body.get("session_id")
|
||||
@@ -592,20 +652,39 @@ async def save_answer(request: Request):
|
||||
selected_answer = body.get("answer", "")
|
||||
time_taken_ms = body.get("time_taken_ms", 0)
|
||||
is_final = body.get("is_final_answer", True)
|
||||
# 🔧 ФИКС (22.09.2026): раньше hint_used был захардкожен False,
|
||||
# поэтому подсказки не попадали в аналитику (hint_dependency всегда 0).
|
||||
hint_used = body.get("hint_used", False)
|
||||
# 🔧 НОВОЕ: клиент сообщает, что это повторная попытка
|
||||
is_retry = body.get("is_retry", False)
|
||||
|
||||
if not session_id or not question_id:
|
||||
raise HTTPException(400, "session_id and question_id required")
|
||||
|
||||
pool = await get_pool()
|
||||
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:
|
||||
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
|
||||
if not correct:
|
||||
@@ -616,58 +695,212 @@ async def save_answer(request: Request):
|
||||
if option:
|
||||
wrong_because = option["wrong_because"]
|
||||
|
||||
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 + проверка владельца сессии.
|
||||
session = await conn.fetchrow(
|
||||
"SELECT * FROM learning_sessions WHERE id = $1", session_id
|
||||
)
|
||||
if not session:
|
||||
raise HTTPException(404, "Session not found")
|
||||
if session["user_id"] != telegram_id:
|
||||
raise HTTPException(403, "Session belongs to another user")
|
||||
|
||||
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, hint_used, wrong_because, is_final_answer)
|
||||
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)
|
||||
# 🔧 Логика revised: если это повторная попытка — фиксируем
|
||||
revised = is_retry or next_attempt > 1
|
||||
|
||||
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")
|
||||
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)
|
||||
body = await request.json()
|
||||
session_id = body.get("session_id")
|
||||
# 🔧 НОВОЕ: язык для формирования отчёта
|
||||
lang = body.get("lang", "ru")
|
||||
|
||||
pool = await get_pool()
|
||||
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:
|
||||
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("""
|
||||
SELECT COUNT(*) as total, COALESCE(SUM(CASE WHEN correct THEN 1 ELSE 0 END), 0) as correct_count
|
||||
FROM user_learning_answers WHERE session_id = $1 AND is_final_answer = TRUE
|
||||
""", session_id)
|
||||
# 🔧 Считаем только ПОСЛЕДНИЕ (is_final_answer=TRUE) ответы на каждый вопрос
|
||||
stats = await conn.fetchrow(
|
||||
"""
|
||||
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_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":
|
||||
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)
|
||||
|
||||
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,
|
||||
)
|
||||
if lesson_row and lesson_row["lesson_id"]:
|
||||
lesson_id = lesson_row["lesson_id"]
|
||||
score = (stats["correct_count"] / stats["total"] * 100) if stats["total"] > 0 else 0
|
||||
|
||||
await conn.execute("""
|
||||
INSERT INTO user_lesson_progress (user_id, lesson_id, started_at, completed_at, attempts_count, correct_count, best_score, completed)
|
||||
score = (
|
||||
stats["correct_count"] / stats["total"] * 100
|
||||
) if stats["total"] > 0 else 0
|
||||
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)
|
||||
ON CONFLICT (user_id, lesson_id) DO UPDATE
|
||||
SET completed_at = NOW(),
|
||||
@@ -675,37 +908,111 @@ async def complete_session(request: Request):
|
||||
correct_count = user_lesson_progress.correct_count + $3,
|
||||
best_score = GREATEST(user_lesson_progress.best_score, $4),
|
||||
completed = TRUE
|
||||
""", telegram_id, lesson_id, stats["correct_count"], score)
|
||||
""",
|
||||
telegram_id, lesson_id, stats["correct_count"], score,
|
||||
)
|
||||
|
||||
# Обновляем прогресс темы если это тест
|
||||
if session["session_type"] == "topic_test":
|
||||
test_score = (stats["correct_count"] / stats["total"] * 100) if stats["total"] > 0 else 0
|
||||
|
||||
await conn.execute("""
|
||||
INSERT INTO user_topic_progress (user_id, topic_id, test_started, test_completed, test_score, completed_at)
|
||||
test_score = (
|
||||
stats["correct_count"] / stats["total"] * 100
|
||||
) if stats["total"] > 0 else 0
|
||||
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())
|
||||
ON CONFLICT (user_id, topic_id) DO UPDATE
|
||||
SET test_completed = TRUE,
|
||||
test_score = $3,
|
||||
completed_at = NOW()
|
||||
""", telegram_id, topic_id, test_score)
|
||||
""",
|
||||
telegram_id, topic_id, test_score,
|
||||
)
|
||||
|
||||
# Обновляем мастерство по всем навыкам из этой сессии
|
||||
skill_tags = await conn.fetch("""
|
||||
SELECT DISTINCT skill_tag FROM user_learning_answers WHERE session_id = $1
|
||||
""", session_id)
|
||||
|
||||
skill_tags = await conn.fetch(
|
||||
"SELECT DISTINCT skill_tag FROM user_learning_answers WHERE session_id = $1",
|
||||
session_id,
|
||||
)
|
||||
for st in skill_tags:
|
||||
await update_skill_mastery(conn, telegram_id, st["skill_tag"])
|
||||
|
||||
# Обновляем прогресс темы ТОЛЬКО для lesson и topic_test
|
||||
if session["session_type"] in ("lesson", "topic_test") and topic_id:
|
||||
await update_topic_progress(conn, telegram_id, topic_id)
|
||||
|
||||
# Обновляем AI-контекст (всегда)
|
||||
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")
|
||||
@@ -808,7 +1115,7 @@ async def get_analytics(request: Request):
|
||||
{"role": "system", "content": system_prompt},
|
||||
{"role": "user", "content": user_prompt},
|
||||
],
|
||||
"max_tokens": 1000,
|
||||
"max_tokens": 3000,
|
||||
"temperature": 0.7,
|
||||
},
|
||||
)
|
||||
|
||||
@@ -1,8 +1,27 @@
|
||||
"""
|
||||
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 os
|
||||
|
||||
from database import get_pool
|
||||
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():
|
||||
"""Инициализирует уровни и все темы"""
|
||||
"""Инициализирует уровни и (опционально) контент из файлов."""
|
||||
pool = await get_pool()
|
||||
async with pool.acquire() as conn:
|
||||
# ============ УРОВНИ ============
|
||||
# ============ УРОВНИ (всегда, они статичны) ============
|
||||
levels = [
|
||||
("A1", "Poziom A1", "Уровень A1", "Рівень A1", "Level A1", 1),
|
||||
("A2", "Poziom A2", "Уровень A2", "Рівень A2", "Level A2", 2),
|
||||
@@ -29,7 +48,29 @@ async def init_learning_data():
|
||||
ON CONFLICT (code) DO NOTHING
|
||||
""", 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_a2.init_level_a2(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_c2.init_level_c2(conn)
|
||||
|
||||
logger.info("Learning data fully initialized")
|
||||
logger.info("[seed] Learning content initialized from files")
|
||||
@@ -0,0 +1,390 @@
|
||||
"""
|
||||
Lectures Router — упрощённая версия.
|
||||
|
||||
Логика:
|
||||
- Лекция = файл (PDF/HTML) + уровень + язык.
|
||||
- Показывается пользователю, если:
|
||||
- level_code == users.current_level
|
||||
- lecture_language == users.app_language
|
||||
- Название = имя файла (без расширения).
|
||||
"""
|
||||
import io
|
||||
import logging
|
||||
import uuid
|
||||
from pathlib import Path
|
||||
from typing import Optional
|
||||
|
||||
from fastapi import APIRouter, Request, HTTPException, UploadFile, File, Form
|
||||
from fastapi.responses import FileResponse
|
||||
|
||||
from auth import require_auth
|
||||
from database import get_pool
|
||||
from config import ADMIN_IDS, UPLOADS_DIR
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
router = APIRouter(tags=["lectures"])
|
||||
|
||||
LEVELS = ["A1", "A2", "B1", "B2", "C1", "C2"]
|
||||
LANGUAGES = ["pl", "ru", "uk", "en"]
|
||||
ALLOWED_FILE_TYPES = {"pdf", "html", "docx", "txt", "md"}
|
||||
MAX_FILE_SIZE_BYTES = 20 * 1024 * 1024
|
||||
|
||||
|
||||
def _require_admin(telegram_id: int) -> None:
|
||||
if telegram_id not in ADMIN_IDS:
|
||||
raise HTTPException(403, "Access denied")
|
||||
|
||||
|
||||
def _ext_from_filename(filename: str) -> str:
|
||||
return filename.rsplit(".", 1)[-1].lower() if "." in filename else ""
|
||||
|
||||
|
||||
def _title_from_filename(filename: str) -> str:
|
||||
"""Убирает расширение + заменяет _ на пробелы."""
|
||||
name = filename.rsplit(".", 1)[0] if "." in filename else filename
|
||||
return name.replace("_", " ").strip()
|
||||
|
||||
|
||||
def _extract_pdf_preview(content: bytes, max_lines: int = 15) -> str:
|
||||
"""Извлекает первые строки текста из PDF."""
|
||||
try:
|
||||
import pdfplumber
|
||||
with pdfplumber.open(io.BytesIO(content)) as pdf:
|
||||
if not pdf.pages:
|
||||
return "(PDF без страниц)"
|
||||
text = pdf.pages[0].extract_text() or ""
|
||||
lines = [line for line in text.split("\n") if line.strip()][:max_lines]
|
||||
return "\n".join(lines)
|
||||
except ImportError:
|
||||
return "(pdfplumber не установлен на сервере)"
|
||||
except Exception as e:
|
||||
logger.error(f"PDF preview error: {e}")
|
||||
return f"(не удалось извлечь текст: {e})"
|
||||
|
||||
|
||||
def _extract_text_preview(content: bytes, max_chars: int = 800) -> str:
|
||||
"""Извлекает первые символы из HTML/TXT/MD."""
|
||||
try:
|
||||
text = content.decode("utf-8", errors="ignore")
|
||||
return text[:max_chars]
|
||||
except Exception as e:
|
||||
return f"(не удалось прочитать: {e})"
|
||||
|
||||
|
||||
# ============ ПУБЛИЧНЫЕ ============
|
||||
|
||||
@router.get("/learning/lectures")
|
||||
async def get_lectures(request: Request, level: Optional[str] = None):
|
||||
"""Список лекций для уровня пользователя + его языка."""
|
||||
telegram_id, _ = await require_auth(request)
|
||||
|
||||
pool = await get_pool()
|
||||
async with pool.acquire() as conn:
|
||||
user = await conn.fetchrow(
|
||||
"SELECT current_level, app_language FROM users WHERE telegram_id = $1",
|
||||
telegram_id,
|
||||
)
|
||||
|
||||
if not level or level not in LEVELS:
|
||||
level = (user["current_level"] if user else None) or "A1"
|
||||
if level not in LEVELS:
|
||||
level = "A1"
|
||||
|
||||
user_lang = (user["app_language"] if user else None) or "ru"
|
||||
if user_lang not in LANGUAGES:
|
||||
user_lang = "ru"
|
||||
|
||||
rows = await conn.fetch("""
|
||||
SELECT id, level_code, lecture_language,
|
||||
file_path, file_type, file_size_bytes,
|
||||
order_number, created_at
|
||||
FROM lectures
|
||||
WHERE level_code = $1
|
||||
AND lecture_language = $2
|
||||
AND is_active = TRUE
|
||||
ORDER BY order_number ASC, id ASC
|
||||
""", level, user_lang)
|
||||
|
||||
return {
|
||||
"level": level,
|
||||
"language": user_lang,
|
||||
"lectures": [
|
||||
{
|
||||
"id": r["id"],
|
||||
"level_code": r["level_code"],
|
||||
"lecture_language": r["lecture_language"],
|
||||
"title": _title_from_filename(Path(r["file_path"]).name),
|
||||
"file_type": r["file_type"],
|
||||
"file_size_kb": round((r["file_size_bytes"] or 0) / 1024, 1),
|
||||
"file_url": r["file_path"],
|
||||
"order_number": r["order_number"],
|
||||
"created_at": r["created_at"].isoformat() if r["created_at"] else None,
|
||||
}
|
||||
for r in rows
|
||||
],
|
||||
}
|
||||
|
||||
|
||||
@router.get("/learning/lecture/{lecture_id}")
|
||||
async def get_lecture(request: Request, lecture_id: int):
|
||||
"""Метаданные одной лекции."""
|
||||
await require_auth(request)
|
||||
|
||||
pool = await get_pool()
|
||||
async with pool.acquire() as conn:
|
||||
row = await conn.fetchrow("""
|
||||
SELECT id, level_code, lecture_language,
|
||||
file_path, file_type, file_size_bytes, order_number
|
||||
FROM lectures
|
||||
WHERE id = $1 AND is_active = TRUE
|
||||
""", lecture_id)
|
||||
|
||||
if not row:
|
||||
raise HTTPException(404, "Lecture not found")
|
||||
|
||||
return {
|
||||
"id": row["id"],
|
||||
"level_code": row["level_code"],
|
||||
"lecture_language": row["lecture_language"],
|
||||
"title": _title_from_filename(Path(row["file_path"]).name),
|
||||
"file_type": row["file_type"],
|
||||
"file_size_kb": round((row["file_size_bytes"] or 0) / 1024, 1),
|
||||
"file_url": row["file_path"],
|
||||
"order_number": row["order_number"],
|
||||
}
|
||||
|
||||
|
||||
@router.get("/learning/lecture/{lecture_id}/download")
|
||||
async def download_lecture(request: Request, lecture_id: int):
|
||||
"""Скачать файл лекции."""
|
||||
await require_auth(request)
|
||||
|
||||
pool = await get_pool()
|
||||
async with pool.acquire() as conn:
|
||||
row = await conn.fetchrow("""
|
||||
SELECT file_path, file_type
|
||||
FROM lectures
|
||||
WHERE id = $1 AND is_active = TRUE
|
||||
""", lecture_id)
|
||||
|
||||
if not row:
|
||||
raise HTTPException(404, "Lecture not found")
|
||||
|
||||
rel_path = row["file_path"].replace("/uploads/", "", 1).lstrip("/")
|
||||
abs_path = Path(UPLOADS_DIR) / rel_path
|
||||
|
||||
if not abs_path.exists():
|
||||
raise HTTPException(404, "File not found on disk")
|
||||
|
||||
return FileResponse(
|
||||
path=str(abs_path),
|
||||
filename=Path(row["file_path"]).name,
|
||||
media_type="application/octet-stream",
|
||||
)
|
||||
|
||||
|
||||
# ============ АДМИНСКИЕ ============
|
||||
|
||||
@router.get("/admin/lectures/list")
|
||||
async def admin_list_lectures(
|
||||
request: Request,
|
||||
level: Optional[str] = None,
|
||||
lecture_language: Optional[str] = None,
|
||||
):
|
||||
"""Список всех лекций для админки."""
|
||||
telegram_id, _ = await require_auth(request)
|
||||
_require_admin(telegram_id)
|
||||
|
||||
pool = await get_pool()
|
||||
async with pool.acquire() as conn:
|
||||
conditions = ["is_active = TRUE"]
|
||||
params = []
|
||||
idx = 1
|
||||
|
||||
if level and level in LEVELS:
|
||||
conditions.append(f"level_code = ${idx}")
|
||||
params.append(level)
|
||||
idx += 1
|
||||
|
||||
if lecture_language and lecture_language in LANGUAGES:
|
||||
conditions.append(f"lecture_language = ${idx}")
|
||||
params.append(lecture_language)
|
||||
idx += 1
|
||||
|
||||
where = " AND ".join(conditions)
|
||||
|
||||
rows = await conn.fetch(f"""
|
||||
SELECT id, level_code, lecture_language,
|
||||
file_path, file_type, file_size_bytes, order_number, created_at
|
||||
FROM lectures
|
||||
WHERE {where}
|
||||
ORDER BY level_code, order_number, id
|
||||
""", *params)
|
||||
|
||||
return {
|
||||
"total": len(rows),
|
||||
"lectures": [
|
||||
{
|
||||
"id": r["id"],
|
||||
"level_code": r["level_code"],
|
||||
"lecture_language": r["lecture_language"],
|
||||
"title": _title_from_filename(Path(r["file_path"]).name),
|
||||
"file_type": r["file_type"],
|
||||
"file_size_kb": round((r["file_size_bytes"] or 0) / 1024, 1),
|
||||
"file_url": r["file_path"],
|
||||
"order_number": r["order_number"],
|
||||
"created_at": r["created_at"].isoformat() if r["created_at"] else None,
|
||||
}
|
||||
for r in rows
|
||||
],
|
||||
}
|
||||
|
||||
|
||||
@router.post("/admin/lectures/preview")
|
||||
async def admin_lecture_preview(
|
||||
request: Request,
|
||||
file: UploadFile = File(...),
|
||||
):
|
||||
"""Превью файла лекции — первые строки текста."""
|
||||
telegram_id, _ = await require_auth(request)
|
||||
_require_admin(telegram_id)
|
||||
|
||||
content = await file.read()
|
||||
if len(content) == 0:
|
||||
raise HTTPException(400, "Empty file")
|
||||
|
||||
ext = _ext_from_filename(file.filename or "")
|
||||
|
||||
if ext == "pdf":
|
||||
preview_text = _extract_pdf_preview(content)
|
||||
elif ext in ("html", "txt", "md"):
|
||||
preview_text = _extract_text_preview(content)
|
||||
else:
|
||||
preview_text = f"(превью недоступно для формата .{ext})"
|
||||
|
||||
return {
|
||||
"file_name": file.filename or "unknown",
|
||||
"file_type": ext,
|
||||
"file_size_kb": round(len(content) / 1024, 1),
|
||||
"preview": preview_text[:1500],
|
||||
}
|
||||
|
||||
|
||||
@router.post("/admin/lectures/upload")
|
||||
async def admin_upload_lecture(
|
||||
request: Request,
|
||||
level_code: str = Form(...),
|
||||
lecture_language: str = Form("ru"),
|
||||
order_number: int = Form(0),
|
||||
file: UploadFile = File(...),
|
||||
):
|
||||
"""Загрузить лекцию (файл + уровень + язык)."""
|
||||
telegram_id, _ = await require_auth(request)
|
||||
_require_admin(telegram_id)
|
||||
|
||||
if level_code not in LEVELS:
|
||||
raise HTTPException(400, f"Invalid level_code: {level_code}")
|
||||
if lecture_language not in LANGUAGES:
|
||||
raise HTTPException(400, f"Invalid lecture_language: {lecture_language}")
|
||||
|
||||
ext = _ext_from_filename(file.filename or "")
|
||||
if ext not in ALLOWED_FILE_TYPES:
|
||||
raise HTTPException(400, f"Invalid file type: {ext}")
|
||||
|
||||
content = await file.read()
|
||||
if len(content) == 0:
|
||||
raise HTTPException(400, "Empty file")
|
||||
if len(content) > MAX_FILE_SIZE_BYTES:
|
||||
raise HTTPException(400, f"File too large. Max: {MAX_FILE_SIZE_BYTES}")
|
||||
|
||||
lectures_dir = Path(UPLOADS_DIR) / "lectures"
|
||||
lectures_dir.mkdir(parents=True, exist_ok=True)
|
||||
|
||||
original_name = (file.filename or "lecture").rsplit(".", 1)[0]
|
||||
safe_name = "".join(c if c.isalnum() or c in "-_" else "_" for c in original_name)[:50]
|
||||
filename = f"{level_code}_{lecture_language}_{safe_name}_{uuid.uuid4().hex[:8]}.{ext}"
|
||||
file_path_disk = lectures_dir / filename
|
||||
file_path_disk.write_bytes(content)
|
||||
|
||||
public_path = f"/uploads/lectures/{filename}"
|
||||
|
||||
pool = await get_pool()
|
||||
async with pool.acquire() as conn:
|
||||
row = await conn.fetchrow("""
|
||||
INSERT INTO lectures
|
||||
(level_code, lecture_language, display_language,
|
||||
title_pl, file_path, file_type, file_size_bytes,
|
||||
order_number, is_active)
|
||||
VALUES ($1, $2, $2, $3, $4, $5, $6, $7, TRUE)
|
||||
RETURNING id
|
||||
""",
|
||||
level_code,
|
||||
lecture_language,
|
||||
_title_from_filename(file.filename or "lecture"),
|
||||
public_path,
|
||||
ext,
|
||||
len(content),
|
||||
order_number,
|
||||
)
|
||||
|
||||
logger.info(f"Lecture uploaded: #{row['id']} [{level_code}/{lecture_language}]")
|
||||
|
||||
return {"status": "ok", "lecture_id": row["id"]}
|
||||
|
||||
|
||||
@router.put("/admin/lectures/{lecture_id}")
|
||||
async def admin_update_lecture(request: Request, lecture_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 FROM lectures WHERE id = $1", lecture_id)
|
||||
if not existing:
|
||||
raise HTTPException(404, "Lecture not found")
|
||||
|
||||
await conn.execute("""
|
||||
UPDATE lectures
|
||||
SET lecture_language = COALESCE($1, lecture_language),
|
||||
display_language = COALESCE($1, display_language),
|
||||
order_number = COALESCE($2, order_number),
|
||||
is_active = COALESCE($3, is_active),
|
||||
edited_at = NOW()
|
||||
WHERE id = $4
|
||||
""",
|
||||
body.get("lecture_language"),
|
||||
body.get("order_number"),
|
||||
body.get("is_active"),
|
||||
lecture_id,
|
||||
)
|
||||
|
||||
return {"status": "ok", "lecture_id": lecture_id}
|
||||
|
||||
|
||||
@router.delete("/admin/lectures/{lecture_id}")
|
||||
async def admin_delete_lecture(request: Request, lecture_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 file_path FROM lectures WHERE id = $1", lecture_id)
|
||||
if not row:
|
||||
raise HTTPException(404, "Lecture not found")
|
||||
|
||||
await conn.execute("DELETE FROM lectures WHERE id = $1", lecture_id)
|
||||
|
||||
rel_path = row["file_path"].replace("/uploads/", "", 1).lstrip("/")
|
||||
abs_path = Path(UPLOADS_DIR) / rel_path
|
||||
try:
|
||||
if abs_path.exists():
|
||||
abs_path.unlink()
|
||||
except Exception as e:
|
||||
logger.error(f"Failed to delete file: {e}")
|
||||
|
||||
return {"status": "ok", "lecture_id": lecture_id}
|
||||
+70
-36
@@ -6,6 +6,9 @@ Orchestrator — мозг чат-учителя.
|
||||
3. Иначе → следующий урок по порядку
|
||||
|
||||
Никакого AI — только детерминированная логика.
|
||||
|
||||
🔧 ОБНОВЛЕНО (04.10.2026): track_filter —
|
||||
учитель уважает аудиторию юзера (pl / ru_uk / en).
|
||||
"""
|
||||
import logging
|
||||
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]:
|
||||
"""
|
||||
Выбирает следующий урок для пользователя.
|
||||
|
||||
|
||||
Возвращает:
|
||||
{
|
||||
"type": "new" | "review" | "test",
|
||||
@@ -24,13 +27,34 @@ async def get_next_lesson(conn, user_id: int) -> Dict[str, Any]:
|
||||
"reason": str,
|
||||
"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("""
|
||||
SELECT current_level FROM users WHERE telegram_id = $1
|
||||
""", 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 ============
|
||||
# Если есть навыки, которые давно не повторяли — повторяем их
|
||||
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
|
||||
LIMIT 1
|
||||
""", user_id)
|
||||
|
||||
|
||||
if overdue_skill:
|
||||
# 🔧 НОВОЕ (04.10.2026): track_filter_lesson — ищем урок по skill_tag
|
||||
# ТОЛЬКО в темах нужного track.
|
||||
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
|
||||
FROM learning_lessons l
|
||||
JOIN learning_topics t ON l.topic_id = t.topic_id
|
||||
WHERE l.skill_tag = $1
|
||||
AND l.is_active = TRUE
|
||||
AND t.track = $2
|
||||
ORDER BY l.order_number
|
||||
LIMIT 1
|
||||
""", overdue_skill["skill_tag"])
|
||||
|
||||
""", overdue_skill["skill_tag"], track)
|
||||
|
||||
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 {
|
||||
"type": "review",
|
||||
"lesson": dict(lesson),
|
||||
"reason": "overdue",
|
||||
"skill_tag": overdue_skill["skill_tag"],
|
||||
}
|
||||
|
||||
|
||||
# ============ ШАГ 2: Проверяем mastery < 75 ============
|
||||
weak_skill = await conn.fetchrow("""
|
||||
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
|
||||
LIMIT 1
|
||||
""", user_id)
|
||||
|
||||
|
||||
if weak_skill:
|
||||
# 🔧 НОВОЕ (04.10.2026): track_filter_lesson
|
||||
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
|
||||
FROM learning_lessons l
|
||||
JOIN learning_topics t ON l.topic_id = t.topic_id
|
||||
WHERE l.skill_tag = $1
|
||||
AND l.is_active = TRUE
|
||||
AND t.track = $2
|
||||
ORDER BY l.order_number
|
||||
LIMIT 1
|
||||
""", weak_skill["skill_tag"])
|
||||
|
||||
""", weak_skill["skill_tag"], track)
|
||||
|
||||
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 {
|
||||
"type": "review",
|
||||
"lesson": dict(lesson),
|
||||
"reason": "weak_mastery",
|
||||
"skill_tag": weak_skill["skill_tag"],
|
||||
}
|
||||
|
||||
|
||||
# ============ ШАГ 3: Проверяем, нужно ли пройти тест темы ============
|
||||
# Если пользователь завершил все уроки темы, но не прошёл тест
|
||||
# 🔧 НОВОЕ (04.10.2026): track_filter_test — только темы нужного track.
|
||||
topic_for_test = await conn.fetchrow("""
|
||||
SELECT tp.topic_id, tp.lessons_total, tp.lessons_completed, tp.test_completed
|
||||
FROM user_topic_progress tp
|
||||
JOIN learning_topics t ON tp.topic_id = t.topic_id
|
||||
WHERE tp.user_id = $1
|
||||
AND tp.lessons_completed >= tp.lessons_total
|
||||
AND tp.lessons_total > 0
|
||||
AND tp.test_completed = FALSE
|
||||
AND t.track = $2
|
||||
ORDER BY tp.topic_id
|
||||
LIMIT 1
|
||||
""", user_id)
|
||||
|
||||
""", user_id, track)
|
||||
|
||||
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 {
|
||||
"type": "test",
|
||||
"lesson": None,
|
||||
"reason": "topic_completed_no_test",
|
||||
"topic_id": topic_for_test["topic_id"],
|
||||
}
|
||||
|
||||
|
||||
# ============ ШАГ 4: Следующий урок по порядку ============
|
||||
# Находим первый непройденный урок в текущем уровне
|
||||
# 🔧 НОВОЕ (04.10.2026): track_filter_next — только уроки нужного track.
|
||||
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,
|
||||
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
|
||||
WHERE t.level_code = $1
|
||||
AND l.is_active = TRUE
|
||||
AND t.track = $3
|
||||
AND l.lesson_id NOT IN (
|
||||
SELECT lesson_id FROM user_lesson_progress
|
||||
WHERE user_id = $2 AND completed = TRUE
|
||||
)
|
||||
ORDER BY t.order_number, l.order_number
|
||||
LIMIT 1
|
||||
""", current_level, user_id)
|
||||
|
||||
""", current_level, user_id, track)
|
||||
|
||||
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 {
|
||||
"type": "new",
|
||||
"lesson": dict(next_lesson),
|
||||
"reason": "next_in_order",
|
||||
"skill_tag": next_lesson["skill_tag"],
|
||||
}
|
||||
|
||||
|
||||
# ============ ШАГ 5: Всё пройдено ============
|
||||
logger.info(f"Orchestrator: all completed for user={user_id}")
|
||||
logger.info(f"Orchestrator: all completed for user={user_id}, track={track}")
|
||||
return {
|
||||
"type": "completed",
|
||||
"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]]:
|
||||
"""Получает урок по ID со всеми данными: объяснение, примеры, вопросы."""
|
||||
|
||||
|
||||
lesson = await conn.fetchrow("""
|
||||
SELECT * FROM learning_lessons WHERE lesson_id = $1 AND is_active = TRUE
|
||||
""", lesson_id)
|
||||
|
||||
|
||||
if not lesson:
|
||||
return None
|
||||
|
||||
|
||||
examples = await conn.fetch("""
|
||||
SELECT * FROM lesson_examples WHERE lesson_id = $1 ORDER BY order_number
|
||||
""", lesson_id)
|
||||
|
||||
|
||||
questions = await conn.fetch("""
|
||||
SELECT * FROM learning_questions
|
||||
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:
|
||||
"""Получает только вопросы урока (без объяснения)."""
|
||||
|
||||
|
||||
questions = await conn.fetch("""
|
||||
SELECT * FROM learning_questions
|
||||
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:
|
||||
"""Получает вопросы финального теста по теме."""
|
||||
|
||||
|
||||
questions = await conn.fetch("""
|
||||
SELECT * FROM learning_questions
|
||||
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:
|
||||
"""Получает случайную реакцию из банка по типу."""
|
||||
|
||||
|
||||
row = await conn.fetchrow("""
|
||||
SELECT text_pl, text_ru, text_uk, text_en
|
||||
FROM teacher_reactions
|
||||
@@ -270,7 +304,7 @@ async def get_random_reaction(conn, reaction_type: str, lang: str) -> str:
|
||||
ORDER BY RANDOM()
|
||||
LIMIT 1
|
||||
""", reaction_type)
|
||||
|
||||
|
||||
if not row:
|
||||
# Запасные реакции, если таблица пуста
|
||||
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")
|
||||
|
||||
|
||||
field = f"text_{lang}"
|
||||
return row.get(field) or row.get("text_en") or "OK"
|
||||
|
||||
|
||||
async def get_wrong_because_explanation(conn, wrong_because: str, lang: str) -> str:
|
||||
"""Получает объяснение ошибки по тегу wrong_because."""
|
||||
|
||||
|
||||
row = await conn.fetchrow("""
|
||||
SELECT explanation_pl, explanation_ru, explanation_uk, explanation_en
|
||||
FROM wrong_because_explanations
|
||||
WHERE wrong_because = $1
|
||||
""", wrong_because)
|
||||
|
||||
|
||||
if not row:
|
||||
return ""
|
||||
|
||||
|
||||
field = f"explanation_{lang}"
|
||||
return row.get(field) or row.get("explanation_en") or ""
|
||||
@@ -1,4 +1,3 @@
|
||||
import random
|
||||
from fastapi import APIRouter, Request, HTTPException
|
||||
from auth import require_auth
|
||||
from database import get_pool
|
||||
@@ -21,14 +20,19 @@ async def get_next_word(request: Request):
|
||||
|
||||
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("""
|
||||
SELECT word_pl, translation_ru, translation_uk, translation_en, level
|
||||
FROM (
|
||||
SELECT DISTINCT ON (word_pl) word_pl, translation_ru, translation_uk, translation_en, level
|
||||
FROM level_words
|
||||
WHERE level_id IS NULL
|
||||
) AS unique_words
|
||||
SELECT word_pl, translation_ru, translation_uk, translation_en,
|
||||
level_code AS level
|
||||
FROM csv_words
|
||||
ORDER BY RANDOM()
|
||||
LIMIT 1
|
||||
""")
|
||||
|
||||
+151
-67
@@ -7,39 +7,6 @@ from database import get_pool
|
||||
router = APIRouter(prefix="/sentences", tags=["sentences"])
|
||||
|
||||
|
||||
@router.get("/{sentence_id}/hint")
|
||||
async def get_sentence_hint(sentence_id: int, request: Request):
|
||||
"""Получить правильное предложение в качестве подсказки (одноразово)"""
|
||||
telegram_id, _ = await require_auth(request)
|
||||
|
||||
pool = await get_pool()
|
||||
async with pool.acquire() as conn:
|
||||
row = await conn.fetchrow(
|
||||
"SELECT sentence_pl FROM sentences WHERE id = $1", sentence_id
|
||||
)
|
||||
if not row:
|
||||
raise HTTPException(404, "Sentence not found")
|
||||
|
||||
# 🔧 ФИКС (24.09.2026): sentence_hint_no_limit — лимит 1 раз на предложение.
|
||||
already_used = await conn.fetchval(
|
||||
"SELECT 1 FROM sentence_hints_used WHERE user_id = $1 AND sentence_id = $2",
|
||||
telegram_id, sentence_id
|
||||
)
|
||||
if already_used:
|
||||
raise HTTPException(403, "Hint already used for this sentence")
|
||||
|
||||
# Записываем использование
|
||||
await conn.execute("""
|
||||
INSERT INTO sentence_hints_used (user_id, sentence_id)
|
||||
VALUES ($1, $2)
|
||||
ON CONFLICT (user_id, sentence_id) DO NOTHING
|
||||
""", telegram_id, sentence_id)
|
||||
|
||||
return {
|
||||
"sentence_pl": row["sentence_pl"],
|
||||
}
|
||||
|
||||
|
||||
def load_sentences_from_csv(filename):
|
||||
"""Загружает предложения из CSV файла (формат: polish,english,russian,ukrainian)."""
|
||||
sentences = []
|
||||
@@ -65,6 +32,7 @@ async def init_sentences():
|
||||
("B1", "sentences_b1.csv"),
|
||||
]
|
||||
|
||||
offset = 0
|
||||
for level, filename in level_files:
|
||||
sentences = load_sentences_from_csv(filename)
|
||||
for i, s in enumerate(sentences):
|
||||
@@ -74,11 +42,12 @@ async def init_sentences():
|
||||
await conn.execute(
|
||||
"""INSERT INTO sentences (sentence_number, sentence_pl, translation_ru, translation_uk, translation_en, difficulty, level)
|
||||
VALUES ($1, $2, $3, $4, $5, $6, $7)
|
||||
ON CONFLICT (level, sentence_number) DO NOTHING""",
|
||||
i + 1, s["sentence_pl"],
|
||||
ON CONFLICT (sentence_number) DO NOTHING""",
|
||||
offset + i + 1, s["sentence_pl"],
|
||||
s["translation_ru"], s["translation_uk"], s["translation_en"],
|
||||
difficulty, level
|
||||
)
|
||||
offset += len(sentences)
|
||||
|
||||
|
||||
def normalize_word_for_display(word: str) -> str:
|
||||
@@ -100,28 +69,34 @@ async def get_next_sentence(request: Request):
|
||||
pool = await get_pool()
|
||||
async with pool.acquire() as conn:
|
||||
user = await conn.fetchrow(
|
||||
"SELECT app_language, current_level FROM users WHERE telegram_id = $1", telegram_id
|
||||
"SELECT app_language, difficulty FROM users WHERE telegram_id = $1", telegram_id
|
||||
)
|
||||
if not user:
|
||||
raise HTTPException(401, "User not registered")
|
||||
|
||||
lang = user["app_language"] or "pl"
|
||||
current_level = user["current_level"] or "A1"
|
||||
difficulty = user["difficulty"] or "medium"
|
||||
|
||||
# Находим случайное непройденное предложение нужного уровня
|
||||
# Находим случайное непройденное предложение (единый пул)
|
||||
row = await conn.fetchrow("""
|
||||
SELECT s.* FROM sentences s
|
||||
WHERE s.level = $1
|
||||
AND s.id NOT IN (
|
||||
SELECT sentence_id FROM sentence_progress WHERE user_id = $2
|
||||
WHERE s.id NOT IN (
|
||||
SELECT sentence_id FROM sentence_progress WHERE user_id = $1 AND completed_at IS NOT NULL
|
||||
)
|
||||
ORDER BY RANDOM()
|
||||
LIMIT 1
|
||||
""", current_level, telegram_id)
|
||||
""", telegram_id)
|
||||
|
||||
if not row:
|
||||
return {"completed": True, "message": "All sentences completed!"}
|
||||
|
||||
# 🔧 НОВОЕ (16.10.2026): строка прогресса (in-progress) для счётчика list_opened.
|
||||
await conn.execute("""
|
||||
INSERT INTO sentence_progress (user_id, sentence_id, list_opened, completion_time)
|
||||
VALUES ($1, $2, 0, 0)
|
||||
ON CONFLICT (user_id, sentence_id) DO NOTHING
|
||||
""", telegram_id, row["id"])
|
||||
|
||||
# Оригинальные слова (для проверки)
|
||||
correct_words = row["sentence_pl"].split()
|
||||
|
||||
@@ -140,10 +115,64 @@ async def get_next_sentence(request: Request):
|
||||
"correct_words": display_words,
|
||||
"translation": translation,
|
||||
"difficulty": row["difficulty"],
|
||||
"user_difficulty": difficulty,
|
||||
"level": row["level"],
|
||||
}
|
||||
|
||||
|
||||
@router.post("/show-answer")
|
||||
async def show_answer(request: Request):
|
||||
"""Подсказка «показать предложение». Easy — ∞ бесплатно, Medium — 2 раза × −20, Hard — 403."""
|
||||
telegram_id, _ = await require_auth(request)
|
||||
body = await request.json()
|
||||
sentence_id = body.get("sentence_id")
|
||||
if not sentence_id:
|
||||
raise HTTPException(400, "sentence_id required")
|
||||
|
||||
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"
|
||||
|
||||
row = await conn.fetchrow(
|
||||
"SELECT sentence_pl FROM sentences WHERE id = $1", sentence_id
|
||||
)
|
||||
if not row:
|
||||
raise HTTPException(404, "Sentence not found")
|
||||
|
||||
if difficulty == "hard":
|
||||
raise HTTPException(403, "Hints are disabled on Hard difficulty")
|
||||
|
||||
progress = await conn.fetchrow(
|
||||
"SELECT list_opened FROM sentence_progress WHERE user_id = $1 AND sentence_id = $2",
|
||||
telegram_id, sentence_id
|
||||
)
|
||||
list_opened = (progress["list_opened"] if progress else 0) or 0
|
||||
|
||||
if difficulty == "medium":
|
||||
if list_opened >= 2:
|
||||
raise HTTPException(403, "Show answer limit reached on Medium difficulty")
|
||||
await conn.execute("""
|
||||
INSERT INTO sentence_progress (user_id, sentence_id, list_opened)
|
||||
VALUES ($1, $2, 1)
|
||||
ON CONFLICT (user_id, sentence_id) DO UPDATE
|
||||
SET list_opened = sentence_progress.list_opened + 1
|
||||
""", telegram_id, sentence_id)
|
||||
new_list_opened = list_opened + 1
|
||||
else:
|
||||
new_list_opened = list_opened # Easy — не инкрементим
|
||||
|
||||
return {
|
||||
"sentence_pl": row["sentence_pl"],
|
||||
"list_opened": new_list_opened,
|
||||
"max_list_opened": None if difficulty == "easy" else 2,
|
||||
}
|
||||
|
||||
|
||||
@router.post("/check")
|
||||
async def check_sentence(request: Request):
|
||||
"""Проверка предложения с защитой от повторного прохождения и выдачей достижений"""
|
||||
@@ -160,6 +189,8 @@ async def check_sentence(request: Request):
|
||||
raise HTTPException(400, "Too many words")
|
||||
|
||||
pool = await get_pool()
|
||||
# 🔧 НОВОЕ (08.10.2026): XP-система — результат award_xp.
|
||||
xp_result = None
|
||||
async with pool.acquire() as conn:
|
||||
user_exists = await conn.fetchval(
|
||||
"SELECT 1 FROM users WHERE telegram_id = $1", telegram_id
|
||||
@@ -174,7 +205,7 @@ async def check_sentence(request: Request):
|
||||
raise HTTPException(404, "Sentence not found")
|
||||
|
||||
existing_progress = await conn.fetchrow(
|
||||
"SELECT score, completed_at FROM sentence_progress WHERE user_id = $1 AND sentence_id = $2",
|
||||
"SELECT score, completed_at FROM sentence_progress WHERE user_id = $1 AND sentence_id = $2 AND completed_at IS NOT NULL",
|
||||
telegram_id, sentence_id
|
||||
)
|
||||
|
||||
@@ -206,20 +237,67 @@ async def check_sentence(request: Request):
|
||||
is_correct = user_words_normalized == correct_words_normalized
|
||||
|
||||
if is_correct:
|
||||
word_count = len(correct_words_original)
|
||||
if word_count <= 4:
|
||||
score = 50
|
||||
elif word_count <= 6:
|
||||
score = 75
|
||||
else:
|
||||
score = 100
|
||||
# 🔧 НОВОЕ (16.10.2026): очки по формуле сложностей.
|
||||
# Easy — фикс 20. Medium — 60 − 20×list_opened (мин 20).
|
||||
# Hard — 100, +50 бонус если completion_time <= 15 сек.
|
||||
wrong_checks = int(body.get("wrong_checks", 0) or 0)
|
||||
|
||||
user_row = await conn.fetchrow(
|
||||
"SELECT difficulty FROM users WHERE telegram_id = $1", telegram_id
|
||||
)
|
||||
difficulty = (user_row["difficulty"] if user_row else None) or "medium"
|
||||
|
||||
progress_row = await conn.fetchrow(
|
||||
"SELECT list_opened FROM sentence_progress WHERE user_id = $1 AND sentence_id = $2",
|
||||
telegram_id, sentence_id
|
||||
)
|
||||
list_opened = (progress_row["list_opened"] if progress_row else 0) or 0
|
||||
|
||||
if difficulty == "easy":
|
||||
points = 20
|
||||
elif difficulty == "medium":
|
||||
points = max(20, 60 - 20 * list_opened)
|
||||
else: # hard
|
||||
points = 100
|
||||
if completion_time is not None and completion_time <= 15:
|
||||
points = 150
|
||||
|
||||
# Начисляем XP
|
||||
from services.xp import award_xp
|
||||
xp_result = await award_xp(conn, telegram_id, "sentence", points)
|
||||
score = xp_result["points"]
|
||||
|
||||
await conn.execute(
|
||||
"""INSERT INTO sentence_progress (user_id, sentence_id, completed_at, score, level)
|
||||
VALUES ($1, $2, NOW(), $3, $4)""",
|
||||
telegram_id, sentence_id, score, row["level"],
|
||||
"""INSERT INTO sentence_progress (user_id, sentence_id, completed_at, score, level, completion_time)
|
||||
VALUES ($1, $2, NOW(), $3, $4, $5)
|
||||
ON CONFLICT (user_id, sentence_id) DO UPDATE
|
||||
SET completed_at = NOW(), score = $3, level = $4, completion_time = $5""",
|
||||
telegram_id, sentence_id, score, row["level"], completion_time or 0,
|
||||
)
|
||||
|
||||
# 🔧 НОВОЕ (16.10.2026): серии в sentence_stats (PK user_id).
|
||||
await conn.execute("""
|
||||
INSERT INTO sentence_stats (user_id, total_score, no_mistakes_streak, perfect_streak, updated_at)
|
||||
VALUES ($1, $2,
|
||||
CASE WHEN $3 = 0 THEN 1 ELSE 0 END,
|
||||
CASE WHEN $3 = 0 AND $4 = 0 THEN 1 ELSE 0 END,
|
||||
NOW())
|
||||
ON CONFLICT (user_id) DO UPDATE
|
||||
SET total_score = sentence_stats.total_score + $2,
|
||||
no_mistakes_streak = CASE WHEN $3 = 0 THEN sentence_stats.no_mistakes_streak + 1 ELSE 0 END,
|
||||
perfect_streak = CASE WHEN $3 = 0 AND $4 = 0 THEN sentence_stats.perfect_streak + 1 ELSE 0 END,
|
||||
updated_at = NOW()
|
||||
""", telegram_id, score, wrong_checks, list_opened)
|
||||
|
||||
# 🔧 НОВОЕ (16.10.2026): читаем серии/очки для достижений.
|
||||
stats_row = await conn.fetchrow(
|
||||
"SELECT total_score, no_mistakes_streak, perfect_streak FROM sentence_stats WHERE user_id = $1",
|
||||
telegram_id
|
||||
)
|
||||
sentence_total_score = stats_row["total_score"] if stats_row else 0
|
||||
sentence_no_mistakes = stats_row["no_mistakes_streak"] if stats_row else 0
|
||||
sentence_perfect_streak = stats_row["perfect_streak"] if stats_row else 0
|
||||
|
||||
# 🔧 ФИКС (23.09.2026): achievements_nested_pool_acquire_sentences —
|
||||
# раньше check_and_award_achievements вызывался ВНУТРИ async with pool.acquire(),
|
||||
# что могло привести к дедлоку пула. Теперь собираем данные внутри блока,
|
||||
@@ -250,6 +328,9 @@ async def check_sentence(request: Request):
|
||||
achievements_to_check = [
|
||||
("sentences_completed", sentences_completed),
|
||||
("total_score", grand_total),
|
||||
("sentence_no_mistakes", sentence_no_mistakes),
|
||||
("sentence_perfect_streak", sentence_perfect_streak),
|
||||
("sentence_xp", sentence_total_score),
|
||||
]
|
||||
if completion_time is not None and completion_time > 0:
|
||||
achievements_to_check.append(("speed_sentence", int(completion_time)))
|
||||
@@ -267,7 +348,18 @@ async def check_sentence(request: Request):
|
||||
"correct_words": [normalize_word_for_display(w) for w in correct_words_original],
|
||||
"already_completed": False,
|
||||
"score": score,
|
||||
"new_achievements": new_achievements
|
||||
"new_achievements": new_achievements,
|
||||
# 🆕 XP
|
||||
"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 {
|
||||
@@ -285,21 +377,14 @@ async def get_sentence_stats(request: Request):
|
||||
|
||||
pool = await get_pool()
|
||||
async with pool.acquire() as conn:
|
||||
user = await conn.fetchrow(
|
||||
"SELECT current_level FROM users WHERE telegram_id = $1", telegram_id
|
||||
)
|
||||
current_level = user["current_level"] if user else "A1"
|
||||
|
||||
total = await conn.fetchval(
|
||||
"SELECT COUNT(*) FROM sentences WHERE level = $1", current_level
|
||||
)
|
||||
total = await conn.fetchval("SELECT COUNT(*) FROM sentences")
|
||||
completed = await conn.fetchval(
|
||||
"SELECT COUNT(*) FROM sentence_progress WHERE user_id = $1 AND level = $2",
|
||||
telegram_id, current_level
|
||||
"SELECT COUNT(*) FROM sentence_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
|
||||
telegram_id
|
||||
)
|
||||
total_score = await conn.fetchval(
|
||||
"SELECT COALESCE(SUM(score), 0) FROM sentence_progress WHERE user_id = $1 AND level = $2",
|
||||
telegram_id, current_level
|
||||
"SELECT COALESCE(SUM(score), 0) FROM sentence_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
|
||||
telegram_id
|
||||
)
|
||||
|
||||
return {
|
||||
@@ -308,5 +393,4 @@ async def get_sentence_stats(request: Request):
|
||||
"remaining": total - (completed or 0),
|
||||
"total_score": total_score or 0,
|
||||
"progress_percent": round(((completed or 0) / total * 100), 1) if total > 0 else 0,
|
||||
"level": current_level,
|
||||
}
|
||||
+5
-5
@@ -1,7 +1,7 @@
|
||||
"""
|
||||
Support Router — система поддержки пользователей.
|
||||
Пользователи пишут админу о багах, неточностях и предложениях.
|
||||
Админ отвечает. Обе стороны могут переводить сообщения через AI (MiniMax-M3).
|
||||
Админ отвечает. Обе стороны могут переводить сообщения через AI (DeepSeek V4 Pro).
|
||||
"""
|
||||
import logging
|
||||
import httpx
|
||||
@@ -16,11 +16,11 @@ logger = logging.getLogger(__name__)
|
||||
router = APIRouter(prefix="/support", tags=["support"])
|
||||
|
||||
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:
|
||||
"""Переводит текст через AI (MiniMax-M3)."""
|
||||
"""Переводит текст через AI (DeepSeek V4 Pro)."""
|
||||
if not TOGETHER_API_KEY:
|
||||
return ""
|
||||
|
||||
@@ -38,7 +38,7 @@ async def call_ai_translate(text: str, target_lang: str) -> str:
|
||||
{"role": "system", "content": f"Ты — переводчик. Переведи текст на язык: {target_lang}. Отвечай только переводом без пояснений. Не используй markdown."},
|
||||
{"role": "user", "content": text},
|
||||
],
|
||||
"max_tokens": 500,
|
||||
"max_tokens": 1500,
|
||||
"temperature": 0.3,
|
||||
},
|
||||
)
|
||||
@@ -334,7 +334,7 @@ async def get_unread_count(request: Request):
|
||||
@router.post("/translate")
|
||||
async def translate_message(request: Request):
|
||||
"""
|
||||
Перевод сообщения через AI (MiniMax-M3).
|
||||
Перевод сообщения через AI (DeepSeek V4 Pro).
|
||||
Доступно и пользователю, и админу.
|
||||
"""
|
||||
telegram_id, _ = await require_auth(request)
|
||||
|
||||
+42
-11
@@ -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 — гибридный чат-учитель.
|
||||
Контент из БД (бесплатно), AI только для реакций и пробелов.
|
||||
@@ -43,7 +53,7 @@ logger = logging.getLogger(__name__)
|
||||
router = APIRouter(prefix="/teacher", tags=["teacher"])
|
||||
|
||||
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
|
||||
|
||||
@@ -232,6 +242,11 @@ async def call_ai(prompt: str, system_prompt: str, max_tokens: int = 500) -> str
|
||||
],
|
||||
"max_tokens": max_tokens,
|
||||
"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"""Ты — Марек, учитель польского языка. Объясняй ошибки кратко и понятно.
|
||||
Отвечай на языке: {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:
|
||||
async with pool.acquire() as conn:
|
||||
@@ -376,7 +392,8 @@ EN_GRAMMAR: [грамматический разбор на английском
|
||||
|
||||
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 значения
|
||||
phrase_pl = "Lepiej późno niż wcale."
|
||||
@@ -705,6 +722,18 @@ async def teacher_answer(request: Request):
|
||||
SELECT * FROM question_options WHERE question_id = $1
|
||||
""", question_id)
|
||||
|
||||
# 🔧 ФИКС (25.09.2026): teacher_answer_missing_session_owner_check —
|
||||
# сессия грузилась без проверки владельца, и это позволяло атакующему
|
||||
# записать мусорные ответы в чужую сессию через save_answer_to_session
|
||||
# ДО того, как мы поймали IDOR. Теперь проверяем ВЛАДЕЛЬЦА СЕССИИ
|
||||
# ПЕРЕД любой записью в БД — fail fast, никаких побочных эффектов.
|
||||
session = await conn.fetchrow(
|
||||
"SELECT * FROM learning_sessions WHERE id = $1 AND user_id = $2",
|
||||
session_id, telegram_id
|
||||
)
|
||||
if not session:
|
||||
raise HTTPException(404, "Session not found or access denied")
|
||||
|
||||
correct_answer = question_row["correct_answer"] or ""
|
||||
is_correct = normalize_answer(selected_answer) == normalize_answer(correct_answer)
|
||||
|
||||
@@ -718,6 +747,8 @@ async def teacher_answer(request: Request):
|
||||
"question": dict(question_row),
|
||||
"options": [dict(o) for o in options],
|
||||
}
|
||||
|
||||
# Только теперь безопасно записываем ответ в user_learning_answers
|
||||
await save_answer_to_session(
|
||||
conn, telegram_id, session_id, question_data,
|
||||
selected_answer, is_correct, time_taken_ms
|
||||
@@ -734,10 +765,6 @@ async def teacher_answer(request: Request):
|
||||
if not is_correct and wrong_because:
|
||||
db_explanation = await get_wrong_because_explanation(conn, wrong_because, lang)
|
||||
|
||||
session = await conn.fetchrow("SELECT * FROM learning_sessions WHERE id = $1", session_id)
|
||||
if not session:
|
||||
raise HTTPException(404, "Session not found")
|
||||
|
||||
if session["session_type"] == "teacher_test":
|
||||
questions = await get_test_questions(conn, session["topic_id"])
|
||||
else:
|
||||
@@ -868,7 +895,8 @@ async def teacher_explain(request: Request):
|
||||
system_prompt = f"""Ты — учитель польского языка. Объясни материал простыми словами.
|
||||
Отвечай на языке: {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:
|
||||
async with pool.acquire() as conn:
|
||||
@@ -943,7 +971,8 @@ async def teacher_examples(request: Request):
|
||||
|
||||
Верни только 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:
|
||||
async with pool.acquire() as conn:
|
||||
@@ -1005,7 +1034,8 @@ async def teacher_free_message(request: Request):
|
||||
Ученик может спросить что угодно: объяснить тему, перевести фразу, дать пример.
|
||||
Отвечай кратко (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:
|
||||
async with pool.acquire() as conn:
|
||||
@@ -1102,7 +1132,8 @@ async def teacher_translate_to_polish(request: Request):
|
||||
system_prompt = f"""Ты — переводчик польского языка. Переведи текст на польский.
|
||||
Отвечай только переводом без пояснений. Не используй 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:
|
||||
async with pool.acquire() as conn:
|
||||
|
||||
@@ -3,7 +3,6 @@ Typing Router — раздел "Печать".
|
||||
Пользователь печатает польские предложения, система проверяет.
|
||||
Без AI — просто сравнение с правильным ответом из БД.
|
||||
"""
|
||||
import random
|
||||
from fastapi import APIRouter, Request, HTTPException
|
||||
from auth import require_auth
|
||||
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")
|
||||
async def set_level(request: Request):
|
||||
"""Устанавливает текущий уровень пользователя (A1, A2, B1, B2, C1, C2)"""
|
||||
@@ -103,4 +123,86 @@ async def set_level(request: Request):
|
||||
return {
|
||||
"status": "ok",
|
||||
"level": level,
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
# ============================================================
|
||||
# 🆕 (08.10.2026): профиль — ник + аватар
|
||||
# ============================================================
|
||||
|
||||
import re as _re
|
||||
|
||||
|
||||
_FORBIDDEN_WORDS = {
|
||||
"admin", "administrator", "root", "moderator", "mod",
|
||||
"pleily", "filwords", "support", "help", "system",
|
||||
"хуй", "пизда", "блядь", "сука", "ебать",
|
||||
"kurwa", "chuj", "pizda", "jebac",
|
||||
"fuck", "shit", "bitch", "ass",
|
||||
}
|
||||
|
||||
_NICKNAME_RE = _re.compile(r'^[\w\s\.\-]+$', flags=_re.UNICODE)
|
||||
|
||||
|
||||
def _clean_nickname(raw: str) -> str:
|
||||
if not raw:
|
||||
raise HTTPException(400, "Nickname is required")
|
||||
nick = raw.strip()
|
||||
if len(nick) < 2:
|
||||
raise HTTPException(400, "Nickname must be at least 2 characters")
|
||||
if len(nick) > 20:
|
||||
raise HTTPException(400, "Nickname must be at most 20 characters")
|
||||
lower = nick.lower()
|
||||
for bad in _FORBIDDEN_WORDS:
|
||||
if bad in lower:
|
||||
raise HTTPException(400, "Nickname contains forbidden words")
|
||||
if not _NICKNAME_RE.match(nick):
|
||||
raise HTTPException(400, "Nickname contains invalid characters")
|
||||
return nick
|
||||
|
||||
|
||||
@router.post("/set-nickname")
|
||||
async def set_nickname(request: Request):
|
||||
"""Сохранить ник пользователя. Body: {"nickname": "Oleg"}"""
|
||||
user_id, _ = await require_auth(request)
|
||||
body = await request.json()
|
||||
nickname = _clean_nickname(body.get("nickname", ""))
|
||||
|
||||
pool = await get_pool()
|
||||
async with pool.acquire() as conn:
|
||||
existing = await conn.fetchval(
|
||||
"SELECT user_id FROM user_profile WHERE nickname = $1 AND user_id != $2",
|
||||
nickname, user_id,
|
||||
)
|
||||
if existing:
|
||||
raise HTTPException(409, "Nickname already taken")
|
||||
|
||||
await conn.execute("""
|
||||
INSERT INTO user_profile (user_id, nickname, updated_at)
|
||||
VALUES ($1, $2, NOW())
|
||||
ON CONFLICT (user_id) DO UPDATE
|
||||
SET nickname = $2, updated_at = NOW()
|
||||
""", user_id, nickname)
|
||||
|
||||
return {"status": "ok", "nickname": nickname}
|
||||
|
||||
|
||||
@router.post("/set-avatar")
|
||||
async def set_avatar(request: Request):
|
||||
"""Сохранить аватар. Body: {"avatar_id": 3}"""
|
||||
user_id, _ = await require_auth(request)
|
||||
body = await request.json()
|
||||
avatar_id = body.get("avatar_id")
|
||||
if not isinstance(avatar_id, int) or avatar_id < 0 or avatar_id > 7:
|
||||
raise HTTPException(400, "avatar_id must be 0..7")
|
||||
|
||||
pool = await get_pool()
|
||||
async with pool.acquire() as conn:
|
||||
await conn.execute("""
|
||||
INSERT INTO user_profile (user_id, avatar_id, updated_at)
|
||||
VALUES ($1, $2, NOW())
|
||||
ON CONFLICT (user_id) DO UPDATE
|
||||
SET avatar_id = $2, updated_at = NOW()
|
||||
""", user_id, avatar_id)
|
||||
|
||||
return {"status": "ok", "avatar_id": avatar_id}
|
||||
+135
-75
@@ -14,7 +14,7 @@ async def get_next_quiz(request: Request):
|
||||
pool = await get_pool()
|
||||
async with pool.acquire() as conn:
|
||||
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:
|
||||
raise HTTPException(401, "User not registered")
|
||||
@@ -22,6 +22,12 @@ async def get_next_quiz(request: Request):
|
||||
lang = user["app_language"] or "pl"
|
||||
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(
|
||||
"SELECT words_guessed, recent_words FROM word_quiz_progress WHERE user_id = $1",
|
||||
telegram_id
|
||||
@@ -32,23 +38,20 @@ async def get_next_quiz(request: Request):
|
||||
async def pick_word(exclude, respect_exclude=True):
|
||||
if respect_exclude and 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"""
|
||||
SELECT word_pl, translation_ru, translation_uk, translation_en
|
||||
FROM (
|
||||
SELECT DISTINCT ON (word_pl) word_pl, translation_ru, translation_uk, translation_en
|
||||
FROM level_words
|
||||
WHERE level = $1 AND level_id IS NULL AND word_pl NOT IN ({placeholders})
|
||||
) AS unique_words
|
||||
FROM csv_words
|
||||
WHERE level_code = $1 AND word_pl NOT IN ({placeholders})
|
||||
ORDER BY RANDOM()
|
||||
LIMIT 1
|
||||
""", current_level, *exclude)
|
||||
return await conn.fetchrow("""
|
||||
SELECT word_pl, translation_ru, translation_uk, translation_en
|
||||
FROM (
|
||||
SELECT DISTINCT ON (word_pl) word_pl, translation_ru, translation_uk, translation_en
|
||||
FROM level_words
|
||||
WHERE level = $1 AND level_id IS NULL
|
||||
) AS unique_words
|
||||
FROM csv_words
|
||||
WHERE level_code = $1
|
||||
ORDER BY RANDOM()
|
||||
LIMIT 1
|
||||
""", current_level)
|
||||
@@ -67,25 +70,21 @@ async def get_next_quiz(request: Request):
|
||||
# Ищем неправильные варианты
|
||||
exclude_for_wrong = recent_words + [correct_polish]
|
||||
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"""
|
||||
SELECT word_pl
|
||||
FROM (
|
||||
SELECT DISTINCT ON (word_pl) word_pl
|
||||
FROM level_words
|
||||
WHERE level = $1 AND level_id IS NULL AND word_pl != $2 AND word_pl NOT IN ({placeholders})
|
||||
) AS unique_wrong
|
||||
FROM csv_words
|
||||
WHERE level_code = $1 AND word_pl != $2 AND word_pl NOT IN ({placeholders})
|
||||
ORDER BY RANDOM()
|
||||
LIMIT 5
|
||||
""", 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("""
|
||||
SELECT word_pl
|
||||
FROM (
|
||||
SELECT DISTINCT ON (word_pl) word_pl
|
||||
FROM level_words
|
||||
WHERE level = $1 AND level_id IS NULL AND word_pl != $2
|
||||
) AS unique_wrong
|
||||
FROM csv_words
|
||||
WHERE level_code = $1 AND word_pl != $2
|
||||
ORDER BY RANDOM()
|
||||
LIMIT 5
|
||||
""", current_level, correct_polish)
|
||||
@@ -97,7 +96,7 @@ async def get_next_quiz(request: Request):
|
||||
if wl not in seen:
|
||||
wrong_options.append(w["word_pl"])
|
||||
seen.add(wl)
|
||||
if len(wrong_options) >= 2:
|
||||
if len(wrong_options) >= wrong_count:
|
||||
break
|
||||
|
||||
recent_words = recent_words + [correct_polish] + wrong_options
|
||||
@@ -114,38 +113,39 @@ async def get_next_quiz(request: Request):
|
||||
options = wrong_options + [correct_polish]
|
||||
random.shuffle(options)
|
||||
|
||||
if total_guessed <= 10:
|
||||
difficulty = "easy"
|
||||
elif total_guessed <= 30:
|
||||
difficulty = "medium"
|
||||
elif total_guessed <= 60:
|
||||
difficulty = "hard"
|
||||
else:
|
||||
difficulty = "expert"
|
||||
time_limit = 10 if difficulty == "hard" else None
|
||||
|
||||
return {
|
||||
"correct_polish": correct_polish,
|
||||
"translation": translation,
|
||||
"options": options,
|
||||
"difficulty": difficulty,
|
||||
"time_limit": time_limit,
|
||||
}
|
||||
|
||||
|
||||
@router.post("/check")
|
||||
async def check_quiz_answer(request: Request):
|
||||
"""Проверяет ответ, начисляет очки и проверяет достижения"""
|
||||
"""Проверяет ответ, начисляет XP и проверяет достижения.
|
||||
|
||||
🔧 НОВОЕ (08.10.2026): XP-система + серии.
|
||||
Штрафы:
|
||||
-1 за каждый неверный выбор (макс 3)
|
||||
-1 если time_ms > 30 сек
|
||||
Минимум 1 звезда.
|
||||
Серия: correct_streak (best_streak хранится в choose_progress).
|
||||
"""
|
||||
telegram_id, _ = await require_auth(request)
|
||||
body = await request.json()
|
||||
correct_polish = body.get("correct_polish", "")
|
||||
user_answer = body.get("answer", "")
|
||||
completion_time = body.get("completion_time")
|
||||
# 🔧 ФИКС (24.09.2026): client_controlled_mistakes_wordquiz —
|
||||
# mistakes больше НЕ берём от клиента. Считаем на сервере.
|
||||
# 🆕 wrong_count приходит с клиента для UI, но мы считаем на сервере
|
||||
# 🔧 ФИКС: current_mistakes — серверный счётчик
|
||||
|
||||
if not correct_polish or not user_answer:
|
||||
raise HTTPException(400, "correct_polish and answer required")
|
||||
|
||||
# Защита от читерства: минимальное время 1 секунда
|
||||
if completion_time is not None and completion_time < 1:
|
||||
return {
|
||||
"correct": False,
|
||||
@@ -154,25 +154,38 @@ async def check_quiz_answer(request: Request):
|
||||
}
|
||||
|
||||
is_correct = user_answer.strip().lower() == correct_polish.strip().lower()
|
||||
|
||||
|
||||
pool = await get_pool()
|
||||
async with pool.acquire() as conn:
|
||||
# Проверка языка
|
||||
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(
|
||||
"SELECT correct_streak FROM word_quiz_progress WHERE user_id = $1",
|
||||
telegram_id
|
||||
) or 0
|
||||
# 🔧 ФИКС (24.09.2026): client_controlled_mistakes_wordquiz —
|
||||
# читаем серверный current_mistakes.
|
||||
mistakes = await conn.fetchval(
|
||||
"SELECT current_mistakes FROM word_quiz_progress WHERE user_id = $1",
|
||||
telegram_id
|
||||
) or 0
|
||||
|
||||
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:
|
||||
current_streak += 1
|
||||
else:
|
||||
current_streak = 0
|
||||
# 🔧 Инкрементим mistakes на сервере
|
||||
await conn.execute("""
|
||||
INSERT INTO word_quiz_progress (user_id, current_mistakes)
|
||||
VALUES ($1, 1)
|
||||
@@ -180,59 +193,83 @@ async def check_quiz_answer(request: Request):
|
||||
SET current_mistakes = word_quiz_progress.current_mistakes + 1
|
||||
""", telegram_id)
|
||||
mistakes += 1
|
||||
|
||||
|
||||
xp_result = None
|
||||
score = 0
|
||||
|
||||
if is_correct:
|
||||
score = max(10, 50 - (mistakes * 20))
|
||||
# 🔧 Сбрасываем mistakes при правильном ответе
|
||||
# 🆕 Фиксированные очки по сложности (ChooseWord)
|
||||
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("""
|
||||
UPDATE word_quiz_progress SET current_mistakes = 0 WHERE user_id = $1
|
||||
""", telegram_id)
|
||||
|
||||
|
||||
await conn.execute("""
|
||||
INSERT INTO word_quiz_progress (user_id, words_guessed, total_score, correct_streak)
|
||||
VALUES ($1, 1, $2, $3)
|
||||
INSERT INTO word_quiz_progress (user_id, words_guessed, total_score, correct_streak, no_mistakes_streak)
|
||||
VALUES ($1, 1, $2, $3, $4)
|
||||
ON CONFLICT (user_id) DO UPDATE
|
||||
SET words_guessed = word_quiz_progress.words_guessed + 1,
|
||||
total_score = word_quiz_progress.total_score + $2,
|
||||
correct_streak = $3
|
||||
""", telegram_id, score, current_streak)
|
||||
|
||||
# 🔧 ФИКС (23.09.2026): achievements_nested_pool_acquire_wordquiz —
|
||||
# вызовы достижений вынесены за async with pool.acquire() (паттерн game.py).
|
||||
correct_streak = $3,
|
||||
no_mistakes_streak = $4
|
||||
""", telegram_id, score, current_streak, no_mistakes_streak)
|
||||
|
||||
# 🆕 Обновляем best_streak в choose_progress
|
||||
await conn.execute("""
|
||||
INSERT INTO choose_progress (user_id, current_streak, best_streak)
|
||||
VALUES ($1, $2, $2)
|
||||
ON CONFLICT (user_id) DO UPDATE
|
||||
SET current_streak = $2,
|
||||
best_streak = GREATEST(choose_progress.best_streak, $2),
|
||||
updated_at = NOW()
|
||||
""", telegram_id, current_streak)
|
||||
|
||||
# Собираем данные для достижений
|
||||
total_guessed = await conn.fetchval(
|
||||
"SELECT words_guessed FROM word_quiz_progress WHERE user_id = $1",
|
||||
telegram_id
|
||||
) or 0
|
||||
wordsearch_score = await conn.fetchval(
|
||||
"SELECT COALESCE(SUM(score), 0) FROM user_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
|
||||
telegram_id
|
||||
) or 0
|
||||
sentence_score = await conn.fetchval(
|
||||
"SELECT COALESCE(SUM(score), 0) FROM sentence_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
|
||||
telegram_id
|
||||
) or 0
|
||||
wordquiz_score = await conn.fetchval(
|
||||
"SELECT COALESCE(total_score, 0) FROM word_quiz_progress WHERE user_id = $1",
|
||||
telegram_id
|
||||
) or 0
|
||||
bubblewords_score = await conn.fetchval(
|
||||
"SELECT COALESCE(total_score, 0) FROM bubble_words_progress WHERE user_id = $1",
|
||||
telegram_id
|
||||
) or 0
|
||||
grand_total = wordsearch_score + sentence_score + wordquiz_score + bubblewords_score
|
||||
|
||||
achievements_to_check = [
|
||||
("quiz_guessed", total_guessed),
|
||||
("total_score", grand_total),
|
||||
("total_score", xp_result["total_xp"]),
|
||||
]
|
||||
if current_streak >= 10:
|
||||
achievements_to_check.append(("quiz_perfect_streak", current_streak))
|
||||
if current_streak >= 5:
|
||||
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:
|
||||
achievements_to_check.append(("quiz_no_mistakes", 1))
|
||||
if completion_time is not None and completion_time > 0 and int(completion_time) <= 3:
|
||||
achievements_to_check.append(("quiz_speed", 3))
|
||||
if completion_time is not None and 0 < completion_time <= 5:
|
||||
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:
|
||||
# При 3 ошибках — начисляем утешительные 10 очков
|
||||
# При 3 ошибках — утешительный XP (10)
|
||||
if mistakes >= 3:
|
||||
await conn.execute("""
|
||||
INSERT INTO word_quiz_progress (user_id, words_guessed, total_score, correct_streak, current_mistakes)
|
||||
@@ -249,7 +286,7 @@ async def check_quiz_answer(request: Request):
|
||||
SET correct_streak = $2
|
||||
""", telegram_id, current_streak)
|
||||
|
||||
# 🔧 ФИКС (23.09.2026): вызовы достижений ВНЕ блока async with pool.acquire()
|
||||
# Достижения — вне транзакции
|
||||
if is_correct:
|
||||
from routers.achievements import check_and_award_achievements
|
||||
new_achievements = []
|
||||
@@ -262,6 +299,19 @@ async def check_quiz_answer(request: Request):
|
||||
"score": score,
|
||||
"correct_streak": current_streak,
|
||||
"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 {
|
||||
@@ -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")
|
||||
async def get_quiz_progress(request: Request):
|
||||
"""Статистика пользователя в квизе"""
|
||||
|
||||
+306
-60
@@ -3,13 +3,74 @@
|
||||
AI Code Review for Filwords PL Backend (JSON-контракт + пак-подход)
|
||||
|
||||
Backend слишком большой (~440K символов) для одного запроса — модель уходит
|
||||
в reasoning и не успевает выдать JSON. Решение: разбиваем файлы на 3 пака
|
||||
в reasoning и не успевает выдать JSON. Решение: разбиваем файлы на паки
|
||||
по папкам, делаем отдельный запрос на каждый пак, объединяем находки.
|
||||
|
||||
(20.09.2026) Первая версия — конвейер без tool-calling, предсказуемо по токенам.
|
||||
(20.09.2026, вечер) Фикс: max_tokens=16000, fallback на reasoning_content.
|
||||
(21.09.2026, вечер) JSON-контракт + snippet-проверка + фильтр confidence.
|
||||
(22.09.2026, вечер) Пак-подход: 3 пака (routers, core, services+scripts).
|
||||
(25.09.2026) Разбивка routers на 4 пака, MAX_OUTPUT_TOKENS=32000.
|
||||
(25.09.2026, вечер) ФИКС root cause: DeepSeek-V4.1-Flash по умолчанию
|
||||
думает (reasoning), и на сложных паках весь max_tokens уходит в
|
||||
thinking — content пустой, finish=length, находки теряются.
|
||||
→ reasoning выключен явно ("reasoning": {"enabled": False}).
|
||||
→ fallback на reasoning_content убран (это была причина "Ошибка
|
||||
парсинга JSON": туда попадал сырой текст рассуждений, а не JSON).
|
||||
→ extract_json теперь спасает отдельные валидные находки, даже если
|
||||
ответ всё же обрежется по max_tokens — вместо потери пака целиком.
|
||||
(26.09.2026) ФИКС quality-first:
|
||||
→ MODEL: DeepSeek-V4.1-Flash → DeepSeek-V4-Pro-0813 (потом откат).
|
||||
→ MAX_OUTPUT_TOKENS: 32000 → 8000 (модель перестаёт писать "всё подряд").
|
||||
→ SYSTEM_PROMPT ужесточён: запрет "Ок"/"Не баг"/"Работает корректно",
|
||||
confidence >= 0.75, ТОП-10 по severity.
|
||||
→ validate_and_filter: overshoot guard — если находок > 15 на пак,
|
||||
берём только топ-10 по confidence (признак, что модель "потекла").
|
||||
(26.09.2026, вечер) ФИКС dual-model + split routers_learning:
|
||||
→ routers_learning (100k) разбит на 3 пака:
|
||||
routers_learning_core, routers_learning_teacher, routers_learning_orch.
|
||||
Это устраняет finish=length — модель успевает выдать JSON.
|
||||
→ Добавлена ВТОРАЯ модель (GLM 5.3) для пересечения находок:
|
||||
DeepSeek V4.1 Flash — основная, GLM 5.3 — вторая.
|
||||
Пересечение по (file, snippet) → confidence +0.05.
|
||||
→ Только primary → normal. Только secondary → normal.
|
||||
→ USE_SECONDARY_MODEL=True включает вторую модель.
|
||||
(26.09.2026, ночь) ФИКС reasoning-per-model + бюджет:
|
||||
→ MODEL_SECONDARY: zai-org/GLM-5.3 (флагман, $1.40/$4.40) →
|
||||
zai-org/GLM-5.3-Flash ($0.15/$0.50). Флагман почти не нужен для
|
||||
point-by-point code review, а стоит в ~9 раз дороже; на 2 репо
|
||||
(backend+frontend) дуал-модель с флагманом упирается в бюджет
|
||||
80 центов/аудит, с Flash — укладывается с большим запасом.
|
||||
→ ROOT CAUSE найден: "reasoning": {"enabled": False} НЕ работает
|
||||
на GLM-5.3 / GLM-5.3-Flash (документация Together: "Thinking
|
||||
cannot be disabled entirely on GLM-5.3"). Флаг тихо игнорировался,
|
||||
GLM продолжал думать, весь max_tokens уходил в reasoning_content,
|
||||
content оставался пустым → "Формат ответа: пусто" именно на
|
||||
GLM-паках. Это и была причина "не работает" у secondary модели.
|
||||
→ call_together_model теперь строит РАЗНЫЙ payload по семейству
|
||||
модели: DeepSeek → reasoning.enabled=False (это работает);
|
||||
GLM-5.3* → reasoning_effort="low" + увеличенный max_tokens
|
||||
(единственный доступный рычаг для GLM-5.3, thinking трейс
|
||||
частично остаётся, но сильно короче).
|
||||
→ Логируем длину reasoning_content (если есть) — видно, сколько
|
||||
токенов модель тратит на мысли до JSON-ответа.
|
||||
(27.09.2026) ФИКС secondary_empty_log:
|
||||
→ Симметрично с frontend: если GLM-5.3-Flash вернул пустой content
|
||||
для пака — пишем явно в stderr, чтобы видеть потери в логах,
|
||||
а не молча терять вклад второй модели.
|
||||
→ Паки не трогаем — routers_admin (97k) пока терпит, но если
|
||||
начнёт терять 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
|
||||
@@ -29,8 +90,20 @@ GITEA_BOT_TOKEN = os.environ.get("BOT_TOKEN")
|
||||
GITEA_INSTANCE = os.environ.get("GITEA_INSTANCE", "https://git.filwordspl.com")
|
||||
GITEA_REPO = os.environ.get("GITEA_REPO", "Drobysh/filwordspl-backend")
|
||||
|
||||
MODEL = "deepseek-ai/DeepSeek-V4.1-Flash"
|
||||
MAX_OUTPUT_TOKENS = 12000
|
||||
# 🔧 ФИКС (05.10.2026): single_model_v4_pro —
|
||||
# Отказались от dual-model (DeepSeek Flash + GLM Flash).
|
||||
# Причина: GLM добавлял мусор, Flash-версии ошибались на сложных файлах.
|
||||
# Теперь: только DeepSeek V4 Pro 0813 — флагман, reasoning, 1M контекст.
|
||||
# Один промпт → один ответ → один фильтр → меньше мусора.
|
||||
MODEL_PRIMARY = "deepseek-ai/DeepSeek-V4-Pro-0813"
|
||||
|
||||
USE_SECONDARY_MODEL = False
|
||||
|
||||
# V4 Pro: reasoning полностью НЕ отключается (тест 05.10.2026:
|
||||
# reasoning_effort="none" игнорируется, "low" даёт ~70 токенов).
|
||||
# max_tokens увеличен с 8000 до 16000 — reasoning (~80%) + JSON (~20%).
|
||||
MAX_OUTPUT_TOKENS = 16000
|
||||
REASONING_EFFORT = "low"
|
||||
|
||||
# Что игнорировать при сборе кода
|
||||
IGNORE_DIRS = {
|
||||
@@ -41,6 +114,7 @@ IGNORE_DIRS = {
|
||||
IGNORE_FILES = {
|
||||
"ai_review.py", "conftest.py", "code_summary.py",
|
||||
"add_levels.py", "generate_levels_v2.py",
|
||||
"__init__.py",
|
||||
}
|
||||
|
||||
# Расширения, которые читаем
|
||||
@@ -50,18 +124,71 @@ INCLUDE_EXTENSIONS = {".py"}
|
||||
MAX_FILE_SIZE = 100_000
|
||||
|
||||
# Фильтр находок
|
||||
MIN_CONFIDENCE = 0.7
|
||||
# 🔧 ФИКС (05.10.2026): filter_more_strict —
|
||||
# V4 Pro увереннее, но подняли порог с 0.75 до 0.80,
|
||||
# чтобы отсеять спорные находки.
|
||||
MIN_CONFIDENCE = 0.80
|
||||
ALLOWED_SEVERITY = {"user_impact", "data_risk", "maintainability"}
|
||||
|
||||
# 🔧 ФИКС (26.09.2026): overshoot guard.
|
||||
OVERSHOOT_LIMIT = 15
|
||||
OVERSHOOT_KEEP = 10
|
||||
|
||||
# 🔧 НОВОЕ (22.09.2026): паки для backend
|
||||
# Backend ~440K символов — не влезает в один запрос (finish=length).
|
||||
# Разбиваем на 3 пака. Каждый пак — отдельный запрос к модели.
|
||||
|
||||
# Паки для backend. Пути проверены по факту (`ls routers/`).
|
||||
PACKS = [
|
||||
{
|
||||
"name": "routers",
|
||||
"paths": ["routers/"],
|
||||
"description": "FastAPI-роутеры: эндпоинты, бизнес-логика, работа с БД",
|
||||
"name": "routers_games",
|
||||
"paths": [
|
||||
"routers/game.py",
|
||||
"routers/hints.py",
|
||||
"routers/wordquiz.py",
|
||||
"routers/bubblewords.py",
|
||||
"routers/sentences.py",
|
||||
"routers/typing.py",
|
||||
"routers/pronunciation.py",
|
||||
],
|
||||
"description": "Игры: wordsearch, hints, quiz, bubbles, sentences, typing, pronunciation",
|
||||
},
|
||||
{
|
||||
"name": "routers_learning_core",
|
||||
"paths": ["routers/learning.py"],
|
||||
"description": "Уроки: learning.py (эндпоинты + update_*)",
|
||||
},
|
||||
{
|
||||
"name": "routers_learning_teacher",
|
||||
"paths": ["routers/teacher.py"],
|
||||
"description": "Учитель: teacher.py",
|
||||
},
|
||||
{
|
||||
"name": "routers_learning_orch",
|
||||
"paths": [
|
||||
"routers/orchestrator.py",
|
||||
"routers/learning_profile.py",
|
||||
"routers/learning_data/",
|
||||
],
|
||||
"description": "Orchestrator + profile + learning_data",
|
||||
},
|
||||
{
|
||||
"name": "routers_admin",
|
||||
"paths": [
|
||||
"routers/admin.py",
|
||||
"routers/admin_content.py",
|
||||
"routers/feed.py",
|
||||
"routers/support.py",
|
||||
],
|
||||
"description": "Админ: dashboard, content editor, feed, support",
|
||||
},
|
||||
{
|
||||
"name": "routers_misc",
|
||||
"paths": [
|
||||
"routers/achievements.py",
|
||||
"routers/users.py",
|
||||
"routers/leaderboard.py",
|
||||
"routers/assistant.py",
|
||||
"routers/tts.py",
|
||||
],
|
||||
"description": "Прочее: achievements, users, leaderboard, assistant, tts",
|
||||
},
|
||||
{
|
||||
"name": "core",
|
||||
@@ -70,8 +197,8 @@ PACKS = [
|
||||
},
|
||||
{
|
||||
"name": "services",
|
||||
"paths": ["services/", "scripts/"],
|
||||
"description": "Сервисы и скрипты автоматизации",
|
||||
"paths": ["scripts/"],
|
||||
"description": "Скрипты автоматизации",
|
||||
},
|
||||
]
|
||||
|
||||
@@ -170,19 +297,21 @@ SYSTEM_PROMPT = """Ты — опытный техлид и ревьюер Python
|
||||
}
|
||||
]
|
||||
|
||||
ПРАВИЛА:
|
||||
ПРАВИЛА (соблюдай строго):
|
||||
1. severity — только одно из: "user_impact", "data_risk", "maintainability".
|
||||
- user_impact: ученик видит баг, теряет прогресс, очки, доступ
|
||||
- data_risk: порча БД, утечка, неверный auth/rate-limit
|
||||
- maintainability: запах, дубль, устаревший API
|
||||
2. snippet — ТОЧНАЯ цитата 1-3 строк из файла. Не перефразируй. Если не уверен — не включай находку.
|
||||
3. confidence — число от 0 до 1. Если меньше 0.7 — не включай.
|
||||
4. Максимум 10 находок за этот пак.
|
||||
5. НЕ переписывай код. Только описывай, что не так и что сделать.
|
||||
6. Без воды. Без общих слов.
|
||||
7. Если проблем нет — верни пустой массив: []
|
||||
3. confidence — число от 0 до 1. Если меньше 0.75 — НЕ включай.
|
||||
4. МАКСИМУМ 10 находок за этот пак. Если находишь больше — выбери ТОП-10 по severity (user_impact > data_risk > maintainability).
|
||||
5. НЕ пиши находки типа "Ок", "Не баг", "Работает корректно", "Не влияет на UX", "Не критично". Только РЕАЛЬНЫЕ проблемы.
|
||||
6. НЕ комментируй каждую функцию. Только баги, security, UX.
|
||||
7. НЕ переписывай код. Только описывай, что не так и что сделать.
|
||||
8. Без воды. Без общих слов.
|
||||
9. Если проблем нет — верни пустой массив: [].
|
||||
|
||||
Отвечай ТОЛЬКО JSON, без markdown-обёрток.
|
||||
Отвечай ТОЛЬКО JSON, без markdown-обёрток. Не думай вслух — сразу выдавай JSON-массив.
|
||||
"""
|
||||
|
||||
|
||||
@@ -192,15 +321,17 @@ USER_PROMPT_TEMPLATE = """Проанализируй часть кода про
|
||||
|
||||
Пак: **{pack_name}** — {pack_description}
|
||||
|
||||
Ищи:
|
||||
1. Баги и логические ошибки
|
||||
Ищи ТОЛЬКО реальные проблемы:
|
||||
1. Баги и логические ошибки (не "Ок", а "тут падает")
|
||||
2. Проблемы безопасности (утечки, инъекции, неправильная валидация)
|
||||
3. N+1 запросы к БД
|
||||
4. Отсутствие обработки ошибок
|
||||
4. Отсутствие обработки ошибок (где РЕАЛЬНО упадёт)
|
||||
5. Дублирование кода
|
||||
6. Мёртвый код
|
||||
7. Слабые места архитектуры
|
||||
|
||||
НЕ пиши "Ок", "Не баг", "Работает корректно". Если проблем нет — верни [].
|
||||
|
||||
Верни JSON-массив находок по формату выше.
|
||||
|
||||
Вот код:
|
||||
@@ -211,9 +342,14 @@ USER_PROMPT_TEMPLATE = """Проанализируй часть кода про
|
||||
|
||||
# ============ Запрос к Together AI ============
|
||||
|
||||
def call_together(code: str, pack: dict) -> str:
|
||||
"""Отправляет код пака в DeepSeek V4.1 Flash."""
|
||||
print(f" 🤖 Отправляю пак '{pack['name']}' в DeepSeek V4.1 Flash...")
|
||||
def call_together_model(code: str, pack: dict, model_name: str) -> str:
|
||||
"""Отправляет код пака в указанную модель.
|
||||
|
||||
🔧 ФИКС (05.10.2026): reasoning_effort_low —
|
||||
V4 Pro: reasoning_effort="none" игнорируется (тест 05.10.2026),
|
||||
"low" даёт минимальный reasoning.
|
||||
"""
|
||||
print(f" 🤖 Отправляю пак '{pack['name']}' в {model_name}...")
|
||||
|
||||
user_prompt = USER_PROMPT_TEMPLATE.format(
|
||||
pack_name=pack["name"],
|
||||
@@ -221,26 +357,32 @@ def call_together(code: str, pack: dict) -> str:
|
||||
code=code,
|
||||
)
|
||||
|
||||
payload = {
|
||||
"model": model_name,
|
||||
"messages": [
|
||||
{"role": "system", "content": SYSTEM_PROMPT},
|
||||
{"role": "user", "content": user_prompt},
|
||||
],
|
||||
"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,
|
||||
}
|
||||
|
||||
response = httpx.post(
|
||||
"https://api.together.xyz/v1/chat/completions",
|
||||
headers={
|
||||
"Authorization": f"Bearer {TOGETHER_API_KEY}",
|
||||
"Content-Type": "application/json",
|
||||
},
|
||||
json={
|
||||
"model": MODEL,
|
||||
"messages": [
|
||||
{"role": "system", "content": SYSTEM_PROMPT},
|
||||
{"role": "user", "content": user_prompt},
|
||||
],
|
||||
"max_tokens": MAX_OUTPUT_TOKENS,
|
||||
"temperature": 0.2,
|
||||
},
|
||||
json=payload,
|
||||
timeout=300.0,
|
||||
)
|
||||
|
||||
if response.status_code != 200:
|
||||
print(f" ❌ Together AI вернул {response.status_code}", file=sys.stderr)
|
||||
print(f" ❌ {model_name} вернул {response.status_code}", file=sys.stderr)
|
||||
print(f" Ответ: {response.text[:500]}", file=sys.stderr)
|
||||
return ""
|
||||
|
||||
@@ -250,27 +392,52 @@ def call_together(code: str, pack: dict) -> str:
|
||||
message = data["choices"][0]["message"]
|
||||
result = message.get("content")
|
||||
if not result:
|
||||
result = message.get("reasoning_content")
|
||||
if not result:
|
||||
raise KeyError("пусто")
|
||||
raise KeyError("пусто (content отсутствует)")
|
||||
except (KeyError, IndexError, TypeError) as e:
|
||||
print(f" ❌ Формат ответа: {e}", file=sys.stderr)
|
||||
# 🔧 ФИКС (26.09.2026, ночь): логируем длину reasoning-трейса,
|
||||
# чтобы видно было, сколько токенов ушло на "мысли" до отказа.
|
||||
reasoning_len = 0
|
||||
try:
|
||||
reasoning_len = len(
|
||||
data["choices"][0]["message"].get("reasoning_content") or ""
|
||||
)
|
||||
except Exception:
|
||||
pass
|
||||
print(f" ❌ Формат ответа: {e} (reasoning_content: {reasoning_len} символов)", file=sys.stderr)
|
||||
return ""
|
||||
|
||||
usage = data.get("usage", {})
|
||||
finish = data["choices"][0].get("finish_reason", "unknown")
|
||||
reasoning_len = len(data["choices"][0]["message"].get("reasoning_content") or "")
|
||||
print(
|
||||
f" ✅ Пак '{pack['name']}': вход={usage.get('prompt_tokens', 0)}, "
|
||||
f"выход={usage.get('completion_tokens', 0)}, finish={finish}"
|
||||
f" ✅ [{model_name.split('/')[-1]}] Пак '{pack['name']}': "
|
||||
f"вход={usage.get('prompt_tokens', 0)}, "
|
||||
f"выход={usage.get('completion_tokens', 0)}, "
|
||||
f"reasoning≈{reasoning_len} симв., finish={finish}"
|
||||
)
|
||||
if finish == "length":
|
||||
print(
|
||||
f" ⚠️ Пак '{pack['name']}' обрезан по max_tokens ({model_name})",
|
||||
file=sys.stderr,
|
||||
)
|
||||
|
||||
return result
|
||||
|
||||
|
||||
def call_together(code: str, pack: dict) -> str:
|
||||
"""Backward-compat: одна модель (primary)."""
|
||||
return call_together_model(code, pack, MODEL_PRIMARY)
|
||||
|
||||
|
||||
# ============ Парсинг и фильтрация JSON ============
|
||||
|
||||
def extract_json(text: str) -> list[dict]:
|
||||
"""Извлекает JSON-массив из ответа модели."""
|
||||
"""Извлекает находки из ответа модели.
|
||||
|
||||
Парсим объекты по одному (json.JSONDecoder.raw_decode) и
|
||||
останавливаемся на первом, который не удалось распарсить — то есть
|
||||
спасаем всё, что модель успела сгенерить до обрезки.
|
||||
"""
|
||||
if not text:
|
||||
return []
|
||||
text = text.strip()
|
||||
@@ -279,34 +446,107 @@ def extract_json(text: str) -> list[dict]:
|
||||
text = re.sub(r"\s*```$", "", text)
|
||||
|
||||
start = text.find("[")
|
||||
end = text.rfind("]")
|
||||
if start == -1 or end == -1 or end < start:
|
||||
if start == -1:
|
||||
print(f" ⚠️ Не найден JSON-массив. Первые 300 символов:\n{text[:300]}", file=sys.stderr)
|
||||
return []
|
||||
|
||||
json_str = text[start:end + 1]
|
||||
decoder = json.JSONDecoder()
|
||||
idx, n = start + 1, len(text)
|
||||
results: list[dict] = []
|
||||
|
||||
try:
|
||||
parsed = json.loads(json_str)
|
||||
if not isinstance(parsed, list):
|
||||
print(f" ⚠️ JSON не массив, а {type(parsed).__name__}", file=sys.stderr)
|
||||
return []
|
||||
return parsed
|
||||
except json.JSONDecodeError as e:
|
||||
print(f" ⚠️ Ошибка парсинга JSON: {e}", file=sys.stderr)
|
||||
return []
|
||||
while idx < n:
|
||||
while idx < n and text[idx] in " \t\n\r,":
|
||||
idx += 1
|
||||
if idx >= n or text[idx] == "]":
|
||||
break
|
||||
try:
|
||||
obj, end = decoder.raw_decode(text, idx)
|
||||
except json.JSONDecodeError:
|
||||
break
|
||||
if isinstance(obj, dict):
|
||||
results.append(obj)
|
||||
idx = end
|
||||
|
||||
if not results:
|
||||
print(" ⚠️ Не удалось извлечь ни одной находки из ответа", file=sys.stderr)
|
||||
|
||||
return results
|
||||
|
||||
|
||||
def merge_dual_findings(primary_raw: str, secondary_raw: str) -> list[dict]:
|
||||
"""Объединяет находки от двух моделей.
|
||||
|
||||
Пересечение по (file, snippet) → confidence +0.05.
|
||||
Только primary → normal.
|
||||
Только secondary → normal.
|
||||
"""
|
||||
p_list = extract_json(primary_raw)
|
||||
s_list = extract_json(secondary_raw)
|
||||
|
||||
def _key(f: dict) -> str:
|
||||
return f"{(f.get('file') or '').strip()}::{(f.get('snippet') or '').strip()}"
|
||||
|
||||
p_map = {_key(f): f for f in p_list if isinstance(f, dict)}
|
||||
s_map = {_key(f): f for f in s_list if isinstance(f, dict)}
|
||||
|
||||
merged: dict[str, dict] = {}
|
||||
|
||||
# Primary — base
|
||||
for k, f in p_map.items():
|
||||
item = dict(f)
|
||||
item["_source"] = "primary"
|
||||
if k in s_map:
|
||||
# Пересечение — повышаем confidence
|
||||
try:
|
||||
conf = float(item.get("confidence", 0) or 0)
|
||||
except (TypeError, ValueError):
|
||||
conf = 0
|
||||
item["confidence"] = min(1.0, round(conf + 0.05, 2))
|
||||
item["_source"] = "both"
|
||||
merged[k] = item
|
||||
|
||||
# Secondary — только то, чего нет в primary
|
||||
for k, f in s_map.items():
|
||||
if k not in merged:
|
||||
item = dict(f)
|
||||
item["_source"] = "secondary"
|
||||
merged[k] = item
|
||||
|
||||
both_count = sum(1 for v in merged.values() if v.get("_source") == "both")
|
||||
print(f" 🔗 Merge: primary={len(p_map)}, secondary={len(s_map)}, "
|
||||
f"пересечение={both_count}, всего={len(merged)}")
|
||||
|
||||
return list(merged.values())
|
||||
|
||||
|
||||
def validate_and_filter(
|
||||
findings: list[dict],
|
||||
files_map: dict[str, str],
|
||||
) -> tuple[list[dict], dict[str, int]]:
|
||||
"""Фильтрует находки: файл существует, snippet совпал, confidence ≥ 0.7, severity валидна."""
|
||||
"""Фильтрует находки: файл существует, snippet совпал, confidence ≥ 0.75, severity валидна.
|
||||
|
||||
Overshoot guard — если находок > 15 на пак, берём только топ-10 по confidence.
|
||||
"""
|
||||
stats = {
|
||||
"total": len(findings),
|
||||
"overshoot": 0,
|
||||
"no_file": 0, "snippet_mismatch": 0, "bad_severity": 0,
|
||||
"low_confidence": 0, "no_effect_or_repro": 0, "passed": 0,
|
||||
}
|
||||
|
||||
if len(findings) > OVERSHOOT_LIMIT:
|
||||
print(
|
||||
f" ⚠️ Overshoot: {len(findings)} находок (> {OVERSHOOT_LIMIT}), "
|
||||
f"берём топ-{OVERSHOOT_KEEP} по confidence",
|
||||
file=sys.stderr,
|
||||
)
|
||||
findings = sorted(
|
||||
[f for f in findings if isinstance(f, dict)],
|
||||
key=lambda x: float(x.get("confidence", 0) or 0),
|
||||
reverse=True,
|
||||
)[:OVERSHOOT_KEEP]
|
||||
stats["overshoot"] = 1
|
||||
|
||||
passed: list[dict] = []
|
||||
|
||||
for f in findings:
|
||||
@@ -370,7 +610,7 @@ def format_issue_body(
|
||||
lines.append("# 🤖 AI Code Review (Backend)")
|
||||
lines.append("")
|
||||
lines.append(f"**Дата:** {date_str}")
|
||||
lines.append(f"**Модель:** `{MODEL}`")
|
||||
lines.append(f"**Модель:** `{MODEL_PRIMARY}`")
|
||||
lines.append(f"**Репозиторий:** `{GITEA_REPO}`")
|
||||
lines.append("")
|
||||
lines.append("## 📊 По пакам")
|
||||
@@ -398,7 +638,9 @@ def format_issue_body(
|
||||
lines.append("")
|
||||
for f in items:
|
||||
counter += 1
|
||||
lines.append(f"### {counter}. {f.get('id', 'без имени')}")
|
||||
source = f.get("_source", "primary")
|
||||
source_mark = "🔗 both" if source == "both" else ("🔵 secondary" if source == "secondary" else "")
|
||||
lines.append(f"### {counter}. {f.get('id', 'без имени')} {source_mark}")
|
||||
lines.append("")
|
||||
lines.append(f"- **Файл:** `{f.get('file')}:{f.get('line', '?')}`")
|
||||
lines.append(f"- **Snippet:** `{f.get('snippet', '').strip()[:120]}`")
|
||||
@@ -411,6 +653,7 @@ def format_issue_body(
|
||||
lines.append("---")
|
||||
lines.append("")
|
||||
lines.append(f"**Итого:** всего находок={total_stats['total']}, "
|
||||
f"overshoot={total_stats.get('overshoot', 0)}, "
|
||||
f"snippet не совпал={total_stats['snippet_mismatch']}, "
|
||||
f"низкий confidence={total_stats['low_confidence']}, "
|
||||
f"прошло={total_stats['passed']}")
|
||||
@@ -457,7 +700,7 @@ def main() -> None:
|
||||
all_passed: list[dict] = []
|
||||
pack_stats: list[dict] = []
|
||||
total_stats = {
|
||||
"total": 0, "no_file": 0, "snippet_mismatch": 0,
|
||||
"total": 0, "overshoot": 0, "no_file": 0, "snippet_mismatch": 0,
|
||||
"bad_severity": 0, "low_confidence": 0,
|
||||
"no_effect_or_repro": 0, "passed": 0,
|
||||
}
|
||||
@@ -471,8 +714,11 @@ def main() -> None:
|
||||
pack_stats.append({"name": pack["name"], "files": 0, "symbols": 0, "findings": 0})
|
||||
continue
|
||||
|
||||
raw = call_together(code, pack)
|
||||
findings = extract_json(raw)
|
||||
primary_raw = call_together_model(code, pack, MODEL_PRIMARY)
|
||||
# 🔧 ФИКС (05.10.2026): single_model —
|
||||
# только V4 Pro, без merge.
|
||||
findings = extract_json(primary_raw)
|
||||
|
||||
filtered, stats = validate_and_filter(findings, files_map)
|
||||
|
||||
all_passed.extend(filtered)
|
||||
|
||||
@@ -0,0 +1,101 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Инвентаризация проекта: все эндпоинты + схема базы.
|
||||
|
||||
Запуск: python scripts/dump_inventory.py
|
||||
Результат: endpoints_inventory.md + database_schema.md
|
||||
"""
|
||||
import asyncio
|
||||
import re
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
sys.path.insert(0, str(Path(__file__).parent.parent))
|
||||
|
||||
from database import get_pool
|
||||
|
||||
|
||||
def dump_endpoints() -> None:
|
||||
"""Собирает все эндпоинты из routers/*.py."""
|
||||
routers_dir = Path("routers")
|
||||
lines = ["# 🛣 Все эндпоинты проекта", ""]
|
||||
total = 0
|
||||
|
||||
for router_file in sorted(routers_dir.glob("*.py")):
|
||||
if router_file.name == "__init__.py":
|
||||
continue
|
||||
|
||||
content = router_file.read_text(encoding="utf-8")
|
||||
|
||||
prefix_match = re.search(r'APIRouter\(prefix="([^"]+)"', content)
|
||||
prefix = prefix_match.group(1) if prefix_match else ""
|
||||
|
||||
endpoints = re.findall(
|
||||
r'@router\.(get|post|put|delete|patch)\("([^"]+)"',
|
||||
content,
|
||||
)
|
||||
|
||||
if endpoints:
|
||||
lines.append(f"## {router_file.name}")
|
||||
lines.append(f"**Префикс:** `{prefix}`")
|
||||
lines.append("")
|
||||
for method, path in endpoints:
|
||||
full_path = f"{prefix}{path}" if path.startswith("/") else f"{prefix}/{path}"
|
||||
lines.append(f"- `{method.upper()} {full_path}`")
|
||||
total += 1
|
||||
lines.append("")
|
||||
|
||||
Path("endpoints_inventory.md").write_text("\n".join(lines), encoding="utf-8")
|
||||
print(f"✅ endpoints_inventory.md — {total} эндпоинтов")
|
||||
|
||||
|
||||
async def dump_schema() -> None:
|
||||
"""Собирает все таблицы и колонки из базы."""
|
||||
pool = await get_pool()
|
||||
async with pool.acquire() as conn:
|
||||
tables = await conn.fetch("""
|
||||
SELECT table_name
|
||||
FROM information_schema.tables
|
||||
WHERE table_schema = 'public'
|
||||
AND table_type = 'BASE TABLE'
|
||||
ORDER BY table_name
|
||||
""")
|
||||
|
||||
lines = ["# 🗄 Схема базы данных", ""]
|
||||
total = 0
|
||||
|
||||
for t in tables:
|
||||
table_name = t["table_name"]
|
||||
lines.append(f"## {table_name}")
|
||||
lines.append("")
|
||||
|
||||
cols = await conn.fetch("""
|
||||
SELECT column_name, data_type, is_nullable, column_default
|
||||
FROM information_schema.columns
|
||||
WHERE table_name = $1
|
||||
ORDER BY ordinal_position
|
||||
""", table_name)
|
||||
|
||||
lines.append("| Колонка | Тип | NULL | Default |")
|
||||
lines.append("|---------|-----|------|---------|")
|
||||
for c in cols:
|
||||
nullable = "YES" if c["is_nullable"] == "YES" else "NO"
|
||||
default = (c["column_default"] or "")[:50]
|
||||
lines.append(f"| {c['column_name']} | {c['data_type']} | {nullable} | {default} |")
|
||||
lines.append("")
|
||||
total += 1
|
||||
|
||||
await pool.close()
|
||||
|
||||
Path("database_schema.md").write_text("\n".join(lines), encoding="utf-8")
|
||||
print(f"✅ database_schema.md — {total} таблиц")
|
||||
|
||||
|
||||
async def main() -> None:
|
||||
dump_endpoints()
|
||||
await dump_schema()
|
||||
print("🎉 Готово!")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
asyncio.run(main())
|
||||
@@ -0,0 +1,61 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Дамп схемы базы данных. Запуск: python scripts/dump_schema.py"""
|
||||
import asyncio
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
sys.path.insert(0, str(Path(__file__).parent.parent))
|
||||
|
||||
from database import get_pool
|
||||
|
||||
|
||||
async def dump_schema() -> None:
|
||||
pool = await get_pool()
|
||||
async with pool.acquire() as conn:
|
||||
print("🔍 Запрашиваю список таблиц...")
|
||||
tables = await conn.fetch("""
|
||||
SELECT table_name
|
||||
FROM information_schema.tables
|
||||
WHERE table_schema = 'public'
|
||||
AND table_type = 'BASE TABLE'
|
||||
ORDER BY table_name
|
||||
""")
|
||||
print(f"📋 Найдено таблиц: {len(tables)}")
|
||||
|
||||
lines = ["# 🗄 Схема базы данных", ""]
|
||||
total = 0
|
||||
|
||||
for t in tables:
|
||||
table_name = t["table_name"]
|
||||
print(f" → {table_name}")
|
||||
lines.append(f"## {table_name}")
|
||||
lines.append("")
|
||||
|
||||
cols = await conn.fetch("""
|
||||
SELECT column_name, data_type, is_nullable, column_default
|
||||
FROM information_schema.columns
|
||||
WHERE table_name = $1
|
||||
ORDER BY ordinal_position
|
||||
""", table_name)
|
||||
|
||||
lines.append("| Колонка | Тип | NULL | Default |")
|
||||
lines.append("|---------|-----|------|---------|")
|
||||
for c in cols:
|
||||
nullable = "YES" if c["is_nullable"] == "YES" else "NO"
|
||||
default = (c["column_default"] or "")[:50]
|
||||
lines.append(f"| {c['column_name']} | {c['data_type']} | {nullable} | {default} |")
|
||||
lines.append("")
|
||||
total += 1
|
||||
|
||||
Path("database_schema.md").write_text("\n".join(lines), encoding="utf-8")
|
||||
print(f"✅ database_schema.md — {total} таблиц")
|
||||
|
||||
|
||||
async def main() -> None:
|
||||
await dump_schema()
|
||||
print("🎉 Готово!")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
# БЕЗ pool.close() — пул закроется сам при выходе процесса.
|
||||
asyncio.run(main())
|
||||
@@ -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,164 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Сброс прогресса и достижений пользователя (для теста «как новый юзер»).
|
||||
|
||||
Что делает:
|
||||
- удаляет весь игровой прогресс (филворд, пузыри, угадай слово,
|
||||
предложения, печать, обучение, XP-лог, серии, волны, статистику слов);
|
||||
- удаляет выданные достижения (user_achievements);
|
||||
- обнуляет XP в user_profile (total_xp, weekly_xp);
|
||||
- сбрасывает users.last_completed_level, last_completed_by_level, current_level.
|
||||
|
||||
Что НЕ трогает:
|
||||
- саму учётку (users: telegram_id, device_id, apple_id, source);
|
||||
- настройки (difficulty, app_language);
|
||||
- авторизацию (auth_identities);
|
||||
- поддержку (support_tickets / support_messages).
|
||||
|
||||
Запуск (из папки backend/):
|
||||
python scripts/reset_user_progress.py --telegram-id -1
|
||||
python scripts/reset_user_progress.py --device-id 11111111-2222-3333-4444-555555555555
|
||||
python scripts/reset_user_progress.py --all-pleily
|
||||
python scripts/reset_user_progress.py --telegram-id -1 --yes # без подтверждения
|
||||
|
||||
Без --yes скрипт спросит подтверждение.
|
||||
"""
|
||||
import argparse
|
||||
import asyncio
|
||||
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__)
|
||||
|
||||
# Таблицы, где user_id = telegram_id. Чистим по каждому найденному юзеру.
|
||||
USER_TABLES = [
|
||||
"user_progress",
|
||||
"sentence_progress",
|
||||
"typing_progress",
|
||||
"user_achievements",
|
||||
"daily_logins",
|
||||
"word_quiz_progress",
|
||||
"bubble_words_progress",
|
||||
"sentence_stats",
|
||||
"choose_progress",
|
||||
"user_seen_levels",
|
||||
"user_game_progress",
|
||||
"wave_results",
|
||||
"user_seen_bubble_levels",
|
||||
"user_word_stats",
|
||||
"xp_log",
|
||||
"typing_hints_used",
|
||||
"chat_history",
|
||||
"chat_usage",
|
||||
"user_learning_answers",
|
||||
"user_learning_answers_archive",
|
||||
"user_lesson_progress",
|
||||
"user_topic_progress",
|
||||
"user_skill_mastery",
|
||||
"learning_sessions",
|
||||
"ai_user_context",
|
||||
"teacher_chat_history",
|
||||
"teacher_ai_usage",
|
||||
]
|
||||
|
||||
|
||||
async def resolve_user_ids(conn, telegram_id, device_id, all_pleily):
|
||||
"""Возвращает список telegram_id, которых нужно сбросить."""
|
||||
if telegram_id is not None:
|
||||
row = await conn.fetchrow(
|
||||
"SELECT telegram_id FROM users WHERE telegram_id = $1", telegram_id
|
||||
)
|
||||
if not row:
|
||||
logger.error(f"❌ Пользователь с telegram_id={telegram_id} не найден")
|
||||
return []
|
||||
return [row["telegram_id"]]
|
||||
|
||||
if device_id is not None:
|
||||
row = await conn.fetchrow(
|
||||
"SELECT telegram_id FROM users WHERE device_id = $1::uuid", device_id
|
||||
)
|
||||
if not row:
|
||||
logger.error(f"❌ Пользователь с device_id={device_id} не найден")
|
||||
return []
|
||||
return [row["telegram_id"]]
|
||||
|
||||
if all_pleily:
|
||||
rows = await conn.fetch(
|
||||
"SELECT telegram_id FROM users WHERE telegram_id < 0 OR source = 'pleily_device'"
|
||||
)
|
||||
return [r["telegram_id"] for r in rows]
|
||||
|
||||
return []
|
||||
|
||||
|
||||
async def reset_user(conn, user_id: int) -> None:
|
||||
"""Чистит прогресс одного пользователя в одной транзакции."""
|
||||
async with conn.transaction():
|
||||
for table in USER_TABLES:
|
||||
await conn.execute(f"DELETE FROM {table} WHERE user_id = $1", user_id)
|
||||
|
||||
# Обнуляем XP-профиль (строку оставляем, чтобы не ломать FK).
|
||||
await conn.execute(
|
||||
"""
|
||||
UPDATE user_profile
|
||||
SET total_xp = 0, weekly_xp = 0, updated_at = NOW()
|
||||
WHERE user_id = $1
|
||||
""",
|
||||
user_id,
|
||||
)
|
||||
|
||||
# Сбрасываем прогресс уровней в users.
|
||||
await conn.execute(
|
||||
"""
|
||||
UPDATE users
|
||||
SET last_completed_level = 0,
|
||||
last_completed_by_level = '{}'::jsonb,
|
||||
current_level = 'A1'
|
||||
WHERE telegram_id = $1
|
||||
""",
|
||||
user_id,
|
||||
)
|
||||
|
||||
|
||||
async def main() -> None:
|
||||
parser = argparse.ArgumentParser(description="Сброс прогресса и достижений пользователя")
|
||||
group = parser.add_mutually_exclusive_group(required=True)
|
||||
group.add_argument("--telegram-id", type=int, help="telegram_id юзера (у Pleily отрицательный)")
|
||||
group.add_argument("--device-id", type=str, help="UUID устройства (Pleily)")
|
||||
group.add_argument("--all-pleily", action="store_true", help="сбросить ВСЕХ Pleily-юзеров")
|
||||
parser.add_argument("--yes", action="store_true", help="не спрашивать подтверждение")
|
||||
args = parser.parse_args()
|
||||
|
||||
pool = await get_pool()
|
||||
async with pool.acquire() as conn:
|
||||
user_ids = await resolve_user_ids(conn, args.telegram_id, args.device_id, args.all_pleily)
|
||||
|
||||
if not user_ids:
|
||||
logger.warning("⚠️ Некого сбрасывать — выхожу")
|
||||
return
|
||||
|
||||
logger.info(f"Найдено пользователей: {len(user_ids)} → {user_ids}")
|
||||
|
||||
if not args.yes:
|
||||
answer = input(
|
||||
f"Сбросить прогресс и достижения для {len(user_ids)} юзер(ов)? [y/N]: "
|
||||
).strip().lower()
|
||||
if answer not in ("y", "yes", "д", "да"):
|
||||
logger.info("Отменено.")
|
||||
return
|
||||
|
||||
for uid in user_ids:
|
||||
await reset_user(conn, uid)
|
||||
logger.info(f"✅ Сброшено: telegram_id={uid}")
|
||||
|
||||
logger.info("🎉 Готово! Можно тестировать как новый пользователь.")
|
||||
|
||||
|
||||
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,
|
||||
}
|
||||
@@ -0,0 +1,105 @@
|
||||
# 🧪 Smoke-test отчёт (реальный юзер, реальная БД)
|
||||
|
||||
**Дата:** 2026-09-26 09:54 UTC
|
||||
**Итого:** 77/77 сценариев прошли
|
||||
|
||||
## ✅ Подтверждено рабочим
|
||||
|
||||
- **pronunciation_pool_stress** (pronunciation) — 30/30 запросов, 30 уникальных слов
|
||||
- **hints_db_increment** (hints) — GET=200, hints_used 0→1
|
||||
- **game_complete_level_full_flow** (game) — idempotent=True, api=90, db=90
|
||||
- **wordquiz_correct_answer** (wordquiz) — status=200, correct=True, score 0→50
|
||||
- **wordquiz_wrong_answer** (wordquiz) — status=200, mistakes 0→1
|
||||
- **bubblewords_complete_flow** (bubblewords) — status=200, levels 0→1, score 0→100
|
||||
- **sentences_check_wrong** (sentences) — status=200, score 0→0 (неверный)
|
||||
- **typing_progress_flow** (typing) — status=200, sentence_id=4704, recorded=True
|
||||
- **users_set_language** (users) — status=200, lang pl→ru
|
||||
- **achievements_track_login** (achievements) — status=200, logins 0→1
|
||||
- **learning_levels_list** (learning) — status=200, уровней=6
|
||||
- **learning_topics_list** (learning) — status=200, тем A1=15
|
||||
- **learning_topic_detail** (learning) — status=200, topic_id=a1_greetings, уроков=10
|
||||
- **learning_session_start** (learning) — status=200, session_id=368, в БД=True
|
||||
- **learning_session_full_flow** (learning) — answer=True, recorded=True, complete=True, is_completed=True
|
||||
- **learning_progress** (learning) — status=200, тем=27
|
||||
- **learning_lesson_detail** (learning) — status=200, lesson=True, questions=True, examples=True
|
||||
- **learning_topic_test** (learning) — status=200, test=True, total=20
|
||||
- **learning_ai_context** (learning) — status=200, analytics=False, context=True, message=False
|
||||
- **learning_practice_start** (learning) — status=200, has_weak_skills=False
|
||||
- **teacher_progress** (teacher) — status=200, уровней=6
|
||||
- **teacher_phrase_of_day** (teacher) — status=200, phrase=Codziennie rano biorę prysznic i piję ka
|
||||
- **teacher_start_or_resume** (teacher) — status=200, type=lesson_explanation, session_recorded=True
|
||||
- **teacher_resume_no_session** (teacher) — status=200, has_active_session=True
|
||||
- **teacher_diagnostic_test** (teacher) — status=200, session_id=371, questions=15, type=diagnostic_test
|
||||
- **teacher_answer_flow** (teacher) — status=200, reaction=True, is_correct=True, recorded=True
|
||||
- **teacher_history_save_load** (teacher) — save=True, load=True, messages_match=True
|
||||
- **teacher_history_clear** (teacher) — status=200, remaining=0
|
||||
- **leaderboard_top** (leaderboard) — status=200, top3=3
|
||||
- **assistant_limit** (assistant) — status=200, is_admin=False, used=0
|
||||
- **assistant_history** (assistant) — status=200, сообщений=0
|
||||
- **assistant_stats_personal** (assistant) — status=200, level=A1, score=240
|
||||
- **assistant_stats_admin_forbidden** (assistant) — status=403 (ожидали 403 — тестовый юзер не админ)
|
||||
- **support_user_tickets** (support) — status=200, тикетов=0
|
||||
- **support_send** (support) — status=200, ticket_id=8, ticket_db=True, msg_db=True
|
||||
- **support_unread_count** (support) — status=200, unread_count=0
|
||||
- **admin_dashboard_forbidden** (admin) — status=403 (ожидали 403 — тестовый юзер не админ)
|
||||
- **admin_sentry_errors_forbidden** (admin) — status=403 (ожидали 403 — тестовый юзер не админ)
|
||||
- **feed_news_section** (feed) — status=200, постов=0
|
||||
- **achievements_track_teacher_menu** (achievements) — status=200, new=1
|
||||
- **achievements_track_progress** (achievements) — status=200, new=1
|
||||
- **achievements_track_cheatsheets** (achievements) — status=200, new=1
|
||||
- **achievements_track_pronunciation** (achievements) — status=200, new=1
|
||||
- **achievements_track_ai_assistant** (achievements) — status=200, new=1
|
||||
- **achievements_track_alphabet** (achievements) — status=200, new=1
|
||||
- **achievements_track_rules** (achievements) — status=200, new=1
|
||||
- **achievements_user** (achievements) — status=200, unlocked=14/56, percent=25.0
|
||||
- **users_is_admin** (users) — status=200, is_admin=False
|
||||
- **users_set_level** (users) — status=200, level A1→A2 (returned to A1)
|
||||
- **hints_word_list** (hints) — status=200, words=5
|
||||
- **hints_remaining** (hints) — status=200, used=2/3, remaining=1
|
||||
- **game_progress** (game) — status=200, last=1, score=240
|
||||
- **game_check_word** (game) — status=200, found=False (координаты произвольные)
|
||||
- **wordquiz_next** (wordquiz) — status=200, correct=True, options=3, diff=easy
|
||||
- **wordquiz_progress** (wordquiz) — status=200, words=1, score=50
|
||||
- **bubblewords_next** (bubblewords) — status=200, words=3, bubbles=9, level=2
|
||||
- **bubblewords_progress** (bubblewords) — status=200, levels=1, score=100
|
||||
- **sentences_next** (sentences) — status=200, id=4542, words=4
|
||||
- **sentences_stats** (sentences) — status=200, total=200, completed=0, percent=0.0
|
||||
- **sentences_hint** (sentences) — first=200, recorded=True, second=403 (ожидали 403)
|
||||
- **typing_next** (typing) — status=200, sentence_id=4701
|
||||
- **typing_hint** (typing) — first=200, recorded=True, second=403 (ожидали 403)
|
||||
- **typing_progress** (typing) — status=200, 1/200, remaining=199
|
||||
- **achievements_all** (achievements) — status=200, всего=56
|
||||
- **assistant_history_clear** (assistant) — status=200, remaining=0
|
||||
- **admin_content_summary** (admin_content) — status=200, уровней=6
|
||||
- **admin_content_word_levels** (admin_content) — status=200, уровней=6
|
||||
- **admin_content_word_detail** (admin_content) — status=200, word_id=36807, word_pl=eksplodować
|
||||
- **admin_content_texts_levels** (admin_content) — status=200, уровней=6
|
||||
- **admin_content_lessons_levels** (admin_content) — status=200, уровней=6
|
||||
- **admin_content_lesson_topics** (admin_content) — status=200, тем A1=15
|
||||
- **admin_content_lesson_detail** (admin_content) — status=200, lesson=True, examples=3, questions=3
|
||||
- **admin_content_wrong_because** (admin_content) — status=200, записей=7
|
||||
- **admin_feed_section_news** (admin_feed) — status=200, постов=0
|
||||
- **admin_feed_delete_not_found** (admin_feed) — status=404 (ожидали 404)
|
||||
- **admin_feed_upload_requires_post_id** (admin_feed) — status=422 (ожидали 422)
|
||||
- **admin_feed_forbidden_for_user** (admin_feed) — status=403 (ожидали 403 — юзер не админ)
|
||||
|
||||
## 📊 По секциям
|
||||
|
||||
- **achievements**: 10/10
|
||||
- **admin**: 2/2
|
||||
- **admin_content**: 8/8
|
||||
- **admin_feed**: 4/4
|
||||
- **assistant**: 5/5
|
||||
- **bubblewords**: 3/3
|
||||
- **feed**: 1/1
|
||||
- **game**: 3/3
|
||||
- **hints**: 3/3
|
||||
- **leaderboard**: 1/1
|
||||
- **learning**: 10/10
|
||||
- **pronunciation**: 1/1
|
||||
- **sentences**: 4/4
|
||||
- **support**: 3/3
|
||||
- **teacher**: 8/8
|
||||
- **typing**: 4/4
|
||||
- **users**: 3/3
|
||||
- **wordquiz**: 4/4
|
||||
+2523
File diff suppressed because it is too large
Load Diff
Reference in New Issue
Block a user