Author SHA1 Message Date
Drobysh 8918309501 [Eva] Добавить удаление осиротевших достижений в init_achievements 2026-10-14 16:50:33 +00:00
Drobysh 1afc7a1654 [Eva] Удалить 7 неактуальных достижений 2026-10-14 16:50:21 +00:00
Drobysh 5fc49d086d [Eva] Поправить счётчик секции General 15 → 9 2026-10-14 16:49:27 +00:00
Drobysh 5a6b81da1d [Eva] Поправить счётчик достижений 52 → 55 2026-10-14 16:49:17 +00:00
Drobysh 7c43812475 [Eva] bubblewords /next: число слов по сложности (easy 3, medium 4, hard 5) 2026-10-14 11:53:50 +00:00
Drobysh e7c512e50e [Eva] fix first_part_hint: json.loads для current_level_words и hinted_words 2026-10-14 11:05:46 +00:00
Drobysh 0d6b56e5c9 [Eva] fix show_words: json.loads для current_level_words 2026-10-14 11:05:43 +00:00
Drobysh 99dd3765d0 [Eva] bubblewords /next: возвращаем difficulty в ответе 2026-10-14 09:37:14 +00:00
Drobysh 929420a284 [Eva] bubblewords /next: читаем difficulty из users 2026-10-14 09:37:10 +00:00
Drobysh 6399d3931c [Eva] bubblewords: очистка состояния + сброс счётчиков в /complete 2026-10-14 09:20:09 +00:00
Drobysh 07d2d197fd [Eva] bubblewords: читать серверные счётчики hints+list 2026-10-14 09:19:59 +00:00
Drobysh 1f7ac86ef5 [Eva] bubblewords: убрать list_opened из body 2026-10-14 09:19:51 +00:00
Drobysh 16b8956b87 [Eva] Добавлен POST /bubblewords/show-words 2026-10-14 09:18:24 +00:00
Drobysh 959b9c4e3f [Eva] Добавлен POST /bubblewords/first-part-hint 2026-10-14 09:16:37 +00:00
Drobysh 4355b94291 [Eva] /next сохраняет состояние уровня и сбрасывает счётчики 2026-10-14 09:13:34 +00:00
Drobysh bd45071142 [Eva] Добавлен import json в bubblewords.py 2026-10-14 09:13:29 +00:00
Drobysh 13fcc8240d [Eva] Добавить 3 колонки в bubble_words_progress (current_list_opened, current_level_words, hinted_words) 2026-10-14 09:10:45 +00:00
Drobysh 4159d6265a [Eva] bubblewords: убираю xp_result["stars"] (KeyError) 2026-10-14 09:01:33 +00:00
Drobysh 741d1799e7 [Eva] bubblewords: bubble_perfect по новой логике 2026-10-14 09:01:21 +00:00
Drobysh 5644b5be16 [Eva] bubblewords: новая формула очков вместо звёзд 2026-10-14 09:01:12 +00:00
Drobysh e65bd5db43 [Eva] bubblewords: читаем difficulty из users 2026-10-14 09:01:02 +00:00
Drobysh 6786acb126 Merge pull request '[Eva] Ева, прочитай .gitignore' (#39) from eva/chat-c3088d-backend into main
Reviewed-on: #39
2026-10-13 17:47:26 +00:00
Drobysh 6fc8c83322 [Eva] complete-level: wave_number отдаёт current_wave 2026-10-13 17:46:36 +00:00
Drobysh bffcb4387c [Eva] complete-level: waves_completed/wave_completed/wave_points от current_wave/current_position_in_wave 2026-10-13 17:46:25 +00:00
Drobysh 01ce5dfa2d [Eva] complete-level: читать current_wave/current_position_in_wave вместо session_number/session_level_num 2026-10-13 17:46:12 +00:00
Drobysh ec9108f2a3 [Eva] complete-level: переименовать session_number → current_wave (объявление) 2026-10-13 17:45:56 +00:00
Drobysh 938d674b09 Merge pull request '[Eva] Ева, прочитай .gitignore' (#38) from eva/chat-c3088d-backend into main
Reviewed-on: #38
2026-10-13 16:36:33 +00:00
Drobysh 556c11fc95 [Eva] complete-level: поля итогов волны в ответе 2026-10-13 16:35:18 +00:00
Drobysh aa7679c49b [Eva] complete-level: подсчёт итогов волны 2026-10-13 16:34:29 +00:00
Drobysh 9db00df88f [Eva] complete-level: убран дубль чтения session_number 2026-10-13 16:34:16 +00:00
Drobysh 4333aa62a6 [Eva] complete-level: запись wave в user_progress 2026-10-13 16:34:07 +00:00
Drobysh bd743e4c48 [Eva] complete-level: инициализация переменных итогов волны 2026-10-13 16:33:56 +00:00
Drobysh f83fcc0e1c [Eva] Добавлена миграция user_progress.wave INTEGER 2026-10-13 16:28:54 +00:00
Drobysh 78d40364bf Merge pull request '[Eva] Ева, прочитай .gitignore' (#37) from eva/chat-c3088d-backend into main
Reviewed-on: #37
2026-10-13 12:07:23 +00:00
Drobysh 20b1cdc464 [Eva] Добавить difficulty в таблицу users 2026-10-13 12:05:45 +00:00
Drobysh 26442db954 Merge pull request '[Eva] Ева, прочитай .gitignore' (#36) from eva/chat-c3088d-backend into main
Reviewed-on: #36
2026-10-13 12:02:29 +00:00
Drobysh e3bc3e8456 [Eva] game.py: difficulty в ответе /game/level/{n} 2026-10-13 11:52:04 +00:00
Drobysh a6fe755fdb [Eva] game.py: difficulty в SELECT /game/level/{n} 2026-10-13 11:51:58 +00:00
Drobysh 959f789f24 [Eva] game.py: формула очков по сложности 2026-10-13 11:51:50 +00:00
Drobysh d181e43ee3 [Eva] game.py: валидация hard-режима в complete-level 2026-10-13 11:51:41 +00:00
Drobysh 6f89336a02 [Eva] game.py: читаем difficulty из users в complete-level 2026-10-13 11:51:33 +00:00
Drobysh f78a1fa19f [Eva] Добавлена миграция users.difficulty 2026-10-13 11:46:06 +00:00
Drobysh 2b5ef446c1 [Eva] Добавлен эндпоинт POST /users/set-difficulty 2026-10-13 11:38:59 +00:00
Drobysh 50c02b7707 Merge pull request '[Eva] Ева, прочитай .gitignore' (#35) from eva/chat-c3088d-backend into main
Reviewed-on: #35
2026-10-13 11:34:18 +00:00
Drobysh 6e02303ea8 [Eva] waves.py: звёзды → очки (max_points_for_wave, wave_medal) 2026-10-13 11:33:02 +00:00
Drobysh 22e4eed3f5 Merge pull request '[Eva] Ева, прочитай .gitignore' (#34) from eva/chat-c3088d-backend into main
Reviewed-on: #34
2026-10-13 11:29:59 +00:00
Drobysh 5e2de6f7e4 [Eva] game.py: убрать ключ stars из ответа complete-level 2026-10-13 11:28:41 +00:00
Drobysh 2dedec5972 [Eva] game.py: звёзды → очки (формула 100−20×подсказки−20×список+бонус) 2026-10-13 11:28:31 +00:00
Drobysh 8b98655716 Merge pull request '[Eva] Ева, прочитай .gitignore' (#33) from eva/chat-c3088d-backend into main
Reviewed-on: #33
2026-10-13 11:23:15 +00:00
Drobysh da7182fb6b [Eva] Возврат award_xp без ключа stars 2026-10-13 11:21:07 +00:00
Drobysh b62311d3ed [Eva] Лог level_up: final_points 2026-10-13 11:21:01 +00:00
Drobysh 6f341a7f33 [Eva] user_profile: начисление final_points 2026-10-13 11:20:55 +00:00
Drobysh 981e65e57c [Eva] xp_log: stars=0, base_points, final_points 2026-10-13 11:20:49 +00:00
Drobysh 9c975dde79 [Eva] Расчёт очков: base_points из points, final_points с множителем 2026-10-13 11:20:37 +00:00
Drobysh df3d32ecd5 [Eva] Сигнатура award_xp: stars → points 2026-10-13 11:20:29 +00:00
Drobysh 437921d9dd [Eva] Убрать константы звёзд (POINTS_PER_STAR, MAX_STARS, MIN_STARS) 2026-10-13 11:19:08 +00:00
Drobysh bcc01a0fe8 Merge pull request '[Eva] Ева, измени в pleily/lib/screens/wordsea' (#32) from eva/chat-a6f27f-backend into main
Reviewed-on: #32
2026-10-12 11:49:51 +00:00
Drobysh 5ee5614fdf [Eva] hint: исключать найденные слова из подсказки первой буквы 2026-10-12 11:49:09 +00:00
Drobysh 8338d6b3c8 Merge pull request '[Eva] Ева, измени в pleily/lib/screens/wordsea' (#31) from eva/chat-a6f27f-backend into main
Reviewed-on: #31
2026-10-12 11:28:05 +00:00
Drobysh 7efa54e455 [Eva] Волна = 10 уровней: обновить описания достижений ws_wave_1 и ws_wave_no_hints 2026-10-12 11:27:30 +00:00
Drobysh 6e4701aecd [Eva] game.py: волна 20 → 10 уровней (3 места) 2026-10-12 11:16:17 +00:00
Drobysh 32a4a68f92 [Eva] Волны: 20 уровней → 10 уровней 2026-10-12 11:15:22 +00:00
Drobysh 12c6bbca51 Merge pull request '[Eva] Ева, измени в pleily/lib/screens/wordsea' (#30) from eva/chat-a6f27f-backend into main
Reviewed-on: #30
2026-10-11 17:44:58 +00:00
Drobysh 5983a4767e [Eva] hints: подсказка первой буквы выбирает новое слово по индексу 2026-10-11 17:44:20 +00:00
Drobysh 794daad69c Merge pull request '[Eva] Ева, измени в pleily/lib/screens/wordsea' (#29) from eva/chat-a6f27f-backend into main
Reviewed-on: #29
2026-10-11 17:31:01 +00:00
Drobysh 154ae25772 [Eva] check-word: проверка координат слова (word_paths) 2026-10-11 17:30:03 +00:00
Drobysh 5e9cd0c901 Merge pull request '[Eva] Ева, измени в pleily/lib/screens/wordsea' (#28) from eva/chat-a6f27f-backend into main
Reviewed-on: #28
2026-10-11 17:12:01 +00:00
Drobysh 22decc1bc3 [Eva] Исправить grid_size_for: волна 1 обучающая (5×5/6×6), волны 2+ чередование 7×7/8×8 2026-10-11 17:11:29 +00:00
Drobysh ea297b2179 Merge pull request '[Eva] Ева, измени в pleily/lib/screens/wordsea' (#27) from eva/chat-a6f27f-backend into main
Reviewed-on: #27
2026-10-11 17:01:40 +00:00
Drobysh 1733b657b5 [Eva] waves.py: удалить wave_plan, grid_size_for по блокам 25/50/200/300 2026-10-11 17:00:05 +00:00
Drobysh 791adfeee9 Merge pull request '[Eva] Ева, измени в pleily/lib/screens/wordsea' (#26) from eva/chat-a6f27f-backend into main
Reviewed-on: #26
2026-10-11 16:43:35 +00:00
Drobysh 8d6a9886e1 [Eva] Добавить волновые достижения филворда в complete_level 2026-10-11 16:42:07 +00:00
Drobysh 0a4c0c5d23 Merge pull request '[Eva] Ева, измени в pleily/lib/screens/wordsea' (#25) from eva/chat-a6f27f-backend into main
Reviewed-on: #25
2026-10-11 16:37:22 +00:00
Drobysh 731aaccf28 [Eva] Добавить 9 волновых достижений филворда 2026-10-11 16:31:42 +00:00
Drobysh 11a1803b91 [Eva] Fix off-by-one в reuse-ветке /game/next 2026-10-10 10:32:28 +00:00
Drobysh 9a3bd6d7c6 [Eva] Fix off-by-one in reuse branch of /game/next 2026-10-10 10:32:22 +00:00
Drobysh 77d822a777 [Eva] Fix off-by-one in reuse branch of /game/next 2026-10-10 10:30:39 +00:00
Drobysh c8ae20184b fix(game): store wave/pos at issue time (fix off-by-one) 2026-10-10 10:14:37 +00:00
Drobysh d30bd4956d [Eva] game/level: добавить wave и position_in_wave в ответ 2026-10-10 09:49:06 +00:00
Drobysh 0be17d54a0 [Eva] game/level: добавить wave и position_in_wave в ответ 2026-10-10 09:49:00 +00:00
Drobysh 1215a68eb3 [Eva] game: add wave and position_in_wave to GET /game/level/{n} 2026-10-10 09:47:56 +00:00
Drobysh a237572ba2 [Eva] Fix 403 в get_level (доступ по user_seen_levels) 2026-10-10 08:25:11 +00:00
Drobysh 8d83022679 [Eva] Fix 403 in get_level (user_seen_levels) 2026-10-10 08:24:13 +00:00
Drobysh 7969ff750a [Eva] Fix /game/next to reuse active level 2026-10-10 08:07:07 +00:00
Drobysh e86719b36d [Eva] Fix /game/next to reuse active level 2026-10-10 08:04:38 +00:00
Drobysh 295cf1ebee [Eva] Fix case-sensitivity in generate_levels (lowercase everywhere) 2026-10-10 07:58:47 +00:00
Drobysh 735d9f51bc [Eva] Fix case-sensitivity in generate_levels (lowercase everywhere) 2026-10-10 07:57:02 +00:00
Drobysh c2c7366445 feat(levels): rebuild sizes 5-8 for wave system (25/50/200/300) 2026-10-09 15:29:22 +00:00
Drobysh ae63b61003 game/get_level: отдаём все 4 перевода (ru/uk/en) + legacy 2026-10-09 11:25:22 +00:00
Drobysh 84927b063f feat: XP foundation + waves + featured game + profile + leaderboard by total_xp
- services/xp.py: award_xp, level_for, RANKS (48), featured_game
- services/waves.py: wave_plan, grid_size_for, wave_medal
- routers/featured.py: GET /featured (игра дня ×1.5)
- routers/users.py: POST /set-nickname, POST /set-avatar
- routers/app_auth.py: /auth/me с XP-полями (level, rank_key, rank_name, xp)
- routers/game.py: award_xp + 3 штрафа + POST /game/next (волны)
- routers/wordquiz.py: award_xp + серии в choose_progress
- routers/bubblewords.py: award_xp + 4 штрафа
- routers/sentences.py: award_xp по длине предложения
- routers/leaderboard.py: сортировка по total_xp, XP-поля в ответе
- database.py: миграции user_profile, xp_log, choose_progress, user_seen_levels, user_game_progress, wave_results, bubble_levels, user_word_stats
- main.py: подключение routers/featured

Проверено:
- /auth/me отдаёт level=1, rank_00, xp_in_level
- /featured отдаёт wordsearch + seconds_left
- /game/complete-level начисляет XP через award_xp
- xp_log, user_profile заполняются
- /game/next выдаёт уровень по волнам
- /leaderboard сортирует по total_xp
2026-10-09 08:12:19 +00:00
Drobysh a3f7d9521f feat(auth): авторизация Pleily — JWT + device_id + auth_identities
Backend:
- POST /auth/device — анонимный вход по device_id (UUID)
- GET /auth/me — текущий юзер
- DELETE /me — удаление аккаунта (Apple требует)

БД:
- users.source TEXT DEFAULT 'telegram'
- users.device_id UUID UNIQUE
- users.apple_id TEXT UNIQUE
- app_user_id_seq (START -1 INCREMENT -1)
- auth_identities (provider, provider_uid, user_id)

Auth:
- JWT через PyJWT, APP_JWT_SECRET из .env
- Authorization: Bearer <token> в require_auth
- Rate limit /auth/device (5/60)

Отрицательные telegram_id для Pleily-юзеров.
2026-10-07 11:21:18 +00:00
Drobysh 5ed0de765d feat(ai-review): single model V4 Pro + stricter filters
- MODEL: V4.1 Flash + GLM → V4 Pro 0813
- USE_SECONDARY_MODEL: True → False
- reasoning_effort: low, max_tokens=16000
- MIN_CONFIDENCE: 0.75 → 0.80
- Удалён merge_dual_findings и _is_glm

Тест 05.10.2026: V4 Pro игнорирует reasoning_effort=none,
low даёт минимальный reasoning (70 токенов на простой запрос).
2026-10-05 13:28:49 +00:00
Drobysh 02b3eb7b40 feat(ai): hybrid models — MiniMax M3 + DeepSeek V4 Pro
- teacher.py: TEACHER_MODEL=DeepSeek V4 Pro, reasoning_effort=none (фраза дня 2-3 сек вместо 28)
- support.py: SUPPORT_MODEL=DeepSeek V4 Pro (перевод сообщений)
- feed.py: TRANSLATE_MODEL=DeepSeek V4 Pro (перевод постов)
- generate_daily_phrase.py: TEACHER_MODEL=DeepSeek V4 Pro
- learning.py: ANALYTICS_MODEL=DeepSeek V4 Pro (reasoning для аналитики)

V4 Pro отключён reasoning (reasoning_effort=none) — быстро и дёшево.
Для аналитики reasoning остаётся (по умолчанию).
2026-10-05 13:00:56 +00:00
Drobysh b0308acb1f chore(lint): удалить неиспользуемые импорты (ruff F401)
- 11 файлов, 16 unused imports удалено
- pip 24.0 → 26.2.1, urllib3 2.7.0 → 2.8.0 (CVE fix)
- pip-audit: 0 vulnerabilities
- Логика не затронута, только imports
- Проверено: systemctl restart OK, /health 200
2026-10-05 11:16:24 +00:00
Drobysh a730ef87f5 feat: track + options_language + test generator + повторы уроков 2026-10-04 16:13:59 +00:00
Drobysh 80b7f6b419 feat(admin_wordsearch): exclude_maxed_words — не отдавать слова с usage_count >= 5
Слова, использованные в 5+ уровнях, «выгорают» — больше не возвращаются
в конструктор. Админ не может случайно повторно использовать слово.

- get_csv_words: WHERE COALESCE(u.usage_count, 0) < 5
- Хардкод 5 = MAX_USAGE_COUNT (в будущем — в константу)
2026-10-03 17:20:28 +00:00
Drobysh 98ac403675 feat(admin): уроки + AI-помощник + повторы + отчёт по теме
Backend:
- admin_ai.py: POST /admin/ai/chat + /admin/ai/translate (DeepSeek V4 Pro 0813)
  * rate limit 60/час, reasoning отключён, context support
  * перевод на 4 языка через JSON mode
- admin_content.py: CRUD уроков/тем + генератор теста
  * GET /lessons/tree — дерево уровней/тем/уроков
  * POST /lessons/topic — создание темы
  * POST /lessons/lesson — создание урока (транзакция)
  * DELETE /lessons/lesson/{id} — каскадное удаление
  * GET /lessons/topic/{id}/questions — вопросы для генератора
  * POST /lessons/test/generate — генерация теста с перемешиванием
  * POST /lessons/lesson/{id}/add-question — добавление вопроса в edit-режиме
- learning.py: attempt_number + revised + revision_of_id
  * show_correct_answer с 3-й попытки
  * session/complete возвращает report (percent, message, weak_skills, next_topic)
- learning_data/__init__.py: seed только при пустой БД
  * SEED_LEARNING_DATA=true для принудительной перезаливки
- main.py: подключение admin_ai router
- database.py: миграция revised + revision_of_id
2026-10-02 12:47:56 +00:00
Drobysh 8c46a78aed feat(feed): /admin/feed/stats — счётчики для бейджа черновиков
- total / drafts / published / pinned одним запросом
- COUNT(*) FILTER — быстро, без N+1
- Нужно для бейджа в сайдбаре админки
2026-10-01 17:37:40 +00:00
Drobysh 75b10c536b fix(hints): word_list не расходует лимит подсказок 2026-10-01 11:43:29 +00:00
Drobysh daa79dd43e feat: last_completed_by_level (per-level прогресс) + полный total_score + пагинация 2026-09-30 17:49:09 +00:00
Drobysh aebeaa833f feat: пагинация /words/all + /texts/all + CRUD текстов + глобальные дубликаты 2026-09-30 16:57:54 +00:00
Drobysh 0755533ae1 feat: пагинация для /words/all + GET texts/all + DELETE text + глобальные дубликаты 2026-09-30 16:46:28 +00:00
Drobysh 7bbce67cc4 feat(words): единый источник csv_words + CRUD + глобальная проверка дубликатов 2026-09-30 12:35:43 +00:00
Drobysh 6d0d1b5001 feat(words): единый источник csv_words — wordquiz, bubblewords, pronunciation + CRUD 2026-09-30 12:17:15 +00:00
Drobysh 2d82d615c7 fix(wordsearch): json.dumps для JSONB + usage_count reflect current levels 2026-09-30 09:53:58 +00:00
Drobysh 247eca55d1 fix(wordsearch): JSONB-строка → JSON.parse в admin_wordsearch + фронт 2026-09-30 09:35:15 +00:00
Drobysh 7dbfcbe760 feat(wordsearch): конструктор уровней + csv_words + word_usage + приоритет ручных в игре 2026-09-29 15:31:13 +00:00
38 changed files with 6580 additions and 569 deletions
+3
View File
@@ -9,3 +9,6 @@ uploads/
.DS_Store .DS_Store
.env.save .env.save
.env.* .env.*
*.backup_*
*.sql
*.backup*
+1 -2
View File
@@ -10,9 +10,8 @@
import asyncio import asyncio
import asyncpg import asyncpg
import json import json
import os
import logging import logging
from datetime import datetime, timedelta, timezone from datetime import datetime
from decimal import Decimal from decimal import Decimal
from pathlib import Path from pathlib import Path
from config import DB_CONFIG from config import DB_CONFIG
+21 -13
View File
@@ -89,15 +89,12 @@ async def verify_telegram_initdata(init_data: str):
async def require_auth(request: Request): async def require_auth(request: Request):
"""Извлекает и проверяет авторизацию из запроса. """Извлекает и проверяет авторизацию из запроса.
Два режима: Пять режимов (в порядке приоритета):
1. X-Admin-Token: <jwt> — админка через браузер (26.09.2026) 1. X-Admin-Token: <jwt> — админка через браузер (26.09.2026)
2. Authorization: tma <initData> — Telegram Mini App 2. Authorization: Bearer <jwt> — Pleily (07.10.2026)
3. Authorization: tma <initData> — Telegram Mini App
Приоритет: 4. X-Telegram-InitData — старый способ
1. X-Admin-Token — если есть, проверяем JWT. 5. query-параметр initData — fallback для deleteFeedPost
2. Authorization: tma <initData> — основной для Mini App.
3. X-Telegram-InitData — старый способ.
4. query-параметр initData — fallback для deleteFeedPost.
""" """
# ============ Режим 1: админ-токен ============ # ============ Режим 1: админ-токен ============
admin_token = request.headers.get('X-Admin-Token', '').strip() admin_token = request.headers.get('X-Admin-Token', '').strip()
@@ -112,19 +109,30 @@ async def require_auth(request: Request):
logger.warning(f"Admin token invalid: {e}") logger.warning(f"Admin token invalid: {e}")
raise HTTPException(401, "Invalid admin token") raise HTTPException(401, "Invalid admin token")
# ============ Режим 2: Telegram initData ============ # ============ Режим 2: Bearer JWT (Pleily) ============
# 🔧 НОВОЕ (07.10.2026): app_jwt_auth —
# мобильное приложение Pleily ходит с Authorization: Bearer <JWT>.
# verify_app_jwt возвращает payload с user_id (отрицательный для Pleily).
auth_header = request.headers.get('Authorization', '')
if auth_header.startswith('Bearer '):
from routers.app_auth import verify_app_jwt
token = auth_header[7:].strip()
payload = verify_app_jwt(token)
user_id = int(payload.get('user_id'))
return user_id, f"app_{user_id}"
# ============ Режим 3: Telegram initData ============
init_data = '' init_data = ''
# 2.1. Authorization: tma <initData> # 3.1. Authorization: tma <initData>
auth_header = request.headers.get('Authorization', '')
if auth_header.startswith('tma '): if auth_header.startswith('tma '):
init_data = auth_header[4:].strip() init_data = auth_header[4:].strip()
# 2.2. X-Telegram-InitData (старый способ) # 3.2. X-Telegram-InitData (старый способ)
if not init_data: if not init_data:
init_data = request.headers.get('X-Telegram-InitData', '') init_data = request.headers.get('X-Telegram-InitData', '')
# 2.3. Query-параметр (fallback, нужен для deleteFeedPost) # 3.3. Query-параметр (fallback, нужен для deleteFeedPost)
if not init_data: if not init_data:
init_data = request.query_params.get('initData', '') init_data = request.query_params.get('initData', '')
+3
View File
@@ -94,3 +94,6 @@ FEED_TARGET_LANGUAGES = ["pl", "ru", "uk", "en"]
ADMIN_LOGIN = os.getenv("ADMIN_LOGIN", "admin") ADMIN_LOGIN = os.getenv("ADMIN_LOGIN", "admin")
ADMIN_PASSWORD_HASH = os.getenv("ADMIN_PASSWORD_HASH", "") ADMIN_PASSWORD_HASH = os.getenv("ADMIN_PASSWORD_HASH", "")
ADMIN_JWT_SECRET = os.getenv("ADMIN_JWT_SECRET", "") ADMIN_JWT_SECRET = os.getenv("ADMIN_JWT_SECRET", "")
# 🔧 НОВОЕ (07.10.2026): app_jwt_secret — JWT для Pleily
APP_JWT_SECRET = os.getenv("APP_JWT_SECRET", "")
+522
View File
@@ -38,6 +38,43 @@ async def init_db():
) )
""") """)
# 🔧 ФИКС (30.09.2026): last_completed_by_level —
# per-level счётчик прогресса. Раньше был один last_completed_level,
# который смешивал A1+A2+B1 → юзер не мог открыть уровень выше max.
col_exists = await conn.fetchval("""
SELECT 1 FROM information_schema.columns
WHERE table_name = 'users' AND column_name = 'last_completed_by_level'
""")
if not col_exists:
await conn.execute("""
ALTER TABLE users ADD COLUMN last_completed_by_level JSONB DEFAULT '{}'::jsonb
""")
logger.info("Added last_completed_by_level column to users")
# Backfill из user_progress
await conn.execute("""
UPDATE users u
SET last_completed_by_level = COALESCE(sub.by_level, '{}'::jsonb)
FROM (
SELECT
user_id,
jsonb_object_agg(level, max_num) AS by_level
FROM (
SELECT
up.user_id,
up.level,
MAX(l.level_number) AS max_num
FROM user_progress up
JOIN levels l ON l.id = up.level_id
WHERE up.completed_at IS NOT NULL
GROUP BY up.user_id, up.level
) inner_sub
GROUP BY user_id
) sub
WHERE u.telegram_id = sub.user_id
""")
logger.info("Backfilled last_completed_by_level from user_progress")
# ============ Авто-миграция: добавляем current_level в users ============ # ============ Авто-миграция: добавляем current_level в users ============
col_exists = await conn.fetchval(""" col_exists = await conn.fetchval("""
SELECT 1 FROM information_schema.columns SELECT 1 FROM information_schema.columns
@@ -192,6 +229,21 @@ async def init_db():
""") """)
logger.info("Added current_streak column to user_progress") logger.info("Added current_streak column to user_progress")
# ============ Авто-миграция: добавляем wave в user_progress ============
# 🔧 НОВОЕ (13.10.2026): wave — номер волны, к которой относится
# пройденный уровень. Нужен для подсчёта wave_points (сумма очков
# за 10 уровней волны) в модалке итогов волны.
col_exists = await conn.fetchval("""
SELECT 1 FROM information_schema.columns
WHERE table_name = 'user_progress' AND column_name = 'wave'
""")
if not col_exists:
await conn.execute("""
ALTER TABLE user_progress
ADD COLUMN wave INTEGER
""")
logger.info("Added wave column to user_progress")
# ============ sentences ============ # ============ sentences ============
await conn.execute(""" await conn.execute("""
CREATE TABLE IF NOT EXISTS sentences ( CREATE TABLE IF NOT EXISTS sentences (
@@ -305,12 +357,17 @@ async def init_db():
""") """)
# ============ learning_topics ============ # ============ learning_topics ============
# 🔧 ОБНОВЛЕНО (04.10.2026): track — разделение аудиторий.
# 'pl' — для поляков (учёба на польском)
# 'ru_uk' — для славян (RU/UK ↔ PL, ОБЩИЙ track)
# 'en' — для англоязычных
await conn.execute(""" await conn.execute("""
CREATE TABLE IF NOT EXISTS learning_topics ( CREATE TABLE IF NOT EXISTS learning_topics (
id SERIAL PRIMARY KEY, id SERIAL PRIMARY KEY,
topic_id VARCHAR(100) UNIQUE NOT NULL, topic_id VARCHAR(100) UNIQUE NOT NULL,
level_code VARCHAR(10) NOT NULL, level_code VARCHAR(10) NOT NULL,
order_number INT NOT NULL, order_number INT NOT NULL,
track VARCHAR(10) NOT NULL DEFAULT 'ru_uk', -- 🔧 НОВОЕ
name_pl TEXT NOT NULL, name_pl TEXT NOT NULL,
name_ru TEXT NOT NULL, name_ru TEXT NOT NULL,
name_uk TEXT NOT NULL, name_uk TEXT NOT NULL,
@@ -324,6 +381,27 @@ async def init_db():
) )
""") """)
# 🔧 НОВОЕ (04.10.2026): track_auto_migration —
# для существующих БД добавляем колонку, если её нет.
col_exists = await conn.fetchval("""
SELECT 1 FROM information_schema.columns
WHERE table_name = 'learning_topics' AND column_name = 'track'
""")
if not col_exists:
await conn.execute("""
ALTER TABLE learning_topics
ADD COLUMN track VARCHAR(10) NOT NULL DEFAULT 'ru_uk'
""")
logger.info("Added track column to learning_topics")
# Backfill: все существующие темы → 'ru_uk' (славянский track)
await conn.execute("""
UPDATE learning_topics
SET track = 'ru_uk'
WHERE track IS NULL OR track = ''
""")
logger.info("Backfilled track='ru_uk' for existing topics")
# ============ learning_lessons ============ # ============ learning_lessons ============
await conn.execute(""" await conn.execute("""
CREATE TABLE IF NOT EXISTS learning_lessons ( CREATE TABLE IF NOT EXISTS learning_lessons (
@@ -430,6 +508,8 @@ async def init_db():
""") """)
# ============ user_learning_answers ============ # ============ user_learning_answers ============
# 🔧 ОБНОВЛЕНО (02.10.2026): добавлены revised и revision_of_id
# прямо в определение — на свежих БД создаются сразу.
await conn.execute(""" await conn.execute("""
CREATE TABLE IF NOT EXISTS user_learning_answers ( CREATE TABLE IF NOT EXISTS user_learning_answers (
id BIGSERIAL PRIMARY KEY, id BIGSERIAL PRIMARY KEY,
@@ -450,10 +530,46 @@ async def init_db():
hint_used BOOLEAN DEFAULT FALSE, hint_used BOOLEAN DEFAULT FALSE,
wrong_because VARCHAR(100), wrong_because VARCHAR(100),
is_final_answer BOOLEAN DEFAULT TRUE, is_final_answer BOOLEAN DEFAULT TRUE,
revised BOOLEAN DEFAULT FALSE, -- 🔧 НОВОЕ
revision_of_id BIGINT, -- 🔧 НОВОЕ
created_at TIMESTAMP DEFAULT NOW() created_at TIMESTAMP DEFAULT NOW()
) )
""") """)
# 🔧 НОВОЕ (02.10.2026): revised — фиксируем, что ученик
# поменял ответ после «Повторить урок».
col_exists = await conn.fetchval("""
SELECT 1 FROM information_schema.columns
WHERE table_name = 'user_learning_answers' AND column_name = 'revised'
""")
if not col_exists:
await conn.execute("""
ALTER TABLE user_learning_answers
ADD COLUMN revised BOOLEAN DEFAULT FALSE
""")
logger.info("Added revised column to user_learning_answers")
# 🔧 НОВОЕ (02.10.2026): revision_of_id — ссылка на предыдущий
# ответ этого же вопроса в этой же сессии. Позволяет строить
# цепочку: первый ответ → второй (после повтора) → третий.
col_exists = await conn.fetchval("""
SELECT 1 FROM information_schema.columns
WHERE table_name = 'user_learning_answers' AND column_name = 'revision_of_id'
""")
if not col_exists:
await conn.execute("""
ALTER TABLE user_learning_answers
ADD COLUMN revision_of_id BIGINT
""")
logger.info("Added revision_of_id column to user_learning_answers")
# Индекс для быстрого поиска цепочек повторов
await conn.execute("""
CREATE INDEX IF NOT EXISTS idx_learning_answers_revision
ON user_learning_answers(revision_of_id)
WHERE revision_of_id IS NOT NULL
""")
# ============ user_lesson_progress ============ # ============ user_lesson_progress ============
await conn.execute(""" await conn.execute("""
CREATE TABLE IF NOT EXISTS user_lesson_progress ( CREATE TABLE IF NOT EXISTS user_lesson_progress (
@@ -782,6 +898,46 @@ async def init_db():
""") """)
logger.info("Added current_hints_used column to bubble_words_progress") logger.info("Added current_hints_used column to bubble_words_progress")
# 🔧 НОВОЕ (14.10.2026): current_list_opened — серверный счётчик
# «показать слова» для текущего уровня пузырей. Medium — 1 раз.
col_exists = await conn.fetchval("""
SELECT 1 FROM information_schema.columns
WHERE table_name = 'bubble_words_progress' AND column_name = 'current_list_opened'
""")
if not col_exists:
await conn.execute("""
ALTER TABLE bubble_words_progress
ADD COLUMN current_list_opened INT DEFAULT 0
""")
logger.info("Added current_list_opened column to bubble_words_progress")
# 🔧 НОВОЕ (14.10.2026): current_level_words — состояние текущего
# уровня пузырей (слова + части + переводы). Нужно для подсказок,
# т.к. уровень генерируется на лету в /next и нигде не хранится.
col_exists = await conn.fetchval("""
SELECT 1 FROM information_schema.columns
WHERE table_name = 'bubble_words_progress' AND column_name = 'current_level_words'
""")
if not col_exists:
await conn.execute("""
ALTER TABLE bubble_words_progress
ADD COLUMN current_level_words JSONB DEFAULT '[]'::jsonb
""")
logger.info("Added current_level_words column to bubble_words_progress")
# 🔧 НОВОЕ (14.10.2026): hinted_words — какие слова уже получили
# подсказку «первая часть» (для «каждый раз разное слово»).
col_exists = await conn.fetchval("""
SELECT 1 FROM information_schema.columns
WHERE table_name = 'bubble_words_progress' AND column_name = 'hinted_words'
""")
if not col_exists:
await conn.execute("""
ALTER TABLE bubble_words_progress
ADD COLUMN hinted_words TEXT[] DEFAULT '{}'
""")
logger.info("Added hinted_words column to bubble_words_progress")
# ============ wrong_because_explanations ============ # ============ wrong_because_explanations ============
await conn.execute(""" await conn.execute("""
CREATE TABLE IF NOT EXISTS wrong_because_explanations ( CREATE TABLE IF NOT EXISTS wrong_because_explanations (
@@ -1068,6 +1224,372 @@ async def init_db():
await conn.execute("CREATE INDEX IF NOT EXISTS idx_levels_level_number ON levels(level, level_number)") await conn.execute("CREATE INDEX IF NOT EXISTS idx_levels_level_number ON levels(level, level_number)")
await conn.execute("CREATE INDEX IF NOT EXISTS idx_level_words_level_id ON level_words(level_id)") await conn.execute("CREATE INDEX IF NOT EXISTS idx_level_words_level_id ON level_words(level_id)")
await conn.execute("CREATE INDEX IF NOT EXISTS idx_level_words_level ON level_words(level)") await conn.execute("CREATE INDEX IF NOT EXISTS idx_level_words_level ON level_words(level)")
# ============ Авто-миграция: wordsearch builder (29.09.2026) ============
# is_active — черновик (FALSE) / опубликован (TRUE)
# created_by — telegram_id админа, создавшего вручную
# created_at — когда создан
col_exists = await conn.fetchval("""
SELECT 1 FROM information_schema.columns
WHERE table_name = 'levels' AND column_name = 'is_active'
""")
if not col_exists:
await conn.execute("""
ALTER TABLE levels ADD COLUMN is_active BOOLEAN DEFAULT TRUE
""")
logger.info("Added is_active column to levels")
col_exists = await conn.fetchval("""
SELECT 1 FROM information_schema.columns
WHERE table_name = 'levels' AND column_name = 'created_by'
""")
if not col_exists:
await conn.execute("""
ALTER TABLE levels ADD COLUMN created_by BIGINT
""")
logger.info("Added created_by column to levels")
col_exists = await conn.fetchval("""
SELECT 1 FROM information_schema.columns
WHERE table_name = 'levels' AND column_name = 'created_at'
""")
if not col_exists:
await conn.execute("""
ALTER TABLE levels ADD COLUMN created_at TIMESTAMP DEFAULT NOW()
""")
logger.info("Added created_at column to levels")
# Индекс для быстрого поиска опубликованных ручных уровней
await conn.execute("""
CREATE INDEX IF NOT EXISTS idx_levels_active_manual
ON levels(level, is_active, created_by)
WHERE is_active = TRUE AND created_by IS NOT NULL
""")
# ============ csv_words — слова из CSV для конструктора ============
await conn.execute("""
CREATE TABLE IF NOT EXISTS csv_words (
id SERIAL PRIMARY KEY,
level_code VARCHAR(10) NOT NULL,
word_pl TEXT NOT NULL,
translation_ru TEXT DEFAULT '',
translation_uk TEXT DEFAULT '',
translation_en TEXT DEFAULT '',
UNIQUE(level_code, word_pl)
)
""")
await conn.execute("""
CREATE INDEX IF NOT EXISTS idx_csv_words_level
ON csv_words(level_code)
""")
logger.info("Table csv_words initialized")
# ============ word_usage — счётчик использований слов ============
await conn.execute("""
CREATE TABLE IF NOT EXISTS word_usage (
id SERIAL PRIMARY KEY,
level_code VARCHAR(10) NOT NULL,
word_pl TEXT NOT NULL,
usage_count INT DEFAULT 0,
last_used_at TIMESTAMP DEFAULT NOW(),
UNIQUE(level_code, word_pl)
)
""")
await conn.execute("""
CREATE INDEX IF NOT EXISTS idx_word_usage_level_word
ON word_usage(level_code, word_pl)
""")
logger.info("Table word_usage initialized")
# ============ 🔧 НОВОЕ (07.10.2026): pleily_auth —
# поддержка авторизации мобильного приложения Pleily.
# - source: откуда пришёл юзер ('telegram' | 'pleily_device' | 'pleily_apple')
# - device_id: UUID устройства (анонимный вход)
# - apple_id: Apple ID (потом, для привязки прогресса)
# - app_user_id_seq: sequence для отрицательных user_id (Pleily-юзеры)
# - auth_identities: связка provider+provider_uid → user_id
# ============================================================
# source
col_exists = await conn.fetchval("""
SELECT 1 FROM information_schema.columns
WHERE table_name = 'users' AND column_name = 'source'
""")
if not col_exists:
await conn.execute("""
ALTER TABLE users ADD COLUMN source TEXT DEFAULT 'telegram'
""")
await conn.execute("""
UPDATE users SET source = 'telegram' WHERE source IS NULL
""")
logger.info("Added source column to users (Pleily)")
# device_id
col_exists = await conn.fetchval("""
SELECT 1 FROM information_schema.columns
WHERE table_name = 'users' AND column_name = 'device_id'
""")
if not col_exists:
await conn.execute("""
ALTER TABLE users ADD COLUMN device_id UUID
""")
await conn.execute("""
CREATE UNIQUE INDEX IF NOT EXISTS idx_users_device_id
ON users(device_id) WHERE device_id IS NOT NULL
""")
logger.info("Added device_id column to users (Pleily)")
# apple_id
col_exists = await conn.fetchval("""
SELECT 1 FROM information_schema.columns
WHERE table_name = 'users' AND column_name = 'apple_id'
""")
if not col_exists:
await conn.execute("""
ALTER TABLE users ADD COLUMN apple_id TEXT
""")
await conn.execute("""
CREATE UNIQUE INDEX IF NOT EXISTS idx_users_apple_id
ON users(apple_id) WHERE apple_id IS NOT NULL
""")
logger.info("Added apple_id column to users (Pleily)")
# difficulty
col_exists = await conn.fetchval("""
SELECT 1 FROM information_schema.columns
WHERE table_name = 'users' AND column_name = 'difficulty'
""")
if not col_exists:
await conn.execute("""
ALTER TABLE users ADD COLUMN difficulty TEXT DEFAULT 'medium'
""")
logger.info("Added difficulty column to users (Pleily)")
# app_user_id_seq — sequence для отрицательных user_id
await conn.execute("""
CREATE SEQUENCE IF NOT EXISTS app_user_id_seq
START -1
INCREMENT -1
MINVALUE -9223372036854775808
MAXVALUE -1
""")
logger.info("Table app_user_id_seq initialized (Pleily)")
# auth_identities — связка provider+provider_uid → user_id
await conn.execute("""
CREATE TABLE IF NOT EXISTS auth_identities (
id BIGSERIAL PRIMARY KEY,
user_id BIGINT NOT NULL REFERENCES users(telegram_id) ON DELETE CASCADE,
provider TEXT NOT NULL,
provider_uid TEXT NOT NULL,
created_at TIMESTAMP DEFAULT NOW(),
UNIQUE(provider, provider_uid)
)
""")
await conn.execute("""
CREATE INDEX IF NOT EXISTS idx_auth_identities_user
ON auth_identities(user_id)
""")
# Backfill: для существующих telegram-юзеров создаём identity
await conn.execute("""
INSERT INTO auth_identities (user_id, provider, provider_uid)
SELECT telegram_id, 'telegram', telegram_id::text
FROM users
WHERE telegram_id > 0
ON CONFLICT DO NOTHING
""")
logger.info("Table auth_identities initialized (Pleily)")
# ============================================================
# 🔧 НОВОЕ (08.10.2026): XP-фундамент Pleily.
# user_profile, xp_log, choose_progress, user_seen_levels,
# user_game_progress, wave_results, bubble_levels,
# user_seen_bubble_levels, user_word_stats.
# + расширение sentences (tokens, alt_orders, word_count).
# ============================================================
# ---------- user_profile ----------
await conn.execute("""
CREATE TABLE IF NOT EXISTS user_profile (
user_id BIGINT PRIMARY KEY
REFERENCES users(telegram_id) ON DELETE CASCADE,
nickname TEXT,
avatar_id INTEGER DEFAULT 0,
total_xp INTEGER DEFAULT 0,
weekly_xp INTEGER DEFAULT 0,
week_started_at DATE DEFAULT CURRENT_DATE,
updated_at TIMESTAMP DEFAULT NOW()
)
""")
await conn.execute("""
CREATE INDEX IF NOT EXISTS idx_user_profile_weekly
ON user_profile(weekly_xp DESC)
""")
logger.info("Table user_profile initialized (XP)")
# ---------- xp_log ----------
await conn.execute("""
CREATE TABLE IF NOT EXISTS xp_log (
id BIGSERIAL PRIMARY KEY,
user_id BIGINT NOT NULL
REFERENCES users(telegram_id) ON DELETE CASCADE,
game TEXT NOT NULL,
stars INTEGER NOT NULL,
base_points INTEGER NOT NULL,
multiplier NUMERIC(3,2) NOT NULL DEFAULT 1.0,
points INTEGER NOT NULL,
created_at TIMESTAMP DEFAULT NOW()
)
""")
await conn.execute("""
CREATE INDEX IF NOT EXISTS idx_xp_log_user_date
ON xp_log(user_id, created_at DESC)
""")
logger.info("Table xp_log initialized (XP)")
# ---------- choose_progress (серии в "Выбери слово") ----------
await conn.execute("""
CREATE TABLE IF NOT EXISTS choose_progress (
user_id BIGINT PRIMARY KEY
REFERENCES users(telegram_id) ON DELETE CASCADE,
current_streak INTEGER DEFAULT 0,
best_streak INTEGER DEFAULT 0,
updated_at TIMESTAMP DEFAULT NOW()
)
""")
logger.info("Table choose_progress initialized")
# ---------- user_seen_levels (филворд: какие уровни видел) ----------
await conn.execute("""
CREATE TABLE IF NOT EXISTS user_seen_levels (
user_id BIGINT NOT NULL
REFERENCES users(telegram_id) ON DELETE CASCADE,
level_id INTEGER NOT NULL
REFERENCES levels(id) ON DELETE CASCADE,
seen_at TIMESTAMP DEFAULT NOW(),
PRIMARY KEY (user_id, level_id)
)
""")
await conn.execute("""
CREATE INDEX IF NOT EXISTS idx_user_seen_levels_user
ON user_seen_levels(user_id, seen_at DESC)
""")
logger.info("Table user_seen_levels initialized")
# ---------- user_game_progress (сессии филворда) ----------
await conn.execute("""
CREATE TABLE IF NOT EXISTS user_game_progress (
user_id BIGINT PRIMARY KEY
REFERENCES users(telegram_id) ON DELETE CASCADE,
session_number INTEGER DEFAULT 1,
session_level_number INTEGER DEFAULT 1,
global_level_number INTEGER DEFAULT 1,
time_limit_seconds INTEGER,
updated_at TIMESTAMP DEFAULT NOW()
)
""")
logger.info("Table user_game_progress initialized")
# ---------- wave_results (итоги волны) ----------
await conn.execute("""
CREATE TABLE IF NOT EXISTS wave_results (
id BIGSERIAL PRIMARY KEY,
user_id BIGINT NOT NULL
REFERENCES users(telegram_id) ON DELETE CASCADE,
wave_number INTEGER NOT NULL,
stars_earned INTEGER DEFAULT 0,
medal TEXT DEFAULT 'none',
completed_at TIMESTAMP DEFAULT NOW(),
UNIQUE (user_id, wave_number)
)
""")
await conn.execute("""
CREATE INDEX IF NOT EXISTS idx_wave_results_user
ON wave_results(user_id, wave_number DESC)
""")
logger.info("Table wave_results initialized")
# ---------- bubble_levels ----------
await conn.execute("""
CREATE TABLE IF NOT EXISTS bubble_levels (
id BIGSERIAL PRIMARY KEY,
word_ids INTEGER[] NOT NULL,
difficulty INTEGER DEFAULT 1,
created_at TIMESTAMP DEFAULT NOW()
)
""")
logger.info("Table bubble_levels initialized")
# ---------- user_seen_bubble_levels ----------
await conn.execute("""
CREATE TABLE IF NOT EXISTS user_seen_bubble_levels (
user_id BIGINT NOT NULL
REFERENCES users(telegram_id) ON DELETE CASCADE,
bubble_level_id BIGINT NOT NULL
REFERENCES bubble_levels(id) ON DELETE CASCADE,
seen_at TIMESTAMP DEFAULT NOW(),
PRIMARY KEY (user_id, bubble_level_id)
)
""")
logger.info("Table user_seen_bubble_levels initialized")
# ---------- user_word_stats (повторение слов) ----------
await conn.execute("""
CREATE TABLE IF NOT EXISTS user_word_stats (
user_id BIGINT NOT NULL
REFERENCES users(telegram_id) ON DELETE CASCADE,
word_pl TEXT NOT NULL,
correct INTEGER DEFAULT 0,
wrong INTEGER DEFAULT 0,
last_seen_at TIMESTAMP DEFAULT NOW(),
PRIMARY KEY (user_id, word_pl)
)
""")
await conn.execute("""
CREATE INDEX IF NOT EXISTS idx_user_word_stats_user
ON user_word_stats(user_id, last_seen_at DESC)
""")
logger.info("Table user_word_stats initialized")
# ---------- sentences: tokens, alt_orders, word_count ----------
for col_name, col_type in (
("tokens", "JSONB DEFAULT '[]'::jsonb"),
("alt_orders", "JSONB DEFAULT '[]'::jsonb"),
("word_count", "INTEGER DEFAULT 0"),
):
col_exists = await conn.fetchval("""
SELECT 1 FROM information_schema.columns
WHERE table_name = 'sentences' AND column_name = $1
""", col_name)
if not col_exists:
await conn.execute(
f"ALTER TABLE sentences ADD COLUMN {col_name} {col_type}"
)
logger.info(f"Added {col_name} column to sentences")
# Backfill: word_count для существующих предложений
await conn.execute("""
UPDATE sentences
SET word_count = array_length(
regexp_split_to_array(trim(sentence_pl), '\\s+'), 1
)
WHERE word_count = 0 OR word_count IS NULL
""")
logger.info("Backfilled sentences.word_count")
# ---------- Backfill: user_profile для существующих юзеров ----------
await conn.execute("""
INSERT INTO user_profile (user_id, total_xp, weekly_xp)
SELECT u.telegram_id, 0, 0
FROM users u
WHERE NOT EXISTS (
SELECT 1 FROM user_profile p WHERE p.user_id = u.telegram_id
)
ON CONFLICT (user_id) DO NOTHING
""")
logger.info("Backfilled user_profile for existing users")
await conn.execute("CREATE INDEX IF NOT EXISTS idx_sentences_level_number ON sentences(level, sentence_number)") await conn.execute("CREATE INDEX IF NOT EXISTS idx_sentences_level_number ON sentences(level, sentence_number)")
# Оставляем score-индексы (не дубли) # Оставляем score-индексы (не дубли)
await conn.execute("CREATE INDEX IF NOT EXISTS idx_user_progress_score ON user_progress(score DESC)") await conn.execute("CREATE INDEX IF NOT EXISTS idx_user_progress_score ON user_progress(score DESC)")
+1
View File
@@ -523,6 +523,7 @@
| last_completed_level | integer | YES | 0 | | last_completed_level | integer | YES | 0 |
| id | integer | NO | nextval('users_id_seq'::regclass) | | id | integer | NO | nextval('users_id_seq'::regclass) |
| current_level | text | YES | 'A1'::text | | current_level | text | YES | 'A1'::text |
| difficulty | text | YES | 'medium'::text |
## voice_usage ## voice_usage
+3 -3
View File
@@ -4,7 +4,7 @@
Что делает: Что делает:
1. Проверяет, есть ли фраза на сегодня в daily_phrases 1. Проверяет, есть ли фраза на сегодня в daily_phrases
2. Если нет — генерирует через AI (MiniMax-M3) 2. Если нет — генерирует через AI (DeepSeek V4 Pro)
3. Пишет в daily_phrases с phrase_date = CURRENT_DATE 3. Пишет в daily_phrases с phrase_date = CURRENT_DATE
Fallback: если AI упал — пишет запасную фразу. Fallback: если AI упал — пишет запасную фразу.
@@ -25,7 +25,7 @@ logging.basicConfig(
logger = logging.getLogger(__name__) logger = logging.getLogger(__name__)
TOGETHER_API_URL = "https://api.together.xyz/v1/chat/completions" TOGETHER_API_URL = "https://api.together.xyz/v1/chat/completions"
TEACHER_MODEL = "MiniMaxAI/MiniMax-M3" TEACHER_MODEL = "deepseek-ai/DeepSeek-V4-Pro-0813"
# Список тем для фразы дня # Список тем для фразы дня
TOPICS_LIST = [ TOPICS_LIST = [
@@ -119,7 +119,7 @@ EN_GRAMMAR: [грамматический разбор на английском
user_prompt = f"Создай фразу дня на тему: {selected_topic}." user_prompt = f"Создай фразу дня на тему: {selected_topic}."
ai_response = await call_ai(system_prompt, user_prompt, max_tokens=1000) ai_response = await call_ai(system_prompt, user_prompt, max_tokens=3000)
if not ai_response: if not ai_response:
logger.warning("AI returned empty response, using fallback") logger.warning("AI returned empty response, using fallback")
+17 -5
View File
@@ -2,19 +2,20 @@ import asyncio
import ipaddress import ipaddress
import logging import logging
import os import os
import re
import time import time
from collections import defaultdict from collections import defaultdict
from contextlib import asynccontextmanager from contextlib import asynccontextmanager
from pathlib import Path from fastapi import FastAPI, Request
from fastapi import FastAPI, Request, HTTPException
from fastapi.middleware.cors import CORSMiddleware from fastapi.middleware.cors import CORSMiddleware
from fastapi.responses import JSONResponse from fastapi.responses import JSONResponse
from fastapi.staticfiles import StaticFiles from fastapi.staticfiles import StaticFiles
from config import FRONTEND_ORIGINS, UPLOADS_DIR, CF_IPS from config import FRONTEND_ORIGINS, UPLOADS_DIR, CF_IPS
from database import init_db from database import init_db
from routers import users, game, hints, leaderboard, sentences, achievements, wordquiz, bubblewords, pronunciation, assistant, learning, tts, typing, teacher, support, admin, feed, admin_content from routers import users, game, hints, leaderboard, sentences, achievements, wordquiz, bubblewords, pronunciation, assistant, learning, tts, typing, teacher, support, admin, feed, admin_content
from routers import lectures, admin_auth from routers import lectures, admin_auth, admin_wordsearch, admin_users
from routers import admin_ai # 🔧 НОВОЕ
from routers import app_auth # 🆕 Pleily auth
from routers import featured as featured_router # 🔧 НОВОЕ (08.10.2026)
from routers.sentences import init_sentences from routers.sentences import init_sentences
from routers.achievements import init_achievements from routers.achievements import init_achievements
from routers.learning_data import init_learning_data from routers.learning_data import init_learning_data
@@ -69,7 +70,10 @@ class RateLimiter:
"/game/check-word": {"max_requests": 30, "window": 60}, "/game/check-word": {"max_requests": 30, "window": 60},
"/game/complete-level": {"max_requests": 10, "window": 60}, "/game/complete-level": {"max_requests": 10, "window": 60},
"/sentences/check": {"max_requests": 20, "window": 60}, "/sentences/check": {"max_requests": 20, "window": 60},
"/leaderboard": {"max_requests": 10, "window": 60}, # 🔧 ФИКС (30.09.2026): leaderboard_rate_limit_too_low —
# Mini App делает несколько запросов подряд при загрузке страницы
# (аватар + данные + ре-рендер) → 429. Подняли до 30/мин.
"/leaderboard": {"max_requests": 30, "window": 60},
"/assistant/chat": {"max_requests": 20, "window": 60}, "/assistant/chat": {"max_requests": 20, "window": 60},
"/learning/answer": {"max_requests": 30, "window": 60}, "/learning/answer": {"max_requests": 30, "window": 60},
"/tts": {"max_requests": 30, "window": 60}, "/tts": {"max_requests": 30, "window": 60},
@@ -89,6 +93,9 @@ class RateLimiter:
# 🔧 ФИКС (22.09.2026): дорогой AI-эндпоинт без лимита выжигал бюджет. # 🔧 ФИКС (22.09.2026): дорогой AI-эндпоинт без лимита выжигал бюджет.
"/learning/analytics": {"max_requests": 5, "window": 60}, "/learning/analytics": {"max_requests": 5, "window": 60},
"/learning/practice/start": {"max_requests": 10, "window": 60}, "/learning/practice/start": {"max_requests": 10, "window": 60},
# 🆕 Pleily (07.10.2026): лимит на вход по device_id.
# Защищает от спама создания новых юзеров.
"/auth/device": {"max_requests": 5, "window": 60},
} }
self._cleanup_task = None self._cleanup_task = None
@@ -365,6 +372,11 @@ app.include_router(feed.router)
app.include_router(admin_content.router) app.include_router(admin_content.router)
app.include_router(lectures.router) app.include_router(lectures.router)
app.include_router(admin_auth.router) app.include_router(admin_auth.router)
app.include_router(admin_wordsearch.router)
app.include_router(admin_users.router)
app.include_router(admin_ai.router) # 🔧 НОВОЕ
app.include_router(app_auth.router) # 🆕 Pleily
app.include_router(featured_router.router) # 🔧 НОВОЕ (08.10.2026)
# ============ Базовые эндпоинты ============ # ============ Базовые эндпоинты ============
+1
View File
@@ -37,3 +37,4 @@ urllib3==2.7.0
uvicorn==0.51.0 uvicorn==0.51.0
yarl==1.24.5 yarl==1.24.5
pdfplumber==0.11.10 pdfplumber==0.11.10
PyJWT==2.15.1
+63 -38
View File
@@ -1,6 +1,6 @@
import logging import logging
from fastapi import APIRouter, Request, HTTPException from fastapi import APIRouter, Request
from auth import require_auth from auth import require_auth
from database import get_pool from database import get_pool
@@ -8,7 +8,7 @@ logger = logging.getLogger(__name__)
router = APIRouter(prefix="/achievements", tags=["achievements"]) router = APIRouter(prefix="/achievements", tags=["achievements"])
# ============ Данные 52 достижений ============ # ============ Данные 55 достижений ============
ACHIEVEMENTS_DATA = [ ACHIEVEMENTS_DATA = [
# ===== Word Search (11) ===== # ===== Word Search (11) =====
{"code": "first_level", "category": "wordsearch", "icon": "🔰", {"code": "first_level", "category": "wordsearch", "icon": "🔰",
@@ -66,6 +66,52 @@ ACHIEVEMENTS_DATA = [
"desc_pl": "Znajdź 5 słów bez błędu", "desc_ru": "Найти 5 слов подряд без ошибок", "desc_uk": "Знайти 5 слів без помилки", "desc_en": "Find 5 words without mistakes", "desc_pl": "Znajdź 5 słów bez błędu", "desc_ru": "Найти 5 слов подряд без ошибок", "desc_uk": "Знайти 5 слів без помилки", "desc_en": "Find 5 words without mistakes",
"type": "perfect_words", "value": 5}, "type": "perfect_words", "value": 5},
# ===== Word Search — волны (9 новых, 11.10.2026) =====
{"code": "ws_wave_1", "category": "wordsearch", "icon": "🌊",
"name_pl": "Pierwsza fala", "name_ru": "Первая волна", "name_uk": "Перша хвиля", "name_en": "First Wave",
"desc_pl": "Ukończ pierwszą falę (10 poziomów)", "desc_ru": "Пройти первую волну (10 уровней)", "desc_uk": "Пройти першу хвилю (10 рівнів)", "desc_en": "Complete your first wave (10 levels)",
"type": "waves_completed", "value": 1},
{"code": "ws_wave_5", "category": "wordsearch", "icon": "🌊",
"name_pl": "Pięć fal", "name_ru": "Пять волн", "name_uk": "П'ять хвиль", "name_en": "Five Waves",
"desc_pl": "Ukończ 5 fal", "desc_ru": "Пройти 5 волн", "desc_uk": "Пройти 5 хвиль", "desc_en": "Complete 5 waves",
"type": "waves_completed", "value": 5},
{"code": "ws_wave_10", "category": "wordsearch", "icon": "🌊",
"name_pl": "Dziesięć fal", "name_ru": "Десять волн", "name_uk": "Десять хвиль", "name_en": "Ten Waves",
"desc_pl": "Ukończ 10 fal", "desc_ru": "Пройти 10 волн", "desc_uk": "Пройти 10 хвиль", "desc_en": "Complete 10 waves",
"type": "waves_completed", "value": 10},
{"code": "ws_wave_25", "category": "wordsearch", "icon": "🌊",
"name_pl": "Dwadzieścia pięć fal", "name_ru": "Двадцать пять волн", "name_uk": "Двадцять п'ять хвиль", "name_en": "Twenty-Five Waves",
"desc_pl": "Ukończ 25 fal", "desc_ru": "Пройти 25 волн", "desc_uk": "Пройти 25 хвиль", "desc_en": "Complete 25 waves",
"type": "waves_completed", "value": 25},
{"code": "ws_wave_50", "category": "wordsearch", "icon": "🌊",
"name_pl": "Pięćdziesiąt fal", "name_ru": "Пятьдесят волн", "name_uk": "П'ятдесят хвиль", "name_en": "Fifty Waves",
"desc_pl": "Ukończ 50 fal", "desc_ru": "Пройти 50 волн", "desc_uk": "Пройти 50 хвиль", "desc_en": "Complete 50 waves",
"type": "waves_completed", "value": 50},
{"code": "ws_speed_run_3", "category": "wordsearch", "icon": "⚡",
"name_pl": "Szybka seria", "name_ru": "Быстрая серия", "name_uk": "Швидка серія", "name_en": "Speed Run",
"desc_pl": "Ukończ 3 poziomy z rzędu, każdy w mniej niż 30 sekund", "desc_ru": "Пройти 3 уровня подряд, каждый быстрее 30 секунд", "desc_uk": "Пройти 3 рівні поспіль, кожен швидше 30 секунд", "desc_en": "Complete 3 levels in a row, each under 30 seconds",
"type": "ws_speed_run", "value": 3},
{"code": "ws_wave_no_hints", "category": "wordsearch", "icon": "🎯",
"name_pl": "Fala bez podpowiedzi", "name_ru": "Волна без подсказок", "name_uk": "Хвиля без підказок", "name_en": "Flawless Wave",
"desc_pl": "Ukończ całą falę (10 poziomów) bez podpowiedzi", "desc_ru": "Пройти всю волну (10 уровней) без подсказок", "desc_uk": "Пройти всю хвилю (10 рівнів) без підказок", "desc_en": "Complete a whole wave (10 levels) without hints",
"type": "ws_no_hints_streak", "value": 10},
{"code": "ws_words_1000", "category": "wordsearch", "icon": "📚",
"name_pl": "Tysiąc słów", "name_ru": "Тысяча слов", "name_uk": "Тисяча слів", "name_en": "Thousand Words",
"desc_pl": "Znajdź 1000 słów w filwordach", "desc_ru": "Найти 1000 слов в филвордах", "desc_uk": "Знайти 1000 слів у філвордах", "desc_en": "Find 1000 words in word searches",
"type": "wordsearch_words", "value": 1000},
{"code": "ws_xp_10000", "category": "wordsearch", "icon": "💎",
"name_pl": "Diament filwordów", "name_ru": "Бриллиант филвордов", "name_uk": "Діамант філвордів", "name_en": "Word Search Diamond",
"desc_pl": "Zdobądź 10 000 XP w filwordach", "desc_ru": "Набрать 10 000 XP в филвордах", "desc_uk": "Набрати 10 000 XP у філвордах", "desc_en": "Earn 10,000 XP in word searches",
"type": "wordsearch_xp", "value": 10000},
# ===== Sentence Builder (10) ===== # ===== Sentence Builder (10) =====
{"code": "first_sentence", "category": "sentence", "icon": "📝", {"code": "first_sentence", "category": "sentence", "icon": "📝",
"name_pl": "Debiutant", "name_ru": "Дебютант", "name_uk": "Дебютант", "name_en": "Debutant", "name_pl": "Debiutant", "name_ru": "Дебютант", "name_uk": "Дебютант", "name_en": "Debutant",
@@ -199,7 +245,7 @@ ACHIEVEMENTS_DATA = [
"desc_pl": "Ukończ poziom w mniej niż 30 sekund", "desc_ru": "Пройти уровень быстрее 30 секунд", "desc_uk": "Пройти рівень швидше 30 секунд", "desc_en": "Complete a level in under 30 seconds", "desc_pl": "Ukończ poziom w mniej niż 30 sekund", "desc_ru": "Пройти уровень быстрее 30 секунд", "desc_uk": "Пройти рівень швидше 30 секунд", "desc_en": "Complete a level in under 30 seconds",
"type": "bubble_speed", "value": 30}, "type": "bubble_speed", "value": 30},
# ===== General (15) ===== # ===== General (9) =====
{"code": "score_1000", "category": "general", "icon": "🌟", {"code": "score_1000", "category": "general", "icon": "🌟",
"name_pl": "Wschodząca gwiazda", "name_ru": "Восходящая звезда", "name_uk": "Висхідна зірка", "name_en": "Rising Star", "name_pl": "Wschodząca gwiazda", "name_ru": "Восходящая звезда", "name_uk": "Висхідна зірка", "name_en": "Rising Star",
"desc_pl": "Zdobądź 1000 punktów", "desc_ru": "Набрать 1000 очков", "desc_uk": "Набрати 1000 балів", "desc_en": "Earn 1000 points", "desc_pl": "Zdobądź 1000 punktów", "desc_ru": "Набрать 1000 очков", "desc_uk": "Набрати 1000 балів", "desc_en": "Earn 1000 points",
@@ -245,42 +291,7 @@ ACHIEVEMENTS_DATA = [
"desc_pl": "Zmień język interfejsu", "desc_ru": "Сменить язык интерфейса", "desc_uk": "Змінити мову інтерфейсу", "desc_en": "Change interface language", "desc_pl": "Zmień język interfejsu", "desc_ru": "Сменить язык интерфейса", "desc_uk": "Змінити мову інтерфейсу", "desc_en": "Change interface language",
"type": "language_changed", "value": 1}, "type": "language_changed", "value": 1},
# 🔧 ИСПРАВЛЕНО: Заменено достижение "Открой Грамматику" на "Открой меню учителя"
{"code": "open_teacher_menu", "category": "general", "icon": "🎓",
"name_pl": "Uczeń", "name_ru": "Ученик", "name_uk": "Учень", "name_en": "Student",
"desc_pl": "Otwórz menu nauczyciela", "desc_ru": "Открыть меню учителя", "desc_uk": "Відкрити меню вчителя", "desc_en": "Open the teacher menu",
"type": "teacher_menu_opened", "value": 1},
{"code": "open_cheatsheets", "category": "general", "icon": "📝",
"name_pl": "Ciekawski", "name_ru": "Любознательный", "name_uk": "Допитливий", "name_en": "Curious",
"desc_pl": "Otwórz sekcję Ściągi", "desc_ru": "Открыть раздел Шпаргалки", "desc_uk": "Відкрити розділ Шпаргалки", "desc_en": "Open the Cheatsheets section",
"type": "cheatsheets_opened", "value": 1},
{"code": "open_pronunciation", "category": "general", "icon": "🔊",
"name_pl": "Słuchacz", "name_ru": "Слушатель", "name_uk": "Слухач", "name_en": "Listener",
"desc_pl": "Otwórz sekcję Wymowa", "desc_ru": "Открыть раздел Произношение", "desc_uk": "Відкрити розділ Вимова", "desc_en": "Open the Pronunciation section",
"type": "pronunciation_opened", "value": 1},
{"code": "open_ai_assistant", "category": "general", "icon": "🤖",
"name_pl": "Asystent AI", "name_ru": "AI-помощник", "name_uk": "AI-помічник", "name_en": "AI Assistant",
"desc_pl": "Otwórz Asystenta AI", "desc_ru": "Открыть AI-помощника", "desc_uk": "Відкрити AI-помічника", "desc_en": "Open the AI Assistant",
"type": "ai_assistant_opened", "value": 1},
{"code": "open_alphabet", "category": "general", "icon": "🔤",
"name_pl": "Alfabetysta", "name_ru": "Алфавитист", "name_uk": "Алфавітист", "name_en": "Alphabetist",
"desc_pl": "Otwórz sekcję Alfabet", "desc_ru": "Открыть раздел Алфавит", "desc_uk": "Відкрити розділ Алфавіт", "desc_en": "Open the Alphabet section",
"type": "alphabet_opened", "value": 1},
{"code": "open_rules", "category": "general", "icon": "📐",
"name_pl": "Gramatyk", "name_ru": "Грамматик", "name_uk": "Граматик", "name_en": "Grammarian",
"desc_pl": "Otwórz sekcję Zasady", "desc_ru": "Открыть раздел Правила", "desc_uk": "Відкрити розділ Правила", "desc_en": "Open the Rules section",
"type": "rules_opened", "value": 1},
# 🔧 НОВОЕ: Достижение за открытие Прогресса
{"code": "open_progress", "category": "general", "icon": "📊",
"name_pl": "Planista", "name_ru": "Планировщик", "name_uk": "Планувальник", "name_en": "Planner",
"desc_pl": "Otwórz sekcję Postęp", "desc_ru": "Открыть раздел Прогресс", "desc_uk": "Відкрити розділ Прогрес", "desc_en": "Open the Progress section",
"type": "progress_opened", "value": 1},
] ]
@@ -323,6 +334,20 @@ async def init_achievements():
requirement_value = EXCLUDED.requirement_value requirement_value = EXCLUDED.requirement_value
""", rows) """, rows)
# 🔧 Удаление осиротевших достижений (которых больше нет в ACHIEVEMENTS_DATA)
await conn.execute("""
DELETE FROM user_achievements
WHERE achievement_id IN (
SELECT id FROM achievements
WHERE code NOT IN (SELECT unnest($1::text[]))
)
""", [a["code"] for a in ACHIEVEMENTS_DATA])
await conn.execute("""
DELETE FROM achievements
WHERE code NOT IN (SELECT unnest($1::text[]))
""", [a["code"] for a in ACHIEVEMENTS_DATA])
logger.info(f"[achievements] init: upserted {len(rows)} achievements") logger.info(f"[achievements] init: upserted {len(rows)} achievements")
+130 -10
View File
@@ -2,9 +2,15 @@
Admin Router — админ-панель с реальной статистикой проекта. Admin Router — админ-панель с реальной статистикой проекта.
1. /admin/dashboard — общая статистика (юзеры, онлайн, по уровням) 1. /admin/dashboard — общая статистика (юзеры, онлайн, по уровням)
2. /admin/sentry-errors — ошибки из Sentry (через API) 2. /admin/sentry-errors — ошибки из Sentry (через API)
3. /admin/sentry-stats — сводка по ошибкам Sentry
🔧 ОБНОВЛЕНО (01.10.2026):
- /sentry-errors: расширенные фильтры (period, status, level, q, limit)
- /sentry-stats: новый эндпоинт для сводки
""" """
import os import os
import logging import logging
from typing import Optional
import httpx import httpx
from fastapi import APIRouter, Request, HTTPException from fastapi import APIRouter, Request, HTTPException
from auth import require_auth from auth import require_auth
@@ -102,10 +108,23 @@ async def get_admin_dashboard(request: Request):
@router.get("/sentry-errors") @router.get("/sentry-errors")
async def get_sentry_errors(request: Request): async def get_sentry_errors(
request: Request,
period: str = "24h",
status: str = "unresolved",
level: Optional[str] = None,
q: Optional[str] = None,
limit: int = 50,
):
""" """
Последние ошибки из Sentry. 🔧 ОБНОВЛЕНО (01.10.2026): расширенные фильтры для Sentry.
Возвращает только unresolved (нерешённые) за последние 24 часа.
Параметры:
- period: '1h', '24h', '7d', '14d', '30d' (по умолчанию 24h)
- status: 'unresolved', 'resolved', 'all' (по умолчанию unresolved)
- level: 'error', 'warning', 'info', 'debug' (опционально)
- q: поиск по title
- limit: 1-100 (по умолчанию 50)
""" """
telegram_id, _ = await require_auth(request) telegram_id, _ = await require_auth(request)
_require_admin(telegram_id) _require_admin(telegram_id)
@@ -113,15 +132,47 @@ async def get_sentry_errors(request: Request):
if not SENTRY_AUTH_TOKEN: if not SENTRY_AUTH_TOKEN:
return {"errors": [], "error": "SENTRY_AUTH_TOKEN not configured"} return {"errors": [], "error": "SENTRY_AUTH_TOKEN not configured"}
# Валидация
# 🔧 ФИКС (01.10.2026): sentry_free_plan_periods —
# Free plan Sentry поддерживает ТОЛЬКО '', '24h', '14d'.
# Остальные → 400 Bad Request.
if period not in ("", "24h", "14d"):
period = "24h"
if status not in ("unresolved", "resolved", "all"):
status = "unresolved"
if level and level not in ("error", "warning", "info", "debug", "fatal"):
level = None
if limit < 1:
limit = 1
elif limit > 100:
limit = 100
# Собираем query для Sentry
query_parts = []
if status == "unresolved":
query_parts.append("is:unresolved")
elif status == "resolved":
query_parts.append("is:resolved")
# 'all' — без фильтра статуса
if level:
query_parts.append(f"level:{level}")
if q and q.strip():
query_parts.append(q.strip())
query = " ".join(query_parts) if query_parts else ""
url = f"{SENTRY_API_BASE}/projects/{SENTRY_ORG_SLUG}/{SENTRY_PROJECT_SLUG}/issues/" url = f"{SENTRY_API_BASE}/projects/{SENTRY_ORG_SLUG}/{SENTRY_PROJECT_SLUG}/issues/"
params = { params = {
"query": "is:unresolved", "statsPeriod": period,
"statsPeriod": "24h", "limit": limit,
"limit": 20, "sort": "freq", # сортировка по частоте
}
headers = {
"Authorization": f"Bearer {SENTRY_AUTH_TOKEN}",
} }
if query:
params["query"] = query
headers = {"Authorization": f"Bearer {SENTRY_AUTH_TOKEN}"}
try: try:
async with httpx.AsyncClient(timeout=10.0) as client: async with httpx.AsyncClient(timeout=10.0) as client:
@@ -147,9 +198,11 @@ async def get_sentry_errors(request: Request):
"last_seen": issue.get("lastSeen"), "last_seen": issue.get("lastSeen"),
"permalink": issue.get("permalink"), "permalink": issue.get("permalink"),
"priority": issue.get("priority"), "priority": issue.get("priority"),
"status": issue.get("status"), # unresolved / resolved
"metadata": issue.get("metadata", {}),
}) })
return {"errors": errors, "count": len(errors)} return {"errors": errors, "count": len(errors), "query": query or "(no filter)"}
except httpx.TimeoutException: except httpx.TimeoutException:
logger.error("Sentry API timeout") logger.error("Sentry API timeout")
@@ -157,3 +210,70 @@ async def get_sentry_errors(request: Request):
except Exception as e: except Exception as e:
logger.error(f"Sentry API unexpected error: {e}") logger.error(f"Sentry API unexpected error: {e}")
return {"errors": [], "error": str(e)} return {"errors": [], "error": str(e)}
@router.get("/sentry-stats")
async def get_sentry_stats(request: Request, period: str = "24h"):
"""
🔧 НОВОЕ (01.10.2026): сводка по ошибкам Sentry.
Возвращает:
- total_unresolved: всего нерешённых
- total_24h: новых за 24ч
- by_level: распределение по уровням (error / warning / info)
- top_culprits: топ-5 проблемных файлов
"""
telegram_id, _ = await require_auth(request)
_require_admin(telegram_id)
if not SENTRY_AUTH_TOKEN:
return {"error": "SENTRY_AUTH_TOKEN not configured"}
# 🔧 ФИКС (01.10.2026): sentry_free_plan_periods — только '', '24h', '14d'.
if period not in ("", "24h", "14d"):
period = "24h"
url = f"{SENTRY_API_BASE}/projects/{SENTRY_ORG_SLUG}/{SENTRY_PROJECT_SLUG}/issues/"
params = {
"query": "is:unresolved",
"statsPeriod": period,
"limit": 100,
}
headers = {"Authorization": f"Bearer {SENTRY_AUTH_TOKEN}"}
try:
async with httpx.AsyncClient(timeout=10.0) as client:
response = await client.get(url, params=params, headers=headers)
if response.status_code != 200:
return {"error": f"Sentry API: {response.status_code}"}
raw_issues = response.json()
# Считаем
by_level: dict = {}
culprits: dict = {}
for issue in raw_issues:
lvl = issue.get("level", "error")
by_level[lvl] = by_level.get(lvl, 0) + 1
culprit = issue.get("culprit", "unknown")
culprits[culprit] = culprits.get(culprit, 0) + int(issue.get("count", 0))
top_culprits = sorted(
[{"culprit": k, "count": v} for k, v in culprits.items()],
key=lambda x: x["count"],
reverse=True,
)[:5]
return {
"total_unresolved": len(raw_issues),
"by_level": by_level,
"top_culprits": top_culprits,
"period": period,
}
except Exception as e:
logger.error(f"Sentry stats error: {e}")
return {"error": str(e)}
+321
View File
@@ -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,
}
+1308 -6
View File
File diff suppressed because it is too large Load Diff
+242
View File
@@ -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,
}
+738
View File
@@ -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
],
}
+287
View File
@@ -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}
-1
View File
@@ -5,7 +5,6 @@ AI Assistant Router — чат-помощник с историей, конте
""" """
import logging import logging
import time import time
import json
import httpx import httpx
from fastapi import APIRouter, Request, HTTPException from fastapi import APIRouter, Request, HTTPException
from auth import require_auth from auth import require_auth
+240 -54
View File
@@ -1,6 +1,6 @@
import random import random
import time
import hashlib # 🔧 НОВОЕ: импорт hashlib для стабильного хэширования import hashlib # 🔧 НОВОЕ: импорт hashlib для стабильного хэширования
import json
from fastapi import APIRouter, Request, HTTPException from fastapi import APIRouter, Request, HTTPException
from auth import require_auth from auth import require_auth
from database import get_pool from database import get_pool
@@ -101,7 +101,7 @@ async def get_next_bubble_level(request: Request):
pool = await get_pool() pool = await get_pool()
async with pool.acquire() as conn: async with pool.acquire() as conn:
user = await conn.fetchrow( user = await conn.fetchrow(
"SELECT app_language, current_level FROM users WHERE telegram_id = $1", telegram_id "SELECT app_language, current_level, difficulty FROM users WHERE telegram_id = $1", telegram_id
) )
if not user: if not user:
raise HTTPException(401, "User not registered") raise HTTPException(401, "User not registered")
@@ -115,22 +115,17 @@ async def get_next_bubble_level(request: Request):
) )
current_bubble_level = (progress["levels_completed"] if progress else 0) + 1 current_bubble_level = (progress["levels_completed"] if progress else 0) + 1
# Прогрессия по количеству слов на уровне # Количество слов по сложности
if current_bubble_level <= 10: difficulty = user["difficulty"] if "difficulty" in user.keys() else "medium"
num_words = random.choice([3, 4]) num_words = {"easy": 3, "medium": 4, "hard": 5}.get(difficulty, 4)
elif current_bubble_level <= 25:
num_words = random.choice([5, 6])
else:
num_words = random.choice([7, 8])
# Запрос слов с фильтром по уровню и level_id IS NULL # 🔧 ФИКС (30.09.2026): csv_words_source —
# источник слов переехал с level_words (старая схема level_id IS NULL)
# на csv_words (level_code). Один источник — CSV-база.
words = await conn.fetch(""" words = await conn.fetch("""
SELECT word_pl, translation_ru, translation_uk, translation_en SELECT word_pl, translation_ru, translation_uk, translation_en
FROM ( FROM csv_words
SELECT DISTINCT ON (word_pl) word_pl, translation_ru, translation_uk, translation_en WHERE level_code = $1
FROM level_words
WHERE level = $1 AND level_id IS NULL
) AS unique_words
ORDER BY RANDOM() ORDER BY RANDOM()
LIMIT $2 LIMIT $2
""", current_level, num_words) """, current_level, num_words)
@@ -164,22 +159,191 @@ async def get_next_bubble_level(request: Request):
random.shuffle(all_parts) random.shuffle(all_parts)
# 🔧 НОВОЕ (14.10.2026): сохраняем состояние уровня для подсказок
# и сбрасываем счётчики подсказок/списка при новом уровне.
level_state = [
{
"word_pl": w["word_pl"],
"translation": w["translation"],
"parts": w["parts"],
}
for w in result_words
]
await conn.execute("""
INSERT INTO bubble_words_progress
(user_id, levels_completed, total_score, level,
current_hints_used, current_list_opened, current_level_words, hinted_words)
VALUES ($1, 0, 0, $2, 0, 0, $3::jsonb, '{}')
ON CONFLICT (user_id) DO UPDATE
SET current_hints_used = 0,
current_list_opened = 0,
current_level_words = $3::jsonb,
hinted_words = '{}'
""", telegram_id, current_level, json.dumps(level_state))
return { return {
"words": result_words, "words": result_words,
"bubbles": all_parts, "bubbles": all_parts,
"level": current_bubble_level, "level": current_bubble_level,
"difficulty": user["difficulty"] or "medium",
}
@router.post("/first-part-hint")
async def first_part_hint(request: Request):
"""Подсказка «первая часть слова» — возвращает первый пузырь одного из несобранных слов.
🔧 НОВОЕ (14.10.2026): аналог GET /hints/first-letter/{level_id} из филворда.
Лимит 3 подсказки, штраф −20 (учитывается в /complete через current_hints_used).
Hard — запрещено (400).
"""
telegram_id, _ = await require_auth(request)
body = await request.json()
found_words = set(body.get("found_words", []) or [])
pool = await get_pool()
async with pool.acquire() as conn:
user = await conn.fetchrow(
"SELECT difficulty FROM users WHERE telegram_id = $1", telegram_id
)
if not user:
raise HTTPException(401, "User not registered")
difficulty = user["difficulty"] or "medium"
if difficulty == "hard":
raise HTTPException(400, "Hints are disabled on Hard difficulty")
progress = await conn.fetchrow(
"SELECT current_hints_used, current_level_words, hinted_words "
"FROM bubble_words_progress WHERE user_id = $1",
telegram_id
)
if not progress:
raise HTTPException(404, "No active level")
hints_used = progress["current_hints_used"] or 0
if hints_used >= 3:
raise HTTPException(400, "All hints used")
raw = progress["current_level_words"]
if isinstance(raw, str):
level_words = json.loads(raw) if raw else []
else:
level_words = raw or []
raw_hinted = progress["hinted_words"]
if isinstance(raw_hinted, str):
hinted = set(json.loads(raw_hinted)) if raw_hinted else set()
else:
hinted = set(raw_hinted or [])
# Слова, которые ещё не собраны и которым ещё не давали подсказку
candidates = [
w for w in level_words
if w.get("word_pl") not in found_words and w.get("word_pl") not in hinted
]
if not candidates:
raise HTTPException(400, "All words already hinted")
chosen = random.choice(candidates)
word_pl = chosen["word_pl"]
parts = chosen.get("parts") or []
first_part = parts[0] if parts else word_pl
new_hints = hints_used + 1
new_hinted = sorted(hinted | {word_pl})
await conn.execute("""
UPDATE bubble_words_progress
SET current_hints_used = $2,
hinted_words = $3
WHERE user_id = $1
""", telegram_id, new_hints, new_hinted)
return {
"word_pl": word_pl,
"first_part": first_part,
"hints_used_total": new_hints,
}
@router.post("/show-words")
async def show_words(request: Request):
"""Подсказка «показать слова» — возвращает все загаданные слова с переводами.
🔧 НОВОЕ (14.10.2026): аналог show-words из филворда.
Easy — без лимита. Medium — 1 раз (−20). Hard — запрещено (400).
"""
telegram_id, _ = await require_auth(request)
pool = await get_pool()
async with pool.acquire() as conn:
user = await conn.fetchrow(
"SELECT difficulty FROM users WHERE telegram_id = $1", telegram_id
)
if not user:
raise HTTPException(401, "User not registered")
difficulty = user["difficulty"] or "medium"
if difficulty == "hard":
raise HTTPException(400, "Word list is disabled on Hard difficulty")
progress = await conn.fetchrow(
"SELECT current_list_opened, current_level_words "
"FROM bubble_words_progress WHERE user_id = $1",
telegram_id
)
if not progress:
raise HTTPException(404, "No active level")
list_opened = progress["current_list_opened"] or 0
# Medium — список можно открыть только 1 раз
if difficulty == "medium" and list_opened >= 1:
raise HTTPException(400, "Word list already used on Medium difficulty")
raw = progress["current_level_words"]
if isinstance(raw, str):
level_words = json.loads(raw) if raw else []
else:
level_words = raw or []
words = [
{"word_pl": w.get("word_pl"), "translation": w.get("translation")}
for w in level_words
]
# Инкремент счётчика для Easy и Medium (Hard сюда не доходит)
new_list_opened = list_opened + 1
await conn.execute("""
UPDATE bubble_words_progress
SET current_list_opened = $2
WHERE user_id = $1
""", telegram_id, new_list_opened)
return {
"words": words,
"list_opened_total": new_list_opened,
} }
@router.post("/complete") @router.post("/complete")
async def complete_bubble_level(request: Request): async def complete_bubble_level(request: Request):
"""Завершение уровня пузырей, начисление очков и проверка достижений""" """Завершение уровня пузырей, начисление XP и проверка достижений.
🔧 НОВОЕ (08.10.2026): XP-система.
Штрафы:
-1 за открытие списка слов (один раз за уровень)
-1 за каждое неправильно собранное слово (макс 3)
-1 если time_ms > 60 сек
Минимум 1 звезда.
"""
telegram_id, _ = await require_auth(request) telegram_id, _ = await require_auth(request)
body = await request.json() body = await request.json()
words_count = body.get("words_count", 3) words_count = body.get("words_count", 3)
completion_time = body.get("completion_time") completion_time = body.get("completion_time")
# 🔧 ФИКС (24.09.2026): client_controlled_hints_bubblewords — wrong_words = int(body.get("wrong_words", 0) or 0)
# hints_used больше НЕ берём от клиента. Читаем из bubble_words_progress.current_hints_used.
pool = await get_pool() pool = await get_pool()
async with pool.acquire() as conn: async with pool.acquire() as conn:
@@ -189,66 +353,77 @@ async def complete_bubble_level(request: Request):
if not user_exists: if not user_exists:
raise HTTPException(401, "User not registered") raise HTTPException(401, "User not registered")
# Получаем current_level пользователя user = await conn.fetchrow(
current_level = await conn.fetchval( "SELECT current_level, difficulty FROM users WHERE telegram_id = $1", telegram_id
"SELECT current_level FROM users WHERE telegram_id = $1", telegram_id )
) or "A1" current_level = user["current_level"] or "A1"
difficulty = user["difficulty"] or "medium"
# 🔧 ФИКС (24.09.2026): client_controlled_hints_bubblewords — # Читаем серверные счётчики (не из body)
# читаем серверный hints_used. progress = await conn.fetchrow(
hints_used = await conn.fetchval( "SELECT current_hints_used, current_list_opened "
"SELECT current_hints_used FROM bubble_words_progress WHERE user_id = $1", "FROM bubble_words_progress WHERE user_id = $1",
telegram_id telegram_id
) or 0 )
hints_used = (progress["current_hints_used"] if progress else 0) or 0
hints_used = min(max(0, hints_used), 3) hints_used = min(max(0, hints_used), 3)
score = max(10, 100 - hints_used * 10) list_opened = (progress["current_list_opened"] if progress else 0) or 0
# 🔧 НОВОЕ (14.10.2026): очки по формуле филворда.
# Hard — фикс 110. Easy/Medium — 100 − 20×hints − 20×list + bonus.
if difficulty == "hard":
if hints_used > 0 or list_opened:
raise HTTPException(
status_code=400,
detail="Hints and word list are disabled on Hard difficulty"
)
points = 110
else:
bonus = 10 if hints_used == 0 else 0
penalty_hints = 20 * hints_used
penalty_list = 0 if difficulty == "easy" else 20 * (1 if list_opened else 0)
points = max(20, min(110, 100 - penalty_hints - penalty_list + bonus))
# Начисляем XP
from services.xp import award_xp
xp_result = await award_xp(conn, telegram_id, "bubbles", points)
score = xp_result["points"]
await conn.execute(""" await conn.execute("""
INSERT INTO bubble_words_progress (user_id, levels_completed, total_score, level, current_hints_used) INSERT INTO bubble_words_progress
VALUES ($1, 1, $2, $3, 0) (user_id, levels_completed, total_score, level,
current_hints_used, current_list_opened, current_level_words, hinted_words)
VALUES ($1, 1, $2, $3, 0, 0, '[]'::jsonb, '{}')
ON CONFLICT (user_id) DO UPDATE ON CONFLICT (user_id) DO UPDATE
SET levels_completed = bubble_words_progress.levels_completed + 1, SET levels_completed = bubble_words_progress.levels_completed + 1,
total_score = bubble_words_progress.total_score + $2, total_score = bubble_words_progress.total_score + $2,
level = $3, level = $3,
current_hints_used = 0 current_hints_used = 0,
current_list_opened = 0,
current_level_words = '[]'::jsonb,
hinted_words = '{}'
""", telegram_id, score, current_level) """, telegram_id, score, current_level)
# 🔧 ФИКС (23.09.2026): achievements_nested_pool_acquire_bubblewords — # Данные для достижений
# вызовы достижений вынесены за async with pool.acquire() (паттерн game.py).
total_levels = await conn.fetchval( total_levels = await conn.fetchval(
"SELECT levels_completed FROM bubble_words_progress WHERE user_id = $1", "SELECT levels_completed FROM bubble_words_progress WHERE user_id = $1",
telegram_id telegram_id
) or 0 ) or 0
wordsearch_score = await conn.fetchval(
"SELECT COALESCE(SUM(score), 0) FROM user_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
telegram_id
) or 0
sentence_score = await conn.fetchval(
"SELECT COALESCE(SUM(score), 0) FROM sentence_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
telegram_id
) or 0
wordquiz_score = await conn.fetchval(
"SELECT COALESCE(total_score, 0) FROM word_quiz_progress WHERE user_id = $1",
telegram_id
) or 0
bubblewords_score = await conn.fetchval(
"SELECT COALESCE(total_score, 0) FROM bubble_words_progress WHERE user_id = $1",
telegram_id
) or 0
grand_total = wordsearch_score + sentence_score + wordquiz_score + bubblewords_score
achievements_to_check = [ achievements_to_check = [
("bubble_levels", total_levels), ("bubble_levels", total_levels),
("total_score", grand_total), ("total_score", xp_result["total_xp"]),
] ]
if hints_used == 0: if hints_used == 0:
achievements_to_check.append(("bubble_no_hints", 1)) achievements_to_check.append(("bubble_no_hints", 1))
if score == 100: if hints_used == 0 and not list_opened and wrong_words == 0:
achievements_to_check.append(("bubble_perfect", 1)) achievements_to_check.append(("bubble_perfect", 1))
if completion_time is not None and completion_time > 0 and int(completion_time) <= 45: if completion_time is not None and 0 < completion_time <= 45:
achievements_to_check.append(("bubble_speed", 45)) achievements_to_check.append(("bubble_speed", 45))
if completion_time is not None and 0 < completion_time <= 30:
achievements_to_check.append(("bubble_speed_30", 30))
# 🔧 ФИКС (23.09.2026): вызовы достижений ВНЕ блока async with pool.acquire() # Достижения — вне транзакции
from routers.achievements import check_and_award_achievements from routers.achievements import check_and_award_achievements
new_achievements = [] new_achievements = []
for ach_type, value in achievements_to_check: for ach_type, value in achievements_to_check:
@@ -260,6 +435,17 @@ async def complete_bubble_level(request: Request):
"score": score, "score": score,
"completion_time": completion_time, "completion_time": completion_time,
"new_achievements": new_achievements, "new_achievements": new_achievements,
# 🆕 XP-поля
"base_points": xp_result["base_points"],
"multiplier": xp_result["multiplier"],
"points": xp_result["points"],
"featured": xp_result["featured"],
"level_up": xp_result["level_up"],
"total_xp": xp_result["total_xp"],
"level": xp_result["level"],
"rank_key": xp_result["rank_key"],
"xp_in_level": xp_result["xp_in_level"],
"xp_needed": xp_result["xp_needed"],
} }
+36
View File
@@ -0,0 +1,36 @@
"""GET /featured — игра дня + обратный отсчёт."""
from fastapi import APIRouter, Request
from auth import require_auth
from services.xp import featured_game, featured_seconds_left, GAMES
router = APIRouter(tags=["featured"])
# 🆕 Игры, которые реально работают в приложении.
# Пока не подключим все 4 — фильтруем.
PLAYABLE_GAMES = {"wordsearch"} # потом добавим choose, sentence, bubbles
@router.get("/featured")
async def get_featured(request: Request):
"""
Возвращает игру дня (глобально для всех) и секунды до смены.
🔧 (08.10.2026): если игра дня ещё не подключена в приложении —
отдаём ближайшую играбельную (для UI-подсказки ×1.5).
"""
await require_auth(request)
game = featured_game()
# Если featured не играбельная — отдаём первую играбельную
if game not in PLAYABLE_GAMES:
playable = [g for g in GAMES if g in PLAYABLE_GAMES]
if playable:
game = playable[0]
return {
"game": game,
"seconds_left": featured_seconds_left(),
"multiplier": 1.5,
"is_actually_featured": game == featured_game(),
}
+179 -5
View File
@@ -11,6 +11,8 @@ Feed Router — посты для карусели (новости / партн
- POST /admin/feed/post/{id}/delete — удалить (вложения удалит CASCADE) - POST /admin/feed/post/{id}/delete — удалить (вложения удалит CASCADE)
- POST /admin/feed/upload-image — загрузить картинку (multipart, до 3 на пост) - POST /admin/feed/upload-image — загрузить картинку (multipart, до 3 на пост)
- POST /admin/feed/translate — перевести title+body вручную (без сохранения) - POST /admin/feed/translate — перевести title+body вручную (без сохранения)
- GET /admin/feed/list — список постов для админки (пагинация, все 4 языка)
- GET /admin/feed/stats — быстрая статистика (total/drafts/published/pinned)
Логика локализации: Логика локализации:
- В БД хранятся 4 версии поста (title_pl/ru/uk/en, body_pl/ru/uk/en). - В БД хранятся 4 версии поста (title_pl/ru/uk/en, body_pl/ru/uk/en).
@@ -21,9 +23,8 @@ import logging
import json import json
import re import re
import uuid import uuid
import os
from pathlib import Path from pathlib import Path
from typing import Optional, Any from typing import Optional
import httpx import httpx
from fastapi import APIRouter, Request, HTTPException, UploadFile, File, Form from fastapi import APIRouter, Request, HTTPException, UploadFile, File, Form
@@ -45,7 +46,7 @@ logger = logging.getLogger(__name__)
router = APIRouter(tags=["feed"]) router = APIRouter(tags=["feed"])
TOGETHER_API_URL = "https://api.together.xyz/v1/chat/completions" TOGETHER_API_URL = "https://api.together.xyz/v1/chat/completions"
TRANSLATE_MODEL = "MiniMaxAI/MiniMax-M3" TRANSLATE_MODEL = "deepseek-ai/DeepSeek-V4-Pro-0813"
# 🔧 ФИКС: бэк отдаёт полный URL картинки, чтобы фронт не гадал, # 🔧 ФИКС: бэк отдаёт полный URL картинки, чтобы фронт не гадал,
# куда склеивать относительный путь /uploads/feed/... # куда склеивать относительный путь /uploads/feed/...
@@ -252,7 +253,7 @@ async def translate_to_all_languages(
{"role": "system", "content": system_prompt}, {"role": "system", "content": system_prompt},
{"role": "user", "content": user_prompt}, {"role": "user", "content": user_prompt},
], ],
"max_tokens": 2000, "max_tokens": 4000,
"temperature": 0.3, "temperature": 0.3,
}, },
) )
@@ -322,7 +323,7 @@ async def admin_create_feed_post(request: Request):
"expires_at": "2026-10-15T23:59:59Z" (опционально, для partners) "expires_at": "2026-10-15T23:59:59Z" (опционально, для partners)
} }
Backend автоматически переведёт title/body на 4 языка через MiniMax-M3. Backend автоматически переведёт title/body на 4 языка через DeepSeek V4 Pro.
Если перевод упал — сохраняем source_language для всех языков (fallback). Если перевод упал — сохраняем source_language для всех языков (fallback).
""" """
telegram_id, _ = await require_auth(request) telegram_id, _ = await require_auth(request)
@@ -789,3 +790,176 @@ async def admin_translate_feed(request: Request):
raise HTTPException(500, "Translation failed (AI unavailable or invalid response)") raise HTTPException(500, "Translation failed (AI unavailable or invalid response)")
return translations return translations
# ============ ADMIN: СПИСОК ПОСТОВ (с пагинацией) ============
@router.get("/admin/feed/list")
async def admin_list_feed_posts(
request: Request,
section: Optional[str] = None,
page: int = 1,
limit: int = 50,
include_drafts: bool = True,
q: Optional[str] = None,
):
"""
🔧 НОВОЕ (01.10.2026): admin_feed_list —
список постов для админки со ВСЕМИ 4 языками + пагинация.
Query:
section — news|partners|contacts|apps (опционально)
page — страница (с 1)
limit — размер страницы (по умолчанию 50, макс 100)
include_drafts — включать is_published=FALSE (по умолчанию True)
q — поиск по title_pl / body_pl (ILIKE)
Ответ:
{ total, page, limit, pages, posts: [...] }
"""
telegram_id, _ = await require_auth(request)
_require_admin(telegram_id)
# Валидация
if section and section not in FEED_SECTIONS:
raise HTTPException(400, f"Invalid section: {section}")
# Защита от дурака
page = max(1, page)
limit = max(1, min(100, limit))
pool = await get_pool()
async with pool.acquire() as conn:
where = []
params = []
idx = 1
if section:
where.append(f"section = ${idx}")
params.append(section)
idx += 1
if not include_drafts:
where.append("is_published = TRUE")
if q:
where.append(f"(title_pl ILIKE ${idx} OR body_pl ILIKE ${idx} OR title_ru ILIKE ${idx} OR body_ru ILIKE ${idx})")
params.append(f"%{q}%")
idx += 1
where_sql = "WHERE " + " AND ".join(where) if where else ""
# Общее количество
total = await conn.fetchval(
f"SELECT COUNT(*) FROM feed_posts {where_sql}",
*params,
) or 0
# Страница
offset = (page - 1) * limit
rows = await conn.fetch(f"""
SELECT * FROM feed_posts
{where_sql}
ORDER BY section, is_pinned DESC, created_at DESC
LIMIT ${idx} OFFSET ${idx + 1}
""", *params, limit, offset)
if not rows:
return {
"total": total,
"page": page,
"limit": limit,
"pages": (total + limit - 1) // limit,
"posts": [],
}
# Вложения одним запросом (без N+1)
post_ids = [r["id"] for r in rows]
att_rows = await conn.fetch("""
SELECT post_id, file_path, order_number
FROM feed_attachments
WHERE post_id = ANY($1::bigint[])
ORDER BY post_id, order_number ASC
""", post_ids)
att_by_post: dict[int, list] = {}
for a in att_rows:
att_by_post.setdefault(a["post_id"], []).append(dict(a))
# Собираем результат
posts = []
for r in rows:
row = dict(r)
attachments = att_by_post.get(r["id"], [])
images = [
f"{API_PUBLIC_URL}{a['file_path']}" if a["file_path"].startswith("/") else a["file_path"]
for a in attachments
]
posts.append({
"id": row["id"],
"section": row["section"],
"source_language": row.get("source_language"),
"is_pinned": bool(row.get("is_pinned")),
"is_published": bool(row.get("is_published")),
"link_url": row.get("link_url"),
"telegram_url": row.get("telegram_url"),
"created_at": row["created_at"].isoformat() if row.get("created_at") else None,
"updated_at": row["updated_at"].isoformat() if row.get("updated_at") else None,
"expires_at": row["expires_at"].isoformat() if row.get("expires_at") else None,
"images": images,
# все 4 языка
"title_pl": row.get("title_pl") or "",
"title_ru": row.get("title_ru") or "",
"title_uk": row.get("title_uk") or "",
"title_en": row.get("title_en") or "",
"body_pl": row.get("body_pl") or "",
"body_ru": row.get("body_ru") or "",
"body_uk": row.get("body_uk") or "",
"body_en": row.get("body_en") or "",
})
return {
"total": total,
"page": page,
"limit": limit,
"pages": (total + limit - 1) // limit,
"posts": posts,
}
# ============ ADMIN: СТАТИСТИКА ДЛЯ БЕЙДЖА ============
@router.get("/admin/feed/stats")
async def admin_feed_stats(request: Request):
"""
🔧 НОВОЕ (01.10.2026): admin_feed_stats —
быстрая статистика для бейджа в сайдбаре.
Ответ:
{
"total": 42, — всего постов
"drafts": 2, — черновиков (is_published=FALSE)
"published": 40, — опубликованных
"pinned": 3 — закреплённых
}
"""
telegram_id, _ = await require_auth(request)
_require_admin(telegram_id)
pool = await get_pool()
async with pool.acquire() as conn:
row = await conn.fetchrow("""
SELECT
COUNT(*) AS total,
COUNT(*) FILTER (WHERE is_published = FALSE) AS drafts,
COUNT(*) FILTER (WHERE is_published = TRUE) AS published,
COUNT(*) FILTER (WHERE is_pinned = TRUE) AS pinned
FROM feed_posts
""")
return {
"total": int(row["total"] or 0),
"drafts": int(row["drafts"] or 0),
"published": int(row["published"] or 0),
"pinned": int(row["pinned"] or 0),
}
+476 -38
View File
@@ -13,7 +13,8 @@ async def get_progress(request: Request):
pool = await get_pool() pool = await get_pool()
async with pool.acquire() as conn: async with pool.acquire() as conn:
user = await conn.fetchrow( user = await conn.fetchrow(
"SELECT last_completed_level, current_level FROM users WHERE telegram_id = $1", """SELECT last_completed_level, current_level, last_completed_by_level
FROM users WHERE telegram_id = $1""",
telegram_id telegram_id
) )
@@ -26,6 +27,12 @@ async def get_progress(request: Request):
current_level = user["current_level"] or "A1" current_level = user["current_level"] or "A1"
# 🔧 ОБНОВЛЕНО (07.10.2026): единый счётчик progress.
# Раньше возвращали last_completed_for_current из per-level JSONB,
# но уровни теперь глобальные (level = 'common').
# Возвращаем users.last_completed_level — единый глобальный прогресс.
last_completed = user["last_completed_level"] or 0
# Очки из филвордов # Очки из филвордов
wordsearch_score = await conn.fetchval( wordsearch_score = await conn.fetchval(
"SELECT COALESCE(SUM(score), 0) FROM user_progress WHERE user_id = $1", "SELECT COALESCE(SUM(score), 0) FROM user_progress WHERE user_id = $1",
@@ -53,7 +60,7 @@ async def get_progress(request: Request):
total_score = (wordsearch_score or 0) + (sentence_score or 0) + (wordquiz_score or 0) + (bubblewords_score or 0) total_score = (wordsearch_score or 0) + (sentence_score or 0) + (wordquiz_score or 0) + (bubblewords_score or 0)
return { return {
"last_completed_level": user["last_completed_level"] or 0, "last_completed_level": last_completed,
"total_score": total_score, "total_score": total_score,
"current_level": current_level "current_level": current_level
} }
@@ -66,7 +73,7 @@ async def get_level(request: Request, level_number: int):
pool = await get_pool() pool = await get_pool()
async with pool.acquire() as conn: async with pool.acquire() as conn:
user = await conn.fetchrow( user = await conn.fetchrow(
"SELECT app_language, current_level, last_completed_level FROM users WHERE telegram_id = $1", telegram_id "SELECT app_language, current_level, last_completed_level, last_completed_by_level, difficulty FROM users WHERE telegram_id = $1", telegram_id
) )
if not user: if not user:
@@ -74,20 +81,43 @@ async def get_level(request: Request, level_number: int):
lang = user["app_language"] or "pl" lang = user["app_language"] or "pl"
current_level = user["current_level"] or "A1" current_level = user["current_level"] or "A1"
# 🔧 ОБНОВЛЕНО (07.10.2026): единый счётчик (без per-level).
# Уровни глобальные (level = 'common'), поэтому прогресс —
# users.last_completed_level. last_completed_by_level оставлен
# в БД для совместимости, но больше не используется здесь.
last_completed = user["last_completed_level"] or 0 last_completed = user["last_completed_level"] or 0
# Проверяем, что уровень доступен (не дальше следующего за пройденным) # 🔧 ОБНОВЛЕНО (07.10.2026): все уровни — common (автогенерированные).
if level_number > 1 and level_number > last_completed + 1: # Ищем по level_number без created_by и без current_level.
raise HTTPException(403, "Level not available yet. Complete previous level first.") # is_active = TRUE — чтобы черновики не показывались.
level = await conn.fetchrow("""
# Получаем уровень по его номеру ВНУТРИ выбранного уровня SELECT * FROM levels
level = await conn.fetchrow( WHERE level_number = $1
"SELECT * FROM levels WHERE level = $1 AND level_number = $2", current_level, level_number AND is_active = TRUE
) LIMIT 1
""", level_number)
if not level: if not level:
raise HTTPException(404, "Level not found") raise HTTPException(404, "Level not found")
# 🔧 ФИКС (10.10.2026): доступ к уровню по user_seen_levels.
# Раньше проверяли level_number > last_completed + 1 — это ломало
# волновую выдачу, где уровни идут вперемешку (5×5 → 6×6 → ...).
# Теперь уровень доступен, если игрок получил его через /game/next
# (есть в user_seen_levels) или уже прошёл (completed_at IS NOT NULL).
# Проверка идёт ПОСЛЕ загрузки уровня, т.к. нужен level["id"].
already_completed = await conn.fetchval(
"SELECT 1 FROM user_progress WHERE user_id = $1 AND level_id = $2 AND completed_at IS NOT NULL",
telegram_id, level["id"]
)
seen = await conn.fetchval(
"SELECT 1 FROM user_seen_levels WHERE user_id = $1 AND level_id = $2",
telegram_id, level["id"]
)
if not seen and not already_completed:
raise HTTPException(403, "Level not available. Get it via /game/next.")
words = await conn.fetch( words = await conn.fetch(
"SELECT * FROM level_words WHERE level_id = $1", level["id"] "SELECT * FROM level_words WHERE level_id = $1", level["id"]
) )
@@ -97,12 +127,43 @@ async def get_level(request: Request, level_number: int):
telegram_id, level["id"], telegram_id, level["id"],
) )
# 🔧 ФИКС (10.10.2026): wave_off_by_one —
# wave/pos хранятся в момент выдачи. Если NULL — fallback.
wave_pos = await conn.fetchrow(
"SELECT current_wave, current_position_in_wave FROM user_game_progress WHERE user_id = $1",
telegram_id,
)
if wave_pos and wave_pos["current_wave"] and wave_pos["current_position_in_wave"]:
current_wave = int(wave_pos["current_wave"])
current_pos = int(wave_pos["current_position_in_wave"])
else:
global_level = await conn.fetchval(
"SELECT global_level_number FROM user_game_progress WHERE user_id = $1",
telegram_id,
)
global_level = int(global_level or 1)
from services.waves import wave_for_level, level_in_wave
current_wave = wave_for_level(global_level)
current_pos = level_in_wave(global_level)
# 🔧 ОБНОВЛЕНО (09.10.2026): отдаём ВСЕ 4 перевода.
# Flutter сам выбирает, какой показать по context.lang.
# Старое поле 'translation' оставлено для совместимости (legacy).
word_list = [] word_list = []
for w in words: for w in words:
translation = w.get(f"translation_{lang}", "") or w.get("translation_pl", "") or w.get("translation_en", "") legacy_translation = (
w.get(f"translation_{lang}", "")
or w.get("translation_en", "")
or ""
)
word_list.append({ word_list.append({
"word_pl": w["word_pl"], "word_pl": w["word_pl"],
"translation": translation, # Legacy (для старого Flutter)
"translation": legacy_translation,
# 🆕 Все переводы (Flutter сам выбирает)
"translation_ru": w.get("translation_ru") or "",
"translation_uk": w.get("translation_uk") or "",
"translation_en": w.get("translation_en") or "",
}) })
grid_letters = level["grid_letters"] grid_letters = level["grid_letters"]
@@ -125,6 +186,10 @@ async def get_level(request: Request, level_number: int):
) )
) )
# 🔧 ФИКС (10.10.2026): wave/pos из зафиксированных значений.
wave = current_wave
pos_in_wave = current_pos
return { return {
"level": { "level": {
"id": level["id"], "id": level["id"],
@@ -140,6 +205,10 @@ async def get_level(request: Request, level_number: int):
"hints_used": progress["hints_used"] if progress else 0, "hints_used": progress["hints_used"] if progress else 0,
"score": progress["score"] if progress else 0, "score": progress["score"] if progress else 0,
}, },
# 🆕 (10.10.2026): волна и позиция в волне.
"wave": wave,
"position_in_wave": pos_in_wave,
"difficulty": user["difficulty"] or "medium",
} }
@@ -184,8 +253,18 @@ async def check_word(request: Request):
continue continue
selected_word = selected_word.lower() selected_word = selected_word.lower()
for word in word_paths.keys(): # 🔧 ФИКС (11.10.2026): word_matched_by_letters_only —
if word.lower() == selected_word: # раньше слово зачислялось только по буквам. Если те же буквы
# встречаются в другом месте сетки (например NOS вверху и внизу),
# сервер зачислял слово, хотя игрок собрал его не там.
# Теперь проверяем координаты: selected_cells должны точно
# совпасть с word_paths[word].
selected_path = [[int(cell[0]), int(cell[1])] for cell in selected_cells]
for word, path in word_paths.items():
if word.lower() != selected_word:
continue
expected_path = [[int(p[0]), int(p[1])] for p in path]
if selected_path == expected_path:
found_word = word found_word = word
break break
@@ -230,7 +309,7 @@ async def check_word(request: Request):
"new_achievements": new_achievements "new_achievements": new_achievements
} }
return {"status": "ok", "found": False, "server_streak": 0} return {"status": "ok", "found": False, "server_streak": 0, "reason": "wrong_path"}
@router.post("/complete-level") @router.post("/complete-level")
@@ -267,15 +346,32 @@ async def complete_level(request: Request):
# 🔧 ФИКС (24.09.2026): client_controlled_hints_game — # 🔧 ФИКС (24.09.2026): client_controlled_hints_game —
# hints_used читаем из БД, не доверяем клиенту. # hints_used читаем из БД, не доверяем клиенту.
hints_used = 0 hints_used = 0
# 🔧 НОВОЕ (08.10.2026): XP-система — результат award_xp.
xp_result = None
# 🆕 (11.10.2026): волновые счётчики для достижений.
waves_completed = 0
wordsearch_xp = 0
fast_streak = 0
no_hints_streak = 0
words_found = 0
# 🆕 (13.10.2026): итоги волны для модалки.
wave_completed = False
wave_points = 0
wave_max_points = 0
wave_medal_result = "none"
current_wave = 1
current_position_in_wave = 1
async with pool.acquire() as conn: async with pool.acquire() as conn:
user = await conn.fetchrow( user = await conn.fetchrow(
"SELECT id, telegram_id, last_completed_level, current_level FROM users WHERE telegram_id = $1", "SELECT id, telegram_id, last_completed_level, current_level, difficulty FROM users WHERE telegram_id = $1",
telegram_id telegram_id
) )
if not user: if not user:
raise HTTPException(401, "User not registered") raise HTTPException(401, "User not registered")
difficulty = user["difficulty"] or "medium"
level = await conn.fetchrow( level = await conn.fetchrow(
"SELECT id, level_number, grid_size, level FROM levels WHERE id = $1", level_id "SELECT id, level_number, grid_size, level FROM levels WHERE id = $1", level_id
) )
@@ -285,9 +381,10 @@ async def complete_level(request: Request):
current_level_number = level["level_number"] current_level_number = level["level_number"]
level_name = level["level"] or "A1" level_name = level["level"] or "A1"
# Проверяем, что уровень принадлежит текущему уровню пользователя # 🔧 ОБНОВЛЕНО (07.10.2026): level = 'common'.
if level_name != (user["current_level"] or "A1"): # Уровни глобальные, поэтому убираем проверку «уровень принадлежит
raise HTTPException(403, "This level does not belong to your current level") # твоему current_level». Оставляем только проверку прогресса выше.
# (Проверка не твоя-не твоя была актуальна, когда были A1/A2/B1.)
# 🔧 ФИКС (25.09.2026): already_completed_detects_hint_row — # 🔧 ФИКС (25.09.2026): already_completed_detects_hint_row —
# раньше already_completed = True при ЛЮБОЙ строке user_progress. # раньше already_completed = True при ЛЮБОЙ строке user_progress.
@@ -320,43 +417,104 @@ async def complete_level(request: Request):
telegram_id, level_id telegram_id, level_id
) or 0 ) or 0
# 🔧 ФИКС (24.09.2026): client_controlled_hints_game — # 🔧 НОВОЕ (08.10.2026): XP-система.
# читаем hints_used из БД, не доверяем клиенту. # Читаем hints_used и list_opened из БД (не доверяем клиенту).
hints_used = await conn.fetchval( hints_used = await conn.fetchval(
"SELECT hints_used FROM user_progress WHERE user_id = $1 AND level_id = $2", "SELECT hints_used FROM user_progress WHERE user_id = $1 AND level_id = $2",
telegram_id, level_id telegram_id, level_id
) or 0 ) or 0
hints_used = min(max(0, hints_used), 3) hints_used = min(max(0, hints_used), 3)
score = max(10, 100 - hints_used * 10) # 🆕 Штрафы (филворд):
# -20 за открытие списка слов (один раз за уровень)
# -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"] # для обратной совместимости
# 🔧 ФИКС (23.09.2026): client_controlled_achievement_values —
# сбрасываем current_streak в 0 при завершении уровня.
#
# 🔧 ФИКС (25.09.2026): complete_level_insert_overwrites_hints_used — # 🔧 ФИКС (25.09.2026): complete_level_insert_overwrites_hints_used —
# раньше INSERT падал с unique violation, если строка user_progress # раньше INSERT падал с unique violation, если строка user_progress
# уже была создана hints.py (юзер взял подсказку → уровень не завершится). # уже была создана hints.py (юзер взял подсказку → уровень не завершится).
# Теперь UPSERT с ON CONFLICT DO UPDATE. # Теперь UPSERT с ON CONFLICT DO UPDATE.
# hints_used уже прочитан из БД выше (не доверяем клиенту). # hints_used уже прочитан из БД выше (не доверяем клиенту).
# 🔧 ФИКС (13.10.2026): wave_off_by_one —
# session_level_number хранит позицию СЛЕДУЮЩЕГО уровня
# (уже увеличенную при выдаче), поэтому модалка волны
# срабатывала на 9-м уровне. Читаем current_wave /
# current_position_in_wave — позицию именно завершаемого уровня.
wave_row = await conn.fetchrow(
"SELECT current_wave, current_position_in_wave FROM user_game_progress WHERE user_id = $1",
telegram_id,
)
if wave_row and wave_row["current_wave"] and wave_row["current_position_in_wave"]:
current_wave = int(wave_row["current_wave"])
current_position_in_wave = int(wave_row["current_position_in_wave"])
else:
# Fallback для старых записей без current_* полей.
global_level = await conn.fetchval(
"SELECT global_level_number FROM user_game_progress WHERE user_id = $1",
telegram_id,
)
global_level = int(global_level or 1)
from services.waves import wave_for_level, level_in_wave
current_wave = wave_for_level(global_level)
current_position_in_wave = level_in_wave(global_level)
await conn.execute(""" await conn.execute("""
INSERT INTO user_progress INSERT INTO user_progress
(user_id, level_id, completed_at, hints_used, score, level, current_streak) (user_id, level_id, completed_at, hints_used, score, level, current_streak, wave)
VALUES ($1, $2, NOW(), $3, $4, $5, 0) VALUES ($1, $2, NOW(), $3, $4, $5, 0, $6)
ON CONFLICT (user_id, level_id) DO UPDATE ON CONFLICT (user_id, level_id) DO UPDATE
SET completed_at = NOW(), SET completed_at = NOW(),
hints_used = $3, hints_used = $3,
score = $4, score = $4,
level = $5, level = $5,
current_streak = 0 current_streak = 0,
""", telegram_id, level_id, hints_used, score, level_name) wave = $6
""", telegram_id, level_id, hints_used, score, level_name, current_wave)
# Обновляем last_completed_level (максимальный номер пройденного уровня) # 🔧 ОБНОВЛЕНО (07.10.2026): единый счётчик progress.
await conn.execute( # Обновляем только users.last_completed_level — глобальный.
"""UPDATE users # last_completed_by_level (JSONB) остаётся в БД для совместимости,
SET last_completed_level = GREATEST(last_completed_level, $2) # но больше не пишется.
WHERE telegram_id = $1""", await conn.execute("""
telegram_id, current_level_number, UPDATE users
) SET last_completed_level = GREATEST(COALESCE(last_completed_level, 0), $2)
WHERE telegram_id = $1
""", telegram_id, current_level_number)
# 🔧 ФИКС (10.10.2026): game_next_reuse_active_level —
# уровень пройден → сбрасываем активный уровень, чтобы
# следующий /game/next выдал новый. Сбрасываем только если
# активный уровень совпадает с завершённым.
await conn.execute("""
UPDATE user_game_progress
SET current_level_id = NULL,
updated_at = NOW()
WHERE user_id = $1 AND current_level_id = $2
""", telegram_id, level_id)
# Собираем данные для достижений внутри блока # Собираем данные для достижений внутри блока
levels_completed = await conn.fetchval( levels_completed = await conn.fetchval(
@@ -382,6 +540,49 @@ async def complete_level(request: Request):
) or 0 ) or 0
grand_total = total_score + sentence_score + wordquiz_score + bubblewords_score grand_total = total_score + sentence_score + wordquiz_score + bubblewords_score
# 🆕 (11.10.2026): волновые счётчики.
words_in_level = await conn.fetchval(
"SELECT COUNT(*) FROM level_words WHERE level_id = $1", level_id
) or 0
# Пройдено волн = current_wave - 1; если только что завершили
# 10-й уровень волны — волна пройдена (+1).
waves_completed = current_wave - 1
if current_position_in_wave == 10:
waves_completed += 1
# 🆕 (13.10.2026): итоги волны для модалки.
from services.waves import max_points_for_wave, wave_medal
wave_completed = (current_position_in_wave == 10)
wave_points = await conn.fetchval(
"SELECT COALESCE(SUM(score), 0) FROM user_progress WHERE user_id = $1 AND wave = $2",
telegram_id, current_wave,
) or 0
wave_max_points = max_points_for_wave()
wave_medal_result = wave_medal(wave_points, wave_max_points)
# XP филворда = сумма score по user_progress (уже посчитана как total_score).
wordsearch_xp = total_score
# Обновляем счётчики серий.
is_fast = completion_time is not None and int(completion_time) <= 30
await conn.execute("""
UPDATE user_game_progress
SET fast_streak = CASE WHEN $2 THEN COALESCE(fast_streak, 0) + 1 ELSE 0 END,
no_hints_streak = CASE WHEN $3 THEN COALESCE(no_hints_streak, 0) + 1 ELSE 0 END,
words_found = COALESCE(words_found, 0) + $4,
updated_at = NOW()
WHERE user_id = $1
""", telegram_id, is_fast, hints_used == 0, words_in_level)
counters = await conn.fetchrow(
"SELECT fast_streak, no_hints_streak, words_found FROM user_game_progress WHERE user_id = $1",
telegram_id,
)
fast_streak = int(counters["fast_streak"] or 0) if counters else 0
no_hints_streak = int(counters["no_hints_streak"] or 0) if counters else 0
words_found = int(counters["words_found"] or 0) if counters else 0
# Если уровень уже был пройден — просто возвращаем результат # Если уровень уже был пройден — просто возвращаем результат
if already_completed: if already_completed:
return { return {
@@ -416,9 +617,246 @@ async def complete_level(request: Request):
ach = await check_and_award_achievements(telegram_id, "perfect_words", server_perfect_streak) ach = await check_and_award_achievements(telegram_id, "perfect_words", server_perfect_streak)
new_achievements.extend(ach) new_achievements.extend(ach)
# 🆕 (11.10.2026): волновые достижения.
ach = await check_and_award_achievements(telegram_id, "waves_completed", waves_completed)
new_achievements.extend(ach)
ach = await check_and_award_achievements(telegram_id, "wordsearch_xp", wordsearch_xp)
new_achievements.extend(ach)
if fast_streak >= 3:
ach = await check_and_award_achievements(telegram_id, "ws_speed_run", fast_streak)
new_achievements.extend(ach)
if no_hints_streak >= 10:
ach = await check_and_award_achievements(telegram_id, "ws_no_hints_streak", no_hints_streak)
new_achievements.extend(ach)
if words_found >= 1000:
ach = await check_and_award_achievements(telegram_id, "wordsearch_words", words_found)
new_achievements.extend(ach)
return { return {
"status": "ok", "status": "ok",
"score": score, "score": score,
"already_completed": False, "already_completed": False,
"new_achievements": new_achievements "new_achievements": new_achievements,
# 🆕 XP-поля
"base_points": xp_result["base_points"],
"multiplier": xp_result["multiplier"],
"points": xp_result["points"],
"featured": xp_result["featured"],
"level_up": xp_result["level_up"],
"total_xp": xp_result["total_xp"],
"level": xp_result["level"],
"rank_key": xp_result["rank_key"],
"xp_in_level": xp_result["xp_in_level"],
"xp_needed": xp_result["xp_needed"],
# 🆕 (13.10.2026): итоги волны для модалки.
"wave_completed": wave_completed,
"wave_number": current_wave,
"wave_points": wave_points,
"wave_max_points": wave_max_points,
"wave_medal": wave_medal_result,
}
# ============================================================
# 🆕 (08.10.2026): Волновая выдача уровня.
# ============================================================
@router.post("/next")
async def get_next_level(request: Request):
"""
Выдаёт следующий уровень по волновой структуре.
Логика:
1. Если есть активный уровень (выдан, но ещё не пройден) — возвращаем его.
2. Иначе смотрим user_game_progress.global_level_number.
3. Определяем волну и размер сетки через wave_plan.
4. Ищем непройденный уровень нужного размера (в user_seen_levels).
5. Помечаем как seen, обновляем user_game_progress, ставим current_level_id.
6. Возвращаем level_number.
🔧 ФИКС (10.10.2026): game_next_reuse_active_level —
раньше /game/next при каждом заходе выдавал НОВЫЙ уровень и
инкрементил global_level_number, даже если предыдущий не был пройден.
Из-за этого при повторном открытии Filwords уровень менялся
(5×5 → 6×6). Теперь сначала проверяем current_level_id:
если уровень выдан и ещё не пройден — возвращаем его же.
"""
telegram_id, _ = await require_auth(request)
pool = await get_pool()
async with pool.acquire() as conn:
# Читаем или создаём прогресс
row = await conn.fetchrow(
"""
SELECT global_level_number, session_number, session_level_number,
current_level_id, current_wave, current_position_in_wave
FROM user_game_progress WHERE user_id = $1
""",
telegram_id,
)
if row is None:
await conn.execute(
"""
INSERT INTO user_game_progress
(user_id, global_level_number, session_number, session_level_number)
VALUES ($1, 1, 1, 1)
ON CONFLICT (user_id) DO NOTHING
""",
telegram_id,
)
global_level = 1
session_number = 1
session_level = 1
current_level_id = None
else:
global_level = int(row["global_level_number"] or 1)
session_number = int(row["session_number"] or 1)
session_level = int(row["session_level_number"] or 1)
current_level_id = row["current_level_id"]
from services.waves import wave_for_level, level_in_wave, grid_size_for
# 🔧 ФИКС (10.10.2026): сначала проверяем активный уровень.
# Если он выдан и ещё не пройден — возвращаем его же,
# не двигая счётчики и не помечая новый уровень как seen.
if current_level_id is not None:
active = await conn.fetchrow(
"""
SELECT id, level_number, grid_size
FROM levels
WHERE id = $1 AND is_active = TRUE
""",
current_level_id,
)
if active is not None:
done = await conn.fetchval(
"""
SELECT 1 FROM user_progress
WHERE user_id = $1 AND level_id = $2
AND (completed_at IS NOT NULL OR COALESCE(score, 0) > 0)
""",
telegram_id, active["id"],
)
if not done:
# 🔧 ФИКС (10.10.2026): off-by-one в reuse-ветке —
# global_level уже инкрементнут при первой выдаче,
# поэтому wave/pos считаем от зафиксированных значений
# current_wave / current_position_in_wave. Fallback —
# старый расчёт для записей без этих полей.
return {
"level_id": active["id"],
"level_number": active["level_number"],
"grid_size": active["grid_size"],
"wave": int(row["current_wave"]) if row["current_wave"] else wave_for_level(global_level),
"position_in_wave": int(row["current_position_in_wave"]) if row["current_position_in_wave"] else level_in_wave(global_level),
"session_number": session_number,
"session_level": session_level,
"global_level": global_level,
"reused": True,
}
# Уровень пройден или удалён/неактивен — сбрасываем активный.
await conn.execute(
"""
UPDATE user_game_progress
SET current_level_id = NULL, updated_at = NOW()
WHERE user_id = $1
""",
telegram_id,
)
# Определяем волну и размер
wave = wave_for_level(global_level)
pos_in_wave = level_in_wave(global_level)
grid_size = grid_size_for(global_level)
# Ищем непройденный уровень нужного размера
# Исключаем те, что уже в user_seen_levels
level = await conn.fetchrow(
"""
SELECT l.id, l.level_number
FROM levels l
WHERE l.grid_size = $1
AND l.is_active = TRUE
AND l.id NOT IN (
SELECT level_id FROM user_seen_levels WHERE user_id = $2
)
ORDER BY RANDOM()
LIMIT 1
""",
grid_size, telegram_id,
)
# Fallback: если непройденных нет, берём самый давно виденный
if level is None:
level = await conn.fetchrow(
"""
SELECT l.id, l.level_number
FROM levels l
JOIN user_seen_levels usl ON usl.level_id = l.id
WHERE l.grid_size = $1
AND l.is_active = TRUE
AND usl.user_id = $2
ORDER BY usl.seen_at ASC
LIMIT 1
""",
grid_size, telegram_id,
)
if level is None:
raise HTTPException(404, "No levels available for this grid size")
level_id = level["id"]
level_number = level["level_number"]
# Помечаем как seen (обновляем seen_at если уже был)
await conn.execute(
"""
INSERT INTO user_seen_levels (user_id, level_id, seen_at)
VALUES ($1, $2, NOW())
ON CONFLICT (user_id, level_id) DO UPDATE
SET seen_at = NOW()
""",
telegram_id, level_id,
)
# Обновляем прогресс
next_global = global_level + 1
next_session_level = session_level + 1
next_session = session_number
if next_session_level > 10:
next_session_level = 1
next_session += 1
# 🔧 ФИКС (10.10.2026): запоминаем выданный уровень как активный.
await conn.execute(
"""
UPDATE user_game_progress
SET global_level_number = $2,
session_number = $3,
session_level_number = $4,
current_level_id = $5,
current_wave = $6,
current_position_in_wave = $7,
updated_at = NOW()
WHERE user_id = $1
""",
telegram_id, next_global, next_session, next_session_level, level_id,
wave, pos_in_wave,
)
return {
"level_id": level_id,
"level_number": level_number,
"grid_size": grid_size,
"wave": wave,
"position_in_wave": pos_in_wave,
"session_number": session_number,
"session_level": session_level,
"global_level": global_level,
"reused": False,
} }
+33 -34
View File
@@ -1,3 +1,5 @@
import random
from fastapi import APIRouter, Request, HTTPException from fastapi import APIRouter, Request, HTTPException
from auth import require_auth from auth import require_auth
from database import get_pool from database import get_pool
@@ -6,7 +8,7 @@ router = APIRouter(prefix="/hints", tags=["hints"])
@router.get("/first-letter/{level_id}") @router.get("/first-letter/{level_id}")
async def get_first_letter_hint(request: Request, level_id: int): async def get_first_letter_hint(request: Request, level_id: int, found: str = ""):
"""Подсказка: показывает первую букву случайного ненайденного слова""" """Подсказка: показывает первую букву случайного ненайденного слова"""
telegram_id, _ = await require_auth(request) telegram_id, _ = await require_auth(request)
@@ -53,25 +55,33 @@ async def get_first_letter_hint(request: Request, level_id: int):
import json import json
word_paths = json.loads(word_paths) word_paths = json.loads(word_paths)
# Находим первое слово, у которого есть путь # Слова уровня, у которых есть путь в word_paths
all_level_words = [w["word_pl"] for w in words] all_level_words = [w["word_pl"] for w in words]
words_with_paths = [
w for w in all_level_words
if w in word_paths and word_paths[w]
]
# Ищем слово с путём (сначала основные, потом filler-слова) if not words_with_paths:
found_word = None
first_cell = None
for word in all_level_words:
if word in word_paths and word_paths[word]:
found_word = word
first_cell = word_paths[word][0]
break
# 🔧 ФИКС (25.09.2026): hint_fake_first_cell —
# если ни у одного слова нет пути в word_paths, подсказка
# бессмысленна. Возвращаем 404, а не фейковую координату [0,0].
if not found_word:
raise HTTPException(404, "No word paths found for this level") raise HTTPException(404, "No word paths found for this level")
# 🔧 ФИКС (12.10.2026): hint_shows_found_word —
# подсказка показывала уже найденное слово. Теперь фронт передаёт
# найденные слова в query-параметре found (через запятую), и мы
# исключаем их из кандидатов.
found_words = {w.strip() for w in found.split(",") if w.strip()}
remaining_words = [w for w in words_with_paths if w not in found_words]
if not remaining_words:
raise HTTPException(404, "All words found")
# 🔧 ФИКС (11.10.2026): hint_always_first_word —
# раньше всегда возвращалось первое слово списка, поэтому
# повторные нажатия давали одну и ту же букву. Теперь слово
# выбирается случайно из ещё не найденных.
found_word = random.choice(remaining_words)
first_cell = word_paths[found_word][0]
# 🔧 ФИКС (25.09.2026): hint_consumed_before_word_paths_check — # 🔧 ФИКС (25.09.2026): hint_consumed_before_word_paths_check —
# инкрементим hints_used ТОЛЬКО после всех проверок. # инкрементим hints_used ТОЛЬКО после всех проверок.
# Раньше при 404 (нет word_paths) подсказка уже была потрачена. # Раньше при 404 (нет word_paths) подсказка уже была потрачена.
@@ -115,7 +125,7 @@ async def get_word_list(request: Request, level_id: int):
if not user_exists: if not user_exists:
raise HTTPException(401, "User not registered") raise HTTPException(401, "User not registered")
# Получаем прогресс пользователя # Получаем прогресс пользователя (для информации в ответе)
progress = await conn.fetchrow( progress = await conn.fetchrow(
"SELECT hints_used FROM user_progress WHERE user_id = $1 AND level_id = $2", "SELECT hints_used FROM user_progress WHERE user_id = $1 AND level_id = $2",
telegram_id, level_id telegram_id, level_id
@@ -123,14 +133,11 @@ async def get_word_list(request: Request, level_id: int):
hints_already_used = progress["hints_used"] if progress else 0 hints_already_used = progress["hints_used"] if progress else 0
# 🔧 ФИКС (23.09.2026): hints_not_incremented — лимит 3 подсказки не работал, # 🔧 ФИКС (01.10.2026): word_list_is_not_hint —
# hints_used никогда не рос. Теперь проверяем лимит и инкрементим в той же транзакции. # «Показать слова» — базовая функция (в UI написано ∞),
MAX_HINTS = 3 # НЕ расходует лимит подсказок и НЕ уменьшает очки.
if hints_already_used >= MAX_HINTS: # Раньше зря инкрементился hints_used → минус 10 очков за уровень.
raise HTTPException(403, "Hint limit reached") # Лимит 3 остаётся ТОЛЬКО для «Первой буквы».
# 🔧 ФИКС (25.09.2026): word_list_hint_consumed_on_empty —
# сначала получаем слова, проверяем что они есть, только потом инкрементим.
words = await conn.fetch( words = await conn.fetch(
"SELECT * FROM level_words WHERE level_id = $1 ORDER BY word_pl", level_id "SELECT * FROM level_words WHERE level_id = $1 ORDER BY word_pl", level_id
) )
@@ -138,15 +145,7 @@ async def get_word_list(request: Request, level_id: int):
if not words: if not words:
raise HTTPException(404, "No words found for this level") raise HTTPException(404, "No words found for this level")
# 🔧 ФИКС (25.09.2026): hints_used_never_incremented_actually — # hints_used НЕ инкрементим. hints_already_used читаем из БД для информации.
# тот же UPSERT, что и в get_first_letter_hint.
await conn.execute("""
INSERT INTO user_progress (user_id, level_id, hints_used)
VALUES ($1, $2, 1)
ON CONFLICT (user_id, level_id) DO UPDATE
SET hints_used = user_progress.hints_used + 1
""", telegram_id, level_id)
hints_already_used += 1
# Определяем язык пользователя # Определяем язык пользователя
user = await conn.fetchrow( user = await conn.fetchrow(
+166 -96
View File
@@ -10,7 +10,18 @@ LEVELS = ["A1", "A2", "B1", "B2", "C1", "C2"]
@router.get("") @router.get("")
async def get_leaderboard(request: Request, limit: int = 50): async def get_leaderboard(request: Request, limit: int = 50):
"""Рейтинг игроков — быстрое чтение из кэша""" """
Рейтинг игроков.
🔧 ОБНОВЛЕНО (08.10.2026): XP-фундамент.
Сортировка: total_xp DESC → total_score DESC.
weekly_xp в БД остаётся, но больше НЕ используется в сортировке.
Legacy-поля (total_score, wordsearch_score, ...) сохранены для Mini App.
Новые поля в каждой строке: total_xp, level, rank_key, rank_name,
xp_in_level, xp_needed, avatar_id.
"""
telegram_id, _ = await require_auth(request) telegram_id, _ = await require_auth(request)
if limit < 1: if limit < 1:
@@ -28,17 +39,39 @@ async def get_leaderboard(request: Request, limit: int = 50):
current_level = user["current_level"] or "A1" current_level = user["current_level"] or "A1"
# Быстрое чтение из MATERIALIZED VIEW # 🆕 Топ-N: matview + LEFT JOIN user_profile для XP.
# 🔧 ОБНОВЛЕНО (08.10.2026): сортировка по total_xp (weekly_xp убран).
rows = await conn.fetch(""" rows = await conn.fetch("""
SELECT * FROM leaderboard_cache SELECT
ORDER BY total_score DESC lc.*,
COALESCE(p.weekly_xp, 0) AS weekly_xp,
COALESCE(p.total_xp, 0) AS total_xp,
COALESCE(p.avatar_id, 0) AS avatar_id,
u.app_language
FROM leaderboard_cache lc
LEFT JOIN user_profile p ON p.user_id = lc.telegram_id
LEFT JOIN users u ON u.telegram_id = lc.telegram_id
ORDER BY COALESCE(p.total_xp, 0) DESC,
lc.total_score DESC,
lc.telegram_id ASC
LIMIT $1 LIMIT $1
""", limit) """, limit)
leaderboard = [] # Импорт XP-хелперов
for i, row in enumerate(rows): from services.xp import level_for, rank_for
leaderboard.append({
"rank": i + 1, def _serialize_row(row, rank_num):
"""Собирает строку рейтинга с legacy + XP-полями."""
weekly_xp = int(row["weekly_xp"] or 0)
total_xp = int(row["total_xp"] or 0)
level, xp_in_level, xp_needed, rank_key = level_for(total_xp)
lang = (row.get("app_language") or "ru").lower()
if lang not in ("pl", "ru", "uk", "en"):
lang = "ru"
return {
# Legacy (Mini App)
"rank": rank_num,
"telegram_id": row["telegram_id"], "telegram_id": row["telegram_id"],
"username": row["username"] or f"Player{row['telegram_id']}", "username": row["username"] or f"Player{row['telegram_id']}",
"total_score": row["total_score"], "total_score": row["total_score"],
@@ -50,100 +83,131 @@ async def get_leaderboard(request: Request, limit: int = 50):
"bubble_levels_completed": row["bubble_levels_completed"], "bubble_levels_completed": row["bubble_levels_completed"],
"levels_completed": 0, "levels_completed": 0,
"sentences_completed": 0, "sentences_completed": 0,
}) # 🆕 XP (Pleily)
"weekly_xp": weekly_xp, # оставлен для legacy Mini App
"total_xp": total_xp,
"level": level,
"rank_key": rank_key,
"rank_name": rank_for(level, lang),
"xp_in_level": xp_in_level,
"xp_needed": xp_needed,
"avatar_id": int(row["avatar_id"] or 0),
"app_language": lang,
}
# 🔧 ФИКС (25.09.2026): leaderboard_rank_wrong_for_uncached_user — leaderboard = [
# если пользователя нет в leaderboard_cache, подзапрос вернёт NULL, _serialize_row(row, rank_num=i + 1)
# и COUNT(*) + 1 = 1 (юзер видит себя первым, хотя у него 0 очков). for i, row in enumerate(rows)
# Теперь: если user нет в кэше — считаем его место по количеству ]
# записей с total_score > 0 + 1 (в конец списка).
my_total_in_cache = await conn.fetchval("""
SELECT total_score FROM leaderboard_cache WHERE telegram_id = $1
""", telegram_id)
if my_total_in_cache is None: # ============ Мой ранг ============
# Пользователя нет в кэше — считаем по количеству с > 0 # Читаем мои XP + legacy-статистику.
user_rank = await conn.fetchval("""
SELECT COUNT(*) + 1 FROM leaderboard_cache
WHERE total_score > 0
""") or 1
else:
user_rank = await conn.fetchval("""
SELECT COUNT(*) + 1 FROM leaderboard_cache
WHERE total_score > $1
""", my_total_in_cache)
# Персональная статистика пользователя
my_row = await conn.fetchrow(""" my_row = await conn.fetchrow("""
SELECT * FROM leaderboard_cache WHERE telegram_id = $1 SELECT
lc.*,
COALESCE(p.weekly_xp, 0) AS weekly_xp,
COALESCE(p.total_xp, 0) AS total_xp,
COALESCE(p.avatar_id, 0) AS avatar_id,
u.app_language
FROM leaderboard_cache lc
LEFT JOIN user_profile p ON p.user_id = lc.telegram_id
LEFT JOIN users u ON u.telegram_id = lc.telegram_id
WHERE lc.telegram_id = $1
""", telegram_id) """, telegram_id)
if my_row: # Если юзера нет в matview — пробуем только user_profile.
if not my_row:
my_profile = await conn.fetchrow("""
SELECT
p.weekly_xp, p.total_xp, p.avatar_id,
u.username, u.app_language, u.current_level
FROM user_profile p
JOIN users u ON u.telegram_id = p.user_id
WHERE p.user_id = $1
""", telegram_id)
if my_profile:
my_weekly_xp = int(my_profile["weekly_xp"] or 0)
my_total_xp = int(my_profile["total_xp"] or 0)
my_avatar_id = int(my_profile["avatar_id"] or 0)
my_username = my_profile["username"]
my_lang = (my_profile["app_language"] or "ru").lower()
else:
my_weekly_xp = 0
my_total_xp = 0
my_avatar_id = 0
my_username = None
my_lang = "ru"
# 🔧 ОБНОВЛЕНО (08.10.2026): место по total_xp (не weekly_xp).
my_position = await conn.fetchval("""
SELECT COUNT(*) + 1
FROM user_profile
WHERE total_xp > $1
""", my_total_xp) or 1
# Legacy-статистика (для совместимости с Mini App)
my_wordsearch = await conn.fetchval(
"SELECT COALESCE(SUM(score), 0) FROM user_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
telegram_id
) or 0
my_sentence = await conn.fetchval(
"SELECT COALESCE(SUM(score), 0) FROM sentence_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
telegram_id
) or 0
my_wordquiz = await conn.fetchval(
"SELECT COALESCE(total_score, 0) FROM word_quiz_progress WHERE user_id = $1",
telegram_id
) or 0
my_words_guessed = await conn.fetchval(
"SELECT COALESCE(words_guessed, 0) FROM word_quiz_progress WHERE user_id = $1",
telegram_id
) or 0
my_bubblewords = await conn.fetchval(
"SELECT COALESCE(total_score, 0) FROM bubble_words_progress WHERE user_id = $1",
telegram_id
) or 0
my_bubble_levels = await conn.fetchval(
"SELECT COALESCE(levels_completed, 0) FROM bubble_words_progress WHERE user_id = $1",
telegram_id
) or 0
my_total = my_wordsearch + my_sentence + my_wordquiz + my_bubblewords
my_wordsearch_levels = 0
my_sentences_completed = 0
my_avatar_id_final = my_avatar_id
my_username_final = my_username
my_lang_final = my_lang
else:
my_weekly_xp = int(my_row["weekly_xp"] or 0)
my_total_xp = int(my_row["total_xp"] or 0)
my_avatar_id_final = int(my_row["avatar_id"] or 0)
my_username_final = my_row["username"]
my_lang_final = (my_row["app_language"] or "ru").lower()
my_wordsearch = my_row["wordsearch_score"] my_wordsearch = my_row["wordsearch_score"]
my_sentence = my_row["sentence_score"] my_sentence = my_row["sentence_score"]
my_wordquiz = my_row["wordquiz_score"] my_wordquiz = my_row["wordquiz_score"]
my_words_guessed = my_row["words_guessed"] my_words_guessed = my_row["words_guessed"]
my_bubblewords = my_row["bubblewords_score"] my_bubblewords = my_row["bubblewords_score"]
my_bubble_levels = my_row["bubble_levels_completed"] my_bubble_levels = my_row["bubble_levels_completed"]
else: my_total = my_wordsearch + my_sentence + my_wordquiz + my_bubblewords
my_wordsearch = 0
my_sentence = 0 # 🔧 ОБНОВЛЕНО (08.10.2026): место по total_xp (не weekly_xp).
my_wordquiz = 0 my_position = await conn.fetchval("""
my_words_guessed = 0 SELECT COUNT(*) + 1
my_bubblewords = 0 FROM user_profile
my_bubble_levels = 0 WHERE total_xp > $1
""", my_total_xp) or 1
# Считаем НАПРЯМУЮ из основных таблиц
my_wordsearch_levels = await conn.fetchval( my_wordsearch_levels = await conn.fetchval(
"SELECT COUNT(DISTINCT level_id) FROM user_progress WHERE user_id = $1 AND completed_at IS NOT NULL", "SELECT COUNT(DISTINCT level_id) FROM user_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
telegram_id telegram_id
) or 0 ) or 0
my_sentences_completed = await conn.fetchval( my_sentences_completed = await conn.fetchval(
"SELECT COUNT(*) FROM sentence_progress WHERE user_id = $1 AND completed_at IS NOT NULL", "SELECT COUNT(*) FROM sentence_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
telegram_id telegram_id
) or 0 ) or 0
# Если пользователя нет в кэше — считаем очки из основных таблиц # ============ level_stats (legacy для Mini App) ============
if not my_row:
my_wordsearch = await conn.fetchval(
"SELECT COALESCE(SUM(score), 0) FROM user_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
telegram_id
) 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. Справочники (не зависят от юзера) — одним запросом
ref_row = await conn.fetchrow(""" ref_row = await conn.fetchrow("""
SELECT SELECT
(SELECT COUNT(*) FROM levels WHERE level = 'A1') AS a1_levels, (SELECT COUNT(*) FROM levels WHERE level = 'A1') AS a1_levels,
@@ -160,11 +224,8 @@ async def get_leaderboard(request: Request, limit: int = 50):
(SELECT COUNT(*) FROM sentences WHERE level = 'C2') AS c2_sent (SELECT COUNT(*) FROM sentences WHERE level = 'C2') AS c2_sent
""") """)
# 2. Очки и прогресс по всем уровням сразу — 4 запроса с GROUP BY
ws_rows = await conn.fetch(""" ws_rows = await conn.fetch("""
SELECT level, SELECT level, COALESCE(SUM(score), 0) AS score, COUNT(*) AS completed
COALESCE(SUM(score), 0) AS score,
COUNT(*) AS completed
FROM user_progress FROM user_progress
WHERE user_id = $1 AND completed_at IS NOT NULL WHERE user_id = $1 AND completed_at IS NOT NULL
GROUP BY level GROUP BY level
@@ -172,9 +233,7 @@ async def get_leaderboard(request: Request, limit: int = 50):
ws_by_level = {r["level"]: r for r in ws_rows} ws_by_level = {r["level"]: r for r in ws_rows}
s_rows = await conn.fetch(""" s_rows = await conn.fetch("""
SELECT level, SELECT level, COALESCE(SUM(score), 0) AS score, COUNT(*) AS completed
COALESCE(SUM(score), 0) AS score,
COUNT(*) AS completed
FROM sentence_progress FROM sentence_progress
WHERE user_id = $1 AND completed_at IS NOT NULL WHERE user_id = $1 AND completed_at IS NOT NULL
GROUP BY level GROUP BY level
@@ -183,23 +242,19 @@ async def get_leaderboard(request: Request, limit: int = 50):
wq_rows = await conn.fetch(""" wq_rows = await conn.fetch("""
SELECT level, COALESCE(total_score, 0) AS score SELECT level, COALESCE(total_score, 0) AS score
FROM word_quiz_progress FROM word_quiz_progress WHERE user_id = $1
WHERE user_id = $1
""", telegram_id) """, telegram_id)
wq_by_level = {r["level"]: r for r in wq_rows} wq_by_level = {r["level"]: r for r in wq_rows}
bw_rows = await conn.fetch(""" bw_rows = await conn.fetch("""
SELECT level, COALESCE(total_score, 0) AS score SELECT level, COALESCE(total_score, 0) AS score
FROM bubble_words_progress FROM bubble_words_progress WHERE user_id = $1
WHERE user_id = $1
""", telegram_id) """, telegram_id)
bw_by_level = {r["level"]: r for r in bw_rows} bw_by_level = {r["level"]: r for r in bw_rows}
# 3. Собираем level_stats в Python — без единого запроса
level_stats = {} level_stats = {}
for lvl in LEVELS: for lvl in LEVELS:
lvl_lower = lvl.lower() lvl_lower = lvl.lower()
ws_score = ws_by_level.get(lvl, {}).get("score", 0) or 0 ws_score = ws_by_level.get(lvl, {}).get("score", 0) or 0
ws_completed = ws_by_level.get(lvl, {}).get("completed", 0) or 0 ws_completed = ws_by_level.get(lvl, {}).get("completed", 0) or 0
s_score = s_by_level.get(lvl, {}).get("score", 0) or 0 s_score = s_by_level.get(lvl, {}).get("score", 0) or 0
@@ -209,7 +264,6 @@ async def get_leaderboard(request: Request, limit: int = 50):
total_ws_levels = ref_row[f"{lvl_lower}_levels"] or 0 total_ws_levels = ref_row[f"{lvl_lower}_levels"] or 0
total_sentences = ref_row[f"{lvl_lower}_sent"] or 0 total_sentences = ref_row[f"{lvl_lower}_sent"] or 0
total_items = total_ws_levels + total_sentences total_items = total_ws_levels + total_sentences
completed_items = ws_completed + s_completed completed_items = ws_completed + s_completed
progress_percent = round((completed_items / total_items * 100), 1) if total_items > 0 else 0 progress_percent = round((completed_items / total_items * 100), 1) if total_items > 0 else 0
@@ -223,15 +277,20 @@ async def get_leaderboard(request: Request, limit: int = 50):
"bubblewords_score": bw_score, "bubblewords_score": bw_score,
} }
# 🔧 ИСПРАВЛЕНО: вызов достижений ВНЕ блока async with pool.acquire() # Достижения
from routers.achievements import check_and_award_achievements from routers.achievements import check_and_award_achievements
if my_position <= 3: if my_position <= 3:
await check_and_award_achievements(telegram_id, "rank_reached", my_position) await check_and_award_achievements(telegram_id, "rank_reached", my_position)
# ============ Мой ранг (XP) ============
my_level, my_xp_in_level, my_xp_needed, my_rank_key = level_for(my_total_xp)
my_rank_name = rank_for(my_level, my_lang_final)
return { return {
"leaderboard": leaderboard, "leaderboard": leaderboard,
"current_level": current_level, "current_level": current_level,
"my_rank": { "my_rank": {
# Legacy
"rank": my_position, "rank": my_position,
"telegram_id": telegram_id, "telegram_id": telegram_id,
"total_score": my_total, "total_score": my_total,
@@ -243,6 +302,17 @@ async def get_leaderboard(request: Request, limit: int = 50):
"words_guessed": my_words_guessed, "words_guessed": my_words_guessed,
"bubblewords_score": my_bubblewords, "bubblewords_score": my_bubblewords,
"bubble_levels_completed": my_bubble_levels, "bubble_levels_completed": my_bubble_levels,
# 🆕 XP
"username": my_username_final,
"weekly_xp": my_weekly_xp, # оставлен для legacy Mini App
"total_xp": my_total_xp,
"level": my_level,
"rank_key": my_rank_key,
"rank_name": my_rank_name,
"xp_in_level": my_xp_in_level,
"xp_needed": my_xp_needed,
"avatar_id": my_avatar_id_final,
"app_language": my_lang_final,
}, },
"level_stats": level_stats, "level_stats": level_stats,
} }
+348 -53
View File
@@ -13,7 +13,6 @@ from fastapi import APIRouter, Request, HTTPException
from auth import require_auth from auth import require_auth
from database import get_pool from database import get_pool
from config import TOGETHER_API_KEY from config import TOGETHER_API_KEY
from .learning_data import init_learning_data
from .learning_profile import get_weak_skills, get_strong_skills from .learning_profile import get_weak_skills, get_strong_skills
logger = logging.getLogger(__name__) logger = logging.getLogger(__name__)
@@ -21,7 +20,7 @@ logger = logging.getLogger(__name__)
router = APIRouter(prefix="/learning", tags=["learning"]) router = APIRouter(prefix="/learning", tags=["learning"])
TOGETHER_API_URL = "https://api.together.xyz/v1/chat/completions" TOGETHER_API_URL = "https://api.together.xyz/v1/chat/completions"
ANALYTICS_MODEL = "MiniMaxAI/MiniMax-M3" ANALYTICS_MODEL = "deepseek-ai/DeepSeek-V4-Pro-0813"
# Доступные функции приложения (для AI — чтобы не галлюцинировал) # Доступные функции приложения (для AI — чтобы не галлюцинировал)
AVAILABLE_FEATURES = [ AVAILABLE_FEATURES = [
@@ -444,12 +443,41 @@ async def get_learning_levels(request: Request):
@router.get("/topics") @router.get("/topics")
async def get_topics(request: Request, level: str = "A1"): async def get_topics(request: Request, level: str = "A1"):
"""Получить темы для уровня""" """
await require_auth(request) Получить темы для уровня.
🔧 ОБНОВЛЕНО (04.10.2026): track_filter —
фильтруем темы по языку юзера:
- pl → track='pl'
- ru/uk → track='ru_uk' (общий для славян)
- en → track='en'
"""
telegram_id, _ = await require_auth(request)
pool = await get_pool() pool = await get_pool()
async with pool.acquire() as conn: async with pool.acquire() as conn:
rows = await conn.fetch("SELECT * FROM learning_topics WHERE level_code = $1 AND is_active = TRUE ORDER BY order_number", level) # Определяем track из app_language юзера
return {"topics": [dict(row) for row in rows]} user_lang = await conn.fetchval(
"SELECT app_language FROM users WHERE telegram_id = $1",
telegram_id,
) or "ru"
if user_lang == "pl":
track = "pl"
elif user_lang == "en":
track = "en"
else:
# ru, uk → общий track
track = "ru_uk"
rows = await conn.fetch("""
SELECT * FROM learning_topics
WHERE level_code = $1
AND is_active = TRUE
AND track = $2
ORDER BY order_number
""", level, track)
return {"topics": [dict(row) for row in rows], "track": track}
@router.get("/topics/{topic_id}") @router.get("/topics/{topic_id}")
@@ -594,9 +622,29 @@ async def start_session(request: Request):
return {"session_id": row["id"]} return {"session_id": row["id"]}
# 🔧 ОБНОВЛЕНО (02.10.2026): attempt_number + revised —
# если ученик отвечает на вопрос повторно (после «Повторить урок»),
# создаётся НОВАЯ запись с attempt_number+1, revised=TRUE,
# revision_of_id=предыдущий ответ. История сохраняется полностью.
@router.post("/answer") @router.post("/answer")
async def save_answer(request: Request): async def save_answer(request: Request):
"""Сохранить ответ пользователя""" """
Сохранить ответ пользователя.
🔧 ОБНОВЛЕНО (02.10.2026): attempt_number + revised —
если ученик отвечает на вопрос повторно (после «Повторить урок»),
создаётся НОВАЯ запись с attempt_number+1, revised=TRUE,
revision_of_id=предыдущий ответ. История сохраняется полностью.
Возвращает:
{
"correct": bool,
"wrong_because": str | None,
"attempt_number": int, # какая это попытка
"show_correct_answer": bool, # TRUE только если attempt >= 3
"correct_answer": str | None # только при show_correct_answer
}
"""
telegram_id, _ = await require_auth(request) telegram_id, _ = await require_auth(request)
body = await request.json() body = await request.json()
session_id = body.get("session_id") session_id = body.get("session_id")
@@ -604,20 +652,39 @@ async def save_answer(request: Request):
selected_answer = body.get("answer", "") selected_answer = body.get("answer", "")
time_taken_ms = body.get("time_taken_ms", 0) time_taken_ms = body.get("time_taken_ms", 0)
is_final = body.get("is_final_answer", True) is_final = body.get("is_final_answer", True)
# 🔧 ФИКС (22.09.2026): раньше hint_used был захардкожен False,
# поэтому подсказки не попадали в аналитику (hint_dependency всегда 0).
hint_used = body.get("hint_used", False) hint_used = body.get("hint_used", False)
# 🔧 НОВОЕ: клиент сообщает, что это повторная попытка
is_retry = body.get("is_retry", False)
if not session_id or not question_id: if not session_id or not question_id:
raise HTTPException(400, "session_id and question_id required") raise HTTPException(400, "session_id and question_id required")
pool = await get_pool() pool = await get_pool()
async with pool.acquire() as conn: async with pool.acquire() as conn:
question = await conn.fetchrow("SELECT * FROM learning_questions WHERE question_id = $1", question_id) question = await conn.fetchrow(
"SELECT * FROM learning_questions WHERE question_id = $1", question_id
)
if not question: if not question:
raise HTTPException(404, "Question not found") raise HTTPException(404, "Question not found")
correct = selected_answer.strip().lower() == (question["correct_answer"] or "").strip().lower() # 🔧 НОВОЕ: считаем текущее количество попыток по этому вопросу в сессии
prev_attempts = await conn.fetch(
"""
SELECT id, attempt_number, correct
FROM user_learning_answers
WHERE session_id = $1 AND question_id = $2
ORDER BY attempt_number ASC
""",
session_id, question_id,
)
next_attempt = (prev_attempts[-1]["attempt_number"] + 1) if prev_attempts else 1
prev_id = prev_attempts[-1]["id"] if prev_attempts else None
correct = (
selected_answer.strip().lower()
== (question["correct_answer"] or "").strip().lower()
)
wrong_because = None wrong_because = None
if not correct: if not correct:
@@ -628,58 +695,212 @@ async def save_answer(request: Request):
if option: if option:
wrong_because = option["wrong_because"] wrong_because = option["wrong_because"]
session = await conn.fetchrow("SELECT * FROM learning_sessions WHERE id = $1", session_id) session = await conn.fetchrow(
"SELECT * FROM learning_sessions WHERE id = $1", session_id
# 🔧 ФИКС (23.09.2026): learning_save_answer_missing_session_check — )
# раньше при несуществующем session_id падало с TypeError → 500.
# Теперь честная 404 + проверка владельца сессии.
if not session: if not session:
raise HTTPException(404, "Session not found") raise HTTPException(404, "Session not found")
if session["user_id"] != telegram_id: if session["user_id"] != telegram_id:
raise HTTPException(403, "Session belongs to another user") raise HTTPException(403, "Session belongs to another user")
await conn.execute(""" # 🔧 Логика revised: если это повторная попытка — фиксируем
INSERT INTO user_learning_answers (user_id, session_id, level_code, topic_id, lesson_id, question_id, selected_answer, correct, skill_tag, question_type, context_type, difficulty, time_taken_ms, hint_used, wrong_because, is_final_answer) revised = is_retry or next_attempt > 1
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16)
""", telegram_id, session_id, session["level_code"], session["topic_id"], question["lesson_id"], question_id, selected_answer, correct, question["skill_tag"], question["question_type"], question["context_type"], question["difficulty"], time_taken_ms, hint_used, wrong_because, is_final)
return {"correct": correct, "wrong_because": wrong_because} # 🔧 is_final_answer: только ПОСЛЕДНЯЯ попытка считается финальной
# (для статистики). Промежуточные — revision-записи, не идут в total.
# Если клиент сказал is_final=False (подсказка) — уважаем.
if is_retry:
# Сначала снимаем флаг is_final_answer у предыдущей записи
await conn.execute(
"""
UPDATE user_learning_answers
SET is_final_answer = FALSE
WHERE session_id = $1 AND question_id = $2
""",
session_id, question_id,
)
await conn.execute(
"""
INSERT INTO user_learning_answers (
user_id, session_id, level_code, topic_id, lesson_id,
question_id, selected_answer, correct, skill_tag,
question_type, context_type, difficulty, time_taken_ms,
attempt_number, hint_used, wrong_because, is_final_answer,
revised, revision_of_id
)
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13,
$14, $15, $16, $17, $18, $19)
""",
telegram_id, session_id, session["level_code"], session["topic_id"],
question["lesson_id"], question_id, selected_answer, correct,
question["skill_tag"], question["question_type"], question["context_type"],
question["difficulty"], time_taken_ms, next_attempt, hint_used,
wrong_because, is_final, revised, prev_id,
)
# 🔧 Решаем, показывать ли правильный ответ
# Первая попытка — НЕ показываем
# Вторая — НЕ показываем
# Третья и выше — показываем
show_correct_answer = next_attempt >= 3
# Правильный ответ — текст варианта (для recognition)
correct_answer_text = None
if show_correct_answer:
correct_option = await conn.fetchrow(
"""
SELECT option_key, text_pl, text_ru, text_uk, text_en
FROM question_options
WHERE question_id = $1 AND is_correct = TRUE
LIMIT 1
""",
question_id,
)
if correct_option:
correct_answer_text = (
f"{correct_option['option_key']} — {correct_option['text_pl']}"
)
else:
# Для production — просто correct_answer из вопроса
correct_answer_text = question["correct_answer"]
return {
"correct": correct,
"wrong_because": wrong_because,
"attempt_number": next_attempt,
"show_correct_answer": show_correct_answer,
"correct_answer": correct_answer_text,
}
# 🔧 ОБНОВЛЕНО (02.10.2026): session_report —
# без AI формируем человеческий отчёт для экрана «Тема пройдена»:
# - total / correct / percent
# - message («Отлично!» / «Стоит повторить»)
# - weak_skills этой темы (с понятными названиями)
# - next_topic
@router.post("/session/complete") @router.post("/session/complete")
async def complete_session(request: Request): async def complete_session(request: Request):
"""Завершить сессию: обновляет прогресс урока/теста, мастерство навыков, прогресс темы и AI-контекст""" """
Завершить сессию: обновляет прогресс, мастерство, AI-контекст
и возвращает отчёт для экрана «Тема пройдена».
🔧 ОБНОВЛЕНО (02.10.2026): session_report —
без AI формируем человеческий отчёт:
- total / correct / percent
- message («Отлично!» / «Стоит повторить»)
- weak_skills этой темы (с понятными названиями)
- next_topic
"""
telegram_id, _ = await require_auth(request) telegram_id, _ = await require_auth(request)
body = await request.json() body = await request.json()
session_id = body.get("session_id") session_id = body.get("session_id")
# 🔧 НОВОЕ: язык для формирования отчёта
lang = body.get("lang", "ru")
pool = await get_pool() pool = await get_pool()
async with pool.acquire() as conn: async with pool.acquire() as conn:
session = await conn.fetchrow("SELECT * FROM learning_sessions WHERE id = $1 AND user_id = $2", session_id, telegram_id) session = await conn.fetchrow(
"SELECT * FROM learning_sessions WHERE id = $1 AND user_id = $2",
session_id, telegram_id,
)
if not session: if not session:
raise HTTPException(404, "Session not found") raise HTTPException(404, "Session not found")
await conn.execute("UPDATE learning_sessions SET is_completed = TRUE, completed_at = NOW() WHERE id = $1", session_id) await conn.execute(
"UPDATE learning_sessions SET is_completed = TRUE, completed_at = NOW() WHERE id = $1",
session_id,
)
stats = await conn.fetchrow(""" # 🔧 Считаем только ПОСЛЕДНИЕ (is_final_answer=TRUE) ответы на каждый вопрос
SELECT COUNT(*) as total, COALESCE(SUM(CASE WHEN correct THEN 1 ELSE 0 END), 0) as correct_count stats = await conn.fetchrow(
FROM user_learning_answers WHERE session_id = $1 AND is_final_answer = TRUE """
""", session_id) WITH last_answers AS (
SELECT DISTINCT ON (question_id) question_id, correct, wrong_because, skill_tag
FROM user_learning_answers
WHERE session_id = $1
ORDER BY question_id, attempt_number DESC
)
SELECT
COUNT(*) AS total,
COALESCE(SUM(CASE WHEN correct THEN 1 ELSE 0 END), 0) AS correct_count
FROM last_answers
""",
session_id,
)
# Слабые навыки этой темы (те, где были ошибки)
weak_rows = await conn.fetch(
"""
WITH last_answers AS (
SELECT DISTINCT ON (question_id) question_id, correct, skill_tag
FROM user_learning_answers
WHERE session_id = $1
ORDER BY question_id, attempt_number DESC
)
SELECT
la.skill_tag,
COUNT(*) FILTER (WHERE NOT la.correct) AS errors,
COALESCE(ll.title_ru, la.skill_tag) AS name_ru,
COALESCE(ll.title_pl, la.skill_tag) AS name_pl,
COALESCE(ll.title_uk, la.skill_tag) AS name_uk,
COALESCE(ll.title_en, la.skill_tag) AS name_en
FROM last_answers la
LEFT JOIN learning_lessons ll ON ll.skill_tag = la.skill_tag
WHERE NOT la.correct
GROUP BY la.skill_tag, ll.title_ru, ll.title_pl, ll.title_uk, ll.title_en
HAVING COUNT(*) FILTER (WHERE NOT la.correct) > 0
ORDER BY errors DESC
LIMIT 5
""",
session_id,
)
# Информация о теме
topic_id = session["topic_id"] topic_id = session["topic_id"]
topic_row = await conn.fetchrow(
"SELECT * FROM learning_topics WHERE topic_id = $1", topic_id
)
# Следующая тема того же уровня
next_topic = None
if topic_row:
next_topic = await conn.fetchrow(
"""
SELECT topic_id, name_ru, name_pl, name_uk, name_en
FROM learning_topics
WHERE level_code = $1
AND order_number > $2
AND is_active = TRUE
ORDER BY order_number
LIMIT 1
""",
topic_row["level_code"], topic_row["order_number"],
)
# ============ Обновляем прогресс ============
# (всё что было — оставляем)
# Обновляем прогресс урока
if session["session_type"] == "lesson": if session["session_type"] == "lesson":
lesson_row = await conn.fetchrow(""" lesson_row = await conn.fetchrow(
SELECT DISTINCT lesson_id FROM user_learning_answers WHERE session_id = $1 AND lesson_id IS NOT NULL """
""", session_id) SELECT DISTINCT lesson_id FROM user_learning_answers
WHERE session_id = $1 AND lesson_id IS NOT NULL
""",
session_id,
)
if lesson_row and lesson_row["lesson_id"]: if lesson_row and lesson_row["lesson_id"]:
lesson_id = lesson_row["lesson_id"] lesson_id = lesson_row["lesson_id"]
score = (stats["correct_count"] / stats["total"] * 100) if stats["total"] > 0 else 0 score = (
stats["correct_count"] / stats["total"] * 100
await conn.execute(""" ) if stats["total"] > 0 else 0
INSERT INTO user_lesson_progress (user_id, lesson_id, started_at, completed_at, attempts_count, correct_count, best_score, completed) await conn.execute(
"""
INSERT INTO user_lesson_progress (
user_id, lesson_id, started_at, completed_at,
attempts_count, correct_count, best_score, completed
)
VALUES ($1, $2, NOW(), NOW(), 1, $3, $4, TRUE) VALUES ($1, $2, NOW(), NOW(), 1, $3, $4, TRUE)
ON CONFLICT (user_id, lesson_id) DO UPDATE ON CONFLICT (user_id, lesson_id) DO UPDATE
SET completed_at = NOW(), SET completed_at = NOW(),
@@ -687,37 +908,111 @@ async def complete_session(request: Request):
correct_count = user_lesson_progress.correct_count + $3, correct_count = user_lesson_progress.correct_count + $3,
best_score = GREATEST(user_lesson_progress.best_score, $4), best_score = GREATEST(user_lesson_progress.best_score, $4),
completed = TRUE completed = TRUE
""", telegram_id, lesson_id, stats["correct_count"], score) """,
telegram_id, lesson_id, stats["correct_count"], score,
)
# Обновляем прогресс темы если это тест
if session["session_type"] == "topic_test": if session["session_type"] == "topic_test":
test_score = (stats["correct_count"] / stats["total"] * 100) if stats["total"] > 0 else 0 test_score = (
stats["correct_count"] / stats["total"] * 100
await conn.execute(""" ) if stats["total"] > 0 else 0
INSERT INTO user_topic_progress (user_id, topic_id, test_started, test_completed, test_score, completed_at) await conn.execute(
"""
INSERT INTO user_topic_progress (
user_id, topic_id, test_started, test_completed, test_score, completed_at
)
VALUES ($1, $2, TRUE, TRUE, $3, NOW()) VALUES ($1, $2, TRUE, TRUE, $3, NOW())
ON CONFLICT (user_id, topic_id) DO UPDATE ON CONFLICT (user_id, topic_id) DO UPDATE
SET test_completed = TRUE, SET test_completed = TRUE,
test_score = $3, test_score = $3,
completed_at = NOW() completed_at = NOW()
""", telegram_id, topic_id, test_score) """,
telegram_id, topic_id, test_score,
# Обновляем мастерство по всем навыкам из этой сессии )
skill_tags = await conn.fetch("""
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: for st in skill_tags:
await update_skill_mastery(conn, telegram_id, st["skill_tag"]) await update_skill_mastery(conn, telegram_id, st["skill_tag"])
# Обновляем прогресс темы ТОЛЬКО для lesson и topic_test
if session["session_type"] in ("lesson", "topic_test") and topic_id: if session["session_type"] in ("lesson", "topic_test") and topic_id:
await update_topic_progress(conn, telegram_id, topic_id) await update_topic_progress(conn, telegram_id, topic_id)
# Обновляем AI-контекст (всегда)
await update_ai_context(conn, telegram_id) await update_ai_context(conn, telegram_id)
return {"status": "ok", "total": stats["total"], "correct_count": stats["correct_count"]} # ============ Формируем отчёт ============
total = stats["total"] or 0
correct_count = stats["correct_count"] or 0
percent = round(correct_count / total * 100) if total > 0 else 0
# Человеческое сообщение (без AI, чистая математика)
if percent >= 90:
message = {
"ru": "Отлично! Ты прекрасно усвоил тему! 🎉",
"pl": "Świetnie! Doskonale opanowałeś temat! 🎉",
"uk": "Чудово! Ти чудово засвоїв тему! 🎉",
"en": "Excellent! You've mastered this topic! 🎉",
}.get(lang, "Отлично! 🎉")
elif percent >= 75:
message = {
"ru": "Хороший результат! Так держать! 💪",
"pl": "Dobry wynik! Tak trzymaj! 💪",
"uk": "Гарний результат! Так тримати! 💪",
"en": "Good result! Keep it up! 💪",
}.get(lang, "Хороший результат! 💪")
elif percent >= 60:
message = {
"ru": "Неплохо! Но есть над чем поработать.",
"pl": "Nieźle! Ale jest nad czym popracować.",
"uk": "Непогано! Але є над чим попрацювати.",
"en": "Not bad! But there's room to improve.",
}.get(lang, "Неплохо!")
else:
message = {
"ru": "Стоит пройти тему ещё раз — много ошибок.",
"pl": "Warto powtórzyć temat — dużo błędów.",
"uk": "Варто пройти тему ще раз — багато помилок.",
"en": "Worth repeating this topic — many mistakes.",
}.get(lang, "Стоит повторить.")
# Слабые навыки на нужном языке
name_field = f"name_{lang}"
weak_skills_out = []
for w in weak_rows:
weak_skills_out.append({
"skill_tag": w["skill_tag"],
"name": w.get(name_field) or w["name_ru"],
"errors": w["errors"],
})
# Информация о следующей теме
next_out = None
if next_topic:
next_out = {
"topic_id": next_topic["topic_id"],
"name": next_topic.get(name_field) or next_topic["name_ru"],
}
# Название текущей темы
topic_name = None
if topic_row:
topic_name = topic_row.get(name_field) or topic_row["name_ru"]
return {
"status": "ok",
"total": total,
"correct_count": correct_count,
"report": {
"topic_id": topic_id,
"topic_name": topic_name,
"percent": percent,
"message": message,
"weak_skills": weak_skills_out,
"next_topic": next_out,
},
}
@router.get("/progress") @router.get("/progress")
@@ -820,7 +1115,7 @@ async def get_analytics(request: Request):
{"role": "system", "content": system_prompt}, {"role": "system", "content": system_prompt},
{"role": "user", "content": user_prompt}, {"role": "user", "content": user_prompt},
], ],
"max_tokens": 1000, "max_tokens": 3000,
"temperature": 0.7, "temperature": 0.7,
}, },
) )
+45 -4
View File
@@ -1,8 +1,27 @@
""" """
Learning Data Package — данные всех уровней. Learning Data Package — данные всех уровней.
Каждый уровень в отдельном файле. Каждый уровень в отдельном файле.
🔧 ОБНОВЛЕНО (02.10.2026): seed_data_only_if_empty —
файлы level_*.py остаются в репозитории как АРХИВ,
но при старте бэкенда контент НЕ перезаписывается, если
в БД уже есть данные.
Причины:
- Контент правится через админку → правки в БД.
- Если seed запускать всегда — правки затираются.
- Уровни (learning_levels) гарантированно создаются — они статичны.
Управление:
- Переменная окружения SEED_LEARNING_DATA=true в .env → заливаем файлы.
- По умолчанию false → пропускаем seed, если данные уже есть.
Для fresh install (пустая БД): seed запустится автоматически,
т.к. проверка «learning_topics пуст» проходит.
""" """
import logging import logging
import os
from database import get_pool from database import get_pool
from . import level_a1, level_a2, level_b1, level_b2, level_c1, level_c2 from . import level_a1, level_a2, level_b1, level_b2, level_c1, level_c2
@@ -10,10 +29,10 @@ logger = logging.getLogger(__name__)
async def init_learning_data(): async def init_learning_data():
"""Инициализирует уровни и все темы""" """Инициализирует уровни и (опционально) контент из файлов."""
pool = await get_pool() pool = await get_pool()
async with pool.acquire() as conn: async with pool.acquire() as conn:
# ============ УРОВНИ ============ # ============ УРОВНИ (всегда, они статичны) ============
levels = [ levels = [
("A1", "Poziom A1", "Уровень A1", "Рівень A1", "Level A1", 1), ("A1", "Poziom A1", "Уровень A1", "Рівень A1", "Level A1", 1),
("A2", "Poziom A2", "Уровень A2", "Рівень A2", "Level A2", 2), ("A2", "Poziom A2", "Уровень A2", "Рівень A2", "Level A2", 2),
@@ -29,7 +48,29 @@ async def init_learning_data():
ON CONFLICT (code) DO NOTHING ON CONFLICT (code) DO NOTHING
""", code, pl, ru, uk, en, sort) """, code, pl, ru, uk, en, sort)
# Загружаем данные каждого уровня logger.info("[seed] learning_levels ensured (A1-C2)")
# ============ ПРОВЕРКА: нужен ли seed контента? ============
force_seed = os.getenv("SEED_LEARNING_DATA", "false").lower() == "true"
topics_count = await conn.fetchval("""
SELECT COUNT(*) FROM learning_topics
""") or 0
if topics_count > 0 and not force_seed:
logger.info(
f"[seed] learning_topics not empty ({topics_count} topics) — "
f"skipping content seed. Установи SEED_LEARNING_DATA=true в .env "
f"для принудительной перезаливки."
)
return
# ============ SEED КОНТЕНТА (fresh install ИЛИ force) ============
if force_seed:
logger.warning("[seed] SEED_LEARNING_DATA=true — принудительная перезаливка контента")
else:
logger.info("[seed] Empty DB detected — seeding content from level_*.py files")
await level_a1.init_level_a1(conn) await level_a1.init_level_a1(conn)
await level_a2.init_level_a2(conn) await level_a2.init_level_a2(conn)
await level_b1.init_level_b1(conn) await level_b1.init_level_b1(conn)
@@ -37,4 +78,4 @@ async def init_learning_data():
await level_c1.init_level_c1(conn) await level_c1.init_level_c1(conn)
await level_c2.init_level_c2(conn) await level_c2.init_level_c2(conn)
logger.info("Learning data fully initialized") logger.info("[seed] Learning content initialized from files")
+45 -11
View File
@@ -6,6 +6,9 @@ Orchestrator — мозг чат-учителя.
3. Иначе → следующий урок по порядку 3. Иначе → следующий урок по порядку
Никакого AI — только детерминированная логика. Никакого AI — только детерминированная логика.
🔧 ОБНОВЛЕНО (04.10.2026): track_filter —
учитель уважает аудиторию юзера (pl / ru_uk / en).
""" """
import logging import logging
from typing import Optional, Dict, Any from typing import Optional, Dict, Any
@@ -24,6 +27,14 @@ async def get_next_lesson(conn, user_id: int) -> Dict[str, Any]:
"reason": str, "reason": str,
"skill_tag": str | None "skill_tag": str | None
} }
🔧 ОБНОВЛЕНО (04.10.2026): track_filter —
учитель уважает аудиторию юзера:
- pl → track='pl'
- ru/uk → track='ru_uk'
- en → track='en'
Все SQL-запросы фильтруют по track, чтобы не подсовывать
RU/UK-уроки польскому или английскому юзеру.
""" """
# Получаем текущий уровень пользователя # Получаем текущий уровень пользователя
@@ -31,6 +42,19 @@ async def get_next_lesson(conn, user_id: int) -> Dict[str, Any]:
SELECT current_level FROM users WHERE telegram_id = $1 SELECT current_level FROM users WHERE telegram_id = $1
""", user_id) or "A1" """, user_id) or "A1"
# 🔧 НОВОЕ (04.10.2026): track_filter —
# определяем track по app_language юзера.
user_lang = await conn.fetchval("""
SELECT app_language FROM users WHERE telegram_id = $1
""", user_id) or "ru"
if user_lang == "pl":
track = "pl"
elif user_lang == "en":
track = "en"
else:
track = "ru_uk"
# ============ ШАГ 1: Проверяем retention_status ============ # ============ ШАГ 1: Проверяем retention_status ============
# Если есть навыки, которые давно не повторяли — повторяем их # Если есть навыки, которые давно не повторяли — повторяем их
overdue_skill = await conn.fetchrow(""" overdue_skill = await conn.fetchrow("""
@@ -44,17 +68,21 @@ async def get_next_lesson(conn, user_id: int) -> Dict[str, Any]:
""", user_id) """, user_id)
if overdue_skill: if overdue_skill:
# 🔧 НОВОЕ (04.10.2026): track_filter_lesson — ищем урок по skill_tag
# ТОЛЬКО в темах нужного track.
lesson = await conn.fetchrow(""" lesson = await conn.fetchrow("""
SELECT l.lesson_id, l.topic_id, l.skill_tag, l.title_pl, l.title_ru, l.title_uk, l.title_en SELECT l.lesson_id, l.topic_id, l.skill_tag, l.title_pl, l.title_ru, l.title_uk, l.title_en
FROM learning_lessons l FROM learning_lessons l
JOIN learning_topics t ON l.topic_id = t.topic_id
WHERE l.skill_tag = $1 WHERE l.skill_tag = $1
AND l.is_active = TRUE AND l.is_active = TRUE
AND t.track = $2
ORDER BY l.order_number ORDER BY l.order_number
LIMIT 1 LIMIT 1
""", overdue_skill["skill_tag"]) """, overdue_skill["skill_tag"], track)
if lesson: if lesson:
logger.info(f"Orchestrator: review (overdue) for user={user_id}, skill={overdue_skill['skill_tag']}") logger.info(f"Orchestrator: review (overdue) for user={user_id}, skill={overdue_skill['skill_tag']}, track={track}")
return { return {
"type": "review", "type": "review",
"lesson": dict(lesson), "lesson": dict(lesson),
@@ -74,17 +102,20 @@ async def get_next_lesson(conn, user_id: int) -> Dict[str, Any]:
""", user_id) """, user_id)
if weak_skill: if weak_skill:
# 🔧 НОВОЕ (04.10.2026): track_filter_lesson
lesson = await conn.fetchrow(""" lesson = await conn.fetchrow("""
SELECT l.lesson_id, l.topic_id, l.skill_tag, l.title_pl, l.title_ru, l.title_uk, l.title_en SELECT l.lesson_id, l.topic_id, l.skill_tag, l.title_pl, l.title_ru, l.title_uk, l.title_en
FROM learning_lessons l FROM learning_lessons l
JOIN learning_topics t ON l.topic_id = t.topic_id
WHERE l.skill_tag = $1 WHERE l.skill_tag = $1
AND l.is_active = TRUE AND l.is_active = TRUE
AND t.track = $2
ORDER BY l.order_number ORDER BY l.order_number
LIMIT 1 LIMIT 1
""", weak_skill["skill_tag"]) """, weak_skill["skill_tag"], track)
if lesson: if lesson:
logger.info(f"Orchestrator: review (weak) for user={user_id}, skill={weak_skill['skill_tag']}, mastery={weak_skill['mastery_score']}") logger.info(f"Orchestrator: review (weak) for user={user_id}, skill={weak_skill['skill_tag']}, mastery={weak_skill['mastery_score']}, track={track}")
return { return {
"type": "review", "type": "review",
"lesson": dict(lesson), "lesson": dict(lesson),
@@ -93,20 +124,22 @@ async def get_next_lesson(conn, user_id: int) -> Dict[str, Any]:
} }
# ============ ШАГ 3: Проверяем, нужно ли пройти тест темы ============ # ============ ШАГ 3: Проверяем, нужно ли пройти тест темы ============
# Если пользователь завершил все уроки темы, но не прошёл тест # 🔧 НОВОЕ (04.10.2026): track_filter_test — только темы нужного track.
topic_for_test = await conn.fetchrow(""" topic_for_test = await conn.fetchrow("""
SELECT tp.topic_id, tp.lessons_total, tp.lessons_completed, tp.test_completed SELECT tp.topic_id, tp.lessons_total, tp.lessons_completed, tp.test_completed
FROM user_topic_progress tp FROM user_topic_progress tp
JOIN learning_topics t ON tp.topic_id = t.topic_id
WHERE tp.user_id = $1 WHERE tp.user_id = $1
AND tp.lessons_completed >= tp.lessons_total AND tp.lessons_completed >= tp.lessons_total
AND tp.lessons_total > 0 AND tp.lessons_total > 0
AND tp.test_completed = FALSE AND tp.test_completed = FALSE
AND t.track = $2
ORDER BY tp.topic_id ORDER BY tp.topic_id
LIMIT 1 LIMIT 1
""", user_id) """, user_id, track)
if topic_for_test: if topic_for_test:
logger.info(f"Orchestrator: test for user={user_id}, topic={topic_for_test['topic_id']}") logger.info(f"Orchestrator: test for user={user_id}, topic={topic_for_test['topic_id']}, track={track}")
return { return {
"type": "test", "type": "test",
"lesson": None, "lesson": None,
@@ -115,7 +148,7 @@ async def get_next_lesson(conn, user_id: int) -> Dict[str, Any]:
} }
# ============ ШАГ 4: Следующий урок по порядку ============ # ============ ШАГ 4: Следующий урок по порядку ============
# Находим первый непройденный урок в текущем уровне # 🔧 НОВОЕ (04.10.2026): track_filter_next — только уроки нужного track.
next_lesson = await conn.fetchrow(""" next_lesson = await conn.fetchrow("""
SELECT l.lesson_id, l.topic_id, l.skill_tag, l.title_pl, l.title_ru, l.title_uk, l.title_en, SELECT l.lesson_id, l.topic_id, l.skill_tag, l.title_pl, l.title_ru, l.title_uk, l.title_en,
t.topic_id as topic_id, t.order_number as topic_order t.topic_id as topic_id, t.order_number as topic_order
@@ -123,16 +156,17 @@ async def get_next_lesson(conn, user_id: int) -> Dict[str, Any]:
JOIN learning_topics t ON l.topic_id = t.topic_id JOIN learning_topics t ON l.topic_id = t.topic_id
WHERE t.level_code = $1 WHERE t.level_code = $1
AND l.is_active = TRUE AND l.is_active = TRUE
AND t.track = $3
AND l.lesson_id NOT IN ( AND l.lesson_id NOT IN (
SELECT lesson_id FROM user_lesson_progress SELECT lesson_id FROM user_lesson_progress
WHERE user_id = $2 AND completed = TRUE WHERE user_id = $2 AND completed = TRUE
) )
ORDER BY t.order_number, l.order_number ORDER BY t.order_number, l.order_number
LIMIT 1 LIMIT 1
""", current_level, user_id) """, current_level, user_id, track)
if next_lesson: if next_lesson:
logger.info(f"Orchestrator: new lesson for user={user_id}, lesson={next_lesson['lesson_id']}") logger.info(f"Orchestrator: new lesson for user={user_id}, lesson={next_lesson['lesson_id']}, track={track}")
return { return {
"type": "new", "type": "new",
"lesson": dict(next_lesson), "lesson": dict(next_lesson),
@@ -141,7 +175,7 @@ async def get_next_lesson(conn, user_id: int) -> Dict[str, Any]:
} }
# ============ ШАГ 5: Всё пройдено ============ # ============ ШАГ 5: Всё пройдено ============
logger.info(f"Orchestrator: all completed for user={user_id}") logger.info(f"Orchestrator: all completed for user={user_id}, track={track}")
return { return {
"type": "completed", "type": "completed",
"lesson": None, "lesson": None,
+12 -8
View File
@@ -1,4 +1,3 @@
import random
from fastapi import APIRouter, Request, HTTPException from fastapi import APIRouter, Request, HTTPException
from auth import require_auth from auth import require_auth
from database import get_pool from database import get_pool
@@ -21,14 +20,19 @@ async def get_next_word(request: Request):
lang = user["app_language"] or "pl" lang = user["app_language"] or "pl"
# Берём случайное слово из всех уровней (без привязки к конкретному уровню) # 🔧 ФИКС (30.09.2026): csv_words_source —
# источник слов переехал с level_words (старая схема level_id IS NULL)
# на csv_words. В csv_words нет колонки level — только level_code.
# Фронт ожидает поле "level", поэтому используем алиас level_code AS level.
# DISTINCT ON (word_pl) больше не нужен — в csv_words
# есть UNIQUE(level_code, word_pl), дубликатов по word_pl на одном
# уровне нет, но между уровнями могут быть. Поэтому слово может
# попасться несколько раз с разным level_code — оставляем как есть
# (для произношения уровень не критичен).
word = await conn.fetchrow(""" word = await conn.fetchrow("""
SELECT word_pl, translation_ru, translation_uk, translation_en, level SELECT word_pl, translation_ru, translation_uk, translation_en,
FROM ( level_code AS level
SELECT DISTINCT ON (word_pl) word_pl, translation_ru, translation_uk, translation_en, level FROM csv_words
FROM level_words
WHERE level_id IS NULL
) AS unique_words
ORDER BY RANDOM() ORDER BY RANDOM()
LIMIT 1 LIMIT 1
""") """)
+34 -4
View File
@@ -160,6 +160,8 @@ async def check_sentence(request: Request):
raise HTTPException(400, "Too many words") raise HTTPException(400, "Too many words")
pool = await get_pool() pool = await get_pool()
# 🔧 НОВОЕ (08.10.2026): XP-система — результат award_xp.
xp_result = None
async with pool.acquire() as conn: async with pool.acquire() as conn:
user_exists = await conn.fetchval( user_exists = await conn.fetchval(
"SELECT 1 FROM users WHERE telegram_id = $1", telegram_id "SELECT 1 FROM users WHERE telegram_id = $1", telegram_id
@@ -207,12 +209,28 @@ async def check_sentence(request: Request):
if is_correct: if is_correct:
word_count = len(correct_words_original) word_count = len(correct_words_original)
# 🆕 Расчёт звёзд для "Составь предложение"
# Старт 5. Штрафы:
# -1 за каждую неверную проверку (клиент шлёт wrong_checks)
# -1 если time > лимита (по длине: 3-4 → 30с, 5-6 → 45с, 7-8 → 60с)
wrong_checks = int(body.get("wrong_checks", 0) or 0)
if word_count <= 4: if word_count <= 4:
score = 50 time_limit = 30
elif word_count <= 6: elif word_count <= 6:
score = 75 time_limit = 45
else: else:
score = 100 time_limit = 60
time_penalty = 1 if (completion_time and completion_time > time_limit) else 0
wrong_penalty = min(max(0, wrong_checks), 3)
stars = max(1, 5 - wrong_penalty - time_penalty)
# Начисляем XP
from services.xp import award_xp
xp_result = await award_xp(conn, telegram_id, "sentence", stars)
score = xp_result["points"]
await conn.execute( await conn.execute(
"""INSERT INTO sentence_progress (user_id, sentence_id, completed_at, score, level) """INSERT INTO sentence_progress (user_id, sentence_id, completed_at, score, level)
@@ -267,7 +285,19 @@ async def check_sentence(request: Request):
"correct_words": [normalize_word_for_display(w) for w in correct_words_original], "correct_words": [normalize_word_for_display(w) for w in correct_words_original],
"already_completed": False, "already_completed": False,
"score": score, "score": score,
"new_achievements": new_achievements "new_achievements": new_achievements,
# 🆕 XP
"stars": xp_result["stars"],
"base_points": xp_result["base_points"],
"multiplier": xp_result["multiplier"],
"points": xp_result["points"],
"featured": xp_result["featured"],
"level_up": xp_result["level_up"],
"total_xp": xp_result["total_xp"],
"level": xp_result["level"],
"rank_key": xp_result["rank_key"],
"xp_in_level": xp_result["xp_in_level"],
"xp_needed": xp_result["xp_needed"],
} }
return { return {
+5 -5
View File
@@ -1,7 +1,7 @@
""" """
Support Router — система поддержки пользователей. Support Router — система поддержки пользователей.
Пользователи пишут админу о багах, неточностях и предложениях. Пользователи пишут админу о багах, неточностях и предложениях.
Админ отвечает. Обе стороны могут переводить сообщения через AI (MiniMax-M3). Админ отвечает. Обе стороны могут переводить сообщения через AI (DeepSeek V4 Pro).
""" """
import logging import logging
import httpx import httpx
@@ -16,11 +16,11 @@ logger = logging.getLogger(__name__)
router = APIRouter(prefix="/support", tags=["support"]) router = APIRouter(prefix="/support", tags=["support"])
TOGETHER_API_URL = "https://api.together.xyz/v1/chat/completions" TOGETHER_API_URL = "https://api.together.xyz/v1/chat/completions"
SUPPORT_MODEL = "MiniMaxAI/MiniMax-M3" SUPPORT_MODEL = "deepseek-ai/DeepSeek-V4-Pro-0813"
async def call_ai_translate(text: str, target_lang: str) -> str: async def call_ai_translate(text: str, target_lang: str) -> str:
"""Переводит текст через AI (MiniMax-M3).""" """Переводит текст через AI (DeepSeek V4 Pro)."""
if not TOGETHER_API_KEY: if not TOGETHER_API_KEY:
return "" return ""
@@ -38,7 +38,7 @@ async def call_ai_translate(text: str, target_lang: str) -> str:
{"role": "system", "content": f"Ты — переводчик. Переведи текст на язык: {target_lang}. Отвечай только переводом без пояснений. Не используй markdown."}, {"role": "system", "content": f"Ты — переводчик. Переведи текст на язык: {target_lang}. Отвечай только переводом без пояснений. Не используй markdown."},
{"role": "user", "content": text}, {"role": "user", "content": text},
], ],
"max_tokens": 500, "max_tokens": 1500,
"temperature": 0.3, "temperature": 0.3,
}, },
) )
@@ -334,7 +334,7 @@ async def get_unread_count(request: Request):
@router.post("/translate") @router.post("/translate")
async def translate_message(request: Request): async def translate_message(request: Request):
""" """
Перевод сообщения через AI (MiniMax-M3). Перевод сообщения через AI (DeepSeek V4 Pro).
Доступно и пользователю, и админу. Доступно и пользователю, и админу.
""" """
telegram_id, _ = await require_auth(request) telegram_id, _ = await require_auth(request)
+28 -7
View File
@@ -1,3 +1,13 @@
# 🔧 ФИКС (05.10.2026): max_tokens_for_v4_pro —
# DeepSeek V4 Pro — reasoning-модель, ~80% токенов уходит в reasoning_content,
# только 20% — в content. Увеличили max_tokens в 3 раза, чтобы избежать
# обрезки (finish_reason='length') и пустого content.
#
# 🔧 ФИКС (05.10.2026): disable_reasoning_for_fast_tasks —
# Для простых задач (переводы, объяснения, примеры) reasoning не нужен,
# добавляем reasoning_effort="none" в call_ai. Это экономит токены
# и ускоряет ответ в 3-4 раза.
""" """
Teacher Router — гибридный чат-учитель. Teacher Router — гибридный чат-учитель.
Контент из БД (бесплатно), AI только для реакций и пробелов. Контент из БД (бесплатно), AI только для реакций и пробелов.
@@ -43,7 +53,7 @@ logger = logging.getLogger(__name__)
router = APIRouter(prefix="/teacher", tags=["teacher"]) router = APIRouter(prefix="/teacher", tags=["teacher"])
TOGETHER_API_URL = "https://api.together.xyz/v1/chat/completions" TOGETHER_API_URL = "https://api.together.xyz/v1/chat/completions"
TEACHER_MODEL = "MiniMaxAI/MiniMax-M3" TEACHER_MODEL = "deepseek-ai/DeepSeek-V4-Pro-0813"
TEACHER_AI_DAILY_LIMIT = 5 TEACHER_AI_DAILY_LIMIT = 5
@@ -232,6 +242,11 @@ async def call_ai(prompt: str, system_prompt: str, max_tokens: int = 500) -> str
], ],
"max_tokens": max_tokens, "max_tokens": max_tokens,
"temperature": 0.7, "temperature": 0.7,
# 🔧 ФИКС (05.10.2026): disable_reasoning_for_fast_tasks —
# V4 Pro — reasoning-модель, тратит 80% токенов на «мысли»
# (reasoning_content) и 20-30 секунд на ответ.
# Для фразы дня и переводов reasoning не нужен → отключаем.
"reasoning_effort": "none",
}, },
) )
@@ -282,7 +297,8 @@ async def get_wrong_answer_ai_explanation(telegram_id: int, lang: str, prompt_te
system_prompt = f"""Ты — Марек, учитель польского языка. Объясняй ошибки кратко и понятно. system_prompt = f"""Ты — Марек, учитель польского языка. Объясняй ошибки кратко и понятно.
Отвечай на языке: {lang}. Не используй markdown.""" Отвечай на языке: {lang}. Не используй markdown."""
ai_response = await call_ai(ai_prompt, system_prompt, max_tokens=200) # 🔧 ФИКС (05.10.2026): max_tokens_for_v4_pro — 200 → 600
ai_response = await call_ai(ai_prompt, system_prompt, max_tokens=600)
if ai_response: if ai_response:
async with pool.acquire() as conn: async with pool.acquire() as conn:
@@ -376,7 +392,8 @@ EN_GRAMMAR: [грамматический разбор на английском
user_prompt = f"Создай фразу дня на тему: {selected_topic}." user_prompt = f"Создай фразу дня на тему: {selected_topic}."
ai_response = await call_ai(user_prompt, system_prompt, max_tokens=1000) # 🔧 ФИКС (05.10.2026): max_tokens_for_v4_pro — 1000 → 3000
ai_response = await call_ai(user_prompt, system_prompt, max_tokens=3000)
# Fallback значения # Fallback значения
phrase_pl = "Lepiej późno niż wcale." phrase_pl = "Lepiej późno niż wcale."
@@ -878,7 +895,8 @@ async def teacher_explain(request: Request):
system_prompt = f"""Ты — учитель польского языка. Объясни материал простыми словами. system_prompt = f"""Ты — учитель польского языка. Объясни материал простыми словами.
Отвечай на языке: {lang}. Не используй markdown.""" Отвечай на языке: {lang}. Не используй markdown."""
ai_response = await call_ai(content, system_prompt) # 🔧 ФИКС (05.10.2026): max_tokens_for_v4_pro — добавляем 1500
ai_response = await call_ai(content, system_prompt, max_tokens=1500)
if ai_response: if ai_response:
async with pool.acquire() as conn: async with pool.acquire() as conn:
@@ -953,7 +971,8 @@ async def teacher_examples(request: Request):
Верни только 5 примеров, без вступлений и пояснений.""" Верни только 5 примеров, без вступлений и пояснений."""
ai_response = await call_ai(topic, system_prompt, max_tokens=500) # 🔧 ФИКС (05.10.2026): max_tokens_for_v4_pro — 500 → 1500
ai_response = await call_ai(topic, system_prompt, max_tokens=1500)
if ai_response: if ai_response:
async with pool.acquire() as conn: async with pool.acquire() as conn:
@@ -1015,7 +1034,8 @@ async def teacher_free_message(request: Request):
Ученик может спросить что угодно: объяснить тему, перевести фразу, дать пример. Ученик может спросить что угодно: объяснить тему, перевести фразу, дать пример.
Отвечай кратко (1-3 предложения) и по делу.""" Отвечай кратко (1-3 предложения) и по делу."""
ai_response = await call_ai(user_message, system_prompt, max_tokens=300) # 🔧 ФИКС (05.10.2026): max_tokens_for_v4_pro — 300 → 900
ai_response = await call_ai(user_message, system_prompt, max_tokens=900)
if ai_response: if ai_response:
async with pool.acquire() as conn: async with pool.acquire() as conn:
@@ -1112,7 +1132,8 @@ async def teacher_translate_to_polish(request: Request):
system_prompt = f"""Ты — переводчик польского языка. Переведи текст на польский. system_prompt = f"""Ты — переводчик польского языка. Переведи текст на польский.
Отвечай только переводом без пояснений. Не используй markdown.""" Отвечай только переводом без пояснений. Не используй markdown."""
ai_response = await call_ai(text, system_prompt, max_tokens=300) # 🔧 ФИКС (05.10.2026): max_tokens_for_v4_pro — 300 → 900
ai_response = await call_ai(text, system_prompt, max_tokens=900)
if ai_response: if ai_response:
async with pool.acquire() as conn: async with pool.acquire() as conn:
-1
View File
@@ -3,7 +3,6 @@ Typing Router — раздел "Печать".
Пользователь печатает польские предложения, система проверяет. Пользователь печатает польские предложения, система проверяет.
Без AI — просто сравнение с правильным ответом из БД. Без AI — просто сравнение с правильным ответом из БД.
""" """
import random
from fastapi import APIRouter, Request, HTTPException from fastapi import APIRouter, Request, HTTPException
from auth import require_auth from auth import require_auth
from database import get_pool from database import get_pool
+102
View File
@@ -76,6 +76,26 @@ async def set_language(request: Request):
} }
@router.post("/set-difficulty")
async def set_difficulty(request: Request):
"""Устанавливает уровень сложности (easy/medium/hard)."""
user_id, _ = await require_auth(request)
body = await request.json()
difficulty = body.get("difficulty", "medium")
if difficulty not in {"easy", "medium", "hard"}:
raise HTTPException(400, "Unsupported difficulty")
pool = await get_pool()
async with pool.acquire() as conn:
await conn.execute(
"UPDATE users SET difficulty = $1 WHERE telegram_id = $2",
difficulty, user_id,
)
return {"status": "ok", "difficulty": difficulty}
@router.post("/set-level") @router.post("/set-level")
async def set_level(request: Request): async def set_level(request: Request):
"""Устанавливает текущий уровень пользователя (A1, A2, B1, B2, C1, C2)""" """Устанавливает текущий уровень пользователя (A1, A2, B1, B2, C1, C2)"""
@@ -104,3 +124,85 @@ async def set_level(request: Request):
"status": "ok", "status": "ok",
"level": level, "level": level,
} }
# ============================================================
# 🆕 (08.10.2026): профиль — ник + аватар
# ============================================================
import re as _re
_FORBIDDEN_WORDS = {
"admin", "administrator", "root", "moderator", "mod",
"pleily", "filwords", "support", "help", "system",
"хуй", "пизда", "блядь", "сука", "ебать",
"kurwa", "chuj", "pizda", "jebac",
"fuck", "shit", "bitch", "ass",
}
_NICKNAME_RE = _re.compile(r'^[\w\s\.\-]+$', flags=_re.UNICODE)
def _clean_nickname(raw: str) -> str:
if not raw:
raise HTTPException(400, "Nickname is required")
nick = raw.strip()
if len(nick) < 2:
raise HTTPException(400, "Nickname must be at least 2 characters")
if len(nick) > 20:
raise HTTPException(400, "Nickname must be at most 20 characters")
lower = nick.lower()
for bad in _FORBIDDEN_WORDS:
if bad in lower:
raise HTTPException(400, "Nickname contains forbidden words")
if not _NICKNAME_RE.match(nick):
raise HTTPException(400, "Nickname contains invalid characters")
return nick
@router.post("/set-nickname")
async def set_nickname(request: Request):
"""Сохранить ник пользователя. Body: {"nickname": "Oleg"}"""
user_id, _ = await require_auth(request)
body = await request.json()
nickname = _clean_nickname(body.get("nickname", ""))
pool = await get_pool()
async with pool.acquire() as conn:
existing = await conn.fetchval(
"SELECT user_id FROM user_profile WHERE nickname = $1 AND user_id != $2",
nickname, user_id,
)
if existing:
raise HTTPException(409, "Nickname already taken")
await conn.execute("""
INSERT INTO user_profile (user_id, nickname, updated_at)
VALUES ($1, $2, NOW())
ON CONFLICT (user_id) DO UPDATE
SET nickname = $2, updated_at = NOW()
""", user_id, nickname)
return {"status": "ok", "nickname": nickname}
@router.post("/set-avatar")
async def set_avatar(request: Request):
"""Сохранить аватар. Body: {"avatar_id": 3}"""
user_id, _ = await require_auth(request)
body = await request.json()
avatar_id = body.get("avatar_id")
if not isinstance(avatar_id, int) or avatar_id < 0 or avatar_id > 7:
raise HTTPException(400, "avatar_id must be 0..7")
pool = await get_pool()
async with pool.acquire() as conn:
await conn.execute("""
INSERT INTO user_profile (user_id, avatar_id, updated_at)
VALUES ($1, $2, NOW())
ON CONFLICT (user_id) DO UPDATE
SET avatar_id = $2, updated_at = NOW()
""", user_id, avatar_id)
return {"status": "ok", "avatar_id": avatar_id}
+81 -52
View File
@@ -32,23 +32,20 @@ async def get_next_quiz(request: Request):
async def pick_word(exclude, respect_exclude=True): async def pick_word(exclude, respect_exclude=True):
if respect_exclude and exclude: if respect_exclude and exclude:
placeholders = ",".join([f"${i+2}" for i in range(len(exclude))]) placeholders = ",".join([f"${i+2}" for i in range(len(exclude))])
# 🔧 ФИКС (30.09.2026): csv_words_source —
# источник слов переехал с level_words (старая схема level_id IS NULL)
# на csv_words (level_code). Один источник — CSV-база.
return await conn.fetchrow(f""" return await conn.fetchrow(f"""
SELECT word_pl, translation_ru, translation_uk, translation_en SELECT word_pl, translation_ru, translation_uk, translation_en
FROM ( FROM csv_words
SELECT DISTINCT ON (word_pl) word_pl, translation_ru, translation_uk, translation_en WHERE level_code = $1 AND word_pl NOT IN ({placeholders})
FROM level_words
WHERE level = $1 AND level_id IS NULL AND word_pl NOT IN ({placeholders})
) AS unique_words
ORDER BY RANDOM() ORDER BY RANDOM()
LIMIT 1 LIMIT 1
""", current_level, *exclude) """, current_level, *exclude)
return await conn.fetchrow(""" return await conn.fetchrow("""
SELECT word_pl, translation_ru, translation_uk, translation_en SELECT word_pl, translation_ru, translation_uk, translation_en
FROM ( FROM csv_words
SELECT DISTINCT ON (word_pl) word_pl, translation_ru, translation_uk, translation_en WHERE level_code = $1
FROM level_words
WHERE level = $1 AND level_id IS NULL
) AS unique_words
ORDER BY RANDOM() ORDER BY RANDOM()
LIMIT 1 LIMIT 1
""", current_level) """, current_level)
@@ -67,25 +64,21 @@ async def get_next_quiz(request: Request):
# Ищем неправильные варианты # Ищем неправильные варианты
exclude_for_wrong = recent_words + [correct_polish] exclude_for_wrong = recent_words + [correct_polish]
placeholders = ",".join([f"${i+3}" for i in range(len(exclude_for_wrong))]) placeholders = ",".join([f"${i+3}" for i in range(len(exclude_for_wrong))])
# 🔧 ФИКС (30.09.2026): csv_words_source — источник переведён на csv_words.
wrong_words = await conn.fetch(f""" wrong_words = await conn.fetch(f"""
SELECT word_pl SELECT word_pl
FROM ( FROM csv_words
SELECT DISTINCT ON (word_pl) word_pl WHERE level_code = $1 AND word_pl != $2 AND word_pl NOT IN ({placeholders})
FROM level_words
WHERE level = $1 AND level_id IS NULL AND word_pl != $2 AND word_pl NOT IN ({placeholders})
) AS unique_wrong
ORDER BY RANDOM() ORDER BY RANDOM()
LIMIT 5 LIMIT 5
""", current_level, correct_polish, *exclude_for_wrong) """, current_level, correct_polish, *exclude_for_wrong)
if len(wrong_words) < 2: if len(wrong_words) < 2:
# 🔧 ФИКС (30.09.2026): csv_words_source — fallback тоже на csv_words.
wrong_words = await conn.fetch(""" wrong_words = await conn.fetch("""
SELECT word_pl SELECT word_pl
FROM ( FROM csv_words
SELECT DISTINCT ON (word_pl) word_pl WHERE level_code = $1 AND word_pl != $2
FROM level_words
WHERE level = $1 AND level_id IS NULL AND word_pl != $2
) AS unique_wrong
ORDER BY RANDOM() ORDER BY RANDOM()
LIMIT 5 LIMIT 5
""", current_level, correct_polish) """, current_level, correct_polish)
@@ -133,19 +126,26 @@ async def get_next_quiz(request: Request):
@router.post("/check") @router.post("/check")
async def check_quiz_answer(request: Request): async def check_quiz_answer(request: Request):
"""Проверяет ответ, начисляет очки и проверяет достижения""" """Проверяет ответ, начисляет XP и проверяет достижения.
🔧 НОВОЕ (08.10.2026): XP-система + серии.
Штрафы:
-1 за каждый неверный выбор (макс 3)
-1 если time_ms > 30 сек
Минимум 1 звезда.
Серия: correct_streak (best_streak хранится в choose_progress).
"""
telegram_id, _ = await require_auth(request) telegram_id, _ = await require_auth(request)
body = await request.json() body = await request.json()
correct_polish = body.get("correct_polish", "") correct_polish = body.get("correct_polish", "")
user_answer = body.get("answer", "") user_answer = body.get("answer", "")
completion_time = body.get("completion_time") completion_time = body.get("completion_time")
# 🔧 ФИКС (24.09.2026): client_controlled_mistakes_wordquiz — # 🆕 wrong_count приходит с клиента для UI, но мы считаем на сервере
# mistakes больше НЕ берём от клиента. Считаем на сервере. # 🔧 ФИКС: current_mistakes — серверный счётчик
if not correct_polish or not user_answer: if not correct_polish or not user_answer:
raise HTTPException(400, "correct_polish and answer required") raise HTTPException(400, "correct_polish and answer required")
# Защита от читерства: минимальное время 1 секунда
if completion_time is not None and completion_time < 1: if completion_time is not None and completion_time < 1:
return { return {
"correct": False, "correct": False,
@@ -157,12 +157,11 @@ async def check_quiz_answer(request: Request):
pool = await get_pool() pool = await get_pool()
async with pool.acquire() as conn: async with pool.acquire() as conn:
# Читаем серверный streak и mistakes
current_streak = await conn.fetchval( current_streak = await conn.fetchval(
"SELECT correct_streak FROM word_quiz_progress WHERE user_id = $1", "SELECT correct_streak FROM word_quiz_progress WHERE user_id = $1",
telegram_id telegram_id
) or 0 ) or 0
# 🔧 ФИКС (24.09.2026): client_controlled_mistakes_wordquiz —
# читаем серверный current_mistakes.
mistakes = await conn.fetchval( mistakes = await conn.fetchval(
"SELECT current_mistakes FROM word_quiz_progress WHERE user_id = $1", "SELECT current_mistakes FROM word_quiz_progress WHERE user_id = $1",
telegram_id telegram_id
@@ -172,7 +171,6 @@ async def check_quiz_answer(request: Request):
current_streak += 1 current_streak += 1
else: else:
current_streak = 0 current_streak = 0
# 🔧 Инкрементим mistakes на сервере
await conn.execute(""" await conn.execute("""
INSERT INTO word_quiz_progress (user_id, current_mistakes) INSERT INTO word_quiz_progress (user_id, current_mistakes)
VALUES ($1, 1) VALUES ($1, 1)
@@ -181,9 +179,24 @@ async def check_quiz_answer(request: Request):
""", telegram_id) """, telegram_id)
mistakes += 1 mistakes += 1
xp_result = None
score = 0
if is_correct: if is_correct:
score = max(10, 50 - (mistakes * 20)) # 🆕 Расчёт звёзд для "Выбери слово"
# 🔧 Сбрасываем mistakes при правильном ответе # Старт 5 звёзд. Штрафы:
# -1 за каждый неверный (макс 3)
# -1 если time > 30 сек
time_penalty = 1 if (completion_time and completion_time > 30) else 0
wrong_penalty = min(mistakes, 3)
stars = max(1, 5 - wrong_penalty - time_penalty)
# Начисляем XP
from services.xp import award_xp
xp_result = await award_xp(conn, telegram_id, "choose", stars)
score = xp_result["points"]
# Сбрасываем mistakes + обновляем серию
await conn.execute(""" await conn.execute("""
UPDATE word_quiz_progress SET current_mistakes = 0 WHERE user_id = $1 UPDATE word_quiz_progress SET current_mistakes = 0 WHERE user_id = $1
""", telegram_id) """, telegram_id)
@@ -197,42 +210,34 @@ async def check_quiz_answer(request: Request):
correct_streak = $3 correct_streak = $3
""", telegram_id, score, current_streak) """, telegram_id, score, current_streak)
# 🔧 ФИКС (23.09.2026): achievements_nested_pool_acquire_wordquiz — # 🆕 Обновляем best_streak в choose_progress
# вызовы достижений вынесены за async with pool.acquire() (паттерн game.py). await conn.execute("""
INSERT INTO choose_progress (user_id, current_streak, best_streak)
VALUES ($1, $2, $2)
ON CONFLICT (user_id) DO UPDATE
SET current_streak = $2,
best_streak = GREATEST(choose_progress.best_streak, $2),
updated_at = NOW()
""", telegram_id, current_streak)
# Собираем данные для достижений
total_guessed = await conn.fetchval( total_guessed = await conn.fetchval(
"SELECT words_guessed FROM word_quiz_progress WHERE user_id = $1", "SELECT words_guessed FROM word_quiz_progress WHERE user_id = $1",
telegram_id telegram_id
) or 0 ) or 0
wordsearch_score = await conn.fetchval(
"SELECT COALESCE(SUM(score), 0) FROM user_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
telegram_id
) or 0
sentence_score = await conn.fetchval(
"SELECT COALESCE(SUM(score), 0) FROM sentence_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
telegram_id
) or 0
wordquiz_score = await conn.fetchval(
"SELECT COALESCE(total_score, 0) FROM word_quiz_progress WHERE user_id = $1",
telegram_id
) or 0
bubblewords_score = await conn.fetchval(
"SELECT COALESCE(total_score, 0) FROM bubble_words_progress WHERE user_id = $1",
telegram_id
) or 0
grand_total = wordsearch_score + sentence_score + wordquiz_score + bubblewords_score
achievements_to_check = [ achievements_to_check = [
("quiz_guessed", total_guessed), ("quiz_guessed", total_guessed),
("total_score", grand_total), ("total_score", xp_result["total_xp"]),
] ]
if current_streak >= 10: if current_streak >= 10:
achievements_to_check.append(("quiz_perfect_streak", current_streak)) achievements_to_check.append(("quiz_perfect_streak", current_streak))
if mistakes == 0: if mistakes == 0:
achievements_to_check.append(("quiz_no_mistakes", 1)) achievements_to_check.append(("quiz_no_mistakes", 1))
if completion_time is not None and completion_time > 0 and int(completion_time) <= 3: if completion_time is not None and 0 < completion_time <= 3:
achievements_to_check.append(("quiz_speed", 3)) achievements_to_check.append(("quiz_speed", 3))
else: else:
# При 3 ошибках — начисляем утешительные 10 очков # При 3 ошибках — утешительный XP (10)
if mistakes >= 3: if mistakes >= 3:
await conn.execute(""" await conn.execute("""
INSERT INTO word_quiz_progress (user_id, words_guessed, total_score, correct_streak, current_mistakes) INSERT INTO word_quiz_progress (user_id, words_guessed, total_score, correct_streak, current_mistakes)
@@ -249,7 +254,7 @@ async def check_quiz_answer(request: Request):
SET correct_streak = $2 SET correct_streak = $2
""", telegram_id, current_streak) """, telegram_id, current_streak)
# 🔧 ФИКС (23.09.2026): вызовы достижений ВНЕ блока async with pool.acquire() # Достижения — вне транзакции
if is_correct: if is_correct:
from routers.achievements import check_and_award_achievements from routers.achievements import check_and_award_achievements
new_achievements = [] new_achievements = []
@@ -262,6 +267,20 @@ async def check_quiz_answer(request: Request):
"score": score, "score": score,
"correct_streak": current_streak, "correct_streak": current_streak,
"new_achievements": new_achievements, "new_achievements": new_achievements,
# 🆕 XP-поля
"stars": xp_result["stars"],
"base_points": xp_result["base_points"],
"multiplier": xp_result["multiplier"],
"points": xp_result["points"],
"featured": xp_result["featured"],
"level_up": xp_result["level_up"],
"total_xp": xp_result["total_xp"],
"level": xp_result["level"],
"rank_key": xp_result["rank_key"],
"xp_in_level": xp_result["xp_in_level"],
"xp_needed": xp_result["xp_needed"],
# 🆕 Серия для UI
"streak_best": (await _get_best_streak(telegram_id)),
} }
return { return {
@@ -271,6 +290,16 @@ async def check_quiz_answer(request: Request):
} }
async def _get_best_streak(telegram_id: int) -> int:
"""Возвращает best_streak пользователя из choose_progress."""
pool = await get_pool()
async with pool.acquire() as conn:
return await conn.fetchval(
"SELECT best_streak FROM choose_progress WHERE user_id = $1",
telegram_id
) or 0
@router.get("/progress") @router.get("/progress")
async def get_quiz_progress(request: Request): async def get_quiz_progress(request: Request):
"""Статистика пользователя в квизе""" """Статистика пользователя в квизе"""
+37 -69
View File
@@ -60,6 +60,17 @@ Backend слишком большой (~440K символов) для одног
а не молча терять вклад второй модели. а не молча терять вклад второй модели.
→ Паки не трогаем — routers_admin (97k) пока терпит, но если → Паки не трогаем — routers_admin (97k) пока терпит, но если
начнёт терять secondary — раздробим. начнёт терять secondary — раздробим.
(05.10.2026) ФИКС single_model_v4_pro:
→ Отказались от dual-model (DeepSeek Flash + GLM Flash).
Причина: GLM добавлял мусор, Flash-версии ошибались на сложных файлах.
→ Теперь: только DeepSeek V4 Pro 0813 — флагман, reasoning, 1M контекст.
Один промпт → один ответ → один фильтр → меньше мусора.
→ MIN_CONFIDENCE: 0.75 → 0.80 — V4 Pro увереннее, но подняли порог,
чтобы отсеять спорные находки.
→ reasoning_effort="low" — V4 Pro: reasoning_effort="none"
игнорируется (тест 05.10.2026), "low" даёт минимальный reasoning
(~70 токенов на простой запрос).
→ MAX_OUTPUT_TOKENS: 8000 → 16000 — reasoning (~80%) + JSON (~20%).
""" """
import json import json
@@ -79,34 +90,20 @@ GITEA_BOT_TOKEN = os.environ.get("BOT_TOKEN")
GITEA_INSTANCE = os.environ.get("GITEA_INSTANCE", "https://git.filwordspl.com") GITEA_INSTANCE = os.environ.get("GITEA_INSTANCE", "https://git.filwordspl.com")
GITEA_REPO = os.environ.get("GITEA_REPO", "Drobysh/filwordspl-backend") GITEA_REPO = os.environ.get("GITEA_REPO", "Drobysh/filwordspl-backend")
# 🔧 ФИКС (26.09.2026, ночь): ai_review_glm_flash — # 🔧 ФИКС (05.10.2026): single_model_v4_pro —
# Флагман GLM-5.3 ($1.40 in / $4.40 out) заменён на GLM-5.3-Flash # Отказались от dual-model (DeepSeek Flash + GLM Flash).
# ($0.15 in / $0.50 out) — та же линейка модели (Z.ai), но кодинг-версия # Причина: GLM добавлял мусор, Flash-версии ошибались на сложных файлах.
# попроще и в ~9 раз дешевле. Для point-by-point ревью одного пака # Теперь: только DeepSeek V4 Pro 0813 — флагман, reasoning, 1M контекст.
# флагманская "глубина" не нужна, а бюджет 80 центов/аудит с флагманом # Один промпт → один ответ → один фильтр → меньше мусора.
# на большом фронтенде почти исчерпывался. MODEL_PRIMARY = "deepseek-ai/DeepSeek-V4-Pro-0813"
MODEL_PRIMARY = "deepseek-ai/DeepSeek-V4.1-Flash"
MODEL_SECONDARY = "zai-org/GLM-5.3-Flash"
MODEL = MODEL_PRIMARY # backward compat
# 🔧 ФИКС (26.09.2026, вечер): secondary_model_enabled — USE_SECONDARY_MODEL = False
# если True — гоняем обе модели, объединяем по пересечению.
USE_SECONDARY_MODEL = True
# 🔧 ФИКС (26.09.2026): ai_review_overshoot — # V4 Pro: reasoning полностью НЕ отключается (тест 05.10.2026:
# 32000 токенов = модель пишет "Ок" на каждую функцию. # reasoning_effort="none" игнорируется, "low" даёт ~70 токенов).
# 10 находок × ~500 токенов = 5000. 8000 — с запасом. # max_tokens увеличен с 8000 до 16000 — reasoning (~80%) + JSON (~20%).
# Актуально только для DeepSeek (у GLM свой лимит, см. GLM_MAX_OUTPUT_TOKENS). MAX_OUTPUT_TOKENS = 16000
MAX_OUTPUT_TOKENS = 8000 REASONING_EFFORT = "low"
# 🔧 ФИКС (26.09.2026, ночь): ai_review_glm_reasoning_budget —
# У GLM-5.3(-Flash) thinking НЕЛЬЗЯ выключить полностью (только
# reasoning_effort="low"/"medium"/"high"/"max"), и трейс мышления
# делит один и тот же max_tokens с финальным JSON-ответом.
# Раньше при max_tokens=8000 весь бюджет у GLM уходил в reasoning,
# content оставался пустым. Даём больше запаса именно для GLM.
GLM_MAX_OUTPUT_TOKENS = 12000
GLM_REASONING_EFFORT = "low"
# Что игнорировать при сборе кода # Что игнорировать при сборе кода
IGNORE_DIRS = { IGNORE_DIRS = {
@@ -127,8 +124,10 @@ INCLUDE_EXTENSIONS = {".py"}
MAX_FILE_SIZE = 100_000 MAX_FILE_SIZE = 100_000
# Фильтр находок # Фильтр находок
# 🔧 ФИКС (26.09.2026): MIN_CONFIDENCE 0.7 → 0.75. # 🔧 ФИКС (05.10.2026): filter_more_strict —
MIN_CONFIDENCE = 0.75 # V4 Pro увереннее, но подняли порог с 0.75 до 0.80,
# чтобы отсеять спорные находки.
MIN_CONFIDENCE = 0.80
ALLOWED_SEVERITY = {"user_impact", "data_risk", "maintainability"} ALLOWED_SEVERITY = {"user_impact", "data_risk", "maintainability"}
# 🔧 ФИКС (26.09.2026): overshoot guard. # 🔧 ФИКС (26.09.2026): overshoot guard.
@@ -343,22 +342,12 @@ USER_PROMPT_TEMPLATE = """Проанализируй часть кода про
# ============ Запрос к Together AI ============ # ============ Запрос к Together AI ============
def _is_glm(model_name: str) -> bool:
return "GLM-5.3" in model_name or "glm-5.3" in model_name.lower()
def call_together_model(code: str, pack: dict, model_name: str) -> str: def call_together_model(code: str, pack: dict, model_name: str) -> str:
"""Отправляет код пака в указанную модель. """Отправляет код пака в указанную модель.
🔧 ФИКС (26.09.2026, ночь): ai_review_reasoning_per_model — 🔧 ФИКС (05.10.2026): reasoning_effort_low —
у DeepSeek reasoning реально выключается через V4 Pro: reasoning_effort="none" игнорируется (тест 05.10.2026),
"reasoning": {"enabled": False}. У GLM-5.3(-Flash) это НЕ работает "low" даёт минимальный reasoning.
(thinking у GLM-5.3 нельзя отключить полностью, см. доки Together) —
там единственный рычаг: reasoning_effort="low" + больший max_tokens,
т.к. reasoning-трейс делит бюджет токенов с финальным ответом.
Раньше общий "reasoning": {"enabled": False} для GLM тихо
игнорировался → весь max_tokens=8000 уходил в мышление →
content пустой → "Формат ответа: пусто" на всех GLM-паках.
""" """
print(f" 🤖 Отправляю пак '{pack['name']}' в {model_name}...") print(f" 🤖 Отправляю пак '{pack['name']}' в {model_name}...")
@@ -375,19 +364,13 @@ def call_together_model(code: str, pack: dict, model_name: str) -> str:
{"role": "user", "content": user_prompt}, {"role": "user", "content": user_prompt},
], ],
"temperature": 0.2, "temperature": 0.2,
"max_tokens": MAX_OUTPUT_TOKENS,
# 🔧 ФИКС (05.10.2026): reasoning_effort_low —
# V4 Pro: reasoning_effort="none" игнорируется (тест 05.10.2026),
# "low" даёт минимальный reasoning (~70 токенов на простой запрос).
"reasoning_effort": REASONING_EFFORT,
} }
if _is_glm(model_name):
# GLM-5.3 / GLM-5.3-Flash: thinking нельзя выключить полностью,
# только снизить через reasoning_effort. Даём больше max_tokens,
# т.к. трейс мышления делит бюджет с JSON-ответом.
payload["reasoning_effort"] = GLM_REASONING_EFFORT
payload["max_tokens"] = GLM_MAX_OUTPUT_TOKENS
else:
# DeepSeek: reasoning реально выключается этим флагом.
payload["reasoning"] = {"enabled": False}
payload["max_tokens"] = MAX_OUTPUT_TOKENS
response = httpx.post( response = httpx.post(
"https://api.together.xyz/v1/chat/completions", "https://api.together.xyz/v1/chat/completions",
headers={ headers={
@@ -627,9 +610,6 @@ def format_issue_body(
lines.append("# 🤖 AI Code Review (Backend)") lines.append("# 🤖 AI Code Review (Backend)")
lines.append("") lines.append("")
lines.append(f"**Дата:** {date_str}") lines.append(f"**Дата:** {date_str}")
if USE_SECONDARY_MODEL:
lines.append(f"**Модели:** `{MODEL_PRIMARY}` + `{MODEL_SECONDARY}`")
else:
lines.append(f"**Модель:** `{MODEL_PRIMARY}`") lines.append(f"**Модель:** `{MODEL_PRIMARY}`")
lines.append(f"**Репозиторий:** `{GITEA_REPO}`") lines.append(f"**Репозиторий:** `{GITEA_REPO}`")
lines.append("") lines.append("")
@@ -735,20 +715,8 @@ def main() -> None:
continue continue
primary_raw = call_together_model(code, pack, MODEL_PRIMARY) primary_raw = call_together_model(code, pack, MODEL_PRIMARY)
# 🔧 ФИКС (05.10.2026): single_model —
if USE_SECONDARY_MODEL: # только V4 Pro, без merge.
secondary_raw = call_together_model(code, pack, MODEL_SECONDARY)
# 🔧 ФИКС (27.09.2026): secondary_empty_log —
# если GLM вернул пусто (весь бюджет ушёл в reasoning),
# пишем это явно, чтобы видеть потери второй модели в логах.
if not secondary_raw:
print(
f" ⚠️ Secondary ({MODEL_SECONDARY}) вернул ПУСТО для пака "
f"'{pack['name']}' — пак потерян для второй модели",
file=sys.stderr,
)
findings = merge_dual_findings(primary_raw, secondary_raw)
else:
findings = extract_json(primary_raw) findings = extract_json(primary_raw)
filtered, stats = validate_and_filter(findings, files_map) filtered, stats = validate_and_filter(findings, files_map)
+572
View File
@@ -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())
+76
View File
@@ -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())
+62
View File
@@ -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
View File
@@ -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,
}