282 Commits
Author SHA1 Message Date
Drobysh e62a2e67a4 Merge pull request '[Eva] ты помнишь проблему с агентом Ева?)' (#67) from eva/chat-5b1483-backend into main
Reviewed-on: #67
2026-11-04 15:56:53 +00:00
Drobysh 1bdeb1afee [Eva] Fix Polish quotes in rule 16 title 2026-11-04 15:55:55 +00:00
Drobysh 152cf3c757 Merge pull request '[Eva] ты помнишь проблему с агентом Ева?)' (#66) from eva/chat-5b1483-backend into main
Reviewed-on: #66
2026-11-04 15:53:02 +00:00
Drobysh 9ab8aa05d8 [Eva] Данные правил 18-25 для seed-скрипта 2026-11-04 15:50:29 +00:00
Drobysh ec81779b8e [Eva] Данные правил 10-17 для seed-скрипта 2026-11-04 15:49:04 +00:00
Drobysh 4ac0604580 [Eva] Данные правил 1-9 для seed-скрипта 2026-11-04 15:47:44 +00:00
Drobysh 779390a616 [Eva] Скрипт наполнения БД правилами грамматики (логика + импорт данных) 2026-11-04 15:45:50 +00:00
Drobysh 259a2600ba [Eva] Скрипт наполнения БД правилами грамматики (часть 1: правила 1-9) 2026-11-04 15:43:15 +00:00
Drobysh ab7d087c1f [Eva] Добавить seed-скрипт правил грамматики (часть 3: правила 18-25) 2026-11-04 15:38:58 +00:00
Drobysh f6a05bb156 [Eva] Добавить seed-скрипт правил грамматики (часть 2: правила 10-17) 2026-11-04 15:37:30 +00:00
Drobysh 07a8848229 [Eva] Часть 1 удаляет только свои 9 правил по title_pl 2026-11-04 15:36:26 +00:00
Drobysh 53635dcc87 [Eva] Добавить seed-скрипт правил грамматики (часть 1: правила 1-9) 2026-11-04 15:34:15 +00:00
Drobysh 9a51437a7e [Eva] teacher.py: эндпоинт GET /teacher/materials 2026-11-04 15:27:32 +00:00
Drobysh f287a60fbb [Eva] seed_teacher_rules.py: убрать лишнюю скобку 2026-11-04 15:26:52 +00:00
Drobysh 651e82c06a [Eva] seed_teacher_rules.py: правило 25 (примеры uk/en) 2026-11-04 15:25:15 +00:00
Drobysh 9742789329 [Eva] seed_teacher_rules.py: правило 25 (часть 1) 2026-11-04 15:24:49 +00:00
Drobysh f43f8e0564 [Eva] seed_teacher_rules.py: правило 24 (условное наклонение) 2026-11-04 15:24:08 +00:00
Drobysh 24af0c1a18 [Eva] seed_teacher_rules.py: правило 23 (безличные конструкции) 2026-11-04 15:23:39 +00:00
Drobysh adde7b19a0 [Eva] seed_teacher_rules.py: правило 22 (вид глагола) 2026-11-04 15:23:17 +00:00
Drobysh 1427fdcbc8 [Eva] seed_teacher_rules.py: правило 21 (предлоги и падежи) 2026-11-04 15:22:53 +00:00
Drobysh 322f0b8974 [Eva] seed_teacher_rules.py: правило 20 (падежи) 2026-11-04 15:22:28 +00:00
Drobysh 3af4e0d098 [Eva] seed_teacher_rules.py: правило 19 (будущее время) 2026-11-04 15:22:09 +00:00
Drobysh 14e4f97ba2 [Eva] seed_teacher_rules.py: убрать маркер из части 2 2026-11-04 15:21:41 +00:00
Drobysh 7ff847c874 [Eva] seed_teacher_rules.py: правило 18 (прошедшее время) 2026-11-04 15:20:42 +00:00
Drobysh 4893d6aa7f [Eva] seed_teacher_rules.py: правило 17 (модальные глаголы) 2026-11-04 15:19:58 +00:00
Drobysh e02a621e30 [Eva] seed_teacher_rules.py: правило 16 (znać/wiedzieć) 2026-11-04 15:19:36 +00:00
Drobysh 2320ad2b92 [Eva] seed_teacher_rules.py: правило 15 (się) 2026-11-04 15:18:50 +00:00
Drobysh 11939f714e [Eva] seed_teacher_rules.py: правило 14 (отрицание nie) 2026-11-04 15:18:25 +00:00
Drobysh c245b22d23 [Eva] seed_teacher_rules.py: правило 13 (согласование прилагательных) 2026-11-04 15:17:59 +00:00
Drobysh 5ce4a61ffe [Eva] seed_teacher_rules.py: правило 12 (примеры uk/en) 2026-11-04 15:16:57 +00:00
Drobysh 48fc316f31 [Eva] seed_teacher_rules.py: правило 12 (часть 1) 2026-11-04 15:15:57 +00:00
Drobysh de5b617259 [Eva] seed_teacher_rules.py: правило 11 (глаголы движения) 2026-11-04 15:14:50 +00:00
Drobysh ed43c93f82 [Eva] seed_teacher_rules.py: правило 10 (числительные) 2026-11-04 15:14:31 +00:00
Drobysh 2a14612415 [Eva] seed_teacher_rules.py: часть 1 (правила 1–9) 2026-11-04 15:12:34 +00:00
Drobysh a81a2bf910 [Eva] teacher_materials: авто-миграция example_* колонок 2026-11-04 15:08:34 +00:00
Drobysh 4d932a54ab [Eva] teacher_materials: добавить example_* колонки 2026-11-04 15:08:06 +00:00
Drobysh 1f21310bc8 Merge pull request '[Eva] ты помнишь проблему с агентом Ева?)' (#65) from eva/chat-5b1483-backend into main
Reviewed-on: #65
2026-11-04 14:59:46 +00:00
Drobysh 1dd746b8c2 [Eva] Улучшен поиск материалов: синонимы категорий на 4 языках + фильтр по языку 2026-11-04 14:58:19 +00:00
Drobysh 435c25e438 Merge pull request '[Eva] ты помнишь проблему с агентом Ева?)' (#64) from eva/chat-5b1483-backend into main
Reviewed-on: #64
2026-11-04 14:51:49 +00:00
Drobysh 8b998e7d2c [Eva] Скрипт наполнения teacher_materials ложными друзьями (ru/uk) 2026-11-04 14:50:44 +00:00
Drobysh 4a90594c5c Merge pull request '[Eva] ты помнишь проблему с агентом Ева?)' (#63) from eva/chat-5b1483-backend into main
Reviewed-on: #63
2026-11-04 14:46:00 +00:00
Drobysh 2f0646bb25 [Eva] Вставить materials_instruction в промт 2026-11-04 14:44:41 +00:00
Drobysh 2052a474d3 [Eva] Добавить инструкцию по материалам в промт 2026-11-04 14:44:30 +00:00
Drobysh 5754ed5bbb [Eva] Подключить поиск материалов в free-message 2026-11-04 14:44:14 +00:00
Drobysh 1fd614e21f [Eva] Добавить поиск материалов по базе знаний 2026-11-04 14:44:01 +00:00
Drobysh 90488bf575 Merge pull request '[Eva] ты помнишь проблему с агентом Ева?)' (#62) from eva/chat-5b1483-backend into main
Reviewed-on: #62
2026-11-04 14:36:00 +00:00
Drobysh 618ff196d4 [Eva] Добавлена таблица teacher_materials для AI-учителя 2026-11-04 14:33:26 +00:00
Drobysh 18f8dfd285 Merge pull request '[Eva] ты помнишь проблему с агентом Ева?)' (#61) from eva/chat-5b1483-backend into main
Reviewed-on: #61
2026-11-04 14:19:53 +00:00
Drobysh c57bf3133e [Eva] Марек отвечает только про Польшу и польский язык 2026-11-04 14:18:08 +00:00
Drobysh 6196639d89 [Eva] Марек: контекст Pleily + нюансы по родному языку ученика 2026-11-04 14:15:14 +00:00
Drobysh b94e53562c Merge pull request '[Eva] ты помнишь проблему с агентом Ева?)' (#60) from eva/chat-5b1483-backend into main
Reviewed-on: #60
2026-11-03 18:20:31 +00:00
Drobysh 32e250ddae [Eva] Отключён лимит AI-запросов учителя (тестирование) 2026-11-03 18:17:40 +00:00
Drobysh 9f92995522 [Eva] Фикс счётчика AI-запросов: command_count вместо COUNT(*) 2026-11-03 18:17:19 +00:00
Drobysh fe6019ecbc [Eva] Убираем длинные тире в ответах AI учителя 2026-11-03 18:09:35 +00:00
Drobysh 0bb061c31f [Eva] Учитель AI: эндпоинт GET /teacher/ai-usage 2026-11-03 18:06:59 +00:00
Drobysh 0c6111d789 [Eva] Учитель AI: usage/limit при исчерпании лимита 2026-11-03 18:06:47 +00:00
Drobysh 5f72bfee6a [Eva] Учитель AI: usage/limit в ответе free-message 2026-11-03 18:06:38 +00:00
Drobysh f4f02f7078 [Eva] Учитель AI: запрет длинных тире в ответах 2026-11-03 18:06:24 +00:00
Drobysh af87fddeb4 Merge pull request '[Eva] ты помнишь проблему с агентом Ева?)' (#59) from eva/chat-5b1483-backend into main
Reviewed-on: #59
2026-11-03 10:45:02 +00:00
Drobysh 2e06012d23 [Eva] Скрипт генерации фразы дня для cron (5:00 утра) 2026-11-03 10:42:30 +00:00
Drobysh 750c03a57a Merge pull request '[Eva] ты помнишь проблему с агентом Ева?)' (#58) from eva/chat-5b1483-backend into main
Reviewed-on: #58
2026-11-02 09:48:32 +00:00
Drobysh 790eabbbef [Eva] Hard в филворде: 110 → 150 очков 2026-11-02 09:47:56 +00:00
Drobysh 4ba1d90f07 [Eva] complete-level проверяет, что все слова найдены 2026-11-02 09:47:49 +00:00
Drobysh eb26ba9a25 [Eva] Повторный свайп найденного слова больше не накручивает серию 2026-11-02 09:47:39 +00:00
Drobysh 3dcc61c92f [Eva] Добавлена колонка found_words в user_progress 2026-11-02 09:47:30 +00:00
Drobysh 707837b109 Merge pull request '[Eva] ты помнишь проблему с агентом Ева?)' (#57) from eva/chat-5b1483-backend into main
Reviewed-on: #57
2026-11-02 09:41:55 +00:00
Drobysh 4e444499d4 [Eva] Убрать мусорный суффикс из частей слова 2026-11-02 09:41:25 +00:00
Drobysh 06cb1ecbb0 [Eva] Убрать неиспользуемый импорт hashlib 2026-11-02 09:41:14 +00:00
Drobysh 4786a73c22 Merge pull request '[Eva] ты помнишь проблему с агентом Ева?)' (#56) from eva/chat-5b1483-backend into main
Reviewed-on: #56
2026-11-02 09:35:04 +00:00
Drobysh 1a8d85a51d [Eva] Hard в пузырях: очки 110 → 150 2026-11-02 09:34:04 +00:00
Drobysh bbca26826d Merge pull request '[Eva] **Цель:** превратить `support_screen.dar' (#55) from eva/chat-14ba33-backend into main
Reviewed-on: #55
2026-10-26 17:57:43 +00:00
Drobysh a679ca4e77 [Eva] schema: sentence_hints_used помечена устаревшей 2026-10-26 17:55:16 +00:00
Drobysh 871d7167e2 [Eva] reset: убрана sentence_hints_used из сброса 2026-10-26 17:55:07 +00:00
Drobysh 8fce00f1e1 [Eva] sentences: удалён эндпоинт /{id}/hint 2026-10-26 17:55:00 +00:00
Drobysh 17f7ed7370 [Eva] test_smoke: hint → show-answer (medium/hard/easy) 2026-10-26 17:54:56 +00:00
Drobysh 5fd4988985 Merge pull request '[Eva] **Цель:** превратить `support_screen.dar' (#54) from eva/chat-14ba33-backend into main
Reviewed-on: #54
2026-10-20 13:10:42 +00:00
Drobysh 361e2d9b61 [Eva] Убрать bubble_perfect_streak, добавить bubble_speed_10 2026-10-20 13:06:26 +00:00
Drobysh 73c88678dc [Eva] Убрать триггер bubble_no_mistakes 2026-10-20 13:06:16 +00:00
Drobysh e8a8d9f11e [Eva] Убрать триггер bubble_perfect 2026-10-20 13:06:06 +00:00
Drobysh 7d52b0232b [Eva] Заменить bubble_perfect_10 на bubble_speed_10 2026-10-20 13:05:55 +00:00
Drobysh 95058b2d3c [Eva] Заменить bubble_no_mistakes на bubble_words_1000 2026-10-20 13:05:38 +00:00
Drobysh 8a78368458 [Eva] Заменить bubble_perfect на bubble_streak_25 2026-10-20 13:05:28 +00:00
Drobysh 4598289f06 Merge pull request '[Eva] **Цель:** превратить `support_screen.dar' (#53) from eva/chat-14ba33-backend into main
Reviewed-on: #53
2026-10-19 11:09:08 +00:00
Drobysh 20674f0823 [Eva] Скрипт сброса прогресса и достижений пользователя 2026-10-19 11:06:55 +00:00
Drobysh 3d379c8357 Merge pull request '[Eva] Ева, привет! Новая задача: игра «Составь' (#52) from eva/chat-ec3e05-backend into main
Reviewed-on: #52
2026-10-16 11:59:54 +00:00
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 bcf4db0ddb Merge pull request '[Eva] Ева, привет! Новая задача: игра «Составь' (#51) from eva/chat-ec3e05-backend into main
Reviewed-on: #51
2026-10-16 11:08:49 +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 ce9f68ae51 Merge pull request '[Eva] Ева, привет! Новая задача: игра «Составь' (#50) from eva/chat-ec3e05-backend into main
Reviewed-on: #50
2026-10-16 10:59:05 +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
55 changed files with 18774 additions and 760 deletions
+3
View File
@@ -9,3 +9,6 @@ uploads/
.DS_Store .DS_Store
.env.save .env.save
.env.* .env.*
*.backup_*
*.sql
*.backup*
+1 -2
View File
@@ -10,9 +10,8 @@
import asyncio import asyncio
import asyncpg import asyncpg
import json import json
import os
import logging import logging
from datetime import datetime, timedelta, timezone from datetime import datetime
from decimal import Decimal from decimal import Decimal
from pathlib import Path from pathlib import Path
from config import DB_CONFIG from config import DB_CONFIG
+39 -25
View File
@@ -73,7 +73,6 @@ async def verify_telegram_initdata(init_data: str):
user_id = user_data.get('id') user_id = user_data.get('id')
username = user_data.get('username', '') username = user_data.get('username', '')
# 🔧 ФИКС (25.09.2026): unused_first_name — удалена мёртвая переменная.
if not user_id: if not user_id:
raise HTTPException(401, "User ID not found in initData") raise HTTPException(401, "User ID not found in initData")
@@ -83,52 +82,67 @@ async def verify_telegram_initdata(init_data: str):
except HTTPException: except HTTPException:
raise raise
except Exception as e: except Exception as e:
# 🔧 ФИКС (23.09.2026): auth_error_leak — раньше в 401 утекали
# внутренние детали (str(e)). Теперь логируем на сервере,
# клиенту — обобщённое сообщение.
logger.error(f"Auth error: {str(e)}", exc_info=True) logger.error(f"Auth error: {str(e)}", exc_info=True)
raise HTTPException(401, "Invalid initData") raise HTTPException(401, "Invalid initData")
async def require_auth(request: Request): async def require_auth(request: Request):
"""Извлекает и проверяет initData из запроса. """Извлекает и проверяет авторизацию из запроса.
🔧 ФИКС (23.09.2026): INIT_DATA_IN_URL — поддержка Authorization: tma <initData>. Пять режимов (в порядке приоритета):
Приоритет источников: 1. X-Admin-Token: <jwt> — админка через браузер (26.09.2026)
1. Authorization: tma <initData> — новый способ (фронт 23.09+) 2. Authorization: Bearer <jwt> — Pleily (07.10.2026)
2. X-Telegram-InitData — старый способ (фронт до 23.09) 3. Authorization: tma <initData> — Telegram Mini App
3. query-параметр initData — fallback для deleteFeedPost 4. X-Telegram-InitData — старый способ
(осознанное исключение из-за 5. query-параметр initData — fallback для deleteFeedPost
Cloudflare preflight-кеша)
Zero-downtime: старые и новые клиенты работают одновременно.
""" """
# ============ Режим 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 = '' init_data = ''
# 1. Authorization: tma <initData> (новый способ) # 3.1. Authorization: tma <initData>
auth_header = request.headers.get('Authorization', '')
if auth_header.startswith('tma '): if auth_header.startswith('tma '):
init_data = auth_header[4:].strip() init_data = auth_header[4:].strip()
# 2. X-Telegram-InitData (старый способ) # 3.2. X-Telegram-InitData (старый способ)
if not init_data: if not init_data:
init_data = request.headers.get('X-Telegram-InitData', '') init_data = request.headers.get('X-Telegram-InitData', '')
# 3. Query-параметр (fallback, нужен для deleteFeedPost) # 3.3. Query-параметр (fallback, нужен для deleteFeedPost)
if not init_data: if not init_data:
init_data = request.query_params.get('initData', '') init_data = request.query_params.get('initData', '')
if not init_data: if not init_data:
raise HTTPException( raise HTTPException(
401, 401,
"initData required. Pass as Authorization header 'tma <initData>' " "Authorization required. Pass 'X-Admin-Token' or "
"or 'X-Telegram-InitData' or query parameter 'initData'" "'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) user_id, username = await verify_telegram_initdata(init_data)
return user_id, username return user_id, username
+19 -1
View File
@@ -26,7 +26,16 @@ DB_CONFIG = {
# дефолтом был конкретный telegram_id (6694989403), который получал админку. # дефолтом был конкретный telegram_id (6694989403), который получал админку.
# Теперь дефолт пустой — админов нет, пока не задан ADMIN_IDS. # Теперь дефолт пустой — админов нет, пока не задан ADMIN_IDS.
ADMIN_IDS = [int(id_str) for id_str in os.getenv("ADMIN_IDS", "").split(",") if id_str.strip()] 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 часа слишком долго, # 🔧 ФИКС (23.09.2026): initdata_age_24h — 24 часа слишком долго,
# окно для replay-атак. Grok рекомендовал 4-6ч (компромисс между UX и безопасностью). # окно для replay-атак. Grok рекомендовал 4-6ч (компромисс между UX и безопасностью).
@@ -79,3 +88,12 @@ FEED_ALLOWED_IMAGE_TYPES = {
# Языки, на которые переводим feed-посты (используется в admin_feed translate) # Языки, на которые переводим feed-посты (используется в admin_feed translate)
FEED_TARGET_LANGUAGES = ["pl", "ru", "uk", "en"] FEED_TARGET_LANGUAGES = ["pl", "ru", "uk", "en"]
# ============ ADMIN PANEL (26.09.2026) ============
# Логин/пароль для входа в админку через браузер.
ADMIN_LOGIN = os.getenv("ADMIN_LOGIN", "admin")
ADMIN_PASSWORD_HASH = os.getenv("ADMIN_PASSWORD_HASH", "")
ADMIN_JWT_SECRET = os.getenv("ADMIN_JWT_SECRET", "")
# 🔧 НОВОЕ (07.10.2026): app_jwt_secret — JWT для Pleily
APP_JWT_SECRET = os.getenv("APP_JWT_SECRET", "")
+864 -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 ============ # ============ Авто-миграция: добавляем current_level в users ============
col_exists = await conn.fetchval(""" col_exists = await conn.fetchval("""
SELECT 1 FROM information_schema.columns SELECT 1 FROM information_schema.columns
@@ -192,6 +229,36 @@ async def init_db():
""") """)
logger.info("Added current_streak column to user_progress") logger.info("Added current_streak column to user_progress")
# ============ Авто-миграция: добавляем wave в user_progress ============
# 🔧 НОВОЕ (13.10.2026): wave — номер волны, к которой относится
# пройденный уровень. Нужен для подсчёта wave_points (сумма очков
# за 10 уровней волны) в модалке итогов волны.
col_exists = await conn.fetchval("""
SELECT 1 FROM information_schema.columns
WHERE table_name = 'user_progress' AND column_name = 'wave'
""")
if not col_exists:
await conn.execute("""
ALTER TABLE user_progress
ADD COLUMN wave INTEGER
""")
logger.info("Added wave column to user_progress")
# ============ Авто-миграция: добавляем found_words в user_progress ============
# 🔧 НОВОЕ (02.11.2026): found_words — список уже найденных слов уровня.
# Нужен, чтобы (1) повторный свайп найденного слова не накручивал
# серию и (2) complete-level мог проверить, что все слова найдены.
col_exists = await conn.fetchval("""
SELECT 1 FROM information_schema.columns
WHERE table_name = 'user_progress' AND column_name = 'found_words'
""")
if not col_exists:
await conn.execute("""
ALTER TABLE user_progress
ADD COLUMN found_words TEXT[] DEFAULT '{}'
""")
logger.info("Added found_words column to user_progress")
# ============ sentences ============ # ============ sentences ============
await conn.execute(""" await conn.execute("""
CREATE TABLE IF NOT EXISTS sentences ( CREATE TABLE IF NOT EXISTS sentences (
@@ -206,20 +273,31 @@ async def init_db():
) )
""") """)
# ============ Убираем старый UNIQUE constraint с sentences.sentence_number ============ # ============ Убираем составной UNIQUE (level, sentence_number) ============
await conn.execute(""" 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(""" await conn.execute("""
DO $$ DO $$
BEGIN BEGIN
IF NOT EXISTS ( IF NOT EXISTS (
SELECT 1 FROM pg_constraint SELECT 1 FROM pg_constraint
WHERE conname = 'sentences_sentence_number_unique' WHERE conname = 'sentences_sentence_number_key'
) THEN ) 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 IF;
END $$; END $$;
""") """)
@@ -248,6 +326,60 @@ async def init_db():
""") """)
logger.info("Added level column to sentence_progress") 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 ============ # ============ typing_progress ============
await conn.execute(""" await conn.execute("""
CREATE TABLE IF NOT EXISTS typing_progress ( CREATE TABLE IF NOT EXISTS typing_progress (
@@ -305,12 +437,17 @@ async def init_db():
""") """)
# ============ learning_topics ============ # ============ learning_topics ============
# 🔧 ОБНОВЛЕНО (04.10.2026): track — разделение аудиторий.
# 'pl' — для поляков (учёба на польском)
# 'ru_uk' — для славян (RU/UK ↔ PL, ОБЩИЙ track)
# 'en' — для англоязычных
await conn.execute(""" await conn.execute("""
CREATE TABLE IF NOT EXISTS learning_topics ( CREATE TABLE IF NOT EXISTS learning_topics (
id SERIAL PRIMARY KEY, id SERIAL PRIMARY KEY,
topic_id VARCHAR(100) UNIQUE NOT NULL, topic_id VARCHAR(100) UNIQUE NOT NULL,
level_code VARCHAR(10) NOT NULL, level_code VARCHAR(10) NOT NULL,
order_number INT NOT NULL, order_number INT NOT NULL,
track VARCHAR(10) NOT NULL DEFAULT 'ru_uk', -- 🔧 НОВОЕ
name_pl TEXT NOT NULL, name_pl TEXT NOT NULL,
name_ru TEXT NOT NULL, name_ru TEXT NOT NULL,
name_uk TEXT NOT NULL, name_uk TEXT NOT NULL,
@@ -324,6 +461,27 @@ async def init_db():
) )
""") """)
# 🔧 НОВОЕ (04.10.2026): track_auto_migration —
# для существующих БД добавляем колонку, если её нет.
col_exists = await conn.fetchval("""
SELECT 1 FROM information_schema.columns
WHERE table_name = 'learning_topics' AND column_name = 'track'
""")
if not col_exists:
await conn.execute("""
ALTER TABLE learning_topics
ADD COLUMN track VARCHAR(10) NOT NULL DEFAULT 'ru_uk'
""")
logger.info("Added track column to learning_topics")
# Backfill: все существующие темы → 'ru_uk' (славянский track)
await conn.execute("""
UPDATE learning_topics
SET track = 'ru_uk'
WHERE track IS NULL OR track = ''
""")
logger.info("Backfilled track='ru_uk' for existing topics")
# ============ learning_lessons ============ # ============ learning_lessons ============
await conn.execute(""" await conn.execute("""
CREATE TABLE IF NOT EXISTS learning_lessons ( CREATE TABLE IF NOT EXISTS learning_lessons (
@@ -430,6 +588,8 @@ async def init_db():
""") """)
# ============ user_learning_answers ============ # ============ user_learning_answers ============
# 🔧 ОБНОВЛЕНО (02.10.2026): добавлены revised и revision_of_id
# прямо в определение — на свежих БД создаются сразу.
await conn.execute(""" await conn.execute("""
CREATE TABLE IF NOT EXISTS user_learning_answers ( CREATE TABLE IF NOT EXISTS user_learning_answers (
id BIGSERIAL PRIMARY KEY, id BIGSERIAL PRIMARY KEY,
@@ -450,10 +610,46 @@ async def init_db():
hint_used BOOLEAN DEFAULT FALSE, hint_used BOOLEAN DEFAULT FALSE,
wrong_because VARCHAR(100), wrong_because VARCHAR(100),
is_final_answer BOOLEAN DEFAULT TRUE, is_final_answer BOOLEAN DEFAULT TRUE,
revised BOOLEAN DEFAULT FALSE, -- 🔧 НОВОЕ
revision_of_id BIGINT, -- 🔧 НОВОЕ
created_at TIMESTAMP DEFAULT NOW() created_at TIMESTAMP DEFAULT NOW()
) )
""") """)
# 🔧 НОВОЕ (02.10.2026): revised — фиксируем, что ученик
# поменял ответ после «Повторить урок».
col_exists = await conn.fetchval("""
SELECT 1 FROM information_schema.columns
WHERE table_name = 'user_learning_answers' AND column_name = 'revised'
""")
if not col_exists:
await conn.execute("""
ALTER TABLE user_learning_answers
ADD COLUMN revised BOOLEAN DEFAULT FALSE
""")
logger.info("Added revised column to user_learning_answers")
# 🔧 НОВОЕ (02.10.2026): revision_of_id — ссылка на предыдущий
# ответ этого же вопроса в этой же сессии. Позволяет строить
# цепочку: первый ответ → второй (после повтора) → третий.
col_exists = await conn.fetchval("""
SELECT 1 FROM information_schema.columns
WHERE table_name = 'user_learning_answers' AND column_name = 'revision_of_id'
""")
if not col_exists:
await conn.execute("""
ALTER TABLE user_learning_answers
ADD COLUMN revision_of_id BIGINT
""")
logger.info("Added revision_of_id column to user_learning_answers")
# Индекс для быстрого поиска цепочек повторов
await conn.execute("""
CREATE INDEX IF NOT EXISTS idx_learning_answers_revision
ON user_learning_answers(revision_of_id)
WHERE revision_of_id IS NOT NULL
""")
# ============ user_lesson_progress ============ # ============ user_lesson_progress ============
await conn.execute(""" await conn.execute("""
CREATE TABLE IF NOT EXISTS user_lesson_progress ( CREATE TABLE IF NOT EXISTS user_lesson_progress (
@@ -747,6 +943,20 @@ async def init_db():
""") """)
logger.info("Added current_mistakes column to word_quiz_progress") logger.info("Added current_mistakes column to word_quiz_progress")
# 🔧 НОВОЕ (15.10.2026): no_mistakes_streak — серия раундов без ошибок
# в «Выбери слово». +1 если раунд пройден без ошибок, иначе сброс в 0.
# Нужен для достижения quiz_no_mistakes_streak.
col_exists = await conn.fetchval("""
SELECT 1 FROM information_schema.columns
WHERE table_name = 'word_quiz_progress' AND column_name = 'no_mistakes_streak'
""")
if not col_exists:
await conn.execute("""
ALTER TABLE word_quiz_progress
ADD COLUMN no_mistakes_streak INTEGER DEFAULT 0
""")
logger.info("Added no_mistakes_streak column to word_quiz_progress")
# ============ bubble_words_progress ============ # ============ bubble_words_progress ============
await conn.execute(""" await conn.execute("""
CREATE TABLE IF NOT EXISTS bubble_words_progress ( CREATE TABLE IF NOT EXISTS bubble_words_progress (
@@ -782,6 +992,151 @@ async def init_db():
""") """)
logger.info("Added current_hints_used column to bubble_words_progress") logger.info("Added current_hints_used column to bubble_words_progress")
# 🔧 НОВОЕ (14.10.2026): current_list_opened — серверный счётчик
# «показать слова» для текущего уровня пузырей. Medium — 1 раз.
col_exists = await conn.fetchval("""
SELECT 1 FROM information_schema.columns
WHERE table_name = 'bubble_words_progress' AND column_name = 'current_list_opened'
""")
if not col_exists:
await conn.execute("""
ALTER TABLE bubble_words_progress
ADD COLUMN current_list_opened INT DEFAULT 0
""")
logger.info("Added current_list_opened column to bubble_words_progress")
# 🔧 НОВОЕ (14.10.2026): current_level_words — состояние текущего
# уровня пузырей (слова + части + переводы). Нужно для подсказок,
# т.к. уровень генерируется на лету в /next и нигде не хранится.
col_exists = await conn.fetchval("""
SELECT 1 FROM information_schema.columns
WHERE table_name = 'bubble_words_progress' AND column_name = 'current_level_words'
""")
if not col_exists:
await conn.execute("""
ALTER TABLE bubble_words_progress
ADD COLUMN current_level_words JSONB DEFAULT '[]'::jsonb
""")
logger.info("Added current_level_words column to bubble_words_progress")
# 🔧 НОВОЕ (14.10.2026): hinted_words — какие слова уже получили
# подсказку «первая часть» (для «каждый раз разное слово»).
col_exists = await conn.fetchval("""
SELECT 1 FROM information_schema.columns
WHERE table_name = 'bubble_words_progress' AND column_name = 'hinted_words'
""")
if not col_exists:
await conn.execute("""
ALTER TABLE bubble_words_progress
ADD COLUMN hinted_words TEXT[] DEFAULT '{}'
""")
logger.info("Added hinted_words column to bubble_words_progress")
# 🔧 НОВОЕ (15.10.2026): words_collected — суммарно собранных слов
# в пузырях. Нужен для достижения bubble_words (собрать N слов).
col_exists = await conn.fetchval("""
SELECT 1 FROM information_schema.columns
WHERE table_name = 'bubble_words_progress' AND column_name = 'words_collected'
""")
if not col_exists:
await conn.execute("""
ALTER TABLE bubble_words_progress
ADD COLUMN words_collected INTEGER DEFAULT 0
""")
logger.info("Added words_collected column to bubble_words_progress")
# 🔧 НОВОЕ (15.10.2026): no_hints_streak — серия уровней БЕЗ подсказок
# и без «показать слова». +1 если hints_used == 0 и not list_opened,
# иначе сброс в 0. Нужен для достижения bubble_streak.
col_exists = await conn.fetchval("""
SELECT 1 FROM information_schema.columns
WHERE table_name = 'bubble_words_progress' AND column_name = 'no_hints_streak'
""")
if not col_exists:
await conn.execute("""
ALTER TABLE bubble_words_progress
ADD COLUMN no_hints_streak INTEGER DEFAULT 0
""")
logger.info("Added no_hints_streak column to bubble_words_progress")
# 🔧 НОВОЕ (15.10.2026): perfect_streak — серия идеальных уровней
# (без подсказок + без списка + без ошибок). +1 если всё чисто,
# иначе сброс в 0. Нужен для достижения bubble_perfect_streak.
col_exists = await conn.fetchval("""
SELECT 1 FROM information_schema.columns
WHERE table_name = 'bubble_words_progress' AND column_name = 'perfect_streak'
""")
if not col_exists:
await conn.execute("""
ALTER TABLE bubble_words_progress
ADD COLUMN perfect_streak INTEGER DEFAULT 0
""")
logger.info("Added perfect_streak column to bubble_words_progress")
# ============ 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 ============ # ============ wrong_because_explanations ============
await conn.execute(""" await conn.execute("""
CREATE TABLE IF NOT EXISTS wrong_because_explanations ( CREATE TABLE IF NOT EXISTS wrong_because_explanations (
@@ -830,6 +1185,132 @@ async def init_db():
) )
""") """)
# ============ teacher_materials — материалы для AI-учителя ============
# 🔧 НОВОЕ (04.11.2026): единое хранилище материалов, на основе которых
# Марек (AI-учитель) отвечает. Вместо десятка таблиц — одна гибкая:
# category — тип материала (rule/cheatsheet/false_friend/word/text/
# alphabet/lesson/lecture/test/example/task), tags — теги для поиска
# (grammar/cases/verbs/...), level — A1..C2. Контент на 4 языках.
# Марек ищет материалы по тегам и отвечает на их основе (защита от
# галлюцинаций). Пополняется через Еву (Oleg пишет текст → Ева INSERT).
await conn.execute("""
CREATE TABLE IF NOT EXISTS teacher_materials (
id BIGSERIAL PRIMARY KEY,
category VARCHAR(50) NOT NULL,
title_pl TEXT,
title_ru TEXT,
title_uk TEXT,
title_en TEXT,
content_pl TEXT,
content_ru TEXT,
content_uk TEXT,
content_en TEXT,
example_pl TEXT,
example_ru TEXT,
example_uk TEXT,
example_en TEXT,
tags TEXT[] DEFAULT '{}',
level VARCHAR(10) DEFAULT 'A1',
is_active BOOLEAN DEFAULT TRUE,
created_at TIMESTAMP DEFAULT NOW(),
updated_at TIMESTAMP DEFAULT NOW()
)
""")
# Индекс по категории (быстрый выбор по типу материала)
await conn.execute("""
CREATE INDEX IF NOT EXISTS idx_teacher_materials_category
ON teacher_materials(category, is_active)
""")
# GIN-индекс по тегам (поиск по массиву тегов)
await conn.execute("""
CREATE INDEX IF NOT EXISTS idx_teacher_materials_tags
ON teacher_materials USING GIN (tags)
""")
# 🔧 НОВОЕ (04.11.2026): example_* — примеры к материалу.
# Правила грамматики состоят из трёх частей: заголовок (title),
# описание (content) и примеры (example). Для существующих БД
# добавляем колонки через ALTER TABLE (CREATE TABLE IF NOT EXISTS
# их не добавит).
for ex_col in ("example_pl", "example_ru", "example_uk", "example_en"):
col_exists = await conn.fetchval("""
SELECT 1 FROM information_schema.columns
WHERE table_name = 'teacher_materials' AND column_name = $1
""", ex_col)
if not col_exists:
await conn.execute(
f"ALTER TABLE teacher_materials ADD COLUMN {ex_col} TEXT"
)
logger.info(f"Added {ex_col} column to teacher_materials")
logger.info("Table teacher_materials initialized")
# ============ 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 — фраза дня ============ # ============ daily_phrases — фраза дня ============
await conn.execute(""" await conn.execute("""
CREATE TABLE IF NOT EXISTS daily_phrases ( CREATE TABLE IF NOT EXISTS daily_phrases (
@@ -989,13 +1470,387 @@ async def init_db():
# - idx_skill_mastery_user (user_id+skill_tag уже UNIQUE) # - idx_skill_mastery_user (user_id+skill_tag уже UNIQUE)
# - idx_user_progress_user (user_id+level_id уже PK) # - idx_user_progress_user (user_id+level_id уже PK)
# - idx_sentence_progress_user (user_id+sentence_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_levels_level_number ON levels(level, level_number)")
await conn.execute("CREATE INDEX IF NOT EXISTS idx_level_words_level_id ON level_words(level_id)") await conn.execute("CREATE INDEX IF NOT EXISTS idx_level_words_level_id ON level_words(level_id)")
await conn.execute("CREATE INDEX IF NOT EXISTS idx_level_words_level ON level_words(level)") await conn.execute("CREATE INDEX IF NOT EXISTS idx_level_words_level ON level_words(level)")
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)") await conn.execute("CREATE INDEX IF NOT EXISTS idx_sentences_level_number ON sentences(level, sentence_number)")
# Оставляем score-индексы (не дубли) # Оставляем score-индексы (не дубли)
await conn.execute("CREATE INDEX IF NOT EXISTS idx_user_progress_score ON user_progress(score DESC)") await conn.execute("CREATE INDEX IF NOT EXISTS idx_user_progress_score ON user_progress(score DESC)")
+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 1. Проверяет, есть ли фраза на сегодня в daily_phrases
2. Если нет — генерирует через AI (MiniMax-M3) 2. Если нет — генерирует через AI (DeepSeek V4 Pro)
3. Пишет в daily_phrases с phrase_date = CURRENT_DATE 3. Пишет в daily_phrases с phrase_date = CURRENT_DATE
Fallback: если AI упал — пишет запасную фразу. Fallback: если AI упал — пишет запасную фразу.
@@ -25,7 +25,7 @@ logging.basicConfig(
logger = logging.getLogger(__name__) logger = logging.getLogger(__name__)
TOGETHER_API_URL = "https://api.together.xyz/v1/chat/completions" TOGETHER_API_URL = "https://api.together.xyz/v1/chat/completions"
TEACHER_MODEL = "MiniMaxAI/MiniMax-M3" TEACHER_MODEL = "deepseek-ai/DeepSeek-V4-Pro-0813"
# Список тем для фразы дня # Список тем для фразы дня
TOPICS_LIST = [ TOPICS_LIST = [
@@ -119,7 +119,7 @@ EN_GRAMMAR: [грамматический разбор на английском
user_prompt = f"Создай фразу дня на тему: {selected_topic}." user_prompt = f"Создай фразу дня на тему: {selected_topic}."
ai_response = await call_ai(system_prompt, user_prompt, max_tokens=1000) ai_response = await call_ai(system_prompt, user_prompt, max_tokens=3000)
if not ai_response: if not ai_response:
logger.warning("AI returned empty response, using fallback") logger.warning("AI returned empty response, using fallback")
+30 -7
View File
@@ -2,18 +2,20 @@ import asyncio
import ipaddress import ipaddress
import logging import logging
import os import os
import re
import time import time
from collections import defaultdict from collections import defaultdict
from contextlib import asynccontextmanager from contextlib import asynccontextmanager
from pathlib import Path from fastapi import FastAPI, Request
from fastapi import FastAPI, Request, HTTPException
from fastapi.middleware.cors import CORSMiddleware from fastapi.middleware.cors import CORSMiddleware
from fastapi.responses import JSONResponse from fastapi.responses import JSONResponse
from fastapi.staticfiles import StaticFiles from fastapi.staticfiles import StaticFiles
from config import FRONTEND_ORIGIN, UPLOADS_DIR, CF_IPS from config import FRONTEND_ORIGINS, UPLOADS_DIR, CF_IPS
from database import init_db from database import init_db
from routers import users, game, hints, leaderboard, sentences, achievements, wordquiz, bubblewords, pronunciation, assistant, learning, tts, typing, teacher, support, admin, feed, admin_content from routers import users, game, hints, leaderboard, sentences, achievements, wordquiz, bubblewords, pronunciation, assistant, learning, tts, typing, teacher, support, admin, feed, admin_content
from routers import lectures, admin_auth, admin_wordsearch, admin_users
from routers import admin_ai # 🔧 НОВОЕ
from routers import app_auth # 🆕 Pleily auth
from routers import featured as featured_router # 🔧 НОВОЕ (08.10.2026)
from routers.sentences import init_sentences from routers.sentences import init_sentences
from routers.achievements import init_achievements from routers.achievements import init_achievements
from routers.learning_data import init_learning_data from routers.learning_data import init_learning_data
@@ -68,7 +70,10 @@ class RateLimiter:
"/game/check-word": {"max_requests": 30, "window": 60}, "/game/check-word": {"max_requests": 30, "window": 60},
"/game/complete-level": {"max_requests": 10, "window": 60}, "/game/complete-level": {"max_requests": 10, "window": 60},
"/sentences/check": {"max_requests": 20, "window": 60}, "/sentences/check": {"max_requests": 20, "window": 60},
"/leaderboard": {"max_requests": 10, "window": 60}, # 🔧 ФИКС (30.09.2026): leaderboard_rate_limit_too_low —
# Mini App делает несколько запросов подряд при загрузке страницы
# (аватар + данные + ре-рендер) → 429. Подняли до 30/мин.
"/leaderboard": {"max_requests": 30, "window": 60},
"/assistant/chat": {"max_requests": 20, "window": 60}, "/assistant/chat": {"max_requests": 20, "window": 60},
"/learning/answer": {"max_requests": 30, "window": 60}, "/learning/answer": {"max_requests": 30, "window": 60},
"/tts": {"max_requests": 30, "window": 60}, "/tts": {"max_requests": 30, "window": 60},
@@ -88,13 +93,21 @@ class RateLimiter:
# 🔧 ФИКС (22.09.2026): дорогой AI-эндпоинт без лимита выжигал бюджет. # 🔧 ФИКС (22.09.2026): дорогой AI-эндпоинт без лимита выжигал бюджет.
"/learning/analytics": {"max_requests": 5, "window": 60}, "/learning/analytics": {"max_requests": 5, "window": 60},
"/learning/practice/start": {"max_requests": 10, "window": 60}, "/learning/practice/start": {"max_requests": 10, "window": 60},
# 🆕 Pleily (07.10.2026): лимит на вход по device_id.
# Защищает от спама создания новых юзеров.
"/auth/device": {"max_requests": 5, "window": 60},
} }
self._cleanup_task = None self._cleanup_task = None
def _cleanup(self): def _cleanup(self):
# 🔧 ФИКС (25.09.2026): rate_limiter_cleanup_hardcoded_window —
# раньше жёстко 60с. Если добавить лимит с window > 60,
# записи удалялись бы раньше времени, и лимит не работал.
# Теперь: max(window) из self.limits.
now = time.time() now = time.time()
max_window = max(cfg["window"] for cfg in self.limits.values())
for key in list(self.requests.keys()): 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]: if not self.requests[key]:
del self.requests[key] del self.requests[key]
@@ -317,9 +330,11 @@ async def rate_limit_middleware(request: Request, call_next):
# ============ CORS ============ # ============ CORS ============
# 🔧 ФИКС (26.09.2026): admin_cors — добавлен admin.filwordspl.com в origins.
# Также добавлен X-Admin-Token в allow_headers для админ-авторизации.
app.add_middleware( app.add_middleware(
CORSMiddleware, CORSMiddleware,
allow_origins=[FRONTEND_ORIGIN], allow_origins=FRONTEND_ORIGINS,
allow_credentials=False, allow_credentials=False,
allow_methods=["GET", "POST", "PUT", "DELETE", "OPTIONS"], allow_methods=["GET", "POST", "PUT", "DELETE", "OPTIONS"],
# 🔧 ФИКС (23.09.2026): INIT_DATA_IN_URL — добавлен Authorization в явный список. # 🔧 ФИКС (23.09.2026): INIT_DATA_IN_URL — добавлен Authorization в явный список.
@@ -329,6 +344,7 @@ app.add_middleware(
"Authorization", "Authorization",
"Content-Type", "Content-Type",
"X-Telegram-InitData", "X-Telegram-InitData",
"X-Admin-Token",
], ],
) )
@@ -354,6 +370,13 @@ app.include_router(support.router)
app.include_router(admin.router) app.include_router(admin.router)
app.include_router(feed.router) app.include_router(feed.router)
app.include_router(admin_content.router) app.include_router(admin_content.router)
app.include_router(lectures.router)
app.include_router(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 urllib3==2.7.0
uvicorn==0.51.0 uvicorn==0.51.0
yarl==1.24.5 yarl==1.24.5
pdfplumber==0.11.10
PyJWT==2.15.1
+259 -63
View File
@@ -1,6 +1,6 @@
import logging import logging
from fastapi import APIRouter, Request, HTTPException from fastapi import APIRouter, Request
from auth import require_auth from auth import require_auth
from database import get_pool from database import get_pool
@@ -8,7 +8,7 @@ logger = logging.getLogger(__name__)
router = APIRouter(prefix="/achievements", tags=["achievements"]) router = APIRouter(prefix="/achievements", tags=["achievements"])
# ============ Данные 52 достижений ============ # ============ Данные 55 достижений ============
ACHIEVEMENTS_DATA = [ ACHIEVEMENTS_DATA = [
# ===== Word Search (11) ===== # ===== Word Search (11) =====
{"code": "first_level", "category": "wordsearch", "icon": "🔰", {"code": "first_level", "category": "wordsearch", "icon": "🔰",
@@ -66,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", "desc_pl": "Znajdź 5 słów bez błędu", "desc_ru": "Найти 5 слов подряд без ошибок", "desc_uk": "Знайти 5 слів без помилки", "desc_en": "Find 5 words without mistakes",
"type": "perfect_words", "value": 5}, "type": "perfect_words", "value": 5},
# ===== 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": "📝", {"code": "first_sentence", "category": "sentence", "icon": "📝",
"name_pl": "Debiutant", "name_ru": "Дебютант", "name_uk": "Дебютант", "name_en": "Debutant", "name_pl": "Debiutant", "name_ru": "Дебютант", "name_uk": "Дебютант", "name_en": "Debutant",
"desc_pl": "Ułóż 1 zdanie", "desc_ru": "Составить 1 предложение", "desc_uk": "Скласти 1 речення", "desc_en": "Build 1 sentence", "desc_pl": "Ułóż 1 zdanie", "desc_ru": "Составить 1 предложение", "desc_uk": "Скласти 1 речення", "desc_en": "Build 1 sentence",
@@ -92,20 +138,16 @@ ACHIEVEMENTS_DATA = [
"desc_pl": "Ułóż 200 zdań", "desc_ru": "Составить 200 предложений", "desc_uk": "Скласти 200 речень", "desc_en": "Build 200 sentences", "desc_pl": "Ułóż 200 zdań", "desc_ru": "Составить 200 предложений", "desc_uk": "Скласти 200 речень", "desc_en": "Build 200 sentences",
"type": "sentences_completed", "value": 200}, "type": "sentences_completed", "value": 200},
{"code": "perfect_sentence_5", "category": "sentence", "icon": "✨", {"code": "sentence_500", "category": "sentence", "icon": "🌟",
"name_pl": "Perfekcjonista", "name_ru": "Перфекционист", "name_uk": "Перфекціоніст", "name_en": "Perfectionist", "name_pl": "Legenda zdań", "name_ru": "Легенда предложений", "name_uk": "Легенда речень", "name_en": "Sentence Legend",
"desc_pl": "Ułóż 5 zdań bez błędu", "desc_ru": "Составить 5 предложений без единой ошибки", "desc_uk": "Скласти 5 речень без жодної помилки", "desc_en": "Build 5 sentences without mistakes", "desc_pl": "Ułóż 500 zdań", "desc_ru": "Составить 500 предложений", "desc_uk": "Скласти 500 речень", "desc_en": "Build 500 sentences",
"type": "perfect_sentences", "value": 5}, "type": "sentences_completed", "value": 500},
{"code": "sentence_perfect_10", "category": "sentence", "icon": "💎", {"code": "sentence_1000", "category": "sentence", "icon": "👑",
"name_pl": "Mistrz zdań", "name_ru": "Мастер предложений", "name_uk": "Майстер речень", "name_en": "Sentence Master", "name_pl": "Guru zdań", "name_ru": "Гуру предложений", "name_uk": "Гуру речень", "name_en": "Sentence Guru",
"desc_pl": "Ułóż 10 zdań bez błędu", "desc_ru": "Составить 10 предложений без ошибок", "desc_uk": "Скласти 10 речень без помилок", "desc_en": "Build 10 sentences without mistakes", "desc_pl": "Ułóż 1000 zdań", "desc_ru": "Составить 1000 предложений", "desc_uk": "Скласти 1000 речень", "desc_en": "Build 1000 sentences",
"type": "perfect_sentences", "value": 10}, "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": "🚀", {"code": "speed_10", "category": "sentence", "icon": "🚀",
"name_pl": "Turbo", "name_ru": "Турбо", "name_uk": "Турбо", "name_en": "Turbo", "name_pl": "Turbo", "name_ru": "Турбо", "name_uk": "Турбо", "name_en": "Turbo",
@@ -117,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", "desc_pl": "Ułóż zdanie w mniej niż 5 sekund", "desc_ru": "Составить предложение быстрее 5 секунд", "desc_uk": "Скласти речення швидше 5 секунд", "desc_en": "Build a sentence in under 5 seconds",
"type": "speed_sentence", "value": 5}, "type": "speed_sentence", "value": 5},
# ===== Word Quiz (8) ===== {"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": "🧠", {"code": "quiz_10", "category": "wordquiz", "icon": "🧠",
"name_pl": "Myśliciel", "name_ru": "Мыслитель", "name_uk": "Мислитель", "name_en": "Thinker", "name_pl": "Myśliciel", "name_ru": "Мыслитель", "name_uk": "Мислитель", "name_en": "Thinker",
"desc_pl": "Odgadnij 10 słów w Quiz słownym", "desc_ru": "Угадать 10 слов в Квизе слов", "desc_uk": "Відгадати 10 слів у Квізі слів", "desc_en": "Guess 10 words in Word Quiz", "desc_pl": "Odgadnij 10 słów w Quiz słownym", "desc_ru": "Угадать 10 слов в Квизе слов", "desc_uk": "Відгадати 10 слів у Квізі слів", "desc_en": "Guess 10 words in Word Quiz",
@@ -136,29 +233,89 @@ ACHIEVEMENTS_DATA = [
{"code": "quiz_perfect_10", "category": "wordquiz", "icon": "💎", {"code": "quiz_perfect_10", "category": "wordquiz", "icon": "💎",
"name_pl": "Idealny wynik", "name_ru": "Идеальный результат", "name_uk": "Ідеальний результат", "name_en": "Perfect Score", "name_pl": "Idealny wynik", "name_ru": "Идеальный результат", "name_uk": "Ідеальний результат", "name_en": "Perfect Score",
"desc_pl": "Odgadnij 10 słów bez pomyłki", "desc_ru": "Угадать 10 слов без ошибок", "desc_uk": "Відгадати 10 слів без помилок", "desc_en": "Guess 10 words without mistakes", "desc_pl": "Odgadnij 10 słów bez pomyłki", "desc_ru": "Угадать 10 слов без ошибок", "desc_uk": "Відгадати 10 слів без помилок", "desc_en": "Guess 10 words without mistakes",
"type": "quiz_perfect_streak", "value": 10}, "type": "quiz_correct_streak", "value": 10},
{"code": "quiz_streak_20", "category": "wordquiz", "icon": "🔥", {"code": "quiz_streak_20", "category": "wordquiz", "icon": "🔥",
"name_pl": "Niepowstrzymany", "name_ru": "Неудержимый", "name_uk": "Невтримний", "name_en": "Unstoppable", "name_pl": "Niepowstrzymany", "name_ru": "Неудержимый", "name_uk": "Невтримний", "name_en": "Unstoppable",
"desc_pl": "Odgadnij 20 słów z rzędu", "desc_ru": "Угадать 20 слов подряд", "desc_uk": "Відгадати 20 слів поспіль", "desc_en": "Guess 20 words in a row", "desc_pl": "Odgadnij 20 słów z rzędu", "desc_ru": "Угадать 20 слов подряд", "desc_uk": "Відгадати 20 слів поспіль", "desc_en": "Guess 20 words in a row",
"type": "quiz_perfect_streak", "value": 20}, "type": "quiz_correct_streak", "value": 20},
{"code": "quiz_speed", "category": "wordquiz", "icon": "⚡", {"code": "quiz_speed", "category": "wordquiz", "icon": "⚡",
"name_pl": "Błyskawica", "name_ru": "Молния", "name_uk": "Блискавка", "name_en": "Lightning", "name_pl": "Błyskawica", "name_ru": "Молния", "name_uk": "Блискавка", "name_en": "Lightning",
"desc_pl": "Odgadnij słowo w mniej niż 3 sekundy", "desc_ru": "Угадать слово быстрее 3 секунд", "desc_uk": "Відгадати слово швидше 3 секунд", "desc_en": "Guess a word in under 3 seconds", "desc_pl": "Odgadnij słowo w mniej niż 3 sekundy", "desc_ru": "Угадать слово быстрее 3 секунд", "desc_uk": "Відгадати слово швидше 3 секунд", "desc_en": "Guess a word in under 3 seconds",
"type": "quiz_speed", "value": 3}, "type": "quiz_speed_3", "value": 3},
{"code": "quiz_speed_2", "category": "wordquiz", "icon": "🚀", {"code": "quiz_speed_2", "category": "wordquiz", "icon": "🚀",
"name_pl": "Super szybki", "name_ru": "Супер быстрый", "name_uk": "Супер швидкий", "name_en": "Super Fast", "name_pl": "Super szybki", "name_ru": "Супер быстрый", "name_uk": "Супер швидкий", "name_en": "Super Fast",
"desc_pl": "Odgadnij słowo w mniej niż 2 sekundy", "desc_ru": "Угадать слово быстрее 2 секунд", "desc_uk": "Відгадати слово швидше 2 секунд", "desc_en": "Guess a word in under 2 seconds", "desc_pl": "Odgadnij słowo w mniej niż 2 sekundy", "desc_ru": "Угадать слово быстрее 2 секунд", "desc_uk": "Відгадати слово швидше 2 секунд", "desc_en": "Guess a word in under 2 seconds",
"type": "quiz_speed", "value": 2}, "type": "quiz_speed_2", "value": 2},
{"code": "quiz_no_mistakes", "category": "wordquiz", "icon": "🏆", {"code": "quiz_no_mistakes", "category": "wordquiz", "icon": "🏆",
"name_pl": "Bezbłędny", "name_ru": "Безошибочный", "name_uk": "Безпомилковий", "name_en": "Flawless", "name_pl": "Bezbłędny", "name_ru": "Безошибочный", "name_uk": "Безпомилковий", "name_en": "Flawless",
"desc_pl": "Odgadnij słowo bez żadnej pomyłki", "desc_ru": "Угадать слово без единой ошибки", "desc_uk": "Відгадати слово без жодної помилки", "desc_en": "Guess a word without any mistakes", "desc_pl": "Odgadnij słowo bez żadnej pomyłki", "desc_ru": "Угадать слово без единой ошибки", "desc_uk": "Відгадати слово без жодної помилки", "desc_en": "Guess a word without any mistakes",
"type": "quiz_no_mistakes", "value": 1}, "type": "quiz_no_mistakes", "value": 1},
# ===== Bubble Words (8) ===== {"code": "quiz_1", "category": "wordquiz", "icon": "🎯",
"name_pl": "Pierwszy krok", "name_ru": "Первый шаг", "name_uk": "Перший крок", "name_en": "First Step",
"desc_pl": "Odgadnij 1 słowo", "desc_ru": "Угадать 1 слово", "desc_uk": "Вгадати 1 слово", "desc_en": "Guess 1 word",
"type": "quiz_guessed", "value": 1},
{"code": "quiz_25", "category": "wordquiz", "icon": "🎓",
"name_pl": "Uczeń", "name_ru": "Ученик", "name_uk": "Учень", "name_en": "Student",
"desc_pl": "Odgadnij 25 słów", "desc_ru": "Угадать 25 слов", "desc_uk": "Вгадати 25 слів", "desc_en": "Guess 25 words",
"type": "quiz_guessed", "value": 25},
{"code": "quiz_200", "category": "wordquiz", "icon": "📚",
"name_pl": "Erudyta", "name_ru": "Эрудит", "name_uk": "Ерудит", "name_en": "Erudite",
"desc_pl": "Odgadnij 200 słów", "desc_ru": "Угадать 200 слов", "desc_uk": "Вгадати 200 слів", "desc_en": "Guess 200 words",
"type": "quiz_guessed", "value": 200},
{"code": "quiz_500", "category": "wordquiz", "icon": "🌟",
"name_pl": "Legenda", "name_ru": "Легенда", "name_uk": "Легенда", "name_en": "Legend",
"desc_pl": "Odgadnij 500 słów", "desc_ru": "Угадать 500 слов", "desc_uk": "Вгадати 500 слів", "desc_en": "Guess 500 words",
"type": "quiz_guessed", "value": 500},
{"code": "quiz_1000", "category": "wordquiz", "icon": "👑",
"name_pl": "Guru", "name_ru": "Гуру", "name_uk": "Гуру", "name_en": "Guru",
"desc_pl": "Odgadnij 1000 słów", "desc_ru": "Угадать 1000 слов", "desc_uk": "Вгадати 1000 слів", "desc_en": "Guess 1000 words",
"type": "quiz_guessed", "value": 1000},
{"code": "quiz_correct_streak_5", "category": "wordquiz", "icon": "🔥",
"name_pl": "Seria", "name_ru": "Серия", "name_uk": "Серія", "name_en": "Streak",
"desc_pl": "5 poprawnych z rzędu", "desc_ru": "5 правильных подряд", "desc_uk": "5 правильних поспіль", "desc_en": "5 correct in a row",
"type": "quiz_correct_streak", "value": 5},
{"code": "quiz_streak_30", "category": "wordquiz", "icon": "💪",
"name_pl": "Na fali", "name_ru": "На волне", "name_uk": "На хвилі", "name_en": "On Fire",
"desc_pl": "30 poprawnych z rzędu", "desc_ru": "30 правильных подряд", "desc_uk": "30 правильних поспіль", "desc_en": "30 correct in a row",
"type": "quiz_correct_streak", "value": 30},
{"code": "quiz_streak_50", "category": "wordquiz", "icon": "🏆",
"name_pl": "Niezwyciężony", "name_ru": "Непобедимый", "name_uk": "Непереможний", "name_en": "Invincible",
"desc_pl": "50 poprawnych z rzędu", "desc_ru": "50 правильных подряд", "desc_uk": "50 правильних поспіль", "desc_en": "50 correct in a row",
"type": "quiz_correct_streak", "value": 50},
{"code": "quiz_no_mistakes_3", "category": "wordquiz", "icon": "✨",
"name_pl": "Czysta trójka", "name_ru": "Чистая тройка", "name_uk": "Чиста трійка", "name_en": "Clean Three",
"desc_pl": "3 rundy bez błędu z rzędu", "desc_ru": "3 раунда без ошибок подряд", "desc_uk": "3 раунди без помилок поспіль", "desc_en": "3 rounds without mistakes in a row",
"type": "quiz_no_mistakes_streak", "value": 3},
{"code": "quiz_perfect_25", "category": "wordquiz", "icon": "💎",
"name_pl": "Perfekcjonista", "name_ru": "Перфекционист", "name_uk": "Перфекціоніст", "name_en": "Perfectionist",
"desc_pl": "25 rund bez błędu z rzędu", "desc_ru": "25 раундов без ошибок подряд", "desc_uk": "25 раундів без помилок поспіль", "desc_en": "25 rounds without mistakes in a row",
"type": "quiz_no_mistakes_streak", "value": 25},
{"code": "quiz_speed_5", "category": "wordquiz", "icon": "⚡",
"name_pl": "Szybki", "name_ru": "Быстрый", "name_uk": "Швидкий", "name_en": "Fast",
"desc_pl": "Odgadnij słowo w mniej niż 5 sekund", "desc_ru": "Угадать слово быстрее 5 секунд", "desc_uk": "Вгадати слово швидше 5 секунд", "desc_en": "Guess a word in under 5 seconds",
"type": "quiz_speed_5", "value": 5},
{"code": "quiz_speed_1", "category": "wordquiz", "icon": "🚀",
"name_pl": "Błyskawica", "name_ru": "Молния", "name_uk": "Блискавка", "name_en": "Lightning",
"desc_pl": "Odgadnij słowo w mniej niż 1 sekundę", "desc_ru": "Угадать слово быстрее 1 секунды", "desc_uk": "Вгадати слово швидше 1 секунди", "desc_en": "Guess a word in under 1 second",
"type": "quiz_speed_1", "value": 1},
# ===== Bubble Words (20) =====
{"code": "bubble_5", "category": "bubblewords", "icon": "🫧", {"code": "bubble_5", "category": "bubblewords", "icon": "🫧",
"name_pl": "Początkujący", "name_ru": "Начинающий", "name_uk": "Початківець", "name_en": "Beginner", "name_pl": "Początkujący", "name_ru": "Начинающий", "name_uk": "Початківець", "name_en": "Beginner",
"desc_pl": "Ukończ 5 poziomów w Bąbelkach słów", "desc_ru": "Пройти 5 уровней в Пузырях слов", "desc_uk": "Пройти 5 рівнів у Бульбашках слів", "desc_en": "Complete 5 levels in Bubble Words", "desc_pl": "Ukończ 5 poziomów w Bąbelkach słów", "desc_ru": "Пройти 5 уровней в Пузырях слов", "desc_uk": "Пройти 5 рівнів у Бульбашках слів", "desc_en": "Complete 5 levels in Bubble Words",
@@ -184,22 +341,82 @@ ACHIEVEMENTS_DATA = [
"desc_pl": "Ukończ poziom bez podpowiedzi", "desc_ru": "Пройти уровень без подсказок", "desc_uk": "Пройти рівень без підказок", "desc_en": "Complete a level without hints", "desc_pl": "Ukończ poziom bez podpowiedzi", "desc_ru": "Пройти уровень без подсказок", "desc_uk": "Пройти рівень без підказок", "desc_en": "Complete a level without hints",
"type": "bubble_no_hints", "value": 1}, "type": "bubble_no_hints", "value": 1},
{"code": "bubble_perfect", "category": "bubblewords", "icon": "✨", {"code": "bubble_streak_25", "category": "bubblewords", "icon": "🔥",
"name_pl": "Perfekcyjny", "name_ru": "Идеальный", "name_uk": "Ідеальний", "name_en": "Perfect", "name_pl": "Dwadzieścia pięć z rzędu", "name_ru": "Двадцать пять подряд", "name_uk": "Двадцять п'ять поспіль", "name_en": "Twenty-Five in a Row",
"desc_pl": "Ukończ poziom z maksymalną punktacją (100)", "desc_ru": "Пройти уровень с максимальным счётом (100)", "desc_uk": "Пройти рівень з максимальним рахунком (100)", "desc_en": "Complete a level with maximum score (100)", "desc_pl": "Ukończ 25 poziomów z rzędu bez podpowiedzi", "desc_ru": "Пройти 25 уровней подряд без подсказок", "desc_uk": "Пройти 25 рівнів поспіль без підказок", "desc_en": "Complete 25 levels in a row without hints",
"type": "bubble_perfect", "value": 1}, "type": "bubble_streak", "value": 25},
{"code": "bubble_speed", "category": "bubblewords", "icon": "🚀", {"code": "bubble_speed", "category": "bubblewords", "icon": "🚀",
"name_pl": "Szybki bańki", "name_ru": "Быстрые пузыри", "name_uk": "Швидкі бульбашки", "name_en": "Fast Bubbles", "name_pl": "Szybki bańki", "name_ru": "Быстрые пузыри", "name_uk": "Швидкі бульбашки", "name_en": "Fast Bubbles",
"desc_pl": "Ukończ poziom w mniej niż 45 sekund", "desc_ru": "Пройти уровень быстрее 45 секунд", "desc_uk": "Пройти рівень швидше 45 секунд", "desc_en": "Complete a level in under 45 seconds", "desc_pl": "Ukończ poziom w mniej niż 45 sekund", "desc_ru": "Пройти уровень быстрее 45 секунд", "desc_uk": "Пройти рівень швидше 45 секунд", "desc_en": "Complete a level in under 45 seconds",
"type": "bubble_speed", "value": 45}, "type": "bubble_speed_45", "value": 45},
{"code": "bubble_speed_30", "category": "bubblewords", "icon": "⚡", {"code": "bubble_speed_30", "category": "bubblewords", "icon": "⚡",
"name_pl": "Bąbelkowa błyskawica", "name_ru": "Пузырьковая молния", "name_uk": "Бульбашкова блискавка", "name_en": "Bubble Lightning", "name_pl": "Bąbelkowa błyskawica", "name_ru": "Пузырьковая молния", "name_uk": "Бульбашкова блискавка", "name_en": "Bubble Lightning",
"desc_pl": "Ukończ poziom w mniej niż 30 sekund", "desc_ru": "Пройти уровень быстрее 30 секунд", "desc_uk": "Пройти рівень швидше 30 секунд", "desc_en": "Complete a level in under 30 seconds", "desc_pl": "Ukończ poziom w mniej niż 30 sekund", "desc_ru": "Пройти уровень быстрее 30 секунд", "desc_uk": "Пройти рівень швидше 30 секунд", "desc_en": "Complete a level in under 30 seconds",
"type": "bubble_speed", "value": 30}, "type": "bubble_speed_30", "value": 30},
# ===== General (15) ===== {"code": "bubble_1", "category": "bubblewords", "icon": "🫧",
"name_pl": "Pierwszy bąbelek", "name_ru": "Первый пузырь", "name_uk": "Перша бульбашка", "name_en": "First Bubble",
"desc_pl": "Ukończ 1 poziom w Bąbelkach słów", "desc_ru": "Пройти 1 уровень в Пузырях слов", "desc_uk": "Пройти 1 рівень у Бульбашках слів", "desc_en": "Complete 1 level in Bubble Words",
"type": "bubble_levels", "value": 1},
{"code": "bubble_10", "category": "bubblewords", "icon": "🫧",
"name_pl": "Dziesięć bąbelków", "name_ru": "Десять пузырей", "name_uk": "Десять бульбашок", "name_en": "Ten Bubbles",
"desc_pl": "Ukończ 10 poziomów w Bąbelkach słów", "desc_ru": "Пройти 10 уровней в Пузырях слов", "desc_uk": "Пройти 10 рівнів у Бульбашках слів", "desc_en": "Complete 10 levels in Bubble Words",
"type": "bubble_levels", "value": 10},
{"code": "bubble_words_25", "category": "bubblewords", "icon": "📚",
"name_pl": "Kolekcjoner", "name_ru": "Собиратель", "name_uk": "Колекціонер", "name_en": "Collector",
"desc_pl": "Zbierz 25 słów", "desc_ru": "Собрать 25 слов", "desc_uk": "Зібрати 25 слів", "desc_en": "Collect 25 words",
"type": "bubble_words", "value": 25},
{"code": "bubble_words_1000", "category": "bubblewords", "icon": "📚",
"name_pl": "Tysiąc słów", "name_ru": "Тысяча слов", "name_uk": "Тисяча слів", "name_en": "Thousand Words",
"desc_pl": "Zbierz 1000 słów", "desc_ru": "Собрать 1000 слов", "desc_uk": "Зібрати 1000 слів", "desc_en": "Collect 1000 words",
"type": "bubble_words", "value": 1000},
{"code": "bubble_streak_3", "category": "bubblewords", "icon": "🔥",
"name_pl": "Seria", "name_ru": "Серия", "name_uk": "Серія", "name_en": "Streak",
"desc_pl": "Ukończ 3 poziomy z rzędu bez podpowiedzi", "desc_ru": "Пройти 3 уровня подряд без подсказок", "desc_uk": "Пройти 3 рівні поспіль без підказок", "desc_en": "Complete 3 levels in a row without hints",
"type": "bubble_streak", "value": 3},
{"code": "bubble_streak_10", "category": "bubblewords", "icon": "💪",
"name_pl": "Niepowstrzymany", "name_ru": "Неудержимый", "name_uk": "Невтримний", "name_en": "Unstoppable",
"desc_pl": "Ukończ 10 poziomów z rzędu bez podpowiedzi", "desc_ru": "Пройти 10 уровней подряд без подсказок", "desc_uk": "Пройти 10 рівнів поспіль без підказок", "desc_en": "Complete 10 levels in a row without hints",
"type": "bubble_streak", "value": 10},
{"code": "bubble_words_100", "category": "bubblewords", "icon": "📖",
"name_pl": "Sto słów", "name_ru": "Сто слов", "name_uk": "Сто слів", "name_en": "Hundred Words",
"desc_pl": "Zbierz 100 słów", "desc_ru": "Собрать 100 слов", "desc_uk": "Зібрати 100 слів", "desc_en": "Collect 100 words",
"type": "bubble_words", "value": 100},
{"code": "bubble_xp_1000", "category": "bubblewords", "icon": "💎",
"name_pl": "Bąbelkowy XP", "name_ru": "Пузырьковый XP", "name_uk": "Бульбашковий XP", "name_en": "Bubble XP",
"desc_pl": "Zdobądź 1000 XP w Bąbelkach", "desc_ru": "Набрать 1000 XP в пузырях", "desc_uk": "Набрати 1000 XP у бульбашках", "desc_en": "Earn 1000 XP in Bubbles",
"type": "bubble_xp", "value": 1000},
{"code": "bubble_200", "category": "bubblewords", "icon": "👑",
"name_pl": "Dwustu poziomów", "name_ru": "Двести уровней", "name_uk": "Двісті рівнів", "name_en": "Two Hundred Levels",
"desc_pl": "Ukończ 200 poziomów w Bąbelkach słów", "desc_ru": "Пройти 200 уровней в Пузырях слов", "desc_uk": "Пройти 200 рівнів у Бульбашках слів", "desc_en": "Complete 200 levels in Bubble Words",
"type": "bubble_levels", "value": 200},
{"code": "bubble_speed_15", "category": "bubblewords", "icon": "⚡",
"name_pl": "Błyskawica", "name_ru": "Молния", "name_uk": "Блискавка", "name_en": "Lightning",
"desc_pl": "Ukończ poziom w mniej niż 15 sekund", "desc_ru": "Пройти уровень быстрее 15 секунд", "desc_uk": "Пройти рівень швидше 15 секунд", "desc_en": "Complete a level in under 15 seconds",
"type": "bubble_speed_15", "value": 15},
{"code": "bubble_speed_10", "category": "bubblewords", "icon": "⚡",
"name_pl": "Mgnienie", "name_ru": "Мгновение", "name_uk": "Миттєвість", "name_en": "Blink",
"desc_pl": "Ukończ poziom w mniej niż 10 sekund", "desc_ru": "Пройти уровень быстрее 10 секунд", "desc_uk": "Пройти рівень швидше 10 секунд", "desc_en": "Complete a level in under 10 seconds",
"type": "bubble_speed_10", "value": 10},
{"code": "bubble_words_500", "category": "bubblewords", "icon": "🏆",
"name_pl": "Pięćset słów", "name_ru": "Пятьсот слов", "name_uk": "П'ятсот слів", "name_en": "Five Hundred Words",
"desc_pl": "Zbierz 500 słów", "desc_ru": "Собрать 500 слов", "desc_uk": "Зібрати 500 слів", "desc_en": "Collect 500 words",
"type": "bubble_words", "value": 500},
# ===== General (9) =====
{"code": "score_1000", "category": "general", "icon": "🌟", {"code": "score_1000", "category": "general", "icon": "🌟",
"name_pl": "Wschodząca gwiazda", "name_ru": "Восходящая звезда", "name_uk": "Висхідна зірка", "name_en": "Rising Star", "name_pl": "Wschodząca gwiazda", "name_ru": "Восходящая звезда", "name_uk": "Висхідна зірка", "name_en": "Rising Star",
"desc_pl": "Zdobądź 1000 punktów", "desc_ru": "Набрать 1000 очков", "desc_uk": "Набрати 1000 балів", "desc_en": "Earn 1000 points", "desc_pl": "Zdobądź 1000 punktów", "desc_ru": "Набрать 1000 очков", "desc_uk": "Набрати 1000 балів", "desc_en": "Earn 1000 points",
@@ -245,42 +462,7 @@ ACHIEVEMENTS_DATA = [
"desc_pl": "Zmień język interfejsu", "desc_ru": "Сменить язык интерфейса", "desc_uk": "Змінити мову інтерфейсу", "desc_en": "Change interface language", "desc_pl": "Zmień język interfejsu", "desc_ru": "Сменить язык интерфейса", "desc_uk": "Змінити мову інтерфейсу", "desc_en": "Change interface language",
"type": "language_changed", "value": 1}, "type": "language_changed", "value": 1},
# 🔧 ИСПРАВЛЕНО: Заменено достижение "Открой Грамматику" на "Открой меню учителя"
{"code": "open_teacher_menu", "category": "general", "icon": "🎓",
"name_pl": "Uczeń", "name_ru": "Ученик", "name_uk": "Учень", "name_en": "Student",
"desc_pl": "Otwórz menu nauczyciela", "desc_ru": "Открыть меню учителя", "desc_uk": "Відкрити меню вчителя", "desc_en": "Open the teacher menu",
"type": "teacher_menu_opened", "value": 1},
{"code": "open_cheatsheets", "category": "general", "icon": "📝",
"name_pl": "Ciekawski", "name_ru": "Любознательный", "name_uk": "Допитливий", "name_en": "Curious",
"desc_pl": "Otwórz sekcję Ściągi", "desc_ru": "Открыть раздел Шпаргалки", "desc_uk": "Відкрити розділ Шпаргалки", "desc_en": "Open the Cheatsheets section",
"type": "cheatsheets_opened", "value": 1},
{"code": "open_pronunciation", "category": "general", "icon": "🔊",
"name_pl": "Słuchacz", "name_ru": "Слушатель", "name_uk": "Слухач", "name_en": "Listener",
"desc_pl": "Otwórz sekcję Wymowa", "desc_ru": "Открыть раздел Произношение", "desc_uk": "Відкрити розділ Вимова", "desc_en": "Open the Pronunciation section",
"type": "pronunciation_opened", "value": 1},
{"code": "open_ai_assistant", "category": "general", "icon": "🤖",
"name_pl": "Asystent AI", "name_ru": "AI-помощник", "name_uk": "AI-помічник", "name_en": "AI Assistant",
"desc_pl": "Otwórz Asystenta AI", "desc_ru": "Открыть AI-помощника", "desc_uk": "Відкрити AI-помічника", "desc_en": "Open the AI Assistant",
"type": "ai_assistant_opened", "value": 1},
{"code": "open_alphabet", "category": "general", "icon": "🔤",
"name_pl": "Alfabetysta", "name_ru": "Алфавитист", "name_uk": "Алфавітист", "name_en": "Alphabetist",
"desc_pl": "Otwórz sekcję Alfabet", "desc_ru": "Открыть раздел Алфавит", "desc_uk": "Відкрити розділ Алфавіт", "desc_en": "Open the Alphabet section",
"type": "alphabet_opened", "value": 1},
{"code": "open_rules", "category": "general", "icon": "📐",
"name_pl": "Gramatyk", "name_ru": "Грамматик", "name_uk": "Граматик", "name_en": "Grammarian",
"desc_pl": "Otwórz sekcję Zasady", "desc_ru": "Открыть раздел Правила", "desc_uk": "Відкрити розділ Правила", "desc_en": "Open the Rules section",
"type": "rules_opened", "value": 1},
# 🔧 НОВОЕ: Достижение за открытие Прогресса
{"code": "open_progress", "category": "general", "icon": "📊",
"name_pl": "Planista", "name_ru": "Планировщик", "name_uk": "Планувальник", "name_en": "Planner",
"desc_pl": "Otwórz sekcję Postęp", "desc_ru": "Открыть раздел Прогресс", "desc_uk": "Відкрити розділ Прогрес", "desc_en": "Open the Progress section",
"type": "progress_opened", "value": 1},
] ]
@@ -323,6 +505,20 @@ async def init_achievements():
requirement_value = EXCLUDED.requirement_value requirement_value = EXCLUDED.requirement_value
""", rows) """, rows)
# 🔧 Удаление осиротевших достижений (которых больше нет в ACHIEVEMENTS_DATA)
await conn.execute("""
DELETE FROM user_achievements
WHERE achievement_id IN (
SELECT id FROM achievements
WHERE code NOT IN (SELECT unnest($1::text[]))
)
""", [a["code"] for a in ACHIEVEMENTS_DATA])
await conn.execute("""
DELETE FROM achievements
WHERE code NOT IN (SELECT unnest($1::text[]))
""", [a["code"] for a in ACHIEVEMENTS_DATA])
logger.info(f"[achievements] init: upserted {len(rows)} achievements") logger.info(f"[achievements] init: upserted {len(rows)} achievements")
+130 -10
View File
@@ -2,9 +2,15 @@
Admin Router — админ-панель с реальной статистикой проекта. Admin Router — админ-панель с реальной статистикой проекта.
1. /admin/dashboard — общая статистика (юзеры, онлайн, по уровням) 1. /admin/dashboard — общая статистика (юзеры, онлайн, по уровням)
2. /admin/sentry-errors — ошибки из Sentry (через API) 2. /admin/sentry-errors — ошибки из Sentry (через API)
3. /admin/sentry-stats — сводка по ошибкам Sentry
🔧 ОБНОВЛЕНО (01.10.2026):
- /sentry-errors: расширенные фильтры (period, status, level, q, limit)
- /sentry-stats: новый эндпоинт для сводки
""" """
import os import os
import logging import logging
from typing import Optional
import httpx import httpx
from fastapi import APIRouter, Request, HTTPException from fastapi import APIRouter, Request, HTTPException
from auth import require_auth from auth import require_auth
@@ -102,10 +108,23 @@ async def get_admin_dashboard(request: Request):
@router.get("/sentry-errors") @router.get("/sentry-errors")
async def get_sentry_errors(request: Request): async def get_sentry_errors(
request: Request,
period: str = "24h",
status: str = "unresolved",
level: Optional[str] = None,
q: Optional[str] = None,
limit: int = 50,
):
""" """
Последние ошибки из Sentry. 🔧 ОБНОВЛЕНО (01.10.2026): расширенные фильтры для Sentry.
Возвращает только unresolved (нерешённые) за последние 24 часа.
Параметры:
- period: '1h', '24h', '7d', '14d', '30d' (по умолчанию 24h)
- status: 'unresolved', 'resolved', 'all' (по умолчанию unresolved)
- level: 'error', 'warning', 'info', 'debug' (опционально)
- q: поиск по title
- limit: 1-100 (по умолчанию 50)
""" """
telegram_id, _ = await require_auth(request) telegram_id, _ = await require_auth(request)
_require_admin(telegram_id) _require_admin(telegram_id)
@@ -113,15 +132,47 @@ async def get_sentry_errors(request: Request):
if not SENTRY_AUTH_TOKEN: if not SENTRY_AUTH_TOKEN:
return {"errors": [], "error": "SENTRY_AUTH_TOKEN not configured"} return {"errors": [], "error": "SENTRY_AUTH_TOKEN not configured"}
# Валидация
# 🔧 ФИКС (01.10.2026): sentry_free_plan_periods —
# Free plan Sentry поддерживает ТОЛЬКО '', '24h', '14d'.
# Остальные → 400 Bad Request.
if period not in ("", "24h", "14d"):
period = "24h"
if status not in ("unresolved", "resolved", "all"):
status = "unresolved"
if level and level not in ("error", "warning", "info", "debug", "fatal"):
level = None
if limit < 1:
limit = 1
elif limit > 100:
limit = 100
# Собираем query для Sentry
query_parts = []
if status == "unresolved":
query_parts.append("is:unresolved")
elif status == "resolved":
query_parts.append("is:resolved")
# 'all' — без фильтра статуса
if level:
query_parts.append(f"level:{level}")
if q and q.strip():
query_parts.append(q.strip())
query = " ".join(query_parts) if query_parts else ""
url = f"{SENTRY_API_BASE}/projects/{SENTRY_ORG_SLUG}/{SENTRY_PROJECT_SLUG}/issues/" url = f"{SENTRY_API_BASE}/projects/{SENTRY_ORG_SLUG}/{SENTRY_PROJECT_SLUG}/issues/"
params = { params = {
"query": "is:unresolved", "statsPeriod": period,
"statsPeriod": "24h", "limit": limit,
"limit": 20, "sort": "freq", # сортировка по частоте
}
headers = {
"Authorization": f"Bearer {SENTRY_AUTH_TOKEN}",
} }
if query:
params["query"] = query
headers = {"Authorization": f"Bearer {SENTRY_AUTH_TOKEN}"}
try: try:
async with httpx.AsyncClient(timeout=10.0) as client: async with httpx.AsyncClient(timeout=10.0) as client:
@@ -147,9 +198,11 @@ async def get_sentry_errors(request: Request):
"last_seen": issue.get("lastSeen"), "last_seen": issue.get("lastSeen"),
"permalink": issue.get("permalink"), "permalink": issue.get("permalink"),
"priority": issue.get("priority"), "priority": issue.get("priority"),
"status": issue.get("status"), # unresolved / resolved
"metadata": issue.get("metadata", {}),
}) })
return {"errors": errors, "count": len(errors)} return {"errors": errors, "count": len(errors), "query": query or "(no filter)"}
except httpx.TimeoutException: except httpx.TimeoutException:
logger.error("Sentry API timeout") logger.error("Sentry API timeout")
@@ -157,3 +210,70 @@ async def get_sentry_errors(request: Request):
except Exception as e: except Exception as e:
logger.error(f"Sentry API unexpected error: {e}") logger.error(f"Sentry API unexpected error: {e}")
return {"errors": [], "error": str(e)} return {"errors": [], "error": str(e)}
@router.get("/sentry-stats")
async def get_sentry_stats(request: Request, period: str = "24h"):
"""
🔧 НОВОЕ (01.10.2026): сводка по ошибкам Sentry.
Возвращает:
- total_unresolved: всего нерешённых
- total_24h: новых за 24ч
- by_level: распределение по уровням (error / warning / info)
- top_culprits: топ-5 проблемных файлов
"""
telegram_id, _ = await require_auth(request)
_require_admin(telegram_id)
if not SENTRY_AUTH_TOKEN:
return {"error": "SENTRY_AUTH_TOKEN not configured"}
# 🔧 ФИКС (01.10.2026): sentry_free_plan_periods — только '', '24h', '14d'.
if period not in ("", "24h", "14d"):
period = "24h"
url = f"{SENTRY_API_BASE}/projects/{SENTRY_ORG_SLUG}/{SENTRY_PROJECT_SLUG}/issues/"
params = {
"query": "is:unresolved",
"statsPeriod": period,
"limit": 100,
}
headers = {"Authorization": f"Bearer {SENTRY_AUTH_TOKEN}"}
try:
async with httpx.AsyncClient(timeout=10.0) as client:
response = await client.get(url, params=params, headers=headers)
if response.status_code != 200:
return {"error": f"Sentry API: {response.status_code}"}
raw_issues = response.json()
# Считаем
by_level: dict = {}
culprits: dict = {}
for issue in raw_issues:
lvl = issue.get("level", "error")
by_level[lvl] = by_level.get(lvl, 0) + 1
culprit = issue.get("culprit", "unknown")
culprits[culprit] = culprits.get(culprit, 0) + int(issue.get("count", 0))
top_culprits = sorted(
[{"culprit": k, "count": v} for k, v in culprits.items()],
key=lambda x: x["count"],
reverse=True,
)[:5]
return {
"total_unresolved": len(raw_issues),
"by_level": by_level,
"top_culprits": top_culprits,
"period": period,
}
except Exception as e:
logger.error(f"Sentry stats error: {e}")
return {"error": str(e)}
+321
View File
@@ -0,0 +1,321 @@
"""
Admin AI Router — универсальный AI-помощник в админке.
🔧 НОВОЕ (02.10.2026): floating AI widget в admin frontend.
Использует DeepSeek V4 Pro 0813 через Together AI:
- Модель: deepseek-ai/DeepSeek-V4-Pro-0813
- Reasoning: отключён для скорости (можно включить через body)
- Rate limit: 60 запросов/час на админа
"""
import logging
import time
from collections import defaultdict
import httpx
from fastapi import APIRouter, Request, HTTPException
from auth import require_auth
from config import TOGETHER_API_KEY, ADMIN_IDS
logger = logging.getLogger(__name__)
router = APIRouter(prefix="/admin/ai", tags=["admin-ai"])
TOGETHER_API_URL = "https://api.together.xyz/v1/chat/completions"
# 🔧 НОВОЕ (02.10.2026): DeepSeek V4 Pro — flagship, 1M контекст, 30+ языков
DEFAULT_MODEL = "deepseek-ai/DeepSeek-V4-Pro-0813"
# In-memory rate limit (60/час на юзера)
_admin_ai_usage: dict[int, list[float]] = defaultdict(list)
_ADMIN_AI_RATE_LIMIT = 60
_ADMIN_AI_RATE_WINDOW = 3600 # 1 час
DEFAULT_SYSTEM_PROMPT = """Ты — помощник преподавателя польского языка в приложении Filwords PL (Telegram Mini App для изучения польского).
Помогаешь создавать учебный контент:
- Задания для уроков (recognition — выбор варианта A/B/C/D)
- Дистракторы (неправильные, но похожие по смыслу варианты)
- Переводы на польский, русский, украинский, английский
- Грамматические пояснения
ПРАВИЛА:
1. Отвечай на языке пользователя (по умолчанию — русский).
2. Не используй markdown. Просто текст.
3. Для заданий-recognition: дай РОВНО 4 варианта (A, B, C, D).
4. Один вариант — правильный (отметь явно).
5. Три других — похожие по смыслу (та же часть речи, тот же контекст).
6. Указывай wrong_because для неправильных: wrong_word, wrong_case, wrong_context, wrong_gender, wrong_sentence_type, wrong_translation.
7. Если просят перевод — дай на все 4 языка (PL, RU, UK, EN).
8. Если просят контекст из БД — используй его, не выдумывай."""
def _check_rate_limit(user_id: int) -> bool:
"""Проверка: не превысил ли админ лимит."""
now = time.time()
# Чистим старые записи
_admin_ai_usage[user_id] = [
t for t in _admin_ai_usage[user_id]
if now - t < _ADMIN_AI_RATE_WINDOW
]
return len(_admin_ai_usage[user_id]) < _ADMIN_AI_RATE_LIMIT
def _increment_usage(user_id: int) -> None:
_admin_ai_usage[user_id].append(time.time())
@router.post("/chat")
async def admin_ai_chat(request: Request):
"""
🔧 НОВОЕ (02.10.2026): admin_ai_chat —
универсальный AI-помощник в админке.
Тело:
{
"message": "Придумай 4 варианта к заданию: ...",
"system_prompt": "опционально, переопределить дефолт",
"model": "deepseek-ai/DeepSeek-V4-Pro-0813", // опционально
"reasoning": false, // опционально, по умолчанию false
"context": "опционально, длинный контекст" // например, вся тема целиком
}
Возвращает:
{
"response": "...",
"model_used": "deepseek-ai/DeepSeek-V4-Pro-0813",
"tokens_used": 123
}
"""
telegram_id, _ = await require_auth(request)
if telegram_id not in ADMIN_IDS:
raise HTTPException(403, "Access denied")
if not _check_rate_limit(telegram_id):
raise HTTPException(429, f"Rate limit exceeded ({_ADMIN_AI_RATE_LIMIT}/hour)")
if not TOGETHER_API_KEY:
raise HTTPException(500, "TOGETHER_API_KEY not configured")
body = await request.json()
message = (body.get("message") or "").strip()
system_prompt = (body.get("system_prompt") or "").strip() or DEFAULT_SYSTEM_PROMPT
model = (body.get("model") or "").strip() or DEFAULT_MODEL
reasoning_enabled = bool(body.get("reasoning", False))
context = (body.get("context") or "").strip()
if not message:
raise HTTPException(400, "message is required")
if len(message) > 4000:
raise HTTPException(400, "message too long (max 4000)")
# Собираем user content: context + message
user_content = message
if context:
user_content = f"Контекст из БД:\n{context}\n\nЗадача:\n{message}"
# Отправляем в Together
try:
async with httpx.AsyncClient(timeout=120.0) as client:
response = await client.post(
TOGETHER_API_URL,
headers={
"Authorization": f"Bearer {TOGETHER_API_KEY}",
"Content-Type": "application/json",
},
json={
"model": model,
"messages": [
{"role": "system", "content": system_prompt},
{"role": "user", "content": user_content},
],
"max_tokens": 2000,
"temperature": 1.0, # 🔧 DeepSeek рекомендует 1.0
"reasoning": {"enabled": reasoning_enabled},
},
)
except httpx.TimeoutException:
raise HTTPException(504, "AI timeout (120s)")
if response.status_code != 200:
logger.error(f"[admin_ai] Together error: {response.status_code} {response.text[:300]}")
raise HTTPException(500, f"AI error: {response.status_code}")
data = response.json()
# Извлекаем ответ
try:
message_obj = data["choices"][0]["message"]
ai_response = message_obj.get("content") or message_obj.get("reasoning_content") or ""
except (KeyError, IndexError, TypeError) as e:
logger.error(f"[admin_ai] parse error: {e}")
raise HTTPException(500, "AI returned invalid response")
if not ai_response:
raise HTTPException(500, "AI returned empty response")
# Считаем токены
usage = data.get("usage", {})
tokens_used = usage.get("total_tokens", 0)
_increment_usage(telegram_id)
logger.info(
f"[admin_ai] user={telegram_id} model={model} tokens={tokens_used}"
)
return {
"response": ai_response.strip(),
"model_used": model,
"tokens_used": tokens_used,
}
@router.post("/translate")
async def admin_ai_translate(request: Request):
"""
🔧 НОВОЕ (02.10.2026): admin_ai_translate —
перевод текста на 4 языка (PL, RU, UK, EN).
Тело:
{
"text": "Podstawowe powitania",
"source_lang": "pl",
"target_langs": ["ru", "uk", "en"] // опционально, по умолчанию все кроме source
}
Возвращает:
{
"translations": {"ru": "...", "uk": "...", "en": "..."},
"source_lang": "pl"
}
"""
telegram_id, _ = await require_auth(request)
if telegram_id not in ADMIN_IDS:
raise HTTPException(403, "Access denied")
if not _check_rate_limit(telegram_id):
raise HTTPException(429, f"Rate limit exceeded ({_ADMIN_AI_RATE_LIMIT}/hour)")
if not TOGETHER_API_KEY:
raise HTTPException(500, "TOGETHER_API_KEY not configured")
body = await request.json()
text = (body.get("text") or "").strip()
source_lang = (body.get("source_lang") or "pl").strip().lower()
target_langs = body.get("target_langs") or ["ru", "uk", "en"]
if not text:
raise HTTPException(400, "text is required")
if len(text) > 3000:
raise HTTPException(400, "text too long (max 3000)")
if source_lang not in ("pl", "ru", "uk", "en"):
raise HTTPException(400, f"Invalid source_lang: {source_lang}")
# Валидация target_langs
valid_langs = {"pl", "ru", "uk", "en"}
target_langs = [l for l in target_langs if l in valid_langs and l != source_lang]
if not target_langs:
raise HTTPException(400, "No valid target_langs")
lang_names = {
"pl": "Polish", "ru": "Russian", "uk": "Ukrainian", "en": "English",
}
source_name = lang_names[source_lang]
targets_str = ", ".join([f'"{l}": "{lang_names[l]}"' for l in target_langs])
system_prompt = f"""Ты — переводчик. Переведи текст с {source_name} на указанные языки.
Верни СТРОГО JSON (без markdown, без пояснений) в формате:
{{
{targets_str}
}}
ПРАВИЛА:
- Переводи ТОЧНО, сохраняя смысл и стиль.
- Для терминов и названий — используй общепринятые варианты.
- Если текст — название урока/темы, переводи как название (с заглавной буквы).
- Если текст — объяснение, сохраняй переносы строк и форматирование.
- Не добавляй ничего кроме JSON."""
user_prompt = f"Текст для перевода:\n{text}"
try:
async with httpx.AsyncClient(timeout=60.0) as client:
response = await client.post(
TOGETHER_API_URL,
headers={
"Authorization": f"Bearer {TOGETHER_API_KEY}",
"Content-Type": "application/json",
},
json={
"model": DEFAULT_MODEL,
"messages": [
{"role": "system", "content": system_prompt},
{"role": "user", "content": user_prompt},
],
"max_tokens": 1500,
"temperature": 0.3, # Для перевода — низкая
"reasoning": {"enabled": False},
},
)
except httpx.TimeoutException:
raise HTTPException(504, "AI timeout")
if response.status_code != 200:
logger.error(f"[admin_ai] translate error: {response.status_code} {response.text[:300]}")
raise HTTPException(500, f"AI error: {response.status_code}")
data = response.json()
try:
message_obj = data["choices"][0]["message"]
raw = (message_obj.get("content") or "").strip()
except (KeyError, IndexError, TypeError):
raise HTTPException(500, "AI returned invalid response")
# Парсим JSON (снимаем ```json ... ``` если AI обернул)
import re as _re
import json as _json
if raw.startswith("```"):
raw = _re.sub(r'^```(?:json)?\s*', '', raw)
raw = _re.sub(r'\s*```$', '', raw)
json_match = _re.search(r'\{.*\}', raw, _re.DOTALL)
if not json_match:
logger.error(f"[admin_ai] no JSON in response: {raw[:200]}")
raise HTTPException(500, "AI returned no JSON")
try:
parsed = _json.loads(json_match.group(0))
except _json.JSONDecodeError as e:
logger.error(f"[admin_ai] JSON parse error: {e}, raw={raw[:300]}")
raise HTTPException(500, "AI returned invalid JSON")
translations = {}
for lang in target_langs:
value = parsed.get(lang, "")
translations[lang] = str(value).strip() if value else ""
tokens_used = data.get("usage", {}).get("total_tokens", 0)
_increment_usage(telegram_id)
logger.info(
f"[admin_ai] translate user={telegram_id} "
f"{source_lang} → {target_langs} tokens={tokens_used}"
)
return {
"translations": translations,
"source_lang": source_lang,
"tokens_used": tokens_used,
}
+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,
}
+1337 -14
View File
File diff suppressed because it is too large Load Diff
+242
View File
@@ -0,0 +1,242 @@
"""
Admin Users Router — управление пользователями.
Доступ: только для ADMIN_IDS.
Эндпоинты:
- GET /admin/users?page=1&limit=50&level=&lang=&q=&active_24h= — список
- GET /admin/users/stats — сводка по уровням/языкам
🔧 ФИКС (30.09.2026): total_score = сумма 4 игр (wordsearch + sentences + quiz + bubbles).
"""
import logging
from typing import Optional
from fastapi import APIRouter, Request, HTTPException
from auth import require_auth
from database import get_pool
from config import ADMIN_IDS
logger = logging.getLogger(__name__)
router = APIRouter(prefix="/admin/users", tags=["admin-users"])
LEVELS = ["A1", "A2", "B1", "B2", "C1", "C2"]
LANGUAGES = ["pl", "ru", "uk", "en"]
def _require_admin(telegram_id: int) -> None:
if telegram_id not in ADMIN_IDS:
raise HTTPException(403, "Access denied")
@router.get("")
async def list_users(
request: Request,
page: int = 1,
limit: int = 50,
level: Optional[str] = None,
lang: Optional[str] = None,
q: Optional[str] = None,
active_24h: bool = False,
):
"""
🔧 НОВОЕ (30.09.2026): список пользователей с пагинацией.
Возвращает:
{
"total": 15,
"page": 1,
"limit": 50,
"pages": 1,
"users": [
{
"telegram_id": 123,
"username": "user",
"app_language": "ru",
"current_level": "A1",
"last_completed_level": 5,
"last_completed_by_level": {"A1": 5, "A2": 3},
"created_at": "...",
"last_login": "...",
"total_score": 1234,
"wordsearch_completed": 5,
"sentence_completed": 10,
"quiz_guessed": 20,
"bubble_completed": 8,
"levels_completed": 5
}
]
}
"""
telegram_id, _ = await require_auth(request)
_require_admin(telegram_id)
if page < 1:
page = 1
if limit < 1:
limit = 1
elif limit > 200:
limit = 200
offset = (page - 1) * limit
pool = await get_pool()
async with pool.acquire() as conn:
conditions = []
params: list = []
idx = 1
if level and level in LEVELS:
conditions.append(f"u.current_level = ${idx}")
params.append(level)
idx += 1
if lang and lang in LANGUAGES:
conditions.append(f"u.app_language = ${idx}")
params.append(lang)
idx += 1
if q and q.strip():
conditions.append(f"""(
CAST(u.telegram_id AS TEXT) ILIKE ${idx} OR
u.username ILIKE ${idx}
)""")
params.append(f"%{q.strip()}%")
idx += 1
if active_24h:
conditions.append(f"""
EXISTS (
SELECT 1 FROM daily_logins dl
WHERE dl.user_id = u.telegram_id
AND dl.login_date >= CURRENT_DATE - INTERVAL '1 day'
)
""")
where = ("WHERE " + " AND ".join(conditions)) if conditions else ""
# Total
total = await conn.fetchval(f"""
SELECT COUNT(*) FROM users u {where}
""", *params) or 0
# Page с агрегатами
rows = await conn.fetch(f"""
SELECT
u.telegram_id,
u.username,
u.app_language,
u.current_level,
u.last_completed_level,
u.last_completed_by_level,
u.created_at,
(SELECT MAX(login_date) FROM daily_logins WHERE user_id = u.telegram_id) AS last_login,
-- 🔧 ФИКС (30.09.2026): total_score теперь = сумма 4 игр
COALESCE((SELECT SUM(score) FROM user_progress
WHERE user_id = u.telegram_id AND completed_at IS NOT NULL), 0)
+ COALESCE((SELECT SUM(score) FROM sentence_progress
WHERE user_id = u.telegram_id AND completed_at IS NOT NULL), 0)
+ COALESCE((SELECT total_score FROM word_quiz_progress
WHERE user_id = u.telegram_id), 0)
+ COALESCE((SELECT total_score FROM bubble_words_progress
WHERE user_id = u.telegram_id), 0) AS total_score,
-- Уровни по играм
COALESCE((SELECT COUNT(*) FROM user_progress
WHERE user_id = u.telegram_id AND completed_at IS NOT NULL), 0) AS wordsearch_completed,
COALESCE((SELECT COUNT(*) FROM sentence_progress
WHERE user_id = u.telegram_id AND completed_at IS NOT NULL), 0) AS sentence_completed,
COALESCE((SELECT words_guessed FROM word_quiz_progress
WHERE user_id = u.telegram_id), 0) AS quiz_guessed,
COALESCE((SELECT levels_completed FROM bubble_words_progress
WHERE user_id = u.telegram_id), 0) AS bubble_completed
FROM users u
{where}
ORDER BY u.created_at DESC
LIMIT ${idx} OFFSET ${idx + 1}
""", *params, limit, offset)
pages = (total + limit - 1) // limit if limit > 0 else 1
return {
"total": total,
"page": page,
"limit": limit,
"pages": pages,
"users": [
{
"telegram_id": r["telegram_id"],
"username": r["username"],
"app_language": r["app_language"] or "pl",
"current_level": r["current_level"] or "A1",
"last_completed_level": r["last_completed_level"] or 0,
"last_completed_by_level": r["last_completed_by_level"] or {},
"created_at": r["created_at"].isoformat() if r["created_at"] else None,
"last_login": r["last_login"].isoformat() if r["last_login"] else None,
"total_score": r["total_score"] or 0,
"wordsearch_completed": r["wordsearch_completed"] or 0,
"sentence_completed": r["sentence_completed"] or 0,
"quiz_guessed": r["quiz_guessed"] or 0,
"bubble_completed": r["bubble_completed"] or 0,
"levels_completed": r["wordsearch_completed"] or 0, # backward compat
}
for r in rows
],
}
@router.get("/stats")
async def users_stats(request: Request):
"""
Сводка: пользователи по уровням и языкам.
"""
telegram_id, _ = await require_auth(request)
_require_admin(telegram_id)
pool = await get_pool()
async with pool.acquire() as conn:
# По уровням
by_level_rows = await conn.fetch("""
SELECT COALESCE(current_level, 'A1') AS level, COUNT(*) AS cnt
FROM users
GROUP BY current_level
ORDER BY
CASE current_level
WHEN 'A1' THEN 1 WHEN 'A2' THEN 2
WHEN 'B1' THEN 3 WHEN 'B2' THEN 4
WHEN 'C1' THEN 5 WHEN 'C2' THEN 6
ELSE 7
END
""")
by_level = {r["level"]: r["cnt"] for r in by_level_rows}
# По языкам
by_lang_rows = await conn.fetch("""
SELECT COALESCE(app_language, 'pl') AS lang, COUNT(*) AS cnt
FROM users
GROUP BY app_language
ORDER BY cnt DESC
""")
by_lang = {r["lang"]: r["cnt"] for r in by_lang_rows}
# Всего
total = await conn.fetchval("SELECT COUNT(*) FROM users") or 0
# Активных за 24ч
active_24h = await conn.fetchval("""
SELECT COUNT(DISTINCT user_id) FROM daily_logins
WHERE login_date >= CURRENT_DATE - INTERVAL '1 day'
""") or 0
# Новых сегодня
new_today = await conn.fetchval("""
SELECT COUNT(*) FROM users WHERE created_at >= CURRENT_DATE
""") or 0
return {
"total": total,
"by_level": by_level,
"by_lang": by_lang,
"active_24h": active_24h,
"new_today": new_today,
}
+738
View File
@@ -0,0 +1,738 @@
"""
Admin Wordsearch Router — конструктор уровней филвордов.
Доступ: только для ADMIN_IDS.
Логика: препод создаёт уровни вручную через админку.
Эндпоинты:
- GET /admin/wordsearch/words?level=A1 — слова из CSV + счётчики
- GET /admin/wordsearch/levels?level=A1 — список созданных уровней
- GET /admin/wordsearch/level/{id} — один уровень (для редактирования)
- POST /admin/wordsearch/level — создать
- PUT /admin/wordsearch/level/{id} — обновить
- DELETE /admin/wordsearch/level/{id} — удалить
- POST /admin/wordsearch/validate — проверить корректность уровня
CRUD слов:
- GET /admin/wordsearch/words/all — полный список слов (с id)
- POST /admin/wordsearch/words — добавить слово
- PUT /admin/wordsearch/words/{word_id} — обновить слово
- DELETE /admin/wordsearch/words/{word_id} — удалить слово
🔧 ОБНОВЛЕНО (30.09.2026): /words/all — пагинация + total.
🔧 ОБНОВЛЕНО (03.10.2026): exclude_maxed_words —
/words не отдаёт слова с usage_count >= 5 (MAX_USAGE_COUNT).
"""
import json
import logging
from typing import Optional
from fastapi import APIRouter, Request, HTTPException
from auth import require_auth
from database import get_pool
from config import ADMIN_IDS
logger = logging.getLogger(__name__)
router = APIRouter(prefix="/admin/wordsearch", tags=["admin-wordsearch"])
LEVELS = ["A1", "A2", "B1", "B2", "C1", "C2"]
MAX_GRID_SIZE = 15
# 🔧 НОВОЕ (03.10.2026): MAX_USAGE_COUNT —
# слово считается «выгоревшим» после 5 использований и не отдаётся
# в конструктор. Хардкод, но легко вынести в конфиг.
MAX_USAGE_COUNT = 5
def _json_or_value(v):
"""🔧 ФИКС (30.09.2026): asyncpg_jsonb_string —
asyncpg возвращает JSONB как строку. Парсим, если строка."""
if isinstance(v, str):
try:
return json.loads(v)
except (json.JSONDecodeError, TypeError):
return v
return v
def _require_admin(telegram_id: int) -> None:
if telegram_id not in ADMIN_IDS:
raise HTTPException(403, "Access denied")
# ============ СЛОВА ИЗ CSV ============
@router.get("/words")
async def get_csv_words(request: Request, level: str = "A1"):
"""
Список слов из CSV для уровня с счётчиком использований.
Сортировка: сначала неиспользованные, потом по алфавиту.
🔧 ОБНОВЛЕНО (03.10.2026): exclude_maxed_words —
слова с usage_count >= MAX_USAGE_COUNT (5) «выгорели» (использованы
слишком много раз). Не отдаём их в конструктор, чтобы админ не мог
использовать повторно.
"""
telegram_id, _ = await require_auth(request)
_require_admin(telegram_id)
if level not in LEVELS:
raise HTTPException(400, f"Invalid level: {level}")
pool = await get_pool()
async with pool.acquire() as conn:
# 🔧 ОБНОВЛЕНО (03.10.2026): exclude_maxed_words —
# слова с usage_count >= 5 «выгорели» (использованы 5 раз).
# Не отдаём их в конструктор, чтобы админ не мог использовать
# повторно. Хардкод 5 = MAX_USAGE_COUNT.
rows = await conn.fetch("""
SELECT
w.word_pl,
w.translation_ru,
w.translation_uk,
w.translation_en,
COALESCE(u.usage_count, 0) AS usage_count
FROM csv_words w
LEFT JOIN word_usage u
ON u.word_pl = w.word_pl AND u.level_code = w.level_code
WHERE w.level_code = $1
AND COALESCE(u.usage_count, 0) < 5
ORDER BY COALESCE(u.usage_count, 0) ASC, w.word_pl ASC
""", level)
return {
"level": level,
"total": len(rows),
"words": [
{
"word_pl": r["word_pl"],
"translation_ru": r["translation_ru"] or "",
"translation_uk": r["translation_uk"] or "",
"translation_en": r["translation_en"] or "",
"usage_count": r["usage_count"],
}
for r in rows
],
}
# ============ УРОВНИ ============
@router.get("/levels")
async def list_levels(request: Request, level: Optional[str] = None):
"""Список созданных вручную уровней филвордов."""
telegram_id, _ = await require_auth(request)
_require_admin(telegram_id)
pool = await get_pool()
async with pool.acquire() as conn:
if level and level in LEVELS:
rows = await conn.fetch("""
SELECT id, level_number, grid_size, level, is_active, created_at,
jsonb_array_length(grid_letters) AS rows_count
FROM levels
WHERE created_by IS NOT NULL AND level = $1
ORDER BY level_number ASC, id ASC
""", level)
else:
rows = await conn.fetch("""
SELECT id, level_number, grid_size, level, is_active, created_at,
jsonb_array_length(grid_letters) AS rows_count
FROM levels
WHERE created_by IS NOT NULL
ORDER BY level, level_number ASC, id ASC
""")
return {
"total": len(rows),
"levels": [
{
"id": r["id"],
"level": r["level"],
"level_number": r["level_number"],
"grid_size": r["grid_size"],
"is_active": r["is_active"],
"created_at": r["created_at"].isoformat() if r["created_at"] else None,
}
for r in rows
],
}
@router.get("/level/{level_id}")
async def get_level(request: Request, level_id: int):
"""Один уровень целиком — для редактирования в конструкторе."""
telegram_id, _ = await require_auth(request)
_require_admin(telegram_id)
pool = await get_pool()
async with pool.acquire() as conn:
row = await conn.fetchrow("""
SELECT id, level_number, grid_size, level, grid_letters, word_paths,
is_active, created_by, created_at
FROM levels
WHERE id = $1 AND created_by IS NOT NULL
""", level_id)
if not row:
raise HTTPException(404, "Level not found")
# Слова уровня для списка размещённых
words_rows = await conn.fetch("""
SELECT word_pl, translation_ru, translation_uk, translation_en
FROM level_words
WHERE level_id = $1
""", level_id)
return {
"id": row["id"],
"level": row["level"],
"level_number": row["level_number"],
"grid_size": row["grid_size"],
"grid_letters": _json_or_value(row["grid_letters"]),
"word_paths": _json_or_value(row["word_paths"]),
"is_active": row["is_active"],
"created_at": row["created_at"].isoformat() if row["created_at"] else None,
"words": [
{
"word_pl": w["word_pl"],
"translation_ru": w["translation_ru"] or "",
"translation_uk": w["translation_uk"] or "",
"translation_en": w["translation_en"] or "",
}
for w in words_rows
],
}
def _validate_payload(payload: dict) -> tuple[int, list, dict]:
"""
Валидация grid_letters и word_paths.
Returns: (grid_size, grid_letters, word_paths)
Raises: HTTPException(400, ...)
"""
grid_size = payload.get("grid_size")
if not isinstance(grid_size, int) or grid_size < 3 or grid_size > MAX_GRID_SIZE:
raise HTTPException(400, f"grid_size must be 3-{MAX_GRID_SIZE}")
grid_letters = payload.get("grid_letters")
if not isinstance(grid_letters, list) or len(grid_letters) != grid_size:
raise HTTPException(400, "grid_letters must be a 2D array of size grid_size × grid_size")
for row in grid_letters:
if not isinstance(row, list) or len(row) != grid_size:
raise HTTPException(400, "each row of grid_letters must have grid_size elements")
for cell in row:
# Разрешаем: null (неактивная), "", либо одна буква
if cell is not None and (not isinstance(cell, str) or len(cell) > 1):
raise HTTPException(400, "cell must be null, '', or a single character")
word_paths = payload.get("word_paths")
if not isinstance(word_paths, dict):
raise HTTPException(400, "word_paths must be an object")
# Проверяем, что каждое слово в word_paths имеет корректный путь
for word, path in word_paths.items():
if not isinstance(word, str) or not word:
raise HTTPException(400, "word must be a non-empty string")
if not isinstance(path, list) or len(path) == 0:
raise HTTPException(400, f"path for '{word}' must be a non-empty array")
# Проверяем, что путь соседний (Manhattan distance 1)
for i in range(1, len(path)):
prev = path[i - 1]
cur = path[i]
if not (isinstance(prev, list) and len(prev) == 2 and
isinstance(cur, list) and len(cur) == 2):
raise HTTPException(400, f"path points for '{word}' must be [r, c]")
dr = abs(prev[0] - cur[0])
dc = abs(prev[1] - cur[1])
if not (dr <= 1 and dc <= 1 and (dr + dc) > 0):
raise HTTPException(400, f"path for '{word}' has non-adjacent cells")
# Проверяем, что буквы в клетках совпадают со словом
word_upper = word.upper()
if len(path) != len(word_upper):
raise HTTPException(
400,
f"path length for '{word}' ({len(path)}) != word length ({len(word_upper)})"
)
for i, (r, c) in enumerate(path):
if r < 0 or r >= grid_size or c < 0 or c >= grid_size:
raise HTTPException(400, f"path for '{word}' goes out of grid")
cell = grid_letters[r][c]
if cell != word_upper[i]:
raise HTTPException(
400,
f"grid[{r}][{c}] = {cell!r}, expected {word_upper[i]!r} for '{word}'"
)
return grid_size, grid_letters, word_paths
@router.post("/validate")
async def validate_level(request: Request):
"""Проверяет корректность уровня без сохранения."""
telegram_id, _ = await require_auth(request)
_require_admin(telegram_id)
body = await request.json()
try:
_validate_payload(body)
except HTTPException as e:
return {"valid": False, "error": e.detail}
return {"valid": True}
# ============ СОЗДАНИЕ / ОБНОВЛЕНИЕ ============
async def _upsert_level_words(conn, level_id: int, level_code: str, word_paths: dict):
"""Обновляет level_words и word_usage для уровня."""
# Получаем переводы из csv_words
words = list(word_paths.keys())
if not words:
return
rows = await conn.fetch("""
SELECT word_pl, translation_ru, translation_uk, translation_en
FROM csv_words
WHERE level_code = $1 AND word_pl = ANY($2::text[])
""", level_code, words)
translations_map = {r["word_pl"]: r for r in rows}
# Удаляем старые level_words
await conn.execute("DELETE FROM level_words WHERE level_id = $1", level_id)
# Вставляем новые
for word in words:
trans = translations_map.get(word, {})
await conn.execute("""
INSERT INTO level_words (level_id, word_pl, translation_ru, translation_uk, translation_en, level)
VALUES ($1, $2, $3, $4, $5, $6)
""", level_id, word,
trans["translation_ru"] if trans else "",
trans["translation_uk"] if trans else "",
trans["translation_en"] if trans else "",
level_code,
)
@router.post("/level")
async def create_level(request: Request):
"""Создать новый уровень."""
telegram_id, _ = await require_auth(request)
_require_admin(telegram_id)
body = await request.json()
level_code = body.get("level", "A1")
if level_code not in LEVELS:
raise HTTPException(400, f"Invalid level: {level_code}")
level_number = body.get("level_number")
if not isinstance(level_number, int) or level_number < 1:
raise HTTPException(400, "level_number must be a positive integer")
is_active = bool(body.get("is_active", False))
grid_size, grid_letters, word_paths = _validate_payload(body)
pool = await get_pool()
async with pool.acquire() as conn:
async with conn.transaction():
# 🔧 ФИКС (29.09.2026): проверяем только РУЧНЫЕ уровни.
# Старые авто-сгенерированные (created_by IS NULL) не мешают.
existing = await conn.fetchval("""
SELECT id FROM levels
WHERE level = $1 AND level_number = $2 AND created_by IS NOT NULL
""", level_code, level_number)
if existing:
raise HTTPException(
409,
f"Level {level_code} #{level_number} already exists (id={existing})"
)
# 🔧 ФИКС (30.09.2026): asyncpg_jsonb_str —
# asyncpg требует json.dumps() для JSONB. Без него — DataError.
row = await conn.fetchrow("""
INSERT INTO levels
(level_number, grid_size, game_type, level, grid_letters, word_paths,
is_active, created_by, created_at)
VALUES ($1, $2, 'wordsearch', $3, $4, $5, $6, $7, NOW())
RETURNING id
""",
level_number, grid_size, level_code,
json.dumps(grid_letters), # 🔧 ФИКС (30.09.2026): asyncpg требует str для JSONB
json.dumps(word_paths), # 🔧 ФИКС (30.09.2026): то же
is_active, telegram_id,
)
level_id = row["id"]
# Обновляем level_words
await _upsert_level_words(conn, level_id, level_code, word_paths)
# Обновляем счётчики использований
for word in word_paths.keys():
await conn.execute("""
INSERT INTO word_usage (level_code, word_pl, usage_count, last_used_at)
VALUES ($1, $2, 1, NOW())
ON CONFLICT (level_code, word_pl)
DO UPDATE SET
usage_count = word_usage.usage_count + 1,
last_used_at = NOW()
""", level_code, word)
logger.info(
f"[admin_wordsearch] level created: {level_code} #{level_number} "
f"(id={level_id}, {len(word_paths)} words, active={is_active}) "
f"by admin {telegram_id}"
)
return {"status": "ok", "level_id": level_id}
@router.put("/level/{level_id}")
async def update_level(request: Request, level_id: int):
"""Обновить уровень."""
telegram_id, _ = await require_auth(request)
_require_admin(telegram_id)
body = await request.json()
pool = await get_pool()
async with pool.acquire() as conn:
existing = await conn.fetchrow("""
SELECT id, level, level_number, word_paths FROM levels
WHERE id = $1 AND created_by IS NOT NULL
""", level_id)
if not existing:
raise HTTPException(404, "Level not found")
level_code = existing["level"]
# 🔧 ФИКС (30.09.2026): usage_count_reflects_current —
# читаем старые слова, чтобы откатить их счётчики при замене.
old_word_paths_raw = existing["word_paths"]
old_word_paths = json.loads(old_word_paths_raw) if isinstance(old_word_paths_raw, str) else old_word_paths_raw
old_words = set(old_word_paths.keys())
grid_size, grid_letters, word_paths = _validate_payload(body)
is_active = bool(body.get("is_active", False))
async with conn.transaction():
# 🔧 ФИКС (30.09.2026): asyncpg_jsonb_str —
# asyncpg требует json.dumps() для JSONB. Без него — DataError.
await conn.execute("""
UPDATE levels
SET grid_size = $1,
grid_letters = $2,
word_paths = $3,
is_active = $4
WHERE id = $5
""",
grid_size,
json.dumps(grid_letters), # 🔧 ФИКС (30.09.2026): asyncpg требует str для JSONB
json.dumps(word_paths), # 🔧 ФИКС (30.09.2026): то же
is_active,
level_id,
)
await _upsert_level_words(conn, level_id, level_code, word_paths)
# 🔧 ФИКС (30.09.2026): usage_count_reflects_current —
# 1) Откатываем счётчики для слов, которых НЕТ в новом уровне.
# 2) Добавляем/инкрементим для новых слов.
# 3) Пересечение — не трогаем (last_used_at обновляем).
new_words = set(word_paths.keys())
words_added = new_words - old_words # новые слова
words_removed = old_words - new_words # убранные слова
# Откатываем счётчики для убранных
for word in words_removed:
await conn.execute("""
UPDATE word_usage
SET usage_count = GREATEST(0, usage_count - 1)
WHERE level_code = $1 AND word_pl = $2
""", level_code, word)
# Если счётчик = 0 — удаляем строку (чтобы не мусорить)
await conn.execute("""
DELETE FROM word_usage
WHERE level_code = $1 AND word_pl = $2 AND usage_count <= 0
""", level_code, word)
# Инкрементим для новых
for word in words_added:
await conn.execute("""
INSERT INTO word_usage (level_code, word_pl, usage_count, last_used_at)
VALUES ($1, $2, 1, NOW())
ON CONFLICT (level_code, word_pl)
DO UPDATE SET
usage_count = word_usage.usage_count + 1,
last_used_at = NOW()
""", level_code, word)
# Для пересечения — обновляем только last_used_at
for word in new_words & old_words:
await conn.execute("""
UPDATE word_usage
SET last_used_at = NOW()
WHERE level_code = $1 AND word_pl = $2
""", level_code, word)
logger.info(
f"[admin_wordsearch] level updated: id={level_id} "
f"({len(word_paths)} words, active={is_active}) "
f"by admin {telegram_id}"
)
return {"status": "ok", "level_id": level_id}
@router.delete("/level/{level_id}")
async def delete_level(request: Request, level_id: int):
"""Удалить уровень (только созданные вручную)."""
telegram_id, _ = await require_auth(request)
_require_admin(telegram_id)
pool = await get_pool()
async with pool.acquire() as conn:
row = await conn.fetchrow("""
SELECT id, level, level_number FROM levels
WHERE id = $1 AND created_by IS NOT NULL
""", level_id)
if not row:
raise HTTPException(404, "Level not found")
await conn.execute("DELETE FROM levels WHERE id = $1", level_id)
logger.info(
f"[admin_wordsearch] level deleted: id={level_id} "
f"({row['level']} #{row['level_number']}) by admin {telegram_id}"
)
return {"status": "ok", "level_id": level_id}
# ============ CRUD СЛОВ (csv_words) ============
@router.post("/words")
async def create_csv_word(request: Request):
"""Добавить слово в csv_words."""
telegram_id, _ = await require_auth(request)
_require_admin(telegram_id)
body = await request.json()
level_code = (body.get("level_code") or "").strip()
word_pl = (body.get("word_pl") or "").strip().lower()
translation_ru = (body.get("translation_ru") or "").strip()
translation_uk = (body.get("translation_uk") or "").strip()
translation_en = (body.get("translation_en") or "").strip()
if level_code not in LEVELS:
raise HTTPException(400, f"Invalid level: {level_code}")
if not word_pl:
raise HTTPException(400, "word_pl is required")
# 🔧 ФИКС (30.09.2026): global_duplicate_warning —
# проверяем все уровни. Если есть — возвращаем 409 с уровнем.
# Фронт покажет предупреждение + кнопку "Всё равно добавить".
# С флагом `force=true` — пропускаем проверку.
force = bool(body.get("force", False))
pool = await get_pool()
async with pool.acquire() as conn:
if not force:
existing = await conn.fetchrow("""
SELECT id, level_code FROM csv_words
WHERE LOWER(word_pl) = LOWER($1)
ORDER BY
CASE level_code
WHEN 'A1' THEN 1 WHEN 'A2' THEN 2
WHEN 'B1' THEN 3 WHEN 'B2' THEN 4
WHEN 'C1' THEN 5 WHEN 'C2' THEN 6
ELSE 7
END
LIMIT 1
""", word_pl)
if existing:
existing_level = existing["level_code"]
if existing_level == level_code:
raise HTTPException(
409,
f"DUPLICATE_SAME_LEVEL|{word_pl}|{existing_level}"
)
else:
raise HTTPException(
409,
f"DUPLICATE_OTHER_LEVEL|{word_pl}|{existing_level}"
)
row = await conn.fetchrow("""
INSERT INTO csv_words (level_code, word_pl, translation_ru, translation_uk, translation_en)
VALUES ($1, $2, $3, $4, $5)
RETURNING id
""", level_code, word_pl, translation_ru, translation_uk, translation_en)
logger.info(f"[admin_wordsearch] csv_word created: #{row['id']} '{word_pl}' in {level_code} by admin {telegram_id}")
return {"status": "ok", "word_id": row["id"]}
@router.put("/words/{word_id}")
async def update_csv_word(request: Request, word_id: int):
"""Обновить слово в csv_words."""
telegram_id, _ = await require_auth(request)
_require_admin(telegram_id)
body = await request.json()
word_pl = (body.get("word_pl") or "").strip().lower()
translation_ru = (body.get("translation_ru") or "").strip()
translation_uk = (body.get("translation_uk") or "").strip()
translation_en = (body.get("translation_en") or "").strip()
if not word_pl:
raise HTTPException(400, "word_pl is required")
pool = await get_pool()
async with pool.acquire() as conn:
existing = await conn.fetchrow("SELECT level_code, word_pl FROM csv_words WHERE id = $1", word_id)
if not existing:
raise HTTPException(404, "Word not found")
await conn.execute("""
UPDATE csv_words
SET word_pl = $1,
translation_ru = $2,
translation_uk = $3,
translation_en = $4
WHERE id = $5
""", word_pl, translation_ru, translation_uk, translation_en, word_id)
# 🔧 Синхронизируем с level_words (для филвордов)
await conn.execute("""
UPDATE level_words
SET word_pl = $1, translation_ru = $2, translation_uk = $3, translation_en = $4
WHERE word_pl = $5
""", word_pl, translation_ru, translation_uk, translation_en, existing["word_pl"])
logger.info(f"[admin_wordsearch] csv_word updated: #{word_id} '{existing['word_pl']}' -> '{word_pl}' by admin {telegram_id}")
return {"status": "ok", "word_id": word_id}
@router.delete("/words/{word_id}")
async def delete_csv_word(request: Request, word_id: int):
"""Удалить слово из csv_words."""
telegram_id, _ = await require_auth(request)
_require_admin(telegram_id)
pool = await get_pool()
async with pool.acquire() as conn:
existing = await conn.fetchrow("SELECT level_code, word_pl FROM csv_words WHERE id = $1", word_id)
if not existing:
raise HTTPException(404, "Word not found")
await conn.execute("DELETE FROM csv_words WHERE id = $1", word_id)
logger.info(f"[admin_wordsearch] csv_word deleted: #{word_id} '{existing['word_pl']}' by admin {telegram_id}")
return {"status": "ok", "word_id": word_id}
@router.get("/words/all")
async def list_all_csv_words(
request: Request,
level: Optional[str] = None,
q: Optional[str] = None,
page: int = 1,
limit: int = 50,
):
"""
🔧 ОБНОВЛЕНО (30.09.2026): пагинация + total.
Возвращает:
{
"total": 2446, # всего под фильтром
"page": 1, # текущая страница
"limit": 50, # размер страницы
"pages": 49, # всего страниц
"words": [...], # слова текущей страницы
}
"""
telegram_id, _ = await require_auth(request)
_require_admin(telegram_id)
if page < 1:
page = 1
if limit < 1:
limit = 1
elif limit > 500:
limit = 500
offset = (page - 1) * limit
pool = await get_pool()
async with pool.acquire() as conn:
# Условия
conditions = []
params: list = []
idx = 1
if level and level in LEVELS:
conditions.append(f"level_code = ${idx}")
params.append(level)
idx += 1
if q and q.strip():
conditions.append(f"""(
word_pl ILIKE ${idx} OR
translation_ru ILIKE ${idx} OR
translation_uk ILIKE ${idx} OR
translation_en ILIKE ${idx}
)""")
params.append(f"%{q.strip()}%")
idx += 1
where = ("WHERE " + " AND ".join(conditions)) if conditions else ""
# Общее количество
total = await conn.fetchval(f"""
SELECT COUNT(*) FROM csv_words {where}
""", *params) or 0
# Страница
rows = await conn.fetch(f"""
SELECT id, level_code, word_pl, translation_ru, translation_uk, translation_en
FROM csv_words
{where}
ORDER BY level_code, word_pl
LIMIT ${idx} OFFSET ${idx + 1}
""", *params, limit, offset)
pages = (total + limit - 1) // limit if limit > 0 else 1
return {
"total": total,
"page": page,
"limit": limit,
"pages": pages,
"words": [
{
"id": r["id"],
"level_code": r["level_code"],
"word_pl": r["word_pl"],
"translation_ru": r["translation_ru"] or "",
"translation_uk": r["translation_uk"] or "",
"translation_en": r["translation_en"] or "",
}
for r in rows
],
}
+287
View File
@@ -0,0 +1,287 @@
"""
App Auth Router — авторизация мобильного приложения Pleily.
Поддерживает:
- Анонимный вход по device_id (UUID) → выдаёт JWT на 365 дней.
- Привязка Apple ID (позже).
- Удаление аккаунта (требование Apple App Store).
Pleily-юзеры имеют ОТРИЦАТЕЛЬНЫЙ telegram_id (из sequence app_user_id_seq).
Telegram-юзеры сохраняют свои положительные telegram_id.
Все Pleily-юзеры изолированы в auth_identities: связка (provider, provider_uid)
указывает на users.telegram_id. Так один юзер может иметь несколько способов входа.
Эндпоинты:
- POST /auth/device — вход по device_id
- GET /auth/me — текущий юзер (для тестов)
- DELETE /me — удаление аккаунта (Apple требует)
🔧 НОВОЕ (07.10.2026): pleily_auth — первая версия.
🔧 ФИКС (07.10.2026): device_id_in_users —
теперь device_id пишется и в users.device_id, и в auth_identities.
Это нужно для SQL-запросов по device_id (админка, миграции).
🔧 НОВОЕ (08.10.2026): auth_me_xp_fields —
в /auth/me добавлены XP-поля: level, rank_key, rank_name,
xp_in_level, xp_needed, total_xp, weekly_xp, weekly_rank.
"""
import logging
import uuid
from datetime import datetime, timezone, timedelta
from typing import Optional
import asyncpg
import jwt
from fastapi import APIRouter, Request, HTTPException, Depends
from auth import require_auth
from database import get_pool
from config import APP_JWT_SECRET
logger = logging.getLogger(__name__)
router = APIRouter(prefix="/auth", tags=["app-auth"])
# JWT настройки
JWT_ALGORITHM = "HS256"
JWT_TTL_DAYS = 365
JWT_TTL = timedelta(days=JWT_TTL_DAYS)
# ============ JWT HELPERS ============
def make_app_jwt(user_id: int) -> str:
"""Создаёт JWT для Pleily-юзера. Payload: {user_id, exp, iat}."""
if not APP_JWT_SECRET:
raise RuntimeError("APP_JWT_SECRET not configured")
now = datetime.now(timezone.utc)
payload = {
"user_id": int(user_id),
"iat": int(now.timestamp()),
"exp": int((now + JWT_TTL).timestamp()),
}
return jwt.encode(payload, APP_JWT_SECRET, algorithm=JWT_ALGORITHM)
def verify_app_jwt(token: str) -> dict:
"""Проверяет JWT, возвращает payload. Бросает ValueError если невалиден."""
if not APP_JWT_SECRET:
raise ValueError("APP_JWT_SECRET not configured")
try:
payload = jwt.decode(token, APP_JWT_SECRET, algorithms=[JWT_ALGORITHM])
except jwt.ExpiredSignatureError:
raise ValueError("Token expired")
except jwt.InvalidTokenError as e:
raise ValueError(f"Invalid token: {e}")
if "user_id" not in payload:
raise ValueError("user_id missing in token payload")
return payload
# ============ ВСПОМОГАТЕЛЬНЫЕ ============
async def _find_user_by_device(conn, device_id: str) -> Optional[int]:
"""Ищет user_id по (provider='device', provider_uid=device_id)."""
row = await conn.fetchrow("""
SELECT user_id FROM auth_identities
WHERE provider = 'device' AND provider_uid = $1
""", device_id)
return row["user_id"] if row else None
async def _create_app_user(conn, device_id: str) -> int:
"""
Создаёт нового Pleily-юзера с отрицательным telegram_id
(из sequence app_user_id_seq) и связкой auth_identities.
Возвращает telegram_id (отрицательный).
"""
# nextval из sequence app_user_id_seq даёт -1, -2, -3, ...
uid_row = await conn.fetchrow("SELECT nextval('app_user_id_seq') AS uid")
uid = uid_row["uid"]
# 🔧 ФИКС (07.10.2026): device_id_in_users —
# раньше device_id сохранялся только в auth_identities,
# а в users.device_id был NULL. Теперь — в обоих местах.
# Это нужно для SQL-запросов по device_id (админка, миграции).
await conn.execute("""
INSERT INTO users (telegram_id, username, source, device_id)
VALUES ($1, $2, 'app', $3)
""", uid, f"app_user_{abs(uid)}", device_id)
# Создаём identity
await conn.execute("""
INSERT INTO auth_identities (user_id, provider, provider_uid)
VALUES ($1, 'device', $2)
""", uid, device_id)
logger.info(f"[app_auth] created Pleily user: telegram_id={uid}, device={device_id}")
return uid
# ============ ЭНДПОИНТЫ ============
@router.post("/device")
async def auth_device(request: Request):
"""
Вход по device_id.
Body: {"device_id": "uuid-string"}
Если юзер с таким device_id уже есть — выдаёт новый JWT.
Если нет — создаёт нового Pleily-юзера и выдаёт JWT.
Returns: {"status": "ok", "token": "...", "user_id": -1}
"""
body = await request.json()
device_id_raw = (body.get("device_id") or "").strip()
if not device_id_raw:
raise HTTPException(400, "device_id is required")
# Валидация UUID
try:
device_uuid = uuid.UUID(device_id_raw)
except (ValueError, AttributeError, TypeError):
raise HTTPException(400, "device_id must be a valid UUID")
device_id_str = str(device_uuid)
pool = await get_pool()
async with pool.acquire() as conn:
# Пытаемся найти существующего юзера
user_id = await _find_user_by_device(conn, device_id_str)
if user_id is None:
# Создаём нового — в транзакции, чтобы nextval + INSERT были атомарны
try:
async with conn.transaction():
user_id = await _create_app_user(conn, device_id_str)
except asyncpg.UniqueViolationError:
# 🔧 Гонка: два параллельных запроса с одним device_id.
# Один вставил, второй словил UniqueViolation на (provider, provider_uid).
# Просто перечитываем — юзер уже есть.
logger.warning(
f"[app_auth] race on device_id={device_id_str}, retrying SELECT"
)
user_id = await _find_user_by_device(conn, device_id_str)
if user_id is None:
raise HTTPException(500, "Failed to create or find user")
token = make_app_jwt(user_id)
logger.info(f"[app_auth] login device={device_id_str} → user_id={user_id}")
return {
"status": "ok",
"token": token,
"user_id": user_id,
}
@router.get("/me")
async def auth_me(request: Request):
"""
Текущий юзер + XP-поля.
🔧 НОВОЕ (08.10.2026): добавлены level, rank_key, rank_name,
xp_in_level, xp_needed, total_xp, weekly_xp.
"""
telegram_id, _ = await require_auth(request)
pool = await get_pool()
async with pool.acquire() as conn:
user = await conn.fetchrow(
"""
SELECT telegram_id, username, app_language, current_level,
source, device_id, apple_id, created_at
FROM users WHERE telegram_id = $1
""",
telegram_id,
)
if not user:
raise HTTPException(401, "User not found")
profile = await conn.fetchrow(
"""
SELECT nickname, avatar_id, total_xp, weekly_xp, week_started_at
FROM user_profile WHERE user_id = $1
""",
telegram_id,
)
# Weekly rank
weekly_rank = await conn.fetchval(
"""
SELECT COUNT(*) + 1
FROM user_profile
WHERE weekly_xp > COALESCE((
SELECT weekly_xp FROM user_profile WHERE user_id = $1
), 0)
""",
telegram_id,
)
# Считаем уровень
from services.xp import level_for, rank_for
total_xp = int(profile["total_xp"]) if profile else 0
weekly_xp = int(profile["weekly_xp"]) if profile else 0
level, xp_in_level, xp_needed, rank_key = level_for(total_xp)
lang = (user["app_language"] or "ru").lower()
if lang not in ("pl", "ru", "uk", "en"):
lang = "ru"
return {
"user_id": user["telegram_id"],
"username": user["username"],
"nickname": profile["nickname"] if profile else None,
"avatar_id": int(profile["avatar_id"]) if profile and profile["avatar_id"] is not None else 0,
"app_language": user["app_language"],
"current_level": user["current_level"],
"source": user["source"],
"device_id": str(user["device_id"]) if user["device_id"] else None,
"apple_id": user["apple_id"],
"created_at": user["created_at"].isoformat() if user["created_at"] else None,
# --- XP ---
"total_xp": total_xp,
"weekly_xp": weekly_xp,
"level": level,
"rank_key": rank_key,
"rank_name": rank_for(level, lang),
"xp_in_level": xp_in_level,
"xp_needed": xp_needed,
"weekly_rank": int(weekly_rank) if weekly_rank else 0,
}
@router.delete("/me")
async def auth_delete_me(request: Request):
"""
Удаление аккаунта Pleily-юзера.
Требуется Apple App Store (право на удаление внутри приложения).
Требует Authorization: Bearer <JWT>.
Удаляем users по telegram_id — FK CASCADE подчистит все связанные
таблицы (auth_identities, learning_sessions, user_learning_answers и т.д.).
"""
user_id, _username = await require_auth(request)
pool = await get_pool()
async with pool.acquire() as conn:
# Проверяем существование
exists = await conn.fetchval(
"SELECT 1 FROM users WHERE telegram_id = $1", user_id
)
if not exists:
raise HTTPException(404, "User not found")
# Удаляем юзера — каскад подчистит auth_identities и остальное
await conn.execute(
"DELETE FROM users WHERE telegram_id = $1", user_id
)
logger.info(f"[app_auth] deleted Pleily user: telegram_id={user_id}")
return {"status": "ok", "user_id": user_id}
-1
View File
@@ -5,7 +5,6 @@ AI Assistant Router — чат-помощник с историей, конте
""" """
import logging import logging
import time import time
import json
import httpx import httpx
from fastapi import APIRouter, Request, HTTPException from fastapi import APIRouter, Request, HTTPException
from auth import require_auth from auth import require_auth
+283 -67
View File
@@ -1,6 +1,5 @@
import random import random
import time import json
import hashlib # 🔧 НОВОЕ: импорт hashlib для стабильного хэширования
from fastapi import APIRouter, Request, HTTPException from fastapi import APIRouter, Request, HTTPException
from auth import require_auth from auth import require_auth
from database import get_pool from database import get_pool
@@ -82,15 +81,9 @@ def split_word_into_parts(word: str, forbidden_parts: set = None) -> list:
attempts += 1 attempts += 1
# Если за 50 попыток не нашли уникальное разбиение — # Если за 50 попыток не нашли уникальное разбиение —
# разбиваем слово ПО БУКВАМ и добавляем суффикс с хешем слова # разбиваем слово ПО БУКВАМ (каждая буква — отдельный пузырь).
# Такой суффикс гарантированно уникален для каждого слова # Без суффиксов: части остаются чистыми, игрок видит обычные буквы.
# 🔧 ИСПРАВЛЕНО: заменён hash() на hashlib.md5 для стабильности между запусками return [letter for letter in word]
word_hash = hashlib.md5(word.encode('utf-8')).hexdigest()[:4] # Берём первые 4 символа MD5
unique_parts = []
for idx, letter in enumerate(word):
unique_parts.append(f"{letter}.{word_hash}.{idx}")
return unique_parts
@router.get("/next") @router.get("/next")
@@ -101,7 +94,7 @@ async def get_next_bubble_level(request: Request):
pool = await get_pool() pool = await get_pool()
async with pool.acquire() as conn: async with pool.acquire() as conn:
user = await conn.fetchrow( user = await conn.fetchrow(
"SELECT app_language, current_level FROM users WHERE telegram_id = $1", telegram_id "SELECT app_language, current_level, difficulty FROM users WHERE telegram_id = $1", telegram_id
) )
if not user: if not user:
raise HTTPException(401, "User not registered") raise HTTPException(401, "User not registered")
@@ -115,22 +108,17 @@ async def get_next_bubble_level(request: Request):
) )
current_bubble_level = (progress["levels_completed"] if progress else 0) + 1 current_bubble_level = (progress["levels_completed"] if progress else 0) + 1
# Прогрессия по количеству слов на уровне # Количество слов по сложности
if current_bubble_level <= 10: difficulty = user["difficulty"] if "difficulty" in user.keys() else "medium"
num_words = random.choice([3, 4]) num_words = {"easy": 3, "medium": 4, "hard": 5}.get(difficulty, 4)
elif current_bubble_level <= 25:
num_words = random.choice([5, 6])
else:
num_words = random.choice([7, 8])
# Запрос слов с фильтром по уровню и level_id IS NULL # 🔧 ФИКС (30.09.2026): csv_words_source —
# источник слов переехал с level_words (старая схема level_id IS NULL)
# на csv_words (level_code). Один источник — CSV-база.
words = await conn.fetch(""" words = await conn.fetch("""
SELECT word_pl, translation_ru, translation_uk, translation_en SELECT word_pl, translation_ru, translation_uk, translation_en
FROM ( FROM csv_words
SELECT DISTINCT ON (word_pl) word_pl, translation_ru, translation_uk, translation_en WHERE level_code = $1
FROM level_words
WHERE level = $1 AND level_id IS NULL
) AS unique_words
ORDER BY RANDOM() ORDER BY RANDOM()
LIMIT $2 LIMIT $2
""", current_level, num_words) """, current_level, num_words)
@@ -164,22 +152,191 @@ async def get_next_bubble_level(request: Request):
random.shuffle(all_parts) random.shuffle(all_parts)
# 🔧 НОВОЕ (14.10.2026): сохраняем состояние уровня для подсказок
# и сбрасываем счётчики подсказок/списка при новом уровне.
level_state = [
{
"word_pl": w["word_pl"],
"translation": w["translation"],
"parts": w["parts"],
}
for w in result_words
]
await conn.execute("""
INSERT INTO bubble_words_progress
(user_id, levels_completed, total_score, level,
current_hints_used, current_list_opened, current_level_words, hinted_words)
VALUES ($1, 0, 0, $2, 0, 0, $3::jsonb, '{}')
ON CONFLICT (user_id) DO UPDATE
SET current_hints_used = 0,
current_list_opened = 0,
current_level_words = $3::jsonb,
hinted_words = '{}'
""", telegram_id, current_level, json.dumps(level_state))
return { return {
"words": result_words, "words": result_words,
"bubbles": all_parts, "bubbles": all_parts,
"level": current_bubble_level, "level": current_bubble_level,
"difficulty": user["difficulty"] or "medium",
}
@router.post("/first-part-hint")
async def first_part_hint(request: Request):
"""Подсказка «первая часть слова» — возвращает первый пузырь одного из несобранных слов.
🔧 НОВОЕ (14.10.2026): аналог GET /hints/first-letter/{level_id} из филворда.
Лимит 3 подсказки, штраф −20 (учитывается в /complete через current_hints_used).
Hard — запрещено (400).
"""
telegram_id, _ = await require_auth(request)
body = await request.json()
found_words = set(body.get("found_words", []) or [])
pool = await get_pool()
async with pool.acquire() as conn:
user = await conn.fetchrow(
"SELECT difficulty FROM users WHERE telegram_id = $1", telegram_id
)
if not user:
raise HTTPException(401, "User not registered")
difficulty = user["difficulty"] or "medium"
if difficulty == "hard":
raise HTTPException(400, "Hints are disabled on Hard difficulty")
progress = await conn.fetchrow(
"SELECT current_hints_used, current_level_words, hinted_words "
"FROM bubble_words_progress WHERE user_id = $1",
telegram_id
)
if not progress:
raise HTTPException(404, "No active level")
hints_used = progress["current_hints_used"] or 0
if hints_used >= 3:
raise HTTPException(400, "All hints used")
raw = progress["current_level_words"]
if isinstance(raw, str):
level_words = json.loads(raw) if raw else []
else:
level_words = raw or []
raw_hinted = progress["hinted_words"]
if isinstance(raw_hinted, str):
hinted = set(json.loads(raw_hinted)) if raw_hinted else set()
else:
hinted = set(raw_hinted or [])
# Слова, которые ещё не собраны и которым ещё не давали подсказку
candidates = [
w for w in level_words
if w.get("word_pl") not in found_words and w.get("word_pl") not in hinted
]
if not candidates:
raise HTTPException(400, "All words already hinted")
chosen = random.choice(candidates)
word_pl = chosen["word_pl"]
parts = chosen.get("parts") or []
first_part = parts[0] if parts else word_pl
new_hints = hints_used + 1
new_hinted = sorted(hinted | {word_pl})
await conn.execute("""
UPDATE bubble_words_progress
SET current_hints_used = $2,
hinted_words = $3
WHERE user_id = $1
""", telegram_id, new_hints, new_hinted)
return {
"word_pl": word_pl,
"first_part": first_part,
"hints_used_total": new_hints,
}
@router.post("/show-words")
async def show_words(request: Request):
"""Подсказка «показать слова» — возвращает все загаданные слова с переводами.
🔧 НОВОЕ (14.10.2026): аналог show-words из филворда.
Easy — без лимита. Medium — 1 раз (−20). Hard — запрещено (400).
"""
telegram_id, _ = await require_auth(request)
pool = await get_pool()
async with pool.acquire() as conn:
user = await conn.fetchrow(
"SELECT difficulty FROM users WHERE telegram_id = $1", telegram_id
)
if not user:
raise HTTPException(401, "User not registered")
difficulty = user["difficulty"] or "medium"
if difficulty == "hard":
raise HTTPException(400, "Word list is disabled on Hard difficulty")
progress = await conn.fetchrow(
"SELECT current_list_opened, current_level_words "
"FROM bubble_words_progress WHERE user_id = $1",
telegram_id
)
if not progress:
raise HTTPException(404, "No active level")
list_opened = progress["current_list_opened"] or 0
# Medium — список можно открыть только 1 раз
if difficulty == "medium" and list_opened >= 1:
raise HTTPException(400, "Word list already used on Medium difficulty")
raw = progress["current_level_words"]
if isinstance(raw, str):
level_words = json.loads(raw) if raw else []
else:
level_words = raw or []
words = [
{"word_pl": w.get("word_pl"), "translation": w.get("translation")}
for w in level_words
]
# Инкремент счётчика для Easy и Medium (Hard сюда не доходит)
new_list_opened = list_opened + 1
await conn.execute("""
UPDATE bubble_words_progress
SET current_list_opened = $2
WHERE user_id = $1
""", telegram_id, new_list_opened)
return {
"words": words,
"list_opened_total": new_list_opened,
} }
@router.post("/complete") @router.post("/complete")
async def complete_bubble_level(request: Request): async def complete_bubble_level(request: Request):
"""Завершение уровня пузырей, начисление очков и проверка достижений""" """Завершение уровня пузырей, начисление XP и проверка достижений.
🔧 НОВОЕ (08.10.2026): XP-система.
Штрафы:
-1 за открытие списка слов (один раз за уровень)
-1 за каждое неправильно собранное слово (макс 3)
-1 если time_ms > 60 сек
Минимум 1 звезда.
"""
telegram_id, _ = await require_auth(request) telegram_id, _ = await require_auth(request)
body = await request.json() body = await request.json()
words_count = body.get("words_count", 3) words_count = body.get("words_count", 3)
completion_time = body.get("completion_time") completion_time = body.get("completion_time")
# 🔧 ФИКС (24.09.2026): client_controlled_hints_bubblewords — wrong_words = int(body.get("wrong_words", 0) or 0)
# hints_used больше НЕ берём от клиента. Читаем из bubble_words_progress.current_hints_used.
pool = await get_pool() pool = await get_pool()
async with pool.acquire() as conn: async with pool.acquire() as conn:
@@ -189,66 +346,114 @@ async def complete_bubble_level(request: Request):
if not user_exists: if not user_exists:
raise HTTPException(401, "User not registered") raise HTTPException(401, "User not registered")
# Получаем current_level пользователя user = await conn.fetchrow(
current_level = await conn.fetchval( "SELECT current_level, difficulty FROM users WHERE telegram_id = $1", telegram_id
"SELECT current_level FROM users WHERE telegram_id = $1", telegram_id )
) or "A1" current_level = user["current_level"] or "A1"
difficulty = user["difficulty"] or "medium"
# 🔧 ФИКС (24.09.2026): client_controlled_hints_bubblewords — # Читаем серверные счётчики (не из body)
# читаем серверный hints_used. progress = await conn.fetchrow(
hints_used = await conn.fetchval( "SELECT current_hints_used, current_list_opened "
"SELECT current_hints_used FROM bubble_words_progress WHERE user_id = $1", "FROM bubble_words_progress WHERE user_id = $1",
telegram_id telegram_id
) or 0 )
hints_used = (progress["current_hints_used"] if progress else 0) or 0
hints_used = min(max(0, hints_used), 3) hints_used = min(max(0, hints_used), 3)
score = max(10, 100 - hints_used * 10) list_opened = (progress["current_list_opened"] if progress else 0) or 0
# 🔧 НОВОЕ (14.10.2026): очки по формуле филворда.
# Hard — фикс 150. 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 = 150
else:
bonus = 10 if hints_used == 0 else 0
penalty_hints = 20 * hints_used
penalty_list = 0 if difficulty == "easy" else 20 * (1 if list_opened else 0)
points = max(20, min(110, 100 - penalty_hints - penalty_list + bonus))
# Начисляем XP
from services.xp import award_xp
xp_result = await award_xp(conn, telegram_id, "bubbles", points)
score = xp_result["points"]
# 🔧 НОВОЕ (15.10.2026): флаги для накопления серий.
no_hints_clean = 1 if (hints_used == 0 and not list_opened) else 0
perfect_clean = 1 if (hints_used == 0 and not list_opened and wrong_words == 0) else 0
await conn.execute(""" await conn.execute("""
INSERT INTO bubble_words_progress (user_id, levels_completed, total_score, level, current_hints_used) INSERT INTO bubble_words_progress
VALUES ($1, 1, $2, $3, 0) (user_id, levels_completed, total_score, level,
current_hints_used, current_list_opened, current_level_words, hinted_words,
words_collected, no_hints_streak, perfect_streak)
VALUES ($1, 1, $2, $3, 0, 0, '[]'::jsonb, '{}', $4, $5, $6)
ON CONFLICT (user_id) DO UPDATE ON CONFLICT (user_id) DO UPDATE
SET levels_completed = bubble_words_progress.levels_completed + 1, SET levels_completed = bubble_words_progress.levels_completed + 1,
total_score = bubble_words_progress.total_score + $2, total_score = bubble_words_progress.total_score + $2,
level = $3, level = $3,
current_hints_used = 0 current_hints_used = 0,
""", telegram_id, score, current_level) current_list_opened = 0,
current_level_words = '[]'::jsonb,
hinted_words = '{}',
words_collected = COALESCE(bubble_words_progress.words_collected, 0) + $4,
no_hints_streak = CASE WHEN $5 = 1
THEN COALESCE(bubble_words_progress.no_hints_streak, 0) + 1 ELSE 0 END,
perfect_streak = CASE WHEN $6 = 1
THEN COALESCE(bubble_words_progress.perfect_streak, 0) + 1 ELSE 0 END
""", telegram_id, score, current_level, words_count, no_hints_clean, perfect_clean)
# 🔧 ФИКС (23.09.2026): achievements_nested_pool_acquire_bubblewords — # 🔧 НОВОЕ (15.10.2026): читаем актуальные счётчики для проверки достижений.
# вызовы достижений вынесены за async with pool.acquire() (паттерн game.py). stats = await conn.fetchrow("""
SELECT words_collected, no_hints_streak, perfect_streak, total_score
FROM bubble_words_progress WHERE user_id = $1
""", telegram_id)
words_collected = stats["words_collected"] or 0
no_hints_streak = stats["no_hints_streak"] or 0
perfect_streak = stats["perfect_streak"] or 0
bubble_total_score = stats["total_score"] or 0
# Данные для достижений
total_levels = await conn.fetchval( total_levels = await conn.fetchval(
"SELECT levels_completed FROM bubble_words_progress WHERE user_id = $1", "SELECT levels_completed FROM bubble_words_progress WHERE user_id = $1",
telegram_id telegram_id
) or 0 ) or 0
wordsearch_score = await conn.fetchval(
"SELECT COALESCE(SUM(score), 0) FROM user_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
telegram_id
) or 0
sentence_score = await conn.fetchval(
"SELECT COALESCE(SUM(score), 0) FROM sentence_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
telegram_id
) or 0
wordquiz_score = await conn.fetchval(
"SELECT COALESCE(total_score, 0) FROM word_quiz_progress WHERE user_id = $1",
telegram_id
) or 0
bubblewords_score = await conn.fetchval(
"SELECT COALESCE(total_score, 0) FROM bubble_words_progress WHERE user_id = $1",
telegram_id
) or 0
grand_total = wordsearch_score + sentence_score + wordquiz_score + bubblewords_score
achievements_to_check = [ achievements_to_check = [
("bubble_levels", total_levels), ("bubble_levels", total_levels),
("total_score", grand_total), ("total_score", xp_result["total_xp"]),
] ]
if hints_used == 0: if hints_used == 0:
achievements_to_check.append(("bubble_no_hints", 1)) achievements_to_check.append(("bubble_no_hints", 1))
if score == 100: if completion_time is not None and 0 < completion_time <= 45:
achievements_to_check.append(("bubble_perfect", 1)) achievements_to_check.append(("bubble_speed_45", 45))
if completion_time is not None and completion_time > 0 and int(completion_time) <= 45: if completion_time is not None and 0 < completion_time <= 30:
achievements_to_check.append(("bubble_speed", 45)) achievements_to_check.append(("bubble_speed_30", 30))
# 🔧 ФИКС (23.09.2026): вызовы достижений ВНЕ блока async with pool.acquire() # 🔧 НОВОЕ (15.10.2026): триггеры новых достижений.
# bubble_words — всего слов собрано
achievements_to_check.append(("bubble_words", words_collected))
# bubble_streak — серия без подсказок (если > 0)
if no_hints_streak > 0:
achievements_to_check.append(("bubble_streak", no_hints_streak))
# bubble_xp — XP в пузырях (total_score — очки именно пузырей)
achievements_to_check.append(("bubble_xp", bubble_total_score))
# bubble_speed_15 — быстрее 15 сек
if completion_time is not None and 0 < completion_time <= 15:
achievements_to_check.append(("bubble_speed_15", 15))
# bubble_speed_10 — быстрее 10 сек
if completion_time is not None and 0 < completion_time <= 10:
achievements_to_check.append(("bubble_speed_10", 10))
# Достижения — вне транзакции
from routers.achievements import check_and_award_achievements from routers.achievements import check_and_award_achievements
new_achievements = [] new_achievements = []
for ach_type, value in achievements_to_check: for ach_type, value in achievements_to_check:
@@ -260,6 +465,17 @@ async def complete_bubble_level(request: Request):
"score": score, "score": score,
"completion_time": completion_time, "completion_time": completion_time,
"new_achievements": new_achievements, "new_achievements": new_achievements,
# 🆕 XP-поля
"base_points": xp_result["base_points"],
"multiplier": xp_result["multiplier"],
"points": xp_result["points"],
"featured": xp_result["featured"],
"level_up": xp_result["level_up"],
"total_xp": xp_result["total_xp"],
"level": xp_result["level"],
"rank_key": xp_result["rank_key"],
"xp_in_level": xp_result["xp_in_level"],
"xp_needed": xp_result["xp_needed"],
} }
+36
View File
@@ -0,0 +1,36 @@
"""GET /featured — игра дня + обратный отсчёт."""
from fastapi import APIRouter, Request
from auth import require_auth
from services.xp import featured_game, featured_seconds_left, GAMES
router = APIRouter(tags=["featured"])
# 🆕 Игры, которые реально работают в приложении.
# Пока не подключим все 4 — фильтруем.
PLAYABLE_GAMES = {"wordsearch"} # потом добавим choose, sentence, bubbles
@router.get("/featured")
async def get_featured(request: Request):
"""
Возвращает игру дня (глобально для всех) и секунды до смены.
🔧 (08.10.2026): если игра дня ещё не подключена в приложении —
отдаём ближайшую играбельную (для UI-подсказки ×1.5).
"""
await require_auth(request)
game = featured_game()
# Если featured не играбельная — отдаём первую играбельную
if game not in PLAYABLE_GAMES:
playable = [g for g in GAMES if g in PLAYABLE_GAMES]
if playable:
game = playable[0]
return {
"game": game,
"seconds_left": featured_seconds_left(),
"multiplier": 1.5,
"is_actually_featured": game == featured_game(),
}
+179 -5
View File
@@ -11,6 +11,8 @@ Feed Router — посты для карусели (новости / партн
- POST /admin/feed/post/{id}/delete — удалить (вложения удалит CASCADE) - POST /admin/feed/post/{id}/delete — удалить (вложения удалит CASCADE)
- POST /admin/feed/upload-image — загрузить картинку (multipart, до 3 на пост) - POST /admin/feed/upload-image — загрузить картинку (multipart, до 3 на пост)
- POST /admin/feed/translate — перевести title+body вручную (без сохранения) - POST /admin/feed/translate — перевести title+body вручную (без сохранения)
- GET /admin/feed/list — список постов для админки (пагинация, все 4 языка)
- GET /admin/feed/stats — быстрая статистика (total/drafts/published/pinned)
Логика локализации: Логика локализации:
- В БД хранятся 4 версии поста (title_pl/ru/uk/en, body_pl/ru/uk/en). - В БД хранятся 4 версии поста (title_pl/ru/uk/en, body_pl/ru/uk/en).
@@ -21,9 +23,8 @@ import logging
import json import json
import re import re
import uuid import uuid
import os
from pathlib import Path from pathlib import Path
from typing import Optional, Any from typing import Optional
import httpx import httpx
from fastapi import APIRouter, Request, HTTPException, UploadFile, File, Form from fastapi import APIRouter, Request, HTTPException, UploadFile, File, Form
@@ -45,7 +46,7 @@ logger = logging.getLogger(__name__)
router = APIRouter(tags=["feed"]) router = APIRouter(tags=["feed"])
TOGETHER_API_URL = "https://api.together.xyz/v1/chat/completions" TOGETHER_API_URL = "https://api.together.xyz/v1/chat/completions"
TRANSLATE_MODEL = "MiniMaxAI/MiniMax-M3" TRANSLATE_MODEL = "deepseek-ai/DeepSeek-V4-Pro-0813"
# 🔧 ФИКС: бэк отдаёт полный URL картинки, чтобы фронт не гадал, # 🔧 ФИКС: бэк отдаёт полный URL картинки, чтобы фронт не гадал,
# куда склеивать относительный путь /uploads/feed/... # куда склеивать относительный путь /uploads/feed/...
@@ -252,7 +253,7 @@ async def translate_to_all_languages(
{"role": "system", "content": system_prompt}, {"role": "system", "content": system_prompt},
{"role": "user", "content": user_prompt}, {"role": "user", "content": user_prompt},
], ],
"max_tokens": 2000, "max_tokens": 4000,
"temperature": 0.3, "temperature": 0.3,
}, },
) )
@@ -322,7 +323,7 @@ async def admin_create_feed_post(request: Request):
"expires_at": "2026-10-15T23:59:59Z" (опционально, для partners) "expires_at": "2026-10-15T23:59:59Z" (опционально, для partners)
} }
Backend автоматически переведёт title/body на 4 языка через MiniMax-M3. Backend автоматически переведёт title/body на 4 языка через DeepSeek V4 Pro.
Если перевод упал — сохраняем source_language для всех языков (fallback). Если перевод упал — сохраняем source_language для всех языков (fallback).
""" """
telegram_id, _ = await require_auth(request) telegram_id, _ = await require_auth(request)
@@ -789,3 +790,176 @@ async def admin_translate_feed(request: Request):
raise HTTPException(500, "Translation failed (AI unavailable or invalid response)") raise HTTPException(500, "Translation failed (AI unavailable or invalid response)")
return translations return translations
# ============ ADMIN: СПИСОК ПОСТОВ (с пагинацией) ============
@router.get("/admin/feed/list")
async def admin_list_feed_posts(
request: Request,
section: Optional[str] = None,
page: int = 1,
limit: int = 50,
include_drafts: bool = True,
q: Optional[str] = None,
):
"""
🔧 НОВОЕ (01.10.2026): admin_feed_list —
список постов для админки со ВСЕМИ 4 языками + пагинация.
Query:
section — news|partners|contacts|apps (опционально)
page — страница (с 1)
limit — размер страницы (по умолчанию 50, макс 100)
include_drafts — включать is_published=FALSE (по умолчанию True)
q — поиск по title_pl / body_pl (ILIKE)
Ответ:
{ total, page, limit, pages, posts: [...] }
"""
telegram_id, _ = await require_auth(request)
_require_admin(telegram_id)
# Валидация
if section and section not in FEED_SECTIONS:
raise HTTPException(400, f"Invalid section: {section}")
# Защита от дурака
page = max(1, page)
limit = max(1, min(100, limit))
pool = await get_pool()
async with pool.acquire() as conn:
where = []
params = []
idx = 1
if section:
where.append(f"section = ${idx}")
params.append(section)
idx += 1
if not include_drafts:
where.append("is_published = TRUE")
if q:
where.append(f"(title_pl ILIKE ${idx} OR body_pl ILIKE ${idx} OR title_ru ILIKE ${idx} OR body_ru ILIKE ${idx})")
params.append(f"%{q}%")
idx += 1
where_sql = "WHERE " + " AND ".join(where) if where else ""
# Общее количество
total = await conn.fetchval(
f"SELECT COUNT(*) FROM feed_posts {where_sql}",
*params,
) or 0
# Страница
offset = (page - 1) * limit
rows = await conn.fetch(f"""
SELECT * FROM feed_posts
{where_sql}
ORDER BY section, is_pinned DESC, created_at DESC
LIMIT ${idx} OFFSET ${idx + 1}
""", *params, limit, offset)
if not rows:
return {
"total": total,
"page": page,
"limit": limit,
"pages": (total + limit - 1) // limit,
"posts": [],
}
# Вложения одним запросом (без N+1)
post_ids = [r["id"] for r in rows]
att_rows = await conn.fetch("""
SELECT post_id, file_path, order_number
FROM feed_attachments
WHERE post_id = ANY($1::bigint[])
ORDER BY post_id, order_number ASC
""", post_ids)
att_by_post: dict[int, list] = {}
for a in att_rows:
att_by_post.setdefault(a["post_id"], []).append(dict(a))
# Собираем результат
posts = []
for r in rows:
row = dict(r)
attachments = att_by_post.get(r["id"], [])
images = [
f"{API_PUBLIC_URL}{a['file_path']}" if a["file_path"].startswith("/") else a["file_path"]
for a in attachments
]
posts.append({
"id": row["id"],
"section": row["section"],
"source_language": row.get("source_language"),
"is_pinned": bool(row.get("is_pinned")),
"is_published": bool(row.get("is_published")),
"link_url": row.get("link_url"),
"telegram_url": row.get("telegram_url"),
"created_at": row["created_at"].isoformat() if row.get("created_at") else None,
"updated_at": row["updated_at"].isoformat() if row.get("updated_at") else None,
"expires_at": row["expires_at"].isoformat() if row.get("expires_at") else None,
"images": images,
# все 4 языка
"title_pl": row.get("title_pl") or "",
"title_ru": row.get("title_ru") or "",
"title_uk": row.get("title_uk") or "",
"title_en": row.get("title_en") or "",
"body_pl": row.get("body_pl") or "",
"body_ru": row.get("body_ru") or "",
"body_uk": row.get("body_uk") or "",
"body_en": row.get("body_en") or "",
})
return {
"total": total,
"page": page,
"limit": limit,
"pages": (total + limit - 1) // limit,
"posts": posts,
}
# ============ ADMIN: СТАТИСТИКА ДЛЯ БЕЙДЖА ============
@router.get("/admin/feed/stats")
async def admin_feed_stats(request: Request):
"""
🔧 НОВОЕ (01.10.2026): admin_feed_stats —
быстрая статистика для бейджа в сайдбаре.
Ответ:
{
"total": 42, — всего постов
"drafts": 2, — черновиков (is_published=FALSE)
"published": 40, — опубликованных
"pinned": 3 — закреплённых
}
"""
telegram_id, _ = await require_auth(request)
_require_admin(telegram_id)
pool = await get_pool()
async with pool.acquire() as conn:
row = await conn.fetchrow("""
SELECT
COUNT(*) AS total,
COUNT(*) FILTER (WHERE is_published = FALSE) AS drafts,
COUNT(*) FILTER (WHERE is_published = TRUE) AS published,
COUNT(*) FILTER (WHERE is_pinned = TRUE) AS pinned
FROM feed_posts
""")
return {
"total": int(row["total"] or 0),
"drafts": int(row["drafts"] or 0),
"published": int(row["published"] or 0),
"pinned": int(row["pinned"] or 0),
}
+552 -43
View File
@@ -13,7 +13,8 @@ async def get_progress(request: Request):
pool = await get_pool() pool = await get_pool()
async with pool.acquire() as conn: async with pool.acquire() as conn:
user = await conn.fetchrow( user = await conn.fetchrow(
"SELECT last_completed_level, current_level FROM users WHERE telegram_id = $1", """SELECT last_completed_level, current_level, last_completed_by_level
FROM users WHERE telegram_id = $1""",
telegram_id telegram_id
) )
@@ -26,6 +27,12 @@ async def get_progress(request: Request):
current_level = user["current_level"] or "A1" current_level = user["current_level"] or "A1"
# 🔧 ОБНОВЛЕНО (07.10.2026): единый счётчик progress.
# Раньше возвращали last_completed_for_current из per-level JSONB,
# но уровни теперь глобальные (level = 'common').
# Возвращаем users.last_completed_level — единый глобальный прогресс.
last_completed = user["last_completed_level"] or 0
# Очки из филвордов # Очки из филвордов
wordsearch_score = await conn.fetchval( wordsearch_score = await conn.fetchval(
"SELECT COALESCE(SUM(score), 0) FROM user_progress WHERE user_id = $1", "SELECT COALESCE(SUM(score), 0) FROM user_progress WHERE user_id = $1",
@@ -53,7 +60,7 @@ async def get_progress(request: Request):
total_score = (wordsearch_score or 0) + (sentence_score or 0) + (wordquiz_score or 0) + (bubblewords_score or 0) total_score = (wordsearch_score or 0) + (sentence_score or 0) + (wordquiz_score or 0) + (bubblewords_score or 0)
return { return {
"last_completed_level": user["last_completed_level"] or 0, "last_completed_level": last_completed,
"total_score": total_score, "total_score": total_score,
"current_level": current_level "current_level": current_level
} }
@@ -66,7 +73,7 @@ async def get_level(request: Request, level_number: int):
pool = await get_pool() pool = await get_pool()
async with pool.acquire() as conn: async with pool.acquire() as conn:
user = await conn.fetchrow( user = await conn.fetchrow(
"SELECT app_language, current_level, last_completed_level FROM users WHERE telegram_id = $1", telegram_id "SELECT app_language, current_level, last_completed_level, last_completed_by_level, difficulty FROM users WHERE telegram_id = $1", telegram_id
) )
if not user: if not user:
@@ -74,20 +81,43 @@ async def get_level(request: Request, level_number: int):
lang = user["app_language"] or "pl" lang = user["app_language"] or "pl"
current_level = user["current_level"] or "A1" current_level = user["current_level"] or "A1"
# 🔧 ОБНОВЛЕНО (07.10.2026): единый счётчик (без per-level).
# Уровни глобальные (level = 'common'), поэтому прогресс —
# users.last_completed_level. last_completed_by_level оставлен
# в БД для совместимости, но больше не используется здесь.
last_completed = user["last_completed_level"] or 0 last_completed = user["last_completed_level"] or 0
# Проверяем, что уровень доступен (не дальше следующего за пройденным) # 🔧 ОБНОВЛЕНО (07.10.2026): все уровни — common (автогенерированные).
if level_number > 1 and level_number > last_completed + 1: # Ищем по level_number без created_by и без current_level.
raise HTTPException(403, "Level not available yet. Complete previous level first.") # is_active = TRUE — чтобы черновики не показывались.
level = await conn.fetchrow("""
# Получаем уровень по его номеру ВНУТРИ выбранного уровня SELECT * FROM levels
level = await conn.fetchrow( WHERE level_number = $1
"SELECT * FROM levels WHERE level = $1 AND level_number = $2", current_level, level_number AND is_active = TRUE
) LIMIT 1
""", level_number)
if not level: if not level:
raise HTTPException(404, "Level not found") raise HTTPException(404, "Level not found")
# 🔧 ФИКС (10.10.2026): доступ к уровню по user_seen_levels.
# Раньше проверяли level_number > last_completed + 1 — это ломало
# волновую выдачу, где уровни идут вперемешку (5×5 → 6×6 → ...).
# Теперь уровень доступен, если игрок получил его через /game/next
# (есть в user_seen_levels) или уже прошёл (completed_at IS NOT NULL).
# Проверка идёт ПОСЛЕ загрузки уровня, т.к. нужен level["id"].
already_completed = await conn.fetchval(
"SELECT 1 FROM user_progress WHERE user_id = $1 AND level_id = $2 AND completed_at IS NOT NULL",
telegram_id, level["id"]
)
seen = await conn.fetchval(
"SELECT 1 FROM user_seen_levels WHERE user_id = $1 AND level_id = $2",
telegram_id, level["id"]
)
if not seen and not already_completed:
raise HTTPException(403, "Level not available. Get it via /game/next.")
words = await conn.fetch( words = await conn.fetch(
"SELECT * FROM level_words WHERE level_id = $1", level["id"] "SELECT * FROM level_words WHERE level_id = $1", level["id"]
) )
@@ -97,12 +127,43 @@ async def get_level(request: Request, level_number: int):
telegram_id, level["id"], telegram_id, level["id"],
) )
# 🔧 ФИКС (10.10.2026): wave_off_by_one —
# wave/pos хранятся в момент выдачи. Если NULL — fallback.
wave_pos = await conn.fetchrow(
"SELECT current_wave, current_position_in_wave FROM user_game_progress WHERE user_id = $1",
telegram_id,
)
if wave_pos and wave_pos["current_wave"] and wave_pos["current_position_in_wave"]:
current_wave = int(wave_pos["current_wave"])
current_pos = int(wave_pos["current_position_in_wave"])
else:
global_level = await conn.fetchval(
"SELECT global_level_number FROM user_game_progress WHERE user_id = $1",
telegram_id,
)
global_level = int(global_level or 1)
from services.waves import wave_for_level, level_in_wave
current_wave = wave_for_level(global_level)
current_pos = level_in_wave(global_level)
# 🔧 ОБНОВЛЕНО (09.10.2026): отдаём ВСЕ 4 перевода.
# Flutter сам выбирает, какой показать по context.lang.
# Старое поле 'translation' оставлено для совместимости (legacy).
word_list = [] word_list = []
for w in words: for w in words:
translation = w.get(f"translation_{lang}", "") or w.get("translation_pl", "") or w.get("translation_en", "") legacy_translation = (
w.get(f"translation_{lang}", "")
or w.get("translation_en", "")
or ""
)
word_list.append({ word_list.append({
"word_pl": w["word_pl"], "word_pl": w["word_pl"],
"translation": translation, # Legacy (для старого Flutter)
"translation": legacy_translation,
# 🆕 Все переводы (Flutter сам выбирает)
"translation_ru": w.get("translation_ru") or "",
"translation_uk": w.get("translation_uk") or "",
"translation_en": w.get("translation_en") or "",
}) })
grid_letters = level["grid_letters"] grid_letters = level["grid_letters"]
@@ -113,6 +174,22 @@ async def get_level(request: Request, level_number: int):
if isinstance(word_paths, str): if isinstance(word_paths, str):
word_paths = json.loads(word_paths) 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 { return {
"level": { "level": {
"id": level["id"], "id": level["id"],
@@ -124,10 +201,14 @@ async def get_level(request: Request, level_number: int):
}, },
"words": word_list, "words": word_list,
"progress": { "progress": {
"completed": progress is not None, "completed": is_completed,
"hints_used": progress["hints_used"] if progress else 0, "hints_used": progress["hints_used"] if progress else 0,
"score": progress["score"] if progress else 0, "score": progress["score"] if progress else 0,
}, },
# 🆕 (10.10.2026): волна и позиция в волне.
"wave": wave,
"position_in_wave": pos_in_wave,
"difficulty": user["difficulty"] or "medium",
} }
@@ -172,8 +253,18 @@ async def check_word(request: Request):
continue continue
selected_word = selected_word.lower() selected_word = selected_word.lower()
for word in word_paths.keys(): # 🔧 ФИКС (11.10.2026): word_matched_by_letters_only —
if word.lower() == selected_word: # раньше слово зачислялось только по буквам. Если те же буквы
# встречаются в другом месте сетки (например NOS вверху и внизу),
# сервер зачислял слово, хотя игрок собрал его не там.
# Теперь проверяем координаты: selected_cells должны точно
# совпасть с word_paths[word].
selected_path = [[int(cell[0]), int(cell[1])] for cell in selected_cells]
for word, path in word_paths.items():
if word.lower() != selected_word:
continue
expected_path = [[int(p[0]), int(p[1])] for p in path]
if selected_path == expected_path:
found_word = word found_word = word
break break
@@ -184,14 +275,33 @@ async def check_word(request: Request):
) )
current_streak = current_streak_row or 0 current_streak = current_streak_row or 0
# 🔧 НОВОЕ (02.11.2026): found_words — какие слова уже найдены.
# Повторный свайп уже найденного слова не должен накручивать серию.
found_words_row = await conn.fetchval(
"SELECT found_words FROM user_progress WHERE user_id = $1 AND level_id = $2",
telegram_id, level_id
)
found_words = list(found_words_row or [])
if found_word: if found_word:
if found_word in found_words:
# Слово уже найдено — не накручиваем серию.
return {
"status": "ok",
"found": True,
"word": found_word,
"server_streak": current_streak,
"already_found": True,
"new_achievements": []
}
server_streak = current_streak + 1 server_streak = current_streak + 1
found_words.append(found_word)
await conn.execute(""" await conn.execute("""
INSERT INTO user_progress (user_id, level_id, current_streak, level) INSERT INTO user_progress (user_id, level_id, current_streak, level, found_words)
VALUES ($1, $2, $3, $4) VALUES ($1, $2, $3, $4, $5)
ON CONFLICT (user_id, level_id) DO UPDATE ON CONFLICT (user_id, level_id) DO UPDATE
SET current_streak = $3 SET current_streak = $3, found_words = $5
""", telegram_id, level_id, server_streak, level_name) """, telegram_id, level_id, server_streak, level_name, found_words)
else: else:
if current_streak > 0: if current_streak > 0:
await conn.execute(""" await conn.execute("""
@@ -218,7 +328,7 @@ async def check_word(request: Request):
"new_achievements": new_achievements "new_achievements": new_achievements
} }
return {"status": "ok", "found": False, "server_streak": 0} return {"status": "ok", "found": False, "server_streak": 0, "reason": "wrong_path"}
@router.post("/complete-level") @router.post("/complete-level")
@@ -255,15 +365,32 @@ async def complete_level(request: Request):
# 🔧 ФИКС (24.09.2026): client_controlled_hints_game — # 🔧 ФИКС (24.09.2026): client_controlled_hints_game —
# hints_used читаем из БД, не доверяем клиенту. # hints_used читаем из БД, не доверяем клиенту.
hints_used = 0 hints_used = 0
# 🔧 НОВОЕ (08.10.2026): XP-система — результат award_xp.
xp_result = None
# 🆕 (11.10.2026): волновые счётчики для достижений.
waves_completed = 0
wordsearch_xp = 0
fast_streak = 0
no_hints_streak = 0
words_found = 0
# 🆕 (13.10.2026): итоги волны для модалки.
wave_completed = False
wave_points = 0
wave_max_points = 0
wave_medal_result = "none"
current_wave = 1
current_position_in_wave = 1
async with pool.acquire() as conn: async with pool.acquire() as conn:
user = await conn.fetchrow( user = await conn.fetchrow(
"SELECT id, telegram_id, last_completed_level, current_level FROM users WHERE telegram_id = $1", "SELECT id, telegram_id, last_completed_level, current_level, difficulty FROM users WHERE telegram_id = $1",
telegram_id telegram_id
) )
if not user: if not user:
raise HTTPException(401, "User not registered") raise HTTPException(401, "User not registered")
difficulty = user["difficulty"] or "medium"
level = await conn.fetchrow( level = await conn.fetchrow(
"SELECT id, level_number, grid_size, level FROM levels WHERE id = $1", level_id "SELECT id, level_number, grid_size, level FROM levels WHERE id = $1", level_id
) )
@@ -273,16 +400,32 @@ async def complete_level(request: Request):
current_level_number = level["level_number"] current_level_number = level["level_number"]
level_name = level["level"] or "A1" level_name = level["level"] or "A1"
# Проверяем, что уровень принадлежит текущему уровню пользователя # 🔧 ОБНОВЛЕНО (07.10.2026): level = 'common'.
if level_name != (user["current_level"] or "A1"): # Уровни глобальные, поэтому убираем проверку «уровень принадлежит
raise HTTPException(403, "This level does not belong to your current level") # твоему current_level». Оставляем только проверку прогресса выше.
# (Проверка не твоя-не твоя была актуальна, когда были A1/A2/B1.)
# 🔧 ФИКС (25.09.2026): already_completed_detects_hint_row —
# раньше 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( 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 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 already_completed = True
existing_score = existing_progress["score"] existing_score = existing_progress["score"]
else: else:
@@ -293,31 +436,117 @@ async def complete_level(request: Request):
telegram_id, level_id telegram_id, level_id
) or 0 ) or 0
# 🔧 ФИКС (24.09.2026): client_controlled_hints_game — # 🔧 НОВОЕ (08.10.2026): XP-система.
# читаем hints_used из БД, не доверяем клиенту. # Читаем hints_used и list_opened из БД (не доверяем клиенту).
hints_used = await conn.fetchval( hints_used = await conn.fetchval(
"SELECT hints_used FROM user_progress WHERE user_id = $1 AND level_id = $2", "SELECT hints_used FROM user_progress WHERE user_id = $1 AND level_id = $2",
telegram_id, level_id telegram_id, level_id
) or 0 ) or 0
hints_used = min(max(0, hints_used), 3) hints_used = min(max(0, hints_used), 3)
score = max(10, 100 - hints_used * 10) # 🔧 НОВОЕ (02.11.2026): проверяем, что все слова найдены.
# Раньше можно было вызвать complete-level напрямую, не найдя
# ни одного слова, и получить очки.
found_words = await conn.fetchval(
"SELECT found_words FROM user_progress WHERE user_id = $1 AND level_id = $2",
telegram_id, level_id
) or []
total_words = await conn.fetchval(
"SELECT COUNT(*) FROM level_words WHERE level_id = $1", level_id
) or 0
if len(found_words) < total_words:
raise HTTPException(400, "Not all words found")
# 🔧 ФИКС (23.09.2026): client_controlled_achievement_values — # 🆕 Штрафы (филворд):
# сбрасываем current_streak в 0 при завершении уровня. # -20 за открытие списка слов (один раз за уровень)
await conn.execute( # -20 за каждую подсказку
"""INSERT INTO user_progress (user_id, level_id, completed_at, hints_used, score, level, current_streak) list_opened = bool(body.get("list_opened", False))
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( if difficulty == "hard":
"""UPDATE users # Hard: фикс 150 (без подсказок и списка)
SET last_completed_level = GREATEST(last_completed_level, $2) points = 150
WHERE telegram_id = $1""", else:
telegram_id, current_level_number, # 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( levels_completed = await conn.fetchval(
@@ -343,6 +572,49 @@ async def complete_level(request: Request):
) or 0 ) or 0
grand_total = total_score + sentence_score + wordquiz_score + bubblewords_score grand_total = total_score + sentence_score + wordquiz_score + bubblewords_score
# 🆕 (11.10.2026): волновые счётчики.
words_in_level = await conn.fetchval(
"SELECT COUNT(*) FROM level_words WHERE level_id = $1", level_id
) or 0
# Пройдено волн = current_wave - 1; если только что завершили
# 10-й уровень волны — волна пройдена (+1).
waves_completed = current_wave - 1
if current_position_in_wave == 10:
waves_completed += 1
# 🆕 (13.10.2026): итоги волны для модалки.
from services.waves import max_points_for_wave, wave_medal
wave_completed = (current_position_in_wave == 10)
wave_points = await conn.fetchval(
"SELECT COALESCE(SUM(score), 0) FROM user_progress WHERE user_id = $1 AND wave = $2",
telegram_id, current_wave,
) or 0
wave_max_points = max_points_for_wave()
wave_medal_result = wave_medal(wave_points, wave_max_points)
# XP филворда = сумма score по user_progress (уже посчитана как total_score).
wordsearch_xp = total_score
# Обновляем счётчики серий.
is_fast = completion_time is not None and int(completion_time) <= 30
await conn.execute("""
UPDATE user_game_progress
SET fast_streak = CASE WHEN $2 THEN COALESCE(fast_streak, 0) + 1 ELSE 0 END,
no_hints_streak = CASE WHEN $3 THEN COALESCE(no_hints_streak, 0) + 1 ELSE 0 END,
words_found = COALESCE(words_found, 0) + $4,
updated_at = NOW()
WHERE user_id = $1
""", telegram_id, is_fast, hints_used == 0, words_in_level)
counters = await conn.fetchrow(
"SELECT fast_streak, no_hints_streak, words_found FROM user_game_progress WHERE user_id = $1",
telegram_id,
)
fast_streak = int(counters["fast_streak"] or 0) if counters else 0
no_hints_streak = int(counters["no_hints_streak"] or 0) if counters else 0
words_found = int(counters["words_found"] or 0) if counters else 0
# Если уровень уже был пройден — просто возвращаем результат # Если уровень уже был пройден — просто возвращаем результат
if already_completed: if already_completed:
return { return {
@@ -377,9 +649,246 @@ async def complete_level(request: Request):
ach = await check_and_award_achievements(telegram_id, "perfect_words", server_perfect_streak) ach = await check_and_award_achievements(telegram_id, "perfect_words", server_perfect_streak)
new_achievements.extend(ach) new_achievements.extend(ach)
# 🆕 (11.10.2026): волновые достижения.
ach = await check_and_award_achievements(telegram_id, "waves_completed", waves_completed)
new_achievements.extend(ach)
ach = await check_and_award_achievements(telegram_id, "wordsearch_xp", wordsearch_xp)
new_achievements.extend(ach)
if fast_streak >= 3:
ach = await check_and_award_achievements(telegram_id, "ws_speed_run", fast_streak)
new_achievements.extend(ach)
if no_hints_streak >= 10:
ach = await check_and_award_achievements(telegram_id, "ws_no_hints_streak", no_hints_streak)
new_achievements.extend(ach)
if words_found >= 1000:
ach = await check_and_award_achievements(telegram_id, "wordsearch_words", words_found)
new_achievements.extend(ach)
return { return {
"status": "ok", "status": "ok",
"score": score, "score": score,
"already_completed": False, "already_completed": False,
"new_achievements": new_achievements "new_achievements": new_achievements,
# 🆕 XP-поля
"base_points": xp_result["base_points"],
"multiplier": xp_result["multiplier"],
"points": xp_result["points"],
"featured": xp_result["featured"],
"level_up": xp_result["level_up"],
"total_xp": xp_result["total_xp"],
"level": xp_result["level"],
"rank_key": xp_result["rank_key"],
"xp_in_level": xp_result["xp_in_level"],
"xp_needed": xp_result["xp_needed"],
# 🆕 (13.10.2026): итоги волны для модалки.
"wave_completed": wave_completed,
"wave_number": current_wave,
"wave_points": wave_points,
"wave_max_points": wave_max_points,
"wave_medal": wave_medal_result,
}
# ============================================================
# 🆕 (08.10.2026): Волновая выдача уровня.
# ============================================================
@router.post("/next")
async def get_next_level(request: Request):
"""
Выдаёт следующий уровень по волновой структуре.
Логика:
1. Если есть активный уровень (выдан, но ещё не пройден) — возвращаем его.
2. Иначе смотрим user_game_progress.global_level_number.
3. Определяем волну и размер сетки через wave_plan.
4. Ищем непройденный уровень нужного размера (в user_seen_levels).
5. Помечаем как seen, обновляем user_game_progress, ставим current_level_id.
6. Возвращаем level_number.
🔧 ФИКС (10.10.2026): game_next_reuse_active_level —
раньше /game/next при каждом заходе выдавал НОВЫЙ уровень и
инкрементил global_level_number, даже если предыдущий не был пройден.
Из-за этого при повторном открытии Filwords уровень менялся
(5×5 → 6×6). Теперь сначала проверяем current_level_id:
если уровень выдан и ещё не пройден — возвращаем его же.
"""
telegram_id, _ = await require_auth(request)
pool = await get_pool()
async with pool.acquire() as conn:
# Читаем или создаём прогресс
row = await conn.fetchrow(
"""
SELECT global_level_number, session_number, session_level_number,
current_level_id, current_wave, current_position_in_wave
FROM user_game_progress WHERE user_id = $1
""",
telegram_id,
)
if row is None:
await conn.execute(
"""
INSERT INTO user_game_progress
(user_id, global_level_number, session_number, session_level_number)
VALUES ($1, 1, 1, 1)
ON CONFLICT (user_id) DO NOTHING
""",
telegram_id,
)
global_level = 1
session_number = 1
session_level = 1
current_level_id = None
else:
global_level = int(row["global_level_number"] or 1)
session_number = int(row["session_number"] or 1)
session_level = int(row["session_level_number"] or 1)
current_level_id = row["current_level_id"]
from services.waves import wave_for_level, level_in_wave, grid_size_for
# 🔧 ФИКС (10.10.2026): сначала проверяем активный уровень.
# Если он выдан и ещё не пройден — возвращаем его же,
# не двигая счётчики и не помечая новый уровень как seen.
if current_level_id is not None:
active = await conn.fetchrow(
"""
SELECT id, level_number, grid_size
FROM levels
WHERE id = $1 AND is_active = TRUE
""",
current_level_id,
)
if active is not None:
done = await conn.fetchval(
"""
SELECT 1 FROM user_progress
WHERE user_id = $1 AND level_id = $2
AND (completed_at IS NOT NULL OR COALESCE(score, 0) > 0)
""",
telegram_id, active["id"],
)
if not done:
# 🔧 ФИКС (10.10.2026): off-by-one в reuse-ветке —
# global_level уже инкрементнут при первой выдаче,
# поэтому wave/pos считаем от зафиксированных значений
# current_wave / current_position_in_wave. Fallback —
# старый расчёт для записей без этих полей.
return {
"level_id": active["id"],
"level_number": active["level_number"],
"grid_size": active["grid_size"],
"wave": int(row["current_wave"]) if row["current_wave"] else wave_for_level(global_level),
"position_in_wave": int(row["current_position_in_wave"]) if row["current_position_in_wave"] else level_in_wave(global_level),
"session_number": session_number,
"session_level": session_level,
"global_level": global_level,
"reused": True,
}
# Уровень пройден или удалён/неактивен — сбрасываем активный.
await conn.execute(
"""
UPDATE user_game_progress
SET current_level_id = NULL, updated_at = NOW()
WHERE user_id = $1
""",
telegram_id,
)
# Определяем волну и размер
wave = wave_for_level(global_level)
pos_in_wave = level_in_wave(global_level)
grid_size = grid_size_for(global_level)
# Ищем непройденный уровень нужного размера
# Исключаем те, что уже в user_seen_levels
level = await conn.fetchrow(
"""
SELECT l.id, l.level_number
FROM levels l
WHERE l.grid_size = $1
AND l.is_active = TRUE
AND l.id NOT IN (
SELECT level_id FROM user_seen_levels WHERE user_id = $2
)
ORDER BY RANDOM()
LIMIT 1
""",
grid_size, telegram_id,
)
# Fallback: если непройденных нет, берём самый давно виденный
if level is None:
level = await conn.fetchrow(
"""
SELECT l.id, l.level_number
FROM levels l
JOIN user_seen_levels usl ON usl.level_id = l.id
WHERE l.grid_size = $1
AND l.is_active = TRUE
AND usl.user_id = $2
ORDER BY usl.seen_at ASC
LIMIT 1
""",
grid_size, telegram_id,
)
if level is None:
raise HTTPException(404, "No levels available for this grid size")
level_id = level["id"]
level_number = level["level_number"]
# Помечаем как seen (обновляем seen_at если уже был)
await conn.execute(
"""
INSERT INTO user_seen_levels (user_id, level_id, seen_at)
VALUES ($1, $2, NOW())
ON CONFLICT (user_id, level_id) DO UPDATE
SET seen_at = NOW()
""",
telegram_id, level_id,
)
# Обновляем прогресс
next_global = global_level + 1
next_session_level = session_level + 1
next_session = session_number
if next_session_level > 10:
next_session_level = 1
next_session += 1
# 🔧 ФИКС (10.10.2026): запоминаем выданный уровень как активный.
await conn.execute(
"""
UPDATE user_game_progress
SET global_level_number = $2,
session_number = $3,
session_level_number = $4,
current_level_id = $5,
current_wave = $6,
current_position_in_wave = $7,
updated_at = NOW()
WHERE user_id = $1
""",
telegram_id, next_global, next_session, next_session_level, level_id,
wave, pos_in_wave,
)
return {
"level_id": level_id,
"level_number": level_number,
"grid_size": grid_size,
"wave": wave,
"position_in_wave": pos_in_wave,
"session_number": session_number,
"session_level": session_level,
"global_level": global_level,
"reused": False,
} }
+44 -47
View File
@@ -1,3 +1,5 @@
import random
from fastapi import APIRouter, Request, HTTPException from fastapi import APIRouter, Request, HTTPException
from auth import require_auth from auth import require_auth
from database import get_pool from database import get_pool
@@ -6,7 +8,7 @@ router = APIRouter(prefix="/hints", tags=["hints"])
@router.get("/first-letter/{level_id}") @router.get("/first-letter/{level_id}")
async def get_first_letter_hint(request: Request, level_id: int): async def get_first_letter_hint(request: Request, level_id: int, found: str = ""):
"""Подсказка: показывает первую букву случайного ненайденного слова""" """Подсказка: показывает первую букву случайного ненайденного слова"""
telegram_id, _ = await require_auth(request) telegram_id, _ = await require_auth(request)
@@ -53,38 +55,47 @@ async def get_first_letter_hint(request: Request, level_id: int):
import json import json
word_paths = json.loads(word_paths) word_paths = json.loads(word_paths)
# Находим первое слово, у которого есть путь # Слова уровня, у которых есть путь в word_paths
all_level_words = [w["word_pl"] for w in words] all_level_words = [w["word_pl"] for w in words]
words_with_paths = [
w for w in all_level_words
if w in word_paths and word_paths[w]
]
# Ищем слово с путём (сначала основные, потом filler-слова) if not words_with_paths:
found_word = None
first_cell = None
for word in all_level_words:
if word in word_paths and word_paths[word]:
found_word = word
first_cell = word_paths[word][0]
break
# 🔧 ФИКС (25.09.2026): hint_fake_first_cell —
# если ни у одного слова нет пути в word_paths, подсказка
# бессмысленна. Возвращаем 404, а не фейковую координату [0,0].
if not found_word:
raise HTTPException(404, "No word paths found for this level") raise HTTPException(404, "No word paths found for this level")
# 🔧 ФИКС (12.10.2026): hint_shows_found_word —
# подсказка показывала уже найденное слово. Теперь фронт передаёт
# найденные слова в query-параметре found (через запятую), и мы
# исключаем их из кандидатов.
found_words = {w.strip() for w in found.split(",") if w.strip()}
remaining_words = [w for w in words_with_paths if w not in found_words]
if not remaining_words:
raise HTTPException(404, "All words found")
# 🔧 ФИКС (11.10.2026): hint_always_first_word —
# раньше всегда возвращалось первое слово списка, поэтому
# повторные нажатия давали одну и ту же букву. Теперь слово
# выбирается случайно из ещё не найденных.
found_word = random.choice(remaining_words)
first_cell = word_paths[found_word][0]
# 🔧 ФИКС (25.09.2026): hint_consumed_before_word_paths_check — # 🔧 ФИКС (25.09.2026): hint_consumed_before_word_paths_check —
# инкрементим hints_used ТОЛЬКО после всех проверок. # инкрементим hints_used ТОЛЬКО после всех проверок.
# Раньше при 404 (нет word_paths) подсказка уже была потрачена. # Раньше при 404 (нет word_paths) подсказка уже была потрачена.
if progress: #
await conn.execute( # 🔧 ФИКС (25.09.2026): hints_used_never_incremented_actually —
"UPDATE user_progress SET hints_used = hints_used + 1 WHERE user_id = $1 AND level_id = $2", # раньше при отсутствии строки user_progress UPDATE затрагивал 0 строк,
telegram_id, level_id # и лимит 3 подсказки не работал для новых юзеров.
) # Теперь UPSERT: INSERT с ON CONFLICT DO UPDATE.
else: await conn.execute("""
await conn.execute( INSERT INTO user_progress (user_id, level_id, hints_used)
"INSERT INTO user_progress (user_id, level_id, hints_used) VALUES ($1, $2, 1)", VALUES ($1, $2, 1)
telegram_id, level_id ON CONFLICT (user_id, level_id) DO UPDATE
) SET hints_used = user_progress.hints_used + 1
""", telegram_id, level_id)
hints_already_used += 1 hints_already_used += 1
return { return {
@@ -114,7 +125,7 @@ async def get_word_list(request: Request, level_id: int):
if not user_exists: if not user_exists:
raise HTTPException(401, "User not registered") raise HTTPException(401, "User not registered")
# Получаем прогресс пользователя # Получаем прогресс пользователя (для информации в ответе)
progress = await conn.fetchrow( progress = await conn.fetchrow(
"SELECT hints_used FROM user_progress WHERE user_id = $1 AND level_id = $2", "SELECT hints_used FROM user_progress WHERE user_id = $1 AND level_id = $2",
telegram_id, level_id telegram_id, level_id
@@ -122,14 +133,11 @@ async def get_word_list(request: Request, level_id: int):
hints_already_used = progress["hints_used"] if progress else 0 hints_already_used = progress["hints_used"] if progress else 0
# 🔧 ФИКС (23.09.2026): hints_not_incremented — лимит 3 подсказки не работал, # 🔧 ФИКС (01.10.2026): word_list_is_not_hint —
# hints_used никогда не рос. Теперь проверяем лимит и инкрементим в той же транзакции. # «Показать слова» — базовая функция (в UI написано ∞),
MAX_HINTS = 3 # НЕ расходует лимит подсказок и НЕ уменьшает очки.
if hints_already_used >= MAX_HINTS: # Раньше зря инкрементился hints_used → минус 10 очков за уровень.
raise HTTPException(403, "Hint limit reached") # Лимит 3 остаётся ТОЛЬКО для «Первой буквы».
# 🔧 ФИКС (25.09.2026): word_list_hint_consumed_on_empty —
# сначала получаем слова, проверяем что они есть, только потом инкрементим.
words = await conn.fetch( words = await conn.fetch(
"SELECT * FROM level_words WHERE level_id = $1 ORDER BY word_pl", level_id "SELECT * FROM level_words WHERE level_id = $1 ORDER BY word_pl", level_id
) )
@@ -137,18 +145,7 @@ async def get_word_list(request: Request, level_id: int):
if not words: if not words:
raise HTTPException(404, "No words found for this level") raise HTTPException(404, "No words found for this level")
# Теперь безопасно инкрементим счётчик # hints_used НЕ инкрементим. hints_already_used читаем из БД для информации.
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
# Определяем язык пользователя # Определяем язык пользователя
user = await conn.fetchrow( user = await conn.fetchrow(
+166 -96
View File
@@ -10,7 +10,18 @@ LEVELS = ["A1", "A2", "B1", "B2", "C1", "C2"]
@router.get("") @router.get("")
async def get_leaderboard(request: Request, limit: int = 50): async def get_leaderboard(request: Request, limit: int = 50):
"""Рейтинг игроков — быстрое чтение из кэша""" """
Рейтинг игроков.
🔧 ОБНОВЛЕНО (08.10.2026): XP-фундамент.
Сортировка: total_xp DESC → total_score DESC.
weekly_xp в БД остаётся, но больше НЕ используется в сортировке.
Legacy-поля (total_score, wordsearch_score, ...) сохранены для Mini App.
Новые поля в каждой строке: total_xp, level, rank_key, rank_name,
xp_in_level, xp_needed, avatar_id.
"""
telegram_id, _ = await require_auth(request) telegram_id, _ = await require_auth(request)
if limit < 1: if limit < 1:
@@ -28,17 +39,39 @@ async def get_leaderboard(request: Request, limit: int = 50):
current_level = user["current_level"] or "A1" current_level = user["current_level"] or "A1"
# Быстрое чтение из MATERIALIZED VIEW # 🆕 Топ-N: matview + LEFT JOIN user_profile для XP.
# 🔧 ОБНОВЛЕНО (08.10.2026): сортировка по total_xp (weekly_xp убран).
rows = await conn.fetch(""" rows = await conn.fetch("""
SELECT * FROM leaderboard_cache SELECT
ORDER BY total_score DESC lc.*,
COALESCE(p.weekly_xp, 0) AS weekly_xp,
COALESCE(p.total_xp, 0) AS total_xp,
COALESCE(p.avatar_id, 0) AS avatar_id,
u.app_language
FROM leaderboard_cache lc
LEFT JOIN user_profile p ON p.user_id = lc.telegram_id
LEFT JOIN users u ON u.telegram_id = lc.telegram_id
ORDER BY COALESCE(p.total_xp, 0) DESC,
lc.total_score DESC,
lc.telegram_id ASC
LIMIT $1 LIMIT $1
""", limit) """, limit)
leaderboard = [] # Импорт XP-хелперов
for i, row in enumerate(rows): from services.xp import level_for, rank_for
leaderboard.append({
"rank": i + 1, def _serialize_row(row, rank_num):
"""Собирает строку рейтинга с legacy + XP-полями."""
weekly_xp = int(row["weekly_xp"] or 0)
total_xp = int(row["total_xp"] or 0)
level, xp_in_level, xp_needed, rank_key = level_for(total_xp)
lang = (row.get("app_language") or "ru").lower()
if lang not in ("pl", "ru", "uk", "en"):
lang = "ru"
return {
# Legacy (Mini App)
"rank": rank_num,
"telegram_id": row["telegram_id"], "telegram_id": row["telegram_id"],
"username": row["username"] or f"Player{row['telegram_id']}", "username": row["username"] or f"Player{row['telegram_id']}",
"total_score": row["total_score"], "total_score": row["total_score"],
@@ -50,100 +83,131 @@ async def get_leaderboard(request: Request, limit: int = 50):
"bubble_levels_completed": row["bubble_levels_completed"], "bubble_levels_completed": row["bubble_levels_completed"],
"levels_completed": 0, "levels_completed": 0,
"sentences_completed": 0, "sentences_completed": 0,
}) # 🆕 XP (Pleily)
"weekly_xp": weekly_xp, # оставлен для legacy Mini App
"total_xp": total_xp,
"level": level,
"rank_key": rank_key,
"rank_name": rank_for(level, lang),
"xp_in_level": xp_in_level,
"xp_needed": xp_needed,
"avatar_id": int(row["avatar_id"] or 0),
"app_language": lang,
}
# 🔧 ФИКС (25.09.2026): leaderboard_rank_wrong_for_uncached_user — leaderboard = [
# если пользователя нет в leaderboard_cache, подзапрос вернёт NULL, _serialize_row(row, rank_num=i + 1)
# и COUNT(*) + 1 = 1 (юзер видит себя первым, хотя у него 0 очков). for i, row in enumerate(rows)
# Теперь: если user нет в кэше — считаем его место по количеству ]
# записей с total_score > 0 + 1 (в конец списка).
my_total_in_cache = await conn.fetchval("""
SELECT total_score FROM leaderboard_cache WHERE telegram_id = $1
""", telegram_id)
if my_total_in_cache is None: # ============ Мой ранг ============
# Пользователя нет в кэше — считаем по количеству с > 0 # Читаем мои XP + legacy-статистику.
user_rank = await conn.fetchval("""
SELECT COUNT(*) + 1 FROM leaderboard_cache
WHERE total_score > 0
""") or 1
else:
user_rank = await conn.fetchval("""
SELECT COUNT(*) + 1 FROM leaderboard_cache
WHERE total_score > $1
""", my_total_in_cache)
# Персональная статистика пользователя
my_row = await conn.fetchrow(""" my_row = await conn.fetchrow("""
SELECT * FROM leaderboard_cache WHERE telegram_id = $1 SELECT
lc.*,
COALESCE(p.weekly_xp, 0) AS weekly_xp,
COALESCE(p.total_xp, 0) AS total_xp,
COALESCE(p.avatar_id, 0) AS avatar_id,
u.app_language
FROM leaderboard_cache lc
LEFT JOIN user_profile p ON p.user_id = lc.telegram_id
LEFT JOIN users u ON u.telegram_id = lc.telegram_id
WHERE lc.telegram_id = $1
""", telegram_id) """, telegram_id)
if my_row: # Если юзера нет в matview — пробуем только user_profile.
if not my_row:
my_profile = await conn.fetchrow("""
SELECT
p.weekly_xp, p.total_xp, p.avatar_id,
u.username, u.app_language, u.current_level
FROM user_profile p
JOIN users u ON u.telegram_id = p.user_id
WHERE p.user_id = $1
""", telegram_id)
if my_profile:
my_weekly_xp = int(my_profile["weekly_xp"] or 0)
my_total_xp = int(my_profile["total_xp"] or 0)
my_avatar_id = int(my_profile["avatar_id"] or 0)
my_username = my_profile["username"]
my_lang = (my_profile["app_language"] or "ru").lower()
else:
my_weekly_xp = 0
my_total_xp = 0
my_avatar_id = 0
my_username = None
my_lang = "ru"
# 🔧 ОБНОВЛЕНО (08.10.2026): место по total_xp (не weekly_xp).
my_position = await conn.fetchval("""
SELECT COUNT(*) + 1
FROM user_profile
WHERE total_xp > $1
""", my_total_xp) or 1
# Legacy-статистика (для совместимости с Mini App)
my_wordsearch = await conn.fetchval(
"SELECT COALESCE(SUM(score), 0) FROM user_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
telegram_id
) or 0
my_sentence = await conn.fetchval(
"SELECT COALESCE(SUM(score), 0) FROM sentence_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
telegram_id
) or 0
my_wordquiz = await conn.fetchval(
"SELECT COALESCE(total_score, 0) FROM word_quiz_progress WHERE user_id = $1",
telegram_id
) or 0
my_words_guessed = await conn.fetchval(
"SELECT COALESCE(words_guessed, 0) FROM word_quiz_progress WHERE user_id = $1",
telegram_id
) or 0
my_bubblewords = await conn.fetchval(
"SELECT COALESCE(total_score, 0) FROM bubble_words_progress WHERE user_id = $1",
telegram_id
) or 0
my_bubble_levels = await conn.fetchval(
"SELECT COALESCE(levels_completed, 0) FROM bubble_words_progress WHERE user_id = $1",
telegram_id
) or 0
my_total = my_wordsearch + my_sentence + my_wordquiz + my_bubblewords
my_wordsearch_levels = 0
my_sentences_completed = 0
my_avatar_id_final = my_avatar_id
my_username_final = my_username
my_lang_final = my_lang
else:
my_weekly_xp = int(my_row["weekly_xp"] or 0)
my_total_xp = int(my_row["total_xp"] or 0)
my_avatar_id_final = int(my_row["avatar_id"] or 0)
my_username_final = my_row["username"]
my_lang_final = (my_row["app_language"] or "ru").lower()
my_wordsearch = my_row["wordsearch_score"] my_wordsearch = my_row["wordsearch_score"]
my_sentence = my_row["sentence_score"] my_sentence = my_row["sentence_score"]
my_wordquiz = my_row["wordquiz_score"] my_wordquiz = my_row["wordquiz_score"]
my_words_guessed = my_row["words_guessed"] my_words_guessed = my_row["words_guessed"]
my_bubblewords = my_row["bubblewords_score"] my_bubblewords = my_row["bubblewords_score"]
my_bubble_levels = my_row["bubble_levels_completed"] my_bubble_levels = my_row["bubble_levels_completed"]
else: my_total = my_wordsearch + my_sentence + my_wordquiz + my_bubblewords
my_wordsearch = 0
my_sentence = 0 # 🔧 ОБНОВЛЕНО (08.10.2026): место по total_xp (не weekly_xp).
my_wordquiz = 0 my_position = await conn.fetchval("""
my_words_guessed = 0 SELECT COUNT(*) + 1
my_bubblewords = 0 FROM user_profile
my_bubble_levels = 0 WHERE total_xp > $1
""", my_total_xp) or 1
# Считаем НАПРЯМУЮ из основных таблиц
my_wordsearch_levels = await conn.fetchval( my_wordsearch_levels = await conn.fetchval(
"SELECT COUNT(DISTINCT level_id) FROM user_progress WHERE user_id = $1 AND completed_at IS NOT NULL", "SELECT COUNT(DISTINCT level_id) FROM user_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
telegram_id telegram_id
) or 0 ) or 0
my_sentences_completed = await conn.fetchval( my_sentences_completed = await conn.fetchval(
"SELECT COUNT(*) FROM sentence_progress WHERE user_id = $1 AND completed_at IS NOT NULL", "SELECT COUNT(*) FROM sentence_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
telegram_id telegram_id
) or 0 ) or 0
# Если пользователя нет в кэше — считаем очки из основных таблиц # ============ level_stats (legacy для Mini App) ============
if not my_row:
my_wordsearch = await conn.fetchval(
"SELECT COALESCE(SUM(score), 0) FROM user_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
telegram_id
) or 0
my_sentence = await conn.fetchval(
"SELECT COALESCE(SUM(score), 0) FROM sentence_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
telegram_id
) or 0
my_wordquiz = await conn.fetchval(
"SELECT COALESCE(total_score, 0) FROM word_quiz_progress WHERE user_id = $1",
telegram_id
) or 0
my_words_guessed = await conn.fetchval(
"SELECT COALESCE(words_guessed, 0) FROM word_quiz_progress WHERE user_id = $1",
telegram_id
) or 0
my_bubblewords = await conn.fetchval(
"SELECT COALESCE(total_score, 0) FROM bubble_words_progress WHERE user_id = $1",
telegram_id
) or 0
my_bubble_levels = await conn.fetchval(
"SELECT COALESCE(levels_completed, 0) FROM bubble_words_progress WHERE user_id = $1",
telegram_id
) or 0
my_total = my_wordsearch + my_sentence + my_wordquiz + my_bubblewords
my_position = user_rank or 1
# 🔧 ФИКС N+1 (19.09.2026): 48 запросов → 5.
# Было: цикл по 6 уровням × 8 запросов = 48 round-trip к БД.
# Стало: 5 агрегированных запросов + сборка level_stats в Python.
# 1. Справочники (не зависят от юзера) — одним запросом
ref_row = await conn.fetchrow(""" ref_row = await conn.fetchrow("""
SELECT SELECT
(SELECT COUNT(*) FROM levels WHERE level = 'A1') AS a1_levels, (SELECT COUNT(*) FROM levels WHERE level = 'A1') AS a1_levels,
@@ -160,11 +224,8 @@ async def get_leaderboard(request: Request, limit: int = 50):
(SELECT COUNT(*) FROM sentences WHERE level = 'C2') AS c2_sent (SELECT COUNT(*) FROM sentences WHERE level = 'C2') AS c2_sent
""") """)
# 2. Очки и прогресс по всем уровням сразу — 4 запроса с GROUP BY
ws_rows = await conn.fetch(""" ws_rows = await conn.fetch("""
SELECT level, SELECT level, COALESCE(SUM(score), 0) AS score, COUNT(*) AS completed
COALESCE(SUM(score), 0) AS score,
COUNT(*) AS completed
FROM user_progress FROM user_progress
WHERE user_id = $1 AND completed_at IS NOT NULL WHERE user_id = $1 AND completed_at IS NOT NULL
GROUP BY level GROUP BY level
@@ -172,9 +233,7 @@ async def get_leaderboard(request: Request, limit: int = 50):
ws_by_level = {r["level"]: r for r in ws_rows} ws_by_level = {r["level"]: r for r in ws_rows}
s_rows = await conn.fetch(""" s_rows = await conn.fetch("""
SELECT level, SELECT level, COALESCE(SUM(score), 0) AS score, COUNT(*) AS completed
COALESCE(SUM(score), 0) AS score,
COUNT(*) AS completed
FROM sentence_progress FROM sentence_progress
WHERE user_id = $1 AND completed_at IS NOT NULL WHERE user_id = $1 AND completed_at IS NOT NULL
GROUP BY level GROUP BY level
@@ -183,23 +242,19 @@ async def get_leaderboard(request: Request, limit: int = 50):
wq_rows = await conn.fetch(""" wq_rows = await conn.fetch("""
SELECT level, COALESCE(total_score, 0) AS score SELECT level, COALESCE(total_score, 0) AS score
FROM word_quiz_progress FROM word_quiz_progress WHERE user_id = $1
WHERE user_id = $1
""", telegram_id) """, telegram_id)
wq_by_level = {r["level"]: r for r in wq_rows} wq_by_level = {r["level"]: r for r in wq_rows}
bw_rows = await conn.fetch(""" bw_rows = await conn.fetch("""
SELECT level, COALESCE(total_score, 0) AS score SELECT level, COALESCE(total_score, 0) AS score
FROM bubble_words_progress FROM bubble_words_progress WHERE user_id = $1
WHERE user_id = $1
""", telegram_id) """, telegram_id)
bw_by_level = {r["level"]: r for r in bw_rows} bw_by_level = {r["level"]: r for r in bw_rows}
# 3. Собираем level_stats в Python — без единого запроса
level_stats = {} level_stats = {}
for lvl in LEVELS: for lvl in LEVELS:
lvl_lower = lvl.lower() lvl_lower = lvl.lower()
ws_score = ws_by_level.get(lvl, {}).get("score", 0) or 0 ws_score = ws_by_level.get(lvl, {}).get("score", 0) or 0
ws_completed = ws_by_level.get(lvl, {}).get("completed", 0) or 0 ws_completed = ws_by_level.get(lvl, {}).get("completed", 0) or 0
s_score = s_by_level.get(lvl, {}).get("score", 0) or 0 s_score = s_by_level.get(lvl, {}).get("score", 0) or 0
@@ -209,7 +264,6 @@ async def get_leaderboard(request: Request, limit: int = 50):
total_ws_levels = ref_row[f"{lvl_lower}_levels"] or 0 total_ws_levels = ref_row[f"{lvl_lower}_levels"] or 0
total_sentences = ref_row[f"{lvl_lower}_sent"] or 0 total_sentences = ref_row[f"{lvl_lower}_sent"] or 0
total_items = total_ws_levels + total_sentences total_items = total_ws_levels + total_sentences
completed_items = ws_completed + s_completed completed_items = ws_completed + s_completed
progress_percent = round((completed_items / total_items * 100), 1) if total_items > 0 else 0 progress_percent = round((completed_items / total_items * 100), 1) if total_items > 0 else 0
@@ -223,15 +277,20 @@ async def get_leaderboard(request: Request, limit: int = 50):
"bubblewords_score": bw_score, "bubblewords_score": bw_score,
} }
# 🔧 ИСПРАВЛЕНО: вызов достижений ВНЕ блока async with pool.acquire() # Достижения
from routers.achievements import check_and_award_achievements from routers.achievements import check_and_award_achievements
if my_position <= 3: if my_position <= 3:
await check_and_award_achievements(telegram_id, "rank_reached", my_position) await check_and_award_achievements(telegram_id, "rank_reached", my_position)
# ============ Мой ранг (XP) ============
my_level, my_xp_in_level, my_xp_needed, my_rank_key = level_for(my_total_xp)
my_rank_name = rank_for(my_level, my_lang_final)
return { return {
"leaderboard": leaderboard, "leaderboard": leaderboard,
"current_level": current_level, "current_level": current_level,
"my_rank": { "my_rank": {
# Legacy
"rank": my_position, "rank": my_position,
"telegram_id": telegram_id, "telegram_id": telegram_id,
"total_score": my_total, "total_score": my_total,
@@ -243,6 +302,17 @@ async def get_leaderboard(request: Request, limit: int = 50):
"words_guessed": my_words_guessed, "words_guessed": my_words_guessed,
"bubblewords_score": my_bubblewords, "bubblewords_score": my_bubblewords,
"bubble_levels_completed": my_bubble_levels, "bubble_levels_completed": my_bubble_levels,
# 🆕 XP
"username": my_username_final,
"weekly_xp": my_weekly_xp, # оставлен для legacy Mini App
"total_xp": my_total_xp,
"level": my_level,
"rank_key": my_rank_key,
"rank_name": my_rank_name,
"xp_in_level": my_xp_in_level,
"xp_needed": my_xp_needed,
"avatar_id": my_avatar_id_final,
"app_language": my_lang_final,
}, },
"level_stats": level_stats, "level_stats": level_stats,
} }
+360 -53
View File
@@ -13,7 +13,6 @@ from fastapi import APIRouter, Request, HTTPException
from auth import require_auth from auth import require_auth
from database import get_pool from database import get_pool
from config import TOGETHER_API_KEY from config import TOGETHER_API_KEY
from .learning_data import init_learning_data
from .learning_profile import get_weak_skills, get_strong_skills from .learning_profile import get_weak_skills, get_strong_skills
logger = logging.getLogger(__name__) logger = logging.getLogger(__name__)
@@ -21,7 +20,7 @@ logger = logging.getLogger(__name__)
router = APIRouter(prefix="/learning", tags=["learning"]) router = APIRouter(prefix="/learning", tags=["learning"])
TOGETHER_API_URL = "https://api.together.xyz/v1/chat/completions" TOGETHER_API_URL = "https://api.together.xyz/v1/chat/completions"
ANALYTICS_MODEL = "MiniMaxAI/MiniMax-M3" ANALYTICS_MODEL = "deepseek-ai/DeepSeek-V4-Pro-0813"
# Доступные функции приложения (для AI — чтобы не галлюцинировал) # Доступные функции приложения (для AI — чтобы не галлюцинировал)
AVAILABLE_FEATURES = [ AVAILABLE_FEATURES = [
@@ -444,12 +443,41 @@ async def get_learning_levels(request: Request):
@router.get("/topics") @router.get("/topics")
async def get_topics(request: Request, level: str = "A1"): async def get_topics(request: Request, level: str = "A1"):
"""Получить темы для уровня""" """
await require_auth(request) Получить темы для уровня.
🔧 ОБНОВЛЕНО (04.10.2026): track_filter —
фильтруем темы по языку юзера:
- pl → track='pl'
- ru/uk → track='ru_uk' (общий для славян)
- en → track='en'
"""
telegram_id, _ = await require_auth(request)
pool = await get_pool() pool = await get_pool()
async with pool.acquire() as conn: async with pool.acquire() as conn:
rows = await conn.fetch("SELECT * FROM learning_topics WHERE level_code = $1 AND is_active = TRUE ORDER BY order_number", level) # Определяем track из app_language юзера
return {"topics": [dict(row) for row in rows]} user_lang = await conn.fetchval(
"SELECT app_language FROM users WHERE telegram_id = $1",
telegram_id,
) or "ru"
if user_lang == "pl":
track = "pl"
elif user_lang == "en":
track = "en"
else:
# ru, uk → общий track
track = "ru_uk"
rows = await conn.fetch("""
SELECT * FROM learning_topics
WHERE level_code = $1
AND is_active = TRUE
AND track = $2
ORDER BY order_number
""", level, track)
return {"topics": [dict(row) for row in rows], "track": track}
@router.get("/topics/{topic_id}") @router.get("/topics/{topic_id}")
@@ -574,6 +602,18 @@ async def start_session(request: Request):
pool = await get_pool() pool = await get_pool()
async with pool.acquire() as conn: 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(""" row = await conn.fetchrow("""
INSERT INTO learning_sessions (user_id, level_code, topic_id, session_type) INSERT INTO learning_sessions (user_id, level_code, topic_id, session_type)
VALUES ($1, $2, $3, $4) RETURNING id VALUES ($1, $2, $3, $4) RETURNING id
@@ -582,9 +622,29 @@ async def start_session(request: Request):
return {"session_id": row["id"]} return {"session_id": row["id"]}
# 🔧 ОБНОВЛЕНО (02.10.2026): attempt_number + revised —
# если ученик отвечает на вопрос повторно (после «Повторить урок»),
# создаётся НОВАЯ запись с attempt_number+1, revised=TRUE,
# revision_of_id=предыдущий ответ. История сохраняется полностью.
@router.post("/answer") @router.post("/answer")
async def save_answer(request: Request): async def save_answer(request: Request):
"""Сохранить ответ пользователя""" """
Сохранить ответ пользователя.
🔧 ОБНОВЛЕНО (02.10.2026): attempt_number + revised —
если ученик отвечает на вопрос повторно (после «Повторить урок»),
создаётся НОВАЯ запись с attempt_number+1, revised=TRUE,
revision_of_id=предыдущий ответ. История сохраняется полностью.
Возвращает:
{
"correct": bool,
"wrong_because": str | None,
"attempt_number": int, # какая это попытка
"show_correct_answer": bool, # TRUE только если attempt >= 3
"correct_answer": str | None # только при show_correct_answer
}
"""
telegram_id, _ = await require_auth(request) telegram_id, _ = await require_auth(request)
body = await request.json() body = await request.json()
session_id = body.get("session_id") session_id = body.get("session_id")
@@ -592,20 +652,39 @@ async def save_answer(request: Request):
selected_answer = body.get("answer", "") selected_answer = body.get("answer", "")
time_taken_ms = body.get("time_taken_ms", 0) time_taken_ms = body.get("time_taken_ms", 0)
is_final = body.get("is_final_answer", True) is_final = body.get("is_final_answer", True)
# 🔧 ФИКС (22.09.2026): раньше hint_used был захардкожен False,
# поэтому подсказки не попадали в аналитику (hint_dependency всегда 0).
hint_used = body.get("hint_used", False) hint_used = body.get("hint_used", False)
# 🔧 НОВОЕ: клиент сообщает, что это повторная попытка
is_retry = body.get("is_retry", False)
if not session_id or not question_id: if not session_id or not question_id:
raise HTTPException(400, "session_id and question_id required") raise HTTPException(400, "session_id and question_id required")
pool = await get_pool() pool = await get_pool()
async with pool.acquire() as conn: async with pool.acquire() as conn:
question = await conn.fetchrow("SELECT * FROM learning_questions WHERE question_id = $1", question_id) question = await conn.fetchrow(
"SELECT * FROM learning_questions WHERE question_id = $1", question_id
)
if not question: if not question:
raise HTTPException(404, "Question not found") raise HTTPException(404, "Question not found")
correct = selected_answer.strip().lower() == (question["correct_answer"] or "").strip().lower() # 🔧 НОВОЕ: считаем текущее количество попыток по этому вопросу в сессии
prev_attempts = await conn.fetch(
"""
SELECT id, attempt_number, correct
FROM user_learning_answers
WHERE session_id = $1 AND question_id = $2
ORDER BY attempt_number ASC
""",
session_id, question_id,
)
next_attempt = (prev_attempts[-1]["attempt_number"] + 1) if prev_attempts else 1
prev_id = prev_attempts[-1]["id"] if prev_attempts else None
correct = (
selected_answer.strip().lower()
== (question["correct_answer"] or "").strip().lower()
)
wrong_because = None wrong_because = None
if not correct: if not correct:
@@ -616,58 +695,212 @@ async def save_answer(request: Request):
if option: if option:
wrong_because = option["wrong_because"] wrong_because = option["wrong_because"]
session = await conn.fetchrow("SELECT * FROM learning_sessions WHERE id = $1", session_id) session = await conn.fetchrow(
"SELECT * FROM learning_sessions WHERE id = $1", session_id
# 🔧 ФИКС (23.09.2026): learning_save_answer_missing_session_check — )
# раньше при несуществующем session_id падало с TypeError → 500.
# Теперь честная 404 + проверка владельца сессии.
if not session: if not session:
raise HTTPException(404, "Session not found") raise HTTPException(404, "Session not found")
if session["user_id"] != telegram_id: if session["user_id"] != telegram_id:
raise HTTPException(403, "Session belongs to another user") raise HTTPException(403, "Session belongs to another user")
await conn.execute(""" # 🔧 Логика revised: если это повторная попытка — фиксируем
INSERT INTO user_learning_answers (user_id, session_id, level_code, topic_id, lesson_id, question_id, selected_answer, correct, skill_tag, question_type, context_type, difficulty, time_taken_ms, hint_used, wrong_because, is_final_answer) revised = is_retry or next_attempt > 1
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16)
""", telegram_id, session_id, session["level_code"], session["topic_id"], question["lesson_id"], question_id, selected_answer, correct, question["skill_tag"], question["question_type"], question["context_type"], question["difficulty"], time_taken_ms, hint_used, wrong_because, is_final)
return {"correct": correct, "wrong_because": wrong_because} # 🔧 is_final_answer: только ПОСЛЕДНЯЯ попытка считается финальной
# (для статистики). Промежуточные — revision-записи, не идут в total.
# Если клиент сказал is_final=False (подсказка) — уважаем.
if is_retry:
# Сначала снимаем флаг is_final_answer у предыдущей записи
await conn.execute(
"""
UPDATE user_learning_answers
SET is_final_answer = FALSE
WHERE session_id = $1 AND question_id = $2
""",
session_id, question_id,
)
await conn.execute(
"""
INSERT INTO user_learning_answers (
user_id, session_id, level_code, topic_id, lesson_id,
question_id, selected_answer, correct, skill_tag,
question_type, context_type, difficulty, time_taken_ms,
attempt_number, hint_used, wrong_because, is_final_answer,
revised, revision_of_id
)
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13,
$14, $15, $16, $17, $18, $19)
""",
telegram_id, session_id, session["level_code"], session["topic_id"],
question["lesson_id"], question_id, selected_answer, correct,
question["skill_tag"], question["question_type"], question["context_type"],
question["difficulty"], time_taken_ms, next_attempt, hint_used,
wrong_because, is_final, revised, prev_id,
)
# 🔧 Решаем, показывать ли правильный ответ
# Первая попытка — НЕ показываем
# Вторая — НЕ показываем
# Третья и выше — показываем
show_correct_answer = next_attempt >= 3
# Правильный ответ — текст варианта (для recognition)
correct_answer_text = None
if show_correct_answer:
correct_option = await conn.fetchrow(
"""
SELECT option_key, text_pl, text_ru, text_uk, text_en
FROM question_options
WHERE question_id = $1 AND is_correct = TRUE
LIMIT 1
""",
question_id,
)
if correct_option:
correct_answer_text = (
f"{correct_option['option_key']} — {correct_option['text_pl']}"
)
else:
# Для production — просто correct_answer из вопроса
correct_answer_text = question["correct_answer"]
return {
"correct": correct,
"wrong_because": wrong_because,
"attempt_number": next_attempt,
"show_correct_answer": show_correct_answer,
"correct_answer": correct_answer_text,
}
# 🔧 ОБНОВЛЕНО (02.10.2026): session_report —
# без AI формируем человеческий отчёт для экрана «Тема пройдена»:
# - total / correct / percent
# - message («Отлично!» / «Стоит повторить»)
# - weak_skills этой темы (с понятными названиями)
# - next_topic
@router.post("/session/complete") @router.post("/session/complete")
async def complete_session(request: Request): async def complete_session(request: Request):
"""Завершить сессию: обновляет прогресс урока/теста, мастерство навыков, прогресс темы и AI-контекст""" """
Завершить сессию: обновляет прогресс, мастерство, AI-контекст
и возвращает отчёт для экрана «Тема пройдена».
🔧 ОБНОВЛЕНО (02.10.2026): session_report —
без AI формируем человеческий отчёт:
- total / correct / percent
- message («Отлично!» / «Стоит повторить»)
- weak_skills этой темы (с понятными названиями)
- next_topic
"""
telegram_id, _ = await require_auth(request) telegram_id, _ = await require_auth(request)
body = await request.json() body = await request.json()
session_id = body.get("session_id") session_id = body.get("session_id")
# 🔧 НОВОЕ: язык для формирования отчёта
lang = body.get("lang", "ru")
pool = await get_pool() pool = await get_pool()
async with pool.acquire() as conn: async with pool.acquire() as conn:
session = await conn.fetchrow("SELECT * FROM learning_sessions WHERE id = $1 AND user_id = $2", session_id, telegram_id) session = await conn.fetchrow(
"SELECT * FROM learning_sessions WHERE id = $1 AND user_id = $2",
session_id, telegram_id,
)
if not session: if not session:
raise HTTPException(404, "Session not found") raise HTTPException(404, "Session not found")
await conn.execute("UPDATE learning_sessions SET is_completed = TRUE, completed_at = NOW() WHERE id = $1", session_id) await conn.execute(
"UPDATE learning_sessions SET is_completed = TRUE, completed_at = NOW() WHERE id = $1",
session_id,
)
stats = await conn.fetchrow(""" # 🔧 Считаем только ПОСЛЕДНИЕ (is_final_answer=TRUE) ответы на каждый вопрос
SELECT COUNT(*) as total, COALESCE(SUM(CASE WHEN correct THEN 1 ELSE 0 END), 0) as correct_count stats = await conn.fetchrow(
FROM user_learning_answers WHERE session_id = $1 AND is_final_answer = TRUE """
""", session_id) WITH last_answers AS (
SELECT DISTINCT ON (question_id) question_id, correct, wrong_because, skill_tag
FROM user_learning_answers
WHERE session_id = $1
ORDER BY question_id, attempt_number DESC
)
SELECT
COUNT(*) AS total,
COALESCE(SUM(CASE WHEN correct THEN 1 ELSE 0 END), 0) AS correct_count
FROM last_answers
""",
session_id,
)
# Слабые навыки этой темы (те, где были ошибки)
weak_rows = await conn.fetch(
"""
WITH last_answers AS (
SELECT DISTINCT ON (question_id) question_id, correct, skill_tag
FROM user_learning_answers
WHERE session_id = $1
ORDER BY question_id, attempt_number DESC
)
SELECT
la.skill_tag,
COUNT(*) FILTER (WHERE NOT la.correct) AS errors,
COALESCE(ll.title_ru, la.skill_tag) AS name_ru,
COALESCE(ll.title_pl, la.skill_tag) AS name_pl,
COALESCE(ll.title_uk, la.skill_tag) AS name_uk,
COALESCE(ll.title_en, la.skill_tag) AS name_en
FROM last_answers la
LEFT JOIN learning_lessons ll ON ll.skill_tag = la.skill_tag
WHERE NOT la.correct
GROUP BY la.skill_tag, ll.title_ru, ll.title_pl, ll.title_uk, ll.title_en
HAVING COUNT(*) FILTER (WHERE NOT la.correct) > 0
ORDER BY errors DESC
LIMIT 5
""",
session_id,
)
# Информация о теме
topic_id = session["topic_id"] topic_id = session["topic_id"]
topic_row = await conn.fetchrow(
"SELECT * FROM learning_topics WHERE topic_id = $1", topic_id
)
# Следующая тема того же уровня
next_topic = None
if topic_row:
next_topic = await conn.fetchrow(
"""
SELECT topic_id, name_ru, name_pl, name_uk, name_en
FROM learning_topics
WHERE level_code = $1
AND order_number > $2
AND is_active = TRUE
ORDER BY order_number
LIMIT 1
""",
topic_row["level_code"], topic_row["order_number"],
)
# ============ Обновляем прогресс ============
# (всё что было — оставляем)
# Обновляем прогресс урока
if session["session_type"] == "lesson": if session["session_type"] == "lesson":
lesson_row = await conn.fetchrow(""" lesson_row = await conn.fetchrow(
SELECT DISTINCT lesson_id FROM user_learning_answers WHERE session_id = $1 AND lesson_id IS NOT NULL """
""", session_id) SELECT DISTINCT lesson_id FROM user_learning_answers
WHERE session_id = $1 AND lesson_id IS NOT NULL
""",
session_id,
)
if lesson_row and lesson_row["lesson_id"]: if lesson_row and lesson_row["lesson_id"]:
lesson_id = lesson_row["lesson_id"] lesson_id = lesson_row["lesson_id"]
score = (stats["correct_count"] / stats["total"] * 100) if stats["total"] > 0 else 0 score = (
stats["correct_count"] / stats["total"] * 100
await conn.execute(""" ) if stats["total"] > 0 else 0
INSERT INTO user_lesson_progress (user_id, lesson_id, started_at, completed_at, attempts_count, correct_count, best_score, completed) await conn.execute(
"""
INSERT INTO user_lesson_progress (
user_id, lesson_id, started_at, completed_at,
attempts_count, correct_count, best_score, completed
)
VALUES ($1, $2, NOW(), NOW(), 1, $3, $4, TRUE) VALUES ($1, $2, NOW(), NOW(), 1, $3, $4, TRUE)
ON CONFLICT (user_id, lesson_id) DO UPDATE ON CONFLICT (user_id, lesson_id) DO UPDATE
SET completed_at = NOW(), SET completed_at = NOW(),
@@ -675,37 +908,111 @@ async def complete_session(request: Request):
correct_count = user_lesson_progress.correct_count + $3, correct_count = user_lesson_progress.correct_count + $3,
best_score = GREATEST(user_lesson_progress.best_score, $4), best_score = GREATEST(user_lesson_progress.best_score, $4),
completed = TRUE completed = TRUE
""", telegram_id, lesson_id, stats["correct_count"], score) """,
telegram_id, lesson_id, stats["correct_count"], score,
)
# Обновляем прогресс темы если это тест
if session["session_type"] == "topic_test": if session["session_type"] == "topic_test":
test_score = (stats["correct_count"] / stats["total"] * 100) if stats["total"] > 0 else 0 test_score = (
stats["correct_count"] / stats["total"] * 100
await conn.execute(""" ) if stats["total"] > 0 else 0
INSERT INTO user_topic_progress (user_id, topic_id, test_started, test_completed, test_score, completed_at) await conn.execute(
"""
INSERT INTO user_topic_progress (
user_id, topic_id, test_started, test_completed, test_score, completed_at
)
VALUES ($1, $2, TRUE, TRUE, $3, NOW()) VALUES ($1, $2, TRUE, TRUE, $3, NOW())
ON CONFLICT (user_id, topic_id) DO UPDATE ON CONFLICT (user_id, topic_id) DO UPDATE
SET test_completed = TRUE, SET test_completed = TRUE,
test_score = $3, test_score = $3,
completed_at = NOW() completed_at = NOW()
""", telegram_id, topic_id, test_score) """,
telegram_id, topic_id, test_score,
# Обновляем мастерство по всем навыкам из этой сессии )
skill_tags = await conn.fetch("""
SELECT DISTINCT skill_tag FROM user_learning_answers WHERE session_id = $1
""", session_id)
skill_tags = await conn.fetch(
"SELECT DISTINCT skill_tag FROM user_learning_answers WHERE session_id = $1",
session_id,
)
for st in skill_tags: for st in skill_tags:
await update_skill_mastery(conn, telegram_id, st["skill_tag"]) await update_skill_mastery(conn, telegram_id, st["skill_tag"])
# Обновляем прогресс темы ТОЛЬКО для lesson и topic_test
if session["session_type"] in ("lesson", "topic_test") and topic_id: if session["session_type"] in ("lesson", "topic_test") and topic_id:
await update_topic_progress(conn, telegram_id, topic_id) await update_topic_progress(conn, telegram_id, topic_id)
# Обновляем AI-контекст (всегда)
await update_ai_context(conn, telegram_id) await update_ai_context(conn, telegram_id)
return {"status": "ok", "total": stats["total"], "correct_count": stats["correct_count"]} # ============ Формируем отчёт ============
total = stats["total"] or 0
correct_count = stats["correct_count"] or 0
percent = round(correct_count / total * 100) if total > 0 else 0
# Человеческое сообщение (без AI, чистая математика)
if percent >= 90:
message = {
"ru": "Отлично! Ты прекрасно усвоил тему! 🎉",
"pl": "Świetnie! Doskonale opanowałeś temat! 🎉",
"uk": "Чудово! Ти чудово засвоїв тему! 🎉",
"en": "Excellent! You've mastered this topic! 🎉",
}.get(lang, "Отлично! 🎉")
elif percent >= 75:
message = {
"ru": "Хороший результат! Так держать! 💪",
"pl": "Dobry wynik! Tak trzymaj! 💪",
"uk": "Гарний результат! Так тримати! 💪",
"en": "Good result! Keep it up! 💪",
}.get(lang, "Хороший результат! 💪")
elif percent >= 60:
message = {
"ru": "Неплохо! Но есть над чем поработать.",
"pl": "Nieźle! Ale jest nad czym popracować.",
"uk": "Непогано! Але є над чим попрацювати.",
"en": "Not bad! But there's room to improve.",
}.get(lang, "Неплохо!")
else:
message = {
"ru": "Стоит пройти тему ещё раз — много ошибок.",
"pl": "Warto powtórzyć temat — dużo błędów.",
"uk": "Варто пройти тему ще раз — багато помилок.",
"en": "Worth repeating this topic — many mistakes.",
}.get(lang, "Стоит повторить.")
# Слабые навыки на нужном языке
name_field = f"name_{lang}"
weak_skills_out = []
for w in weak_rows:
weak_skills_out.append({
"skill_tag": w["skill_tag"],
"name": w.get(name_field) or w["name_ru"],
"errors": w["errors"],
})
# Информация о следующей теме
next_out = None
if next_topic:
next_out = {
"topic_id": next_topic["topic_id"],
"name": next_topic.get(name_field) or next_topic["name_ru"],
}
# Название текущей темы
topic_name = None
if topic_row:
topic_name = topic_row.get(name_field) or topic_row["name_ru"]
return {
"status": "ok",
"total": total,
"correct_count": correct_count,
"report": {
"topic_id": topic_id,
"topic_name": topic_name,
"percent": percent,
"message": message,
"weak_skills": weak_skills_out,
"next_topic": next_out,
},
}
@router.get("/progress") @router.get("/progress")
@@ -808,7 +1115,7 @@ async def get_analytics(request: Request):
{"role": "system", "content": system_prompt}, {"role": "system", "content": system_prompt},
{"role": "user", "content": user_prompt}, {"role": "user", "content": user_prompt},
], ],
"max_tokens": 1000, "max_tokens": 3000,
"temperature": 0.7, "temperature": 0.7,
}, },
) )
+45 -4
View File
@@ -1,8 +1,27 @@
""" """
Learning Data Package — данные всех уровней. Learning Data Package — данные всех уровней.
Каждый уровень в отдельном файле. Каждый уровень в отдельном файле.
🔧 ОБНОВЛЕНО (02.10.2026): seed_data_only_if_empty —
файлы level_*.py остаются в репозитории как АРХИВ,
но при старте бэкенда контент НЕ перезаписывается, если
в БД уже есть данные.
Причины:
- Контент правится через админку → правки в БД.
- Если seed запускать всегда — правки затираются.
- Уровни (learning_levels) гарантированно создаются — они статичны.
Управление:
- Переменная окружения SEED_LEARNING_DATA=true в .env → заливаем файлы.
- По умолчанию false → пропускаем seed, если данные уже есть.
Для fresh install (пустая БД): seed запустится автоматически,
т.к. проверка «learning_topics пуст» проходит.
""" """
import logging import logging
import os
from database import get_pool from database import get_pool
from . import level_a1, level_a2, level_b1, level_b2, level_c1, level_c2 from . import level_a1, level_a2, level_b1, level_b2, level_c1, level_c2
@@ -10,10 +29,10 @@ logger = logging.getLogger(__name__)
async def init_learning_data(): async def init_learning_data():
"""Инициализирует уровни и все темы""" """Инициализирует уровни и (опционально) контент из файлов."""
pool = await get_pool() pool = await get_pool()
async with pool.acquire() as conn: async with pool.acquire() as conn:
# ============ УРОВНИ ============ # ============ УРОВНИ (всегда, они статичны) ============
levels = [ levels = [
("A1", "Poziom A1", "Уровень A1", "Рівень A1", "Level A1", 1), ("A1", "Poziom A1", "Уровень A1", "Рівень A1", "Level A1", 1),
("A2", "Poziom A2", "Уровень A2", "Рівень A2", "Level A2", 2), ("A2", "Poziom A2", "Уровень A2", "Рівень A2", "Level A2", 2),
@@ -29,7 +48,29 @@ async def init_learning_data():
ON CONFLICT (code) DO NOTHING ON CONFLICT (code) DO NOTHING
""", code, pl, ru, uk, en, sort) """, code, pl, ru, uk, en, sort)
# Загружаем данные каждого уровня logger.info("[seed] learning_levels ensured (A1-C2)")
# ============ ПРОВЕРКА: нужен ли seed контента? ============
force_seed = os.getenv("SEED_LEARNING_DATA", "false").lower() == "true"
topics_count = await conn.fetchval("""
SELECT COUNT(*) FROM learning_topics
""") or 0
if topics_count > 0 and not force_seed:
logger.info(
f"[seed] learning_topics not empty ({topics_count} topics) — "
f"skipping content seed. Установи SEED_LEARNING_DATA=true в .env "
f"для принудительной перезаливки."
)
return
# ============ SEED КОНТЕНТА (fresh install ИЛИ force) ============
if force_seed:
logger.warning("[seed] SEED_LEARNING_DATA=true — принудительная перезаливка контента")
else:
logger.info("[seed] Empty DB detected — seeding content from level_*.py files")
await level_a1.init_level_a1(conn) await level_a1.init_level_a1(conn)
await level_a2.init_level_a2(conn) await level_a2.init_level_a2(conn)
await level_b1.init_level_b1(conn) await level_b1.init_level_b1(conn)
@@ -37,4 +78,4 @@ async def init_learning_data():
await level_c1.init_level_c1(conn) await level_c1.init_level_c1(conn)
await level_c2.init_level_c2(conn) await level_c2.init_level_c2(conn)
logger.info("Learning data fully initialized") logger.info("[seed] Learning content initialized from files")
+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. Иначе → следующий урок по порядку 3. Иначе → следующий урок по порядку
Никакого AI — только детерминированная логика. Никакого AI — только детерминированная логика.
🔧 ОБНОВЛЕНО (04.10.2026): track_filter —
учитель уважает аудиторию юзера (pl / ru_uk / en).
""" """
import logging import logging
from typing import Optional, Dict, Any from typing import Optional, Dict, Any
@@ -24,6 +27,14 @@ async def get_next_lesson(conn, user_id: int) -> Dict[str, Any]:
"reason": str, "reason": str,
"skill_tag": str | None "skill_tag": str | None
} }
🔧 ОБНОВЛЕНО (04.10.2026): track_filter —
учитель уважает аудиторию юзера:
- pl → track='pl'
- ru/uk → track='ru_uk'
- en → track='en'
Все SQL-запросы фильтруют по track, чтобы не подсовывать
RU/UK-уроки польскому или английскому юзеру.
""" """
# Получаем текущий уровень пользователя # Получаем текущий уровень пользователя
@@ -31,6 +42,19 @@ async def get_next_lesson(conn, user_id: int) -> Dict[str, Any]:
SELECT current_level FROM users WHERE telegram_id = $1 SELECT current_level FROM users WHERE telegram_id = $1
""", user_id) or "A1" """, user_id) or "A1"
# 🔧 НОВОЕ (04.10.2026): track_filter —
# определяем track по app_language юзера.
user_lang = await conn.fetchval("""
SELECT app_language FROM users WHERE telegram_id = $1
""", user_id) or "ru"
if user_lang == "pl":
track = "pl"
elif user_lang == "en":
track = "en"
else:
track = "ru_uk"
# ============ ШАГ 1: Проверяем retention_status ============ # ============ ШАГ 1: Проверяем retention_status ============
# Если есть навыки, которые давно не повторяли — повторяем их # Если есть навыки, которые давно не повторяли — повторяем их
overdue_skill = await conn.fetchrow(""" overdue_skill = await conn.fetchrow("""
@@ -44,17 +68,21 @@ async def get_next_lesson(conn, user_id: int) -> Dict[str, Any]:
""", user_id) """, user_id)
if overdue_skill: if overdue_skill:
# 🔧 НОВОЕ (04.10.2026): track_filter_lesson — ищем урок по skill_tag
# ТОЛЬКО в темах нужного track.
lesson = await conn.fetchrow(""" lesson = await conn.fetchrow("""
SELECT l.lesson_id, l.topic_id, l.skill_tag, l.title_pl, l.title_ru, l.title_uk, l.title_en SELECT l.lesson_id, l.topic_id, l.skill_tag, l.title_pl, l.title_ru, l.title_uk, l.title_en
FROM learning_lessons l FROM learning_lessons l
JOIN learning_topics t ON l.topic_id = t.topic_id
WHERE l.skill_tag = $1 WHERE l.skill_tag = $1
AND l.is_active = TRUE AND l.is_active = TRUE
AND t.track = $2
ORDER BY l.order_number ORDER BY l.order_number
LIMIT 1 LIMIT 1
""", overdue_skill["skill_tag"]) """, overdue_skill["skill_tag"], track)
if lesson: if lesson:
logger.info(f"Orchestrator: review (overdue) for user={user_id}, skill={overdue_skill['skill_tag']}") logger.info(f"Orchestrator: review (overdue) for user={user_id}, skill={overdue_skill['skill_tag']}, track={track}")
return { return {
"type": "review", "type": "review",
"lesson": dict(lesson), "lesson": dict(lesson),
@@ -74,17 +102,20 @@ async def get_next_lesson(conn, user_id: int) -> Dict[str, Any]:
""", user_id) """, user_id)
if weak_skill: if weak_skill:
# 🔧 НОВОЕ (04.10.2026): track_filter_lesson
lesson = await conn.fetchrow(""" lesson = await conn.fetchrow("""
SELECT l.lesson_id, l.topic_id, l.skill_tag, l.title_pl, l.title_ru, l.title_uk, l.title_en SELECT l.lesson_id, l.topic_id, l.skill_tag, l.title_pl, l.title_ru, l.title_uk, l.title_en
FROM learning_lessons l FROM learning_lessons l
JOIN learning_topics t ON l.topic_id = t.topic_id
WHERE l.skill_tag = $1 WHERE l.skill_tag = $1
AND l.is_active = TRUE AND l.is_active = TRUE
AND t.track = $2
ORDER BY l.order_number ORDER BY l.order_number
LIMIT 1 LIMIT 1
""", weak_skill["skill_tag"]) """, weak_skill["skill_tag"], track)
if lesson: if lesson:
logger.info(f"Orchestrator: review (weak) for user={user_id}, skill={weak_skill['skill_tag']}, mastery={weak_skill['mastery_score']}") logger.info(f"Orchestrator: review (weak) for user={user_id}, skill={weak_skill['skill_tag']}, mastery={weak_skill['mastery_score']}, track={track}")
return { return {
"type": "review", "type": "review",
"lesson": dict(lesson), "lesson": dict(lesson),
@@ -93,20 +124,22 @@ async def get_next_lesson(conn, user_id: int) -> Dict[str, Any]:
} }
# ============ ШАГ 3: Проверяем, нужно ли пройти тест темы ============ # ============ ШАГ 3: Проверяем, нужно ли пройти тест темы ============
# Если пользователь завершил все уроки темы, но не прошёл тест # 🔧 НОВОЕ (04.10.2026): track_filter_test — только темы нужного track.
topic_for_test = await conn.fetchrow(""" topic_for_test = await conn.fetchrow("""
SELECT tp.topic_id, tp.lessons_total, tp.lessons_completed, tp.test_completed SELECT tp.topic_id, tp.lessons_total, tp.lessons_completed, tp.test_completed
FROM user_topic_progress tp FROM user_topic_progress tp
JOIN learning_topics t ON tp.topic_id = t.topic_id
WHERE tp.user_id = $1 WHERE tp.user_id = $1
AND tp.lessons_completed >= tp.lessons_total AND tp.lessons_completed >= tp.lessons_total
AND tp.lessons_total > 0 AND tp.lessons_total > 0
AND tp.test_completed = FALSE AND tp.test_completed = FALSE
AND t.track = $2
ORDER BY tp.topic_id ORDER BY tp.topic_id
LIMIT 1 LIMIT 1
""", user_id) """, user_id, track)
if topic_for_test: if topic_for_test:
logger.info(f"Orchestrator: test for user={user_id}, topic={topic_for_test['topic_id']}") logger.info(f"Orchestrator: test for user={user_id}, topic={topic_for_test['topic_id']}, track={track}")
return { return {
"type": "test", "type": "test",
"lesson": None, "lesson": None,
@@ -115,7 +148,7 @@ async def get_next_lesson(conn, user_id: int) -> Dict[str, Any]:
} }
# ============ ШАГ 4: Следующий урок по порядку ============ # ============ ШАГ 4: Следующий урок по порядку ============
# Находим первый непройденный урок в текущем уровне # 🔧 НОВОЕ (04.10.2026): track_filter_next — только уроки нужного track.
next_lesson = await conn.fetchrow(""" next_lesson = await conn.fetchrow("""
SELECT l.lesson_id, l.topic_id, l.skill_tag, l.title_pl, l.title_ru, l.title_uk, l.title_en, SELECT l.lesson_id, l.topic_id, l.skill_tag, l.title_pl, l.title_ru, l.title_uk, l.title_en,
t.topic_id as topic_id, t.order_number as topic_order t.topic_id as topic_id, t.order_number as topic_order
@@ -123,16 +156,17 @@ async def get_next_lesson(conn, user_id: int) -> Dict[str, Any]:
JOIN learning_topics t ON l.topic_id = t.topic_id JOIN learning_topics t ON l.topic_id = t.topic_id
WHERE t.level_code = $1 WHERE t.level_code = $1
AND l.is_active = TRUE AND l.is_active = TRUE
AND t.track = $3
AND l.lesson_id NOT IN ( AND l.lesson_id NOT IN (
SELECT lesson_id FROM user_lesson_progress SELECT lesson_id FROM user_lesson_progress
WHERE user_id = $2 AND completed = TRUE WHERE user_id = $2 AND completed = TRUE
) )
ORDER BY t.order_number, l.order_number ORDER BY t.order_number, l.order_number
LIMIT 1 LIMIT 1
""", current_level, user_id) """, current_level, user_id, track)
if next_lesson: if next_lesson:
logger.info(f"Orchestrator: new lesson for user={user_id}, lesson={next_lesson['lesson_id']}") logger.info(f"Orchestrator: new lesson for user={user_id}, lesson={next_lesson['lesson_id']}, track={track}")
return { return {
"type": "new", "type": "new",
"lesson": dict(next_lesson), "lesson": dict(next_lesson),
@@ -141,7 +175,7 @@ async def get_next_lesson(conn, user_id: int) -> Dict[str, Any]:
} }
# ============ ШАГ 5: Всё пройдено ============ # ============ ШАГ 5: Всё пройдено ============
logger.info(f"Orchestrator: all completed for user={user_id}") logger.info(f"Orchestrator: all completed for user={user_id}, track={track}")
return { return {
"type": "completed", "type": "completed",
"lesson": None, "lesson": None,
+12 -8
View File
@@ -1,4 +1,3 @@
import random
from fastapi import APIRouter, Request, HTTPException from fastapi import APIRouter, Request, HTTPException
from auth import require_auth from auth import require_auth
from database import get_pool from database import get_pool
@@ -21,14 +20,19 @@ async def get_next_word(request: Request):
lang = user["app_language"] or "pl" lang = user["app_language"] or "pl"
# Берём случайное слово из всех уровней (без привязки к конкретному уровню) # 🔧 ФИКС (30.09.2026): csv_words_source —
# источник слов переехал с level_words (старая схема level_id IS NULL)
# на csv_words. В csv_words нет колонки level — только level_code.
# Фронт ожидает поле "level", поэтому используем алиас level_code AS level.
# DISTINCT ON (word_pl) больше не нужен — в csv_words
# есть UNIQUE(level_code, word_pl), дубликатов по word_pl на одном
# уровне нет, но между уровнями могут быть. Поэтому слово может
# попасться несколько раз с разным level_code — оставляем как есть
# (для произношения уровень не критичен).
word = await conn.fetchrow(""" word = await conn.fetchrow("""
SELECT word_pl, translation_ru, translation_uk, translation_en, level SELECT word_pl, translation_ru, translation_uk, translation_en,
FROM ( level_code AS level
SELECT DISTINCT ON (word_pl) word_pl, translation_ru, translation_uk, translation_en, level FROM csv_words
FROM level_words
WHERE level_id IS NULL
) AS unique_words
ORDER BY RANDOM() ORDER BY RANDOM()
LIMIT 1 LIMIT 1
""") """)
+151 -67
View File
@@ -7,39 +7,6 @@ from database import get_pool
router = APIRouter(prefix="/sentences", tags=["sentences"]) router = APIRouter(prefix="/sentences", tags=["sentences"])
@router.get("/{sentence_id}/hint")
async def get_sentence_hint(sentence_id: int, request: Request):
"""Получить правильное предложение в качестве подсказки (одноразово)"""
telegram_id, _ = await require_auth(request)
pool = await get_pool()
async with pool.acquire() as conn:
row = await conn.fetchrow(
"SELECT sentence_pl FROM sentences WHERE id = $1", sentence_id
)
if not row:
raise HTTPException(404, "Sentence not found")
# 🔧 ФИКС (24.09.2026): sentence_hint_no_limit — лимит 1 раз на предложение.
already_used = await conn.fetchval(
"SELECT 1 FROM sentence_hints_used WHERE user_id = $1 AND sentence_id = $2",
telegram_id, sentence_id
)
if already_used:
raise HTTPException(403, "Hint already used for this sentence")
# Записываем использование
await conn.execute("""
INSERT INTO sentence_hints_used (user_id, sentence_id)
VALUES ($1, $2)
ON CONFLICT (user_id, sentence_id) DO NOTHING
""", telegram_id, sentence_id)
return {
"sentence_pl": row["sentence_pl"],
}
def load_sentences_from_csv(filename): def load_sentences_from_csv(filename):
"""Загружает предложения из CSV файла (формат: polish,english,russian,ukrainian).""" """Загружает предложения из CSV файла (формат: polish,english,russian,ukrainian)."""
sentences = [] sentences = []
@@ -65,6 +32,7 @@ async def init_sentences():
("B1", "sentences_b1.csv"), ("B1", "sentences_b1.csv"),
] ]
offset = 0
for level, filename in level_files: for level, filename in level_files:
sentences = load_sentences_from_csv(filename) sentences = load_sentences_from_csv(filename)
for i, s in enumerate(sentences): for i, s in enumerate(sentences):
@@ -74,11 +42,12 @@ async def init_sentences():
await conn.execute( await conn.execute(
"""INSERT INTO sentences (sentence_number, sentence_pl, translation_ru, translation_uk, translation_en, difficulty, level) """INSERT INTO sentences (sentence_number, sentence_pl, translation_ru, translation_uk, translation_en, difficulty, level)
VALUES ($1, $2, $3, $4, $5, $6, $7) VALUES ($1, $2, $3, $4, $5, $6, $7)
ON CONFLICT (level, sentence_number) DO NOTHING""", ON CONFLICT (sentence_number) DO NOTHING""",
i + 1, s["sentence_pl"], offset + i + 1, s["sentence_pl"],
s["translation_ru"], s["translation_uk"], s["translation_en"], s["translation_ru"], s["translation_uk"], s["translation_en"],
difficulty, level difficulty, level
) )
offset += len(sentences)
def normalize_word_for_display(word: str) -> str: def normalize_word_for_display(word: str) -> str:
@@ -100,28 +69,34 @@ async def get_next_sentence(request: Request):
pool = await get_pool() pool = await get_pool()
async with pool.acquire() as conn: async with pool.acquire() as conn:
user = await conn.fetchrow( user = await conn.fetchrow(
"SELECT app_language, current_level FROM users WHERE telegram_id = $1", telegram_id "SELECT app_language, difficulty FROM users WHERE telegram_id = $1", telegram_id
) )
if not user: if not user:
raise HTTPException(401, "User not registered") raise HTTPException(401, "User not registered")
lang = user["app_language"] or "pl" lang = user["app_language"] or "pl"
current_level = user["current_level"] or "A1" difficulty = user["difficulty"] or "medium"
# Находим случайное непройденное предложение нужного уровня # Находим случайное непройденное предложение (единый пул)
row = await conn.fetchrow(""" row = await conn.fetchrow("""
SELECT s.* FROM sentences s SELECT s.* FROM sentences s
WHERE s.level = $1 WHERE s.id NOT IN (
AND s.id NOT IN ( SELECT sentence_id FROM sentence_progress WHERE user_id = $1 AND completed_at IS NOT NULL
SELECT sentence_id FROM sentence_progress WHERE user_id = $2
) )
ORDER BY RANDOM() ORDER BY RANDOM()
LIMIT 1 LIMIT 1
""", current_level, telegram_id) """, telegram_id)
if not row: if not row:
return {"completed": True, "message": "All sentences completed!"} 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() correct_words = row["sentence_pl"].split()
@@ -140,10 +115,64 @@ async def get_next_sentence(request: Request):
"correct_words": display_words, "correct_words": display_words,
"translation": translation, "translation": translation,
"difficulty": row["difficulty"], "difficulty": row["difficulty"],
"user_difficulty": difficulty,
"level": row["level"], "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") @router.post("/check")
async def check_sentence(request: Request): async def check_sentence(request: Request):
"""Проверка предложения с защитой от повторного прохождения и выдачей достижений""" """Проверка предложения с защитой от повторного прохождения и выдачей достижений"""
@@ -160,6 +189,8 @@ async def check_sentence(request: Request):
raise HTTPException(400, "Too many words") raise HTTPException(400, "Too many words")
pool = await get_pool() pool = await get_pool()
# 🔧 НОВОЕ (08.10.2026): XP-система — результат award_xp.
xp_result = None
async with pool.acquire() as conn: async with pool.acquire() as conn:
user_exists = await conn.fetchval( user_exists = await conn.fetchval(
"SELECT 1 FROM users WHERE telegram_id = $1", telegram_id "SELECT 1 FROM users WHERE telegram_id = $1", telegram_id
@@ -174,7 +205,7 @@ async def check_sentence(request: Request):
raise HTTPException(404, "Sentence not found") raise HTTPException(404, "Sentence not found")
existing_progress = await conn.fetchrow( 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 telegram_id, sentence_id
) )
@@ -206,20 +237,67 @@ async def check_sentence(request: Request):
is_correct = user_words_normalized == correct_words_normalized is_correct = user_words_normalized == correct_words_normalized
if is_correct: if is_correct:
word_count = len(correct_words_original) # 🔧 НОВОЕ (16.10.2026): очки по формуле сложностей.
if word_count <= 4: # Easy — фикс 20. Medium — 60 − 20×list_opened (мин 20).
score = 50 # Hard — 100, +50 бонус если completion_time <= 15 сек.
elif word_count <= 6: wrong_checks = int(body.get("wrong_checks", 0) or 0)
score = 75
else: user_row = await conn.fetchrow(
score = 100 "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( await conn.execute(
"""INSERT INTO sentence_progress (user_id, sentence_id, completed_at, score, level) """INSERT INTO sentence_progress (user_id, sentence_id, completed_at, score, level, completion_time)
VALUES ($1, $2, NOW(), $3, $4)""", VALUES ($1, $2, NOW(), $3, $4, $5)
telegram_id, sentence_id, score, row["level"], 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 — # 🔧 ФИКС (23.09.2026): achievements_nested_pool_acquire_sentences —
# раньше check_and_award_achievements вызывался ВНУТРИ async with pool.acquire(), # раньше check_and_award_achievements вызывался ВНУТРИ async with pool.acquire(),
# что могло привести к дедлоку пула. Теперь собираем данные внутри блока, # что могло привести к дедлоку пула. Теперь собираем данные внутри блока,
@@ -250,6 +328,9 @@ async def check_sentence(request: Request):
achievements_to_check = [ achievements_to_check = [
("sentences_completed", sentences_completed), ("sentences_completed", sentences_completed),
("total_score", grand_total), ("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: if completion_time is not None and completion_time > 0:
achievements_to_check.append(("speed_sentence", int(completion_time))) achievements_to_check.append(("speed_sentence", int(completion_time)))
@@ -267,7 +348,18 @@ async def check_sentence(request: Request):
"correct_words": [normalize_word_for_display(w) for w in correct_words_original], "correct_words": [normalize_word_for_display(w) for w in correct_words_original],
"already_completed": False, "already_completed": False,
"score": score, "score": score,
"new_achievements": new_achievements "new_achievements": new_achievements,
# 🆕 XP
"base_points": xp_result["base_points"],
"multiplier": xp_result["multiplier"],
"points": xp_result["points"],
"featured": xp_result["featured"],
"level_up": xp_result["level_up"],
"total_xp": xp_result["total_xp"],
"level": xp_result["level"],
"rank_key": xp_result["rank_key"],
"xp_in_level": xp_result["xp_in_level"],
"xp_needed": xp_result["xp_needed"],
} }
return { return {
@@ -285,21 +377,14 @@ async def get_sentence_stats(request: Request):
pool = await get_pool() pool = await get_pool()
async with pool.acquire() as conn: async with pool.acquire() as conn:
user = await conn.fetchrow( total = await conn.fetchval("SELECT COUNT(*) FROM sentences")
"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
)
completed = await conn.fetchval( completed = await conn.fetchval(
"SELECT COUNT(*) FROM sentence_progress WHERE user_id = $1 AND level = $2", "SELECT COUNT(*) FROM sentence_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
telegram_id, current_level telegram_id
) )
total_score = await conn.fetchval( total_score = await conn.fetchval(
"SELECT COALESCE(SUM(score), 0) FROM sentence_progress WHERE user_id = $1 AND level = $2", "SELECT COALESCE(SUM(score), 0) FROM sentence_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
telegram_id, current_level telegram_id
) )
return { return {
@@ -308,5 +393,4 @@ async def get_sentence_stats(request: Request):
"remaining": total - (completed or 0), "remaining": total - (completed or 0),
"total_score": total_score or 0, "total_score": total_score or 0,
"progress_percent": round(((completed or 0) / total * 100), 1) if total > 0 else 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 — система поддержки пользователей. Support Router — система поддержки пользователей.
Пользователи пишут админу о багах, неточностях и предложениях. Пользователи пишут админу о багах, неточностях и предложениях.
Админ отвечает. Обе стороны могут переводить сообщения через AI (MiniMax-M3). Админ отвечает. Обе стороны могут переводить сообщения через AI (DeepSeek V4 Pro).
""" """
import logging import logging
import httpx import httpx
@@ -16,11 +16,11 @@ logger = logging.getLogger(__name__)
router = APIRouter(prefix="/support", tags=["support"]) router = APIRouter(prefix="/support", tags=["support"])
TOGETHER_API_URL = "https://api.together.xyz/v1/chat/completions" TOGETHER_API_URL = "https://api.together.xyz/v1/chat/completions"
SUPPORT_MODEL = "MiniMaxAI/MiniMax-M3" SUPPORT_MODEL = "deepseek-ai/DeepSeek-V4-Pro-0813"
async def call_ai_translate(text: str, target_lang: str) -> str: async def call_ai_translate(text: str, target_lang: str) -> str:
"""Переводит текст через AI (MiniMax-M3).""" """Переводит текст через AI (DeepSeek V4 Pro)."""
if not TOGETHER_API_KEY: if not TOGETHER_API_KEY:
return "" return ""
@@ -38,7 +38,7 @@ async def call_ai_translate(text: str, target_lang: str) -> str:
{"role": "system", "content": f"Ты — переводчик. Переведи текст на язык: {target_lang}. Отвечай только переводом без пояснений. Не используй markdown."}, {"role": "system", "content": f"Ты — переводчик. Переведи текст на язык: {target_lang}. Отвечай только переводом без пояснений. Не используй markdown."},
{"role": "user", "content": text}, {"role": "user", "content": text},
], ],
"max_tokens": 500, "max_tokens": 1500,
"temperature": 0.3, "temperature": 0.3,
}, },
) )
@@ -334,7 +334,7 @@ async def get_unread_count(request: Request):
@router.post("/translate") @router.post("/translate")
async def translate_message(request: Request): async def translate_message(request: Request):
""" """
Перевод сообщения через AI (MiniMax-M3). Перевод сообщения через AI (DeepSeek V4 Pro).
Доступно и пользователю, и админу. Доступно и пользователю, и админу.
""" """
telegram_id, _ = await require_auth(request) telegram_id, _ = await require_auth(request)
+231 -21
View File
@@ -1,3 +1,13 @@
# 🔧 ФИКС (05.10.2026): max_tokens_for_v4_pro —
# DeepSeek V4 Pro — reasoning-модель, ~80% токенов уходит в reasoning_content,
# только 20% — в content. Увеличили max_tokens в 3 раза, чтобы избежать
# обрезки (finish_reason='length') и пустого content.
#
# 🔧 ФИКС (05.10.2026): disable_reasoning_for_fast_tasks —
# Для простых задач (переводы, объяснения, примеры) reasoning не нужен,
# добавляем reasoning_effort="none" в call_ai. Это экономит токены
# и ускоряет ответ в 3-4 раза.
""" """
Teacher Router — гибридный чат-учитель. Teacher Router — гибридный чат-учитель.
Контент из БД (бесплатно), AI только для реакций и пробелов. Контент из БД (бесплатно), AI только для реакций и пробелов.
@@ -43,7 +53,7 @@ logger = logging.getLogger(__name__)
router = APIRouter(prefix="/teacher", tags=["teacher"]) router = APIRouter(prefix="/teacher", tags=["teacher"])
TOGETHER_API_URL = "https://api.together.xyz/v1/chat/completions" TOGETHER_API_URL = "https://api.together.xyz/v1/chat/completions"
TEACHER_MODEL = "MiniMaxAI/MiniMax-M3" TEACHER_MODEL = "deepseek-ai/DeepSeek-V4-Pro-0813"
TEACHER_AI_DAILY_LIMIT = 5 TEACHER_AI_DAILY_LIMIT = 5
@@ -79,10 +89,93 @@ async def get_user_lang(conn, user_id: int) -> str:
return lang if lang in ["pl", "ru", "uk", "en"] else "pl" return lang if lang in ["pl", "ru", "uk", "en"] else "pl"
# 🔧 (04.11.2026): словарь синонимов категорий на 4 языках.
# Позволяет понимать запросы вида «дай 5 ложных друзей» (русский),
# «фальшиві друзі» (украинский), «false friends» (английский) и т.д.
CATEGORY_SYNONYMS = {
"false_friend": ["ложн", "фальшив", "хибн", "помилков", "false friend", "falszywy", "fałszyw"],
"rule": ["правил", "reguł", "zasada", "zasady", "rule"],
"cheatsheet": ["шпаргал", "ściąg", "cheatsheet"],
"word": ["слов", "słow", "słowo", "word"],
"text": ["текст", "tekst", "text"],
"alphabet": ["алфавит", "азбук", "абетк", "alfabet", "alphabet"],
"lesson": ["урок", "lekcj", "lesson"],
"lecture": ["лекци", "лекці", "wykład", "lecture"],
"test": ["тест", "sprawdzian", "test"],
"example": ["пример", "приклад", "przykład", "example"],
"task": ["задан", "завдан", "zadani", "task"],
}
# Языковые теги материалов (совпадают с тегами, которые ставит seed-скрипт).
LANG_TAGS = {"pl", "ru", "uk", "en"}
async def search_teacher_materials(conn, query: str, lang: str, limit: int = 5):
"""
Ищет материалы в базе знаний Pleily (teacher_materials) по запросу.
Понимает категории на 4 языках (синонимы), фильтрует по языку пользователя,
сопоставляет теги и слова запроса с title/content материала.
Возвращает список самых релевантных материалов (до limit).
"""
rows = await conn.fetch("""
SELECT * FROM teacher_materials
WHERE is_active = TRUE
ORDER BY created_at DESC
LIMIT 200
""")
query_lower = query.lower()
query_words = [w for w in re.split(r'[^a-ząćęłńóśźż0-9]+', query_lower) if len(w) > 2]
# Определяем запрошенную категорию по синонимам.
requested_category = None
for category, synonyms in CATEGORY_SYNONYMS.items():
if any(s in query_lower for s in synonyms):
requested_category = category
break
scored = []
for row in rows:
tags = row["tags"] or []
category = row["category"]
title = (row.get(f"title_{lang}") or row.get("title_pl") or "").lower()
content = (row.get(f"content_{lang}") or row.get("content_pl") or "").lower()
# 🔧 Фильтр по языку: если у материала есть языковой тег (ru/uk/en/pl),
# и он не совпадает с языком пользователя — пропускаем материал.
# Материалы без языкового тега считаются универсальными.
material_lang_tags = [t for t in tags if t in LANG_TAGS]
if material_lang_tags and lang not in material_lang_tags:
continue
score = 0
# Категория совпала с запрошенной — сильный сигнал.
if requested_category and category == requested_category:
score += 5
for tag in tags:
if tag.lower() in query_lower:
score += 3
for word in query_words:
if word in title:
score += 2
if word in content:
score += 1
if score > 0:
scored.append((score, row))
scored.sort(key=lambda x: -x[0])
return [r for _, r in scored[:limit]]
async def get_teacher_ai_usage(conn, user_id: int) -> int: async def get_teacher_ai_usage(conn, user_id: int) -> int:
"""Получает количество AI-команд учителя за сегодня.""" """Получает количество AI-команд учителя за сегодня."""
# 🔧 ФИКС (03.11.2026): было COUNT(*) — считало СТРОКИ, а не команды.
# Таблица teacher_ai_usage хранит всё в одной строке на юзера (UNIQUE
# user_id+usage_date), где command_count растёт. COUNT(*) всегда давал
# 0 или 1 → счётчик «застревал» на «0 из 5». Теперь читаем command_count.
count = await conn.fetchval(""" count = await conn.fetchval("""
SELECT COUNT(*) FROM teacher_ai_usage SELECT command_count FROM teacher_ai_usage
WHERE user_id = $1 AND usage_date = CURRENT_DATE WHERE user_id = $1 AND usage_date = CURRENT_DATE
""", user_id) """, user_id)
return count or 0 return count or 0
@@ -100,10 +193,9 @@ async def increment_teacher_ai_usage(conn, user_id: int) -> None:
async def check_ai_limit(conn, user_id: int) -> bool: async def check_ai_limit(conn, user_id: int) -> bool:
"""Проверяет, может ли пользователь использовать AI-команду.""" """Проверяет, может ли пользователь использовать AI-команду."""
if user_id in ADMIN_IDS: # 🔧 (03.11.2026): лимит временно отключён — Oleg тестирует раздел.
# Вернём лимит (TEACHER_AI_DAILY_LIMIT) перед запуском для реальных юзеров.
return True return True
usage = await get_teacher_ai_usage(conn, user_id)
return usage < TEACHER_AI_DAILY_LIMIT
async def start_learning_session(conn, user_id: int, level_code: str, topic_id: str, session_type: str) -> int: async def start_learning_session(conn, user_id: int, level_code: str, topic_id: str, session_type: str) -> int:
@@ -232,6 +324,11 @@ async def call_ai(prompt: str, system_prompt: str, max_tokens: int = 500) -> str
], ],
"max_tokens": max_tokens, "max_tokens": max_tokens,
"temperature": 0.7, "temperature": 0.7,
# 🔧 ФИКС (05.10.2026): disable_reasoning_for_fast_tasks —
# V4 Pro — reasoning-модель, тратит 80% токенов на «мысли»
# (reasoning_content) и 20-30 секунд на ответ.
# Для фразы дня и переводов reasoning не нужен → отключаем.
"reasoning_effort": "none",
}, },
) )
@@ -256,6 +353,8 @@ async def call_ai(prompt: str, system_prompt: str, max_tokens: int = 500) -> str
ai_response = ai_response.strip() ai_response = ai_response.strip()
ai_response = re.sub(r'\s*\([a-z_]+_[a-z_]+\)', '', ai_response) ai_response = re.sub(r'\s*\([a-z_]+_[a-z_]+\)', '', ai_response)
# 🔧 ФИКС (03.11.2026): убираем длинные тире (— и –) — заменяем на дефис.
ai_response = ai_response.replace('—', '-').replace('–', '-')
return ai_response return ai_response
except Exception as e: except Exception as e:
logger.error(f"AI error: {str(e)}") logger.error(f"AI error: {str(e)}")
@@ -282,7 +381,8 @@ async def get_wrong_answer_ai_explanation(telegram_id: int, lang: str, prompt_te
system_prompt = f"""Ты — Марек, учитель польского языка. Объясняй ошибки кратко и понятно. system_prompt = f"""Ты — Марек, учитель польского языка. Объясняй ошибки кратко и понятно.
Отвечай на языке: {lang}. Не используй markdown.""" Отвечай на языке: {lang}. Не используй markdown."""
ai_response = await call_ai(ai_prompt, system_prompt, max_tokens=200) # 🔧 ФИКС (05.10.2026): max_tokens_for_v4_pro — 200 → 600
ai_response = await call_ai(ai_prompt, system_prompt, max_tokens=600)
if ai_response: if ai_response:
async with pool.acquire() as conn: async with pool.acquire() as conn:
@@ -376,7 +476,8 @@ EN_GRAMMAR: [грамматический разбор на английском
user_prompt = f"Создай фразу дня на тему: {selected_topic}." user_prompt = f"Создай фразу дня на тему: {selected_topic}."
ai_response = await call_ai(user_prompt, system_prompt, max_tokens=1000) # 🔧 ФИКС (05.10.2026): max_tokens_for_v4_pro — 1000 → 3000
ai_response = await call_ai(user_prompt, system_prompt, max_tokens=3000)
# Fallback значения # Fallback значения
phrase_pl = "Lepiej późno niż wcale." phrase_pl = "Lepiej późno niż wcale."
@@ -705,6 +806,18 @@ async def teacher_answer(request: Request):
SELECT * FROM question_options WHERE question_id = $1 SELECT * FROM question_options WHERE question_id = $1
""", question_id) """, 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 "" correct_answer = question_row["correct_answer"] or ""
is_correct = normalize_answer(selected_answer) == normalize_answer(correct_answer) is_correct = normalize_answer(selected_answer) == normalize_answer(correct_answer)
@@ -718,6 +831,8 @@ async def teacher_answer(request: Request):
"question": dict(question_row), "question": dict(question_row),
"options": [dict(o) for o in options], "options": [dict(o) for o in options],
} }
# Только теперь безопасно записываем ответ в user_learning_answers
await save_answer_to_session( await save_answer_to_session(
conn, telegram_id, session_id, question_data, conn, telegram_id, session_id, question_data,
selected_answer, is_correct, time_taken_ms selected_answer, is_correct, time_taken_ms
@@ -734,10 +849,6 @@ async def teacher_answer(request: Request):
if not is_correct and wrong_because: if not is_correct and wrong_because:
db_explanation = await get_wrong_because_explanation(conn, wrong_because, lang) 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": if session["session_type"] == "teacher_test":
questions = await get_test_questions(conn, session["topic_id"]) questions = await get_test_questions(conn, session["topic_id"])
else: else:
@@ -868,7 +979,8 @@ async def teacher_explain(request: Request):
system_prompt = f"""Ты — учитель польского языка. Объясни материал простыми словами. system_prompt = f"""Ты — учитель польского языка. Объясни материал простыми словами.
Отвечай на языке: {lang}. Не используй markdown.""" Отвечай на языке: {lang}. Не используй markdown."""
ai_response = await call_ai(content, system_prompt) # 🔧 ФИКС (05.10.2026): max_tokens_for_v4_pro — добавляем 1500
ai_response = await call_ai(content, system_prompt, max_tokens=1500)
if ai_response: if ai_response:
async with pool.acquire() as conn: async with pool.acquire() as conn:
@@ -943,7 +1055,8 @@ async def teacher_examples(request: Request):
Верни только 5 примеров, без вступлений и пояснений.""" Верни только 5 примеров, без вступлений и пояснений."""
ai_response = await call_ai(topic, system_prompt, max_tokens=500) # 🔧 ФИКС (05.10.2026): max_tokens_for_v4_pro — 500 → 1500
ai_response = await call_ai(topic, system_prompt, max_tokens=1500)
if ai_response: if ai_response:
async with pool.acquire() as conn: async with pool.acquire() as conn:
@@ -976,10 +1089,13 @@ async def teacher_free_message(request: Request):
lang = await get_user_lang(conn, telegram_id) lang = await get_user_lang(conn, telegram_id)
if not await check_ai_limit(conn, telegram_id): if not await check_ai_limit(conn, telegram_id):
usage = await get_teacher_ai_usage(conn, telegram_id)
return { return {
"response": "", "response": "",
"limit_exceeded": True, "limit_exceeded": True,
"message": get_ai_limit_message(lang) "message": get_ai_limit_message(lang),
"usage": usage,
"limit": TEACHER_AI_DAILY_LIMIT,
} }
context_parts = [] context_parts = []
@@ -996,22 +1112,82 @@ async def teacher_free_message(request: Request):
context_text = "\n".join(context_parts) if context_parts else "" context_text = "\n".join(context_parts) if context_parts else ""
system_prompt = f"""Ты — Марек, учитель польского языка в приложении Filwords PL. # 🔧 (04.11.2026): ищем материалы в базе знаний Pleily.
Ты дружелюбный, поддерживающий и краткий. materials = await search_teacher_materials(conn, user_message, lang)
# 🔧 (04.11.2026): Марек — учитель в Pleily (не Filwords PL).
# Учитываем родной язык ученика: для каждого языка — свои нюансы объяснения.
lang_nuances = {
"pl": "Ученик — носитель польского языка. Объясняй углублённо: стилистика, нюансы, редкие формы, синонимы. Не переводи на другие языки.",
"ru": "Ученик — русскоговорящий. Объясняй через сходства и различия с русским: падежи, ложные друзья, похожие слова. Предупреждай о типичных ошибках русскоговорящих.",
"uk": "Ученик — украиноговорящий. Объясняй через сходства и различия с украинским: много общего, но есть ложные друзья. Предупреждай о типичных ошибках украиноговорящих.",
"en": "Ученик — англоговорящий. Объясняй через английский: грамматические параллели, ложные друзья, произношение. Предупреждай о типичных ошибках англоговорящих.",
}
nuance_text = lang_nuances.get(lang, lang_nuances["en"])
# 🔧 (04.11.2026): материалы из базы знаний Pleily.
if materials:
materials_parts = []
for m in materials:
m_title = m.get(f"title_{lang}") or m.get("title_pl") or ""
m_content = m.get(f"content_{lang}") or m.get("content_pl") or ""
materials_parts.append(f"[{m['category']}] {m_title}\n{m_content}")
materials_text = "\n\n".join(materials_parts)
materials_instruction = (
"Используй следующие материалы из базы знаний Pleily. "
"Отвечай СТРОГО на их основе, не выдумывай факты:\n"
+ materials_text
)
else:
materials_instruction = (
"В базе знаний Pleily нет материалов по этому вопросу. "
"Ты отвечаешь на основе своих знаний ИИ. "
"В начале ответа честно предупреди ученика, что эта информация создана ИИ, "
"а не на основе базы знаний Pleily, и ИИ может ошибаться (галлюцинировать), "
"поэтому на 100% доверять ей нельзя."
)
system_prompt = f"""Ты — Марек, дружелюбный учитель польского языка в приложении Pleily.
Ты помогаешь ученику выучить польский язык.
Отвечай на языке: {lang}. Отвечай на языке: {lang}.
Не используй markdown. Не используй markdown и длинные тире (—).
{nuance_text}
{context_text} {context_text}
Ученик может спросить что угодно: объяснить тему, перевести фразу, дать пример. {materials_instruction}
Ты специализируешься ТОЛЬКО на Польше: польский язык, польская история, польская культура, жизнь в Польше, польские документы и всё, что связано с Польшей.
Если вопрос НЕ касается Польши, польского языка, польской истории, польской культуры, жизни в Польше или польских документов — вежливо откажись и скажи, что ты специализируешься только на Польше и польском языке. Не отвечай на посторонние вопросы (программирование, кулинария других стран, общие знания и т.п.).
Ученик может спросить что угодно про Польшу: объяснить тему, перевести фразу, дать пример, рассказать об истории или жизни в Польше.
Отвечай кратко (1-3 предложения) и по делу.""" Отвечай кратко (1-3 предложения) и по делу."""
ai_response = await call_ai(user_message, system_prompt, max_tokens=300) # 🔧 ФИКС (05.10.2026): max_tokens_for_v4_pro — 300 → 900
ai_response = await call_ai(user_message, system_prompt, max_tokens=900)
if ai_response: if ai_response:
async with pool.acquire() as conn: async with pool.acquire() as conn:
await increment_teacher_ai_usage(conn, telegram_id) await increment_teacher_ai_usage(conn, telegram_id)
return {"response": ai_response} async with pool.acquire() as conn:
usage = await get_teacher_ai_usage(conn, telegram_id)
return {"response": ai_response, "usage": usage, "limit": TEACHER_AI_DAILY_LIMIT}
@router.get("/ai-usage")
async def teacher_ai_usage(request: Request):
"""
Возвращает количество использованных AI-запросов учителя за сегодня
и дневной лимит.
"""
telegram_id, _ = await require_auth(request)
pool = await get_pool()
async with pool.acquire() as conn:
usage = await get_teacher_ai_usage(conn, telegram_id)
return {"usage": usage, "limit": TEACHER_AI_DAILY_LIMIT}
@router.post("/diagnostic-test") @router.post("/diagnostic-test")
@@ -1102,7 +1278,8 @@ async def teacher_translate_to_polish(request: Request):
system_prompt = f"""Ты — переводчик польского языка. Переведи текст на польский. system_prompt = f"""Ты — переводчик польского языка. Переведи текст на польский.
Отвечай только переводом без пояснений. Не используй markdown.""" Отвечай только переводом без пояснений. Не используй markdown."""
ai_response = await call_ai(text, system_prompt, max_tokens=300) # 🔧 ФИКС (05.10.2026): max_tokens_for_v4_pro — 300 → 900
ai_response = await call_ai(text, system_prompt, max_tokens=900)
if ai_response: if ai_response:
async with pool.acquire() as conn: async with pool.acquire() as conn:
@@ -1226,3 +1403,36 @@ async def clear_teacher_history(request: Request):
""", telegram_id) """, telegram_id)
return {"status": "ok"} return {"status": "ok"}
@router.get("/materials")
async def get_teacher_materials(request: Request, category: str = "rule"):
"""
Возвращает список материалов из базы знаний Pleily по категории.
Используется разделом «Правила» (category='rule') для отображения
списка правил грамматики. Каждый материал отдаётся на языке пользователя.
"""
telegram_id, _ = await require_auth(request)
pool = await get_pool()
async with pool.acquire() as conn:
lang = await get_user_lang(conn, telegram_id)
rows = await conn.fetch("""
SELECT * FROM teacher_materials
WHERE category = $1 AND is_active = TRUE
ORDER BY id
""", category)
result = []
for row in rows:
result.append({
"id": row["id"],
"category": row["category"],
"title": row.get(f"title_{lang}") or row.get("title_pl") or "",
"content": row.get(f"content_{lang}") or row.get("content_pl") or "",
"example": row.get(f"example_{lang}") or row.get("example_pl") or "",
"level": row["level"],
})
return {"materials": result}
-1
View File
@@ -3,7 +3,6 @@ Typing Router — раздел "Печать".
Пользователь печатает польские предложения, система проверяет. Пользователь печатает польские предложения, система проверяет.
Без AI — просто сравнение с правильным ответом из БД. Без AI — просто сравнение с правильным ответом из БД.
""" """
import random
from fastapi import APIRouter, Request, HTTPException from fastapi import APIRouter, Request, HTTPException
from auth import require_auth from auth import require_auth
from database import get_pool from database import get_pool
+102
View File
@@ -76,6 +76,26 @@ async def set_language(request: Request):
} }
@router.post("/set-difficulty")
async def set_difficulty(request: Request):
"""Устанавливает уровень сложности (easy/medium/hard)."""
user_id, _ = await require_auth(request)
body = await request.json()
difficulty = body.get("difficulty", "medium")
if difficulty not in {"easy", "medium", "hard"}:
raise HTTPException(400, "Unsupported difficulty")
pool = await get_pool()
async with pool.acquire() as conn:
await conn.execute(
"UPDATE users SET difficulty = $1 WHERE telegram_id = $2",
difficulty, user_id,
)
return {"status": "ok", "difficulty": difficulty}
@router.post("/set-level") @router.post("/set-level")
async def set_level(request: Request): async def set_level(request: Request):
"""Устанавливает текущий уровень пользователя (A1, A2, B1, B2, C1, C2)""" """Устанавливает текущий уровень пользователя (A1, A2, B1, B2, C1, C2)"""
@@ -104,3 +124,85 @@ async def set_level(request: Request):
"status": "ok", "status": "ok",
"level": level, "level": level,
} }
# ============================================================
# 🆕 (08.10.2026): профиль — ник + аватар
# ============================================================
import re as _re
_FORBIDDEN_WORDS = {
"admin", "administrator", "root", "moderator", "mod",
"pleily", "filwords", "support", "help", "system",
"хуй", "пизда", "блядь", "сука", "ебать",
"kurwa", "chuj", "pizda", "jebac",
"fuck", "shit", "bitch", "ass",
}
_NICKNAME_RE = _re.compile(r'^[\w\s\.\-]+$', flags=_re.UNICODE)
def _clean_nickname(raw: str) -> str:
if not raw:
raise HTTPException(400, "Nickname is required")
nick = raw.strip()
if len(nick) < 2:
raise HTTPException(400, "Nickname must be at least 2 characters")
if len(nick) > 20:
raise HTTPException(400, "Nickname must be at most 20 characters")
lower = nick.lower()
for bad in _FORBIDDEN_WORDS:
if bad in lower:
raise HTTPException(400, "Nickname contains forbidden words")
if not _NICKNAME_RE.match(nick):
raise HTTPException(400, "Nickname contains invalid characters")
return nick
@router.post("/set-nickname")
async def set_nickname(request: Request):
"""Сохранить ник пользователя. Body: {"nickname": "Oleg"}"""
user_id, _ = await require_auth(request)
body = await request.json()
nickname = _clean_nickname(body.get("nickname", ""))
pool = await get_pool()
async with pool.acquire() as conn:
existing = await conn.fetchval(
"SELECT user_id FROM user_profile WHERE nickname = $1 AND user_id != $2",
nickname, user_id,
)
if existing:
raise HTTPException(409, "Nickname already taken")
await conn.execute("""
INSERT INTO user_profile (user_id, nickname, updated_at)
VALUES ($1, $2, NOW())
ON CONFLICT (user_id) DO UPDATE
SET nickname = $2, updated_at = NOW()
""", user_id, nickname)
return {"status": "ok", "nickname": nickname}
@router.post("/set-avatar")
async def set_avatar(request: Request):
"""Сохранить аватар. Body: {"avatar_id": 3}"""
user_id, _ = await require_auth(request)
body = await request.json()
avatar_id = body.get("avatar_id")
if not isinstance(avatar_id, int) or avatar_id < 0 or avatar_id > 7:
raise HTTPException(400, "avatar_id must be 0..7")
pool = await get_pool()
async with pool.acquire() as conn:
await conn.execute("""
INSERT INTO user_profile (user_id, avatar_id, updated_at)
VALUES ($1, $2, NOW())
ON CONFLICT (user_id) DO UPDATE
SET avatar_id = $2, updated_at = NOW()
""", user_id, avatar_id)
return {"status": "ok", "avatar_id": avatar_id}
+130 -70
View File
@@ -14,7 +14,7 @@ async def get_next_quiz(request: Request):
pool = await get_pool() pool = await get_pool()
async with pool.acquire() as conn: async with pool.acquire() as conn:
user = await conn.fetchrow( user = await conn.fetchrow(
"SELECT app_language, current_level FROM users WHERE telegram_id = $1", telegram_id "SELECT app_language, current_level, difficulty FROM users WHERE telegram_id = $1", telegram_id
) )
if not user: if not user:
raise HTTPException(401, "User not registered") raise HTTPException(401, "User not registered")
@@ -22,6 +22,12 @@ async def get_next_quiz(request: Request):
lang = user["app_language"] or "pl" lang = user["app_language"] or "pl"
current_level = user["current_level"] or "A1" current_level = user["current_level"] or "A1"
if lang == 'pl':
raise HTTPException(403, "ChooseWord не поддерживает польский язык. Используйте другой язык.")
difficulty = user.get("difficulty") or "medium"
wrong_count = {"easy": 2, "medium": 3, "hard": 4}.get(difficulty, 3)
progress = await conn.fetchrow( progress = await conn.fetchrow(
"SELECT words_guessed, recent_words FROM word_quiz_progress WHERE user_id = $1", "SELECT words_guessed, recent_words FROM word_quiz_progress WHERE user_id = $1",
telegram_id telegram_id
@@ -32,23 +38,20 @@ async def get_next_quiz(request: Request):
async def pick_word(exclude, respect_exclude=True): async def pick_word(exclude, respect_exclude=True):
if respect_exclude and exclude: if respect_exclude and exclude:
placeholders = ",".join([f"${i+2}" for i in range(len(exclude))]) placeholders = ",".join([f"${i+2}" for i in range(len(exclude))])
# 🔧 ФИКС (30.09.2026): csv_words_source —
# источник слов переехал с level_words (старая схема level_id IS NULL)
# на csv_words (level_code). Один источник — CSV-база.
return await conn.fetchrow(f""" return await conn.fetchrow(f"""
SELECT word_pl, translation_ru, translation_uk, translation_en SELECT word_pl, translation_ru, translation_uk, translation_en
FROM ( FROM csv_words
SELECT DISTINCT ON (word_pl) word_pl, translation_ru, translation_uk, translation_en WHERE level_code = $1 AND word_pl NOT IN ({placeholders})
FROM level_words
WHERE level = $1 AND level_id IS NULL AND word_pl NOT IN ({placeholders})
) AS unique_words
ORDER BY RANDOM() ORDER BY RANDOM()
LIMIT 1 LIMIT 1
""", current_level, *exclude) """, current_level, *exclude)
return await conn.fetchrow(""" return await conn.fetchrow("""
SELECT word_pl, translation_ru, translation_uk, translation_en SELECT word_pl, translation_ru, translation_uk, translation_en
FROM ( FROM csv_words
SELECT DISTINCT ON (word_pl) word_pl, translation_ru, translation_uk, translation_en WHERE level_code = $1
FROM level_words
WHERE level = $1 AND level_id IS NULL
) AS unique_words
ORDER BY RANDOM() ORDER BY RANDOM()
LIMIT 1 LIMIT 1
""", current_level) """, current_level)
@@ -67,25 +70,21 @@ async def get_next_quiz(request: Request):
# Ищем неправильные варианты # Ищем неправильные варианты
exclude_for_wrong = recent_words + [correct_polish] exclude_for_wrong = recent_words + [correct_polish]
placeholders = ",".join([f"${i+3}" for i in range(len(exclude_for_wrong))]) placeholders = ",".join([f"${i+3}" for i in range(len(exclude_for_wrong))])
# 🔧 ФИКС (30.09.2026): csv_words_source — источник переведён на csv_words.
wrong_words = await conn.fetch(f""" wrong_words = await conn.fetch(f"""
SELECT word_pl SELECT word_pl
FROM ( FROM csv_words
SELECT DISTINCT ON (word_pl) word_pl WHERE level_code = $1 AND word_pl != $2 AND word_pl NOT IN ({placeholders})
FROM level_words
WHERE level = $1 AND level_id IS NULL AND word_pl != $2 AND word_pl NOT IN ({placeholders})
) AS unique_wrong
ORDER BY RANDOM() ORDER BY RANDOM()
LIMIT 5 LIMIT 5
""", current_level, correct_polish, *exclude_for_wrong) """, current_level, correct_polish, *exclude_for_wrong)
if len(wrong_words) < 2: if len(wrong_words) < wrong_count:
# 🔧 ФИКС (30.09.2026): csv_words_source — fallback тоже на csv_words.
wrong_words = await conn.fetch(""" wrong_words = await conn.fetch("""
SELECT word_pl SELECT word_pl
FROM ( FROM csv_words
SELECT DISTINCT ON (word_pl) word_pl WHERE level_code = $1 AND word_pl != $2
FROM level_words
WHERE level = $1 AND level_id IS NULL AND word_pl != $2
) AS unique_wrong
ORDER BY RANDOM() ORDER BY RANDOM()
LIMIT 5 LIMIT 5
""", current_level, correct_polish) """, current_level, correct_polish)
@@ -97,7 +96,7 @@ async def get_next_quiz(request: Request):
if wl not in seen: if wl not in seen:
wrong_options.append(w["word_pl"]) wrong_options.append(w["word_pl"])
seen.add(wl) seen.add(wl)
if len(wrong_options) >= 2: if len(wrong_options) >= wrong_count:
break break
recent_words = recent_words + [correct_polish] + wrong_options recent_words = recent_words + [correct_polish] + wrong_options
@@ -114,38 +113,39 @@ async def get_next_quiz(request: Request):
options = wrong_options + [correct_polish] options = wrong_options + [correct_polish]
random.shuffle(options) random.shuffle(options)
if total_guessed <= 10: time_limit = 10 if difficulty == "hard" else None
difficulty = "easy"
elif total_guessed <= 30:
difficulty = "medium"
elif total_guessed <= 60:
difficulty = "hard"
else:
difficulty = "expert"
return { return {
"correct_polish": correct_polish, "correct_polish": correct_polish,
"translation": translation, "translation": translation,
"options": options, "options": options,
"difficulty": difficulty, "difficulty": difficulty,
"time_limit": time_limit,
} }
@router.post("/check") @router.post("/check")
async def check_quiz_answer(request: Request): async def check_quiz_answer(request: Request):
"""Проверяет ответ, начисляет очки и проверяет достижения""" """Проверяет ответ, начисляет XP и проверяет достижения.
🔧 НОВОЕ (08.10.2026): XP-система + серии.
Штрафы:
-1 за каждый неверный выбор (макс 3)
-1 если time_ms > 30 сек
Минимум 1 звезда.
Серия: correct_streak (best_streak хранится в choose_progress).
"""
telegram_id, _ = await require_auth(request) telegram_id, _ = await require_auth(request)
body = await request.json() body = await request.json()
correct_polish = body.get("correct_polish", "") correct_polish = body.get("correct_polish", "")
user_answer = body.get("answer", "") user_answer = body.get("answer", "")
completion_time = body.get("completion_time") completion_time = body.get("completion_time")
# 🔧 ФИКС (24.09.2026): client_controlled_mistakes_wordquiz — # 🆕 wrong_count приходит с клиента для UI, но мы считаем на сервере
# mistakes больше НЕ берём от клиента. Считаем на сервере. # 🔧 ФИКС: current_mistakes — серверный счётчик
if not correct_polish or not user_answer: if not correct_polish or not user_answer:
raise HTTPException(400, "correct_polish and answer required") raise HTTPException(400, "correct_polish and answer required")
# Защита от читерства: минимальное время 1 секунда
if completion_time is not None and completion_time < 1: if completion_time is not None and completion_time < 1:
return { return {
"correct": False, "correct": False,
@@ -157,22 +157,35 @@ async def check_quiz_answer(request: Request):
pool = await get_pool() pool = await get_pool()
async with pool.acquire() as conn: async with pool.acquire() as conn:
# Проверка языка
lang = await conn.fetchval(
"SELECT app_language FROM users WHERE telegram_id = $1", telegram_id
) or "pl"
if lang == 'pl':
raise HTTPException(403, "ChooseWord не поддерживает польский язык.")
difficulty = await conn.fetchval(
"SELECT difficulty FROM users WHERE telegram_id = $1", telegram_id
) or "medium"
# Читаем серверный streak и mistakes
current_streak = await conn.fetchval( current_streak = await conn.fetchval(
"SELECT correct_streak FROM word_quiz_progress WHERE user_id = $1", "SELECT correct_streak FROM word_quiz_progress WHERE user_id = $1",
telegram_id telegram_id
) or 0 ) or 0
# 🔧 ФИКС (24.09.2026): client_controlled_mistakes_wordquiz —
# читаем серверный current_mistakes.
mistakes = await conn.fetchval( mistakes = await conn.fetchval(
"SELECT current_mistakes FROM word_quiz_progress WHERE user_id = $1", "SELECT current_mistakes FROM word_quiz_progress WHERE user_id = $1",
telegram_id telegram_id
) or 0 ) or 0
no_mistakes_streak = await conn.fetchval(
"SELECT no_mistakes_streak FROM word_quiz_progress WHERE user_id = $1",
telegram_id
) or 0
if is_correct: if is_correct:
current_streak += 1 current_streak += 1
else: else:
current_streak = 0 current_streak = 0
# 🔧 Инкрементим mistakes на сервере
await conn.execute(""" await conn.execute("""
INSERT INTO word_quiz_progress (user_id, current_mistakes) INSERT INTO word_quiz_progress (user_id, current_mistakes)
VALUES ($1, 1) VALUES ($1, 1)
@@ -181,58 +194,82 @@ async def check_quiz_answer(request: Request):
""", telegram_id) """, telegram_id)
mistakes += 1 mistakes += 1
xp_result = None
score = 0
if is_correct: if is_correct:
score = max(10, 50 - (mistakes * 20)) # 🆕 Фиксированные очки по сложности (ChooseWord)
# 🔧 Сбрасываем mistakes при правильном ответе if difficulty == "easy":
points = max(20, min(60, 60 - 20 * mistakes))
elif difficulty == "medium":
points = max(20, min(80, 80 - 20 * mistakes))
else: # hard
points = max(20, min(110, 110 - 20 * mistakes))
if completion_time is not None and completion_time > 10:
points = 20
# Начисляем XP
from services.xp import award_xp
xp_result = await award_xp(conn, telegram_id, "choose", points)
score = xp_result["points"]
# no_mistakes_streak: +1 если раунд чистый, иначе сброс
if mistakes == 0:
no_mistakes_streak += 1
else:
no_mistakes_streak = 0
# Сбрасываем mistakes + обновляем серию
await conn.execute(""" await conn.execute("""
UPDATE word_quiz_progress SET current_mistakes = 0 WHERE user_id = $1 UPDATE word_quiz_progress SET current_mistakes = 0 WHERE user_id = $1
""", telegram_id) """, telegram_id)
await conn.execute(""" await conn.execute("""
INSERT INTO word_quiz_progress (user_id, words_guessed, total_score, correct_streak) INSERT INTO word_quiz_progress (user_id, words_guessed, total_score, correct_streak, no_mistakes_streak)
VALUES ($1, 1, $2, $3) VALUES ($1, 1, $2, $3, $4)
ON CONFLICT (user_id) DO UPDATE ON CONFLICT (user_id) DO UPDATE
SET words_guessed = word_quiz_progress.words_guessed + 1, SET words_guessed = word_quiz_progress.words_guessed + 1,
total_score = word_quiz_progress.total_score + $2, total_score = word_quiz_progress.total_score + $2,
correct_streak = $3 correct_streak = $3,
""", telegram_id, score, current_streak) no_mistakes_streak = $4
""", telegram_id, score, current_streak, no_mistakes_streak)
# 🔧 ФИКС (23.09.2026): achievements_nested_pool_acquire_wordquiz — # 🆕 Обновляем best_streak в choose_progress
# вызовы достижений вынесены за async with pool.acquire() (паттерн game.py). await conn.execute("""
INSERT INTO choose_progress (user_id, current_streak, best_streak)
VALUES ($1, $2, $2)
ON CONFLICT (user_id) DO UPDATE
SET current_streak = $2,
best_streak = GREATEST(choose_progress.best_streak, $2),
updated_at = NOW()
""", telegram_id, current_streak)
# Собираем данные для достижений
total_guessed = await conn.fetchval( total_guessed = await conn.fetchval(
"SELECT words_guessed FROM word_quiz_progress WHERE user_id = $1", "SELECT words_guessed FROM word_quiz_progress WHERE user_id = $1",
telegram_id telegram_id
) or 0 ) or 0
wordsearch_score = await conn.fetchval(
"SELECT COALESCE(SUM(score), 0) FROM user_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
telegram_id
) or 0
sentence_score = await conn.fetchval(
"SELECT COALESCE(SUM(score), 0) FROM sentence_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
telegram_id
) or 0
wordquiz_score = await conn.fetchval(
"SELECT COALESCE(total_score, 0) FROM word_quiz_progress WHERE user_id = $1",
telegram_id
) or 0
bubblewords_score = await conn.fetchval(
"SELECT COALESCE(total_score, 0) FROM bubble_words_progress WHERE user_id = $1",
telegram_id
) or 0
grand_total = wordsearch_score + sentence_score + wordquiz_score + bubblewords_score
achievements_to_check = [ achievements_to_check = [
("quiz_guessed", total_guessed), ("quiz_guessed", total_guessed),
("total_score", grand_total), ("total_score", xp_result["total_xp"]),
] ]
if current_streak >= 10: if current_streak >= 5:
achievements_to_check.append(("quiz_perfect_streak", current_streak)) achievements_to_check.append(("quiz_correct_streak", current_streak))
if no_mistakes_streak > 0:
achievements_to_check.append(("quiz_no_mistakes_streak", no_mistakes_streak))
if mistakes == 0: if mistakes == 0:
achievements_to_check.append(("quiz_no_mistakes", 1)) achievements_to_check.append(("quiz_no_mistakes", 1))
if completion_time is not None and completion_time > 0 and int(completion_time) <= 3: if completion_time is not None and 0 < completion_time <= 5:
achievements_to_check.append(("quiz_speed", 3)) achievements_to_check.append(("quiz_speed_5", 5))
if completion_time is not None and 0 < completion_time <= 3:
achievements_to_check.append(("quiz_speed_3", 3))
if completion_time is not None and 0 < completion_time <= 2:
achievements_to_check.append(("quiz_speed_2", 2))
if completion_time is not None and 0 < completion_time <= 1:
achievements_to_check.append(("quiz_speed_1", 1))
else: else:
# При 3 ошибках — начисляем утешительные 10 очков # При 3 ошибках — утешительный XP (10)
if mistakes >= 3: if mistakes >= 3:
await conn.execute(""" await conn.execute("""
INSERT INTO word_quiz_progress (user_id, words_guessed, total_score, correct_streak, current_mistakes) INSERT INTO word_quiz_progress (user_id, words_guessed, total_score, correct_streak, current_mistakes)
@@ -249,7 +286,7 @@ async def check_quiz_answer(request: Request):
SET correct_streak = $2 SET correct_streak = $2
""", telegram_id, current_streak) """, telegram_id, current_streak)
# 🔧 ФИКС (23.09.2026): вызовы достижений ВНЕ блока async with pool.acquire() # Достижения — вне транзакции
if is_correct: if is_correct:
from routers.achievements import check_and_award_achievements from routers.achievements import check_and_award_achievements
new_achievements = [] new_achievements = []
@@ -262,6 +299,19 @@ async def check_quiz_answer(request: Request):
"score": score, "score": score,
"correct_streak": current_streak, "correct_streak": current_streak,
"new_achievements": new_achievements, "new_achievements": new_achievements,
# 🆕 XP-поля
"base_points": xp_result["base_points"],
"multiplier": xp_result["multiplier"],
"points": xp_result["points"],
"featured": xp_result["featured"],
"level_up": xp_result["level_up"],
"total_xp": xp_result["total_xp"],
"level": xp_result["level"],
"rank_key": xp_result["rank_key"],
"xp_in_level": xp_result["xp_in_level"],
"xp_needed": xp_result["xp_needed"],
# 🆕 Серия для UI
"streak_best": (await _get_best_streak(telegram_id)),
} }
return { return {
@@ -271,6 +321,16 @@ async def check_quiz_answer(request: Request):
} }
async def _get_best_streak(telegram_id: int) -> int:
"""Возвращает best_streak пользователя из choose_progress."""
pool = await get_pool()
async with pool.acquire() as conn:
return await conn.fetchval(
"SELECT best_streak FROM choose_progress WHERE user_id = $1",
telegram_id
) or 0
@router.get("/progress") @router.get("/progress")
async def get_quiz_progress(request: Request): async def get_quiz_progress(request: Request):
"""Статистика пользователя в квизе""" """Статистика пользователя в квизе"""
+305 -59
View File
@@ -3,13 +3,74 @@
AI Code Review for Filwords PL Backend (JSON-контракт + пак-подход) AI Code Review for Filwords PL Backend (JSON-контракт + пак-подход)
Backend слишком большой (~440K символов) для одного запроса — модель уходит Backend слишком большой (~440K символов) для одного запроса — модель уходит
в reasoning и не успевает выдать JSON. Решение: разбиваем файлы на 3 пака в reasoning и не успевает выдать JSON. Решение: разбиваем файлы на паки
по папкам, делаем отдельный запрос на каждый пак, объединяем находки. по папкам, делаем отдельный запрос на каждый пак, объединяем находки.
(20.09.2026) Первая версия — конвейер без tool-calling, предсказуемо по токенам. (20.09.2026) Первая версия — конвейер без tool-calling, предсказуемо по токенам.
(20.09.2026, вечер) Фикс: max_tokens=16000, fallback на reasoning_content. (20.09.2026, вечер) Фикс: max_tokens=16000, fallback на reasoning_content.
(21.09.2026, вечер) JSON-контракт + snippet-проверка + фильтр confidence. (21.09.2026, вечер) JSON-контракт + snippet-проверка + фильтр confidence.
(22.09.2026, вечер) Пак-подход: 3 пака (routers, core, services+scripts). (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 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_INSTANCE = os.environ.get("GITEA_INSTANCE", "https://git.filwordspl.com")
GITEA_REPO = os.environ.get("GITEA_REPO", "Drobysh/filwordspl-backend") GITEA_REPO = os.environ.get("GITEA_REPO", "Drobysh/filwordspl-backend")
MODEL = "deepseek-ai/DeepSeek-V4.1-Flash" # 🔧 ФИКС (05.10.2026): single_model_v4_pro —
MAX_OUTPUT_TOKENS = 12000 # Отказались от 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 = { IGNORE_DIRS = {
@@ -41,6 +114,7 @@ IGNORE_DIRS = {
IGNORE_FILES = { IGNORE_FILES = {
"ai_review.py", "conftest.py", "code_summary.py", "ai_review.py", "conftest.py", "code_summary.py",
"add_levels.py", "generate_levels_v2.py", "add_levels.py", "generate_levels_v2.py",
"__init__.py",
} }
# Расширения, которые читаем # Расширения, которые читаем
@@ -50,18 +124,71 @@ INCLUDE_EXTENSIONS = {".py"}
MAX_FILE_SIZE = 100_000 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"} 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). # Паки для backend. Пути проверены по факту (`ls routers/`).
# Разбиваем на 3 пака. Каждый пак — отдельный запрос к модели.
PACKS = [ PACKS = [
{ {
"name": "routers", "name": "routers_games",
"paths": ["routers/"], "paths": [
"description": "FastAPI-роутеры: эндпоинты, бизнес-логика, работа с БД", "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", "name": "core",
@@ -70,8 +197,8 @@ PACKS = [
}, },
{ {
"name": "services", "name": "services",
"paths": ["services/", "scripts/"], "paths": ["scripts/"],
"description": "Сервисы и скрипты автоматизации", "description": "Скрипты автоматизации",
}, },
] ]
@@ -170,19 +297,21 @@ SYSTEM_PROMPT = """Ты — опытный техлид и ревьюер Python
} }
] ]
ПРАВИЛА: ПРАВИЛА (соблюдай строго):
1. severity — только одно из: "user_impact", "data_risk", "maintainability". 1. severity — только одно из: "user_impact", "data_risk", "maintainability".
- user_impact: ученик видит баг, теряет прогресс, очки, доступ - user_impact: ученик видит баг, теряет прогресс, очки, доступ
- data_risk: порча БД, утечка, неверный auth/rate-limit - data_risk: порча БД, утечка, неверный auth/rate-limit
- maintainability: запах, дубль, устаревший API - maintainability: запах, дубль, устаревший API
2. snippet — ТОЧНАЯ цитата 1-3 строк из файла. Не перефразируй. Если не уверен — не включай находку. 2. snippet — ТОЧНАЯ цитата 1-3 строк из файла. Не перефразируй. Если не уверен — не включай находку.
3. confidence — число от 0 до 1. Если меньше 0.7 — не включай. 3. confidence — число от 0 до 1. Если меньше 0.75 — НЕ включай.
4. Максимум 10 находок за этот пак. 4. МАКСИМУМ 10 находок за этот пак. Если находишь больше — выбери ТОП-10 по severity (user_impact > data_risk > maintainability).
5. НЕ переписывай код. Только описывай, что не так и что сделать. 5. НЕ пиши находки типа "Ок", "Не баг", "Работает корректно", "Не влияет на UX", "Не критично". Только РЕАЛЬНЫЕ проблемы.
6. Без воды. Без общих слов. 6. НЕ комментируй каждую функцию. Только баги, security, UX.
7. Если проблем нет — верни пустой массив: [] 7. НЕ переписывай код. Только описывай, что не так и что сделать.
8. Без воды. Без общих слов.
9. Если проблем нет — верни пустой массив: [].
Отвечай ТОЛЬКО JSON, без markdown-обёрток. Отвечай ТОЛЬКО JSON, без markdown-обёрток. Не думай вслух — сразу выдавай JSON-массив.
""" """
@@ -192,15 +321,17 @@ USER_PROMPT_TEMPLATE = """Проанализируй часть кода про
Пак: **{pack_name}** — {pack_description} Пак: **{pack_name}** — {pack_description}
Ищи: Ищи ТОЛЬКО реальные проблемы:
1. Баги и логические ошибки 1. Баги и логические ошибки (не "Ок", а "тут падает")
2. Проблемы безопасности (утечки, инъекции, неправильная валидация) 2. Проблемы безопасности (утечки, инъекции, неправильная валидация)
3. N+1 запросы к БД 3. N+1 запросы к БД
4. Отсутствие обработки ошибок 4. Отсутствие обработки ошибок (где РЕАЛЬНО упадёт)
5. Дублирование кода 5. Дублирование кода
6. Мёртвый код 6. Мёртвый код
7. Слабые места архитектуры 7. Слабые места архитектуры
НЕ пиши "Ок", "Не баг", "Работает корректно". Если проблем нет — верни [].
Верни JSON-массив находок по формату выше. Верни JSON-массив находок по формату выше.
Вот код: Вот код:
@@ -211,9 +342,14 @@ USER_PROMPT_TEMPLATE = """Проанализируй часть кода про
# ============ Запрос к Together AI ============ # ============ Запрос к Together AI ============
def call_together(code: str, pack: dict) -> str: def call_together_model(code: str, pack: dict, model_name: str) -> str:
"""Отправляет код пака в DeepSeek V4.1 Flash.""" """Отправляет код пака в указанную модель.
print(f" 🤖 Отправляю пак '{pack['name']}' в DeepSeek V4.1 Flash...")
🔧 ФИКС (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( user_prompt = USER_PROMPT_TEMPLATE.format(
pack_name=pack["name"], pack_name=pack["name"],
@@ -221,26 +357,32 @@ def call_together(code: str, pack: dict) -> str:
code=code, 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( response = httpx.post(
"https://api.together.xyz/v1/chat/completions", "https://api.together.xyz/v1/chat/completions",
headers={ headers={
"Authorization": f"Bearer {TOGETHER_API_KEY}", "Authorization": f"Bearer {TOGETHER_API_KEY}",
"Content-Type": "application/json", "Content-Type": "application/json",
}, },
json={ json=payload,
"model": MODEL,
"messages": [
{"role": "system", "content": SYSTEM_PROMPT},
{"role": "user", "content": user_prompt},
],
"max_tokens": MAX_OUTPUT_TOKENS,
"temperature": 0.2,
},
timeout=300.0, timeout=300.0,
) )
if response.status_code != 200: 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) print(f" Ответ: {response.text[:500]}", file=sys.stderr)
return "" return ""
@@ -250,27 +392,52 @@ def call_together(code: str, pack: dict) -> str:
message = data["choices"][0]["message"] message = data["choices"][0]["message"]
result = message.get("content") result = message.get("content")
if not result: if not result:
result = message.get("reasoning_content") raise KeyError("пусто (content отсутствует)")
if not result:
raise KeyError("пусто")
except (KeyError, IndexError, TypeError) as e: 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 "" return ""
usage = data.get("usage", {}) usage = data.get("usage", {})
finish = data["choices"][0].get("finish_reason", "unknown") finish = data["choices"][0].get("finish_reason", "unknown")
reasoning_len = len(data["choices"][0]["message"].get("reasoning_content") or "")
print( print(
f" ✅ Пак '{pack['name']}': вход={usage.get('prompt_tokens', 0)}, " f" ✅ [{model_name.split('/')[-1]}] Пак '{pack['name']}': "
f"выход={usage.get('completion_tokens', 0)}, finish={finish}" 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 return result
def call_together(code: str, pack: dict) -> str:
"""Backward-compat: одна модель (primary)."""
return call_together_model(code, pack, MODEL_PRIMARY)
# ============ Парсинг и фильтрация JSON ============ # ============ Парсинг и фильтрация JSON ============
def extract_json(text: str) -> list[dict]: def extract_json(text: str) -> list[dict]:
"""Извлекает JSON-массив из ответа модели.""" """Извлекает находки из ответа модели.
Парсим объекты по одному (json.JSONDecoder.raw_decode) и
останавливаемся на первом, который не удалось распарсить — то есть
спасаем всё, что модель успела сгенерить до обрезки.
"""
if not text: if not text:
return [] return []
text = text.strip() text = text.strip()
@@ -279,34 +446,107 @@ def extract_json(text: str) -> list[dict]:
text = re.sub(r"\s*```$", "", text) text = re.sub(r"\s*```$", "", text)
start = text.find("[") start = text.find("[")
end = text.rfind("]") if start == -1:
if start == -1 or end == -1 or end < start:
print(f" ⚠️ Не найден JSON-массив. Первые 300 символов:\n{text[:300]}", file=sys.stderr) print(f" ⚠️ Не найден JSON-массив. Первые 300 символов:\n{text[:300]}", file=sys.stderr)
return [] 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: try:
parsed = json.loads(json_str) obj, end = decoder.raw_decode(text, idx)
if not isinstance(parsed, list): except json.JSONDecodeError:
print(f" ⚠️ JSON не массив, а {type(parsed).__name__}", file=sys.stderr) break
return [] if isinstance(obj, dict):
return parsed results.append(obj)
except json.JSONDecodeError as e: idx = end
print(f" ⚠️ Ошибка парсинга JSON: {e}", file=sys.stderr)
return [] 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( def validate_and_filter(
findings: list[dict], findings: list[dict],
files_map: dict[str, str], files_map: dict[str, str],
) -> tuple[list[dict], dict[str, int]]: ) -> tuple[list[dict], dict[str, int]]:
"""Фильтрует находки: файл существует, snippet совпал, confidence ≥ 0.7, severity валидна.""" """Фильтрует находки: файл существует, snippet совпал, confidence ≥ 0.75, severity валидна.
Overshoot guard — если находок > 15 на пак, берём только топ-10 по confidence.
"""
stats = { stats = {
"total": len(findings), "total": len(findings),
"overshoot": 0,
"no_file": 0, "snippet_mismatch": 0, "bad_severity": 0, "no_file": 0, "snippet_mismatch": 0, "bad_severity": 0,
"low_confidence": 0, "no_effect_or_repro": 0, "passed": 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] = [] passed: list[dict] = []
for f in findings: for f in findings:
@@ -370,7 +610,7 @@ def format_issue_body(
lines.append("# 🤖 AI Code Review (Backend)") lines.append("# 🤖 AI Code Review (Backend)")
lines.append("") lines.append("")
lines.append(f"**Дата:** {date_str}") lines.append(f"**Дата:** {date_str}")
lines.append(f"**Модель:** `{MODEL}`") lines.append(f"**Модель:** `{MODEL_PRIMARY}`")
lines.append(f"**Репозиторий:** `{GITEA_REPO}`") lines.append(f"**Репозиторий:** `{GITEA_REPO}`")
lines.append("") lines.append("")
lines.append("## 📊 По пакам") lines.append("## 📊 По пакам")
@@ -398,7 +638,9 @@ def format_issue_body(
lines.append("") lines.append("")
for f in items: for f in items:
counter += 1 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("")
lines.append(f"- **Файл:** `{f.get('file')}:{f.get('line', '?')}`") lines.append(f"- **Файл:** `{f.get('file')}:{f.get('line', '?')}`")
lines.append(f"- **Snippet:** `{f.get('snippet', '').strip()[:120]}`") lines.append(f"- **Snippet:** `{f.get('snippet', '').strip()[:120]}`")
@@ -411,6 +653,7 @@ def format_issue_body(
lines.append("---") lines.append("---")
lines.append("") lines.append("")
lines.append(f"**Итого:** всего находок={total_stats['total']}, " lines.append(f"**Итого:** всего находок={total_stats['total']}, "
f"overshoot={total_stats.get('overshoot', 0)}, "
f"snippet не совпал={total_stats['snippet_mismatch']}, " f"snippet не совпал={total_stats['snippet_mismatch']}, "
f"низкий confidence={total_stats['low_confidence']}, " f"низкий confidence={total_stats['low_confidence']}, "
f"прошло={total_stats['passed']}") f"прошло={total_stats['passed']}")
@@ -457,7 +700,7 @@ def main() -> None:
all_passed: list[dict] = [] all_passed: list[dict] = []
pack_stats: list[dict] = [] pack_stats: list[dict] = []
total_stats = { 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, "bad_severity": 0, "low_confidence": 0,
"no_effect_or_repro": 0, "passed": 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}) pack_stats.append({"name": pack["name"], "files": 0, "symbols": 0, "findings": 0})
continue continue
raw = call_together(code, pack) primary_raw = call_together_model(code, pack, MODEL_PRIMARY)
findings = extract_json(raw) # 🔧 ФИКС (05.10.2026): single_model —
# только V4 Pro, без merge.
findings = extract_json(primary_raw)
filtered, stats = validate_and_filter(findings, files_map) filtered, stats = validate_and_filter(findings, files_map)
all_passed.extend(filtered) 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())
+133
View File
@@ -0,0 +1,133 @@
"""
Генерирует фразу дня и сохраняет в БД (таблица daily_phrases).
Запускается по cron в 5:00 утра, чтобы фраза была готова заранее —
до того, как первый пользователь откроет её в приложении.
Эндпоинт GET /teacher/phrase-of-day потом просто отдаёт готовую фразу из кэша.
Запуск вручную (из папки backend):
python scripts/generate_daily_phrase.py
Cron (на сервере, пример):
0 5 * * * cd /root/filwordspl/backend && /usr/bin/python3 scripts/generate_daily_phrase.py >> /var/log/daily_phrase.log 2>&1
"""
import asyncio
import json
import os
import random
import sys
from datetime import datetime, timezone
# Добавляем корень backend в sys.path, чтобы работали импорты
# config / database / routers.teacher (как в FastAPI-приложении).
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
from database import get_pool
from routers.teacher import call_ai
TOPICS = [
"приветствие и знакомство",
"семья и друзья",
"еда и напитки",
"покупки и магазины",
"транспорт и путешествия",
"работа и профессии",
"погода и времена года",
"дом и квартира",
"хобби и свободное время",
"здоровье и самочувствие",
"город и местность",
"ежедневная рутина",
]
async def main():
pool = await get_pool()
async with pool.acquire() as conn:
today = datetime.now(timezone.utc).date()
existing = await conn.fetchrow(
"SELECT * FROM daily_phrases WHERE phrase_date = $1", today
)
if existing:
print(f"Фраза на {today} уже есть, пропускаю: {existing['phrase_pl']}")
return
selected_topic = random.choice(TOPICS)
system_prompt = f"""Ты — учитель польского языка. Создай фразу дня для изучения польского.
Тема фразы: {selected_topic}.
Фраза должна быть уровня A2-B1, полезной в повседневной жизни.
Верни ответ строго в таком формате (без markdown, просто текст):
PHRASE: [фраза на польском]
RU: [перевод на русский]
UK: [перевод на украинский]
EN: [перевод на английский]
PL_GRAMMAR: [грамматический разбор на польском, 1-2 предложения]
RU_GRAMMAR: [грамматический разбор на русском, 1-2 предложения]
UK_GRAMMAR: [грамматический разбор на украинском, 1-2 предложения]
EN_GRAMMAR: [грамматический разбор на английском, 1-2 предложения]"""
user_prompt = f"Создай фразу дня на тему: {selected_topic}."
ai_response = await call_ai(user_prompt, system_prompt, max_tokens=3000)
# Fallback значения (если AI не ответил)
phrase_pl = "Lepiej późno niż wcale."
translations = {
"ru": "Лучше поздно, чем никогда.",
"uk": "Краще пізно, ніж ніколи.",
"en": "Better late than never.",
}
grammar_breakdowns = {
"pl": "Lepiej - przyslowek w stopniu wyzszym. Pozno - przyslowek.",
"ru": "Lepiej - наречие в сравнительной степени. Pozno - наречие.",
"uk": "Lepiej - прислівник у вищому ступені. Pozno - прислівник.",
"en": "Lepiej - adverb in comparative degree. Pozno - adverb.",
}
if ai_response:
lines = ai_response.strip().split("\n")
for line in lines:
line = line.strip()
if line.startswith("PHRASE:"):
phrase_pl = line.replace("PHRASE:", "").strip()
elif line.startswith("RU:"):
translations["ru"] = line.replace("RU:", "").strip()
elif line.startswith("UK:"):
translations["uk"] = line.replace("UK:", "").strip()
elif line.startswith("EN:"):
translations["en"] = line.replace("EN:", "").strip()
elif line.startswith("PL_GRAMMAR:"):
grammar_breakdowns["pl"] = line.replace("PL_GRAMMAR:", "").strip()
elif line.startswith("RU_GRAMMAR:"):
grammar_breakdowns["ru"] = line.replace("RU_GRAMMAR:", "").strip()
elif line.startswith("UK_GRAMMAR:"):
grammar_breakdowns["uk"] = line.replace("UK_GRAMMAR:", "").strip()
elif line.startswith("EN_GRAMMAR:"):
grammar_breakdowns["en"] = line.replace("EN_GRAMMAR:", "").strip()
await conn.execute(
"""
INSERT INTO daily_phrases (phrase_date, phrase_pl, translations, grammar_breakdowns)
VALUES ($1, $2, $3::jsonb, $4::jsonb)
ON CONFLICT (phrase_date) DO UPDATE SET
phrase_pl = EXCLUDED.phrase_pl,
translations = EXCLUDED.translations,
grammar_breakdowns = EXCLUDED.grammar_breakdowns
""",
today,
phrase_pl,
json.dumps(translations, ensure_ascii=False),
json.dumps(grammar_breakdowns, ensure_ascii=False),
)
print(f"Фраза дня сгенерирована: {phrase_pl} ({today})")
await pool.close()
if __name__ == "__main__":
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())
+164
View File
@@ -0,0 +1,164 @@
#!/usr/bin/env python3
"""
Сброс прогресса и достижений пользователя (для теста «как новый юзер»).
Что делает:
- удаляет весь игровой прогресс (филворд, пузыри, угадай слово,
предложения, печать, обучение, XP-лог, серии, волны, статистику слов);
- удаляет выданные достижения (user_achievements);
- обнуляет XP в user_profile (total_xp, weekly_xp);
- сбрасывает users.last_completed_level, last_completed_by_level, current_level.
Что НЕ трогает:
- саму учётку (users: telegram_id, device_id, apple_id, source);
- настройки (difficulty, app_language);
- авторизацию (auth_identities);
- поддержку (support_tickets / support_messages).
Запуск (из папки backend/):
python scripts/reset_user_progress.py --telegram-id -1
python scripts/reset_user_progress.py --device-id 11111111-2222-3333-4444-555555555555
python scripts/reset_user_progress.py --all-pleily
python scripts/reset_user_progress.py --telegram-id -1 --yes # без подтверждения
Без --yes скрипт спросит подтверждение.
"""
import argparse
import asyncio
import logging
import sys
from pathlib import Path
sys.path.insert(0, str(Path(__file__).parent.parent))
from database import get_pool
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)
# Таблицы, где user_id = telegram_id. Чистим по каждому найденному юзеру.
USER_TABLES = [
"user_progress",
"sentence_progress",
"typing_progress",
"user_achievements",
"daily_logins",
"word_quiz_progress",
"bubble_words_progress",
"sentence_stats",
"choose_progress",
"user_seen_levels",
"user_game_progress",
"wave_results",
"user_seen_bubble_levels",
"user_word_stats",
"xp_log",
"typing_hints_used",
"chat_history",
"chat_usage",
"user_learning_answers",
"user_learning_answers_archive",
"user_lesson_progress",
"user_topic_progress",
"user_skill_mastery",
"learning_sessions",
"ai_user_context",
"teacher_chat_history",
"teacher_ai_usage",
]
async def resolve_user_ids(conn, telegram_id, device_id, all_pleily):
"""Возвращает список telegram_id, которых нужно сбросить."""
if telegram_id is not None:
row = await conn.fetchrow(
"SELECT telegram_id FROM users WHERE telegram_id = $1", telegram_id
)
if not row:
logger.error(f"❌ Пользователь с telegram_id={telegram_id} не найден")
return []
return [row["telegram_id"]]
if device_id is not None:
row = await conn.fetchrow(
"SELECT telegram_id FROM users WHERE device_id = $1::uuid", device_id
)
if not row:
logger.error(f"❌ Пользователь с device_id={device_id} не найден")
return []
return [row["telegram_id"]]
if all_pleily:
rows = await conn.fetch(
"SELECT telegram_id FROM users WHERE telegram_id < 0 OR source = 'pleily_device'"
)
return [r["telegram_id"] for r in rows]
return []
async def reset_user(conn, user_id: int) -> None:
"""Чистит прогресс одного пользователя в одной транзакции."""
async with conn.transaction():
for table in USER_TABLES:
await conn.execute(f"DELETE FROM {table} WHERE user_id = $1", user_id)
# Обнуляем XP-профиль (строку оставляем, чтобы не ломать FK).
await conn.execute(
"""
UPDATE user_profile
SET total_xp = 0, weekly_xp = 0, updated_at = NOW()
WHERE user_id = $1
""",
user_id,
)
# Сбрасываем прогресс уровней в users.
await conn.execute(
"""
UPDATE users
SET last_completed_level = 0,
last_completed_by_level = '{}'::jsonb,
current_level = 'A1'
WHERE telegram_id = $1
""",
user_id,
)
async def main() -> None:
parser = argparse.ArgumentParser(description="Сброс прогресса и достижений пользователя")
group = parser.add_mutually_exclusive_group(required=True)
group.add_argument("--telegram-id", type=int, help="telegram_id юзера (у Pleily отрицательный)")
group.add_argument("--device-id", type=str, help="UUID устройства (Pleily)")
group.add_argument("--all-pleily", action="store_true", help="сбросить ВСЕХ Pleily-юзеров")
parser.add_argument("--yes", action="store_true", help="не спрашивать подтверждение")
args = parser.parse_args()
pool = await get_pool()
async with pool.acquire() as conn:
user_ids = await resolve_user_ids(conn, args.telegram_id, args.device_id, args.all_pleily)
if not user_ids:
logger.warning("⚠️ Некого сбрасывать — выхожу")
return
logger.info(f"Найдено пользователей: {len(user_ids)} → {user_ids}")
if not args.yes:
answer = input(
f"Сбросить прогресс и достижения для {len(user_ids)} юзер(ов)? [y/N]: "
).strip().lower()
if answer not in ("y", "yes", "д", "да"):
logger.info("Отменено.")
return
for uid in user_ids:
await reset_user(conn, uid)
logger.info(f"✅ Сброшено: telegram_id={uid}")
logger.info("🎉 Готово! Можно тестировать как новый пользователь.")
if __name__ == "__main__":
asyncio.run(main())
File diff suppressed because it is too large Load Diff
+968
View File
@@ -0,0 +1,968 @@
"""
Наполняет таблицу teacher_materials правилами грамматики (rule), часть 2 (правила 10–17).
Данные взяты из pleily/lib/data/grammar_rules_part2.dart.
Запуск (из папки backend):
python scripts/seed_grammar_rules_part2.py
Скрипт идемпотентный: удаляет только свои правила (по title_pl),
потом вставляет заново. Не затирает правила из part1/part3.
"""
import asyncio
import os
import sys
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
from database import get_pool
GRAMMAR_RULES = [
# 10. ЧИСЛИТЕЛЬНЫЕ
{
"title": {
"pl": "Liczebniki",
"ru": "Числительные",
"uk": "Числівники",
"en": "Numerals",
},
"description": {
"pl": """Po liczebnikach rzeczownik może przyjmować różne formy.
📌 2, 3, 4 – najczęściej łączą się z mianownikiem liczby mnogiej
📌 5 i więcej – najczęściej łączą się z dopełniaczem liczby mnogiej
⚠️ W konstrukcjach z liczebnikami 5+ czasownik często występuje w liczbie pojedynczej.""",
"ru": """После числительных существительное может принимать разные формы.
📌 2, 3, 4 – обычно сочетаются с именительным падежом множественного числа
📌 5 и больше – обычно сочетаются с родительным падежом множественного числа
⚠️ В конструкциях с числительными 5+ глагол часто употребляется в единственном числе.""",
"uk": """Після числівників іменник може мати різні форми.
📌 2, 3, 4 – найчастіше поєднуються з називним відмінком множини
📌 5 і більше – найчастіше поєднуються з родовим відмінком множини
⚠️ У конструкціях із числівниками 5+ дієслово часто вживається в однині.""",
"en": """After numerals, the noun can take different forms.
📌 2, 3, 4 – usually take the nominative plural
📌 5 and above – usually take the genitive plural
⚠️ With numerals 5+, the verb is often used in the singular.""",
},
"example": {
"pl": """📌 2, 3, 4 → Mianownik (kto? co?)
Mam dwa koty.
Mam trzy psy.
Mam cztery książki.
📌 5+ → Dopełniacz (kogo? czego?)
Mam pięć kotów.
Mam siedem psów.
Mam sześć książek.
⚠️ Wiek: Mam 21 lat.
Mam 22 lata.
Mam 25 lat.""",
"ru": """📌 2, 3, 4 → Mianownik (kto? co?) — Именительный
Mam dwa koty.
У меня два кота.
Mam trzy psy.
У меня три собаки.
Mam cztery książki.
У меня четыре книги.
📌 5+ → Dopełniacz (kogo? czego?) — Родительный
Mam pięć kotów.
У меня пять котов.
Mam siedem psów.
У меня семь собак.
Mam sześć książek.
У меня шесть книг.
⚠️ Возраст:
Mam 21 lat. — Мне 21 год.
Mam 22 lata. — Мне 22 года.
Mam 25 lat. — Мне 25 лет.""",
"uk": """📌 2, 3, 4 → Mianownik (kto? co?) — Називний
Mam dwa koty.
У мене два коти.
Mam trzy psy.
У мене три собаки.
Mam cztery książki.
У мене чотири книги.
📌 5+ → Dopełniacz (kogo? czego?) — Родовий
Mam pięć kotów.
У мене п'ять котів.
Mam siedem psów.
У мене сім собак.
Mam sześć książek.
У мене шість книг.
⚠️ Вік:
Mam 21 lat. — Мені 21 рік.
Mam 22 lata. — Мені 22 роки.
Mam 25 lat. — Мені 25 років.""",
"en": """📌 2, 3, 4 → Mianownik (kto? co?) — Nominative
Mam dwa koty.
I have two cats.
Mam trzy psy.
I have three dogs.
Mam cztery książki.
I have four books.
📌 5+ → Dopełniacz (kogo? czego?) — Genitive
Mam pięć kotów.
I have five cats.
Mam siedem psów.
I have seven dogs.
Mam sześć książek.
I have six books.
⚠️ Age:
Mam 21 lat. — I am 21 years old.
Mam 22 lata. — I am 22 years old.
Mam 25 lat. — I am 25 years old.""",
},
"tags": ["rule", "grammar", "numeral", "number"],
},
# 11. ГЛАГОЛЫ ДВИЖЕНИЯ
{
"title": {
"pl": "Czasowniki ruchu",
"ru": "Глаголы движения",
"uk": "Дієслова руху",
"en": "Verbs of motion",
},
"description": {
"pl": """🚶 iść / chodzić – ruch pieszo
🚗 jechać / jeździć – ruch środkiem transportu
📌 iść, jechać – pojedynczy lub konkretny kierunek ruchu
📌 chodzić, jeździć – ruch powtarzający się, zwyczaj lub ogólną możliwość""",
"ru": """🚶 iść / chodzić – движение пешком
🚗 jechać / jeździć – движение на транспорте
📌 iść, jechać – единичное или конкретное направление движения
📌 chodzić, jeździć – повторяющееся движение, привычка или регулярность""",
"uk": """🚶 iść / chodzić – рух пішки
🚗 jechać / jeździć – рух транспортом
📌 iść, jechać – одиничний або конкретний напрямок руху
📌 chodzić, jeździć – повторюваний рух, звичка або регулярність""",
"en": """🚶 iść / chodzić – movement on foot
🚗 jechać / jeździć – movement by vehicle
📌 iść, jechać – a single or specific movement
📌 chodzić, jeździć – repeated movement, habit or regular activity""",
},
"example": {
"pl": """🔹 iść / jechać — konkretny ruch (teraz):
Idę do sklepu.
Jadę do Warszawy.
🔹 chodzić / jeździć — zwyczaj, powtarzanie:
Chodzę do pracy pieszo.
Jeżdżę do Warszawy co miesiąc.
Dziecko idzie do szkoły.
Dzieci chodzą do szkoły od poniedziałku do piątku.""",
"ru": """🔹 iść / jechać — конкретное движение (сейчас):
Idę do sklepu.
Я иду в магазин.
Jadę do Warszawy.
Я еду в Варшаву.
🔹 chodzić / jeździć — привычка, регулярность:
Chodzę do pracy pieszo.
Я хожу на работу пешком.
Jeżdżę do Warszawy co miesiąc.
Я езжу в Варшаву каждый месяц.
Dziecko idzie do szkoły.
Ребёнок идёт в школу.
Dzieci chodzą do szkoły od poniedziałku do piątku.
Дети ходят в школу с понедельника по пятницу.""",
"uk": """🔹 iść / jechać — конкретний рух (зараз):
Idę do sklepu.
Я йду до магазину.
Jadę do Warszawy.
Я їду до Варшави.
🔹 chodzić / jeździć — звичка, регулярність:
Chodzę do pracy pieszo.
Я ходжу на роботу пішки.
Jeżdżę do Warszawy co miesiąc.
Я їжджу до Варшави щомісяця.
Dziecko idzie do szkoły.
Дитина йде до школи.
Dzieci chodzą do szkoły od poniedziałku do piątku.
Діти ходять до школи з понеділка до п'ятниці.""",
"en": """🔹 iść / jechać — specific movement (now):
Idę do sklepu.
I'm going to the shop.
Jadę do Warszawy.
I'm going to Warsaw.
🔹 chodzić / jeździć — habit, repetition:
Chodzę do pracy pieszo.
I walk to work.
Jeżdżę do Warszawy co miesiąc.
I go to Warsaw every month.
Dziecko idzie do szkoły.
The child is going to school.
Dzieci chodzą do szkoły od poniedziałku do piątku.
Children go to school from Monday to Friday.""",
},
"tags": ["rule", "grammar", "verb", "motion"],
},
# 12. СТЕПЕНИ СРАВНЕНИЯ
{
"title": {
"pl": "Stopniowanie przymiotników",
"ru": "Степени сравнения прилагательных",
"uk": "Ступені порівняння прикметників",
"en": "Comparison of adjectives",
},
"description": {
"pl": """W języku polskim wyróżniamy trzy stopnie przymiotnika:
⭐ Równy – zwykły opis
⭐⭐ Wyższy – porównujemy dwie rzeczy
⭐⭐⭐ Najwyższy – wskazujemy coś jako najbardziej ...
📌 Często używamy końcówek -szy / -ejszy oraz przedrostka naj-.
⚠️ Nie wszystkie przymiotniki tworzą stopnie regularnie.
📌 męskoosobowy – grupa mężczyzn (dobrzy chłopcy)
📌 niemęskoosobowy – kobiety, dzieci, zwierzęta, rzeczy (dobre dziewczyny, dobre dzieci)""",
"ru": """В польском языке выделяют три степени сравнения прилагательных:
⭐ Положительная – обычное описание
⭐⭐ Сравнительная – сравниваем два предмета
⭐⭐⭐ Превосходная – выделяем что-то как самое ...
📌 Часто используются окончания -szy / -ejszy и приставка naj-.
⚠️ Не все прилагательные образуют степени сравнения регулярно.
📌 męskoosobowy – группа мужчин (dobrzy chłopcy — хорошие мальчики)
📌 niemęskoosobowy – женщины, дети, животные, предметы (dobre dziewczyny — хорошие девочки, dobre dzieci — хорошие дети)""",
"uk": """У польській мові виділяють три ступені порівняння прикметників:
⭐ Звичайний – звичайний опис
⭐⭐ Вищий – порівнюємо два предмети
⭐⭐⭐ Найвищий – виділяємо щось як найбільш ...
📌 Часто використовуються закінчення -szy / -ejszy та префікс naj-.
⚠️ Не всі прикметники утворюють ступені порівняння регулярно.
📌 męskoosobowy – група чоловіків (dobrzy chłopcy — хороші хлопці)
📌 niemęskoosobowy – жінки, діти, тварини, предмети (dobre dziewczyny — хороші дівчата, dobre dzieci — хороші діти)""",
"en": """Polish has three degrees of comparison:
⭐ Positive – ordinary description
⭐⭐ Comparative – comparing two things
⭐⭐⭐ Superlative – identifying something as the most ...
📌 The endings -szy / -ejszy and the prefix naj- are often used.
⚠️ Not all adjectives form their degrees regularly.
📌 męskoosobowy – a group of men (dobrzy chłopcy — good boys)
📌 niemęskoosobowy – women, children, animals, things (dobre dziewczyny — good girls, dobre dzieci — good children)""",
},
"example": {
"pl": """⭐ Równy — zwykły opis:
ładny telefon.
⭐⭐ Wyższy — porównujemy 2 rzeczy:
Ten telefon jest ładniejszy niż tamten.
⭐⭐⭐ Najwyższy — wyróżniamy 1 rzecz:
To jest najładniejszy telefon.
ładny → ładniejszy → najładniejszy
szybki → szybszy → najszybszy
🔄 Nieregularne:
dobry → lepszy → najlepszy
zły → gorszy → najgorszy
duży → większy → największy
mały → mniejszy → najmniejszy
📌 Męskoosobowy vs niemęskoosobowy:
Męskoosobowy: dobrzy chłopcy
Niemęskoosobowy: dobre dziewczyny, dobre dzieci""",
"ru": """⭐ Równy — Положительная (обычное описание):
ładny telefon.
Красивый телефон.
⭐⭐ Wyższy — Сравнительная (сравниваем 2 предмета):
Ten telefon jest ładniejszy niż tamten.
Этот телефон красивее того.
⭐⭐⭐ Najwyższy — Превосходная (выделяем 1 предмет):
To jest najładniejszy telefon.
Это самый красивый телефон.
ładny → ładniejszy → najładniejszy
szybki → szybszy → najszybszy
быстрый → быстрее → самый быстрый
🔄 Nieregularne — Неправильные:
dobry → lepszy → najlepszy (хороший → лучше → лучший)
zły → gorszy → najgorszy (плохой → хуже → худший)
duży → większy → największy (большой → больше → самый большой)
mały → mniejszy → najmniejszy (маленький → меньше → самый маленький)
📌 Męskoosobowy vs niemęskoosobowy:
Męskoosobowy: dobrzy chłopcy — хорошие мальчики
Niemęskoosobowy: dobre dziewczyny — хорошие девочки, dobre dzieci — хорошие дети""",
"uk": """⭐ Równy — Звичайний (звичайний опис):
ładny telefon.
Гарний телефон.
⭐⭐ Wyższy — Вищий (порівнюємо 2 предмети):
Ten telefon jest ładniejszy niż tamten.
Цей телефон гарніший за той.
⭐⭐⭐ Najwyższy — Найвищий (виділяємо 1 предмет):
To jest najładniejszy telefon.
Це найгарніший телефон.
ładny → ładniejszy → najładniejszy
szybki → szybszy → najszybszy
швидкий → швидший → найшвидший
🔄 Nieregularne — Неправильні:
dobry → lepszy → najlepszy (добрий → кращий → найкращий)
zły → gorszy → najgorszy (поганий → гірший → найгірший)
duży → większy → największy (великий → більший → найбільший)
mały → mniejszy → najmniejszy (малий → менший → найменший)
📌 Męskoosobowy vs niemęskoosobowy:
Męskoosobowy: dobrzy chłopcy — хороші хлопці
Niemęskoosobowy: dobre dziewczyny — хороші дівчата, dobre dzieci — хороші діти""",
"en": """⭐ Równy — Positive (ordinary description):
ładny telefon.
A pretty phone.
⭐⭐ Wyższy — Comparative (comparing 2 things):
Ten telefon jest ładniejszy niż tamten.
This phone is prettier than that one.
⭐⭐⭐ Najwyższy — Superlative (singling out 1 thing):
To jest najładniejszy telefon.
This is the prettiest phone.
ładny → ładniejszy → najładniejszy
szybki → szybszy → najszybszy
fast → faster → the fastest
🔄 Nieregularne — Irregular:
dobry → lepszy → najlepszy (good → better → best)
zły → gorszy → najgorszy (bad → worse → worst)
duży → większy → największy (big → bigger → biggest)
mały → mniejszy → najmniejszy (small → smaller → smallest)
📌 Męskoosobowy vs niemęskoosobowy:
Męskoosobowy: dobrzy chłopcy — good boys
Niemęskoosobowy: dobre dziewczyny — good girls, dobre dzieci — good children""",
},
"tags": ["rule", "grammar", "adjective", "comparison"],
},
# 13. СОГЛАСОВАНИЕ ПРИЛАГАТЕЛЬНЫХ
{
"title": {
"pl": "Zgodność przymiotnika z rzeczownikiem",
"ru": "Согласование прилагательных",
"uk": "Узгодження прикметників",
"en": "Adjective agreement",
},
"description": {
"pl": """Przymiotnik dopasowuje się do rzeczownika pod względem rodzaju, liczby i przypadku.
📌 Liczba pojedyncza: -y/-i (męski), -a (żeński), -e (nijaki)
📌 Liczba mnoga: -i/-y (męskoosobowy), -e (niemęskoosobowy)""",
"ru": """Прилагательное согласуется с существительным по роду, числу и падежу.
📌 Единственное число: -y/-i (мужской), -a (женский), -e (средний)
📌 Множественное число: -i/-y (мужской личный), -e (немужской личный)""",
"uk": """Прикметник узгоджується з іменником за родом, числом і відмінком.
📌 Однина: -y/-i (чоловічий), -a (жіночий), -e (середній)
📌 Множина: -i/-y (чоловічо-особовий), -e (нечоловічо-особовий)""",
"en": """An adjective agrees with the noun in gender, number and case.
📌 Singular: -y/-i (masculine), -a (feminine), -e (neuter)
📌 Plural: -i/-y (masculine personal), -e (non-masculine-personal)""",
},
"example": {
"pl": """🔹 Liczba pojedyncza:
Rodzaj męski: dobry chłopiec.
Rodzaj żeński: dobra dziewczyna.
Rodzaj nijaki: dobre dziecko.
🔹 Liczba mnoga:
Męskoosobowy: dobrzy chłopcy.
Niemęskoosobowy: dobre dziewczyny.""",
"ru": """🔹 Liczba pojedyncza — Единственное число:
Rodzaj męski (мужской): dobry chłopiec.
Хороший мальчик.
Rodzaj żeński (женский): dobra dziewczyna.
Хорошая девочка.
Rodzaj nijaki (средний): dobre dziecko.
Хороший ребёнок.
🔹 Liczba mnoga — Множественное число:
Męskoosobowy (мужской личный): dobrzy chłopcy.
Хорошие мальчики.
Niemęskoosobowy (немужской личный): dobre dziewczyny.
Хорошие девочки.""",
"uk": """🔹 Liczba pojedyncza — Однина:
Rodzaj męski (чоловічий): dobry chłopiec.
Хороший хлопчик.
Rodzaj żeński (жіночий): dobra dziewczyna.
Хороша дівчина.
Rodzaj nijaki (середній): dobre dziecko.
Хороша дитина.
🔹 Liczba mnoga — Множина:
Męskoosobowy (чоловічо-особовий): dobrzy chłopcy.
Хороші хлопці.
Niemęskoosobowy (немужсько-особовий): dobre dziewczyny.
Хороші дівчата.""",
"en": """🔹 Liczba pojedyncza — Singular:
Rodzaj męski (masculine): dobry chłopiec.
A good boy.
Rodzaj żeński (feminine): dobra dziewczyna.
A good girl.
Rodzaj nijaki (neuter): dobre dziecko.
A good child.
🔹 Liczba mnoga — Plural:
Męskoosobowy (masculine personal): dobrzy chłopcy.
Good boys.
Niemęskoosobowy (non-masculine-personal): dobre dziewczyny.
Good girls.""",
},
"tags": ["rule", "grammar", "adjective", "agreement"],
},
# 14. ОТРИЦАНИЕ NIE
{
"title": {
"pl": "Przeczenie „nie”",
"ru": "Отрицание «nie»",
"uk": "Заперечення «nie»",
"en": 'Negation "nie"',
},
"description": {
"pl": """📌 Z czasownikami „nie" piszemy osobno.
📌 Z przymiotnikami „nie" często piszemy łącznie, gdy tworzy przeciwstawne znaczenie.
📌 Z przysłówkami odprzymiotnikowymi często piszemy łącznie.
⚠️ Pisownia „nie" ma więcej szczegółowych zasad i wyjątków.""",
"ru": """📌 С глаголами „nie" пишется раздельно.
📌 С прилагательными „nie" часто пишется слитно, если образует противоположное значение.
📌 С наречиями, образованными от прилагательных, часто пишется слитно.
⚠️ У написания „nie" есть дополнительные правила и исключения.""",
"uk": """📌 З дієсловами „nie" пишеться окремо.
📌 З прикметниками „nie" часто пишеться разом, якщо утворює протилежне значення.
📌 Із прислівниками, утвореними від прикметників, часто пишеться разом.
⚠️ Написання „nie" має додаткові правила та винятки.""",
"en": """📌 With verbs, „nie" is written separately.
📌 With adjectives, „nie" is often written together when it creates an opposite meaning.
📌 With adverbs derived from adjectives, it is often written together.
⚠️ There are additional rules and exceptions for writing „nie".""",
},
"example": {
"pl": """🔹 Czasownik — osobno:
Nie wiem.
Nie mam czasu.
Nie lubię kawy.
🔹 Przymiotnik — często razem:
To jest nieładny dom.
On jest niegrzeczny.
🔹 Przysłówek — często razem:
Sklep jest niedaleko.""",
"ru": """🔹 Czasownik — Глагол (раздельно):
Nie wiem.
Я не знаю.
Nie mam czasu.
У меня нет времени.
Nie lubię kawy.
Я не люблю кофе.
🔹 Przymiotnik — Прилагательное (часто слитно):
To jest nieładny dom.
Это некрасивый дом.
On jest niegrzeczny.
Он невежливый.
🔹 Przysłówek — Наречие (часто слитно):
Sklep jest niedaleko.
Магазин недалеко.""",
"uk": """🔹 Czasownik — Дієслово (окремо):
Nie wiem.
Я не знаю.
Nie mam czasu.
У мене немає часу.
Nie lubię kawy.
Я не люблю каву.
🔹 Przymiotnik — Прикметник (часто разом):
To jest nieładny dom.
Це некрасивий будинок.
On jest niegrzeczny.
Він нечемний.
🔹 Przysłówek — Прислівник (часто разом):
Sklep jest niedaleko.
Магазин недалеко.""",
"en": """🔹 Czasownik — Verb (separate):
Nie wiem.
I don't know.
Nie mam czasu.
I don't have time.
Nie lubię kawy.
I don't like coffee.
🔹 Przymiotnik — Adjective (often together):
To jest nieładny dom.
This is an unattractive house.
On jest niegrzeczny.
He is rude.
🔹 Przysłówek — Adverb (often together):
Sklep jest niedaleko.
The shop is nearby.""",
},
"tags": ["rule", "grammar", "negation", "nie"],
},
# 15. SIĘ
{
"title": {
"pl": "Czasowniki zwrotne i „się”",
"ru": "Возвратные глаголы и «się»",
"uk": "Зворотні дієслова та «się»",
"en": 'Reflexive verbs and "się"',
},
"description": {
"pl": """„Się" jest częstą cząstką w języku polskim.
📌 Czasem odnosi się do osoby wykonującej czynność.
📌 Często jest stałą częścią konstrukcji czasownikowej i nie tłumaczy się go dosłownie.
📌 Może występować przed czasownikiem lub po nim.""",
"ru": """„Się" – частая частица в польском языке.
📌 Иногда относится к человеку, который выполняет действие.
📌 Часто является постоянной частью глагольной конструкции и не переводится буквально.
📌 Может стоять перед глаголом или после него.""",
"uk": """„Się" – часта частка в польській мові.
📌 Іноді стосується особи, яка виконує дію.
📌 Часто є постійною частиною дієслівної конструкції та не перекладається буквально.
📌 Може стояти перед дієсловом або після нього.""",
"en": """„Się" is a common particle in Polish.
📌 Sometimes it refers to the person performing the action.
📌 Often it is a fixed part of a verb construction and is not translated literally.
📌 It can appear before or after the verb.""",
},
"example": {
"pl": """Myję się rano.
Uczę się polskiego.
Ona szybko się ubiera.
Dzieci bawią się w ogrodzie.
Interesuję się muzyką.
Boję się psów.
Jutro się spotykamy.""",
"ru": """Myję się rano.
Я умываюсь утром.
Uczę się polskiego.
Я учу польский.
Ona szybko się ubiera.
Она быстро одевается.
Dzieci bawią się w ogrodzie.
Дети играют в саду.
Interesuję się muzyką.
Я интересуюсь музыкой.
Boję się psów.
Я боюсь собак.
Jutro się spotykamy.
Мы встречаемся завтра.""",
"uk": """Myję się rano.
Я вмиваюся вранці.
Uczę się polskiego.
Я вивчаю польську.
Ona szybko się ubiera.
Вона швидко одягається.
Dzieci bawią się w ogrodzie.
Діти граються в саду.
Interesuję się muzyką.
Я цікавлюся музикою.
Boję się psów.
Я боюся собак.
Jutro się spotykamy.
Ми зустрічаємося завтра.""",
"en": """Myję się rano.
I wash myself in the morning.
Uczę się polskiego.
I'm learning Polish.
Ona szybko się ubiera.
She gets dressed quickly.
Dzieci bawią się w ogrodzie.
The children are playing in the garden.
Interesuję się muzyką.
I'm interested in music.
Boję się psów.
I'm afraid of dogs.
Jutro się spotykamy.
We're meeting tomorrow.""",
},
"tags": ["rule", "grammar", "reflexive", "sie"],
},
# 16. ZNAĆ / WIEDZIEĆ
{
"title": {
"pl": "„Znać" i „wiedzieć"",
"ru": "«Znać» и «wiedzieć»",
"uk": "«Znać» та «wiedzieć»",
"en": '"Znać" vs "wiedzieć"',
},
"description": {
"pl": """📌 ZNAĆ – znać osoby, miejsca, języki, rzeczy lub utwory.
📌 WIEDZIEĆ – posiadać informację lub znać fakt.
Po „wiedzieć" często występują konstrukcje: wiem, gdzie... / wiem, że... / wiem, kiedy...""",
"ru": """📌 ZNAĆ – знать людей, места, языки, предметы или произведения.
📌 WIEDZIEĆ – знать информацию или факт.
После „wiedzieć" часто используются конструкции: wiem, gdzie... / wiem, że... / wiem, kiedy...""",
"uk": """📌 ZNAĆ – знати людей, місця, мови, предмети або твори.
📌 WIEDZIEĆ – знати інформацію або факт.
Після „wiedzieć" часто використовуються конструкції: wiem, gdzie... / wiem, że... / wiem, kiedy...""",
"en": """📌 ZNAĆ – to know people, places, languages, things or works.
📌 WIEDZIEĆ – to know information or a fact.
After „wiedzieć", common constructions include: wiem, gdzie... / wiem, że... / wiem, kiedy...""",
},
"example": {
"pl": """🔹 ZNAĆ (osoby, miejsca, języki, rzeczy):
Znam Annę.
Znam Warszawę.
Znam polski.
Znam tę piosenkę.
🔹 WIEDZIEĆ (fakty, informacje):
Wiem, gdzie mieszkasz.
Wiem, że masz rację.
Wiem, która jest godzina.
Nie wiem, kiedy przyjdzie.""",
"ru": """🔹 ZNAĆ (люди, места, языки, предметы):
Znam Annę.
Я знаю Анну.
Znam Warszawę.
Я знаю Варшаву.
Znam polski.
Я знаю польский.
Znam tę piosenkę.
Я знаю эту песню.
🔹 WIEDZIEĆ (факты, информация):
Wiem, gdzie mieszkasz.
Я знаю, где ты живёшь.
Wiem, że masz rację.
Я знаю, что ты прав.
Wiem, która jest godzina.
Я знаю, который час.
Nie wiem, kiedy przyjdzie.
Я не знаю, когда он придёт.""",
"uk": """🔹 ZNAĆ (люди, місця, мови, предмети):
Znam Annę.
Я знаю Анну.
Znam Warszawę.
Я знаю Варшаву.
Znam polski.
Я знаю польську.
Znam tę piosenkę.
Я знаю цю пісню.
🔹 WIEDZIEĆ (факти, інформація):
Wiem, gdzie mieszkasz.
Я знаю, де ти живеш.
Wiem, że masz rację.
Я знаю, що ти маєш рацію.
Wiem, która jest godzina.
Я знаю, котра година.
Nie wiem, kiedy przyjdzie.
Я не знаю, коли він прийде.""",
"en": """🔹 ZNAĆ (people, places, languages, things):
Znam Annę.
I know Anna.
Znam Warszawę.
I know Warsaw.
Znam polski.
I know Polish.
Znam tę piosenkę.
I know this song.
🔹 WIEDZIEĆ (facts, information):
Wiem, gdzie mieszkasz.
I know where you live.
Wiem, że masz rację.
I know that you're right.
Wiem, która jest godzina.
I know what time it is.
Nie wiem, kiedy przyjdzie.
I don't know when he'll come.""",
},
"tags": ["rule", "grammar", "verb", "znac", "wiedziec"],
},
# 17. МОДАЛЬНЫЕ ГЛАГОЛЫ
{
"title": {
"pl": "Czasowniki modalne",
"ru": "Модальные глаголы",
"uk": "Модальні дієслова",
"en": "Modal verbs",
},
"description": {
"pl": """Czasowniki modalne łączą się z bezokolicznikiem i wyrażają możliwość, chęć, konieczność lub powinność.
📌 móc – możliwość, pozwolenie
📌 chcieć – chęć
📌 musieć – konieczność
📌 powinien/powinna/powinno – powinność, rada
⚠️ „powinien" odmienia się przez rodzaj i osobę, ale nie jak zwykły czasownik – to forma specjalna.""",
"ru": """Модальные глаголы сочетаются с инфинитивом и выражают возможность, желание, необходимость или долженствование.
📌 móc – возможность, разрешение
📌 chcieć – желание
📌 musieć – необходимость
📌 powinien/powinna/powinno – долженствование, совет
⚠️ „powinien" изменяется по роду и лицу, но не как обычный глагол – это особая форма.""",
"uk": """Модальні дієслова поєднуються з інфінітивом і виражають можливість, бажання, необхідність або обов'язок.
📌 móc – можливість, дозвіл
📌 chcieć – бажання
📌 musieć – необхідність
📌 powinien/powinna/powinno – обов'язок, порада
⚠️ „powinien" змінюється за родом та особою, але не як звичайне дієслово – це особлива форма.""",
"en": """Modal verbs combine with an infinitive and express possibility, desire, necessity or obligation.
📌 móc – possibility, permission
📌 chcieć – desire
📌 musieć – necessity
📌 powinien/powinna/powinno – obligation, advice
⚠️ „powinien" changes by gender and person, but not like a regular verb – it is a special form.""",
},
"example": {
"pl": """Mogę ci pomóc.
Czy mogę otworzyć okno?
Chcę nauczyć się polskiego.
Musimy iść już teraz.
Powinieneś odpocząć.
Powinna Pani zadzwonić do lekarza.
Dzieci powinny więcej spać.""",
"ru": """Mogę ci pomóc.
Я могу тебе помочь.
Czy mogę otworzyć okno?
Могу я открыть окно?
Chcę nauczyć się polskiego.
Я хочу выучить польский.
Musimy iść już teraz.
Нам нужно идти уже сейчас.
Powinieneś odpocząć.
Тебе следует отдохнуть. (к мужчине)
Powinna Pani zadzwonić do lekarza.
Вам следует позвонить врачу. (к женщине, формально)
Dzieci powinny więcej spać.
Детям следует больше спать.""",
"uk": """Mogę ci pomóc.
Я можу тобі допомогти.
Czy mogę otworzyć okno?
Чи можу я відкрити вікно?
Chcę nauczyć się polskiego.
Я хочу вивчити польську.
Musimy iść już teraz.
Нам треба йти вже зараз.
Powinieneś odpocząć.
Тобі слід відпочити. (до чоловіка)
Powinna Pani zadzwonić do lekarza.
Вам слід зателефонувати лікарю. (до жінки, формально)
Dzieci powinny więcej spać.
Дітям слід більше спати.""",
"en": """Mogę ci pomóc.
I can help you.
Czy mogę otworzyć okno?
May I open the window?
Chcę nauczyć się polskiego.
I want to learn Polish.
Musimy iść już teraz.
We have to go right now.
Powinieneś odpocząć.
You should rest. (to a man)
Powinna Pani zadzwonić do lekarza.
You should call the doctor. (to a woman, formal)
Dzieci powinny więcej spać.
Children should sleep more.""",
},
"tags": ["rule", "grammar", "verb", "modal"],
},
]
async def main():
pool = await get_pool()
async with pool.acquire() as conn:
# Идемпотентность: удаляем только правила из этой части (по title_pl).
await conn.execute("""
DELETE FROM teacher_materials
WHERE category = 'rule' AND title_pl = ANY($1::text[])
""", [
"Liczebniki", "Czasowniki ruchu", "Stopniowanie przymiotników",
"Zgodność przymiotnika z rzeczownikiem", "Przeczenie „nie”",
"Czasowniki zwrotne i „się”", "„Znać" i „wiedzieć"", "Czasowniki modalne",
])
inserted = 0
for r in GRAMMAR_RULES:
await conn.execute(
"""
INSERT INTO teacher_materials (
category,
title_pl, title_ru, title_uk, title_en,
content_pl, content_ru, content_uk, content_en,
example_pl, example_ru, example_uk, example_en,
tags, level, is_active
)
VALUES (
'rule',
$1, $2, $3, $4,
$5, $6, $7, $8,
$9, $10, $11, $12,
$13, 'A1', TRUE
)
""",
r["title"]["pl"], r["title"]["ru"], r["title"]["uk"], r["title"]["en"],
r["description"]["pl"], r["description"]["ru"], r["description"]["uk"], r["description"]["en"],
r["example"]["pl"], r["example"]["ru"], r["example"]["uk"], r["example"]["en"],
r["tags"],
)
inserted += 1
print(f"Готово. Вставлено правил (часть 2): {inserted}")
await pool.close()
if __name__ == "__main__":
asyncio.run(main())
File diff suppressed because it is too large Load Diff
+326
View File
@@ -0,0 +1,326 @@
"""
Наполняет таблицу teacher_materials ложными друзьями (false_friend)
для русского и украинского языков.
Данные взяты из frontend/src/data/falseFriends.ts.
Запуск (из папки backend):
python scripts/seed_teacher_materials.py
Скрипт идемпотентный: сначала удаляет все записи category='false_friend',
потом вставляет заново. Повторный запуск не создаёт дубликатов.
"""
import asyncio
import os
import sys
# Добавляем корень backend в sys.path, чтобы работали импорты database.
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
from database import get_pool
# ============ РУССКИЙ СПИСОК (основной) ============
# (word_pl, false_meaning, true_meaning)
FALSE_FRIENDS_RU = [
("zapomnieć", "запомнить", "забыть"),
("zapamiętać", "запамятовать", "запомнить"),
("dywan", "диван", "ковёр"),
("dziwny", "дивный", "странный"),
("dzierżawa", "держава", "аренда"),
("gnój", "гной", "навоз, помёт"),
("godzić się", "годиться", "мириться, примиряться"),
("gotować się", "готовиться", "кипеть, вариться"),
("górny", "горный", "верхний"),
("kawior", "ковёр (созвучие)", "икра"),
("kąpać się", "капать", "купаться"),
("kiedy", "кеды", "когда"),
("kokarda", "кокарда", "бант"),
("komórka", "каморка", "клетка (биол.), мобильный телефон"),
("konieczny", "—", "необходимый, обязательный"),
("garnitur", "гарнитур (мебель)", "мужской костюм"),
("głaz", "глаз", "скала, валун"),
("czaszka", "чашка", "череп"),
("sklep", "склеп", "магазин"),
("grób", "гроб", "могила"),
("dynia", "дыня", "тыква"),
("widmo", "видимо", "призрак, привидение; спектр"),
("uroda", "урод", "красота"),
("magazyn", "магазин", "склад; журнал"),
("potrawa", "отрава", "блюдо (кулинарное)"),
("ukrop", "укроп", "кипяток"),
("puszka", "пушка", "консервная банка"),
("zakaz", "заказ", "запрет"),
("zakon", "закон", "монашеский орден"),
("zamach", "замах", "покушение"),
("zamordowany", "замордованный", "убитый"),
("podstawa", "подстава", "основа"),
("zasada", "засада", "принцип, основа"),
("prosto", "просто", "прямо"),
("rano", "рано", "утро, утром"),
("jutro", "—", "завтра"),
("krzesło", "кресло", "стул"),
("krawat", "кровать", "галстук"),
("familia", "фамилия", "семья"),
("fistaszki", "фисташки", "арахис"),
("gadać", "гадать", "болтать, трепаться"),
("wymagać", "вымогать", "требовать, нуждаться"),
("wzór", "взор", "образец, пример"),
("zabieg", "забег", "процедура; хлопоты"),
("zabór", "забор", "захват, завоевание"),
("zachwyt", "захват", "восхищение"),
("zaginąć", "погибнуть", "потеряться, пропасть"),
("zajadły", "заядлый", "яростный, остервенелый"),
("wygodny", "выгодный", "удобный"),
]
# ============ РУССКИЙ СПИСОК (бонусный) ============
# (word_pl, obvious_meaning, additional_meaning)
FALSE_FRIENDS_RU_BONUS = [
("akademik", "академик", "студенческое общежитие"),
("bałwan", "болван", "снеговик; идол"),
("brązowy", "бронзовый", "коричневый"),
("cierpieć", "терпеть", "страдать"),
("dlaczego", "зачем", "почему"),
("gniazdo", "гнездо", "розетка"),
("jagoda", "ягода", "черника"),
("kij", "кий (бильярдный)", "любая палка, клюшка"),
("kolega", "коллега", "друг, приятель"),
("kontakt", "контакт", "розетка"),
("koło", "круг", "колесо"),
("kuchnia", "кухня", "кухонная плита"),
("kwas", "квас", "кислота"),
("kwota", "квота", "сумма (денег)"),
("nauka", "наука", "учёба"),
("pilot", "пилот", "пульт; экскурсовод"),
("prawo", "право", "закон"),
("restauracja", "реставрация", "ресторан"),
("surowy", "суровый", "сырой"),
("sztuka", "штука", "искусство; пьеса"),
("słodki", "сладкий", "пресный, несолёный"),
("ważny", "важный", "действительный (о документе)"),
("zły", "злой", "плохой; неподходящий"),
]
# ============ УКРАИНСКИЙ СПИСОК (основной) ============
# (word_pl, false_meaning, true_meaning)
FALSE_FRIENDS_UK = [
("Arka", "арка", "ковчег"),
("Awans", "аванс", "підвищення, просування"),
("Bakalie", "бакалія", "сухофрукти і горіхи"),
("Baśń", "байка", "казка"),
("Belka", "білка", "балка"),
("Bohater", "богатир", "герой"),
("Broń", "бронь", "зброя"),
("Błysk", "блиск", "спалах, проблиск (або блешня)"),
("Błędny", "блідий", "помилковий, хибний"),
("Ciecierzyca", "сочевиця", "нут"),
("Czaszka", "чашка", "череп"),
("Dawka", "давка", "доза"),
("Dogadać się", "здогадатися", "порозумітися"),
("Dowolny", "задоволений", "довільний"),
("Dynia", "диня", "гарбуз"),
("Dywan", "диван", "килим"),
("Dzieło", "діло", "витвір"),
("Gadać", "гадати", "базікати, теревенити"),
("Gospodarka", "господарка", "економіка (або господарство)"),
("Grubość", "грубість", "товщина"),
("Grzywna", "гривня", "штраф"),
("Imiennik", "іменник", "тезко (або однофамілець)"),
("Jajecznica", "яєчня (глазунья)", "скрембл"),
("Kierownica", "керівниця", "кермо"),
("Kit", "кіт", "мастика"),
("Konieczność", "кінцівка", "необхідність"),
("Krzesło", "крісло", "стілець"),
("Kubek", "кубок", "кухоль"),
("Laskowy", "лагідний", "лісовий"),
("Magazyn", "магазин", "склад (або журнал)"),
("Mecz", "меч", "матч"),
("Mylny", "мильний", "помилковий"),
("Nagły", "нахабний", "раптовий, неочікуваний"),
("Naprawić", "направити", "виправити, налагодити"),
("Niewidomy", "невідомий", "незрячий"),
("Nocnik", "нічник", "горщик (туалетний)"),
("Objawy", "об'яви", "симптоми"),
("Obywatel", "обиватель", "громадянин"),
("Oddychanie", "відпочинок", "дихання"),
("Owoce", "овочі", "фрукти"),
("Palacz", "кат", "курець (або кочегар)"),
("Pamiętnik", "пам'ятник", "щоденник (або мемуари)"),
("Pensja", "пенсія", "зарплата"),
("Pieczen", "печінка", "печеня (тушковане м'ясо)"),
("Pieczywo", "печиво", "випічка"),
("Plecy", "плечі", "спина"),
("Pojazd", "поїзд", "транспортний засіб"),
("Polny", "повний", "польовий"),
("Portfel", "портфель", "гаманець"),
("Przypadek", "припадок", "випадок (або відмінок)"),
("Puszka", "пушка", "бляшанка"),
("Pyszny", "пишний", "дуже смачний"),
("Płyn", "плин", "рідина"),
("Rano", "рано", "ранок (або вранці)"),
("Rodzice", "родичі", "батьки"),
("Rogatka", "рогатка", "шлагбаум"),
("Rosół", "розсіл", "бульйон"),
("Rozbierać się", "розбиратися", "роздягатися"),
("Rozkaz", "розповідь", "наказ, команда"),
("Rozwaga", "розвага", "розсудливість"),
("Samodzielny", "саморобний", "самостійний"),
("Ser", "сер", "сир"),
("Sklep", "склеп", "магазин"),
("Skoro", "скоро", "оскільки"),
("Sople", "соплі", "бурульки"),
("Sprzątać", "заховати", "прибирати (наводити порядок)"),
("Statek", "статок", "судно, корабель"),
("Szczyt", "щит", "вершина, верх (або саміт)"),
("Szlak", "шлак", "шлях, маршрут"),
("Szyny", "шини", "рейки"),
("Tlen", "тлін", "кисень"),
("Umowa", "умова", "угода, договір"),
("Umysł", "умисел", "розум"),
("Urok", "урок", "очарування"),
("Uznać", "дізнатися", "визнати"),
("Ułamek", "уламок", "дріб (або доля, частина)"),
("Wizerunek", "візерунок", "зображення (або імідж)"),
("Wniosek", "внесок", "висновок (або заява, пропозиція)"),
("Woń", "сморід", "аромат"),
("Wrzucać", "вручати", "вкидати"),
("Wygoda", "вигода", "зручність"),
("Wyzywać", "визивати", "обзивати"),
("Zabieg", "забіг", "процедура"),
("Zachowywać", "заховувати", "зберігати (або поводитись)"),
("Zakaz", "замовлення", "заборона"),
("Zamierzać", "замерзати", "мати намір, збиратися"),
("Zapomnieć", "запам'ятати", "забути"),
("Zapowiedź", "заповідь", "оголошення, анонс"),
("Zasób", "засіб", "запас, ресурс"),
("Zawód", "завод", "професія"),
("Zdanie", "будівля", "речення (або думка, погляд)"),
("Zgadzać się", "згадати", "погоджуватись"),
("Śliwki", "вершки", "сливи"),
("Śpiączka", "сплячка", "кома (втрата свідомості)"),
("Żyletka", "жилетка", "лезо"),
("Żywot", "живіт", "життя"),
]
# ============ УКРАИНСКИЙ СПИСОК (бонусный) ============
# (word_pl, obvious_meaning, additional_meaning)
FALSE_FRIENDS_UK_BONUS = [
("Akademik", "академік", "гуртожиток"),
("Bałwan", "бовдур", "сніговик; також ідол"),
("Brązowy", "бронзовий", "коричневий"),
("Cierpieć", "терпіти", "страждати"),
("Dlaczego", "навіщо", "чому"),
("Gniazdo", "гніздо", "розетка"),
("Góra", "гора", "верх"),
("Jagoda", "ягода", "чорниця"),
("Jama", "яма", "порожнина"),
("Kij", "кий", "ключка; кран для пива"),
("Kolega", "колега", "друг, приятель"),
("Kontakt", "контакт", "розетка"),
("Koło", "коло", "колесо"),
("Kuchnia", "кухня", "кухонна плита"),
("Kurka", "курка", "лисичка (гриб)"),
("Kwas", "квас", "кислота"),
("Kwota", "квота", "сума (грошей)"),
("Nauka", "наука", "навчання"),
("Opuścić", "опустити", "покинути"),
("Parkiet", "паркет", "танцпол; біржа"),
("Pilot", "пілот", "пульт; екскурсовод"),
("Pluton", "Плутон", "плутоній; взвод"),
("Po", "по", "після"),
("Prawo", "право", "закон"),
("Prosto", "просто", "прямо"),
("Przystawka", "приставка", "закуска"),
("Restauracja", "реставрація", "ресторан"),
("Sprawiedliwość", "справедливість", "правосуддя"),
("Surowy", "суворий", "сирий"),
("Sztuka", "штука", "мистецтво; п'єса"),
("Słodki", "солодкий", "прісний"),
("Terminowy", "терміновий", "вчасний, пунктуальний"),
("Trampolina", "трамплін", "батут"),
("Twierdzenie", "твердження", "теорема"),
("Upadek", "упадок", "падіння"),
("Ważny", "важливий", "дійсний"),
("Wiatrak", "вітряк", "вентилятор"),
("Wymazać", "вимазати", "стерти, усунути"),
("Wypadek", "випадок", "аварія"),
("Zakładać", "закладати", "вдягати; встановлювати"),
("Zapasy", "запаси", "боротьба (спорт)"),
("Zły", "злий", "поганий; непідхожий"),
]
def _is_empty(value: str) -> bool:
"""Проверяет, пустое ли «ложное» значение (— или пустая строка)."""
return value in ("—", "-", "", None)
async def main():
pool = await get_pool()
async with pool.acquire() as conn:
# Идемпотентность: удаляем старые записи false_friend, чтобы не дублировать.
await conn.execute("DELETE FROM teacher_materials WHERE category = 'false_friend'")
inserted = 0
# --- Русские основные ---
for word_pl, false_meaning, true_meaning in FALSE_FRIENDS_RU:
if _is_empty(false_meaning):
content_ru = f"На самом деле: {true_meaning}"
else:
content_ru = f"Кажется: {false_meaning}. На самом деле: {true_meaning}"
await conn.execute(
"""
INSERT INTO teacher_materials (category, title_pl, content_ru, tags, level, is_active)
VALUES ('false_friend', $1, $2, $3, 'A1', TRUE)
""",
word_pl, content_ru, ["false_friend", "ru"],
)
inserted += 1
# --- Русские бонусные ---
for word_pl, obvious_meaning, additional_meaning in FALSE_FRIENDS_RU_BONUS:
content_ru = f"Очевидное значение: {obvious_meaning}. Дополнительное: {additional_meaning}"
await conn.execute(
"""
INSERT INTO teacher_materials (category, title_pl, content_ru, tags, level, is_active)
VALUES ('false_friend', $1, $2, $3, 'A1', TRUE)
""",
word_pl, content_ru, ["false_friend", "ru"],
)
inserted += 1
# --- Украинские основные ---
for word_pl, false_meaning, true_meaning in FALSE_FRIENDS_UK:
if _is_empty(false_meaning):
content_uk = f"Насправді: {true_meaning}"
else:
content_uk = f"Здається: {false_meaning}. Насправді: {true_meaning}"
await conn.execute(
"""
INSERT INTO teacher_materials (category, title_pl, content_uk, tags, level, is_active)
VALUES ('false_friend', $1, $2, $3, 'A1', TRUE)
""",
word_pl, content_uk, ["false_friend", "uk"],
)
inserted += 1
# --- Украинские бонусные ---
for word_pl, obvious_meaning, additional_meaning in FALSE_FRIENDS_UK_BONUS:
content_uk = f"Очевидне значення: {obvious_meaning}. Додаткове: {additional_meaning}"
await conn.execute(
"""
INSERT INTO teacher_materials (category, title_pl, content_uk, tags, level, is_active)
VALUES ('false_friend', $1, $2, $3, 'A1', TRUE)
""",
word_pl, content_uk, ["false_friend", "uk"],
)
inserted += 1
print(f"Готово. Вставлено ложных друзей: {inserted}")
await pool.close()
if __name__ == "__main__":
asyncio.run(main())
+63
View File
@@ -0,0 +1,63 @@
"""
Наполняет таблицу teacher_materials правилами грамматики (category='rule').
Данные взяты из pleily/lib/data/grammar_rules_part1/2/3.dart.
Данные лежат в трёх модулях:
teacher_rules_data_1.py — правила 1–9
teacher_rules_data_2.py — правила 10–17
teacher_rules_data_3.py — правила 18–25
Запуск (из папки backend):
python scripts/seed_teacher_rules.py
Скрипт идемпотентный: сначала удаляет все записи category='rule',
потом вставляет заново. Повторный запуск не создаёт дубликатов.
"""
import asyncio
import os
import sys
# Добавляем корень backend в sys.path, чтобы работали импорты database.
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
# Добавляем папку scripts/, чтобы работали импорты модулей данных.
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
from database import get_pool
from teacher_rules_data_1 import RULES_1
from teacher_rules_data_2 import RULES_2
from teacher_rules_data_3 import RULES_3
RULES = RULES_1 + RULES_2 + RULES_3
async def main():
pool = await get_pool()
async with pool.acquire() as conn:
# Идемпотентность: удаляем старые записи rule, чтобы не дублировать.
await conn.execute("DELETE FROM teacher_materials WHERE category = 'rule'")
inserted = 0
for r in RULES:
await conn.execute(
"""
INSERT INTO teacher_materials
(category, title_pl, title_ru, title_uk, title_en,
content_pl, content_ru, content_uk, content_en,
example_pl, example_ru, example_uk, example_en,
tags, level, is_active)
VALUES ('rule', $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, 'A1', TRUE)
""",
r["title"]["pl"], r["title"]["ru"], r["title"]["uk"], r["title"]["en"],
r["content"]["pl"], r["content"]["ru"], r["content"]["uk"], r["content"]["en"],
r["example"]["pl"], r["example"]["ru"], r["example"]["uk"], r["example"]["en"],
r["tags"],
)
inserted += 1
print(f"Готово. Вставлено правил: {inserted}")
await pool.close()
if __name__ == "__main__":
asyncio.run(main())
File diff suppressed because it is too large Load Diff
+882
View File
@@ -0,0 +1,882 @@
"""Правила грамматики 10–17 (данные для seed_teacher_rules.py)."""
RULES_2 = [
# 10. ЧИСЛИТЕЛЬНЫЕ
{
"title": {
"pl": "Liczebniki",
"ru": "Числительные",
"uk": "Числівники",
"en": "Numerals",
},
"content": {
"pl": """Po liczebnikach rzeczownik może przyjmować różne formy.
📌 2, 3, 4 – najczęściej łączą się z mianownikiem liczby mnogiej
📌 5 i więcej – najczęściej łączą się z dopełniaczem liczby mnogiej
⚠️ W konstrukcjach z liczebnikami 5+ czasownik często występuje w liczbie pojedynczej.""",
"ru": """После числительных существительное может принимать разные формы.
📌 2, 3, 4 – обычно сочетаются с именительным падежом множественного числа
📌 5 и больше – обычно сочетаются с родительным падежом множественного числа
⚠️ В конструкциях с числительными 5+ глагол часто употребляется в единственном числе.""",
"uk": """Після числівників іменник може мати різні форми.
📌 2, 3, 4 – найчастіше поєднуються з називним відмінком множини
📌 5 і більше – найчастіше поєднуються з родовим відмінком множини
⚠️ У конструкціях із числівниками 5+ дієслово часто вживається в однині.""",
"en": """After numerals, the noun can take different forms.
📌 2, 3, 4 – usually take the nominative plural
📌 5 and above – usually take the genitive plural
⚠️ With numerals 5+, the verb is often used in the singular.""",
},
"example": {
"pl": """📌 2, 3, 4 → Mianownik (kto? co?)
Mam dwa koty.
Mam trzy psy.
Mam cztery książki.
📌 5+ → Dopełniacz (kogo? czego?)
Mam pięć kotów.
Mam siedem psów.
Mam sześć książek.
⚠️ Wiek: Mam 21 lat.
Mam 22 lata.
Mam 25 lat.""",
"ru": """📌 2, 3, 4 → Mianownik (kto? co?) — Именительный
Mam dwa koty.
У меня два кота.
Mam trzy psy.
У меня три собаки.
Mam cztery książki.
У меня четыре книги.
📌 5+ → Dopełniacz (kogo? czego?) — Родительный
Mam pięć kotów.
У меня пять котов.
Mam siedem psów.
У меня семь собак.
Mam sześć książek.
У меня шесть книг.
⚠️ Возраст:
Mam 21 lat. — Мне 21 год.
Mam 22 lata. — Мне 22 года.
Mam 25 lat. — Мне 25 лет.""",
"uk": """📌 2, 3, 4 → Mianownik (kto? co?) — Називний
Mam dwa koty.
У мене два коти.
Mam trzy psy.
У мене три собаки.
Mam cztery książki.
У мене чотири книги.
📌 5+ → Dopełniacz (kogo? czego?) — Родовий
Mam pięć kotów.
У мене п'ять котів.
Mam siedem psów.
У мене сім собак.
Mam sześć książek.
У мене шість книг.
⚠️ Вік:
Mam 21 lat. — Мені 21 рік.
Mam 22 lata. — Мені 22 роки.
Mam 25 lat. — Мені 25 років.""",
"en": """📌 2, 3, 4 → Mianownik (kto? co?) — Nominative
Mam dwa koty.
I have two cats.
Mam trzy psy.
I have three dogs.
Mam cztery książki.
I have four books.
📌 5+ → Dopełniacz (kogo? czego?) — Genitive
Mam pięć kotów.
I have five cats.
Mam siedem psów.
I have seven dogs.
Mam sześć książek.
I have six books.
⚠️ Age:
Mam 21 lat. — I am 21 years old.
Mam 22 lata. — I am 22 years old.
Mam 25 lat. — I am 25 years old.""",
},
"tags": ["rule", "grammar", "numeral"],
},
# 11. ГЛАГОЛЫ ДВИЖЕНИЯ
{
"title": {
"pl": "Czasowniki ruchu",
"ru": "Глаголы движения",
"uk": "Дієслова руху",
"en": "Verbs of motion",
},
"content": {
"pl": """🚶 iść / chodzić – ruch pieszo
🚗 jechać / jeździć – ruch środkiem transportu
📌 iść, jechać – pojedynczy lub konkretny kierunek ruchu
📌 chodzić, jeździć – ruch powtarzający się, zwyczaj lub ogólną możliwość""",
"ru": """🚶 iść / chodzić – движение пешком
🚗 jechać / jeździć – движение на транспорте
📌 iść, jechać – единичное или конкретное направление движения
📌 chodzić, jeździć – повторяющееся движение, привычка или регулярность""",
"uk": """🚶 iść / chodzić – рух пішки
🚗 jechać / jeździć – рух транспортом
📌 iść, jechać – одиничний або конкретний напрямок руху
📌 chodzić, jeździć – повторюваний рух, звичка або регулярність""",
"en": """🚶 iść / chodzić – movement on foot
🚗 jechać / jeździć – movement by vehicle
📌 iść, jechać – a single or specific movement
📌 chodzić, jeździć – repeated movement, habit or regular activity""",
},
"example": {
"pl": """🔹 iść / jechać — konkretny ruch (teraz):
Idę do sklepu.
Jadę do Warszawy.
🔹 chodzić / jeździć — zwyczaj, powtarzanie:
Chodzę do pracy pieszo.
Jeżdżę do Warszawy co miesiąc.
Dziecko idzie do szkoły.
Dzieci chodzą do szkoły od poniedziałku do piątku.""",
"ru": """🔹 iść / jechać — конкретное движение (сейчас):
Idę do sklepu.
Я иду в магазин.
Jadę do Warszawy.
Я еду в Варшаву.
🔹 chodzić / jeździć — привычка, регулярность:
Chodzę do pracy pieszo.
Я хожу на работу пешком.
Jeżdżę do Warszawy co miesiąc.
Я езжу в Варшаву каждый месяц.
Dziecko idzie do szkoły.
Ребёнок идёт в школу.
Dzieci chodzą do szkoły od poniedziałku do piątku.
Дети ходят в школу с понедельника по пятницу.""",
"uk": """🔹 iść / jechać — конкретний рух (зараз):
Idę do sklepu.
Я йду до магазину.
Jadę do Warszawy.
Я їду до Варшави.
🔹 chodzić / jeździć — звичка, регулярність:
Chodzę do pracy pieszo.
Я ходжу на роботу пішки.
Jeżdżę do Warszawy co miesiąc.
Я їжджу до Варшави щомісяця.
Dziecko idzie do szkoły.
Дитина йде до школи.
Dzieci chodzą do szkoły od poniedziałku do piątku.
Діти ходять до школи з понеділка до п'ятниці.""",
"en": """🔹 iść / jechać — specific movement (now):
Idę do sklepu.
I'm going to the shop.
Jadę do Warszawy.
I'm going to Warsaw.
🔹 chodzić / jeździć — habit, repetition:
Chodzę do pracy pieszo.
I walk to work.
Jeżdżę do Warszawy co miesiąc.
I go to Warsaw every month.
Dziecko idzie do szkoły.
The child is going to school.
Dzieci chodzą do szkoły od poniedziałku do piątku.
Children go to school from Monday to Friday.""",
},
"tags": ["rule", "grammar", "verb", "motion"],
},
# 12. СТЕПЕНИ СРАВНЕНИЯ
{
"title": {
"pl": "Stopniowanie przymiotników",
"ru": "Степени сравнения прилагательных",
"uk": "Ступені порівняння прикметників",
"en": "Comparison of adjectives",
},
"content": {
"pl": """W języku polskim wyróżniamy trzy stopnie przymiotnika:
⭐ Równy – zwykły opis
⭐⭐ Wyższy – porównujemy dwie rzeczy
⭐⭐⭐ Najwyższy – wskazujemy coś jako najbardziej ...
📌 Często używamy końcówek -szy / -ejszy oraz przedrostka naj-.
⚠️ Nie wszystkie przymiotniki tworzą stopnie regularnie.""",
"ru": """В польском языке выделяют три степени сравнения прилагательных:
⭐ Положительная – обычное описание
⭐⭐ Сравнительная – сравниваем два предмета
⭐⭐⭐ Превосходная – выделяем что-то как самое ...
📌 Часто используются окончания -szy / -ejszy и приставка naj-.
⚠️ Не все прилагательные образуют степени сравнения регулярно.""",
"uk": """У польській мові виділяють три ступені порівняння прикметників:
⭐ Звичайний – звичайний опис
⭐⭐ Вищий – порівнюємо два предмети
⭐⭐⭐ Найвищий – виділяємо щось як найбільш ...
📌 Часто використовуються закінчення -szy / -ejszy та префікс naj-.
⚠️ Не всі прикметники утворюють ступені порівняння регулярно.""",
"en": """Polish has three degrees of comparison:
⭐ Positive – ordinary description
⭐⭐ Comparative – comparing two things
⭐⭐⭐ Superlative – identifying something as the most ...
📌 The endings -szy / -ejszy and the prefix naj- are often used.
⚠️ Not all adjectives form their degrees regularly.""",
},
"example": {
"pl": """⭐ Równy — zwykły opis:
ładny telefon.
⭐⭐ Wyższy — porównujemy 2 rzeczy:
Ten telefon jest ładniejszy niż tamten.
⭐⭐⭐ Najwyższy — wyróżniamy 1 rzecz:
To jest najładniejszy telefon.
ładny → ładniejszy → najładniejszy
szybki → szybszy → najszybszy
🔄 Nieregularne:
dobry → lepszy → najlepszy
zły → gorszy → najgorszy
duży → większy → największy
mały → mniejszy → najmniejszy""",
"ru": """⭐ Równy — Положительная (обычное описание):
ładny telefon.
Красивый телефон.
⭐⭐ Wyższy — Сравнительная (сравниваем 2 предмета):
Ten telefon jest ładniejszy niż tamten.
Этот телефон красивее того.
⭐⭐⭐ Najwyższy — Превосходная (выделяем 1 предмет):
To jest najładniejszy telefon.
Это самый красивый телефон.
ładny → ładniejszy → najładniejszy
szybki → szybszy → najszybszy
быстрый → быстрее → самый быстрый
🔄 Nieregularne — Неправильные:
dobry → lepszy → najlepszy (хороший → лучше → лучший)
zły → gorszy → najgorszy (плохой → хуже → худший)
duży → większy → największy (большой → больше → самый большой)
mały → mniejszy → najmniejszy (маленький → меньше → самый маленький)""",
"uk": """⭐ Równy — Звичайний (звичайний опис):
ładny telefon.
Гарний телефон.
⭐⭐ Wyższy — Вищий (порівнюємо 2 предмети):
Ten telefon jest ładniejszy niż tamten.
Цей телефон гарніший за той.
⭐⭐⭐ Najwyższy — Найвищий (виділяємо 1 предмет):
To jest najładniejszy telefon.
Це найгарніший телефон.
ładny → ładniejszy → najładniejszy
szybki → szybszy → najszybszy
швидкий → швидший → найшвидший
🔄 Nieregularne — Неправильні:
dobry → lepszy → najlepszy (добрий → кращий → найкращий)
zły → gorszy → najgorszy (поганий → гірший → найгірший)
duży → większy → największy (великий → більший → найбільший)
mały → mniejszy → najmniejszy (малий → менший → найменший)""",
"en": """⭐ Równy — Positive (ordinary description):
ładny telefon.
A pretty phone.
⭐⭐ Wyższy — Comparative (comparing 2 things):
Ten telefon jest ładniejszy niż tamten.
This phone is prettier than that one.
⭐⭐⭐ Najwyższy — Superlative (singling out 1 thing):
To jest najładniejszy telefon.
This is the prettiest phone.
ładny → ładniejszy → najładniejszy
szybki → szybszy → najszybszy
fast → faster → the fastest
🔄 Nieregularne — Irregular:
dobry → lepszy → najlepszy (good → better → best)
zły → gorszy → najgorszy (bad → worse → worst)
duży → większy → największy (big → bigger → biggest)
mały → mniejszy → najmniejszy (small → smaller → smallest)""",
},
"tags": ["rule", "grammar", "adjective", "comparison"],
},
# 13. СОГЛАСОВАНИЕ ПРИЛАГАТЕЛЬНЫХ
{
"title": {
"pl": "Zgodność przymiotnika z rzeczownikiem",
"ru": "Согласование прилагательных",
"uk": "Узгодження прикметників",
"en": "Adjective agreement",
},
"content": {
"pl": """Przymiotnik dopasowuje się do rzeczownika pod względem rodzaju, liczby i przypadku.
📌 Liczba pojedyncza: -y/-i (męski), -a (żeński), -e (nijaki)
📌 Liczba mnoga: -i/-y (męskoosobowy), -e (niemęskoosobowy)""",
"ru": """Прилагательное согласуется с существительным по роду, числу и падежу.
📌 Единственное число: -y/-i (мужской), -a (женский), -e (средний)
📌 Множественное число: -i/-y (мужской личный), -e (немужской личный)""",
"uk": """Прикметник узгоджується з іменником за родом, числом і відмінком.
📌 Однина: -y/-i (чоловічий), -a (жіночий), -e (середній)
📌 Множина: -i/-y (чоловічо-особовий), -e (нечоловічо-особовий)""",
"en": """An adjective agrees with the noun in gender, number and case.
📌 Singular: -y/-i (masculine), -a (feminine), -e (neuter)
📌 Plural: -i/-y (masculine personal), -e (non-masculine-personal)""",
},
"example": {
"pl": """🔹 Liczba pojedyncza:
Rodzaj męski: dobry chłopiec.
Rodzaj żeński: dobra dziewczyna.
Rodzaj nijaki: dobre dziecko.
🔹 Liczba mnoga:
Męskoosobowy: dobrzy chłopcy.
Niemęskoosobowy: dobre dziewczyny.""",
"ru": """🔹 Liczba pojedyncza — Единственное число:
Rodzaj męski (мужской): dobry chłopiec.
Хороший мальчик.
Rodzaj żeński (женский): dobra dziewczyna.
Хорошая девочка.
Rodzaj nijaki (средний): dobre dziecko.
Хороший ребёнок.
🔹 Liczba mnoga — Множественное число:
Męskoosobowy (мужской личный): dobrzy chłopcy.
Хорошие мальчики.
Niemęskoosobowy (немужской личный): dobre dziewczyny.
Хорошие девочки.""",
"uk": """🔹 Liczba pojedyncza — Однина:
Rodzaj męski (чоловічий): dobry chłopiec.
Хороший хлопчик.
Rodzaj żeński (жіночий): dobra dziewczyna.
Хороша дівчина.
Rodzaj nijaki (середній): dobre dziecko.
Хороша дитина.
🔹 Liczba mnoga — Множина:
Męskoosobowy (чоловічо-особовий): dobrzy chłopcy.
Хороші хлопці.
Niemęskoosobowy (немужсько-особовий): dobre dziewczyny.
Хороші дівчата.""",
"en": """🔹 Liczba pojedyncza — Singular:
Rodzaj męski (masculine): dobry chłopiec.
A good boy.
Rodzaj żeński (feminine): dobra dziewczyna.
A good girl.
Rodzaj nijaki (neuter): dobre dziecko.
A good child.
🔹 Liczba mnoga — Plural:
Męskoosobowy (masculine personal): dobrzy chłopcy.
Good boys.
Niemęskoosobowy (non-masculine-personal): dobre dziewczyny.
Good girls.""",
},
"tags": ["rule", "grammar", "adjective", "agreement"],
},
# 14. ОТРИЦАНИЕ NIE
{
"title": {
"pl": "Przeczenie „nie”",
"ru": "Отрицание «nie»",
"uk": "Заперечення «nie»",
"en": "Negation \"nie\"",
},
"content": {
"pl": """📌 Z czasownikami „nie" piszemy osobno.
📌 Z przymiotnikami „nie" często piszemy łącznie, gdy tworzy przeciwstawne znaczenie.
📌 Z przysłówkami odprzymiotnikowymi często piszemy łącznie.
⚠️ Pisownia „nie" ma więcej szczegółowych zasad i wyjątków.""",
"ru": """📌 С глаголами „nie" пишется раздельно.
📌 С прилагательными „nie" часто пишется слитно, если образует противоположное значение.
📌 С наречиями, образованными от прилагательных, часто пишется слитно.
⚠️ У написания „nie" есть дополнительные правила и исключения.""",
"uk": """📌 З дієсловами „nie" пишеться окремо.
📌 З прикметниками „nie" часто пишеться разом, якщо утворює протилежне значення.
📌 Із прислівниками, утвореними від прикметників, часто пишеться разом.
⚠️ Написання „nie" має додаткові правила та винятки.""",
"en": """📌 With verbs, „nie" is written separately.
📌 With adjectives, „nie" is often written together when it creates an opposite meaning.
📌 With adverbs derived from adjectives, it is often written together.
⚠️ There are additional rules and exceptions for writing „nie".""",
},
"example": {
"pl": """🔹 Czasownik — osobno:
Nie wiem.
Nie mam czasu.
Nie lubię kawy.
🔹 Przymiotnik — często razem:
To jest nieładny dom.
On jest niegrzeczny.
🔹 Przysłówek — często razem:
Sklep jest niedaleko.""",
"ru": """🔹 Czasownik — Глагол (раздельно):
Nie wiem.
Я не знаю.
Nie mam czasu.
У меня нет времени.
Nie lubię kawy.
Я не люблю кофе.
🔹 Przymiotnik — Прилагательное (часто слитно):
To jest nieładny dom.
Это некрасивый дом.
On jest niegrzeczny.
Он невежливый.
🔹 Przysłówek — Наречие (часто слитно):
Sklep jest niedaleko.
Магазин недалеко.""",
"uk": """🔹 Czasownik — Дієслово (окремо):
Nie wiem.
Я не знаю.
Nie mam czasu.
У мене немає часу.
Nie lubię kawy.
Я не люблю каву.
🔹 Przymiotnik — Прикметник (часто разом):
To jest nieładny dom.
Це некрасивий будинок.
On jest niegrzeczny.
Він нечемний.
🔹 Przysłówek — Прислівник (часто разом):
Sklep jest niedaleko.
Магазин недалеко.""",
"en": """🔹 Czasownik — Verb (separate):
Nie wiem.
I don't know.
Nie mam czasu.
I don't have time.
Nie lubię kawy.
I don't like coffee.
🔹 Przymiotnik — Adjective (often together):
To jest nieładny dom.
This is an unattractive house.
On jest niegrzeczny.
He is rude.
🔹 Przysłówek — Adverb (often together):
Sklep jest niedaleko.
The shop is nearby.""",
},
"tags": ["rule", "grammar", "negation"],
},
# 15. SIĘ
{
"title": {
"pl": "Czasowniki zwrotne i „się”",
"ru": "Возвратные глаголы и «się»",
"uk": "Зворотні дієслова та «się»",
"en": "Reflexive verbs and \"się\"",
},
"content": {
"pl": """„Się" jest częstą cząstką w języku polskim.
📌 Czasem odnosi się do osoby wykonującej czynność.
📌 Często jest stałą częścią konstrukcji czasownikowej i nie tłumaczy się go dosłownie.
📌 Może występować przed czasownikiem lub po nim.""",
"ru": """„Się" – частая частица в польском языке.
📌 Иногда относится к человеку, который выполняет действие.
📌 Часто является постоянной частью глагольной конструкции и не переводится буквально.
📌 Может стоять перед глаголом или после него.""",
"uk": """„Się" – часта частка в польській мові.
📌 Іноді стосується особи, яка виконує дію.
📌 Часто є постійною частиною дієслівної конструкції та не перекладається буквально.
📌 Може стояти перед дієсловом або після нього.""",
"en": """\"Się\" is a common particle in Polish.
📌 Sometimes it refers to the person performing the action.
📌 Often it is a fixed part of a verb construction and is not translated literally.
📌 It can appear before or after the verb.""",
},
"example": {
"pl": """Myję się rano.
Uczę się polskiego.
Ona szybko się ubiera.
Dzieci bawią się w ogrodzie.
Interesuję się muzyką.
Boję się psów.
Jutro się spotykamy.""",
"ru": """Myję się rano.
Я умываюсь утром.
Uczę się polskiego.
Я учу польский.
Ona szybko się ubiera.
Она быстро одевается.
Dzieci bawią się w ogrodzie.
Дети играют в саду.
Interesuję się muzyką.
Я интересуюсь музыкой.
Boję się psów.
Я боюсь собак.
Jutro się spotykamy.
Мы встречаемся завтра.""",
"uk": """Myję się rano.
Я вмиваюся вранці.
Uczę się polskiego.
Я вивчаю польську.
Ona szybko się ubiera.
Вона швидко одягається.
Dzieci bawią się w ogrodzie.
Діти граються в саду.
Interesuję się muzyką.
Я цікавлюся музикою.
Boję się psów.
Я боюся собак.
Jutro się spotykamy.
Ми зустрічаємося завтра.""",
"en": """Myję się rano.
I wash myself in the morning.
Uczę się polskiego.
I'm learning Polish.
Ona szybko się ubiera.
She gets dressed quickly.
Dzieci bawią się w ogrodzie.
The children are playing in the garden.
Interesuję się muzyką.
I'm interested in music.
Boję się psów.
I'm afraid of dogs.
Jutro się spotykamy.
We're meeting tomorrow.""",
},
"tags": ["rule", "grammar", "reflexive"],
},
# 16. ZNAĆ / WIEDZIEĆ
{
"title": {
"pl": "„Znać” i „wiedzieć”",
"ru": "«Znać» и «wiedzieć»",
"uk": "«Znać» та «wiedzieć»",
"en": "\"Znać\" vs \"wiedzieć\"",
},
"content": {
"pl": """📌 ZNAĆ – znać osoby, miejsca, języki, rzeczy lub utwory.
📌 WIEDZIEĆ – posiadać informację lub znać fakt.
Po „wiedzieć" często występują konstrukcje: wiem, gdzie... / wiem, że... / wiem, kiedy...""",
"ru": """📌 ZNAĆ – знать людей, места, языки, предметы или произведения.
📌 WIEDZIEĆ – знать информацию или факт.
После „wiedzieć" часто используются конструкции: wiem, gdzie... / wiem, że... / wiem, kiedy...""",
"uk": """📌 ZNAĆ – знати людей, місця, мови, предмети або твори.
📌 WIEDZIEĆ – знати інформацію або факт.
Після „wiedzieć" часто використовуються конструкції: wiem, gdzie... / wiem, że... / wiem, kiedy...""",
"en": """📌 ZNAĆ – to know people, places, languages, things or works.
📌 WIEDZIEĆ – to know information or a fact.
After „wiedzieć", common constructions include: wiem, gdzie... / wiem, że... / wiem, kiedy...""",
},
"example": {
"pl": """🔹 ZNAĆ (osoby, miejsca, języki, rzeczy):
Znam Annę.
Znam Warszawę.
Znam polski.
Znam tę piosenkę.
🔹 WIEDZIEĆ (fakty, informacje):
Wiem, gdzie mieszkasz.
Wiem, że masz rację.
Wiem, która jest godzina.
Nie wiem, kiedy przyjdzie.""",
"ru": """🔹 ZNAĆ (люди, места, языки, предметы):
Znam Annę.
Я знаю Анну.
Znam Warszawę.
Я знаю Варшаву.
Znam polski.
Я знаю польский.
Znam tę piosenkę.
Я знаю эту песню.
🔹 WIEDZIEĆ (факты, информация):
Wiem, gdzie mieszkasz.
Я знаю, где ты живёшь.
Wiem, że masz rację.
Я знаю, что ты прав.
Wiem, która jest godzina.
Я знаю, который час.
Nie wiem, kiedy przyjdzie.
Я не знаю, когда он придёт.""",
"uk": """🔹 ZNAĆ (люди, місця, мови, предмети):
Znam Annę.
Я знаю Анну.
Znam Warszawę.
Я знаю Варшаву.
Znam polski.
Я знаю польську.
Znam tę piosenkę.
Я знаю цю пісню.
🔹 WIEDZIEĆ (факти, інформація):
Wiem, gdzie mieszkasz.
Я знаю, де ти живеш.
Wiem, że masz rację.
Я знаю, що ти маєш рацію.
Wiem, która jest godzina.
Я знаю, котра година.
Nie wiem, kiedy przyjdzie.
Я не знаю, коли він прийде.""",
"en": """🔹 ZNAĆ (people, places, languages, things):
Znam Annę.
I know Anna.
Znam Warszawę.
I know Warsaw.
Znam polski.
I know Polish.
Znam tę piosenkę.
I know this song.
🔹 WIEDZIEĆ (facts, information):
Wiem, gdzie mieszkasz.
I know where you live.
Wiem, że masz rację.
I know that you're right.
Wiem, która jest godzina.
I know what time it is.
Nie wiem, kiedy przyjdzie.
I don't know when he'll come.""",
},
"tags": ["rule", "grammar", "verb"],
},
# 17. МОДАЛЬНЫЕ ГЛАГОЛЫ
{
"title": {
"pl": "Czasowniki modalne",
"ru": "Модальные глаголы",
"uk": "Модальні дієслова",
"en": "Modal verbs",
},
"content": {
"pl": """Czasowniki modalne łączą się z bezokolicznikiem i wyrażają możliwość, chęć, konieczność lub powinność.
📌 móc – możliwość, pozwolenie
📌 chcieć – chęć
📌 musieć – konieczność
📌 powinien/powinna/powinno – powinność, rada
⚠️ „powinien" odmienia się przez rodzaj i osobę, ale nie jak zwykły czasownik – to forma specjalna.""",
"ru": """Модальные глаголы сочетаются с инфинитивом и выражают возможность, желание, необходимость или долженствование.
📌 móc – возможность, разрешение
📌 chcieć – желание
📌 musieć – необходимость
📌 powinien/powinna/powinno – долженствование, совет
⚠️ „powinien" изменяется по роду и лицу, но не как обычный глагол – это особая форма.""",
"uk": """Модальні дієслова поєднуються з інфінітивом і виражають можливість, бажання, необхідність або обов'язок.
📌 móc – можливість, дозвіл
📌 chcieć – бажання
📌 musieć – необхідність
📌 powinien/powinna/powinno – обов'язок, порада
⚠️ „powinien" змінюється за родом та особою, але не як звичайне дієслово – це особлива форма.""",
"en": """Modal verbs combine with an infinitive and express possibility, desire, necessity or obligation.
📌 móc – possibility, permission
📌 chcieć – desire
📌 musieć – necessity
📌 powinien/powinna/powinno – obligation, advice
⚠️ „powinien" changes by gender and person, but not like a regular verb – it is a special form.""",
},
"example": {
"pl": """Mogę ci pomóc.
Czy mogę otworzyć okno?
Chcę nauczyć się polskiego.
Musimy iść już teraz.
Powinieneś odpocząć.
Powinna Pani zadzwonić do lekarza.
Dzieci powinny więcej spać.""",
"ru": """Mogę ci pomóc.
Я могу тебе помочь.
Czy mogę otworzyć okno?
Могу я открыть окно?
Chcę nauczyć się polskiego.
Я хочу выучить польский.
Musimy iść już teraz.
Нам нужно идти уже сейчас.
Powinieneś odpocząć.
Тебе следует отдохнуть. (к мужчине)
Powinna Pani zadzwonić do lekarza.
Вам следует позвонить врачу. (к женщине, формально)
Dzieci powinny więcej spać.
Детям следует больше спать.""",
"uk": """Mogę ci pomóc.
Я можу тобі допомогти.
Czy mogę otworzyć okno?
Чи можу я відкрити вікно?
Chcę nauczyć się polskiego.
Я хочу вивчити польську.
Musimy iść już teraz.
Нам треба йти вже зараз.
Powinieneś odpocząć.
Тобі слід відпочити. (до чоловіка)
Powinna Pani zadzwonić do lekarza.
Вам слід зателефонувати лікарю. (до жінки, формально)
Dzieci powinny więcej spać.
Дітям слід більше спати.""",
"en": """Mogę ci pomóc.
I can help you.
Czy mogę otworzyć okno?
May I open the window?
Chcę nauczyć się polskiego.
I want to learn Polish.
Musimy iść już teraz.
We have to go right now.
Powinieneś odpocząć.
You should rest. (to a man)
Powinna Pani zadzwonić do lekarza.
You should call the doctor. (to a woman, formal)
Dzieci powinny więcej spać.
Children should sleep more.""",
},
"tags": ["rule", "grammar", "verb", "modal"],
},
]
+965
View File
@@ -0,0 +1,965 @@
"""Правила грамматики 18–25 (данные для seed_teacher_rules.py)."""
RULES_3 = [
# 18. ПРОШЕДШЕЕ ВРЕМЯ
{
"title": {
"pl": "Czas przeszły",
"ru": "Прошедшее время",
"uk": "Минулий час",
"en": "Past tense",
},
"content": {
"pl": """Czas przeszły tworzymy od tematu czasownika, dodając końcówkę rodzajową „-ł/-ła/-ło/-li/-ły" oraz końcówkę osobową.
📌 Liczba pojedyncza: -łem/-łam, -łeś/-łaś, -ł/-ła/-ło
📌 Liczba mnoga: -liśmy/-łyśmy, -liście/-łyście, -li/-ły
⚠️ Końcówka osobowa może „odklejać się" od czasownika i przesuwać na inne słowo w zdaniu (np. na zaimek).""",
"ru": """Прошедшее время образуем от основы глагола, добавляя родовое окончание „-ł/-ła/-ło/-li/-ły" и личное окончание.
📌 Единственное число: -łem/-łam, -łeś/-łaś, -ł/-ła/-ło
📌 Множественное число: -liśmy/-łyśmy, -liście/-łyście, -li/-ły
⚠️ Личное окончание может „отклеиваться" от глагола и переходить на другое слово в предложении (например, на местоимение).""",
"uk": """Минулий час утворюємо від основи дієслова, додаючи родове закінчення „-ł/-ła/-ło/-li/-ły" та особове закінчення.
📌 Однина: -łem/-łam, -łeś/-łaś, -ł/-ła/-ło
📌 Множина: -liśmy/-łyśmy, -liście/-łyście, -li/-ły
⚠️ Особове закінчення може „відклеюватися" від дієслова і переходити на інше слово в реченні (наприклад, на займенник).""",
"en": """The past tense is formed from the verb stem by adding the gender ending „-ł/-ła/-ło/-li/-ły" plus a personal ending.
📌 Singular: -łem/-łam, -łeś/-łaś, -ł/-ła/-ło
📌 Plural: -liśmy/-łyśmy, -liście/-łyście, -li/-ły
⚠️ The personal ending can "detach" from the verb and move onto another word in the sentence (e.g. onto a pronoun).""",
},
"example": {
"pl": """🔹 CZYTAĆ (mężczyzna / kobieta):
czytałem / czytałam
czytałeś / czytałaś
czytał / czytała / czytało
🔹 Liczba mnoga:
czytaliśmy / czytałyśmy
czytaliście / czytałyście
czytali / czytały
Wczoraj czytałem książkę.
Ona wczoraj oglądała film.
Gdzieś ty był?""",
"ru": """🔹 CZYTAĆ (мужчина / женщина):
czytałem / czytałam
я читал / я читала
czytałeś / czytałaś
ты читал / ты читала
czytał / czytała / czytało
он читал / она читала / оно читало
🔹 Множественное число:
czytaliśmy / czytałyśmy
мы читали
czytaliście / czytałyście
вы читали
czytali / czytały
они читали
Wczoraj czytałem książkę.
Вчера я читал книгу.
Ona wczoraj oglądała film.
Она вчера смотрела фильм.
Gdzieś ty był?
Где ты был?""",
"uk": """🔹 CZYTAĆ (чоловік / жінка):
czytałem / czytałam
я читав / я читала
czytałeś / czytałaś
ти читав / ти читала
czytał / czytała / czytało
він читав / вона читала / воно читало
🔹 Множина:
czytaliśmy / czytałyśmy
ми читали
czytaliście / czytałyście
ви читали
czytali / czytały
вони читали
Wczoraj czytałem książkę.
Вчора я читав книгу.
Ona wczoraj oglądała film.
Вона вчора дивилася фільм.
Gdzieś ty był?
Де ти був?""",
"en": """🔹 CZYTAĆ (male / female speaker):
czytałem / czytałam
I read (past, male / female)
czytałeś / czytałaś
you read (past, male / female)
czytał / czytała / czytało
he read / she read / it read
🔹 Plural:
czytaliśmy / czytałyśmy
we read
czytaliście / czytałyście
you (pl.) read
czytali / czytały
they read
Wczoraj czytałem książkę.
Yesterday I read a book.
Ona wczoraj oglądała film.
Yesterday she watched a movie.
Gdzieś ty był?
Where were you?""",
},
"tags": ["rule", "grammar", "verb", "past"],
},
# 19. БУДУЩЕЕ ВРЕМЯ
{
"title": {
"pl": "Czas przyszły",
"ru": "Будущее время",
"uk": "Майбутній час",
"en": "Future tense",
},
"content": {
"pl": """📌 Czasowniki dokonane – forma wyglądająca jak teraźniejsza ma znaczenie przyszłe (przeczytam, zrobię).
📌 Czasowniki niedokonane – czas przyszły złożony: „będę" + bezokolicznik LUB „będę" + forma czasu przeszłego (osobowa).
⚠️ Obie wersje z „będę" (bezokolicznik i forma przeszła) są poprawne i oznaczają to samo.""",
"ru": """📌 Совершенные глаголы – форма, похожая на настоящее время, имеет значение будущего (przeczytam, zrobię).
📌 Несовершенные глаголы – составное будущее время: „będę" + инфинитив ИЛИ „będę" + форма прошедшего времени (личная).
⚠️ Оба варианта с „będę" (инфинитив и форма прошедшего) правильны и означают одно и то же.""",
"uk": """📌 Доконані дієслова – форма, схожа на теперішній час, має значення майбутнього (przeczytam, zrobię).
📌 Недоконані дієслова – складений майбутній час: „będę" + інфінітив АБО „będę" + форма минулого часу (особова).
⚠️ Обидва варіанти з „będę" (інфінітив і форма минулого) правильні й означають те саме.""",
"en": """📌 Perfective verbs – a form that looks like the present tense actually has a future meaning (przeczytam, zrobię).
📌 Imperfective verbs – compound future tense: „będę" + infinitive OR „będę" + a past-tense (personal) form.
⚠️ Both versions with „będę" (infinitive and past-tense form) are correct and mean the same thing.""",
},
"example": {
"pl": """🔹 DOKONANY (forma prosta = przyszłość):
Przeczytam tę książkę.
Zrobię to jutro.
Kupię nowy telefon.
🔹 NIEDOKONANY (będę + bezokolicznik):
Będę czytać książkę.
Będę pracować cały dzień.
🔹 NIEDOKONANY (będę + forma przeszła):
Będę czytał książkę.
Będziesz pracowała jutro?""",
"ru": """🔹 DOKONANY — Совершенный (простая форма = будущее):
Przeczytam tę książkę.
Я прочитаю эту книгу.
Zrobię to jutro.
Я сделаю это завтра.
Kupię nowy telefon.
Я куплю новый телефон.
🔹 NIEDOKONANY — Несовершенный (będę + инфинитив):
Będę czytać książkę.
Я буду читать книгу.
Będę pracować cały dzień.
Я буду работать весь день.
🔹 NIEDOKONANY — Несовершенный (będę + форма прошедшего):
Będę czytał książkę.
Я буду читать книгу. (то же значение)
Będziesz pracowała jutro?
Ты будешь работать завтра? (к женщине)""",
"uk": """🔹 DOKONANY — Доконаний (проста форма = майбутнє):
Przeczytam tę książkę.
Я прочитаю цю книгу.
Zrobię to jutro.
Я зроблю це завтра.
Kupię nowy telefon.
Я куплю новий телефон.
🔹 NIEDOKONANY — Недоконаний (będę + інфінітив):
Będę czytać książkę.
Я буду читати книгу.
Będę pracować cały dzień.
Я буду працювати цілий день.
🔹 NIEDOKONANY — Недоконаний (będę + форма минулого):
Będę czytał książkę.
Я буду читати книгу. (те саме значення)
Będziesz pracowała jutro?
Ти будеш працювати завтра? (до жінки)""",
"en": """🔹 DOKONANY — Perfective (simple form = future):
Przeczytam tę książkę.
I will read this book.
Zrobię to jutro.
I will do it tomorrow.
Kupię nowy telefon.
I will buy a new phone.
🔹 NIEDOKONANY — Imperfective (będę + infinitive):
Będę czytać książkę.
I will be reading a book.
Będę pracować cały dzień.
I will be working all day.
🔹 NIEDOKONANY — Imperfective (będę + past-tense form):
Będę czytał książkę.
I will be reading a book. (same meaning)
Będziesz pracowała jutro?
Will you be working tomorrow? (to a woman)""",
},
"tags": ["rule", "grammar", "verb", "future"],
},
# 20. ПАДЕЖИ
{
"title": {
"pl": "Przypadki",
"ru": "Падежи",
"uk": "Відмінки",
"en": "Cases",
},
"content": {
"pl": "Język polski ma 7 przypadków. Przypadek pokazuje funkcję rzeczownika w zdaniu i często wpływa na jego końcówkę.",
"ru": "В польском языке 7 падежей. Падеж показывает функцию существительного в предложении и часто влияет на его окончание.",
"uk": "У польській мові 7 відмінків. Відмінок показує функцію іменника в реченні та часто впливає на його закінчення.",
"en": "Polish has 7 cases. The case shows the function of a noun in a sentence and often changes its ending.",
},
"example": {
"pl": """1️⃣ Mianownik (kto? co?): To jest dom.
2️⃣ Dopełniacz (kogo? czego?): Nie ma domu.
3️⃣ Celownik (komu? czemu?): Pomagam bratu.
4️⃣ Biernik (kogo? co?): Widzę dom.
5️⃣ Narzędnik (z kim? z czym?): Jadę z bratem.
6️⃣ Miejscownik (o kim? o czym?): Myślę o domu.
7️⃣ Wołacz (O! — zwracanie się do kogoś): Mamo! Piotrze!""",
"ru": """1️⃣ Mianownik (kto? co?) — Именительный (кто? что?):
To jest dom.
Это дом.
2️⃣ Dopełniacz (kogo? czego?) — Родительный (кого? чего?):
Nie ma domu.
Нет дома.
3️⃣ Celownik (komu? czemu?) — Дательный (кому? чему?):
Pomagam bratu.
Я помогаю брату.
4️⃣ Biernik (kogo? co?) — Винительный (кого? что?):
Widzę dom.
Я вижу дом.
5️⃣ Narzędnik (z kim? z czym?) — Творительный (с кем? с чем?):
Jadę z bratem.
Я еду с братом.
6️⃣ Miejscownik (o kim? o czym?) — Местный (о ком? о чём?):
Myślę o domu.
Я думаю о доме.
7️⃣ Wołacz (О! — обращение к кому-то):
Mamo! Piotrze!
Мама! Пётр!""",
"uk": """1️⃣ Mianownik (kto? co?) — Називний (хто? що?):
To jest dom.
Це будинок.
2️⃣ Dopełniacz (kogo? czego?) — Родовий (кого? чого?):
Nie ma domu.
Немає будинку.
3️⃣ Celownik (komu? czemu?) — Давальний (кому? чому?):
Pomagam bratu.
Я допомагаю братові.
4️⃣ Biernik (kogo? co?) — Знахідний (кого? що?):
Widzę dom.
Я бачу будинок.
5️⃣ Narzędnik (z kim? z czym?) — Орудний (з ким? з чим?):
Jadę z bratem.
Я їду з братом.
6️⃣ Miejscownik (o kim? o czym?) — Місцевий (про кого? про що?):
Myślę o domu.
Я думаю про будинок.
7️⃣ Wołacz (О! — звертання до когось):
Mamo! Piotrze!
Мамо! Петре!""",
"en": """1️⃣ Mianownik (kto? co?) — Nominative (who? what?):
To jest dom.
This is a house.
2️⃣ Dopełniacz (kogo? czego?) — Genitive (of whom? of what?):
Nie ma domu.
There is no house.
3️⃣ Celownik (komu? czemu?) — Dative (to whom? to what?):
Pomagam bratu.
I help my brother.
4️⃣ Biernik (kogo? co?) — Accusative (whom? what?):
Widzę dom.
I see the house.
5️⃣ Narzędnik (z kim? z czym?) — Instrumental (with whom? with what?):
Jadę z bratem.
I'm going with my brother.
6️⃣ Miejscownik (o kim? o czym?) — Locative (about whom? about what?):
Myślę o domu.
I'm thinking about the house.
7️⃣ Wołacz (Oh! — direct address to someone):
Mamo! Piotrze!
Mum! Piotr!""",
},
"tags": ["rule", "grammar", "case"],
},
# 21. ПРЕДЛОГИ И ПАДЕЖИ
{
"title": {
"pl": "Przyimki i przypadki",
"ru": "Предлоги и падежи",
"uk": "Прийменники та відмінки",
"en": "Prepositions and cases",
},
"content": {
"pl": """Przyimki łączą się z określonymi przypadkami. Ten sam przyimek może czasem łączyć się z różnymi przypadkami i wtedy znaczenie może się zmieniać.
📌 Kierunek: często biernik
📌 Miejsce: często miejscownik
📌 do, z – dopełniacz
📌 z – narzędnik, gdy oznacza „z kim / z czym".""",
"ru": """Предлоги сочетаются с определёнными падежами. Один и тот же предлог иногда может сочетаться с разными падежами, и тогда значение может меняться.
📌 Направление: часто винительный
📌 Место: часто местный
📌 do, z – родительный
📌 z – творительный, когда означает «с кем / с чем»""",
"uk": """Прийменники поєднуються з певними відмінками. Один і той самий прийменник іноді може поєднуватися з різними відмінками, і тоді значення може змінюватися.
📌 Напрямок: часто знахідний
📌 Місце: часто місцевий
📌 do, z – родовий
📌 z – орудний, коли означає «з ким / з чим»""",
"en": """Prepositions are used with specific cases. The same preposition can sometimes be used with different cases, which can change the meaning.
📌 Direction: often accusative
📌 Location: often locative
📌 do, z – genitive
📌 z – instrumental when it means "with whom / with what".""",
},
"example": {
"pl": """do + dopełniacz (kogo? czego?): Idę do domu.
z + dopełniacz (kogo? czego?): Wracam z pracy.
w + miejscownik (o kim? o czym?): Jestem w domu.
na + biernik (kogo? co?): Idę na koncert.
na + miejscownik (o kim? o czym?): Jestem na koncercie.
z + narzędnik (z kim? z czym?): Rozmawiam z kolegą.
o + miejscownik (o kim? o czym?): Myślę o wakacjach.""",
"ru": """do + Dopełniacz (kogo? czego?) — Родительный:
Idę do domu.
Я иду домой.
z + Dopełniacz (kogo? czego?) — Родительный:
Wracam z pracy.
Я возвращаюсь с работы.
w + Miejscownik (o kim? o czym?) — Местный:
Jestem w domu.
Я дома.
na + Biernik (kogo? co?) — Винительный:
Idę na koncert.
Я иду на концерт.
na + Miejscownik (o kim? o czym?) — Местный:
Jestem na koncercie.
Я на концерте.
z + Narzędnik (z kim? z czym?) — Творительный:
Rozmawiam z kolegą.
Я разговариваю с другом.
o + Miejscownik (o kim? o czym?) — Местный:
Myślę o wakacjach.
Я думаю о каникулах.""",
"uk": """do + Dopełniacz (kogo? czego?) — Родовий:
Idę do domu.
Я йду додому.
z + Dopełniacz (kogo? czego?) — Родовий:
Wracam z pracy.
Я повертаюся з роботи.
w + Miejscownik (o kim? o czym?) — Місцевий:
Jestem w domu.
Я вдома.
na + Biernik (kogo? co?) — Знахідний:
Idę na koncert.
Я йду на концерт.
na + Miejscownik (o kim? o czym?) — Місцевий:
Jestem na koncercie.
Я на концерті.
z + Narzędnik (z kim? z czym?) — Орудний:
Rozmawiam z kolegą.
Я розмовляю з другом.
o + Miejscownik (o kim? o czym?) — Місцевий:
Myślę o wakacjach.
Я думаю про канікули.""",
"en": """do + Dopełniacz (kogo? czego?) — Genitive:
Idę do domu.
I'm going home.
z + Dopełniacz (kogo? czego?) — Genitive:
Wracam z pracy.
I'm coming back from work.
w + Miejscownik (o kim? o czym?) — Locative:
Jestem w domu.
I'm at home.
na + Biernik (kogo? co?) — Accusative:
Idę na koncert.
I'm going to a concert.
na + Miejscownik (o kim? o czym?) — Locative:
Jestem na koncercie.
I'm at the concert.
z + Narzędnik (z kim? z czym?) — Instrumental:
Rozmawiam z kolegą.
I'm talking with a friend.
o + Miejscownik (o kim? o czym?) — Locative:
Myślę o wakacjach.
I'm thinking about the holidays.""",
},
"tags": ["rule", "grammar", "preposition", "case"],
},
# 22. ВИД ГЛАГОЛА
{
"title": {
"pl": "Aspekt czasownika",
"ru": "Вид глагола",
"uk": "Вид дієслова",
"en": "Verb aspect",
},
"content": {
"pl": """📌 NIEDOKONANY – proces, trwanie, powtarzalność lub czynność bez wskazania zakończenia.
📌 DOKONANY – zakończenie czynności lub osiągnięcie rezultatu.
⚠️ Czasowniki dokonane nie mają prawdziwego czasu teraźniejszego. Ich formy wyglądające jak teraźniejsze odnoszą się do przyszłości.""",
"ru": """📌 НЕСОВЕРШЕННЫЙ – процесс, длительность, повторяемость или действие без указания на завершение.
📌 СОВЕРШЕННЫЙ – завершение действия или достижение результата.
⚠️ У совершенных глаголов нет настоящего времени в обычном смысле. Их формы, похожие на настоящее время, относятся к будущему.""",
"uk": """📌 НЕДОКОНАНИЙ – процес, тривалість, повторюваність або дія без указання на завершення.
📌 ДОКОНАНИЙ – завершення дії або досягнення результату.
⚠️ Доконані дієслова не мають справжнього теперішнього часу. Їхні форми, схожі на теперішній час, мають значення майбутнього.""",
"en": """📌 IMPERFECTIVE – a process, duration, repetition or an action without indicating completion.
📌 PERFECTIVE – completion of an action or an achieved result.
⚠️ Perfective verbs do not have a true present tense. Their forms that look like present tense refer to the future.""",
},
"example": {
"pl": """🔹 NIEDOKONANY — proces, trwanie:
Czytam książkę.
Robię zadanie.
Kupuję chleb.
🔹 DOKONANY — rezultat, zakończenie:
Przeczytam książkę.
Zrobię zadanie.
Kupię chleb.""",
"ru": """🔹 NIEDOKONANY — Несовершенный (процесс, длительность):
Czytam książkę.
Я читаю книгу.
Robię zadanie.
Я делаю задание.
Kupuję chleb.
Я покупаю хлеб.
🔹 DOKONANY — Совершенный (результат, завершение):
Przeczytam książkę.
Я прочитаю книгу.
Zrobię zadanie.
Я сделаю задание.
Kupię chleb.
Я куплю хлеб.""",
"uk": """🔹 NIEDOKONANY — Недоконаний (процес, тривалість):
Czytam książkę.
Я читаю книгу.
Robię zadanie.
Я роблю завдання.
Kupuję chleb.
Я купую хліб.
🔹 DOKONANY — Доконаний (результат, завершення):
Przeczytam książkę.
Я прочитаю книгу.
Zrobię zadanie.
Я зроблю завдання.
Kupię chleb.
Я куплю хліб.""",
"en": """🔹 NIEDOKONANY — Imperfective (process, duration):
Czytam książkę.
I'm reading a book.
Robię zadanie.
I'm doing the task.
Kupuję chleb.
I'm buying bread.
🔹 DOKONANY — Perfective (result, completion):
Przeczytam książkę.
I will read the book.
Zrobię zadanie.
I will do the task.
Kupię chleb.
I will buy bread.""",
},
"tags": ["rule", "grammar", "verb", "aspect"],
},
# 23. БЕЗЛИЧНЫЕ КОНСТРУКЦИИ
{
"title": {
"pl": "Konstrukcje bezosobowe: trzeba, można, warto",
"ru": "Безличные конструкции: trzeba, można, warto",
"uk": "Безособові конструкції: trzeba, można, warto",
"en": "Impersonal constructions: trzeba, można, warto",
},
"content": {
"pl": """Te wyrażenia łączą się z bezokolicznikiem i nie odmieniają się przez osoby – opisują sytuację ogólną, a nie konkretną osobę.
📌 trzeba – konieczność
📌 można – możliwość, pozwolenie
📌 nie można – zakaz
📌 warto – opłacalność, dobra rada
📌 należy – konieczność (styl formalny)""",
"ru": """Эти выражения сочетаются с инфинитивом и не изменяются по лицам – они описывают общую ситуацию, а не конкретного человека.
📌 trzeba – необходимость
📌 można – возможность, разрешение
📌 nie można – запрет
📌 warto – целесообразность, хороший совет
📌 należy – необходимость (формальный стиль)""",
"uk": """Ці вирази поєднуються з інфінітивом і не змінюються за особами – вони описують загальну ситуацію, а не конкретну людину.
📌 trzeba – необхідність
📌 można – можливість, дозвіл
📌 nie można – заборона
📌 warto – доцільність, хороша порада
📌 należy – необхідність (формальний стиль)""",
"en": """These expressions combine with an infinitive and do not change by person – they describe a general situation rather than a specific person.
📌 trzeba – necessity
📌 można – possibility, permission
📌 nie można – prohibition
📌 warto – it's worthwhile, good advice
📌 należy – necessity (formal style)""",
},
"example": {
"pl": """Trzeba więcej pić wody.
Trzeba było wcześniej wyjść.
Można tu parkować.
Nie można tu palić.
Warto odwiedzić Kraków.
Warto było przyjść wcześniej.
Należy przestrzegać zasad.""",
"ru": """Trzeba więcej pić wody.
Нужно больше пить воды.
Trzeba było wcześniej wyjść.
Нужно было выйти раньше.
Można tu parkować.
Здесь можно парковаться.
Nie można tu palić.
Здесь нельзя курить.
Warto odwiedzić Kraków.
Стоит посетить Краков.
Warto było przyjść wcześniej.
Стоило прийти раньше.
Należy przestrzegać zasad.
Следует соблюдать правила.""",
"uk": """Trzeba więcej pić wody.
Потрібно більше пити води.
Trzeba było wcześniej wyjść.
Треба було вийти раніше.
Można tu parkować.
Тут можна паркуватися.
Nie można tu palić.
Тут не можна палити.
Warto odwiedzić Kraków.
Варто відвідати Краків.
Warto było przyjść wcześniej.
Варто було прийти раніше.
Należy przestrzegać zasad.
Слід дотримуватися правил.""",
"en": """Trzeba więcej pić wody.
One needs to drink more water.
Trzeba było wcześniej wyjść.
We should have left earlier.
Można tu parkować.
You can park here.
Nie można tu palić.
You can't smoke here.
Warto odwiedzić Kraków.
It's worth visiting Kraków.
Warto było przyjść wcześniej.
It would have been worth coming earlier.
Należy przestrzegać zasad.
The rules must be followed.""",
},
"tags": ["rule", "grammar", "impersonal"],
},
# 24. УСЛОВНОЕ НАКЛОНЕНИЕ
{
"title": {
"pl": "Tryb przypuszczający",
"ru": "Условное наклонение",
"uk": "Умовний спосіб",
"en": "Conditional mood",
},
"content": {
"pl": """Trybu przypuszczającego używamy do wyrażania sytuacji możliwych, hipotetycznych, życzeń i warunków.
📌 Tworzenie: forma czasu przeszłego + cząstka „by".
📌 Formy: bym, byś, by, byśmy, byście, by.
📌 Cząstka „by" może łączyć się z czasownikiem lub innymi wyrazami w zdaniu.
💡 Skąd się bierze forma typu „poszedł"? To forma czasu przeszłego (przeszły). Najpierw tworzymy czas przeszły (np. „poszedłem"), a potem dodajemy cząstkę „by" („poszedłbym").""",
"ru": """Условное наклонение используется для выражения возможных и гипотетических ситуаций, пожеланий и условий.
📌 Образование: форма прошедшего времени + частица „by".
📌 Формы: bym, byś, by, byśmy, byście, by.
📌 Частица „by" может соединяться с глаголом или другими словами в предложении.
💡 Откуда берётся форма типа „poszedł"? Это форма прошедшего времени. Сначала образуем прошедшее время (например, „poszedłem"), а потом добавляем частицу „by" („poszedłbym").""",
"uk": """Умовний спосіб використовуємо для вираження можливих і гіпотетичних ситуацій, побажань та умов.
📌 Утворення: форма минулого часу + частка „by".
📌 Форми: bym, byś, by, byśmy, byście, by.
📌 Частка „by" може поєднуватися з дієсловом або іншими словами в реченні.
💡 Звідки береться форма типу „poszedł"? Це форма минулого часу. Спочатку утворюємо минулий час (наприклад, „poszedłem"), а потім додаємо частку „by" („poszedłbym").""",
"en": """The conditional mood is used for possible and hypothetical situations, wishes and conditions.
📌 Formation: past tense form + the particle „by".
📌 Forms: bym, byś, by, byśmy, byście, by.
📌 The particle „by" can attach to the verb or occur with other words in the sentence.
💡 Where does a form like „poszedł" come from? It is the past tense form. First we form the past tense (e.g. „poszedłem"), and then we add the particle „by" („poszedłbym").""",
},
"example": {
"pl": """Ja bym poszedł do kina.
Ty byś poszedł ze mną.
On by kupił samochód.
Ona by została w domu.
My byśmy pojechali nad morze.
Wy byście zobaczyli Warszawę.
Oni by przyszli wcześniej.
Gdybym miał czas, pojechałbym do Krakowa.""",
"ru": """Tryb przypuszczający — Условное наклонение:
Ja bym poszedł do kina.
Я бы пошёл в кино.
Ty byś poszedł ze mną.
Ты бы пошёл со мной.
On by kupił samochód.
Он бы купил машину.
Ona by została w domu.
Она бы осталась дома.
My byśmy pojechali nad morze.
Мы бы поехали к морю.
Wy byście zobaczyli Warszawę.
Вы бы увидели Варшаву.
Oni by przyszli wcześniej.
Они бы пришли раньше.
Gdybym miał czas, pojechałbym do Krakowa.
Если бы у меня было время, я бы поехал в Краков.""",
"uk": """Tryb przypuszczający — Умовний спосіб:
Ja bym poszedł do kina.
Я б пішов у кіно.
Ty byś poszedł ze mną.
Ти б пішов зі мною.
On by kupił samochód.
Він би купив автомобіль.
Ona by została w domu.
Вона б залишилася вдома.
My byśmy pojechali nad morze.
Ми б поїхали до моря.
Wy byście zobaczyli Warszawę.
Ви б побачили Варшаву.
Oni by przyszli wcześniej.
Вони б прийшли раніше.
Gdybym miał czas, pojechałbym do Krakowa.
Якби я мав час, я б поїхав до Кракова.""",
"en": """Tryb przypuszczający — Conditional mood:
Ja bym poszedł do kina.
I would go to the cinema.
Ty byś poszedł ze mną.
You would go with me.
On by kupił samochód.
He would buy a car.
Ona by została w domu.
She would stay at home.
My byśmy pojechali nad morze.
We would go to the seaside.
Wy byście zobaczyli Warszawę.
You would see Warsaw.
Oni by przyszli wcześniej.
They would come earlier.
Gdybym miał czas, pojechałbym do Krakowa.
If I had time, I would go to Kraków.""",
},
"tags": ["rule", "grammar", "conditional"],
},
# 25. MĘSKOOSOBOWY
{
"title": {
"pl": "Formy męskoosobowe w mianowniku liczby mnogiej",
"ru": "Мужские личные формы (именительный падеж, мн. число)",
"uk": "Чоловічо-особові форми в називному відмінку множини",
"en": "Masculine-personal forms in the nominative plural",
},
"content": {
"pl": """Gdy mówimy o grupie mężczyzn (lub grupie mieszanej z co najmniej jednym mężczyzną), rzeczowniki i przymiotniki w mianowniku liczby mnogiej mają specjalną formę męskoosobową. Często towarzyszy jej zmiękczenie ostatniej spółgłoski tematu.
📌 -t → -ci (student → studenci)
📌 -d → -dzi (sąsiad → sąsiedzi)
📌 -k, -g → -cy, -dzy (Polak → Polacy, kolega → koledzy)
📌 -r → -rzy (aktor → aktorzy)
⚠️ To jedna z trudniejszych części gramatyki – wiele form trzeba po prostu zapamiętać.""",
"ru": """Когда говорим о группе мужчин (или смешанной группе, где есть хотя бы один мужчина), существительные и прилагательные в именительном падеже множественного числа имеют особую форму мужского рода. Часто её сопровождает смягчение последнего согласного основы.
📌 -t → -ci (student → studenci)
📌 -d → -dzi (sąsiad → sąsiedzi)
📌 -k, -g → -cy, -dzy (Polak → Polacy, kolega → koledzy)
📌 -r → -rzy (aktor → aktorzy)
⚠️ Это одна из самых сложных частей грамматики – многие формы нужно просто запомнить.""",
"uk": """Коли говоримо про групу чоловіків (або змішану групу, де є хоча б один чоловік), іменники та прикметники в називному відмінку множини мають особливу чоловічо-особову форму. Часто її супроводжує пом'якшення останнього приголосного основи.
📌 -t → -ci (student → studenci)
📌 -d → -dzi (sąsiad → sąsiedzi)
📌 -k, -g → -cy, -dzy (Polak → Polacy, kolega → koledzy)
📌 -r → -rzy (aktor → aktorzy)
⚠️ Це одна з найскладніших частин граматики – багато форм потрібно просто запам'ятати.""",
"en": """When talking about a group of men (or a mixed group including at least one man), nouns and adjectives in the nominative plural take a special masculine-personal form. This is often accompanied by softening of the stem's final consonant.
📌 -t → -ci (student → studenci)
📌 -d → -dzi (sąsiad → sąsiedzi)
📌 -k, -g → -cy, -dzy (Polak → Polacy, kolega → koledzy)
📌 -r → -rzy (aktor → aktorzy)
⚠️ This is one of the trickier parts of the grammar – many forms simply need to be memorized.""",
},
"example": {
"pl": """🔹 Rzeczowniki:
student → studenci
sąsiad → sąsiedzi
Polak → Polacy
kolega → koledzy
aktor → aktorzy
🔹 Przymiotniki:
dobry → dobrzy
młody → młodzi
wysoki → wysocy
Ci studenci są bardzo zdolni.
Nasi sąsiedzi są mili.
To są dobrzy aktorzy.""",
"ru": """🔹 Rzeczowniki — Существительные:
student → studenci
студент → студенты
sąsiad → sąsiedzi
сосед → соседи
Polak → Polacy
поляк → поляки
kolega → koledzy
коллега → коллеги
aktor → aktorzy
актёр → актёры
🔹 Przymiotniki — Прилагательные:
dobry → dobrzy (хороший → хорошие)
młody → młodzi (молодой → молодые)
wysoki → wysocy (высокий → высокие)
Ci studenci są bardzo zdolni.
Эти студенты очень способные.
Nasi sąsiedzi są mili.
Наши соседи приветливые.
To są dobrzy aktorzy.
Это хорошие актёры.""",
"uk": """🔹 Rzeczowniki — Іменники:
student → studenci
студент → студенти
sąsiad → sąsiedzi
сусід → сусіди
Polak → Polacy
поляк → поляки
kolega → koledzy
колега → колеги
aktor → aktorzy
актор → актори
🔹 Przymiotniki — Прикметники:
dobry → dobrzy (добрий → добрі)
młody → młodzi (молодий → молоді)
wysoki → wysocy (високий → високі)
Ci studenci są bardzo zdolni.
Ці студенти дуже здібні.
Nasi sąsiedzi są mili.
Наші сусіди приємні.
To są dobrzy aktorzy.
Це хороші актори.""",
"en": """🔹 Rzeczowniki — Nouns:
student → studenci (student → students)
sąsiad → sąsiedzi (neighbor → neighbors)
Polak → Polacy (Pole → Poles)
kolega → koledzy (colleague → colleagues)
aktor → aktorzy (actor → actors)
🔹 Przymiotniki — Adjectives:
dobry → dobrzy (good)
młody → młodzi (young)
wysoki → wysocy (tall)
Ci studenci są bardzo zdolni.
These students are very talented.
Nasi sąsiedzi są mili.
Our neighbors are nice.
To są dobrzy aktorzy.
These are good actors.""",
},
"tags": ["rule", "grammar", "noun", "masculine"],
},
]
+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
+2523
View File
File diff suppressed because it is too large Load Diff