feat: JLPT levels for Japanese, custom practice scenarios, UI improvements

- Add separate level systems: CEFR (A1-C2) for European languages, JLPT (N5-N1) for Japanese
- Store levels per language in new `levels_by_language` JSON field
- Add custom scenario option in AI practice mode
- Show action buttons after practice ends (new dialogue, tasks, words)
- Fix level display across all handlers to use correct level system
- Add Alembic migration for levels_by_language field
- Update all locale files (ru, en, ja) with new keys

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

bot/handlers/import_text.py

@@ -9,7 +9,8 @@ from database.models import WordSource
 from services.user_service import UserService
 from services.vocabulary_service import VocabularyService
 from services.ai_service import ai_service
-from utils.i18n import t
+from utils.i18n import t, get_user_lang
+from utils.levels import get_user_level_for_language
 
 router = Router()
 
@@ -44,7 +45,10 @@ async def cmd_import(message: Message, state: FSMContext):
 async def cancel_import(message: Message, state: FSMContext):
     """Отмена импорта"""
     await state.clear()
-    await message.answer("❌ Импорт отменён.")
+    async with async_session_maker() as session:
+        user = await UserService.get_user_by_telegram_id(session, message.from_user.id)
+    lang = get_user_lang(user)
+    await message.answer(t(lang, 'import_extra.cancelled'))
 
 
 @router.message(ImportStates.waiting_for_text)
@@ -52,12 +56,16 @@ async def process_text(message: Message, state: FSMContext):
     """Обработка текста от пользователя"""
     text = message.text.strip()
 
+    async with async_session_maker() as session:
+        user = await UserService.get_user_by_telegram_id(session, message.from_user.id)
+    lang = get_user_lang(user)
+
     if len(text) < 50:
-        await message.answer(t('ru', 'import.too_short'))
+        await message.answer(t(lang, 'import.too_short'))
         return
 
     if len(text) > 3000:
-        await message.answer(t('ru', 'import.too_long'))
+        await message.answer(t(lang, 'import.too_long'))
         return
 
     async with async_session_maker() as session:
@@ -67,9 +75,10 @@ async def process_text(message: Message, state: FSMContext):
         processing_msg = await message.answer(t(user.language_interface or 'ru', 'import.processing'))
 
         # Извлекаем слова через AI
+        current_level = get_user_level_for_language(user)
         words = await ai_service.extract_words_from_text(
             text=text,
-            level=user.level.value,
+            level=current_level,
             max_words=15,
             learning_lang=user.learning_language,
             translation_lang=user.language_interface,
@@ -87,7 +96,7 @@ async def process_text(message: Message, state: FSMContext):
             words=words,
             user_id=user.id,
             original_text=text,
-            level=user.level.name
+            level=current_level
         )
         await state.set_state(ImportStates.viewing_words)
 

bot/handlers/level_test.py

@@ -5,9 +5,10 @@ from aiogram.fsm.context import FSMContext
 from aiogram.fsm.state import State, StatesGroup
 
 from database.db import async_session_maker
-from database.models import LanguageLevel
 from services.user_service import UserService
 from services.ai_service import ai_service
+from utils.i18n import t, get_user_lang
+from utils.levels import get_level_system, get_available_levels, CEFR_LEVELS, JLPT_LEVELS
 
 router = Router()
 
@@ -58,28 +59,31 @@ async def begin_test(callback: CallbackQuery, state: FSMContext):
     await callback.answer()
     await callback.message.delete()
 
-    # Показываем индикатор загрузки
-    loading_msg = await callback.message.answer("🔄 Генерирую вопросы...")
+    async with async_session_maker() as session:
+        user = await UserService.get_user_by_telegram_id(session, callback.from_user.id)
+    lang = get_user_lang(user)
+    learning_lang = getattr(user, 'learning_language', 'en') or 'en'
 
-    # Генерируем тест через AI
-    questions = await ai_service.generate_level_test()
+    # Показываем индикатор загрузки
+    loading_msg = await callback.message.answer(t(lang, 'level_test_extra.generating'))
+
+    # Генерируем тест через AI с учётом языка изучения
+    questions = await ai_service.generate_level_test(learning_lang)
 
     await loading_msg.delete()
 
     if not questions:
-        await callback.message.answer(
-            "❌ Не удалось сгенерировать тест. Попробуй позже или используй /settings для ручной установки уровня."
-        )
+        await callback.message.answer(t(lang, 'level_test_extra.generate_failed'))
         await state.clear()
-        await callback.answer()
         return
 
-    # Сохраняем данные в состоянии
+    # Сохраняем данные в состоянии (включая язык для определения системы уровней)
     await state.update_data(
         questions=questions,
         current_question=0,
         correct_answers=0,
-        answers=[]  # Для отслеживания ответов по уровням
+        answers=[],  # Для отслеживания ответов по уровням
+        learning_language=learning_lang
     )
     await state.set_state(LevelTestStates.taking_test)
 
@@ -138,32 +142,35 @@ async def show_question(message: Message, state: FSMContext):
 @router.callback_query(F.data.startswith("show_qtr_"), LevelTestStates.taking_test)
 async def show_question_translation(callback: CallbackQuery, state: FSMContext):
     """Показать перевод текущего вопроса"""
+    async with async_session_maker() as session:
+        user = await UserService.get_user_by_telegram_id(session, callback.from_user.id)
+    lang = get_user_lang(user)
+
     try:
         idx = int(callback.data.split("_")[-1])
     except Exception:
-        await callback.answer("Перевод недоступен", show_alert=True)
+        await callback.answer(t(lang, 'level_test_extra.translation_unavailable'), show_alert=True)
         return
 
     data = await state.get_data()
     questions = data.get('questions', [])
     if not (0 <= idx < len(questions)):
-        await callback.answer("Перевод недоступен", show_alert=True)
+        await callback.answer(t(lang, 'level_test_extra.translation_unavailable'), show_alert=True)
         return
 
-    ru = questions[idx].get('question_ru') or "Перевод недоступен"
+    ru = questions[idx].get('question_ru') or t(lang, 'level_test_extra.translation_unavailable')
 
     # Вставляем перевод в текущий текст сообщения
     orig = callback.message.text or ""
-    marker = "Перевод вопроса:"
+    marker = t(lang, 'level_test_extra.translation_marker')
     if marker in orig:
-        await callback.answer("Перевод уже показан")
+        await callback.answer(t(lang, 'level_test_extra.translation_already'))
         return
 
     new_text = f"{orig}\n{marker} <i>{ru}</i>"
     try:
         await callback.message.edit_text(new_text, reply_markup=callback.message.reply_markup)
     except Exception:
-        # Запасной путь, если редактирование невозможно
         await callback.message.answer(f"{marker} <i>{ru}</i>")
     await callback.answer()
 
@@ -171,6 +178,10 @@ async def show_question_translation(callback: CallbackQuery, state: FSMContext):
 @router.callback_query(F.data.startswith("answer_"), LevelTestStates.taking_test)
 async def process_answer(callback: CallbackQuery, state: FSMContext):
     """Обработать ответ на вопрос"""
+    async with async_session_maker() as session:
+        user = await UserService.get_user_by_telegram_id(session, callback.from_user.id)
+    lang = get_user_lang(user)
+
     answer_idx = int(callback.data.split("_")[1])
 
     data = await state.get_data()
@@ -194,14 +205,14 @@ async def process_answer(callback: CallbackQuery, state: FSMContext):
 
     # Показываем результат
     if is_correct:
-        result_text = "✅ Правильно!"
+        result_text = t(lang, 'level_test_extra.correct')
     else:
         correct_option = question['options'][question['correct']]
-        result_text = f"❌ Неправильно\nПравильный ответ: <b>{correct_option}</b>"
+        result_text = t(lang, 'level_test_extra.incorrect') + "\n" + t(lang, 'level_test_extra.correct_answer', answer=correct_option)
 
     await callback.message.edit_text(
-        f"❓ <b>Вопрос {current_idx + 1} из {len(questions)}</b>\n\n"
-        f"{result_text}"
+        t(lang, 'level_test.q_header', i=current_idx + 1, n=len(questions)) + "\n\n" +
+        result_text
     )
 
     # Переходим к следующему вопросу
@@ -225,65 +236,61 @@ async def finish_test(message: Message, state: FSMContext):
     questions = data.get('questions', [])
     correct_answers = data.get('correct_answers', 0)
     answers = data.get('answers', [])
+    learning_lang = data.get('learning_language', 'en')
 
     total = len(questions)
     accuracy = int((correct_answers / total) * 100) if total > 0 else 0
 
     # Определяем уровень на основе правильных ответов по уровням
-    level = determine_level(answers)
+    level = determine_level(answers, learning_lang)
 
     # Сохраняем уровень в базе данных
     async with async_session_maker() as session:
         user = await UserService.get_user_by_telegram_id(session, message.chat.id)
         if user:
-            user.level = level
-            await session.commit()
+            await UserService.update_user_level(session, user.id, level, learning_lang)
 
-    # Описания уровней
-    level_descriptions = {
-        "A1": "Начальный - понимаешь основные фразы и можешь представиться",
-        "A2": "Элементарный - можешь общаться на простые темы",
-        "B1": "Средний - можешь поддержать беседу на знакомые темы",
-        "B2": "Выше среднего - свободно общаешься в большинстве ситуаций",
-        "C1": "Продвинутый - используешь язык гибко и эффективно",
-        "C2": "Профессиональный - владеешь языком на уровне носителя"
-    }
+    lang = get_user_lang(user)
+    level_desc = t(lang, f'level_test_extra.level_desc.{level}')
 
     await state.clear()
 
     result_text = (
-        f"🎉 <b>Тест завершён!</b>\n\n"
-        f"📊 Результаты:\n"
-        f"Правильных ответов: <b>{correct_answers}</b> из {total}\n"
-        f"Точность: <b>{accuracy}%</b>\n\n"
-        f"🎯 Твой уровень: <b>{level.value}</b>\n"
-        f"<i>{level_descriptions.get(level.value, '')}</i>\n\n"
-        f"Теперь задания и материалы будут подбираться под твой уровень!\n"
-        f"Ты можешь изменить уровень в любое время через /settings"
+        t(lang, 'level_test_extra.result_title') +
+        t(lang, 'level_test_extra.results_header') +
+        t(lang, 'level_test_extra.correct_count', correct=correct_answers, total=total) +
+        t(lang, 'level_test_extra.accuracy', accuracy=accuracy) +
+        t(lang, 'level_test_extra.your_level', level=level) +
+        f"<i>{level_desc}</i>\n\n" +
+        t(lang, 'level_test_extra.level_set_hint')
     )
 
     await message.answer(result_text)
 
 
-def determine_level(answers: list) -> LanguageLevel:
+def determine_level(answers: list, learning_language: str = "en") -> str:
     """
     Определить уровень на основе ответов
 
     Args:
         answers: Список ответов с уровнями
+        learning_language: Язык изучения для выбора системы уровней
 
     Returns:
-        Определённый уровень
+        Определённый уровень (строка: A1-C2 или N5-N1)
     """
+    # Выбираем систему уровней
+    level_system = get_level_system(learning_language)
+
+    if level_system == "jlpt":
+        levels_order = JLPT_LEVELS  # ["N5", "N4", "N3", "N2", "N1"]
+        default_level = "N5"
+    else:
+        levels_order = CEFR_LEVELS  # ["A1", "A2", "B1", "B2", "C1", "C2"]
+        default_level = "A1"
+
     # Подсчитываем правильные ответы по уровням
-    level_stats = {
-        'A1': {'correct': 0, 'total': 0},
-        'A2': {'correct': 0, 'total': 0},
-        'B1': {'correct': 0, 'total': 0},
-        'B2': {'correct': 0, 'total': 0},
-        'C1': {'correct': 0, 'total': 0},
-        'C2': {'correct': 0, 'total': 0}
-    }
+    level_stats = {level: {'correct': 0, 'total': 0} for level in levels_order}
 
     for answer in answers:
         level = answer['level']
@@ -293,8 +300,7 @@ def determine_level(answers: list) -> LanguageLevel:
                 level_stats[level]['correct'] += 1
 
     # Определяем уровень: ищем последний уровень, где правильно >= 50%
-    levels_order = ['A1', 'A2', 'B1', 'B2', 'C1', 'C2']
-    determined_level = 'A1'
+    determined_level = default_level
 
     for level in levels_order:
         if level_stats[level]['total'] > 0:
@@ -305,4 +311,4 @@ def determine_level(answers: list) -> LanguageLevel:
                 # Если не прошёл этот уровень, останавливаемся
                 break
 
-    return LanguageLevel[determined_level]
+    return determined_level

bot/handlers/practice.py

@@ -7,7 +7,8 @@ from aiogram.fsm.state import State, StatesGroup
 from database.db import async_session_maker
 from services.user_service import UserService
 from services.ai_service import ai_service
-from utils.i18n import t
+from utils.i18n import t, get_user_lang
+from utils.levels import get_user_level_for_language
 
 router = Router()
 
@@ -15,18 +16,17 @@ router = Router()
 class PracticeStates(StatesGroup):
     """Состояния для диалоговой практики"""
     choosing_scenario = State()
+    entering_custom_scenario = State()
     in_conversation = State()
 
 
-# Доступные сценарии
-SCENARIOS = {
-    "restaurant": {"ru": "🍽️ Ресторан", "en": "🍽️ Restaurant", "ja": "🍽️ レストラン"},
-    "shopping":   {"ru": "🛍️ Магазин",  "en": "🛍️ Shopping",   "ja": "🛍️ ショッピング"},
-    "travel":     {"ru": "✈️ Путешествие","en": "✈️ Travel",     "ja": "✈️ 旅行"},
-    "work":       {"ru": "💼 Работа",    "en": "💼 Work",       "ja": "💼 仕事"},
-    "doctor":     {"ru": "🏥 Врач",      "en": "🏥 Doctor",     "ja": "🏥 医者"},
-    "casual":     {"ru": "💬 Общение",   "en": "💬 Casual",     "ja": "💬 会話"}
-}
+# Доступные сценарии (ключи для i18n)
+SCENARIO_KEYS = ["restaurant", "shopping", "travel", "work", "doctor", "casual"]
+
+
+def get_scenario_name(lang: str, scenario: str) -> str:
+    """Получить локализованное название сценария"""
+    return t(lang, f'practice.scenario.{scenario}')
 
 
 @router.message(Command("practice"))
@@ -39,23 +39,167 @@ async def cmd_practice(message: Message, state: FSMContext):
             await message.answer(t('ru', 'common.start_first'))
             return
 
+        lang = get_user_lang(user)
+
         # Показываем выбор сценария
         keyboard = []
-        lang = user.language_interface or 'ru'
-        for scenario_id, names in SCENARIOS.items():
+        for scenario_id in SCENARIO_KEYS:
             keyboard.append([
                 InlineKeyboardButton(
-                    text=names.get(lang, names.get('ru')),
+                    text=get_scenario_name(lang, scenario_id),
                     callback_data=f"scenario_{scenario_id}"
                 )
             ])
+        # Кнопка для своего сценария
+        keyboard.append([
+            InlineKeyboardButton(
+                text=t(lang, 'practice.custom_scenario_btn'),
+                callback_data="scenario_custom"
+            )
+        ])
 
         reply_markup = InlineKeyboardMarkup(inline_keyboard=keyboard)
 
-        await state.update_data(user_id=user.id, level=user.level.value)
+        await state.update_data(user_id=user.id, level=get_user_level_for_language(user))
         await state.set_state(PracticeStates.choosing_scenario)
 
-        await message.answer(t(user.language_interface or 'ru', 'practice.start_text'), reply_markup=reply_markup)
+        await message.answer(t(lang, 'practice.start_text'), reply_markup=reply_markup)
+
+
+@router.callback_query(F.data == "scenario_custom", PracticeStates.choosing_scenario)
+async def request_custom_scenario(callback: CallbackQuery, state: FSMContext):
+    """Запросить ввод своего сценария"""
+    await callback.answer()
+    async with async_session_maker() as session:
+        user = await UserService.get_user_by_telegram_id(session, callback.from_user.id)
+    lang = get_user_lang(user)
+
+    await callback.message.edit_text(
+        t(lang, 'practice.custom_scenario_prompt'),
+        reply_markup=InlineKeyboardMarkup(inline_keyboard=[
+            [InlineKeyboardButton(text=t(lang, 'settings.back'), callback_data="back_to_scenarios")]
+        ])
+    )
+    await state.set_state(PracticeStates.entering_custom_scenario)
+
+
+@router.callback_query(F.data == "back_to_scenarios", PracticeStates.entering_custom_scenario)
+async def back_to_scenarios(callback: CallbackQuery, state: FSMContext):
+    """Вернуться к выбору сценариев"""
+    await callback.answer()
+    async with async_session_maker() as session:
+        user = await UserService.get_user_by_telegram_id(session, callback.from_user.id)
+    lang = get_user_lang(user)
+
+    keyboard = []
+    for scenario_id in SCENARIO_KEYS:
+        keyboard.append([
+            InlineKeyboardButton(
+                text=get_scenario_name(lang, scenario_id),
+                callback_data=f"scenario_{scenario_id}"
+            )
+        ])
+    keyboard.append([
+        InlineKeyboardButton(
+            text=t(lang, 'practice.custom_scenario_btn'),
+            callback_data="scenario_custom"
+        )
+    ])
+
+    await callback.message.edit_text(
+        t(lang, 'practice.start_text'),
+        reply_markup=InlineKeyboardMarkup(inline_keyboard=keyboard)
+    )
+    await state.set_state(PracticeStates.choosing_scenario)
+
+
+@router.message(PracticeStates.entering_custom_scenario)
+async def handle_custom_scenario(message: Message, state: FSMContext):
+    """Обработка ввода своего сценария"""
+    custom_scenario = message.text.strip()
+
+    if not custom_scenario or len(custom_scenario) < 3:
+        async with async_session_maker() as session:
+            user = await UserService.get_user_by_telegram_id(session, message.from_user.id)
+        lang = get_user_lang(user)
+        await message.answer(t(lang, 'practice.custom_scenario_too_short'))
+        return
+
+    data = await state.get_data()
+    level = data.get('level', 'B1')
+
+    async with async_session_maker() as session:
+        user = await UserService.get_user_by_telegram_id(session, message.from_user.id)
+    ui_lang = get_user_lang(user)
+    learn_lang = (user.learning_language if user else 'en') or 'en'
+
+    # Показываем индикатор
+    thinking_msg = await message.answer(t(ui_lang, 'practice.thinking_prepare'))
+
+    # Начинаем диалог с кастомным сценарием
+    conversation_start = await ai_service.start_conversation(
+        custom_scenario,  # Передаём описание сценария напрямую
+        level,
+        learning_lang=learn_lang,
+        translation_lang=ui_lang
+    )
+
+    await thinking_msg.delete()
+
+    # Сохраняем данные в состоянии
+    await state.update_data(
+        scenario=custom_scenario,
+        scenario_name=custom_scenario,
+        conversation_history=[],
+        message_count=0
+    )
+    await state.set_state(PracticeStates.in_conversation)
+
+    # Формируем сообщение
+    ai_msg = conversation_start.get('message', '')
+    if learn_lang.lower() == 'ja':
+        annotated = conversation_start.get('message_annotated')
+        if annotated:
+            ai_msg = annotated
+        else:
+            fg = conversation_start.get('furigana')
+            if fg:
+                ai_msg = f"{ai_msg} ({fg})"
+
+    text = (
+        f"<b>🎭 {custom_scenario}</b>\n\n"
+        f"📝 <i>{conversation_start.get('context', '')}</i>\n\n"
+        f"<b>AI:</b> {ai_msg}\n\n"
+        f"{t(ui_lang, 'practice.hints')}\n"
+    )
+
+    for suggestion in conversation_start.get('suggestions', []):
+        if isinstance(suggestion, dict):
+            if learn_lang.lower() == 'ja':
+                learn_text = suggestion.get('learn_annotated') or suggestion.get('learn') or ''
+            else:
+                learn_text = suggestion.get('learn') or ''
+            trans_text = suggestion.get('trans') or ''
+        else:
+            learn_text = str(suggestion)
+            trans_text = ''
+        if trans_text:
+            text += f"<span class=\"tg-spoiler\">• {learn_text}</span> ({trans_text})\n"
+        else:
+            text += f"<span class=\"tg-spoiler\">• {learn_text}</span>\n"
+
+    text += t(ui_lang, 'practice.write_or_stop')
+
+    # Сохраняем перевод
+    translations = {0: conversation_start.get('translation', '')}
+    await state.update_data(translations=translations)
+
+    keyboard = InlineKeyboardMarkup(inline_keyboard=[
+        [InlineKeyboardButton(text=t(ui_lang, 'practice.show_translation_btn'), callback_data="show_tr_0")],
+        [InlineKeyboardButton(text=t(ui_lang, 'practice.stop_btn'), callback_data="stop_practice")]
+    ])
+
+    await message.answer(text, reply_markup=keyboard)
 
 
 @router.callback_query(F.data.startswith("scenario_"), PracticeStates.choosing_scenario)
@@ -69,7 +213,7 @@ async def start_scenario(callback: CallbackQuery, state: FSMContext):
     # Определяем языки пользователя
     async with async_session_maker() as session:
         user = await UserService.get_user_by_telegram_id(session, callback.from_user.id)
-    ui_lang = (user.language_interface if user else 'ru') or 'ru'
+    ui_lang = get_user_lang(user)
     learn_lang = (user.learning_language if user else 'en') or 'en'
 
     # Удаляем клавиатуру
@@ -91,7 +235,7 @@ async def start_scenario(callback: CallbackQuery, state: FSMContext):
     # Сохраняем данные в состоянии
     await state.update_data(
         scenario=scenario,
-        scenario_name=SCENARIOS[scenario],
+        scenario_name=scenario,
         conversation_history=[],
         message_count=0
     )
@@ -110,7 +254,7 @@ async def start_scenario(callback: CallbackQuery, state: FSMContext):
                 ai_msg = f"{ai_msg} ({fg})"
 
     text = (
-        f"<b>{SCENARIOS[scenario].get(ui_lang, SCENARIOS[scenario]['ru'])}</b>\n\n"
+        f"<b>{get_scenario_name(ui_lang, scenario)}</b>\n\n"
         f"📝 <i>{conversation_start.get('context', '')}</i>\n\n"
         f"<b>AI:</b> {ai_msg}\n\n"
         f"{t(ui_lang, 'practice.hints')}\n"
@@ -148,6 +292,17 @@ async def start_scenario(callback: CallbackQuery, state: FSMContext):
     await callback.message.answer(text, reply_markup=keyboard)
 
 
+def get_end_keyboard(lang: str) -> InlineKeyboardMarkup:
+    """Клавиатура после завершения диалога"""
+    return InlineKeyboardMarkup(inline_keyboard=[
+        [InlineKeyboardButton(text=t(lang, 'practice.new_practice_btn'), callback_data="new_practice")],
+        [
+            InlineKeyboardButton(text=t(lang, 'practice.to_tasks_btn'), callback_data="go_tasks"),
+            InlineKeyboardButton(text=t(lang, 'practice.to_words_btn'), callback_data="go_words")
+        ]
+    ])
+
+
 @router.message(Command("stop"), PracticeStates.in_conversation)
 async def stop_practice(message: Message, state: FSMContext):
     """Завершить диалоговую практику"""
@@ -161,10 +316,9 @@ async def stop_practice(message: Message, state: FSMContext):
     end_text = (
         t(lang, 'practice.end_title') + "\n\n" +
         t(lang, 'practice.end_exchanged', n=message_count) + "\n\n" +
-        t(lang, 'practice.end_keep') + "\n" +
-        t(lang, 'practice.end_hint')
+        t(lang, 'practice.end_keep')
     )
-    await message.answer(end_text)
+    await message.answer(end_text, reply_markup=get_end_keyboard(lang))
 
 
 @router.callback_query(F.data == "stop_practice", PracticeStates.in_conversation)
@@ -182,13 +336,72 @@ async def stop_practice_callback(callback: CallbackQuery, state: FSMContext):
     end_text = (
         t(lang, 'practice.end_title') + "\n\n" +
         t(lang, 'practice.end_exchanged', n=message_count) + "\n\n" +
-        t(lang, 'practice.end_keep') + "\n" +
-        t(lang, 'practice.end_hint')
+        t(lang, 'practice.end_keep')
     )
-    await callback.message.answer(end_text)
+    await callback.message.answer(end_text, reply_markup=get_end_keyboard(lang))
     await callback.answer()
 
 
+@router.callback_query(F.data == "new_practice")
+async def new_practice_callback(callback: CallbackQuery, state: FSMContext):
+    """Начать новую практику"""
+    await callback.answer()
+
+    async with async_session_maker() as session:
+        user = await UserService.get_user_by_telegram_id(session, callback.from_user.id)
+
+    if not user:
+        await callback.message.edit_text(t('ru', 'common.start_first'))
+        return
+
+    lang = get_user_lang(user)
+
+    # Показываем выбор сценария
+    keyboard = []
+    for scenario_id in SCENARIO_KEYS:
+        keyboard.append([
+            InlineKeyboardButton(
+                text=get_scenario_name(lang, scenario_id),
+                callback_data=f"scenario_{scenario_id}"
+            )
+        ])
+    keyboard.append([
+        InlineKeyboardButton(
+            text=t(lang, 'practice.custom_scenario_btn'),
+            callback_data="scenario_custom"
+        )
+    ])
+
+    reply_markup = InlineKeyboardMarkup(inline_keyboard=keyboard)
+
+    await state.update_data(user_id=user.id, level=get_user_level_for_language(user))
+    await state.set_state(PracticeStates.choosing_scenario)
+
+    await callback.message.edit_text(t(lang, 'practice.start_text'), reply_markup=reply_markup)
+
+
+@router.callback_query(F.data == "go_tasks")
+async def go_tasks_callback(callback: CallbackQuery):
+    """Перейти к заданиям"""
+    await callback.message.delete()
+    await callback.answer()
+    async with async_session_maker() as session:
+        user = await UserService.get_user_by_telegram_id(session, callback.from_user.id)
+    lang = (user.language_interface if user else 'ru') or 'ru'
+    await callback.message.answer(t(lang, 'practice.go_tasks_hint'))
+
+
+@router.callback_query(F.data == "go_words")
+async def go_words_callback(callback: CallbackQuery):
+    """Перейти к словам"""
+    await callback.message.delete()
+    await callback.answer()
+    async with async_session_maker() as session:
+        user = await UserService.get_user_by_telegram_id(session, callback.from_user.id)
+    lang = (user.language_interface if user else 'ru') or 'ru'
+    await callback.message.answer(t(lang, 'practice.go_words_hint'))
+
+
 @router.message(PracticeStates.in_conversation)
 async def handle_conversation(message: Message, state: FSMContext):
     """Обработка сообщений в диалоге"""

bot/handlers/settings.py

@@ -4,52 +4,39 @@ from aiogram.types import Message, CallbackQuery, InlineKeyboardMarkup, InlineKe
 from aiogram.fsm.context import FSMContext
 
 from database.db import async_session_maker
-from database.models import LanguageLevel
 from bot.handlers.start import main_menu_keyboard
 from services.user_service import UserService
+from utils.i18n import t, get_user_lang
+from utils.levels import (
+    get_user_level_for_language,
+    get_available_levels,
+    get_level_system,
+    get_level_key_for_i18n,
+)
 
 router = Router()
 
 
-def _is_en(user) -> bool:
-    try:
-        return (getattr(user, 'language_interface', 'ru') or 'ru') == 'en'
-    except Exception:
-        return False
-
-
-def _is_ja(user) -> bool:
-    try:
-        return (getattr(user, 'language_interface', 'ru') or 'ru') == 'ja'
-    except Exception:
-        return False
-
-
 def get_settings_keyboard(user) -> InlineKeyboardMarkup:
     """Создать клавиатуру настроек"""
-    is_en = _is_en(user)
-    is_ja = _is_ja(user)
+    lang = get_user_lang(user)
+    ui_lang_code = getattr(user, 'language_interface', 'ru') or 'ru'
+    current_level = get_user_level_for_language(user)
     keyboard = InlineKeyboardMarkup(inline_keyboard=[
         [InlineKeyboardButton(
-            text=(
-                "📊 Level: " if is_en else ("📊 レベル: " if is_ja else "📊 Уровень: ")
-            ) + f"{user.level.value}",
+            text=t(lang, 'settings.level_prefix') + f"{current_level}",
             callback_data="settings_level"
         )],
         [InlineKeyboardButton(
-            text=(
-                "🎯 Learning language: " if is_en else ("🎯 学習言語: " if is_ja else "🎯 Язык изучения: ")
-            ) + (user.learning_language.upper()),
+            text=t(lang, 'settings.learning_prefix') + user.learning_language.upper(),
             callback_data="settings_learning"
         )],
         [InlineKeyboardButton(
-            text=(
-                "🌐 Interface language: " if is_en else ("🌐 インターフェース言語: " if is_ja else "🌐 Язык интерфейса: ")
-            ) + ("🇬🇧 English" if getattr(user, 'language_interface', 'ru') == 'en' else ("🇯🇵 日本語" if getattr(user, 'language_interface', 'ru') == 'ja' else "🇷🇺 Русский")),
+            text=t(lang, 'settings.interface_prefix') + t(lang, f'settings.lang_name.{ui_lang_code}'),
             callback_data="settings_language"
         )],
         [InlineKeyboardButton(
-            text=("❌ Close" if is_en else ("❌ 閉じる" if is_ja else "❌ Закрыть")),
+            text=t(lang, 'settings.close'),
             callback_data="settings_close"
         )]
     ])
@@ -57,75 +44,49 @@ def get_settings_keyboard(user) -> InlineKeyboardMarkup:
 
 
 def get_level_keyboard(user=None) -> InlineKeyboardMarkup:
-    """Клавиатура выбора уровня"""
-    lang = getattr(user, 'language_interface', 'ru') if user is not None else 'ru'
-    if lang == 'en':
-        levels = [
-            ("A1 - Beginner", "set_level_A1"),
-            ("A2 - Elementary", "set_level_A2"),
-            ("B1 - Intermediate", "set_level_B1"),
-            ("B2 - Upper-intermediate", "set_level_B2"),
-            ("C1 - Advanced", "set_level_C1"),
-            ("C2 - Proficient", "set_level_C2"),
-        ]
-    elif lang == 'ja':
-        levels = [
-            ("A1 - 初級", "set_level_A1"),
-            ("A2 - 初級(上)", "set_level_A2"),
-            ("B1 - 中級", "set_level_B1"),
-            ("B2 - 中級(上)", "set_level_B2"),
-            ("C1 - 上級", "set_level_C1"),
-            ("C2 - ネイティブ", "set_level_C2"),
-        ]
-    else:
-        levels = [
-            ("A1 - Начальный", "set_level_A1"),
-            ("A2 - Элементарный", "set_level_A2"),
-            ("B1 - Средний", "set_level_B1"),
-            ("B2 - Выше среднего", "set_level_B2"),
-            ("C1 - Продвинутый", "set_level_C1"),
-            ("C2 - Профессиональный", "set_level_C2"),
-        ]
+    """Клавиатура выбора уровня (CEFR или JLPT в зависимости от языка изучения)"""
+    lang = get_user_lang(user)
+    learning_lang = getattr(user, 'learning_language', 'en') or 'en'
+    available_levels = get_available_levels(learning_lang)
 
     keyboard = []
-    for level_name, callback_data in levels:
-        keyboard.append([InlineKeyboardButton(text=level_name, callback_data=callback_data)])
+    for level in available_levels:
+        # Ключ локализации: settings.level.a1 или settings.jlpt.n5
+        i18n_key = get_level_key_for_i18n(learning_lang, level)
+        level_name = t(lang, i18n_key)
+        keyboard.append([InlineKeyboardButton(text=level_name, callback_data=f"set_level_{level}")])
 
-    back_label = "⬅️ Back" if lang == 'en' else ("⬅️ 戻る" if lang == 'ja' else "⬅️ Назад")
-    keyboard.append([InlineKeyboardButton(text=back_label, callback_data="settings_back")])
+    keyboard.append([InlineKeyboardButton(text=t(lang, 'settings.back'), callback_data="settings_back")])
 
     return InlineKeyboardMarkup(inline_keyboard=keyboard)
 
 
 def get_language_keyboard(user=None) -> InlineKeyboardMarkup:
     """Клавиатура выбора языка интерфейса"""
-    lang = getattr(user, 'language_interface', 'ru') if user is not None else 'ru'
-    back = "⬅️ Back" if lang == 'en' else ("⬅️ 戻る" if lang == 'ja' else "⬅️ Назад")
+    lang = get_user_lang(user)
     keyboard = InlineKeyboardMarkup(inline_keyboard=[
-        [InlineKeyboardButton(text="🇷🇺 Русский", callback_data="set_lang_ru")],
-        [InlineKeyboardButton(text="🇬🇧 English", callback_data="set_lang_en")],
-        [InlineKeyboardButton(text="🇯🇵 日本語", callback_data="set_lang_ja")],
-        [InlineKeyboardButton(text=back, callback_data="settings_back")]
+        [InlineKeyboardButton(text=t(lang, 'settings.lang_name.ru'), callback_data="set_lang_ru")],
+        [InlineKeyboardButton(text=t(lang, 'settings.lang_name.en'), callback_data="set_lang_en")],
+        [InlineKeyboardButton(text=t(lang, 'settings.lang_name.ja'), callback_data="set_lang_ja")],
+        [InlineKeyboardButton(text=t(lang, 'settings.back'), callback_data="settings_back")]
     ])
     return keyboard
 
 
 def get_learning_language_keyboard(user=None) -> InlineKeyboardMarkup:
     """Клавиатура выбора языка изучения"""
-    lang = getattr(user, 'language_interface', 'ru') if user is not None else 'ru'
-    back = "⬅️ Back" if lang == 'en' else ("⬅️ 戻る" if lang == 'ja' else "⬅️ Назад")
+    lang = get_user_lang(user)
 
-    # Пары (код -> подпись)
     options = [
-        ("en", "🇬🇧 English" if lang != 'ja' else "🇬🇧 英語"),
-        ("es", "🇪🇸 Spanish" if lang == 'en' else ("🇪🇸 スペイン語" if lang == 'ja' else "🇪🇸 Испанский")),
-        ("de", "🇩🇪 German" if lang == 'en' else ("🇩🇪 ドイツ語" if lang == 'ja' else "🇩🇪 Немецкий")),
-        ("fr", "🇫🇷 French" if lang == 'en' else ("🇫🇷 フランス語" if lang == 'ja' else "🇫🇷 Французский")),
-        ("ja", "🇯🇵 Japanese" if lang == 'en' else ("🇯🇵 日本語" if lang == 'ja' else "🇯🇵 Японский")),
+        ("en", t(lang, 'settings.learning_lang.en')),
+        ("es", t(lang, 'settings.learning_lang.es')),
+        ("de", t(lang, 'settings.learning_lang.de')),
+        ("fr", t(lang, 'settings.learning_lang.fr')),
+        ("ja", t(lang, 'settings.learning_lang.ja')),
     ]
 
     keyboard = [[InlineKeyboardButton(text=label, callback_data=f"set_learning_{code}")] for code, label in options]
-    keyboard.append([InlineKeyboardButton(text=back, callback_data="settings_back")])
+    keyboard.append([InlineKeyboardButton(text=t(lang, 'settings.back'), callback_data="settings_back")])
     return InlineKeyboardMarkup(inline_keyboard=keyboard)
 
 
@@ -136,16 +97,19 @@ async def cmd_settings(message: Message):
         user = await UserService.get_user_by_telegram_id(session, message.from_user.id)
 
         if not user:
-            await message.answer("Сначала запусти бота командой /start")
+            await message.answer(t('ru', 'common.start_first'))
             return
 
-        lang = getattr(user, 'language_interface', 'ru')
-        title = "⚙️ <b>Settings</b>\n\n" if lang == 'en' else ("⚙️ <b>設定</b>\n\n" if lang == 'ja' else "⚙️ <b>Настройки</b>\n\n")
-        level_label = "📊 English level: " if lang == 'en' else ("📊 英語レベル: " if lang == 'ja' else "📊 Уровень английского: ")
-        lang_label = "🌐 Interface language: " if lang == 'en' else ("🌐 インターフェース言語: " if lang == 'ja' else "🌐 Язык интерфейса: ")
-        lang_value = 'English' if lang == 'en' else ('日本語' if lang == 'ja' else ('Русский' if user.language_interface == 'ru' else 'English'))
-        footer = "Choose what to change:" if lang == 'en' else ("変更したい項目を選択:" if lang == 'ja' else "Выбери, что хочешь изменить:")
-        settings_text = f"{title}{level_label}<b>{user.level.value}</b>\n{lang_label}<b>{lang_value}</b>\n\n{footer}"
+        lang = get_user_lang(user)
+        ui_lang_code = getattr(user, 'language_interface', 'ru') or 'ru'
+        lang_value = t(lang, f'settings.lang_name.{ui_lang_code}')
+        current_level = get_user_level_for_language(user)
+        settings_text = (
+            t(lang, 'settings.title') +
+            t(lang, 'settings.level_prefix') + f"<b>{current_level}</b>\n" +
+            t(lang, 'settings.interface_prefix') + f"<b>{lang_value}</b>\n\n" +
+            t(lang, 'settings.choose')
+        )
 
         await message.answer(settings_text, reply_markup=get_settings_keyboard(user))
 
@@ -155,15 +119,13 @@ async def settings_level(callback: CallbackQuery):
     """Показать выбор уровня"""
     async with async_session_maker() as session:
         user = await UserService.get_user_by_telegram_id(session, callback.from_user.id)
-    lang = getattr(user, 'language_interface', 'ru') if user else 'ru'
-    title = "📊 <b>Choose your English level:</b>\n\n" if lang == 'en' else ("📊 <b>英語レベルを選択:</b>\n\n" if lang == 'ja' else "📊 <b>Выбери свой уровень английского:</b>\n\n")
-    body = (
-        "<b>A1-A2</b> - Beginner\n<b>B1-B2</b> - Intermediate\n<b>C1-C2</b> - Advanced\n\n" if lang == 'en' else (
-        "<b>A1-A2</b> - 初級\n<b>B1-B2</b> - 中級\n<b>C1-C2</b> - 上級\n\n" if lang == 'ja' else 
-        "<b>A1-A2</b> - Начинающий\n<b>B1-B2</b> - Средний\n<b>C1-C2</b> - Продвинутый\n\n"
-    ))
-    tail = "This affects difficulty of suggested words and tasks." if lang == 'en' else ("これは提案される単語や課題の難易度に影響します。" if lang == 'ja' else "Это влияет на сложность предлагаемых слов и заданий.")
-    await callback.message.edit_text(title + body + tail, reply_markup=get_level_keyboard(user))
+    lang = get_user_lang(user)
+    learning_lang = getattr(user, 'learning_language', 'en') or 'en'
+    level_system = get_level_system(learning_lang)
+    # Выбираем правильное описание групп уровней
+    groups_key = 'settings.jlpt_groups' if level_system == 'jlpt' else 'settings.level_groups'
+    text = t(lang, 'settings.level_title') + t(lang, groups_key) + t(lang, 'settings.level_hint')
+    await callback.message.edit_text(text, reply_markup=get_level_keyboard(user))
     await callback.answer()
 
 
@@ -172,9 +134,8 @@ async def settings_learning(callback: CallbackQuery):
     """Показать выбор языка изучения"""
     async with async_session_maker() as session:
         user = await UserService.get_user_by_telegram_id(session, callback.from_user.id)
-    lang = getattr(user, 'language_interface', 'ru') if user else 'ru'
-    title = "🎯 <b>Select learning language:</b>\n\n" if lang == 'en' else ("🎯 <b>学習言語を選択:</b>\n\n" if lang == 'ja' else "🎯 <b>Выбери язык изучения:</b>\n\n")
-    await callback.message.edit_text(title, reply_markup=get_learning_language_keyboard(user))
+    lang = get_user_lang(user)
+    await callback.message.edit_text(t(lang, 'settings.learning_title'), reply_markup=get_learning_language_keyboard(user))
     await callback.answer()
 
 
@@ -186,42 +147,32 @@ async def set_learning_language(callback: CallbackQuery):
         user = await UserService.get_user_by_telegram_id(session, callback.from_user.id)
         if user:
             await UserService.update_user_learning_language(session, user.id, code)
-            lang = getattr(user, 'language_interface', 'ru')
-            if lang == 'en':
-                text = f"✅ Learning language: <b>{code.upper()}</b>"
-                back = "⬅️ Back to settings"
-            elif lang == 'ja':
-                text = f"✅ 学習言語: <b>{code.upper()}</b>"
-                back = "⬅️ 設定に戻る"
-            else:
-                text = f"✅ Язык изучения: <b>{code.upper()}</b>"
-                back = "⬅️ К настройкам"
+            lang = get_user_lang(user)
+            text = t(lang, 'settings.learning_changed', code=code.upper())
             await callback.message.edit_text(
                 text,
-                reply_markup=InlineKeyboardMarkup(inline_keyboard=[[InlineKeyboardButton(text=back, callback_data="settings_back")]])
+                reply_markup=InlineKeyboardMarkup(inline_keyboard=[[InlineKeyboardButton(text=t(lang, 'settings.back_to_settings'), callback_data="settings_back")]])
             )
     await callback.answer()
 
 
 @router.callback_query(F.data.startswith("set_level_"))
 async def set_level(callback: CallbackQuery):
-    """Установить уровень"""
-    level_str = callback.data.split("_")[-1]  # A1, A2, B1, B2, C1, C2
+    """Установить уровень (CEFR или JLPT)"""
+    level_str = callback.data.split("_")[-1]  # A1, A2, B1, B2, C1, C2 или N5, N4, N3, N2, N1
 
     async with async_session_maker() as session:
         user = await UserService.get_user_by_telegram_id(session, callback.from_user.id)
 
         if user:
-            # Обновляем уровень
-            await UserService.update_user_level(session, user.id, LanguageLevel[level_str])
+            # Передаём строковый уровень, UserService сам разберётся с системой
+            await UserService.update_user_level(session, user.id, level_str)
 
-            lang = getattr(user, 'language_interface', 'ru')
-            changed = "✅ Level changed to " if lang == 'en' else ("✅ レベルが変更されました: " if lang == 'ja' else "✅ Уровень изменен на ")
-            msg = changed + f"<b>{level_str}</b>\n\n" + ("You will now receive words and tasks matching your level!" if lang == 'en' else ("これからレベルに合った単語と課題が出題されます！" if lang == 'ja' else "Теперь ты будешь получать слова и задания, соответствующие твоему уровню!"))
-            back = "⬅️ Back to settings" if lang == 'en' else ("⬅️ 設定に戻る" if lang == 'ja' else "⬅️ К настройкам")
+            lang = get_user_lang(user)
+            msg = t(lang, 'settings.level_changed', level=level_str) + t(lang, 'settings.level_changed_hint')
             await callback.message.edit_text(
                 msg,
-                reply_markup=InlineKeyboardMarkup(inline_keyboard=[[InlineKeyboardButton(text=back, callback_data="settings_back")]])
+                reply_markup=InlineKeyboardMarkup(inline_keyboard=[[InlineKeyboardButton(text=t(lang, 'settings.back_to_settings'), callback_data="settings_back")]])
             )
 
     await callback.answer()
@@ -232,11 +183,9 @@ async def settings_language(callback: CallbackQuery):
     """Показать выбор языка"""
     async with async_session_maker() as session:
         user = await UserService.get_user_by_telegram_id(session, callback.from_user.id)
-    lang = getattr(user, 'language_interface', 'ru') if user else 'ru'
-    title = "🌐 <b>Select interface language:</b>\n\n" if lang == 'en' else ("🌐 <b>インターフェース言語を選択:</b>\n\n" if lang == 'ja' else "🌐 <b>Выбери язык интерфейса:</b>\n\n")
-    desc = "This will change the language of bot messages." if lang == 'en' else ("ボットの表示言語が変更されます。" if lang == 'ja' else "Это изменит язык всех сообщений бота.")
+    lang = get_user_lang(user)
     await callback.message.edit_text(
-        title + desc,
+        t(lang, 'settings.lang_title') + t(lang, 'settings.lang_desc'),
         reply_markup=get_language_keyboard(user)
     )
     await callback.answer()
@@ -245,29 +194,21 @@ async def settings_language(callback: CallbackQuery):
 @router.callback_query(F.data.startswith("set_lang_"))
 async def set_language(callback: CallbackQuery):
     """Установить язык"""
-    lang = callback.data.split("_")[-1]  # ru | en | ja
+    new_lang = callback.data.split("_")[-1]  # ru | en | ja
 
     async with async_session_maker() as session:
         user = await UserService.get_user_by_telegram_id(session, callback.from_user.id)
 
         if user:
-            await UserService.update_user_language(session, user.id, lang)
-            if lang == 'en':
-                text = "✅ Interface language: <b>English</b>"
-                back = "⬅️ Back"
-            elif lang == 'ja':
-                text = "✅ インターフェース言語: <b>日本語</b>"
-                back = "⬅️ 戻る"
-            else:
-                text = "✅ Язык интерфейса: <b>Русский</b>"
-                back = "⬅️ К настройкам"
+            await UserService.update_user_language(session, user.id, new_lang)
+            # Используем новый язык для сообщений
+            text = t(new_lang, 'settings.lang_changed')
             await callback.message.edit_text(
                 text,
-                reply_markup=InlineKeyboardMarkup(inline_keyboard=[[InlineKeyboardButton(text=back, callback_data="settings_back")]])
+                reply_markup=InlineKeyboardMarkup(inline_keyboard=[[InlineKeyboardButton(text=t(new_lang, 'settings.back'), callback_data="settings_back")]])
             )
             # Обновляем клавиатуру чата на выбранный язык
-            menu_updated = "Main menu updated ⤵️" if lang == 'en' else ("メインメニューを更新しました ⤵️" if lang == 'ja' else "Клавиатура обновлена ⤵️")
-            await callback.message.answer(menu_updated, reply_markup=main_menu_keyboard(lang))
+            await callback.message.answer(t(new_lang, 'settings.menu_updated'), reply_markup=main_menu_keyboard(new_lang))
 
     await callback.answer()
 
@@ -279,13 +220,16 @@ async def settings_back(callback: CallbackQuery):
         user = await UserService.get_user_by_telegram_id(session, callback.from_user.id)
 
         if user:
-            lang = getattr(user, 'language_interface', 'ru')
-            title = "⚙️ <b>Settings</b>\n\n" if lang == 'en' else ("⚙️ <b>設定</b>\n\n" if lang == 'ja' else "⚙️ <b>Настройки</b>\n\n")
-            level_label = "📊 English level: " if lang == 'en' else ("📊 英語レベル: " if lang == 'ja' else "📊 Уровень английского: ")
-            lang_label = "🌐 Interface language: " if lang == 'en' else ("🌐 インターフェース言語: " if lang == 'ja' else "🌐 Язык интерфейса: ")
-            lang_value = 'English' if user.language_interface == 'en' else ('日本語' if user.language_interface == 'ja' else 'Русский')
-            footer = "Choose what to change:" if lang == 'en' else ("変更したい項目を選択:" if lang == 'ja' else "Выбери, что хочешь изменить:")
-            settings_text = f"{title}{level_label}<b>{user.level.value}</b>\n{lang_label}<b>{lang_value}</b>\n\n{footer}"
+            lang = get_user_lang(user)
+            ui_lang_code = getattr(user, 'language_interface', 'ru') or 'ru'
+            lang_value = t(lang, f'settings.lang_name.{ui_lang_code}')
+            current_level = get_user_level_for_language(user)
+            settings_text = (
+                t(lang, 'settings.title') +
+                t(lang, 'settings.level_prefix') + f"<b>{current_level}</b>\n" +
+                t(lang, 'settings.interface_prefix') + f"<b>{lang_value}</b>\n\n" +
+                t(lang, 'settings.choose')
+            )
 
             await callback.message.edit_text(settings_text, reply_markup=get_settings_keyboard(user))
 

bot/handlers/start.py

@@ -13,6 +13,7 @@ from aiogram.fsm.context import FSMContext
 from database.db import async_session_maker
 from services.user_service import UserService
 from utils.i18n import t
+from utils.levels import get_user_level_for_language
 
 router = Router()
 
@@ -185,10 +186,11 @@ async def pick_theme_from_menu(callback: CallbackQuery, state: FSMContext):
             return
 
         lang = (user.language_interface or 'ru')
+        current_level = get_user_level_for_language(user)
         generating = await callback.message.answer(t(lang, 'words.generating', theme=theme))
         words = await ai_service.generate_thematic_words(
             theme=theme,
-            level=user.level.value,
+            level=current_level,
             count=10,
             learning_lang=user.learning_language,
             translation_lang=user.language_interface,
@@ -200,7 +202,7 @@ async def pick_theme_from_menu(callback: CallbackQuery, state: FSMContext):
             return
 
         # Сохраняем в состояние как в /words
-        await state.update_data(theme=theme, words=words, user_id=user.id, level=user.level.name)
+        await state.update_data(theme=theme, words=words, user_id=user.id, level=current_level)
         await state.set_state(WordsStates.viewing_words)
 
         await show_words_list(callback.message, words, theme)

bot/handlers/tasks.py

@@ -37,7 +37,7 @@ async def cmd_task(message: Message, state: FSMContext):
         )
 
         if not tasks:
-            await message.answer(t(user.level.value and (user.language_interface or 'ru') or 'ru', 'tasks.no_words'))
+            await message.answer(t(user.language_interface or 'ru', 'tasks.no_words'))
             return
 
         # Сохраняем задания в состоянии

bot/handlers/vocabulary.py

@@ -9,7 +9,7 @@ from database.models import WordSource
 from services.user_service import UserService
 from services.vocabulary_service import VocabularyService
 from services.ai_service import ai_service
-from utils.i18n import t
+from utils.i18n import t, get_user_lang
 
 router = Router()
 
@@ -58,10 +58,8 @@ async def process_word_addition(message: Message, state: FSMContext, word: str):
         # Проверяем, есть ли уже такое слово
         existing_word = await VocabularyService.find_word(session, user.id, word)
         if existing_word:
-            await message.answer(
-                f"Слово '<b>{word}</b>' уже есть в твоём словаре!\n"
-                f"Перевод: {existing_word.word_translation}"
-            )
+            lang = get_user_lang(user)
+            await message.answer(t(lang, 'add.exists', word=word, translation=existing_word.word_translation))
             await state.clear()
             return
 

bot/handlers/words.py

@@ -10,6 +10,7 @@ from services.user_service import UserService
 from services.vocabulary_service import VocabularyService
 from services.ai_service import ai_service
 from utils.i18n import t
+from utils.levels import get_user_level_for_language
 
 router = Router()
 
@@ -50,9 +51,10 @@ async def cmd_words(message: Message, state: FSMContext):
         generating_msg = await message.answer(t(lang, 'words.generating', theme=theme))
 
         # Генерируем слова через AI
+        current_level = get_user_level_for_language(user)
         words = await ai_service.generate_thematic_words(
             theme=theme,
-            level=user.level.value,
+            level=current_level,
             count=10,
             learning_lang=user.learning_language,
             translation_lang=user.language_interface,
@@ -69,7 +71,7 @@ async def cmd_words(message: Message, state: FSMContext):
             theme=theme,
             words=words,
             user_id=user.id,
-            level=user.level.name
+            level=current_level
         )
         await state.set_state(WordsStates.viewing_words)