feat(admin): уроки + AI-помощник + повторы + отчёт по теме

Backend:
- admin_ai.py: POST /admin/ai/chat + /admin/ai/translate (DeepSeek V4 Pro 0813)
  * rate limit 60/час, reasoning отключён, context support
  * перевод на 4 языка через JSON mode
- admin_content.py: CRUD уроков/тем + генератор теста
  * GET /lessons/tree — дерево уровней/тем/уроков
  * POST /lessons/topic — создание темы
  * POST /lessons/lesson — создание урока (транзакция)
  * DELETE /lessons/lesson/{id} — каскадное удаление
  * GET /lessons/topic/{id}/questions — вопросы для генератора
  * POST /lessons/test/generate — генерация теста с перемешиванием
  * POST /lessons/lesson/{id}/add-question — добавление вопроса в edit-режиме
- learning.py: attempt_number + revised + revision_of_id
  * show_correct_answer с 3-й попытки
  * session/complete возвращает report (percent, message, weak_skills, next_topic)
- learning_data/__init__.py: seed только при пустой БД
  * SEED_LEARNING_DATA=true для принудительной перезаливки
- main.py: подключение admin_ai router
- database.py: миграция revised + revision_of_id
This commit is contained in:
2026-10-02 12:47:56 +00:00
parent 8c46a78aed
commit 98ac403675
6 changed files with 1755 additions and 51 deletions
+38
View File
@@ -467,6 +467,8 @@ async def init_db():
""")
# ============ user_learning_answers ============
# 🔧 ОБНОВЛЕНО (02.10.2026): добавлены revised и revision_of_id
# прямо в определение — на свежих БД создаются сразу.
await conn.execute("""
CREATE TABLE IF NOT EXISTS user_learning_answers (
id BIGSERIAL PRIMARY KEY,
@@ -487,10 +489,46 @@ async def init_db():
hint_used BOOLEAN DEFAULT FALSE,
wrong_because VARCHAR(100),
is_final_answer BOOLEAN DEFAULT TRUE,
revised BOOLEAN DEFAULT FALSE, -- 🔧 НОВОЕ
revision_of_id BIGINT, -- 🔧 НОВОЕ
created_at TIMESTAMP DEFAULT NOW()
)
""")
# 🔧 НОВОЕ (02.10.2026): revised — фиксируем, что ученик
# поменял ответ после «Повторить урок».
col_exists = await conn.fetchval("""
SELECT 1 FROM information_schema.columns
WHERE table_name = 'user_learning_answers' AND column_name = 'revised'
""")
if not col_exists:
await conn.execute("""
ALTER TABLE user_learning_answers
ADD COLUMN revised BOOLEAN DEFAULT FALSE
""")
logger.info("Added revised column to user_learning_answers")
# 🔧 НОВОЕ (02.10.2026): revision_of_id — ссылка на предыдущий
# ответ этого же вопроса в этой же сессии. Позволяет строить
# цепочку: первый ответ → второй (после повтора) → третий.
col_exists = await conn.fetchval("""
SELECT 1 FROM information_schema.columns
WHERE table_name = 'user_learning_answers' AND column_name = 'revision_of_id'
""")
if not col_exists:
await conn.execute("""
ALTER TABLE user_learning_answers
ADD COLUMN revision_of_id BIGINT
""")
logger.info("Added revision_of_id column to user_learning_answers")
# Индекс для быстрого поиска цепочек повторов
await conn.execute("""
CREATE INDEX IF NOT EXISTS idx_learning_answers_revision
ON user_learning_answers(revision_of_id)
WHERE revision_of_id IS NOT NULL
""")
# ============ user_lesson_progress ============
await conn.execute("""
CREATE TABLE IF NOT EXISTS user_lesson_progress (
+2
View File
@@ -15,6 +15,7 @@ from config import FRONTEND_ORIGINS, UPLOADS_DIR, CF_IPS
from database import init_db
from routers import users, game, hints, leaderboard, sentences, achievements, wordquiz, bubblewords, pronunciation, assistant, learning, tts, typing, teacher, support, admin, feed, admin_content
from routers import lectures, admin_auth, admin_wordsearch, admin_users
from routers import admin_ai # 🔧 НОВОЕ
from routers.sentences import init_sentences
from routers.achievements import init_achievements
from routers.learning_data import init_learning_data
@@ -370,6 +371,7 @@ app.include_router(lectures.router)
app.include_router(admin_auth.router)
app.include_router(admin_wordsearch.router)
app.include_router(admin_users.router)
app.include_router(admin_ai.router) # 🔧 НОВОЕ
# ============ Базовые эндпоинты ============
+322
View File
@@ -0,0 +1,322 @@
"""
Admin AI Router — универсальный AI-помощник в админке.
🔧 НОВОЕ (02.10.2026): floating AI widget в admin frontend.
Использует DeepSeek V4 Pro 0813 через Together AI:
- Модель: deepseek-ai/DeepSeek-V4-Pro-0813
- Reasoning: отключён для скорости (можно включить через body)
- Rate limit: 60 запросов/час на админа
"""
import logging
import time
from collections import defaultdict
from typing import Optional
import httpx
from fastapi import APIRouter, Request, HTTPException
from auth import require_auth
from config import TOGETHER_API_KEY, ADMIN_IDS
logger = logging.getLogger(__name__)
router = APIRouter(prefix="/admin/ai", tags=["admin-ai"])
TOGETHER_API_URL = "https://api.together.xyz/v1/chat/completions"
# 🔧 НОВОЕ (02.10.2026): DeepSeek V4 Pro — flagship, 1M контекст, 30+ языков
DEFAULT_MODEL = "deepseek-ai/DeepSeek-V4-Pro-0813"
# In-memory rate limit (60/час на юзера)
_admin_ai_usage: dict[int, list[float]] = defaultdict(list)
_ADMIN_AI_RATE_LIMIT = 60
_ADMIN_AI_RATE_WINDOW = 3600 # 1 час
DEFAULT_SYSTEM_PROMPT = """Ты — помощник преподавателя польского языка в приложении Filwords PL (Telegram Mini App для изучения польского).
Помогаешь создавать учебный контент:
- Задания для уроков (recognition — выбор варианта A/B/C/D)
- Дистракторы (неправильные, но похожие по смыслу варианты)
- Переводы на польский, русский, украинский, английский
- Грамматические пояснения
ПРАВИЛА:
1. Отвечай на языке пользователя (по умолчанию — русский).
2. Не используй markdown. Просто текст.
3. Для заданий-recognition: дай РОВНО 4 варианта (A, B, C, D).
4. Один вариант — правильный (отметь явно).
5. Три других — похожие по смыслу (та же часть речи, тот же контекст).
6. Указывай wrong_because для неправильных: wrong_word, wrong_case, wrong_context, wrong_gender, wrong_sentence_type, wrong_translation.
7. Если просят перевод — дай на все 4 языка (PL, RU, UK, EN).
8. Если просят контекст из БД — используй его, не выдумывай."""
def _check_rate_limit(user_id: int) -> bool:
"""Проверка: не превысил ли админ лимит."""
now = time.time()
# Чистим старые записи
_admin_ai_usage[user_id] = [
t for t in _admin_ai_usage[user_id]
if now - t < _ADMIN_AI_RATE_WINDOW
]
return len(_admin_ai_usage[user_id]) < _ADMIN_AI_RATE_LIMIT
def _increment_usage(user_id: int) -> None:
_admin_ai_usage[user_id].append(time.time())
@router.post("/chat")
async def admin_ai_chat(request: Request):
"""
🔧 НОВОЕ (02.10.2026): admin_ai_chat —
универсальный AI-помощник в админке.
Тело:
{
"message": "Придумай 4 варианта к заданию: ...",
"system_prompt": "опционально, переопределить дефолт",
"model": "deepseek-ai/DeepSeek-V4-Pro-0813", // опционально
"reasoning": false, // опционально, по умолчанию false
"context": "опционально, длинный контекст" // например, вся тема целиком
}
Возвращает:
{
"response": "...",
"model_used": "deepseek-ai/DeepSeek-V4-Pro-0813",
"tokens_used": 123
}
"""
telegram_id, _ = await require_auth(request)
if telegram_id not in ADMIN_IDS:
raise HTTPException(403, "Access denied")
if not _check_rate_limit(telegram_id):
raise HTTPException(429, f"Rate limit exceeded ({_ADMIN_AI_RATE_LIMIT}/hour)")
if not TOGETHER_API_KEY:
raise HTTPException(500, "TOGETHER_API_KEY not configured")
body = await request.json()
message = (body.get("message") or "").strip()
system_prompt = (body.get("system_prompt") or "").strip() or DEFAULT_SYSTEM_PROMPT
model = (body.get("model") or "").strip() or DEFAULT_MODEL
reasoning_enabled = bool(body.get("reasoning", False))
context = (body.get("context") or "").strip()
if not message:
raise HTTPException(400, "message is required")
if len(message) > 4000:
raise HTTPException(400, "message too long (max 4000)")
# Собираем user content: context + message
user_content = message
if context:
user_content = f"Контекст из БД:\n{context}\n\nЗадача:\n{message}"
# Отправляем в Together
try:
async with httpx.AsyncClient(timeout=120.0) as client:
response = await client.post(
TOGETHER_API_URL,
headers={
"Authorization": f"Bearer {TOGETHER_API_KEY}",
"Content-Type": "application/json",
},
json={
"model": model,
"messages": [
{"role": "system", "content": system_prompt},
{"role": "user", "content": user_content},
],
"max_tokens": 2000,
"temperature": 1.0, # 🔧 DeepSeek рекомендует 1.0
"reasoning": {"enabled": reasoning_enabled},
},
)
except httpx.TimeoutException:
raise HTTPException(504, "AI timeout (120s)")
if response.status_code != 200:
logger.error(f"[admin_ai] Together error: {response.status_code} {response.text[:300]}")
raise HTTPException(500, f"AI error: {response.status_code}")
data = response.json()
# Извлекаем ответ
try:
message_obj = data["choices"][0]["message"]
ai_response = message_obj.get("content") or message_obj.get("reasoning_content") or ""
except (KeyError, IndexError, TypeError) as e:
logger.error(f"[admin_ai] parse error: {e}")
raise HTTPException(500, "AI returned invalid response")
if not ai_response:
raise HTTPException(500, "AI returned empty response")
# Считаем токены
usage = data.get("usage", {})
tokens_used = usage.get("total_tokens", 0)
_increment_usage(telegram_id)
logger.info(
f"[admin_ai] user={telegram_id} model={model} tokens={tokens_used}"
)
return {
"response": ai_response.strip(),
"model_used": model,
"tokens_used": tokens_used,
}
@router.post("/translate")
async def admin_ai_translate(request: Request):
"""
🔧 НОВОЕ (02.10.2026): admin_ai_translate —
перевод текста на 4 языка (PL, RU, UK, EN).
Тело:
{
"text": "Podstawowe powitania",
"source_lang": "pl",
"target_langs": ["ru", "uk", "en"] // опционально, по умолчанию все кроме source
}
Возвращает:
{
"translations": {"ru": "...", "uk": "...", "en": "..."},
"source_lang": "pl"
}
"""
telegram_id, _ = await require_auth(request)
if telegram_id not in ADMIN_IDS:
raise HTTPException(403, "Access denied")
if not _check_rate_limit(telegram_id):
raise HTTPException(429, f"Rate limit exceeded ({_ADMIN_AI_RATE_LIMIT}/hour)")
if not TOGETHER_API_KEY:
raise HTTPException(500, "TOGETHER_API_KEY not configured")
body = await request.json()
text = (body.get("text") or "").strip()
source_lang = (body.get("source_lang") or "pl").strip().lower()
target_langs = body.get("target_langs") or ["ru", "uk", "en"]
if not text:
raise HTTPException(400, "text is required")
if len(text) > 3000:
raise HTTPException(400, "text too long (max 3000)")
if source_lang not in ("pl", "ru", "uk", "en"):
raise HTTPException(400, f"Invalid source_lang: {source_lang}")
# Валидация target_langs
valid_langs = {"pl", "ru", "uk", "en"}
target_langs = [l for l in target_langs if l in valid_langs and l != source_lang]
if not target_langs:
raise HTTPException(400, "No valid target_langs")
lang_names = {
"pl": "Polish", "ru": "Russian", "uk": "Ukrainian", "en": "English",
}
source_name = lang_names[source_lang]
targets_str = ", ".join([f'"{l}": "{lang_names[l]}"' for l in target_langs])
system_prompt = f"""Ты — переводчик. Переведи текст с {source_name} на указанные языки.
Верни СТРОГО JSON (без markdown, без пояснений) в формате:
{{
{targets_str}
}}
ПРАВИЛА:
- Переводи ТОЧНО, сохраняя смысл и стиль.
- Для терминов и названий — используй общепринятые варианты.
- Если текст — название урока/темы, переводи как название (с заглавной буквы).
- Если текст — объяснение, сохраняй переносы строк и форматирование.
- Не добавляй ничего кроме JSON."""
user_prompt = f"Текст для перевода:\n{text}"
try:
async with httpx.AsyncClient(timeout=60.0) as client:
response = await client.post(
TOGETHER_API_URL,
headers={
"Authorization": f"Bearer {TOGETHER_API_KEY}",
"Content-Type": "application/json",
},
json={
"model": DEFAULT_MODEL,
"messages": [
{"role": "system", "content": system_prompt},
{"role": "user", "content": user_prompt},
],
"max_tokens": 1500,
"temperature": 0.3, # Для перевода — низкая
"reasoning": {"enabled": False},
},
)
except httpx.TimeoutException:
raise HTTPException(504, "AI timeout")
if response.status_code != 200:
logger.error(f"[admin_ai] translate error: {response.status_code} {response.text[:300]}")
raise HTTPException(500, f"AI error: {response.status_code}")
data = response.json()
try:
message_obj = data["choices"][0]["message"]
raw = (message_obj.get("content") or "").strip()
except (KeyError, IndexError, TypeError):
raise HTTPException(500, "AI returned invalid response")
# Парсим JSON (снимаем ```json ... ``` если AI обернул)
import re as _re
import json as _json
if raw.startswith("```"):
raw = _re.sub(r'^```(?:json)?\s*', '', raw)
raw = _re.sub(r'\s*```$', '', raw)
json_match = _re.search(r'\{.*\}', raw, _re.DOTALL)
if not json_match:
logger.error(f"[admin_ai] no JSON in response: {raw[:200]}")
raise HTTPException(500, "AI returned no JSON")
try:
parsed = _json.loads(json_match.group(0))
except _json.JSONDecodeError as e:
logger.error(f"[admin_ai] JSON parse error: {e}, raw={raw[:300]}")
raise HTTPException(500, "AI returned invalid JSON")
translations = {}
for lang in target_langs:
value = parsed.get(lang, "")
translations[lang] = str(value).strip() if value else ""
tokens_used = data.get("usage", {}).get("total_tokens", 0)
_increment_usage(telegram_id)
logger.info(
f"[admin_ai] translate user={telegram_id} "
f"{source_lang} → {target_langs} tokens={tokens_used}"
)
return {
"translations": translations,
"source_lang": source_lang,
"tokens_used": tokens_used,
}
File diff suppressed because it is too large Load Diff
+313 -46
View File
@@ -594,9 +594,29 @@ async def start_session(request: Request):
return {"session_id": row["id"]}
# 🔧 ОБНОВЛЕНО (02.10.2026): attempt_number + revised —
# если ученик отвечает на вопрос повторно (после «Повторить урок»),
# создаётся НОВАЯ запись с attempt_number+1, revised=TRUE,
# revision_of_id=предыдущий ответ. История сохраняется полностью.
@router.post("/answer")
async def save_answer(request: Request):
"""Сохранить ответ пользователя"""
"""
Сохранить ответ пользователя.
🔧 ОБНОВЛЕНО (02.10.2026): attempt_number + revised —
если ученик отвечает на вопрос повторно (после «Повторить урок»),
создаётся НОВАЯ запись с attempt_number+1, revised=TRUE,
revision_of_id=предыдущий ответ. История сохраняется полностью.
Возвращает:
{
"correct": bool,
"wrong_because": str | None,
"attempt_number": int, # какая это попытка
"show_correct_answer": bool, # TRUE только если attempt >= 3
"correct_answer": str | None # только при show_correct_answer
}
"""
telegram_id, _ = await require_auth(request)
body = await request.json()
session_id = body.get("session_id")
@@ -604,20 +624,39 @@ async def save_answer(request: Request):
selected_answer = body.get("answer", "")
time_taken_ms = body.get("time_taken_ms", 0)
is_final = body.get("is_final_answer", True)
# 🔧 ФИКС (22.09.2026): раньше hint_used был захардкожен False,
# поэтому подсказки не попадали в аналитику (hint_dependency всегда 0).
hint_used = body.get("hint_used", False)
# 🔧 НОВОЕ: клиент сообщает, что это повторная попытка
is_retry = body.get("is_retry", False)
if not session_id or not question_id:
raise HTTPException(400, "session_id and question_id required")
pool = await get_pool()
async with pool.acquire() as conn:
question = await conn.fetchrow("SELECT * FROM learning_questions WHERE question_id = $1", question_id)
question = await conn.fetchrow(
"SELECT * FROM learning_questions WHERE question_id = $1", question_id
)
if not question:
raise HTTPException(404, "Question not found")
correct = selected_answer.strip().lower() == (question["correct_answer"] or "").strip().lower()
# 🔧 НОВОЕ: считаем текущее количество попыток по этому вопросу в сессии
prev_attempts = await conn.fetch(
"""
SELECT id, attempt_number, correct
FROM user_learning_answers
WHERE session_id = $1 AND question_id = $2
ORDER BY attempt_number ASC
""",
session_id, question_id,
)
next_attempt = (prev_attempts[-1]["attempt_number"] + 1) if prev_attempts else 1
prev_id = prev_attempts[-1]["id"] if prev_attempts else None
correct = (
selected_answer.strip().lower()
== (question["correct_answer"] or "").strip().lower()
)
wrong_because = None
if not correct:
@@ -628,58 +667,212 @@ async def save_answer(request: Request):
if option:
wrong_because = option["wrong_because"]
session = await conn.fetchrow("SELECT * FROM learning_sessions WHERE id = $1", session_id)
# 🔧 ФИКС (23.09.2026): learning_save_answer_missing_session_check —
# раньше при несуществующем session_id падало с TypeError → 500.
# Теперь честная 404 + проверка владельца сессии.
session = await conn.fetchrow(
"SELECT * FROM learning_sessions WHERE id = $1", session_id
)
if not session:
raise HTTPException(404, "Session not found")
if session["user_id"] != telegram_id:
raise HTTPException(403, "Session belongs to another user")
await conn.execute("""
INSERT INTO user_learning_answers (user_id, session_id, level_code, topic_id, lesson_id, question_id, selected_answer, correct, skill_tag, question_type, context_type, difficulty, time_taken_ms, hint_used, wrong_because, is_final_answer)
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16)
""", telegram_id, session_id, session["level_code"], session["topic_id"], question["lesson_id"], question_id, selected_answer, correct, question["skill_tag"], question["question_type"], question["context_type"], question["difficulty"], time_taken_ms, hint_used, wrong_because, is_final)
# 🔧 Логика revised: если это повторная попытка — фиксируем
revised = is_retry or next_attempt > 1
return {"correct": correct, "wrong_because": wrong_because}
# 🔧 is_final_answer: только ПОСЛЕДНЯЯ попытка считается финальной
# (для статистики). Промежуточные — revision-записи, не идут в total.
# Если клиент сказал is_final=False (подсказка) — уважаем.
if is_retry:
# Сначала снимаем флаг is_final_answer у предыдущей записи
await conn.execute(
"""
UPDATE user_learning_answers
SET is_final_answer = FALSE
WHERE session_id = $1 AND question_id = $2
""",
session_id, question_id,
)
await conn.execute(
"""
INSERT INTO user_learning_answers (
user_id, session_id, level_code, topic_id, lesson_id,
question_id, selected_answer, correct, skill_tag,
question_type, context_type, difficulty, time_taken_ms,
attempt_number, hint_used, wrong_because, is_final_answer,
revised, revision_of_id
)
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13,
$14, $15, $16, $17, $18, $19)
""",
telegram_id, session_id, session["level_code"], session["topic_id"],
question["lesson_id"], question_id, selected_answer, correct,
question["skill_tag"], question["question_type"], question["context_type"],
question["difficulty"], time_taken_ms, next_attempt, hint_used,
wrong_because, is_final, revised, prev_id,
)
# 🔧 Решаем, показывать ли правильный ответ
# Первая попытка — НЕ показываем
# Вторая — НЕ показываем
# Третья и выше — показываем
show_correct_answer = next_attempt >= 3
# Правильный ответ — текст варианта (для recognition)
correct_answer_text = None
if show_correct_answer:
correct_option = await conn.fetchrow(
"""
SELECT option_key, text_pl, text_ru, text_uk, text_en
FROM question_options
WHERE question_id = $1 AND is_correct = TRUE
LIMIT 1
""",
question_id,
)
if correct_option:
correct_answer_text = (
f"{correct_option['option_key']} — {correct_option['text_pl']}"
)
else:
# Для production — просто correct_answer из вопроса
correct_answer_text = question["correct_answer"]
return {
"correct": correct,
"wrong_because": wrong_because,
"attempt_number": next_attempt,
"show_correct_answer": show_correct_answer,
"correct_answer": correct_answer_text,
}
# 🔧 ОБНОВЛЕНО (02.10.2026): session_report —
# без AI формируем человеческий отчёт для экрана «Тема пройдена»:
# - total / correct / percent
# - message («Отлично!» / «Стоит повторить»)
# - weak_skills этой темы (с понятными названиями)
# - next_topic
@router.post("/session/complete")
async def complete_session(request: Request):
"""Завершить сессию: обновляет прогресс урока/теста, мастерство навыков, прогресс темы и AI-контекст"""
"""
Завершить сессию: обновляет прогресс, мастерство, AI-контекст
и возвращает отчёт для экрана «Тема пройдена».
🔧 ОБНОВЛЕНО (02.10.2026): session_report —
без AI формируем человеческий отчёт:
- total / correct / percent
- message («Отлично!» / «Стоит повторить»)
- weak_skills этой темы (с понятными названиями)
- next_topic
"""
telegram_id, _ = await require_auth(request)
body = await request.json()
session_id = body.get("session_id")
# 🔧 НОВОЕ: язык для формирования отчёта
lang = body.get("lang", "ru")
pool = await get_pool()
async with pool.acquire() as conn:
session = await conn.fetchrow("SELECT * FROM learning_sessions WHERE id = $1 AND user_id = $2", session_id, telegram_id)
session = await conn.fetchrow(
"SELECT * FROM learning_sessions WHERE id = $1 AND user_id = $2",
session_id, telegram_id,
)
if not session:
raise HTTPException(404, "Session not found")
await conn.execute("UPDATE learning_sessions SET is_completed = TRUE, completed_at = NOW() WHERE id = $1", session_id)
await conn.execute(
"UPDATE learning_sessions SET is_completed = TRUE, completed_at = NOW() WHERE id = $1",
session_id,
)
stats = await conn.fetchrow("""
SELECT COUNT(*) as total, COALESCE(SUM(CASE WHEN correct THEN 1 ELSE 0 END), 0) as correct_count
FROM user_learning_answers WHERE session_id = $1 AND is_final_answer = TRUE
""", session_id)
# 🔧 Считаем только ПОСЛЕДНИЕ (is_final_answer=TRUE) ответы на каждый вопрос
stats = await conn.fetchrow(
"""
WITH last_answers AS (
SELECT DISTINCT ON (question_id) question_id, correct, wrong_because, skill_tag
FROM user_learning_answers
WHERE session_id = $1
ORDER BY question_id, attempt_number DESC
)
SELECT
COUNT(*) AS total,
COALESCE(SUM(CASE WHEN correct THEN 1 ELSE 0 END), 0) AS correct_count
FROM last_answers
""",
session_id,
)
# Слабые навыки этой темы (те, где были ошибки)
weak_rows = await conn.fetch(
"""
WITH last_answers AS (
SELECT DISTINCT ON (question_id) question_id, correct, skill_tag
FROM user_learning_answers
WHERE session_id = $1
ORDER BY question_id, attempt_number DESC
)
SELECT
la.skill_tag,
COUNT(*) FILTER (WHERE NOT la.correct) AS errors,
COALESCE(ll.title_ru, la.skill_tag) AS name_ru,
COALESCE(ll.title_pl, la.skill_tag) AS name_pl,
COALESCE(ll.title_uk, la.skill_tag) AS name_uk,
COALESCE(ll.title_en, la.skill_tag) AS name_en
FROM last_answers la
LEFT JOIN learning_lessons ll ON ll.skill_tag = la.skill_tag
WHERE NOT la.correct
GROUP BY la.skill_tag, ll.title_ru, ll.title_pl, ll.title_uk, ll.title_en
HAVING COUNT(*) FILTER (WHERE NOT la.correct) > 0
ORDER BY errors DESC
LIMIT 5
""",
session_id,
)
# Информация о теме
topic_id = session["topic_id"]
topic_row = await conn.fetchrow(
"SELECT * FROM learning_topics WHERE topic_id = $1", topic_id
)
# Следующая тема того же уровня
next_topic = None
if topic_row:
next_topic = await conn.fetchrow(
"""
SELECT topic_id, name_ru, name_pl, name_uk, name_en
FROM learning_topics
WHERE level_code = $1
AND order_number > $2
AND is_active = TRUE
ORDER BY order_number
LIMIT 1
""",
topic_row["level_code"], topic_row["order_number"],
)
# ============ Обновляем прогресс ============
# (всё что было — оставляем)
# Обновляем прогресс урока
if session["session_type"] == "lesson":
lesson_row = await conn.fetchrow("""
SELECT DISTINCT lesson_id FROM user_learning_answers WHERE session_id = $1 AND lesson_id IS NOT NULL
""", session_id)
lesson_row = await conn.fetchrow(
"""
SELECT DISTINCT lesson_id FROM user_learning_answers
WHERE session_id = $1 AND lesson_id IS NOT NULL
""",
session_id,
)
if lesson_row and lesson_row["lesson_id"]:
lesson_id = lesson_row["lesson_id"]
score = (stats["correct_count"] / stats["total"] * 100) if stats["total"] > 0 else 0
await conn.execute("""
INSERT INTO user_lesson_progress (user_id, lesson_id, started_at, completed_at, attempts_count, correct_count, best_score, completed)
score = (
stats["correct_count"] / stats["total"] * 100
) if stats["total"] > 0 else 0
await conn.execute(
"""
INSERT INTO user_lesson_progress (
user_id, lesson_id, started_at, completed_at,
attempts_count, correct_count, best_score, completed
)
VALUES ($1, $2, NOW(), NOW(), 1, $3, $4, TRUE)
ON CONFLICT (user_id, lesson_id) DO UPDATE
SET completed_at = NOW(),
@@ -687,37 +880,111 @@ async def complete_session(request: Request):
correct_count = user_lesson_progress.correct_count + $3,
best_score = GREATEST(user_lesson_progress.best_score, $4),
completed = TRUE
""", telegram_id, lesson_id, stats["correct_count"], score)
""",
telegram_id, lesson_id, stats["correct_count"], score,
)
# Обновляем прогресс темы если это тест
if session["session_type"] == "topic_test":
test_score = (stats["correct_count"] / stats["total"] * 100) if stats["total"] > 0 else 0
await conn.execute("""
INSERT INTO user_topic_progress (user_id, topic_id, test_started, test_completed, test_score, completed_at)
test_score = (
stats["correct_count"] / stats["total"] * 100
) if stats["total"] > 0 else 0
await conn.execute(
"""
INSERT INTO user_topic_progress (
user_id, topic_id, test_started, test_completed, test_score, completed_at
)
VALUES ($1, $2, TRUE, TRUE, $3, NOW())
ON CONFLICT (user_id, topic_id) DO UPDATE
SET test_completed = TRUE,
test_score = $3,
completed_at = NOW()
""", telegram_id, topic_id, test_score)
# Обновляем мастерство по всем навыкам из этой сессии
skill_tags = await conn.fetch("""
SELECT DISTINCT skill_tag FROM user_learning_answers WHERE session_id = $1
""", session_id)
""",
telegram_id, topic_id, test_score,
)
skill_tags = await conn.fetch(
"SELECT DISTINCT skill_tag FROM user_learning_answers WHERE session_id = $1",
session_id,
)
for st in skill_tags:
await update_skill_mastery(conn, telegram_id, st["skill_tag"])
# Обновляем прогресс темы ТОЛЬКО для lesson и topic_test
if session["session_type"] in ("lesson", "topic_test") and topic_id:
await update_topic_progress(conn, telegram_id, topic_id)
# Обновляем AI-контекст (всегда)
await update_ai_context(conn, telegram_id)
return {"status": "ok", "total": stats["total"], "correct_count": stats["correct_count"]}
# ============ Формируем отчёт ============
total = stats["total"] or 0
correct_count = stats["correct_count"] or 0
percent = round(correct_count / total * 100) if total > 0 else 0
# Человеческое сообщение (без AI, чистая математика)
if percent >= 90:
message = {
"ru": "Отлично! Ты прекрасно усвоил тему! 🎉",
"pl": "Świetnie! Doskonale opanowałeś temat! 🎉",
"uk": "Чудово! Ти чудово засвоїв тему! 🎉",
"en": "Excellent! You've mastered this topic! 🎉",
}.get(lang, "Отлично! 🎉")
elif percent >= 75:
message = {
"ru": "Хороший результат! Так держать! 💪",
"pl": "Dobry wynik! Tak trzymaj! 💪",
"uk": "Гарний результат! Так тримати! 💪",
"en": "Good result! Keep it up! 💪",
}.get(lang, "Хороший результат! 💪")
elif percent >= 60:
message = {
"ru": "Неплохо! Но есть над чем поработать.",
"pl": "Nieźle! Ale jest nad czym popracować.",
"uk": "Непогано! Але є над чим попрацювати.",
"en": "Not bad! But there's room to improve.",
}.get(lang, "Неплохо!")
else:
message = {
"ru": "Стоит пройти тему ещё раз — много ошибок.",
"pl": "Warto powtórzyć temat — dużo błędów.",
"uk": "Варто пройти тему ще раз — багато помилок.",
"en": "Worth repeating this topic — many mistakes.",
}.get(lang, "Стоит повторить.")
# Слабые навыки на нужном языке
name_field = f"name_{lang}"
weak_skills_out = []
for w in weak_rows:
weak_skills_out.append({
"skill_tag": w["skill_tag"],
"name": w.get(name_field) or w["name_ru"],
"errors": w["errors"],
})
# Информация о следующей теме
next_out = None
if next_topic:
next_out = {
"topic_id": next_topic["topic_id"],
"name": next_topic.get(name_field) or next_topic["name_ru"],
}
# Название текущей темы
topic_name = None
if topic_row:
topic_name = topic_row.get(name_field) or topic_row["name_ru"]
return {
"status": "ok",
"total": total,
"correct_count": correct_count,
"report": {
"topic_id": topic_id,
"topic_name": topic_name,
"percent": percent,
"message": message,
"weak_skills": weak_skills_out,
"next_topic": next_out,
},
}
@router.get("/progress")
+45 -4
View File
@@ -1,8 +1,27 @@
"""
Learning Data Package — данные всех уровней.
Каждый уровень в отдельном файле.
🔧 ОБНОВЛЕНО (02.10.2026): seed_data_only_if_empty —
файлы level_*.py остаются в репозитории как АРХИВ,
но при старте бэкенда контент НЕ перезаписывается, если
в БД уже есть данные.
Причины:
- Контент правится через админку → правки в БД.
- Если seed запускать всегда — правки затираются.
- Уровни (learning_levels) гарантированно создаются — они статичны.
Управление:
- Переменная окружения SEED_LEARNING_DATA=true в .env → заливаем файлы.
- По умолчанию false → пропускаем seed, если данные уже есть.
Для fresh install (пустая БД): seed запустится автоматически,
т.к. проверка «learning_topics пуст» проходит.
"""
import logging
import os
from database import get_pool
from . import level_a1, level_a2, level_b1, level_b2, level_c1, level_c2
@@ -10,10 +29,10 @@ logger = logging.getLogger(__name__)
async def init_learning_data():
"""Инициализирует уровни и все темы"""
"""Инициализирует уровни и (опционально) контент из файлов."""
pool = await get_pool()
async with pool.acquire() as conn:
# ============ УРОВНИ ============
# ============ УРОВНИ (всегда, они статичны) ============
levels = [
("A1", "Poziom A1", "Уровень A1", "Рівень A1", "Level A1", 1),
("A2", "Poziom A2", "Уровень A2", "Рівень A2", "Level A2", 2),
@@ -29,7 +48,29 @@ async def init_learning_data():
ON CONFLICT (code) DO NOTHING
""", code, pl, ru, uk, en, sort)
# Загружаем данные каждого уровня
logger.info("[seed] learning_levels ensured (A1-C2)")
# ============ ПРОВЕРКА: нужен ли seed контента? ============
force_seed = os.getenv("SEED_LEARNING_DATA", "false").lower() == "true"
topics_count = await conn.fetchval("""
SELECT COUNT(*) FROM learning_topics
""") or 0
if topics_count > 0 and not force_seed:
logger.info(
f"[seed] learning_topics not empty ({topics_count} topics) — "
f"skipping content seed. Установи SEED_LEARNING_DATA=true в .env "
f"для принудительной перезаливки."
)
return
# ============ SEED КОНТЕНТА (fresh install ИЛИ force) ============
if force_seed:
logger.warning("[seed] SEED_LEARNING_DATA=true — принудительная перезаливка контента")
else:
logger.info("[seed] Empty DB detected — seeding content from level_*.py files")
await level_a1.init_level_a1(conn)
await level_a2.init_level_a2(conn)
await level_b1.init_level_b1(conn)
@@ -37,4 +78,4 @@ async def init_learning_data():
await level_c1.init_level_c1(conn)
await level_c2.init_level_c2(conn)
logger.info("Learning data fully initialized")
logger.info("[seed] Learning content initialized from files")