Добавлен функционал для работы с медиагруппами и улучшена обработка сообщений

- Реализованы методы для добавления связи между постами и сообщениями в `PostRepository` и `AsyncBotDB`. - Обновлены обработчики публикации постов для корректной работы с медиагруппами, включая удаление и уведомление авторов. - Улучшена логика обработки сообщений в `AlbumMiddleware` для более эффективного сбора медиагрупп. - Обновлены тесты для проверки нового функционала и обработки ошибок.
2026-01-24 01:23:35 +03:00
parent fecac6091e
commit 0e2aef8c03
7 changed files with 199 additions and 138 deletions
--- a/helper_bot/handlers/callback/services.py
+++ b/helper_bot/handlers/callback/services.py
@@ -54,7 +54,12 @@ class PostPublishService:
    @track_errors("post_publish_service", "publish_post")
    async def publish_post(self, call: CallbackQuery) -> None:
        """Основной метод публикации поста"""
-        # Проверяем, является ли сообщение частью медиагруппы
+        # Проверяем, является ли сообщение helper-сообщением медиагруппы
+        if call.message.text == CONTENT_TYPE_MEDIA_GROUP:
+            await self._publish_media_group(call)
+            return
+        
+        # Проверяем, является ли сообщение частью медиагруппы (для обратной совместимости)
        if call.message.media_group_id:
            await self._publish_media_group(call)
            return
@@ -280,44 +285,42 @@ class PostPublishService:
    @track_media_processing("media_group")
    async def _publish_media_group(self, call: CallbackQuery) -> None:
        """Публикация медиагруппы"""
-        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}")
+            media_group_message_ids = await self.db.get_post_ids_by_helper_id(helper_message_id)
+            if not media_group_message_ids:
+                logger.error(f"_publish_media_group: Не найдены message_id медиагруппы для helper_message_id={helper_message_id}")
+                raise PublishError("Не найдены 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}")
+                logger.error(f"_publish_media_group: Контент медиагруппы не найден в базе данных для helper_message_id={helper_message_id}")
                raise PublishError("Контент медиагруппы не найден в базе данных")
            
-            # Получаем сырой текст и is_anonymous по helper_message_id
-            logger.debug(f"Получаю текст и is_anonymous поста для helper_message_id: {helper_message_id}")
            raw_text, is_anonymous = await self.db.get_post_text_and_anonymity_by_helper_id(helper_message_id)
            if raw_text is None:
                raw_text = ""
-            logger.debug(f"Текст поста получен: {'пустой' if not raw_text else f'длина: {len(raw_text)} символов'}, is_anonymous={is_anonymous}")
            
-            # Получаем 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}")
+                logger.error(f"_publish_media_group: Автор не найден для медиагруппы helper_message_id={helper_message_id}")
                raise PostNotFoundError(f"Автор не найден для медиагруппы {helper_message_id}")
-            logger.debug(f"ID автора получен: {author_id}")
            
-            # Получаем данные автора
            user = await self.db.get_user_by_id(author_id)
            if not user:
                raise PostNotFoundError(f"Пользователь {author_id} не найден в базе данных")
            
-            # Формируем финальный текст с учетом is_anonymous
            formatted_text = get_text_message(raw_text, user.first_name, user.username, is_anonymous)
-            logger.debug(f"Сформирован финальный текст: {'пустой' if not formatted_text else f'длина: {len(formatted_text)} символов'}")
            
-            # Отправляем медиагруппу в канал
-            logger.info(f"Отправляю медиагруппу в канал {self.main_public}")
+            try:
+                await self._get_bot(call.message).delete_messages(
+                    chat_id=self.group_for_posts, 
+                    message_ids=media_group_message_ids
+                )
+            except Exception as e:
+                logger.warning(f"_publish_media_group: Ошибка при удалении медиагруппы из чата модерации: {e}")
+            
            sent_messages = await send_media_group_to_channel(
                bot=self._get_bot(call.message), 
                chat_id=self.main_public, 
@@ -326,31 +329,49 @@ class PostPublishService:
                s3_storage=self.s3_storage
            )
            
-            # Получаем оригинальные message_id из медиагруппы
-            original_message_ids = await self.db.get_post_ids_from_telegram_by_last_id(helper_message_id)
-            logger.debug(f"Получены оригинальные message_id медиагруппы: {original_message_ids}")
-            
-            # Сохраняем published_message_id для каждого сообщения медиагруппы
-            if len(sent_messages) == len(original_message_ids):
-                for i, original_message_id in enumerate(original_message_ids):
+            if len(sent_messages) == len(media_group_message_ids):
+                for i, original_message_id in enumerate(media_group_message_ids):
                    published_message_id = sent_messages[i].message_id
-                    await self.db.update_published_message_id(
-                        original_message_id=original_message_id,
-                        published_message_id=published_message_id
-                    )
-                    # Сохраняем медиафайл из опубликованного сообщения (используем уже сохраненный файл)
-                    await self._save_published_post_content(sent_messages[i], published_message_id, original_message_id)
-                    logger.debug(f"Сохранен published_message_id: {original_message_id} -> {published_message_id}")
+                    try:
+                        await self.db.update_published_message_id(
+                            original_message_id=original_message_id,
+                            published_message_id=published_message_id
+                        )
+                        await self._save_published_post_content(sent_messages[i], published_message_id, original_message_id)
+                    except Exception as e:
+                        logger.warning(f"_publish_media_group: Ошибка при сохранении published_message_id для {original_message_id}: {e}")
            else:
-                logger.warning(f"Количество опубликованных сообщений ({len(sent_messages)}) не совпадает с количеством оригинальных ({len(original_message_ids)})")
+                logger.warning(f"_publish_media_group: Количество опубликованных сообщений ({len(sent_messages)}) не совпадает с количеством оригинальных ({len(media_group_message_ids)})")

            await self.db.update_status_for_media_group_by_helper_id(helper_message_id, "approved")
-            logger.debug(f"Удаляю медиагруппу и уведомляю автора {author_id}")
-            await self._delete_media_group_and_notify_author(call, author_id)
-            logger.info(f'Медиагруппа опубликована в канале {self.main_public}, опубликовано сообщений: {len(sent_messages)}.')
+            
+            # Удаляем helper сообщение - это критично, делаем это всегда
+            try:
+                await self._get_bot(call.message).delete_message(
+                    chat_id=self.group_for_posts,
+                    message_id=helper_message_id
+                )
+            except Exception as e:
+                logger.warning(f"_publish_media_group: Ошибка при удалении helper сообщения: {e}")
+            
+            try:
+                await send_text_message(author_id, call.message, MESSAGE_POST_PUBLISHED)
+            except Exception as e:
+                if str(e) == ERROR_BOT_BLOCKED:
+                    logger.warning(f"_publish_media_group: Пользователь {author_id} заблокировал бота")
+                    raise UserBlockedBotError("Пользователь заблокировал бота")
+                logger.error(f"_publish_media_group: Ошибка при отправке уведомления автору: {e}")
            
        except Exception as e:
-            logger.error(f"Ошибка при публикации медиагруппы: {e}")
+            logger.error(f"_publish_media_group: Ошибка при публикации медиагруппы: {e}")
+            # Пытаемся удалить helper сообщение даже при ошибке
+            try:
+                await self._get_bot(call.message).delete_message(
+                    chat_id=self.group_for_posts,
+                    message_id=call.message.message_id
+                )
+            except Exception as delete_error:
+                logger.warning(f"_publish_media_group: Не удалось удалить helper сообщение при ошибке: {delete_error}")
            raise PublishError(f"Не удалось опубликовать медиагруппу: {str(e)}")

    @track_time("decline_post", "post_publish_service")
@@ -399,27 +420,32 @@ class PostPublishService:
    @track_media_processing("media_group")
    async def _decline_media_group(self, call: CallbackQuery) -> None:
        """Отклонение медиагруппы"""
-        await self.db.update_status_for_media_group_by_helper_id(call.message.message_id, "declined")
+        helper_message_id = call.message.message_id
+        
+        await self.db.update_status_for_media_group_by_helper_id(helper_message_id, "declined")

-        post_ids = await self.db.get_post_ids_from_telegram_by_last_id(call.message.message_id)
-        message_ids = post_ids.copy()
-        message_ids.append(call.message.message_id)
-        logger.debug(f"Получены ID сообщений для удаления: {message_ids}")
+        media_group_message_ids = await self.db.get_post_ids_by_helper_id(helper_message_id)

-        author_id = await self._get_author_id_for_media_group(call.message.message_id)
-        logger.debug(f"ID автора медиагруппы получен: {author_id}")
+        message_ids_to_delete = media_group_message_ids.copy()
+        message_ids_to_delete.append(helper_message_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)
+        author_id = await self._get_author_id_for_media_group(helper_message_id)
+
+        try:
+            await self._get_bot(call.message).delete_messages(
+                chat_id=self.group_for_posts, 
+                message_ids=message_ids_to_delete
+            )
+        except Exception as e:
+            logger.warning(f"_decline_media_group: Ошибка при удалении сообщений: {e}")
        
        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} заблокировал бота")
+                logger.warning(f"_decline_media_group: Пользователь {author_id} заблокировал бота")
                raise UserBlockedBotError("Пользователь заблокировал бота")
-            logger.error(f"Ошибка при отправке уведомления автору медиагруппы {author_id}: {e}")
+            logger.error(f"_decline_media_group: Ошибка при отправке уведомления автору {author_id}: {e}")
            raise

    @track_time("_get_author_id", "post_publish_service")
@@ -477,12 +503,15 @@ class PostPublishService:
    @track_errors("post_publish_service", "_delete_media_group_and_notify_author")
    @track_media_processing("media_group")
    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)
+        """Удаление медиагруппы и уведомление автора (legacy метод, используется для обратной совместимости)"""
+        helper_message_id = call.message.message_id
+        
+        media_group_message_ids = await self.db.get_post_ids_by_helper_id(helper_message_id)

-        #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)
+        message_ids_to_delete = media_group_message_ids.copy()
+        message_ids_to_delete.append(helper_message_id)
+        
+        await self._get_bot(call.message).delete_messages(chat_id=self.group_for_posts, message_ids=message_ids_to_delete)
        try:
            await send_text_message(author_id, call.message, MESSAGE_POST_PUBLISHED)
        except Exception as e:
@@ -538,7 +567,12 @@ class BanService:
    @db_query_time("ban_user_from_post", "users", "mixed")
    async def ban_user_from_post(self, call: CallbackQuery) -> None:
        """Бан пользователя за спам"""
-        author_id = await self.db.get_author_id_by_message_id(call.message.message_id)
+        # Если это helper-сообщение медиагруппы, используем специальный метод
+        if call.message.text == CONTENT_TYPE_MEDIA_GROUP:
+            author_id = await self.db.get_author_id_by_helper_message_id(call.message.message_id)
+        else:
+            author_id = await self.db.get_author_id_by_message_id(call.message.message_id)
+        
        if not author_id:
            raise UserNotFoundError(f"Автор не найден для сообщения {call.message.message_id}")
        
--- a/helper_bot/handlers/private/private_handlers.py
+++ b/helper_bot/handlers/private/private_handlers.py
@@ -51,9 +51,8 @@ class PrivateHandlers:
        self.post_service = PostService(db, settings, s3_storage)
        self.sticker_service = StickerService(settings)
        
-        # Create router
        self.router = Router()
-        self.router.message.middleware(AlbumMiddleware())
+        self.router.message.middleware(AlbumMiddleware(latency=5.0))
        self.router.message.middleware(BlacklistMiddleware())
        
        # Register handlers
@@ -158,12 +157,10 @@ class PrivateHandlers:
    @track_time("suggest_router", "private_handlers")
    async def suggest_router(self, message: types.Message, state: FSMContext, album: list = None, **kwargs):
        """Handle post submission in suggest state"""
-        # Post service operations with metrics
        await self.user_service.update_user_activity(message.from_user.id)
-        await self.user_service.log_user_message(message)
+        if message.media_group_id is None:
+            await self.user_service.log_user_message(message)
        await self.post_service.process_post(message, album)
-        
-        # Send success message and return to start state
        markup_for_user = await get_reply_keyboard(self.db, message.from_user.id)
        success_send_message = messages.get_message(get_first_name(message), 'SUCCESS_SEND_MESSAGE')
        await message.answer(success_send_message, reply_markup=markup_for_user)
--- a/helper_bot/handlers/private/services.py
+++ b/helper_bot/handlers/private/services.py
@@ -323,7 +323,6 @@ class PostService:
    @track_media_processing("media_group")
    async def handle_media_group_post(self, message: types.Message, album: list, first_name: str) -> None:
        """Handle media group post submission"""
-        #TODO: Мне кажется тут какая-то дичь с одинаковыми переменными, в которых post_caption никуда не ведет
        post_caption = " "
        raw_caption = ""
        
@@ -331,12 +330,17 @@ class PostService:
            raw_caption = album[0].caption or ""
            post_caption = get_text_message(album[0].caption.lower(), first_name, message.from_user.username)
        
-        # Определяем анонимность на основе сырого caption
        is_anonymous = determine_anonymity(raw_caption)
+        media_group = await prepare_media_group_from_middlewares(album, post_caption)
+        
+        media_group_message_ids = await send_media_group_message_to_private_chat(
+            self.settings.group_for_posts, message, media_group, self.db, None, self.s3_storage
+        )
+        
+        main_post_id = media_group_message_ids[-1]
        
-        # Создаем основной пост для медиагруппы
        main_post = TelegramPost(
-            message_id=message.message_id,  # ID основного сообщения медиагруппы
+            message_id=main_post_id,
            text=raw_caption,
            author_id=message.from_user.id,
            created_at=int(datetime.now().timestamp()),
@@ -344,32 +348,32 @@ class PostService:
        )
        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, main_post.message_id, self.s3_storage
-        )
+        for msg_id in media_group_message_ids:
+            await self.db.add_message_link(main_post_id, msg_id)
        
        await asyncio.sleep(0.2)
        
-        # Создаем helper сообщение с кнопками
        markup = get_reply_keyboard_for_post()
-        help_message = await send_text_message(self.settings.group_for_posts, message, "ВРУЧНУЮ ВЫКЛАДЫВАТЬ, ПОСЛЕ ВЫКЛАДКИ УДАЛИТЬ ОБА ПОСТА")
+        helper_message = await send_text_message(
+            self.settings.group_for_posts, 
+            message, 
+            "^",
+            markup
+        )
+        helper_message_id = helper_message.message_id
        
-        # Создаем helper пост и связываем его с основным
        helper_post = TelegramPost(
-            message_id=help_message.message_id,  # ID helper сообщения
-            text="^",  # Специальный маркер для медиагруппы
+            message_id=helper_message_id,
+            text="^",
            author_id=message.from_user.id,
-            helper_text_message_id=main_post.message_id,  # Ссылка на основной пост
+            helper_text_message_id=main_post_id,
            created_at=int(datetime.now().timestamp())
        )
        await self.db.add_post(helper_post)
        
-        # Обновляем основной пост, чтобы он ссылался на helper
        await self.db.update_helper_message(
-            message_id=main_post.message_id, 
-            helper_message_id=help_message.message_id
+            message_id=main_post_id, 
+            helper_message_id=helper_message_id
        )
    
    @track_time("process_post", "post_service")
@@ -378,13 +382,8 @@ 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(
-                self.settings.group_for_logs, message,
-                f'Закинул медиагруппу, пользователь: имя - {first_name}, ник - {safe_username}'
-            )
            await self.handle_media_group_post(message, album, first_name)
            return