Skip to content
TheChatArchiveThe Chat Archive
gpt-4o-2024-08-06· OpenAIAi2 WildChat-4.8M (AI2)

if 'messageid' in activation: messageid = activation['messageid'] зачем это нужно? это…

  1. User

    if 'message_id' in activation: message_id = activation['message_id']

    зачем это нужно? это не лишнее?

    import asyncio import logging import time from typing import Dict, Any from aiogram import Dispatcher, types, F, Bot from aiogram.utils.keyboard import InlineKeyboardBuilder from aiogram.fsm.context import FSMContext

    from ..data import get_user_api_key from ..api import SmsHubAPI from ..utils import safe_edit_or_send_message, safe_delete_message from .start import send_main_menu from ..constants import SERVICE_DISPLAY_NAMES

    logger = logging.getLogger(name)

    Глобальная переменная для активаций

    user_activations: Dict[int, Dict[str, Dict[str, Any]]] = {}

    async def current_activations_handler(callback_query: types.CallbackQuery, state: FSMContext): try: await callback_query.answer() except Exception as e: logger.warning(f"Не удалось ответить на callback_query: {e}") user_id = callback_query.from_user.id activations = user_activations.get(user_id, {}) if not activations: keyboard = InlineKeyboardBuilder() keyboard.button(text="🔙 Назад", callback_data="back_to_main_menu") keyboard.adjust(1) await safe_edit_or_send_message( message=callback_query.message, new_text="У вас нет активных активаций.", state=state, reply_markup=keyboard.as_markup() ) return

    keyboard = InlineKeyboardBuilder()
    for activation_id, data in activations.items():
        service_name = SERVICE_DISPLAY_NAMES.get(data['service'], data['service'])
        keyboard.button(
            text=f"{service_name} ({data['number']}) - {data['status']}",
            callback_data=f"manage_activation:{activation_id}"
        )
    keyboard.button(text="🔙 Назад", callback_data="back_to_main_menu")
    keyboard.adjust(1)
    
    # Используем `message_id` из сохраненного активацией сообщения
    if 'message_id' in data:
        message_id = data['message_id']
        try:
            await callback_query.message.bot.edit_message_text(
                chat_id=callback_query.message.chat.id,
                message_id=message_id,
                text="Ваши текущие активации:",
                reply_markup=keyboard.as_markup()
            )
        except Exception as e:
            logger.error(f"Ошибка при редактировании сообщения: {e}")
    

    async def manage_activation_handler(callback_query: types.CallbackQuery, state: FSMContext): try: await callback_query.answer() except Exception as e: logger.warning(f"Не удалось ответить на callback_query: {e}")

    user_id = callback_query.from_user.id
    activation_id = callback_query.data.split(":")[1]
    activations = user_activations.get(user_id, {})
    activation = activations.get(activation_id)
    
    if not activation:
        await safe_edit_or_send_message(
            message=callback_query.message,
            new_text="Активация не найдена.",
            state=state,
            reply_markup=callback_query.message.reply_markup
        )
        return
    
    service_name = SERVICE_DISPLAY_NAMES.get(activation['service'], activation['service'])
    
    keyboard = InlineKeyboardBuilder()
    
    if activation['status'] == 'Ожидание SMS':
        keyboard.button(text="❌ Отменить активацию", callback_data=f"cancel_activation:{activation_id}")
    elif activation['status'].startswith('Код получен'):
        keyboard.button(text="📂 Текущие активации", callback_data="current_activations")
        keyboard.button(text="✅ Завершить активацию", callback_data=f"complete_activation:{activation_id}")
    elif activation['status'].startswith('Ожидание повторного SMS'):
        keyboard.button(text="✅ Завершить активацию", callback_data=f"complete_activation:{activation_id}")
    else:
        keyboard.button(text="✅ Завершить активацию", callback_data=f"complete_activation:{activation_id}")
        keyboard.button(text="❌ Отменить активацию", callback_data=f"cancel_activation:{activation_id}")
    
    keyboard.button(text="🔙 Назад", callback_data="current_activations")
    keyboard.adjust(1)
    
    if 'message_id' in activation:
        message_id = activation['message_id']
        try:
            await callback_query.message.bot.edit_message_text(
                chat_id=callback_query.message.chat.id,
                message_id=message_id,
                text=(
                    f"*Активация:* {activation_id}\n"
                    f"*Сервис:* {service_name}\n"
                    f"*Номер:* `{activation['number']}`\n"
                    f"*Статус:* {activation['status']}"
                ),
                reply_markup=keyboard.as_markup(),
                parse_mode="Markdown"
            )
        except Exception as e:
            logger.error(f"Ошибка при редактировании сообщения: {e}")
    

    async def cancel_activation_handler(callback_query: types.CallbackQuery, state: FSMContext): try: await callback_query.answer() except Exception as e: logger.warning(f"Не удалось ответить на callback_query: {e}")

    user_id = callback_query.from_user.id
    activation_id = callback_query.data.split(":")[1]
    user_api_key = get_user_api_key(user_id)
    smshub_api = SmsHubAPI(user_api_key)
    
    activations = user_activations.get(user_id, {})
    activation = activations.get(activation_id)
    
    if activation:
        task = activation.get('task')
        if task:
            task.cancel()
    
        result = await smshub_api.cancel_activation(activation_id)
        logger.info(f"Активация {activation_id} отменена на стороне API: {result}")
    
        del activations[activation_id]
    
        keyboard = InlineKeyboardBuilder()
        keyboard.button(text="🔙 Назад", callback_data="current_activations")
        keyboard.adjust(1)
    
        if 'message_id' in activation:
            message_id = activation['message_id']
            try:
                await callback_query.message.bot.edit_message_text(
                    chat_id=callback_query.message.chat.id,
                    message_id=message_id,
                    text="Активация успешно отменена.",
                    reply_markup=keyboard.as_markup()
                )
            except Exception as e:
                logger.error(f"Ошибка при редактировании сообщения: {e}")
    else:
        await safe_edit_or_send_message(
            message=callback_query.message,
            new_text="Активация не найдена.",
            state=state,
            reply_markup=callback_query.message.reply_markup
        )
    

    async def request_another_sms_handler(callback_query: types.CallbackQuery, state: FSMContext): try: await callback_query.answer() except Exception as e: logger.warning(f"Не удалось ответить на callback_query: {e}")

    user_id = callback_query.from_user.id
    activation_id = callback_query.data.split(":")[1]
    user_api_key = get_user_api_key(user_id)
    smshub_api = SmsHubAPI(user_api_key)
    activations = user_activations.get(user_id, {})
    activation = activations.get(activation_id)
    
    if not activation:
        await safe_edit_or_send_message(
            message=callback_query.message,
            new_text="Активация не найдена.",
            state=state,
            reply_markup=callback_query.message.reply_markup
        )
        return
    
    result = await smshub_api.set_status(activation_id, status="3")
    if result == "ACCESS_RETRY_GET":
        task = activation.get('task')
        if task:
            task.cancel()
    
        task = asyncio.create_task(poll_for_sms(
            bot=callback_query.message.bot,
            user_id=user_id,
            chat_id=callback_query.from_user.id,
            activation_id=activation_id,
            smshub_api=smshub_api
        ))
        activation['task'] = task
        activation['status'] = 'Ожидание повторного SMS'
    
        if 'message_id' in activation:
            message_id = activation['message_id']
            try:
                await callback_query.message.bot.edit_message_text(
                    chat_id=callback_query.message.chat.id,
                    message_id=message_id,
                    text="Запрошен повторный SMS. Ожидание SMS...",
                    reply_markup=callback_query.message.reply_markup
                )
            except Exception as e:
                logger.error(f"Ошибка при редактировании сообщения: {e}")
    else:
        logger.error(f"Не удалось запросить повторное SMS. Ответ: {result}")
        await safe_edit_or_send_message(
            message=callback_query.message,
            new_text="Не удалось запросить повторный SMS. Попробуйте снова.",
            state=state,
            reply_markup=callback_query.message.reply_markup
        )
    

    async def complete_activation_handler(callback_query: types.CallbackQuery, state: FSMContext): try: await callback_query.answer() except Exception as e: logger.warning(f"Не удалось ответить на callback_query: {e}")

    user_id = callback_query.from_user.id
    activation_id = callback_query.data.split(":")[1]
    user_api_key = get_user_api_key(user_id)
    smshub_api = SmsHubAPI(user_api_key)
    activations = user_activations.get(user_id, {})
    activation = activations.get(activation_id)
    
    if not activation:
        await safe_edit_or_send_message(
            message=callback_query.message,
            new_text="Активация не найдена.",
            state=state,
            reply_markup=callback_query.message.reply_markup
        )
        return
    
    result = await smshub_api.set_status(activation_id, status="6")
    if result == "ACCESS_ACTIVATION":
        task = activation.get('task')
        if task:
            task.cancel()
    
        del activations[activation_id]
    
        keyboard = InlineKeyboardBuilder()
        keyboard.button(text="🔙 Назад", callback_data="current_activations")
        keyboard.adjust(1)
    
        if 'message_id' in activation:
            message_id = activation['message_id']
            try:
                await callback_query.message.bot.edit_message_text(
                    chat_id=callback_query.message.chat.id,
                    message_id=message_id,
                    text="Активация успешно завершена.",
                    reply_markup=keyboard.as_markup()
                )
            except Exception as e:
                logger.error(f"Ошибка при редактировании сообщения: {e}")
    else:
        logger.error(f"Не удалось завершить активацию. Ответ: {result}")
        await safe_edit_or_send_message(
            message=callback_query.message,
            new_text="Не удалось завершить активацию. Попробуйте снова.",
            state=state,
            reply_markup=callback_query.message.reply_markup
        )
    

    async def poll_for_sms(bot: Bot, user_id: int, chat_id: int, activation_id: str, smshub_api: SmsHubAPI): activations = user_activations.get(user_id, {}) activation = activations.get(activation_id)

    if not activation:
        logger.error(f"Активация {activation_id} не найдена для пользователя {user_id}.")
        return
    
    try:
        max_wait_time = 300
        poll_interval = 3
        elapsed_time = 0
    
        while elapsed_time < max_wait_time:
            await asyncio.sleep(poll_interval)
            elapsed_time += poll_interval
    
            status_response = await smshub_api.get_status(activation_id)
            if not status_response:
                logger.error("Нет ответа при запросе статуса активации.")
                await bot.send_message(chat_id, "Не удалось получить статус активации. Попробуйте позже.")
                return
    
            status_parts = status_response.split(":", 1)
            status = status_parts[0]
    
            if status == "STATUS_WAIT_CODE":
                logger.debug(f"Ожидание SMS кода для активации {activation_id}.")
                activation['last_update'] = time.time()
                continue
            elif status.startswith("STATUS_WAIT_RETRY"):
                last_code = status_parts[1] if len(status_parts) > 1 else "нет предыдущего кода"
                logger.info(f"Ожидание повторного SMS кода, последний код: {last_code}")
                activation['status'] = f'Ожидание повторного SMS (последний код: {last_code})'
                activation['last_update'] = time.time()
                continue
            elif status == "STATUS_CANCEL":
                await bot.send_message(chat_id, "Активация была отменена.")
                activation['status'] = 'Активация отменена'
                return
            elif status == "STATUS_OK":
                code = status_parts[1] if len(status_parts) > 1 else "Код не получен"
                logger.info(f"Получен код активации для {activation_id}: {code}")
                activation['status'] = f'Код получен: {code}'
                activation['last_update'] = time.time()
    
                # Создаем инлайн-клавиатуру
                keyboard = InlineKeyboardBuilder()
                keyboard.button(text="📂 Текущие активации", callback_data="current_activations")
                keyboard.button(text="✅ Завершить активацию", callback_data=f"complete_activation:{activation_id}")
                keyboard.adjust(1)
    
                # Удаляем предыдущее сообщение, чтобы с новыми появилось уведомление
                previous_message_id = activation.get("message_id")
                await safe_delete_message(bot, chat_id, previous_message_id)
    
                # Отправляем новое сообщение
                sent_message = await bot.send_message(
                    chat_id=chat_id,
                    text=f"Код активации для номера `{activation['number']}`: `{code}`",
                    reply_markup=keyboard.as_markup(),
                    parse_mode="Markdown"
                )
                activation['message_id'] = sent_message.message_id
    
                return
            else:
                logger.error(f"Непредвиденный статус активации: {status_response}")
                activation['status'] = f'Неизвестный статус: {status}'
                await bot.send_message(chat_id, f"Неизвестный статус активации: {status}")
                return
    except asyncio.CancelledError:
        logger.info(f"Задача poll_for_sms для активации {activation_id} была отменена.")
    except Exception as e:
        logger.error(f"Ошибка в poll_for_sms: {e}")
        activation['status'] = 'Ошибка при получении SMS'
        await bot.send_message(chat_id, "Произошла ошибка при получении SMS.")
    

    def register_activation_handlers(dp: Dispatcher): dp.callback_query.register(current_activations_handler, F.data == "current_activations") dp.callback_query.register(manage_activation_handler, F.data.startswith("manage_activation")) dp.callback_query.register(cancel_activation_handler, F.data.startswith("cancel_activation")) dp.callback_query.register(request_another_sms_handler, F.data.startswith("request_another_sms")) dp.callback_query.register(complete_activation_handler, F.data.startswith("complete_activation"))

  2. Assistant

    In your code, the lines checking for 'message_id' in the activation dictionary and subsequently using it are not redundant—they serve a specific purpose. Let's break down why these lines are necessary:

    1. Purpose of 'message_id': The 'message_id' entry in the activation dictionary is used to store the ID of the Telegram message that the bot initially sent to the user. This allows the bot to later reference and edit this specific message, rather than sending a new message. This is useful for updating the content without cluttering the chat with new messages.

    2. Reason for Checking 'message_id': The condition if 'message_id' in activation: is necessary because activation may not always have a 'message_id' stored, particularly if it's newly created or if there's some error when trying to store the message ID. By checking if 'message_id' exists, you avoid potential errors that could happen when you try to access an undefined key in the dictionary.

    3. Use Case within Your Handlers:

      • Whenever there is a need to update the status of an activation or its representation in the chat, having the message_id allows you to use Telegram API methods like edit_message_text to directly modify the existing message. This keeps your bot's chat clean and less confusing for users.
      • Using the message_id to locate and edit a specific message is more efficient and creates a better user experience, especially in highly interactive applications like chatbots.

    In conclusion, the checks for 'message_id' are vital to ensure your bot can appropriately manage and update messages related to user activations. They are not redundant; rather, they are essential for robust message handling logic within the bot's architecture.

  3. User

    на русском

  4. Assistant

    В вашем коде строки, которые проверяют наличие ключа 'message_id' в словаре activation и используют его, не являются лишними — они выполняют конкретную функцию. Давайте разберем, почему эти строки необходимы:

    1. Назначение 'message_id': Ключ 'message_id' в словаре activation используется для хранения ID сообщения в Telegram, которое бот изначально отправил пользователю. Это позволяет боту позже ссылаться на это конкретное сообщение и редактировать его, а не отправлять новое сообщение. Это полезно для обновления содержания без засорения чата новыми сообщениями.

    2. Зачем проверять 'message_id': Условие if 'message_id' in activation: необходимо, потому что в activation не всегда может быть сохранен ключ 'message_id', особенно если активация только что создана или произошла какая-то ошибка при попытке сохранить ID сообщения. Проверка существования 'message_id' позволяет избежать ошибок, которые могут возникнуть при попытке доступа к неопределенному ключу в словаре.

    3. Использование в ваших обработчиках:

      • Каждый раз, когда необходимо обновить статус активации или ее представление в чате, наличие message_id позволяет вам использовать методы Telegram API, такие как edit_message_text, чтобы напрямую изменить существующее сообщение. Это помогает вашему боту поддерживать чистоту чата и избегать путаницы у пользователей.
      • Использование message_id для нахождения и редактирования конкретного сообщения более эффективно и создает лучший пользовательский опыт, особенно в интерактивных приложениях, таких как чат-боты.

    В итоге, проверки с использованием 'message_id' являются важными для того, чтобы ваш бот мог надлежащим образом управлять и обновлять сообщения, связанные с активациями пользователей. Это не избыточные элементы, а, наоборот, необходимые для устойчивой логики обработки сообщений в архитектуре бота.

  5. User

    стоит ли сюда что-то добавить?

    bot/handlers/init.py

    from aiogram import Dispatcher

    from .start import register_start_handlers from .settings import register_settings_handlers from .balance import register_balance_handlers from .sms import register_sms_handlers from .activation import register_activation_handlers from .errors import register_error_handlers

    def register_handlers(dp: Dispatcher): register_start_handlers(dp) register_settings_handlers(dp) register_balance_handlers(dp) register_sms_handlers(dp) register_activation_handlers(dp) register_error_handlers(dp)

  6. Assistant

    Ваш файл __init__.py в папке handlers служит важной целью — регистрацией всех обработчиков для вашего бота. На первый взгляд, он выглядит достаточно полным и хорошо организованным, так как все функции регистрации импортируются и вызываются последовательно для настройки диспетчера.

    Тем не менее, вот несколько мыслей и рекомендаций, которые могут помочь улучшить структуру или функциональность вашего __init__.py, в зависимости от ваших потребностей:

    1. Документация:

      • Добавьте комментарий или docstring, описывающий, что именно делает функция register_handlers. Это поможет другим разработчикам (и вам самим в будущем) быстрее понять назначение кода.
    2. Логирование:

      • Если у вас есть система логирования, рассмотрите возможность добавления простого лога для информирования о том, что регистрация обработчиков началась и успешно завершена. Это может быть полезно для отладки или аудита.

        import logging
        logger = logging.getLogger(__name__)
        
        def register_handlers(dp: Dispatcher):
            logger.info("Начало регистрации обработчиков.")
            register_start_handlers(dp)
            register_settings_handlers(dp)
            register_balance_handlers(dp)
            register_sms_handlers(dp)
            register_activation_handlers(dp)
            register_error_handlers(dp)
            logger.info("Регистрация обработчиков завершена.")
        
    3. Гибкость:

      • Если у вас есть планы в будущем динамически настраивать регистрацию обработчиков (например, в зависимости от конфигурации или окружения), вы можете использовать какой-нибудь конфигурационный файл или параметры командной строки для определения, какие обработчики регистрировать.
    4. Обработка ошибок:

      • В некоторых случаях может быть полезно добавить обработку ошибок, чтобы поймать и логировать исключения, которые могут возникнуть при регистрации обработчиков.

    Тем не менее, если ваше приложение работает стабильно и не планируется значительных изменений в ближайшее время, то ваш текущий подход к организации файла вполне адекватен и может оставаться таким. Добавление новых функциональностей всегда должно быть обосновано реальными потребностями или предстоящими изменениями архитектуры.