trevor/new_lottery_bot
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: глобальный чат по умолчанию

Browse Source 
- Все сообщения (текст, фото, видео, документы, стикеры, голосовые) автоматически рассылаются всем пользователям
- Исключение: команды (начинаются с /) не рассылаются
- Исключение для админов: паттерны счетов обрабатываются в account_handlers
- Упрощена логика - убран режим forward, всегда broadcast
- Показ статистики доставки: успешно/неуспешно
- Проверка прав на отправку сообщений (баны)
This commit is contained in:
Andrew K. Choi
2025-11-17 11:19:00 +09:00
parent 9dbf90aca9
commit 9a06d460e5
2 changed files with 157 additions and 255 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
.bot.pid
View File

@@ -1 +1 @@
969266 983032

410
src/handlers/chat_handlers.py
View File

@@ -104,39 +104,43 @@ async def forward_to_channel(message: Message, channel_id: str) -> tuple[bool, O
@router.message(F.text) @router.message(F.text)
async def handle_text_message(message: Message): async def handle_text_message(message: Message):
"""Обработчик текстовых сообщений""" """
# Проверяем является ли это командой Обработчик текстовых сообщений - глобальный чат (broadcast всем)
Сообщения автоматически рассылаются всем пользователям, кроме:
- Команд (начинаются с /)
- Паттернов счетов для админов (обрабатываются в account_handlers)
"""
# 1. Проверяем является ли это командой
if message.text and message.text.startswith('/'): if message.text and message.text.startswith('/'):
# Список команд, которые НЕ нужно пересылать # Список известных команд
# (Базовые команды /start, /help уже обработаны раньше в main.py) user_commands = ['/my_code', '/my_accounts', '/chat']
user_commands = ['/my_code', '/my_accounts']
admin_commands = [ admin_commands = [
'/add_account', '/remove_account', '/verify_winner', '/winner_status', '/user_info', '/add_account', '/remove_account', '/verify_winner', '/winner_status', '/user_info',
'/check_unclaimed', '/redraw', '/check_unclaimed', '/redraw', '/admin', '/delete',
'/chat_mode', '/set_forward', '/global_ban', '/ban', '/unban', '/banlist', '/delete_msg', '/chat_stats' '/chat_mode', '/set_forward', '/global_ban', '/ban', '/unban', '/banlist', '/delete_msg', '/chat_stats'
] ]
# Извлекаем команду (первое слово) # Извлекаем команду (первое слово)
command = message.text.split()[0] if message.text else '' command = message.text.split()[0] if message.text else ''
# Если это пользовательская команда - пропускаем, она будет обработана другими обработчиками # Если это известная команда - пропускаем (будет обработана другими обработчиками)
if command in user_commands: if command in user_commands or command in admin_commands:
return return
# Если это админская команда # Неизвестная команда - тоже не рассылаем
if command in admin_commands:
# Проверяем права админа
if not is_admin(message.from_user.id):
await message.answer("❌ У вас нет прав для выполнения этой команды")
return
# Если админ - команда будет обработана другими обработчиками, пропускаем пересылку
return
# Если неизвестная команда - тоже не пересылаем
return return
# 2. Для админов - проверяем на паттерн счетов
if is_admin(message.from_user.id):
from ..utils.account_utils import parse_accounts_from_message
accounts = parse_accounts_from_message(message.text)
if accounts:
# Это сообщение с счетами - пропускаем, обработает account_handlers
return
# 3. Проверяем права на отправку в чат
async with async_session_maker() as session: async with async_session_maker() as session:
# Проверяем права на отправку
can_send, reason = await ChatPermissionService.can_send_message( can_send, reason = await ChatPermissionService.can_send_message(
session, session,
message.from_user.id, message.from_user.id,
@@ -147,63 +151,35 @@ async def handle_text_message(message: Message):
await message.answer(f"❌ {reason}") await message.answer(f"❌ {reason}")
return return
# Получаем настройки чата
settings = await ChatSettingsService.get_or_create_settings(session)
# Получаем пользователя # Получаем пользователя
user = await UserService.get_user_by_telegram_id(session, message.from_user.id) user = await UserService.get_user_by_telegram_id(session, message.from_user.id)
if not user: if not user:
await message.answer("❌ Пользователь не найден") await message.answer("❌ Вы не зарегистрированы. Используйте /start")
return return
# Обрабатываем в зависимости от режима # 4. Рассылаем сообщение всем (broadcast)
if settings.mode == 'broadcast': forwarded_ids, success, fail = await broadcast_message_with_scheduler(message, exclude_user_id=message.from_user.id)
# Режим рассылки с планировщиком
forwarded_ids, success, fail = await broadcast_message_with_scheduler(message, exclude_user_id=message.from_user.id) # Сохраняем сообщение в историю
await ChatMessageService.save_message(
# Сохраняем сообщение в историю session,
await ChatMessageService.save_message( user_id=user.id,
session, telegram_message_id=message.message_id,
user_id=user.id, message_type='text',
telegram_message_id=message.message_id, text=message.text,
message_type='text', forwarded_ids=forwarded_ids
text=message.text, )
forwarded_ids=forwarded_ids
) await message.answer(
f"✅ Сообщение разослано!\n"
await message.answer( f"📤 Доставлено: {success}\n"
f"✅ Сообщение разослано!\n" f"❌ Не доставлено: {fail}"
f"📤 Доставлено: {success}\n" )
f"❌ Не доставлено: {fail}"
)
elif settings.mode == 'forward':
# Режим пересылки в канал
if not settings.forward_chat_id:
await message.answer("❌ Канал для пересылки не настроен")
return
success, channel_msg_id = await forward_to_channel(message, settings.forward_chat_id)
if success:
# Сохраняем сообщение в историю
await ChatMessageService.save_message(
session,
user_id=user.id,
telegram_message_id=message.message_id,
message_type='text',
text=message.text,
forwarded_ids={'channel': channel_msg_id} if channel_msg_id else None
)
await message.answer("✅ Сообщение переслано в канал")
else:
await message.answer("❌ Не удалось переслать сообщение")
@router.message(F.photo) @router.message(F.photo)
async def handle_photo_message(message: Message): async def handle_photo_message(message: Message):
"""Обработчик фото""" """Обработчик фото - глобальный чат (broadcast всем)"""
async with async_session_maker() as session: async with async_session_maker() as session:
can_send, reason = await ChatPermissionService.can_send_message( can_send, reason = await ChatPermissionService.can_send_message(
session, session,
@@ -215,50 +191,38 @@ async def handle_photo_message(message: Message):
await message.answer(f"❌ {reason}") await message.answer(f"❌ {reason}")
return return
settings = await ChatSettingsService.get_or_create_settings(session)
user = await UserService.get_user_by_telegram_id(session, message.from_user.id) user = await UserService.get_user_by_telegram_id(session, message.from_user.id)
if not user: if not user:
await message.answer("❌ Вы не зарегистрированы. Используйте /start")
return return
# Получаем file_id самого большого фото # Получаем file_id самого большого фото
photo = message.photo[-1] photo = message.photo[-1]
if settings.mode == 'broadcast': # Рассылаем всем
forwarded_ids, success, fail = await broadcast_message_with_scheduler(message, exclude_user_id=message.from_user.id) forwarded_ids, success, fail = await broadcast_message_with_scheduler(message, exclude_user_id=message.from_user.id)
await ChatMessageService.save_message( await ChatMessageService.save_message(
session, session,
user_id=user.id, user_id=user.id,
telegram_message_id=message.message_id, telegram_message_id=message.message_id,
message_type='photo', message_type='photo',
text=message.caption, text=message.caption,
file_id=photo.file_id, file_id=photo.file_id,
forwarded_ids=forwarded_ids forwarded_ids=forwarded_ids
) )
await message.answer(f"✅ Фото разослано: {success} получателей") await message.answer(
f"✅ Фото разослано!\n"
elif settings.mode == 'forward': f"📤 Доставлено: {success}\n"
if settings.forward_chat_id: f"❌ Не доставлено: {fail}"
success, channel_msg_id = await forward_to_channel(message, settings.forward_chat_id) )
if success:
await ChatMessageService.save_message(
session,
user_id=user.id,
telegram_message_id=message.message_id,
message_type='photo',
text=message.caption,
file_id=photo.file_id,
forwarded_ids={'channel': channel_msg_id} if channel_msg_id else None
)
await message.answer("✅ Фото переслано в канал")
@router.message(F.video) @router.message(F.video)
async def handle_video_message(message: Message): async def handle_video_message(message: Message):
"""Обработчик видео""" """Обработчик видео - глобальный чат (broadcast всем)"""
async with async_session_maker() as session: async with async_session_maker() as session:
can_send, reason = await ChatPermissionService.can_send_message( can_send, reason = await ChatPermissionService.can_send_message(
session, session,
@@ -270,47 +234,35 @@ async def handle_video_message(message: Message):
await message.answer(f"❌ {reason}") await message.answer(f"❌ {reason}")
return return
settings = await ChatSettingsService.get_or_create_settings(session)
user = await UserService.get_user_by_telegram_id(session, message.from_user.id) user = await UserService.get_user_by_telegram_id(session, message.from_user.id)
if not user: if not user:
await message.answer("❌ Вы не зарегистрированы. Используйте /start")
return return
if settings.mode == 'broadcast': # Рассылаем всем
forwarded_ids, success, fail = await broadcast_message_with_scheduler(message, exclude_user_id=message.from_user.id) forwarded_ids, success, fail = await broadcast_message_with_scheduler(message, exclude_user_id=message.from_user.id)
await ChatMessageService.save_message( await ChatMessageService.save_message(
session, session,
user_id=user.id, user_id=user.id,
telegram_message_id=message.message_id, telegram_message_id=message.message_id,
message_type='video', message_type='video',
text=message.caption, text=message.caption,
file_id=message.video.file_id, file_id=message.video.file_id,
forwarded_ids=forwarded_ids forwarded_ids=forwarded_ids
) )
await message.answer(f"✅ Видео разослано: {success} получателей") await message.answer(
f"✅ Видео разослано!\n"
elif settings.mode == 'forward': f"📤 Доставлено: {success}\n"
if settings.forward_chat_id: f"❌ Не доставлено: {fail}"
success, channel_msg_id = await forward_to_channel(message, settings.forward_chat_id) )
if success:
await ChatMessageService.save_message(
session,
user_id=user.id,
telegram_message_id=message.message_id,
message_type='video',
text=message.caption,
file_id=message.video.file_id,
forwarded_ids={'channel': channel_msg_id} if channel_msg_id else None
)
await message.answer("✅ Видео переслано в канал")
@router.message(F.document) @router.message(F.document)
async def handle_document_message(message: Message): async def handle_document_message(message: Message):
"""Обработчик документов""" """Обработчик документов - глобальный чат (broadcast всем)"""
async with async_session_maker() as session: async with async_session_maker() as session:
can_send, reason = await ChatPermissionService.can_send_message( can_send, reason = await ChatPermissionService.can_send_message(
session, session,
@@ -322,47 +274,34 @@ async def handle_document_message(message: Message):
await message.answer(f"❌ {reason}") await message.answer(f"❌ {reason}")
return return
settings = await ChatSettingsService.get_or_create_settings(session)
user = await UserService.get_user_by_telegram_id(session, message.from_user.id) user = await UserService.get_user_by_telegram_id(session, message.from_user.id)
if not user: if not user:
await message.answer("❌ Вы не зарегистрированы. Используйте /start")
return return
if settings.mode == 'broadcast': forwarded_ids, success, fail = await broadcast_message_with_scheduler(message, exclude_user_id=message.from_user.id)
forwarded_ids, success, fail = await broadcast_message_with_scheduler(message, exclude_user_id=message.from_user.id)
await ChatMessageService.save_message(
await ChatMessageService.save_message( session,
session, user_id=user.id,
user_id=user.id, telegram_message_id=message.message_id,
telegram_message_id=message.message_id, message_type='document',
message_type='document', text=message.caption,
text=message.caption, file_id=message.document.file_id,
file_id=message.document.file_id, forwarded_ids=forwarded_ids
forwarded_ids=forwarded_ids )
)
await message.answer(
await message.answer(f"✅ Документ разослан: {success} получателей") f"✅ Документ разослан!\n"
f"📤 Доставлено: {success}\n"
elif settings.mode == 'forward': f"❌ Не доставлено: {fail}"
if settings.forward_chat_id: )
success, channel_msg_id = await forward_to_channel(message, settings.forward_chat_id)
if success:
await ChatMessageService.save_message(
session,
user_id=user.id,
telegram_message_id=message.message_id,
message_type='document',
text=message.caption,
file_id=message.document.file_id,
forwarded_ids={'channel': channel_msg_id} if channel_msg_id else None
)
await message.answer("✅ Документ переслан в канал")
@router.message(F.animation) @router.message(F.animation)
async def handle_animation_message(message: Message): async def handle_animation_message(message: Message):
"""Обработчик GIF анимаций""" """Обработчик GIF анимаций - глобальный чат (broadcast всем)"""
async with async_session_maker() as session: async with async_session_maker() as session:
can_send, reason = await ChatPermissionService.can_send_message( can_send, reason = await ChatPermissionService.can_send_message(
session, session,
@@ -374,47 +313,34 @@ async def handle_animation_message(message: Message):
await message.answer(f"❌ {reason}") await message.answer(f"❌ {reason}")
return return
settings = await ChatSettingsService.get_or_create_settings(session)
user = await UserService.get_user_by_telegram_id(session, message.from_user.id) user = await UserService.get_user_by_telegram_id(session, message.from_user.id)
if not user: if not user:
await message.answer("❌ Вы не зарегистрированы. Используйте /start")
return return
if settings.mode == 'broadcast': forwarded_ids, success, fail = await broadcast_message_with_scheduler(message, exclude_user_id=message.from_user.id)
forwarded_ids, success, fail = await broadcast_message_with_scheduler(message, exclude_user_id=message.from_user.id)
await ChatMessageService.save_message(
await ChatMessageService.save_message( session,
session, user_id=user.id,
user_id=user.id, telegram_message_id=message.message_id,
telegram_message_id=message.message_id, message_type='animation',
message_type='animation', text=message.caption,
text=message.caption, file_id=message.animation.file_id,
file_id=message.animation.file_id, forwarded_ids=forwarded_ids
forwarded_ids=forwarded_ids )
)
await message.answer(
await message.answer(f"✅ Анимация разослана: {success} получателей") f"✅ Анимация разослана!\n"
f"📤 Доставлено: {success}\n"
elif settings.mode == 'forward': f"❌ Не доставлено: {fail}"
if settings.forward_chat_id: )
success, channel_msg_id = await forward_to_channel(message, settings.forward_chat_id)
if success:
await ChatMessageService.save_message(
session,
user_id=user.id,
telegram_message_id=message.message_id,
message_type='animation',
text=message.caption,
file_id=message.animation.file_id,
forwarded_ids={'channel': channel_msg_id} if channel_msg_id else None
)
await message.answer("✅ Анимация переслана в канал")
@router.message(F.sticker) @router.message(F.sticker)
async def handle_sticker_message(message: Message): async def handle_sticker_message(message: Message):
"""Обработчик стикеров""" """Обработчик стикеров - глобальный чат (broadcast всем)"""
async with async_session_maker() as session: async with async_session_maker() as session:
can_send, reason = await ChatPermissionService.can_send_message( can_send, reason = await ChatPermissionService.can_send_message(
session, session,
@@ -426,45 +352,33 @@ async def handle_sticker_message(message: Message):
await message.answer(f"❌ {reason}") await message.answer(f"❌ {reason}")
return return
settings = await ChatSettingsService.get_or_create_settings(session)
user = await UserService.get_user_by_telegram_id(session, message.from_user.id) user = await UserService.get_user_by_telegram_id(session, message.from_user.id)
if not user: if not user:
await message.answer("❌ Вы не зарегистрированы. Используйте /start")
return return
if settings.mode == 'broadcast': forwarded_ids, success, fail = await broadcast_message_with_scheduler(message, exclude_user_id=message.from_user.id)
forwarded_ids, success, fail = await broadcast_message_with_scheduler(message, exclude_user_id=message.from_user.id)
await ChatMessageService.save_message(
await ChatMessageService.save_message( session,
session, user_id=user.id,
user_id=user.id, telegram_message_id=message.message_id,
telegram_message_id=message.message_id, message_type='sticker',
message_type='sticker', file_id=message.sticker.file_id,
file_id=message.sticker.file_id, forwarded_ids=forwarded_ids
forwarded_ids=forwarded_ids )
)
await message.answer(
await message.answer(f"✅ Стикер разослан: {success} получателей") f"✅ Стикер разослан!\n"
f"📤 Доставлено: {success}\n"
elif settings.mode == 'forward': f"❌ Не доставлено: {fail}"
if settings.forward_chat_id: )
success, channel_msg_id = await forward_to_channel(message, settings.forward_chat_id)
if success:
await ChatMessageService.save_message(
session,
user_id=user.id,
telegram_message_id=message.message_id,
message_type='sticker',
file_id=message.sticker.file_id,
forwarded_ids={'channel': channel_msg_id} if channel_msg_id else None
)
await message.answer("✅ Стикер переслан в канал")
@router.message(F.voice) @router.message(F.voice)
async def handle_voice_message(message: Message): async def handle_voice_message(message: Message):
"""Обработчик голосовых сообщений""" """Обработчик голосовых сообщений - глобальный чат (broadcast всем)"""
async with async_session_maker() as session: async with async_session_maker() as session:
can_send, reason = await ChatPermissionService.can_send_message( can_send, reason = await ChatPermissionService.can_send_message(
session, session,
@@ -476,37 +390,25 @@ async def handle_voice_message(message: Message):
await message.answer(f"❌ {reason}") await message.answer(f"❌ {reason}")
return return
settings = await ChatSettingsService.get_or_create_settings(session)
user = await UserService.get_user_by_telegram_id(session, message.from_user.id) user = await UserService.get_user_by_telegram_id(session, message.from_user.id)
if not user: if not user:
await message.answer("❌ Вы не зарегистрированы. Используйте /start")
return return
if settings.mode == 'broadcast': forwarded_ids, success, fail = await broadcast_message_with_scheduler(message, exclude_user_id=message.from_user.id)
forwarded_ids, success, fail = await broadcast_message_with_scheduler(message, exclude_user_id=message.from_user.id)
await ChatMessageService.save_message(
await ChatMessageService.save_message( session,
session, user_id=user.id,
user_id=user.id, telegram_message_id=message.message_id,
telegram_message_id=message.message_id, message_type='voice',
message_type='voice', file_id=message.voice.file_id,
file_id=message.voice.file_id, forwarded_ids=forwarded_ids
forwarded_ids=forwarded_ids )
)
await message.answer(
await message.answer(f"✅ Голосовое сообщение разослано: {success} получателей") f"✅ Голосовое сообщение разослано!\n"
f"📤 Доставлено: {success}\n"
elif settings.mode == 'forward': f"❌ Не доставлено: {fail}"
if settings.forward_chat_id: )
success, channel_msg_id = await forward_to_channel(message, settings.forward_chat_id)
if success:
await ChatMessageService.save_message(
session,
user_id=user.id,
telegram_message_id=message.message_id,
message_type='voice',
file_id=message.voice.file_id,
forwarded_ids={'channel': channel_msg_id} if channel_msg_id else None
)
await message.answer("✅ Голосовое сообщение переслано в канал")