Author SHA1 Message Date
Drobysh ba9a43dcfa [Eva] B5.4: /stats — убрать фильтр по уровню и поле level 2026-10-16 11:59:03 +00:00
Drobysh 3c9548540c [Eva] B5.3: database.py — UNIQUE(sentence_number) + перенумерация 2026-10-16 11:58:59 +00:00
Drobysh 5810eccde1 [Eva] B5.2: init_sentences — единый пул, сквозная нумерация 1..400 2026-10-16 11:58:53 +00:00
Drobysh 1df1119d11 [Eva] B5.1: /next — убрать фильтр по уровню (единый пул) 2026-10-16 11:58:50 +00:00
Drobysh 965d5d2503 [Eva] B4: добавляем user_difficulty в ответ /sentences/next 2026-10-16 11:08:03 +00:00
Drobysh a313c08b95 [Eva] B4: читаем difficulty юзера в /sentences/next 2026-10-16 11:08:00 +00:00
Drobysh 400cf375be [Eva] Добавляю идеальные серии и XP-достижения 2026-10-16 10:58:06 +00:00
Drobysh 11ef94a9bf [Eva] Добавляю sentence_speed_3 и серии без ошибок 2026-10-16 10:57:53 +00:00
Drobysh ed60a54e0c [Eva] Добавляю sentence_500 и sentence_1000 2026-10-16 10:57:42 +00:00
Drobysh 2d687904b0 [Eva] Удаляю 3 мёртвых достижения предложений 2026-10-16 10:57:12 +00:00
Drobysh c7ca0c97c2 [Eva] Sentence Builder: заголовок 10 → 20 2026-10-16 10:57:09 +00:00
Drobysh 3dfe34f18a [Eva] Добавляем 3 новых типа достижений в /check 2026-10-16 10:56:48 +00:00
Drobysh 61fbbe55e8 [Eva] Читаем sentence_stats для достижений 2026-10-16 10:56:45 +00:00
Drobysh 7cbde183ff [Eva] B2.3: убрать stars из ответа (KeyError) 2026-10-16 10:49:07 +00:00
Drobysh da3f1567a8 [Eva] B2.3: формула очков по сложности + серии в sentence_stats 2026-10-16 10:49:00 +00:00
Drobysh 82eb9208d8 [Eva] B2.3: already_completed по completed_at IS NOT NULL 2026-10-16 10:48:50 +00:00
Drobysh 5b2dbc0d42 [Eva] B2.2: новый эндпоинт POST /sentences/show-answer 2026-10-16 10:48:37 +00:00
Drobysh 3548654d6a [Eva] B2.1: /next создаёт строку прогресса (in-progress) 2026-10-16 10:48:26 +00:00
Drobysh 4e78c32c18 [Eva] B2.1: /next исключает только завершённые предложения 2026-10-16 10:48:17 +00:00
Drobysh 5be242aafd [Eva] Добавлена таблица sentence_stats + идемпотентные миграции 2026-10-16 10:46:30 +00:00
Drobysh 10242f89b3 [Eva] B1: миграции sentence_progress (list_opened, no_mistakes_streak, perfect_streak, completion_time) 2026-10-16 10:37:29 +00:00
Drobysh 299c4e2fd5 Merge pull request '[Eva] Ева, критичный фикс в wordquiz.py — 500' (#49) from eva/chat-55df46-backend into main
Reviewed-on: #49
2026-10-15 17:46:02 +00:00
Drobysh 38e0c2fe80 [Eva] Fix 500 on /wordquiz/next: LIMIT (wrong_count + 1) → LIMIT 5 (fallback) 2026-10-15 17:45:27 +00:00
Drobysh d669b37397 [Eva] Fix 500 on /wordquiz/next: LIMIT (wrong_count + 1) → LIMIT 5 2026-10-15 17:45:24 +00:00
Drobysh d334bc958d Merge pull request '[Eva] Ева, начинаем новую игру ChooseWord («Уг' (#47) from eva/chat-d4b957-backend into main
Reviewed-on: #47
2026-10-15 17:11:32 +00:00
Drobysh ccd733ba36 [Eva] /check: новые триггеры достижений 2026-10-15 17:10:37 +00:00
Drobysh b7c6bd9ebe [Eva] /check: накопление no_mistakes_streak + запись 2026-10-15 17:10:33 +00:00
Drobysh b25f27fcfe [Eva] /check: читаем no_mistakes_streak 2026-10-15 17:10:28 +00:00
Drobysh 69224b546b [Eva] 6 новых достижений Word Quiz (часть 2) 2026-10-15 17:09:58 +00:00
Drobysh d375a1e1ac [Eva] 6 новых достижений Word Quiz (часть 1) 2026-10-15 17:09:42 +00:00
Drobysh 739cda7eb8 [Eva] quiz_speed_2: тип → quiz_speed_2 2026-10-15 17:09:14 +00:00
Drobysh 8f96c61f29 [Eva] quiz_speed: тип → quiz_speed_3 2026-10-15 17:09:11 +00:00
Drobysh 96abab9883 [Eva] quiz_streak_20: тип → quiz_correct_streak 2026-10-15 17:09:08 +00:00
Drobysh 689a2258c0 [Eva] quiz_perfect_10: тип → quiz_correct_streak 2026-10-15 17:09:05 +00:00
Drobysh cc8e0e01f0 [Eva] Заголовок секции Word Quiz 8 → 20 2026-10-15 17:08:51 +00:00
Drobysh 7d5e3a7d8f [Eva] Миграция: no_mistakes_streak в word_quiz_progress 2026-10-15 17:08:48 +00:00
Drobysh 934e81a55a [Eva] ChooseWord /check: убираю поле stars из ответа 2026-10-15 17:02:13 +00:00
Drobysh 7e8c0e132e [Eva] ChooseWord /check: очки по сложности вместо звёзд 2026-10-15 17:02:06 +00:00
Drobysh af3c634bfd [Eva] ChooseWord /check: проверка языка + difficulty 2026-10-15 17:01:58 +00:00
Drobysh 7ddfc2e451 [Eva] ChooseWord /next: time_limit + новый return 2026-10-15 17:01:55 +00:00
Drobysh 34bae9bb6a [Eva] ChooseWord /next: обрезка вариантов по wrong_count 2026-10-15 17:01:52 +00:00
Drobysh 175691136e [Eva] ChooseWord /next: проверка минимума по wrong_count 2026-10-15 17:01:47 +00:00
Drobysh 7f5fc8311c [Eva] ChooseWord /next: LIMIT fallback по wrong_count 2026-10-15 17:01:44 +00:00
Drobysh edf29cb806 [Eva] ChooseWord /next: LIMIT по wrong_count 2026-10-15 17:01:41 +00:00
Drobysh 279fc5f313 [Eva] ChooseWord /next: проверка языка + wrong_count по сложности 2026-10-15 17:01:39 +00:00
Drobysh 07eebf6fed [Eva] ChooseWord /next: читаем difficulty из users 2026-10-15 17:01:35 +00:00
Drobysh c60f9a39c2 Merge pull request '[Eva] Ева, привет! Задача — собрать анамнез по' (#46) from eva/chat-42ebdc-backend into main
Reviewed-on: #46
2026-10-15 08:13:21 +00:00
Drobysh ced4cd1c8e [Eva] Триггеры новых достижений bubble_words/no_mistakes/streak/xp/speed_15/perfect_streak 2026-10-15 08:12:53 +00:00
Drobysh 25b1437e0b [Eva] Накопление счётчиков words_collected/no_hints_streak/perfect_streak в /complete 2026-10-15 08:12:49 +00:00
Drobysh d77d9bdaef [Eva] achievements: +4 достижения Bubble Words (часть 3) 2026-10-15 08:10:23 +00:00
Drobysh 85a168e8d7 [Eva] achievements: +4 достижения Bubble Words (часть 2) 2026-10-15 08:10:12 +00:00
Drobysh 7204111ad6 [Eva] achievements: +4 достижения Bubble Words (часть 1) 2026-10-15 08:09:54 +00:00
Drobysh 214567383e [Eva] achievements: Bubble Words 8 → 20 (заголовок секции) 2026-10-15 08:07:30 +00:00
Drobysh 3257b5da3b [Eva] Миграция: 3 колонки в bubble_words_progress (words_collected, no_hints_streak, perfect_streak) 2026-10-15 08:05:27 +00:00
Drobysh 92780b247d [Eva] bubble_speed_30: тип bubble_speed → bubble_speed_30 2026-10-15 08:01:19 +00:00
Drobysh eeb5a382c9 [Eva] bubble_speed: тип bubble_speed → bubble_speed_45 2026-10-15 08:01:16 +00:00
Drobysh ab45d026dd [Eva] bubblewords: передаём тип bubble_speed_45 2026-10-15 08:01:06 +00:00
Drobysh b6a8783ad0 Merge pull request '[Eva] Ева, патч 21 применён — теперь ты можешь' (#45) from eva/chat-b7c183-backend into main
Reviewed-on: #45
2026-10-14 16:52:17 +00:00
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 abc3a8ae7d Merge pull request '[Eva] Ева, патч 21 применён — теперь ты можешь' (#44) from eva/chat-b7c183-backend into main
Reviewed-on: #44
2026-10-14 11:59:16 +00:00
Drobysh 7c43812475 [Eva] bubblewords /next: число слов по сложности (easy 3, medium 4, hard 5) 2026-10-14 11:53:50 +00:00
Drobysh 3f7e7ef8d6 Merge pull request '[Eva] Ева, патч 21 применён — теперь ты можешь' (#43) from eva/chat-b7c183-backend into main
Reviewed-on: #43
2026-10-14 11:06:40 +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 4bbaa0030f Merge pull request '[Eva] Ева, патч 21 применён — теперь ты можешь' (#42) from eva/chat-b7c183-backend into main
Reviewed-on: #42
2026-10-14 09:37:45 +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 3c60cfed31 Merge pull request '[Eva] Ева, патч 21 применён — теперь ты можешь' (#41) from eva/chat-b7c183-backend into main
Reviewed-on: #41
2026-10-14 09:25:07 +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 118345f701 Merge pull request '[Eva] Ева, патч 21 применён — теперь ты можешь' (#40) from eva/chat-b7c183-backend into main
Reviewed-on: #40
2026-10-14 09:03:24 +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
Drobysh f2c7be8451 feat(db): lectures.lecture_language + display_language, миграция + индекс 2026-09-27 10:35:18 +00:00
Drobysh c4814d8442 refactor(lectures): упрощена модель — уровень+язык+файл, admin/list + preview 2026-09-27 10:35:03 +00:00
Drobysh 9642d73cf1 chore(deps): pin pdfplumber==0.11.10 2026-09-27 10:34:49 +00:00
Drobysh 453db5b91c 🔐 Admin auth + Lectures backend
Новое:
- routers/admin_auth.py — JWT-логин для админки
- auth.py — двухрежимная авторизация (X-Admin-Token + Telegram)
- config.py — ADMIN_LOGIN, ADMIN_PASSWORD_HASH, ADMIN_JWT_SECRET,
              FRONTEND_ORIGINS (admin.filwordspl.com), ADMIN_TOKEN_USER_ID
- main.py — CORS для admin-домена, X-Admin-Token в allow_headers
- routers/lectures.py — 6 эндпоинтов для лекций (PDF/HTML)
- database.py — таблица lectures
- smoke_test_report.md — отчёт робота
2026-09-27 07:54:32 +00:00
Drobysh f7859783d3 📄 Lectures: backend для раздела «Обучение»
Новое:
- Таблица lectures (PDF/HTML, привязка к уровню, скачивание)
- routers/lectures.py — 6 эндпоинтов:
  - GET  /learning/lectures?level=A1 — список
  - GET  /learning/lecture/{id} — метаданные
  - GET  /learning/lecture/{id}/download — скачать файл
  - POST /admin/lectures/upload — загрузить (multipart)
  - PUT  /admin/lectures/{id} — редактировать
  - DELETE /admin/lectures/{id} — удалить
- Регистрация роутера в main.py
- Миграция в database.py::init_db()

Проверено: GET /learning/lectures → 200, {level:A1, lectures:[]}
2026-09-26 16:46:29 +00:00
Drobysh d6231b7b0f 🧪 Smoke-test: fix admin_content — патч ADMIN_IDS в модуле
Root cause: admin_content.py использует 'from config import ADMIN_IDS' —
значение импортируется при загрузке модуля. Патч config.ADMIN_IDS
не влияет на уже загруженный модуль.

Fix: патчим admin_content_module.ADMIN_IDS напрямую (как для admin,
feed, support, users).

Было: 8 FAILED (403 для всех admin_content)
Стало: ожидаем 8 PASSED
2026-09-26 09:54:09 +00:00
Drobysh ccfe31b9fa 🧪 Smoke-test: подволна A2 — 58 сценариев, 53 PASSED + 5 SKIPPED
Добавлено (волна 6):
- learning: lesson_detail, topic_test, ai_context, practice_start, analytics*
- teacher: resume_no_session, diagnostic_test, answer_flow, history_save_load,
           history_clear, free_message*, translate_to_polish*, explain*
- achievements: 8 track-эндпоинтов + user
- users: is_admin, set_level (+ возврат на A1)
- admin: sentry_errors_forbidden
- assistant: stats_personal, stats_admin_forbidden
- support: send, unread_count
- feed: post_detail
- hints: word_list, remaining
- game: progress, check_word

* — AI-эндпоинты, помечены @pytest.mark.skip

Инвентаризация (scripts + результат):
- scripts/dump_inventory.py — собирает эндпоинты + схему БД
- scripts/dump_schema.py — только схема БД (без pool.close, чтобы не висло)
- endpoints_inventory.md — 105 эндпоинтов
- database_schema.md — 40 таблиц

Итого: 58 сценариев, 53 PASSED, 5 SKIPPED (AI), 0 FAILED.
2026-09-26 09:41:04 +00:00
Drobysh 42db922c4d 🧪 Smoke-test: подволна A2 — +33 сценария (learning, teacher, achievements, users, admin, assistant, support, feed, hints, game) 2026-09-26 09:35:47 +00:00
Drobysh ffec374a74 🧪 Smoke-test: fix cleanup order (FK learning_sessions → user_learning_answers)
25/25 сценариев PASSED. Ошибка была в teardown:
user_learning_answers.session_id ссылается на learning_sessions.id
через FK. При удалении learning_sessions первым Postgres падал
с ForeignKeyViolationError.

Fix: удаляем user_learning_answers ДО learning_sessions.
Порядок в NON_FK_TABLES теперь: дочерние → родительские.
2026-09-26 09:24:54 +00:00
Drobysh 7b50e5ba92 🧪 Smoke-test: волны 2-5 — 25 сценариев
Покрытие:
- pronunciation, hints, game (волна 1)
- wordquiz, bubblewords, sentences, typing (волна 2)
- users, achievements (волна 2)
- learning: levels, topics, session/start, session/full_flow, progress (волна 3)
- teacher: progress, phrase-of-day, start (волна 3)
- leaderboard: top (волна 3)
- assistant: limit, history (волна 4)
- support: user-tickets (волна 4)
- admin: dashboard forbidden (волна 5)
- feed: news (волна 5)

Все проверки через реальную БД. Отчёт группируется по секциям.
2026-09-26 09:22:27 +00:00
Drobysh 7141b73c58 🧪 Smoke-test: 10/10 PASSED — волна 1 + волна 2
Покрытие (10 сценариев):
- pronunciation_pool_stress — утечка пула
- hints_db_increment — списание подсказок
- game_complete_level_full_flow — идемпотентность + score
- wordquiz_correct_answer — total_score растёт
- wordquiz_wrong_answer — current_mistakes растёт
- bubblewords_complete_flow — levels + score
- sentences_check_wrong — неверный ответ не начисляет
- typing_progress_flow — typing_progress записан
- users_set_language — app_language меняется
- achievements_track_login — daily_logins растёт

Результат: 10/10 PASSED за 0.79s.
Робот подтверждает: большинство находок AI-ревью по этим
разделам — галлюцинации.

Инвентаризация:
- scripts/dump_inventory.py — собирает эндпоинты + схему
- endpoints_inventory.md — 105 эндпоинтов
- database_schema.md — 40 таблиц
2026-09-26 09:16:20 +00:00
Drobysh eef9c393ca 🧪 Smoke-test: fix typing_progress_flow (sentence_pl из БД)
Root cause: GET /typing/next возвращает sentence_id + translation,
но НЕ sentence_pl. Робот не мог отправить правильный текст.

Fix:
- Берём sentence_pl напрямую из базы по sentence_id
- Если completed=True — не FAIL, а SKIP (все пройдены)

Результат волны 2: 9/10 PASSED, 1 SKIPPED (typing)
2026-09-26 09:13:04 +00:00
Drobysh b883cd50bf 🧪 Smoke-test: волна 2 — +7 сценариев (wordquiz, bubblewords, sentences, typing, users, achievements)
Добавлено:
- wordquiz_correct_answer — total_score растёт при правильном ответе
- wordquiz_wrong_answer — current_mistakes растёт при неверном
- bubblewords_complete_flow — levels_completed + total_score растут
- sentences_check_wrong — неверный ответ НЕ начисляет очки
- typing_progress_flow — typing_progress.completed_at записан
- users_set_language — app_language меняется
- achievements_track_login — daily_logins.login_date записан

Покрытие: 10 сценариев (3 базовых + 7 новых)
2026-09-26 09:09:21 +00:00
Drobysh 571139f364 🧪 Smoke-test: TestClient → httpx.AsyncClient (fix asyncpg loop conflict)
Root cause: TestClient (starlette) создаёт свой event loop для каждого
запроса, а asyncpg-пул привязан к тому event loop, в котором создан.
Второй запрос падал с InterfaceError: cannot perform operation:
another operation is in progress.

- Заменён TestClient на httpx.AsyncClient + ASGITransport
- Все client.get/post теперь с await
- Все запросы идут в том же event loop, что и asyncpg-пул
2026-09-26 08:49:46 +00:00
Drobysh b650adc05c 🧪 Smoke-test робот: проверка 3 сценариев против реальной БД
Диагност, не хирург: дёргает эндпоинты как фронтенд, читает БД,
не чинит баги — только пишет отчёт smoke_test_report.md.

- pronunciation_pool_stress: 30 запросов подряд (проверка утечки пула)
- hints_db_increment: сверка hints_used в user_progress до/после
- game_complete_level_full_flow: идемпотентность + сверка score с БД

Использует SMOKE_USER_ID=9999999999 (отдельно от TEST_USER_ID=999999999).
После прогона чистит за собой.
2026-09-26 08:45:07 +00:00
Drobysh 9791d33b3a 🔧 AI Review: логируем ПУСТО от secondary (backend)
Симметрично с frontend: если GLM-5.3-Flash вернул пустой content
для пака — пишем явно в stderr, чтобы видеть потери в логах,
а не молча терять вклад второй модели.

Паки не трогаем — routers_admin (97k) пока терпит.
2026-09-25 19:54:14 +00:00
Drobysh fa2f4e1500 🔧 AI Review: reasoning_effort=low для GLM (thinking не выключается)
Root cause: reasoning: {enabled: false} НЕ работает для GLM-5.3(-Flash).
Thinking нельзя отключить полностью (доки Together).
Единственный рычаг — reasoning_effort=low + max_tokens=12000.

- MODEL_SECONDARY: GLM-5.3 → GLM-5.3-Flash ($0.15/$0.50 vs $1.40/$4.40)
- _is_glm() — определение GLM по имени
- GLM: reasoning_effort=low, max_tokens=12000
- DeepSeek: reasoning={enabled: false}, max_tokens=8000
- Логируем длину reasoning_content для диагностики
- Разбивка routers_learning на 3 пака (было finish=length)

Бюджет: ~$0.25-0.35 на оба репо.
2026-09-25 19:27:15 +00:00
Drobysh 8de309bca9 🔧 AI Review: dual-model (DeepSeek + GLM 5.3) + split routers_learning
1. routers_learning (100k) разбит на 3 пака:
   - routers_learning_core (learning.py)
   - routers_learning_teacher (teacher.py)
   - routers_learning_orch (orchestrator + profile + data)
   → finish=length исчезнет.

2. Вторая модель GLM 5.3:
   - MODEL_PRIMARY = DeepSeek V4.1 Flash (основная)
   - MODEL_SECONDARY = GLM 5.3 (вторая)
   - merge_dual_findings: пересечение по (file, snippet) → confidence +0.05
   - Только primary → normal, только secondary → normal
   - USE_SECONDARY_MODEL=True

3. format_issue_body показывает источник: 🔗 both / 🔵 secondary

Ожидаем: качество находок, меньше ложных.
2026-09-25 18:57:22 +00:00
Drobysh 54ae48f193 🔧 AI Review: откат V4 Pro → V4.1 Flash
V4 Pro 0813 не поддерживает reasoning: {enabled: false} —
content пустой, finish=length, находки теряются.
Откат на проверенный V4.1 Flash.
Все фиксы оставлены: MAX_OUTPUT_TOKENS=8000, MIN_CONFIDENCE=0.75,
ужесточённый промпт (запрет 'Ок'/'Не баг'), overshoot guard (>15 → топ-10).
2026-09-25 18:41:45 +00:00
Drobysh c3c0521ae4 🔧 AI Review: DeepSeek V4 Pro 0813 (quality-first)
- MODEL: DeepSeek-V4.1-Flash → DeepSeek-V4-Pro-0813
  (Coding 68.8 AA, SWE-Bench 80.6%, 1M контекст)
- MAX_OUTPUT_TOKENS: 32000 → 8000 (модель перестаёт писать всё подряд)
- MIN_CONFIDENCE: 0.7 → 0.75
- SYSTEM_PROMPT: запрет 'Ок'/'Не баг'/'Работает корректно', ТОП-10 по severity
- USER_PROMPT: 'Ищи ТОЛЬКО реальные проблемы'
- validate_and_filter: overshoot guard (> 15 находок → топ-10 по confidence)
- reasoning: {enabled: false} (остаётся)

Цель: убрать 81% мусора из routers_learning (было 174 находки, ~130 'Ок').
2026-09-25 18:31:43 +00:00
Drobysh f7a4bf5c71 🌊 Волна 23: быстрые фиксы (N+1, индексы, rate limiter, options)
- admin_content get_word_levels: 12 запросов → 1 GROUP BY
- admin_content update_lesson: валидация >26 options (option_key overflow)
- database.py: удалены дубли индексов levels/sentences
- main.py RateLimiter._cleanup: использует max(window) из limits

Аудит v10: быстрые фиксы
2026-09-25 18:07:09 +00:00
Drobysh eda9bbd92c 🔧 ФИКС: completed/already_completed не путают подсказку с завершением
Проблема: hints.py создаёт строку user_progress с score=0,
completed_at=NULL (пометка о подсказке). Но:
- get_level: completed = progress is not None → показывал 'Уже пройдено!'
- complete_level: already_completed = True при любой строке →
  last_completed_level НЕ обновлялся → следующие уровни недоступны

Фикс: completed / already_completed = completed_at IS NOT NULL
ИЛИ score > 0. Строка от подсказки больше не считается пройденным уровнем.
2026-09-25 17:47:44 +00:00
Drobysh 6ce33b0ce1 🌊 Волна 21: backend — 4 фикса (сессии, hints, complete_level)
- start_session: реальный level_code из learning_topics (не доверяем клиенту)
- teacher_answer: проверка владельца сессии (user_id)
- hints.py: UPSERT вместо UPDATE (лимит 3 подсказки для новых юзеров)
- game.py complete_level: ON CONFLICT DO UPDATE (не падаем с unique violation,
  если юзер брал подсказку → строка user_progress уже есть)

Аудит v10 backend: критичные фиксы
2026-09-25 17:08:46 +00:00
Drobysh cceea8acf8 🔧 AI Review (backend): root cause fix — отключён reasoning
Root cause: DeepSeek-V4.1-Flash по умолчанию reasoning-модель
(reasoning_effort=high). На больших паках весь max_tokens уходил
в thinking → content пустой, finish=length, находки терялись.

Фиксы:
- reasoning: {enabled: False} — не тратить бюджет на thinking
- Убран fallback на reasoning_content (источник 'Ошибка парсинга JSON':
  туда попадал сырой текст рассуждений, не JSON)
- extract_json через json.JSONDecoder.raw_decode — спасаем валидные
  объекты, даже если ответ обрезан по max_tokens
- В SYSTEM_PROMPT: 'Не думай вслух — сразу выдавай JSON-массив'

Ожидается: finish=stop на всех паках, полные находки.
2026-09-25 16:30:38 +00:00
Drobysh 36cf226397 🔧 AI Review (backend): max_tokens 12k→32k + разбивка routers
- MAX_OUTPUT_TOKENS: 12000 → 32000 (DeepSeek обрезался на больших паках)
- routers (329k, 21 файл) → 4 пака:
  * routers_games — game, hints, wordquiz, bubblewords, sentences, typing, pronunciation
  * routers_learning — learning, learning_profile, teacher, orchestrator, learning_data
  * routers_admin — admin, admin_content, feed, support
  * routers_misc — achievements, users, leaderboard, assistant, tts
- core (main, database, auth, config, bot) — отдельный пак
- services → scripts (убран пустой __init__.py)
- __init__.py добавлен в IGNORE_FILES
- Итого: 3 пака → 6 паков, максимальный ~120k символов
2026-09-25 15:56:46 +00:00
Drobysh 2b08a4999f 🌊 Волна 19: backend — 6 фиксов + database.py
database.py:
- get_pool_race: asyncio.Lock + двойная проверка
- init_db_no_transaction: вся инициализация в одной транзакции
- drop_constraint_cascade: убран CASCADE
- add_pk_on_duplicates: DELETE дублей через DISTINCT ON (умная версия)
- redundant_index_users_telegram: удалены дубли индексов
- fstring_sql_migration: whitelist regex _SAFE_NAME + _SAFE_TYPE
- ensure_achievements_code_key: гарантия UNIQUE на achievements.code
- sentence_hints_used + typing_hints_used
- client_controlled_* (current_streak, current_mistakes, current_hints_used)

routers/hints.py:
- hint_consumed_before_word_paths_check: инкремент после проверок
- word_list_hint_consumed_on_empty: слова до инкремента

routers/admin_content.py:
- admin_content_text_levels_n_plus_1: 12 запросов → 1 GROUP BY

routers/assistant.py:
- assistant_admin_stats_n_plus_1: 10 запросов → 2 GROUP BY

routers/leaderboard.py:
- leaderboard_admin_stats_n_plus_1: 6 запросов → 1 GROUP BY

routers/achievements.py:
- init_achievements_n_plus_1: 104 запроса → 1 bulk upsert
- добавлен logger (отсутствовал)

Аудит v6: backend 6/6 закрыто
2026-09-25 10:10:11 +00:00
Drobysh 555bf44db2 🌊 Волна 19: backend — 6 фиксов (hints + N+1 + logger) 2026-09-25 10:09:13 +00:00
45 changed files with 11805 additions and 759 deletions
+3
View File
@@ -9,3 +9,6 @@ uploads/
.DS_Store
.env.save
.env.*
*.backup_*
*.sql
*.backup*
+1 -2
View File
@@ -10,9 +10,8 @@
import asyncio
import asyncpg
import json
import os
import logging
from datetime import datetime, timedelta, timezone
from datetime import datetime
from decimal import Decimal
from pathlib import Path
from config import DB_CONFIG
+39 -25
View File
@@ -73,7 +73,6 @@ async def verify_telegram_initdata(init_data: str):
user_id = user_data.get('id')
username = user_data.get('username', '')
# 🔧 ФИКС (25.09.2026): unused_first_name — удалена мёртвая переменная.
if not user_id:
raise HTTPException(401, "User ID not found in initData")
@@ -83,52 +82,67 @@ async def verify_telegram_initdata(init_data: str):
except HTTPException:
raise
except Exception as e:
# 🔧 ФИКС (23.09.2026): auth_error_leak — раньше в 401 утекали
# внутренние детали (str(e)). Теперь логируем на сервере,
# клиенту — обобщённое сообщение.
logger.error(f"Auth error: {str(e)}", exc_info=True)
raise HTTPException(401, "Invalid initData")
async def require_auth(request: Request):
"""Извлекает и проверяет initData из запроса.
"""Извлекает и проверяет авторизацию из запроса.
🔧 ФИКС (23.09.2026): INIT_DATA_IN_URL — поддержка Authorization: tma <initData>.
Приоритет источников:
1. Authorization: tma <initData> — новый способ (фронт 23.09+)
2. X-Telegram-InitData — старый способ (фронт до 23.09)
3. query-параметр initData — fallback для deleteFeedPost
(осознанное исключение из-за
Cloudflare preflight-кеша)
Zero-downtime: старые и новые клиенты работают одновременно.
Пять режимов (в порядке приоритета):
1. X-Admin-Token: <jwt> — админка через браузер (26.09.2026)
2. Authorization: Bearer <jwt> — Pleily (07.10.2026)
3. Authorization: tma <initData> — Telegram Mini App
4. X-Telegram-InitData — старый способ
5. query-параметр initData — fallback для deleteFeedPost
"""
# ============ Режим 1: админ-токен ============
admin_token = request.headers.get('X-Admin-Token', '').strip()
if admin_token:
try:
from routers.admin_auth import verify_jwt
from config import ADMIN_TOKEN_USER_ID
payload = verify_jwt(admin_token)
# Возвращаем специальный ID для admin-токена
return ADMIN_TOKEN_USER_ID, payload.get('login', 'admin')
except ValueError as e:
logger.warning(f"Admin token invalid: {e}")
raise HTTPException(401, "Invalid admin token")
# ============ Режим 2: Bearer JWT (Pleily) ============
# 🔧 НОВОЕ (07.10.2026): app_jwt_auth —
# мобильное приложение Pleily ходит с Authorization: Bearer <JWT>.
# verify_app_jwt возвращает payload с user_id (отрицательный для Pleily).
auth_header = request.headers.get('Authorization', '')
if auth_header.startswith('Bearer '):
from routers.app_auth import verify_app_jwt
token = auth_header[7:].strip()
payload = verify_app_jwt(token)
user_id = int(payload.get('user_id'))
return user_id, f"app_{user_id}"
# ============ Режим 3: Telegram initData ============
init_data = ''
# 1. Authorization: tma <initData> (новый способ)
auth_header = request.headers.get('Authorization', '')
# 3.1. Authorization: tma <initData>
if auth_header.startswith('tma '):
init_data = auth_header[4:].strip()
# 2. X-Telegram-InitData (старый способ)
# 3.2. X-Telegram-InitData (старый способ)
if not init_data:
init_data = request.headers.get('X-Telegram-InitData', '')
# 3. Query-параметр (fallback, нужен для deleteFeedPost)
# 3.3. Query-параметр (fallback, нужен для deleteFeedPost)
if not init_data:
init_data = request.query_params.get('initData', '')
if not init_data:
raise HTTPException(
401,
"initData required. Pass as Authorization header 'tma <initData>' "
"or 'X-Telegram-InitData' or query parameter 'initData'"
"Authorization required. Pass 'X-Admin-Token' or "
"'Authorization: tma <initData>' or 'X-Telegram-InitData' "
"or query parameter 'initData'"
)
# 🔧 ФИКС (23.09.2026): double_unquote_initdata — убран повторный unquote.
# Starlette уже декодирует query_params. Повторный unquote ломал auth,
# если в initData был символ '%' (например в first_name).
# Декодирование значений происходит внутри verify_telegram_initdata.
user_id, username = await verify_telegram_initdata(init_data)
return user_id, username
+19 -1
View File
@@ -26,7 +26,16 @@ DB_CONFIG = {
# дефолтом был конкретный telegram_id (6694989403), который получал админку.
# Теперь дефолт пустой — админов нет, пока не задан ADMIN_IDS.
ADMIN_IDS = [int(id_str) for id_str in os.getenv("ADMIN_IDS", "").split(",") if id_str.strip()]
FRONTEND_ORIGIN = os.getenv("FRONTEND_ORIGIN", "https://filwordspl.com")
# Маркер для admin-токена (авторизация через браузер)
ADMIN_TOKEN_USER_ID = -1
if ADMIN_TOKEN_USER_ID not in ADMIN_IDS:
ADMIN_IDS.append(ADMIN_TOKEN_USER_ID)
# 🔧 ФИКС (26.09.2026): admin_cors — добавляем admin-домен для CORS
FRONTEND_ORIGINS = [
"https://filwordspl.com",
"https://admin.filwordspl.com",
]
# 🔧 ФИКС (23.09.2026): initdata_age_24h — 24 часа слишком долго,
# окно для replay-атак. Grok рекомендовал 4-6ч (компромисс между UX и безопасностью).
@@ -79,3 +88,12 @@ FEED_ALLOWED_IMAGE_TYPES = {
# Языки, на которые переводим feed-посты (используется в admin_feed translate)
FEED_TARGET_LANGUAGES = ["pl", "ru", "uk", "en"]
# ============ ADMIN PANEL (26.09.2026) ============
# Логин/пароль для входа в админку через браузер.
ADMIN_LOGIN = os.getenv("ADMIN_LOGIN", "admin")
ADMIN_PASSWORD_HASH = os.getenv("ADMIN_PASSWORD_HASH", "")
ADMIN_JWT_SECRET = os.getenv("ADMIN_JWT_SECRET", "")
# 🔧 НОВОЕ (07.10.2026): app_jwt_secret — JWT для Pleily
APP_JWT_SECRET = os.getenv("APP_JWT_SECRET", "")
+813 -9
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 ============
col_exists = await conn.fetchval("""
SELECT 1 FROM information_schema.columns
@@ -192,6 +229,21 @@ async def init_db():
""")
logger.info("Added current_streak column to user_progress")
# ============ Авто-миграция: добавляем wave в user_progress ============
# 🔧 НОВОЕ (13.10.2026): wave — номер волны, к которой относится
# пройденный уровень. Нужен для подсчёта wave_points (сумма очков
# за 10 уровней волны) в модалке итогов волны.
col_exists = await conn.fetchval("""
SELECT 1 FROM information_schema.columns
WHERE table_name = 'user_progress' AND column_name = 'wave'
""")
if not col_exists:
await conn.execute("""
ALTER TABLE user_progress
ADD COLUMN wave INTEGER
""")
logger.info("Added wave column to user_progress")
# ============ sentences ============
await conn.execute("""
CREATE TABLE IF NOT EXISTS sentences (
@@ -206,20 +258,31 @@ async def init_db():
)
""")
# ============ Убираем старый UNIQUE constraint с sentences.sentence_number ============
# ============ Убираем составной UNIQUE (level, sentence_number) ============
await conn.execute("""
ALTER TABLE sentences DROP CONSTRAINT IF EXISTS sentences_sentence_number_key
ALTER TABLE sentences DROP CONSTRAINT IF EXISTS sentences_sentence_number_unique
""")
# ============ Добавляем составной UNIQUE (level, sentence_number) ============
# ============ Пересчёт номеров: единый пул 1..N ============
await conn.execute("""
UPDATE sentences s
SET sentence_number = sub.rn
FROM (
SELECT id, ROW_NUMBER() OVER (ORDER BY id) AS rn
FROM sentences
) sub
WHERE s.id = sub.id
""")
# ============ Добавляем UNIQUE (sentence_number) ============
await conn.execute("""
DO $$
BEGIN
IF NOT EXISTS (
SELECT 1 FROM pg_constraint
WHERE conname = 'sentences_sentence_number_unique'
WHERE conname = 'sentences_sentence_number_key'
) THEN
ALTER TABLE sentences ADD CONSTRAINT sentences_sentence_number_unique UNIQUE (level, sentence_number);
ALTER TABLE sentences ADD CONSTRAINT sentences_sentence_number_key UNIQUE (sentence_number);
END IF;
END $$;
""")
@@ -248,6 +311,60 @@ async def init_db():
""")
logger.info("Added level column to sentence_progress")
# 🔧 НОВОЕ (16.10.2026): list_opened — счётчик «показать предложение»
# для текущего предложения. Medium — лимит 2, Easy — ∞, Hard — 0.
col_exists = await conn.fetchval("""
SELECT 1 FROM information_schema.columns
WHERE table_name = 'sentence_progress' AND column_name = 'list_opened'
""")
if not col_exists:
await conn.execute("""
ALTER TABLE sentence_progress
ADD COLUMN list_opened INTEGER DEFAULT 0
""")
logger.info("Added list_opened column to sentence_progress")
# 🔧 НОВОЕ (16.10.2026): no_mistakes_streak — серия предложений без ошибок.
# +1 если предложение собрано без ошибок, иначе сброс в 0.
# Нужен для достижения sentence_no_mistakes.
col_exists = await conn.fetchval("""
SELECT 1 FROM information_schema.columns
WHERE table_name = 'sentence_progress' AND column_name = 'no_mistakes_streak'
""")
if not col_exists:
await conn.execute("""
ALTER TABLE sentence_progress
ADD COLUMN no_mistakes_streak INTEGER DEFAULT 0
""")
logger.info("Added no_mistakes_streak column to sentence_progress")
# 🔧 НОВОЕ (16.10.2026): perfect_streak — серия идеальных предложений
# (без ошибок + без показов). +1 если всё чисто, иначе сброс в 0.
# Нужен для достижения sentence_perfect_streak.
col_exists = await conn.fetchval("""
SELECT 1 FROM information_schema.columns
WHERE table_name = 'sentence_progress' AND column_name = 'perfect_streak'
""")
if not col_exists:
await conn.execute("""
ALTER TABLE sentence_progress
ADD COLUMN perfect_streak INTEGER DEFAULT 0
""")
logger.info("Added perfect_streak column to sentence_progress")
# 🔧 НОВОЕ (16.10.2026): completion_time — время прохождения последнего
# предложения (сек). Для статистики и бонуса Hard (≤15 сек).
col_exists = await conn.fetchval("""
SELECT 1 FROM information_schema.columns
WHERE table_name = 'sentence_progress' AND column_name = 'completion_time'
""")
if not col_exists:
await conn.execute("""
ALTER TABLE sentence_progress
ADD COLUMN completion_time INTEGER DEFAULT 0
""")
logger.info("Added completion_time column to sentence_progress")
# ============ typing_progress ============
await conn.execute("""
CREATE TABLE IF NOT EXISTS typing_progress (
@@ -305,12 +422,17 @@ async def init_db():
""")
# ============ learning_topics ============
# 🔧 ОБНОВЛЕНО (04.10.2026): track — разделение аудиторий.
# 'pl' — для поляков (учёба на польском)
# 'ru_uk' — для славян (RU/UK ↔ PL, ОБЩИЙ track)
# 'en' — для англоязычных
await conn.execute("""
CREATE TABLE IF NOT EXISTS learning_topics (
id SERIAL PRIMARY KEY,
topic_id VARCHAR(100) UNIQUE NOT NULL,
level_code VARCHAR(10) NOT NULL,
order_number INT NOT NULL,
track VARCHAR(10) NOT NULL DEFAULT 'ru_uk', -- 🔧 НОВОЕ
name_pl TEXT NOT NULL,
name_ru TEXT NOT NULL,
name_uk TEXT NOT NULL,
@@ -324,6 +446,27 @@ async def init_db():
)
""")
# 🔧 НОВОЕ (04.10.2026): track_auto_migration —
# для существующих БД добавляем колонку, если её нет.
col_exists = await conn.fetchval("""
SELECT 1 FROM information_schema.columns
WHERE table_name = 'learning_topics' AND column_name = 'track'
""")
if not col_exists:
await conn.execute("""
ALTER TABLE learning_topics
ADD COLUMN track VARCHAR(10) NOT NULL DEFAULT 'ru_uk'
""")
logger.info("Added track column to learning_topics")
# Backfill: все существующие темы → 'ru_uk' (славянский track)
await conn.execute("""
UPDATE learning_topics
SET track = 'ru_uk'
WHERE track IS NULL OR track = ''
""")
logger.info("Backfilled track='ru_uk' for existing topics")
# ============ learning_lessons ============
await conn.execute("""
CREATE TABLE IF NOT EXISTS learning_lessons (
@@ -430,6 +573,8 @@ async def init_db():
""")
# ============ user_learning_answers ============
# 🔧 ОБНОВЛЕНО (02.10.2026): добавлены revised и revision_of_id
# прямо в определение — на свежих БД создаются сразу.
await conn.execute("""
CREATE TABLE IF NOT EXISTS user_learning_answers (
id BIGSERIAL PRIMARY KEY,
@@ -450,10 +595,46 @@ async def init_db():
hint_used BOOLEAN DEFAULT FALSE,
wrong_because VARCHAR(100),
is_final_answer BOOLEAN DEFAULT TRUE,
revised BOOLEAN DEFAULT FALSE, -- 🔧 НОВОЕ
revision_of_id BIGINT, -- 🔧 НОВОЕ
created_at TIMESTAMP DEFAULT NOW()
)
""")
# 🔧 НОВОЕ (02.10.2026): revised — фиксируем, что ученик
# поменял ответ после «Повторить урок».
col_exists = await conn.fetchval("""
SELECT 1 FROM information_schema.columns
WHERE table_name = 'user_learning_answers' AND column_name = 'revised'
""")
if not col_exists:
await conn.execute("""
ALTER TABLE user_learning_answers
ADD COLUMN revised BOOLEAN DEFAULT FALSE
""")
logger.info("Added revised column to user_learning_answers")
# 🔧 НОВОЕ (02.10.2026): revision_of_id — ссылка на предыдущий
# ответ этого же вопроса в этой же сессии. Позволяет строить
# цепочку: первый ответ → второй (после повтора) → третий.
col_exists = await conn.fetchval("""
SELECT 1 FROM information_schema.columns
WHERE table_name = 'user_learning_answers' AND column_name = 'revision_of_id'
""")
if not col_exists:
await conn.execute("""
ALTER TABLE user_learning_answers
ADD COLUMN revision_of_id BIGINT
""")
logger.info("Added revision_of_id column to user_learning_answers")
# Индекс для быстрого поиска цепочек повторов
await conn.execute("""
CREATE INDEX IF NOT EXISTS idx_learning_answers_revision
ON user_learning_answers(revision_of_id)
WHERE revision_of_id IS NOT NULL
""")
# ============ user_lesson_progress ============
await conn.execute("""
CREATE TABLE IF NOT EXISTS user_lesson_progress (
@@ -643,6 +824,32 @@ async def init_db():
)
""")
# 🔧 ФИКС (25.09.2026): ensure_achievements_code_key —
# фикс init_achievements_n_plus_1 использует ON CONFLICT (code).
# UNIQUE-инфраструктура для колонки code должна существовать.
# В CREATE TABLE выше уже есть UNIQUE NOT NULL — но если таблица
# была создана старой версией кода без UNIQUE, добавляем констрейнт.
await conn.execute("""
DO $$
BEGIN
IF NOT EXISTS (
SELECT 1 FROM pg_constraint
WHERE conname = 'achievements_code_key'
) AND NOT EXISTS (
SELECT 1 FROM pg_constraint
WHERE conrelid = 'achievements'::regclass
AND contype IN ('u', 'p')
AND conkey = ARRAY[
(SELECT attnum FROM pg_attribute
WHERE attrelid = 'achievements'::regclass
AND attname = 'code')
]
) THEN
ALTER TABLE achievements ADD CONSTRAINT achievements_code_key UNIQUE (code);
END IF;
END $$;
""")
# ============ user_achievements ============
await conn.execute("""
CREATE TABLE IF NOT EXISTS user_achievements (
@@ -721,6 +928,20 @@ async def init_db():
""")
logger.info("Added current_mistakes column to word_quiz_progress")
# 🔧 НОВОЕ (15.10.2026): no_mistakes_streak — серия раундов без ошибок
# в «Выбери слово». +1 если раунд пройден без ошибок, иначе сброс в 0.
# Нужен для достижения quiz_no_mistakes_streak.
col_exists = await conn.fetchval("""
SELECT 1 FROM information_schema.columns
WHERE table_name = 'word_quiz_progress' AND column_name = 'no_mistakes_streak'
""")
if not col_exists:
await conn.execute("""
ALTER TABLE word_quiz_progress
ADD COLUMN no_mistakes_streak INTEGER DEFAULT 0
""")
logger.info("Added no_mistakes_streak column to word_quiz_progress")
# ============ bubble_words_progress ============
await conn.execute("""
CREATE TABLE IF NOT EXISTS bubble_words_progress (
@@ -756,6 +977,151 @@ async def init_db():
""")
logger.info("Added current_hints_used column to bubble_words_progress")
# 🔧 НОВОЕ (14.10.2026): current_list_opened — серверный счётчик
# «показать слова» для текущего уровня пузырей. Medium — 1 раз.
col_exists = await conn.fetchval("""
SELECT 1 FROM information_schema.columns
WHERE table_name = 'bubble_words_progress' AND column_name = 'current_list_opened'
""")
if not col_exists:
await conn.execute("""
ALTER TABLE bubble_words_progress
ADD COLUMN current_list_opened INT DEFAULT 0
""")
logger.info("Added current_list_opened column to bubble_words_progress")
# 🔧 НОВОЕ (14.10.2026): current_level_words — состояние текущего
# уровня пузырей (слова + части + переводы). Нужно для подсказок,
# т.к. уровень генерируется на лету в /next и нигде не хранится.
col_exists = await conn.fetchval("""
SELECT 1 FROM information_schema.columns
WHERE table_name = 'bubble_words_progress' AND column_name = 'current_level_words'
""")
if not col_exists:
await conn.execute("""
ALTER TABLE bubble_words_progress
ADD COLUMN current_level_words JSONB DEFAULT '[]'::jsonb
""")
logger.info("Added current_level_words column to bubble_words_progress")
# 🔧 НОВОЕ (14.10.2026): hinted_words — какие слова уже получили
# подсказку «первая часть» (для «каждый раз разное слово»).
col_exists = await conn.fetchval("""
SELECT 1 FROM information_schema.columns
WHERE table_name = 'bubble_words_progress' AND column_name = 'hinted_words'
""")
if not col_exists:
await conn.execute("""
ALTER TABLE bubble_words_progress
ADD COLUMN hinted_words TEXT[] DEFAULT '{}'
""")
logger.info("Added hinted_words column to bubble_words_progress")
# 🔧 НОВОЕ (15.10.2026): words_collected — суммарно собранных слов
# в пузырях. Нужен для достижения bubble_words (собрать N слов).
col_exists = await conn.fetchval("""
SELECT 1 FROM information_schema.columns
WHERE table_name = 'bubble_words_progress' AND column_name = 'words_collected'
""")
if not col_exists:
await conn.execute("""
ALTER TABLE bubble_words_progress
ADD COLUMN words_collected INTEGER DEFAULT 0
""")
logger.info("Added words_collected column to bubble_words_progress")
# 🔧 НОВОЕ (15.10.2026): no_hints_streak — серия уровней БЕЗ подсказок
# и без «показать слова». +1 если hints_used == 0 и not list_opened,
# иначе сброс в 0. Нужен для достижения bubble_streak.
col_exists = await conn.fetchval("""
SELECT 1 FROM information_schema.columns
WHERE table_name = 'bubble_words_progress' AND column_name = 'no_hints_streak'
""")
if not col_exists:
await conn.execute("""
ALTER TABLE bubble_words_progress
ADD COLUMN no_hints_streak INTEGER DEFAULT 0
""")
logger.info("Added no_hints_streak column to bubble_words_progress")
# 🔧 НОВОЕ (15.10.2026): perfect_streak — серия идеальных уровней
# (без подсказок + без списка + без ошибок). +1 если всё чисто,
# иначе сброс в 0. Нужен для достижения bubble_perfect_streak.
col_exists = await conn.fetchval("""
SELECT 1 FROM information_schema.columns
WHERE table_name = 'bubble_words_progress' AND column_name = 'perfect_streak'
""")
if not col_exists:
await conn.execute("""
ALTER TABLE bubble_words_progress
ADD COLUMN perfect_streak INTEGER DEFAULT 0
""")
logger.info("Added perfect_streak column to bubble_words_progress")
# ============ sentence_stats ============
# 🔧 НОВОЕ (16.10.2026): глобальная статистика игры «Составь предложение».
# PK = user_id (одна строка на юзера), по образцу word_quiz_progress.
# total_score — суммарные очки; no_mistakes_streak / perfect_streak —
# серии для достижений sentence_no_mistakes / sentence_perfect_streak.
await conn.execute("""
CREATE TABLE IF NOT EXISTS sentence_stats (
user_id BIGINT PRIMARY KEY
REFERENCES users(telegram_id) ON DELETE CASCADE,
total_score INTEGER DEFAULT 0,
no_mistakes_streak INTEGER DEFAULT 0,
perfect_streak INTEGER DEFAULT 0,
updated_at TIMESTAMP DEFAULT NOW()
)
""")
# ============ Авто-миграция: total_score ============
col_exists = await conn.fetchval("""
SELECT 1 FROM information_schema.columns
WHERE table_name = 'sentence_stats' AND column_name = 'total_score'
""")
if not col_exists:
await conn.execute("""
ALTER TABLE sentence_stats
ADD COLUMN total_score INTEGER DEFAULT 0
""")
logger.info("Added total_score column to sentence_stats")
# ============ Авто-миграция: no_mistakes_streak ============
col_exists = await conn.fetchval("""
SELECT 1 FROM information_schema.columns
WHERE table_name = 'sentence_stats' AND column_name = 'no_mistakes_streak'
""")
if not col_exists:
await conn.execute("""
ALTER TABLE sentence_stats
ADD COLUMN no_mistakes_streak INTEGER DEFAULT 0
""")
logger.info("Added no_mistakes_streak column to sentence_stats")
# ============ Авто-миграция: perfect_streak ============
col_exists = await conn.fetchval("""
SELECT 1 FROM information_schema.columns
WHERE table_name = 'sentence_stats' AND column_name = 'perfect_streak'
""")
if not col_exists:
await conn.execute("""
ALTER TABLE sentence_stats
ADD COLUMN perfect_streak INTEGER DEFAULT 0
""")
logger.info("Added perfect_streak column to sentence_stats")
# ============ Авто-миграция: updated_at ============
col_exists = await conn.fetchval("""
SELECT 1 FROM information_schema.columns
WHERE table_name = 'sentence_stats' AND column_name = 'updated_at'
""")
if not col_exists:
await conn.execute("""
ALTER TABLE sentence_stats
ADD COLUMN updated_at TIMESTAMP DEFAULT NOW()
""")
logger.info("Added updated_at column to sentence_stats")
# ============ wrong_because_explanations ============
await conn.execute("""
CREATE TABLE IF NOT EXISTS wrong_because_explanations (
@@ -804,6 +1170,70 @@ async def init_db():
)
""")
# ============ lectures — лекции (архивы) ============
# 🔧 ОБНОВЛЕНО (27.09.2026): добавлены lecture_language и display_language.
# title_pl и title_ru/uk/en теперь nullable — фронт забирает заголовок
# из display_language, а не из title_pl.
await conn.execute("""
CREATE TABLE IF NOT EXISTS lectures (
id BIGSERIAL PRIMARY KEY,
level_code VARCHAR(10) NOT NULL,
lecture_language VARCHAR(10) NOT NULL DEFAULT 'ru',
display_language VARCHAR(10) NOT NULL DEFAULT 'ru',
title_pl TEXT,
title_ru TEXT,
title_uk TEXT,
title_en TEXT,
description_pl TEXT,
description_ru TEXT,
description_uk TEXT,
description_en TEXT,
file_path TEXT NOT NULL,
file_type VARCHAR(20) NOT NULL,
file_size_bytes INT,
order_number INT NOT NULL DEFAULT 0,
is_active BOOLEAN DEFAULT TRUE,
created_at TIMESTAMP DEFAULT NOW(),
edited_at TIMESTAMP
)
""")
# ============ Авто-миграция: lecture_language + display_language ============
col_exists = await conn.fetchval("""
SELECT 1 FROM information_schema.columns
WHERE table_name = 'lectures' AND column_name = 'lecture_language'
""")
if not col_exists:
await conn.execute("""
ALTER TABLE lectures
ADD COLUMN lecture_language VARCHAR(10) DEFAULT 'ru'
""")
logger.info("Added lecture_language column to lectures")
col_exists = await conn.fetchval("""
SELECT 1 FROM information_schema.columns
WHERE table_name = 'lectures' AND column_name = 'display_language'
""")
if not col_exists:
await conn.execute("""
ALTER TABLE lectures
ADD COLUMN display_language VARCHAR(10) DEFAULT 'ru'
""")
logger.info("Added display_language column to lectures")
await conn.execute("""
CREATE INDEX IF NOT EXISTS idx_lectures_level
ON lectures(level_code, order_number)
""")
# 🔧 НОВОЕ (27.09.2026): составной индекс по языкам лекции/отображения.
await conn.execute("""
CREATE INDEX IF NOT EXISTS idx_lectures_lang
ON lectures(level_code, lecture_language, order_number)
""")
logger.info("Table lectures initialized")
# ============ daily_phrases — фраза дня ============
await conn.execute("""
CREATE TABLE IF NOT EXISTS daily_phrases (
@@ -963,13 +1393,387 @@ async def init_db():
# - idx_skill_mastery_user (user_id+skill_tag уже UNIQUE)
# - idx_user_progress_user (user_id+level_id уже PK)
# - idx_sentence_progress_user (user_id+sentence_id уже PK)
await conn.execute("CREATE INDEX IF NOT EXISTS idx_levels_number ON levels(level_number)")
await conn.execute("CREATE INDEX IF NOT EXISTS idx_levels_level ON levels(level)")
#
# 🔧 ФИКС (25.09.2026): redundant_indexes_levels_sentences —
# составной индекс (level, level_number) покрывает и level,
# и level_number. Убраны дубли:
# idx_levels_number, idx_levels_level,
# idx_sentences_number, idx_sentences_level.
# DROP на случай, если они уже созданы в предыдущих деплоях.
await conn.execute("DROP INDEX IF EXISTS idx_levels_number")
await conn.execute("DROP INDEX IF EXISTS idx_levels_level")
await conn.execute("DROP INDEX IF EXISTS idx_sentences_number")
await conn.execute("DROP INDEX IF EXISTS idx_sentences_level")
await conn.execute("CREATE INDEX IF NOT EXISTS idx_levels_level_number ON levels(level, level_number)")
await conn.execute("CREATE INDEX IF NOT EXISTS idx_level_words_level_id ON level_words(level_id)")
await conn.execute("CREATE INDEX IF NOT EXISTS idx_level_words_level ON level_words(level)")
await conn.execute("CREATE INDEX IF NOT EXISTS idx_sentences_number ON sentences(sentence_number)")
await conn.execute("CREATE INDEX IF NOT EXISTS idx_sentences_level ON sentences(level)")
# ============ Авто-миграция: wordsearch builder (29.09.2026) ============
# is_active — черновик (FALSE) / опубликован (TRUE)
# created_by — telegram_id админа, создавшего вручную
# created_at — когда создан
col_exists = await conn.fetchval("""
SELECT 1 FROM information_schema.columns
WHERE table_name = 'levels' AND column_name = 'is_active'
""")
if not col_exists:
await conn.execute("""
ALTER TABLE levels ADD COLUMN is_active BOOLEAN DEFAULT TRUE
""")
logger.info("Added is_active column to levels")
col_exists = await conn.fetchval("""
SELECT 1 FROM information_schema.columns
WHERE table_name = 'levels' AND column_name = 'created_by'
""")
if not col_exists:
await conn.execute("""
ALTER TABLE levels ADD COLUMN created_by BIGINT
""")
logger.info("Added created_by column to levels")
col_exists = await conn.fetchval("""
SELECT 1 FROM information_schema.columns
WHERE table_name = 'levels' AND column_name = 'created_at'
""")
if not col_exists:
await conn.execute("""
ALTER TABLE levels ADD COLUMN created_at TIMESTAMP DEFAULT NOW()
""")
logger.info("Added created_at column to levels")
# Индекс для быстрого поиска опубликованных ручных уровней
await conn.execute("""
CREATE INDEX IF NOT EXISTS idx_levels_active_manual
ON levels(level, is_active, created_by)
WHERE is_active = TRUE AND created_by IS NOT NULL
""")
# ============ csv_words — слова из CSV для конструктора ============
await conn.execute("""
CREATE TABLE IF NOT EXISTS csv_words (
id SERIAL PRIMARY KEY,
level_code VARCHAR(10) NOT NULL,
word_pl TEXT NOT NULL,
translation_ru TEXT DEFAULT '',
translation_uk TEXT DEFAULT '',
translation_en TEXT DEFAULT '',
UNIQUE(level_code, word_pl)
)
""")
await conn.execute("""
CREATE INDEX IF NOT EXISTS idx_csv_words_level
ON csv_words(level_code)
""")
logger.info("Table csv_words initialized")
# ============ word_usage — счётчик использований слов ============
await conn.execute("""
CREATE TABLE IF NOT EXISTS word_usage (
id SERIAL PRIMARY KEY,
level_code VARCHAR(10) NOT NULL,
word_pl TEXT NOT NULL,
usage_count INT DEFAULT 0,
last_used_at TIMESTAMP DEFAULT NOW(),
UNIQUE(level_code, word_pl)
)
""")
await conn.execute("""
CREATE INDEX IF NOT EXISTS idx_word_usage_level_word
ON word_usage(level_code, word_pl)
""")
logger.info("Table word_usage initialized")
# ============ 🔧 НОВОЕ (07.10.2026): pleily_auth —
# поддержка авторизации мобильного приложения Pleily.
# - source: откуда пришёл юзер ('telegram' | 'pleily_device' | 'pleily_apple')
# - device_id: UUID устройства (анонимный вход)
# - apple_id: Apple ID (потом, для привязки прогресса)
# - app_user_id_seq: sequence для отрицательных user_id (Pleily-юзеры)
# - auth_identities: связка provider+provider_uid → user_id
# ============================================================
# source
col_exists = await conn.fetchval("""
SELECT 1 FROM information_schema.columns
WHERE table_name = 'users' AND column_name = 'source'
""")
if not col_exists:
await conn.execute("""
ALTER TABLE users ADD COLUMN source TEXT DEFAULT 'telegram'
""")
await conn.execute("""
UPDATE users SET source = 'telegram' WHERE source IS NULL
""")
logger.info("Added source column to users (Pleily)")
# device_id
col_exists = await conn.fetchval("""
SELECT 1 FROM information_schema.columns
WHERE table_name = 'users' AND column_name = 'device_id'
""")
if not col_exists:
await conn.execute("""
ALTER TABLE users ADD COLUMN device_id UUID
""")
await conn.execute("""
CREATE UNIQUE INDEX IF NOT EXISTS idx_users_device_id
ON users(device_id) WHERE device_id IS NOT NULL
""")
logger.info("Added device_id column to users (Pleily)")
# apple_id
col_exists = await conn.fetchval("""
SELECT 1 FROM information_schema.columns
WHERE table_name = 'users' AND column_name = 'apple_id'
""")
if not col_exists:
await conn.execute("""
ALTER TABLE users ADD COLUMN apple_id TEXT
""")
await conn.execute("""
CREATE UNIQUE INDEX IF NOT EXISTS idx_users_apple_id
ON users(apple_id) WHERE apple_id IS NOT NULL
""")
logger.info("Added apple_id column to users (Pleily)")
# difficulty
col_exists = await conn.fetchval("""
SELECT 1 FROM information_schema.columns
WHERE table_name = 'users' AND column_name = 'difficulty'
""")
if not col_exists:
await conn.execute("""
ALTER TABLE users ADD COLUMN difficulty TEXT DEFAULT 'medium'
""")
logger.info("Added difficulty column to users (Pleily)")
# app_user_id_seq — sequence для отрицательных user_id
await conn.execute("""
CREATE SEQUENCE IF NOT EXISTS app_user_id_seq
START -1
INCREMENT -1
MINVALUE -9223372036854775808
MAXVALUE -1
""")
logger.info("Table app_user_id_seq initialized (Pleily)")
# auth_identities — связка provider+provider_uid → user_id
await conn.execute("""
CREATE TABLE IF NOT EXISTS auth_identities (
id BIGSERIAL PRIMARY KEY,
user_id BIGINT NOT NULL REFERENCES users(telegram_id) ON DELETE CASCADE,
provider TEXT NOT NULL,
provider_uid TEXT NOT NULL,
created_at TIMESTAMP DEFAULT NOW(),
UNIQUE(provider, provider_uid)
)
""")
await conn.execute("""
CREATE INDEX IF NOT EXISTS idx_auth_identities_user
ON auth_identities(user_id)
""")
# Backfill: для существующих telegram-юзеров создаём identity
await conn.execute("""
INSERT INTO auth_identities (user_id, provider, provider_uid)
SELECT telegram_id, 'telegram', telegram_id::text
FROM users
WHERE telegram_id > 0
ON CONFLICT DO NOTHING
""")
logger.info("Table auth_identities initialized (Pleily)")
# ============================================================
# 🔧 НОВОЕ (08.10.2026): XP-фундамент Pleily.
# user_profile, xp_log, choose_progress, user_seen_levels,
# user_game_progress, wave_results, bubble_levels,
# user_seen_bubble_levels, user_word_stats.
# + расширение sentences (tokens, alt_orders, word_count).
# ============================================================
# ---------- user_profile ----------
await conn.execute("""
CREATE TABLE IF NOT EXISTS user_profile (
user_id BIGINT PRIMARY KEY
REFERENCES users(telegram_id) ON DELETE CASCADE,
nickname TEXT,
avatar_id INTEGER DEFAULT 0,
total_xp INTEGER DEFAULT 0,
weekly_xp INTEGER DEFAULT 0,
week_started_at DATE DEFAULT CURRENT_DATE,
updated_at TIMESTAMP DEFAULT NOW()
)
""")
await conn.execute("""
CREATE INDEX IF NOT EXISTS idx_user_profile_weekly
ON user_profile(weekly_xp DESC)
""")
logger.info("Table user_profile initialized (XP)")
# ---------- xp_log ----------
await conn.execute("""
CREATE TABLE IF NOT EXISTS xp_log (
id BIGSERIAL PRIMARY KEY,
user_id BIGINT NOT NULL
REFERENCES users(telegram_id) ON DELETE CASCADE,
game TEXT NOT NULL,
stars INTEGER NOT NULL,
base_points INTEGER NOT NULL,
multiplier NUMERIC(3,2) NOT NULL DEFAULT 1.0,
points INTEGER NOT NULL,
created_at TIMESTAMP DEFAULT NOW()
)
""")
await conn.execute("""
CREATE INDEX IF NOT EXISTS idx_xp_log_user_date
ON xp_log(user_id, created_at DESC)
""")
logger.info("Table xp_log initialized (XP)")
# ---------- choose_progress (серии в "Выбери слово") ----------
await conn.execute("""
CREATE TABLE IF NOT EXISTS choose_progress (
user_id BIGINT PRIMARY KEY
REFERENCES users(telegram_id) ON DELETE CASCADE,
current_streak INTEGER DEFAULT 0,
best_streak INTEGER DEFAULT 0,
updated_at TIMESTAMP DEFAULT NOW()
)
""")
logger.info("Table choose_progress initialized")
# ---------- user_seen_levels (филворд: какие уровни видел) ----------
await conn.execute("""
CREATE TABLE IF NOT EXISTS user_seen_levels (
user_id BIGINT NOT NULL
REFERENCES users(telegram_id) ON DELETE CASCADE,
level_id INTEGER NOT NULL
REFERENCES levels(id) ON DELETE CASCADE,
seen_at TIMESTAMP DEFAULT NOW(),
PRIMARY KEY (user_id, level_id)
)
""")
await conn.execute("""
CREATE INDEX IF NOT EXISTS idx_user_seen_levels_user
ON user_seen_levels(user_id, seen_at DESC)
""")
logger.info("Table user_seen_levels initialized")
# ---------- user_game_progress (сессии филворда) ----------
await conn.execute("""
CREATE TABLE IF NOT EXISTS user_game_progress (
user_id BIGINT PRIMARY KEY
REFERENCES users(telegram_id) ON DELETE CASCADE,
session_number INTEGER DEFAULT 1,
session_level_number INTEGER DEFAULT 1,
global_level_number INTEGER DEFAULT 1,
time_limit_seconds INTEGER,
updated_at TIMESTAMP DEFAULT NOW()
)
""")
logger.info("Table user_game_progress initialized")
# ---------- wave_results (итоги волны) ----------
await conn.execute("""
CREATE TABLE IF NOT EXISTS wave_results (
id BIGSERIAL PRIMARY KEY,
user_id BIGINT NOT NULL
REFERENCES users(telegram_id) ON DELETE CASCADE,
wave_number INTEGER NOT NULL,
stars_earned INTEGER DEFAULT 0,
medal TEXT DEFAULT 'none',
completed_at TIMESTAMP DEFAULT NOW(),
UNIQUE (user_id, wave_number)
)
""")
await conn.execute("""
CREATE INDEX IF NOT EXISTS idx_wave_results_user
ON wave_results(user_id, wave_number DESC)
""")
logger.info("Table wave_results initialized")
# ---------- bubble_levels ----------
await conn.execute("""
CREATE TABLE IF NOT EXISTS bubble_levels (
id BIGSERIAL PRIMARY KEY,
word_ids INTEGER[] NOT NULL,
difficulty INTEGER DEFAULT 1,
created_at TIMESTAMP DEFAULT NOW()
)
""")
logger.info("Table bubble_levels initialized")
# ---------- user_seen_bubble_levels ----------
await conn.execute("""
CREATE TABLE IF NOT EXISTS user_seen_bubble_levels (
user_id BIGINT NOT NULL
REFERENCES users(telegram_id) ON DELETE CASCADE,
bubble_level_id BIGINT NOT NULL
REFERENCES bubble_levels(id) ON DELETE CASCADE,
seen_at TIMESTAMP DEFAULT NOW(),
PRIMARY KEY (user_id, bubble_level_id)
)
""")
logger.info("Table user_seen_bubble_levels initialized")
# ---------- user_word_stats (повторение слов) ----------
await conn.execute("""
CREATE TABLE IF NOT EXISTS user_word_stats (
user_id BIGINT NOT NULL
REFERENCES users(telegram_id) ON DELETE CASCADE,
word_pl TEXT NOT NULL,
correct INTEGER DEFAULT 0,
wrong INTEGER DEFAULT 0,
last_seen_at TIMESTAMP DEFAULT NOW(),
PRIMARY KEY (user_id, word_pl)
)
""")
await conn.execute("""
CREATE INDEX IF NOT EXISTS idx_user_word_stats_user
ON user_word_stats(user_id, last_seen_at DESC)
""")
logger.info("Table user_word_stats initialized")
# ---------- sentences: tokens, alt_orders, word_count ----------
for col_name, col_type in (
("tokens", "JSONB DEFAULT '[]'::jsonb"),
("alt_orders", "JSONB DEFAULT '[]'::jsonb"),
("word_count", "INTEGER DEFAULT 0"),
):
col_exists = await conn.fetchval("""
SELECT 1 FROM information_schema.columns
WHERE table_name = 'sentences' AND column_name = $1
""", col_name)
if not col_exists:
await conn.execute(
f"ALTER TABLE sentences ADD COLUMN {col_name} {col_type}"
)
logger.info(f"Added {col_name} column to sentences")
# Backfill: word_count для существующих предложений
await conn.execute("""
UPDATE sentences
SET word_count = array_length(
regexp_split_to_array(trim(sentence_pl), '\\s+'), 1
)
WHERE word_count = 0 OR word_count IS NULL
""")
logger.info("Backfilled sentences.word_count")
# ---------- Backfill: user_profile для существующих юзеров ----------
await conn.execute("""
INSERT INTO user_profile (user_id, total_xp, weekly_xp)
SELECT u.telegram_id, 0, 0
FROM users u
WHERE NOT EXISTS (
SELECT 1 FROM user_profile p WHERE p.user_id = u.telegram_id
)
ON CONFLICT (user_id) DO NOTHING
""")
logger.info("Backfilled user_profile for existing users")
await conn.execute("CREATE INDEX IF NOT EXISTS idx_sentences_level_number ON sentences(level, sentence_number)")
# Оставляем score-индексы (не дубли)
await conn.execute("CREATE INDEX IF NOT EXISTS idx_user_progress_score ON user_progress(score DESC)")
+558
View File
@@ -0,0 +1,558 @@
# 🗄 Схема базы данных
## achievements
| Колонка | Тип | NULL | Default |
|---------|-----|------|---------|
| id | integer | NO | nextval('achievements_id_seq'::regclass) |
| code | text | NO | |
| category | text | YES | 'general'::text |
| name_pl | text | NO | |
| name_ru | text | NO | |
| name_uk | text | NO | |
| name_en | text | NO | |
| description_pl | text | YES | ''::text |
| description_ru | text | YES | ''::text |
| description_uk | text | YES | ''::text |
| description_en | text | YES | ''::text |
| icon | text | YES | '🏆'::text |
| requirement_type | text | NO | |
| requirement_value | integer | YES | 0 |
## ai_user_context
| Колонка | Тип | NULL | Default |
|---------|-----|------|---------|
| user_id | bigint | NO | |
| current_level | character varying | YES | |
| completed_topics | integer | YES | 0 |
| completed_lessons | integer | YES | 0 |
| overall_mastery | numeric | YES | |
| strong_skills | jsonb | YES | '[]'::jsonb |
| weak_skills | jsonb | YES | '[]'::jsonb |
| uncertain_skills | jsonb | YES | '[]'::jsonb |
| recurring_errors | jsonb | YES | '[]'::jsonb |
| recommended_topics | jsonb | YES | '[]'::jsonb |
| recommended_lessons | jsonb | YES | '[]'::jsonb |
| last_analysis_at | timestamp without time zone | YES | |
| analytics_enabled | boolean | YES | false |
| level_topics_total | integer | YES | 0 |
| level_completion_percent | numeric | YES | 0 |
## bubble_words_progress
| Колонка | Тип | NULL | Default |
|---------|-----|------|---------|
| user_id | bigint | NO | |
| levels_completed | integer | YES | 0 |
| total_score | integer | YES | 0 |
| recent_words | ARRAY | YES | '{}'::text[] |
| level | text | YES | 'A1'::text |
| current_hints_used | integer | YES | 0 |
## chat_history
| Колонка | Тип | NULL | Default |
|---------|-----|------|---------|
| id | integer | NO | nextval('chat_history_id_seq'::regclass) |
| user_id | bigint | YES | |
| message | text | NO | |
| is_user | boolean | YES | true |
| created_at | timestamp without time zone | YES | now() |
## chat_usage
| Колонка | Тип | NULL | Default |
|---------|-----|------|---------|
| id | integer | NO | nextval('chat_usage_id_seq'::regclass) |
| user_id | bigint | YES | |
| usage_date | date | YES | CURRENT_DATE |
| message_count | integer | YES | 0 |
## daily_logins
| Колонка | Тип | NULL | Default |
|---------|-----|------|---------|
| user_id | bigint | NO | |
| login_date | date | NO | CURRENT_DATE |
## daily_phrases
| Колонка | Тип | NULL | Default |
|---------|-----|------|---------|
| id | integer | NO | nextval('daily_phrases_id_seq'::regclass) |
| phrase_date | date | NO | |
| phrase_pl | text | NO | |
| translations | jsonb | NO | '{}'::jsonb |
| grammar_breakdowns | jsonb | NO | '{}'::jsonb |
| created_at | timestamp without time zone | YES | now() |
## feed_attachments
| Колонка | Тип | NULL | Default |
|---------|-----|------|---------|
| id | bigint | NO | nextval('feed_attachments_id_seq'::regclass) |
| post_id | bigint | NO | |
| file_path | text | NO | |
| file_type | text | YES | 'image'::text |
| order_number | integer | NO | 0 |
| created_at | timestamp without time zone | YES | now() |
## feed_posts
| Колонка | Тип | NULL | Default |
|---------|-----|------|---------|
| id | bigint | NO | nextval('feed_posts_id_seq'::regclass) |
| section | text | NO | |
| source_language | text | NO | 'ru'::text |
| title_pl | text | YES | |
| title_ru | text | YES | |
| title_uk | text | YES | |
| title_en | text | YES | |
| body_pl | text | YES | |
| body_ru | text | YES | |
| body_uk | text | YES | |
| body_en | text | YES | |
| link_url | text | YES | |
| telegram_url | text | YES | |
| author_id | bigint | NO | |
| is_pinned | boolean | YES | false |
| is_published | boolean | YES | true |
| created_at | timestamp without time zone | YES | now() |
| updated_at | timestamp without time zone | YES | now() |
| edited_at | timestamp without time zone | YES | |
| expires_at | timestamp without time zone | YES | |
## learning_lessons
| Колонка | Тип | NULL | Default |
|---------|-----|------|---------|
| id | integer | NO | nextval('learning_lessons_id_seq'::regclass) |
| lesson_id | character varying | NO | |
| topic_id | character varying | NO | |
| order_number | integer | NO | |
| skill_tag | character varying | NO | |
| title_pl | text | NO | |
| title_ru | text | NO | |
| title_uk | text | NO | |
| title_en | text | NO | |
| objective_pl | text | YES | |
| objective_ru | text | YES | |
| objective_uk | text | YES | |
| objective_en | text | YES | |
| explanation_pl | text | YES | |
| explanation_ru | text | YES | |
| explanation_uk | text | YES | |
| explanation_en | text | YES | |
| is_active | boolean | YES | true |
| edited_at | timestamp without time zone | YES | |
## learning_levels
| Колонка | Тип | NULL | Default |
|---------|-----|------|---------|
| id | integer | NO | nextval('learning_levels_id_seq'::regclass) |
| code | character varying | NO | |
| name_pl | text | NO | |
| name_ru | text | NO | |
| name_uk | text | NO | |
| name_en | text | NO | |
| sort_order | integer | NO | |
| is_active | boolean | YES | true |
## learning_questions
| Колонка | Тип | NULL | Default |
|---------|-----|------|---------|
| id | integer | NO | nextval('learning_questions_id_seq'::regclass) |
| question_id | character varying | NO | |
| lesson_id | character varying | YES | |
| topic_id | character varying | NO | |
| context_type | character varying | NO | |
| question_type | character varying | NO | |
| skill_tag | character varying | NO | |
| difficulty | integer | NO | |
| prompt_pl | text | YES | |
| prompt_ru | text | YES | |
| prompt_uk | text | YES | |
| prompt_en | text | YES | |
| correct_answer | text | YES | |
| hint_type | character varying | YES | |
| hint_value | text | YES | |
| is_test_question | boolean | YES | false |
| test_order | integer | YES | |
| options_language | text | YES | 'pl'::text |
| edited_at | timestamp without time zone | YES | |
## learning_sessions
| Колонка | Тип | NULL | Default |
|---------|-----|------|---------|
| id | bigint | NO | nextval('learning_sessions_id_seq'::regclass) |
| user_id | bigint | NO | |
| level_code | character varying | NO | |
| topic_id | character varying | NO | |
| session_type | character varying | NO | |
| started_at | timestamp without time zone | NO | now() |
| completed_at | timestamp without time zone | YES | |
| is_completed | boolean | YES | false |
## learning_topics
| Колонка | Тип | NULL | Default |
|---------|-----|------|---------|
| id | integer | NO | nextval('learning_topics_id_seq'::regclass) |
| topic_id | character varying | NO | |
| level_code | character varying | NO | |
| order_number | integer | NO | |
| name_pl | text | NO | |
| name_ru | text | NO | |
| name_uk | text | NO | |
| name_en | text | NO | |
| description_pl | text | YES | |
| description_ru | text | YES | |
| description_uk | text | YES | |
| description_en | text | YES | |
| is_active | boolean | YES | true |
| edited_at | timestamp without time zone | YES | |
## lesson_examples
| Колонка | Тип | NULL | Default |
|---------|-----|------|---------|
| id | integer | NO | nextval('lesson_examples_id_seq'::regclass) |
| lesson_id | character varying | NO | |
| order_number | integer | NO | |
| text_pl | text | NO | |
| text_ru | text | YES | |
| text_uk | text | YES | |
| text_en | text | YES | |
| audio_url | text | YES | |
| edited_at | timestamp without time zone | YES | |
## lesson_progress
| Колонка | Тип | NULL | Default |
|---------|-----|------|---------|
| id | integer | NO | nextval('lesson_progress_id_seq'::regclass) |
| user_id | bigint | YES | |
| level | text | YES | 'A1'::text |
| topic | text | YES | ''::text |
| correct_count | integer | YES | 0 |
| total_questions | integer | YES | 0 |
| created_at | timestamp without time zone | YES | now() |
## level_words
| Колонка | Тип | NULL | Default |
|---------|-----|------|---------|
| id | integer | NO | nextval('level_words_id_seq'::regclass) |
| level_id | integer | YES | |
| word_pl | text | NO | |
| translation_ru | text | YES | ''::text |
| translation_uk | text | YES | ''::text |
| translation_en | text | YES | ''::text |
| level | text | YES | 'A1'::text |
| edited_at | timestamp without time zone | YES | |
## levels
| Колонка | Тип | NULL | Default |
|---------|-----|------|---------|
| id | integer | NO | nextval('levels_id_seq'::regclass) |
| level_number | integer | NO | |
| grid_size | integer | NO | |
| game_type | text | YES | 'wordsearch'::text |
| theme | text | YES | ''::text |
| grid_letters | jsonb | NO | '[]'::jsonb |
| word_paths | jsonb | NO | '{}'::jsonb |
| level | text | YES | 'A1'::text |
## question_options
| Колонка | Тип | NULL | Default |
|---------|-----|------|---------|
| id | integer | NO | nextval('question_options_id_seq'::regclass) |
| question_id | character varying | NO | |
| option_key | character varying | NO | |
| text_pl | text | YES | |
| text_ru | text | YES | |
| text_uk | text | YES | |
| text_en | text | YES | |
| is_correct | boolean | NO | |
| wrong_because | character varying | YES | |
| edited_at | timestamp without time zone | YES | |
## sentence_hints_used
| Колонка | Тип | NULL | Default |
|---------|-----|------|---------|
| user_id | bigint | NO | |
| sentence_id | integer | NO | |
| used_at | timestamp without time zone | YES | now() |
## sentence_progress
| Колонка | Тип | NULL | Default |
|---------|-----|------|---------|
| user_id | bigint | NO | |
| sentence_id | integer | NO | |
| completed_at | timestamp without time zone | YES | |
| score | integer | YES | 0 |
| level | text | YES | 'A1'::text |
## sentences
| Колонка | Тип | NULL | Default |
|---------|-----|------|---------|
| id | integer | NO | nextval('sentences_id_seq'::regclass) |
| sentence_number | integer | NO | |
| theme | text | YES | ''::text |
| sentence_pl | text | NO | |
| translation_ru | text | YES | ''::text |
| translation_uk | text | YES | ''::text |
| translation_en | text | YES | ''::text |
| difficulty | integer | YES | 1 |
| level | text | YES | 'A1'::text |
| edited_at | timestamp without time zone | YES | |
## support_messages
| Колонка | Тип | NULL | Default |
|---------|-----|------|---------|
| id | bigint | NO | nextval('support_messages_id_seq'::regclass) |
| ticket_id | bigint | NO | |
| sender_id | bigint | NO | |
| message | text | NO | |
| is_read | boolean | YES | false |
| created_at | timestamp without time zone | YES | now() |
## support_tickets
| Колонка | Тип | NULL | Default |
|---------|-----|------|---------|
| id | bigint | NO | nextval('support_tickets_id_seq'::regclass) |
| user_id | bigint | NO | |
| status | text | YES | 'open'::text |
| created_at | timestamp without time zone | YES | now() |
| updated_at | timestamp without time zone | YES | now() |
## teacher_ai_usage
| Колонка | Тип | NULL | Default |
|---------|-----|------|---------|
| id | bigint | NO | nextval('teacher_ai_usage_id_seq'::regclass) |
| user_id | bigint | NO | |
| usage_date | date | YES | CURRENT_DATE |
| command_count | integer | YES | 0 |
## teacher_chat_history
| Колонка | Тип | NULL | Default |
|---------|-----|------|---------|
| id | bigint | NO | nextval('teacher_chat_history_id_seq'::regclass) |
| user_id | bigint | NO | |
| messages | jsonb | NO | '[]'::jsonb |
| updated_at | timestamp without time zone | YES | now() |
## teacher_reactions
| Колонка | Тип | NULL | Default |
|---------|-----|------|---------|
| id | integer | NO | nextval('teacher_reactions_id_seq'::regclass) |
| reaction_type | character varying | NO | |
| text_pl | text | NO | |
| text_ru | text | NO | |
| text_uk | text | NO | |
| text_en | text | NO | |
## typing_hints_used
| Колонка | Тип | NULL | Default |
|---------|-----|------|---------|
| user_id | bigint | NO | |
| sentence_id | integer | NO | |
| used_at | timestamp without time zone | YES | now() |
## typing_progress
| Колонка | Тип | NULL | Default |
|---------|-----|------|---------|
| user_id | bigint | NO | |
| sentence_id | integer | NO | |
| completed_at | timestamp without time zone | YES | now() |
## user_achievements
| Колонка | Тип | NULL | Default |
|---------|-----|------|---------|
| user_id | bigint | NO | |
| achievement_id | integer | NO | |
| unlocked_at | timestamp without time zone | YES | now() |
## user_learning_answers
| Колонка | Тип | NULL | Default |
|---------|-----|------|---------|
| id | bigint | NO | nextval('user_learning_answers_id_seq'::regclass) |
| user_id | bigint | NO | |
| session_id | bigint | NO | |
| level_code | character varying | NO | |
| topic_id | character varying | NO | |
| lesson_id | character varying | YES | |
| question_id | character varying | NO | |
| selected_answer | text | YES | |
| correct | boolean | YES | |
| skill_tag | character varying | NO | |
| question_type | character varying | NO | |
| context_type | character varying | NO | |
| difficulty | integer | NO | |
| time_taken_ms | integer | YES | |
| attempt_number | integer | YES | 1 |
| hint_used | boolean | YES | false |
| wrong_because | character varying | YES | |
| is_final_answer | boolean | YES | true |
| created_at | timestamp without time zone | YES | now() |
## user_learning_answers_archive
| Колонка | Тип | NULL | Default |
|---------|-----|------|---------|
| id | bigint | NO | nextval('user_learning_answers_archive_id_seq'::re |
| user_id | bigint | NO | |
| skill_tag | character varying | NO | |
| correct | boolean | YES | |
| wrong_because | character varying | YES | |
| created_at | date | YES | |
| archived_at | timestamp without time zone | YES | now() |
## user_lesson_progress
| Колонка | Тип | NULL | Default |
|---------|-----|------|---------|
| id | bigint | NO | nextval('user_lesson_progress_id_seq'::regclass) |
| user_id | bigint | NO | |
| lesson_id | character varying | NO | |
| started_at | timestamp without time zone | YES | |
| completed_at | timestamp without time zone | YES | |
| attempts_count | integer | YES | 0 |
| correct_count | integer | YES | 0 |
| best_score | numeric | YES | |
| average_time_ms | integer | YES | |
| completed | boolean | YES | false |
## user_progress
| Колонка | Тип | NULL | Default |
|---------|-----|------|---------|
| user_id | bigint | NO | |
| level_id | integer | NO | |
| completed_at | timestamp without time zone | YES | |
| hints_used | integer | YES | 0 |
| score | integer | YES | 0 |
| level | text | YES | 'A1'::text |
| current_streak | integer | YES | 0 |
## user_skill_mastery
| Колонка | Тип | NULL | Default |
|---------|-----|------|---------|
| id | bigint | NO | nextval('user_skill_mastery_id_seq'::regclass) |
| user_id | bigint | NO | |
| skill_tag | character varying | NO | |
| attempts_count | integer | YES | 0 |
| correct_count | integer | YES | 0 |
| recognition_score | numeric | YES | |
| production_score | numeric | YES | |
| application_score | numeric | YES | |
| retention_score | numeric | YES | |
| hint_dependency | numeric | YES | |
| average_time_ms | integer | YES | |
| recent_accuracy | numeric | YES | |
| long_term_accuracy | numeric | YES | |
| mastery_score | numeric | YES | |
| confidence | numeric | YES | |
| last_attempt_at | timestamp without time zone | YES | |
| median_time_ms | integer | YES | 0 |
| recognition_attempts | integer | YES | 0 |
| recognition_correct | integer | YES | 0 |
| production_attempts | integer | YES | 0 |
| production_correct | integer | YES | 0 |
| application_attempts | integer | YES | 0 |
| application_correct | integer | YES | 0 |
| median_correct_time_ms | integer | YES | 0 |
| median_wrong_time_ms | integer | YES | 0 |
| last_3_accuracy | numeric | YES | |
| last_5_accuracy | numeric | YES | |
| last_10_accuracy | numeric | YES | |
| error_count | integer | YES | 0 |
| repeated_error_count | integer | YES | 0 |
| days_since_last_attempt | integer | YES | 0 |
| previous_mastery_score | numeric | YES | 0 |
| mastery_delta | numeric | YES | 0 |
| trend | text | YES | 'insufficient_data'::text |
| retention_status | text | YES | 'fresh'::text |
| fluency_score | numeric | YES | 0 |
| passive_knowledge_score | numeric | YES | 0 |
| active_knowledge_score | numeric | YES | 0 |
## user_topic_progress
| Колонка | Тип | NULL | Default |
|---------|-----|------|---------|
| id | bigint | NO | nextval('user_topic_progress_id_seq'::regclass) |
| user_id | bigint | NO | |
| topic_id | character varying | NO | |
| lessons_total | integer | YES | 0 |
| lessons_completed | integer | YES | 0 |
| test_started | boolean | YES | false |
| test_completed | boolean | YES | false |
| test_score | numeric | YES | |
| topic_mastery | numeric | YES | |
| confidence | numeric | YES | |
| completed_at | timestamp without time zone | YES | |
## users
| Колонка | Тип | NULL | Default |
|---------|-----|------|---------|
| telegram_id | bigint | NO | |
| username | text | YES | |
| app_language | text | YES | 'pl'::text |
| created_at | timestamp without time zone | YES | now() |
| last_completed_level | integer | YES | 0 |
| id | integer | NO | nextval('users_id_seq'::regclass) |
| current_level | text | YES | 'A1'::text |
| difficulty | text | YES | 'medium'::text |
## voice_usage
| Колонка | Тип | NULL | Default |
|---------|-----|------|---------|
| id | integer | NO | nextval('voice_usage_id_seq'::regclass) |
| user_id | bigint | YES | |
| usage_date | date | YES | CURRENT_DATE |
| voice_count | integer | YES | 0 |
## word_quiz_progress
| Колонка | Тип | NULL | Default |
|---------|-----|------|---------|
| user_id | bigint | NO | |
| words_guessed | integer | YES | 0 |
| total_score | integer | YES | 0 |
| correct_streak | integer | YES | 0 |
| recent_words | ARRAY | YES | '{}'::text[] |
| level | text | YES | 'A1'::text |
| current_mistakes | integer | YES | 0 |
## wrong_because_explanations
| Колонка | Тип | NULL | Default |
|---------|-----|------|---------|
| id | integer | NO | nextval('wrong_because_explanations_id_seq'::regcl |
| wrong_because | character varying | NO | |
| explanation_pl | text | NO | |
| explanation_ru | text | NO | |
| explanation_uk | text | NO | |
| explanation_en | text | NO | |
+174
View File
@@ -0,0 +1,174 @@
# 🛣 Все эндпоинты проекта
## achievements.py
**Префикс:** `/achievements`
- `GET /achievements/user`
- `POST /achievements/track-login`
- `POST /achievements/track-teacher-menu`
- `POST /achievements/track-progress`
- `POST /achievements/track-cheatsheets`
- `POST /achievements/track-pronunciation`
- `POST /achievements/track-ai-assistant`
- `POST /achievements/track-alphabet`
- `POST /achievements/track-rules`
## admin.py
**Префикс:** `/admin`
- `GET /admin/dashboard`
- `GET /admin/sentry-errors`
## admin_content.py
**Префикс:** `/admin/content`
- `GET /admin/content/summary`
- `GET /admin/content/words/levels`
- `GET /admin/content/words/level/{level}`
- `GET /admin/content/words/word/{word_id}`
- `PUT /admin/content/words/word/{word_id}`
- `POST /admin/content/words/level/{level}`
- `GET /admin/content/texts/levels`
- `GET /admin/content/texts/level/{level}`
- `GET /admin/content/texts/text/{text_id}`
- `PUT /admin/content/texts/text/{text_id}`
- `POST /admin/content/texts/level/{level}`
- `GET /admin/content/lessons/levels`
- `GET /admin/content/lessons/level/{level}/topics`
- `GET /admin/content/lessons/topic/{topic_id}`
- `GET /admin/content/lessons/lesson/{lesson_id}`
- `PUT /admin/content/lessons/lesson/{lesson_id}`
- `GET /admin/content/wrong-because`
## assistant.py
**Префикс:** `/assistant`
- `POST /assistant/chat`
- `POST /assistant/save-analytics`
- `GET /assistant/stats/personal`
- `GET /assistant/stats/admin`
- `GET /assistant/limit`
- `GET /assistant/history`
- `POST /assistant/history/clear`
## bubblewords.py
**Префикс:** `/bubblewords`
- `GET /bubblewords/next`
- `POST /bubblewords/complete`
- `GET /bubblewords/progress`
## feed.py
**Префикс:** ``
- `GET /feed/{section}`
- `GET /feed/post/{post_id}`
- `POST /admin/feed/post`
- `PUT /admin/feed/post/{post_id}`
- `POST /admin/feed/post/{post_id}/delete`
- `POST /admin/feed/upload-image`
- `POST /admin/feed/translate`
## game.py
**Префикс:** `/game`
- `GET /game/progress`
- `GET /game/level/{level_number}`
- `POST /game/check-word`
- `POST /game/complete-level`
## hints.py
**Префикс:** `/hints`
- `GET /hints/first-letter/{level_id}`
- `GET /hints/word-list/{level_id}`
- `GET /hints/remaining/{level_id}`
## leaderboard.py
**Префикс:** `/leaderboard`
- `GET /leaderboard/admin/stats`
- `GET /leaderboard/top`
## learning.py
**Префикс:** `/learning`
- `GET /learning/levels`
- `GET /learning/topics`
- `GET /learning/topics/{topic_id}`
- `GET /learning/lessons/{lesson_id}`
- `GET /learning/test/{topic_id}`
- `POST /learning/session/start`
- `POST /learning/answer`
- `POST /learning/session/complete`
- `GET /learning/progress`
- `POST /learning/analytics`
- `GET /learning/ai/context`
- `POST /learning/practice/start`
## pronunciation.py
**Префикс:** `/pronunciation`
- `GET /pronunciation/next`
## sentences.py
**Префикс:** `/sentences`
- `GET /sentences/{sentence_id}/hint`
- `GET /sentences/next`
- `POST /sentences/check`
- `GET /sentences/stats`
## support.py
**Префикс:** `/support`
- `POST /support/send`
- `GET /support/user-tickets`
- `GET /support/user-messages/{ticket_id}`
- `GET /support/user-unread-count`
- `POST /support/delete-ticket/{ticket_id}`
- `GET /support/admin-tickets`
- `GET /support/admin-messages/{ticket_id}`
- `POST /support/admin-reply`
- `GET /support/unread-count`
- `POST /support/translate`
## teacher.py
**Префикс:** `/teacher`
- `GET /teacher/phrase-of-day`
- `POST /teacher/resume`
- `POST /teacher/start`
- `POST /teacher/answer`
- `POST /teacher/explain`
- `POST /teacher/examples`
- `POST /teacher/free-message`
- `POST /teacher/diagnostic-test`
- `POST /teacher/translate-to-polish`
- `GET /teacher/progress`
- `POST /teacher/history/save`
- `GET /teacher/history/load`
- `POST /teacher/history/clear`
## typing.py
**Префикс:** `/typing`
- `GET /typing/next`
- `POST /typing/check`
- `GET /typing/hint/{sentence_id}`
- `GET /typing/progress`
## users.py
**Префикс:** `/users`
- `POST /users/register`
- `GET /users/me/is-admin`
- `POST /users/set-language`
- `POST /users/set-level`
## wordquiz.py
**Префикс:** `/wordquiz`
- `GET /wordquiz/next`
- `POST /wordquiz/check`
- `GET /wordquiz/progress`
+3 -3
View File
@@ -4,7 +4,7 @@
Что делает:
1. Проверяет, есть ли фраза на сегодня в daily_phrases
2. Если нет — генерирует через AI (MiniMax-M3)
2. Если нет — генерирует через AI (DeepSeek V4 Pro)
3. Пишет в daily_phrases с phrase_date = CURRENT_DATE
Fallback: если AI упал — пишет запасную фразу.
@@ -25,7 +25,7 @@ logging.basicConfig(
logger = logging.getLogger(__name__)
TOGETHER_API_URL = "https://api.together.xyz/v1/chat/completions"
TEACHER_MODEL = "MiniMaxAI/MiniMax-M3"
TEACHER_MODEL = "deepseek-ai/DeepSeek-V4-Pro-0813"
# Список тем для фразы дня
TOPICS_LIST = [
@@ -119,7 +119,7 @@ EN_GRAMMAR: [грамматический разбор на английском
user_prompt = f"Создай фразу дня на тему: {selected_topic}."
ai_response = await call_ai(system_prompt, user_prompt, max_tokens=1000)
ai_response = await call_ai(system_prompt, user_prompt, max_tokens=3000)
if not ai_response:
logger.warning("AI returned empty response, using fallback")
+30 -7
View File
@@ -2,18 +2,20 @@ import asyncio
import ipaddress
import logging
import os
import re
import time
from collections import defaultdict
from contextlib import asynccontextmanager
from pathlib import Path
from fastapi import FastAPI, Request, HTTPException
from fastapi import FastAPI, Request
from fastapi.middleware.cors import CORSMiddleware
from fastapi.responses import JSONResponse
from fastapi.staticfiles import StaticFiles
from config import FRONTEND_ORIGIN, UPLOADS_DIR, CF_IPS
from config import FRONTEND_ORIGINS, UPLOADS_DIR, CF_IPS
from database import init_db
from routers import users, game, hints, leaderboard, sentences, achievements, wordquiz, bubblewords, pronunciation, assistant, learning, tts, typing, teacher, support, admin, feed, admin_content
from routers import lectures, admin_auth, admin_wordsearch, admin_users
from routers import admin_ai # 🔧 НОВОЕ
from routers import app_auth # 🆕 Pleily auth
from routers import featured as featured_router # 🔧 НОВОЕ (08.10.2026)
from routers.sentences import init_sentences
from routers.achievements import init_achievements
from routers.learning_data import init_learning_data
@@ -68,7 +70,10 @@ class RateLimiter:
"/game/check-word": {"max_requests": 30, "window": 60},
"/game/complete-level": {"max_requests": 10, "window": 60},
"/sentences/check": {"max_requests": 20, "window": 60},
"/leaderboard": {"max_requests": 10, "window": 60},
# 🔧 ФИКС (30.09.2026): leaderboard_rate_limit_too_low —
# Mini App делает несколько запросов подряд при загрузке страницы
# (аватар + данные + ре-рендер) → 429. Подняли до 30/мин.
"/leaderboard": {"max_requests": 30, "window": 60},
"/assistant/chat": {"max_requests": 20, "window": 60},
"/learning/answer": {"max_requests": 30, "window": 60},
"/tts": {"max_requests": 30, "window": 60},
@@ -88,13 +93,21 @@ class RateLimiter:
# 🔧 ФИКС (22.09.2026): дорогой AI-эндпоинт без лимита выжигал бюджет.
"/learning/analytics": {"max_requests": 5, "window": 60},
"/learning/practice/start": {"max_requests": 10, "window": 60},
# 🆕 Pleily (07.10.2026): лимит на вход по device_id.
# Защищает от спама создания новых юзеров.
"/auth/device": {"max_requests": 5, "window": 60},
}
self._cleanup_task = None
def _cleanup(self):
# 🔧 ФИКС (25.09.2026): rate_limiter_cleanup_hardcoded_window —
# раньше жёстко 60с. Если добавить лимит с window > 60,
# записи удалялись бы раньше времени, и лимит не работал.
# Теперь: max(window) из self.limits.
now = time.time()
max_window = max(cfg["window"] for cfg in self.limits.values())
for key in list(self.requests.keys()):
self.requests[key] = [t for t in self.requests[key] if now - t < 60]
self.requests[key] = [t for t in self.requests[key] if now - t < max_window]
if not self.requests[key]:
del self.requests[key]
@@ -317,9 +330,11 @@ async def rate_limit_middleware(request: Request, call_next):
# ============ CORS ============
# 🔧 ФИКС (26.09.2026): admin_cors — добавлен admin.filwordspl.com в origins.
# Также добавлен X-Admin-Token в allow_headers для админ-авторизации.
app.add_middleware(
CORSMiddleware,
allow_origins=[FRONTEND_ORIGIN],
allow_origins=FRONTEND_ORIGINS,
allow_credentials=False,
allow_methods=["GET", "POST", "PUT", "DELETE", "OPTIONS"],
# 🔧 ФИКС (23.09.2026): INIT_DATA_IN_URL — добавлен Authorization в явный список.
@@ -329,6 +344,7 @@ app.add_middleware(
"Authorization",
"Content-Type",
"X-Telegram-InitData",
"X-Admin-Token",
],
)
@@ -354,6 +370,13 @@ app.include_router(support.router)
app.include_router(admin.router)
app.include_router(feed.router)
app.include_router(admin_content.router)
app.include_router(lectures.router)
app.include_router(admin_auth.router)
app.include_router(admin_wordsearch.router)
app.include_router(admin_users.router)
app.include_router(admin_ai.router) # 🔧 НОВОЕ
app.include_router(app_auth.router) # 🆕 Pleily
app.include_router(featured_router.router) # 🔧 НОВОЕ (08.10.2026)
# ============ Базовые эндпоинты ============
+2
View File
@@ -36,3 +36,5 @@ typing_extensions==4.16.0
urllib3==2.7.0
uvicorn==0.51.0
yarl==1.24.5
pdfplumber==0.11.10
PyJWT==2.15.1
+291 -92
View File
@@ -1,10 +1,14 @@
from fastapi import APIRouter, Request, HTTPException
import logging
from fastapi import APIRouter, Request
from auth import require_auth
from database import get_pool
logger = logging.getLogger(__name__)
router = APIRouter(prefix="/achievements", tags=["achievements"])
# ============ Данные 52 достижений ============
# ============ Данные 55 достижений ============
ACHIEVEMENTS_DATA = [
# ===== Word Search (11) =====
{"code": "first_level", "category": "wordsearch", "icon": "🔰",
@@ -62,7 +66,53 @@ ACHIEVEMENTS_DATA = [
"desc_pl": "Znajdź 5 słów bez błędu", "desc_ru": "Найти 5 слов подряд без ошибок", "desc_uk": "Знайти 5 слів без помилки", "desc_en": "Find 5 words without mistakes",
"type": "perfect_words", "value": 5},
# ===== Sentence Builder (10) =====
# ===== Word Search — волны (9 новых, 11.10.2026) =====
{"code": "ws_wave_1", "category": "wordsearch", "icon": "🌊",
"name_pl": "Pierwsza fala", "name_ru": "Первая волна", "name_uk": "Перша хвиля", "name_en": "First Wave",
"desc_pl": "Ukończ pierwszą falę (10 poziomów)", "desc_ru": "Пройти первую волну (10 уровней)", "desc_uk": "Пройти першу хвилю (10 рівнів)", "desc_en": "Complete your first wave (10 levels)",
"type": "waves_completed", "value": 1},
{"code": "ws_wave_5", "category": "wordsearch", "icon": "🌊",
"name_pl": "Pięć fal", "name_ru": "Пять волн", "name_uk": "П'ять хвиль", "name_en": "Five Waves",
"desc_pl": "Ukończ 5 fal", "desc_ru": "Пройти 5 волн", "desc_uk": "Пройти 5 хвиль", "desc_en": "Complete 5 waves",
"type": "waves_completed", "value": 5},
{"code": "ws_wave_10", "category": "wordsearch", "icon": "🌊",
"name_pl": "Dziesięć fal", "name_ru": "Десять волн", "name_uk": "Десять хвиль", "name_en": "Ten Waves",
"desc_pl": "Ukończ 10 fal", "desc_ru": "Пройти 10 волн", "desc_uk": "Пройти 10 хвиль", "desc_en": "Complete 10 waves",
"type": "waves_completed", "value": 10},
{"code": "ws_wave_25", "category": "wordsearch", "icon": "🌊",
"name_pl": "Dwadzieścia pięć fal", "name_ru": "Двадцать пять волн", "name_uk": "Двадцять п'ять хвиль", "name_en": "Twenty-Five Waves",
"desc_pl": "Ukończ 25 fal", "desc_ru": "Пройти 25 волн", "desc_uk": "Пройти 25 хвиль", "desc_en": "Complete 25 waves",
"type": "waves_completed", "value": 25},
{"code": "ws_wave_50", "category": "wordsearch", "icon": "🌊",
"name_pl": "Pięćdziesiąt fal", "name_ru": "Пятьдесят волн", "name_uk": "П'ятдесят хвиль", "name_en": "Fifty Waves",
"desc_pl": "Ukończ 50 fal", "desc_ru": "Пройти 50 волн", "desc_uk": "Пройти 50 хвиль", "desc_en": "Complete 50 waves",
"type": "waves_completed", "value": 50},
{"code": "ws_speed_run_3", "category": "wordsearch", "icon": "⚡",
"name_pl": "Szybka seria", "name_ru": "Быстрая серия", "name_uk": "Швидка серія", "name_en": "Speed Run",
"desc_pl": "Ukończ 3 poziomy z rzędu, każdy w mniej niż 30 sekund", "desc_ru": "Пройти 3 уровня подряд, каждый быстрее 30 секунд", "desc_uk": "Пройти 3 рівні поспіль, кожен швидше 30 секунд", "desc_en": "Complete 3 levels in a row, each under 30 seconds",
"type": "ws_speed_run", "value": 3},
{"code": "ws_wave_no_hints", "category": "wordsearch", "icon": "🎯",
"name_pl": "Fala bez podpowiedzi", "name_ru": "Волна без подсказок", "name_uk": "Хвиля без підказок", "name_en": "Flawless Wave",
"desc_pl": "Ukończ całą falę (10 poziomów) bez podpowiedzi", "desc_ru": "Пройти всю волну (10 уровней) без подсказок", "desc_uk": "Пройти всю хвилю (10 рівнів) без підказок", "desc_en": "Complete a whole wave (10 levels) without hints",
"type": "ws_no_hints_streak", "value": 10},
{"code": "ws_words_1000", "category": "wordsearch", "icon": "📚",
"name_pl": "Tysiąc słów", "name_ru": "Тысяча слов", "name_uk": "Тисяча слів", "name_en": "Thousand Words",
"desc_pl": "Znajdź 1000 słów w filwordach", "desc_ru": "Найти 1000 слов в филвордах", "desc_uk": "Знайти 1000 слів у філвордах", "desc_en": "Find 1000 words in word searches",
"type": "wordsearch_words", "value": 1000},
{"code": "ws_xp_10000", "category": "wordsearch", "icon": "💎",
"name_pl": "Diament filwordów", "name_ru": "Бриллиант филвордов", "name_uk": "Діамант філвордів", "name_en": "Word Search Diamond",
"desc_pl": "Zdobądź 10 000 XP w filwordach", "desc_ru": "Набрать 10 000 XP в филвордах", "desc_uk": "Набрати 10 000 XP у філвордах", "desc_en": "Earn 10,000 XP in word searches",
"type": "wordsearch_xp", "value": 10000},
# ===== Sentence Builder (20) =====
{"code": "first_sentence", "category": "sentence", "icon": "📝",
"name_pl": "Debiutant", "name_ru": "Дебютант", "name_uk": "Дебютант", "name_en": "Debutant",
"desc_pl": "Ułóż 1 zdanie", "desc_ru": "Составить 1 предложение", "desc_uk": "Скласти 1 речення", "desc_en": "Build 1 sentence",
@@ -88,20 +138,16 @@ ACHIEVEMENTS_DATA = [
"desc_pl": "Ułóż 200 zdań", "desc_ru": "Составить 200 предложений", "desc_uk": "Скласти 200 речень", "desc_en": "Build 200 sentences",
"type": "sentences_completed", "value": 200},
{"code": "perfect_sentence_5", "category": "sentence", "icon": "✨",
"name_pl": "Perfekcjonista", "name_ru": "Перфекционист", "name_uk": "Перфекціоніст", "name_en": "Perfectionist",
"desc_pl": "Ułóż 5 zdań bez błędu", "desc_ru": "Составить 5 предложений без единой ошибки", "desc_uk": "Скласти 5 речень без жодної помилки", "desc_en": "Build 5 sentences without mistakes",
"type": "perfect_sentences", "value": 5},
{"code": "sentence_500", "category": "sentence", "icon": "🌟",
"name_pl": "Legenda zdań", "name_ru": "Легенда предложений", "name_uk": "Легенда речень", "name_en": "Sentence Legend",
"desc_pl": "Ułóż 500 zdań", "desc_ru": "Составить 500 предложений", "desc_uk": "Скласти 500 речень", "desc_en": "Build 500 sentences",
"type": "sentences_completed", "value": 500},
{"code": "sentence_perfect_10", "category": "sentence", "icon": "💎",
"name_pl": "Mistrz zdań", "name_ru": "Мастер предложений", "name_uk": "Майстер речень", "name_en": "Sentence Master",
"desc_pl": "Ułóż 10 zdań bez błędu", "desc_ru": "Составить 10 предложений без ошибок", "desc_uk": "Скласти 10 речень без помилок", "desc_en": "Build 10 sentences without mistakes",
"type": "perfect_sentences", "value": 10},
{"code": "sentence_1000", "category": "sentence", "icon": "👑",
"name_pl": "Guru zdań", "name_ru": "Гуру предложений", "name_uk": "Гуру речень", "name_en": "Sentence Guru",
"desc_pl": "Ułóż 1000 zdań", "desc_ru": "Составить 1000 предложений", "desc_uk": "Скласти 1000 речень", "desc_en": "Build 1000 sentences",
"type": "sentences_completed", "value": 1000},
{"code": "sentence_streak_10", "category": "sentence", "icon": "💪",
"name_pl": "Nieomylny", "name_ru": "Безошибочный", "name_uk": "Безпомилковий", "name_en": "Flawless",
"desc_pl": "Ułóż 10 zdań z rzędu bez błędu", "desc_ru": "Составить 10 предложений подряд без ошибок", "desc_uk": "Скласти 10 речень поспіль без помилок", "desc_en": "Build 10 sentences in a row without mistakes",
"type": "sentence_streak", "value": 10},
{"code": "speed_10", "category": "sentence", "icon": "🚀",
"name_pl": "Turbo", "name_ru": "Турбо", "name_uk": "Турбо", "name_en": "Turbo",
@@ -113,7 +159,62 @@ ACHIEVEMENTS_DATA = [
"desc_pl": "Ułóż zdanie w mniej niż 5 sekund", "desc_ru": "Составить предложение быстрее 5 секунд", "desc_uk": "Скласти речення швидше 5 секунд", "desc_en": "Build a sentence in under 5 seconds",
"type": "speed_sentence", "value": 5},
# ===== Word Quiz (8) =====
{"code": "sentence_speed_3", "category": "sentence", "icon": "⚡",
"name_pl": "Błyskawica", "name_ru": "Молния", "name_uk": "Блискавка", "name_en": "Lightning",
"desc_pl": "Ułóż zdanie w mniej niż 3 sekundy", "desc_ru": "Составить предложение быстрее 3 секунд", "desc_uk": "Скласти речення швидше 3 секунд", "desc_en": "Build a sentence in under 3 seconds",
"type": "speed_sentence", "value": 3},
{"code": "sentence_no_mistakes_5", "category": "sentence", "icon": "✨",
"name_pl": "Bezbłędny", "name_ru": "Безошибочный", "name_uk": "Безпомилковий", "name_en": "Flawless",
"desc_pl": "Ułóż 5 zdań bez błędu z rzędu", "desc_ru": "Составить 5 предложений без ошибок подряд", "desc_uk": "Скласти 5 речень без помилок поспіль", "desc_en": "Build 5 sentences without mistakes in a row",
"type": "sentence_no_mistakes", "value": 5},
{"code": "sentence_no_mistakes_10", "category": "sentence", "icon": "💎",
"name_pl": "Nieomylny", "name_ru": "Безошибочный", "name_uk": "Безпомилковий", "name_en": "Infallible",
"desc_pl": "Ułóż 10 zdań bez błędu z rzędu", "desc_ru": "Составить 10 предложений без ошибок подряд", "desc_uk": "Скласти 10 речень без помилок поспіль", "desc_en": "Build 10 sentences without mistakes in a row",
"type": "sentence_no_mistakes", "value": 10},
{"code": "sentence_no_mistakes_25", "category": "sentence", "icon": "🏆",
"name_pl": "Mistrz czystości", "name_ru": "Мастер чистоты", "name_uk": "Майстер чистоти", "name_en": "Pure Master",
"desc_pl": "Ułóż 25 zdań bez błędu z rzędu", "desc_ru": "Составить 25 предложений без ошибок подряд", "desc_uk": "Скласти 25 речень без помилок поспіль", "desc_en": "Build 25 sentences without mistakes in a row",
"type": "sentence_no_mistakes", "value": 25},
{"code": "sentence_no_mistakes_50", "category": "sentence", "icon": "👑",
"name_pl": "Król czystości", "name_ru": "Король чистоты", "name_uk": "Король чистоти", "name_en": "Pure King",
"desc_pl": "Ułóż 50 zdań bez błędu z rzędu", "desc_ru": "Составить 50 предложений без ошибок подряд", "desc_uk": "Скласти 50 речень без помилок поспіль", "desc_en": "Build 50 sentences without mistakes in a row",
"type": "sentence_no_mistakes", "value": 50},
{"code": "sentence_perfect_streak_5", "category": "sentence", "icon": "✨",
"name_pl": "Perfekcyjna seria", "name_ru": "Идеальная серия", "name_uk": "Ідеальна серія", "name_en": "Perfect Streak",
"desc_pl": "Ułóż 5 idealnych zdań z rzędu", "desc_ru": "Составить 5 идеальных предложений подряд", "desc_uk": "Скласти 5 ідеальних речень поспіль", "desc_en": "Build 5 perfect sentences in a row",
"type": "sentence_perfect_streak", "value": 5},
{"code": "sentence_perfect_streak_10", "category": "sentence", "icon": "💎",
"name_pl": "Mistrz perfekcji", "name_ru": "Мастер идеала", "name_uk": "Майстер ідеалу", "name_en": "Perfection Master",
"desc_pl": "Ułóż 10 idealnych zdań z rzędu", "desc_ru": "Составить 10 идеальных предложений подряд", "desc_uk": "Скласти 10 ідеальних речень поспіль", "desc_en": "Build 10 perfect sentences in a row",
"type": "sentence_perfect_streak", "value": 10},
{"code": "sentence_perfect_streak_25", "category": "sentence", "icon": "🏆",
"name_pl": "Perfekcjonista", "name_ru": "Перфекционист", "name_uk": "Перфекціоніст", "name_en": "Perfectionist",
"desc_pl": "Ułóż 25 idealnych zdań z rzędu", "desc_ru": "Составить 25 идеальных предложений подряд", "desc_uk": "Скласти 25 ідеальних речень поспіль", "desc_en": "Build 25 perfect sentences in a row",
"type": "sentence_perfect_streak", "value": 25},
{"code": "sentence_perfect_streak_50", "category": "sentence", "icon": "👑",
"name_pl": "Idealny król", "name_ru": "Идеальный король", "name_uk": "Ідеальний король", "name_en": "Perfect King",
"desc_pl": "Ułóż 50 idealnych zdań z rzędu", "desc_ru": "Составить 50 идеальных предложений подряд", "desc_uk": "Скласти 50 ідеальних речень поспіль", "desc_en": "Build 50 perfect sentences in a row",
"type": "sentence_perfect_streak", "value": 50},
{"code": "sentence_xp_1000", "category": "sentence", "icon": "💎",
"name_pl": "Zdaniowy XP", "name_ru": "XP предложений", "name_uk": "XP речень", "name_en": "Sentence XP",
"desc_pl": "Zdobądź 1000 punktów w zdaniach", "desc_ru": "Набрать 1000 очков в предложениях", "desc_uk": "Набрати 1000 балів у реченнях", "desc_en": "Earn 1000 points in sentences",
"type": "sentence_xp", "value": 1000},
{"code": "sentence_xp_5000", "category": "sentence", "icon": "👑",
"name_pl": "Zdaniowy diament", "name_ru": "Бриллиант предложений", "name_uk": "Діамант речень", "name_en": "Sentence Diamond",
"desc_pl": "Zdobądź 5000 punktów w zdaniach", "desc_ru": "Набрать 5000 очков в предложениях", "desc_uk": "Набрати 5000 балів у реченнях", "desc_en": "Earn 5000 points in sentences",
"type": "sentence_xp", "value": 5000},
# ===== Word Quiz (20) =====
{"code": "quiz_10", "category": "wordquiz", "icon": "🧠",
"name_pl": "Myśliciel", "name_ru": "Мыслитель", "name_uk": "Мислитель", "name_en": "Thinker",
"desc_pl": "Odgadnij 10 słów w Quiz słownym", "desc_ru": "Угадать 10 слов в Квизе слов", "desc_uk": "Відгадати 10 слів у Квізі слів", "desc_en": "Guess 10 words in Word Quiz",
@@ -132,29 +233,89 @@ ACHIEVEMENTS_DATA = [
{"code": "quiz_perfect_10", "category": "wordquiz", "icon": "💎",
"name_pl": "Idealny wynik", "name_ru": "Идеальный результат", "name_uk": "Ідеальний результат", "name_en": "Perfect Score",
"desc_pl": "Odgadnij 10 słów bez pomyłki", "desc_ru": "Угадать 10 слов без ошибок", "desc_uk": "Відгадати 10 слів без помилок", "desc_en": "Guess 10 words without mistakes",
"type": "quiz_perfect_streak", "value": 10},
"type": "quiz_correct_streak", "value": 10},
{"code": "quiz_streak_20", "category": "wordquiz", "icon": "🔥",
"name_pl": "Niepowstrzymany", "name_ru": "Неудержимый", "name_uk": "Невтримний", "name_en": "Unstoppable",
"desc_pl": "Odgadnij 20 słów z rzędu", "desc_ru": "Угадать 20 слов подряд", "desc_uk": "Відгадати 20 слів поспіль", "desc_en": "Guess 20 words in a row",
"type": "quiz_perfect_streak", "value": 20},
"type": "quiz_correct_streak", "value": 20},
{"code": "quiz_speed", "category": "wordquiz", "icon": "⚡",
"name_pl": "Błyskawica", "name_ru": "Молния", "name_uk": "Блискавка", "name_en": "Lightning",
"desc_pl": "Odgadnij słowo w mniej niż 3 sekundy", "desc_ru": "Угадать слово быстрее 3 секунд", "desc_uk": "Відгадати слово швидше 3 секунд", "desc_en": "Guess a word in under 3 seconds",
"type": "quiz_speed", "value": 3},
"type": "quiz_speed_3", "value": 3},
{"code": "quiz_speed_2", "category": "wordquiz", "icon": "🚀",
"name_pl": "Super szybki", "name_ru": "Супер быстрый", "name_uk": "Супер швидкий", "name_en": "Super Fast",
"desc_pl": "Odgadnij słowo w mniej niż 2 sekundy", "desc_ru": "Угадать слово быстрее 2 секунд", "desc_uk": "Відгадати слово швидше 2 секунд", "desc_en": "Guess a word in under 2 seconds",
"type": "quiz_speed", "value": 2},
"type": "quiz_speed_2", "value": 2},
{"code": "quiz_no_mistakes", "category": "wordquiz", "icon": "🏆",
"name_pl": "Bezbłędny", "name_ru": "Безошибочный", "name_uk": "Безпомилковий", "name_en": "Flawless",
"desc_pl": "Odgadnij słowo bez żadnej pomyłki", "desc_ru": "Угадать слово без единой ошибки", "desc_uk": "Відгадати слово без жодної помилки", "desc_en": "Guess a word without any mistakes",
"type": "quiz_no_mistakes", "value": 1},
# ===== Bubble Words (8) =====
{"code": "quiz_1", "category": "wordquiz", "icon": "🎯",
"name_pl": "Pierwszy krok", "name_ru": "Первый шаг", "name_uk": "Перший крок", "name_en": "First Step",
"desc_pl": "Odgadnij 1 słowo", "desc_ru": "Угадать 1 слово", "desc_uk": "Вгадати 1 слово", "desc_en": "Guess 1 word",
"type": "quiz_guessed", "value": 1},
{"code": "quiz_25", "category": "wordquiz", "icon": "🎓",
"name_pl": "Uczeń", "name_ru": "Ученик", "name_uk": "Учень", "name_en": "Student",
"desc_pl": "Odgadnij 25 słów", "desc_ru": "Угадать 25 слов", "desc_uk": "Вгадати 25 слів", "desc_en": "Guess 25 words",
"type": "quiz_guessed", "value": 25},
{"code": "quiz_200", "category": "wordquiz", "icon": "📚",
"name_pl": "Erudyta", "name_ru": "Эрудит", "name_uk": "Ерудит", "name_en": "Erudite",
"desc_pl": "Odgadnij 200 słów", "desc_ru": "Угадать 200 слов", "desc_uk": "Вгадати 200 слів", "desc_en": "Guess 200 words",
"type": "quiz_guessed", "value": 200},
{"code": "quiz_500", "category": "wordquiz", "icon": "🌟",
"name_pl": "Legenda", "name_ru": "Легенда", "name_uk": "Легенда", "name_en": "Legend",
"desc_pl": "Odgadnij 500 słów", "desc_ru": "Угадать 500 слов", "desc_uk": "Вгадати 500 слів", "desc_en": "Guess 500 words",
"type": "quiz_guessed", "value": 500},
{"code": "quiz_1000", "category": "wordquiz", "icon": "👑",
"name_pl": "Guru", "name_ru": "Гуру", "name_uk": "Гуру", "name_en": "Guru",
"desc_pl": "Odgadnij 1000 słów", "desc_ru": "Угадать 1000 слов", "desc_uk": "Вгадати 1000 слів", "desc_en": "Guess 1000 words",
"type": "quiz_guessed", "value": 1000},
{"code": "quiz_correct_streak_5", "category": "wordquiz", "icon": "🔥",
"name_pl": "Seria", "name_ru": "Серия", "name_uk": "Серія", "name_en": "Streak",
"desc_pl": "5 poprawnych z rzędu", "desc_ru": "5 правильных подряд", "desc_uk": "5 правильних поспіль", "desc_en": "5 correct in a row",
"type": "quiz_correct_streak", "value": 5},
{"code": "quiz_streak_30", "category": "wordquiz", "icon": "💪",
"name_pl": "Na fali", "name_ru": "На волне", "name_uk": "На хвилі", "name_en": "On Fire",
"desc_pl": "30 poprawnych z rzędu", "desc_ru": "30 правильных подряд", "desc_uk": "30 правильних поспіль", "desc_en": "30 correct in a row",
"type": "quiz_correct_streak", "value": 30},
{"code": "quiz_streak_50", "category": "wordquiz", "icon": "🏆",
"name_pl": "Niezwyciężony", "name_ru": "Непобедимый", "name_uk": "Непереможний", "name_en": "Invincible",
"desc_pl": "50 poprawnych z rzędu", "desc_ru": "50 правильных подряд", "desc_uk": "50 правильних поспіль", "desc_en": "50 correct in a row",
"type": "quiz_correct_streak", "value": 50},
{"code": "quiz_no_mistakes_3", "category": "wordquiz", "icon": "✨",
"name_pl": "Czysta trójka", "name_ru": "Чистая тройка", "name_uk": "Чиста трійка", "name_en": "Clean Three",
"desc_pl": "3 rundy bez błędu z rzędu", "desc_ru": "3 раунда без ошибок подряд", "desc_uk": "3 раунди без помилок поспіль", "desc_en": "3 rounds without mistakes in a row",
"type": "quiz_no_mistakes_streak", "value": 3},
{"code": "quiz_perfect_25", "category": "wordquiz", "icon": "💎",
"name_pl": "Perfekcjonista", "name_ru": "Перфекционист", "name_uk": "Перфекціоніст", "name_en": "Perfectionist",
"desc_pl": "25 rund bez błędu z rzędu", "desc_ru": "25 раундов без ошибок подряд", "desc_uk": "25 раундів без помилок поспіль", "desc_en": "25 rounds without mistakes in a row",
"type": "quiz_no_mistakes_streak", "value": 25},
{"code": "quiz_speed_5", "category": "wordquiz", "icon": "⚡",
"name_pl": "Szybki", "name_ru": "Быстрый", "name_uk": "Швидкий", "name_en": "Fast",
"desc_pl": "Odgadnij słowo w mniej niż 5 sekund", "desc_ru": "Угадать слово быстрее 5 секунд", "desc_uk": "Вгадати слово швидше 5 секунд", "desc_en": "Guess a word in under 5 seconds",
"type": "quiz_speed_5", "value": 5},
{"code": "quiz_speed_1", "category": "wordquiz", "icon": "🚀",
"name_pl": "Błyskawica", "name_ru": "Молния", "name_uk": "Блискавка", "name_en": "Lightning",
"desc_pl": "Odgadnij słowo w mniej niż 1 sekundę", "desc_ru": "Угадать слово быстрее 1 секунды", "desc_uk": "Вгадати слово швидше 1 секунди", "desc_en": "Guess a word in under 1 second",
"type": "quiz_speed_1", "value": 1},
# ===== Bubble Words (20) =====
{"code": "bubble_5", "category": "bubblewords", "icon": "🫧",
"name_pl": "Początkujący", "name_ru": "Начинающий", "name_uk": "Початківець", "name_en": "Beginner",
"desc_pl": "Ukończ 5 poziomów w Bąbelkach słów", "desc_ru": "Пройти 5 уровней в Пузырях слов", "desc_uk": "Пройти 5 рівнів у Бульбашках слів", "desc_en": "Complete 5 levels in Bubble Words",
@@ -188,14 +349,74 @@ ACHIEVEMENTS_DATA = [
{"code": "bubble_speed", "category": "bubblewords", "icon": "🚀",
"name_pl": "Szybki bańki", "name_ru": "Быстрые пузыри", "name_uk": "Швидкі бульбашки", "name_en": "Fast Bubbles",
"desc_pl": "Ukończ poziom w mniej niż 45 sekund", "desc_ru": "Пройти уровень быстрее 45 секунд", "desc_uk": "Пройти рівень швидше 45 секунд", "desc_en": "Complete a level in under 45 seconds",
"type": "bubble_speed", "value": 45},
"type": "bubble_speed_45", "value": 45},
{"code": "bubble_speed_30", "category": "bubblewords", "icon": "⚡",
"name_pl": "Bąbelkowa błyskawica", "name_ru": "Пузырьковая молния", "name_uk": "Бульбашкова блискавка", "name_en": "Bubble Lightning",
"desc_pl": "Ukończ poziom w mniej niż 30 sekund", "desc_ru": "Пройти уровень быстрее 30 секунд", "desc_uk": "Пройти рівень швидше 30 секунд", "desc_en": "Complete a level in under 30 seconds",
"type": "bubble_speed", "value": 30},
"type": "bubble_speed_30", "value": 30},
# ===== General (15) =====
{"code": "bubble_1", "category": "bubblewords", "icon": "🫧",
"name_pl": "Pierwszy bąbelek", "name_ru": "Первый пузырь", "name_uk": "Перша бульбашка", "name_en": "First Bubble",
"desc_pl": "Ukończ 1 poziom w Bąbelkach słów", "desc_ru": "Пройти 1 уровень в Пузырях слов", "desc_uk": "Пройти 1 рівень у Бульбашках слів", "desc_en": "Complete 1 level in Bubble Words",
"type": "bubble_levels", "value": 1},
{"code": "bubble_10", "category": "bubblewords", "icon": "🫧",
"name_pl": "Dziesięć bąbelków", "name_ru": "Десять пузырей", "name_uk": "Десять бульбашок", "name_en": "Ten Bubbles",
"desc_pl": "Ukończ 10 poziomów w Bąbelkach słów", "desc_ru": "Пройти 10 уровней в Пузырях слов", "desc_uk": "Пройти 10 рівнів у Бульбашках слів", "desc_en": "Complete 10 levels in Bubble Words",
"type": "bubble_levels", "value": 10},
{"code": "bubble_words_25", "category": "bubblewords", "icon": "📚",
"name_pl": "Kolekcjoner", "name_ru": "Собиратель", "name_uk": "Колекціонер", "name_en": "Collector",
"desc_pl": "Zbierz 25 słów", "desc_ru": "Собрать 25 слов", "desc_uk": "Зібрати 25 слів", "desc_en": "Collect 25 words",
"type": "bubble_words", "value": 25},
{"code": "bubble_no_mistakes", "category": "bubblewords", "icon": "✨",
"name_pl": "Bezbłędny", "name_ru": "Без ошибок", "name_uk": "Без помилок", "name_en": "No Mistakes",
"desc_pl": "Ukończ poziom bez żadnej pomyłki", "desc_ru": "Пройти уровень без единой ошибки", "desc_uk": "Пройти рівень без жодної помилки", "desc_en": "Complete a level without any mistakes",
"type": "bubble_no_mistakes", "value": 1},
{"code": "bubble_streak_3", "category": "bubblewords", "icon": "🔥",
"name_pl": "Seria", "name_ru": "Серия", "name_uk": "Серія", "name_en": "Streak",
"desc_pl": "Ukończ 3 poziomy z rzędu bez podpowiedzi", "desc_ru": "Пройти 3 уровня подряд без подсказок", "desc_uk": "Пройти 3 рівні поспіль без підказок", "desc_en": "Complete 3 levels in a row without hints",
"type": "bubble_streak", "value": 3},
{"code": "bubble_streak_10", "category": "bubblewords", "icon": "💪",
"name_pl": "Niepowstrzymany", "name_ru": "Неудержимый", "name_uk": "Невтримний", "name_en": "Unstoppable",
"desc_pl": "Ukończ 10 poziomów z rzędu bez podpowiedzi", "desc_ru": "Пройти 10 уровней подряд без подсказок", "desc_uk": "Пройти 10 рівнів поспіль без підказок", "desc_en": "Complete 10 levels in a row without hints",
"type": "bubble_streak", "value": 10},
{"code": "bubble_words_100", "category": "bubblewords", "icon": "📖",
"name_pl": "Sto słów", "name_ru": "Сто слов", "name_uk": "Сто слів", "name_en": "Hundred Words",
"desc_pl": "Zbierz 100 słów", "desc_ru": "Собрать 100 слов", "desc_uk": "Зібрати 100 слів", "desc_en": "Collect 100 words",
"type": "bubble_words", "value": 100},
{"code": "bubble_xp_1000", "category": "bubblewords", "icon": "💎",
"name_pl": "Bąbelkowy XP", "name_ru": "Пузырьковый XP", "name_uk": "Бульбашковий XP", "name_en": "Bubble XP",
"desc_pl": "Zdobądź 1000 XP w Bąbelkach", "desc_ru": "Набрать 1000 XP в пузырях", "desc_uk": "Набрати 1000 XP у бульбашках", "desc_en": "Earn 1000 XP in Bubbles",
"type": "bubble_xp", "value": 1000},
{"code": "bubble_200", "category": "bubblewords", "icon": "👑",
"name_pl": "Dwustu poziomów", "name_ru": "Двести уровней", "name_uk": "Двісті рівнів", "name_en": "Two Hundred Levels",
"desc_pl": "Ukończ 200 poziomów w Bąbelkach słów", "desc_ru": "Пройти 200 уровней в Пузырях слов", "desc_uk": "Пройти 200 рівнів у Бульбашках слів", "desc_en": "Complete 200 levels in Bubble Words",
"type": "bubble_levels", "value": 200},
{"code": "bubble_speed_15", "category": "bubblewords", "icon": "⚡",
"name_pl": "Błyskawica", "name_ru": "Молния", "name_uk": "Блискавка", "name_en": "Lightning",
"desc_pl": "Ukończ poziom w mniej niż 15 sekund", "desc_ru": "Пройти уровень быстрее 15 секунд", "desc_uk": "Пройти рівень швидше 15 секунд", "desc_en": "Complete a level in under 15 seconds",
"type": "bubble_speed_15", "value": 15},
{"code": "bubble_perfect_10", "category": "bubblewords", "icon": "🌟",
"name_pl": "Perfekcyjna seria", "name_ru": "Идеальная серия", "name_uk": "Ідеальна серія", "name_en": "Perfect Streak",
"desc_pl": "Ukończ 10 idealnych poziomów z rzędu", "desc_ru": "Пройти 10 идеальных уровней подряд", "desc_uk": "Пройти 10 ідеальних рівнів поспіль", "desc_en": "Complete 10 perfect levels in a row",
"type": "bubble_perfect_streak", "value": 10},
{"code": "bubble_words_500", "category": "bubblewords", "icon": "🏆",
"name_pl": "Pięćset słów", "name_ru": "Пятьсот слов", "name_uk": "П'ятсот слів", "name_en": "Five Hundred Words",
"desc_pl": "Zbierz 500 słów", "desc_ru": "Собрать 500 слов", "desc_uk": "Зібрати 500 слів", "desc_en": "Collect 500 words",
"type": "bubble_words", "value": 500},
# ===== General (9) =====
{"code": "score_1000", "category": "general", "icon": "🌟",
"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",
@@ -241,86 +462,64 @@ ACHIEVEMENTS_DATA = [
"desc_pl": "Zmień język interfejsu", "desc_ru": "Сменить язык интерфейса", "desc_uk": "Змінити мову інтерфейсу", "desc_en": "Change interface language",
"type": "language_changed", "value": 1},
# 🔧 ИСПРАВЛЕНО: Заменено достижение "Открой Грамматику" на "Открой меню учителя"
{"code": "open_teacher_menu", "category": "general", "icon": "🎓",
"name_pl": "Uczeń", "name_ru": "Ученик", "name_uk": "Учень", "name_en": "Student",
"desc_pl": "Otwórz menu nauczyciela", "desc_ru": "Открыть меню учителя", "desc_uk": "Відкрити меню вчителя", "desc_en": "Open the teacher menu",
"type": "teacher_menu_opened", "value": 1},
{"code": "open_cheatsheets", "category": "general", "icon": "📝",
"name_pl": "Ciekawski", "name_ru": "Любознательный", "name_uk": "Допитливий", "name_en": "Curious",
"desc_pl": "Otwórz sekcję Ściągi", "desc_ru": "Открыть раздел Шпаргалки", "desc_uk": "Відкрити розділ Шпаргалки", "desc_en": "Open the Cheatsheets section",
"type": "cheatsheets_opened", "value": 1},
{"code": "open_pronunciation", "category": "general", "icon": "🔊",
"name_pl": "Słuchacz", "name_ru": "Слушатель", "name_uk": "Слухач", "name_en": "Listener",
"desc_pl": "Otwórz sekcję Wymowa", "desc_ru": "Открыть раздел Произношение", "desc_uk": "Відкрити розділ Вимова", "desc_en": "Open the Pronunciation section",
"type": "pronunciation_opened", "value": 1},
{"code": "open_ai_assistant", "category": "general", "icon": "🤖",
"name_pl": "Asystent AI", "name_ru": "AI-помощник", "name_uk": "AI-помічник", "name_en": "AI Assistant",
"desc_pl": "Otwórz Asystenta AI", "desc_ru": "Открыть AI-помощника", "desc_uk": "Відкрити AI-помічника", "desc_en": "Open the AI Assistant",
"type": "ai_assistant_opened", "value": 1},
{"code": "open_alphabet", "category": "general", "icon": "🔤",
"name_pl": "Alfabetysta", "name_ru": "Алфавитист", "name_uk": "Алфавітист", "name_en": "Alphabetist",
"desc_pl": "Otwórz sekcję Alfabet", "desc_ru": "Открыть раздел Алфавит", "desc_uk": "Відкрити розділ Алфавіт", "desc_en": "Open the Alphabet section",
"type": "alphabet_opened", "value": 1},
{"code": "open_rules", "category": "general", "icon": "📐",
"name_pl": "Gramatyk", "name_ru": "Грамматик", "name_uk": "Граматик", "name_en": "Grammarian",
"desc_pl": "Otwórz sekcję Zasady", "desc_ru": "Открыть раздел Правила", "desc_uk": "Відкрити розділ Правила", "desc_en": "Open the Rules section",
"type": "rules_opened", "value": 1},
# 🔧 НОВОЕ: Достижение за открытие Прогресса
{"code": "open_progress", "category": "general", "icon": "📊",
"name_pl": "Planista", "name_ru": "Планировщик", "name_uk": "Планувальник", "name_en": "Planner",
"desc_pl": "Otwórz sekcję Postęp", "desc_ru": "Открыть раздел Прогресс", "desc_uk": "Відкрити розділ Прогрес", "desc_en": "Open the Progress section",
"type": "progress_opened", "value": 1},
]
async def init_achievements():
"""Добавляет новые достижения, не трогая существующие"""
"""Добавляет/обновляет достижения одним bulk upsert."""
pool = await get_pool()
async with pool.acquire() as conn:
for a in ACHIEVEMENTS_DATA:
exists = await conn.fetchval(
"SELECT 1 FROM achievements WHERE code = $1", a["code"]
)
if not exists:
await conn.execute(
"""INSERT INTO achievements (code, category, icon,
name_pl, name_ru, name_uk, name_en,
description_pl, description_ru, description_uk, description_en,
requirement_type, requirement_value)
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13)""",
# 🔧 ФИКС (25.09.2026): init_achievements_n_plus_1 —
# 52 SELECT + 52 INSERT/UPDATE (104 запроса) → 1 bulk upsert.
# Требует UNIQUE constraint на achievements.code (achievements_code_key).
rows = [
(
a["code"], a["category"], a["icon"],
a["name_pl"], a["name_ru"], a["name_uk"], a["name_en"],
a["desc_pl"], a["desc_ru"], a["desc_uk"], a["desc_en"],
a["type"], a["value"]
a["type"], a["value"],
)
else:
# 🔧 НОВОЕ: Обновляем существующие достижения (на случай изменения названий)
for a in ACHIEVEMENTS_DATA
]
await conn.executemany("""
INSERT INTO achievements
(code, category, icon,
name_pl, name_ru, name_uk, name_en,
description_pl, description_ru, description_uk, description_en,
requirement_type, requirement_value)
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13)
ON CONFLICT (code) DO UPDATE SET
category = EXCLUDED.category,
icon = EXCLUDED.icon,
name_pl = EXCLUDED.name_pl,
name_ru = EXCLUDED.name_ru,
name_uk = EXCLUDED.name_uk,
name_en = EXCLUDED.name_en,
description_pl = EXCLUDED.description_pl,
description_ru = EXCLUDED.description_ru,
description_uk = EXCLUDED.description_uk,
description_en = EXCLUDED.description_en,
requirement_type = EXCLUDED.requirement_type,
requirement_value = EXCLUDED.requirement_value
""", rows)
# 🔧 Удаление осиротевших достижений (которых больше нет в ACHIEVEMENTS_DATA)
await conn.execute("""
UPDATE achievements SET
category = $2,
icon = $3,
name_pl = $4,
name_ru = $5,
name_uk = $6,
name_en = $7,
description_pl = $8,
description_ru = $9,
description_uk = $10,
description_en = $11,
requirement_type = $12,
requirement_value = $13
WHERE code = $1
""", a["code"], a["category"], a["icon"],
a["name_pl"], a["name_ru"], a["name_uk"], a["name_en"],
a["desc_pl"], a["desc_ru"], a["desc_uk"], a["desc_en"],
a["type"], a["value"])
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")
@router.get("")
+130 -10
View File
@@ -2,9 +2,15 @@
Admin Router — админ-панель с реальной статистикой проекта.
1. /admin/dashboard — общая статистика (юзеры, онлайн, по уровням)
2. /admin/sentry-errors — ошибки из Sentry (через API)
3. /admin/sentry-stats — сводка по ошибкам Sentry
🔧 ОБНОВЛЕНО (01.10.2026):
- /sentry-errors: расширенные фильтры (period, status, level, q, limit)
- /sentry-stats: новый эндпоинт для сводки
"""
import os
import logging
from typing import Optional
import httpx
from fastapi import APIRouter, Request, HTTPException
from auth import require_auth
@@ -102,10 +108,23 @@ async def get_admin_dashboard(request: Request):
@router.get("/sentry-errors")
async def get_sentry_errors(request: Request):
async def get_sentry_errors(
request: Request,
period: str = "24h",
status: str = "unresolved",
level: Optional[str] = None,
q: Optional[str] = None,
limit: int = 50,
):
"""
Последние ошибки из Sentry.
Возвращает только unresolved (нерешённые) за последние 24 часа.
🔧 ОБНОВЛЕНО (01.10.2026): расширенные фильтры для Sentry.
Параметры:
- period: '1h', '24h', '7d', '14d', '30d' (по умолчанию 24h)
- status: 'unresolved', 'resolved', 'all' (по умолчанию unresolved)
- level: 'error', 'warning', 'info', 'debug' (опционально)
- q: поиск по title
- limit: 1-100 (по умолчанию 50)
"""
telegram_id, _ = await require_auth(request)
_require_admin(telegram_id)
@@ -113,15 +132,47 @@ async def get_sentry_errors(request: Request):
if not SENTRY_AUTH_TOKEN:
return {"errors": [], "error": "SENTRY_AUTH_TOKEN not configured"}
# Валидация
# 🔧 ФИКС (01.10.2026): sentry_free_plan_periods —
# Free plan Sentry поддерживает ТОЛЬКО '', '24h', '14d'.
# Остальные → 400 Bad Request.
if period not in ("", "24h", "14d"):
period = "24h"
if status not in ("unresolved", "resolved", "all"):
status = "unresolved"
if level and level not in ("error", "warning", "info", "debug", "fatal"):
level = None
if limit < 1:
limit = 1
elif limit > 100:
limit = 100
# Собираем query для Sentry
query_parts = []
if status == "unresolved":
query_parts.append("is:unresolved")
elif status == "resolved":
query_parts.append("is:resolved")
# 'all' — без фильтра статуса
if level:
query_parts.append(f"level:{level}")
if q and q.strip():
query_parts.append(q.strip())
query = " ".join(query_parts) if query_parts else ""
url = f"{SENTRY_API_BASE}/projects/{SENTRY_ORG_SLUG}/{SENTRY_PROJECT_SLUG}/issues/"
params = {
"query": "is:unresolved",
"statsPeriod": "24h",
"limit": 20,
}
headers = {
"Authorization": f"Bearer {SENTRY_AUTH_TOKEN}",
"statsPeriod": period,
"limit": limit,
"sort": "freq", # сортировка по частоте
}
if query:
params["query"] = query
headers = {"Authorization": f"Bearer {SENTRY_AUTH_TOKEN}"}
try:
async with httpx.AsyncClient(timeout=10.0) as client:
@@ -147,9 +198,11 @@ async def get_sentry_errors(request: Request):
"last_seen": issue.get("lastSeen"),
"permalink": issue.get("permalink"),
"priority": issue.get("priority"),
"status": issue.get("status"), # unresolved / resolved
"metadata": issue.get("metadata", {}),
})
return {"errors": errors, "count": len(errors)}
return {"errors": errors, "count": len(errors), "query": query or "(no filter)"}
except httpx.TimeoutException:
logger.error("Sentry API timeout")
@@ -157,3 +210,70 @@ async def get_sentry_errors(request: Request):
except Exception as e:
logger.error(f"Sentry API unexpected error: {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,
}
+124
View File
@@ -0,0 +1,124 @@
"""
Admin Auth Router — авторизация админки через логин/пароль.
Отдаёт JWT-токен. Токен используется для доступа к /admin/* эндпоинтам
через заголовок X-Admin-Token.
"""
import hashlib
import hmac
import json
import time
import base64
import logging
from fastapi import APIRouter, Request, HTTPException
from config import ADMIN_LOGIN, ADMIN_PASSWORD_HASH, ADMIN_JWT_SECRET
logger = logging.getLogger(__name__)
router = APIRouter(prefix="/admin", tags=["admin-auth"])
# Время жизни токена — 24 часа
TOKEN_TTL_SECONDS = 24 * 60 * 60
def _base64url_encode(data: bytes) -> str:
return base64.urlsafe_b64encode(data).rstrip(b"=").decode("ascii")
def _base64url_decode(data: str) -> bytes:
padding = "=" * (4 - len(data) % 4)
return base64.urlsafe_b64decode(data + padding)
def create_jwt(payload: dict) -> str:
"""Создаёт JWT-токен с HMAC-SHA256 подписью."""
header = {"alg": "HS256", "typ": "JWT"}
header_b64 = _base64url_encode(json.dumps(header, separators=(",", ":")).encode())
payload_b64 = _base64url_encode(json.dumps(payload, separators=(",", ":")).encode())
message = f"{header_b64}.{payload_b64}"
signature = hmac.new(
ADMIN_JWT_SECRET.encode(),
message.encode(),
hashlib.sha256,
).digest()
signature_b64 = _base64url_encode(signature)
return f"{message}.{signature_b64}"
def verify_jwt(token: str) -> dict:
"""Проверяет JWT-токен. Возвращает payload или бросает исключение."""
try:
parts = token.split(".")
if len(parts) != 3:
raise ValueError("Invalid token format")
header_b64, payload_b64, signature_b64 = parts
message = f"{header_b64}.{payload_b64}"
expected_signature = hmac.new(
ADMIN_JWT_SECRET.encode(),
message.encode(),
hashlib.sha256,
).digest()
actual_signature = _base64url_decode(signature_b64)
if not hmac.compare_digest(expected_signature, actual_signature):
raise ValueError("Invalid signature")
payload = json.loads(_base64url_decode(payload_b64))
# Проверяем срок действия
if payload.get("exp", 0) < time.time():
raise ValueError("Token expired")
return payload
except Exception as e:
raise ValueError(f"Invalid token: {e}")
@router.post("/login")
async def admin_login(request: Request):
"""
Логин админа. Принимает {login, password}, отдаёт JWT-токен.
"""
if not ADMIN_PASSWORD_HASH or not ADMIN_JWT_SECRET:
raise HTTPException(500, "Admin auth not configured")
body = await request.json()
login = (body.get("login") or "").strip()
password = body.get("password") or ""
if not login or not password:
raise HTTPException(400, "login and password required")
# Проверяем логин
if login != ADMIN_LOGIN:
logger.warning(f"Admin login failed: wrong login '{login}'")
raise HTTPException(401, "Invalid credentials")
# Проверяем пароль (sha256-хэш)
password_hash = hashlib.sha256(password.encode()).hexdigest()
if not hmac.compare_digest(password_hash, ADMIN_PASSWORD_HASH):
logger.warning(f"Admin login failed: wrong password for '{login}'")
raise HTTPException(401, "Invalid credentials")
# Создаём JWT
now = int(time.time())
payload = {
"sub": "admin",
"login": login,
"iat": now,
"exp": now + TOKEN_TTL_SECONDS,
}
token = create_jwt(payload)
logger.info(f"Admin login successful: {login}")
return {
"status": "ok",
"token": token,
"expires_in": TOKEN_TTL_SECONDS,
}
+1357 -21
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}
+20 -11
View File
@@ -5,7 +5,6 @@ AI Assistant Router — чат-помощник с историей, конте
"""
import logging
import time
import json
import httpx
from fastapi import APIRouter, Request, HTTPException
from auth import require_auth
@@ -439,17 +438,27 @@ async def get_admin_stats(request: Request):
) active
""") or 0
# Языки
language_counts = {}
for lang in ["pl", "ru", "uk", "en"]:
count = await conn.fetchval("SELECT COUNT(*) FROM users WHERE app_language = $1", lang) or 0
language_counts[lang] = count
# 🔧 ФИКС (25.09.2026): assistant_admin_stats_n_plus_1 —
# 2 GROUP BY вместо 10 COUNT-запросов.
LANGUAGES = ["pl", "ru", "uk", "en"]
# Уровни
level_counts = {}
for level in LEVELS:
count = await conn.fetchval("SELECT COUNT(*) FROM users WHERE current_level = $1", level) or 0
level_counts[level] = count
lang_rows = await conn.fetch("""
SELECT app_language, COUNT(*) as cnt
FROM users
WHERE app_language = ANY($1::text[])
GROUP BY app_language
""", LANGUAGES)
lang_map = {r["app_language"]: r["cnt"] for r in lang_rows}
language_counts = {lang: lang_map.get(lang, 0) for lang in LANGUAGES}
level_rows = await conn.fetch("""
SELECT current_level, COUNT(*) as cnt
FROM users
WHERE current_level = ANY($1::text[])
GROUP BY current_level
""", LEVELS)
level_map = {r["current_level"]: r["cnt"] for r in level_rows}
level_counts = {level: level_map.get(level, 0) for level in LEVELS}
return {
"total_users": total_users,
+285 -56
View File
@@ -1,6 +1,6 @@
import random
import time
import hashlib # 🔧 НОВОЕ: импорт hashlib для стабильного хэширования
import json
from fastapi import APIRouter, Request, HTTPException
from auth import require_auth
from database import get_pool
@@ -101,7 +101,7 @@ async def get_next_bubble_level(request: Request):
pool = await get_pool()
async with pool.acquire() as conn:
user = await conn.fetchrow(
"SELECT app_language, current_level FROM users WHERE telegram_id = $1", telegram_id
"SELECT app_language, current_level, difficulty FROM users WHERE telegram_id = $1", telegram_id
)
if not user:
raise HTTPException(401, "User not registered")
@@ -115,22 +115,17 @@ async def get_next_bubble_level(request: Request):
)
current_bubble_level = (progress["levels_completed"] if progress else 0) + 1
# Прогрессия по количеству слов на уровне
if current_bubble_level <= 10:
num_words = random.choice([3, 4])
elif current_bubble_level <= 25:
num_words = random.choice([5, 6])
else:
num_words = random.choice([7, 8])
# Количество слов по сложности
difficulty = user["difficulty"] if "difficulty" in user.keys() else "medium"
num_words = {"easy": 3, "medium": 4, "hard": 5}.get(difficulty, 4)
# Запрос слов с фильтром по уровню и level_id IS NULL
# 🔧 ФИКС (30.09.2026): csv_words_source —
# источник слов переехал с level_words (старая схема level_id IS NULL)
# на csv_words (level_code). Один источник — CSV-база.
words = await conn.fetch("""
SELECT word_pl, translation_ru, translation_uk, translation_en
FROM (
SELECT DISTINCT ON (word_pl) word_pl, translation_ru, translation_uk, translation_en
FROM level_words
WHERE level = $1 AND level_id IS NULL
) AS unique_words
FROM csv_words
WHERE level_code = $1
ORDER BY RANDOM()
LIMIT $2
""", current_level, num_words)
@@ -164,22 +159,191 @@ async def get_next_bubble_level(request: Request):
random.shuffle(all_parts)
# 🔧 НОВОЕ (14.10.2026): сохраняем состояние уровня для подсказок
# и сбрасываем счётчики подсказок/списка при новом уровне.
level_state = [
{
"word_pl": w["word_pl"],
"translation": w["translation"],
"parts": w["parts"],
}
for w in result_words
]
await conn.execute("""
INSERT INTO bubble_words_progress
(user_id, levels_completed, total_score, level,
current_hints_used, current_list_opened, current_level_words, hinted_words)
VALUES ($1, 0, 0, $2, 0, 0, $3::jsonb, '{}')
ON CONFLICT (user_id) DO UPDATE
SET current_hints_used = 0,
current_list_opened = 0,
current_level_words = $3::jsonb,
hinted_words = '{}'
""", telegram_id, current_level, json.dumps(level_state))
return {
"words": result_words,
"bubbles": all_parts,
"level": current_bubble_level,
"difficulty": user["difficulty"] or "medium",
}
@router.post("/first-part-hint")
async def first_part_hint(request: Request):
"""Подсказка «первая часть слова» — возвращает первый пузырь одного из несобранных слов.
🔧 НОВОЕ (14.10.2026): аналог GET /hints/first-letter/{level_id} из филворда.
Лимит 3 подсказки, штраф −20 (учитывается в /complete через current_hints_used).
Hard — запрещено (400).
"""
telegram_id, _ = await require_auth(request)
body = await request.json()
found_words = set(body.get("found_words", []) or [])
pool = await get_pool()
async with pool.acquire() as conn:
user = await conn.fetchrow(
"SELECT difficulty FROM users WHERE telegram_id = $1", telegram_id
)
if not user:
raise HTTPException(401, "User not registered")
difficulty = user["difficulty"] or "medium"
if difficulty == "hard":
raise HTTPException(400, "Hints are disabled on Hard difficulty")
progress = await conn.fetchrow(
"SELECT current_hints_used, current_level_words, hinted_words "
"FROM bubble_words_progress WHERE user_id = $1",
telegram_id
)
if not progress:
raise HTTPException(404, "No active level")
hints_used = progress["current_hints_used"] or 0
if hints_used >= 3:
raise HTTPException(400, "All hints used")
raw = progress["current_level_words"]
if isinstance(raw, str):
level_words = json.loads(raw) if raw else []
else:
level_words = raw or []
raw_hinted = progress["hinted_words"]
if isinstance(raw_hinted, str):
hinted = set(json.loads(raw_hinted)) if raw_hinted else set()
else:
hinted = set(raw_hinted or [])
# Слова, которые ещё не собраны и которым ещё не давали подсказку
candidates = [
w for w in level_words
if w.get("word_pl") not in found_words and w.get("word_pl") not in hinted
]
if not candidates:
raise HTTPException(400, "All words already hinted")
chosen = random.choice(candidates)
word_pl = chosen["word_pl"]
parts = chosen.get("parts") or []
first_part = parts[0] if parts else word_pl
new_hints = hints_used + 1
new_hinted = sorted(hinted | {word_pl})
await conn.execute("""
UPDATE bubble_words_progress
SET current_hints_used = $2,
hinted_words = $3
WHERE user_id = $1
""", telegram_id, new_hints, new_hinted)
return {
"word_pl": word_pl,
"first_part": first_part,
"hints_used_total": new_hints,
}
@router.post("/show-words")
async def show_words(request: Request):
"""Подсказка «показать слова» — возвращает все загаданные слова с переводами.
🔧 НОВОЕ (14.10.2026): аналог show-words из филворда.
Easy — без лимита. Medium — 1 раз (−20). Hard — запрещено (400).
"""
telegram_id, _ = await require_auth(request)
pool = await get_pool()
async with pool.acquire() as conn:
user = await conn.fetchrow(
"SELECT difficulty FROM users WHERE telegram_id = $1", telegram_id
)
if not user:
raise HTTPException(401, "User not registered")
difficulty = user["difficulty"] or "medium"
if difficulty == "hard":
raise HTTPException(400, "Word list is disabled on Hard difficulty")
progress = await conn.fetchrow(
"SELECT current_list_opened, current_level_words "
"FROM bubble_words_progress WHERE user_id = $1",
telegram_id
)
if not progress:
raise HTTPException(404, "No active level")
list_opened = progress["current_list_opened"] or 0
# Medium — список можно открыть только 1 раз
if difficulty == "medium" and list_opened >= 1:
raise HTTPException(400, "Word list already used on Medium difficulty")
raw = progress["current_level_words"]
if isinstance(raw, str):
level_words = json.loads(raw) if raw else []
else:
level_words = raw or []
words = [
{"word_pl": w.get("word_pl"), "translation": w.get("translation")}
for w in level_words
]
# Инкремент счётчика для Easy и Medium (Hard сюда не доходит)
new_list_opened = list_opened + 1
await conn.execute("""
UPDATE bubble_words_progress
SET current_list_opened = $2
WHERE user_id = $1
""", telegram_id, new_list_opened)
return {
"words": words,
"list_opened_total": new_list_opened,
}
@router.post("/complete")
async def complete_bubble_level(request: Request):
"""Завершение уровня пузырей, начисление очков и проверка достижений"""
"""Завершение уровня пузырей, начисление XP и проверка достижений.
🔧 НОВОЕ (08.10.2026): XP-система.
Штрафы:
-1 за открытие списка слов (один раз за уровень)
-1 за каждое неправильно собранное слово (макс 3)
-1 если time_ms > 60 сек
Минимум 1 звезда.
"""
telegram_id, _ = await require_auth(request)
body = await request.json()
words_count = body.get("words_count", 3)
completion_time = body.get("completion_time")
# 🔧 ФИКС (24.09.2026): client_controlled_hints_bubblewords —
# hints_used больше НЕ берём от клиента. Читаем из bubble_words_progress.current_hints_used.
wrong_words = int(body.get("wrong_words", 0) or 0)
pool = await get_pool()
async with pool.acquire() as conn:
@@ -189,66 +353,120 @@ async def complete_bubble_level(request: Request):
if not user_exists:
raise HTTPException(401, "User not registered")
# Получаем current_level пользователя
current_level = await conn.fetchval(
"SELECT current_level FROM users WHERE telegram_id = $1", telegram_id
) or "A1"
user = await conn.fetchrow(
"SELECT current_level, difficulty FROM users WHERE telegram_id = $1", telegram_id
)
current_level = user["current_level"] or "A1"
difficulty = user["difficulty"] or "medium"
# 🔧 ФИКС (24.09.2026): client_controlled_hints_bubblewords —
# читаем серверный hints_used.
hints_used = await conn.fetchval(
"SELECT current_hints_used FROM bubble_words_progress WHERE user_id = $1",
# Читаем серверные счётчики (не из body)
progress = await conn.fetchrow(
"SELECT current_hints_used, current_list_opened "
"FROM bubble_words_progress WHERE user_id = $1",
telegram_id
) or 0
)
hints_used = (progress["current_hints_used"] if progress else 0) or 0
hints_used = min(max(0, hints_used), 3)
score = max(10, 100 - hints_used * 10)
list_opened = (progress["current_list_opened"] if progress else 0) or 0
# 🔧 НОВОЕ (14.10.2026): очки по формуле филворда.
# Hard — фикс 110. Easy/Medium — 100 − 20×hints − 20×list + bonus.
if difficulty == "hard":
if hints_used > 0 or list_opened:
raise HTTPException(
status_code=400,
detail="Hints and word list are disabled on Hard difficulty"
)
points = 110
else:
bonus = 10 if hints_used == 0 else 0
penalty_hints = 20 * hints_used
penalty_list = 0 if difficulty == "easy" else 20 * (1 if list_opened else 0)
points = max(20, min(110, 100 - penalty_hints - penalty_list + bonus))
# Начисляем XP
from services.xp import award_xp
xp_result = await award_xp(conn, telegram_id, "bubbles", points)
score = xp_result["points"]
# 🔧 НОВОЕ (15.10.2026): флаги для накопления серий.
no_hints_clean = 1 if (hints_used == 0 and not list_opened) else 0
perfect_clean = 1 if (hints_used == 0 and not list_opened and wrong_words == 0) else 0
await conn.execute("""
INSERT INTO bubble_words_progress (user_id, levels_completed, total_score, level, current_hints_used)
VALUES ($1, 1, $2, $3, 0)
INSERT INTO bubble_words_progress
(user_id, levels_completed, total_score, level,
current_hints_used, current_list_opened, current_level_words, hinted_words,
words_collected, no_hints_streak, perfect_streak)
VALUES ($1, 1, $2, $3, 0, 0, '[]'::jsonb, '{}', $4, $5, $6)
ON CONFLICT (user_id) DO UPDATE
SET levels_completed = bubble_words_progress.levels_completed + 1,
total_score = bubble_words_progress.total_score + $2,
level = $3,
current_hints_used = 0
""", telegram_id, score, current_level)
current_hints_used = 0,
current_list_opened = 0,
current_level_words = '[]'::jsonb,
hinted_words = '{}',
words_collected = COALESCE(bubble_words_progress.words_collected, 0) + $4,
no_hints_streak = CASE WHEN $5 = 1
THEN COALESCE(bubble_words_progress.no_hints_streak, 0) + 1 ELSE 0 END,
perfect_streak = CASE WHEN $6 = 1
THEN COALESCE(bubble_words_progress.perfect_streak, 0) + 1 ELSE 0 END
""", telegram_id, score, current_level, words_count, no_hints_clean, perfect_clean)
# 🔧 ФИКС (23.09.2026): achievements_nested_pool_acquire_bubblewords —
# вызовы достижений вынесены за async with pool.acquire() (паттерн game.py).
# 🔧 НОВОЕ (15.10.2026): читаем актуальные счётчики для проверки достижений.
stats = await conn.fetchrow("""
SELECT words_collected, no_hints_streak, perfect_streak, total_score
FROM bubble_words_progress WHERE user_id = $1
""", telegram_id)
words_collected = stats["words_collected"] or 0
no_hints_streak = stats["no_hints_streak"] or 0
perfect_streak = stats["perfect_streak"] or 0
bubble_total_score = stats["total_score"] or 0
# Данные для достижений
total_levels = await conn.fetchval(
"SELECT levels_completed FROM bubble_words_progress WHERE user_id = $1",
telegram_id
) or 0
wordsearch_score = await conn.fetchval(
"SELECT COALESCE(SUM(score), 0) FROM user_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
telegram_id
) or 0
sentence_score = await conn.fetchval(
"SELECT COALESCE(SUM(score), 0) FROM sentence_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
telegram_id
) or 0
wordquiz_score = await conn.fetchval(
"SELECT COALESCE(total_score, 0) FROM word_quiz_progress WHERE user_id = $1",
telegram_id
) or 0
bubblewords_score = await conn.fetchval(
"SELECT COALESCE(total_score, 0) FROM bubble_words_progress WHERE user_id = $1",
telegram_id
) or 0
grand_total = wordsearch_score + sentence_score + wordquiz_score + bubblewords_score
achievements_to_check = [
("bubble_levels", total_levels),
("total_score", grand_total),
("total_score", xp_result["total_xp"]),
]
if hints_used == 0:
achievements_to_check.append(("bubble_no_hints", 1))
if score == 100:
if hints_used == 0 and not list_opened and wrong_words == 0:
achievements_to_check.append(("bubble_perfect", 1))
if completion_time is not None and completion_time > 0 and int(completion_time) <= 45:
achievements_to_check.append(("bubble_speed", 45))
if completion_time is not None and 0 < completion_time <= 45:
achievements_to_check.append(("bubble_speed_45", 45))
if completion_time is not None and 0 < completion_time <= 30:
achievements_to_check.append(("bubble_speed_30", 30))
# 🔧 ФИКС (23.09.2026): вызовы достижений ВНЕ блока async with pool.acquire()
# 🔧 НОВОЕ (15.10.2026): триггеры новых достижений.
# bubble_words — всего слов собрано
achievements_to_check.append(("bubble_words", words_collected))
# bubble_no_mistakes — уровень без ошибок
if wrong_words == 0:
achievements_to_check.append(("bubble_no_mistakes", 1))
# bubble_streak — серия без подсказок (если > 0)
if no_hints_streak > 0:
achievements_to_check.append(("bubble_streak", no_hints_streak))
# bubble_xp — XP в пузырях (total_score — очки именно пузырей)
achievements_to_check.append(("bubble_xp", bubble_total_score))
# bubble_speed_15 — быстрее 15 сек
if completion_time is not None and 0 < completion_time <= 15:
achievements_to_check.append(("bubble_speed_15", 15))
# bubble_perfect_streak — серия идеальных (если > 0)
if perfect_streak > 0:
achievements_to_check.append(("bubble_perfect_streak", perfect_streak))
# Достижения — вне транзакции
from routers.achievements import check_and_award_achievements
new_achievements = []
for ach_type, value in achievements_to_check:
@@ -260,6 +478,17 @@ async def complete_bubble_level(request: Request):
"score": score,
"completion_time": completion_time,
"new_achievements": new_achievements,
# 🆕 XP-поля
"base_points": xp_result["base_points"],
"multiplier": xp_result["multiplier"],
"points": xp_result["points"],
"featured": xp_result["featured"],
"level_up": xp_result["level_up"],
"total_xp": xp_result["total_xp"],
"level": xp_result["level"],
"rank_key": xp_result["rank_key"],
"xp_in_level": xp_result["xp_in_level"],
"xp_needed": xp_result["xp_needed"],
}
+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/upload-image — загрузить картинку (multipart, до 3 на пост)
- POST /admin/feed/translate — перевести title+body вручную (без сохранения)
- GET /admin/feed/list — список постов для админки (пагинация, все 4 языка)
- GET /admin/feed/stats — быстрая статистика (total/drafts/published/pinned)
Логика локализации:
- В БД хранятся 4 версии поста (title_pl/ru/uk/en, body_pl/ru/uk/en).
@@ -21,9 +23,8 @@ import logging
import json
import re
import uuid
import os
from pathlib import Path
from typing import Optional, Any
from typing import Optional
import httpx
from fastapi import APIRouter, Request, HTTPException, UploadFile, File, Form
@@ -45,7 +46,7 @@ logger = logging.getLogger(__name__)
router = APIRouter(tags=["feed"])
TOGETHER_API_URL = "https://api.together.xyz/v1/chat/completions"
TRANSLATE_MODEL = "MiniMaxAI/MiniMax-M3"
TRANSLATE_MODEL = "deepseek-ai/DeepSeek-V4-Pro-0813"
# 🔧 ФИКС: бэк отдаёт полный URL картинки, чтобы фронт не гадал,
# куда склеивать относительный путь /uploads/feed/...
@@ -252,7 +253,7 @@ async def translate_to_all_languages(
{"role": "system", "content": system_prompt},
{"role": "user", "content": user_prompt},
],
"max_tokens": 2000,
"max_tokens": 4000,
"temperature": 0.3,
},
)
@@ -322,7 +323,7 @@ async def admin_create_feed_post(request: Request):
"expires_at": "2026-10-15T23:59:59Z" (опционально, для partners)
}
Backend автоматически переведёт title/body на 4 языка через MiniMax-M3.
Backend автоматически переведёт title/body на 4 языка через DeepSeek V4 Pro.
Если перевод упал — сохраняем source_language для всех языков (fallback).
"""
telegram_id, _ = await require_auth(request)
@@ -789,3 +790,176 @@ async def admin_translate_feed(request: Request):
raise HTTPException(500, "Translation failed (AI unavailable or invalid response)")
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),
}
+516 -39
View File
@@ -13,7 +13,8 @@ async def get_progress(request: Request):
pool = await get_pool()
async with pool.acquire() as conn:
user = await conn.fetchrow(
"SELECT last_completed_level, current_level FROM users WHERE telegram_id = $1",
"""SELECT last_completed_level, current_level, last_completed_by_level
FROM users WHERE telegram_id = $1""",
telegram_id
)
@@ -26,6 +27,12 @@ async def get_progress(request: Request):
current_level = user["current_level"] or "A1"
# 🔧 ОБНОВЛЕНО (07.10.2026): единый счётчик progress.
# Раньше возвращали last_completed_for_current из per-level JSONB,
# но уровни теперь глобальные (level = 'common').
# Возвращаем users.last_completed_level — единый глобальный прогресс.
last_completed = user["last_completed_level"] or 0
# Очки из филвордов
wordsearch_score = await conn.fetchval(
"SELECT COALESCE(SUM(score), 0) FROM user_progress WHERE user_id = $1",
@@ -53,7 +60,7 @@ async def get_progress(request: Request):
total_score = (wordsearch_score or 0) + (sentence_score or 0) + (wordquiz_score or 0) + (bubblewords_score or 0)
return {
"last_completed_level": user["last_completed_level"] or 0,
"last_completed_level": last_completed,
"total_score": total_score,
"current_level": current_level
}
@@ -66,7 +73,7 @@ async def get_level(request: Request, level_number: int):
pool = await get_pool()
async with pool.acquire() as conn:
user = await conn.fetchrow(
"SELECT app_language, current_level, last_completed_level FROM users WHERE telegram_id = $1", telegram_id
"SELECT app_language, current_level, last_completed_level, last_completed_by_level, difficulty FROM users WHERE telegram_id = $1", telegram_id
)
if not user:
@@ -74,20 +81,43 @@ async def get_level(request: Request, level_number: int):
lang = user["app_language"] or "pl"
current_level = user["current_level"] or "A1"
# 🔧 ОБНОВЛЕНО (07.10.2026): единый счётчик (без per-level).
# Уровни глобальные (level = 'common'), поэтому прогресс —
# users.last_completed_level. last_completed_by_level оставлен
# в БД для совместимости, но больше не используется здесь.
last_completed = user["last_completed_level"] or 0
# Проверяем, что уровень доступен (не дальше следующего за пройденным)
if level_number > 1 and level_number > last_completed + 1:
raise HTTPException(403, "Level not available yet. Complete previous level first.")
# Получаем уровень по его номеру ВНУТРИ выбранного уровня
level = await conn.fetchrow(
"SELECT * FROM levels WHERE level = $1 AND level_number = $2", current_level, level_number
)
# 🔧 ОБНОВЛЕНО (07.10.2026): все уровни — common (автогенерированные).
# Ищем по level_number без created_by и без current_level.
# is_active = TRUE — чтобы черновики не показывались.
level = await conn.fetchrow("""
SELECT * FROM levels
WHERE level_number = $1
AND is_active = TRUE
LIMIT 1
""", level_number)
if not level:
raise HTTPException(404, "Level not found")
# 🔧 ФИКС (10.10.2026): доступ к уровню по user_seen_levels.
# Раньше проверяли level_number > last_completed + 1 — это ломало
# волновую выдачу, где уровни идут вперемешку (5×5 → 6×6 → ...).
# Теперь уровень доступен, если игрок получил его через /game/next
# (есть в user_seen_levels) или уже прошёл (completed_at IS NOT NULL).
# Проверка идёт ПОСЛЕ загрузки уровня, т.к. нужен level["id"].
already_completed = await conn.fetchval(
"SELECT 1 FROM user_progress WHERE user_id = $1 AND level_id = $2 AND completed_at IS NOT NULL",
telegram_id, level["id"]
)
seen = await conn.fetchval(
"SELECT 1 FROM user_seen_levels WHERE user_id = $1 AND level_id = $2",
telegram_id, level["id"]
)
if not seen and not already_completed:
raise HTTPException(403, "Level not available. Get it via /game/next.")
words = await conn.fetch(
"SELECT * FROM level_words WHERE level_id = $1", level["id"]
)
@@ -97,12 +127,43 @@ async def get_level(request: Request, level_number: int):
telegram_id, level["id"],
)
# 🔧 ФИКС (10.10.2026): wave_off_by_one —
# wave/pos хранятся в момент выдачи. Если NULL — fallback.
wave_pos = await conn.fetchrow(
"SELECT current_wave, current_position_in_wave FROM user_game_progress WHERE user_id = $1",
telegram_id,
)
if wave_pos and wave_pos["current_wave"] and wave_pos["current_position_in_wave"]:
current_wave = int(wave_pos["current_wave"])
current_pos = int(wave_pos["current_position_in_wave"])
else:
global_level = await conn.fetchval(
"SELECT global_level_number FROM user_game_progress WHERE user_id = $1",
telegram_id,
)
global_level = int(global_level or 1)
from services.waves import wave_for_level, level_in_wave
current_wave = wave_for_level(global_level)
current_pos = level_in_wave(global_level)
# 🔧 ОБНОВЛЕНО (09.10.2026): отдаём ВСЕ 4 перевода.
# Flutter сам выбирает, какой показать по context.lang.
# Старое поле 'translation' оставлено для совместимости (legacy).
word_list = []
for w in words:
translation = w.get(f"translation_{lang}", "") or w.get("translation_pl", "") or w.get("translation_en", "")
legacy_translation = (
w.get(f"translation_{lang}", "")
or w.get("translation_en", "")
or ""
)
word_list.append({
"word_pl": w["word_pl"],
"translation": translation,
# Legacy (для старого Flutter)
"translation": legacy_translation,
# 🆕 Все переводы (Flutter сам выбирает)
"translation_ru": w.get("translation_ru") or "",
"translation_uk": w.get("translation_uk") or "",
"translation_en": w.get("translation_en") or "",
})
grid_letters = level["grid_letters"]
@@ -113,6 +174,22 @@ async def get_level(request: Request, level_number: int):
if isinstance(word_paths, str):
word_paths = json.loads(word_paths)
# 🔧 ФИКС (25.09.2026): completed_detects_hint_row —
# раньше completed = progress is not None. Но hints.py создаёт
# строку при подсказке (score=0, completed_at=NULL) — это НЕ завершение.
# Теперь: completed = completed_at IS NOT NULL OR score > 0.
is_completed = (
progress is not None
and (
progress["completed_at"] is not None
or (progress["score"] or 0) > 0
)
)
# 🔧 ФИКС (10.10.2026): wave/pos из зафиксированных значений.
wave = current_wave
pos_in_wave = current_pos
return {
"level": {
"id": level["id"],
@@ -124,10 +201,14 @@ async def get_level(request: Request, level_number: int):
},
"words": word_list,
"progress": {
"completed": progress is not None,
"completed": is_completed,
"hints_used": progress["hints_used"] if progress else 0,
"score": progress["score"] if progress else 0,
},
# 🆕 (10.10.2026): волна и позиция в волне.
"wave": wave,
"position_in_wave": pos_in_wave,
"difficulty": user["difficulty"] or "medium",
}
@@ -172,8 +253,18 @@ async def check_word(request: Request):
continue
selected_word = selected_word.lower()
for word in word_paths.keys():
if word.lower() == selected_word:
# 🔧 ФИКС (11.10.2026): word_matched_by_letters_only —
# раньше слово зачислялось только по буквам. Если те же буквы
# встречаются в другом месте сетки (например NOS вверху и внизу),
# сервер зачислял слово, хотя игрок собрал его не там.
# Теперь проверяем координаты: selected_cells должны точно
# совпасть с word_paths[word].
selected_path = [[int(cell[0]), int(cell[1])] for cell in selected_cells]
for word, path in word_paths.items():
if word.lower() != selected_word:
continue
expected_path = [[int(p[0]), int(p[1])] for p in path]
if selected_path == expected_path:
found_word = word
break
@@ -218,7 +309,7 @@ async def check_word(request: Request):
"new_achievements": new_achievements
}
return {"status": "ok", "found": False, "server_streak": 0}
return {"status": "ok", "found": False, "server_streak": 0, "reason": "wrong_path"}
@router.post("/complete-level")
@@ -255,15 +346,32 @@ async def complete_level(request: Request):
# 🔧 ФИКС (24.09.2026): client_controlled_hints_game —
# hints_used читаем из БД, не доверяем клиенту.
hints_used = 0
# 🔧 НОВОЕ (08.10.2026): XP-система — результат award_xp.
xp_result = None
# 🆕 (11.10.2026): волновые счётчики для достижений.
waves_completed = 0
wordsearch_xp = 0
fast_streak = 0
no_hints_streak = 0
words_found = 0
# 🆕 (13.10.2026): итоги волны для модалки.
wave_completed = False
wave_points = 0
wave_max_points = 0
wave_medal_result = "none"
current_wave = 1
current_position_in_wave = 1
async with pool.acquire() as conn:
user = await conn.fetchrow(
"SELECT id, telegram_id, last_completed_level, current_level FROM users WHERE telegram_id = $1",
"SELECT id, telegram_id, last_completed_level, current_level, difficulty FROM users WHERE telegram_id = $1",
telegram_id
)
if not user:
raise HTTPException(401, "User not registered")
difficulty = user["difficulty"] or "medium"
level = await conn.fetchrow(
"SELECT id, level_number, grid_size, level FROM levels WHERE id = $1", level_id
)
@@ -273,16 +381,32 @@ async def complete_level(request: Request):
current_level_number = level["level_number"]
level_name = level["level"] or "A1"
# Проверяем, что уровень принадлежит текущему уровню пользователя
if level_name != (user["current_level"] or "A1"):
raise HTTPException(403, "This level does not belong to your current level")
# 🔧 ОБНОВЛЕНО (07.10.2026): level = 'common'.
# Уровни глобальные, поэтому убираем проверку «уровень принадлежит
# твоему current_level». Оставляем только проверку прогресса выше.
# (Проверка не твоя-не твоя была актуальна, когда были A1/A2/B1.)
# 🔧 ФИКС (25.09.2026): already_completed_detects_hint_row —
# раньше already_completed = True при ЛЮБОЙ строке user_progress.
# Но hints.py создаёт строку при подсказке (score=0,
# completed_at=NULL) — это НЕ завершение. Тогда complete_level
# считал уровень пройденным и НЕ обновлял last_completed_level.
# Теперь: уже пройден только если completed_at IS NOT NULL
# ИЛИ score > 0.
existing_progress = await conn.fetchrow(
"SELECT score FROM user_progress WHERE user_id = $1 AND level_id = $2",
"SELECT score, completed_at FROM user_progress WHERE user_id = $1 AND level_id = $2",
telegram_id, level_id
)
if existing_progress:
is_really_completed = (
existing_progress is not None
and (
existing_progress["completed_at"] is not None
or (existing_progress["score"] or 0) > 0
)
)
if is_really_completed:
already_completed = True
existing_score = existing_progress["score"]
else:
@@ -293,31 +417,104 @@ async def complete_level(request: Request):
telegram_id, level_id
) or 0
# 🔧 ФИКС (24.09.2026): client_controlled_hints_game —
# читаем hints_used из БД, не доверяем клиенту.
# 🔧 НОВОЕ (08.10.2026): XP-система.
# Читаем hints_used и list_opened из БД (не доверяем клиенту).
hints_used = await conn.fetchval(
"SELECT hints_used FROM user_progress WHERE user_id = $1 AND level_id = $2",
telegram_id, level_id
) or 0
hints_used = min(max(0, hints_used), 3)
score = max(10, 100 - hints_used * 10)
# 🆕 Штрафы (филворд):
# -20 за открытие списка слов (один раз за уровень)
# -20 за каждую подсказку
list_opened = bool(body.get("list_opened", False))
# 🔧 ФИКС (23.09.2026): client_controlled_achievement_values —
# сбрасываем current_streak в 0 при завершении уровня.
await conn.execute(
"""INSERT INTO user_progress (user_id, level_id, completed_at, hints_used, score, level, current_streak)
VALUES ($1, $2, NOW(), $3, $4, $5, 0)""",
telegram_id, level_id, hints_used, score, level_name,
# 🔧 НОВОЕ (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"
)
# Обновляем last_completed_level (максимальный номер пройденного уровня)
await conn.execute(
"""UPDATE users
SET last_completed_level = GREATEST(last_completed_level, $2)
WHERE telegram_id = $1""",
telegram_id, current_level_number,
# Очки в зависимости от сложности
if difficulty == "hard":
# Hard: фикс 110 (без подсказок и списка)
points = 110
else:
# Easy / Medium
bonus = 10 if hints_used == 0 else 0
penalty_hints = 20 * hints_used
penalty_list = 0 if difficulty == "easy" else 20 * (1 if list_opened else 0)
points = max(20, min(110, 100 - penalty_hints - penalty_list + bonus))
# Начисляем XP через единую функцию
from services.xp import award_xp
xp_result = await award_xp(conn, telegram_id, "wordsearch", points)
score = xp_result["points"] # для обратной совместимости
# 🔧 ФИКС (25.09.2026): complete_level_insert_overwrites_hints_used —
# раньше INSERT падал с unique violation, если строка user_progress
# уже была создана hints.py (юзер взял подсказку → уровень не завершится).
# Теперь UPSERT с ON CONFLICT DO UPDATE.
# hints_used уже прочитан из БД выше (не доверяем клиенту).
# 🔧 ФИКС (13.10.2026): wave_off_by_one —
# session_level_number хранит позицию СЛЕДУЮЩЕГО уровня
# (уже увеличенную при выдаче), поэтому модалка волны
# срабатывала на 9-м уровне. Читаем current_wave /
# current_position_in_wave — позицию именно завершаемого уровня.
wave_row = await conn.fetchrow(
"SELECT current_wave, current_position_in_wave FROM user_game_progress WHERE user_id = $1",
telegram_id,
)
if wave_row and wave_row["current_wave"] and wave_row["current_position_in_wave"]:
current_wave = int(wave_row["current_wave"])
current_position_in_wave = int(wave_row["current_position_in_wave"])
else:
# Fallback для старых записей без current_* полей.
global_level = await conn.fetchval(
"SELECT global_level_number FROM user_game_progress WHERE user_id = $1",
telegram_id,
)
global_level = int(global_level or 1)
from services.waves import wave_for_level, level_in_wave
current_wave = wave_for_level(global_level)
current_position_in_wave = level_in_wave(global_level)
await conn.execute("""
INSERT INTO user_progress
(user_id, level_id, completed_at, hints_used, score, level, current_streak, wave)
VALUES ($1, $2, NOW(), $3, $4, $5, 0, $6)
ON CONFLICT (user_id, level_id) DO UPDATE
SET completed_at = NOW(),
hints_used = $3,
score = $4,
level = $5,
current_streak = 0,
wave = $6
""", telegram_id, level_id, hints_used, score, level_name, current_wave)
# 🔧 ОБНОВЛЕНО (07.10.2026): единый счётчик progress.
# Обновляем только users.last_completed_level — глобальный.
# last_completed_by_level (JSONB) остаётся в БД для совместимости,
# но больше не пишется.
await conn.execute("""
UPDATE users
SET last_completed_level = GREATEST(COALESCE(last_completed_level, 0), $2)
WHERE telegram_id = $1
""", telegram_id, current_level_number)
# 🔧 ФИКС (10.10.2026): game_next_reuse_active_level —
# уровень пройден → сбрасываем активный уровень, чтобы
# следующий /game/next выдал новый. Сбрасываем только если
# активный уровень совпадает с завершённым.
await conn.execute("""
UPDATE user_game_progress
SET current_level_id = NULL,
updated_at = NOW()
WHERE user_id = $1 AND current_level_id = $2
""", telegram_id, level_id)
# Собираем данные для достижений внутри блока
levels_completed = await conn.fetchval(
@@ -343,6 +540,49 @@ async def complete_level(request: Request):
) or 0
grand_total = total_score + sentence_score + wordquiz_score + bubblewords_score
# 🆕 (11.10.2026): волновые счётчики.
words_in_level = await conn.fetchval(
"SELECT COUNT(*) FROM level_words WHERE level_id = $1", level_id
) or 0
# Пройдено волн = current_wave - 1; если только что завершили
# 10-й уровень волны — волна пройдена (+1).
waves_completed = current_wave - 1
if current_position_in_wave == 10:
waves_completed += 1
# 🆕 (13.10.2026): итоги волны для модалки.
from services.waves import max_points_for_wave, wave_medal
wave_completed = (current_position_in_wave == 10)
wave_points = await conn.fetchval(
"SELECT COALESCE(SUM(score), 0) FROM user_progress WHERE user_id = $1 AND wave = $2",
telegram_id, current_wave,
) or 0
wave_max_points = max_points_for_wave()
wave_medal_result = wave_medal(wave_points, wave_max_points)
# XP филворда = сумма score по user_progress (уже посчитана как total_score).
wordsearch_xp = total_score
# Обновляем счётчики серий.
is_fast = completion_time is not None and int(completion_time) <= 30
await conn.execute("""
UPDATE user_game_progress
SET fast_streak = CASE WHEN $2 THEN COALESCE(fast_streak, 0) + 1 ELSE 0 END,
no_hints_streak = CASE WHEN $3 THEN COALESCE(no_hints_streak, 0) + 1 ELSE 0 END,
words_found = COALESCE(words_found, 0) + $4,
updated_at = NOW()
WHERE user_id = $1
""", telegram_id, is_fast, hints_used == 0, words_in_level)
counters = await conn.fetchrow(
"SELECT fast_streak, no_hints_streak, words_found FROM user_game_progress WHERE user_id = $1",
telegram_id,
)
fast_streak = int(counters["fast_streak"] or 0) if counters else 0
no_hints_streak = int(counters["no_hints_streak"] or 0) if counters else 0
words_found = int(counters["words_found"] or 0) if counters else 0
# Если уровень уже был пройден — просто возвращаем результат
if already_completed:
return {
@@ -377,9 +617,246 @@ async def complete_level(request: Request):
ach = await check_and_award_achievements(telegram_id, "perfect_words", server_perfect_streak)
new_achievements.extend(ach)
# 🆕 (11.10.2026): волновые достижения.
ach = await check_and_award_achievements(telegram_id, "waves_completed", waves_completed)
new_achievements.extend(ach)
ach = await check_and_award_achievements(telegram_id, "wordsearch_xp", wordsearch_xp)
new_achievements.extend(ach)
if fast_streak >= 3:
ach = await check_and_award_achievements(telegram_id, "ws_speed_run", fast_streak)
new_achievements.extend(ach)
if no_hints_streak >= 10:
ach = await check_and_award_achievements(telegram_id, "ws_no_hints_streak", no_hints_streak)
new_achievements.extend(ach)
if words_found >= 1000:
ach = await check_and_award_achievements(telegram_id, "wordsearch_words", words_found)
new_achievements.extend(ach)
return {
"status": "ok",
"score": score,
"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,
}
+53 -49
View File
@@ -1,3 +1,5 @@
import random
from fastapi import APIRouter, Request, HTTPException
from auth import require_auth
from database import get_pool
@@ -6,7 +8,7 @@ router = APIRouter(prefix="/hints", tags=["hints"])
@router.get("/first-letter/{level_id}")
async def get_first_letter_hint(request: Request, level_id: int):
async def get_first_letter_hint(request: Request, level_id: int, found: str = ""):
"""Подсказка: показывает первую букву случайного ненайденного слова"""
telegram_id, _ = await require_auth(request)
@@ -48,43 +50,54 @@ async def get_first_letter_hint(request: Request, level_id: int):
if not words:
raise HTTPException(404, "No words found for this level")
# Теперь безопасно инкрементим счётчик
if progress:
await conn.execute(
"UPDATE user_progress SET hints_used = hints_used + 1 WHERE user_id = $1 AND level_id = $2",
telegram_id, level_id
)
else:
await conn.execute(
"INSERT INTO user_progress (user_id, level_id, hints_used) VALUES ($1, $2, 1)",
telegram_id, level_id
)
hints_already_used += 1
word_paths = level["word_paths"]
if isinstance(word_paths, str):
import json
word_paths = json.loads(word_paths)
# Находим первое слово, у которого есть путь
# Слова уровня, у которых есть путь в word_paths
all_level_words = [w["word_pl"] for w in words]
words_with_paths = [
w for w in all_level_words
if w in word_paths and word_paths[w]
]
# Ищем слово с путём (сначала основные, потом filler-слова)
found_word = None
first_cell = None
for word in all_level_words:
if word in word_paths and word_paths[word]:
found_word = word
first_cell = word_paths[word][0]
break
# 🔧 ФИКС (25.09.2026): hint_fake_first_cell —
# если ни у одного слова нет пути в word_paths, подсказка
# бессмысленна. Возвращаем 404, а не фейковую координату [0,0].
if not found_word:
if not words_with_paths:
raise HTTPException(404, "No word paths found for this level")
# 🔧 ФИКС (12.10.2026): hint_shows_found_word —
# подсказка показывала уже найденное слово. Теперь фронт передаёт
# найденные слова в query-параметре found (через запятую), и мы
# исключаем их из кандидатов.
found_words = {w.strip() for w in found.split(",") if w.strip()}
remaining_words = [w for w in words_with_paths if w not in found_words]
if not remaining_words:
raise HTTPException(404, "All words found")
# 🔧 ФИКС (11.10.2026): hint_always_first_word —
# раньше всегда возвращалось первое слово списка, поэтому
# повторные нажатия давали одну и ту же букву. Теперь слово
# выбирается случайно из ещё не найденных.
found_word = random.choice(remaining_words)
first_cell = word_paths[found_word][0]
# 🔧 ФИКС (25.09.2026): hint_consumed_before_word_paths_check —
# инкрементим hints_used ТОЛЬКО после всех проверок.
# Раньше при 404 (нет word_paths) подсказка уже была потрачена.
#
# 🔧 ФИКС (25.09.2026): hints_used_never_incremented_actually —
# раньше при отсутствии строки user_progress UPDATE затрагивал 0 строк,
# и лимит 3 подсказки не работал для новых юзеров.
# Теперь UPSERT: INSERT с ON CONFLICT DO UPDATE.
await conn.execute("""
INSERT INTO user_progress (user_id, level_id, hints_used)
VALUES ($1, $2, 1)
ON CONFLICT (user_id, level_id) DO UPDATE
SET hints_used = user_progress.hints_used + 1
""", telegram_id, level_id)
hints_already_used += 1
return {
"status": "ok",
"word": found_word,
@@ -112,7 +125,7 @@ async def get_word_list(request: Request, level_id: int):
if not user_exists:
raise HTTPException(401, "User not registered")
# Получаем прогресс пользователя
# Получаем прогресс пользователя (для информации в ответе)
progress = await conn.fetchrow(
"SELECT hints_used FROM user_progress WHERE user_id = $1 AND level_id = $2",
telegram_id, level_id
@@ -120,29 +133,20 @@ async def get_word_list(request: Request, level_id: int):
hints_already_used = progress["hints_used"] if progress else 0
# 🔧 ФИКС (23.09.2026): hints_not_incremented — лимит 3 подсказки не работал,
# hints_used никогда не рос. Теперь проверяем лимит и инкрементим в той же транзакции.
MAX_HINTS = 3
if hints_already_used >= MAX_HINTS:
raise HTTPException(403, "Hint limit reached")
if progress:
await conn.execute(
"UPDATE user_progress SET hints_used = hints_used + 1 WHERE user_id = $1 AND level_id = $2",
telegram_id, level_id
)
else:
await conn.execute(
"INSERT INTO user_progress (user_id, level_id, hints_used) VALUES ($1, $2, 1)",
telegram_id, level_id
)
hints_already_used += 1
# Получаем слова
# 🔧 ФИКС (01.10.2026): word_list_is_not_hint —
# «Показать слова» — базовая функция (в UI написано ∞),
# НЕ расходует лимит подсказок и НЕ уменьшает очки.
# Раньше зря инкрементился hints_used → минус 10 очков за уровень.
# Лимит 3 остаётся ТОЛЬКО для «Первой буквы».
words = await conn.fetch(
"SELECT * FROM level_words WHERE level_id = $1 ORDER BY word_pl", level_id
)
if not words:
raise HTTPException(404, "No words found for this level")
# hints_used НЕ инкрементим. hints_already_used читаем из БД для информации.
# Определяем язык пользователя
user = await conn.fetchrow(
"SELECT app_language FROM users WHERE telegram_id = $1", telegram_id
+176 -103
View File
@@ -10,7 +10,18 @@ LEVELS = ["A1", "A2", "B1", "B2", "C1", "C2"]
@router.get("")
async def get_leaderboard(request: Request, limit: int = 50):
"""Рейтинг игроков — быстрое чтение из кэша"""
"""
Рейтинг игроков.
🔧 ОБНОВЛЕНО (08.10.2026): XP-фундамент.
Сортировка: total_xp DESC → total_score DESC.
weekly_xp в БД остаётся, но больше НЕ используется в сортировке.
Legacy-поля (total_score, wordsearch_score, ...) сохранены для Mini App.
Новые поля в каждой строке: total_xp, level, rank_key, rank_name,
xp_in_level, xp_needed, avatar_id.
"""
telegram_id, _ = await require_auth(request)
if limit < 1:
@@ -28,17 +39,39 @@ async def get_leaderboard(request: Request, limit: int = 50):
current_level = user["current_level"] or "A1"
# Быстрое чтение из MATERIALIZED VIEW
# 🆕 Топ-N: matview + LEFT JOIN user_profile для XP.
# 🔧 ОБНОВЛЕНО (08.10.2026): сортировка по total_xp (weekly_xp убран).
rows = await conn.fetch("""
SELECT * FROM leaderboard_cache
ORDER BY total_score DESC
SELECT
lc.*,
COALESCE(p.weekly_xp, 0) AS weekly_xp,
COALESCE(p.total_xp, 0) AS total_xp,
COALESCE(p.avatar_id, 0) AS avatar_id,
u.app_language
FROM leaderboard_cache lc
LEFT JOIN user_profile p ON p.user_id = lc.telegram_id
LEFT JOIN users u ON u.telegram_id = lc.telegram_id
ORDER BY COALESCE(p.total_xp, 0) DESC,
lc.total_score DESC,
lc.telegram_id ASC
LIMIT $1
""", limit)
leaderboard = []
for i, row in enumerate(rows):
leaderboard.append({
"rank": i + 1,
# Импорт XP-хелперов
from services.xp import level_for, rank_for
def _serialize_row(row, rank_num):
"""Собирает строку рейтинга с legacy + XP-полями."""
weekly_xp = int(row["weekly_xp"] or 0)
total_xp = int(row["total_xp"] or 0)
level, xp_in_level, xp_needed, rank_key = level_for(total_xp)
lang = (row.get("app_language") or "ru").lower()
if lang not in ("pl", "ru", "uk", "en"):
lang = "ru"
return {
# Legacy (Mini App)
"rank": rank_num,
"telegram_id": row["telegram_id"],
"username": row["username"] or f"Player{row['telegram_id']}",
"total_score": row["total_score"],
@@ -50,100 +83,131 @@ async def get_leaderboard(request: Request, limit: int = 50):
"bubble_levels_completed": row["bubble_levels_completed"],
"levels_completed": 0,
"sentences_completed": 0,
})
# 🆕 XP (Pleily)
"weekly_xp": weekly_xp, # оставлен для legacy Mini App
"total_xp": total_xp,
"level": level,
"rank_key": rank_key,
"rank_name": rank_for(level, lang),
"xp_in_level": xp_in_level,
"xp_needed": xp_needed,
"avatar_id": int(row["avatar_id"] or 0),
"app_language": lang,
}
# 🔧 ФИКС (25.09.2026): leaderboard_rank_wrong_for_uncached_user —
# если пользователя нет в leaderboard_cache, подзапрос вернёт NULL,
# и COUNT(*) + 1 = 1 (юзер видит себя первым, хотя у него 0 очков).
# Теперь: если user нет в кэше — считаем его место по количеству
# записей с total_score > 0 + 1 (в конец списка).
my_total_in_cache = await conn.fetchval("""
SELECT total_score FROM leaderboard_cache WHERE telegram_id = $1
""", telegram_id)
leaderboard = [
_serialize_row(row, rank_num=i + 1)
for i, row in enumerate(rows)
]
if my_total_in_cache is None:
# Пользователя нет в кэше — считаем по количеству с > 0
user_rank = await conn.fetchval("""
SELECT COUNT(*) + 1 FROM leaderboard_cache
WHERE total_score > 0
""") or 1
else:
user_rank = await conn.fetchval("""
SELECT COUNT(*) + 1 FROM leaderboard_cache
WHERE total_score > $1
""", my_total_in_cache)
# Персональная статистика пользователя
# ============ Мой ранг ============
# Читаем мои XP + legacy-статистику.
my_row = await conn.fetchrow("""
SELECT * FROM leaderboard_cache WHERE telegram_id = $1
SELECT
lc.*,
COALESCE(p.weekly_xp, 0) AS weekly_xp,
COALESCE(p.total_xp, 0) AS total_xp,
COALESCE(p.avatar_id, 0) AS avatar_id,
u.app_language
FROM leaderboard_cache lc
LEFT JOIN user_profile p ON p.user_id = lc.telegram_id
LEFT JOIN users u ON u.telegram_id = lc.telegram_id
WHERE lc.telegram_id = $1
""", telegram_id)
if my_row:
# Если юзера нет в matview — пробуем только user_profile.
if not my_row:
my_profile = await conn.fetchrow("""
SELECT
p.weekly_xp, p.total_xp, p.avatar_id,
u.username, u.app_language, u.current_level
FROM user_profile p
JOIN users u ON u.telegram_id = p.user_id
WHERE p.user_id = $1
""", telegram_id)
if my_profile:
my_weekly_xp = int(my_profile["weekly_xp"] or 0)
my_total_xp = int(my_profile["total_xp"] or 0)
my_avatar_id = int(my_profile["avatar_id"] or 0)
my_username = my_profile["username"]
my_lang = (my_profile["app_language"] or "ru").lower()
else:
my_weekly_xp = 0
my_total_xp = 0
my_avatar_id = 0
my_username = None
my_lang = "ru"
# 🔧 ОБНОВЛЕНО (08.10.2026): место по total_xp (не weekly_xp).
my_position = await conn.fetchval("""
SELECT COUNT(*) + 1
FROM user_profile
WHERE total_xp > $1
""", my_total_xp) or 1
# Legacy-статистика (для совместимости с Mini App)
my_wordsearch = await conn.fetchval(
"SELECT COALESCE(SUM(score), 0) FROM user_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
telegram_id
) or 0
my_sentence = await conn.fetchval(
"SELECT COALESCE(SUM(score), 0) FROM sentence_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
telegram_id
) or 0
my_wordquiz = await conn.fetchval(
"SELECT COALESCE(total_score, 0) FROM word_quiz_progress WHERE user_id = $1",
telegram_id
) or 0
my_words_guessed = await conn.fetchval(
"SELECT COALESCE(words_guessed, 0) FROM word_quiz_progress WHERE user_id = $1",
telegram_id
) or 0
my_bubblewords = await conn.fetchval(
"SELECT COALESCE(total_score, 0) FROM bubble_words_progress WHERE user_id = $1",
telegram_id
) or 0
my_bubble_levels = await conn.fetchval(
"SELECT COALESCE(levels_completed, 0) FROM bubble_words_progress WHERE user_id = $1",
telegram_id
) or 0
my_total = my_wordsearch + my_sentence + my_wordquiz + my_bubblewords
my_wordsearch_levels = 0
my_sentences_completed = 0
my_avatar_id_final = my_avatar_id
my_username_final = my_username
my_lang_final = my_lang
else:
my_weekly_xp = int(my_row["weekly_xp"] or 0)
my_total_xp = int(my_row["total_xp"] or 0)
my_avatar_id_final = int(my_row["avatar_id"] or 0)
my_username_final = my_row["username"]
my_lang_final = (my_row["app_language"] or "ru").lower()
my_wordsearch = my_row["wordsearch_score"]
my_sentence = my_row["sentence_score"]
my_wordquiz = my_row["wordquiz_score"]
my_words_guessed = my_row["words_guessed"]
my_bubblewords = my_row["bubblewords_score"]
my_bubble_levels = my_row["bubble_levels_completed"]
else:
my_wordsearch = 0
my_sentence = 0
my_wordquiz = 0
my_words_guessed = 0
my_bubblewords = 0
my_bubble_levels = 0
my_total = my_wordsearch + my_sentence + my_wordquiz + my_bubblewords
# 🔧 ОБНОВЛЕНО (08.10.2026): место по total_xp (не weekly_xp).
my_position = await conn.fetchval("""
SELECT COUNT(*) + 1
FROM user_profile
WHERE total_xp > $1
""", my_total_xp) or 1
# Считаем НАПРЯМУЮ из основных таблиц
my_wordsearch_levels = await conn.fetchval(
"SELECT COUNT(DISTINCT level_id) FROM user_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
telegram_id
) or 0
my_sentences_completed = await conn.fetchval(
"SELECT COUNT(*) FROM sentence_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
telegram_id
) or 0
# Если пользователя нет в кэше — считаем очки из основных таблиц
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. Справочники (не зависят от юзера) — одним запросом
# ============ level_stats (legacy для Mini App) ============
ref_row = await conn.fetchrow("""
SELECT
(SELECT COUNT(*) FROM levels WHERE level = 'A1') AS a1_levels,
@@ -160,11 +224,8 @@ async def get_leaderboard(request: Request, limit: int = 50):
(SELECT COUNT(*) FROM sentences WHERE level = 'C2') AS c2_sent
""")
# 2. Очки и прогресс по всем уровням сразу — 4 запроса с GROUP BY
ws_rows = await conn.fetch("""
SELECT level,
COALESCE(SUM(score), 0) AS score,
COUNT(*) AS completed
SELECT level, COALESCE(SUM(score), 0) AS score, COUNT(*) AS completed
FROM user_progress
WHERE user_id = $1 AND completed_at IS NOT NULL
GROUP BY level
@@ -172,9 +233,7 @@ async def get_leaderboard(request: Request, limit: int = 50):
ws_by_level = {r["level"]: r for r in ws_rows}
s_rows = await conn.fetch("""
SELECT level,
COALESCE(SUM(score), 0) AS score,
COUNT(*) AS completed
SELECT level, COALESCE(SUM(score), 0) AS score, COUNT(*) AS completed
FROM sentence_progress
WHERE user_id = $1 AND completed_at IS NOT NULL
GROUP BY level
@@ -183,23 +242,19 @@ async def get_leaderboard(request: Request, limit: int = 50):
wq_rows = await conn.fetch("""
SELECT level, COALESCE(total_score, 0) AS score
FROM word_quiz_progress
WHERE user_id = $1
FROM word_quiz_progress WHERE user_id = $1
""", telegram_id)
wq_by_level = {r["level"]: r for r in wq_rows}
bw_rows = await conn.fetch("""
SELECT level, COALESCE(total_score, 0) AS score
FROM bubble_words_progress
WHERE user_id = $1
FROM bubble_words_progress WHERE user_id = $1
""", telegram_id)
bw_by_level = {r["level"]: r for r in bw_rows}
# 3. Собираем level_stats в Python — без единого запроса
level_stats = {}
for lvl in LEVELS:
lvl_lower = lvl.lower()
ws_score = ws_by_level.get(lvl, {}).get("score", 0) or 0
ws_completed = ws_by_level.get(lvl, {}).get("completed", 0) or 0
s_score = s_by_level.get(lvl, {}).get("score", 0) or 0
@@ -209,7 +264,6 @@ async def get_leaderboard(request: Request, limit: int = 50):
total_ws_levels = ref_row[f"{lvl_lower}_levels"] or 0
total_sentences = ref_row[f"{lvl_lower}_sent"] or 0
total_items = total_ws_levels + total_sentences
completed_items = ws_completed + s_completed
progress_percent = round((completed_items / total_items * 100), 1) if total_items > 0 else 0
@@ -223,15 +277,20 @@ async def get_leaderboard(request: Request, limit: int = 50):
"bubblewords_score": bw_score,
}
# 🔧 ИСПРАВЛЕНО: вызов достижений ВНЕ блока async with pool.acquire()
# Достижения
from routers.achievements import check_and_award_achievements
if my_position <= 3:
await check_and_award_achievements(telegram_id, "rank_reached", my_position)
# ============ Мой ранг (XP) ============
my_level, my_xp_in_level, my_xp_needed, my_rank_key = level_for(my_total_xp)
my_rank_name = rank_for(my_level, my_lang_final)
return {
"leaderboard": leaderboard,
"current_level": current_level,
"my_rank": {
# Legacy
"rank": my_position,
"telegram_id": telegram_id,
"total_score": my_total,
@@ -243,6 +302,17 @@ async def get_leaderboard(request: Request, limit: int = 50):
"words_guessed": my_words_guessed,
"bubblewords_score": my_bubblewords,
"bubble_levels_completed": my_bubble_levels,
# 🆕 XP
"username": my_username_final,
"weekly_xp": my_weekly_xp, # оставлен для legacy Mini App
"total_xp": my_total_xp,
"level": my_level,
"rank_key": my_rank_key,
"rank_name": my_rank_name,
"xp_in_level": my_xp_in_level,
"xp_needed": my_xp_needed,
"avatar_id": my_avatar_id_final,
"app_language": my_lang_final,
},
"level_stats": level_stats,
}
@@ -298,13 +368,16 @@ async def get_admin_stats(request: Request):
WHERE a.code = 'open_teacher_menu'
""") or 0
# Количество пользователей по уровням
level_counts = {}
for lvl in LEVELS:
count = await conn.fetchval(
"SELECT COUNT(*) FROM users WHERE current_level = $1", lvl
) or 0
level_counts[lvl] = count
# 🔧 ФИКС (25.09.2026): leaderboard_admin_stats_n_plus_1 —
# 1 GROUP BY вместо 6 COUNT-запросов.
level_rows = await conn.fetch("""
SELECT current_level, COUNT(*) as cnt
FROM users
WHERE current_level = ANY($1::text[])
GROUP BY current_level
""", LEVELS)
level_map = {r["current_level"]: r["cnt"] for r in level_rows}
level_counts = {lvl: level_map.get(lvl, 0) for lvl in LEVELS}
return {
"total_users": total_users,
+360 -53
View File
@@ -13,7 +13,6 @@ from fastapi import APIRouter, Request, HTTPException
from auth import require_auth
from database import get_pool
from config import TOGETHER_API_KEY
from .learning_data import init_learning_data
from .learning_profile import get_weak_skills, get_strong_skills
logger = logging.getLogger(__name__)
@@ -21,7 +20,7 @@ logger = logging.getLogger(__name__)
router = APIRouter(prefix="/learning", tags=["learning"])
TOGETHER_API_URL = "https://api.together.xyz/v1/chat/completions"
ANALYTICS_MODEL = "MiniMaxAI/MiniMax-M3"
ANALYTICS_MODEL = "deepseek-ai/DeepSeek-V4-Pro-0813"
# Доступные функции приложения (для AI — чтобы не галлюцинировал)
AVAILABLE_FEATURES = [
@@ -444,12 +443,41 @@ async def get_learning_levels(request: Request):
@router.get("/topics")
async def get_topics(request: Request, level: str = "A1"):
"""Получить темы для уровня"""
await require_auth(request)
"""
Получить темы для уровня.
🔧 ОБНОВЛЕНО (04.10.2026): track_filter —
фильтруем темы по языку юзера:
- pl → track='pl'
- ru/uk → track='ru_uk' (общий для славян)
- en → track='en'
"""
telegram_id, _ = await require_auth(request)
pool = await get_pool()
async with pool.acquire() as conn:
rows = await conn.fetch("SELECT * FROM learning_topics WHERE level_code = $1 AND is_active = TRUE ORDER BY order_number", level)
return {"topics": [dict(row) for row in rows]}
# Определяем track из app_language юзера
user_lang = await conn.fetchval(
"SELECT app_language FROM users WHERE telegram_id = $1",
telegram_id,
) or "ru"
if user_lang == "pl":
track = "pl"
elif user_lang == "en":
track = "en"
else:
# ru, uk → общий track
track = "ru_uk"
rows = await conn.fetch("""
SELECT * FROM learning_topics
WHERE level_code = $1
AND is_active = TRUE
AND track = $2
ORDER BY order_number
""", level, track)
return {"topics": [dict(row) for row in rows], "track": track}
@router.get("/topics/{topic_id}")
@@ -574,6 +602,18 @@ async def start_session(request: Request):
pool = await get_pool()
async with pool.acquire() as conn:
# 🔧 ФИКС (25.09.2026): hardcoded_a1_level_from_client —
# клиент присылает 'A1' хардкодом (LessonViewPage, TestViewPage).
# Сервер должен сам достать level_code из темы, а не доверять клиенту.
# Если тема не найдена (например, practice без topic_id) — оставляем
# клиентский level_code как fallback.
if topic_id:
real_level = await conn.fetchval("""
SELECT level_code FROM learning_topics WHERE topic_id = $1
""", topic_id)
if real_level:
level_code = real_level
row = await conn.fetchrow("""
INSERT INTO learning_sessions (user_id, level_code, topic_id, session_type)
VALUES ($1, $2, $3, $4) RETURNING id
@@ -582,9 +622,29 @@ async def start_session(request: Request):
return {"session_id": row["id"]}
# 🔧 ОБНОВЛЕНО (02.10.2026): attempt_number + revised —
# если ученик отвечает на вопрос повторно (после «Повторить урок»),
# создаётся НОВАЯ запись с attempt_number+1, revised=TRUE,
# revision_of_id=предыдущий ответ. История сохраняется полностью.
@router.post("/answer")
async def save_answer(request: Request):
"""Сохранить ответ пользователя"""
"""
Сохранить ответ пользователя.
🔧 ОБНОВЛЕНО (02.10.2026): attempt_number + revised —
если ученик отвечает на вопрос повторно (после «Повторить урок»),
создаётся НОВАЯ запись с attempt_number+1, revised=TRUE,
revision_of_id=предыдущий ответ. История сохраняется полностью.
Возвращает:
{
"correct": bool,
"wrong_because": str | None,
"attempt_number": int, # какая это попытка
"show_correct_answer": bool, # TRUE только если attempt >= 3
"correct_answer": str | None # только при show_correct_answer
}
"""
telegram_id, _ = await require_auth(request)
body = await request.json()
session_id = body.get("session_id")
@@ -592,20 +652,39 @@ async def save_answer(request: Request):
selected_answer = body.get("answer", "")
time_taken_ms = body.get("time_taken_ms", 0)
is_final = body.get("is_final_answer", True)
# 🔧 ФИКС (22.09.2026): раньше hint_used был захардкожен False,
# поэтому подсказки не попадали в аналитику (hint_dependency всегда 0).
hint_used = body.get("hint_used", False)
# 🔧 НОВОЕ: клиент сообщает, что это повторная попытка
is_retry = body.get("is_retry", False)
if not session_id or not question_id:
raise HTTPException(400, "session_id and question_id required")
pool = await get_pool()
async with pool.acquire() as conn:
question = await conn.fetchrow("SELECT * FROM learning_questions WHERE question_id = $1", question_id)
question = await conn.fetchrow(
"SELECT * FROM learning_questions WHERE question_id = $1", question_id
)
if not question:
raise HTTPException(404, "Question not found")
correct = selected_answer.strip().lower() == (question["correct_answer"] or "").strip().lower()
# 🔧 НОВОЕ: считаем текущее количество попыток по этому вопросу в сессии
prev_attempts = await conn.fetch(
"""
SELECT id, attempt_number, correct
FROM user_learning_answers
WHERE session_id = $1 AND question_id = $2
ORDER BY attempt_number ASC
""",
session_id, question_id,
)
next_attempt = (prev_attempts[-1]["attempt_number"] + 1) if prev_attempts else 1
prev_id = prev_attempts[-1]["id"] if prev_attempts else None
correct = (
selected_answer.strip().lower()
== (question["correct_answer"] or "").strip().lower()
)
wrong_because = None
if not correct:
@@ -616,58 +695,212 @@ async def save_answer(request: Request):
if option:
wrong_because = option["wrong_because"]
session = await conn.fetchrow("SELECT * FROM learning_sessions WHERE id = $1", session_id)
# 🔧 ФИКС (23.09.2026): learning_save_answer_missing_session_check —
# раньше при несуществующем session_id падало с TypeError → 500.
# Теперь честная 404 + проверка владельца сессии.
session = await conn.fetchrow(
"SELECT * FROM learning_sessions WHERE id = $1", session_id
)
if not session:
raise HTTPException(404, "Session not found")
if session["user_id"] != telegram_id:
raise HTTPException(403, "Session belongs to another user")
await conn.execute("""
INSERT INTO user_learning_answers (user_id, session_id, level_code, topic_id, lesson_id, question_id, selected_answer, correct, skill_tag, question_type, context_type, difficulty, time_taken_ms, hint_used, wrong_because, is_final_answer)
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16)
""", telegram_id, session_id, session["level_code"], session["topic_id"], question["lesson_id"], question_id, selected_answer, correct, question["skill_tag"], question["question_type"], question["context_type"], question["difficulty"], time_taken_ms, hint_used, wrong_because, is_final)
# 🔧 Логика revised: если это повторная попытка — фиксируем
revised = is_retry or next_attempt > 1
return {"correct": correct, "wrong_because": wrong_because}
# 🔧 is_final_answer: только ПОСЛЕДНЯЯ попытка считается финальной
# (для статистики). Промежуточные — revision-записи, не идут в total.
# Если клиент сказал is_final=False (подсказка) — уважаем.
if is_retry:
# Сначала снимаем флаг is_final_answer у предыдущей записи
await conn.execute(
"""
UPDATE user_learning_answers
SET is_final_answer = FALSE
WHERE session_id = $1 AND question_id = $2
""",
session_id, question_id,
)
await conn.execute(
"""
INSERT INTO user_learning_answers (
user_id, session_id, level_code, topic_id, lesson_id,
question_id, selected_answer, correct, skill_tag,
question_type, context_type, difficulty, time_taken_ms,
attempt_number, hint_used, wrong_because, is_final_answer,
revised, revision_of_id
)
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13,
$14, $15, $16, $17, $18, $19)
""",
telegram_id, session_id, session["level_code"], session["topic_id"],
question["lesson_id"], question_id, selected_answer, correct,
question["skill_tag"], question["question_type"], question["context_type"],
question["difficulty"], time_taken_ms, next_attempt, hint_used,
wrong_because, is_final, revised, prev_id,
)
# 🔧 Решаем, показывать ли правильный ответ
# Первая попытка — НЕ показываем
# Вторая — НЕ показываем
# Третья и выше — показываем
show_correct_answer = next_attempt >= 3
# Правильный ответ — текст варианта (для recognition)
correct_answer_text = None
if show_correct_answer:
correct_option = await conn.fetchrow(
"""
SELECT option_key, text_pl, text_ru, text_uk, text_en
FROM question_options
WHERE question_id = $1 AND is_correct = TRUE
LIMIT 1
""",
question_id,
)
if correct_option:
correct_answer_text = (
f"{correct_option['option_key']} — {correct_option['text_pl']}"
)
else:
# Для production — просто correct_answer из вопроса
correct_answer_text = question["correct_answer"]
return {
"correct": correct,
"wrong_because": wrong_because,
"attempt_number": next_attempt,
"show_correct_answer": show_correct_answer,
"correct_answer": correct_answer_text,
}
# 🔧 ОБНОВЛЕНО (02.10.2026): session_report —
# без AI формируем человеческий отчёт для экрана «Тема пройдена»:
# - total / correct / percent
# - message («Отлично!» / «Стоит повторить»)
# - weak_skills этой темы (с понятными названиями)
# - next_topic
@router.post("/session/complete")
async def complete_session(request: Request):
"""Завершить сессию: обновляет прогресс урока/теста, мастерство навыков, прогресс темы и AI-контекст"""
"""
Завершить сессию: обновляет прогресс, мастерство, AI-контекст
и возвращает отчёт для экрана «Тема пройдена».
🔧 ОБНОВЛЕНО (02.10.2026): session_report —
без AI формируем человеческий отчёт:
- total / correct / percent
- message («Отлично!» / «Стоит повторить»)
- weak_skills этой темы (с понятными названиями)
- next_topic
"""
telegram_id, _ = await require_auth(request)
body = await request.json()
session_id = body.get("session_id")
# 🔧 НОВОЕ: язык для формирования отчёта
lang = body.get("lang", "ru")
pool = await get_pool()
async with pool.acquire() as conn:
session = await conn.fetchrow("SELECT * FROM learning_sessions WHERE id = $1 AND user_id = $2", session_id, telegram_id)
session = await conn.fetchrow(
"SELECT * FROM learning_sessions WHERE id = $1 AND user_id = $2",
session_id, telegram_id,
)
if not session:
raise HTTPException(404, "Session not found")
await conn.execute("UPDATE learning_sessions SET is_completed = TRUE, completed_at = NOW() WHERE id = $1", session_id)
await conn.execute(
"UPDATE learning_sessions SET is_completed = TRUE, completed_at = NOW() WHERE id = $1",
session_id,
)
stats = await conn.fetchrow("""
SELECT COUNT(*) as total, COALESCE(SUM(CASE WHEN correct THEN 1 ELSE 0 END), 0) as correct_count
FROM user_learning_answers WHERE session_id = $1 AND is_final_answer = TRUE
""", session_id)
# 🔧 Считаем только ПОСЛЕДНИЕ (is_final_answer=TRUE) ответы на каждый вопрос
stats = await conn.fetchrow(
"""
WITH last_answers AS (
SELECT DISTINCT ON (question_id) question_id, correct, wrong_because, skill_tag
FROM user_learning_answers
WHERE session_id = $1
ORDER BY question_id, attempt_number DESC
)
SELECT
COUNT(*) AS total,
COALESCE(SUM(CASE WHEN correct THEN 1 ELSE 0 END), 0) AS correct_count
FROM last_answers
""",
session_id,
)
# Слабые навыки этой темы (те, где были ошибки)
weak_rows = await conn.fetch(
"""
WITH last_answers AS (
SELECT DISTINCT ON (question_id) question_id, correct, skill_tag
FROM user_learning_answers
WHERE session_id = $1
ORDER BY question_id, attempt_number DESC
)
SELECT
la.skill_tag,
COUNT(*) FILTER (WHERE NOT la.correct) AS errors,
COALESCE(ll.title_ru, la.skill_tag) AS name_ru,
COALESCE(ll.title_pl, la.skill_tag) AS name_pl,
COALESCE(ll.title_uk, la.skill_tag) AS name_uk,
COALESCE(ll.title_en, la.skill_tag) AS name_en
FROM last_answers la
LEFT JOIN learning_lessons ll ON ll.skill_tag = la.skill_tag
WHERE NOT la.correct
GROUP BY la.skill_tag, ll.title_ru, ll.title_pl, ll.title_uk, ll.title_en
HAVING COUNT(*) FILTER (WHERE NOT la.correct) > 0
ORDER BY errors DESC
LIMIT 5
""",
session_id,
)
# Информация о теме
topic_id = session["topic_id"]
topic_row = await conn.fetchrow(
"SELECT * FROM learning_topics WHERE topic_id = $1", topic_id
)
# Следующая тема того же уровня
next_topic = None
if topic_row:
next_topic = await conn.fetchrow(
"""
SELECT topic_id, name_ru, name_pl, name_uk, name_en
FROM learning_topics
WHERE level_code = $1
AND order_number > $2
AND is_active = TRUE
ORDER BY order_number
LIMIT 1
""",
topic_row["level_code"], topic_row["order_number"],
)
# ============ Обновляем прогресс ============
# (всё что было — оставляем)
# Обновляем прогресс урока
if session["session_type"] == "lesson":
lesson_row = await conn.fetchrow("""
SELECT DISTINCT lesson_id FROM user_learning_answers WHERE session_id = $1 AND lesson_id IS NOT NULL
""", session_id)
lesson_row = await conn.fetchrow(
"""
SELECT DISTINCT lesson_id FROM user_learning_answers
WHERE session_id = $1 AND lesson_id IS NOT NULL
""",
session_id,
)
if lesson_row and lesson_row["lesson_id"]:
lesson_id = lesson_row["lesson_id"]
score = (stats["correct_count"] / stats["total"] * 100) if stats["total"] > 0 else 0
await conn.execute("""
INSERT INTO user_lesson_progress (user_id, lesson_id, started_at, completed_at, attempts_count, correct_count, best_score, completed)
score = (
stats["correct_count"] / stats["total"] * 100
) if stats["total"] > 0 else 0
await conn.execute(
"""
INSERT INTO user_lesson_progress (
user_id, lesson_id, started_at, completed_at,
attempts_count, correct_count, best_score, completed
)
VALUES ($1, $2, NOW(), NOW(), 1, $3, $4, TRUE)
ON CONFLICT (user_id, lesson_id) DO UPDATE
SET completed_at = NOW(),
@@ -675,37 +908,111 @@ async def complete_session(request: Request):
correct_count = user_lesson_progress.correct_count + $3,
best_score = GREATEST(user_lesson_progress.best_score, $4),
completed = TRUE
""", telegram_id, lesson_id, stats["correct_count"], score)
""",
telegram_id, lesson_id, stats["correct_count"], score,
)
# Обновляем прогресс темы если это тест
if session["session_type"] == "topic_test":
test_score = (stats["correct_count"] / stats["total"] * 100) if stats["total"] > 0 else 0
await conn.execute("""
INSERT INTO user_topic_progress (user_id, topic_id, test_started, test_completed, test_score, completed_at)
test_score = (
stats["correct_count"] / stats["total"] * 100
) if stats["total"] > 0 else 0
await conn.execute(
"""
INSERT INTO user_topic_progress (
user_id, topic_id, test_started, test_completed, test_score, completed_at
)
VALUES ($1, $2, TRUE, TRUE, $3, NOW())
ON CONFLICT (user_id, topic_id) DO UPDATE
SET test_completed = TRUE,
test_score = $3,
completed_at = NOW()
""", telegram_id, topic_id, test_score)
# Обновляем мастерство по всем навыкам из этой сессии
skill_tags = await conn.fetch("""
SELECT DISTINCT skill_tag FROM user_learning_answers WHERE session_id = $1
""", session_id)
""",
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,
)
for st in skill_tags:
await update_skill_mastery(conn, telegram_id, st["skill_tag"])
# Обновляем прогресс темы ТОЛЬКО для lesson и topic_test
if session["session_type"] in ("lesson", "topic_test") and topic_id:
await update_topic_progress(conn, telegram_id, topic_id)
# Обновляем AI-контекст (всегда)
await update_ai_context(conn, telegram_id)
return {"status": "ok", "total": stats["total"], "correct_count": stats["correct_count"]}
# ============ Формируем отчёт ============
total = stats["total"] or 0
correct_count = stats["correct_count"] or 0
percent = round(correct_count / total * 100) if total > 0 else 0
# Человеческое сообщение (без AI, чистая математика)
if percent >= 90:
message = {
"ru": "Отлично! Ты прекрасно усвоил тему! 🎉",
"pl": "Świetnie! Doskonale opanowałeś temat! 🎉",
"uk": "Чудово! Ти чудово засвоїв тему! 🎉",
"en": "Excellent! You've mastered this topic! 🎉",
}.get(lang, "Отлично! 🎉")
elif percent >= 75:
message = {
"ru": "Хороший результат! Так держать! 💪",
"pl": "Dobry wynik! Tak trzymaj! 💪",
"uk": "Гарний результат! Так тримати! 💪",
"en": "Good result! Keep it up! 💪",
}.get(lang, "Хороший результат! 💪")
elif percent >= 60:
message = {
"ru": "Неплохо! Но есть над чем поработать.",
"pl": "Nieźle! Ale jest nad czym popracować.",
"uk": "Непогано! Але є над чим попрацювати.",
"en": "Not bad! But there's room to improve.",
}.get(lang, "Неплохо!")
else:
message = {
"ru": "Стоит пройти тему ещё раз — много ошибок.",
"pl": "Warto powtórzyć temat — dużo błędów.",
"uk": "Варто пройти тему ще раз — багато помилок.",
"en": "Worth repeating this topic — many mistakes.",
}.get(lang, "Стоит повторить.")
# Слабые навыки на нужном языке
name_field = f"name_{lang}"
weak_skills_out = []
for w in weak_rows:
weak_skills_out.append({
"skill_tag": w["skill_tag"],
"name": w.get(name_field) or w["name_ru"],
"errors": w["errors"],
})
# Информация о следующей теме
next_out = None
if next_topic:
next_out = {
"topic_id": next_topic["topic_id"],
"name": next_topic.get(name_field) or next_topic["name_ru"],
}
# Название текущей темы
topic_name = None
if topic_row:
topic_name = topic_row.get(name_field) or topic_row["name_ru"]
return {
"status": "ok",
"total": total,
"correct_count": correct_count,
"report": {
"topic_id": topic_id,
"topic_name": topic_name,
"percent": percent,
"message": message,
"weak_skills": weak_skills_out,
"next_topic": next_out,
},
}
@router.get("/progress")
@@ -808,7 +1115,7 @@ async def get_analytics(request: Request):
{"role": "system", "content": system_prompt},
{"role": "user", "content": user_prompt},
],
"max_tokens": 1000,
"max_tokens": 3000,
"temperature": 0.7,
},
)
+45 -4
View File
@@ -1,8 +1,27 @@
"""
Learning Data Package — данные всех уровней.
Каждый уровень в отдельном файле.
🔧 ОБНОВЛЕНО (02.10.2026): seed_data_only_if_empty —
файлы level_*.py остаются в репозитории как АРХИВ,
но при старте бэкенда контент НЕ перезаписывается, если
в БД уже есть данные.
Причины:
- Контент правится через админку → правки в БД.
- Если seed запускать всегда — правки затираются.
- Уровни (learning_levels) гарантированно создаются — они статичны.
Управление:
- Переменная окружения SEED_LEARNING_DATA=true в .env → заливаем файлы.
- По умолчанию false → пропускаем seed, если данные уже есть.
Для fresh install (пустая БД): seed запустится автоматически,
т.к. проверка «learning_topics пуст» проходит.
"""
import logging
import os
from database import get_pool
from . import level_a1, level_a2, level_b1, level_b2, level_c1, level_c2
@@ -10,10 +29,10 @@ logger = logging.getLogger(__name__)
async def init_learning_data():
"""Инициализирует уровни и все темы"""
"""Инициализирует уровни и (опционально) контент из файлов."""
pool = await get_pool()
async with pool.acquire() as conn:
# ============ УРОВНИ ============
# ============ УРОВНИ (всегда, они статичны) ============
levels = [
("A1", "Poziom A1", "Уровень A1", "Рівень A1", "Level A1", 1),
("A2", "Poziom A2", "Уровень A2", "Рівень A2", "Level A2", 2),
@@ -29,7 +48,29 @@ async def init_learning_data():
ON CONFLICT (code) DO NOTHING
""", code, pl, ru, uk, en, sort)
# Загружаем данные каждого уровня
logger.info("[seed] learning_levels ensured (A1-C2)")
# ============ ПРОВЕРКА: нужен ли seed контента? ============
force_seed = os.getenv("SEED_LEARNING_DATA", "false").lower() == "true"
topics_count = await conn.fetchval("""
SELECT COUNT(*) FROM learning_topics
""") or 0
if topics_count > 0 and not force_seed:
logger.info(
f"[seed] learning_topics not empty ({topics_count} topics) — "
f"skipping content seed. Установи SEED_LEARNING_DATA=true в .env "
f"для принудительной перезаливки."
)
return
# ============ SEED КОНТЕНТА (fresh install ИЛИ force) ============
if force_seed:
logger.warning("[seed] SEED_LEARNING_DATA=true — принудительная перезаливка контента")
else:
logger.info("[seed] Empty DB detected — seeding content from level_*.py files")
await level_a1.init_level_a1(conn)
await level_a2.init_level_a2(conn)
await level_b1.init_level_b1(conn)
@@ -37,4 +78,4 @@ async def init_learning_data():
await level_c1.init_level_c1(conn)
await level_c2.init_level_c2(conn)
logger.info("Learning data fully initialized")
logger.info("[seed] Learning content initialized from files")
+390
View File
@@ -0,0 +1,390 @@
"""
Lectures Router — упрощённая версия.
Логика:
- Лекция = файл (PDF/HTML) + уровень + язык.
- Показывается пользователю, если:
- level_code == users.current_level
- lecture_language == users.app_language
- Название = имя файла (без расширения).
"""
import io
import logging
import uuid
from pathlib import Path
from typing import Optional
from fastapi import APIRouter, Request, HTTPException, UploadFile, File, Form
from fastapi.responses import FileResponse
from auth import require_auth
from database import get_pool
from config import ADMIN_IDS, UPLOADS_DIR
logger = logging.getLogger(__name__)
router = APIRouter(tags=["lectures"])
LEVELS = ["A1", "A2", "B1", "B2", "C1", "C2"]
LANGUAGES = ["pl", "ru", "uk", "en"]
ALLOWED_FILE_TYPES = {"pdf", "html", "docx", "txt", "md"}
MAX_FILE_SIZE_BYTES = 20 * 1024 * 1024
def _require_admin(telegram_id: int) -> None:
if telegram_id not in ADMIN_IDS:
raise HTTPException(403, "Access denied")
def _ext_from_filename(filename: str) -> str:
return filename.rsplit(".", 1)[-1].lower() if "." in filename else ""
def _title_from_filename(filename: str) -> str:
"""Убирает расширение + заменяет _ на пробелы."""
name = filename.rsplit(".", 1)[0] if "." in filename else filename
return name.replace("_", " ").strip()
def _extract_pdf_preview(content: bytes, max_lines: int = 15) -> str:
"""Извлекает первые строки текста из PDF."""
try:
import pdfplumber
with pdfplumber.open(io.BytesIO(content)) as pdf:
if not pdf.pages:
return "(PDF без страниц)"
text = pdf.pages[0].extract_text() or ""
lines = [line for line in text.split("\n") if line.strip()][:max_lines]
return "\n".join(lines)
except ImportError:
return "(pdfplumber не установлен на сервере)"
except Exception as e:
logger.error(f"PDF preview error: {e}")
return f"(не удалось извлечь текст: {e})"
def _extract_text_preview(content: bytes, max_chars: int = 800) -> str:
"""Извлекает первые символы из HTML/TXT/MD."""
try:
text = content.decode("utf-8", errors="ignore")
return text[:max_chars]
except Exception as e:
return f"(не удалось прочитать: {e})"
# ============ ПУБЛИЧНЫЕ ============
@router.get("/learning/lectures")
async def get_lectures(request: Request, level: Optional[str] = None):
"""Список лекций для уровня пользователя + его языка."""
telegram_id, _ = await require_auth(request)
pool = await get_pool()
async with pool.acquire() as conn:
user = await conn.fetchrow(
"SELECT current_level, app_language FROM users WHERE telegram_id = $1",
telegram_id,
)
if not level or level not in LEVELS:
level = (user["current_level"] if user else None) or "A1"
if level not in LEVELS:
level = "A1"
user_lang = (user["app_language"] if user else None) or "ru"
if user_lang not in LANGUAGES:
user_lang = "ru"
rows = await conn.fetch("""
SELECT id, level_code, lecture_language,
file_path, file_type, file_size_bytes,
order_number, created_at
FROM lectures
WHERE level_code = $1
AND lecture_language = $2
AND is_active = TRUE
ORDER BY order_number ASC, id ASC
""", level, user_lang)
return {
"level": level,
"language": user_lang,
"lectures": [
{
"id": r["id"],
"level_code": r["level_code"],
"lecture_language": r["lecture_language"],
"title": _title_from_filename(Path(r["file_path"]).name),
"file_type": r["file_type"],
"file_size_kb": round((r["file_size_bytes"] or 0) / 1024, 1),
"file_url": r["file_path"],
"order_number": r["order_number"],
"created_at": r["created_at"].isoformat() if r["created_at"] else None,
}
for r in rows
],
}
@router.get("/learning/lecture/{lecture_id}")
async def get_lecture(request: Request, lecture_id: int):
"""Метаданные одной лекции."""
await require_auth(request)
pool = await get_pool()
async with pool.acquire() as conn:
row = await conn.fetchrow("""
SELECT id, level_code, lecture_language,
file_path, file_type, file_size_bytes, order_number
FROM lectures
WHERE id = $1 AND is_active = TRUE
""", lecture_id)
if not row:
raise HTTPException(404, "Lecture not found")
return {
"id": row["id"],
"level_code": row["level_code"],
"lecture_language": row["lecture_language"],
"title": _title_from_filename(Path(row["file_path"]).name),
"file_type": row["file_type"],
"file_size_kb": round((row["file_size_bytes"] or 0) / 1024, 1),
"file_url": row["file_path"],
"order_number": row["order_number"],
}
@router.get("/learning/lecture/{lecture_id}/download")
async def download_lecture(request: Request, lecture_id: int):
"""Скачать файл лекции."""
await require_auth(request)
pool = await get_pool()
async with pool.acquire() as conn:
row = await conn.fetchrow("""
SELECT file_path, file_type
FROM lectures
WHERE id = $1 AND is_active = TRUE
""", lecture_id)
if not row:
raise HTTPException(404, "Lecture not found")
rel_path = row["file_path"].replace("/uploads/", "", 1).lstrip("/")
abs_path = Path(UPLOADS_DIR) / rel_path
if not abs_path.exists():
raise HTTPException(404, "File not found on disk")
return FileResponse(
path=str(abs_path),
filename=Path(row["file_path"]).name,
media_type="application/octet-stream",
)
# ============ АДМИНСКИЕ ============
@router.get("/admin/lectures/list")
async def admin_list_lectures(
request: Request,
level: Optional[str] = None,
lecture_language: Optional[str] = None,
):
"""Список всех лекций для админки."""
telegram_id, _ = await require_auth(request)
_require_admin(telegram_id)
pool = await get_pool()
async with pool.acquire() as conn:
conditions = ["is_active = TRUE"]
params = []
idx = 1
if level and level in LEVELS:
conditions.append(f"level_code = ${idx}")
params.append(level)
idx += 1
if lecture_language and lecture_language in LANGUAGES:
conditions.append(f"lecture_language = ${idx}")
params.append(lecture_language)
idx += 1
where = " AND ".join(conditions)
rows = await conn.fetch(f"""
SELECT id, level_code, lecture_language,
file_path, file_type, file_size_bytes, order_number, created_at
FROM lectures
WHERE {where}
ORDER BY level_code, order_number, id
""", *params)
return {
"total": len(rows),
"lectures": [
{
"id": r["id"],
"level_code": r["level_code"],
"lecture_language": r["lecture_language"],
"title": _title_from_filename(Path(r["file_path"]).name),
"file_type": r["file_type"],
"file_size_kb": round((r["file_size_bytes"] or 0) / 1024, 1),
"file_url": r["file_path"],
"order_number": r["order_number"],
"created_at": r["created_at"].isoformat() if r["created_at"] else None,
}
for r in rows
],
}
@router.post("/admin/lectures/preview")
async def admin_lecture_preview(
request: Request,
file: UploadFile = File(...),
):
"""Превью файла лекции — первые строки текста."""
telegram_id, _ = await require_auth(request)
_require_admin(telegram_id)
content = await file.read()
if len(content) == 0:
raise HTTPException(400, "Empty file")
ext = _ext_from_filename(file.filename or "")
if ext == "pdf":
preview_text = _extract_pdf_preview(content)
elif ext in ("html", "txt", "md"):
preview_text = _extract_text_preview(content)
else:
preview_text = f"(превью недоступно для формата .{ext})"
return {
"file_name": file.filename or "unknown",
"file_type": ext,
"file_size_kb": round(len(content) / 1024, 1),
"preview": preview_text[:1500],
}
@router.post("/admin/lectures/upload")
async def admin_upload_lecture(
request: Request,
level_code: str = Form(...),
lecture_language: str = Form("ru"),
order_number: int = Form(0),
file: UploadFile = File(...),
):
"""Загрузить лекцию (файл + уровень + язык)."""
telegram_id, _ = await require_auth(request)
_require_admin(telegram_id)
if level_code not in LEVELS:
raise HTTPException(400, f"Invalid level_code: {level_code}")
if lecture_language not in LANGUAGES:
raise HTTPException(400, f"Invalid lecture_language: {lecture_language}")
ext = _ext_from_filename(file.filename or "")
if ext not in ALLOWED_FILE_TYPES:
raise HTTPException(400, f"Invalid file type: {ext}")
content = await file.read()
if len(content) == 0:
raise HTTPException(400, "Empty file")
if len(content) > MAX_FILE_SIZE_BYTES:
raise HTTPException(400, f"File too large. Max: {MAX_FILE_SIZE_BYTES}")
lectures_dir = Path(UPLOADS_DIR) / "lectures"
lectures_dir.mkdir(parents=True, exist_ok=True)
original_name = (file.filename or "lecture").rsplit(".", 1)[0]
safe_name = "".join(c if c.isalnum() or c in "-_" else "_" for c in original_name)[:50]
filename = f"{level_code}_{lecture_language}_{safe_name}_{uuid.uuid4().hex[:8]}.{ext}"
file_path_disk = lectures_dir / filename
file_path_disk.write_bytes(content)
public_path = f"/uploads/lectures/{filename}"
pool = await get_pool()
async with pool.acquire() as conn:
row = await conn.fetchrow("""
INSERT INTO lectures
(level_code, lecture_language, display_language,
title_pl, file_path, file_type, file_size_bytes,
order_number, is_active)
VALUES ($1, $2, $2, $3, $4, $5, $6, $7, TRUE)
RETURNING id
""",
level_code,
lecture_language,
_title_from_filename(file.filename or "lecture"),
public_path,
ext,
len(content),
order_number,
)
logger.info(f"Lecture uploaded: #{row['id']} [{level_code}/{lecture_language}]")
return {"status": "ok", "lecture_id": row["id"]}
@router.put("/admin/lectures/{lecture_id}")
async def admin_update_lecture(request: Request, lecture_id: int):
"""Обновить метаданные лекции."""
telegram_id, _ = await require_auth(request)
_require_admin(telegram_id)
body = await request.json()
pool = await get_pool()
async with pool.acquire() as conn:
existing = await conn.fetchrow("SELECT id FROM lectures WHERE id = $1", lecture_id)
if not existing:
raise HTTPException(404, "Lecture not found")
await conn.execute("""
UPDATE lectures
SET lecture_language = COALESCE($1, lecture_language),
display_language = COALESCE($1, display_language),
order_number = COALESCE($2, order_number),
is_active = COALESCE($3, is_active),
edited_at = NOW()
WHERE id = $4
""",
body.get("lecture_language"),
body.get("order_number"),
body.get("is_active"),
lecture_id,
)
return {"status": "ok", "lecture_id": lecture_id}
@router.delete("/admin/lectures/{lecture_id}")
async def admin_delete_lecture(request: Request, lecture_id: int):
"""Удалить лекцию."""
telegram_id, _ = await require_auth(request)
_require_admin(telegram_id)
pool = await get_pool()
async with pool.acquire() as conn:
row = await conn.fetchrow("SELECT file_path FROM lectures WHERE id = $1", lecture_id)
if not row:
raise HTTPException(404, "Lecture not found")
await conn.execute("DELETE FROM lectures WHERE id = $1", lecture_id)
rel_path = row["file_path"].replace("/uploads/", "", 1).lstrip("/")
abs_path = Path(UPLOADS_DIR) / rel_path
try:
if abs_path.exists():
abs_path.unlink()
except Exception as e:
logger.error(f"Failed to delete file: {e}")
return {"status": "ok", "lecture_id": lecture_id}
+45 -11
View File
@@ -6,6 +6,9 @@ Orchestrator — мозг чат-учителя.
3. Иначе → следующий урок по порядку
Никакого AI — только детерминированная логика.
🔧 ОБНОВЛЕНО (04.10.2026): track_filter —
учитель уважает аудиторию юзера (pl / ru_uk / en).
"""
import logging
from typing import Optional, Dict, Any
@@ -24,6 +27,14 @@ async def get_next_lesson(conn, user_id: int) -> Dict[str, Any]:
"reason": str,
"skill_tag": str | None
}
🔧 ОБНОВЛЕНО (04.10.2026): track_filter —
учитель уважает аудиторию юзера:
- pl → track='pl'
- ru/uk → track='ru_uk'
- en → track='en'
Все SQL-запросы фильтруют по track, чтобы не подсовывать
RU/UK-уроки польскому или английскому юзеру.
"""
# Получаем текущий уровень пользователя
@@ -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
""", user_id) or "A1"
# 🔧 НОВОЕ (04.10.2026): track_filter —
# определяем track по app_language юзера.
user_lang = await conn.fetchval("""
SELECT app_language FROM users WHERE telegram_id = $1
""", user_id) or "ru"
if user_lang == "pl":
track = "pl"
elif user_lang == "en":
track = "en"
else:
track = "ru_uk"
# ============ ШАГ 1: Проверяем retention_status ============
# Если есть навыки, которые давно не повторяли — повторяем их
overdue_skill = await conn.fetchrow("""
@@ -44,17 +68,21 @@ async def get_next_lesson(conn, user_id: int) -> Dict[str, Any]:
""", user_id)
if overdue_skill:
# 🔧 НОВОЕ (04.10.2026): track_filter_lesson — ищем урок по skill_tag
# ТОЛЬКО в темах нужного track.
lesson = await conn.fetchrow("""
SELECT l.lesson_id, l.topic_id, l.skill_tag, l.title_pl, l.title_ru, l.title_uk, l.title_en
FROM learning_lessons l
JOIN learning_topics t ON l.topic_id = t.topic_id
WHERE l.skill_tag = $1
AND l.is_active = TRUE
AND t.track = $2
ORDER BY l.order_number
LIMIT 1
""", overdue_skill["skill_tag"])
""", overdue_skill["skill_tag"], track)
if lesson:
logger.info(f"Orchestrator: review (overdue) for user={user_id}, skill={overdue_skill['skill_tag']}")
logger.info(f"Orchestrator: review (overdue) for user={user_id}, skill={overdue_skill['skill_tag']}, track={track}")
return {
"type": "review",
"lesson": dict(lesson),
@@ -74,17 +102,20 @@ async def get_next_lesson(conn, user_id: int) -> Dict[str, Any]:
""", user_id)
if weak_skill:
# 🔧 НОВОЕ (04.10.2026): track_filter_lesson
lesson = await conn.fetchrow("""
SELECT l.lesson_id, l.topic_id, l.skill_tag, l.title_pl, l.title_ru, l.title_uk, l.title_en
FROM learning_lessons l
JOIN learning_topics t ON l.topic_id = t.topic_id
WHERE l.skill_tag = $1
AND l.is_active = TRUE
AND t.track = $2
ORDER BY l.order_number
LIMIT 1
""", weak_skill["skill_tag"])
""", weak_skill["skill_tag"], track)
if lesson:
logger.info(f"Orchestrator: review (weak) for user={user_id}, skill={weak_skill['skill_tag']}, mastery={weak_skill['mastery_score']}")
logger.info(f"Orchestrator: review (weak) for user={user_id}, skill={weak_skill['skill_tag']}, mastery={weak_skill['mastery_score']}, track={track}")
return {
"type": "review",
"lesson": dict(lesson),
@@ -93,20 +124,22 @@ async def get_next_lesson(conn, user_id: int) -> Dict[str, Any]:
}
# ============ ШАГ 3: Проверяем, нужно ли пройти тест темы ============
# Если пользователь завершил все уроки темы, но не прошёл тест
# 🔧 НОВОЕ (04.10.2026): track_filter_test — только темы нужного track.
topic_for_test = await conn.fetchrow("""
SELECT tp.topic_id, tp.lessons_total, tp.lessons_completed, tp.test_completed
FROM user_topic_progress tp
JOIN learning_topics t ON tp.topic_id = t.topic_id
WHERE tp.user_id = $1
AND tp.lessons_completed >= tp.lessons_total
AND tp.lessons_total > 0
AND tp.test_completed = FALSE
AND t.track = $2
ORDER BY tp.topic_id
LIMIT 1
""", user_id)
""", user_id, track)
if topic_for_test:
logger.info(f"Orchestrator: test for user={user_id}, topic={topic_for_test['topic_id']}")
logger.info(f"Orchestrator: test for user={user_id}, topic={topic_for_test['topic_id']}, track={track}")
return {
"type": "test",
"lesson": None,
@@ -115,7 +148,7 @@ async def get_next_lesson(conn, user_id: int) -> Dict[str, Any]:
}
# ============ ШАГ 4: Следующий урок по порядку ============
# Находим первый непройденный урок в текущем уровне
# 🔧 НОВОЕ (04.10.2026): track_filter_next — только уроки нужного track.
next_lesson = await conn.fetchrow("""
SELECT l.lesson_id, l.topic_id, l.skill_tag, l.title_pl, l.title_ru, l.title_uk, l.title_en,
t.topic_id as topic_id, t.order_number as topic_order
@@ -123,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
WHERE t.level_code = $1
AND l.is_active = TRUE
AND t.track = $3
AND l.lesson_id NOT IN (
SELECT lesson_id FROM user_lesson_progress
WHERE user_id = $2 AND completed = TRUE
)
ORDER BY t.order_number, l.order_number
LIMIT 1
""", current_level, user_id)
""", current_level, user_id, track)
if next_lesson:
logger.info(f"Orchestrator: new lesson for user={user_id}, lesson={next_lesson['lesson_id']}")
logger.info(f"Orchestrator: new lesson for user={user_id}, lesson={next_lesson['lesson_id']}, track={track}")
return {
"type": "new",
"lesson": dict(next_lesson),
@@ -141,7 +175,7 @@ async def get_next_lesson(conn, user_id: int) -> Dict[str, Any]:
}
# ============ ШАГ 5: Всё пройдено ============
logger.info(f"Orchestrator: all completed for user={user_id}")
logger.info(f"Orchestrator: all completed for user={user_id}, track={track}")
return {
"type": "completed",
"lesson": None,
+12 -8
View File
@@ -1,4 +1,3 @@
import random
from fastapi import APIRouter, Request, HTTPException
from auth import require_auth
from database import get_pool
@@ -21,14 +20,19 @@ async def get_next_word(request: Request):
lang = user["app_language"] or "pl"
# Берём случайное слово из всех уровней (без привязки к конкретному уровню)
# 🔧 ФИКС (30.09.2026): csv_words_source —
# источник слов переехал с level_words (старая схема level_id IS NULL)
# на csv_words. В csv_words нет колонки level — только level_code.
# Фронт ожидает поле "level", поэтому используем алиас level_code AS level.
# DISTINCT ON (word_pl) больше не нужен — в csv_words
# есть UNIQUE(level_code, word_pl), дубликатов по word_pl на одном
# уровне нет, но между уровнями могут быть. Поэтому слово может
# попасться несколько раз с разным level_code — оставляем как есть
# (для произношения уровень не критичен).
word = await conn.fetchrow("""
SELECT word_pl, translation_ru, translation_uk, translation_en, level
FROM (
SELECT DISTINCT ON (word_pl) word_pl, translation_ru, translation_uk, translation_en, level
FROM level_words
WHERE level_id IS NULL
) AS unique_words
SELECT word_pl, translation_ru, translation_uk, translation_en,
level_code AS level
FROM csv_words
ORDER BY RANDOM()
LIMIT 1
""")
+151 -34
View File
@@ -65,6 +65,7 @@ async def init_sentences():
("B1", "sentences_b1.csv"),
]
offset = 0
for level, filename in level_files:
sentences = load_sentences_from_csv(filename)
for i, s in enumerate(sentences):
@@ -74,11 +75,12 @@ async def init_sentences():
await conn.execute(
"""INSERT INTO sentences (sentence_number, sentence_pl, translation_ru, translation_uk, translation_en, difficulty, level)
VALUES ($1, $2, $3, $4, $5, $6, $7)
ON CONFLICT (level, sentence_number) DO NOTHING""",
i + 1, s["sentence_pl"],
ON CONFLICT (sentence_number) DO NOTHING""",
offset + i + 1, s["sentence_pl"],
s["translation_ru"], s["translation_uk"], s["translation_en"],
difficulty, level
)
offset += len(sentences)
def normalize_word_for_display(word: str) -> str:
@@ -100,28 +102,34 @@ async def get_next_sentence(request: Request):
pool = await get_pool()
async with pool.acquire() as conn:
user = await conn.fetchrow(
"SELECT app_language, current_level FROM users WHERE telegram_id = $1", telegram_id
"SELECT app_language, difficulty FROM users WHERE telegram_id = $1", telegram_id
)
if not user:
raise HTTPException(401, "User not registered")
lang = user["app_language"] or "pl"
current_level = user["current_level"] or "A1"
difficulty = user["difficulty"] or "medium"
# Находим случайное непройденное предложение нужного уровня
# Находим случайное непройденное предложение (единый пул)
row = await conn.fetchrow("""
SELECT s.* FROM sentences s
WHERE s.level = $1
AND s.id NOT IN (
SELECT sentence_id FROM sentence_progress WHERE user_id = $2
WHERE s.id NOT IN (
SELECT sentence_id FROM sentence_progress WHERE user_id = $1 AND completed_at IS NOT NULL
)
ORDER BY RANDOM()
LIMIT 1
""", current_level, telegram_id)
""", telegram_id)
if not row:
return {"completed": True, "message": "All sentences completed!"}
# 🔧 НОВОЕ (16.10.2026): строка прогресса (in-progress) для счётчика list_opened.
await conn.execute("""
INSERT INTO sentence_progress (user_id, sentence_id, list_opened, completion_time)
VALUES ($1, $2, 0, 0)
ON CONFLICT (user_id, sentence_id) DO NOTHING
""", telegram_id, row["id"])
# Оригинальные слова (для проверки)
correct_words = row["sentence_pl"].split()
@@ -140,10 +148,64 @@ async def get_next_sentence(request: Request):
"correct_words": display_words,
"translation": translation,
"difficulty": row["difficulty"],
"user_difficulty": difficulty,
"level": row["level"],
}
@router.post("/show-answer")
async def show_answer(request: Request):
"""Подсказка «показать предложение». Easy — ∞ бесплатно, Medium — 2 раза × −20, Hard — 403."""
telegram_id, _ = await require_auth(request)
body = await request.json()
sentence_id = body.get("sentence_id")
if not sentence_id:
raise HTTPException(400, "sentence_id required")
pool = await get_pool()
async with pool.acquire() as conn:
user = await conn.fetchrow(
"SELECT difficulty FROM users WHERE telegram_id = $1", telegram_id
)
if not user:
raise HTTPException(401, "User not registered")
difficulty = user["difficulty"] or "medium"
row = await conn.fetchrow(
"SELECT sentence_pl FROM sentences WHERE id = $1", sentence_id
)
if not row:
raise HTTPException(404, "Sentence not found")
if difficulty == "hard":
raise HTTPException(403, "Hints are disabled on Hard difficulty")
progress = await conn.fetchrow(
"SELECT list_opened FROM sentence_progress WHERE user_id = $1 AND sentence_id = $2",
telegram_id, sentence_id
)
list_opened = (progress["list_opened"] if progress else 0) or 0
if difficulty == "medium":
if list_opened >= 2:
raise HTTPException(403, "Show answer limit reached on Medium difficulty")
await conn.execute("""
INSERT INTO sentence_progress (user_id, sentence_id, list_opened)
VALUES ($1, $2, 1)
ON CONFLICT (user_id, sentence_id) DO UPDATE
SET list_opened = sentence_progress.list_opened + 1
""", telegram_id, sentence_id)
new_list_opened = list_opened + 1
else:
new_list_opened = list_opened # Easy — не инкрементим
return {
"sentence_pl": row["sentence_pl"],
"list_opened": new_list_opened,
"max_list_opened": None if difficulty == "easy" else 2,
}
@router.post("/check")
async def check_sentence(request: Request):
"""Проверка предложения с защитой от повторного прохождения и выдачей достижений"""
@@ -160,6 +222,8 @@ async def check_sentence(request: Request):
raise HTTPException(400, "Too many words")
pool = await get_pool()
# 🔧 НОВОЕ (08.10.2026): XP-система — результат award_xp.
xp_result = None
async with pool.acquire() as conn:
user_exists = await conn.fetchval(
"SELECT 1 FROM users WHERE telegram_id = $1", telegram_id
@@ -174,7 +238,7 @@ async def check_sentence(request: Request):
raise HTTPException(404, "Sentence not found")
existing_progress = await conn.fetchrow(
"SELECT score, completed_at FROM sentence_progress WHERE user_id = $1 AND sentence_id = $2",
"SELECT score, completed_at FROM sentence_progress WHERE user_id = $1 AND sentence_id = $2 AND completed_at IS NOT NULL",
telegram_id, sentence_id
)
@@ -206,20 +270,67 @@ async def check_sentence(request: Request):
is_correct = user_words_normalized == correct_words_normalized
if is_correct:
word_count = len(correct_words_original)
if word_count <= 4:
score = 50
elif word_count <= 6:
score = 75
else:
score = 100
# 🔧 НОВОЕ (16.10.2026): очки по формуле сложностей.
# Easy — фикс 20. Medium — 60 − 20×list_opened (мин 20).
# Hard — 100, +50 бонус если completion_time <= 15 сек.
wrong_checks = int(body.get("wrong_checks", 0) or 0)
user_row = await conn.fetchrow(
"SELECT difficulty FROM users WHERE telegram_id = $1", telegram_id
)
difficulty = (user_row["difficulty"] if user_row else None) or "medium"
progress_row = await conn.fetchrow(
"SELECT list_opened FROM sentence_progress WHERE user_id = $1 AND sentence_id = $2",
telegram_id, sentence_id
)
list_opened = (progress_row["list_opened"] if progress_row else 0) or 0
if difficulty == "easy":
points = 20
elif difficulty == "medium":
points = max(20, 60 - 20 * list_opened)
else: # hard
points = 100
if completion_time is not None and completion_time <= 15:
points = 150
# Начисляем XP
from services.xp import award_xp
xp_result = await award_xp(conn, telegram_id, "sentence", points)
score = xp_result["points"]
await conn.execute(
"""INSERT INTO sentence_progress (user_id, sentence_id, completed_at, score, level)
VALUES ($1, $2, NOW(), $3, $4)""",
telegram_id, sentence_id, score, row["level"],
"""INSERT INTO sentence_progress (user_id, sentence_id, completed_at, score, level, completion_time)
VALUES ($1, $2, NOW(), $3, $4, $5)
ON CONFLICT (user_id, sentence_id) DO UPDATE
SET completed_at = NOW(), score = $3, level = $4, completion_time = $5""",
telegram_id, sentence_id, score, row["level"], completion_time or 0,
)
# 🔧 НОВОЕ (16.10.2026): серии в sentence_stats (PK user_id).
await conn.execute("""
INSERT INTO sentence_stats (user_id, total_score, no_mistakes_streak, perfect_streak, updated_at)
VALUES ($1, $2,
CASE WHEN $3 = 0 THEN 1 ELSE 0 END,
CASE WHEN $3 = 0 AND $4 = 0 THEN 1 ELSE 0 END,
NOW())
ON CONFLICT (user_id) DO UPDATE
SET total_score = sentence_stats.total_score + $2,
no_mistakes_streak = CASE WHEN $3 = 0 THEN sentence_stats.no_mistakes_streak + 1 ELSE 0 END,
perfect_streak = CASE WHEN $3 = 0 AND $4 = 0 THEN sentence_stats.perfect_streak + 1 ELSE 0 END,
updated_at = NOW()
""", telegram_id, score, wrong_checks, list_opened)
# 🔧 НОВОЕ (16.10.2026): читаем серии/очки для достижений.
stats_row = await conn.fetchrow(
"SELECT total_score, no_mistakes_streak, perfect_streak FROM sentence_stats WHERE user_id = $1",
telegram_id
)
sentence_total_score = stats_row["total_score"] if stats_row else 0
sentence_no_mistakes = stats_row["no_mistakes_streak"] if stats_row else 0
sentence_perfect_streak = stats_row["perfect_streak"] if stats_row else 0
# 🔧 ФИКС (23.09.2026): achievements_nested_pool_acquire_sentences —
# раньше check_and_award_achievements вызывался ВНУТРИ async with pool.acquire(),
# что могло привести к дедлоку пула. Теперь собираем данные внутри блока,
@@ -250,6 +361,9 @@ async def check_sentence(request: Request):
achievements_to_check = [
("sentences_completed", sentences_completed),
("total_score", grand_total),
("sentence_no_mistakes", sentence_no_mistakes),
("sentence_perfect_streak", sentence_perfect_streak),
("sentence_xp", sentence_total_score),
]
if completion_time is not None and completion_time > 0:
achievements_to_check.append(("speed_sentence", int(completion_time)))
@@ -267,7 +381,18 @@ async def check_sentence(request: Request):
"correct_words": [normalize_word_for_display(w) for w in correct_words_original],
"already_completed": False,
"score": score,
"new_achievements": new_achievements
"new_achievements": new_achievements,
# 🆕 XP
"base_points": xp_result["base_points"],
"multiplier": xp_result["multiplier"],
"points": xp_result["points"],
"featured": xp_result["featured"],
"level_up": xp_result["level_up"],
"total_xp": xp_result["total_xp"],
"level": xp_result["level"],
"rank_key": xp_result["rank_key"],
"xp_in_level": xp_result["xp_in_level"],
"xp_needed": xp_result["xp_needed"],
}
return {
@@ -285,21 +410,14 @@ async def get_sentence_stats(request: Request):
pool = await get_pool()
async with pool.acquire() as conn:
user = await conn.fetchrow(
"SELECT current_level FROM users WHERE telegram_id = $1", telegram_id
)
current_level = user["current_level"] if user else "A1"
total = await conn.fetchval(
"SELECT COUNT(*) FROM sentences WHERE level = $1", current_level
)
total = await conn.fetchval("SELECT COUNT(*) FROM sentences")
completed = await conn.fetchval(
"SELECT COUNT(*) FROM sentence_progress WHERE user_id = $1 AND level = $2",
telegram_id, current_level
"SELECT COUNT(*) FROM sentence_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
telegram_id
)
total_score = await conn.fetchval(
"SELECT COALESCE(SUM(score), 0) FROM sentence_progress WHERE user_id = $1 AND level = $2",
telegram_id, current_level
"SELECT COALESCE(SUM(score), 0) FROM sentence_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
telegram_id
)
return {
@@ -308,5 +426,4 @@ async def get_sentence_stats(request: Request):
"remaining": total - (completed or 0),
"total_score": total_score or 0,
"progress_percent": round(((completed or 0) / total * 100), 1) if total > 0 else 0,
"level": current_level,
}
+5 -5
View File
@@ -1,7 +1,7 @@
"""
Support Router — система поддержки пользователей.
Пользователи пишут админу о багах, неточностях и предложениях.
Админ отвечает. Обе стороны могут переводить сообщения через AI (MiniMax-M3).
Админ отвечает. Обе стороны могут переводить сообщения через AI (DeepSeek V4 Pro).
"""
import logging
import httpx
@@ -16,11 +16,11 @@ logger = logging.getLogger(__name__)
router = APIRouter(prefix="/support", tags=["support"])
TOGETHER_API_URL = "https://api.together.xyz/v1/chat/completions"
SUPPORT_MODEL = "MiniMaxAI/MiniMax-M3"
SUPPORT_MODEL = "deepseek-ai/DeepSeek-V4-Pro-0813"
async def call_ai_translate(text: str, target_lang: str) -> str:
"""Переводит текст через AI (MiniMax-M3)."""
"""Переводит текст через AI (DeepSeek V4 Pro)."""
if not TOGETHER_API_KEY:
return ""
@@ -38,7 +38,7 @@ async def call_ai_translate(text: str, target_lang: str) -> str:
{"role": "system", "content": f"Ты — переводчик. Переведи текст на язык: {target_lang}. Отвечай только переводом без пояснений. Не используй markdown."},
{"role": "user", "content": text},
],
"max_tokens": 500,
"max_tokens": 1500,
"temperature": 0.3,
},
)
@@ -334,7 +334,7 @@ async def get_unread_count(request: Request):
@router.post("/translate")
async def translate_message(request: Request):
"""
Перевод сообщения через AI (MiniMax-M3).
Перевод сообщения через AI (DeepSeek V4 Pro).
Доступно и пользователю, и админу.
"""
telegram_id, _ = await require_auth(request)
+42 -11
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 — гибридный чат-учитель.
Контент из БД (бесплатно), AI только для реакций и пробелов.
@@ -43,7 +53,7 @@ logger = logging.getLogger(__name__)
router = APIRouter(prefix="/teacher", tags=["teacher"])
TOGETHER_API_URL = "https://api.together.xyz/v1/chat/completions"
TEACHER_MODEL = "MiniMaxAI/MiniMax-M3"
TEACHER_MODEL = "deepseek-ai/DeepSeek-V4-Pro-0813"
TEACHER_AI_DAILY_LIMIT = 5
@@ -232,6 +242,11 @@ async def call_ai(prompt: str, system_prompt: str, max_tokens: int = 500) -> str
],
"max_tokens": max_tokens,
"temperature": 0.7,
# 🔧 ФИКС (05.10.2026): disable_reasoning_for_fast_tasks —
# V4 Pro — reasoning-модель, тратит 80% токенов на «мысли»
# (reasoning_content) и 20-30 секунд на ответ.
# Для фразы дня и переводов reasoning не нужен → отключаем.
"reasoning_effort": "none",
},
)
@@ -282,7 +297,8 @@ async def get_wrong_answer_ai_explanation(telegram_id: int, lang: str, prompt_te
system_prompt = f"""Ты — Марек, учитель польского языка. Объясняй ошибки кратко и понятно.
Отвечай на языке: {lang}. Не используй markdown."""
ai_response = await call_ai(ai_prompt, system_prompt, max_tokens=200)
# 🔧 ФИКС (05.10.2026): max_tokens_for_v4_pro — 200 → 600
ai_response = await call_ai(ai_prompt, system_prompt, max_tokens=600)
if ai_response:
async with pool.acquire() as conn:
@@ -376,7 +392,8 @@ EN_GRAMMAR: [грамматический разбор на английском
user_prompt = f"Создай фразу дня на тему: {selected_topic}."
ai_response = await call_ai(user_prompt, system_prompt, max_tokens=1000)
# 🔧 ФИКС (05.10.2026): max_tokens_for_v4_pro — 1000 → 3000
ai_response = await call_ai(user_prompt, system_prompt, max_tokens=3000)
# Fallback значения
phrase_pl = "Lepiej późno niż wcale."
@@ -705,6 +722,18 @@ async def teacher_answer(request: Request):
SELECT * FROM question_options WHERE question_id = $1
""", question_id)
# 🔧 ФИКС (25.09.2026): teacher_answer_missing_session_owner_check —
# сессия грузилась без проверки владельца, и это позволяло атакующему
# записать мусорные ответы в чужую сессию через save_answer_to_session
# ДО того, как мы поймали IDOR. Теперь проверяем ВЛАДЕЛЬЦА СЕССИИ
# ПЕРЕД любой записью в БД — fail fast, никаких побочных эффектов.
session = await conn.fetchrow(
"SELECT * FROM learning_sessions WHERE id = $1 AND user_id = $2",
session_id, telegram_id
)
if not session:
raise HTTPException(404, "Session not found or access denied")
correct_answer = question_row["correct_answer"] or ""
is_correct = normalize_answer(selected_answer) == normalize_answer(correct_answer)
@@ -718,6 +747,8 @@ async def teacher_answer(request: Request):
"question": dict(question_row),
"options": [dict(o) for o in options],
}
# Только теперь безопасно записываем ответ в user_learning_answers
await save_answer_to_session(
conn, telegram_id, session_id, question_data,
selected_answer, is_correct, time_taken_ms
@@ -734,10 +765,6 @@ async def teacher_answer(request: Request):
if not is_correct and wrong_because:
db_explanation = await get_wrong_because_explanation(conn, wrong_because, lang)
session = await conn.fetchrow("SELECT * FROM learning_sessions WHERE id = $1", session_id)
if not session:
raise HTTPException(404, "Session not found")
if session["session_type"] == "teacher_test":
questions = await get_test_questions(conn, session["topic_id"])
else:
@@ -868,7 +895,8 @@ async def teacher_explain(request: Request):
system_prompt = f"""Ты — учитель польского языка. Объясни материал простыми словами.
Отвечай на языке: {lang}. Не используй markdown."""
ai_response = await call_ai(content, system_prompt)
# 🔧 ФИКС (05.10.2026): max_tokens_for_v4_pro — добавляем 1500
ai_response = await call_ai(content, system_prompt, max_tokens=1500)
if ai_response:
async with pool.acquire() as conn:
@@ -943,7 +971,8 @@ async def teacher_examples(request: Request):
Верни только 5 примеров, без вступлений и пояснений."""
ai_response = await call_ai(topic, system_prompt, max_tokens=500)
# 🔧 ФИКС (05.10.2026): max_tokens_for_v4_pro — 500 → 1500
ai_response = await call_ai(topic, system_prompt, max_tokens=1500)
if ai_response:
async with pool.acquire() as conn:
@@ -1005,7 +1034,8 @@ async def teacher_free_message(request: Request):
Ученик может спросить что угодно: объяснить тему, перевести фразу, дать пример.
Отвечай кратко (1-3 предложения) и по делу."""
ai_response = await call_ai(user_message, system_prompt, max_tokens=300)
# 🔧 ФИКС (05.10.2026): max_tokens_for_v4_pro — 300 → 900
ai_response = await call_ai(user_message, system_prompt, max_tokens=900)
if ai_response:
async with pool.acquire() as conn:
@@ -1102,7 +1132,8 @@ async def teacher_translate_to_polish(request: Request):
system_prompt = f"""Ты — переводчик польского языка. Переведи текст на польский.
Отвечай только переводом без пояснений. Не используй markdown."""
ai_response = await call_ai(text, system_prompt, max_tokens=300)
# 🔧 ФИКС (05.10.2026): max_tokens_for_v4_pro — 300 → 900
ai_response = await call_ai(text, system_prompt, max_tokens=900)
if ai_response:
async with pool.acquire() as conn:
-1
View File
@@ -3,7 +3,6 @@ Typing Router — раздел "Печать".
Пользователь печатает польские предложения, система проверяет.
Без AI — просто сравнение с правильным ответом из БД.
"""
import random
from fastapi import APIRouter, Request, HTTPException
from auth import require_auth
from database import get_pool
+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")
async def set_level(request: Request):
"""Устанавливает текущий уровень пользователя (A1, A2, B1, B2, C1, C2)"""
@@ -104,3 +124,85 @@ async def set_level(request: Request):
"status": "ok",
"level": level,
}
# ============================================================
# 🆕 (08.10.2026): профиль — ник + аватар
# ============================================================
import re as _re
_FORBIDDEN_WORDS = {
"admin", "administrator", "root", "moderator", "mod",
"pleily", "filwords", "support", "help", "system",
"хуй", "пизда", "блядь", "сука", "ебать",
"kurwa", "chuj", "pizda", "jebac",
"fuck", "shit", "bitch", "ass",
}
_NICKNAME_RE = _re.compile(r'^[\w\s\.\-]+$', flags=_re.UNICODE)
def _clean_nickname(raw: str) -> str:
if not raw:
raise HTTPException(400, "Nickname is required")
nick = raw.strip()
if len(nick) < 2:
raise HTTPException(400, "Nickname must be at least 2 characters")
if len(nick) > 20:
raise HTTPException(400, "Nickname must be at most 20 characters")
lower = nick.lower()
for bad in _FORBIDDEN_WORDS:
if bad in lower:
raise HTTPException(400, "Nickname contains forbidden words")
if not _NICKNAME_RE.match(nick):
raise HTTPException(400, "Nickname contains invalid characters")
return nick
@router.post("/set-nickname")
async def set_nickname(request: Request):
"""Сохранить ник пользователя. Body: {"nickname": "Oleg"}"""
user_id, _ = await require_auth(request)
body = await request.json()
nickname = _clean_nickname(body.get("nickname", ""))
pool = await get_pool()
async with pool.acquire() as conn:
existing = await conn.fetchval(
"SELECT user_id FROM user_profile WHERE nickname = $1 AND user_id != $2",
nickname, user_id,
)
if existing:
raise HTTPException(409, "Nickname already taken")
await conn.execute("""
INSERT INTO user_profile (user_id, nickname, updated_at)
VALUES ($1, $2, NOW())
ON CONFLICT (user_id) DO UPDATE
SET nickname = $2, updated_at = NOW()
""", user_id, nickname)
return {"status": "ok", "nickname": nickname}
@router.post("/set-avatar")
async def set_avatar(request: Request):
"""Сохранить аватар. Body: {"avatar_id": 3}"""
user_id, _ = await require_auth(request)
body = await request.json()
avatar_id = body.get("avatar_id")
if not isinstance(avatar_id, int) or avatar_id < 0 or avatar_id > 7:
raise HTTPException(400, "avatar_id must be 0..7")
pool = await get_pool()
async with pool.acquire() as conn:
await conn.execute("""
INSERT INTO user_profile (user_id, avatar_id, updated_at)
VALUES ($1, $2, NOW())
ON CONFLICT (user_id) DO UPDATE
SET avatar_id = $2, updated_at = NOW()
""", user_id, avatar_id)
return {"status": "ok", "avatar_id": avatar_id}
+130 -70
View File
@@ -14,7 +14,7 @@ async def get_next_quiz(request: Request):
pool = await get_pool()
async with pool.acquire() as conn:
user = await conn.fetchrow(
"SELECT app_language, current_level FROM users WHERE telegram_id = $1", telegram_id
"SELECT app_language, current_level, difficulty FROM users WHERE telegram_id = $1", telegram_id
)
if not user:
raise HTTPException(401, "User not registered")
@@ -22,6 +22,12 @@ async def get_next_quiz(request: Request):
lang = user["app_language"] or "pl"
current_level = user["current_level"] or "A1"
if lang == 'pl':
raise HTTPException(403, "ChooseWord не поддерживает польский язык. Используйте другой язык.")
difficulty = user.get("difficulty") or "medium"
wrong_count = {"easy": 2, "medium": 3, "hard": 4}.get(difficulty, 3)
progress = await conn.fetchrow(
"SELECT words_guessed, recent_words FROM word_quiz_progress WHERE user_id = $1",
telegram_id
@@ -32,23 +38,20 @@ async def get_next_quiz(request: Request):
async def pick_word(exclude, respect_exclude=True):
if respect_exclude and exclude:
placeholders = ",".join([f"${i+2}" for i in range(len(exclude))])
# 🔧 ФИКС (30.09.2026): csv_words_source —
# источник слов переехал с level_words (старая схема level_id IS NULL)
# на csv_words (level_code). Один источник — CSV-база.
return await conn.fetchrow(f"""
SELECT word_pl, translation_ru, translation_uk, translation_en
FROM (
SELECT DISTINCT ON (word_pl) word_pl, translation_ru, translation_uk, translation_en
FROM level_words
WHERE level = $1 AND level_id IS NULL AND word_pl NOT IN ({placeholders})
) AS unique_words
FROM csv_words
WHERE level_code = $1 AND word_pl NOT IN ({placeholders})
ORDER BY RANDOM()
LIMIT 1
""", current_level, *exclude)
return await conn.fetchrow("""
SELECT word_pl, translation_ru, translation_uk, translation_en
FROM (
SELECT DISTINCT ON (word_pl) word_pl, translation_ru, translation_uk, translation_en
FROM level_words
WHERE level = $1 AND level_id IS NULL
) AS unique_words
FROM csv_words
WHERE level_code = $1
ORDER BY RANDOM()
LIMIT 1
""", current_level)
@@ -67,25 +70,21 @@ async def get_next_quiz(request: Request):
# Ищем неправильные варианты
exclude_for_wrong = recent_words + [correct_polish]
placeholders = ",".join([f"${i+3}" for i in range(len(exclude_for_wrong))])
# 🔧 ФИКС (30.09.2026): csv_words_source — источник переведён на csv_words.
wrong_words = await conn.fetch(f"""
SELECT word_pl
FROM (
SELECT DISTINCT ON (word_pl) word_pl
FROM level_words
WHERE level = $1 AND level_id IS NULL AND word_pl != $2 AND word_pl NOT IN ({placeholders})
) AS unique_wrong
FROM csv_words
WHERE level_code = $1 AND word_pl != $2 AND word_pl NOT IN ({placeholders})
ORDER BY RANDOM()
LIMIT 5
""", current_level, correct_polish, *exclude_for_wrong)
if len(wrong_words) < 2:
if len(wrong_words) < wrong_count:
# 🔧 ФИКС (30.09.2026): csv_words_source — fallback тоже на csv_words.
wrong_words = await conn.fetch("""
SELECT word_pl
FROM (
SELECT DISTINCT ON (word_pl) word_pl
FROM level_words
WHERE level = $1 AND level_id IS NULL AND word_pl != $2
) AS unique_wrong
FROM csv_words
WHERE level_code = $1 AND word_pl != $2
ORDER BY RANDOM()
LIMIT 5
""", current_level, correct_polish)
@@ -97,7 +96,7 @@ async def get_next_quiz(request: Request):
if wl not in seen:
wrong_options.append(w["word_pl"])
seen.add(wl)
if len(wrong_options) >= 2:
if len(wrong_options) >= wrong_count:
break
recent_words = recent_words + [correct_polish] + wrong_options
@@ -114,38 +113,39 @@ async def get_next_quiz(request: Request):
options = wrong_options + [correct_polish]
random.shuffle(options)
if total_guessed <= 10:
difficulty = "easy"
elif total_guessed <= 30:
difficulty = "medium"
elif total_guessed <= 60:
difficulty = "hard"
else:
difficulty = "expert"
time_limit = 10 if difficulty == "hard" else None
return {
"correct_polish": correct_polish,
"translation": translation,
"options": options,
"difficulty": difficulty,
"time_limit": time_limit,
}
@router.post("/check")
async def check_quiz_answer(request: Request):
"""Проверяет ответ, начисляет очки и проверяет достижения"""
"""Проверяет ответ, начисляет XP и проверяет достижения.
🔧 НОВОЕ (08.10.2026): XP-система + серии.
Штрафы:
-1 за каждый неверный выбор (макс 3)
-1 если time_ms > 30 сек
Минимум 1 звезда.
Серия: correct_streak (best_streak хранится в choose_progress).
"""
telegram_id, _ = await require_auth(request)
body = await request.json()
correct_polish = body.get("correct_polish", "")
user_answer = body.get("answer", "")
completion_time = body.get("completion_time")
# 🔧 ФИКС (24.09.2026): client_controlled_mistakes_wordquiz —
# mistakes больше НЕ берём от клиента. Считаем на сервере.
# 🆕 wrong_count приходит с клиента для UI, но мы считаем на сервере
# 🔧 ФИКС: current_mistakes — серверный счётчик
if not correct_polish or not user_answer:
raise HTTPException(400, "correct_polish and answer required")
# Защита от читерства: минимальное время 1 секунда
if completion_time is not None and completion_time < 1:
return {
"correct": False,
@@ -157,22 +157,35 @@ async def check_quiz_answer(request: Request):
pool = await get_pool()
async with pool.acquire() as conn:
# Проверка языка
lang = await conn.fetchval(
"SELECT app_language FROM users WHERE telegram_id = $1", telegram_id
) or "pl"
if lang == 'pl':
raise HTTPException(403, "ChooseWord не поддерживает польский язык.")
difficulty = await conn.fetchval(
"SELECT difficulty FROM users WHERE telegram_id = $1", telegram_id
) or "medium"
# Читаем серверный streak и mistakes
current_streak = await conn.fetchval(
"SELECT correct_streak FROM word_quiz_progress WHERE user_id = $1",
telegram_id
) or 0
# 🔧 ФИКС (24.09.2026): client_controlled_mistakes_wordquiz —
# читаем серверный current_mistakes.
mistakes = await conn.fetchval(
"SELECT current_mistakes FROM word_quiz_progress WHERE user_id = $1",
telegram_id
) or 0
no_mistakes_streak = await conn.fetchval(
"SELECT no_mistakes_streak FROM word_quiz_progress WHERE user_id = $1",
telegram_id
) or 0
if is_correct:
current_streak += 1
else:
current_streak = 0
# 🔧 Инкрементим mistakes на сервере
await conn.execute("""
INSERT INTO word_quiz_progress (user_id, current_mistakes)
VALUES ($1, 1)
@@ -181,58 +194,82 @@ async def check_quiz_answer(request: Request):
""", telegram_id)
mistakes += 1
xp_result = None
score = 0
if is_correct:
score = max(10, 50 - (mistakes * 20))
# 🔧 Сбрасываем mistakes при правильном ответе
# 🆕 Фиксированные очки по сложности (ChooseWord)
if difficulty == "easy":
points = max(20, min(60, 60 - 20 * mistakes))
elif difficulty == "medium":
points = max(20, min(80, 80 - 20 * mistakes))
else: # hard
points = max(20, min(110, 110 - 20 * mistakes))
if completion_time is not None and completion_time > 10:
points = 20
# Начисляем XP
from services.xp import award_xp
xp_result = await award_xp(conn, telegram_id, "choose", points)
score = xp_result["points"]
# no_mistakes_streak: +1 если раунд чистый, иначе сброс
if mistakes == 0:
no_mistakes_streak += 1
else:
no_mistakes_streak = 0
# Сбрасываем mistakes + обновляем серию
await conn.execute("""
UPDATE word_quiz_progress SET current_mistakes = 0 WHERE user_id = $1
""", telegram_id)
await conn.execute("""
INSERT INTO word_quiz_progress (user_id, words_guessed, total_score, correct_streak)
VALUES ($1, 1, $2, $3)
INSERT INTO word_quiz_progress (user_id, words_guessed, total_score, correct_streak, no_mistakes_streak)
VALUES ($1, 1, $2, $3, $4)
ON CONFLICT (user_id) DO UPDATE
SET words_guessed = word_quiz_progress.words_guessed + 1,
total_score = word_quiz_progress.total_score + $2,
correct_streak = $3
""", telegram_id, score, current_streak)
correct_streak = $3,
no_mistakes_streak = $4
""", telegram_id, score, current_streak, no_mistakes_streak)
# 🔧 ФИКС (23.09.2026): achievements_nested_pool_acquire_wordquiz —
# вызовы достижений вынесены за async with pool.acquire() (паттерн game.py).
# 🆕 Обновляем best_streak в choose_progress
await conn.execute("""
INSERT INTO choose_progress (user_id, current_streak, best_streak)
VALUES ($1, $2, $2)
ON CONFLICT (user_id) DO UPDATE
SET current_streak = $2,
best_streak = GREATEST(choose_progress.best_streak, $2),
updated_at = NOW()
""", telegram_id, current_streak)
# Собираем данные для достижений
total_guessed = await conn.fetchval(
"SELECT words_guessed FROM word_quiz_progress WHERE user_id = $1",
telegram_id
) or 0
wordsearch_score = await conn.fetchval(
"SELECT COALESCE(SUM(score), 0) FROM user_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
telegram_id
) or 0
sentence_score = await conn.fetchval(
"SELECT COALESCE(SUM(score), 0) FROM sentence_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
telegram_id
) or 0
wordquiz_score = await conn.fetchval(
"SELECT COALESCE(total_score, 0) FROM word_quiz_progress WHERE user_id = $1",
telegram_id
) or 0
bubblewords_score = await conn.fetchval(
"SELECT COALESCE(total_score, 0) FROM bubble_words_progress WHERE user_id = $1",
telegram_id
) or 0
grand_total = wordsearch_score + sentence_score + wordquiz_score + bubblewords_score
achievements_to_check = [
("quiz_guessed", total_guessed),
("total_score", grand_total),
("total_score", xp_result["total_xp"]),
]
if current_streak >= 10:
achievements_to_check.append(("quiz_perfect_streak", current_streak))
if current_streak >= 5:
achievements_to_check.append(("quiz_correct_streak", current_streak))
if no_mistakes_streak > 0:
achievements_to_check.append(("quiz_no_mistakes_streak", no_mistakes_streak))
if mistakes == 0:
achievements_to_check.append(("quiz_no_mistakes", 1))
if completion_time is not None and completion_time > 0 and int(completion_time) <= 3:
achievements_to_check.append(("quiz_speed", 3))
if completion_time is not None and 0 < completion_time <= 5:
achievements_to_check.append(("quiz_speed_5", 5))
if completion_time is not None and 0 < completion_time <= 3:
achievements_to_check.append(("quiz_speed_3", 3))
if completion_time is not None and 0 < completion_time <= 2:
achievements_to_check.append(("quiz_speed_2", 2))
if completion_time is not None and 0 < completion_time <= 1:
achievements_to_check.append(("quiz_speed_1", 1))
else:
# При 3 ошибках — начисляем утешительные 10 очков
# При 3 ошибках — утешительный XP (10)
if mistakes >= 3:
await conn.execute("""
INSERT INTO word_quiz_progress (user_id, words_guessed, total_score, correct_streak, current_mistakes)
@@ -249,7 +286,7 @@ async def check_quiz_answer(request: Request):
SET correct_streak = $2
""", telegram_id, current_streak)
# 🔧 ФИКС (23.09.2026): вызовы достижений ВНЕ блока async with pool.acquire()
# Достижения — вне транзакции
if is_correct:
from routers.achievements import check_and_award_achievements
new_achievements = []
@@ -262,6 +299,19 @@ async def check_quiz_answer(request: Request):
"score": score,
"correct_streak": current_streak,
"new_achievements": new_achievements,
# 🆕 XP-поля
"base_points": xp_result["base_points"],
"multiplier": xp_result["multiplier"],
"points": xp_result["points"],
"featured": xp_result["featured"],
"level_up": xp_result["level_up"],
"total_xp": xp_result["total_xp"],
"level": xp_result["level"],
"rank_key": xp_result["rank_key"],
"xp_in_level": xp_result["xp_in_level"],
"xp_needed": xp_result["xp_needed"],
# 🆕 Серия для UI
"streak_best": (await _get_best_streak(telegram_id)),
}
return {
@@ -271,6 +321,16 @@ async def check_quiz_answer(request: Request):
}
async def _get_best_streak(telegram_id: int) -> int:
"""Возвращает best_streak пользователя из choose_progress."""
pool = await get_pool()
async with pool.acquire() as conn:
return await conn.fetchval(
"SELECT best_streak FROM choose_progress WHERE user_id = $1",
telegram_id
) or 0
@router.get("/progress")
async def get_quiz_progress(request: Request):
"""Статистика пользователя в квизе"""
+305 -59
View File
@@ -3,13 +3,74 @@
AI Code Review for Filwords PL Backend (JSON-контракт + пак-подход)
Backend слишком большой (~440K символов) для одного запроса — модель уходит
в reasoning и не успевает выдать JSON. Решение: разбиваем файлы на 3 пака
в reasoning и не успевает выдать JSON. Решение: разбиваем файлы на паки
по папкам, делаем отдельный запрос на каждый пак, объединяем находки.
(20.09.2026) Первая версия — конвейер без tool-calling, предсказуемо по токенам.
(20.09.2026, вечер) Фикс: max_tokens=16000, fallback на reasoning_content.
(21.09.2026, вечер) JSON-контракт + snippet-проверка + фильтр confidence.
(22.09.2026, вечер) Пак-подход: 3 пака (routers, core, services+scripts).
(25.09.2026) Разбивка routers на 4 пака, MAX_OUTPUT_TOKENS=32000.
(25.09.2026, вечер) ФИКС root cause: DeepSeek-V4.1-Flash по умолчанию
думает (reasoning), и на сложных паках весь max_tokens уходит в
thinking — content пустой, finish=length, находки теряются.
→ reasoning выключен явно ("reasoning": {"enabled": False}).
→ fallback на reasoning_content убран (это была причина "Ошибка
парсинга JSON": туда попадал сырой текст рассуждений, а не JSON).
→ extract_json теперь спасает отдельные валидные находки, даже если
ответ всё же обрежется по max_tokens — вместо потери пака целиком.
(26.09.2026) ФИКС quality-first:
→ MODEL: DeepSeek-V4.1-Flash → DeepSeek-V4-Pro-0813 (потом откат).
→ MAX_OUTPUT_TOKENS: 32000 → 8000 (модель перестаёт писать "всё подряд").
→ SYSTEM_PROMPT ужесточён: запрет "Ок"/"Не баг"/"Работает корректно",
confidence >= 0.75, ТОП-10 по severity.
→ validate_and_filter: overshoot guard — если находок > 15 на пак,
берём только топ-10 по confidence (признак, что модель "потекла").
(26.09.2026, вечер) ФИКС dual-model + split routers_learning:
→ routers_learning (100k) разбит на 3 пака:
routers_learning_core, routers_learning_teacher, routers_learning_orch.
Это устраняет finish=length — модель успевает выдать JSON.
→ Добавлена ВТОРАЯ модель (GLM 5.3) для пересечения находок:
DeepSeek V4.1 Flash — основная, GLM 5.3 — вторая.
Пересечение по (file, snippet) → confidence +0.05.
→ Только primary → normal. Только secondary → normal.
→ USE_SECONDARY_MODEL=True включает вторую модель.
(26.09.2026, ночь) ФИКС reasoning-per-model + бюджет:
→ MODEL_SECONDARY: zai-org/GLM-5.3 (флагман, $1.40/$4.40) →
zai-org/GLM-5.3-Flash ($0.15/$0.50). Флагман почти не нужен для
point-by-point code review, а стоит в ~9 раз дороже; на 2 репо
(backend+frontend) дуал-модель с флагманом упирается в бюджет
80 центов/аудит, с Flash — укладывается с большим запасом.
→ ROOT CAUSE найден: "reasoning": {"enabled": False} НЕ работает
на GLM-5.3 / GLM-5.3-Flash (документация Together: "Thinking
cannot be disabled entirely on GLM-5.3"). Флаг тихо игнорировался,
GLM продолжал думать, весь max_tokens уходил в reasoning_content,
content оставался пустым → "Формат ответа: пусто" именно на
GLM-паках. Это и была причина "не работает" у secondary модели.
→ call_together_model теперь строит РАЗНЫЙ payload по семейству
модели: DeepSeek → reasoning.enabled=False (это работает);
GLM-5.3* → reasoning_effort="low" + увеличенный max_tokens
(единственный доступный рычаг для GLM-5.3, thinking трейс
частично остаётся, но сильно короче).
→ Логируем длину reasoning_content (если есть) — видно, сколько
токенов модель тратит на мысли до JSON-ответа.
(27.09.2026) ФИКС secondary_empty_log:
→ Симметрично с frontend: если GLM-5.3-Flash вернул пустой content
для пака — пишем явно в stderr, чтобы видеть потери в логах,
а не молча терять вклад второй модели.
→ Паки не трогаем — routers_admin (97k) пока терпит, но если
начнёт терять secondary — раздробим.
(05.10.2026) ФИКС single_model_v4_pro:
→ Отказались от dual-model (DeepSeek Flash + GLM Flash).
Причина: GLM добавлял мусор, Flash-версии ошибались на сложных файлах.
→ Теперь: только DeepSeek V4 Pro 0813 — флагман, reasoning, 1M контекст.
Один промпт → один ответ → один фильтр → меньше мусора.
→ MIN_CONFIDENCE: 0.75 → 0.80 — V4 Pro увереннее, но подняли порог,
чтобы отсеять спорные находки.
→ reasoning_effort="low" — V4 Pro: reasoning_effort="none"
игнорируется (тест 05.10.2026), "low" даёт минимальный reasoning
(~70 токенов на простой запрос).
→ MAX_OUTPUT_TOKENS: 8000 → 16000 — reasoning (~80%) + JSON (~20%).
"""
import json
@@ -29,8 +90,20 @@ GITEA_BOT_TOKEN = os.environ.get("BOT_TOKEN")
GITEA_INSTANCE = os.environ.get("GITEA_INSTANCE", "https://git.filwordspl.com")
GITEA_REPO = os.environ.get("GITEA_REPO", "Drobysh/filwordspl-backend")
MODEL = "deepseek-ai/DeepSeek-V4.1-Flash"
MAX_OUTPUT_TOKENS = 12000
# 🔧 ФИКС (05.10.2026): single_model_v4_pro —
# Отказались от dual-model (DeepSeek Flash + GLM Flash).
# Причина: GLM добавлял мусор, Flash-версии ошибались на сложных файлах.
# Теперь: только DeepSeek V4 Pro 0813 — флагман, reasoning, 1M контекст.
# Один промпт → один ответ → один фильтр → меньше мусора.
MODEL_PRIMARY = "deepseek-ai/DeepSeek-V4-Pro-0813"
USE_SECONDARY_MODEL = False
# V4 Pro: reasoning полностью НЕ отключается (тест 05.10.2026:
# reasoning_effort="none" игнорируется, "low" даёт ~70 токенов).
# max_tokens увеличен с 8000 до 16000 — reasoning (~80%) + JSON (~20%).
MAX_OUTPUT_TOKENS = 16000
REASONING_EFFORT = "low"
# Что игнорировать при сборе кода
IGNORE_DIRS = {
@@ -41,6 +114,7 @@ IGNORE_DIRS = {
IGNORE_FILES = {
"ai_review.py", "conftest.py", "code_summary.py",
"add_levels.py", "generate_levels_v2.py",
"__init__.py",
}
# Расширения, которые читаем
@@ -50,18 +124,71 @@ INCLUDE_EXTENSIONS = {".py"}
MAX_FILE_SIZE = 100_000
# Фильтр находок
MIN_CONFIDENCE = 0.7
# 🔧 ФИКС (05.10.2026): filter_more_strict —
# V4 Pro увереннее, но подняли порог с 0.75 до 0.80,
# чтобы отсеять спорные находки.
MIN_CONFIDENCE = 0.80
ALLOWED_SEVERITY = {"user_impact", "data_risk", "maintainability"}
# 🔧 ФИКС (26.09.2026): overshoot guard.
OVERSHOOT_LIMIT = 15
OVERSHOOT_KEEP = 10
# 🔧 НОВОЕ (22.09.2026): паки для backend
# Backend ~440K символов — не влезает в один запрос (finish=length).
# Разбиваем на 3 пака. Каждый пак — отдельный запрос к модели.
# Паки для backend. Пути проверены по факту (`ls routers/`).
PACKS = [
{
"name": "routers",
"paths": ["routers/"],
"description": "FastAPI-роутеры: эндпоинты, бизнес-логика, работа с БД",
"name": "routers_games",
"paths": [
"routers/game.py",
"routers/hints.py",
"routers/wordquiz.py",
"routers/bubblewords.py",
"routers/sentences.py",
"routers/typing.py",
"routers/pronunciation.py",
],
"description": "Игры: wordsearch, hints, quiz, bubbles, sentences, typing, pronunciation",
},
{
"name": "routers_learning_core",
"paths": ["routers/learning.py"],
"description": "Уроки: learning.py (эндпоинты + update_*)",
},
{
"name": "routers_learning_teacher",
"paths": ["routers/teacher.py"],
"description": "Учитель: teacher.py",
},
{
"name": "routers_learning_orch",
"paths": [
"routers/orchestrator.py",
"routers/learning_profile.py",
"routers/learning_data/",
],
"description": "Orchestrator + profile + learning_data",
},
{
"name": "routers_admin",
"paths": [
"routers/admin.py",
"routers/admin_content.py",
"routers/feed.py",
"routers/support.py",
],
"description": "Админ: dashboard, content editor, feed, support",
},
{
"name": "routers_misc",
"paths": [
"routers/achievements.py",
"routers/users.py",
"routers/leaderboard.py",
"routers/assistant.py",
"routers/tts.py",
],
"description": "Прочее: achievements, users, leaderboard, assistant, tts",
},
{
"name": "core",
@@ -70,8 +197,8 @@ PACKS = [
},
{
"name": "services",
"paths": ["services/", "scripts/"],
"description": "Сервисы и скрипты автоматизации",
"paths": ["scripts/"],
"description": "Скрипты автоматизации",
},
]
@@ -170,19 +297,21 @@ SYSTEM_PROMPT = """Ты — опытный техлид и ревьюер Python
}
]
ПРАВИЛА:
ПРАВИЛА (соблюдай строго):
1. severity — только одно из: "user_impact", "data_risk", "maintainability".
- user_impact: ученик видит баг, теряет прогресс, очки, доступ
- data_risk: порча БД, утечка, неверный auth/rate-limit
- maintainability: запах, дубль, устаревший API
2. snippet — ТОЧНАЯ цитата 1-3 строк из файла. Не перефразируй. Если не уверен — не включай находку.
3. confidence — число от 0 до 1. Если меньше 0.7 — не включай.
4. Максимум 10 находок за этот пак.
5. НЕ переписывай код. Только описывай, что не так и что сделать.
6. Без воды. Без общих слов.
7. Если проблем нет — верни пустой массив: []
3. confidence — число от 0 до 1. Если меньше 0.75 — НЕ включай.
4. МАКСИМУМ 10 находок за этот пак. Если находишь больше — выбери ТОП-10 по severity (user_impact > data_risk > maintainability).
5. НЕ пиши находки типа "Ок", "Не баг", "Работает корректно", "Не влияет на UX", "Не критично". Только РЕАЛЬНЫЕ проблемы.
6. НЕ комментируй каждую функцию. Только баги, security, UX.
7. НЕ переписывай код. Только описывай, что не так и что сделать.
8. Без воды. Без общих слов.
9. Если проблем нет — верни пустой массив: [].
Отвечай ТОЛЬКО JSON, без markdown-обёрток.
Отвечай ТОЛЬКО JSON, без markdown-обёрток. Не думай вслух — сразу выдавай JSON-массив.
"""
@@ -192,15 +321,17 @@ USER_PROMPT_TEMPLATE = """Проанализируй часть кода про
Пак: **{pack_name}** — {pack_description}
Ищи:
1. Баги и логические ошибки
Ищи ТОЛЬКО реальные проблемы:
1. Баги и логические ошибки (не "Ок", а "тут падает")
2. Проблемы безопасности (утечки, инъекции, неправильная валидация)
3. N+1 запросы к БД
4. Отсутствие обработки ошибок
4. Отсутствие обработки ошибок (где РЕАЛЬНО упадёт)
5. Дублирование кода
6. Мёртвый код
7. Слабые места архитектуры
НЕ пиши "Ок", "Не баг", "Работает корректно". Если проблем нет — верни [].
Верни JSON-массив находок по формату выше.
Вот код:
@@ -211,9 +342,14 @@ USER_PROMPT_TEMPLATE = """Проанализируй часть кода про
# ============ Запрос к Together AI ============
def call_together(code: str, pack: dict) -> str:
"""Отправляет код пака в DeepSeek V4.1 Flash."""
print(f" 🤖 Отправляю пак '{pack['name']}' в DeepSeek V4.1 Flash...")
def call_together_model(code: str, pack: dict, model_name: str) -> str:
"""Отправляет код пака в указанную модель.
🔧 ФИКС (05.10.2026): reasoning_effort_low —
V4 Pro: reasoning_effort="none" игнорируется (тест 05.10.2026),
"low" даёт минимальный reasoning.
"""
print(f" 🤖 Отправляю пак '{pack['name']}' в {model_name}...")
user_prompt = USER_PROMPT_TEMPLATE.format(
pack_name=pack["name"],
@@ -221,26 +357,32 @@ def call_together(code: str, pack: dict) -> str:
code=code,
)
payload = {
"model": model_name,
"messages": [
{"role": "system", "content": SYSTEM_PROMPT},
{"role": "user", "content": user_prompt},
],
"temperature": 0.2,
"max_tokens": MAX_OUTPUT_TOKENS,
# 🔧 ФИКС (05.10.2026): reasoning_effort_low —
# V4 Pro: reasoning_effort="none" игнорируется (тест 05.10.2026),
# "low" даёт минимальный reasoning (~70 токенов на простой запрос).
"reasoning_effort": REASONING_EFFORT,
}
response = httpx.post(
"https://api.together.xyz/v1/chat/completions",
headers={
"Authorization": f"Bearer {TOGETHER_API_KEY}",
"Content-Type": "application/json",
},
json={
"model": MODEL,
"messages": [
{"role": "system", "content": SYSTEM_PROMPT},
{"role": "user", "content": user_prompt},
],
"max_tokens": MAX_OUTPUT_TOKENS,
"temperature": 0.2,
},
json=payload,
timeout=300.0,
)
if response.status_code != 200:
print(f" ❌ Together AI вернул {response.status_code}", file=sys.stderr)
print(f" ❌ {model_name} вернул {response.status_code}", file=sys.stderr)
print(f" Ответ: {response.text[:500]}", file=sys.stderr)
return ""
@@ -250,27 +392,52 @@ def call_together(code: str, pack: dict) -> str:
message = data["choices"][0]["message"]
result = message.get("content")
if not result:
result = message.get("reasoning_content")
if not result:
raise KeyError("пусто")
raise KeyError("пусто (content отсутствует)")
except (KeyError, IndexError, TypeError) as e:
print(f" ❌ Формат ответа: {e}", file=sys.stderr)
# 🔧 ФИКС (26.09.2026, ночь): логируем длину reasoning-трейса,
# чтобы видно было, сколько токенов ушло на "мысли" до отказа.
reasoning_len = 0
try:
reasoning_len = len(
data["choices"][0]["message"].get("reasoning_content") or ""
)
except Exception:
pass
print(f" ❌ Формат ответа: {e} (reasoning_content: {reasoning_len} символов)", file=sys.stderr)
return ""
usage = data.get("usage", {})
finish = data["choices"][0].get("finish_reason", "unknown")
reasoning_len = len(data["choices"][0]["message"].get("reasoning_content") or "")
print(
f" ✅ Пак '{pack['name']}': вход={usage.get('prompt_tokens', 0)}, "
f"выход={usage.get('completion_tokens', 0)}, finish={finish}"
f" ✅ [{model_name.split('/')[-1]}] Пак '{pack['name']}': "
f"вход={usage.get('prompt_tokens', 0)}, "
f"выход={usage.get('completion_tokens', 0)}, "
f"reasoning≈{reasoning_len} симв., finish={finish}"
)
if finish == "length":
print(
f" ⚠️ Пак '{pack['name']}' обрезан по max_tokens ({model_name})",
file=sys.stderr,
)
return result
def call_together(code: str, pack: dict) -> str:
"""Backward-compat: одна модель (primary)."""
return call_together_model(code, pack, MODEL_PRIMARY)
# ============ Парсинг и фильтрация JSON ============
def extract_json(text: str) -> list[dict]:
"""Извлекает JSON-массив из ответа модели."""
"""Извлекает находки из ответа модели.
Парсим объекты по одному (json.JSONDecoder.raw_decode) и
останавливаемся на первом, который не удалось распарсить — то есть
спасаем всё, что модель успела сгенерить до обрезки.
"""
if not text:
return []
text = text.strip()
@@ -279,34 +446,107 @@ def extract_json(text: str) -> list[dict]:
text = re.sub(r"\s*```$", "", text)
start = text.find("[")
end = text.rfind("]")
if start == -1 or end == -1 or end < start:
if start == -1:
print(f" ⚠️ Не найден JSON-массив. Первые 300 символов:\n{text[:300]}", file=sys.stderr)
return []
json_str = text[start:end + 1]
decoder = json.JSONDecoder()
idx, n = start + 1, len(text)
results: list[dict] = []
while idx < n:
while idx < n and text[idx] in " \t\n\r,":
idx += 1
if idx >= n or text[idx] == "]":
break
try:
parsed = json.loads(json_str)
if not isinstance(parsed, list):
print(f" ⚠️ JSON не массив, а {type(parsed).__name__}", file=sys.stderr)
return []
return parsed
except json.JSONDecodeError as e:
print(f" ⚠️ Ошибка парсинга JSON: {e}", file=sys.stderr)
return []
obj, end = decoder.raw_decode(text, idx)
except json.JSONDecodeError:
break
if isinstance(obj, dict):
results.append(obj)
idx = end
if not results:
print(" ⚠️ Не удалось извлечь ни одной находки из ответа", file=sys.stderr)
return results
def merge_dual_findings(primary_raw: str, secondary_raw: str) -> list[dict]:
"""Объединяет находки от двух моделей.
Пересечение по (file, snippet) → confidence +0.05.
Только primary → normal.
Только secondary → normal.
"""
p_list = extract_json(primary_raw)
s_list = extract_json(secondary_raw)
def _key(f: dict) -> str:
return f"{(f.get('file') or '').strip()}::{(f.get('snippet') or '').strip()}"
p_map = {_key(f): f for f in p_list if isinstance(f, dict)}
s_map = {_key(f): f for f in s_list if isinstance(f, dict)}
merged: dict[str, dict] = {}
# Primary — base
for k, f in p_map.items():
item = dict(f)
item["_source"] = "primary"
if k in s_map:
# Пересечение — повышаем confidence
try:
conf = float(item.get("confidence", 0) or 0)
except (TypeError, ValueError):
conf = 0
item["confidence"] = min(1.0, round(conf + 0.05, 2))
item["_source"] = "both"
merged[k] = item
# Secondary — только то, чего нет в primary
for k, f in s_map.items():
if k not in merged:
item = dict(f)
item["_source"] = "secondary"
merged[k] = item
both_count = sum(1 for v in merged.values() if v.get("_source") == "both")
print(f" 🔗 Merge: primary={len(p_map)}, secondary={len(s_map)}, "
f"пересечение={both_count}, всего={len(merged)}")
return list(merged.values())
def validate_and_filter(
findings: list[dict],
files_map: dict[str, str],
) -> tuple[list[dict], dict[str, int]]:
"""Фильтрует находки: файл существует, snippet совпал, confidence ≥ 0.7, severity валидна."""
"""Фильтрует находки: файл существует, snippet совпал, confidence ≥ 0.75, severity валидна.
Overshoot guard — если находок > 15 на пак, берём только топ-10 по confidence.
"""
stats = {
"total": len(findings),
"overshoot": 0,
"no_file": 0, "snippet_mismatch": 0, "bad_severity": 0,
"low_confidence": 0, "no_effect_or_repro": 0, "passed": 0,
}
if len(findings) > OVERSHOOT_LIMIT:
print(
f" ⚠️ Overshoot: {len(findings)} находок (> {OVERSHOOT_LIMIT}), "
f"берём топ-{OVERSHOOT_KEEP} по confidence",
file=sys.stderr,
)
findings = sorted(
[f for f in findings if isinstance(f, dict)],
key=lambda x: float(x.get("confidence", 0) or 0),
reverse=True,
)[:OVERSHOOT_KEEP]
stats["overshoot"] = 1
passed: list[dict] = []
for f in findings:
@@ -370,7 +610,7 @@ def format_issue_body(
lines.append("# 🤖 AI Code Review (Backend)")
lines.append("")
lines.append(f"**Дата:** {date_str}")
lines.append(f"**Модель:** `{MODEL}`")
lines.append(f"**Модель:** `{MODEL_PRIMARY}`")
lines.append(f"**Репозиторий:** `{GITEA_REPO}`")
lines.append("")
lines.append("## 📊 По пакам")
@@ -398,7 +638,9 @@ def format_issue_body(
lines.append("")
for f in items:
counter += 1
lines.append(f"### {counter}. {f.get('id', 'без имени')}")
source = f.get("_source", "primary")
source_mark = "🔗 both" if source == "both" else ("🔵 secondary" if source == "secondary" else "")
lines.append(f"### {counter}. {f.get('id', 'без имени')} {source_mark}")
lines.append("")
lines.append(f"- **Файл:** `{f.get('file')}:{f.get('line', '?')}`")
lines.append(f"- **Snippet:** `{f.get('snippet', '').strip()[:120]}`")
@@ -411,6 +653,7 @@ def format_issue_body(
lines.append("---")
lines.append("")
lines.append(f"**Итого:** всего находок={total_stats['total']}, "
f"overshoot={total_stats.get('overshoot', 0)}, "
f"snippet не совпал={total_stats['snippet_mismatch']}, "
f"низкий confidence={total_stats['low_confidence']}, "
f"прошло={total_stats['passed']}")
@@ -457,7 +700,7 @@ def main() -> None:
all_passed: list[dict] = []
pack_stats: list[dict] = []
total_stats = {
"total": 0, "no_file": 0, "snippet_mismatch": 0,
"total": 0, "overshoot": 0, "no_file": 0, "snippet_mismatch": 0,
"bad_severity": 0, "low_confidence": 0,
"no_effect_or_repro": 0, "passed": 0,
}
@@ -471,8 +714,11 @@ def main() -> None:
pack_stats.append({"name": pack["name"], "files": 0, "symbols": 0, "findings": 0})
continue
raw = call_together(code, pack)
findings = extract_json(raw)
primary_raw = call_together_model(code, pack, MODEL_PRIMARY)
# 🔧 ФИКС (05.10.2026): single_model —
# только V4 Pro, без merge.
findings = extract_json(primary_raw)
filtered, stats = validate_and_filter(findings, files_map)
all_passed.extend(filtered)
+101
View File
@@ -0,0 +1,101 @@
#!/usr/bin/env python3
"""
Инвентаризация проекта: все эндпоинты + схема базы.
Запуск: python scripts/dump_inventory.py
Результат: endpoints_inventory.md + database_schema.md
"""
import asyncio
import re
import sys
from pathlib import Path
sys.path.insert(0, str(Path(__file__).parent.parent))
from database import get_pool
def dump_endpoints() -> None:
"""Собирает все эндпоинты из routers/*.py."""
routers_dir = Path("routers")
lines = ["# 🛣 Все эндпоинты проекта", ""]
total = 0
for router_file in sorted(routers_dir.glob("*.py")):
if router_file.name == "__init__.py":
continue
content = router_file.read_text(encoding="utf-8")
prefix_match = re.search(r'APIRouter\(prefix="([^"]+)"', content)
prefix = prefix_match.group(1) if prefix_match else ""
endpoints = re.findall(
r'@router\.(get|post|put|delete|patch)\("([^"]+)"',
content,
)
if endpoints:
lines.append(f"## {router_file.name}")
lines.append(f"**Префикс:** `{prefix}`")
lines.append("")
for method, path in endpoints:
full_path = f"{prefix}{path}" if path.startswith("/") else f"{prefix}/{path}"
lines.append(f"- `{method.upper()} {full_path}`")
total += 1
lines.append("")
Path("endpoints_inventory.md").write_text("\n".join(lines), encoding="utf-8")
print(f"✅ endpoints_inventory.md — {total} эндпоинтов")
async def dump_schema() -> None:
"""Собирает все таблицы и колонки из базы."""
pool = await get_pool()
async with pool.acquire() as conn:
tables = await conn.fetch("""
SELECT table_name
FROM information_schema.tables
WHERE table_schema = 'public'
AND table_type = 'BASE TABLE'
ORDER BY table_name
""")
lines = ["# 🗄 Схема базы данных", ""]
total = 0
for t in tables:
table_name = t["table_name"]
lines.append(f"## {table_name}")
lines.append("")
cols = await conn.fetch("""
SELECT column_name, data_type, is_nullable, column_default
FROM information_schema.columns
WHERE table_name = $1
ORDER BY ordinal_position
""", table_name)
lines.append("| Колонка | Тип | NULL | Default |")
lines.append("|---------|-----|------|---------|")
for c in cols:
nullable = "YES" if c["is_nullable"] == "YES" else "NO"
default = (c["column_default"] or "")[:50]
lines.append(f"| {c['column_name']} | {c['data_type']} | {nullable} | {default} |")
lines.append("")
total += 1
await pool.close()
Path("database_schema.md").write_text("\n".join(lines), encoding="utf-8")
print(f"✅ database_schema.md — {total} таблиц")
async def main() -> None:
dump_endpoints()
await dump_schema()
print("🎉 Готово!")
if __name__ == "__main__":
asyncio.run(main())
+61
View File
@@ -0,0 +1,61 @@
#!/usr/bin/env python3
"""Дамп схемы базы данных. Запуск: python scripts/dump_schema.py"""
import asyncio
import sys
from pathlib import Path
sys.path.insert(0, str(Path(__file__).parent.parent))
from database import get_pool
async def dump_schema() -> None:
pool = await get_pool()
async with pool.acquire() as conn:
print("🔍 Запрашиваю список таблиц...")
tables = await conn.fetch("""
SELECT table_name
FROM information_schema.tables
WHERE table_schema = 'public'
AND table_type = 'BASE TABLE'
ORDER BY table_name
""")
print(f"📋 Найдено таблиц: {len(tables)}")
lines = ["# 🗄 Схема базы данных", ""]
total = 0
for t in tables:
table_name = t["table_name"]
print(f" → {table_name}")
lines.append(f"## {table_name}")
lines.append("")
cols = await conn.fetch("""
SELECT column_name, data_type, is_nullable, column_default
FROM information_schema.columns
WHERE table_name = $1
ORDER BY ordinal_position
""", table_name)
lines.append("| Колонка | Тип | NULL | Default |")
lines.append("|---------|-----|------|---------|")
for c in cols:
nullable = "YES" if c["is_nullable"] == "YES" else "NO"
default = (c["column_default"] or "")[:50]
lines.append(f"| {c['column_name']} | {c['data_type']} | {nullable} | {default} |")
lines.append("")
total += 1
Path("database_schema.md").write_text("\n".join(lines), encoding="utf-8")
print(f"✅ database_schema.md — {total} таблиц")
async def main() -> None:
await dump_schema()
print("🎉 Готово!")
if __name__ == "__main__":
# БЕЗ pool.close() — пул закроется сам при выходе процесса.
asyncio.run(main())
+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,
}
+105
View File
@@ -0,0 +1,105 @@
# 🧪 Smoke-test отчёт (реальный юзер, реальная БД)
**Дата:** 2026-09-26 09:54 UTC
**Итого:** 77/77 сценариев прошли
## ✅ Подтверждено рабочим
- **pronunciation_pool_stress** (pronunciation) — 30/30 запросов, 30 уникальных слов
- **hints_db_increment** (hints) — GET=200, hints_used 0→1
- **game_complete_level_full_flow** (game) — idempotent=True, api=90, db=90
- **wordquiz_correct_answer** (wordquiz) — status=200, correct=True, score 0→50
- **wordquiz_wrong_answer** (wordquiz) — status=200, mistakes 0→1
- **bubblewords_complete_flow** (bubblewords) — status=200, levels 0→1, score 0→100
- **sentences_check_wrong** (sentences) — status=200, score 0→0 (неверный)
- **typing_progress_flow** (typing) — status=200, sentence_id=4704, recorded=True
- **users_set_language** (users) — status=200, lang pl→ru
- **achievements_track_login** (achievements) — status=200, logins 0→1
- **learning_levels_list** (learning) — status=200, уровней=6
- **learning_topics_list** (learning) — status=200, тем A1=15
- **learning_topic_detail** (learning) — status=200, topic_id=a1_greetings, уроков=10
- **learning_session_start** (learning) — status=200, session_id=368, в БД=True
- **learning_session_full_flow** (learning) — answer=True, recorded=True, complete=True, is_completed=True
- **learning_progress** (learning) — status=200, тем=27
- **learning_lesson_detail** (learning) — status=200, lesson=True, questions=True, examples=True
- **learning_topic_test** (learning) — status=200, test=True, total=20
- **learning_ai_context** (learning) — status=200, analytics=False, context=True, message=False
- **learning_practice_start** (learning) — status=200, has_weak_skills=False
- **teacher_progress** (teacher) — status=200, уровней=6
- **teacher_phrase_of_day** (teacher) — status=200, phrase=Codziennie rano biorę prysznic i piję ka
- **teacher_start_or_resume** (teacher) — status=200, type=lesson_explanation, session_recorded=True
- **teacher_resume_no_session** (teacher) — status=200, has_active_session=True
- **teacher_diagnostic_test** (teacher) — status=200, session_id=371, questions=15, type=diagnostic_test
- **teacher_answer_flow** (teacher) — status=200, reaction=True, is_correct=True, recorded=True
- **teacher_history_save_load** (teacher) — save=True, load=True, messages_match=True
- **teacher_history_clear** (teacher) — status=200, remaining=0
- **leaderboard_top** (leaderboard) — status=200, top3=3
- **assistant_limit** (assistant) — status=200, is_admin=False, used=0
- **assistant_history** (assistant) — status=200, сообщений=0
- **assistant_stats_personal** (assistant) — status=200, level=A1, score=240
- **assistant_stats_admin_forbidden** (assistant) — status=403 (ожидали 403 — тестовый юзер не админ)
- **support_user_tickets** (support) — status=200, тикетов=0
- **support_send** (support) — status=200, ticket_id=8, ticket_db=True, msg_db=True
- **support_unread_count** (support) — status=200, unread_count=0
- **admin_dashboard_forbidden** (admin) — status=403 (ожидали 403 — тестовый юзер не админ)
- **admin_sentry_errors_forbidden** (admin) — status=403 (ожидали 403 — тестовый юзер не админ)
- **feed_news_section** (feed) — status=200, постов=0
- **achievements_track_teacher_menu** (achievements) — status=200, new=1
- **achievements_track_progress** (achievements) — status=200, new=1
- **achievements_track_cheatsheets** (achievements) — status=200, new=1
- **achievements_track_pronunciation** (achievements) — status=200, new=1
- **achievements_track_ai_assistant** (achievements) — status=200, new=1
- **achievements_track_alphabet** (achievements) — status=200, new=1
- **achievements_track_rules** (achievements) — status=200, new=1
- **achievements_user** (achievements) — status=200, unlocked=14/56, percent=25.0
- **users_is_admin** (users) — status=200, is_admin=False
- **users_set_level** (users) — status=200, level A1→A2 (returned to A1)
- **hints_word_list** (hints) — status=200, words=5
- **hints_remaining** (hints) — status=200, used=2/3, remaining=1
- **game_progress** (game) — status=200, last=1, score=240
- **game_check_word** (game) — status=200, found=False (координаты произвольные)
- **wordquiz_next** (wordquiz) — status=200, correct=True, options=3, diff=easy
- **wordquiz_progress** (wordquiz) — status=200, words=1, score=50
- **bubblewords_next** (bubblewords) — status=200, words=3, bubbles=9, level=2
- **bubblewords_progress** (bubblewords) — status=200, levels=1, score=100
- **sentences_next** (sentences) — status=200, id=4542, words=4
- **sentences_stats** (sentences) — status=200, total=200, completed=0, percent=0.0
- **sentences_hint** (sentences) — first=200, recorded=True, second=403 (ожидали 403)
- **typing_next** (typing) — status=200, sentence_id=4701
- **typing_hint** (typing) — first=200, recorded=True, second=403 (ожидали 403)
- **typing_progress** (typing) — status=200, 1/200, remaining=199
- **achievements_all** (achievements) — status=200, всего=56
- **assistant_history_clear** (assistant) — status=200, remaining=0
- **admin_content_summary** (admin_content) — status=200, уровней=6
- **admin_content_word_levels** (admin_content) — status=200, уровней=6
- **admin_content_word_detail** (admin_content) — status=200, word_id=36807, word_pl=eksplodować
- **admin_content_texts_levels** (admin_content) — status=200, уровней=6
- **admin_content_lessons_levels** (admin_content) — status=200, уровней=6
- **admin_content_lesson_topics** (admin_content) — status=200, тем A1=15
- **admin_content_lesson_detail** (admin_content) — status=200, lesson=True, examples=3, questions=3
- **admin_content_wrong_because** (admin_content) — status=200, записей=7
- **admin_feed_section_news** (admin_feed) — status=200, постов=0
- **admin_feed_delete_not_found** (admin_feed) — status=404 (ожидали 404)
- **admin_feed_upload_requires_post_id** (admin_feed) — status=422 (ожидали 422)
- **admin_feed_forbidden_for_user** (admin_feed) — status=403 (ожидали 403 — юзер не админ)
## 📊 По секциям
- **achievements**: 10/10
- **admin**: 2/2
- **admin_content**: 8/8
- **admin_feed**: 4/4
- **assistant**: 5/5
- **bubblewords**: 3/3
- **feed**: 1/1
- **game**: 3/3
- **hints**: 3/3
- **leaderboard**: 1/1
- **learning**: 10/10
- **pronunciation**: 1/1
- **sentences**: 4/4
- **support**: 3/3
- **teacher**: 8/8
- **typing**: 4/4
- **users**: 3/3
- **wordquiz**: 4/4
+2482
View File
File diff suppressed because it is too large Load Diff