Add middleware and refactor admin handlers for improved functionality

- Introduced `DependenciesMiddleware` and `BlacklistMiddleware` for enhanced request handling across all routers.
- Refactored admin handlers to utilize new middleware, improving access control and error handling.
- Updated the `admin_router` to include middleware for access checks and streamlined the process of banning users.
- Enhanced the structure of admin handler imports for better organization and maintainability.
- Improved error handling in various admin functions to ensure robust user interactions.

helper_bot/handlers/callback/__init__.py

@@ -1 +1,24 @@
 from .callback_handlers import callback_router
+from .services import PostPublishService, BanService
+from .exceptions import UserBlockedBotError, PostNotFoundError, UserNotFoundError, PublishError, BanError
+from .constants import (
+    CALLBACK_PUBLISH, CALLBACK_DECLINE, CALLBACK_BAN, CALLBACK_UNLOCK, 
+    CALLBACK_RETURN, CALLBACK_PAGE
+)
+
+__all__ = [
+    'callback_router',
+    'PostPublishService',
+    'BanService',
+    'UserBlockedBotError',
+    'PostNotFoundError',
+    'UserNotFoundError',
+    'PublishError',
+    'BanError',
+    'CALLBACK_PUBLISH',
+    'CALLBACK_DECLINE',
+    'CALLBACK_BAN',
+    'CALLBACK_UNLOCK',
+    'CALLBACK_RETURN',
+    'CALLBACK_PAGE'
+]

helper_bot/handlers/callback/callback_handlers.py

@@ -1,322 +1,188 @@
 import html
+from tkinter import S
 import traceback
-from datetime import datetime, timedelta
 
-from aiogram import Router, F
+from aiogram import Router
 from aiogram.fsm.context import FSMContext
 from aiogram.types import CallbackQuery
+from aiogram import F
+from aiogram.filters import MagicData
 
 from helper_bot.keyboards.keyboards import create_keyboard_with_pagination, get_reply_keyboard_admin, \
     create_keyboard_for_ban_reason
+from helper_bot.utils.helper_func import get_banned_users_list, get_banned_users_buttons
 from helper_bot.utils.base_dependency_factory import get_global_instance
-from helper_bot.utils.helper_func import send_text_message, send_photo_message, get_banned_users_list, \
-    get_banned_users_buttons, delete_user_blacklist, send_media_group_to_channel, \
-    send_video_message, send_video_note_message, send_audio_message, send_voice_message
+from .dependency_factory import get_post_publish_service, get_ban_service
+from .exceptions import UserBlockedBotError, PostNotFoundError, UserNotFoundError, PublishError, BanError
+from .constants import (
+    CALLBACK_PUBLISH, CALLBACK_DECLINE, CALLBACK_BAN, CALLBACK_UNLOCK, 
+    CALLBACK_RETURN, CALLBACK_PAGE, MESSAGE_PUBLISHED, MESSAGE_DECLINED, 
+    MESSAGE_USER_BANNED, MESSAGE_USER_UNLOCKED, MESSAGE_ERROR,
+    ERROR_BOT_BLOCKED
+)
 from logs.custom_logger import logger
 
 callback_router = Router()
 
-bdf = get_global_instance()
-GROUP_FOR_POST = bdf.settings['Telegram']['group_for_posts']
-GROUP_FOR_MESSAGE = bdf.settings['Telegram']['group_for_message']
-MAIN_PUBLIC = bdf.settings['Telegram']['main_public']
-GROUP_FOR_LOGS = bdf.settings['Telegram']['group_for_logs']
-IMPORTANT_LOGS = bdf.settings['Telegram']['important_logs']
-PREVIEW_LINK = bdf.settings['Telegram']['preview_link']
-LOGS = bdf.settings['Settings']['logs']
-TEST = bdf.settings['Settings']['test']
 
-BotDB = bdf.get_db()
-
-
-@callback_router.callback_query(
-    F.data == "publish"
-)
-async def post_for_group(call: CallbackQuery, state: FSMContext):
+@callback_router.callback_query(F.data == CALLBACK_PUBLISH)
+async def post_for_group(
+    call: CallbackQuery,
+    settings: MagicData("settings")
+    ):
+    publish_service = get_post_publish_service()
+    # TODO: переделать на MagicData
     logger.info(
         f'Получен callback-запрос с действием: {call.data} от пользователя {call.from_user.full_name} (ID сообщения: {call.message.message_id})')
-    text_post = html.escape(str(call.message.text))
-    text_post_with_photo = html.escape(str(call.message.caption))
-    if call.message.content_type == 'text' and call.message.text != "^":
-        try:
-            # Пересылаем сообщение в канал
-            await send_text_message(MAIN_PUBLIC, call.message, text_post)
-
-            # Получаем из базы автора
-            author_id = BotDB.get_author_id_by_message_id(call.message.message_id)
-
-            # Очищаем предложку и удаляем оттуда пост
-            await call.bot.delete_message(chat_id=GROUP_FOR_POST, message_id=call.message.message_id)
-            logger.info(f'Текст сообщения опубликован в канале {MAIN_PUBLIC}.')
-            await call.answer(text='Выложено!', cache_time=3)
-
-            # Отвечаем пользователю
-            await send_text_message(author_id, call.message, 'Твой пост был выложен🥰')
-        except Exception as e:
-            if e.message != 'Forbidden: bot was blocked by the user':
-                await call.bot.send_message(chat_id=IMPORTANT_LOGS,
-                                            text=f"Произошла ошибка: {str(e)}\n\nTraceback:\n{traceback.format_exc()}")
-                logger.error(f'Ошибка при публикации текста в канал {MAIN_PUBLIC}: {str(e)}')
-                await call.answer(text='Что-то пошло не так!', show_alert=True, cache_time=3)
-    elif call.message.content_type == 'photo':
-        try:
-            await send_photo_message(MAIN_PUBLIC, call.message, call.message.photo[-1].file_id, text_post_with_photo)
-
-            # Получаем из базы автора + отправляем сообщение + удаляем сообщение из предложки
-            author_id = BotDB.get_author_id_by_message_id(call.message.message_id)
-
-            # Удаляем пост из предложки
-            await call.bot.delete_message(chat_id=GROUP_FOR_POST, message_id=call.message.message_id)
-            logger.info(f'Пост с фото опубликован в канале {MAIN_PUBLIC}.')
-            await call.answer(text='Выложено!', cache_time=3)
-            await send_text_message(author_id, call.message, 'Твой пост был выложен🥰')
-        except Exception as e:
-            if e.message != 'Forbidden: bot was blocked by the user':
-                await call.bot.send_message(chat_id=IMPORTANT_LOGS,
-                                            text=f"Произошла ошибка: {str(e)}\n\nTraceback:\n{traceback.format_exc()}")
-                logger.error(f'Ошибка при публикации фотографии в канал {MAIN_PUBLIC}: {str(e)}')
-                await call.answer(text='Что-то пошло не так!', show_alert=True, cache_time=3)
-    elif call.message.content_type == 'video':
-        try:
-            await send_video_message(MAIN_PUBLIC, call.message, call.message.video.file_id, text_post_with_photo)
-
-            # Получаем из базы автора + отправляем сообщение + удаляем сообщение из предложки
-            author_id = BotDB.get_author_id_by_message_id(call.message.message_id)
-
-            await call.bot.delete_message(chat_id=GROUP_FOR_POST, message_id=call.message.message_id)
-            logger.info(f'Пост с видео опубликован в канале {MAIN_PUBLIC}.')
-            await call.answer(text='Выложено!', cache_time=3)
-
-            await send_text_message(author_id, call.message, 'Твой пост был выложен🥰')
-        except Exception as e:
-            if e.message != 'Forbidden: bot was blocked by the user':
-                await call.bot.send_message(chat_id=IMPORTANT_LOGS,
-                                            text=f"Произошла ошибка: {str(e)}\n\nTraceback:\n{traceback.format_exc()}")
-                logger.error(f'Ошибка при публикации видео в канал {MAIN_PUBLIC}: {str(e)}')
-                await call.answer(text='Что-то пошло не так!', show_alert=True, cache_time=3)
-    elif call.message.content_type == 'video_note':
-        try:
-            await send_video_note_message(MAIN_PUBLIC, call.message, call.message.video_note.file_id)
-
-            # Получаем из базы автора + отправляем сообщение + удаляем сообщение из предложки
-            author_id = BotDB.get_author_id_by_message_id(call.message.message_id)
-
-            await call.bot.delete_message(chat_id=GROUP_FOR_POST, message_id=call.message.message_id)
-            logger.info(f'Пост с кружком опубликован в канале {MAIN_PUBLIC}.')
-            await call.answer(text='Выложено!', cache_time=3)
-            await send_text_message(author_id, call.message, 'Твой пост был выложен🥰')
-        except Exception as e:
-            if e.message != 'Forbidden: bot was blocked by the user':
-                await call.bot.send_message(chat_id=IMPORTANT_LOGS,
-                                            text=f"Произошла ошибка: {str(e)}\n\nTraceback:\n{traceback.format_exc()}")
-                logger.error(f'Ошибка при публикации кружка в канал {MAIN_PUBLIC}: {str(e)}')
-                await call.answer(text='Что-то пошло не так!', show_alert=True, cache_time=3)
-    elif call.message.content_type == 'audio':
-        try:
-            await send_audio_message(MAIN_PUBLIC, call.message, call.message.audio.file_id, text_post_with_photo)
-
-            # Получаем из базы автора + отправляем сообщение + удаляем сообщение из предложки
-            author_id = BotDB.get_author_id_by_message_id(call.message.message_id)
-
-            await call.bot.delete_message(chat_id=GROUP_FOR_POST, message_id=call.message.message_id)
-            logger.info(f'Пост с аудио опубликован в канале {MAIN_PUBLIC}.')
-            await call.answer(text='Выложено!', cache_time=3)
-            await send_text_message(author_id, call.message, 'Твой пост был выложен🥰')
-        except Exception as e:
-            if e.message != 'Forbidden: bot was blocked by the user':
-                await call.bot.send_message(chat_id=IMPORTANT_LOGS,
-                                            text=f"Произошла ошибка: {str(e)}\n\nTraceback:\n{traceback.format_exc()}")
-                logger.error(f'Ошибка при публикации аудио в канал {MAIN_PUBLIC}: {str(e)}')
-                await call.answer(text='Что-то пошло не так!', show_alert=True, cache_time=3)
-    elif call.message.content_type == 'voice':
-        try:
-            await send_voice_message(MAIN_PUBLIC, call.message, call.message.voice.file_id)
-
-            # Получаем из базы автора + отправляем сообщение + удаляем сообщение из предложки
-            author_id = BotDB.get_author_id_by_message_id(call.message.message_id)
-
-            await call.bot.delete_message(chat_id=GROUP_FOR_POST, message_id=call.message.message_id)
-            logger.info(f'Пост с войсом опубликован в канале {MAIN_PUBLIC}.')
-            await call.answer(text='Выложено!', cache_time=3)
-            await send_text_message(author_id, call.message, 'Твой пост был выложен🥰')
-        except Exception as e:
-            if e.message != 'Forbidden: bot was blocked by the user':
-                await call.bot.send_message(chat_id=IMPORTANT_LOGS,
-                                            text=f"Произошла ошибка: {str(e)}\n\nTraceback:\n{traceback.format_exc()}")
-                logger.error(f'Ошибка при публикации войса в канал {MAIN_PUBLIC}: {str(e)}')
-                await call.answer(text='Что-то пошло не так!', show_alert=True, cache_time=3)
-    elif call.message.text == "^":
-        # Получаем контент медиагруппы и текст для публикации
-        post_content = BotDB.get_post_content_from_telegram_by_last_id(call.message.message_id)
-        pre_text = BotDB.get_post_text_from_telegram_by_last_id(call.message.message_id)
-        post_text = html.escape(str(pre_text))
-
-        # Готовим список для удаления
-        post_ids = BotDB.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 send_media_group_to_channel(bot=call.bot, chat_id=MAIN_PUBLIC, post_content=post_content,
-                                          post_text=post_text)
-
-        # Получаем из базы автора + отправляем сообщение + удаляем сообщение из предложки
-        author_id = BotDB.get_author_id_by_helper_message_id(call.message.message_id)
-
-        # TODO: Удалить фотки с локалки после выкладки?
-        await call.bot.delete_messages(chat_id=GROUP_FOR_POST, message_ids=message_ids)
-        await call.answer(text='Выложено!', cache_time=3)
-
-        await send_text_message(author_id, call.message, 'Твой пост был выложен🥰')
+    
+    try:
+        await publish_service.publish_post(call)
+        await call.answer(text=MESSAGE_PUBLISHED, cache_time=3)
+    except UserBlockedBotError:
+        await call.answer(text=MESSAGE_ERROR, show_alert=True, cache_time=3)
+    except (PostNotFoundError, PublishError) as e:
+        logger.error(f'Ошибка при публикации поста: {str(e)}')
+        await call.answer(text=MESSAGE_ERROR, show_alert=True, cache_time=3)
+    except Exception as e:
+        if str(e) == ERROR_BOT_BLOCKED:
+            await call.answer(text=MESSAGE_ERROR, show_alert=True, cache_time=3)
+        else:
+            important_logs = settings['Telegram']['important_logs']
+            await call.bot.send_message(
+                chat_id=important_logs,
+                text=f"Произошла ошибка: {str(e)}\n\nTraceback:\n{traceback.format_exc()}"
+            )
+            logger.error(f'Неожиданная ошибка при публикации поста: {str(e)}')
+            await call.answer(text=MESSAGE_ERROR, show_alert=True, cache_time=3)
 
 
-@callback_router.callback_query(
-    F.data == "decline"
-)
-async def decline_post_for_group(call: CallbackQuery, state: FSMContext):
+@callback_router.callback_query(F.data == CALLBACK_DECLINE)
+async def decline_post_for_group(
+    call: CallbackQuery,
+    settings: MagicData("settings")
+    ):
+    publish_service = get_post_publish_service()
+    # TODO: переделать на MagicData
     logger.info(
         f'Получен callback-запрос с данными: {call.data} от пользователя {call.from_user.full_name} (ID: {call.from_user.id})')
     try:
-        if call.message.content_type == 'text' and call.message.text != "^" or call.message.content_type == 'photo' \
-                or call.message.content_type == 'audio' or call.message.content_type == 'voice' \
-                or call.message.content_type == 'video' or call.message.content_type == 'video_note':
-            await call.bot.delete_message(chat_id=GROUP_FOR_POST, message_id=call.message.message_id)
-
-            # Получаем из базы автора + отправляем сообщение + удаляем сообщение из предложки
-            author_id = BotDB.get_author_id_by_message_id(call.message.message_id)
-
-            logger.info(
-                f'Сообщение отклонено админом {call.from_user.full_name} (ID: {call.from_user.id}).')
-            await call.answer(text='Отклонено!', cache_time=3)
-            await send_text_message(author_id, call.message, 'Твой пост был отклонен😔')
-        if call.message.text == '^':
-            post_ids = BotDB.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 call.bot.delete_messages(chat_id=GROUP_FOR_POST, message_ids=message_ids)
-
-            # Получаем из базы автора + отправляем сообщение + удаляем сообщение из предложки
-            author_id = BotDB.get_author_id_by_helper_message_id(call.message.message_id)
-
-            await call.answer(text='Удалено!', cache_time=3)
-
-            await send_text_message(author_id, call.message, 'Твой пост был отклонен😔')
+        await publish_service.decline_post(call)
+        await call.answer(text=MESSAGE_DECLINED, cache_time=3)
+    except UserBlockedBotError:
+        await call.answer(text=MESSAGE_ERROR, show_alert=True, cache_time=3)
+    except (PostNotFoundError, PublishError) as e:
+        logger.error(f'Ошибка при отклонении поста: {str(e)}')
+        await call.answer(text=MESSAGE_ERROR, show_alert=True, cache_time=3)
     except Exception as e:
-        if e.message != 'Forbidden: bot was blocked by the user':
-            await call.bot.send_message(IMPORTANT_LOGS,
-                                        f"Произошла ошибка: {str(e)}\n\nTraceback:\n{traceback.format_exc()}")
-            logger.error(f'Ошибка при удалении сообщения в группе {GROUP_FOR_POST}: {str(e)}')
-            await call.answer(text='Что-то пошло не так!', show_alert=True, cache_time=3)
+        if str(e) == ERROR_BOT_BLOCKED:
+            await call.answer(text=MESSAGE_ERROR, show_alert=True, cache_time=3)
+        else:
+            important_logs = settings['Telegram']['important_logs']
+            await call.bot.send_message(
+                chat_id=important_logs,
+                text=f"Произошла ошибка: {str(e)}\n\nTraceback:\n{traceback.format_exc()}"
+            )
+            logger.error(f'Неожиданная ошибка при отклонении поста: {str(e)}')
+            await call.answer(text=MESSAGE_ERROR, show_alert=True, cache_time=3)
 
 
-@callback_router.callback_query(
-    F.data == "ban"
-)
+@callback_router.callback_query(F.data == CALLBACK_BAN)
 async def ban_user_from_post(call: CallbackQuery):
+    ban_service = get_ban_service()
+    # TODO: переделать на MagicData
     try:
-        # Получаем информацию о пользователе из сообщения
-        author_id = BotDB.get_author_id_by_message_id(call.message.message_id)
-        user_name = BotDB.get_username(user_id=author_id)
-        full_name = call.message.from_user.full_name if call.message.from_user else "Неизвестно"
-        
-        # Устанавливаем причину бана и дату разблокировки (+7 дней)
-        current_date = datetime.now()
-        date_to_unban = current_date + timedelta(days=7)
-        
-        # Записываем в базу данных
-        BotDB.set_user_blacklist(
-            user_id=author_id,
-            user_name=user_name,
-            message_for_user="Спам",
-            date_to_unban=date_to_unban
-        )
-        
-        # Удаляем пост из предложки
-        await call.bot.delete_message(chat_id=GROUP_FOR_POST, message_id=call.message.message_id)
-        
-        # Отправляем сообщение пользователю о блокировке
-        date_str = date_to_unban.strftime("%d.%m.%Y %H:%M")
-        await send_text_message(author_id, call.message, f"Ты заблокирован за спам. Дата разблокировки: {date_str}")
-        
-        logger.info(f"Пользователь {author_id} заблокирован за спам до {date_str}")
-        await call.answer(text='Пользователь заблокирован!', cache_time=3)
-        
-    except Exception as e:
+        await ban_service.ban_user_from_post(call)
+        await call.answer(text=MESSAGE_USER_BANNED, cache_time=3)
+    except UserBlockedBotError:
+        await call.answer(text=MESSAGE_ERROR, show_alert=True, cache_time=3)
+    except (UserNotFoundError, BanError) as e:
         logger.error(f'Ошибка при блокировке пользователя: {str(e)}')
-        await call.answer(text='Ошибка при блокировке!', show_alert=True, cache_time=3)
+        await call.answer(text=MESSAGE_ERROR, show_alert=True, cache_time=3)
+    except Exception as e:
+        if str(e) == ERROR_BOT_BLOCKED:
+            await call.answer(text=MESSAGE_ERROR, show_alert=True, cache_time=3)
+        else:
+            logger.error(f'Неожиданная ошибка при блокировке пользователя: {str(e)}')
+            await call.answer(text=MESSAGE_ERROR, show_alert=True, cache_time=3)
 
 
-@callback_router.callback_query(
-    F.data.contains('ban')
-)
+@callback_router.callback_query(F.data.contains(CALLBACK_BAN))
 async def process_ban_user(call: CallbackQuery, state: FSMContext):
+    ban_service = get_ban_service()
+    # TODO: переделать на MagicData
     user_id = call.data[4:]
-    logger.info(
-        f"Вызов функции process_ban_user. Данные callback: {call.data} пользователь: {user_id}")
-    user_name = BotDB.get_username(user_id=user_id)
-    if user_name:
-        await state.update_data(user_id=user_id, user_name=user_name, message_for_user=None,
-                                date_to_unban=None)
+    logger.info(f"Вызов функции process_ban_user. Данные callback: {call.data} пользователь: {user_id}")
+    
+    try:
+        user_name = await ban_service.ban_user(user_id, "")
+        await state.update_data(user_id=user_id, user_name=user_name, message_for_user=None, date_to_unban=None)
         markup = create_keyboard_for_ban_reason()
-        # Экранируем потенциально проблемные символы
+        
         user_name_escaped = html.escape(str(user_name))
         full_name_escaped = html.escape(str(call.message.from_user.full_name))
         await call.message.answer(
             text=f"<b>Выбран пользователь:\nid:</b> {user_id}\n<b>username:</b> {user_name_escaped}\nИмя:{full_name_escaped}\nВыбери причину бана из списка или напиши ее в чат",
-            reply_markup=markup)
+            reply_markup=markup
+        )
         await state.set_state('BAN_2')
-    else:
+    except UserNotFoundError:
         markup = get_reply_keyboard_admin()
         await call.message.answer(text='Пользователь с таким ID не найден в базе', reply_markup=markup)
         await state.set_state('ADMIN')
 
 
-@callback_router.callback_query(
-    F.data.contains('unlock')
-)
+@callback_router.callback_query(F.data.contains(CALLBACK_UNLOCK))
 async def process_unlock_user(call: CallbackQuery):
+    ban_service = get_ban_service()
+    # TODO: переделать на MagicData
     user_id = call.data[7:]
-    user_name = BotDB.get_username(user_id=user_id)
-    delete_user_blacklist(user_id, BotDB)
-    logger.info(f"Разблокирован пользователь с ID: {user_id} username:{user_name}")
-    username = BotDB.get_username(user_id)
-    await call.answer(f'Пользователь разблокирован {username}', show_alert=True)
+    
+    try:
+        username = await ban_service.unlock_user(user_id)
+        await call.answer(f'{MESSAGE_USER_UNLOCKED} {username}', show_alert=True)
+    except UserNotFoundError:
+        await call.answer(text='Пользователь не найден в базе', show_alert=True, cache_time=3)
+    except Exception as e:
+        logger.error(f'Ошибка при разблокировке пользователя: {str(e)}')
+        await call.answer(text=MESSAGE_ERROR, show_alert=True, cache_time=3)
 
 
-@callback_router.callback_query(
-    F.data == 'return'
-)
+@callback_router.callback_query(F.data == CALLBACK_RETURN)
 async def return_to_main_menu(call: CallbackQuery):
     await call.message.delete()
     logger.info(f"Запуск админ панели для пользователя: {call.message.from_user.id}")
     markup = get_reply_keyboard_admin()
-    await call.message.answer("Добро пожаловать в админку. Выбери что хочешь:",
-                              reply_markup=markup)
+    await call.message.answer("Добро пожаловать в админку. Выбери что хочешь:", reply_markup=markup)
 
 
-@callback_router.callback_query(
-    F.data.contains('page')
-)
-async def change_page(call: CallbackQuery):
+@callback_router.callback_query(F.data.contains(CALLBACK_PAGE))
+async def change_page(
+    call: CallbackQuery,
+    bot_db: MagicData("bot_db")
+    ):
     page_number = int(call.data[5:])
     logger.info(f"Переход на страницу {page_number}")
+    
     if call.message.text == 'Список пользователей которые последними обращались к боту':
-        list_users = BotDB.get_last_users_from_db()
-        # TODO: Здесь где-то надо добавить обработку ошибки IndexError: list index out of range
-        keyboard = create_keyboard_with_pagination(int(page_number), len(list_users), list_users,
-                                                   'ban')
-
-        await call.bot.edit_message_reply_markup(chat_id=call.message.chat.id, message_id=call.message.message_id,
-                                                 reply_markup=keyboard)
+        list_users = bot_db.get_last_users_from_db()
+        keyboard = create_keyboard_with_pagination(int(page_number), len(list_users), list_users, 'ban')
+        await call.bot.edit_message_reply_markup(
+            chat_id=call.message.chat.id, 
+            message_id=call.message.message_id,
+            reply_markup=keyboard
+        )
     else:
-        # Готовим сообщения
-        message_user = get_banned_users_list(int(page_number) * 7 - 7, BotDB)
-        await call.bot.edit_message_text(chat_id=call.message.chat.id, message_id=call.message.message_id,
-                                         text=message_user)
-
-        # Готовим клавиатуру
-        buttons = get_banned_users_buttons(BotDB)
+        message_user = get_banned_users_list(int(page_number) * 7 - 7, bot_db)
+        await call.bot.edit_message_text(
+            chat_id=call.message.chat.id, 
+            message_id=call.message.message_id,
+            text=message_user
+        )
+        
+        buttons = get_banned_users_buttons(bot_db)
         keyboard = create_keyboard_with_pagination(int(call.data[5:]), len(buttons), buttons, 'unlock')
-        await call.bot.edit_message_reply_markup(chat_id=call.message.chat.id, message_id=call.message.message_id,
-                                                 reply_markup=keyboard)
+        await call.bot.edit_message_reply_markup(
+            chat_id=call.message.chat.id, 
+            message_id=call.message.message_id,
+            reply_markup=keyboard
+        )

helper_bot/handlers/callback/constants.py

@@ -0,0 +1,29 @@
+# Callback data constants
+CALLBACK_PUBLISH = "publish"
+CALLBACK_DECLINE = "decline"
+CALLBACK_BAN = "ban"
+CALLBACK_UNLOCK = "unlock"
+CALLBACK_RETURN = "return"
+CALLBACK_PAGE = "page"
+
+# Content types
+CONTENT_TYPE_TEXT = "text"
+CONTENT_TYPE_PHOTO = "photo"
+CONTENT_TYPE_VIDEO = "video"
+CONTENT_TYPE_VIDEO_NOTE = "video_note"
+CONTENT_TYPE_AUDIO = "audio"
+CONTENT_TYPE_VOICE = "voice"
+CONTENT_TYPE_MEDIA_GROUP = "^"
+
+# Messages
+MESSAGE_PUBLISHED = "Выложено!"
+MESSAGE_DECLINED = "Отклонено!"
+MESSAGE_USER_BANNED = "Пользователь заблокирован!"
+MESSAGE_USER_UNLOCKED = "Пользователь разблокирован"
+MESSAGE_ERROR = "Что-то пошло не так!"
+MESSAGE_POST_PUBLISHED = "Твой пост был выложен🥰"
+MESSAGE_POST_DECLINED = "Твой пост был отклонен😔"
+MESSAGE_USER_BANNED_SPAM = "Ты заблокирован за спам. Дата разблокировки: {date}"
+
+# Error messages
+ERROR_BOT_BLOCKED = "Forbidden: bot was blocked by the user"

helper_bot/handlers/callback/dependency_factory.py

@@ -0,0 +1,33 @@
+from typing import Callable
+from aiogram import Bot
+from aiogram.client.default import DefaultBotProperties
+from aiogram.fsm.context import FSMContext
+
+from helper_bot.utils.base_dependency_factory import get_global_instance
+from .services import PostPublishService, BanService
+
+
+def get_post_publish_service() -> PostPublishService:
+    """Фабрика для PostPublishService"""
+    bdf = get_global_instance()
+    bot = Bot(
+        token=bdf.settings['Telegram']['bot_token'],
+        default=DefaultBotProperties(parse_mode='HTML'),
+        timeout=30.0
+    )
+    db = bdf.get_db()
+    settings = bdf.settings
+    return PostPublishService(bot, db, settings)
+
+
+def get_ban_service() -> BanService:
+    """Фабрика для BanService"""
+    bdf = get_global_instance()
+    bot = Bot(
+        token=bdf.settings['Telegram']['bot_token'],
+        default=DefaultBotProperties(parse_mode='HTML'),
+        timeout=30.0
+    )
+    db = bdf.get_db()
+    settings = bdf.settings
+    return BanService(bot, db, settings)

helper_bot/handlers/callback/exceptions.py

@@ -0,0 +1,23 @@
+class UserBlockedBotError(Exception):
+    """Исключение, возникающее когда пользователь заблокировал бота"""
+    pass
+
+
+class PostNotFoundError(Exception):
+    """Исключение, возникающее когда пост не найден в базе данных"""
+    pass
+
+
+class UserNotFoundError(Exception):
+    """Исключение, возникающее когда пользователь не найден в базе данных"""
+    pass
+
+
+class PublishError(Exception):
+    """Общее исключение для ошибок публикации"""
+    pass
+
+
+class BanError(Exception):
+    """Исключение для ошибок бана/разбана пользователей"""
+    pass

helper_bot/handlers/callback/services.py

@@ -0,0 +1,249 @@
+import html
+from datetime import datetime, timedelta
+from typing import Dict, Any
+
+from aiogram import Bot
+from aiogram.types import CallbackQuery
+
+from helper_bot.utils.helper_func import (
+    send_text_message, send_photo_message, send_video_message, 
+    send_video_note_message, send_audio_message, send_voice_message,
+    send_media_group_to_channel, delete_user_blacklist
+)
+from helper_bot.keyboards.keyboards import create_keyboard_for_ban_reason
+from .exceptions import (
+    UserBlockedBotError, PostNotFoundError, UserNotFoundError, 
+    PublishError, BanError
+)
+from .constants import (
+    CONTENT_TYPE_TEXT, CONTENT_TYPE_PHOTO, CONTENT_TYPE_VIDEO,
+    CONTENT_TYPE_VIDEO_NOTE, CONTENT_TYPE_AUDIO, CONTENT_TYPE_VOICE,
+    CONTENT_TYPE_MEDIA_GROUP, MESSAGE_POST_PUBLISHED, MESSAGE_POST_DECLINED,
+    MESSAGE_USER_BANNED_SPAM, ERROR_BOT_BLOCKED
+)
+from logs.custom_logger import logger
+
+
+class PostPublishService:
+    def __init__(self, bot: Bot, db, settings: Dict[str, Any]):
+        self.bot = bot
+        self.db = db
+        self.settings = settings
+        self.group_for_posts = settings['Telegram']['group_for_posts']
+        self.main_public = settings['Telegram']['main_public']
+        self.important_logs = settings['Telegram']['important_logs']
+
+    async def publish_post(self, call: CallbackQuery) -> None:
+        """Основной метод публикации поста"""
+        content_type = call.message.content_type
+        
+        if content_type == CONTENT_TYPE_TEXT and call.message.text != CONTENT_TYPE_MEDIA_GROUP:
+            await self._publish_text_post(call)
+        elif content_type == CONTENT_TYPE_PHOTO:
+            await self._publish_photo_post(call)
+        elif content_type == CONTENT_TYPE_VIDEO:
+            await self._publish_video_post(call)
+        elif content_type == CONTENT_TYPE_VIDEO_NOTE:
+            await self._publish_video_note_post(call)
+        elif content_type == CONTENT_TYPE_AUDIO:
+            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}")
+
+    async def _publish_text_post(self, call: CallbackQuery) -> None:
+        """Публикация текстового поста"""
+        text_post = html.escape(str(call.message.text))
+        author_id = self._get_author_id(call.message.message_id)
+        
+        await send_text_message(self.main_public, call.message, text_post)
+        await self._delete_post_and_notify_author(call, author_id)
+        logger.info(f'Текст сообщения опубликован в канале {self.main_public}.')
+
+    async def _publish_photo_post(self, call: CallbackQuery) -> None:
+        """Публикация поста с фото"""
+        text_post_with_photo = html.escape(str(call.message.caption))
+        author_id = self._get_author_id(call.message.message_id)
+        
+        await send_photo_message(self.main_public, call.message, call.message.photo[-1].file_id, text_post_with_photo)
+        await self._delete_post_and_notify_author(call, author_id)
+        logger.info(f'Пост с фото опубликован в канале {self.main_public}.')
+
+    async def _publish_video_post(self, call: CallbackQuery) -> None:
+        """Публикация поста с видео"""
+        text_post_with_photo = html.escape(str(call.message.caption))
+        author_id = self._get_author_id(call.message.message_id)
+        
+        await send_video_message(self.main_public, call.message, call.message.video.file_id, text_post_with_photo)
+        await self._delete_post_and_notify_author(call, author_id)
+        logger.info(f'Пост с видео опубликован в канале {self.main_public}.')
+
+    async def _publish_video_note_post(self, call: CallbackQuery) -> None:
+        """Публикация поста с кружком"""
+        author_id = self._get_author_id(call.message.message_id)
+        
+        await send_video_note_message(self.main_public, call.message, call.message.video_note.file_id)
+        await self._delete_post_and_notify_author(call, author_id)
+        logger.info(f'Пост с кружком опубликован в канале {self.main_public}.')
+
+    async def _publish_audio_post(self, call: CallbackQuery) -> None:
+        """Публикация поста с аудио"""
+        text_post_with_photo = html.escape(str(call.message.caption))
+        author_id = self._get_author_id(call.message.message_id)
+        
+        await send_audio_message(self.main_public, call.message, call.message.audio.file_id, text_post_with_photo)
+        await self._delete_post_and_notify_author(call, author_id)
+        logger.info(f'Пост с аудио опубликован в канале {self.main_public}.')
+
+    async def _publish_voice_post(self, call: CallbackQuery) -> None:
+        """Публикация поста с войсом"""
+        author_id = self._get_author_id(call.message.message_id)
+        
+        await send_voice_message(self.main_public, call.message, call.message.voice.file_id)
+        await self._delete_post_and_notify_author(call, author_id)
+        logger.info(f'Пост с войсом опубликован в канале {self.main_public}.')
+
+    async def _publish_media_group(self, call: CallbackQuery) -> None:
+        """Публикация медиагруппы"""
+        post_content = self.db.get_post_content_from_telegram_by_last_id(call.message.message_id)
+        pre_text = self.db.get_post_text_from_telegram_by_last_id(call.message.message_id)
+        post_text = html.escape(str(pre_text))
+        author_id = self._get_author_id_for_media_group(call.message.message_id)
+        
+        await send_media_group_to_channel(bot=self.bot, chat_id=self.main_public, post_content=post_content, post_text=post_text)
+        await self._delete_media_group_and_notify_author(call, author_id)
+
+    async def decline_post(self, call: CallbackQuery) -> None:
+        """Отклонение поста"""
+        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]:
+            await self._decline_single_post(call)
+        elif call.message.text == CONTENT_TYPE_MEDIA_GROUP:
+            await self._decline_media_group(call)
+        else:
+            raise PublishError(f"Неподдерживаемый тип контента для отклонения: {content_type}")
+
+    async def _decline_single_post(self, call: CallbackQuery) -> None:
+        """Отклонение одиночного поста"""
+        author_id = self._get_author_id(call.message.message_id)
+        await self.bot.delete_message(chat_id=self.group_for_posts, message_id=call.message.message_id)
+        try:
+            await send_text_message(author_id, call.message, MESSAGE_POST_DECLINED)
+        except Exception as e:
+            if str(e) == ERROR_BOT_BLOCKED:
+                raise UserBlockedBotError("Пользователь заблокировал бота")
+            raise
+        logger.info(f'Сообщение отклонено админом {call.from_user.full_name} (ID: {call.from_user.id}).')
+
+    async def _decline_media_group(self, call: CallbackQuery) -> None:
+        """Отклонение медиагруппы"""
+        post_ids = 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)
+        
+        author_id = self._get_author_id_for_media_group(call.message.message_id)
+        await self.bot.delete_messages(chat_id=self.group_for_posts, message_ids=message_ids)
+        try:
+            await send_text_message(author_id, call.message, MESSAGE_POST_DECLINED)
+        except Exception as e:
+            if str(e) == ERROR_BOT_BLOCKED:
+                raise UserBlockedBotError("Пользователь заблокировал бота")
+            raise
+
+    def _get_author_id(self, message_id: int) -> int:
+        """Получение ID автора по ID сообщения"""
+        author_id = self.db.get_author_id_by_message_id(message_id)
+        if not author_id:
+            raise PostNotFoundError(f"Автор не найден для сообщения {message_id}")
+        return author_id
+
+    def _get_author_id_for_media_group(self, message_id: int) -> int:
+        """Получение ID автора для медиагруппы"""
+        author_id = self.db.get_author_id_by_helper_message_id(message_id)
+        if not author_id:
+            raise PostNotFoundError(f"Автор не найден для медиагруппы {message_id}")
+        return author_id
+
+    async def _delete_post_and_notify_author(self, call: CallbackQuery, author_id: int) -> None:
+        """Удаление поста и уведомление автора"""
+        await self.bot.delete_message(chat_id=self.group_for_posts, message_id=call.message.message_id)
+        try:
+            await send_text_message(author_id, call.message, MESSAGE_POST_PUBLISHED)
+        except Exception as e:
+            if str(e) == ERROR_BOT_BLOCKED:
+                raise UserBlockedBotError("Пользователь заблокировал бота")
+            raise
+
+    async def _delete_media_group_and_notify_author(self, call: CallbackQuery, author_id: int) -> None:
+        """Удаление медиагруппы и уведомление автора"""
+        post_ids = 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.bot.delete_messages(chat_id=self.group_for_posts, message_ids=message_ids)
+        try:
+            await send_text_message(author_id, call.message, MESSAGE_POST_PUBLISHED)
+        except Exception as e:
+            if str(e) == ERROR_BOT_BLOCKED:
+                raise UserBlockedBotError("Пользователь заблокировал бота")
+            raise
+
+
+class BanService:
+    def __init__(self, bot: Bot, db, settings: Dict[str, Any]):
+        self.bot = bot
+        self.db = db
+        self.settings = settings
+        self.group_for_posts = settings['Telegram']['group_for_posts']
+        self.important_logs = settings['Telegram']['important_logs']
+
+    async def ban_user_from_post(self, call: CallbackQuery) -> None:
+        """Бан пользователя за спам"""
+        author_id = self.db.get_author_id_by_message_id(call.message.message_id)
+        if not author_id:
+            raise UserNotFoundError(f"Автор не найден для сообщения {call.message.message_id}")
+        
+        user_name = self.db.get_username(user_id=author_id)
+        current_date = datetime.now()
+        date_to_unban = current_date + timedelta(days=7)
+        
+        self.db.set_user_blacklist(
+            user_id=author_id,
+            user_name=user_name,
+            message_for_user="Спам",
+            date_to_unban=date_to_unban
+        )
+        
+        await self.bot.delete_message(chat_id=self.group_for_posts, message_id=call.message.message_id)
+        
+        date_str = date_to_unban.strftime("%d.%m.%Y %H:%M")
+        try:
+            await send_text_message(author_id, call.message, MESSAGE_USER_BANNED_SPAM.format(date=date_str))
+        except Exception as e:
+            if str(e) == ERROR_BOT_BLOCKED:
+                raise UserBlockedBotError("Пользователь заблокировал бота")
+            raise
+        
+        logger.info(f"Пользователь {author_id} заблокирован за спам до {date_str}")
+
+    async def ban_user(self, user_id: str, user_name: str) -> str:
+        """Бан пользователя по ID"""
+        user_name = self.db.get_username(user_id=user_id)
+        if not user_name:
+            raise UserNotFoundError(f"Пользователь с ID {user_id} не найден в базе")
+        
+        return user_name
+
+    async def unlock_user(self, user_id: str) -> str:
+        """Разблокировка пользователя"""
+        user_name = self.db.get_username(user_id=user_id)
+        if not user_name:
+            raise UserNotFoundError(f"Пользователь с ID {user_id} не найден в базе")
+        
+        delete_user_blacklist(user_id, self.db)
+        logger.info(f"Разблокирован пользователь с ID: {user_id} username:{user_name}")
+        return user_name