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

смотри, в этом коде есть проблема, я сделал специально так, чтобы "код активации"…

  1. User

    смотри, в этом коде есть проблема, я сделал специально так, чтобы "код активации" приходил как новое сообщение удаляя предудущее, чтобы тем самым создать уведомление, так и нужно, но из-за этого при дальнейшем нажатии на кнопки под сообщением "код активации" телеграм не может найти сообщение для удаления и не может прислать следубщее сообщение в текущем с помощью функции редактирования текста и ему приходитсчя отправлять новоое сообщение, а мне то не нужно, мне нужно, чтобы всегда все сообщеняи были в текущем сообщении, можно это испарвить?

    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 ..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)
    
    await safe_edit_or_send_message(
        message=callback_query.message,
        new_text="Ваши текущие активации:",
        state=state,
        reply_markup=keyboard.as_markup()
    )
    

    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)
    
    await safe_edit_or_send_message(
        message=callback_query.message,
        new_text=(
            f"*Активация:* {activation_id}\n"
            f"*Сервис:* {service_name}\n"
            f"*Номер:* `{activation['number']}`\n"
            f"*Статус:* {activation['status']}"
        ),
        state=state,
        reply_markup=keyboard.as_markup(),
        parse_mode="Markdown"
    )
    

    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)
    
        await safe_edit_or_send_message(
            message=callback_query.message,
            new_text="Активация успешно отменена.",
            state=state,
            reply_markup=keyboard.as_markup()
        )
    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'
    
        await safe_edit_or_send_message(
            message=callback_query.message,
            new_text="Запрошен повторный SMS. Ожидание SMS...",
            state=state,
            reply_markup=callback_query.message.reply_markup
        )
    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)
    
        await safe_edit_or_send_message(
            message=callback_query.message,
            new_text="Активация успешно завершена.",
            state=state,
            reply_markup=keyboard.as_markup()
        )
    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

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

    1. Вместо отправки нового сообщения с кодом активации, попробуем сразу редактировать существующее.
    2. Используйте отдельную логику удаления сообщений только тогда, когда это формально необходимо.

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

    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")
                    try:
                        await bot.edit_message_text(
                            chat_id=chat_id,
                            message_id=previous_message_id,
                            text=f"Код активации для номера `{activation['number']}`: `{code}`",
                            reply_markup=keyboard.as_markup(),
                            parse_mode="Markdown"
                        )
                    except Exception as e:
                        logger.warning(f"Не удалось отредактировать сообщение: {e}")
                        # Если не удалось отредактировать, отправляем новое сообщение
                        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.")
    

    Этот пример улучшает предыдущую попытку удаления сообщений, монтируя логику на редактирование текста существующего сообщения. Если это не удается (например, если сообщение уже удалено), просто отправляется новое сообщение.

    Этот подход минимизирует количество посылаемых новых сообщений и улучшает устойчивость вашей системы к возникновению ошибок при редактировании сообщений.

  3. User

    у меня уже есть логика замены сообщений, вот она в отдельном фалйе utils: import logging import time import aiohttp from aiogram import Bot, types from aiogram.exceptions import TelegramBadRequest from aiogram.fsm.context import FSMContext from aiogram import Dispatcher from typing import Optional

    logger = logging.getLogger(name)

    EXCHANGE_RATE_API_URL = "https://api.exchangerate-api.com/v4/latest/USD" USD_TO_RUB_RATE_TTL = 3600

    _cached_usd_to_rub_rate: Optional[float] = None _cached_usd_to_rub_rate_time: float = 0.0

    async def get_usd_to_rub_rate() -> Optional[float]: global _cached_usd_to_rub_rate, _cached_usd_to_rub_rate_time now = time.time() if _cached_usd_to_rub_rate and (now - _cached_usd_to_rub_rate_time < USD_TO_RUB_RATE_TTL): return _cached_usd_to_rub_rate try: async with aiohttp.ClientSession() as session: async with session.get(EXCHANGE_RATE_API_URL) as response: data = await response.json() rate = data.get('rates', {}).get('RUB') if rate: _cached_usd_to_rub_rate = rate _cached_usd_to_rub_rate_time = now return rate else: logger.error("Курс RUB не найден в ответе.") return None except Exception as e: logger.error(f"Ошибка при запросе курса валют: {e}") return None

    async def safe_edit_or_send_message( message: types.Message, new_text: str, state: FSMContext, **kwargs ) -> Optional[types.Message]: data = await state.get_data() last_message_id = data.get('last_message_id') last_message_text = data.get('last_message_text') last_reply_markup = data.get('last_reply_markup')

    new_reply_markup = kwargs.get("reply_markup")
    
    if last_message_id and (last_message_text != new_text or last_reply_markup != new_reply_markup):
        try:
            sent_message = await message.bot.edit_message_text(
                new_text,
                chat_id=message.chat.id,
                message_id=last_message_id,
                **kwargs
            )
            await state.update_data(last_message_text=new_text, last_reply_markup=new_reply_markup)
            return sent_message
        except TelegramBadRequest as e:
            if "message can't be edited" in str(e).lower():
                logger.warning(f"Сообщение не может быть отредактировано: {e}. Пробуем отправить новое сообщение.")
            else:
                logger.error(f"Ошибка при редактировании сообщения: {e}")
        except Exception as e:
            logger.exception(f"Неожиданная ошибка при редактировании сообщения: {e}")
    
    if last_message_id:
        try:
            await message.bot.delete_message(chat_id=message.chat.id, message_id=last_message_id)
        except Exception as del_exc:
            logger.error(f"Не удалось удалить сообщение: {del_exc}")
    
    try:
        sent_message = await message.answer(new_text, **kwargs)
        await state.update_data(
            last_message_id=sent_message.message_id,
            last_message_text=new_text,
            last_reply_markup=new_reply_markup
        )
        return sent_message
    except Exception as e:
        logger.error(f"Не удалось отправить новое сообщение: {e}")
        return None
    

    async def safe_delete_message(bot: Bot, chat_id: int, message_id: int) -> None: try: await bot.delete_message(chat_id=chat_id, message_id=message_id) except Exception as e: logger.error(f"Не удалось удалить сообщение: {e}")

    async def on_startup(dispatcher: Dispatcher): logger.info("Бот успешно запущен.")

  4. Assistant

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

    1. Неправильным сохранением и управлением состоянием сообщений.
    2. Попыткой редактировать сообщение, которое уже было удалено.
    3. Возникновением исключений, которые не обрабатываются должным образом.

    Вот несколько советов для устранения этих проблем:

    1. Проверьте обновление состояния

    Убедитесь, что вы правильно сохраняете и обновляете last_message_id, last_message_text и last_reply_markup в состоянии пользователя. Это важно для того, чтобы функция safe_edit_or_send_message могла корректно работать с последним сообщением:

    • Проверьте, что данные обновляются после каждого отправленного сообщения.
    • Проверьте, что вы адекватно извлекаете состояние перед вызовом safe_edit_or_send_message.

    2. Обработка исключений

    В вашем методе вы уже обрабатываете исключения TelegramBadRequest, но можно добавить дополнительные логи для других ошибок, чтобы лучше понимать, что происходит:

    except TelegramBadRequest as e:
        if "message can't be edited" in str(e).lower():
            logger.warning(f"Сообщение не может быть отредактировано: {e}. Пробуем отправить новое сообщение.")
        else:
            logger.error(f"Ошибка при редактировании сообщения: {e}")
    except Exception as e:
        logger.exception(f"Неожиданная ошибка при редактировании сообщения: {e}")
    

    3. Используйте подходящие данные

    Убедитесь, что когда вы вызываете safe_edit_or_send_message, вы передаете правильное состояние и данные сообщения. Вот пример того, как вы можете использовать этот метод:

    await safe_edit_or_send_message(
        message=callback_query.message,
        new_text="Ваш новый текст сообщения",
        state=state,
        reply_markup=keyboard.as_markup()  # Предполагая, что вы уже собрали клавиатуру заранее
    )
    

    4. Логирование

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

    Заключение

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

  5. User

    можешль исрпавтиь коды и присалть мне готовый исправленный вариант

  6. Assistant

    Конечно. Давайте попробуем отладить и исправить основные проблемы в вашем коде, связав логику safe_edit_or_send_message с обработчиками. Я постараюсь внести необходимые изменения, чтобы ваш код работал как задумано, сохраняя сообщения и корректно их редактируя.

    Вот как может выглядеть ваш обновленный код:

    Основной код:

    import asyncio
    import logging
    from typing import Dict, Any
    from aiogram import Dispatcher, types, F
    from aiogram.fsm.context import FSMContext
    from aiogram.utils.keyboard import InlineKeyboardBuilder
    
    from ..data import get_user_api_key
    from ..api import SmsHubAPI
    from ..utils import safe_edit_or_send_message, safe_delete_message
    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, {})
    
        keyboard = InlineKeyboardBuilder()
        if not activations:
            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
    
        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)
    
        await safe_edit_or_send_message(
            message=callback_query.message,
            new_text="Ваши текущие активации:",
            state=state,
            reply_markup=keyboard.as_markup()
        )
    
    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)
    
        await safe_edit_or_send_message(
            message=callback_query.message,
            new_text=(
                f"*Активация:* {activation_id}\n"
                f"*Сервис:* {service_name}\n"
                f"*Номер:* `{activation['number']}`\n"
                f"*Статус:* {activation['status']}"
            ),
            state=state,
            reply_markup=keyboard.as_markup(),
            parse_mode="Markdown"
        )
    
    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)
    
            await safe_edit_or_send_message(
                message=callback_query.message,
                new_text="Активация успешно отменена.",
                state=state,
                reply_markup=keyboard.as_markup()
            )
        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'
    
            await safe_edit_or_send_message(
                message=callback_query.message,
                new_text="Запрошен повторный SMS. Ожидание SMS...",
                state=state,
                reply_markup=callback_query.message.reply_markup
            )
        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)
    
            await safe_edit_or_send_message(
                message=callback_query.message,
                new_text="Активация успешно завершена.",
                state=state,
                reply_markup=keyboard.as_markup()
            )
        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")
                    if previous_message_id:
                        try:
                            await bot.edit_message_text(
                                chat_id=chat_id,
                                message_id=previous_message_id,
                                text=f"Код активации для номера `{activation['number']}`: `{code}`",
                                reply_markup=keyboard.as_markup(),
                                parse_mode="Markdown"
                            )
                        except TelegramBadRequest as e:
                            if "message can't be edited" in str(e).lower():
                                logger.warning("Сообщение не может быть отредактировано: Отправка нового сообщения.")
                            else:
                                logger.error(f"Ошибка при редактировании сообщения: {e}")
                    else:
                        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"))
    

    Объяснение

    1. Проверка существования сообщения: Пред варименно проверяем, существует ли идентификатор последнего отправленного сообщения. Если нет, просто отправляем новое сообщение.

    2. Точечное обновление контекста: Убедитесь, что мы всегда сохраняем состояние сообщения и его данные (текст, разметка), чтобы использованные переустановки убедились, что сообщение всегда можно было изменить.

    3. Проверка на редактирование: Удаление/изменение сообщения происходит только по необходимости. Лишние обращения к API Телеграм минимизируются.

    Надеюсь, в результате этого обновления ваш код будет работать исправно, и сообщения будут корректно обрабатываться в контексте вашего чат-бота.

  7. User

    нет, все сообщеняи всега должны быть внутри одного сообщения и у меня бот задуман так, что всегда эти сообщеняи можно редактировать, сделай это

  8. Assistant

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

    Вот как вы можете реализовать это:

    1. Используйте состояние пользователя для хранения идентификатора сообщения, которое вы редактируете.
    2. Всегда проверяйте возможность редактирования сообщения перед попыткой его редактирования.

    Обновим основной код, чтобы отражать эти изменения:

    import asyncio
    import logging
    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
    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, {})
    
        keyboard = InlineKeyboardBuilder()
        if not activations:
            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
    
        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)
    
        await safe_edit_or_send_message(
            message=callback_query.message,
            new_text="Ваши текущие активации:",
            state=state,
            reply_markup=keyboard.as_markup()
        )
    
    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)
    
        await safe_edit_or_send_message(
            message=callback_query.message,
            new_text=(
                f"*Активация:* {activation_id}\n"
                f"*Сервис:* {service_name}\n"
                f"*Номер:* `{activation['number']}`\n"
                f"*Статус:* {activation['status']}"
            ),
            state=state,
            reply_markup=keyboard.as_markup(),
            parse_mode="Markdown"
        )
    
    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)
    
            await safe_edit_or_send_message(
                message=callback_query.message,
                new_text="Активация успешно отменена.",
                state=state,
                reply_markup=keyboard.as_markup()
            )
        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,
                state=state  # Передаем состояние здесь
            ))
            activation['task'] = task
            activation['status'] = 'Ожидание повторного SMS'
    
            await safe_edit_or_send_message(
                message=callback_query.message,
                new_text="Запрошен повторный SMS. Ожидание SMS...",
                state=state,
                reply_markup=callback_query.message.reply_markup
            )
        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)
    
            await safe_edit_or_send_message(
                message=callback_query.message,
                new_text="Активация успешно завершена.",
                state=state,
                reply_markup=keyboard.as_markup()
            )
        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, state: FSMContext):
        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.edit_message_text(chat_id=chat_id, message_id=activation.get("message_id"), text="Активация была отменена.")
                    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)
    
                    # Редактируем существующее сообщение с новым кодом
                    await safe_edit_or_send_message(
                        message=types.Message(chat=types.Chat(id=chat_id), message_id=activation.get("message_id")),
                        new_text=f"Код активации для номера `{activation['number']}`: `{code}`",
                        state=state,
                        reply_markup=keyboard.as_markup(),
                        parse_mode="Markdown"
                    )
                    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"))
    

    Важные Шаги

    • Использование safe_edit_or_send_message: убедитесь, что состояние пользователя (FSMContext) всегда сохраняет последнюю информацию о сообщении (message_id, текст, клавиатуру), чтобы его можно было редактировать.

    • Редактирование сообщения: попытка изменить существующее сообщение. Если оно успешно, дополнительное сообщение не отправляется.

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

  9. User

    Oct 22 15:42:15 vps1707806210 python[18985]: 2024-10-22 15:42:15,884 - bot.api - INFO - Изменение статуса активации: 721406935 на статус 8 Oct 22 15:42:16 vps1707806210 python[18985]: 2024-10-22 15:42:16,081 - bot.api - INFO - Ответ изменения статуса: ACCESS_CANCEL Oct 22 15:42:16 vps1707806210 python[18985]: 2024-10-22 15:42:16,082 - bot.handlers.activation - INFO - Активация 721406935 отменена на стороне API: ACCESS_CANCEL Oct 22 15:42:16 vps1707806210 python[18985]: 2024-10-22 15:42:16,420 - aiogram.event - INFO - Update id=480224531 is handled. Duration 782 ms by bot id=7625597085 Oct 22 15:42:16 vps1707806210 python[18985]: 2024-10-22 15:42:16,576 - bot.api - INFO - Запрос номера для сервиса: ya, страна: 0, оператор: megafon, макс. цена: 0.0206, валюта: 643 Oct 22 15:42:16 vps1707806210 python[18985]: 2024-10-22 15:42:16,774 - bot.api - INFO - Ответ номера: ACCESS_NUMBER:721406994:79306773441 Oct 22 15:42:16 vps1707806210 python[18985]: 2024-10-22 15:42:16,776 - bot.handlers.sms - INFO - Пользователь 389669884 получил номер: 79306773441, активация ID: 721406994 Oct 22 15:42:16 vps1707806210 python[18985]: 2024-10-22 15:42:16,849 - bot.handlers.sms - ERROR - Ошибка при попытке получения номера, попытка 2: poll_for_sms() missing 1 required positional argument: 'state'

  10. Assistant

    Ошибка, которую вы видите, указывает на то, что функция poll_for_sms вызывается без необходимых аргументов, в частности, без аргумента state. Давайте разберемся, как это можно исправить.

    Вероятнее всего, вызов для запуска poll_for_sms находится в методе или функции, где не передается объект состояния FSMContext. Чтобы исправить это, нужно убедиться, что при вызове poll_for_sms передаются все необходимые аргументы.

    Исправление кода

    Найдите место, где вы создаете задачу для функции poll_for_sms, и убедитесь, что state передается:

    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,
        state=state  # Убедитесь, что state передается здесь
    ))
    

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

    Общие моменты

    • Убедитесь, что state доступен: state передается в ваши обработчики через контекст вызова (например, при обработке callback_query).
    • Передача всех обязательных аргументов: Следите за соответствием всех аргументов. Все параметры объявленной функции должны иметь соответствующие значения.

    Проверка и исходный код

    Позже, после исправления этого использования, подайте в журнал или консоль, что вы успешно передали state, чтобы убедиться, что ваш код теперь работает корректно:

    logger.info(f"Передан state в poll_for_sms для {activation_id}")
    

    Такое логирование поможет вам убедиться, что нужный объект состояния передается, и проблема не повторяется.

  11. User

    Oct 22 15:47:30 vps1707806210 python[19235]: 2024-10-22 15:47:30,423 - bot.api - INFO - Запрос статуса для активации: 721410746 Oct 22 15:47:30 vps1707806210 python[19235]: 2024-10-22 15:47:30,588 - bot.api - INFO - Ответ статуса: STATUS_OK:1768 Oct 22 15:47:30 vps1707806210 python[19235]: 2024-10-22 15:47:30,589 - bot.handlers.activation - INFO - Получен код активации для 721410746: 1768 Oct 22 15:47:30 vps1707806210 python[19235]: 2024-10-22 15:47:30,591 - bot.handlers.activation - ERROR - Ошибка в poll_for_sms: 1 validation error for Chat Oct 22 15:47:30 vps1707806210 python[19235]: type Oct 22 15:47:30 vps1707806210 python[19235]: Field required [type=missing, input_value={'id': 389669884}, input_type=dict] Oct 22 15:47:30 vps1707806210 python[19235]: For further information visit https://errors.pydantic.dev/2.9/v/missing

  12. Assistant

    Ошибка, которую вы видите, связана с тем, что объект Chat для Телеграма создается неполным — отсутствуют обязательные поля, такие как type. Это поле требуется для правильного создания объекта Chat в библиотеке aiogram.

    Возникновение такой ошибки может быть связано с тем, как вы передаете данные в метод, который должен редактировать сообщение, или как вы пытаетесь создать объект Message.

    Исправление ошибки

    При редактировании сообщения с использованием aiogram, вы должны предоставить полный объект Chat и Message, включая обязательные поля. Давайте посмотрим, как вы можете исправить эту ошибку:

    1. Убедитесь, что используете существующий объект message: Если у вас уже есть объект сообщения из Телеграма, используйте его вместо попыток создания собственного.

    2. Создайте корректный объект Chat, если необходимо: Если вы все-таки создаете объект Chat вручную, обязательно укажите все необходимые поля, включая type.

    Вот пример исправления:

    from aiogram.types import Chat, Message
    
    # Пример редактирования существующего сообщения
    chat_id = chat_id  # Используйте chat_id откуда вы его получили
    message_id = activation.get("message_id")  # Используйте существующий message_id
    
    chat = Chat(id=chat_id, type='private')  # Убедитесь, что тип указан корректно
    mess = Message(chat=chat, message_id=message_id)
    
    # Затем используйте созданный объект Message как аргумент
    await safe_edit_or_send_message(
        message=mess,
        new_text=f"Код активации для номера `{activation['number']}`: `{code}`",
        state=state,
        reply_markup=keyboard.as_markup(),
        parse_mode="Markdown"
    )
    

    Общие советы

    • Используйте предоставленные объекты: Если у вас есть доступ к объекту callback_query или message, который связан с нажатой кнопкой или другим взаимодействием, всегда предпочтительно использовать этот объект для редактирования.

    • Изучите API Телеграма: Убедитесь, что вы хорошо понимаете, какие поля нужны для различных методов и как их правильно использовать в aiogram.

    • Логирование и валидация: Используйте логирование и другие инструменты для проверки каждого шага в вашем коде а также для отладки, когда что-то идет не так.