Files
filwordspl-backend/routers/teacher.py

1438 lines
63 KiB
Python
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
# 🔧 ФИКС (05.10.2026): max_tokens_for_v4_pro —
# DeepSeek V4 Pro — reasoning-модель, ~80% токенов уходит в reasoning_content,
# только 20% — в content. Увеличили max_tokens в 3 раза, чтобы избежать
# обрезки (finish_reason='length') и пустого content.
#
# 🔧 ФИКС (05.10.2026): disable_reasoning_for_fast_tasks —
# Для простых задач (переводы, объяснения, примеры) reasoning не нужен,
# добавляем reasoning_effort="none" в call_ai. Это экономит токены
# и ускоряет ответ в 3-4 раза.
"""
Teacher Router — гибридный чат-учитель.
Контент из БД (бесплатно), AI только для реакций и пробелов.
Типы сообщений:
1. Объяснение — из learning_lessons
2. Вопрос recognition — кнопки A/B/C/D
3. Вопрос production — поле ввода
4. Реакция — шаблон + wrong_because_explanations (без AI)
5. AI-сообщение — только по явному триггеру
Слэш-команды:
- /start — начать урок
- /resume — восстановить сессию
- /answer — проверить ответ
- /explain — AI-объяснение
- /examples — 5 примеров по теме (после теста темы)
- /free-message — свободное сообщение
- /diagnostic-test — тест на определение уровня
- /translate-to-polish — перевод на польский
"""
import logging
import json
import httpx
import re
import unicodedata
from datetime import datetime, timezone
from fastapi import APIRouter, Request, HTTPException
from auth import require_auth
from database import get_pool
from config import TOGETHER_API_KEY, ADMIN_IDS
from .orchestrator import (
get_next_lesson,
get_lesson_by_id,
get_lesson_questions,
get_test_questions,
get_random_reaction,
get_wrong_because_explanation,
)
logger = logging.getLogger(__name__)
router = APIRouter(prefix="/teacher", tags=["teacher"])
TOGETHER_API_URL = "https://api.together.xyz/v1/chat/completions"
TEACHER_MODEL = "deepseek-ai/DeepSeek-V4-Pro-0813"
TEACHER_AI_DAILY_LIMIT = 5
def get_ai_limit_message(lang: str) -> str:
"""Возвращает локализованное сообщение о исчерпании AI-лимита."""
messages = {
"pl": "Dziś wykorzystałeś już limit AI-pomocy. Wróć jutro!",
"ru": "Сегодня ты использовал лимит AI-помощи. Возвращайся завтра!",
"uk": "Сьогодні ти використав ліміт AI-допомоги. Повертайся завтра!",
"en": "You've used your AI help limit today. Come back tomorrow!",
}
return messages.get(lang, messages["en"])
def normalize_answer(text: str) -> str:
"""Нормализует ответ: нижний регистр, убирает диакритику и пунктуацию."""
if not text:
return ""
text = text.strip().lower()
text = re.sub(r'[.,!?;:()\[\]{}"\'\-—–…]', '', text)
text = unicodedata.normalize('NFKD', text)
text = ''.join(c for c in text if not unicodedata.combining(c))
text = ' '.join(text.split())
return text
async def get_user_lang(conn, user_id: int) -> str:
"""Получает язык интерфейса пользователя."""
lang = await conn.fetchval("""
SELECT app_language FROM users WHERE telegram_id = $1
""", user_id)
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:
"""Получает количество 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("""
SELECT command_count FROM teacher_ai_usage
WHERE user_id = $1 AND usage_date = CURRENT_DATE
""", user_id)
return count or 0
async def increment_teacher_ai_usage(conn, user_id: int) -> None:
"""Увеличивает счётчик AI-команд учителя за сегодня."""
await conn.execute("""
INSERT INTO teacher_ai_usage (user_id, usage_date, command_count)
VALUES ($1, CURRENT_DATE, 1)
ON CONFLICT (user_id, usage_date)
DO UPDATE SET command_count = teacher_ai_usage.command_count + 1
""", user_id)
async def check_ai_limit(conn, user_id: int) -> bool:
"""Проверяет, может ли пользователь использовать AI-команду."""
# 🔧 (03.11.2026): лимит временно отключён — Oleg тестирует раздел.
# Вернём лимит (TEACHER_AI_DAILY_LIMIT) перед запуском для реальных юзеров.
return True
async def start_learning_session(conn, user_id: int, level_code: str, topic_id: str, session_type: str) -> int:
"""Создаёт сессию обучения и возвращает session_id."""
row = await conn.fetchrow("""
INSERT INTO learning_sessions (user_id, level_code, topic_id, session_type)
VALUES ($1, $2, $3, $4) RETURNING id
""", user_id, level_code, topic_id, session_type)
return row["id"]
async def save_answer_to_session(conn, user_id: int, session_id: int, question_data: dict, selected_answer: str, correct: bool, time_taken_ms: int = 0, hint_used: bool = False) -> None:
"""Сохраняет ответ в user_learning_answers."""
q = question_data["question"]
wrong_because = None
if not correct:
for opt in question_data.get("options", []):
if opt.get("option_key") == selected_answer and opt.get("wrong_because"):
wrong_because = opt["wrong_because"]
break
await conn.execute("""
INSERT INTO user_learning_answers (
user_id, session_id, level_code, topic_id, lesson_id,
question_id, selected_answer, correct, skill_tag,
question_type, context_type, difficulty, time_taken_ms,
hint_used, wrong_because, is_final_answer
) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, TRUE)
""",
user_id, session_id, q.get("level_code", "A1"), q.get("topic_id", ""), q.get("lesson_id"),
q["question_id"], selected_answer, correct, q["skill_tag"],
q["question_type"], q["context_type"], q["difficulty"], time_taken_ms,
hint_used, wrong_because)
async def update_mastery_after_lesson(conn, user_id: int, session_id: int) -> None:
"""Обновляет mastery и прогресс урока после завершения."""
from .learning import update_skill_mastery, update_topic_progress, update_ai_context
skill_tags = await conn.fetch("""
SELECT DISTINCT skill_tag FROM user_learning_answers WHERE session_id = $1
""", session_id)
for st in skill_tags:
await update_skill_mastery(conn, user_id, st["skill_tag"])
session = await conn.fetchrow("SELECT * FROM learning_sessions WHERE id = $1", session_id)
if session and session["session_type"] == "teacher_lesson":
lesson_row = await conn.fetchrow("""
SELECT DISTINCT lesson_id FROM user_learning_answers
WHERE session_id = $1 AND lesson_id IS NOT NULL
""", session_id)
if lesson_row and lesson_row["lesson_id"]:
lesson_id = lesson_row["lesson_id"]
stats = await conn.fetchrow("""
SELECT COUNT(*) as total,
COALESCE(SUM(CASE WHEN correct THEN 1 ELSE 0 END), 0) as correct_count
FROM user_learning_answers
WHERE session_id = $1 AND is_final_answer = TRUE
""", session_id)
total = stats["total"] if stats["total"] else 0
correct_count = stats["correct_count"] if stats["correct_count"] else 0
score = round((correct_count / total * 100), 2) if total > 0 else 0
await conn.execute("""
INSERT INTO user_lesson_progress (user_id, lesson_id, started_at, completed_at, attempts_count, correct_count, best_score, completed)
VALUES ($1, $2, NOW(), NOW(), 1, $3, $4, TRUE)
ON CONFLICT (user_id, lesson_id) DO UPDATE
SET completed_at = NOW(),
attempts_count = user_lesson_progress.attempts_count + 1,
correct_count = user_lesson_progress.correct_count + $3,
best_score = GREATEST(user_lesson_progress.best_score, $4),
completed = TRUE
""", user_id, lesson_id, correct_count, score)
if session and session["topic_id"]:
if session["session_type"] == "teacher_test":
stats = await conn.fetchrow("""
SELECT COUNT(*) as total,
COALESCE(SUM(CASE WHEN correct THEN 1 ELSE 0 END), 0) as correct_count
FROM user_learning_answers
WHERE session_id = $1 AND is_final_answer = TRUE
""", session_id)
total = stats["total"] if stats["total"] else 0
correct_count = stats["correct_count"] if stats["correct_count"] else 0
test_score = round((correct_count / total * 100), 2) if total > 0 else 0
await conn.execute("""
INSERT INTO user_topic_progress (user_id, topic_id, test_started, test_completed, test_score, completed_at)
VALUES ($1, $2, TRUE, TRUE, $3, NOW())
ON CONFLICT (user_id, topic_id) DO UPDATE
SET test_completed = TRUE,
test_score = $3,
completed_at = NOW()
""", user_id, session["topic_id"], test_score)
await update_topic_progress(conn, user_id, session["topic_id"])
await update_ai_context(conn, user_id)
async def call_ai(prompt: str, system_prompt: str, max_tokens: int = 500) -> str:
"""Вызывает AI и возвращает ответ."""
if not TOGETHER_API_KEY:
return ""
try:
async with httpx.AsyncClient(timeout=90.0) as client:
response = await client.post(
TOGETHER_API_URL,
headers={
"Authorization": f"Bearer {TOGETHER_API_KEY}",
"Content-Type": "application/json",
},
json={
"model": TEACHER_MODEL,
"messages": [
{"role": "system", "content": system_prompt},
{"role": "user", "content": prompt},
],
"max_tokens": max_tokens,
"temperature": 0.7,
# 🔧 ФИКС (05.10.2026): disable_reasoning_for_fast_tasks —
# V4 Pro — reasoning-модель, тратит 80% токенов на «мысли»
# (reasoning_content) и 20-30 секунд на ответ.
# Для фразы дня и переводов reasoning не нужен → отключаем.
"reasoning_effort": "none",
},
)
if response.status_code != 200:
logger.error(f"AI API error: {response.status_code}, body={response.text[:200]}")
return ""
data = response.json()
# 🔧 ФИКС (22.09.2026): безопасно извлекаем content.
# Together AI может вернуть reasoning_content или пустой content.
try:
message = data["choices"][0]["message"]
ai_response = message.get("content") or message.get("reasoning_content") or ""
except (KeyError, IndexError, TypeError) as e:
logger.error(f"AI response format error: {e}, data={str(data)[:300]}")
return ""
if not ai_response:
logger.warning(f"AI returned empty content. finish_reason={data.get('choices', [{}])[0].get('finish_reason')}")
return ""
ai_response = ai_response.strip()
ai_response = re.sub(r'\s*\([a-z_]+_[a-z_]+\)', '', ai_response)
# 🔧 ФИКС (03.11.2026): убираем длинные тире (— и –) — заменяем на дефис.
ai_response = ai_response.replace('—', '-').replace('–', '-')
return ai_response
except Exception as e:
logger.error(f"AI error: {str(e)}")
return ""
async def get_wrong_answer_ai_explanation(telegram_id: int, lang: str, prompt_text: str, selected_answer: str, correct_answer_text: str) -> str:
"""
Получает AI-объяснение для неправильного ответа.
Проверяет лимит и инкрементирует счётчик.
Если лимит исчерпан — возвращает локализованное сообщение.
"""
pool = await get_pool()
async with pool.acquire() as conn:
if not await check_ai_limit(conn, telegram_id):
return get_ai_limit_message(lang)
ai_prompt = f"""Вопрос: {prompt_text}
Ответ ученика: {selected_answer}
Правильный ответ: {correct_answer_text}
Объясни кратко (1-2 предложения), почему правильный ответ именно такой."""
system_prompt = f"""Ты — Марек, учитель польского языка. Объясняй ошибки кратко и понятно.
Отвечай на языке: {lang}. Не используй markdown."""
# 🔧 ФИКС (05.10.2026): max_tokens_for_v4_pro — 200 → 600
ai_response = await call_ai(ai_prompt, system_prompt, max_tokens=600)
if ai_response:
async with pool.acquire() as conn:
await increment_teacher_ai_usage(conn, telegram_id)
else:
# 🔧 ФИКС (25.09.2026): teacher_ai_explanation_empty_on_failure —
# если AI упал и лимит НЕ исчерпан, возвращаем нейтральный fallback,
# а не пустую строку (иначе ученик не понимает, почему ошибся).
if not await _check_ai_limit_for_fallback(telegram_id, lang):
ai_response = get_ai_limit_message(lang)
else:
# Нейтральный fallback на 4 языках
fallbacks = {
"pl": "Zastanów się nad tym pytaniem jeszcze raz.",
"ru": "Подумай над этим вопросом ещё раз.",
"uk": "Поміркуй над цим питанням ще раз.",
"en": "Think about this question again.",
}
ai_response = fallbacks.get(lang, fallbacks["en"])
return ai_response
async def _check_ai_limit_for_fallback(telegram_id: int, lang: str) -> bool:
"""Проверяет, был ли лимит исчерпан (для fallback-сообщения)."""
pool = await get_pool()
async with pool.acquire() as conn:
return await check_ai_limit(conn, telegram_id)
# ============ ФРАЗА ДНЯ ============
@router.get("/phrase-of-day")
async def get_phrase_of_day(request: Request):
"""
Возвращает фразу дня.
Фраза кэшируется для всех пользователей на 24 часа.
Не тратит AI-лимит пользователя.
"""
telegram_id, _ = await require_auth(request)
pool = await get_pool()
async with pool.acquire() as conn:
lang = await get_user_lang(conn, telegram_id)
# 🔧 ФИКС (23.09.2026): teacher_create_table_on_every_request —
# DDL перенесён в database.py::init_db(). Раньше выполнялся на КАЖДЫЙ
# GET /teacher/phrase-of-day. Теперь — только при старте приложения.
today = datetime.now(timezone.utc).date()
today_phrase = await conn.fetchrow("""
SELECT * FROM daily_phrases WHERE phrase_date = $1
""", today)
if not today_phrase:
# Список тем для фразы дня
topics_list = [
"приветствие и знакомство",
"семья и друзья",
"еда и напитки",
"покупки и магазины",
"транспорт и путешествия",
"работа и профессии",
"погода и времена года",
"дом и квартира",
"хобби и свободное время",
"здоровье и самочувствие",
"город и местность",
"ежедневная рутина"
]
# Выбираем случайную тему
import random
selected_topic = random.choice(topics_list)
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}."
# 🔧 ФИКС (05.10.2026): max_tokens_for_v4_pro — 1000 → 3000
ai_response = await call_ai(user_prompt, system_prompt, max_tokens=3000)
# Fallback значения
phrase_pl = "Lepiej późno niż wcale."
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))
today_phrase = await conn.fetchrow("""
SELECT * FROM daily_phrases WHERE phrase_date = $1
""", today)
translations = today_phrase["translations"]
grammar_breakdowns = today_phrase["grammar_breakdowns"]
if isinstance(translations, str):
translations = json.loads(translations)
if isinstance(grammar_breakdowns, str):
grammar_breakdowns = json.loads(grammar_breakdowns)
result = {
"phrase_pl": today_phrase["phrase_pl"],
"date": today_phrase["phrase_date"].isoformat() if today_phrase["phrase_date"] else None,
}
if lang != "pl":
result["translation"] = translations.get(lang, translations.get("en", ""))
result["grammar_breakdown"] = grammar_breakdowns.get(lang, grammar_breakdowns.get("en", ""))
return result
@router.post("/resume")
async def teacher_resume(request: Request):
"""
Восстанавливает активную сессию.
Проверяет, есть ли незавершённая сессия и возвращает текущий вопрос.
"""
telegram_id, _ = await require_auth(request)
pool = await get_pool()
async with pool.acquire() as conn:
lang = await get_user_lang(conn, telegram_id)
session = await conn.fetchrow("""
SELECT * FROM learning_sessions
WHERE user_id = $1 AND is_completed = FALSE
ORDER BY id DESC
LIMIT 1
""", telegram_id)
if not session:
return {"has_active_session": False}
last_answer = await conn.fetchrow("""
SELECT question_id FROM user_learning_answers
WHERE session_id = $1
ORDER BY id DESC
LIMIT 1
""", session["id"])
if not last_answer:
if session["session_type"] == "teacher_test":
questions = await get_test_questions(conn, session["topic_id"])
else:
# 🔧 ФИКС (22.09.2026): learning_sessions не хранит lesson_id.
# Берём lesson_id из первого вопроса урока через topic_id сессии.
# Находим первый урок темы, чтобы восстановить сессию.
lesson_id = await conn.fetchval("""
SELECT lesson_id FROM learning_lessons
WHERE topic_id = $1 AND is_active = TRUE
ORDER BY order_number
LIMIT 1
""", session["topic_id"])
if lesson_id:
questions = await get_lesson_questions(conn, lesson_id)
else:
questions = []
if questions:
return {
"has_active_session": True,
"session_id": session["id"],
"session_type": session["session_type"],
"topic_id": session["topic_id"],
"question": questions[0],
"question_index": 0,
"total_questions": len(questions),
}
return {"has_active_session": False}
if session["session_type"] == "teacher_test":
questions = await get_test_questions(conn, session["topic_id"])
else:
lesson_id = await conn.fetchval("""
SELECT lesson_id FROM user_learning_answers
WHERE session_id = $1 AND lesson_id IS NOT NULL
LIMIT 1
""", session["id"])
if lesson_id:
questions = await get_lesson_questions(conn, lesson_id)
else:
questions = []
last_question_id = last_answer["question_id"]
last_index = 0
for i, q in enumerate(questions):
if q["question"]["question_id"] == last_question_id:
last_index = i
break
next_index = last_index + 1
if next_index >= len(questions):
await conn.execute("""
UPDATE learning_sessions SET is_completed = TRUE, completed_at = NOW()
WHERE id = $1
""", session["id"])
await update_mastery_after_lesson(conn, telegram_id, session["id"])
return {"has_active_session": False, "session_completed": True}
next_question = questions[next_index]
return {
"has_active_session": True,
"session_id": session["id"],
"session_type": session["session_type"],
"topic_id": session["topic_id"],
"question": next_question,
"question_index": next_index,
"total_questions": len(questions),
}
@router.post("/start")
async def teacher_start(request: Request):
"""
Начинает или продолжает урок.
Возвращает первое сообщение от учителя.
"""
telegram_id, username = await require_auth(request)
pool = await get_pool()
async with pool.acquire() as conn:
lang = await get_user_lang(conn, telegram_id)
first_name = username or "uczniu"
next_lesson = await get_next_lesson(conn, telegram_id)
if next_lesson["type"] == "completed":
return {
"message_type": "completed",
"text": "Wszystkie lekcje ukończone! Świetna robota!" if lang == "pl" else
"Все уроки пройдены! Отличная работа!" if lang == "ru" else
"Всі уроки пройдені! Чудова робота!" if lang == "uk" else
"All lessons completed! Great job!",
}
if next_lesson["type"] == "test":
topic_id = next_lesson.get("topic_id")
test_questions = await get_test_questions(conn, topic_id)
if not test_questions:
return {
"message_type": "error",
"text": "No test questions found.",
}
# 🔧 ФИКС (23.09.2026): teacher_hardcoded_a1_level — брали "A1" хардкодом,
# даже если юзер на B1/C1. Теперь реальный уровень из users.
user_level = await conn.fetchval(
"SELECT current_level FROM users WHERE telegram_id = $1", telegram_id
) or "A1"
session_id = await start_learning_session(conn, telegram_id, user_level, topic_id, "teacher_test")
first_question = test_questions[0]
return {
"message_type": "test_start",
"session_id": session_id,
"topic_id": topic_id,
"topic_name": "",
"text": "Czas na test!" if lang == "pl" else
"Время теста!" if lang == "ru" else
"Час тесту!" if lang == "uk" else
"Test time!",
"question": first_question,
"question_index": 0,
"total_questions": len(test_questions),
"has_translate_command": True,
}
lesson_id = next_lesson["lesson"]["lesson_id"]
lesson_data = await get_lesson_by_id(conn, lesson_id)
if not lesson_data:
return {
"message_type": "error",
"text": "Lesson not found.",
}
# 🔧 ФИКС (23.09.2026): teacher_hardcoded_a1_level — реальный уровень из users.
user_level = await conn.fetchval(
"SELECT current_level FROM users WHERE telegram_id = $1", telegram_id
) or "A1"
session_id = await start_learning_session(
conn, telegram_id, user_level, lesson_data["lesson"]["topic_id"], "teacher_lesson"
)
lesson = lesson_data["lesson"]
examples = lesson_data["examples"]
explanation_field = f"explanation_{lang}"
title_field = f"title_{lang}"
explanation_text = lesson.get(explanation_field) or lesson.get("explanation_en") or ""
title_text = lesson.get(title_field) or lesson.get("title_en") or ""
examples_text = ""
for ex in examples:
ex_field = f"text_{lang}"
ex_translation = ex.get(ex_field) or ex.get("text_en") or ""
examples_text += f"🇵🇱 {ex['text_pl']} → {ex_translation}\n"
full_text = f"{title_text}\n\n{explanation_text}"
if examples_text:
full_text += f"\n\nPrzykłady:\n{examples_text}"
questions = lesson_data["questions"]
first_question = questions[0] if questions else None
if not first_question:
return {
"message_type": "lesson_completed",
"session_id": session_id,
"text": "Lekcja zakończona!" if lang == "pl" else
"Урок завершён!" if lang == "ru" else
"Урок завершено!" if lang == "uk" else
"Lesson completed!",
}
return {
"message_type": "lesson_explanation",
"session_id": session_id,
"lesson_id": lesson_id,
"topic_id": lesson_data["lesson"]["topic_id"],
"topic_name": title_text,
"text": full_text,
"question": first_question,
"question_index": 0,
"total_questions": len(questions),
"has_explain_command": True,
"has_translate_command": True,
}
@router.post("/answer")
async def teacher_answer(request: Request):
"""
Проверяет ответ пользователя и возвращает реакцию + следующий вопрос.
"""
telegram_id, _ = await require_auth(request)
body = await request.json()
session_id = body.get("session_id")
question_id = body.get("question_id")
selected_answer = body.get("answer", "")
time_taken_ms = body.get("time_taken_ms", 0)
if not session_id or not question_id:
raise HTTPException(400, "session_id and question_id required")
pool = await get_pool()
async with pool.acquire() as conn:
lang = await get_user_lang(conn, telegram_id)
question_row = await conn.fetchrow("""
SELECT * FROM learning_questions WHERE question_id = $1
""", question_id)
if not question_row:
raise HTTPException(404, "Question not found")
options = await conn.fetch("""
SELECT * FROM question_options WHERE question_id = $1
""", question_id)
# 🔧 ФИКС (25.09.2026): teacher_answer_missing_session_owner_check —
# сессия грузилась без проверки владельца, и это позволяло атакующему
# записать мусорные ответы в чужую сессию через save_answer_to_session
# ДО того, как мы поймали IDOR. Теперь проверяем ВЛАДЕЛЬЦА СЕССИИ
# ПЕРЕД любой записью в БД — fail fast, никаких побочных эффектов.
session = await conn.fetchrow(
"SELECT * FROM learning_sessions WHERE id = $1 AND user_id = $2",
session_id, telegram_id
)
if not session:
raise HTTPException(404, "Session not found or access denied")
correct_answer = question_row["correct_answer"] or ""
is_correct = normalize_answer(selected_answer) == normalize_answer(correct_answer)
wrong_because = None
for opt in options:
if opt["option_key"] == selected_answer and not is_correct and opt.get("wrong_because"):
wrong_because = opt["wrong_because"]
break
question_data = {
"question": dict(question_row),
"options": [dict(o) for o in options],
}
# Только теперь безопасно записываем ответ в user_learning_answers
await save_answer_to_session(
conn, telegram_id, session_id, question_data,
selected_answer, is_correct, time_taken_ms
)
if is_correct:
reaction_type = "correct"
else:
reaction_type = "wrong" if wrong_because else "almost"
reaction_text = await get_random_reaction(conn, reaction_type, lang)
db_explanation = ""
if not is_correct and wrong_because:
db_explanation = await get_wrong_because_explanation(conn, wrong_because, lang)
if session["session_type"] == "teacher_test":
questions = await get_test_questions(conn, session["topic_id"])
else:
lesson_id = question_row["lesson_id"]
if lesson_id:
questions = await get_lesson_questions(conn, lesson_id)
else:
questions = []
current_index = 0
for i, q in enumerate(questions):
if q["question"]["question_id"] == question_id:
current_index = i
break
next_index = current_index + 1
options_language = question_row.get("options_language") or "pl"
correct_answer_text = ""
for opt in options:
if opt["is_correct"]:
if options_language == "user":
correct_answer_text = opt.get(f"text_{lang}", "") or opt.get("text_pl", "") or ""
else:
correct_answer_text = opt.get("text_pl", "") or opt.get("text_ru", "") or ""
break
prompt_text = question_row.get(f"prompt_{lang}") or question_row.get("prompt_en") or ""
needs_ai_explanation = not is_correct and not db_explanation
session_completed = next_index >= len(questions)
next_question_data = None if session_completed else questions[next_index]
if session_completed:
stats = await conn.fetchrow("""
SELECT COUNT(*) as total,
COALESCE(SUM(CASE WHEN correct THEN 1 ELSE 0 END), 0) as correct_count
FROM user_learning_answers
WHERE session_id = $1 AND is_final_answer = TRUE
""", session_id)
session_stats = {
"total": stats["total"] if stats["total"] else 0,
"correct_count": stats["correct_count"] if stats["correct_count"] else 0,
}
session_type = session["session_type"]
await conn.execute("""
UPDATE learning_sessions SET is_completed = TRUE, completed_at = NOW()
WHERE id = $1
""", session_id)
await update_mastery_after_lesson(conn, telegram_id, session_id)
explanation_text = db_explanation
if needs_ai_explanation:
explanation_text = await get_wrong_answer_ai_explanation(
telegram_id, lang, prompt_text, selected_answer, correct_answer_text
)
if session_completed:
return {
"message_type": "lesson_completed",
"reaction": reaction_text,
"explanation": explanation_text,
"is_correct": is_correct,
"correct_answer": correct_answer_text,
"wrong_because": wrong_because or "",
"session_completed": True,
"session_stats": session_stats,
"session_type": session_type,
}
return {
"message_type": "next_question",
"reaction": reaction_text,
"explanation": explanation_text,
"is_correct": is_correct,
"correct_answer": correct_answer_text,
"wrong_because": wrong_because or "",
"question": next_question_data,
"question_index": next_index,
"total_questions": len(questions),
"has_explain_command": not is_correct,
}
@router.post("/explain")
async def teacher_explain(request: Request):
"""
AI-объяснение текущего урока или ошибки.
"""
telegram_id, _ = await require_auth(request)
body = await request.json()
lesson_id = body.get("lesson_id", "")
question_id = body.get("question_id", "")
topic = body.get("topic", "")
pool = await get_pool()
async with pool.acquire() as conn:
lang = await get_user_lang(conn, telegram_id)
if not await check_ai_limit(conn, telegram_id):
return {
"response": "",
"limit_exceeded": True,
"message": get_ai_limit_message(lang)
}
content = ""
if lesson_id:
lesson = await conn.fetchrow("""
SELECT * FROM learning_lessons WHERE lesson_id = $1
""", lesson_id)
if lesson:
content = lesson.get(f"explanation_{lang}") or lesson.get("explanation_en") or ""
elif question_id:
question = await conn.fetchrow("""
SELECT * FROM learning_questions WHERE question_id = $1
""", question_id)
if question:
content = question.get(f"prompt_{lang}") or question.get("prompt_en") or ""
else:
content = topic
if not content:
return {"response": "", "error": "No content to explain"}
system_prompt = f"""Ты — учитель польского языка. Объясни материал простыми словами.
Отвечай на языке: {lang}. Не используй markdown."""
# 🔧 ФИКС (05.10.2026): max_tokens_for_v4_pro — добавляем 1500
ai_response = await call_ai(content, system_prompt, max_tokens=1500)
if ai_response:
async with pool.acquire() as conn:
await increment_teacher_ai_usage(conn, telegram_id)
return {"response": ai_response}
@router.post("/examples")
async def teacher_examples(request: Request):
"""
Даёт 5 примеров предложений по текущей теме.
Формат: 🇵🇱 польская фраза → перевод на язык пользователя.
AI-команда, лимит 5/день.
"""
telegram_id, _ = await require_auth(request)
body = await request.json()
topic = body.get("topic", "")
lesson_id = body.get("lesson_id", "")
topic_id = body.get("topic_id", "")
pool = await get_pool()
async with pool.acquire() as conn:
lang = await get_user_lang(conn, telegram_id)
if not await check_ai_limit(conn, telegram_id):
return {
"response": "",
"limit_exceeded": True,
"message": get_ai_limit_message(lang)
}
# Если не передан topic — берём по lesson_id
if lesson_id and not topic:
lesson = await conn.fetchrow("""
SELECT title_pl, title_ru, title_uk, title_en
FROM learning_lessons WHERE lesson_id = $1
""", lesson_id)
if lesson:
topic = lesson.get(f"title_{lang}") or lesson.get("title_en") or ""
# Если не передан topic и lesson_id — берём по topic_id
if topic_id and not topic:
topic_row = await conn.fetchrow("""
SELECT name_pl, name_ru, name_uk, name_en
FROM learning_topics WHERE topic_id = $1
""", topic_id)
if topic_row:
topic = topic_row.get(f"name_{lang}") or topic_row.get("name_en") or ""
if not topic:
topic = "polish language"
lang_names = {
"pl": "polskiego",
"ru": "русский",
"uk": "украинский",
"en": "English",
}
lang_name = lang_names.get(lang, "English")
system_prompt = f"""Ты — учитель польского языка. Дай ровно 5 примеров предложений по теме: {topic}.
Каждый пример — простое предложение уровня A2, полезное в повседневной жизни.
Формат ответа (без markdown, каждый пример с новой строки):
🇵🇱 [польское предложение] → [перевод на {lang_name}]
Пример:
🇵🇱 Jestem nauczycielem. → Я учитель.
🇵🇱 Pracuję w biurze. → Я работаю в офисе.
Верни только 5 примеров, без вступлений и пояснений."""
# 🔧 ФИКС (05.10.2026): max_tokens_for_v4_pro — 500 → 1500
ai_response = await call_ai(topic, system_prompt, max_tokens=1500)
if ai_response:
async with pool.acquire() as conn:
await increment_teacher_ai_usage(conn, telegram_id)
return {"response": ai_response}
@router.post("/free-message")
async def teacher_free_message(request: Request):
"""
Обрабатывает свободное сообщение пользователя.
"""
telegram_id, _ = await require_auth(request)
body = await request.json()
user_message = body.get("message", "").strip()
lesson_id = body.get("lesson_id", "")
topic_id = body.get("topic_id", "")
topic_name = body.get("topic_name", "")
if not user_message:
raise HTTPException(400, "message is required")
if len(user_message) > 300:
raise HTTPException(400, "Message too long (max 300 characters)")
pool = await get_pool()
async with pool.acquire() as conn:
lang = await get_user_lang(conn, telegram_id)
if not await check_ai_limit(conn, telegram_id):
usage = await get_teacher_ai_usage(conn, telegram_id)
return {
"response": "",
"limit_exceeded": True,
"message": get_ai_limit_message(lang),
"usage": usage,
"limit": TEACHER_AI_DAILY_LIMIT,
}
context_parts = []
if topic_name:
context_parts.append(f"Текущая тема урока: {topic_name}")
if lesson_id:
lesson = await conn.fetchrow("""
SELECT title_pl, title_ru, title_uk, title_en
FROM learning_lessons WHERE lesson_id = $1
""", lesson_id)
if lesson:
lesson_title = lesson.get(f"title_{lang}") or lesson.get("title_en") or ""
context_parts.append(f"Текущий урок: {lesson_title}")
context_text = "\n".join(context_parts) if context_parts else ""
# 🔧 (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}.
Не используй markdown и длинные тире (—).
{nuance_text}
{context_text}
{materials_instruction}
Ты специализируешься ТОЛЬКО на Польше: польский язык, польская история, польская культура, жизнь в Польше, польские документы и всё, что связано с Польшей.
Если вопрос НЕ касается Польши, польского языка, польской истории, польской культуры, жизни в Польше или польских документов — вежливо откажись и скажи, что ты специализируешься только на Польше и польском языке. Не отвечай на посторонние вопросы (программирование, кулинария других стран, общие знания и т.п.).
Ученик может спросить что угодно про Польшу: объяснить тему, перевести фразу, дать пример, рассказать об истории или жизни в Польше.
Отвечай кратко (1-3 предложения) и по делу."""
# 🔧 ФИКС (05.10.2026): max_tokens_for_v4_pro — 300 → 900
ai_response = await call_ai(user_message, system_prompt, max_tokens=900)
if ai_response:
async with pool.acquire() as conn:
await increment_teacher_ai_usage(conn, telegram_id)
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")
async def teacher_diagnostic_test(request: Request):
"""
Тест на определение уровня языка.
Берёт случайные вопросы разных тем и уровней.
"""
telegram_id, _ = await require_auth(request)
pool = await get_pool()
async with pool.acquire() as conn:
lang = await get_user_lang(conn, telegram_id)
questions = await conn.fetch("""
SELECT * FROM learning_questions
WHERE is_test_question = TRUE
ORDER BY RANDOM()
LIMIT 15
""")
if not questions:
return {"error": "No questions available"}
# 🔧 ФИКС (23.09.2026): teacher_hardcoded_a1_level — реальный уровень из users.
user_level = await conn.fetchval(
"SELECT current_level FROM users WHERE telegram_id = $1", telegram_id
) or "A1"
session_id = await start_learning_session(conn, telegram_id, user_level, "", "diagnostic_test")
# 🔧 ФИКС (25.09.2026): teacher_diagnostic_test_n_plus_1 —
# один запрос ANY + группировка в Python.
question_ids = [q["question_id"] for q in questions]
all_options = []
if question_ids:
all_options = await conn.fetch("""
SELECT * FROM question_options
WHERE question_id = ANY($1::text[])
""", question_ids)
options_by_q: dict = {}
for o in all_options:
options_by_q.setdefault(o["question_id"], []).append(dict(o))
questions_data = []
for q in questions:
questions_data.append({
"question": dict(q),
"options": options_by_q.get(q["question_id"], []),
})
return {
"session_id": session_id,
"questions": questions_data,
"total_questions": len(questions_data),
}
@router.post("/translate-to-polish")
async def teacher_translate_to_polish(request: Request):
"""
Переводит текст на польский язык.
AI-команда, лимит 5/день.
"""
telegram_id, _ = await require_auth(request)
body = await request.json()
text = body.get("text", "").strip()
if not text:
raise HTTPException(400, "text is required")
if len(text) > 300:
raise HTTPException(400, "Text too long (max 300 characters)")
pool = await get_pool()
async with pool.acquire() as conn:
lang = await get_user_lang(conn, telegram_id)
if not await check_ai_limit(conn, telegram_id):
return {
"response": "",
"limit_exceeded": True,
"message": get_ai_limit_message(lang)
}
system_prompt = f"""Ты — переводчик польского языка. Переведи текст на польский.
Отвечай только переводом без пояснений. Не используй markdown."""
# 🔧 ФИКС (05.10.2026): max_tokens_for_v4_pro — 300 → 900
ai_response = await call_ai(text, system_prompt, max_tokens=900)
if ai_response:
async with pool.acquire() as conn:
await increment_teacher_ai_usage(conn, telegram_id)
return {"response": ai_response}
# ============ ПРОГРЕСС ПО УРОВНЯМ ============
@router.get("/progress")
async def teacher_progress(request: Request):
"""
Возвращает прогресс пользователя по всем уровням (A1-C2).
Для каждого уровня: сколько тем пройдено из общего количества.
"""
telegram_id, _ = await require_auth(request)
pool = await get_pool()
async with pool.acquire() as conn:
levels = await conn.fetch("""
SELECT code, name_pl, name_ru, name_uk, name_en
FROM learning_levels
WHERE is_active = TRUE
ORDER BY sort_order
""")
if not levels:
return {"levels": []}
level_codes = [lvl["code"] for lvl in levels]
# 🔧 ФИКС (25.09.2026): teacher_progress_n_plus_1 —
# 2 запроса вместо 2×N.
topics_total_rows = await conn.fetch("""
SELECT level_code, COUNT(*) as cnt
FROM learning_topics
WHERE level_code = ANY($1::text[]) AND is_active = TRUE
GROUP BY level_code
""", level_codes)
topics_total_map = {r["level_code"]: r["cnt"] for r in topics_total_rows}
topics_completed_rows = await conn.fetch("""
SELECT t.level_code, COUNT(*) as cnt
FROM user_topic_progress utp
JOIN learning_topics t ON utp.topic_id = t.topic_id
WHERE utp.user_id = $1
AND utp.test_completed = TRUE
AND t.is_active = TRUE
AND t.level_code = ANY($2::text[])
GROUP BY t.level_code
""", telegram_id, level_codes)
topics_completed_map = {r["level_code"]: r["cnt"] for r in topics_completed_rows}
result = []
for level in levels:
code = level["code"]
result.append({
"code": code,
"name_pl": level["name_pl"],
"name_ru": level["name_ru"],
"name_uk": level["name_uk"],
"name_en": level["name_en"],
"topics_total": topics_total_map.get(code, 0),
"topics_completed": topics_completed_map.get(code, 0),
})
return {"levels": result}
@router.post("/history/save")
async def save_teacher_history(request: Request):
"""Сохраняет историю чата учителя на сервере."""
telegram_id, _ = await require_auth(request)
body = await request.json()
messages = body.get("messages", [])
if not isinstance(messages, list):
raise HTTPException(400, "messages must be a list")
pool = await get_pool()
async with pool.acquire() as conn:
await conn.execute("""
INSERT INTO teacher_chat_history (user_id, messages, updated_at)
VALUES ($1, $2::jsonb, NOW())
ON CONFLICT (user_id) DO UPDATE
SET messages = $2::jsonb, updated_at = NOW()
""", telegram_id, json.dumps(messages, ensure_ascii=False))
return {"status": "ok"}
@router.get("/history/load")
async def load_teacher_history(request: Request):
"""Загружает историю чата учителя с сервера."""
telegram_id, _ = await require_auth(request)
pool = await get_pool()
async with pool.acquire() as conn:
row = await conn.fetchrow("""
SELECT messages FROM teacher_chat_history WHERE user_id = $1
""", telegram_id)
if row and row["messages"]:
messages = row["messages"]
if isinstance(messages, str):
messages = json.loads(messages)
return {"messages": messages}
return {"messages": []}
@router.post("/history/clear")
async def clear_teacher_history(request: Request):
"""Очищает историю чата учителя на сервере."""
telegram_id, _ = await require_auth(request)
pool = await get_pool()
async with pool.acquire() as conn:
await conn.execute("""
DELETE FROM teacher_chat_history WHERE user_id = $1
""", telegram_id)
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}