python Исходник самописный код для тг бота по типу ОСМТ

[ATE1CT]

ниже код хс

import logging
from aiogram import Bot, Dispatcher, executor, types
from aiogram.contrib.fsm_storage.memory import MemoryStorage
from aiogram.dispatcher import FSMContext
from aiogram.dispatcher.filters.state import State, StatesGroup
import smtplib
import sqlite3
import datetime
from datetime import datetime, date, timedelta
from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
import aiocryptopay
from aiocryptopay import AioCryptoPay, Networks
import asyncio
import re
import socket
ip_address = socket.gethostbyname(socket.gethostname())
print("IP-адрес вашего устройства:", ip_address) #на всякий случай
conn = sqlite3.connect('email_bot.db')
c = conn.cursor()
c.execute('''CREATE TABLE IF NOT EXISTS users
                 (id INTEGER PRIMARY KEY AUTOINCREMENT,
                  registration_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
                  subscription BOOLEAN DEFAULT 0,
                  emails_sent INTEGER DEFAULT 0,
                  subscription_expiry TIMESTAMP,
                  last_email_date TEXT)''')

conn.commit()
bot = Bot(token="токен") #менять
storage = MemoryStorage()
dp = Dispatcher(bot, storage=storage)
CRYPTO_PAY_MAINNET_TOKEN = "крипто бот токен" #менять
crypto_mainnet = AioCryptoPay(token=CRYPTO_PAY_MAINNET_TOKEN, network=Networks.MAIN_NET)
invoices_users = {}
class SendEmail(StatesGroup):
    recipient = State()
    subject = State()
    body = State()
@dp.message_handler(commands=['start'])
async def send_welcome(message: types.Message):
    user_id = message.from_user.id
    c.execute("SELECT * FROM users WHERE id = ?", (user_id,))
    user_data = c.fetchone()
    if user_data:
        registration_date_str = user_data[1]
        registration_date = datetime.strptime(registration_date_str, '%Y-%m-%d %H:%M:%S')
        subscription = "Активна" if user_data[2] else "Неактивна"
        emails_sent = user_data[3]
        subscription_expiry = user_data[4]
        last_email_date = user_data[5]
        today = datetime.now().date()
        if last_email_date is None or datetime.strptime(last_email_date, '%Y-%m-%d').date() < today:
            c.execute("UPDATE users SET emails_sent = 0 WHERE id = ?", (user_id,))
            conn.commit()
        if subscription_expiry:
            subscription_expiry_str = subscription_expiry
            subscription_expiry_str = re.sub(r'\.\d+$', '', subscription_expiry_str)
            try:
                subscription_expiry = datetime.strptime(subscription_expiry_str, '%Y-%m-%d %H:%M:%S')
            except ValueError:
                subscription = "Неактивна"
            else:
                if subscription_expiry < datetime.now():
                    subscription = "Неактивна"
        days_in_bot = (datetime.now() - registration_date).days
    else:
        c.execute("INSERT INTO users (id, last_email_date) VALUES (?, ?)", (user_id, None))
        conn.commit()
        registration_date = datetime.now()
        subscription = "Неактивна"
        emails_sent = 0
        days_in_bot = 0
    profile_text = (
        "🖥 Профиль\n"
        "➖➖➖➖➖➖➖➖➖➖➖➖➖\n"
        f"🗞 Дней в боте: {days_in_bot}\n"
        f"⏳ Дата регистрации: {registration_date.strftime('%Y-%m-%d %H:%M')}\n"
        f"💻 Данные: ({user_id})\n"
        f"⚜️ Подписка: {subscription}\n"
        f"💠 Отправленных писем: {emails_sent}\n"
        "➖➖➖➖➖➖➖➖➖➖➖➖➖"
    )
    keyboard = InlineKeyboardMarkup(row_width=2)
    send_email_button = InlineKeyboardButton("Отправить письмо", callback_data="send_email")
    buy_subscription_button = InlineKeyboardButton("Купить подписку", callback_data="pay")
    help_button = InlineKeyboardButton("Помощь", callback_data="help")
    keyboard.add(send_email_button, buy_subscription_button, help_button)
    await message.reply(profile_text, reply_markup=keyboard)
@dp.callback_query_handler(lambda c: c.data == 'send_email')
async def process_send_email(callback_query: types.CallbackQuery):
    user_id = callback_query.from_user.id
    c.execute("SELECT subscription, subscription_expiry, emails_sent FROM users WHERE id = ?", (user_id,))
    user_data = c.fetchone()
    if user_data is None:
        await bot.send_message(user_id, "У вас нет активной подписки. Пожалуйста, купите подписку, чтобы получить доступ к отправке писем.")
    else:
        subscription_status, subscription_expiry_str, emails_sent = user_data
        today = datetime.now().date()
        if subscription_status:
            if subscription_expiry_str:
                subscription_expiry_str = re.sub(r'\.\d+$', '', subscription_expiry_str)
                try:
                    subscription_expiry = datetime.strptime(subscription_expiry_str, '%Y-%m-%d %H:%M:%S')
                except ValueError:
                    await bot.send_message(user_id, "Ваша подписка истекла. Пожалуйста, купите новую подписку.")
                else:
                    if subscription_expiry > datetime.now():
                        if emails_sent < 10:                 
                            cancel_keyboard = InlineKeyboardMarkup(inline_keyboard=[[InlineKeyboardButton("❌ Отменить ❌", callback_data="cancel_send_email")]])
                            await bot.send_message(user_id, "Чтобы отменить отправку, нажмите кнопку ниже:", reply_markup=cancel_keyboard)
                            await bot.send_message(user_id, "Введите адрес получателя:")
                            await SendEmail.recipient.set()
                        else:
                            await bot.send_message(user_id, "Вы достигли лимита в 10 писем в день. Попробуйте снова завтра.")
                    else:
                        await bot.send_message(user_id, "Ваша подписка истекла. Пожалуйста, купите новую подписку.")
            else:
                await bot.send_message(user_id, "Ваша подписка истекла. Пожалуйста, купите новую подписку.")
        else:
            await bot.send_message(user_id, "У вас нет активной подписки. Пожалуйста, купите подписку, чтобы получить доступ к отправке писем.")
    await callback_query.answer()
@dp.callback_query_handler(lambda c: c.data == 'cancel_send_email', state=SendEmail)
async def cancel_send_email(callback_query: types.CallbackQuery, state: FSMContext):
    await state.finish()
    await bot.send_message(callback_query.from_user.id, "Отправка письма отменена.")
    await callback_query.answer()
@dp.message_handler(state=SendEmail.recipient)
async def send_recipient_handler(message: types.Message, state: FSMContext):
    recipient = message.text
    await state.update_data(recipient=recipient)
    await message.reply("Введите тему письма:")
    await SendEmail.next()
@dp.message_handler(state=SendEmail.subject)
async def send_subject_handler(message: types.Message, state: FSMContext):
    subject = message.text
    await state.update_data(subject=subject)
    await message.reply("Введите текст сообщения:")
    await SendEmail.next()
@dp.message_handler(state=SendEmail.body)
async def send_body_handler(message: types.Message, state: FSMContext):
    body = message.text
    data = await state.get_data()
    recipient = data.get('recipient')
    subject = data.get('subject')
    server = smtplib.SMTP('smtp.mail.ru', 587)
    server.starttls()
    email_address = 'почта@mail.ru' #менять
    password = 'пароль для приложений' #менять
    server.login(email_address, password)
    try:
        mail_message = f"Subject: {subject}\n\n{body}".encode('utf-8')
        server.sendmail(email_address, recipient, mail_message)
        server.quit()
        await message.reply("Письмо отправлено успешно!")
        user_id = message.from_user.id
        c.execute("UPDATE users SET emails_sent = emails_sent + 1, last_email_date = ? WHERE id = ?", (datetime.now().date().strftime('%Y-%m-%d'), user_id))
        conn.commit()
        await state.finish()
    except Exception as e:
        await message.reply(f"❌ Ошибка при отправке письма: {str(e)} ❌")
        server.quit()
        await state.finish()
@dp.callback_query_handler(lambda c: c.data == 'pay')
async def process_sponsor(callback_query: types.CallbackQuery):
    user_id = callback_query.from_user.id
    c.execute("SELECT subscription FROM users WHERE id = ?", (user_id,))
    subscription_status = c.fetchone()[0]
    if subscription_status:
        await bot.send_message(user_id, "У вас уже есть активная подписка.")
    else:
        usdt_invoice = await crypto_mainnet.create_invoice(amount=2, asset='USDT')
        invoice_url = usdt_invoice.bot_invoice_url
        invoices_users[usdt_invoice.invoice_id] = callback_query.from_user.id
        markup = types.InlineKeyboardMarkup()
        item_back = types.InlineKeyboardButton("⬅Назад", callback_data='back')
        item_link = types.InlineKeyboardButton("Ссылка на счет", url=invoice_url)
        markup.add(item_back, item_link)
        
        await bot.edit_message_text(chat_id=callback_query.from_user.id, message_id=callback_query.message.message_id,
                                     text="Подписка\n\n"
                                          "Получите доступ к отправке до 300 писем в месяц🚀\n\n"
                                          "✅ Преимущества подписки:\n"
                                          "  - Отправляйте письма анонимно\n"
                                          "  - Пользуйтесь нашими услугами 24/7\n"
                                          "  - Получайте доступ к 20+ почтам\n\n"
                                          "💸 Стоимость подписки:\n"
                                          "  - Ежемесячная подписка стоит 2$",
                                     reply_markup=markup)
    await callback_query.answer()
async def check_invoice_status():
    processed_invoices = set()
    while True:
        invoices = await crypto_mainnet.get_invoices()
        if invoices is None:
            await asyncio.sleep(5)
            continue
        for invoice in invoices:
            if invoice.status == 'paid':
                user_id = invoices_users.get(invoice.invoice_id)
                if user_id and invoice.invoice_id not in processed_invoices:
                    await bot.send_message(user_id, "💸")
                    await asyncio.sleep(5)
                    await bot.send_message(user_id, "Платеж прошел успешно")
                    expiry_date = datetime.now() + timedelta(days=30)
                    c.execute("UPDATE users SET subscription = 1, subscription_expiry = ? WHERE id = ?", (expiry_date, user_id))
                    conn.commit()

                    processed_invoices.add(invoice.invoice_id)
        await asyncio.sleep(5)
@dp.callback_query_handler(lambda c: c.data == 'back')
async def process_back(callback_query: types.CallbackQuery):
    await bot.answer_callback_query(callback_query.id)
    user_id = callback_query.from_user.id
    c.execute("SELECT * FROM users WHERE id = ?", (user_id,))
    user_data = c.fetchone()
    if user_data:
        registration_date_str = user_data[1]
        registration_date = datetime.strptime(registration_date_str, '%Y-%m-%d %H:%M:%S')
        subscription = "Активна" if user_data[2] else "Неактивна"
        emails_sent = user_data[3]
        subscription_expiry = user_data[4]
        last_email_date = user_data[5]
        today = datetime.now().date()
        if last_email_date is None or datetime.strptime(last_email_date, '%Y-%m-%d').date() < today:
            c.execute("UPDATE users SET emails_sent = 0 WHERE id = ?", (user_id,))
            conn.commit()
        if subscription_expiry:
            subscription_expiry_str = subscription_expiry
            subscription_expiry_str = re.sub(r'\.\d+$', '', subscription_expiry_str)
            try:
                subscription_expiry = datetime.strptime(subscription_expiry_str, '%Y-%m-%d %H:%M:%S')
            except ValueError:
                subscription = "Неактивна"
            else:
                if subscription_expiry < datetime.now():
                    subscription = "Неактивна"
        days_in_bot = (datetime.now() - registration_date).days
    else:
        subscription = "Неактивна"
        c.execute("INSERT INTO users (id, last_email_date) VALUES (?, ?)", (user_id, None))
        conn.commit()
        registration_date = datetime.now()
        emails_sent = 0
        days_in_bot = 0
    profile_text = (
        "🖥 Профиль\n"
        "➖➖➖➖➖➖➖➖➖➖➖➖➖\n"
        f"🗞 Дней в боте: {days_in_bot}\n"
        f"⏳ Дата регистрации: {registration_date.strftime('%Y-%m-%d %H:%M')}\n"
        f"💻 Данные: ({user_id})\n"
        f"⚜️ Подписка: {subscription}\n"
        f"💠 Отправленных писем: {emails_sent}\n"
        "➖➖➖➖➖➖➖➖➖➖➖➖➖"
    )
    keyboard = InlineKeyboardMarkup(row_width=2)
    send_email_button = InlineKeyboardButton("Отправить письмо", callback_data="send_email")
    buy_subscription_button = InlineKeyboardButton("Купить подписку", callback_data="pay")
    help_button = InlineKeyboardButton("Помощь", callback_data="help")
    keyboard.add(send_email_button, buy_subscription_button, help_button)
    await bot.edit_message_text(chat_id=callback_query.message.chat.id,
                                 message_id=callback_query.message.message_id,
                                 text=profile_text,
                                 reply_markup=keyboard)
@dp.callback_query_handler(lambda c: c.data == 'help')
async def process_help(callback_query: types.CallbackQuery):
    help_text = (
        "Этот бот позволяет вам отправлять электронные письма через Telegram.\n\n"
        "Для начала работы с ботом используйте команду /start.\n\n"
        "Вы можете сделать следующее:\n"
        "- Нажмите 'Отправить письмо', чтобы отправить электронное письмо.\n"
        "- Нажмите 'Купить подписку', чтобы получить доступ к отправке писем.\n"
        "- Если у вас возникли вопросы, напишите @модер.\n" #менять
        "\nСпасибо, что выбрали нашего бота!"
    )
    keyboard = InlineKeyboardMarkup()
    back_button = InlineKeyboardButton("⬅Назад", callback_data="back")
    keyboard.add(back_button)
    await bot.edit_message_text(chat_id=callback_query.message.chat.id,
                                message_id=callback_query.message.message_id,
                                text=help_text,
                                reply_markup=keyboard)
    await callback_query.answer()
if __name__ == '__main__':
    loop = asyncio.get_event_loop()
    loop.create_task(check_invoice_status())
    executor.start_polling(dp, skip_updates=True)
    conn.close()

 

[dopes]

вот это уже годно прям, скачаю()