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 ============ # ============ user_learning_answers ============
# 🔧 ОБНОВЛЕНО (02.10.2026): добавлены revised и revision_of_id
# прямо в определение — на свежих БД создаются сразу.
await conn.execute(""" await conn.execute("""
CREATE TABLE IF NOT EXISTS user_learning_answers ( CREATE TABLE IF NOT EXISTS user_learning_answers (
id BIGSERIAL PRIMARY KEY, id BIGSERIAL PRIMARY KEY,
@@ -487,10 +489,46 @@ async def init_db():
hint_used BOOLEAN DEFAULT FALSE, hint_used BOOLEAN DEFAULT FALSE,
wrong_because VARCHAR(100), wrong_because VARCHAR(100),
is_final_answer BOOLEAN DEFAULT TRUE, is_final_answer BOOLEAN DEFAULT TRUE,
revised BOOLEAN DEFAULT FALSE, -- 🔧 НОВОЕ
revision_of_id BIGINT, -- 🔧 НОВОЕ
created_at TIMESTAMP DEFAULT NOW() created_at TIMESTAMP DEFAULT NOW()
) )
""") """)
# 🔧 НОВОЕ (02.10.2026): revised — фиксируем, что ученик
# поменял ответ после «Повторить урок».
col_exists = await conn.fetchval("""
SELECT 1 FROM information_schema.columns
WHERE table_name = 'user_learning_answers' AND column_name = 'revised'
""")
if not col_exists:
await conn.execute("""
ALTER TABLE user_learning_answers
ADD COLUMN revised BOOLEAN DEFAULT FALSE
""")
logger.info("Added revised column to user_learning_answers")
# 🔧 НОВОЕ (02.10.2026): revision_of_id — ссылка на предыдущий
# ответ этого же вопроса в этой же сессии. Позволяет строить
# цепочку: первый ответ → второй (после повтора) → третий.
col_exists = await conn.fetchval("""
SELECT 1 FROM information_schema.columns
WHERE table_name = 'user_learning_answers' AND column_name = 'revision_of_id'
""")
if not col_exists:
await conn.execute("""
ALTER TABLE user_learning_answers
ADD COLUMN revision_of_id BIGINT
""")
logger.info("Added revision_of_id column to user_learning_answers")
# Индекс для быстрого поиска цепочек повторов
await conn.execute("""
CREATE INDEX IF NOT EXISTS idx_learning_answers_revision
ON user_learning_answers(revision_of_id)
WHERE revision_of_id IS NOT NULL
""")
# ============ user_lesson_progress ============ # ============ user_lesson_progress ============
await conn.execute(""" await conn.execute("""
CREATE TABLE IF NOT EXISTS user_lesson_progress ( CREATE TABLE IF NOT EXISTS user_lesson_progress (
+2
View File
@@ -15,6 +15,7 @@ from config import FRONTEND_ORIGINS, UPLOADS_DIR, CF_IPS
from database import init_db from database import init_db
from routers import users, game, hints, leaderboard, sentences, achievements, wordquiz, bubblewords, pronunciation, assistant, learning, tts, typing, teacher, support, admin, feed, admin_content from routers import users, game, hints, leaderboard, sentences, achievements, wordquiz, bubblewords, pronunciation, assistant, learning, tts, typing, teacher, support, admin, feed, admin_content
from routers import lectures, admin_auth, admin_wordsearch, admin_users from routers import lectures, admin_auth, admin_wordsearch, admin_users
from routers import admin_ai # 🔧 НОВОЕ
from routers.sentences import init_sentences from routers.sentences import init_sentences
from routers.achievements import init_achievements from routers.achievements import init_achievements
from routers.learning_data import init_learning_data from routers.learning_data import init_learning_data
@@ -370,6 +371,7 @@ app.include_router(lectures.router)
app.include_router(admin_auth.router) app.include_router(admin_auth.router)
app.include_router(admin_wordsearch.router) app.include_router(admin_wordsearch.router)
app.include_router(admin_users.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,
}
+1035 -1
View File
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"]} return {"session_id": row["id"]}
# 🔧 ОБНОВЛЕНО (02.10.2026): attempt_number + revised —
# если ученик отвечает на вопрос повторно (после «Повторить урок»),
# создаётся НОВАЯ запись с attempt_number+1, revised=TRUE,
# revision_of_id=предыдущий ответ. История сохраняется полностью.
@router.post("/answer") @router.post("/answer")
async def save_answer(request: Request): async def save_answer(request: Request):
"""Сохранить ответ пользователя""" """
Сохранить ответ пользователя.
🔧 ОБНОВЛЕНО (02.10.2026): attempt_number + revised —
если ученик отвечает на вопрос повторно (после «Повторить урок»),
создаётся НОВАЯ запись с attempt_number+1, revised=TRUE,
revision_of_id=предыдущий ответ. История сохраняется полностью.
Возвращает:
{
"correct": bool,
"wrong_because": str | None,
"attempt_number": int, # какая это попытка
"show_correct_answer": bool, # TRUE только если attempt >= 3
"correct_answer": str | None # только при show_correct_answer
}
"""
telegram_id, _ = await require_auth(request) telegram_id, _ = await require_auth(request)
body = await request.json() body = await request.json()
session_id = body.get("session_id") session_id = body.get("session_id")
@@ -604,20 +624,39 @@ async def save_answer(request: Request):
selected_answer = body.get("answer", "") selected_answer = body.get("answer", "")
time_taken_ms = body.get("time_taken_ms", 0) time_taken_ms = body.get("time_taken_ms", 0)
is_final = body.get("is_final_answer", True) is_final = body.get("is_final_answer", True)
# 🔧 ФИКС (22.09.2026): раньше hint_used был захардкожен False,
# поэтому подсказки не попадали в аналитику (hint_dependency всегда 0).
hint_used = body.get("hint_used", False) hint_used = body.get("hint_used", False)
# 🔧 НОВОЕ: клиент сообщает, что это повторная попытка
is_retry = body.get("is_retry", False)
if not session_id or not question_id: if not session_id or not question_id:
raise HTTPException(400, "session_id and question_id required") raise HTTPException(400, "session_id and question_id required")
pool = await get_pool() pool = await get_pool()
async with pool.acquire() as conn: async with pool.acquire() as conn:
question = await conn.fetchrow("SELECT * FROM learning_questions WHERE question_id = $1", question_id) question = await conn.fetchrow(
"SELECT * FROM learning_questions WHERE question_id = $1", question_id
)
if not question: if not question:
raise HTTPException(404, "Question not found") raise HTTPException(404, "Question not found")
correct = selected_answer.strip().lower() == (question["correct_answer"] or "").strip().lower() # 🔧 НОВОЕ: считаем текущее количество попыток по этому вопросу в сессии
prev_attempts = await conn.fetch(
"""
SELECT id, attempt_number, correct
FROM user_learning_answers
WHERE session_id = $1 AND question_id = $2
ORDER BY attempt_number ASC
""",
session_id, question_id,
)
next_attempt = (prev_attempts[-1]["attempt_number"] + 1) if prev_attempts else 1
prev_id = prev_attempts[-1]["id"] if prev_attempts else None
correct = (
selected_answer.strip().lower()
== (question["correct_answer"] or "").strip().lower()
)
wrong_because = None wrong_because = None
if not correct: if not correct:
@@ -628,58 +667,212 @@ async def save_answer(request: Request):
if option: if option:
wrong_because = option["wrong_because"] wrong_because = option["wrong_because"]
session = await conn.fetchrow("SELECT * FROM learning_sessions WHERE id = $1", session_id) session = await conn.fetchrow(
"SELECT * FROM learning_sessions WHERE id = $1", session_id
# 🔧 ФИКС (23.09.2026): learning_save_answer_missing_session_check — )
# раньше при несуществующем session_id падало с TypeError → 500.
# Теперь честная 404 + проверка владельца сессии.
if not session: if not session:
raise HTTPException(404, "Session not found") raise HTTPException(404, "Session not found")
if session["user_id"] != telegram_id: if session["user_id"] != telegram_id:
raise HTTPException(403, "Session belongs to another user") raise HTTPException(403, "Session belongs to another user")
await conn.execute(""" # 🔧 Логика revised: если это повторная попытка — фиксируем
INSERT INTO user_learning_answers (user_id, session_id, level_code, topic_id, lesson_id, question_id, selected_answer, correct, skill_tag, question_type, context_type, difficulty, time_taken_ms, hint_used, wrong_because, is_final_answer) revised = is_retry or next_attempt > 1
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16)
""", telegram_id, session_id, session["level_code"], session["topic_id"], question["lesson_id"], question_id, selected_answer, correct, question["skill_tag"], question["question_type"], question["context_type"], question["difficulty"], time_taken_ms, hint_used, wrong_because, is_final)
return {"correct": correct, "wrong_because": wrong_because} # 🔧 is_final_answer: только ПОСЛЕДНЯЯ попытка считается финальной
# (для статистики). Промежуточные — revision-записи, не идут в total.
# Если клиент сказал is_final=False (подсказка) — уважаем.
if is_retry:
# Сначала снимаем флаг is_final_answer у предыдущей записи
await conn.execute(
"""
UPDATE user_learning_answers
SET is_final_answer = FALSE
WHERE session_id = $1 AND question_id = $2
""",
session_id, question_id,
)
await conn.execute(
"""
INSERT INTO user_learning_answers (
user_id, session_id, level_code, topic_id, lesson_id,
question_id, selected_answer, correct, skill_tag,
question_type, context_type, difficulty, time_taken_ms,
attempt_number, hint_used, wrong_because, is_final_answer,
revised, revision_of_id
)
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13,
$14, $15, $16, $17, $18, $19)
""",
telegram_id, session_id, session["level_code"], session["topic_id"],
question["lesson_id"], question_id, selected_answer, correct,
question["skill_tag"], question["question_type"], question["context_type"],
question["difficulty"], time_taken_ms, next_attempt, hint_used,
wrong_because, is_final, revised, prev_id,
)
# 🔧 Решаем, показывать ли правильный ответ
# Первая попытка — НЕ показываем
# Вторая — НЕ показываем
# Третья и выше — показываем
show_correct_answer = next_attempt >= 3
# Правильный ответ — текст варианта (для recognition)
correct_answer_text = None
if show_correct_answer:
correct_option = await conn.fetchrow(
"""
SELECT option_key, text_pl, text_ru, text_uk, text_en
FROM question_options
WHERE question_id = $1 AND is_correct = TRUE
LIMIT 1
""",
question_id,
)
if correct_option:
correct_answer_text = (
f"{correct_option['option_key']} — {correct_option['text_pl']}"
)
else:
# Для production — просто correct_answer из вопроса
correct_answer_text = question["correct_answer"]
return {
"correct": correct,
"wrong_because": wrong_because,
"attempt_number": next_attempt,
"show_correct_answer": show_correct_answer,
"correct_answer": correct_answer_text,
}
# 🔧 ОБНОВЛЕНО (02.10.2026): session_report —
# без AI формируем человеческий отчёт для экрана «Тема пройдена»:
# - total / correct / percent
# - message («Отлично!» / «Стоит повторить»)
# - weak_skills этой темы (с понятными названиями)
# - next_topic
@router.post("/session/complete") @router.post("/session/complete")
async def complete_session(request: Request): async def complete_session(request: Request):
"""Завершить сессию: обновляет прогресс урока/теста, мастерство навыков, прогресс темы и AI-контекст""" """
Завершить сессию: обновляет прогресс, мастерство, AI-контекст
и возвращает отчёт для экрана «Тема пройдена».
🔧 ОБНОВЛЕНО (02.10.2026): session_report —
без AI формируем человеческий отчёт:
- total / correct / percent
- message («Отлично!» / «Стоит повторить»)
- weak_skills этой темы (с понятными названиями)
- next_topic
"""
telegram_id, _ = await require_auth(request) telegram_id, _ = await require_auth(request)
body = await request.json() body = await request.json()
session_id = body.get("session_id") session_id = body.get("session_id")
# 🔧 НОВОЕ: язык для формирования отчёта
lang = body.get("lang", "ru")
pool = await get_pool() pool = await get_pool()
async with pool.acquire() as conn: async with pool.acquire() as conn:
session = await conn.fetchrow("SELECT * FROM learning_sessions WHERE id = $1 AND user_id = $2", session_id, telegram_id) session = await conn.fetchrow(
"SELECT * FROM learning_sessions WHERE id = $1 AND user_id = $2",
session_id, telegram_id,
)
if not session: if not session:
raise HTTPException(404, "Session not found") raise HTTPException(404, "Session not found")
await conn.execute("UPDATE learning_sessions SET is_completed = TRUE, completed_at = NOW() WHERE id = $1", session_id) await conn.execute(
"UPDATE learning_sessions SET is_completed = TRUE, completed_at = NOW() WHERE id = $1",
session_id,
)
stats = await conn.fetchrow(""" # 🔧 Считаем только ПОСЛЕДНИЕ (is_final_answer=TRUE) ответы на каждый вопрос
SELECT COUNT(*) as total, COALESCE(SUM(CASE WHEN correct THEN 1 ELSE 0 END), 0) as correct_count stats = await conn.fetchrow(
FROM user_learning_answers WHERE session_id = $1 AND is_final_answer = TRUE """
""", session_id) WITH last_answers AS (
SELECT DISTINCT ON (question_id) question_id, correct, wrong_because, skill_tag
FROM user_learning_answers
WHERE session_id = $1
ORDER BY question_id, attempt_number DESC
)
SELECT
COUNT(*) AS total,
COALESCE(SUM(CASE WHEN correct THEN 1 ELSE 0 END), 0) AS correct_count
FROM last_answers
""",
session_id,
)
# Слабые навыки этой темы (те, где были ошибки)
weak_rows = await conn.fetch(
"""
WITH last_answers AS (
SELECT DISTINCT ON (question_id) question_id, correct, skill_tag
FROM user_learning_answers
WHERE session_id = $1
ORDER BY question_id, attempt_number DESC
)
SELECT
la.skill_tag,
COUNT(*) FILTER (WHERE NOT la.correct) AS errors,
COALESCE(ll.title_ru, la.skill_tag) AS name_ru,
COALESCE(ll.title_pl, la.skill_tag) AS name_pl,
COALESCE(ll.title_uk, la.skill_tag) AS name_uk,
COALESCE(ll.title_en, la.skill_tag) AS name_en
FROM last_answers la
LEFT JOIN learning_lessons ll ON ll.skill_tag = la.skill_tag
WHERE NOT la.correct
GROUP BY la.skill_tag, ll.title_ru, ll.title_pl, ll.title_uk, ll.title_en
HAVING COUNT(*) FILTER (WHERE NOT la.correct) > 0
ORDER BY errors DESC
LIMIT 5
""",
session_id,
)
# Информация о теме
topic_id = session["topic_id"] topic_id = session["topic_id"]
topic_row = await conn.fetchrow(
"SELECT * FROM learning_topics WHERE topic_id = $1", topic_id
)
# Следующая тема того же уровня
next_topic = None
if topic_row:
next_topic = await conn.fetchrow(
"""
SELECT topic_id, name_ru, name_pl, name_uk, name_en
FROM learning_topics
WHERE level_code = $1
AND order_number > $2
AND is_active = TRUE
ORDER BY order_number
LIMIT 1
""",
topic_row["level_code"], topic_row["order_number"],
)
# ============ Обновляем прогресс ============
# (всё что было — оставляем)
# Обновляем прогресс урока
if session["session_type"] == "lesson": if session["session_type"] == "lesson":
lesson_row = await conn.fetchrow(""" lesson_row = await conn.fetchrow(
SELECT DISTINCT lesson_id FROM user_learning_answers WHERE session_id = $1 AND lesson_id IS NOT NULL """
""", session_id) SELECT DISTINCT lesson_id FROM user_learning_answers
WHERE session_id = $1 AND lesson_id IS NOT NULL
""",
session_id,
)
if lesson_row and lesson_row["lesson_id"]: if lesson_row and lesson_row["lesson_id"]:
lesson_id = lesson_row["lesson_id"] lesson_id = lesson_row["lesson_id"]
score = (stats["correct_count"] / stats["total"] * 100) if stats["total"] > 0 else 0 score = (
stats["correct_count"] / stats["total"] * 100
await conn.execute(""" ) if stats["total"] > 0 else 0
INSERT INTO user_lesson_progress (user_id, lesson_id, started_at, completed_at, attempts_count, correct_count, best_score, completed) await conn.execute(
"""
INSERT INTO user_lesson_progress (
user_id, lesson_id, started_at, completed_at,
attempts_count, correct_count, best_score, completed
)
VALUES ($1, $2, NOW(), NOW(), 1, $3, $4, TRUE) VALUES ($1, $2, NOW(), NOW(), 1, $3, $4, TRUE)
ON CONFLICT (user_id, lesson_id) DO UPDATE ON CONFLICT (user_id, lesson_id) DO UPDATE
SET completed_at = NOW(), SET completed_at = NOW(),
@@ -687,37 +880,111 @@ async def complete_session(request: Request):
correct_count = user_lesson_progress.correct_count + $3, correct_count = user_lesson_progress.correct_count + $3,
best_score = GREATEST(user_lesson_progress.best_score, $4), best_score = GREATEST(user_lesson_progress.best_score, $4),
completed = TRUE completed = TRUE
""", telegram_id, lesson_id, stats["correct_count"], score) """,
telegram_id, lesson_id, stats["correct_count"], score,
)
# Обновляем прогресс темы если это тест
if session["session_type"] == "topic_test": if session["session_type"] == "topic_test":
test_score = (stats["correct_count"] / stats["total"] * 100) if stats["total"] > 0 else 0 test_score = (
stats["correct_count"] / stats["total"] * 100
await conn.execute(""" ) if stats["total"] > 0 else 0
INSERT INTO user_topic_progress (user_id, topic_id, test_started, test_completed, test_score, completed_at) await conn.execute(
"""
INSERT INTO user_topic_progress (
user_id, topic_id, test_started, test_completed, test_score, completed_at
)
VALUES ($1, $2, TRUE, TRUE, $3, NOW()) VALUES ($1, $2, TRUE, TRUE, $3, NOW())
ON CONFLICT (user_id, topic_id) DO UPDATE ON CONFLICT (user_id, topic_id) DO UPDATE
SET test_completed = TRUE, SET test_completed = TRUE,
test_score = $3, test_score = $3,
completed_at = NOW() completed_at = NOW()
""", telegram_id, topic_id, test_score) """,
telegram_id, topic_id, test_score,
)
# Обновляем мастерство по всем навыкам из этой сессии skill_tags = await conn.fetch(
skill_tags = await conn.fetch(""" "SELECT DISTINCT skill_tag FROM user_learning_answers WHERE session_id = $1",
SELECT DISTINCT skill_tag FROM user_learning_answers WHERE session_id = $1 session_id,
""", session_id) )
for st in skill_tags: for st in skill_tags:
await update_skill_mastery(conn, telegram_id, st["skill_tag"]) await update_skill_mastery(conn, telegram_id, st["skill_tag"])
# Обновляем прогресс темы ТОЛЬКО для lesson и topic_test
if session["session_type"] in ("lesson", "topic_test") and topic_id: if session["session_type"] in ("lesson", "topic_test") and topic_id:
await update_topic_progress(conn, telegram_id, topic_id) await update_topic_progress(conn, telegram_id, topic_id)
# Обновляем AI-контекст (всегда)
await update_ai_context(conn, telegram_id) await update_ai_context(conn, telegram_id)
return {"status": "ok", "total": stats["total"], "correct_count": stats["correct_count"]} # ============ Формируем отчёт ============
total = stats["total"] or 0
correct_count = stats["correct_count"] or 0
percent = round(correct_count / total * 100) if total > 0 else 0
# Человеческое сообщение (без AI, чистая математика)
if percent >= 90:
message = {
"ru": "Отлично! Ты прекрасно усвоил тему! 🎉",
"pl": "Świetnie! Doskonale opanowałeś temat! 🎉",
"uk": "Чудово! Ти чудово засвоїв тему! 🎉",
"en": "Excellent! You've mastered this topic! 🎉",
}.get(lang, "Отлично! 🎉")
elif percent >= 75:
message = {
"ru": "Хороший результат! Так держать! 💪",
"pl": "Dobry wynik! Tak trzymaj! 💪",
"uk": "Гарний результат! Так тримати! 💪",
"en": "Good result! Keep it up! 💪",
}.get(lang, "Хороший результат! 💪")
elif percent >= 60:
message = {
"ru": "Неплохо! Но есть над чем поработать.",
"pl": "Nieźle! Ale jest nad czym popracować.",
"uk": "Непогано! Але є над чим попрацювати.",
"en": "Not bad! But there's room to improve.",
}.get(lang, "Неплохо!")
else:
message = {
"ru": "Стоит пройти тему ещё раз — много ошибок.",
"pl": "Warto powtórzyć temat — dużo błędów.",
"uk": "Варто пройти тему ще раз — багато помилок.",
"en": "Worth repeating this topic — many mistakes.",
}.get(lang, "Стоит повторить.")
# Слабые навыки на нужном языке
name_field = f"name_{lang}"
weak_skills_out = []
for w in weak_rows:
weak_skills_out.append({
"skill_tag": w["skill_tag"],
"name": w.get(name_field) or w["name_ru"],
"errors": w["errors"],
})
# Информация о следующей теме
next_out = None
if next_topic:
next_out = {
"topic_id": next_topic["topic_id"],
"name": next_topic.get(name_field) or next_topic["name_ru"],
}
# Название текущей темы
topic_name = None
if topic_row:
topic_name = topic_row.get(name_field) or topic_row["name_ru"]
return {
"status": "ok",
"total": total,
"correct_count": correct_count,
"report": {
"topic_id": topic_id,
"topic_name": topic_name,
"percent": percent,
"message": message,
"weak_skills": weak_skills_out,
"next_topic": next_out,
},
}
@router.get("/progress") @router.get("/progress")
+45 -4
View File
@@ -1,8 +1,27 @@
""" """
Learning Data Package — данные всех уровней. Learning Data Package — данные всех уровней.
Каждый уровень в отдельном файле. Каждый уровень в отдельном файле.
🔧 ОБНОВЛЕНО (02.10.2026): seed_data_only_if_empty —
файлы level_*.py остаются в репозитории как АРХИВ,
но при старте бэкенда контент НЕ перезаписывается, если
в БД уже есть данные.
Причины:
- Контент правится через админку → правки в БД.
- Если seed запускать всегда — правки затираются.
- Уровни (learning_levels) гарантированно создаются — они статичны.
Управление:
- Переменная окружения SEED_LEARNING_DATA=true в .env → заливаем файлы.
- По умолчанию false → пропускаем seed, если данные уже есть.
Для fresh install (пустая БД): seed запустится автоматически,
т.к. проверка «learning_topics пуст» проходит.
""" """
import logging import logging
import os
from database import get_pool from database import get_pool
from . import level_a1, level_a2, level_b1, level_b2, level_c1, level_c2 from . import level_a1, level_a2, level_b1, level_b2, level_c1, level_c2
@@ -10,10 +29,10 @@ logger = logging.getLogger(__name__)
async def init_learning_data(): async def init_learning_data():
"""Инициализирует уровни и все темы""" """Инициализирует уровни и (опционально) контент из файлов."""
pool = await get_pool() pool = await get_pool()
async with pool.acquire() as conn: async with pool.acquire() as conn:
# ============ УРОВНИ ============ # ============ УРОВНИ (всегда, они статичны) ============
levels = [ levels = [
("A1", "Poziom A1", "Уровень A1", "Рівень A1", "Level A1", 1), ("A1", "Poziom A1", "Уровень A1", "Рівень A1", "Level A1", 1),
("A2", "Poziom A2", "Уровень A2", "Рівень A2", "Level A2", 2), ("A2", "Poziom A2", "Уровень A2", "Рівень A2", "Level A2", 2),
@@ -29,7 +48,29 @@ async def init_learning_data():
ON CONFLICT (code) DO NOTHING ON CONFLICT (code) DO NOTHING
""", code, pl, ru, uk, en, sort) """, code, pl, ru, uk, en, sort)
# Загружаем данные каждого уровня logger.info("[seed] learning_levels ensured (A1-C2)")
# ============ ПРОВЕРКА: нужен ли seed контента? ============
force_seed = os.getenv("SEED_LEARNING_DATA", "false").lower() == "true"
topics_count = await conn.fetchval("""
SELECT COUNT(*) FROM learning_topics
""") or 0
if topics_count > 0 and not force_seed:
logger.info(
f"[seed] learning_topics not empty ({topics_count} topics) — "
f"skipping content seed. Установи SEED_LEARNING_DATA=true в .env "
f"для принудительной перезаливки."
)
return
# ============ SEED КОНТЕНТА (fresh install ИЛИ force) ============
if force_seed:
logger.warning("[seed] SEED_LEARNING_DATA=true — принудительная перезаливка контента")
else:
logger.info("[seed] Empty DB detected — seeding content from level_*.py files")
await level_a1.init_level_a1(conn) await level_a1.init_level_a1(conn)
await level_a2.init_level_a2(conn) await level_a2.init_level_a2(conn)
await level_b1.init_level_b1(conn) await level_b1.init_level_b1(conn)
@@ -37,4 +78,4 @@ async def init_learning_data():
await level_c1.init_level_c1(conn) await level_c1.init_level_c1(conn)
await level_c2.init_level_c2(conn) await level_c2.init_level_c2(conn)
logger.info("Learning data fully initialized") logger.info("[seed] Learning content initialized from files")