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.
This commit is contained in:
@@ -1 +1,37 @@
|
||||
from .admin_handlers import admin_router
|
||||
from .admin_handlers import admin_router
|
||||
from .dependencies import AdminAccessMiddleware, BotDB, Settings
|
||||
from .services import AdminService, User, BannedUser
|
||||
from .exceptions import (
|
||||
AdminError,
|
||||
AdminAccessDeniedError,
|
||||
UserNotFoundError,
|
||||
InvalidInputError,
|
||||
UserAlreadyBannedError
|
||||
)
|
||||
from .utils import (
|
||||
return_to_admin_menu,
|
||||
handle_admin_error,
|
||||
format_user_info,
|
||||
format_ban_confirmation,
|
||||
escape_html
|
||||
)
|
||||
|
||||
__all__ = [
|
||||
'admin_router',
|
||||
'AdminAccessMiddleware',
|
||||
'BotDB',
|
||||
'Settings',
|
||||
'AdminService',
|
||||
'User',
|
||||
'BannedUser',
|
||||
'AdminError',
|
||||
'AdminAccessDeniedError',
|
||||
'UserNotFoundError',
|
||||
'InvalidInputError',
|
||||
'UserAlreadyBannedError',
|
||||
'return_to_admin_menu',
|
||||
'handle_admin_error',
|
||||
'format_user_info',
|
||||
'format_ban_confirmation',
|
||||
'escape_html'
|
||||
]
|
||||
@@ -1,52 +1,55 @@
|
||||
import traceback
|
||||
import html
|
||||
|
||||
from aiogram import Router, types, F
|
||||
from aiogram.filters import Command, StateFilter
|
||||
from aiogram.filters import Command, StateFilter, MagicData
|
||||
from aiogram.fsm.context import FSMContext
|
||||
|
||||
from helper_bot.filters.main import ChatTypeFilter
|
||||
from helper_bot.keyboards.keyboards import get_reply_keyboard_admin, create_keyboard_with_pagination, \
|
||||
create_keyboard_for_ban_days, create_keyboard_for_approve_ban, create_keyboard_for_ban_reason
|
||||
from helper_bot.utils.base_dependency_factory import get_global_instance
|
||||
from helper_bot.utils.helper_func import check_access, add_days_to_date, get_banned_users_buttons, get_banned_users_list
|
||||
from helper_bot.keyboards.keyboards import (
|
||||
get_reply_keyboard_admin,
|
||||
create_keyboard_with_pagination,
|
||||
create_keyboard_for_ban_days,
|
||||
create_keyboard_for_approve_ban,
|
||||
create_keyboard_for_ban_reason
|
||||
)
|
||||
from helper_bot.handlers.admin.dependencies import AdminAccessMiddleware
|
||||
from helper_bot.handlers.admin.services import AdminService
|
||||
from helper_bot.handlers.admin.exceptions import (
|
||||
UserAlreadyBannedError,
|
||||
InvalidInputError
|
||||
)
|
||||
from helper_bot.handlers.admin.utils import (
|
||||
return_to_admin_menu,
|
||||
handle_admin_error,
|
||||
format_user_info,
|
||||
format_ban_confirmation,
|
||||
escape_html
|
||||
)
|
||||
from logs.custom_logger import logger
|
||||
|
||||
# Создаем роутер с middleware для проверки доступа
|
||||
admin_router = Router()
|
||||
admin_router.message.middleware(AdminAccessMiddleware())
|
||||
|
||||
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()
|
||||
|
||||
# ============================================================================
|
||||
# ХЕНДЛЕРЫ МЕНЮ
|
||||
# ============================================================================
|
||||
|
||||
@admin_router.message(
|
||||
ChatTypeFilter(chat_type=["private"]),
|
||||
Command('admin')
|
||||
)
|
||||
async def admin_panel(message: types.Message, state: FSMContext):
|
||||
async def admin_panel(
|
||||
message: types.Message,
|
||||
state: FSMContext
|
||||
):
|
||||
"""Главное меню администратора"""
|
||||
try:
|
||||
if check_access(message.from_user.id, BotDB):
|
||||
await state.set_state("ADMIN")
|
||||
logger.info(f"Запуск админ панели для пользователя: {message.from_user.id}")
|
||||
markup = get_reply_keyboard_admin()
|
||||
await message.answer("Добро пожаловать в админку. Выбери что хочешь:",
|
||||
reply_markup=markup)
|
||||
else:
|
||||
await message.answer('Доступ запрещен, досвидания!')
|
||||
await state.set_state("START")
|
||||
await state.set_state("ADMIN")
|
||||
logger.info(f"Запуск админ панели для пользователя: {message.from_user.id}")
|
||||
markup = get_reply_keyboard_admin()
|
||||
await message.answer("Добро пожаловать в админку. Выбери что хочешь:", reply_markup=markup)
|
||||
except Exception as e:
|
||||
logger.error(f"Ошибка при запуске админ панели: {e}")
|
||||
await message.bot.send_message(IMPORTANT_LOGS,
|
||||
f'Ошибка в функции admin_panel {e}. Traceback: {traceback.format_exc()}')
|
||||
await state.set_state("START")
|
||||
await handle_admin_error(message, e, state, "admin_panel")
|
||||
|
||||
|
||||
@admin_router.message(
|
||||
@@ -54,150 +57,30 @@ async def admin_panel(message: types.Message, state: FSMContext):
|
||||
StateFilter("ADMIN"),
|
||||
F.text == 'Бан (Список)'
|
||||
)
|
||||
async def get_last_users(message: types.Message, state: FSMContext):
|
||||
# Дополнительная проверка на админские права
|
||||
if not check_access(message.from_user.id, BotDB):
|
||||
await message.answer('Доступ запрещен!')
|
||||
await state.set_state("START")
|
||||
return
|
||||
logger.info(
|
||||
f"Попытка получения списка последних пользователей. Текст сообщения: {message.text} Имя автора сообщения: {message.from_user.full_name})")
|
||||
list_users = BotDB.get_last_users_from_db()
|
||||
keyboard = create_keyboard_with_pagination(1, len(list_users), list_users, 'ban')
|
||||
await message.answer(text="Список пользователей которые последними обращались к боту",
|
||||
reply_markup=keyboard)
|
||||
|
||||
|
||||
@admin_router.message(
|
||||
ChatTypeFilter(chat_type=["private"]),
|
||||
StateFilter("ADMIN"),
|
||||
F.text == 'Бан по нику'
|
||||
)
|
||||
async def ban_by_nickname(message: types.Message, state: FSMContext):
|
||||
# Дополнительная проверка на админские права
|
||||
if not check_access(message.from_user.id, BotDB):
|
||||
await message.answer('Доступ запрещен!')
|
||||
await state.set_state("START")
|
||||
return
|
||||
await message.answer('Пришли мне username блокируемого пользователя')
|
||||
await state.set_state('PRE_BAN')
|
||||
|
||||
|
||||
@admin_router.message(
|
||||
ChatTypeFilter(chat_type=["private"]),
|
||||
StateFilter("ADMIN"),
|
||||
F.text == 'Бан по ID'
|
||||
)
|
||||
async def ban_by_id(message: types.Message, state: FSMContext):
|
||||
# Дополнительная проверка на админские права
|
||||
if not check_access(message.from_user.id, BotDB):
|
||||
await message.answer('Доступ запрещен!')
|
||||
await state.set_state("START")
|
||||
return
|
||||
await message.answer('Пришли мне ID блокируемого пользователя')
|
||||
await state.set_state('PRE_BAN_ID')
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@admin_router.message(
|
||||
ChatTypeFilter(chat_type=["private"]),
|
||||
StateFilter("PRE_BAN", "PRE_BAN_ID", "BAN_2"),
|
||||
F.text == 'Отменить'
|
||||
)
|
||||
async def decline_ban(message: types.Message, state: FSMContext):
|
||||
# Дополнительная проверка на админские права
|
||||
if not check_access(message.from_user.id, BotDB):
|
||||
await message.answer('Доступ запрещен!')
|
||||
await state.set_state("START")
|
||||
return
|
||||
current_state = await state.get_state()
|
||||
await state.set_data({})
|
||||
await state.set_state("ADMIN")
|
||||
logger.info(f"Отмена процедуры блокировки из состояния: {current_state}")
|
||||
markup = get_reply_keyboard_admin()
|
||||
await message.answer('Вернулись в меню', reply_markup=markup)
|
||||
|
||||
|
||||
@admin_router.message(
|
||||
ChatTypeFilter(chat_type=["private"]),
|
||||
StateFilter("PRE_BAN")
|
||||
)
|
||||
async def ban_by_nickname_step_2(message: types.Message, state: FSMContext):
|
||||
# Дополнительная проверка на админские права
|
||||
if not check_access(message.from_user.id, BotDB):
|
||||
await message.answer('Доступ запрещен!')
|
||||
await state.set_state("START")
|
||||
return
|
||||
logger.info(
|
||||
f"Функция ban_by_nickname_2. Получен никнейм пользователя: {message.text}")
|
||||
user_name = message.text
|
||||
user_id = BotDB.get_user_id_by_username(user_name)
|
||||
await state.update_data(user_id=user_id, user_name=user_name, message_for_user=None,
|
||||
date_to_unban=None)
|
||||
full_name = BotDB.get_full_name_by_id(user_id)
|
||||
markup = create_keyboard_for_ban_reason()
|
||||
# Экранируем потенциально проблемные символы
|
||||
user_name_escaped = html.escape(str(user_name))
|
||||
full_name_escaped = html.escape(str(full_name))
|
||||
await message.answer(
|
||||
text=f"<b>Выбран пользователь:\nid:</b> {user_id}\n<b>username:</b> {user_name_escaped}\n"
|
||||
f"Имя:{full_name_escaped}\nВыбери причину бана из списка или напиши ее в чат",
|
||||
reply_markup=markup)
|
||||
await state.set_state('BAN_2')
|
||||
|
||||
|
||||
@admin_router.message(
|
||||
ChatTypeFilter(chat_type=["private"]),
|
||||
StateFilter("PRE_BAN_ID")
|
||||
)
|
||||
async def ban_by_id_step_2(message: types.Message, state: FSMContext):
|
||||
# Дополнительная проверка на админские права
|
||||
if not check_access(message.from_user.id, BotDB):
|
||||
await message.answer('Доступ запрещен!')
|
||||
await state.set_state("START")
|
||||
return
|
||||
async def get_last_users(
|
||||
message: types.Message,
|
||||
state: FSMContext,
|
||||
bot_db: MagicData("bot_db")
|
||||
):
|
||||
"""Получение списка последних пользователей"""
|
||||
try:
|
||||
user_id = int(message.text)
|
||||
logger.info(f"Функция ban_by_id_step_2. Получен ID пользователя: {user_id}")
|
||||
logger.info(f"Получение списка последних пользователей. Пользователь: {message.from_user.full_name}")
|
||||
admin_service = AdminService(bot_db)
|
||||
users = admin_service.get_last_users()
|
||||
|
||||
# Проверяем, существует ли пользователь в базе
|
||||
user_info = BotDB.get_user_info_by_id(user_id)
|
||||
if not user_info:
|
||||
await message.answer(f"Пользователь с ID {user_id} не найден в базе данных.")
|
||||
await state.set_state('ADMIN')
|
||||
markup = get_reply_keyboard_admin()
|
||||
await message.answer('Вернулись в меню', reply_markup=markup)
|
||||
return
|
||||
# Преобразуем в формат для клавиатуры (кортежи как ожидает create_keyboard_with_pagination)
|
||||
users_data = [
|
||||
(user.full_name, user.username) # (full_name, username) - формат кортежей
|
||||
for user in users
|
||||
]
|
||||
|
||||
user_name = user_info.get('username', 'Неизвестно')
|
||||
full_name = user_info.get('full_name', 'Неизвестно')
|
||||
|
||||
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(full_name))
|
||||
keyboard = create_keyboard_with_pagination(1, len(users_data), users_data, 'ban')
|
||||
await message.answer(
|
||||
text=f"<b>Выбран пользователь:\nid:</b> {user_id}\n<b>username:</b> {user_name_escaped}\n"
|
||||
f"Имя:{full_name_escaped}\nВыбери причину бана из списка или напиши ее в чат",
|
||||
reply_markup=markup)
|
||||
await state.set_state('BAN_2')
|
||||
|
||||
except ValueError:
|
||||
await message.answer("Пожалуйста, введите корректный числовой ID пользователя.")
|
||||
await state.set_state('ADMIN')
|
||||
markup = get_reply_keyboard_admin()
|
||||
await message.answer('Вернулись в меню', reply_markup=markup)
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
text="Список пользователей которые последними обращались к боту",
|
||||
reply_markup=keyboard
|
||||
)
|
||||
except Exception as e:
|
||||
await handle_admin_error(message, e, state, "get_last_users")
|
||||
|
||||
|
||||
@admin_router.message(
|
||||
@@ -205,80 +88,222 @@ async def ban_by_id_step_2(message: types.Message, state: FSMContext):
|
||||
StateFilter("ADMIN"),
|
||||
F.text == 'Разбан (список)'
|
||||
)
|
||||
async def get_banned_users(message):
|
||||
logger.info(
|
||||
f"Попытка получения списка заблокированных пользователей. Текст сообщения: {message.text} Имя автора сообщения: {message.from_user.full_name})")
|
||||
message_text = get_banned_users_list(0, BotDB)
|
||||
buttons_list = get_banned_users_buttons(BotDB)
|
||||
if buttons_list:
|
||||
k = create_keyboard_with_pagination(1, len(buttons_list), buttons_list, 'unlock')
|
||||
await message.answer(text=message_text, reply_markup=k)
|
||||
else:
|
||||
await message.answer(text="В списке забанненых пользователей никого нет")
|
||||
async def get_banned_users(
|
||||
message: types.Message,
|
||||
state: FSMContext,
|
||||
bot_db: MagicData("bot_db")
|
||||
):
|
||||
"""Получение списка заблокированных пользователей"""
|
||||
try:
|
||||
logger.info(f"Получение списка заблокированных пользователей. Пользователь: {message.from_user.full_name}")
|
||||
admin_service = AdminService(bot_db)
|
||||
message_text, buttons_list = admin_service.get_banned_users_for_display(0)
|
||||
|
||||
if buttons_list:
|
||||
keyboard = create_keyboard_with_pagination(1, len(buttons_list), buttons_list, 'unlock')
|
||||
await message.answer(text=message_text, reply_markup=keyboard)
|
||||
else:
|
||||
await message.answer(text="В списке заблокированных пользователей никого нет")
|
||||
except Exception as e:
|
||||
await handle_admin_error(message, e, state, "get_banned_users")
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# ХЕНДЛЕРЫ ПРОЦЕССА БАНА
|
||||
# ============================================================================
|
||||
|
||||
@admin_router.message(
|
||||
ChatTypeFilter(chat_type=["private"]),
|
||||
StateFilter("BAN_2")
|
||||
StateFilter("ADMIN"),
|
||||
F.text.in_(['Бан по нику', 'Бан по ID'])
|
||||
)
|
||||
async def ban_user_step_2(message: types.Message, state: FSMContext):
|
||||
user_data = await state.get_data()
|
||||
logger.info(f"Переход на шаг 2 бана пользователя. Словарь с данными для бана: {user_data})")
|
||||
await state.update_data(message_for_user=message.text)
|
||||
markup = create_keyboard_for_ban_days()
|
||||
# Экранируем message.text для безопасного использования
|
||||
safe_message_text = html.escape(str(message.text)) if message.text else ""
|
||||
await message.answer(f"Выбрана причина: {safe_message_text}. Выбери срок бана в днях или напиши "
|
||||
f"его в чат", reply_markup=markup)
|
||||
await state.set_state("BAN_3")
|
||||
async def start_ban_process(
|
||||
message: types.Message,
|
||||
state: FSMContext,
|
||||
):
|
||||
"""Начало процесса блокировки пользователя"""
|
||||
try:
|
||||
ban_type = "username" if message.text == 'Бан по нику' else "id"
|
||||
await state.update_data(ban_type=ban_type)
|
||||
|
||||
prompt_text = "Пришли мне username блокируемого пользователя" if ban_type == "username" else "Пришли мне ID блокируемого пользователя"
|
||||
await message.answer(prompt_text)
|
||||
await state.set_state('AWAIT_BAN_TARGET')
|
||||
except Exception as e:
|
||||
await handle_admin_error(message, e, state, "start_ban_process")
|
||||
|
||||
|
||||
@admin_router.message(
|
||||
ChatTypeFilter(chat_type=["private"]),
|
||||
StateFilter("BAN_3")
|
||||
StateFilter("AWAIT_BAN_TARGET")
|
||||
)
|
||||
async def ban_user_step_3(message: types.Message, state: FSMContext):
|
||||
logger.info(f"ban_user_step_3. Расчет даты разбана. Входные данные {message.text}")
|
||||
if message.text != 'Навсегда':
|
||||
count_days = int(message.text)
|
||||
date_to_unban = add_days_to_date(count_days)
|
||||
else:
|
||||
date_to_unban = None
|
||||
logger.info(f"ban_user_step_3. Расчет даты разбана. date_to_unban: {date_to_unban}")
|
||||
await state.update_data(date_to_unban=date_to_unban)
|
||||
user_data = await state.get_data()
|
||||
markup = create_keyboard_for_approve_ban()
|
||||
# Экранируем user_data для безопасного использования
|
||||
safe_message_for_user = html.escape(str(user_data['message_for_user'])) if user_data.get('message_for_user') else ""
|
||||
safe_date_to_unban = html.escape(str(user_data['date_to_unban'])) if user_data.get('date_to_unban') else ""
|
||||
await message.answer(
|
||||
f"Необходимо подтверждение:\nПользователь:{user_data['user_id']}\nПричина бана:{safe_message_for_user}\nСрок бана:{safe_date_to_unban}",
|
||||
reply_markup=markup)
|
||||
await state.set_state("BAN_FINAL")
|
||||
async def process_ban_target(
|
||||
message: types.Message,
|
||||
state: FSMContext,
|
||||
bot_db: MagicData("bot_db")
|
||||
):
|
||||
"""Обработка введенного username/ID для блокировки"""
|
||||
try:
|
||||
user_data = await state.get_data()
|
||||
ban_type = user_data.get('ban_type')
|
||||
admin_service = AdminService(bot_db)
|
||||
|
||||
|
||||
# Определяем пользователя
|
||||
if ban_type == "username":
|
||||
user = admin_service.get_user_by_username(message.text)
|
||||
if not user:
|
||||
await message.answer(f"Пользователь с username '{escape_html(message.text)}' не найден.")
|
||||
await return_to_admin_menu(message, state)
|
||||
return
|
||||
else: # ban_type == "id"
|
||||
try:
|
||||
user_id = admin_service.validate_user_input(message.text)
|
||||
user = admin_service.get_user_by_id(user_id)
|
||||
if not user:
|
||||
await message.answer(f"Пользователь с ID {user_id} не найден в базе данных.")
|
||||
await return_to_admin_menu(message, state)
|
||||
return
|
||||
except InvalidInputError as e:
|
||||
await message.answer(str(e))
|
||||
await return_to_admin_menu(message, state)
|
||||
return
|
||||
|
||||
# Сохраняем данные пользователя
|
||||
await state.update_data(
|
||||
target_user_id=user.user_id,
|
||||
target_username=user.username,
|
||||
target_full_name=user.full_name
|
||||
)
|
||||
|
||||
# Показываем информацию о пользователе и запрашиваем причину
|
||||
user_info = format_user_info(user.user_id, user.username, user.full_name)
|
||||
markup = create_keyboard_for_ban_reason()
|
||||
await message.answer(
|
||||
text=f"{user_info}\n\nВыбери причину бана из списка или напиши ее в чат",
|
||||
reply_markup=markup
|
||||
)
|
||||
await state.set_state('AWAIT_BAN_DETAILS')
|
||||
|
||||
except Exception as e:
|
||||
await handle_admin_error(message, e, state, "process_ban_target")
|
||||
|
||||
|
||||
@admin_router.message(
|
||||
ChatTypeFilter(chat_type=["private"]),
|
||||
StateFilter("BAN_FINAL"),
|
||||
StateFilter("AWAIT_BAN_DETAILS")
|
||||
)
|
||||
async def process_ban_reason(
|
||||
message: types.Message,
|
||||
state: FSMContext
|
||||
):
|
||||
"""Обработка причины блокировки"""
|
||||
try:
|
||||
await state.update_data(ban_reason=message.text)
|
||||
markup = create_keyboard_for_ban_days()
|
||||
safe_reason = escape_html(message.text)
|
||||
await message.answer(
|
||||
f"Выбрана причина: {safe_reason}. Выбери срок бана в днях или напиши его в чат",
|
||||
reply_markup=markup
|
||||
)
|
||||
await state.set_state('AWAIT_BAN_DURATION')
|
||||
except Exception as e:
|
||||
await handle_admin_error(message, e, state, "process_ban_reason")
|
||||
|
||||
|
||||
@admin_router.message(
|
||||
ChatTypeFilter(chat_type=["private"]),
|
||||
StateFilter("AWAIT_BAN_DURATION")
|
||||
)
|
||||
async def process_ban_duration(
|
||||
message: types.Message,
|
||||
state: FSMContext,
|
||||
):
|
||||
"""Обработка срока блокировки"""
|
||||
try:
|
||||
user_data = await state.get_data()
|
||||
|
||||
# Определяем срок блокировки
|
||||
if message.text == 'Навсегда':
|
||||
ban_days = None
|
||||
else:
|
||||
try:
|
||||
ban_days = int(message.text)
|
||||
if ban_days <= 0:
|
||||
await message.answer("Срок блокировки должен быть положительным числом.")
|
||||
return
|
||||
except ValueError:
|
||||
await message.answer("Пожалуйста, введите корректное число дней или выберите 'Навсегда'.")
|
||||
return
|
||||
|
||||
await state.update_data(ban_days=ban_days)
|
||||
|
||||
# Показываем подтверждение
|
||||
confirmation_text = format_ban_confirmation(
|
||||
user_data['target_user_id'],
|
||||
user_data['ban_reason'],
|
||||
ban_days
|
||||
)
|
||||
markup = create_keyboard_for_approve_ban()
|
||||
await message.answer(confirmation_text, reply_markup=markup)
|
||||
await state.set_state('BAN_CONFIRMATION')
|
||||
|
||||
except Exception as e:
|
||||
await handle_admin_error(message, e, state, "process_ban_duration")
|
||||
|
||||
|
||||
@admin_router.message(
|
||||
ChatTypeFilter(chat_type=["private"]),
|
||||
StateFilter("BAN_CONFIRMATION"),
|
||||
F.text == 'Подтвердить'
|
||||
)
|
||||
async def approve_ban(message: types.Message, state: FSMContext):
|
||||
user_data = await state.get_data()
|
||||
logger.info(f"Переход на финальный шаг бана пользователя. Словарь с данными для бана: {user_data})")
|
||||
exists = BotDB.check_user_in_blacklist(user_data['user_id'])
|
||||
if exists:
|
||||
await message.reply(f"Пользователь уже был заблокирован ранее.")
|
||||
logger.info(f"Пользователь: {user_data['user_id']} был заблокирован ранее)")
|
||||
await state.set_state('ADMIN')
|
||||
else:
|
||||
BotDB.set_user_blacklist(user_data['user_id'],
|
||||
user_data['user_name'],
|
||||
user_data['message_for_user'],
|
||||
user_data['date_to_unban'])
|
||||
# Экранируем user_name для безопасного использования
|
||||
safe_user_name = html.escape(str(user_data['user_name'])) if user_data.get('user_name') else "Неизвестный пользователь"
|
||||
await message.reply(f"Пользователь {safe_user_name} успешно заблокирован.")
|
||||
logger.info(f"Пользователь: {user_data['user_id']} успешно заблокирован)")
|
||||
await state.set_state('ADMIN')
|
||||
markup = get_reply_keyboard_admin()
|
||||
await message.answer('Вернулись в меню', reply_markup=markup)
|
||||
async def confirm_ban(
|
||||
message: types.Message,
|
||||
state: FSMContext,
|
||||
bot_db: MagicData("bot_db")
|
||||
):
|
||||
"""Подтверждение блокировки пользователя"""
|
||||
try:
|
||||
user_data = await state.get_data()
|
||||
admin_service = AdminService(bot_db)
|
||||
|
||||
|
||||
# Выполняем блокировку
|
||||
admin_service.ban_user(
|
||||
user_id=user_data['target_user_id'],
|
||||
username=user_data['target_username'],
|
||||
reason=user_data['ban_reason'],
|
||||
ban_days=user_data['ban_days']
|
||||
)
|
||||
|
||||
safe_username = escape_html(user_data['target_username'])
|
||||
await message.reply(f"Пользователь {safe_username} успешно заблокирован.")
|
||||
await return_to_admin_menu(message, state)
|
||||
|
||||
except UserAlreadyBannedError as e:
|
||||
await message.reply(str(e))
|
||||
await return_to_admin_menu(message, state)
|
||||
except Exception as e:
|
||||
await handle_admin_error(message, e, state, "confirm_ban")
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# ХЕНДЛЕРЫ ОТМЕНЫ И НАВИГАЦИИ
|
||||
# ============================================================================
|
||||
|
||||
@admin_router.message(
|
||||
ChatTypeFilter(chat_type=["private"]),
|
||||
StateFilter("AWAIT_BAN_TARGET", "AWAIT_BAN_DETAILS", "AWAIT_BAN_DURATION", "BAN_CONFIRMATION"),
|
||||
F.text == 'Отменить'
|
||||
)
|
||||
async def cancel_ban_process(
|
||||
message: types.Message,
|
||||
state: FSMContext
|
||||
):
|
||||
"""Отмена процесса блокировки"""
|
||||
try:
|
||||
current_state = await state.get_state()
|
||||
logger.info(f"Отмена процедуры блокировки из состояния: {current_state}")
|
||||
await return_to_admin_menu(message, state)
|
||||
except Exception as e:
|
||||
await handle_admin_error(message, e, state, "cancel_ban_process")
|
||||
|
||||
60
helper_bot/handlers/admin/dependencies.py
Normal file
60
helper_bot/handlers/admin/dependencies.py
Normal file
@@ -0,0 +1,60 @@
|
||||
from typing import Annotated, Dict, Any
|
||||
from aiogram import BaseMiddleware
|
||||
from aiogram.types import TelegramObject
|
||||
|
||||
from helper_bot.utils.base_dependency_factory import get_global_instance
|
||||
from helper_bot.utils.helper_func import check_access
|
||||
from logs.custom_logger import logger
|
||||
|
||||
|
||||
class AdminAccessMiddleware(BaseMiddleware):
|
||||
"""Middleware для проверки административного доступа"""
|
||||
|
||||
async def __call__(self, handler, event: TelegramObject, data: Dict[str, Any]) -> Any:
|
||||
if hasattr(event, 'from_user'):
|
||||
user_id = event.from_user.id
|
||||
|
||||
# Получаем bot_db из data (внедренного DependenciesMiddleware)
|
||||
bot_db = data.get('bot_db')
|
||||
if not bot_db:
|
||||
# Fallback: получаем напрямую если middleware не сработала
|
||||
bdf = get_global_instance()
|
||||
bot_db = bdf.get_db()
|
||||
|
||||
if not check_access(user_id, bot_db):
|
||||
if hasattr(event, 'answer'):
|
||||
await event.answer('Доступ запрещен!')
|
||||
return
|
||||
|
||||
try:
|
||||
# Вызываем хендлер с data
|
||||
return await handler(event, data)
|
||||
except TypeError as e:
|
||||
if "missing 1 required positional argument: 'data'" in str(e):
|
||||
logger.error(f"Ошибка в AdminAccessMiddleware: {e}. Хендлер не принимает параметр 'data'")
|
||||
# Пытаемся вызвать хендлер без data (для совместимости с MagicData)
|
||||
return await handler(event)
|
||||
else:
|
||||
logger.error(f"TypeError в AdminAccessMiddleware: {e}")
|
||||
raise
|
||||
except Exception as e:
|
||||
logger.error(f"Неожиданная ошибка в AdminAccessMiddleware: {e}")
|
||||
raise
|
||||
|
||||
|
||||
# Dependency providers
|
||||
def get_bot_db():
|
||||
"""Провайдер для получения экземпляра БД"""
|
||||
bdf = get_global_instance()
|
||||
return bdf.get_db()
|
||||
|
||||
|
||||
def get_settings():
|
||||
"""Провайдер для получения настроек"""
|
||||
bdf = get_global_instance()
|
||||
return bdf.settings
|
||||
|
||||
|
||||
# Type aliases for dependency injection
|
||||
BotDB = Annotated[object, get_bot_db()]
|
||||
Settings = Annotated[dict, get_settings()]
|
||||
23
helper_bot/handlers/admin/exceptions.py
Normal file
23
helper_bot/handlers/admin/exceptions.py
Normal file
@@ -0,0 +1,23 @@
|
||||
class AdminError(Exception):
|
||||
"""Базовое исключение для административных операций"""
|
||||
pass
|
||||
|
||||
|
||||
class AdminAccessDeniedError(AdminError):
|
||||
"""Исключение при отказе в административном доступе"""
|
||||
pass
|
||||
|
||||
|
||||
class UserNotFoundError(AdminError):
|
||||
"""Исключение при отсутствии пользователя"""
|
||||
pass
|
||||
|
||||
|
||||
class InvalidInputError(AdminError):
|
||||
"""Исключение при некорректном вводе данных"""
|
||||
pass
|
||||
|
||||
|
||||
class UserAlreadyBannedError(AdminError):
|
||||
"""Исключение при попытке забанить уже заблокированного пользователя"""
|
||||
pass
|
||||
146
helper_bot/handlers/admin/services.py
Normal file
146
helper_bot/handlers/admin/services.py
Normal file
@@ -0,0 +1,146 @@
|
||||
from typing import List, Optional
|
||||
from datetime import datetime
|
||||
|
||||
from helper_bot.utils.helper_func import add_days_to_date, get_banned_users_buttons, get_banned_users_list
|
||||
from helper_bot.handlers.admin.exceptions import UserAlreadyBannedError, InvalidInputError
|
||||
from logs.custom_logger import logger
|
||||
|
||||
|
||||
class User:
|
||||
"""Модель пользователя"""
|
||||
def __init__(self, user_id: int, username: str, full_name: str):
|
||||
self.user_id = user_id
|
||||
self.username = username
|
||||
self.full_name = full_name
|
||||
|
||||
|
||||
class BannedUser:
|
||||
"""Модель заблокированного пользователя"""
|
||||
def __init__(self, user_id: int, username: str, reason: str, unban_date: Optional[datetime]):
|
||||
self.user_id = user_id
|
||||
self.username = username
|
||||
self.reason = reason
|
||||
self.unban_date = unban_date
|
||||
|
||||
|
||||
class AdminService:
|
||||
"""Сервис для административных операций"""
|
||||
|
||||
def __init__(self, bot_db):
|
||||
self.bot_db = bot_db
|
||||
|
||||
def get_last_users(self) -> List[User]:
|
||||
"""Получить список последних пользователей"""
|
||||
try:
|
||||
users_data = self.bot_db.get_last_users_from_db()
|
||||
return [
|
||||
User(
|
||||
user_id=user[1],
|
||||
username='Неизвестно',
|
||||
full_name=user[0]
|
||||
)
|
||||
for user in users_data
|
||||
]
|
||||
except Exception as e:
|
||||
logger.error(f"Ошибка при получении списка последних пользователей: {e}")
|
||||
raise
|
||||
|
||||
def get_banned_users(self) -> List[BannedUser]:
|
||||
"""Получить список заблокированных пользователей"""
|
||||
try:
|
||||
banned_users_data = self.bot_db.get_banned_users_from_db()
|
||||
return [
|
||||
BannedUser(
|
||||
user_id=user[1], # user_id
|
||||
username=user[0], # user_name
|
||||
reason=user[2], # message_for_user
|
||||
unban_date=user[3] # date_to_unban
|
||||
)
|
||||
for user in banned_users_data
|
||||
]
|
||||
except Exception as e:
|
||||
logger.error(f"Ошибка при получении списка заблокированных пользователей: {e}")
|
||||
raise
|
||||
|
||||
def get_user_by_username(self, username: str) -> Optional[User]:
|
||||
"""Получить пользователя по username"""
|
||||
try:
|
||||
user_id = self.bot_db.get_user_id_by_username(username)
|
||||
if not user_id:
|
||||
return None
|
||||
|
||||
full_name = self.bot_db.get_full_name_by_id(user_id)
|
||||
return User(
|
||||
user_id=user_id,
|
||||
username=username,
|
||||
full_name=full_name or 'Неизвестно'
|
||||
)
|
||||
except Exception as e:
|
||||
logger.error(f"Ошибка при поиске пользователя по username {username}: {e}")
|
||||
raise
|
||||
|
||||
def get_user_by_id(self, user_id: int) -> Optional[User]:
|
||||
"""Получить пользователя по ID"""
|
||||
try:
|
||||
user_info = self.bot_db.get_user_info_by_id(user_id)
|
||||
if not user_info:
|
||||
return None
|
||||
|
||||
return User(
|
||||
user_id=user_id,
|
||||
username=user_info.get('username', 'Неизвестно'),
|
||||
full_name=user_info.get('full_name', 'Неизвестно')
|
||||
)
|
||||
except Exception as e:
|
||||
logger.error(f"Ошибка при поиске пользователя по ID {user_id}: {e}")
|
||||
raise
|
||||
|
||||
def ban_user(self, user_id: int, username: str, reason: str, ban_days: Optional[int]) -> None:
|
||||
"""Заблокировать пользователя"""
|
||||
try:
|
||||
# Проверяем, не заблокирован ли уже пользователь
|
||||
if self.bot_db.check_user_in_blacklist(user_id):
|
||||
raise UserAlreadyBannedError(f"Пользователь {user_id} уже заблокирован")
|
||||
|
||||
# Рассчитываем дату разблокировки
|
||||
date_to_unban = None
|
||||
if ban_days is not None:
|
||||
date_to_unban = add_days_to_date(ban_days)
|
||||
|
||||
# Сохраняем в БД
|
||||
self.bot_db.set_user_blacklist(user_id, username, reason, date_to_unban)
|
||||
|
||||
logger.info(f"Пользователь {user_id} ({username}) заблокирован. Причина: {reason}, срок: {ban_days} дней")
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Ошибка при блокировке пользователя {user_id}: {e}")
|
||||
raise
|
||||
|
||||
def unban_user(self, user_id: int) -> None:
|
||||
"""Разблокировать пользователя"""
|
||||
try:
|
||||
self.bot_db.delete_user_blacklist(user_id)
|
||||
logger.info(f"Пользователь {user_id} разблокирован")
|
||||
except Exception as e:
|
||||
logger.error(f"Ошибка при разблокировке пользователя {user_id}: {e}")
|
||||
raise
|
||||
|
||||
def validate_user_input(self, input_text: str) -> int:
|
||||
"""Валидация введенного ID пользователя"""
|
||||
try:
|
||||
user_id = int(input_text.strip())
|
||||
if user_id <= 0:
|
||||
raise InvalidInputError("ID пользователя должен быть положительным числом")
|
||||
return user_id
|
||||
except ValueError:
|
||||
raise InvalidInputError("ID пользователя должен быть числом")
|
||||
|
||||
def get_banned_users_for_display(self, page: int = 0) -> tuple[str, list]:
|
||||
"""Получить данные заблокированных пользователей для отображения"""
|
||||
try:
|
||||
message_text = get_banned_users_list(page, self.bot_db)
|
||||
buttons_list = get_banned_users_buttons(self.bot_db)
|
||||
return message_text, buttons_list
|
||||
except Exception as e:
|
||||
logger.error(f"Ошибка при получении данных заблокированных пользователей: {e}")
|
||||
raise
|
||||
61
helper_bot/handlers/admin/utils.py
Normal file
61
helper_bot/handlers/admin/utils.py
Normal file
@@ -0,0 +1,61 @@
|
||||
import html
|
||||
from typing import Optional
|
||||
from aiogram import types
|
||||
from aiogram.fsm.context import FSMContext
|
||||
|
||||
from helper_bot.keyboards.keyboards import get_reply_keyboard_admin
|
||||
from helper_bot.handlers.admin.exceptions import AdminError
|
||||
from logs.custom_logger import logger
|
||||
|
||||
|
||||
def escape_html(text: str) -> str:
|
||||
"""Экранирование HTML для безопасного использования в сообщениях"""
|
||||
return html.escape(str(text)) if text else ""
|
||||
|
||||
|
||||
async def return_to_admin_menu(message: types.Message, state: FSMContext,
|
||||
additional_message: Optional[str] = None) -> None:
|
||||
"""Универсальная функция для возврата в админ-меню"""
|
||||
await state.set_data({})
|
||||
await state.set_state("ADMIN")
|
||||
markup = get_reply_keyboard_admin()
|
||||
|
||||
if additional_message:
|
||||
await message.answer(additional_message)
|
||||
|
||||
await message.answer('Вернулись в меню', reply_markup=markup)
|
||||
|
||||
|
||||
async def handle_admin_error(message: types.Message, error: Exception,
|
||||
state: FSMContext, error_context: str = "") -> None:
|
||||
"""Централизованная обработка ошибок административных операций"""
|
||||
logger.error(f"Ошибка в {error_context}: {error}")
|
||||
|
||||
if isinstance(error, AdminError):
|
||||
await message.answer(f"Ошибка: {str(error)}")
|
||||
else:
|
||||
await message.answer("Произошла внутренняя ошибка. Попробуйте позже.")
|
||||
|
||||
await return_to_admin_menu(message, state)
|
||||
|
||||
|
||||
def format_user_info(user_id: int, username: str, full_name: str) -> str:
|
||||
"""Форматирование информации о пользователе для отображения"""
|
||||
safe_username = escape_html(username)
|
||||
safe_full_name = escape_html(full_name)
|
||||
|
||||
return (f"<b>Выбран пользователь:</b>\n"
|
||||
f"<b>ID:</b> {user_id}\n"
|
||||
f"<b>Username:</b> {safe_username}\n"
|
||||
f"<b>Имя:</b> {safe_full_name}")
|
||||
|
||||
|
||||
def format_ban_confirmation(user_id: int, reason: str, ban_days: Optional[int]) -> str:
|
||||
"""Форматирование подтверждения бана"""
|
||||
safe_reason = escape_html(reason)
|
||||
ban_text = "Навсегда" if ban_days is None else f"{ban_days} дней"
|
||||
|
||||
return (f"<b>Необходимо подтверждение:</b>\n"
|
||||
f"<b>Пользователь:</b> {user_id}\n"
|
||||
f"<b>Причина бана:</b> {safe_reason}\n"
|
||||
f"<b>Срок бана:</b> {ban_text}")
|
||||
@@ -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'
|
||||
]
|
||||
|
||||
@@ -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
|
||||
)
|
||||
|
||||
29
helper_bot/handlers/callback/constants.py
Normal file
29
helper_bot/handlers/callback/constants.py
Normal file
@@ -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"
|
||||
33
helper_bot/handlers/callback/dependency_factory.py
Normal file
33
helper_bot/handlers/callback/dependency_factory.py
Normal file
@@ -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)
|
||||
23
helper_bot/handlers/callback/exceptions.py
Normal file
23
helper_bot/handlers/callback/exceptions.py
Normal file
@@ -0,0 +1,23 @@
|
||||
class UserBlockedBotError(Exception):
|
||||
"""Исключение, возникающее когда пользователь заблокировал бота"""
|
||||
pass
|
||||
|
||||
|
||||
class PostNotFoundError(Exception):
|
||||
"""Исключение, возникающее когда пост не найден в базе данных"""
|
||||
pass
|
||||
|
||||
|
||||
class UserNotFoundError(Exception):
|
||||
"""Исключение, возникающее когда пользователь не найден в базе данных"""
|
||||
pass
|
||||
|
||||
|
||||
class PublishError(Exception):
|
||||
"""Общее исключение для ошибок публикации"""
|
||||
pass
|
||||
|
||||
|
||||
class BanError(Exception):
|
||||
"""Исключение для ошибок бана/разбана пользователей"""
|
||||
pass
|
||||
249
helper_bot/handlers/callback/services.py
Normal file
249
helper_bot/handlers/callback/services.py
Normal file
@@ -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
|
||||
@@ -1 +1,47 @@
|
||||
from .group_handlers import group_router
|
||||
"""Group handlers package for Telegram bot"""
|
||||
|
||||
# Local imports - main components
|
||||
from .group_handlers import (
|
||||
group_router,
|
||||
create_group_handlers,
|
||||
GroupHandlers
|
||||
)
|
||||
|
||||
# Local imports - services
|
||||
from .services import (
|
||||
AdminReplyService,
|
||||
DatabaseProtocol
|
||||
)
|
||||
|
||||
# Local imports - constants and utilities
|
||||
from .constants import (
|
||||
FSM_STATES,
|
||||
ERROR_MESSAGES
|
||||
)
|
||||
from .exceptions import (
|
||||
NoReplyToMessageError,
|
||||
UserNotFoundError
|
||||
)
|
||||
from .decorators import error_handler
|
||||
|
||||
__all__ = [
|
||||
# Main components
|
||||
'group_router',
|
||||
'create_group_handlers',
|
||||
'GroupHandlers',
|
||||
|
||||
# Services
|
||||
'AdminReplyService',
|
||||
'DatabaseProtocol',
|
||||
|
||||
# Constants
|
||||
'FSM_STATES',
|
||||
'ERROR_MESSAGES',
|
||||
|
||||
# Exceptions
|
||||
'NoReplyToMessageError',
|
||||
'UserNotFoundError',
|
||||
|
||||
# Utilities
|
||||
'error_handler'
|
||||
]
|
||||
|
||||
14
helper_bot/handlers/group/constants.py
Normal file
14
helper_bot/handlers/group/constants.py
Normal file
@@ -0,0 +1,14 @@
|
||||
"""Constants for group handlers"""
|
||||
|
||||
from typing import Final
|
||||
|
||||
# FSM States
|
||||
FSM_STATES: Final[dict[str, str]] = {
|
||||
"CHAT": "CHAT"
|
||||
}
|
||||
|
||||
# Error messages
|
||||
ERROR_MESSAGES: Final[dict[str, str]] = {
|
||||
"NO_REPLY_TO_MESSAGE": "Блять, выдели сообщение!",
|
||||
"USER_NOT_FOUND": "Не могу найти кому ответить в базе, проебали сообщение."
|
||||
}
|
||||
36
helper_bot/handlers/group/decorators.py
Normal file
36
helper_bot/handlers/group/decorators.py
Normal file
@@ -0,0 +1,36 @@
|
||||
"""Decorators and utility functions for group handlers"""
|
||||
|
||||
# Standard library imports
|
||||
import traceback
|
||||
from typing import Any, Callable
|
||||
|
||||
# Third-party imports
|
||||
from aiogram import types
|
||||
|
||||
# Local imports
|
||||
from logs.custom_logger import logger
|
||||
|
||||
|
||||
def error_handler(func: Callable[..., Any]) -> Callable[..., Any]:
|
||||
"""Decorator for centralized error handling"""
|
||||
async def wrapper(*args: Any, **kwargs: Any) -> Any:
|
||||
try:
|
||||
return await func(*args, **kwargs)
|
||||
except Exception as e:
|
||||
logger.error(f"Error in {func.__name__}: {str(e)}")
|
||||
# Try to send error to logs if possible
|
||||
try:
|
||||
message = next((arg for arg in args if isinstance(arg, types.Message)), None)
|
||||
if message and hasattr(message, 'bot'):
|
||||
from helper_bot.utils.base_dependency_factory import get_global_instance
|
||||
bdf = get_global_instance()
|
||||
important_logs = bdf.settings['Telegram']['important_logs']
|
||||
await message.bot.send_message(
|
||||
chat_id=important_logs,
|
||||
text=f"Произошла ошибка в {func.__name__}: {str(e)}\n\nTraceback:\n{traceback.format_exc()}"
|
||||
)
|
||||
except Exception:
|
||||
# If we can't log the error, at least it was logged to logger
|
||||
pass
|
||||
raise
|
||||
return wrapper
|
||||
11
helper_bot/handlers/group/exceptions.py
Normal file
11
helper_bot/handlers/group/exceptions.py
Normal file
@@ -0,0 +1,11 @@
|
||||
"""Custom exceptions for group handlers"""
|
||||
|
||||
|
||||
class NoReplyToMessageError(Exception):
|
||||
"""Raised when admin tries to reply without selecting a message"""
|
||||
pass
|
||||
|
||||
|
||||
class UserNotFoundError(Exception):
|
||||
"""Raised when user is not found in database for the given message_id"""
|
||||
pass
|
||||
@@ -1,49 +1,106 @@
|
||||
"""Main group handlers module for Telegram bot"""
|
||||
|
||||
# Third-party imports
|
||||
from aiogram import Router, types
|
||||
from aiogram.fsm.context import FSMContext
|
||||
|
||||
# Local imports - filters
|
||||
from helper_bot.filters.main import ChatTypeFilter
|
||||
from helper_bot.keyboards.keyboards import get_reply_keyboard_leave_chat
|
||||
from helper_bot.utils.base_dependency_factory import get_global_instance
|
||||
from helper_bot.utils.helper_func import send_text_message
|
||||
|
||||
# Local imports - modular components
|
||||
from .constants import FSM_STATES, ERROR_MESSAGES
|
||||
from .services import AdminReplyService
|
||||
from .decorators import error_handler
|
||||
from .exceptions import UserNotFoundError
|
||||
|
||||
# Local imports - utilities
|
||||
from logs.custom_logger import logger
|
||||
|
||||
|
||||
class GroupHandlers:
|
||||
"""Main handler class for group messages"""
|
||||
|
||||
def __init__(self, db, keyboard_markup: types.ReplyKeyboardMarkup):
|
||||
self.db = db
|
||||
self.keyboard_markup = keyboard_markup
|
||||
self.admin_reply_service = AdminReplyService(db)
|
||||
|
||||
# Create router
|
||||
self.router = Router()
|
||||
|
||||
# Register handlers
|
||||
self._register_handlers()
|
||||
|
||||
def _register_handlers(self):
|
||||
"""Register all message handlers"""
|
||||
self.router.message.register(
|
||||
self.handle_message,
|
||||
ChatTypeFilter(chat_type=["group", "supergroup"])
|
||||
)
|
||||
|
||||
@error_handler
|
||||
async def handle_message(self, message: types.Message, state: FSMContext):
|
||||
"""Handle admin reply to user through group chat"""
|
||||
logger.info(
|
||||
f'Получено сообщение в группе {message.chat.title} (ID: {message.chat.id}) '
|
||||
f'от пользователя {message.from_user.full_name} (ID: {message.from_user.id}): "{message.text}"'
|
||||
)
|
||||
|
||||
# Check if message is a reply
|
||||
if not message.reply_to_message:
|
||||
await message.answer(ERROR_MESSAGES["NO_REPLY_TO_MESSAGE"])
|
||||
logger.warning(
|
||||
f'В группе {message.chat.title} (ID: {message.chat.id}) '
|
||||
f'админ не выделил сообщение для ответа.'
|
||||
)
|
||||
return
|
||||
|
||||
message_id = message.reply_to_message.message_id
|
||||
reply_text = message.text
|
||||
|
||||
try:
|
||||
# Get user ID for reply
|
||||
chat_id = self.admin_reply_service.get_user_id_for_reply(message_id)
|
||||
|
||||
# Send reply to user
|
||||
await self.admin_reply_service.send_reply_to_user(
|
||||
chat_id, message, reply_text, self.keyboard_markup
|
||||
)
|
||||
|
||||
# Set state
|
||||
await state.set_state(FSM_STATES["CHAT"])
|
||||
|
||||
except UserNotFoundError:
|
||||
await message.answer(ERROR_MESSAGES["USER_NOT_FOUND"])
|
||||
logger.error(
|
||||
f'Ошибка при поиске пользователя в базе для ответа на сообщение: {reply_text} '
|
||||
f'в группе {message.chat.title} (ID сообщения: {message.message_id})'
|
||||
)
|
||||
|
||||
|
||||
# Factory function to create handlers with dependencies
|
||||
def create_group_handlers(db, keyboard_markup: types.ReplyKeyboardMarkup) -> GroupHandlers:
|
||||
"""Create group handlers instance with dependencies"""
|
||||
return GroupHandlers(db, keyboard_markup)
|
||||
|
||||
|
||||
# Legacy router for backward compatibility
|
||||
group_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']
|
||||
# Initialize with global dependencies (for backward compatibility)
|
||||
def init_legacy_router():
|
||||
"""Initialize legacy router with global dependencies"""
|
||||
global group_router
|
||||
|
||||
from helper_bot.utils.base_dependency_factory import get_global_instance
|
||||
from helper_bot.keyboards.keyboards import get_reply_keyboard_leave_chat
|
||||
|
||||
bdf = get_global_instance()
|
||||
db = bdf.get_db()
|
||||
keyboard_markup = get_reply_keyboard_leave_chat()
|
||||
|
||||
handlers = create_group_handlers(db, keyboard_markup)
|
||||
group_router = handlers.router
|
||||
|
||||
BotDB = bdf.get_db()
|
||||
|
||||
|
||||
@group_router.message(
|
||||
ChatTypeFilter(chat_type=["group", "supergroup"]),
|
||||
)
|
||||
async def handle_message(message: types.Message, state: FSMContext):
|
||||
"""Функция ответа админа пользователю через закрытый чат"""
|
||||
logger.info(
|
||||
f'Получено сообщение в группе {message.chat.title} (ID: {message.chat.id}) от пользователя {message.from_user.full_name} (ID: {message.from_user.id}): "{message.text}"')
|
||||
markup = get_reply_keyboard_leave_chat()
|
||||
message_id = 0
|
||||
try:
|
||||
message_id = message.reply_to_message.message_id
|
||||
except AttributeError as e:
|
||||
await message.answer('Блять, выдели сообщение!')
|
||||
logger.warning(
|
||||
f'В группе {message.chat.title} (ID: {message.chat.id}) админ не выделил сообщение для ответа. Ошибка {str(e)}')
|
||||
message_from_admin = message.text
|
||||
try:
|
||||
chat_id = BotDB.get_user_by_message_id(message_id)
|
||||
await send_text_message(chat_id, message, message_from_admin, markup)
|
||||
await state.set_state("CHAT")
|
||||
logger.info(f'Ответ админа "{message.text}" отправлен пользователю с ID: {chat_id} на сообщение {message_id}')
|
||||
except TypeError as e:
|
||||
await message.answer('Не могу найти кому ответить в базе, проебали сообщение.')
|
||||
logger.error(
|
||||
f'Ошибка при поиске пользователя в базе для ответа на сообщение: {message.text} в группе {message.chat.title} (ID сообщения: {message.message_id}) Ошибка: {str(e)}')
|
||||
# Initialize legacy router
|
||||
init_legacy_router()
|
||||
|
||||
64
helper_bot/handlers/group/services.py
Normal file
64
helper_bot/handlers/group/services.py
Normal file
@@ -0,0 +1,64 @@
|
||||
"""Service classes for group handlers"""
|
||||
|
||||
# Standard library imports
|
||||
from typing import Protocol, Optional
|
||||
|
||||
# Third-party imports
|
||||
from aiogram import types
|
||||
|
||||
# Local imports
|
||||
from helper_bot.utils.helper_func import send_text_message
|
||||
from .exceptions import NoReplyToMessageError, UserNotFoundError
|
||||
from logs.custom_logger import logger
|
||||
|
||||
|
||||
class DatabaseProtocol(Protocol):
|
||||
"""Protocol for database operations"""
|
||||
def get_user_by_message_id(self, message_id: int) -> Optional[int]: ...
|
||||
|
||||
|
||||
class AdminReplyService:
|
||||
"""Service for admin reply operations"""
|
||||
|
||||
def __init__(self, db: DatabaseProtocol) -> None:
|
||||
self.db = db
|
||||
|
||||
def get_user_id_for_reply(self, message_id: int) -> int:
|
||||
"""
|
||||
Get user ID for reply by message ID.
|
||||
|
||||
Args:
|
||||
message_id: ID of the message to reply to
|
||||
|
||||
Returns:
|
||||
User ID for the reply
|
||||
|
||||
Raises:
|
||||
UserNotFoundError: If user is not found in database
|
||||
"""
|
||||
user_id = self.db.get_user_by_message_id(message_id)
|
||||
if user_id is None:
|
||||
raise UserNotFoundError(f"User not found for message_id: {message_id}")
|
||||
return user_id
|
||||
|
||||
async def send_reply_to_user(
|
||||
self,
|
||||
chat_id: int,
|
||||
message: types.Message,
|
||||
reply_text: str,
|
||||
markup: types.ReplyKeyboardMarkup
|
||||
) -> None:
|
||||
"""
|
||||
Send reply to user.
|
||||
|
||||
Args:
|
||||
chat_id: User's chat ID
|
||||
message: Original message from admin
|
||||
reply_text: Text to send to user
|
||||
markup: Reply keyboard markup
|
||||
"""
|
||||
await send_text_message(chat_id, message, reply_text, markup)
|
||||
logger.info(
|
||||
f'Ответ админа "{reply_text}" отправлен пользователю с ID: {chat_id} '
|
||||
f'на сообщение {message.reply_to_message.message_id if message.reply_to_message else "N/A"}'
|
||||
)
|
||||
@@ -1,20 +1,45 @@
|
||||
"""Private handlers package for Telegram bot"""
|
||||
|
||||
from .private_handlers import private_router, create_private_handlers, PrivateHandlers
|
||||
from .services import BotSettings, UserService, PostService, StickerService
|
||||
from .constants import FSM_STATES, BUTTON_TEXTS, ERROR_MESSAGES
|
||||
# Local imports - main components
|
||||
from .private_handlers import (
|
||||
private_router,
|
||||
create_private_handlers,
|
||||
PrivateHandlers
|
||||
)
|
||||
|
||||
# Local imports - services
|
||||
from .services import (
|
||||
BotSettings,
|
||||
UserService,
|
||||
PostService,
|
||||
StickerService
|
||||
)
|
||||
|
||||
# Local imports - constants and utilities
|
||||
from .constants import (
|
||||
FSM_STATES,
|
||||
BUTTON_TEXTS,
|
||||
ERROR_MESSAGES
|
||||
)
|
||||
from .decorators import error_handler
|
||||
|
||||
__all__ = [
|
||||
# Main components
|
||||
'private_router',
|
||||
'create_private_handlers',
|
||||
'PrivateHandlers',
|
||||
|
||||
# Services
|
||||
'BotSettings',
|
||||
'UserService',
|
||||
'PostService',
|
||||
'StickerService',
|
||||
|
||||
# Constants
|
||||
'FSM_STATES',
|
||||
'BUTTON_TEXTS',
|
||||
'ERROR_MESSAGES',
|
||||
|
||||
# Utilities
|
||||
'error_handler'
|
||||
]
|
||||
|
||||
@@ -1,7 +1,9 @@
|
||||
"""Constants for private handlers"""
|
||||
|
||||
from typing import Final
|
||||
|
||||
# FSM States
|
||||
FSM_STATES = {
|
||||
FSM_STATES: Final[dict[str, str]] = {
|
||||
"START": "START",
|
||||
"SUGGEST": "SUGGEST",
|
||||
"PRE_CHAT": "PRE_CHAT",
|
||||
@@ -9,7 +11,7 @@ FSM_STATES = {
|
||||
}
|
||||
|
||||
# Button texts
|
||||
BUTTON_TEXTS = {
|
||||
BUTTON_TEXTS: Final[dict[str, str]] = {
|
||||
"SUGGEST_POST": "📢Предложить свой пост",
|
||||
"SAY_GOODBYE": "👋🏼Сказать пока!",
|
||||
"LEAVE_CHAT": "Выйти из чата",
|
||||
@@ -19,7 +21,7 @@ BUTTON_TEXTS = {
|
||||
}
|
||||
|
||||
# Error messages
|
||||
ERROR_MESSAGES = {
|
||||
ERROR_MESSAGES: Final[dict[str, str]] = {
|
||||
"UNSUPPORTED_CONTENT": (
|
||||
'Я пока не умею работать с таким сообщением. '
|
||||
'Пришли текст и фото/фоты(ы). А лучше перешли это сообщение админу @kerrad1\n'
|
||||
|
||||
@@ -1,13 +1,19 @@
|
||||
"""Decorators and utility functions for private handlers"""
|
||||
|
||||
# Standard library imports
|
||||
import traceback
|
||||
from typing import Any, Callable
|
||||
|
||||
# Third-party imports
|
||||
from aiogram import types
|
||||
|
||||
# Local imports
|
||||
from logs.custom_logger import logger
|
||||
|
||||
|
||||
def error_handler(func):
|
||||
def error_handler(func: Callable[..., Any]) -> Callable[..., Any]:
|
||||
"""Decorator for centralized error handling"""
|
||||
async def wrapper(*args, **kwargs):
|
||||
async def wrapper(*args: Any, **kwargs: Any) -> Any:
|
||||
try:
|
||||
return await func(*args, **kwargs)
|
||||
except Exception as e:
|
||||
@@ -23,7 +29,8 @@ def error_handler(func):
|
||||
chat_id=important_logs,
|
||||
text=f"Произошла ошибка в {func.__name__}: {str(e)}\n\nTraceback:\n{traceback.format_exc()}"
|
||||
)
|
||||
except:
|
||||
pass # If we can't log the error, at least it was logged to logger
|
||||
except Exception:
|
||||
# If we can't log the error, at least it was logged to logger
|
||||
pass
|
||||
raise
|
||||
return wrapper
|
||||
|
||||
@@ -1,28 +1,30 @@
|
||||
import random
|
||||
import traceback
|
||||
import asyncio
|
||||
import html
|
||||
from datetime import datetime
|
||||
from pathlib import Path
|
||||
"""Main private handlers module for Telegram bot"""
|
||||
|
||||
# Standard library imports
|
||||
import asyncio
|
||||
from datetime import datetime
|
||||
|
||||
# Third-party imports
|
||||
from aiogram import types, Router, F
|
||||
from aiogram.filters import Command, StateFilter
|
||||
from aiogram.fsm.context import FSMContext
|
||||
from aiogram.types import FSInputFile
|
||||
|
||||
# Local imports - filters and middlewares
|
||||
from helper_bot.filters.main import ChatTypeFilter
|
||||
from helper_bot.keyboards import get_reply_keyboard, get_reply_keyboard_for_post
|
||||
from helper_bot.keyboards.keyboards import get_reply_keyboard_leave_chat
|
||||
from helper_bot.middlewares.album_middleware import AlbumMiddleware
|
||||
from helper_bot.middlewares.blacklist_middleware import BlacklistMiddleware
|
||||
from helper_bot.utils import messages
|
||||
from helper_bot.utils.helper_func import get_first_name, get_text_message, send_text_message, send_photo_message, \
|
||||
send_media_group_message_to_private_chat, prepare_media_group_from_middlewares, send_video_message, \
|
||||
send_video_note_message, send_audio_message, send_voice_message, add_in_db_media, \
|
||||
check_user_emoji, check_username_and_full_name, update_user_info
|
||||
from logs.custom_logger import logger
|
||||
|
||||
# Import new modular components
|
||||
# Local imports - utilities
|
||||
from helper_bot.keyboards import get_reply_keyboard, get_reply_keyboard_for_post
|
||||
from helper_bot.keyboards.keyboards import get_reply_keyboard_leave_chat
|
||||
from helper_bot.utils import messages
|
||||
from helper_bot.utils.helper_func import (
|
||||
get_first_name,
|
||||
update_user_info,
|
||||
check_user_emoji
|
||||
)
|
||||
|
||||
# Local imports - modular components
|
||||
from .constants import FSM_STATES, BUTTON_TEXTS, ERROR_MESSAGES
|
||||
from .services import BotSettings, UserService, PostService, StickerService
|
||||
from .decorators import error_handler
|
||||
@@ -112,10 +114,7 @@ class PrivateHandlers:
|
||||
|
||||
markup = types.ReplyKeyboardRemove()
|
||||
suggest_news = messages.get_message(get_first_name(message), 'SUGGEST_NEWS')
|
||||
await message.answer(suggest_news)
|
||||
await asyncio.sleep(0.3)
|
||||
suggest_news_2 = messages.get_message(get_first_name(message), 'SUGGEST_NEWS_2')
|
||||
await message.answer(suggest_news_2, reply_markup=markup)
|
||||
await message.answer(suggest_news, reply_markup=markup)
|
||||
|
||||
@error_handler
|
||||
async def end_message(self, message: types.Message, state: FSMContext, **kwargs):
|
||||
|
||||
@@ -1,25 +1,50 @@
|
||||
"""Service classes for private handlers"""
|
||||
|
||||
# Standard library imports
|
||||
import random
|
||||
import asyncio
|
||||
import html
|
||||
from datetime import datetime
|
||||
from pathlib import Path
|
||||
from typing import Dict, Callable
|
||||
from typing import Dict, Callable, Any, Protocol, Union
|
||||
from dataclasses import dataclass
|
||||
|
||||
# Third-party imports
|
||||
from aiogram import types
|
||||
from aiogram.types import FSInputFile
|
||||
|
||||
# Local imports - utilities
|
||||
from helper_bot.utils.helper_func import (
|
||||
get_first_name, get_text_message, send_text_message, send_photo_message,
|
||||
send_media_group_message_to_private_chat, prepare_media_group_from_middlewares,
|
||||
send_video_message, send_video_note_message, send_audio_message, send_voice_message,
|
||||
add_in_db_media, check_username_and_full_name
|
||||
get_first_name,
|
||||
get_text_message,
|
||||
send_text_message,
|
||||
send_photo_message,
|
||||
send_media_group_message_to_private_chat,
|
||||
prepare_media_group_from_middlewares,
|
||||
send_video_message,
|
||||
send_video_note_message,
|
||||
send_audio_message,
|
||||
send_voice_message,
|
||||
add_in_db_media,
|
||||
check_username_and_full_name
|
||||
)
|
||||
from helper_bot.keyboards import get_reply_keyboard_for_post
|
||||
|
||||
|
||||
class DatabaseProtocol(Protocol):
|
||||
"""Protocol for database operations"""
|
||||
def user_exists(self, user_id: int) -> bool: ...
|
||||
def add_new_user_in_db(self, user_id: int, first_name: str, full_name: str,
|
||||
username: str, is_bot: bool, language_code: str,
|
||||
emoji: str, created_date: str, updated_date: str) -> None: ...
|
||||
def update_username_and_full_name(self, user_id: int, username: str, full_name: str) -> None: ...
|
||||
def update_date_for_user(self, date: str, user_id: int) -> None: ...
|
||||
def add_post_in_db(self, message_id: int, text: str, user_id: int) -> None: ...
|
||||
def update_info_about_stickers(self, user_id: int) -> None: ...
|
||||
def add_new_message_in_db(self, text: str, user_id: int, message_id: int, date: str) -> None: ...
|
||||
def update_helper_message_in_db(self, message_id: int, helper_message_id: int) -> None: ...
|
||||
|
||||
|
||||
@dataclass
|
||||
class BotSettings:
|
||||
"""Bot configuration settings"""
|
||||
@@ -36,7 +61,7 @@ class BotSettings:
|
||||
class UserService:
|
||||
"""Service for user-related operations"""
|
||||
|
||||
def __init__(self, db, settings: BotSettings):
|
||||
def __init__(self, db: DatabaseProtocol, settings: BotSettings) -> None:
|
||||
self.db = db
|
||||
self.settings = settings
|
||||
|
||||
@@ -90,7 +115,7 @@ class UserService:
|
||||
class PostService:
|
||||
"""Service for post-related operations"""
|
||||
|
||||
def __init__(self, db, settings: BotSettings):
|
||||
def __init__(self, db: DatabaseProtocol, settings: BotSettings) -> None:
|
||||
self.db = db
|
||||
self.settings = settings
|
||||
|
||||
@@ -168,7 +193,7 @@ class PostService:
|
||||
"""Handle media group post submission"""
|
||||
post_caption = " "
|
||||
|
||||
if album[0].caption:
|
||||
if album and album[0].caption:
|
||||
post_caption = get_text_message(album[0].caption.lower(), first_name, message.from_user.username)
|
||||
|
||||
media_group = await prepare_media_group_from_middlewares(album, post_caption)
|
||||
@@ -185,7 +210,7 @@ class PostService:
|
||||
message_id=media_group_message_id, helper_message_id=help_message_id
|
||||
)
|
||||
|
||||
async def process_post(self, message: types.Message, album: list = None) -> None:
|
||||
async def process_post(self, message: types.Message, album: Union[list[types.Message], None] = None) -> None:
|
||||
"""Process post based on content type"""
|
||||
first_name = get_first_name(message)
|
||||
|
||||
@@ -220,12 +245,14 @@ class PostService:
|
||||
class StickerService:
|
||||
"""Service for sticker-related operations"""
|
||||
|
||||
def __init__(self, settings: BotSettings):
|
||||
def __init__(self, settings: BotSettings) -> None:
|
||||
self.settings = settings
|
||||
|
||||
async def send_random_hello_sticker(self, message: types.Message) -> None:
|
||||
"""Send random hello sticker"""
|
||||
name_stick_hello = list(Path('Stick').rglob('Hello_*'))
|
||||
if not name_stick_hello:
|
||||
return
|
||||
random_stick_hello = random.choice(name_stick_hello)
|
||||
random_stick_hello = FSInputFile(path=random_stick_hello)
|
||||
await message.answer_sticker(random_stick_hello)
|
||||
@@ -234,6 +261,8 @@ class StickerService:
|
||||
async def send_random_goodbye_sticker(self, message: types.Message) -> None:
|
||||
"""Send random goodbye sticker"""
|
||||
name_stick_bye = list(Path('Stick').rglob('Universal_*'))
|
||||
if not name_stick_bye:
|
||||
return
|
||||
random_stick_bye = random.choice(name_stick_bye)
|
||||
random_stick_bye = FSInputFile(path=random_stick_bye)
|
||||
await message.answer_sticker(random_stick_bye)
|
||||
|
||||
Reference in New Issue
Block a user