subscriptions/bot.py

import os
from datetime import datetime, timedelta
import datetime
from aiogram import types, F, Router
from aiogram.filters import Command
from aiogram.fsm.context import FSMContext

from database_queries import (presence_user_bd, adding_user_db, update_user_db, user_search, getting_course,
                              installation_zero_question, installation_one_question, status_question,
                              write_hash_to_table, search_hash_in_table, number_of_streams_from_subscriptions,
                              number_of_threads_from_threads, get_user_data, subscription_entry,
                              subscription_end_record, check_expired_subscriptions)
from main import bot_chat
import qrcode
from utils import create_connection, get_contract_ret_tron, get_contract_ret_arbitrum, payment_order_yukassa, \
    check_payment_status
from states import QuestionStates
from dotenv import load_dotenv

load_dotenv()

router = Router()


# Словарь для хранения состояния пользователя
user_states = {}


@router.message(Command("start"))
async def cmd_start(message: types.Message):
    """ Основное меню """
    photo = types.FSInputFile("1_IMAGE.png")
    user_id = message.from_user.id
    username = message.from_user.username or "No name"
    conn = create_connection()
    cursor = conn.cursor()
    result = presence_user_bd(user_id)
    if result is None:
        adding_user_db(user_id, username)
    keyboard = types.InlineKeyboardMarkup(
        row_width=1,
        inline_keyboard=[
            [types.InlineKeyboardButton(text="Купить подписку", callback_data="buy_subscription")],
            [types.InlineKeyboardButton(text="FAQ блок", callback_data="faq_block"),
             types.InlineKeyboardButton(text="Моя подписка", callback_data="my_subscription")],
            [types.InlineKeyboardButton(text="Задать вопрос", callback_data="ask_question")], ], )
    # Отправляем меню пользователю
    await message.reply_photo(photo=photo, reply_markup=keyboard)


@router.callback_query(F.data == "buy_subscription")
async def handle_buy_subscription(callback_query: types.CallbackQuery):
    """ Выбор подписки или потоков """
    await callback_query.message.delete()
    keyboard = types.InlineKeyboardMarkup(row_width=1, inline_keyboard=[
            [types.InlineKeyboardButton(text="Купить подписку на 1 мес.", callback_data="buy_1_month")],
            [types.InlineKeyboardButton(text="Купить подписку на 2 мес.", callback_data="buy_2_month")],
            [types.InlineKeyboardButton(text="Купить подписку на 3 мес.", callback_data="buy_3_month")],
            [types.InlineKeyboardButton(text="Увеличение потоков.", callback_data="increase_flow")],
            [types.InlineKeyboardButton(text="Обратно в меню", callback_data="back_to_menu")],],)
    # Отправляем подменю пользователю
    await callback_query.message.answer("Выберите срок подписки:", reply_markup=keyboard)


@router.callback_query(F.data == "increase_flow")
async def handle_increase_flow(callback_query: types.CallbackQuery, state: FSMContext):
    """ Получение от пользователя количество потоков """
    await state.set_state(QuestionStates.count_flow)
    user_id = callback_query.from_user.id
    if user_id not in user_states:  # Проверка на существование состояния пользователя
        user_states[user_id] = {}  # Инициализация состояния пользователя
    await callback_query.message.delete()
    msg_to_delete = await callback_query.message.answer("Введите количество потоков:",
                                        reply_markup=types.InlineKeyboardMarkup(row_width=1, inline_keyboard=[
                                            [types.InlineKeyboardButton(text="Изменить",
                                                                        callback_data="buy_subscription")]]))
    await state.update_data(msg_to_delete=msg_to_delete)


@router.message(QuestionStates.count_flow)
async def handle_flow_count(message: types.Message, state: FSMContext):
    """ Подтверждение покупки указанных потоков от пользователя """
    await message.delete()
    data = await state.get_data()
    msg_to_delete = data.get('msg_to_delete')
    if msg_to_delete:
        try:
            await msg_to_delete.delete()
        except:
            pass
    user_id = message.from_user.id
    user_states.setdefault(user_id, {})  # Инициализация состояния пользователя с помощью setdefault
    if message.text.isdigit():
        flow_count = int(message.text)
        user_states[user_id] = flow_count  # Сохранение количества потоков
        total_price_usd = flow_count * 2
        keyboard = types.InlineKeyboardMarkup(row_width=1, inline_keyboard=[
            [types.InlineKeyboardButton(text="Да", callback_data="yes_flow_count"),
             types.InlineKeyboardButton(text="Изменить", callback_data="buy_subscription")],
            [types.InlineKeyboardButton(text="Обратно в меню", callback_data="back_to_menu")]
        ])
        await message.answer(f"Вы хотите купить {flow_count} поток(ов) за ${total_price_usd}?", reply_markup=keyboard)
    else:
        await message.answer("Пожалуйста, введите корректное число.")


@router.callback_query(F.data == "buy_1_month")
@router.callback_query(F.data == "buy_2_month")
@router.callback_query(F.data == "buy_3_month")
async def handle_buy_subscription_confirm(callback_query: types.CallbackQuery):
    """ Получение подтверждения по покупке подписки и пользователя """
    user_id = callback_query.from_user.id
    user_states[user_id] = callback_query.data  # Сохраняем текущее состояние
    # Подтверждение перехода к оплате
    keyboard = types.InlineKeyboardMarkup(row_width=1, inline_keyboard=[
            [types.InlineKeyboardButton(text="Да", callback_data="YES"),
             types.InlineKeyboardButton(text="Изменить", callback_data="buy_subscription")],
            [types.InlineKeyboardButton(text="Обратно в меню", callback_data="back_to_menu")],],)
    months = {"buy_1_month": 1,
              "buy_2_month": 2,
              "buy_3_month": 3}
    month_count = months.get(callback_query.data)
    price = month_count * 1
    # Отправляем запрос подтверждения
    await callback_query.message.edit_text(
        f"Вы хотите купить подписку сроком на {month_count} мес. за {price} $?", reply_markup=keyboard,)


@router.callback_query(F.data == "yes_flow_count")
async def handle_payment_method(callback_query: types.CallbackQuery):
    """ Меню выбора способа оплаты потоков """
    user_id = callback_query.from_user.id
    flow_count = user_states[user_id]  # Получаем состояние пользователя
    total_price_usd = flow_count * 2
    # Получаем курс USD/RUB из бд
    conn = create_connection()
    cursor = conn.cursor()
    course_usd_rub = getting_course(cursor)  # Функция для получения курса
    price_rub = round(total_price_usd * course_usd_rub[1])
    # Выбор способа оплаты
    keyboard = types.InlineKeyboardMarkup(
        row_width=1,
        inline_keyboard=[
            [types.InlineKeyboardButton(text=f"USDT TRC20 - {total_price_usd}$", callback_data="tron")],
            [types.InlineKeyboardButton(text=f"Arbitrum - {total_price_usd}$", callback_data="Arbitrum")],
            [types.InlineKeyboardButton(text=f"ЮКасса {price_rub} руб.", callback_data="Yukassa")],
            [types.InlineKeyboardButton(text="Обратно в меню", callback_data="back_to_menu")],],)
    # Отправляем запрос на выбор способа оплаты
    await callback_query.message.edit_text(
        f"Выберете способ оплаты товара за {total_price_usd} USDT или {price_rub} руб.",
        reply_markup=keyboard,)

@router.callback_query(F.data == "YES")
async def handle_payment_method(callback_query: types.CallbackQuery):
    """ Меню выбора способа оплаты подписки """
    user_id = callback_query.from_user.id  # Получаем состояние пользователя
    subscription_type = user_states.get(user_id)
    if subscription_type:
        months = {"buy_1_month": 1,
                  "buy_2_month": 2,
                  "buy_3_month": 3}
        month_count = months.get(subscription_type)  # На входе мы получаем строку. далее переводим ее в int
        price_usd = month_count * 1
        # Получаем курс USD/RUB из бд
        conn = create_connection()
        cursor = conn.cursor()
        course_usd_rub = getting_course(cursor)
        price_rub = round(price_usd * course_usd_rub[1])
        # Выбор способа оплаты
        keyboard = types.InlineKeyboardMarkup(
            row_width=1,
            inline_keyboard=[
                [types.InlineKeyboardButton(text=f"USDT TRC20 - {price_usd}$", callback_data="tron")],
                [types.InlineKeyboardButton(text=f"Arbitrum - {price_usd}$", callback_data="Arbitrum")],
                [types.InlineKeyboardButton(text=f"ЮКасса {price_rub} руб.", callback_data="Yukassa")],
                [types.InlineKeyboardButton(text="Обратно в меню", callback_data="back_to_menu")],],)
        # Отправляем запрос на выбор способа оплаты
        await callback_query.message.edit_text(
            f"Выберете способ оплаты товара на {month_count} мес. за {price_usd} USDT или {price_rub} руб.",
            reply_markup=keyboard,)


@router.callback_query(F.data == "tron")
async def example(callback_query: types.CallbackQuery, state: FSMContext):
    """ Платежный хэндлер трона на личный кошелек"""
    await callback_query.message.delete()
    await state.set_state(QuestionStates.waiting_for_hash)    # ожидание хэша от пользователя
    user_id = callback_query.from_user.id   # Получение айди пользователя
    flow_count = user_states[user_id]  # Получение количесва потоков
    subscription_type = user_states.get(user_id)  # Получение строки по подписке
    if isinstance(subscription_type, str):  # проверка - идет покупка потоков или подписки
        months = {"buy_1_month": 1,
                  "buy_2_month": 2,
                  "buy_3_month": 3}
        month_count = months.get(subscription_type)
        price_usd = month_count * 1
    else:
        price_usd = flow_count * 2
    payment_url = os.getenv('TO_ADRESS')  # Ссылка на кошелек заказчика
    filename = "site.png"
    # Генерация QR-кода
    img = qrcode.make(payment_url)
    img.save(filename)
    photo = types.FSInputFile(filename)
    message_to_delete = await callback_query.message.answer_photo(
        photo=photo, caption=f"Для оплаты необходимо совершить пополнение в размере {price_usd}$"
                            f" на кошелек: {payment_url} После оплаты напишите хэш операции для проверки статуса",
        reply_markup=types.InlineKeyboardMarkup(row_width=1, inline_keyboard=[
            [types.InlineKeyboardButton(text="Изменить", callback_data="buy_subscription")]]))
    os.remove(filename)
    await state.update_data(message_to_delete=message_to_delete)


@router.callback_query(F.data == "Arbitrum")
async def example(callback_query: types.CallbackQuery, state: FSMContext):
    """ Платежный хэндлер арбитрума на личный кошелек"""
    await callback_query.message.delete()
    await state.set_state(QuestionStates.waiting_for_hash)   # ожидание хэша от пользователя
    user_id = callback_query.from_user.id  # Получение айди пользователя
    flow_count = user_states[user_id]  # Получение количесва потоков
    subscription_type = user_states.get(user_id)   # Получение строки по подписке
    if isinstance(subscription_type, str):  # проверка - идет покупка потоков или подписки
        months = {"buy_1_month": 1,
                  "buy_2_month": 2,
                  "buy_3_month": 3}
        month_count = months.get(subscription_type)
        price_usd = month_count * 1
    else:
        price_usd = flow_count * 2
    payment_url = os.getenv('ARBITRUM_ADRESS')  # Ссылка на кошелек заказчика
    filename = "site.png"
    # Генерация QR-кода
    img = qrcode.make(payment_url)
    img.save(filename)
    photo = types.FSInputFile(filename)
    message_to_delete = await callback_query.message.answer_photo(
        photo=photo, caption=f"Для оплаты необходимо совершить пополнение в размере {price_usd}$"
                            f" на кошелек: {payment_url} После оплаты напишите хэш операции для проверки статуса",
        reply_markup=types.InlineKeyboardMarkup(row_width=1, inline_keyboard=[
            [types.InlineKeyboardButton(text="Изменить", callback_data="buy_subscription")]]))
    os.remove(filename)
    await state.update_data(message_to_delete=message_to_delete)


@router.callback_query(F.data == "Yukassa")
async def example(callback_query: types.CallbackQuery, state: FSMContext):
    """ Платежный хэндлер юкассы """
    await callback_query.message.delete()
    user_id = callback_query.from_user.id  # Получение айди пользователя
    flow_count = user_states[user_id]  # Получение количесва потоков
    subscription_type = user_states.get(user_id)  # Получение строки по подписке
    if isinstance(subscription_type, str):  # проверка - идет покупка потоков или подписки
        months = {"buy_1_month": 1,
                  "buy_2_month": 2,
                  "buy_3_month": 3}
        month_count = months.get(subscription_type)
        price_usd = month_count * 1
    else:
        price_usd = flow_count * 2
    # Получаем курс USD/RUB
    conn = create_connection()
    cursor = conn.cursor()
    course_usd_rub = getting_course(cursor)
    price_rub = round(price_usd * course_usd_rub[1])
    bot_me = await bot_chat.get_me()  # эта и строчка ниже - получение имя бота
    bot_username = bot_me.username
    result = await payment_order_yukassa(price_rub, bot_username)  # функция возвращает словарь платежного поручения
    payment_url = result['confirmation']['confirmation_url']  # вытаскиваем ссылку на оплату из словаря
    payment_id = result["id"]  # вытаскиваем айди платежа
    await state.update_data(payment_id=payment_id)  # Сохраняем payment_id в состоянии. нужен для след хэндлера
    filename = "site.png"
    # Генерация QR-кода
    img = qrcode.make(payment_url)
    img.save(filename)
    photo = types.FSInputFile(filename)
    await callback_query.message.answer_photo(
        photo=photo, caption=f"Необходимо совершить оплату в размере {price_rub}руб по ссылке: {payment_url}",
        reply_markup=types.InlineKeyboardMarkup(row_width=1, inline_keyboard=[
            [types.InlineKeyboardButton(text="Изменить", callback_data="buy_subscription")],
            [types.InlineKeyboardButton(text="Проверить платеж", callback_data=f"check {payment_id}")]]))
    os.remove(filename)


@router.callback_query(F.data.startswith("check"))
async def check_payment(callback_query: types.CallbackQuery, state: FSMContext):
    """ Проверка платежа юкассы по айди платежа """
    await callback_query.message.delete()
    await state.set_state(QuestionStates.payment_id)  # Получаем состояние айди платежки из прошлого хэндлера
    user_id = callback_query.from_user.id  # Получаем айди пользователя
    data = await state.get_data()  # Получаем данные состояния
    payment_id = data.get("payment_id")  # Извлекаем payment_id
    subscription_type = user_states.get(user_id)   # Извлекаем состояние по подписки
    flow_count = user_states[user_id]  # Извлекаем состояние по потокам
    if isinstance(subscription_type, str):  # Проверяем, была ли это оплата потоков или подписки
        months = {"buy_1_month": 1,
                  "buy_2_month": 2,
                  "buy_3_month": 3}
        month_count = months.get(subscription_type)
        price_usd = month_count * 1
    else:
        price_usd = flow_count * 1
    conn = create_connection()
    cursor = conn.cursor()
    if search_hash_in_table(cursor, payment_id):
        await callback_query.message.answer("Повторная проверка по хешу запрещена",
                             reply_markup=types.InlineKeyboardMarkup(row_width=1, inline_keyboard=[
                                 [types.InlineKeyboardButton(text="Обратно в меню", callback_data="back_to_menu")]]))
    else:
        if check_payment_status(payment_id) == "succeeded":
            await callback_query.message.answer(
                "Платеж успешно произведен", reply_markup=types.InlineKeyboardMarkup
                (row_width=1, inline_keyboard=[[types.InlineKeyboardButton
                                                (text="Обратно в меню", callback_data="back_to_menu")]]))
            write_hash_to_table(cursor, payment_id, user_id)
            conn.commit()
            if isinstance(subscription_type, str):
                # делаем запись в бд при покупки подписки. устанавливается "3" при условии отсутсвия активной подписки
                number_of_streams_from_subscriptions(cursor, user_id)  # Запись 3 единицы, если их не было
                conn.commit()
                subscription_entry(cursor, user_id, price_usd)   # Запись подписки в столбец (1,2,3 мес)
                conn.commit()
                subscription_end_record(cursor, user_id)  # Запись даты окончания подписки в столбцы
                conn.commit()
            else:
                # добавляем в столбец количество потоков
                number_of_threads_from_threads(cursor, user_id, price_usd)
                conn.commit()
        else:
            await callback_query.message.answer(
                "Ошибка, проверьте правильность написания хэша и повторите попытку проверки статуса платежа",
                reply_markup=types.InlineKeyboardMarkup
                (row_width=1, inline_keyboard=[[types.InlineKeyboardButton
                                                (text="Обратно в меню", callback_data="back_to_menu")]]))
    await callback_query.bot.unban_chat_member(-4226821992, user_id)


@router.message(QuestionStates.waiting_for_hash)
async def handle_hash(message: types.Message, state: FSMContext):
    # хендлер по проверке по хешу статуса операции
    data = await state.get_data()
    message_to_delete = data.get('message_to_delete')
    if message_to_delete:
        try:
            await message_to_delete.delete()
        except:
            pass
    await message.delete()
    await state.set_state(QuestionStates.waiting_for_hash)
    user_id = message.from_user.id
    flow_count = user_states[user_id]
    subscription_type = user_states.get(user_id)
    if isinstance(subscription_type, str):
        months = {"buy_1_month": 1,
                  "buy_2_month": 2,
                  "buy_3_month": 3}
        month_count = months.get(subscription_type)
        price_usd = month_count * 1
    else:
        price_usd = flow_count * 1
    user_id = message.from_user.id
    conn = create_connection()
    cursor = conn.cursor()
    user_hash = message.text.strip()  # Записываем хэш
    # Проводим проверку на наличие хеша в таблице успешных операций. Если успешна - повторная проверка запрещена
    if search_hash_in_table(cursor, user_hash):
        await message.answer("Повторная проверка по хешу запрещена",
                             reply_markup=types.InlineKeyboardMarkup(row_width=1, inline_keyboard=[
                                 [types.InlineKeyboardButton(text="Обратно в меню", callback_data="back_to_menu")]]))
    else:
        result = get_contract_ret_tron(user_hash, price_usd)
        result_2 = get_contract_ret_arbitrum(user_hash, price_usd)  # вызов функции для проверки статуса платежа
        # если успешный статус, выводим отбивку пользователю и записываем хеш в таблицу чтобы последующие
        # проверки были невозможны
        if result:
            await message.answer(
                "Платеж успешно произведен", reply_markup=types.InlineKeyboardMarkup
                (row_width=1, inline_keyboard=[[types.InlineKeyboardButton
                                                (text="Обратно в меню", callback_data="back_to_menu")]]))
            write_hash_to_table(cursor, user_hash, user_id)
            conn.commit()
            if isinstance(subscription_type, str):
                print(isinstance(subscription_type, str))
                # делаем запись в бд при покупки подписки. устанавливается "3" при условии отсутсвия активной подписки
                number_of_streams_from_subscriptions(cursor, user_id)
                conn.commit()
                subscription_entry(cursor, user_id, price_usd)
                conn.commit()
                subscription_end_record(cursor, user_id)
                conn.commit()
            else:
                # добавляем в столбец количество потоков
                number_of_threads_from_threads(cursor, user_id, price_usd)
                conn.commit()
        elif result_2:
            await message.answer(
                "Платеж успешно произведен", reply_markup=types.InlineKeyboardMarkup
                (row_width=1, inline_keyboard=[[types.InlineKeyboardButton
                                                (text="Обратно в меню", callback_data="back_to_menu")]]))
            write_hash_to_table(cursor, user_hash, user_id)
            conn.commit()
            if isinstance(subscription_type, str):
                # делаем запись в бд при покупки подписки. устанавливается "3" при условии отсутсвия активной подписки
                number_of_streams_from_subscriptions(cursor, user_id)
                conn.commit()
                subscription_entry(cursor, user_id, price_usd)
                conn.commit()
                subscription_end_record(cursor, user_id)
                conn.commit()
            else:
                # добавляем в столбец количество потоков
                number_of_threads_from_threads(cursor, user_id, price_usd)
                conn.commit()
        else:
            await message.answer(
                "Ошибка, проверьте правильность написания хэша и повторите попытку проверки статуса платежа",
                reply_markup=types.InlineKeyboardMarkup
                (row_width=1, inline_keyboard=[[types.InlineKeyboardButton
                                                (text="Обратно в меню", callback_data="back_to_menu")]]))
    await message.bot.unban_chat_member(-4226821992, user_id)


@router.callback_query(F.data == "back_to_menu")
async def handle_back_to_menu(callback_query: types.CallbackQuery):
    keyboard = types.InlineKeyboardMarkup(row_width=1, inline_keyboard=[
            [types.InlineKeyboardButton(text="Купить подписку", callback_data="buy_subscription")],
            [types.InlineKeyboardButton(text="FAQ блок", callback_data="faq_block"),
             types.InlineKeyboardButton(text="Моя подписка", callback_data="my_subscription")],
            [types.InlineKeyboardButton(text="Задать вопрос", callback_data="ask_question")],],)
    # Отправляем сообщение с инлайн-клавиатурой
    await callback_query.message.edit_text("Добро пожаловать! Выберите действие:", reply_markup=keyboard)


@router.callback_query(F.data == "faq_block")
async def handle_faq_block(callback_query: types.CallbackQuery):
    # сообщение с информацией о FAQ
    await callback_query.message.delete()
    await callback_query.message.answer("Тут будет FAQ блок",
                                           reply_markup=types.InlineKeyboardMarkup(row_width=1, inline_keyboard=[
                                               [types.InlineKeyboardButton(text="Обратно в меню",
                                                                           callback_data="back_to_menu")]],),)


@router.callback_query(F.data == "my_subscription")
async def handle_faq_block(callback_query: types.CallbackQuery):
    await callback_query.message.delete()
    user_id = callback_query.from_user.id  # выковыриваем айди пользователя
    conn = create_connection()
    cursor = conn.cursor()
    user_data = get_user_data(cursor, user_id)  # Получение данных о пользователе из базы данных или API
    chat_id = '-4226821992'  # Замените на ваш chat_id
    expire_date = datetime.datetime.now() + timedelta(hours=1)
    expire_date_timestamp = int(expire_date.timestamp())
    link = await bot_chat.create_chat_invite_link(chat_id=chat_id, name=None, expire_date=expire_date_timestamp,
                                                  member_limit=1)
    print(link.invite_link)
    # Формирование текста сообщения
    message_text = f"Приветствуем, {user_data[2]}\n"
    message_text += f"Ваш уникальный ID: {user_id}\n"
    message_text += f"Ваш ZennolabID: {user_data[3]}\n"
    message_text += f"Кол-во потоков Bcoin: {user_data[8]}\n"
    if user_data[9] == '0':
        message_text += f"Увас нет активных подписок\n"
    else:
        message_text += f"Ваши активные подписки:\n- Подписка на {user_data[9]} мес. до {user_data[10]}\n"
    if user_data[4] is not None and user_data[4] != 0:
        message_text += f"Переходите по ссылке в нашу группу: {link.invite_link}\n"
    await callback_query.message.answer(message_text,
                                        reply_markup=types.InlineKeyboardMarkup(row_width=1, inline_keyboard=[
                                               [types.InlineKeyboardButton(text="Обратно в меню",
                                                                           callback_data="back_to_menu")]],),)


@router.callback_query(F.data == "ask_question")
async def handle_ask_question(callback_query: types.CallbackQuery, state: FSMContext):
    await callback_query.message.delete()
    user_id = callback_query.from_user.id
    conn = create_connection()
    cursor = conn.cursor()
    state_user = status_question(cursor, user_id)[0]
    if state_user == 1:
        await callback_query.answer("Отправка вопроса запрещена. Дождитесь ответа на прошлый вопрос",
                                    reply_markup=types.InlineKeyboardMarkup(row_width=1, inline_keyboard=[
                                        [types.InlineKeyboardButton(text="Обратно в меню",
                                                                    callback_data="back_to_menu")]]))
    else:
        # ожидание вопроса от пользователя
        await state.set_state(QuestionStates.waiting_for_question)
        await callback_query.message.answer(
            "🙌 Задавайте вопрос, в ближайшее время Вам ответят.",
            reply_markup=types.InlineKeyboardMarkup(row_width=1, inline_keyboard=[
                [types.InlineKeyboardButton(text="Обратно в меню", callback_data="back_to_menu")]],),)


@router.message(QuestionStates.waiting_for_question)
async def handle_question(message: types.Message, state: FSMContext):
    # Записываем вопрос и отправляем в группу
    question = message.text
    user_id = message.from_user.id
    username = message.from_user.username or "No name"
    conn = create_connection()
    cursor = conn.cursor()
    # Проверяем, существует ли пользователь в таблице
    result = presence_user_bd(user_id)
    if not int(result[6]) == 0:
        # Если пользователь существует, просто обновляем информацию о вопросе
        await message.answer(
            "Спасибо, Ваш вопрос принят в работу!",
            reply_markup=types.InlineKeyboardMarkup(row_width=1, inline_keyboard=[
                [types.InlineKeyboardButton(text="Купить подписку", callback_data="buy_subscription")],
                [types.InlineKeyboardButton(text="FAQ блок", callback_data="faq_block"),
                 types.InlineKeyboardButton(text="Моя подписка", callback_data="my_subscription")],
                [types.InlineKeyboardButton(text="Задать вопрос", callback_data="ask_question")],],))
        await bot_chat.send_message(chat_id=-1002195305182, text=question, message_thread_id=result[6])
    else:
        await message.answer("Спасибо, Ваш вопрос принят в работу!",
                             reply_markup=types.InlineKeyboardMarkup(row_width=1, inline_keyboard=[
                                 [types.InlineKeyboardButton(text="Купить подписку", callback_data="buy_subscription")],
                                 [types.InlineKeyboardButton(text="FAQ блок", callback_data="faq_block"),
                                  types.InlineKeyboardButton(text="Моя подписка", callback_data="my_subscription")],
                                 [types.InlineKeyboardButton(text="Задать вопрос", callback_data="ask_question")],],))
        topic = await bot_chat.create_forum_topic(chat_id=-1002195305182, name=f"Вопрос от {username}")
        update_user_db(cursor, topic.message_thread_id, user_id)
        conn.commit()  # Подтверждаем изменения
        await bot_chat.send_message(chat_id=-1002195305182, text=question, message_thread_id=topic.message_thread_id,)
    installation_one_question(cursor, user_id)
    conn.commit()
    await state.clear()


@router.message(F.chat.type == "supergroup", F.text)
async def handle_answer(message: types.Message):
    conn = create_connection()
    cursor = conn.cursor()
    search_user = user_search(cursor, message.message_thread_id)
    await bot_chat.send_message(chat_id=search_user[1], text=f"Ответ на Ваш вопрос: {message.text}")
    installation_zero_question(cursor, search_user[1])
    conn.commit()