Enhance admin handlers with improved logging and error handling

- Added detailed logging for user ban processing in `process_ban_target` and `process_ban_reason` functions, including user data and error messages.
- Improved error handling for user input validation and database interactions.
- Updated `return_to_admin_menu` function to log user return actions.
- Enhanced media group handling in `PostPublishService` with better error logging and author ID retrieval.
- Added new button options in voice handlers and updated keyboard layouts for improved user interaction.
- Refactored album middleware to better handle media group messages and added documentation for clarity.

helper_bot/handlers/admin/admin_handlers.py

@@ -145,32 +145,42 @@ async def process_ban_target(
     bot_db: MagicData("bot_db")
     ):
     """Обработка введенного username/ID для блокировки"""
+    logger.info(f"process_ban_target: === НАЧАЛО ОБРАБОТКИ === Получено сообщение от {message.from_user.id}: {message.text}")
+    
     try:
         user_data = await state.get_data()
         ban_type = user_data.get('ban_type')
         admin_service = AdminService(bot_db)
         
+        logger.info(f"process_ban_target: ban_type={ban_type}, user_data={user_data}")
 
         # Определяем пользователя
         if ban_type == "username":
+            logger.info(f"process_ban_target: Поиск пользователя по username: {message.text}")
             user = await admin_service.get_user_by_username(message.text)
             if not user:
+                logger.warning(f"process_ban_target: Пользователь с username '{message.text}' не найден")
                 await message.answer(f"Пользователь с username '{escape_html(message.text)}' не найден.")
                 await return_to_admin_menu(message, state)
                 return
         else:  # ban_type == "id"
             try:
+                logger.info(f"process_ban_target: Валидация и поиск пользователя по ID: {message.text}")
                 user_id = await admin_service.validate_user_input(message.text)
                 user = await admin_service.get_user_by_id(user_id)
                 if not user:
+                    logger.warning(f"process_ban_target: Пользователь с ID {user_id} не найден в базе данных")
                     await message.answer(f"Пользователь с ID {user_id} не найден в базе данных.")
                     await return_to_admin_menu(message, state)
                     return
             except InvalidInputError as e:
+                logger.error(f"process_ban_target: Ошибка валидации ID: {e}")
                 await message.answer(str(e))
                 await return_to_admin_menu(message, state)
                 return
         
+        logger.info(f"process_ban_target: Найден пользователь: {user.user_id}, {user.username}, {user.full_name}")
+        
         # Сохраняем данные пользователя
         await state.update_data(
             target_user_id=user.user_id,
@@ -181,13 +191,17 @@ async def process_ban_target(
         # Показываем информацию о пользователе и запрашиваем причину
         user_info = format_user_info(user.user_id, user.username, user.full_name)
         markup = create_keyboard_for_ban_reason()
+        logger.info(f"process_ban_target: Отправка сообщения с причиной бана, user_info: {user_info}")
+        
         await message.answer(
             text=f"{user_info}\n\nВыбери причину бана из списка или напиши ее в чат",
             reply_markup=markup
         )
         await state.set_state('AWAIT_BAN_DETAILS')
+        logger.info("process_ban_target: Состояние изменено на AWAIT_BAN_DETAILS")
         
     except Exception as e:
+        logger.error(f"process_ban_target: Неожиданная ошибка: {e}", exc_info=True)
         await handle_admin_error(message, e, state, "process_ban_target")
 
 
@@ -201,16 +215,33 @@ async def process_ban_reason(
     **kwargs
     ):
     """Обработка причины блокировки"""
+    logger.info(f"process_ban_reason: === НАЧАЛО ОБРАБОТКИ === Получено сообщение от {message.from_user.id}: {message.text}")
+    
     try:
+        # Проверяем текущее состояние
+        current_state = await state.get_state()
+        logger.info(f"process_ban_reason: Текущее состояние: {current_state}")
+        
+        # Проверяем данные состояния
+        state_data = await state.get_data()
+        logger.info(f"process_ban_reason: Данные состояния: {state_data}")
+        
+        logger.info(f"process_ban_reason: Обновление данных состояния с причиной: {message.text}")
         await state.update_data(ban_reason=message.text)
+        
         markup = create_keyboard_for_ban_days()
         safe_reason = escape_html(message.text)
+        logger.info(f"process_ban_reason: Отправка сообщения с выбором срока бана, причина: {safe_reason}")
+        
         await message.answer(
             f"Выбрана причина: {safe_reason}. Выбери срок бана в днях или напиши его в чат",
             reply_markup=markup
         )
         await state.set_state('AWAIT_BAN_DURATION')
+        logger.info("process_ban_reason: Состояние изменено на AWAIT_BAN_DURATION")
+        
     except Exception as e:
+        logger.error(f"process_ban_reason: Неожиданная ошибка: {e}", exc_info=True)
         await handle_admin_error(message, e, state, "process_ban_reason")
 
 

helper_bot/handlers/admin/utils.py

@@ -16,14 +16,18 @@ def escape_html(text: str) -> str:
 async def return_to_admin_menu(message: types.Message, state: FSMContext, 
                               additional_message: Optional[str] = None) -> None:
     """Универсальная функция для возврата в админ-меню"""
+    logger.info(f"return_to_admin_menu: Возврат в админ-меню для пользователя {message.from_user.id}")
+    
     await state.set_data({})
     await state.set_state("ADMIN")
     markup = get_reply_keyboard_admin()
     
     if additional_message:
+        logger.info(f"return_to_admin_menu: Отправка дополнительного сообщения: {additional_message}")
         await message.answer(additional_message)
     
     await message.answer('Вернулись в меню', reply_markup=markup)
+    logger.info(f"return_to_admin_menu: Пользователь {message.from_user.id} успешно возвращен в админ-меню")
 
 
 async def handle_admin_error(message: types.Message, error: Exception, 

helper_bot/handlers/callback/services.py

@@ -1,5 +1,5 @@
-import html
 from datetime import datetime, timedelta
+import html
 from typing import Dict, Any
 
 from aiogram import Bot
@@ -42,9 +42,14 @@ class PostPublishService:
 
     async def publish_post(self, call: CallbackQuery) -> None:
         """Основной метод публикации поста"""
+        # Проверяем, является ли сообщение частью медиагруппы
+        if call.message.media_group_id:
+            await self._publish_media_group(call)
+            return
+            
         content_type = call.message.content_type
         
-        if content_type == CONTENT_TYPE_TEXT and call.message.text != CONTENT_TYPE_MEDIA_GROUP:
+        if content_type == CONTENT_TYPE_TEXT:
             await self._publish_text_post(call)
         elif content_type == CONTENT_TYPE_PHOTO:
             await self._publish_photo_post(call)
@@ -56,8 +61,6 @@ class PostPublishService:
             await self._publish_audio_post(call)
         elif content_type == CONTENT_TYPE_VOICE:
             await self._publish_voice_post(call)
-        elif call.message.text == CONTENT_TYPE_MEDIA_GROUP:
-            await self._publish_media_group(call)
         else:
             raise PublishError(f"Неподдерживаемый тип контента: {content_type}")
 
@@ -115,51 +118,111 @@ class PostPublishService:
 
     async def _publish_media_group(self, call: CallbackQuery) -> None:
         """Публикация медиагруппы"""
-        post_content = await self.db.get_post_content_from_telegram_by_last_id(call.message.message_id)
-        pre_text = await self.db.get_post_text_from_telegram_by_last_id(call.message.message_id)
-        post_text = html.escape(str(pre_text))
-        author_id = await self._get_author_id_for_media_group(call.message.message_id)
-        
-        await send_media_group_to_channel(bot=self._get_bot(call.message), chat_id=self.main_public, post_content=post_content, post_text=post_text)
-        await self._delete_media_group_and_notify_author(call, author_id)
+        logger.info(f"Начинаю публикацию медиагруппы. Helper message ID: {call.message.message_id}")
+        try:
+            # call.message.message_id - это ID helper сообщения
+            helper_message_id = call.message.message_id
+            
+            # Получаем контент медиагруппы по helper_message_id
+            logger.debug(f"Получаю контент медиагруппы для helper_message_id: {helper_message_id}")
+            post_content = await self.db.get_post_content_by_helper_id(helper_message_id)
+            if not post_content:
+                logger.error(f"Контент медиагруппы не найден в базе данных для helper_message_id: {helper_message_id}")
+                raise PublishError("Контент медиагруппы не найден в базе данных")
+            
+            # Получаем текст поста по helper_message_id
+            logger.debug(f"Получаю текст поста для helper_message_id: {helper_message_id}")
+            pre_text = await self.db.get_post_text_by_helper_id(helper_message_id)
+            post_text = html.escape(str(pre_text)) if pre_text else ""
+            logger.debug(f"Текст поста получен: {'пустой' if not post_text else f'длина: {len(post_text)} символов'}")
+            
+            # Получаем ID автора по helper_message_id
+            logger.debug(f"Получаю ID автора для helper_message_id: {helper_message_id}")
+            author_id = await self.db.get_author_id_by_helper_message_id(helper_message_id)
+            if not author_id:
+                logger.error(f"Автор не найден для медиагруппы {helper_message_id}")
+                raise PostNotFoundError(f"Автор не найден для медиагруппы {helper_message_id}")
+            logger.debug(f"ID автора получен: {author_id}")
+            
+            # Отправляем медиагруппу в канал
+            logger.info(f"Отправляю медиагруппу в канал {self.main_public}")
+            await send_media_group_to_channel(
+                bot=self._get_bot(call.message), 
+                chat_id=self.main_public, 
+                post_content=post_content, 
+                post_text=post_text
+            )
+            
+            logger.debug(f"Удаляю медиагруппу и уведомляю автора {author_id}")
+            await self._delete_media_group_and_notify_author(call, author_id)
+            logger.info(f'Медиагруппа опубликована в канале {self.main_public}.')
+            
+        except Exception as e:
+            logger.error(f"Ошибка при публикации медиагруппы: {e}")
+            raise PublishError(f"Не удалось опубликовать медиагруппу: {str(e)}")
 
     async def decline_post(self, call: CallbackQuery) -> None:
         """Отклонение поста"""
+        logger.info(f"Начинаю отклонение поста. Message ID: {call.message.message_id}, Content type: {call.message.content_type}")
+        # Проверяем, является ли сообщение частью медиагруппы (осознанный костыль, т.к. сообщение к которому прикреплен коллбек без медиагруппы)
+        if call.message.text == CONTENT_TYPE_MEDIA_GROUP:
+            logger.debug("Сообщение является частью медиагруппы, вызываю _decline_media_group")
+            await self._decline_media_group(call)
+            return
+            
         content_type = call.message.content_type
         
-        if (content_type == CONTENT_TYPE_TEXT and call.message.text != CONTENT_TYPE_MEDIA_GROUP) or \
-           content_type in [CONTENT_TYPE_PHOTO, CONTENT_TYPE_AUDIO, CONTENT_TYPE_VOICE, CONTENT_TYPE_VIDEO, CONTENT_TYPE_VIDEO_NOTE]:
+        if content_type in [CONTENT_TYPE_TEXT, CONTENT_TYPE_PHOTO, CONTENT_TYPE_AUDIO, 
+                           CONTENT_TYPE_VOICE, CONTENT_TYPE_VIDEO, CONTENT_TYPE_VIDEO_NOTE]:
+            logger.debug(f"Отклоняю одиночный пост типа: {content_type}")
             await self._decline_single_post(call)
-        elif call.message.text == CONTENT_TYPE_MEDIA_GROUP:
-            await self._decline_media_group(call)
         else:
+            logger.error(f"Неподдерживаемый тип контента для отклонения: {content_type}")
             raise PublishError(f"Неподдерживаемый тип контента для отклонения: {content_type}")
 
     async def _decline_single_post(self, call: CallbackQuery) -> None:
         """Отклонение одиночного поста"""
+        logger.debug(f"Отклоняю одиночный пост. Message ID: {call.message.message_id}")
         author_id = await self._get_author_id(call.message.message_id)
+        logger.debug(f"ID автора получен: {author_id}")
+        
+        logger.debug(f"Удаляю сообщение из группы {self.group_for_posts}")
         await self._get_bot(call.message).delete_message(chat_id=self.group_for_posts, message_id=call.message.message_id)
+        
         try:
+            logger.debug(f"Отправляю уведомление об отклонении автору {author_id}")
             await send_text_message(author_id, call.message, MESSAGE_POST_DECLINED)
         except Exception as e:
             if str(e) == ERROR_BOT_BLOCKED:
+                logger.warning(f"Пользователь {author_id} заблокировал бота")
                 raise UserBlockedBotError("Пользователь заблокировал бота")
+            logger.error(f"Ошибка при отправке уведомления автору {author_id}: {e}")
             raise
         logger.info(f'Сообщение отклонено админом {call.from_user.full_name} (ID: {call.from_user.id}).')
 
     async def _decline_media_group(self, call: CallbackQuery) -> None:
         """Отклонение медиагруппы"""
+        logger.debug(f"Отклоняю медиагруппу. Helper message ID: {call.message.message_id}")
+        
         post_ids = await self.db.get_post_ids_from_telegram_by_last_id(call.message.message_id)
-        message_ids = [row[0] for row in post_ids]
+        message_ids = post_ids.copy()
         message_ids.append(call.message.message_id)
+        logger.debug(f"Получены ID сообщений для удаления: {message_ids}")
         
         author_id = await self._get_author_id_for_media_group(call.message.message_id)
+        logger.debug(f"ID автора медиагруппы получен: {author_id}")
+        
+        logger.debug(f"Удаляю {len(message_ids)} сообщений из группы {self.group_for_posts}")
         await self._get_bot(call.message).delete_messages(chat_id=self.group_for_posts, message_ids=message_ids)
+        
         try:
+            logger.debug(f"Отправляю уведомление об отклонении автору медиагруппы {author_id}")
             await send_text_message(author_id, call.message, MESSAGE_POST_DECLINED)
         except Exception as e:
             if str(e) == ERROR_BOT_BLOCKED:
+                logger.warning(f"Пользователь {author_id} заблокировал бота")
                 raise UserBlockedBotError("Пользователь заблокировал бота")
+            logger.error(f"Ошибка при отправке уведомления автору медиагруппы {author_id}: {e}")
             raise
 
     async def _get_author_id(self, message_id: int) -> int:
@@ -171,7 +234,27 @@ class PostPublishService:
 
     async def _get_author_id_for_media_group(self, message_id: int) -> int:
         """Получение ID автора для медиагруппы"""
+        # Сначала пытаемся найти автора по helper_message_id
         author_id = await self.db.get_author_id_by_helper_message_id(message_id)
+        if author_id:
+            return author_id
+        
+        # Если не найден, ищем по основному message_id медиагруппы
+        # Для этого нужно найти связанные сообщения медиагруппы
+        try:
+            # Получаем все ID сообщений медиагруппы
+            post_ids = await self.db.get_post_ids_from_telegram_by_last_id(message_id)
+            if post_ids:
+                # Берем первый ID (основное сообщение медиагруппы)
+                main_message_id = post_ids[0]
+                author_id = await self.db.get_author_id_by_message_id(main_message_id)
+                if author_id:
+                    return author_id
+        except Exception as e:
+            logger.warning(f"Не удалось найти автора через связанные сообщения: {e}")
+        
+        # Если все способы не сработали, ищем напрямую
+        author_id = await self.db.get_author_id_by_message_id(message_id)
         if not author_id:
             raise PostNotFoundError(f"Автор не найден для медиагруппы {message_id}")
         return author_id
@@ -190,9 +273,10 @@ class PostPublishService:
     async def _delete_media_group_and_notify_author(self, call: CallbackQuery, author_id: int) -> None:
         """Удаление медиагруппы и уведомление автора"""
         post_ids = await self.db.get_post_ids_from_telegram_by_last_id(call.message.message_id)
-        message_ids = [row[0] for row in post_ids]
-        message_ids.append(call.message.message_id)
-        await self._get_bot(call.message).delete_messages(chat_id=self.group_for_posts, message_ids=message_ids)
+
+        #message_ids = post_ids.copy()
+        post_ids.append(call.message.message_id)
+        await self._get_bot(call.message).delete_messages(chat_id=self.group_for_posts, message_ids=post_ids)
         try:
             await send_text_message(author_id, call.message, MESSAGE_POST_PUBLISHED)
         except Exception as e:

helper_bot/handlers/private/services.py

@@ -272,6 +272,16 @@ class PostService:
         if album and album[0].caption:
             post_caption = get_text_message(album[0].caption.lower(), first_name, message.from_user.username)
         
+        # Создаем основной пост для медиагруппы
+        main_post = TelegramPost(
+            message_id=message.message_id,  # ID основного сообщения медиагруппы
+            text=post_caption,
+            author_id=message.from_user.id,
+            created_at=int(datetime.now().timestamp())
+        )
+        await self.db.add_post(main_post)
+        
+        # Отправляем медиагруппу в группу для модерации
         media_group = await prepare_media_group_from_middlewares(album, post_caption)
         media_group_message_id = await send_media_group_message_to_private_chat(
             self.settings.group_for_posts, message, media_group, self.db
@@ -279,11 +289,24 @@ class PostService:
         
         await asyncio.sleep(0.2)
         
+        # Создаем helper сообщение с кнопками
         markup = get_reply_keyboard_for_post()
-        help_message_id = await send_text_message(self.settings.group_for_posts, message, "^", markup)
+        help_message_id = await send_text_message(self.settings.group_for_posts, message, "ВРУЧНУЮ ВЫКЛАДЫВАТЬ, ПОСЛЕ ВЫКЛАДКИ УДАЛИТЬ ОБА ПОСТА")
         
+        # Создаем helper пост и связываем его с основным
+        helper_post = TelegramPost(
+            message_id=help_message_id,  # ID helper сообщения
+            text="^",  # Специальный маркер для медиагруппы
+            author_id=message.from_user.id,
+            helper_text_message_id=main_post.message_id,  # Ссылка на основной пост
+            created_at=int(datetime.now().timestamp())
+        )
+        await self.db.add_post(helper_post)
+        
+        # Обновляем основной пост, чтобы он ссылался на helper
         await self.db.update_helper_message(
-            message_id=media_group_message_id, helper_message_id=help_message_id
+            message_id=main_post.message_id, 
+            helper_message_id=help_message_id
         )
     
     @track_time("process_post", "post_service")
@@ -291,7 +314,7 @@ class PostService:
     async def process_post(self, message: types.Message, album: Union[list, None] = None) -> None:
         """Process post based on content type"""
         first_name = get_first_name(message)
-        
+        # TODO: Бесит меня этот функционал
         if message.media_group_id is not None:
             safe_username = html.escape(message.from_user.username) if message.from_user.username else "Без никнейма"
             await send_text_message(

helper_bot/handlers/voice/constants.py

@@ -30,7 +30,10 @@ BTN_LISTEN = "🎧Послушать"
 # Button to command mapping for metrics
 BUTTON_COMMAND_MAPPING: Final[Dict[str, str]] = {
     "🎤Высказаться": "voice_speak",
-    "🎧Послушать": "voice_listen"
+    "🎧Послушать": "voice_listen",
+    "Отменить": "voice_cancel",
+    "🔄Сбросить прослушивания": "voice_refresh_listen",
+    "😊Узнать эмодзи": "voice_emoji"
 }
 
 # Callback data

helper_bot/handlers/voice/services.py

@@ -1,5 +1,6 @@
 import random
 import asyncio
+import traceback
 from datetime import datetime
 from pathlib import Path
 from typing import List, Optional, Tuple
@@ -255,22 +256,40 @@ class AudioFileService:
     async def download_and_save_audio(self, bot, message, file_name: str) -> None:
         """Скачать и сохранить аудио файл"""
         try:
+            logger.info(f"Начинаем скачивание и сохранение аудио: {file_name}")
+            
             # Проверяем наличие голосового сообщения
             if not message or not message.voice:
+                logger.error("Сообщение или голосовое сообщение не найдено")
                 raise FileOperationError("Сообщение или голосовое сообщение не найдено")
                 
             file_id = message.voice.file_id
+            logger.info(f"Получен file_id: {file_id}")
+            
             file_info = await bot.get_file(file_id=file_id)
+            logger.info(f"Получена информация о файле: {file_info.file_path}")
+            
             downloaded_file = await bot.download_file(file_path=file_info.file_path)
+            logger.info(f"Файл скачан, размер: {len(downloaded_file.read()) if downloaded_file else 'None'} bytes")
+            
+            # Сбрасываем позицию в файле
+            downloaded_file.seek(0)
             
             # Создаем директорию если она не существует
             import os
             os.makedirs(VOICE_USERS_DIR, exist_ok=True)
+            logger.info(f"Директория {VOICE_USERS_DIR} создана/проверена")
+            
+            file_path = f'{VOICE_USERS_DIR}/{file_name}.ogg'
+            logger.info(f"Сохраняем файл по пути: {file_path}")
             
             # Сохраняем файл
-            with open(f'{VOICE_USERS_DIR}/{file_name}.ogg', 'wb') as new_file:
+            with open(file_path, 'wb') as new_file:
                 new_file.write(downloaded_file.read())
                 
+            logger.info(f"Файл успешно сохранен: {file_path}")
+                
         except Exception as e:
             logger.error(f"Ошибка при скачивании и сохранении аудио: {e}")
+            logger.error(f"Traceback: {traceback.format_exc()}")
             raise FileOperationError(f"Не удалось скачать и сохранить аудио: {e}")

helper_bot/handlers/voice/voice_handler.py

@@ -18,12 +18,14 @@ from helper_bot.handlers.voice.constants import *
 from helper_bot.handlers.voice.services import VoiceBotService
 from helper_bot.handlers.voice.utils import get_last_message_text, validate_voice_message, get_user_emoji_safe
 from helper_bot.keyboards.keyboards import get_main_keyboard, get_reply_keyboard_for_voice
+from helper_bot.keyboards import get_reply_keyboard
+from helper_bot.handlers.private.constants import FSM_STATES
 from helper_bot.handlers.private.constants import BUTTON_TEXTS
 
 
 class VoiceHandlers:
     def __init__(self, db, settings):
-        self.db = db
+        self.db = db.get_db() if hasattr(db, 'get_db') else db
         self.settings = settings
         self.router = Router()
         self._setup_handlers()
@@ -93,6 +95,25 @@ class VoiceHandlers:
             ChatTypeFilter(chat_type=["private"]),
             F.text == BTN_LISTEN
         )
+        
+        # Новые обработчики кнопок
+        self.router.message.register(
+            self.cancel_handler,
+            ChatTypeFilter(chat_type=["private"]),
+            F.text == "Отменить"
+        )
+        
+        self.router.message.register(
+            self.refresh_listen_function,
+            ChatTypeFilter(chat_type=["private"]),
+            F.text == "🔄Сбросить прослушивания"
+        )
+        
+        self.router.message.register(
+            self.handle_emoji_message,
+            ChatTypeFilter(chat_type=["private"]),
+            F.text == "😊Узнать эмодзи"
+        )
 
     async def voice_bot_button_handler(self, message: types.Message, state: FSMContext, bot_db: MagicData("bot_db"), settings: MagicData("settings")):
         """Обработчик кнопки 'Голосовой бот' из основной клавиатуры"""
@@ -180,6 +201,19 @@ class VoiceHandlers:
         except Exception as e:
             logger.error(f"Ошибка при отметке получения приветствия: {e}")
 
+    async def cancel_handler(
+        self,
+        message: types.Message, 
+        state: FSMContext, 
+        bot_db: MagicData("bot_db"),
+        settings: MagicData("settings")
+    ):
+        """Обработчик кнопки 'Отменить' - возвращает в начальное состояние"""
+        await message.forward(chat_id=settings['Telegram']['group_for_logs'])
+        await update_user_info(VOICE_BOT_NAME, message)
+        markup = await get_reply_keyboard(self.db, message.from_user.id)
+        await message.answer(text='Добро пожаловать в меню!', reply_markup=markup, parse_mode='HTML')
+        await state.set_state(FSM_STATES["START"])
 
     async def refresh_listen_function(
         self,
@@ -334,7 +368,7 @@ class VoiceHandlers:
                 await voice_service.mark_audio_as_listened(audio_for_user, message.from_user.id)
                 
                 # Получаем количество оставшихся аудио только после успешной отправки
-                remaining_count = await voice_service.get_remaining_audio_count(message.from_user.id) - 1
+                remaining_count = await voice_service.get_remaining_audio_count(message.from_user.id)
                 await message.answer(
                     text=f'Осталось непрослушанных: <b>{remaining_count}</b>', 
                     reply_markup=markup