1365 lines
59 KiB
Python
1365 lines
59 KiB
Python
# 🔧 ФИКС (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"
|
||
|
||
|
||
async def search_teacher_materials(conn, query: str, lang: str, limit: int = 3):
|
||
"""
|
||
Ищет материалы в базе знаний Pleily (teacher_materials) по запросу.
|
||
Сопоставляет теги и слова запроса с 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]
|
||
|
||
scored = []
|
||
for row in rows:
|
||
tags = row["tags"] or []
|
||
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()
|
||
|
||
score = 0
|
||
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"} |