```python
import os
import string
import random
import sqlite3
from telegram import (
    Update,
    ReplyKeyboardMarkup,
    ReplyKeyboardRemove,
)
from telegram.ext import (
    ApplicationBuilder,
    CommandHandler,
    MessageHandler,
    ContextTypes,
    filters,
)
from dotenv import load_dotenv

# Загрузка переменных окружения из .env файла
load_dotenv()

BOT_TOKEN = os.getenv('BOT_TOKEN')
ADMIN_USER_ID = os.getenv('ADMIN_USER_ID')
SBERBANK_NUMBER = os.getenv('SBERBANK_NUMBER')
SBERBANK_AMOUNT = os.getenv('SBERBANK_AMOUNT')

if not all([BOT_TOKEN, ADMIN_USER_ID, SBERBANK_NUMBER, SBERBANK_AMOUNT]):
    raise ValueError("Пожалуйста, убедитесь, что все переменные окружения корректно настроены.")

# Инициализация базы данных
def init_db():
    conn = sqlite3.connect('payments.db')
    cursor = conn.cursor()
    cursor.execute('''
    CREATE TABLE IF NOT EXISTS payments (
        user_id INTEGER PRIMARY KEY,
        unique_id TEXT,
        payment_status TEXT
    )
    ''')
    conn.commit()
    return conn, cursor

conn, cursor = init_db()

def generate_unique_id(length=8):
    characters = string.ascii_letters + string.digits
    return ''.join(random.choice(characters) for _ in range(length))

async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
    user_id = update.effective_user.id
    username = update.effective_user.username or "Неведомый пользователь"
    
    # Проверка, если пользователь уже оплатил
    cursor.execute("SELECT payment_status FROM payments WHERE user_id=?", (user_id,))
    result = cursor.fetchone()
    if result and result[0] == 'paid':
        await update.message.reply_text("Вы уже оплатили. Добро пожаловать!")
    else:
        unique_id = generate_unique_id()
        cursor.execute("INSERT OR REPLACE INTO payments (user_id, unique_id, payment_status) VALUES (?, ?, ?)", 
                       (user_id, unique_id, 'pending'))
        conn.commit()
        
        payment_instructions = (
            "Чтобы получить доступ к функциям бота, пожалуйста, совершите перевод на следующую карту Сбербанк:\n\n"
            f"📱 Номер для перевода: {SBERBANK_NUMBER}\n"
            f"💰 Сумма: {SBERBANK_AMOUNT} рублей\n"
            f"🆔 Уникальный ID: {unique_id}\n\n"
            "Введите Ваш Уникальный ID в комментарии к переводу.\n\n"
            "После совершения перевода, отправьте боту сообщение с вашим уникальным ID для подтверждения оплаты."
        )
        await update.message.reply_text(
            payment_instructions,
            reply_markup=ReplyKeyboardMarkup([["Отправить ID"]], one_time_keyboard=True),
        )

async def confirm_payment(update: Update, context: ContextTypes.DEFAULT_TYPE):
    user_id = update.effective_user.id
    user_message = update.message.text.strip()
    
    # Получение уникального ID пользователя
    cursor.execute("SELECT unique_id, payment_status FROM payments WHERE user_id=?", (user_id,))
    result = cursor.fetchone()
    
    if not result:
        await update.message.reply_text("Вы не запрашивали оплату. Введите /start для начала.")
        return
    
    unique_id, payment_status = result
    if payment_status == 'paid':
        await update.message.reply_text("Вы уже подтвердили оплату. Добро пожаловать!")
        return
    
    if user_message == unique_id:
        await update.message.reply_text(
            "Ваш уникальный ID получен. Ожидайте подтверждения оплаты администратором.",
            reply_markup=ReplyKeyboardRemove(),
        )
        # Уведомление администратора
        admin_message = (
            f"Пользователь @{update.effective_user.username} (ID: {user_id}) отправил свой уникальный ID для подтверждения оплаты:\n\n"
            f"🆔 Уникальный ID: {unique_id}"
        )
        try:
            await context.bot.send_message(chat_id=ADMIN_USER_ID, text=admin_message)
        except Exception as e:
            print(f"Ошибка при отправке сообщения администратору: {e}")
    else:
        await update.message.reply_text("Неверный уникальный ID. Пожалуйста, попробуйте снова.")

async def protected_command(update: Update, context: ContextTypes.DEFAULT_TYPE):
    user_id = update.effective_user.id
    cursor.execute("SELECT payment_status FROM payments WHERE user_id=?", (user_id,))
    result = cursor.fetchone()
    
    if result and result[0] == 'paid':
        await update.message.reply_text("Вот ваш доступный контент.")
    else:
        await update.message.reply_text(
            "Для доступа, пожалуйста, оплатите.",
            reply_markup=ReplyKeyboardMarkup([["Отправить ID"]], one_time_keyboard=True),
        )

def main():
    application = ApplicationBuilder().token(BOT_TOKEN).build()

    application.add_handler(CommandHandler("start", start))
    application.add_handler(CommandHandler("protected", protected_command))
    application.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, confirm_payment))

    print("Бот запущен...")
    application.run_polling()

if __name__ == '__main__':
    main()
```
```python
import os
import sqlite3
from dotenv import load_dotenv
from telegram import Bot
import asyncio

# Загрузка переменных окружения из .env файла
load_dotenv()

BOT_TOKEN = os.getenv('BOT_TOKEN')
ADMIN_USER_ID = os.getenv('ADMIN_USER_ID')  # не обязательно, но может быть использовано для уведомлений администратора

if not BOT_TOKEN:
    raise ValueError("Пожалуйста, убедитесь, что переменная окружения BOT_TOKEN настроена.")

# Подключение к базе данных
def init_db():
    conn = sqlite3.connect('payments.db')
    conn.row_factory = sqlite3.Row  # для доступа к столбцам по имени
    cursor = conn.cursor()
    cursor.execute('''
    CREATE TABLE IF NOT EXISTS payments (
        user_id INTEGER PRIMARY KEY,
        unique_id TEXT,
        payment_status TEXT
    )
    ''')
    conn.commit()
    return conn, cursor

conn, cursor = init_db()

async def send_notification(user_id):
    bot = Bot(token=BOT_TOKEN)
    message = "Ваш платеж был подтвержден! Спасибо за оплату."
    try:
        await bot.send_message(chat_id=user_id, text=message)
    except Exception as e:
        print(f"Ошибка при отправке сообщения пользователю {user_id}: {e}")
    finally:
        await bot.close()

async def confirm_payment(unique_id):
    # Поиск пользователя по unique_id
    cursor.execute("SELECT user_id, payment_status FROM payments WHERE unique_id=?", (unique_id,))
    result = cursor.fetchone()
    
    if not result:
        print(f"Уникальный ID {unique_id} не найден.")
        return
    
    user_id = result['user_id']
    payment_status = result['payment_status']
    
    if payment_status == 'paid':
        print(f"Платеж для пользователя с ID {user_id} уже подтвержден.")
        return
    
    # Обновление статуса оплаты
    cursor.execute("UPDATE payments SET payment_status=? WHERE user_id=?", ('paid', user_id))
    conn.commit()
    print(f"Платеж для пользователя с ID {user_id} успешно подтвержден.")
    
    # Отправка уведомления пользователю
    await send_notification(user_id)

def main():
    print("=== Административная программа для подтверждения оплат ===")
    loop = asyncio.get_event_loop()
    while True:
        user_input = input("Введите уникальный ID для подтверждения оплаты (или 'exit' для выхода): ").strip()
        if user_input.lower() == 'exit':
            break
        loop.run_until_complete(confirm_payment(user_input))
    conn.close()
    print("Программа завершена.")

if __name__ == '__main__':
    main()
```
Как сделать чтобы кнопка Отправить ID отправляла уникальный ID.
Как сделать чтобы после подтверждения оплаты пользователю выдавало так называемые "210 Запросов"
Улучши совместимость между ботом и админской панелью