diff --git a/Makefile b/Makefile
index 1fd7563..2c74c19 100644
--- a/Makefile
+++ b/Makefile
@@ -91,7 +91,6 @@ docker-bot-build:
docker-bot-rebuild:
docker-compose stop bot
docker-compose rm bot
- docker-compose build --no-cache bot
docker-compose up -d bot
docker-bot-rebuild-full:
diff --git a/README.md b/README.md
index 1829b51..b865daf 100644
--- a/README.md
+++ b/README.md
@@ -289,6 +289,11 @@ bot_tg_language/
- [x] Убрать переводы текстов (скрыть перевод в упражнениях/диалогах/тестах)
- [x] Добавлены английский и японский в локализацию интерфейса
- [x] Добавлены языки для обучения
+- [x] Добавить возможность иметь словам несколько переводов
+- [x] Добавить возможность импорта слов из файлов (txt, md)
+- [x] Добавить импорт нескольких слов (bulk-импорт)
+- [x] Добавлена механика "Слова дня"
+- [x] Добавлена механика "Мини истории"
**Следующие улучшения:**
- [ ] Экспорт словаря (PDF, Anki, CSV)
@@ -296,11 +301,8 @@ bot_tg_language/
- [ ] Групповые челленджи и лидерборды
- [ ] Gamification (стрики, достижения, уровни)
- [ ] Расширенная аналитика с графиками
-- [ ] Добавить импорт нескольких слов (bulk-импорт)
- [ ] Создание задач на выбранные слова (из словаря/подборок)
-- [ ] Добавить возможность иметь словам несколько переводов
- [ ] Изменить словарь: оставить только слова и добавить возможность получать инфо о словах
-- [ ] Добавить возможность импорта слов из файлов
## Cloudflare AI Gateway (опционально)
diff --git a/bot/handlers/exercises.py b/bot/handlers/exercises.py
new file mode 100644
index 0000000..c45c505
--- /dev/null
+++ b/bot/handlers/exercises.py
@@ -0,0 +1,415 @@
+"""Handler для грамматических упражнений."""
+
+from aiogram import Router, F
+from aiogram.filters import Command
+from aiogram.types import Message, CallbackQuery, InlineKeyboardMarkup, InlineKeyboardButton
+from aiogram.fsm.context import FSMContext
+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, get_user_lang, get_user_translation_lang
+from utils.levels import get_user_level_for_language
+from data.grammar_rules import get_topics_for_current_level_only, get_grammar_topics_for_level
+
+router = Router()
+
+# Количество тем на одной странице
+TOPICS_PER_PAGE = 6
+
+
+class ExercisesStates(StatesGroup):
+ """Состояния для грамматических упражнений."""
+ choosing_topic = State()
+ viewing_rule = State()
+ doing_exercise = State()
+ waiting_answer = State()
+
+
+@router.message(Command("exercises"))
+async def cmd_exercises(message: Message, state: FSMContext):
+ """Обработчик команды /exercises."""
+ await show_exercises_menu(message, state, telegram_id=message.from_user.id)
+
+
+async def show_exercises_menu(message: Message, state: FSMContext, page: int = 0, telegram_id: int = None):
+ """Показать меню выбора темы упражнений."""
+ async with async_session_maker() as session:
+ user = await UserService.get_user_by_telegram_id(session, telegram_id)
+
+ if not user:
+ await message.answer(t('ru', 'common.start_first'))
+ return
+
+ lang = get_user_lang(user)
+ learning_lang = user.learning_language or 'en'
+ level = get_user_level_for_language(user)
+
+ # Получаем темы для текущего уровня
+ topics = get_topics_for_current_level_only(learning_lang, level)
+
+ if not topics:
+ await message.answer(t(lang, 'exercises.no_topics'))
+ return
+
+ # Пагинация
+ total_pages = (len(topics) + TOPICS_PER_PAGE - 1) // TOPICS_PER_PAGE
+ start_idx = page * TOPICS_PER_PAGE
+ end_idx = start_idx + TOPICS_PER_PAGE
+ page_topics = topics[start_idx:end_idx]
+
+ # Сохраняем в состоянии
+ await state.update_data(
+ topics=[t for t in topics], # Все темы
+ page=page,
+ level=level,
+ learning_lang=learning_lang,
+ user_id=user.id
+ )
+ await state.set_state(ExercisesStates.choosing_topic)
+
+ # Формируем текст
+ text = (
+ t(lang, 'exercises.title') + "\n\n" +
+ t(lang, 'exercises.your_level', level=level) + "\n\n" +
+ t(lang, 'exercises.choose_topic')
+ )
+
+ # Формируем клавиатуру
+ keyboard = []
+
+ for topic in page_topics:
+ # Используем русское название если интерфейс на русском, иначе английское
+ if lang == 'ru' and topic.get('name_ru'):
+ btn_text = topic['name_ru']
+ else:
+ btn_text = topic['name']
+
+ keyboard.append([
+ InlineKeyboardButton(
+ text=btn_text,
+ callback_data=f"exercise_topic_{topic['id']}"
+ )
+ ])
+
+ # Навигация по страницам
+ nav_row = []
+ if page > 0:
+ nav_row.append(InlineKeyboardButton(text="⬅️", callback_data=f"exercises_page_{page - 1}"))
+ if total_pages > 1:
+ nav_row.append(InlineKeyboardButton(text=f"{page + 1}/{total_pages}", callback_data="exercises_noop"))
+ if page < total_pages - 1:
+ nav_row.append(InlineKeyboardButton(text="➡️", callback_data=f"exercises_page_{page + 1}"))
+
+ if nav_row:
+ keyboard.append(nav_row)
+
+ # Кнопка закрыть
+ keyboard.append([
+ InlineKeyboardButton(text=t(lang, 'exercises.close_btn'), callback_data="exercises_close")
+ ])
+
+ reply_markup = InlineKeyboardMarkup(inline_keyboard=keyboard)
+ await message.answer(text, reply_markup=reply_markup)
+
+
+@router.callback_query(F.data.startswith("exercises_page_"))
+async def exercises_page_callback(callback: CallbackQuery, state: FSMContext):
+ """Переключение страницы тем."""
+ page = int(callback.data.split("_")[-1])
+ await callback.answer()
+
+ # Удаляем старое сообщение и показываем новое
+ await callback.message.delete()
+ await show_exercises_menu(callback.message, state, page=page, telegram_id=callback.from_user.id)
+
+
+@router.callback_query(F.data == "exercises_noop")
+async def exercises_noop_callback(callback: CallbackQuery):
+ """Пустой callback для кнопки с номером страницы."""
+ await callback.answer()
+
+
+@router.callback_query(F.data == "exercises_close")
+async def exercises_close_callback(callback: CallbackQuery, state: FSMContext):
+ """Закрыть меню упражнений."""
+ await callback.message.delete()
+ await state.clear()
+ await callback.answer()
+
+
+@router.callback_query(F.data.startswith("exercise_topic_"))
+async def exercise_topic_callback(callback: CallbackQuery, state: FSMContext):
+ """Выбор темы для упражнения - показываем правило."""
+ await callback.answer()
+ topic_id = callback.data.replace("exercise_topic_", "")
+
+ data = await state.get_data()
+ topics = data.get('topics', [])
+ level = data.get('level', 'A1')
+ learning_lang = data.get('learning_lang', 'en')
+ user_id = data.get('user_id')
+
+ # Находим выбранную тему
+ topic = next((tp for tp in topics if tp['id'] == topic_id), None)
+ if not topic:
+ 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) if user else 'ru'
+ await callback.message.edit_text(t(lang, 'exercises.generate_failed'))
+ return
+
+ 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) if user else 'ru'
+
+ # Показываем индикатор генерации правила
+ await callback.message.edit_text(t(lang, 'exercises.generating_rule'))
+
+ # Генерируем объяснение правила
+ rule_text = await ai_service.generate_grammar_rule(
+ topic_name=topic['name'],
+ topic_description=topic.get('description', ''),
+ level=level,
+ learning_lang=learning_lang,
+ ui_lang=lang,
+ user_id=user_id
+ )
+
+ # Сохраняем данные темы в состоянии
+ await state.update_data(
+ current_topic=topic,
+ rule_text=rule_text
+ )
+ await state.set_state(ExercisesStates.viewing_rule)
+
+ # Показываем правило с кнопкой "Начать упражнения"
+ topic_display = topic.get('name_ru', topic['name']) if lang == 'ru' else topic['name']
+ text = f"📖 {topic_display}\n\n{rule_text}"
+
+ keyboard = InlineKeyboardMarkup(inline_keyboard=[
+ [InlineKeyboardButton(text=t(lang, 'exercises.start_btn'), callback_data="exercises_start_tasks")],
+ [InlineKeyboardButton(text=t(lang, 'exercises.back_btn'), callback_data="exercises_back_to_topics")]
+ ])
+
+ await callback.message.edit_text(text, reply_markup=keyboard)
+
+
+@router.callback_query(F.data == "exercises_start_tasks", ExercisesStates.viewing_rule)
+async def start_exercises_callback(callback: CallbackQuery, state: FSMContext):
+ """Начать упражнения после просмотра правила."""
+ await callback.answer()
+
+ data = await state.get_data()
+ topic = data.get('current_topic', {})
+ level = data.get('level', 'A1')
+ learning_lang = data.get('learning_lang', 'en')
+ user_id = data.get('user_id')
+
+ 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) if user else 'ru'
+ translation_lang = get_user_translation_lang(user) if user else 'ru'
+ tasks_count = getattr(user, 'tasks_count', 5) or 5
+
+ # Показываем индикатор генерации
+ await callback.message.edit_text(t(lang, 'exercises.generating'))
+
+ # Генерируем упражнения
+ exercises = await ai_service.generate_grammar_exercise(
+ topic_id=topic.get('id', ''),
+ topic_name=topic.get('name', ''),
+ topic_description=topic.get('description', ''),
+ level=level,
+ learning_lang=learning_lang,
+ translation_lang=translation_lang,
+ count=tasks_count,
+ user_id=user_id
+ )
+
+ if not exercises:
+ await callback.message.edit_text(t(lang, 'exercises.generate_failed'))
+ return
+
+ # Сохраняем упражнения в состоянии
+ await state.update_data(
+ exercises=exercises,
+ current_exercise=0,
+ correct_count=0,
+ topic_name=topic.get('name', ''),
+ topic_name_ru=topic.get('name_ru', topic.get('name', ''))
+ )
+ await state.set_state(ExercisesStates.waiting_answer)
+
+ # Показываем первое упражнение
+ await show_exercise(callback.message, state, lang, edit=True)
+
+
+async def show_exercise(message: Message, state: FSMContext, lang: str, edit: bool = False):
+ """Показать текущее упражнение."""
+ data = await state.get_data()
+ exercises = data.get('exercises', [])
+ current = data.get('current_exercise', 0)
+ topic_name = data.get('topic_name_ru' if lang == 'ru' else 'topic_name', '')
+
+ if current >= len(exercises):
+ # Все упражнения завершены
+ await show_results(message, state, lang, edit)
+ return
+
+ exercise = exercises[current]
+
+ text = (
+ t(lang, 'exercises.task_header', topic=topic_name) + "\n\n" +
+ f"{current + 1}/{len(exercises)}\n\n" +
+ t(lang, 'exercises.instruction') + "\n\n" +
+ f"📝 {exercise.get('sentence', '')}\n\n" +
+ f"💬 {exercise.get('translation', '')}\n\n" +
+ f"💡 {exercise.get('hint', '')}\n\n" +
+ t(lang, 'exercises.write_answer')
+ )
+
+ # Кнопки
+ keyboard = InlineKeyboardMarkup(inline_keyboard=[
+ [InlineKeyboardButton(text=t(lang, 'exercises.back_btn'), callback_data="exercises_back_to_topics")],
+ [InlineKeyboardButton(text=t(lang, 'exercises.close_btn'), callback_data="exercises_close")]
+ ])
+
+ if edit:
+ await message.edit_text(text, reply_markup=keyboard)
+ else:
+ await message.answer(text, reply_markup=keyboard)
+
+
+@router.callback_query(F.data == "exercises_back_to_topics")
+async def back_to_topics_callback(callback: CallbackQuery, state: FSMContext):
+ """Вернуться к выбору темы."""
+ await callback.answer()
+ await callback.message.delete()
+
+ data = await state.get_data()
+ page = data.get('page', 0)
+
+ await show_exercises_menu(callback.message, state, page=page, telegram_id=callback.from_user.id)
+
+
+@router.message(ExercisesStates.waiting_answer)
+async def process_answer(message: Message, state: FSMContext):
+ """Обработка ответа пользователя."""
+ user_answer = message.text.strip().lower()
+
+ 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 user else 'ru'
+
+ data = await state.get_data()
+ exercises = data.get('exercises', [])
+ current = data.get('current_exercise', 0)
+ correct_count = data.get('correct_count', 0)
+
+ if current >= len(exercises):
+ return
+
+ exercise = exercises[current]
+ correct_answer = exercise.get('correct_answer', '').strip().lower()
+
+ # Проверяем ответ
+ is_correct = user_answer == correct_answer
+
+ if is_correct:
+ correct_count += 1
+ result_text = t(lang, 'exercises.correct') + "\n\n"
+ else:
+ result_text = (
+ t(lang, 'exercises.incorrect') + "\n\n" +
+ t(lang, 'exercises.your_answer', answer=message.text) + "\n" +
+ t(lang, 'exercises.right_answer', answer=exercise.get('correct_answer', '')) + "\n\n"
+ )
+
+ # Добавляем объяснение
+ result_text += t(lang, 'exercises.explanation', text=exercise.get('explanation', ''))
+
+ # Обновляем состояние
+ await state.update_data(
+ current_exercise=current + 1,
+ correct_count=correct_count
+ )
+
+ # Кнопка "Следующее" или "Результаты"
+ if current + 1 < len(exercises):
+ keyboard = InlineKeyboardMarkup(inline_keyboard=[
+ [InlineKeyboardButton(text=t(lang, 'exercises.next_btn'), callback_data="exercises_next")]
+ ])
+ else:
+ keyboard = InlineKeyboardMarkup(inline_keyboard=[
+ [InlineKeyboardButton(text=t(lang, 'exercises.results_btn'), callback_data="exercises_finish")]
+ ])
+
+ await message.answer(result_text, reply_markup=keyboard)
+
+
+@router.callback_query(F.data == "exercises_next")
+async def next_exercise_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)
+
+ lang = get_user_lang(user) if user else 'ru'
+
+ await show_exercise(callback.message, state, lang, edit=True)
+
+
+@router.callback_query(F.data == "exercises_finish")
+async def finish_exercises_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)
+
+ lang = get_user_lang(user) if user else 'ru'
+
+ # Убираем кнопку с предыдущего сообщения (оставляем фидбэк видимым)
+ await callback.message.edit_reply_markup(reply_markup=None)
+ # Показываем результаты новым сообщением
+ await show_results(callback.message, state, lang, edit=False)
+
+
+async def show_results(message: Message, state: FSMContext, lang: str, edit: bool = False):
+ """Показать результаты упражнений."""
+ data = await state.get_data()
+ exercises = data.get('exercises', [])
+ correct_count = data.get('correct_count', 0)
+ total = len(exercises)
+ topic_name = data.get('topic_name_ru' if lang == 'ru' else 'topic_name', '')
+
+ text = (
+ f"🎉 {topic_name}\n\n" +
+ t(lang, 'exercises.score', correct=correct_count, total=total)
+ )
+
+ keyboard = InlineKeyboardMarkup(inline_keyboard=[
+ [InlineKeyboardButton(text=t(lang, 'exercises.back_btn'), callback_data="exercises_restart")],
+ [InlineKeyboardButton(text=t(lang, 'exercises.close_btn'), callback_data="exercises_close")]
+ ])
+
+ if edit:
+ await message.edit_text(text, reply_markup=keyboard)
+ else:
+ await message.answer(text, reply_markup=keyboard)
+
+ await state.clear()
+
+
+@router.callback_query(F.data == "exercises_restart")
+async def restart_exercises_callback(callback: CallbackQuery, state: FSMContext):
+ """Вернуться к выбору темы после завершения."""
+ await callback.answer()
+ await callback.message.delete()
+ await show_exercises_menu(callback.message, state, page=0, telegram_id=callback.from_user.id)
diff --git a/bot/handlers/practice.py b/bot/handlers/practice.py
index 4c76ee9..9c23ff6 100644
--- a/bot/handlers/practice.py
+++ b/bot/handlers/practice.py
@@ -29,6 +29,40 @@ def get_scenario_name(lang: str, scenario: str) -> str:
return t(lang, f'practice.scenario.{scenario}')
+async def show_practice_menu(message: Message, telegram_id: int, edit: bool = False):
+ """Показать меню выбора сценария практики"""
+ async with async_session_maker() as session:
+ user = await UserService.get_user_by_telegram_id(session, telegram_id)
+
+ if not user:
+ await message.answer(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)
+
+ if edit:
+ await message.edit_text(t(lang, 'practice.start_text'), reply_markup=reply_markup)
+ else:
+ await message.answer(t(lang, 'practice.start_text'), reply_markup=reply_markup)
+
+
@router.message(Command("practice"))
async def cmd_practice(message: Message, state: FSMContext):
"""Обработчик команды /practice"""
@@ -39,31 +73,10 @@ async def cmd_practice(message: Message, state: FSMContext):
await message.answer(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 message.answer(t(lang, 'practice.start_text'), reply_markup=reply_markup)
+ await show_practice_menu(message, message.from_user.id, edit=False)
@router.callback_query(F.data == "scenario_custom", PracticeStates.choosing_scenario)
diff --git a/bot/handlers/start.py b/bot/handlers/start.py
index 3591457..e43ff9e 100644
--- a/bot/handlers/start.py
+++ b/bot/handlers/start.py
@@ -13,7 +13,7 @@ from aiogram.fsm.state import State, StatesGroup
from database.db import async_session_maker
from services.user_service import UserService
-from utils.i18n import t, get_user_translation_lang
+from utils.i18n import t, get_user_translation_lang, get_user_lang
from utils.levels import get_user_level_for_language
router = Router()
@@ -57,16 +57,19 @@ def main_menu_keyboard(lang: str = 'ru') -> ReplyKeyboardMarkup:
return ReplyKeyboardMarkup(
resize_keyboard=True,
keyboard=[
- [
- KeyboardButton(text=t(lang, "menu.add")),
- KeyboardButton(text=t(lang, "menu.vocab")),
- ],
[
KeyboardButton(text=t(lang, "menu.task")),
KeyboardButton(text=t(lang, "menu.practice")),
],
[
+ KeyboardButton(text=t(lang, "menu.exercises")),
+ KeyboardButton(text=t(lang, "menu.vocab")),
+ ],
+ [
+ KeyboardButton(text=t(lang, "menu.add")),
KeyboardButton(text=t(lang, "menu.stats")),
+ ],
+ [
KeyboardButton(text=t(lang, "menu.settings")),
],
],
@@ -326,8 +329,74 @@ async def btn_task_pressed(message: Message, state: FSMContext):
@router.message(_menu_match('menu.practice'))
async def btn_practice_pressed(message: Message, state: FSMContext):
- from bot.handlers.practice import cmd_practice
- await cmd_practice(message, state)
+ """Показать меню практики"""
+ await state.clear()
+
+ 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 user else 'ru'
+
+ keyboard = InlineKeyboardMarkup(inline_keyboard=[
+ [InlineKeyboardButton(
+ text=f"📖 {t(lang, 'practice_menu.stories')}",
+ callback_data="practice_stories"
+ )],
+ [InlineKeyboardButton(
+ text=f"💬 {t(lang, 'practice_menu.ai_chat')}",
+ callback_data="practice_ai"
+ )],
+ ])
+
+ await message.answer(
+ f"💬 {t(lang, 'practice_menu.title')}\n\n{t(lang, 'practice_menu.choose')}",
+ reply_markup=keyboard
+ )
+
+
+@router.callback_query(F.data == "practice_stories")
+async def practice_stories_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)
+ lang = get_user_lang(user) if user else 'ru'
+
+ keyboard = InlineKeyboardMarkup(inline_keyboard=[
+ [
+ InlineKeyboardButton(text=f"🗣 {t(lang, 'story.genre.dialogue')}", callback_data="story_genre_dialogue"),
+ InlineKeyboardButton(text=f"📰 {t(lang, 'story.genre.news')}", callback_data="story_genre_news"),
+ ],
+ [
+ InlineKeyboardButton(text=f"🎭 {t(lang, 'story.genre.story')}", callback_data="story_genre_story"),
+ InlineKeyboardButton(text=f"📧 {t(lang, 'story.genre.letter')}", callback_data="story_genre_letter"),
+ ],
+ [
+ InlineKeyboardButton(text=f"🍳 {t(lang, 'story.genre.recipe')}", callback_data="story_genre_recipe"),
+ ],
+ ])
+
+ await callback.message.edit_text(
+ f"📖 {t(lang, 'story.title')}\n\n{t(lang, 'story.choose_genre')}",
+ reply_markup=keyboard
+ )
+
+
+@router.callback_query(F.data == "practice_ai")
+async def practice_ai_callback(callback: CallbackQuery, state: FSMContext):
+ """Переход к AI практике"""
+ await callback.answer()
+
+ async with async_session_maker() as session:
+ user = await UserService.get_user_by_telegram_id(session, callback.from_user.id)
+ if user:
+ from bot.handlers.practice import PracticeStates
+ from utils.levels import get_user_level_for_language
+ await state.update_data(user_id=user.id, level=get_user_level_for_language(user))
+ await state.set_state(PracticeStates.choosing_scenario)
+
+ from bot.handlers.practice import show_practice_menu
+ await show_practice_menu(callback.message, callback.from_user.id, edit=True)
@router.message(_menu_match('menu.import'))
@@ -391,6 +460,14 @@ async def btn_settings_pressed(message: Message):
await cmd_settings(message)
+
+@router.message(_menu_match('menu.exercises'))
+async def btn_exercises_pressed(message: Message, state: FSMContext):
+ """Показать меню грамматических упражнений."""
+ from bot.handlers.exercises import show_exercises_menu
+ await show_exercises_menu(message, state, telegram_id=message.from_user.id)
+
+
@router.message(_menu_match('menu.words'))
async def btn_words_pressed(message: Message, state: FSMContext):
"""Подсказать про тематические слова и показать быстрые темы."""
diff --git a/bot/handlers/stories.py b/bot/handlers/stories.py
new file mode 100644
index 0000000..c187dc0
--- /dev/null
+++ b/bot/handlers/stories.py
@@ -0,0 +1,688 @@
+"""Handler для мини-историй (Reading Practice)."""
+
+from aiogram import Router, F
+from aiogram.filters import Command
+from aiogram.types import Message, CallbackQuery, InlineKeyboardMarkup, InlineKeyboardButton
+from aiogram.fsm.context import FSMContext
+from aiogram.fsm.state import State, StatesGroup
+
+from database.db import async_session_maker
+from database.models import MiniStory, StoryGenre, 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, get_user_lang, get_user_translation_lang
+from utils.levels import get_user_level_for_language
+
+router = Router()
+
+
+class StoryStates(StatesGroup):
+ """Состояния для чтения истории"""
+ reading = State() # Чтение истории
+ questions = State() # Ответы на вопросы
+
+
+GENRE_EMOJI = {
+ "dialogue": "🗣",
+ "news": "📰",
+ "story": "🎭",
+ "letter": "📧",
+ "recipe": "🍳"
+}
+
+
+def get_genre_keyboard(lang: str) -> InlineKeyboardMarkup:
+ """Клавиатура выбора жанра"""
+ return InlineKeyboardMarkup(inline_keyboard=[
+ [
+ InlineKeyboardButton(
+ text=f"🗣 {t(lang, 'story.genre.dialogue')}",
+ callback_data="story_genre_dialogue"
+ ),
+ InlineKeyboardButton(
+ text=f"📰 {t(lang, 'story.genre.news')}",
+ callback_data="story_genre_news"
+ ),
+ ],
+ [
+ InlineKeyboardButton(
+ text=f"🎭 {t(lang, 'story.genre.story')}",
+ callback_data="story_genre_story"
+ ),
+ InlineKeyboardButton(
+ text=f"📧 {t(lang, 'story.genre.letter')}",
+ callback_data="story_genre_letter"
+ ),
+ ],
+ [
+ InlineKeyboardButton(
+ text=f"🍳 {t(lang, 'story.genre.recipe')}",
+ callback_data="story_genre_recipe"
+ ),
+ ],
+ ])
+
+
+def format_story_text(story: MiniStory, lang: str, show_translation: bool = False) -> str:
+ """Форматировать текст истории"""
+ emoji = GENRE_EMOJI.get(story.genre.value, "📖")
+
+ text = f"{emoji} {story.title}\n"
+ text += f"{t(lang, 'story.level')}: {story.level} • {story.word_count} {t(lang, 'story.words')}\n"
+ text += "─" * 20 + "\n\n"
+ text += story.content
+
+ if show_translation and story.translation:
+ text += "\n\n" + "─" * 20
+ text += f"\n\n🌐 {t(lang, 'story.translation')}:\n\n"
+ text += f"{story.translation}"
+
+ text += "\n\n" + "─" * 20
+
+ return text
+
+
+def get_story_keyboard(story_id: int, lang: str, show_translation: bool = False) -> InlineKeyboardMarkup:
+ """Клавиатура под историей"""
+ # Кнопка перевода - показать или скрыть
+ if show_translation:
+ translation_btn = InlineKeyboardButton(
+ text=f"🌐 {t(lang, 'story.hide_translation')}",
+ callback_data=f"story_hide_translation_{story_id}"
+ )
+ else:
+ translation_btn = InlineKeyboardButton(
+ text=f"🌐 {t(lang, 'story.show_translation')}",
+ callback_data=f"story_show_translation_{story_id}"
+ )
+
+ return InlineKeyboardMarkup(inline_keyboard=[
+ [translation_btn],
+ [
+ InlineKeyboardButton(
+ text=f"📝 {t(lang, 'story.questions_btn')}",
+ callback_data=f"story_questions_{story_id}"
+ ),
+ ],
+ [
+ InlineKeyboardButton(
+ text=f"📚 {t(lang, 'story.vocab_btn')}",
+ callback_data=f"story_vocab_{story_id}"
+ ),
+ ],
+ [
+ InlineKeyboardButton(
+ text=f"🔄 {t(lang, 'story.new_btn')}",
+ callback_data="story_new"
+ ),
+ ],
+ ])
+
+
+@router.message(Command("story"))
+async def cmd_story(message: Message, state: FSMContext):
+ """Обработчик команды /story"""
+ await state.clear()
+
+ async with async_session_maker() as session:
+ user = await UserService.get_user_by_telegram_id(session, message.from_user.id)
+
+ if not user:
+ await message.answer(t('ru', 'common.start_first'))
+ return
+
+ lang = get_user_lang(user)
+
+ text = f"📖 {t(lang, 'story.title')}\n\n"
+ text += t(lang, 'story.choose_genre')
+
+ await message.answer(text, reply_markup=get_genre_keyboard(lang))
+
+
+@router.callback_query(F.data == "story_new")
+async def story_new_callback(callback: CallbackQuery, state: FSMContext):
+ """Показать выбор жанра для новой истории"""
+ await callback.answer()
+ await state.clear()
+
+ 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)
+
+ text = f"📖 {t(lang, 'story.title')}\n\n"
+ text += t(lang, 'story.choose_genre')
+
+ await callback.message.edit_text(text, reply_markup=get_genre_keyboard(lang))
+
+
+@router.callback_query(F.data.startswith("story_genre_"))
+async def story_genre_callback(callback: CallbackQuery, state: FSMContext):
+ """Генерация истории выбранного жанра"""
+ await callback.answer()
+
+ genre = callback.data.replace("story_genre_", "")
+
+ 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 = user.learning_language or 'en'
+ level = get_user_level_for_language(user)
+ translation_lang = get_user_translation_lang(user)
+
+ # Показываем индикатор генерации
+ await callback.message.edit_text(t(lang, 'story.generating'))
+
+ # Получаем количество вопросов из настроек
+ tasks_count = getattr(user, 'tasks_count', 5) or 5
+
+ # Генерируем историю
+ story_data = await ai_service.generate_mini_story(
+ genre=genre,
+ level=level,
+ learning_lang=learning_lang,
+ translation_lang=translation_lang,
+ user_id=user.id,
+ num_questions=tasks_count
+ )
+
+ if not story_data:
+ await callback.message.edit_text(
+ t(lang, 'story.failed'),
+ reply_markup=InlineKeyboardMarkup(inline_keyboard=[
+ [InlineKeyboardButton(
+ text=f"🔄 {t(lang, 'story.try_again')}",
+ callback_data="story_new"
+ )]
+ ])
+ )
+ return
+
+ # Сохраняем историю в БД
+ story = MiniStory(
+ user_id=user.id,
+ title=story_data.get('title', 'Story'),
+ content=story_data.get('content', ''),
+ translation=story_data.get('translation', ''),
+ genre=StoryGenre(genre),
+ learning_lang=learning_lang,
+ level=level,
+ word_count=story_data.get('word_count', 0),
+ vocabulary=story_data.get('vocabulary', []),
+ questions=story_data.get('questions', [])
+ )
+ session.add(story)
+ await session.commit()
+ await session.refresh(story)
+
+ # Сохраняем ID истории в состоянии
+ await state.update_data(story_id=story.id)
+ await state.set_state(StoryStates.reading)
+
+ # Показываем историю
+ text = format_story_text(story, lang)
+ await callback.message.edit_text(
+ text,
+ reply_markup=get_story_keyboard(story.id, lang)
+ )
+
+
+@router.callback_query(F.data.startswith("story_show_translation_"))
+async def story_show_translation_callback(callback: CallbackQuery):
+ """Показать перевод истории"""
+ await callback.answer()
+
+ story_id = int(callback.data.replace("story_show_translation_", ""))
+
+ 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)
+
+ story = await session.get(MiniStory, story_id)
+ if not story:
+ await callback.answer(t(lang, 'story.not_found'), show_alert=True)
+ return
+
+ text = format_story_text(story, lang, show_translation=True)
+ await callback.message.edit_text(
+ text,
+ reply_markup=get_story_keyboard(story.id, lang, show_translation=True)
+ )
+
+
+@router.callback_query(F.data.startswith("story_hide_translation_"))
+async def story_hide_translation_callback(callback: CallbackQuery):
+ """Скрыть перевод истории"""
+ await callback.answer()
+
+ story_id = int(callback.data.replace("story_hide_translation_", ""))
+
+ 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)
+
+ story = await session.get(MiniStory, story_id)
+ if not story:
+ await callback.answer(t(lang, 'story.not_found'), show_alert=True)
+ return
+
+ text = format_story_text(story, lang, show_translation=False)
+ await callback.message.edit_text(
+ text,
+ reply_markup=get_story_keyboard(story.id, lang, show_translation=False)
+ )
+
+
+@router.callback_query(F.data.startswith("story_vocab_"))
+async def story_vocab_callback(callback: CallbackQuery):
+ """Показать словарь истории"""
+ await callback.answer()
+
+ story_id = int(callback.data.replace("story_vocab_", ""))
+
+ 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)
+
+ story = await session.get(MiniStory, story_id)
+ if not story:
+ await callback.answer(t(lang, 'story.not_found'), show_alert=True)
+ return
+
+ vocabulary = story.vocabulary or []
+
+ if not vocabulary:
+ await callback.answer(t(lang, 'story.no_vocab'), show_alert=True)
+ return
+
+ # Формируем текст со словами
+ text = f"📚 {t(lang, 'story.vocabulary')}\n\n"
+
+ keyboard_buttons = []
+ for i, word_data in enumerate(vocabulary[:10]):
+ word = word_data.get('word', '')
+ translation = word_data.get('translation', '')
+ transcription = word_data.get('transcription', '')
+
+ if transcription:
+ text += f"• {word} [{transcription}] — {translation}\n"
+ else:
+ text += f"• {word} — {translation}\n"
+
+ # Кнопка добавления слова
+ keyboard_buttons.append([
+ InlineKeyboardButton(
+ text=f"➕ {word}",
+ callback_data=f"story_addword_{story_id}_{i}"
+ )
+ ])
+
+ # Кнопка "Добавить все"
+ keyboard_buttons.append([
+ InlineKeyboardButton(
+ text=f"➕ {t(lang, 'story.add_all')}",
+ callback_data=f"story_addall_{story_id}"
+ )
+ ])
+
+ # Кнопка назад
+ keyboard_buttons.append([
+ InlineKeyboardButton(
+ text=f"⬅️ {t(lang, 'story.back')}",
+ callback_data=f"story_back_{story_id}"
+ )
+ ])
+
+ await callback.message.edit_text(
+ text,
+ reply_markup=InlineKeyboardMarkup(inline_keyboard=keyboard_buttons)
+ )
+
+
+@router.callback_query(F.data.startswith("story_addword_"))
+async def story_addword_callback(callback: CallbackQuery):
+ """Добавить одно слово из истории"""
+ parts = callback.data.split("_")
+ story_id = int(parts[2])
+ word_idx = int(parts[3])
+
+ 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)
+
+ story = await session.get(MiniStory, story_id)
+ if not story or not story.vocabulary:
+ await callback.answer(t(lang, 'story.not_found'), show_alert=True)
+ return
+
+ if word_idx >= len(story.vocabulary):
+ await callback.answer(t(lang, 'story.word_not_found'), show_alert=True)
+ return
+
+ word_data = story.vocabulary[word_idx]
+ word = word_data.get('word', '')
+ translation = word_data.get('translation', '')
+ transcription = word_data.get('transcription')
+
+ # Проверяем, нет ли уже
+ existing = await VocabularyService.get_word_by_original(
+ session, user.id, word, source_lang=story.learning_lang
+ )
+
+ if existing:
+ await callback.answer(t(lang, 'words.already_exists', word=word), show_alert=True)
+ return
+
+ # Добавляем слово
+ translation_lang = get_user_translation_lang(user)
+ await VocabularyService.add_word(
+ session=session,
+ user_id=user.id,
+ word_original=word,
+ word_translation=translation,
+ source_lang=story.learning_lang,
+ translation_lang=translation_lang,
+ transcription=transcription,
+ difficulty_level=story.level,
+ source=WordSource.IMPORT
+ )
+ await session.commit()
+
+ await callback.answer(t(lang, 'story.word_added', word=word), show_alert=True)
+
+
+@router.callback_query(F.data.startswith("story_addall_"))
+async def story_addall_callback(callback: CallbackQuery):
+ """Добавить все слова из истории"""
+ story_id = int(callback.data.replace("story_addall_", ""))
+
+ 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)
+
+ story = await session.get(MiniStory, story_id)
+ if not story or not story.vocabulary:
+ await callback.answer(t(lang, 'story.not_found'), show_alert=True)
+ return
+
+ translation_lang = get_user_translation_lang(user)
+ added = 0
+
+ for word_data in story.vocabulary:
+ word = word_data.get('word', '')
+ translation = word_data.get('translation', '')
+ transcription = word_data.get('transcription')
+
+ # Проверяем дубликаты
+ existing = await VocabularyService.get_word_by_original(
+ session, user.id, word, source_lang=story.learning_lang
+ )
+
+ if not existing:
+ await VocabularyService.add_word(
+ session=session,
+ user_id=user.id,
+ word_original=word,
+ word_translation=translation,
+ source_lang=story.learning_lang,
+ translation_lang=translation_lang,
+ transcription=transcription,
+ difficulty_level=story.level,
+ source=WordSource.IMPORT
+ )
+ added += 1
+
+ await session.commit()
+ await callback.answer(t(lang, 'story.words_added', n=added), show_alert=True)
+
+
+@router.callback_query(F.data.startswith("story_back_"))
+async def story_back_callback(callback: CallbackQuery):
+ """Вернуться к истории"""
+ await callback.answer()
+
+ story_id = int(callback.data.replace("story_back_", ""))
+
+ 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)
+
+ story = await session.get(MiniStory, story_id)
+ if not story:
+ await callback.message.edit_text(t(lang, 'story.not_found'))
+ return
+
+ text = format_story_text(story, lang)
+ await callback.message.edit_text(
+ text,
+ reply_markup=get_story_keyboard(story.id, lang)
+ )
+
+
+@router.callback_query(F.data.startswith("story_questions_"))
+async def story_questions_callback(callback: CallbackQuery, state: FSMContext):
+ """Показать вопросы по истории"""
+ await callback.answer()
+
+ story_id = int(callback.data.replace("story_questions_", ""))
+
+ 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)
+
+ story = await session.get(MiniStory, story_id)
+ if not story:
+ await callback.message.edit_text(t(lang, 'story.not_found'))
+ return
+
+ questions = story.questions or []
+ if not questions:
+ await callback.answer(t(lang, 'story.no_questions'), show_alert=True)
+ return
+
+ # Сохраняем состояние
+ await state.update_data(
+ story_id=story_id,
+ current_question=0,
+ correct_answers=0,
+ total_questions=len(questions)
+ )
+ await state.set_state(StoryStates.questions)
+
+ # Показываем первый вопрос
+ await show_question(callback.message, story, 0, lang, edit=True)
+
+
+async def show_question(message: Message, story: MiniStory, q_idx: int, lang: str, edit: bool = False):
+ """Показать вопрос"""
+ questions = story.questions or []
+
+ if q_idx >= len(questions):
+ return
+
+ q = questions[q_idx]
+ total = len(questions)
+
+ text = f"📝 {t(lang, 'story.question')} {q_idx + 1}/{total}\n\n"
+ text += f"{q.get('question', '')}\n"
+
+ # Кнопки с вариантами ответов
+ options = q.get('options', [])
+ keyboard_buttons = []
+
+ for i, option in enumerate(options):
+ keyboard_buttons.append([
+ InlineKeyboardButton(
+ text=option,
+ callback_data=f"story_answer_{story.id}_{q_idx}_{i}"
+ )
+ ])
+
+ keyboard = InlineKeyboardMarkup(inline_keyboard=keyboard_buttons)
+
+ if edit:
+ await message.edit_text(text, reply_markup=keyboard)
+ else:
+ await message.answer(text, reply_markup=keyboard)
+
+
+@router.callback_query(F.data.startswith("story_answer_"))
+async def story_answer_callback(callback: CallbackQuery, state: FSMContext):
+ """Обработка ответа на вопрос"""
+ parts = callback.data.split("_")
+ story_id = int(parts[2])
+ q_idx = int(parts[3])
+ answer_idx = int(parts[4])
+
+ 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)
+
+ story = await session.get(MiniStory, story_id)
+ if not story:
+ await callback.answer(t(lang, 'story.not_found'), show_alert=True)
+ return
+
+ questions = story.questions or []
+ if q_idx >= len(questions):
+ await callback.answer(t(lang, 'story.question_not_found'), show_alert=True)
+ return
+
+ q = questions[q_idx]
+ correct = q.get('correct', 0)
+ options = q.get('options', [])
+
+ # Получаем данные состояния
+ data = await state.get_data()
+ correct_answers = data.get('correct_answers', 0)
+ total_questions = data.get('total_questions', len(questions))
+
+ # Проверяем ответ
+ is_correct = (answer_idx == correct)
+ if is_correct:
+ correct_answers += 1
+
+ # Показываем результат ответа
+ text = f"📝 {t(lang, 'story.question')} {q_idx + 1}/{total_questions}\n\n"
+ text += f"{q.get('question', '')}\n\n"
+
+ for i, option in enumerate(options):
+ if i == correct:
+ text += f"✅ {option}\n"
+ elif i == answer_idx and not is_correct:
+ text += f"❌ {option}\n"
+ else:
+ text += f"○ {option}\n"
+
+ if is_correct:
+ text += f"\n{t(lang, 'story.correct')}"
+ await callback.answer("✅", show_alert=False)
+ else:
+ text += f"\n{t(lang, 'story.incorrect')}"
+ await callback.answer("❌", show_alert=False)
+
+ # Обновляем состояние
+ await state.update_data(correct_answers=correct_answers)
+
+ # Следующий вопрос или результаты
+ next_q_idx = q_idx + 1
+
+ if next_q_idx < total_questions:
+ keyboard = InlineKeyboardMarkup(inline_keyboard=[
+ [InlineKeyboardButton(
+ text=f"➡️ {t(lang, 'story.next_question')}",
+ callback_data=f"story_nextq_{story_id}_{next_q_idx}"
+ )]
+ ])
+ else:
+ keyboard = InlineKeyboardMarkup(inline_keyboard=[
+ [InlineKeyboardButton(
+ text=f"📊 {t(lang, 'story.show_results')}",
+ callback_data=f"story_results_{story_id}_{correct_answers}"
+ )]
+ ])
+
+ await callback.message.edit_text(text, reply_markup=keyboard)
+
+
+@router.callback_query(F.data.startswith("story_nextq_"))
+async def story_nextq_callback(callback: CallbackQuery, state: FSMContext):
+ """Следующий вопрос"""
+ await callback.answer()
+
+ parts = callback.data.split("_")
+ story_id = int(parts[2])
+ q_idx = int(parts[3])
+
+ 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)
+
+ story = await session.get(MiniStory, story_id)
+ if not story:
+ await callback.message.edit_text(t(lang, 'story.not_found'))
+ return
+
+ await show_question(callback.message, story, q_idx, lang, edit=True)
+
+
+@router.callback_query(F.data.startswith("story_results_"))
+async def story_results_callback(callback: CallbackQuery, state: FSMContext):
+ """Показать результаты"""
+ await callback.answer()
+ await state.clear()
+
+ parts = callback.data.split("_")
+ story_id = int(parts[2])
+ correct_answers = int(parts[3])
+
+ 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)
+
+ story = await session.get(MiniStory, story_id)
+ if not story:
+ await callback.message.edit_text(t(lang, 'story.not_found'))
+ return
+
+ total = len(story.questions or [])
+
+ # Обновляем статус истории
+ story.is_completed = True
+ story.correct_answers = correct_answers
+ await session.commit()
+
+ # Определяем эмодзи по результату
+ percentage = (correct_answers / total * 100) if total > 0 else 0
+ if percentage >= 80:
+ emoji = "🎉"
+ comment = t(lang, 'story.result_excellent')
+ elif percentage >= 50:
+ emoji = "👍"
+ comment = t(lang, 'story.result_good')
+ else:
+ emoji = "📚"
+ comment = t(lang, 'story.result_practice')
+
+ text = f"{emoji} {t(lang, 'story.results_title')}\n\n"
+ text += f"📖 {story.title}\n\n"
+ text += f"{t(lang, 'story.correct_answers')}: {correct_answers}/{total}\n"
+ text += f"{t(lang, 'story.accuracy')}: {percentage:.0f}%\n\n"
+ text += f"{comment}"
+
+ keyboard = InlineKeyboardMarkup(inline_keyboard=[
+ [
+ InlineKeyboardButton(
+ text=f"📚 {t(lang, 'story.vocab_btn')}",
+ callback_data=f"story_vocab_{story_id}"
+ ),
+ ],
+ [
+ InlineKeyboardButton(
+ text=f"🔄 {t(lang, 'story.new_btn')}",
+ callback_data="story_new"
+ ),
+ ],
+ ])
+
+ await callback.message.edit_text(text, reply_markup=keyboard)
diff --git a/bot/handlers/vocabulary.py b/bot/handlers/vocabulary.py
index 522c2ea..e8d7099 100644
--- a/bot/handlers/vocabulary.py
+++ b/bot/handlers/vocabulary.py
@@ -18,12 +18,13 @@ class AddWordStates(StatesGroup):
"""Состояния для добавления слова"""
waiting_for_confirmation = State()
waiting_for_word = State()
+ viewing_batch = State() # Просмотр списка слов для batch-добавления
@router.message(Command("add"))
async def cmd_add(message: Message, state: FSMContext):
- """Обработчик команды /add [слово]"""
- # Получаем слово из команды
+ """Обработчик команды /add [слово] или /add [слово1, слово2, ...]"""
+ # Получаем слово(а) из команды
parts = message.text.split(maxsplit=1)
if len(parts) < 2:
@@ -34,15 +35,32 @@ async def cmd_add(message: Message, state: FSMContext):
await state.set_state(AddWordStates.waiting_for_word)
return
- word = parts[1].strip()
- await process_word_addition(message, state, word)
+ text = parts[1].strip()
+
+ # Проверяем, есть ли несколько слов (через запятую)
+ if ',' in text:
+ words = [w.strip() for w in text.split(',') if w.strip()]
+ if len(words) > 1:
+ await process_batch_addition(message, state, words)
+ return
+
+ # Одно слово - стандартная обработка
+ await process_word_addition(message, state, text)
@router.message(AddWordStates.waiting_for_word)
async def process_word_input(message: Message, state: FSMContext):
- """Обработка ввода слова"""
- word = message.text.strip()
- await process_word_addition(message, state, word)
+ """Обработка ввода слова или нескольких слов"""
+ text = message.text.strip()
+
+ # Проверяем, есть ли несколько слов (через запятую)
+ if ',' in text:
+ words = [w.strip() for w in text.split(',') if w.strip()]
+ if len(words) > 1:
+ await process_batch_addition(message, state, words)
+ return
+
+ await process_word_addition(message, state, text)
async def process_word_addition(message: Message, state: FSMContext, word: str):
@@ -188,6 +206,201 @@ async def cancel_add_word(callback: CallbackQuery, state: FSMContext):
await callback.answer()
+# === Batch добавление нескольких слов ===
+
+async def process_batch_addition(message: Message, state: FSMContext, words: list[str]):
+ """Обработка добавления нескольких слов"""
+ async with async_session_maker() as session:
+ user = await UserService.get_user_by_telegram_id(session, message.from_user.id)
+
+ if not user:
+ await message.answer(t('ru', 'common.start_first'))
+ return
+
+ lang = get_user_lang(user)
+
+ # Ограничиваем количество слов
+ if len(words) > 20:
+ words = words[:20]
+ await message.answer(t(lang, 'add_batch.truncated', n=20))
+
+ # Показываем индикатор загрузки
+ processing_msg = await message.answer(t(lang, 'add_batch.translating', n=len(words)))
+
+ # Получаем переводы через AI batch-методом
+ source_lang = user.learning_language or 'en'
+ translation_lang = get_user_translation_lang(user)
+
+ translated_words = await ai_service.translate_words_batch(
+ words=words,
+ source_lang=source_lang,
+ translation_lang=translation_lang,
+ user_id=user.id
+ )
+
+ await processing_msg.delete()
+
+ if not translated_words:
+ await message.answer(t(lang, 'add_batch.failed'))
+ return
+
+ # Сохраняем данные в состоянии
+ await state.update_data(
+ batch_words=translated_words,
+ user_id=user.id
+ )
+ await state.set_state(AddWordStates.viewing_batch)
+
+ # Показываем список слов
+ await show_batch_words(message, translated_words, lang)
+
+
+async def show_batch_words(message: Message, words: list, lang: str):
+ """Показать список слов для batch-добавления"""
+ text = t(lang, 'add_batch.header', n=len(words)) + "\n\n"
+
+ for idx, word_data in enumerate(words, 1):
+ word = word_data.get('word', '')
+ translation = word_data.get('translation', '')
+ transcription = word_data.get('transcription', '')
+
+ line = f"{idx}. {word}"
+ if transcription:
+ line += f" [{transcription}]"
+ line += f"\n {translation}\n"
+ text += line
+
+ text += "\n" + t(lang, 'add_batch.choose')
+
+ # Создаем кнопки для каждого слова (по 2 в ряд)
+ keyboard = []
+ for idx, word_data in enumerate(words):
+ button = InlineKeyboardButton(
+ text=f"➕ {word_data.get('word', '')[:15]}",
+ callback_data=f"batch_word_{idx}"
+ )
+ if len(keyboard) == 0 or len(keyboard[-1]) == 2:
+ keyboard.append([button])
+ else:
+ keyboard[-1].append(button)
+
+ # Кнопка "Добавить все"
+ keyboard.append([
+ InlineKeyboardButton(text=t(lang, 'words.add_all_btn'), callback_data="batch_add_all")
+ ])
+
+ # Кнопка "Закрыть"
+ keyboard.append([
+ InlineKeyboardButton(text=t(lang, 'words.close_btn'), callback_data="batch_close")
+ ])
+
+ reply_markup = InlineKeyboardMarkup(inline_keyboard=keyboard)
+ await message.answer(text, reply_markup=reply_markup)
+
+
+@router.callback_query(F.data.startswith("batch_word_"), AddWordStates.viewing_batch)
+async def batch_add_single(callback: CallbackQuery, state: FSMContext):
+ """Добавить одно слово из batch"""
+ await callback.answer()
+ word_index = int(callback.data.split("_")[2])
+
+ data = await state.get_data()
+ words = data.get('batch_words', [])
+ user_id = data.get('user_id')
+
+ if word_index >= len(words):
+ return
+
+ word_data = words[word_index]
+
+ 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)
+
+ # Проверяем, нет ли уже такого слова
+ existing = await VocabularyService.get_word_by_original(
+ session, user_id, word_data.get('word', ''), source_lang=user.learning_language
+ )
+
+ if existing:
+ await callback.answer(t(lang, 'words.already_exists', word=word_data.get('word', '')), show_alert=True)
+ return
+
+ # Добавляем слово
+ translation_lang = get_user_translation_lang(user)
+
+ await VocabularyService.add_word(
+ session=session,
+ user_id=user_id,
+ word_original=word_data.get('word', ''),
+ word_translation=word_data.get('translation', ''),
+ source_lang=user.learning_language,
+ translation_lang=translation_lang,
+ transcription=word_data.get('transcription'),
+ source=WordSource.MANUAL
+ )
+
+ await callback.message.answer(t(lang, 'words.added_single', word=word_data.get('word', '')))
+
+
+@router.callback_query(F.data == "batch_add_all", AddWordStates.viewing_batch)
+async def batch_add_all(callback: CallbackQuery, state: FSMContext):
+ """Добавить все слова из batch"""
+ await callback.answer()
+
+ data = await state.get_data()
+ words = data.get('batch_words', [])
+ user_id = data.get('user_id')
+
+ added_count = 0
+ skipped_count = 0
+
+ async with async_session_maker() as session:
+ user = await UserService.get_user_by_telegram_id(session, callback.from_user.id)
+
+ for word_data in words:
+ # Проверяем, нет ли уже такого слова
+ existing = await VocabularyService.get_word_by_original(
+ session, user_id, word_data.get('word', ''), source_lang=user.learning_language
+ )
+
+ if existing:
+ skipped_count += 1
+ continue
+
+ # Добавляем слово
+ translation_lang = get_user_translation_lang(user)
+
+ await VocabularyService.add_word(
+ session=session,
+ user_id=user_id,
+ word_original=word_data.get('word', ''),
+ word_translation=word_data.get('translation', ''),
+ source_lang=user.learning_language,
+ translation_lang=translation_lang,
+ transcription=word_data.get('transcription'),
+ source=WordSource.MANUAL
+ )
+ added_count += 1
+
+ lang = get_user_lang(user)
+ result_text = t(lang, 'import.added_count', n=added_count)
+ if skipped_count > 0:
+ result_text += "\n" + t(lang, 'import.skipped_count', n=skipped_count)
+
+ await callback.message.edit_reply_markup(reply_markup=None)
+ await callback.message.answer(result_text)
+ await state.clear()
+
+
+@router.callback_query(F.data == "batch_close", AddWordStates.viewing_batch)
+async def batch_close(callback: CallbackQuery, state: FSMContext):
+ """Закрыть batch добавление"""
+ await callback.message.delete()
+ await state.clear()
+ await callback.answer()
+
+
WORDS_PER_PAGE = 10
diff --git a/bot/handlers/wordofday.py b/bot/handlers/wordofday.py
new file mode 100644
index 0000000..51fa4d5
--- /dev/null
+++ b/bot/handlers/wordofday.py
@@ -0,0 +1,139 @@
+"""Handler для функции 'Слово дня'."""
+
+from datetime import datetime
+
+from aiogram import Router, F
+from aiogram.filters import Command
+from aiogram.types import Message, CallbackQuery, InlineKeyboardMarkup, InlineKeyboardButton
+
+from database.db import async_session_maker
+from database.models import WordOfDay, WordSource
+from services.user_service import UserService
+from services.vocabulary_service import VocabularyService
+from services.wordofday_service import wordofday_service
+from utils.i18n import t, get_user_lang, get_user_translation_lang
+from utils.levels import get_user_level_for_language
+
+router = Router()
+
+
+def format_word_of_day(wod: WordOfDay, lang: str) -> str:
+ """Форматировать слово дня для отображения."""
+ date_str = wod.date.strftime("%d.%m.%Y")
+
+ text = f"🌅 {t(lang, 'wod.title')} — {date_str}\n\n"
+ text += f"📝 {wod.word}\n"
+
+ if wod.transcription:
+ text += f"🔊 [{wod.transcription}]\n"
+
+ text += f"\n💬 {wod.translation}\n"
+
+ # Примеры
+ if wod.examples:
+ text += f"\n📖 {t(lang, 'wod.examples')}:\n"
+ for ex in wod.examples[:2]:
+ sentence = ex.get('sentence', '')
+ translation = ex.get('translation', '')
+ text += f"• {sentence}\n"
+ if translation:
+ text += f" ({translation})\n"
+
+ # Синонимы
+ if wod.synonyms:
+ text += f"\n🔗 {t(lang, 'wod.synonyms')}: {wod.synonyms}\n"
+
+ # Этимология/интересный факт
+ if wod.etymology:
+ text += f"\n💡 {wod.etymology}\n"
+
+ return text
+
+
+@router.message(Command("wordofday"))
+async def cmd_wordofday(message: Message):
+ """Обработчик команды /wordofday."""
+ async with async_session_maker() as session:
+ user = await UserService.get_user_by_telegram_id(session, message.from_user.id)
+
+ if not user:
+ await message.answer(t('ru', 'common.start_first'))
+ return
+
+ lang = get_user_lang(user)
+ learning_lang = user.learning_language or 'en'
+ level = get_user_level_for_language(user)
+
+ # Получаем слово дня из глобальной таблицы
+ wod = await wordofday_service.get_word_of_day(
+ learning_lang=learning_lang,
+ level=level
+ )
+
+ if not wod:
+ # Слово ещё не сгенерировано - показываем сообщение
+ await message.answer(t(lang, 'wod.not_available'))
+ return
+
+ # Форматируем и отправляем
+ text = format_word_of_day(wod, lang)
+
+ # Кнопка добавления в словарь
+ keyboard = InlineKeyboardMarkup(inline_keyboard=[
+ [InlineKeyboardButton(
+ text=t(lang, 'wod.add_btn'),
+ callback_data=f"wod_add_{wod.id}"
+ )]
+ ])
+
+ await message.answer(text, reply_markup=keyboard)
+
+
+@router.callback_query(F.data.startswith("wod_add_"))
+async def wod_add_callback(callback: CallbackQuery):
+ """Добавить слово дня в словарь."""
+ await callback.answer()
+
+ wod_id = int(callback.data.replace("wod_add_", ""))
+
+ 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)
+
+ # Получаем слово дня
+ wod = await session.get(WordOfDay, wod_id)
+ if not wod:
+ await callback.answer(t(lang, 'wod.not_found'), show_alert=True)
+ return
+
+ # Проверяем, нет ли уже в словаре
+ existing = await VocabularyService.get_word_by_original(
+ session, user.id, wod.word, source_lang=wod.learning_lang
+ )
+
+ if existing:
+ await callback.answer(t(lang, 'words.already_exists', word=wod.word), show_alert=True)
+ return
+
+ # Добавляем в словарь
+ translation_lang = get_user_translation_lang(user)
+
+ await VocabularyService.add_word(
+ session=session,
+ user_id=user.id,
+ word_original=wod.word,
+ word_translation=wod.translation,
+ source_lang=wod.learning_lang,
+ translation_lang=translation_lang,
+ transcription=wod.transcription,
+ difficulty_level=wod.level,
+ source=WordSource.SUGGESTED
+ )
+
+ await session.commit()
+
+ # Обновляем сообщение
+ text = format_word_of_day(wod, lang)
+ text += f"\n✅ {t(lang, 'wod.added')}"
+
+ await callback.message.edit_text(text, reply_markup=None)
diff --git a/data/__init__.py b/data/__init__.py
new file mode 100644
index 0000000..aaf8b62
--- /dev/null
+++ b/data/__init__.py
@@ -0,0 +1 @@
+# Data module for grammar rules and other static data
diff --git a/data/grammar_rules.py b/data/grammar_rules.py
new file mode 100644
index 0000000..a862e8a
--- /dev/null
+++ b/data/grammar_rules.py
@@ -0,0 +1,321 @@
+"""
+Грамматические правила для упражнений по уровням CEFR (английский) и JLPT (японский).
+Данные основаны на официальных требованиях CEFR и JLPT.
+"""
+
+# Английский язык - CEFR уровни
+ENGLISH_GRAMMAR_RULES = {
+ "A1": [
+ {"id": "present_simple", "name": "Present Simple", "name_ru": "Простое настоящее время", "description": "I work, he works"},
+ {"id": "present_continuous", "name": "Present Continuous", "name_ru": "Настоящее длительное", "description": "I am working"},
+ {"id": "present_perfect", "name": "Present Perfect", "name_ru": "Настоящее совершенное", "description": "I have worked"},
+ {"id": "past_simple", "name": "Past Simple", "name_ru": "Простое прошедшее", "description": "I worked, I went"},
+ {"id": "irregular_verbs", "name": "Irregular verbs", "name_ru": "Неправильные глаголы", "description": "go-went-gone, see-saw-seen"},
+ {"id": "future_will", "name": "Future with will", "name_ru": "Будущее с will", "description": "I will work"},
+ {"id": "be_verb", "name": "Verb 'to be'", "name_ru": "Глагол to be", "description": "am, is, are"},
+ {"id": "have_got", "name": "Have got", "name_ru": "Have got", "description": "I have got / I've got"},
+ {"id": "there_is_are", "name": "There is/are", "name_ru": "There is/are", "description": "There is a book, there are books"},
+ {"id": "articles_basic", "name": "Articles (basic)", "name_ru": "Артикли (базовые)", "description": "a, an, the"},
+ {"id": "possessive_adj", "name": "Possessive adjectives", "name_ru": "Притяжательные прил.", "description": "my, your, his, her"},
+ {"id": "object_pronouns", "name": "Object pronouns", "name_ru": "Объектные местоимения", "description": "me, you, him, her"},
+ {"id": "demonstratives", "name": "Demonstratives", "name_ru": "Указательные мест.", "description": "this, that, these, those"},
+ {"id": "countable_uncountable", "name": "Countable/Uncountable", "name_ru": "Исчисл./неисчисляемые", "description": "many/much, some/any"},
+ {"id": "imperatives", "name": "Imperatives", "name_ru": "Повелительное накл.", "description": "Go!, Don't go!"},
+ {"id": "can_ability", "name": "Can (ability)", "name_ru": "Can (способность)", "description": "I can swim"},
+ {"id": "prepositions_place", "name": "Prepositions of place", "name_ru": "Предлоги места", "description": "in, on, at, under"},
+ {"id": "prepositions_time", "name": "Prepositions of time", "name_ru": "Предлоги времени", "description": "in, on, at (time)"},
+ {"id": "adjective_order", "name": "Adjective order", "name_ru": "Порядок прилагательных", "description": "a big red car"},
+ {"id": "adverbs_frequency", "name": "Adverbs of frequency", "name_ru": "Наречия частотности", "description": "always, usually, never"},
+ {"id": "how_much_many", "name": "How much/many", "name_ru": "How much/many", "description": "How much/How many"},
+ ],
+ "A2": [
+ {"id": "past_continuous", "name": "Past Continuous", "name_ru": "Прошедшее длительное", "description": "I was working"},
+ {"id": "present_perfect_ever", "name": "Present Perfect + ever/never", "name_ru": "Present Perfect + ever/never", "description": "Have you ever...?"},
+ {"id": "going_to", "name": "Going to (future)", "name_ru": "Going to (будущее)", "description": "I'm going to work"},
+ {"id": "comparatives", "name": "Comparatives", "name_ru": "Сравнительная степень", "description": "bigger, more expensive"},
+ {"id": "superlatives", "name": "Superlatives", "name_ru": "Превосходная степень", "description": "the biggest, the most"},
+ {"id": "must_obligation", "name": "Must (obligation)", "name_ru": "Must (обязательство)", "description": "You must go"},
+ {"id": "should_advice", "name": "Should (advice)", "name_ru": "Should (совет)", "description": "You should go"},
+ {"id": "have_to", "name": "Have to", "name_ru": "Have to", "description": "I have to work"},
+ {"id": "could_past", "name": "Could (past ability)", "name_ru": "Could (прошлая способ.)", "description": "I could swim when I was 5"},
+ {"id": "would_like", "name": "Would like", "name_ru": "Would like", "description": "I would like to..."},
+ {"id": "first_conditional", "name": "First Conditional", "name_ru": "Условные 1 типа", "description": "If it rains, I will stay"},
+ {"id": "gerund_verb", "name": "Gerund after verbs", "name_ru": "Герундий после глаголов", "description": "I enjoy swimming"},
+ {"id": "infinitive_verb", "name": "Infinitive after verbs", "name_ru": "Инфинитив после глаг.", "description": "I want to go"},
+ {"id": "adverbs_manner", "name": "Adverbs of manner", "name_ru": "Наречия образа действия", "description": "quickly, slowly"},
+ {"id": "possessive_pronouns", "name": "Possessive pronouns", "name_ru": "Притяжательные мест.", "description": "mine, yours, his"},
+ {"id": "relative_who_which", "name": "Relative clauses (who/which)", "name_ru": "Относительные (who/which)", "description": "The man who..."},
+ {"id": "too_enough", "name": "Too/Enough", "name_ru": "Too/Enough", "description": "too big, big enough"},
+ ],
+ "B1": [
+ {"id": "past_perfect", "name": "Past Perfect", "name_ru": "Прошедшее совершенное", "description": "I had worked"},
+ {"id": "present_perfect_cont", "name": "Present Perfect Continuous", "name_ru": "Наст. соверш. длит.", "description": "I have been working"},
+ {"id": "future_continuous", "name": "Future Continuous", "name_ru": "Будущее длительное", "description": "I will be working"},
+ {"id": "second_conditional", "name": "Second Conditional", "name_ru": "Условные 2 типа", "description": "If I had money, I would buy"},
+ {"id": "passive_simple", "name": "Passive Voice (simple)", "name_ru": "Страдательный залог", "description": "The book was written"},
+ {"id": "reported_speech", "name": "Reported Speech", "name_ru": "Косвенная речь", "description": "He said that..."},
+ {"id": "used_to", "name": "Used to", "name_ru": "Used to", "description": "I used to play"},
+ {"id": "modals_possibility", "name": "Modals of possibility", "name_ru": "Модальные (возможность)", "description": "might, may, could"},
+ {"id": "relative_clauses_def", "name": "Defining relative clauses", "name_ru": "Определяющие придат.", "description": "The book that I read"},
+ {"id": "question_tags", "name": "Question tags", "name_ru": "Разделительные вопросы", "description": "You like it, don't you?"},
+ {"id": "so_neither", "name": "So/Neither", "name_ru": "So/Neither", "description": "So do I, Neither do I"},
+ {"id": "phrasal_verbs_basic", "name": "Phrasal verbs (basic)", "name_ru": "Фразовые глаголы", "description": "get up, look for"},
+ {"id": "wish_present", "name": "Wish + past simple", "name_ru": "Wish (настоящее)", "description": "I wish I had..."},
+ ],
+ "B2": [
+ {"id": "past_perfect_cont", "name": "Past Perfect Continuous", "name_ru": "Прошедшее соверш. длит.", "description": "I had been working"},
+ {"id": "future_perfect", "name": "Future Perfect", "name_ru": "Будущее совершенное", "description": "I will have finished"},
+ {"id": "future_perfect_cont", "name": "Future Perfect Continuous", "name_ru": "Будущее соверш. длит.", "description": "I will have been working"},
+ {"id": "third_conditional", "name": "Third Conditional", "name_ru": "Условные 3 типа", "description": "If I had known, I would have..."},
+ {"id": "mixed_conditionals", "name": "Mixed Conditionals", "name_ru": "Смешанные условные", "description": "If I had studied, I would be..."},
+ {"id": "passive_all_tenses", "name": "Passive (all tenses)", "name_ru": "Страд. залог (все времена)", "description": "is being done, had been done"},
+ {"id": "causative_have", "name": "Causative (have/get)", "name_ru": "Каузатив", "description": "I had my hair cut"},
+ {"id": "relative_non_defining", "name": "Non-defining relatives", "name_ru": "Неопред. придаточные", "description": "My sister, who lives..."},
+ {"id": "inversion", "name": "Inversion", "name_ru": "Инверсия", "description": "Never have I seen..."},
+ {"id": "wish_past", "name": "Wish + past perfect", "name_ru": "Wish (прошедшее)", "description": "I wish I had done..."},
+ {"id": "modals_deduction", "name": "Modals of deduction", "name_ru": "Модальные (вывод)", "description": "must be, can't be, might have"},
+ {"id": "emphasis_cleft", "name": "Cleft sentences", "name_ru": "Расщепленные предл.", "description": "It was John who..."},
+ {"id": "participle_clauses", "name": "Participle clauses", "name_ru": "Причастные обороты", "description": "Having finished, I left"},
+ ],
+ "C1": [
+ {"id": "subjunctive", "name": "Subjunctive mood", "name_ru": "Сослагательное накл.", "description": "I suggest that he go..."},
+ {"id": "inversion_negative", "name": "Inversion (negative adverbials)", "name_ru": "Инверсия (отриц.)", "description": "Rarely do I..."},
+ {"id": "ellipsis", "name": "Ellipsis", "name_ru": "Эллипсис", "description": "I can and will do it"},
+ {"id": "fronting", "name": "Fronting", "name_ru": "Фронтинг", "description": "Strange though it may seem"},
+ {"id": "nominal_relative", "name": "Nominal relative clauses", "name_ru": "Номинальные придат.", "description": "What I need is..."},
+ {"id": "advanced_passives", "name": "Advanced passives", "name_ru": "Сложный страд. залог", "description": "It is said that..."},
+ {"id": "discourse_markers", "name": "Discourse markers", "name_ru": "Дискурсивные маркеры", "description": "nevertheless, furthermore"},
+ ],
+ "C2": [
+ {"id": "advanced_inversion", "name": "Advanced inversion", "name_ru": "Продвинутая инверсия", "description": "So surprised was I that..."},
+ {"id": "complex_passives", "name": "Complex passive structures", "name_ru": "Сложные страд. структуры", "description": "He is believed to have..."},
+ {"id": "idiomatic_subjunctive", "name": "Idiomatic subjunctive", "name_ru": "Идиом. сослагательное", "description": "Be that as it may..."},
+ {"id": "advanced_conditionals", "name": "Advanced conditionals", "name_ru": "Продвинутые условные", "description": "Were it not for..."},
+ {"id": "nuanced_modals", "name": "Nuanced modals", "name_ru": "Нюансы модальных", "description": "could well be, might just"},
+ ],
+}
+
+# Японский язык - JLPT уровни (N5-N1)
+JAPANESE_GRAMMAR_RULES = {
+ "N5": [
+ # Частицы
+ {"id": "particle_wa", "name": "Частица は (тема)", "name_ru": "Частица は (тема)", "description": "わたしは学生です"},
+ {"id": "particle_ga", "name": "Частица が (подлежащее)", "name_ru": "Частица が (подлежащее)", "description": "ねこがいます"},
+ {"id": "particle_wo", "name": "Частица を (объект)", "name_ru": "Частица を (объект)", "description": "りんごをたべます"},
+ {"id": "particle_ni", "name": "Частица に (направление/время)", "name_ru": "Частица に (направление/время)", "description": "がっこうにいきます、7じにおきます"},
+ {"id": "particle_de", "name": "Частица で (место/средство)", "name_ru": "Частица で (место/средство)", "description": "でんしゃでいきます"},
+ {"id": "particle_he", "name": "Частица へ (направление)", "name_ru": "Частица へ (направление)", "description": "にほんへいきます"},
+ {"id": "particle_to", "name": "Частица と (и/с)", "name_ru": "Частица と (и/с)", "description": "ともだちといきます"},
+ {"id": "particle_mo", "name": "Частица も (тоже)", "name_ru": "Частица も (тоже)", "description": "わたしもいきます"},
+ {"id": "particle_no", "name": "Частица の (притяжание)", "name_ru": "Частица の (притяжание)", "description": "わたしのほん"},
+ {"id": "particle_ka", "name": "Частица か (вопрос)", "name_ru": "Частица か (вопрос)", "description": "これはなんですか"},
+ {"id": "particle_ne_yo", "name": "Частицы ね/よ", "name_ru": "Частицы ね/よ", "description": "いいですね、いきますよ"},
+ # Глаголы
+ {"id": "verb_masu", "name": "ます-форма глаголов", "name_ru": "ます-форма глаголов", "description": "たべます、のみます"},
+ {"id": "verb_te", "name": "て-форма глаголов", "name_ru": "て-форма глаголов", "description": "たべて、のんで、いって"},
+ {"id": "verb_ta", "name": "た-форма (прошедшее)", "name_ru": "た-форма (прошедшее)", "description": "たべた、のんだ"},
+ {"id": "verb_nai", "name": "ない-форма (отрицание)", "name_ru": "ない-форма (отрицание)", "description": "たべない、のまない"},
+ {"id": "verb_te_kudasai", "name": "てください (просьба)", "name_ru": "てください (просьба)", "description": "たべてください"},
+ {"id": "verb_te_imasu", "name": "ています (длительное)", "name_ru": "ています (длительное)", "description": "たべています"},
+ {"id": "verb_tai", "name": "たい (хочу)", "name_ru": "たい (хочу)", "description": "たべたい、いきたい"},
+ {"id": "verb_mashou", "name": "ましょう (предложение)", "name_ru": "ましょう (предложение)", "description": "いきましょう"},
+ # Прилагательные
+ {"id": "adj_i", "name": "い-прилагательные", "name_ru": "い-прилагательные", "description": "おおきい、ちいさい、あたらしい"},
+ {"id": "adj_na", "name": "な-прилагательные", "name_ru": "な-прилагательные", "description": "きれいな、しずかな、げんきな"},
+ {"id": "adj_past", "name": "Прошедшее время прил.", "name_ru": "Прошедшее время прилагательных", "description": "おおきかった、しずかだった"},
+ {"id": "adj_negative", "name": "Отрицание прилагательных", "name_ru": "Отрицание прилагательных", "description": "おおきくない、しずかじゃない"},
+ # Базовые конструкции
+ {"id": "desu_da", "name": "です/だ (связка)", "name_ru": "です/だ (связка)", "description": "がくせいです"},
+ {"id": "aru_iru", "name": "ある/いる (существование)", "name_ru": "ある/いる (существование)", "description": "ほんがあります、ねこがいます"},
+ {"id": "kara_made", "name": "から/まで (от/до)", "name_ru": "から/まで (от/до)", "description": "9じから5じまで"},
+ {"id": "kara_reason", "name": "から (причина)", "name_ru": "から (причина)", "description": "あついからまどをあけます"},
+ {"id": "ga_hoshii", "name": "がほしい (хочу что-то)", "name_ru": "がほしい (хочу что-то)", "description": "みずがほしいです"},
+ {"id": "counters_basic", "name": "Счётные слова (базовые)", "name_ru": "Счётные слова (базовые)", "description": "ひとつ、ふたり、さんぼん"},
+ ],
+ "N4": [
+ # Формы глаголов
+ {"id": "potential", "name": "Потенциальная форма", "name_ru": "Потенциальная форма (できる)", "description": "たべられる、のめる、できる"},
+ {"id": "volitional", "name": "Волитивная форма (よう)", "name_ru": "Волитивная форма (よう)", "description": "たべよう、いこう"},
+ {"id": "imperative", "name": "Повелительная форма", "name_ru": "Повелительная форма", "description": "たべろ、いけ、するな"},
+ {"id": "passive", "name": "Страдательный залог", "name_ru": "Страдательный залог (られる)", "description": "たべられる、よまれる"},
+ {"id": "causative", "name": "Каузатив (させる)", "name_ru": "Каузатив (させる)", "description": "たべさせる、いかせる"},
+ # Условные формы
+ {"id": "cond_ba", "name": "Условие ～ば", "name_ru": "Условие ～ば", "description": "たべれば、いけば"},
+ {"id": "cond_tara", "name": "Условие ～たら", "name_ru": "Условие ～たら", "description": "たべたら、いったら"},
+ {"id": "cond_nara", "name": "Условие ～なら", "name_ru": "Условие ～なら", "description": "いくなら、たかいなら"},
+ {"id": "cond_to", "name": "Условие ～と", "name_ru": "Условие ～と", "description": "ボタンをおすとドアがあく"},
+ # Грамматические конструкции
+ {"id": "te_kara", "name": "てから (после того как)", "name_ru": "てから (после того как)", "description": "たべてからでかけます"},
+ {"id": "te_shimau", "name": "てしまう (завершение/сожаление)", "name_ru": "てしまう (завершение/сожаление)", "description": "たべてしまった、わすれてしまった"},
+ {"id": "te_oku", "name": "ておく (заранее)", "name_ru": "ておく (заранее)", "description": "よやくしておきます"},
+ {"id": "te_aru", "name": "てある (результат)", "name_ru": "てある (результат)", "description": "まどがあけてある"},
+ {"id": "te_miru", "name": "てみる (попробовать)", "name_ru": "てみる (попробовать)", "description": "たべてみる"},
+ {"id": "te_iku_kuru", "name": "ていく/てくる", "name_ru": "ていく/てくる", "description": "もっていく、かってくる"},
+ {"id": "te_ageru_morau_kureru", "name": "てあげる/もらう/くれる", "name_ru": "てあげる/もらう/くれる", "description": "おしえてあげる"},
+ {"id": "you_ni_naru", "name": "ようになる (стать)", "name_ru": "ようになる (стать)", "description": "はなせるようになった"},
+ {"id": "you_ni_suru", "name": "ようにする (стараться)", "name_ru": "ようにする (стараться)", "description": "はやくねるようにする"},
+ {"id": "sou_appearance", "name": "そう (выглядит)", "name_ru": "そう (выглядит)", "description": "おいしそう、ふりそう"},
+ {"id": "sou_hearsay", "name": "そうだ (говорят)", "name_ru": "そうだ (говорят)", "description": "あめがふるそうだ"},
+ {"id": "rashii", "name": "らしい (похоже)", "name_ru": "らしい (похоже/типично)", "description": "かれはびょうきらしい"},
+ {"id": "noni", "name": "のに (хотя)", "name_ru": "のに (хотя)", "description": "いったのにいなかった"},
+ {"id": "tame_ni", "name": "ために (для/из-за)", "name_ru": "ために (для/из-за)", "description": "けんこうのためにうんどうする"},
+ {"id": "node", "name": "ので (потому что)", "name_ru": "ので (потому что)", "description": "あめなのでいかない"},
+ ],
+ "N3": [
+ # Сложные формы глаголов
+ {"id": "causative_passive", "name": "Каузатив-пассив", "name_ru": "Каузатив-пассив (させられる)", "description": "たべさせられる"},
+ {"id": "passive_adversative", "name": "Адверсатив (страдание)", "name_ru": "Адверсативный пассив", "description": "あめにふられた"},
+ # Грамматические конструкции
+ {"id": "wake", "name": "わけ (смысл/причина)", "name_ru": "わけ (смысл/причина)", "description": "いくわけにはいかない"},
+ {"id": "wake_da", "name": "わけだ (выходит что)", "name_ru": "わけだ (выходит что)", "description": "だからつかれたわけだ"},
+ {"id": "hazu", "name": "はず (должно быть)", "name_ru": "はず (должно быть)", "description": "もうついたはずだ"},
+ {"id": "beki", "name": "べき (следует)", "name_ru": "べき (следует)", "description": "いくべきだ"},
+ {"id": "koto_ni_naru", "name": "ことになる (решено)", "name_ru": "ことになる (решено)", "description": "にほんにいくことになった"},
+ {"id": "koto_ni_suru", "name": "ことにする (решить)", "name_ru": "ことにする (решить)", "description": "やめることにした"},
+ {"id": "koto_ga_aru", "name": "ことがある (бывает/опыт)", "name_ru": "ことがある (бывает/опыт)", "description": "いったことがある"},
+ {"id": "koto_ga_dekiru", "name": "ことができる (можно)", "name_ru": "ことができる (можно)", "description": "およぐことができる"},
+ {"id": "mono", "name": "もの/もん (ведь)", "name_ru": "もの/もん (ведь)", "description": "だってすきなんだもん"},
+ {"id": "bakari", "name": "ばかり (только/недавно)", "name_ru": "ばかり (только/недавно)", "description": "きたばかり、ゲームばかり"},
+ {"id": "to_iu", "name": "という (называемый)", "name_ru": "という (называемый)", "description": "さくらというはな"},
+ {"id": "you_da", "name": "ようだ (похоже)", "name_ru": "ようだ (похоже)", "description": "かれはつかれているようだ"},
+ {"id": "mitai", "name": "みたい (как будто)", "name_ru": "みたい (как будто)", "description": "ゆめみたい"},
+ {"id": "tsumori", "name": "つもり (намерение)", "name_ru": "つもり (намерение)", "description": "いくつもりだ"},
+ {"id": "tokoro", "name": "ところ (момент)", "name_ru": "ところ (момент)", "description": "いまでかけるところ"},
+ {"id": "aida", "name": "間/間に (пока)", "name_ru": "間/間に (пока)", "description": "ねているあいだに"},
+ {"id": "nagara", "name": "ながら (одновременно)", "name_ru": "ながら (одновременно)", "description": "あるきながらはなす"},
+ {"id": "toki", "name": "とき (когда)", "name_ru": "とき (когда)", "description": "いくとき、いったとき"},
+ {"id": "ba_ii", "name": "ばいい (достаточно)", "name_ru": "ばいい (достаточно)", "description": "いけばいい"},
+ {"id": "tara_ii", "name": "たらいい (лучше бы)", "name_ru": "たらいい (лучше бы)", "description": "いったらいいのに"},
+ # Выражения
+ {"id": "te_hoshii", "name": "てほしい (хочу чтобы)", "name_ru": "てほしい (хочу чтобы)", "description": "きてほしい"},
+ {"id": "te_naranai", "name": "てならない (очень)", "name_ru": "てならない (очень)", "description": "うれしくてならない"},
+ {"id": "te_tamaranai", "name": "てたまらない (невыносимо)", "name_ru": "てたまらない (невыносимо)", "description": "あつくてたまらない"},
+ ],
+ "N2": [
+ # Продвинутая грамматика
+ {"id": "zaru_wo_enai", "name": "ざるを得ない (вынужден)", "name_ru": "ざるを得ない (вынужден)", "description": "いかざるをえない"},
+ {"id": "nai_wake_ni_wa_ikanai", "name": "ないわけにはいかない", "name_ru": "ないわけにはいかない", "description": "いかないわけにはいかない"},
+ {"id": "ppoi", "name": "っぽい (похожий на)", "name_ru": "っぽい (похожий на)", "description": "こどもっぽい、あきっぽい"},
+ {"id": "gachi", "name": "がち (склонен)", "name_ru": "がち (склонен)", "description": "びょうきがち、わすれがち"},
+ {"id": "gimi", "name": "ぎみ (слегка)", "name_ru": "ぎみ (слегка)", "description": "つかれぎみ、かぜぎみ"},
+ {"id": "kke", "name": "っけ (кажется/вспомнил)", "name_ru": "っけ (кажется/вспомнил)", "description": "なんだっけ"},
+ {"id": "dokoro_ka", "name": "どころか (не то что)", "name_ru": "どころか (не то что)", "description": "かんたんどころかむずかしい"},
+ {"id": "koso", "name": "こそ (именно)", "name_ru": "こそ (именно)", "description": "こちらこそ、いまこそ"},
+ {"id": "sae", "name": "さえ (даже)", "name_ru": "さえ (даже)", "description": "こどもでさえしっている"},
+ {"id": "sae_ba", "name": "さえ～ば (если только)", "name_ru": "さえ～ば (если только)", "description": "おかねさえあればいい"},
+ {"id": "shika_nai", "name": "しかない (только/приходится)", "name_ru": "しかない (только/приходится)", "description": "いくしかない"},
+ {"id": "to_wa_kagiranai", "name": "とは限らない (не обязательно)", "name_ru": "とは限らない (не обязательно)", "description": "たかいとはかぎらない"},
+ {"id": "mono_nara", "name": "ものなら (если бы)", "name_ru": "ものなら (если бы)", "description": "できるものならやってみろ"},
+ {"id": "mono_da", "name": "ものだ (так уж устроено)", "name_ru": "ものだ (так уж устроено)", "description": "むかしはよくいったものだ"},
+ {"id": "mono_no", "name": "ものの (хотя)", "name_ru": "ものの (хотя)", "description": "かったものの、つかわない"},
+ # Формальный стиль
+ {"id": "ni_tsuite", "name": "について (о/насчёт)", "name_ru": "について (о/насчёт)", "description": "にほんについて"},
+ {"id": "ni_totte", "name": "にとって (для кого)", "name_ru": "にとって (для кого)", "description": "わたしにとって"},
+ {"id": "ni_yotte", "name": "によって (в зависимости)", "name_ru": "によって (в зависимости)", "description": "ひとによってちがう"},
+ {"id": "ni_oite", "name": "において (в/на)", "name_ru": "において (в/на)", "description": "かいぎにおいて"},
+ {"id": "ni_kanshite", "name": "に関して (касательно)", "name_ru": "に関して (касательно)", "description": "じけんにかんして"},
+ {"id": "ni_okeru", "name": "における (в контексте)", "name_ru": "における (в контексте)", "description": "にほんにおけるもんだい"},
+ {"id": "to_shite", "name": "として (в качестве)", "name_ru": "として (в качестве)", "description": "がくせいとして"},
+ {"id": "keigo_sonkei", "name": "Уважительное кейго", "name_ru": "Уважительное кейго (尊敬語)", "description": "いらっしゃる、おっしゃる"},
+ {"id": "keigo_kenjou", "name": "Скромное кейго", "name_ru": "Скромное кейго (謙譲語)", "description": "いたす、もうす、まいる"},
+ ],
+ "N1": [
+ # Литературные и архаичные формы
+ {"id": "de_aru", "name": "である (письм. связка)", "name_ru": "である (письменная связка)", "description": "これは本である"},
+ {"id": "taru", "name": "たる (книжный)", "name_ru": "たる (книжный)", "description": "いだいたる、どうどうたる"},
+ {"id": "beshi", "name": "べし (книжный долг)", "name_ru": "べし (книжный)", "description": "しるべし、ゆくべし"},
+ {"id": "nari", "name": "なり (книжный)", "name_ru": "なり (книжный)", "description": "なんなりと、きくなり"},
+ {"id": "gotoku", "name": "ごとく/ごとし (подобно)", "name_ru": "ごとく/ごとし (подобно)", "description": "みずのごとく"},
+ {"id": "zukunme", "name": "ずくめ (сплошь)", "name_ru": "ずくめ (сплошь)", "description": "くろずくめ、いいことずくめ"},
+ # Сложные конструкции
+ {"id": "made_mo_nai", "name": "までもない (не нужно)", "name_ru": "までもない (не нужно)", "description": "いうまでもない"},
+ {"id": "ni_taeru", "name": "に耐える (выдерживать)", "name_ru": "に耐える (выдерживать)", "description": "ひひょうにたえる"},
+ {"id": "ni_taenai", "name": "に堪えない (не выдержать)", "name_ru": "に堪えない (не выдержать)", "description": "みるにたえない"},
+ {"id": "wo_motte", "name": "をもって (посредством)", "name_ru": "をもって (посредством)", "description": "せいいをもって"},
+ {"id": "wo_kagiri_ni", "name": "を限りに (начиная с)", "name_ru": "を限りに (начиная с)", "description": "きょうをかぎりに"},
+ {"id": "wo_yogi_naku_sareru", "name": "を余儀なくされる", "name_ru": "を余儀なくされる", "description": "へんこうをよぎなくされる"},
+ {"id": "wo_mono_tomo_shinai", "name": "をものともしない", "name_ru": "をものともしない", "description": "きけんをものともしない"},
+ {"id": "ikan", "name": "いかん (формальный)", "name_ru": "いかん (формальный)", "description": "けっかいかんでは"},
+ {"id": "ikan_ni_yotte", "name": "いかんによって", "name_ru": "いかんによって", "description": "どりょくいかんによって"},
+ {"id": "ni_sokushite", "name": "に即して (в соответствии)", "name_ru": "に即して (в соответствии)", "description": "じじつにそくして"},
+ {"id": "ni_hoka_naranai", "name": "にほかならない (не что иное)", "name_ru": "にほかならない (не что иное)", "description": "これはあいにほかならない"},
+ {"id": "tomo_arou", "name": "ともあろう (несмотря на статус)", "name_ru": "ともあろう (несмотря на статус)", "description": "せんせいともあろうひとが"},
+ {"id": "tomo_naku", "name": "ともなく (без особого)", "name_ru": "ともなく (без особого)", "description": "みるともなくみる"},
+ {"id": "to_iedo_mo", "name": "といえども (даже если)", "name_ru": "といえども (даже если)", "description": "せんもんかといえども"},
+ {"id": "nagaramo", "name": "ながらも (хотя и)", "name_ru": "ながらも (хотя и)", "description": "ざんねんながらも"},
+ {"id": "tomo_sureba", "name": "ともすれば (порой)", "name_ru": "ともすれば (порой)", "description": "ともすればわすれがち"},
+ ],
+}
+
+
+def get_grammar_topics_for_level(learning_lang: str, level: str) -> list:
+ """
+ Получить список грамматических тем для уровня.
+
+ Args:
+ learning_lang: Язык изучения ('en' или 'ja')
+ level: Уровень пользователя (A1-C2 для английского, N5-N1 для японского)
+
+ Returns:
+ Список словарей с грамматическими темами
+ """
+ if learning_lang == 'en':
+ rules = ENGLISH_GRAMMAR_RULES
+ # Для английского включаем текущий уровень и все ниже
+ level_order = ['A1', 'A2', 'B1', 'B2', 'C1', 'C2']
+ elif learning_lang == 'ja':
+ rules = JAPANESE_GRAMMAR_RULES
+ # Для японского N5 - самый низкий, N1 - самый высокий
+ level_order = ['N5', 'N4', 'N3', 'N2', 'N1']
+ else:
+ return []
+
+ # Нормализуем уровень
+ level_upper = level.upper()
+ if level_upper not in level_order:
+ # Если уровень не распознан, возвращаем базовый
+ level_upper = level_order[0]
+
+ # Собираем темы для текущего и всех предыдущих уровней
+ result = []
+ for lvl in level_order:
+ if lvl in rules:
+ for topic in rules[lvl]:
+ topic_copy = topic.copy()
+ topic_copy['level'] = lvl
+ result.append(topic_copy)
+ if lvl == level_upper:
+ break
+
+ return result
+
+
+def get_topics_for_current_level_only(learning_lang: str, level: str) -> list:
+ """
+ Получить список грамматических тем ТОЛЬКО для текущего уровня.
+
+ Args:
+ learning_lang: Язык изучения ('en' или 'ja')
+ level: Уровень пользователя
+
+ Returns:
+ Список словарей с грамматическими темами только для текущего уровня
+ """
+ if learning_lang == 'en':
+ rules = ENGLISH_GRAMMAR_RULES
+ elif learning_lang == 'ja':
+ rules = JAPANESE_GRAMMAR_RULES
+ else:
+ return []
+
+ level_upper = level.upper()
+ if level_upper not in rules:
+ return []
+
+ result = []
+ for topic in rules[level_upper]:
+ topic_copy = topic.copy()
+ topic_copy['level'] = level_upper
+ result.append(topic_copy)
+
+ return result
diff --git a/database/models.py b/database/models.py
index 6623882..1d890df 100644
--- a/database/models.py
+++ b/database/models.py
@@ -139,3 +139,52 @@ class AIModel(Base):
display_name: Mapped[str] = mapped_column(String(100), nullable=False) # Название для отображения
is_active: Mapped[bool] = mapped_column(Boolean, default=False) # Только одна модель активна
created_at: Mapped[datetime] = mapped_column(DateTime, default=datetime.utcnow)
+
+
+class StoryGenre(str, enum.Enum):
+ """Жанры мини-историй"""
+ dialogue = "dialogue" # 🗣 Диалоги
+ news = "news" # 📰 Новости
+ story = "story" # 🎭 Истории
+ letter = "letter" # 📧 Письма
+ recipe = "recipe" # 🍳 Рецепты
+
+
+class MiniStory(Base):
+ """Модель мини-истории для чтения"""
+ __tablename__ = "mini_stories"
+
+ id: Mapped[int] = mapped_column(primary_key=True)
+ user_id: Mapped[int] = mapped_column(Integer, nullable=False, index=True)
+ title: Mapped[str] = mapped_column(String(255), nullable=False)
+ content: Mapped[str] = mapped_column(String(5000), nullable=False) # Текст истории
+ translation: Mapped[Optional[str]] = mapped_column(String(5000), nullable=True) # Перевод истории
+ genre: Mapped[StoryGenre] = mapped_column(SQLEnum(StoryGenre), nullable=False)
+ learning_lang: Mapped[str] = mapped_column(String(5), nullable=False) # en/ja
+ level: Mapped[str] = mapped_column(String(5), nullable=False) # A1-C2 или N5-N1
+ word_count: Mapped[int] = mapped_column(Integer, default=0) # Количество слов
+ vocabulary: Mapped[Optional[dict]] = mapped_column(JSON) # [{word, translation, transcription}]
+ questions: Mapped[Optional[dict]] = mapped_column(JSON) # [{question, options[], correct}]
+ is_completed: Mapped[bool] = mapped_column(Boolean, default=False)
+ correct_answers: Mapped[int] = mapped_column(Integer, default=0)
+ created_at: Mapped[datetime] = mapped_column(DateTime, default=datetime.utcnow)
+
+
+class WordOfDay(Base):
+ """Модель слова дня (глобальная для всех пользователей по уровню)"""
+ __tablename__ = "word_of_day"
+ __table_args__ = (
+ UniqueConstraint("date", "learning_lang", "level", name="uq_wod_date_lang_level"),
+ )
+
+ id: Mapped[int] = mapped_column(primary_key=True)
+ word: Mapped[str] = mapped_column(String(255), nullable=False)
+ transcription: Mapped[Optional[str]] = mapped_column(String(255))
+ translation: Mapped[str] = mapped_column(String(500), nullable=False)
+ examples: Mapped[Optional[dict]] = mapped_column(JSON) # [{sentence, translation}]
+ synonyms: Mapped[Optional[str]] = mapped_column(String(500)) # Синонимы через запятую
+ etymology: Mapped[Optional[str]] = mapped_column(String(500)) # Этимология/интересный факт
+ learning_lang: Mapped[str] = mapped_column(String(5), nullable=False, index=True) # en/ja
+ level: Mapped[str] = mapped_column(String(5), nullable=False, index=True) # A1-C2 или N5-N1
+ date: Mapped[datetime] = mapped_column(DateTime, nullable=False, index=True) # Дата слова (только дата, без времени)
+ created_at: Mapped[datetime] = mapped_column(DateTime, default=datetime.utcnow)
diff --git a/locales/en.json b/locales/en.json
index 1954976..debffc3 100644
--- a/locales/en.json
+++ b/locales/en.json
@@ -1,15 +1,34 @@
{
"menu": {
+ "wordofday": "🌅 Word of Day",
"add": "➕ Add word",
"vocab": "📚 Vocabulary",
"task": "🧠 Task",
"practice": "💬 Practice",
+ "exercises": "📖 Exercises",
"words": "🎯 Thematic words",
"import": "📖 Import",
"stats": "📊 Stats",
"settings": "⚙️ Settings",
"below": "Main menu below ⤵️"
},
+ "practice_menu": {
+ "title": "Practice",
+ "choose": "Choose practice mode:",
+ "stories": "Mini Stories",
+ "ai_chat": "AI Chat"
+ },
+ "wod": {
+ "title": "Word of the Day",
+ "generating": "🔄 Generating word of the day...",
+ "failed": "❌ Failed to generate word of the day. Try again later.",
+ "not_available": "🕐 Word of the day is not ready yet.\n\nWords are generated daily at 00:00 UTC.\nTry again later!",
+ "examples": "Examples",
+ "synonyms": "Synonyms",
+ "add_btn": "➕ Add to vocabulary",
+ "added": "Added to vocabulary!",
+ "not_found": "Word not found"
+ },
"add_menu": {
"title": "➕ Add words\n\nChoose method:",
"manual": "📝 Manual",
@@ -55,7 +74,7 @@
"skip_msg": "✅ Okay!\n\nYou can take the test later with /level_test\nor set level manually in /settings\n\nLet's start! Try:\n• /words travel - thematic words\n• /practice - AI dialogue\n• /add hello - add a word"
},
"add": {
- "prompt": "Send the word you want to add:\nFor example: /add elephant\n\nOr just send the word without a command!",
+ "prompt": "Send the word you want to add:\n• Single word: /add elephant\n• Multiple: /add apple, banana, orange\n\nOr just send the word without a command!",
"searching": "⏳ Looking up translation and examples...",
"examples_header": "Examples:",
"translations_header": "Translations:",
@@ -69,6 +88,13 @@
"added_success": "✅ Word '{word}' added!\n\nTotal words in vocabulary: {count}\n\nKeep adding new words or use /task to practice!",
"cancelled": "Cancelled. You can add another word with /add"
},
+ "add_batch": {
+ "header": "📝 Words to add ({n}):",
+ "translating": "⏳ Translating {n} words...",
+ "choose": "Select words to add or add all at once:",
+ "truncated": "⚠️ Too many words. Showing first {n}.",
+ "failed": "❌ Failed to get translations. Try again later."
+ },
"vocab": {
"empty": "📚 Your vocabulary is empty!\n\nAdd your first word with /add or just send me a word.",
"header": "📚 Your vocabulary:",
@@ -191,7 +217,54 @@
"invalid_format": "❌ Invalid time format!\n\nUse HH:MM (e.g., 09:00 or 18:30)\nOr send /cancel to abort",
"time_set_title": "✅ Time set!",
"status_on_line": "Status: Enabled",
- "use_settings": "Use /reminder to change settings."
+ "use_settings": "Use /reminder to change settings.",
+ "daily_title": "⏰ Time to practice!",
+ "daily_wod": "🌅 Word of the Day:",
+ "daily_tips": "Don't forget to practice today:\n• /task - complete tasks\n• /practice - practice dialogue\n• /words - add new words",
+ "daily_motivation": "💪 Regular practice is the key to success!"
+ },
+ "story": {
+ "title": "Mini Stories",
+ "choose_genre": "Choose a story genre:",
+ "genre": {
+ "dialogue": "Dialogues",
+ "news": "News",
+ "story": "Stories",
+ "letter": "Letters",
+ "recipe": "Recipes"
+ },
+ "generating": "🔄 Generating story...",
+ "failed": "❌ Failed to generate story. Try again.",
+ "try_again": "Try again",
+ "level": "Level",
+ "words": "words",
+ "questions_btn": "Questions",
+ "vocab_btn": "Vocabulary",
+ "new_btn": "New story",
+ "back": "Back",
+ "not_found": "Story not found",
+ "no_vocab": "No vocabulary words",
+ "no_questions": "No questions",
+ "vocabulary": "Story Vocabulary",
+ "add_all": "Add all",
+ "word_added": "✅ Word '{word}' added!",
+ "words_added": "✅ Added words: {n}",
+ "word_not_found": "Word not found",
+ "question": "Question",
+ "question_not_found": "Question not found",
+ "correct": "✅ Correct!",
+ "incorrect": "❌ Incorrect",
+ "next_question": "Next question",
+ "show_results": "Results",
+ "results_title": "Results",
+ "correct_answers": "Correct answers",
+ "accuracy": "Accuracy",
+ "result_excellent": "Excellent! You understood the text well.",
+ "result_good": "Good job! You understood most of the text.",
+ "result_practice": "Try reading the story more carefully.",
+ "translation": "Translation",
+ "show_translation": "Show translation",
+ "hide_translation": "Hide translation"
},
"level_test": {
"show_translation_btn": "👁️ Show question translation",
@@ -330,5 +403,29 @@
"err_not_found": "❌ Error: word not found",
"already_exists": "The word '{word}' is already in your vocabulary",
"added_single": "✅ Word '{word}' added to vocabulary"
+ },
+ "exercises": {
+ "title": "📖 Grammar Exercises",
+ "choose_topic": "Choose a topic for exercises:",
+ "your_level": "Your level: {level}",
+ "generating_rule": "🔄 Generating grammar explanation...",
+ "generating": "🔄 Generating exercises...",
+ "generate_failed": "❌ Failed to generate exercise. Please try again later.",
+ "start_btn": "▶️ Start exercises",
+ "task_header": "📝 Exercise: {topic}",
+ "instruction": "Fill in the blanks with the correct form:",
+ "check_btn": "✅ Check",
+ "next_btn": "➡️ Next",
+ "results_btn": "📊 Results",
+ "back_btn": "⬅️ Back to topics",
+ "close_btn": "❌ Close",
+ "correct": "✅ Correct!",
+ "incorrect": "❌ Incorrect",
+ "your_answer": "Your answer: {answer}",
+ "right_answer": "Correct answer: {answer}",
+ "explanation": "💡 {text}",
+ "score": "Score: {correct} of {total}",
+ "no_topics": "No topics available for your level yet.",
+ "write_answer": "Write your answer:"
}
}
diff --git a/locales/ja.json b/locales/ja.json
index 95e773d..20412f9 100644
--- a/locales/ja.json
+++ b/locales/ja.json
@@ -1,15 +1,34 @@
{
"menu": {
+ "wordofday": "🌅 今日の単語",
"add": "➕ 単語を追加",
"vocab": "📚 単語帳",
"task": "🧠 課題",
"practice": "💬 練習",
+ "exercises": "📖 文法練習",
"words": "🎯 テーマ別単語",
"import": "📖 インポート",
"stats": "📊 統計",
"settings": "⚙️ 設定",
"below": "メインメニューは下にあります ⤵️"
},
+ "practice_menu": {
+ "title": "練習",
+ "choose": "練習モードを選択:",
+ "stories": "ミニストーリー",
+ "ai_chat": "AIとの会話"
+ },
+ "wod": {
+ "title": "今日の単語",
+ "generating": "🔄 今日の単語を生成中...",
+ "failed": "❌ 今日の単語の生成に失敗しました。後でもう一度お試しください。",
+ "not_available": "🕐 今日の単語はまだ準備中です。\n\n単語は毎日UTC 00:00に生成されます。\n後でもう一度お試しください！",
+ "examples": "例文",
+ "synonyms": "類義語",
+ "add_btn": "➕ 単語帳に追加",
+ "added": "単語帳に追加しました！",
+ "not_found": "単語が見つかりません"
+ },
"add_menu": {
"title": "➕ 単語を追加\n\n方法を選択:",
"manual": "📝 手動",
@@ -55,7 +74,7 @@
"skip_msg": "✅ わかりました！\n\n/level_test で後からテストを受けるか、/settings でレベルを設定できます。\n\nはじめましょう！おすすめ:\n• /words travel - テーマ別単語\n• /practice - AIとの会話\n• /add hello - 単語を追加"
},
"add": {
- "prompt": "追加したい単語を送ってください:\n例: /add elephant\n\nコマンドなしで単語だけ送ってもOKです！",
+ "prompt": "追加したい単語を送ってください:\n• 1語: /add elephant\n• 複数: /add apple, banana, orange\n\nコマンドなしで単語だけ送ってもOKです！",
"searching": "⏳ 翻訳と例を検索中...",
"examples_header": "例文:",
"translations_header": "翻訳:",
@@ -69,6 +88,13 @@
"added_success": "✅ 単語 '{word}' を追加しました！\n\n単語帳の総数: {count}\n\nさらに追加するか、/task で練習しましょう！",
"cancelled": "キャンセルしました。/add で別の単語を追加できます"
},
+ "add_batch": {
+ "header": "📝 追加する単語 ({n}):",
+ "translating": "⏳ {n} 語を翻訳中...",
+ "choose": "追加する単語を選ぶか、一括で追加してください:",
+ "truncated": "⚠️ 単語が多すぎます。最初の {n} 語を表示。",
+ "failed": "❌ 翻訳の取得に失敗しました。後でもう一度お試しください。"
+ },
"vocab": {
"empty": "📚 単語帳はまだ空です！\n\n/add で最初の単語を追加するか、単語を直接送ってください。",
"header": "📚 あなたの単語帳:",
@@ -183,7 +209,54 @@
"invalid_format": "❌ 時間の形式が正しくありません！\n\nHH:MM（例: 09:00 / 18:30）形式を使用してください\nまたは /cancel で中止",
"time_set_title": "✅ 時間を設定しました！",
"status_on_line": "ステータス: 有効",
- "use_settings": "/reminder で設定を変更できます。"
+ "use_settings": "/reminder で設定を変更できます。",
+ "daily_title": "⏰ 練習の時間です！",
+ "daily_wod": "🌅 今日の単語:",
+ "daily_tips": "今日も練習を忘れずに:\n• /task - 課題を解く\n• /practice - 会話練習\n• /words - 新しい単語を追加",
+ "daily_motivation": "💪 継続は力なり！"
+ },
+ "story": {
+ "title": "ミニストーリー",
+ "choose_genre": "ストーリーのジャンルを選択:",
+ "genre": {
+ "dialogue": "会話",
+ "news": "ニュース",
+ "story": "物語",
+ "letter": "手紙",
+ "recipe": "レシピ"
+ },
+ "generating": "🔄 ストーリーを生成中...",
+ "failed": "❌ ストーリーの生成に失敗しました。もう一度お試しください。",
+ "try_again": "もう一度試す",
+ "level": "レベル",
+ "words": "単語",
+ "questions_btn": "質問",
+ "vocab_btn": "単語帳",
+ "new_btn": "新しいストーリー",
+ "back": "戻る",
+ "not_found": "ストーリーが見つかりません",
+ "no_vocab": "単語がありません",
+ "no_questions": "質問がありません",
+ "vocabulary": "ストーリーの単語",
+ "add_all": "すべて追加",
+ "word_added": "✅ 「{word}」を追加しました！",
+ "words_added": "✅ {n}単語を追加しました",
+ "word_not_found": "単語が見つかりません",
+ "question": "質問",
+ "question_not_found": "質問が見つかりません",
+ "correct": "✅ 正解！",
+ "incorrect": "❌ 不正解",
+ "next_question": "次の質問",
+ "show_results": "結果",
+ "results_title": "結果",
+ "correct_answers": "正解数",
+ "accuracy": "正解率",
+ "result_excellent": "素晴らしい！テキストをよく理解できました。",
+ "result_good": "よくできました！大部分を理解できました。",
+ "result_practice": "もう一度注意深く読んでみてください。",
+ "translation": "翻訳",
+ "show_translation": "翻訳を表示",
+ "hide_translation": "翻訳を隠す"
},
"level_test": {
"show_translation_btn": "👁️ 質問の翻訳を表示",
@@ -322,5 +395,29 @@
"err_not_found": "❌ エラー: 単語が見つかりません",
"already_exists": "単語 '{word}' はすでに単語帳にあります",
"added_single": "✅ 単語 '{word}' を単語帳に追加しました"
+ },
+ "exercises": {
+ "title": "📖 文法練習",
+ "choose_topic": "練習するトピックを選択してください:",
+ "your_level": "あなたのレベル: {level}",
+ "generating_rule": "🔄 文法説明を生成中...",
+ "generating": "🔄 練習問題を生成中...",
+ "generate_failed": "❌ 練習問題の生成に失敗しました。後でもう一度お試しください。",
+ "start_btn": "▶️ 練習を開始",
+ "task_header": "📝 練習: {topic}",
+ "instruction": "正しい形式で空欄を埋めてください:",
+ "check_btn": "✅ 確認",
+ "next_btn": "➡️ 次へ",
+ "results_btn": "📊 結果",
+ "back_btn": "⬅️ トピックに戻る",
+ "close_btn": "❌ 閉じる",
+ "correct": "✅ 正解！",
+ "incorrect": "❌ 不正解",
+ "your_answer": "あなたの回答: {answer}",
+ "right_answer": "正解: {answer}",
+ "explanation": "💡 {text}",
+ "score": "スコア: {total}問中{correct}問正解",
+ "no_topics": "あなたのレベルで利用可能なトピックはまだありません。",
+ "write_answer": "回答を入力してください:"
}
}
diff --git a/locales/ru.json b/locales/ru.json
index c75fe6c..3da6b08 100644
--- a/locales/ru.json
+++ b/locales/ru.json
@@ -1,15 +1,34 @@
{
"menu": {
+ "wordofday": "🌅 Слово дня",
"add": "➕ Добавить слово",
"vocab": "📚 Словарь",
"task": "🧠 Задание",
"practice": "💬 Практика",
+ "exercises": "📖 Упражнения",
"words": "🎯 Тематические слова",
"import": "📖 Импорт",
"stats": "📊 Статистика",
"settings": "⚙️ Настройки",
"below": "Главное меню доступно ниже ⤵️"
},
+ "practice_menu": {
+ "title": "Практика",
+ "choose": "Выбери режим практики:",
+ "stories": "Мини-истории",
+ "ai_chat": "Диалог с AI"
+ },
+ "wod": {
+ "title": "Слово дня",
+ "generating": "🔄 Генерирую слово дня...",
+ "failed": "❌ Не удалось сгенерировать слово дня. Попробуй позже.",
+ "not_available": "🕐 Слово дня ещё не готово.\n\nСлова генерируются ежедневно в 00:00 UTC.\nПопробуй позже!",
+ "examples": "Примеры",
+ "synonyms": "Синонимы",
+ "add_btn": "➕ Добавить в словарь",
+ "added": "Добавлено в словарь!",
+ "not_found": "Слово не найдено"
+ },
"add_menu": {
"title": "➕ Добавление слов\n\nВыберите способ:",
"manual": "📝 Вручную",
@@ -55,7 +74,7 @@
"skip_msg": "✅ Хорошо!\n\nТы можешь пройти тест позже командой /level_test\nили установить уровень вручную в /settings\n\nДавай начнём! Попробуй:\n• /words travel - тематическая подборка\n• /practice - диалог с AI\n• /add hello - добавить слово"
},
"add": {
- "prompt": "Отправь слово, которое хочешь добавить:\nНапример: /add elephant\n\nИли просто отправь слово без команды!",
+ "prompt": "Отправь слово, которое хочешь добавить:\n• Одно слово: /add elephant\n• Несколько: /add apple, banana, orange\n\nИли просто отправь слово без команды!",
"searching": "⏳ Ищу перевод и примеры...",
"examples_header": "Примеры:",
"translations_header": "Переводы:",
@@ -69,6 +88,13 @@
"added_success": "✅ Слово '{word}' добавлено!\n\nВсего слов в словаре: {count}\n\nПродолжай добавлять новые слова или используй /task для практики!",
"cancelled": "Отменено. Можешь добавить другое слово командой /add"
},
+ "add_batch": {
+ "header": "📝 Слова для добавления ({n}):",
+ "translating": "⏳ Перевожу {n} слов...",
+ "choose": "Выбери слова для добавления или добавь все сразу:",
+ "truncated": "⚠️ Слишком много слов. Показаны первые {n}.",
+ "failed": "❌ Не удалось получить переводы. Попробуй позже."
+ },
"vocab": {
"empty": "📚 Твой словарь пока пуст!\n\nДобавь первое слово командой /add или просто отправь мне слово.",
"header": "📚 Твой словарь:",
@@ -180,7 +206,54 @@
"invalid_format": "❌ Неверный формат времени!\n\nИспользуй формат HH:MM (например, 09:00 или 18:30)\nИли отправь /cancel для отмены",
"time_set_title": "✅ Время установлено!",
"status_on_line": "Статус: Включены",
- "use_settings": "Используй /reminder для изменения настроек."
+ "use_settings": "Используй /reminder для изменения настроек.",
+ "daily_title": "⏰ Время для практики!",
+ "daily_wod": "🌅 Слово дня:",
+ "daily_tips": "Не забудь потренироваться сегодня:\n• /task - выполни задания\n• /practice - попрактикуй диалог\n• /words - добавь новые слова",
+ "daily_motivation": "💪 Регулярная практика - ключ к успеху!"
+ },
+ "story": {
+ "title": "Мини-истории",
+ "choose_genre": "Выбери жанр истории:",
+ "genre": {
+ "dialogue": "Диалоги",
+ "news": "Новости",
+ "story": "Рассказы",
+ "letter": "Письма",
+ "recipe": "Рецепты"
+ },
+ "generating": "🔄 Генерирую историю...",
+ "failed": "❌ Не удалось сгенерировать историю. Попробуй ещё раз.",
+ "try_again": "Попробовать снова",
+ "level": "Уровень",
+ "words": "слов",
+ "questions_btn": "Вопросы",
+ "vocab_btn": "Словарь",
+ "new_btn": "Новая история",
+ "back": "Назад",
+ "not_found": "История не найдена",
+ "no_vocab": "Нет слов для изучения",
+ "no_questions": "Нет вопросов",
+ "vocabulary": "Словарь истории",
+ "add_all": "Добавить все",
+ "word_added": "✅ Слово '{word}' добавлено!",
+ "words_added": "✅ Добавлено слов: {n}",
+ "word_not_found": "Слово не найдено",
+ "question": "Вопрос",
+ "question_not_found": "Вопрос не найден",
+ "correct": "✅ Правильно!",
+ "incorrect": "❌ Неправильно",
+ "next_question": "Следующий вопрос",
+ "show_results": "Результаты",
+ "results_title": "Результаты",
+ "correct_answers": "Правильных ответов",
+ "accuracy": "Точность",
+ "result_excellent": "Отличный результат! Ты хорошо понял текст.",
+ "result_good": "Хорошо! Большую часть текста ты понял.",
+ "result_practice": "Попробуй перечитать историю внимательнее.",
+ "translation": "Перевод",
+ "show_translation": "Показать перевод",
+ "hide_translation": "Скрыть перевод"
},
"stats": {
"header": "📊 Твоя статистика",
@@ -330,5 +403,29 @@
"err_not_found": "❌ Ошибка: слово не найдено",
"already_exists": "Слово '{word}' уже в словаре",
"added_single": "✅ Слово '{word}' добавлено в словарь"
+ },
+ "exercises": {
+ "title": "📖 Грамматические упражнения",
+ "choose_topic": "Выбери тему для упражнения:",
+ "your_level": "Твой уровень: {level}",
+ "generating_rule": "🔄 Генерирую объяснение правила...",
+ "generating": "🔄 Генерирую упражнения...",
+ "generate_failed": "❌ Не удалось сгенерировать упражнение. Попробуй позже.",
+ "start_btn": "▶️ Начать упражнения",
+ "task_header": "📝 Упражнение: {topic}",
+ "instruction": "Заполни пропуски правильной формой:",
+ "check_btn": "✅ Проверить",
+ "next_btn": "➡️ Следующее",
+ "results_btn": "📊 Результаты",
+ "back_btn": "⬅️ К темам",
+ "close_btn": "❌ Закрыть",
+ "correct": "✅ Правильно!",
+ "incorrect": "❌ Неправильно",
+ "your_answer": "Твой ответ: {answer}",
+ "right_answer": "Правильный ответ: {answer}",
+ "explanation": "💡 {text}",
+ "score": "Результат: {correct} из {total}",
+ "no_topics": "Для твоего уровня пока нет доступных тем.",
+ "write_answer": "Напиши свой ответ:"
}
}
diff --git a/main.py b/main.py
index d049ec2..f37642a 100644
--- a/main.py
+++ b/main.py
@@ -7,8 +7,7 @@ from aiogram.enums import ParseMode
from aiogram.types import BotCommand
from config.settings import settings
-from bot.handlers import start, vocabulary, tasks, settings as settings_handler, words, import_text, practice, reminder, level_test, admin
-from database.db import init_db
+from bot.handlers import start, vocabulary, tasks, settings as settings_handler, words, import_text, practice, reminder, level_test, admin, exercises, wordofday, stories
from services.reminder_service import init_reminder_service
@@ -30,15 +29,14 @@ async def main():
# Команды бота для меню Telegram
await bot.set_my_commands([
BotCommand(command="start", description="Запустить бота"),
- BotCommand(command="add", description="Добавить слово"),
- BotCommand(command="words", description="Тематическая подборка слов"),
- BotCommand(command="import", description="Импорт слов из текста"),
- BotCommand(command="vocabulary", description="Мой словарь"),
BotCommand(command="task", description="Задания"),
BotCommand(command="practice", description="Диалог с AI"),
+ BotCommand(command="story", description="Мини-истории"),
+ BotCommand(command="add", description="Добавить слово"),
+ BotCommand(command="words", description="Тематическая подборка слов"),
+ BotCommand(command="vocabulary", description="Мой словарь"),
BotCommand(command="stats", description="Статистика"),
BotCommand(command="settings", description="Настройки"),
- BotCommand(command="reminder", description="Напоминания"),
BotCommand(command="help", description="Справка"),
])
@@ -51,11 +49,13 @@ async def main():
dp.include_router(words.router)
dp.include_router(import_text.router)
dp.include_router(practice.router)
+ dp.include_router(exercises.router)
+ dp.include_router(wordofday.router)
+ dp.include_router(stories.router)
dp.include_router(reminder.router)
dp.include_router(admin.router)
- # Инициализация базы данных
- await init_db()
+ # База данных инициализируется через Alembic миграции (make local-migrate)
# Инициализация и запуск сервиса напоминаний
reminder_service = init_reminder_service(bot)
diff --git a/migrations/versions/20251209_add_mini_stories.py b/migrations/versions/20251209_add_mini_stories.py
new file mode 100644
index 0000000..b4e192a
--- /dev/null
+++ b/migrations/versions/20251209_add_mini_stories.py
@@ -0,0 +1,55 @@
+"""Add mini_stories table
+
+Revision ID: 20251209_mini_stories
+Revises: 20251209_word_of_day
+Create Date: 2024-12-09
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy.dialects import postgresql
+
+# revision identifiers, used by Alembic.
+revision: str = '20251209_mini_stories'
+down_revision: Union[str, None] = '20251209_word_of_day'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+ # Удаляем старую таблицу и enum если существуют
+ op.execute("DROP TABLE IF EXISTS mini_stories CASCADE")
+ op.execute("DROP TYPE IF EXISTS storygenre CASCADE")
+
+ # Создаём enum через raw SQL
+ op.execute("CREATE TYPE storygenre AS ENUM ('dialogue', 'news', 'story', 'letter', 'recipe')")
+
+ # Создаём таблицу используя postgresql.ENUM с create_type=False
+ story_genre = postgresql.ENUM('dialogue', 'news', 'story', 'letter', 'recipe', name='storygenre', create_type=False)
+
+ op.create_table(
+ 'mini_stories',
+ sa.Column('id', sa.Integer(), nullable=False),
+ sa.Column('user_id', sa.Integer(), nullable=False),
+ sa.Column('title', sa.String(length=255), nullable=False),
+ sa.Column('content', sa.String(length=5000), nullable=False),
+ sa.Column('genre', story_genre, nullable=False),
+ sa.Column('learning_lang', sa.String(length=5), nullable=False),
+ sa.Column('level', sa.String(length=5), nullable=False),
+ sa.Column('word_count', sa.Integer(), nullable=True, server_default='0'),
+ sa.Column('vocabulary', sa.JSON(), nullable=True),
+ sa.Column('questions', sa.JSON(), nullable=True),
+ sa.Column('is_completed', sa.Boolean(), nullable=True, server_default='false'),
+ sa.Column('correct_answers', sa.Integer(), nullable=True, server_default='0'),
+ sa.Column('created_at', sa.DateTime(), nullable=True),
+ sa.PrimaryKeyConstraint('id')
+ )
+ op.create_index('ix_mini_stories_user_id', 'mini_stories', ['user_id'], unique=False)
+
+
+def downgrade() -> None:
+ op.drop_index('ix_mini_stories_user_id', table_name='mini_stories')
+ op.drop_table('mini_stories')
+ op.execute("DROP TYPE IF EXISTS storygenre CASCADE")
diff --git a/migrations/versions/20251209_add_story_translation.py b/migrations/versions/20251209_add_story_translation.py
new file mode 100644
index 0000000..4baf83c
--- /dev/null
+++ b/migrations/versions/20251209_add_story_translation.py
@@ -0,0 +1,26 @@
+"""Add translation field to mini_stories
+
+Revision ID: 20251209_story_translation
+Revises: 20251209_mini_stories
+Create Date: 2025-12-09
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision: str = '20251209_story_translation'
+down_revision: Union[str, None] = '20251209_mini_stories'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+ op.add_column('mini_stories', sa.Column('translation', sa.String(5000), nullable=True))
+
+
+def downgrade() -> None:
+ op.drop_column('mini_stories', 'translation')
diff --git a/migrations/versions/20251209_add_word_of_day.py b/migrations/versions/20251209_add_word_of_day.py
new file mode 100644
index 0000000..6ee4f47
--- /dev/null
+++ b/migrations/versions/20251209_add_word_of_day.py
@@ -0,0 +1,50 @@
+"""Add word_of_day table (global by level)
+
+Revision ID: 20251209_word_of_day
+Revises: 20251208_user_ai_model
+Create Date: 2024-12-09
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision: str = '20251209_word_of_day'
+down_revision: Union[str, None] = '20251208_user_ai_model'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+ # Удаляем старую таблицу если существует (была с user_id)
+ op.execute("DROP TABLE IF EXISTS word_of_day CASCADE")
+
+ op.create_table(
+ 'word_of_day',
+ sa.Column('id', sa.Integer(), nullable=False),
+ sa.Column('word', sa.String(length=255), nullable=False),
+ sa.Column('transcription', sa.String(length=255), nullable=True),
+ sa.Column('translation', sa.String(length=500), nullable=False),
+ sa.Column('examples', sa.JSON(), nullable=True),
+ sa.Column('synonyms', sa.String(length=500), nullable=True),
+ sa.Column('etymology', sa.String(length=500), nullable=True),
+ sa.Column('learning_lang', sa.String(length=5), nullable=False),
+ sa.Column('level', sa.String(length=5), nullable=False),
+ sa.Column('date', sa.DateTime(), nullable=False),
+ sa.Column('created_at', sa.DateTime(), nullable=True),
+ sa.PrimaryKeyConstraint('id'),
+ sa.UniqueConstraint('date', 'learning_lang', 'level', name='uq_wod_date_lang_level')
+ )
+ op.create_index('ix_word_of_day_learning_lang', 'word_of_day', ['learning_lang'], unique=False)
+ op.create_index('ix_word_of_day_level', 'word_of_day', ['level'], unique=False)
+ op.create_index('ix_word_of_day_date', 'word_of_day', ['date'], unique=False)
+
+
+def downgrade() -> None:
+ op.drop_index('ix_word_of_day_date', table_name='word_of_day')
+ op.drop_index('ix_word_of_day_level', table_name='word_of_day')
+ op.drop_index('ix_word_of_day_learning_lang', table_name='word_of_day')
+ op.drop_table('word_of_day')
diff --git a/services/ai_service.py b/services/ai_service.py
index c3ad4bd..434c66e 100644
--- a/services/ai_service.py
+++ b/services/ai_service.py
@@ -54,6 +54,40 @@ class AIService:
self._cached_model: Optional[str] = None
self._cached_provider: Optional[AIProvider] = None
+ def _markdown_to_html(self, text: str) -> str:
+ """Конвертировать markdown форматирование в HTML для Telegram."""
+ import re
+ # **bold** -> bold
+ text = re.sub(r'\*\*(.+?)\*\*', r'\1', text)
+ # *italic* -> italic (но не внутри уже конвертированных тегов)
+ text = re.sub(r'(?)\*([^*]+?)\*(?![^<]*\1', text)
+ # Убираем оставшиеся одиночные * в начале строк (списки)
+ text = re.sub(r'^\*\s+', '• ', text, flags=re.MULTILINE)
+ return text
+
+ def _strip_markdown_code_block(self, text: str) -> str:
+ """Удалить markdown обёртку ```json ... ``` из текста."""
+ import re
+ text = text.strip()
+
+ # Паттерн для ```json ... ``` или просто ``` ... ```
+ pattern = r'^```(?:json)?\s*\n?(.*?)\n?```$'
+ match = re.match(pattern, text, re.DOTALL)
+ if match:
+ return match.group(1).strip()
+
+ # Альтернативный способ - если начинается с ``` но паттерн не сработал
+ if text.startswith('```'):
+ lines = text.split('\n')
+ # Убираем первую строку (```json или ```)
+ lines = lines[1:]
+ # Убираем последнюю строку если это ```
+ if lines and lines[-1].strip() == '```':
+ lines = lines[:-1]
+ return '\n'.join(lines).strip()
+
+ return text
+
async def _get_active_model(self, user_id: Optional[int] = None) -> tuple[str, AIProvider]:
"""
Получить активную модель и провайдера из БД.
@@ -136,15 +170,8 @@ class AIService:
# Конвертируем ответ Google в формат OpenAI для совместимости
text = data["candidates"][0]["content"]["parts"][0]["text"]
- # Убираем markdown обёртку если есть (```json ... ```)
- if text.startswith('```'):
- lines = text.split('\n')
- # Убираем первую строку (```json) и последнюю (```)
- if lines[-1].strip() == '```':
- lines = lines[1:-1]
- else:
- lines = lines[1:]
- text = '\n'.join(lines)
+ # Убираем markdown обёртку если есть (```json ... ``` или ```...```)
+ text = self._strip_markdown_code_block(text)
return {
"choices": [{
@@ -1080,6 +1107,215 @@ User: {user_message}
return self._get_jlpt_fallback_questions()
return self._get_cefr_fallback_questions()
+ async def generate_grammar_rule(
+ self,
+ topic_name: str,
+ topic_description: str,
+ level: str,
+ learning_lang: str = "en",
+ ui_lang: str = "ru",
+ user_id: Optional[int] = None
+ ) -> str:
+ """
+ Генерация объяснения грамматического правила.
+
+ Args:
+ topic_name: Название темы (например, "Present Simple")
+ topic_description: Описание темы (например, "I work, he works")
+ level: Уровень пользователя (A1-C2 или N5-N1)
+ learning_lang: Язык изучения
+ ui_lang: Язык интерфейса для объяснения
+ user_id: ID пользователя в БД
+
+ Returns:
+ Текст с объяснением правила
+ """
+ if learning_lang == "ja":
+ language_name = "японского"
+ else:
+ language_name = "английского"
+
+ prompt = f"""Объясни грамматическое правило "{topic_name}" ({topic_description}) для изучающих {language_name} язык.
+
+Уровень ученика: {level}
+Язык объяснения: {ui_lang}
+
+Требования:
+- Объяснение должно быть кратким и понятным (3-5 предложений)
+- Приведи формулу/структуру правила
+- Дай 2-3 примера с переводом
+- Упомяни типичные ошибки (если есть)
+- Адаптируй сложность под уровень {level}
+
+ВАЖНО - форматирование для Telegram (используй ТОЛЬКО HTML теги, НЕ markdown):
+- жирный текст для важного (НЕ **жирный**)
+- курсив для примеров (НЕ *курсив*)
+- НЕ используй звёздочки *, НЕ используй markdown
+- Можно использовать эмодзи"""
+
+ try:
+ logger.info(f"[AI Request] generate_grammar_rule: topic='{topic_name}', level='{level}'")
+
+ messages = [
+ {"role": "system", "content": f"Ты - опытный преподаватель {language_name} языка. Объясняй правила просто и понятно."},
+ {"role": "user", "content": prompt}
+ ]
+
+ # Для этого запроса не используем JSON mode
+ model_name, provider = await self._get_active_model(user_id)
+
+ if provider == AIProvider.google:
+ response_data = await self._make_google_request_text(messages, temperature=0.5, model=model_name)
+ else:
+ response_data = await self._make_openai_request_text(messages, temperature=0.5, model=model_name)
+
+ rule_text = response_data['choices'][0]['message']['content']
+ # Конвертируем markdown в HTML на случай если AI использовал звёздочки
+ rule_text = self._markdown_to_html(rule_text)
+ logger.info(f"[AI Response] generate_grammar_rule: success, {len(rule_text)} chars")
+ return rule_text
+
+ except Exception as e:
+ logger.error(f"[AI Error] generate_grammar_rule: {type(e).__name__}: {str(e)}")
+ return f"📖 {topic_name}\n\n{topic_description}\n\nИзучите это правило и приступайте к упражнениям."
+
+ async def _make_google_request_text(self, messages: list, temperature: float = 0.3, model: str = "gemini-2.0-flash-lite") -> dict:
+ """Запрос к Google без JSON mode (для текстовых ответов)"""
+ url = f"{self.google_base_url}/models/{model}:generateContent"
+
+ contents = []
+ for msg in messages:
+ role = msg["role"]
+ content = msg["content"]
+ if role == "system":
+ contents.insert(0, {"role": "user", "parts": [{"text": f"[System instruction]: {content}"}]})
+ elif role == "user":
+ contents.append({"role": "user", "parts": [{"text": content}]})
+ elif role == "assistant":
+ contents.append({"role": "model", "parts": [{"text": content}]})
+
+ payload = {
+ "contents": contents,
+ "generationConfig": {"temperature": temperature}
+ }
+
+ headers = {
+ "Content-Type": "application/json",
+ "x-goog-api-key": self.google_api_key
+ }
+
+ response = await self.http_client.post(url, headers=headers, json=payload)
+ response.raise_for_status()
+ data = response.json()
+
+ text = data["candidates"][0]["content"]["parts"][0]["text"]
+ return {"choices": [{"message": {"content": text}}]}
+
+ async def _make_openai_request_text(self, messages: list, temperature: float = 0.3, model: str = "gpt-4o-mini") -> dict:
+ """Запрос к OpenAI без JSON mode (для текстовых ответов)"""
+ url = f"{self.openai_base_url}/chat/completions"
+
+ headers = {
+ "Authorization": f"Bearer {self.openai_api_key}",
+ "Content-Type": "application/json"
+ }
+
+ payload = {
+ "model": model,
+ "messages": messages,
+ "temperature": temperature
+ }
+
+ response = await self.http_client.post(url, headers=headers, json=payload)
+ response.raise_for_status()
+ return response.json()
+
+ async def generate_grammar_exercise(
+ self,
+ topic_id: str,
+ topic_name: str,
+ topic_description: str,
+ level: str,
+ learning_lang: str = "en",
+ translation_lang: str = "ru",
+ count: int = 3,
+ user_id: Optional[int] = None
+ ) -> List[Dict]:
+ """
+ Генерация грамматических упражнений по теме.
+
+ Args:
+ topic_id: ID темы (например, "present_simple")
+ topic_name: Название темы (например, "Present Simple")
+ topic_description: Описание темы (например, "I work, he works")
+ level: Уровень пользователя (A1-C2 или N5-N1)
+ learning_lang: Язык изучения
+ translation_lang: Язык перевода
+ count: Количество упражнений
+ user_id: ID пользователя в БД для получения его модели
+
+ Returns:
+ Список упражнений
+ """
+ if learning_lang == "ja":
+ language_name = "японском"
+ else:
+ language_name = "английском"
+
+ prompt = f"""Создай {count} грамматических упражнения на тему "{topic_name}" ({topic_description}).
+
+Уровень: {level}
+Язык: {language_name}
+Язык перевода: {translation_lang}
+
+Верни ответ в формате JSON:
+{{
+ "exercises": [
+ {{
+ "sentence": "предложение с пропуском ___ на {learning_lang}",
+ "translation": "ПОЛНЫЙ перевод предложения на {translation_lang} (без пропусков, с правильным ответом)",
+ "correct_answer": "правильный ответ для пропуска",
+ "hint": "краткая подсказка на {translation_lang} (1-2 слова)",
+ "explanation": "объяснение правила на {translation_lang} (1-2 предложения)"
+ }}
+ ]
+}}
+
+Требования:
+- Предложения должны быть естественными и полезными
+- Пропуск обозначай как ___
+- ВАЖНО: translation должен быть ПОЛНЫМ переводом готового предложения (без пропусков), чтобы ученик понимал смысл
+- Подсказка должна направлять к ответу, но не содержать его
+- Объяснение должно быть понятным для уровня {level}
+- Сложность должна соответствовать уровню {level}"""
+
+ try:
+ logger.info(f"[AI Request] generate_grammar_exercise: topic='{topic_name}', level='{level}'")
+
+ messages = [
+ {"role": "system", "content": f"Ты - преподаватель {language_name} языка. Создавай качественные упражнения. Отвечай только JSON."},
+ {"role": "user", "content": prompt}
+ ]
+
+ response_data = await self._make_request(messages, temperature=0.7, user_id=user_id)
+
+ import json
+ result = json.loads(response_data['choices'][0]['message']['content'])
+ exercises = result.get('exercises', [])
+ logger.info(f"[AI Response] generate_grammar_exercise: success, {len(exercises)} exercises generated")
+ return exercises
+
+ except Exception as e:
+ logger.error(f"[AI Error] generate_grammar_exercise: {type(e).__name__}: {str(e)}")
+ # Fallback с простым упражнением
+ return [{
+ "sentence": f"Example sentence with ___ ({topic_name})",
+ "translation": "Пример предложения",
+ "correct_answer": "answer",
+ "hint": "hint",
+ "explanation": f"This exercise is about {topic_name}."
+ }]
+
def _get_cefr_fallback_questions(self) -> List[Dict]:
"""Fallback вопросы для CEFR (английский и европейские языки)"""
return [
@@ -1134,6 +1370,214 @@ User: {user_message}
}
]
+ async def generate_word_of_day(
+ self,
+ level: str,
+ learning_lang: str = "en",
+ translation_lang: str = "ru",
+ excluded_words: List[str] = None,
+ user_id: Optional[int] = None
+ ) -> Optional[Dict]:
+ """
+ Генерация слова дня.
+
+ Args:
+ level: Уровень пользователя (A1-C2 или N5-N1)
+ learning_lang: Язык изучения
+ translation_lang: Язык перевода
+ excluded_words: Список слов для исключения (уже были)
+ user_id: ID пользователя для выбора модели
+
+ Returns:
+ Dict с полями: word, transcription, translation, examples, synonyms, etymology
+ """
+ language_names = {
+ "en": "английский",
+ "ja": "японский"
+ }
+ language_name = language_names.get(learning_lang, "английский")
+
+ translation_names = {
+ "ru": "русский",
+ "en": "английский",
+ "ja": "японский"
+ }
+ translation_name = translation_names.get(translation_lang, "русский")
+
+ excluded_str = ""
+ if excluded_words:
+ excluded_str = f"\n\nНЕ используй эти слова (уже были): {', '.join(excluded_words[:20])}"
+
+ prompt = f"""Сгенерируй интересное "слово дня" для изучающего {language_name} язык на уровне {level}.
+
+Требования:
+- Слово должно быть полезным и интересным
+- Подходящее для уровня {level}
+- НЕ слишком простое и НЕ слишком сложное
+- Желательно с интересной этимологией или фактом{excluded_str}
+
+Верни JSON:
+{{
+ "word": "слово на {language_name}",
+ "transcription": "транскрипция (IPA для английского, хирагана для японского)",
+ "translation": "перевод на {translation_name}",
+ "examples": [
+ {{"sentence": "пример предложения", "translation": "перевод примера"}},
+ {{"sentence": "второй пример", "translation": "перевод"}}
+ ],
+ "synonyms": "синоним1, синоним2, синоним3",
+ "etymology": "краткий интересный факт о слове или его происхождении (1-2 предложения)"
+}}"""
+
+ try:
+ logger.info(f"[AI Request] generate_word_of_day: level='{level}', lang='{learning_lang}'")
+
+ messages = [
+ {"role": "system", "content": "Ты - опытный лингвист, который подбирает интересные слова для изучения."},
+ {"role": "user", "content": prompt}
+ ]
+
+ model_name, provider = await self._get_active_model(user_id)
+
+ if provider == AIProvider.google:
+ response_data = await self._make_google_request(messages, temperature=0.8, model=model_name)
+ else:
+ response_data = await self._make_openai_request(messages, temperature=0.8, model=model_name)
+
+ content = response_data['choices'][0]['message']['content']
+ content = self._strip_markdown_code_block(content)
+ result = json.loads(content)
+
+ logger.info(f"[AI Response] generate_word_of_day: word='{result.get('word', 'N/A')}'")
+ return result
+
+ except Exception as e:
+ logger.error(f"[AI Error] generate_word_of_day: {type(e).__name__}: {str(e)}")
+ return None
+
+ async def generate_mini_story(
+ self,
+ genre: str,
+ level: str,
+ learning_lang: str = "en",
+ translation_lang: str = "ru",
+ user_id: Optional[int] = None,
+ num_questions: int = 5
+ ) -> Optional[Dict]:
+ """
+ Генерация мини-истории для чтения.
+
+ Args:
+ genre: Жанр (dialogue, news, story, letter, recipe)
+ level: Уровень (A1-C2 или N5-N1)
+ learning_lang: Язык истории
+ translation_lang: Язык переводов
+ user_id: ID пользователя для выбора модели
+ num_questions: Количество вопросов (из настроек пользователя)
+
+ Returns:
+ Dict с полями: title, content, vocabulary, questions, word_count
+ """
+ import json
+
+ language_names = {
+ "en": "английский",
+ "ja": "японский"
+ }
+ language_name = language_names.get(learning_lang, "английский")
+
+ translation_names = {
+ "ru": "русский",
+ "en": "английский",
+ "ja": "японский"
+ }
+ translation_name = translation_names.get(translation_lang, "русский")
+
+ genre_descriptions = {
+ "dialogue": "разговорный диалог между людьми",
+ "news": "короткая новостная статья",
+ "story": "художественный рассказ с сюжетом",
+ "letter": "email или письмо",
+ "recipe": "рецепт блюда с инструкциями"
+ }
+ genre_desc = genre_descriptions.get(genre, "короткий рассказ")
+
+ # Определяем длину текста по уровню
+ word_counts = {
+ "A1": "50-80", "N5": "30-50",
+ "A2": "80-120", "N4": "50-80",
+ "B1": "120-180", "N3": "80-120",
+ "B2": "180-250", "N2": "120-180",
+ "C1": "250-350", "N1": "180-250",
+ "C2": "300-400"
+ }
+ word_range = word_counts.get(level, "100-150")
+
+ # Генерируем примеры вопросов для промпта
+ questions_examples = []
+ for i in range(num_questions):
+ questions_examples.append(f''' {{
+ "question": "Вопрос {i + 1} на понимание на {translation_name}",
+ "options": ["вариант 1", "вариант 2", "вариант 3"],
+ "correct": {i % 3}
+ }}''')
+ questions_json = ",\n".join(questions_examples)
+
+ prompt = f"""Создай {genre_desc} на {language_name} языке для уровня {level}.
+
+Требования:
+- Длина: {word_range} слов
+- Используй лексику и грамматику подходящую для уровня {level}
+- История должна быть интересной и законченной
+- Выдели 5-8 ключевых слов которые могут быть новыми для изучающего
+- Добавь полный перевод текста на {translation_name} язык
+
+Верни JSON:
+{{
+ "title": "Название истории на {language_name}",
+ "content": "Полный текст истории",
+ "translation": "Полный перевод истории на {translation_name}",
+ "vocabulary": [
+ {{"word": "слово", "translation": "перевод на {translation_name}", "transcription": "транскрипция"}},
+ ...
+ ],
+ "questions": [
+{questions_json}
+ ],
+ "word_count": число_слов_в_тексте
+}}
+
+Важно:
+- Создай ровно {num_questions} вопросов на понимание текста
+- У каждого вопроса ровно 3 варианта ответа
+- correct — индекс правильного ответа (0, 1 или 2)"""
+
+ try:
+ logger.info(f"[AI Request] generate_mini_story: genre='{genre}', level='{level}', lang='{learning_lang}'")
+
+ messages = [
+ {"role": "system", "content": "Ты - автор адаптированных текстов для изучающих иностранные языки."},
+ {"role": "user", "content": prompt}
+ ]
+
+ model_name, provider = await self._get_active_model(user_id)
+
+ if provider == AIProvider.google:
+ response_data = await self._make_google_request(messages, temperature=0.8, model=model_name)
+ else:
+ response_data = await self._make_openai_request(messages, temperature=0.8, model=model_name)
+
+ content = response_data['choices'][0]['message']['content']
+ content = self._strip_markdown_code_block(content)
+ result = json.loads(content)
+
+ logger.info(f"[AI Response] generate_mini_story: title='{result.get('title', 'N/A')}', words={result.get('word_count', 0)}")
+ return result
+
+ except Exception as e:
+ logger.error(f"[AI Error] generate_mini_story: {type(e).__name__}: {str(e)}")
+ return None
+
def _get_jlpt_fallback_questions(self) -> List[Dict]:
"""Fallback вопросы для JLPT (японский)"""
return [
diff --git a/services/reminder_service.py b/services/reminder_service.py
index b4b6889..7207162 100644
--- a/services/reminder_service.py
+++ b/services/reminder_service.py
@@ -1,12 +1,12 @@
import logging
from datetime import datetime, timedelta
-from typing import List
+from typing import List, Optional
from apscheduler.schedulers.asyncio import AsyncIOScheduler
from apscheduler.triggers.cron import CronTrigger
from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession
-from database.models import User
+from database.models import User, JLPT_LANGUAGES
from database.db import async_session_maker
logger = logging.getLogger(__name__)
@@ -30,9 +30,26 @@ class ReminderService:
replace_existing=True
)
+ # Генерация слов дня в 00:00 UTC
+ self.scheduler.add_job(
+ self.generate_daily_words,
+ trigger=CronTrigger(hour=0, minute=0, timezone='UTC'),
+ id='generate_words_of_day',
+ replace_existing=True
+ )
+
self.scheduler.start()
logger.info("Планировщик напоминаний запущен")
+ async def generate_daily_words(self):
+ """Генерация слов дня для всех уровней"""
+ try:
+ from services.wordofday_service import wordofday_service
+ results = await wordofday_service.generate_all_words_for_today()
+ logger.info(f"Слова дня сгенерированы: {results}")
+ except Exception as e:
+ logger.error(f"Ошибка генерации слов дня: {e}")
+
def shutdown(self):
"""Остановить планировщик"""
self.scheduler.shutdown()
@@ -97,6 +114,17 @@ class ReminderService:
return time_diff < 300 # 5 минут в секундах
+ async def _get_user_level(self, user: User) -> str:
+ """Получить уровень пользователя для текущего языка изучения"""
+ # Сначала проверяем levels_by_language
+ if user.levels_by_language and user.learning_language in user.levels_by_language:
+ return user.levels_by_language[user.learning_language]
+
+ # Иначе используем общий уровень
+ if user.learning_language in JLPT_LANGUAGES:
+ return "N5" # Дефолтный JLPT уровень
+ return user.level.value if user.level else "A1"
+
async def _send_reminder(self, user: User, session: AsyncSession):
"""
Отправить напоминание пользователю
@@ -106,18 +134,37 @@ class ReminderService:
session: Сессия базы данных
"""
try:
- message_text = (
- "⏰ Время для практики!\n\n"
- "Не забудь потренироваться сегодня:\n"
- "• /task - выполни задания\n"
- "• /practice - попрактикуй диалог\n"
- "• /words - добавь новые слова\n\n"
- "💪 Регулярная практика - ключ к успеху!"
+ from services.wordofday_service import wordofday_service
+ from utils.i18n import t
+
+ lang = user.language_interface or "ru"
+
+ # Получаем слово дня для пользователя
+ level = await self._get_user_level(user)
+ word_of_day = await wordofday_service.get_word_of_day(
+ learning_lang=user.learning_language,
+ level=level
)
+ # Формируем сообщение
+ message_parts = [t(lang, "reminder.daily_title") + "\n"]
+
+ # Добавляем слово дня если есть
+ if word_of_day:
+ word_text = await wordofday_service.format_word_for_user(
+ word_of_day,
+ translation_lang=user.translation_language or user.language_interface,
+ ui_lang=lang
+ )
+ message_parts.append(f"{t(lang, 'reminder.daily_wod')}\n{word_text}\n")
+
+ message_parts.append(t(lang, "reminder.daily_tips"))
+ message_parts.append(f"\n{t(lang, 'reminder.daily_motivation')}")
+
await self.bot.send_message(
chat_id=user.telegram_id,
- text=message_text
+ text="\n".join(message_parts),
+ parse_mode="HTML"
)
# Обновляем время последнего напоминания
diff --git a/services/wordofday_service.py b/services/wordofday_service.py
new file mode 100644
index 0000000..1df63ab
--- /dev/null
+++ b/services/wordofday_service.py
@@ -0,0 +1,227 @@
+"""Сервис генерации слова дня"""
+import logging
+from datetime import datetime, date
+from typing import Optional, Dict, List
+
+from sqlalchemy import select, and_
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from database.db import async_session_maker
+from database.models import WordOfDay, LanguageLevel, JLPTLevel, JLPT_LANGUAGES
+from services.ai_service import ai_service
+
+logger = logging.getLogger(__name__)
+
+# Уровни для каждого языка
+CEFR_LEVELS = [level.value for level in LanguageLevel] # A1-C2
+JLPT_LEVELS = [level.value for level in JLPTLevel] # N5-N1
+
+# Языки для генерации
+LEARNING_LANGUAGES = ["en", "ja"]
+
+
+class WordOfDayService:
+ """Сервис для генерации и получения слова дня"""
+
+ async def generate_all_words_for_today(self) -> Dict[str, int]:
+ """
+ Генерация слов дня для всех языков и уровней.
+ Вызывается в 00:00 UTC.
+
+ Returns:
+ Dict с количеством сгенерированных слов по языкам
+ """
+ today = datetime.utcnow().replace(hour=0, minute=0, second=0, microsecond=0)
+ results = {"en": 0, "ja": 0, "errors": 0}
+
+ async with async_session_maker() as session:
+ for lang in LEARNING_LANGUAGES:
+ levels = JLPT_LEVELS if lang in JLPT_LANGUAGES else CEFR_LEVELS
+
+ for level in levels:
+ try:
+ # Проверяем, не сгенерировано ли уже
+ existing = await self._get_word_for_date(
+ session, today, lang, level
+ )
+ if existing:
+ logger.debug(
+ f"Слово дня уже существует: {lang}/{level}"
+ )
+ continue
+
+ # Получаем список недавних слов для исключения
+ excluded = await self._get_recent_words(session, lang, level, days=30)
+
+ # Генерируем слово
+ word_data = await ai_service.generate_word_of_day(
+ level=level,
+ learning_lang=lang,
+ translation_lang="ru", # Базовый перевод на русский
+ excluded_words=excluded
+ )
+
+ if word_data:
+ word_of_day = WordOfDay(
+ word=word_data.get("word", ""),
+ transcription=word_data.get("transcription"),
+ translation=word_data.get("translation", ""),
+ examples=word_data.get("examples"),
+ synonyms=word_data.get("synonyms"),
+ etymology=word_data.get("etymology"),
+ learning_lang=lang,
+ level=level,
+ date=today
+ )
+ session.add(word_of_day)
+ await session.commit()
+ results[lang] += 1
+ logger.info(
+ f"Сгенерировано слово дня: {word_data.get('word')} "
+ f"({lang}/{level})"
+ )
+ else:
+ results["errors"] += 1
+ logger.warning(
+ f"Не удалось сгенерировать слово для {lang}/{level}"
+ )
+
+ except Exception as e:
+ results["errors"] += 1
+ logger.error(
+ f"Ошибка генерации слова для {lang}/{level}: {e}"
+ )
+
+ total = results["en"] + results["ja"]
+ logger.info(
+ f"Генерация слов дня завершена: всего={total}, "
+ f"en={results['en']}, ja={results['ja']}, ошибок={results['errors']}"
+ )
+ return results
+
+ async def get_word_of_day(
+ self,
+ learning_lang: str,
+ level: str,
+ target_date: Optional[datetime] = None
+ ) -> Optional[WordOfDay]:
+ """
+ Получить слово дня для языка и уровня.
+
+ Args:
+ learning_lang: Язык изучения (en/ja)
+ level: Уровень (A1-C2 или N5-N1)
+ target_date: Дата (по умолчанию сегодня)
+
+ Returns:
+ WordOfDay или None
+ """
+ if target_date is None:
+ target_date = datetime.utcnow().replace(
+ hour=0, minute=0, second=0, microsecond=0
+ )
+ else:
+ target_date = target_date.replace(
+ hour=0, minute=0, second=0, microsecond=0
+ )
+
+ async with async_session_maker() as session:
+ return await self._get_word_for_date(
+ session, target_date, learning_lang, level
+ )
+
+ async def _get_word_for_date(
+ self,
+ session: AsyncSession,
+ target_date: datetime,
+ learning_lang: str,
+ level: str
+ ) -> Optional[WordOfDay]:
+ """Получить слово из БД для конкретной даты"""
+ result = await session.execute(
+ select(WordOfDay).where(
+ and_(
+ WordOfDay.date == target_date,
+ WordOfDay.learning_lang == learning_lang,
+ WordOfDay.level == level
+ )
+ )
+ )
+ return result.scalar_one_or_none()
+
+ async def _get_recent_words(
+ self,
+ session: AsyncSession,
+ learning_lang: str,
+ level: str,
+ days: int = 30
+ ) -> List[str]:
+ """Получить список недавних слов для исключения"""
+ from datetime import timedelta
+
+ cutoff_date = datetime.utcnow() - timedelta(days=days)
+ result = await session.execute(
+ select(WordOfDay.word).where(
+ and_(
+ WordOfDay.learning_lang == learning_lang,
+ WordOfDay.level == level,
+ WordOfDay.date >= cutoff_date
+ )
+ )
+ )
+ return [row[0] for row in result.fetchall()]
+
+ async def format_word_for_user(
+ self,
+ word: WordOfDay,
+ translation_lang: str = "ru",
+ ui_lang: str = None
+ ) -> str:
+ """
+ Форматировать слово дня для отображения пользователю.
+
+ Args:
+ word: Объект WordOfDay
+ translation_lang: Язык перевода для пользователя
+ ui_lang: Язык интерфейса (для локализации заголовков)
+
+ Returns:
+ Отформатированная строка
+ """
+ from utils.i18n import t
+
+ lang = ui_lang or translation_lang or "ru"
+ lines = []
+
+ # Заголовок со словом
+ if word.transcription:
+ lines.append(f"📚 {word.word} [{word.transcription}]")
+ else:
+ lines.append(f"📚 {word.word}")
+
+ # Перевод
+ lines.append(f"📝 {word.translation}")
+
+ # Синонимы
+ if word.synonyms:
+ lines.append(f"\n🔄 {t(lang, 'wod.synonyms')}: {word.synonyms}")
+
+ # Примеры
+ if word.examples:
+ lines.append(f"\n📖 {t(lang, 'wod.examples')}:")
+ for i, example in enumerate(word.examples[:3], 1):
+ sentence = example.get("sentence", "")
+ translation = example.get("translation", "")
+ lines.append(f" {i}. {sentence}")
+ if translation:
+ lines.append(f" {translation}")
+
+ # Этимология/интересный факт
+ if word.etymology:
+ lines.append(f"\n💡 {word.etymology}")
+
+ return "\n".join(lines)
+
+
+# Глобальный экземпляр сервиса
+wordofday_service = WordOfDayService()
diff --git a/ИДЕИ.txt b/ИДЕИ.txt
deleted file mode 100644
index 73b9310..0000000
--- a/ИДЕИ.txt
+++ /dev/null
@@ -1,3 +0,0 @@
-Сделать задачки с помощью голосовых, человек должен написать что услышал, человек должен записать голосовой слова
-Сделать задачки с картинками, человек должен написать что изоображено на картинке
-Сделать задания по темам тип времён или неправильных глаголов на английском
\ No newline at end of file