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

смотри, в этом коде activations все отлично, но нуно только испарвить, что сообщение для…

  1. User

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

    1. 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"))

    1. 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("Бот успешно запущен.")

  2. Assistant

    Чтобы исправить код так, чтобы сообщения с "кодом активации" уведомляли пользователя об изменениях при редактировании, и не заменяли предыдущие сообщения, а просто отображались, можно внести следующие изменения:

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

    2. Убедиться, что каждое отправленное сообщение включает в себя уведомление, чтобы пользователь знал, что было получено новое сообщение.

    Изменения можно внести в функцию poll_for_sms, потому что именно там происходит отправка кода активации:

    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)
    
                    # Отправляем новое сообщение с уведомлением
                    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

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

  4. Assistant

    Чтобы сообщение с кодом активации заменялось на предыдущее сообщение, но при этом пользователь знал, что произошла замена (например, из-за какого-то уведомления), мы можем добавить визуальный элемент в текст сообщения, чтобы это было более заметно. Например, можно добавить эмодзи, указать время получения или просто текстовое уведомление "Новое сообщение" или "Обновление".

    Давайте добавим такое уведомление непосредственно в текст сообщения о получении кода активации. Изменим функцию poll_for_sms таким образом, чтобы добавлялась индикация об обновлении:

    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)
    
                    # Используем safe_edit_or_send_message для редактирования или отправки сообщения
                    new_text = (
                        f"🔔 *Обновление!* 🔔\n"
                        f"Код активации для номера `{activation['number']}`: `{code}`.\n"
                        f"Пожалуйста, используйте этот код для завершения активации."
                    )
    
                    sent_message = await safe_edit_or_send_message(
                        message=callback_query.message,
                        new_text=new_text,
                        state=state,
                        reply_markup=keyboard.as_markup(),
                        parse_mode="Markdown"
                    )
                    activation['message_id'] = sent_message.message_id if sent_message else None
                    
                    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.")
    

    В этом изменении добавлена строка с уведомлением "🔔 Обновление! 🔔" в начале сообщения, чтобы пользователь заметил, что сообщение изменилось. Вы также можете изменить текст аннотации на то, что представляет собой более подходящее уведомление для вашей ситуации.

  5. User

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

  6. Assistant

    Понятно. Если требуется уведомление, но сообщения при этом необходимо заменять, можно воспользоваться следующей техникой: при замене содержимого сообщения в Telegram вызвать звуковое уведомление невозможно, так как замена сообщения происходит "тихо", без уведомления. Однако, есть способ обойти это ограничение:

    1. Временное удаление и повторная отправка: Для сообщения с кодом активации можно сначала удалить предыдущее сообщение, а затем отправить новое сообщение. Это заставит Telegram отобразить уведомление о новом сообщении. Однако это нарушит принцип замены текста в одном и том же сообщении, поскольку идентификатор сообщения изменится.

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

    Вот как это можно сделать немного изменив вашу текущую логику, пытаясь минимизировать изменения в структуре:

    async def send_activation_code(bot: Bot, chat_id: int, activation: Dict[str, Any], code: str):
        # Создаем инлайн-клавиатуру
        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:
            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}`.\nПожалуйста, используйте этот код для завершения активации.",
            reply_markup=keyboard.as_markup(),
            parse_mode="Markdown"
        )
    
        # Сохраняем ID отправленного сообщения
        activation['message_id'] = sent_message.message_id
    
    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("Нет ответа при запросе статуса активации.")
                    return
    
                status_parts = status_response.split(":", 1)
                status = status_parts[0]
    
                if status == "STATUS_WAIT_CODE":
                    activation['last_update'] = time.time()
                    continue
                elif status.startswith("STATUS_WAIT_RETRY"):
                    activation['status'] = f'Ожидание повторного SMS (последний код: {status_parts[1] if len(status_parts) > 1 else "нет предыдущего кода"})'
                    activation['last_update'] = time.time()
                    continue
                elif status == "STATUS_CANCEL":
                    logger.info(f"Активация была отменена.")
                    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()
    
                    await send_activation_code(bot, chat_id, activation, code)
                    return
                else:
                    logger.error(f"Непредвиденный статус активации: {status_response}")
                    return
        except asyncio.CancelledError:
            logger.info(f"Задача poll_for_sms для активации {activation_id} была отменена.")
        except Exception as e:
            logger.error(f"Ошибка в poll_for_sms: {e}")
    

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

  7. User

    но если мы так сделаем, то последуущие сообщения нарушатся и не будут отображаться в одном сообщении?

  8. Assistant

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

    К сожалению, Telegram API не предоставляет возможности отправлять уведомления о редактировании сообщений. В Telegram у пользователя не будет звукового или визуального уведомления, если сообщение просто обновляется.

    Однако, есть несколько альтернативных подходов, которые можно рассмотреть:

    1. Прозрачность для пользователя: Явно уведомляйте пользователя текстом о каждом изменении. Например, добавьте в сообщения нечто вроде: "⚠️ Обратите внимание, сообщение обновлено".

    2. Закладка: Используйте фразы в начале текста, такие как "🔔 Новое обновление 🔔", чтобы привлечь внимание к изменению содержания сообщения.

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

    4. Разделение по задачам: Для особых задач или контекста используйте отдельные сообщения, оставляя меньше важных обновлений для плавной замены.

    Каждое из этих решений имеет свои ограничения и не заменит полностью функции уведомлений о редактировании в Telegram. Поэтому компромисс может зависеть от важности уведомлений для вашего приложения и уровня воздействия, который вы хотите достичь на пользователей.

  9. User

    может быть добавить дополнительное сообщение, которое будет исчезать к примеру чреез 5 секунд? к примеру добавить сообщение "КОД ПОЛУЧЕН", предудыщее сообщение будет просто изменяться и там будет отобжатаься код сообщения как нужно, а это сообщение просто как уведомление будет поялвяться и исчезать и больше не будет нигде участоваовать

  10. Assistant

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

    Вот как вы можете реализовать это в вашей функции poll_for_sms:

    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("Нет ответа при запросе статуса активации.")
                    return
    
                status_parts = status_response.split(":", 1)
                status = status_parts[0]
    
                if status == "STATUS_WAIT_CODE":
                    activation['last_update'] = time.time()
                    continue
                elif status.startswith("STATUS_WAIT_RETRY"):
                    activation['status'] = f'Ожидание повторного SMS (последний код: {status_parts[1] if len(status_parts) > 1 else "нет предыдущего кода"})'
                    activation['last_update'] = time.time()
                    continue
                elif status == "STATUS_CANCEL":
                    logger.info(f"Активация была отменена.")
                    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()
    
                    # Отправка временного уведомления
                    temp_message = await bot.send_message(chat_id, "🔔 КОД ПОЛУЧЕН 🔔")
                    await asyncio.sleep(5)  # Ждем 5 секунд
                    await safe_delete_message(bot, chat_id, temp_message.message_id)
    
                    # Редактирование основного сообщения с заменой текста
                    keyboard = InlineKeyboardBuilder()
                    keyboard.button(text="📂 Текущие активации", callback_data="current_activations")
                    keyboard.button(text="✅ Завершить активацию", callback_data=f"complete_activation:{activation_id}")
                    keyboard.adjust(1)
    
                    new_text = (
                        f"Код активации для номера `{activation['number']}`: `{code}`.\n"
                        f"Пожалуйста, используйте этот код для завершения активации."
                    )
    
                    sent_message = await safe_edit_or_send_message(
                        message=callback_query.message,
                        new_text=new_text,
                        state=state,
                        reply_markup=keyboard.as_markup(),
                        parse_mode="Markdown"
                    )
                    activation['message_id'] = sent_message.message_id if sent_message else None
                    
                    return
                else:
                    logger.error(f"Непредвиденный статус активации: {status_response}")
                    return
        except asyncio.CancelledError:
            logger.info(f"Задача poll_for_sms для активации {activation_id} была отменена.")
        except Exception as e:
            logger.error(f"Ошибка в poll_for_sms: {e}")
    

    В этом решении мы отправляем отдельное сообщение "🔔 КОД ПОЛУЧЕН 🔔" и используем asyncio.sleep для ожидания перед его удалением. После этого выполняется стандартная логика обновления основного сообщения. Этот подход дает пользователю кратковременное уведомление без нарушения основного процесса замены сообщений.

  11. User

    можно полный исправленный код?

  12. Assistant

    Конечно, вот полный исправленный код с добавленным временным уведомлением "КОД ПОЛУЧЕН", которое удаляется через несколько секунд после отображения:

    import asyncio
    import logging
    import time
    from typing import Dict, Any, Optional
    from aiogram import Dispatcher, types, 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 send_activation_code(bot: Bot, chat_id: int, activation: Dict[str, Any], code: str, state: FSMContext):
        # Отправка временного уведомления
        temp_message = await bot.send_message(chat_id, "🔔 КОД ПОЛУЧЕН 🔔")
        await asyncio.sleep(5)  # Ждем 5 секунд
        await safe_delete_message(bot, chat_id, temp_message.message_id)
    
        # Редактирование основного сообщения с заменой текста
        keyboard = InlineKeyboardBuilder()
        keyboard.button(text="📂 Текущие активации", callback_data="current_activations")
        keyboard.button(text="✅ Завершить активацию", callback_data=f"complete_activation:{activation['id']}")
        keyboard.adjust(1)
    
        new_text = (
            f"Код активации для номера `{activation['number']}`: `{code}`.\n"
            f"Пожалуйста, используйте этот код для завершения активации."
        )
    
        # Используем safe_edit_or_send_message для редактирования или отправки сообщения
        sent_message = await safe_edit_or_send_message(
            message=callback_query.message,
            new_text=new_text,
            state=state,
            reply_markup=keyboard.as_markup(),
            parse_mode="Markdown"
        )
        activation['message_id'] = sent_message.message_id if sent_message else None
    
    
    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":
                    activation['last_update'] = time.time()
                    continue
                elif status.startswith("STATUS_WAIT_RETRY"):
                    activation['status'] = f'Ожидание повторного SMS (последний код: {status_parts[1] if len(status_parts) > 1 else "нет предыдущего кода"})'
                    activation['last_update'] = time.time()
                    continue
                elif status == "STATUS_CANCEL":
                    logger.info(f"Активация была отменена.")
                    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()
    
                    await send_activation_code(bot, chat_id, activation, code, state)
                    return
                else:
                    logger.error(f"Непредвиденный статус активации: {status_response}")
                    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"))
    

    В этом коде, когда будет получен код активации, пользователь увидит временное уведомление "🔔 КОД ПОЛУЧЕН 🔔", которое будет отображаться в течение 5 секунд, а затем удалится. Основное сообщение с состоянием активации будет обновлено для включения кода без отправки нового сообщения.

    Обратите внимание, что следует убедиться, что при вызове poll_for_sms у вас будет доступен объект state, необходимый для работы с safe_edit_or_send_message.