commit cc2f64d4cd080bc28b3caddd2d295fa701ce327a Author: Mary Date: Fri Aug 16 08:42:00 2024 +0300 Initial commit diff --git a/.env b/.env new file mode 100644 index 0000000..a84c7bf --- /dev/null +++ b/.env @@ -0,0 +1,10 @@ +API_TOKEN = "6594413238:AAFahDg955k1GE9a4JE9T9yHyQoJZV5TFEk" +TO_ADRESS = 'TRFBWmb5NkvKuQpYyPaYzZAX46VCUJtiq1' +ARBITRUM_API_KEY = 'P61RFT45N63PJYT5MDY1CEHG1US1C5KZZ4' +ARBITRUM_ADRESS = '683dc0af0d3797523104b57a7889b97a5871fbbb' +ACCOUNT_ID_YK = '438627' +SECRET_KEY_YK = 'test_c4W1yT9yzc8WT-d1YvJKGX59yOfXBMpeNtWegH2uJqo' +DB_HOST = "localhost" +DB_USER = "root" +DB_PASSWORD = "vy!f..rVJ7t9tmG" +DB_DATABASE = "subscriptions" \ No newline at end of file diff --git a/.idea/inspectionProfiles/Project_Default.xml b/.idea/inspectionProfiles/Project_Default.xml new file mode 100644 index 0000000..8bfb0e3 --- /dev/null +++ b/.idea/inspectionProfiles/Project_Default.xml @@ -0,0 +1,31 @@ + + + + \ No newline at end of file diff --git a/.idea/inspectionProfiles/profiles_settings.xml b/.idea/inspectionProfiles/profiles_settings.xml new file mode 100644 index 0000000..105ce2d --- /dev/null +++ b/.idea/inspectionProfiles/profiles_settings.xml @@ -0,0 +1,6 @@ + + + + \ No newline at end of file diff --git a/.idea/misc.xml b/.idea/misc.xml new file mode 100644 index 0000000..2eee177 --- /dev/null +++ b/.idea/misc.xml @@ -0,0 +1,7 @@ + + + + + + \ No newline at end of file diff --git a/.idea/modules.xml b/.idea/modules.xml new file mode 100644 index 0000000..4a010df --- /dev/null +++ b/.idea/modules.xml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/.idea/subscriptions.iml b/.idea/subscriptions.iml new file mode 100644 index 0000000..2c80e12 --- /dev/null +++ b/.idea/subscriptions.iml @@ -0,0 +1,10 @@ + + + + + + + + + + \ No newline at end of file diff --git a/.idea/vcs.xml b/.idea/vcs.xml new file mode 100644 index 0000000..94a25f7 --- /dev/null +++ b/.idea/vcs.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/.idea/workspace.xml b/.idea/workspace.xml new file mode 100644 index 0000000..9377c4c --- /dev/null +++ b/.idea/workspace.xml @@ -0,0 +1,119 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + { + "associatedIndex": 3 +} + + + + + { + "keyToString": { + "Python.admin.executor": "Run", + "Python.bot.executor": "Run", + "Python.database_queries.executor": "Run", + "Python.main.executor": "Run", + "Python.payment_binance_pay.executor": "Run", + "Python.payments.executor": "Run", + "Python.payments_tron.executor": "Run", + "Python.test.executor": "Run", + "Python.test3.executor": "Run", + "Python.utils.executor": "Run", + "RunOnceActivity.OpenProjectViewOnStart": "true", + "RunOnceActivity.ShowReadmeOnStart": "true", + "git-widget-placeholder": "main", + "last_opened_file_path": "C:/Users/PC/Desktop/subscriptions" + } +} + + + + + + + + + + + + + + + + + + + + + + + + + + 1722862614099 + + + + \ No newline at end of file diff --git a/1_IMAGE.png b/1_IMAGE.png new file mode 100644 index 0000000..a9a01d0 Binary files /dev/null and b/1_IMAGE.png differ diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..cf1792f --- /dev/null +++ b/Dockerfile @@ -0,0 +1,17 @@ +# используем базовый образ Python версии 3 +FROM python:3 + +# устанавливаем рабочую директорию внутри контейнера +WORKDIR /app + +# копируем файл с зависимостями проекта в рабочую директорию внутри контейнера +COPY requirements.txt . + +# устанавливаем зависимости внутри контейнера +RUN pip install -r requirements.txt + +# копируем код приложения из текущей папки в рабочую директорию внутри контейнера +COPY . . + +# Запускаем бота +CMD ["python", "main.py"] \ No newline at end of file diff --git a/__pycache__/bot.cpython-312.pyc b/__pycache__/bot.cpython-312.pyc new file mode 100644 index 0000000..e8a593d Binary files /dev/null and b/__pycache__/bot.cpython-312.pyc differ diff --git a/__pycache__/database_queries.cpython-312.pyc b/__pycache__/database_queries.cpython-312.pyc new file mode 100644 index 0000000..bf24b2e Binary files /dev/null and b/__pycache__/database_queries.cpython-312.pyc differ diff --git a/__pycache__/main.cpython-312.pyc b/__pycache__/main.cpython-312.pyc new file mode 100644 index 0000000..a44d858 Binary files /dev/null and b/__pycache__/main.cpython-312.pyc differ diff --git a/__pycache__/states.cpython-312.pyc b/__pycache__/states.cpython-312.pyc new file mode 100644 index 0000000..cd18d47 Binary files /dev/null and b/__pycache__/states.cpython-312.pyc differ diff --git a/__pycache__/utils.cpython-312.pyc b/__pycache__/utils.cpython-312.pyc new file mode 100644 index 0000000..057fd56 Binary files /dev/null and b/__pycache__/utils.cpython-312.pyc differ diff --git a/bot.py b/bot.py new file mode 100644 index 0000000..71f4378 --- /dev/null +++ b/bot.py @@ -0,0 +1,538 @@ + +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() diff --git a/database_queries.py b/database_queries.py new file mode 100644 index 0000000..969f2d9 --- /dev/null +++ b/database_queries.py @@ -0,0 +1,160 @@ +from datetime import datetime, date +from typing import Any +from utils import create_connection + + +def presence_user_bd(user_id: int) -> tuple: + """Проверяем, существует ли пользователь в таблице users """ + conn = create_connection() + cursor = conn.cursor() + cursor.execute("SELECT * FROM users WHERE telegram_id = %s", (user_id,)) + return cursor.fetchone() + +def adding_user_db(user_id: int, username: str) -> None: + """Добавление пользователя в таблицу users (имя и id)""" + conn = create_connection() + cursor = conn.cursor() + cursor.execute( + "INSERT INTO users (telegram_id, telegram_username) VALUES (%s, %s)", + (user_id, username)) + conn.commit() + + +def update_user_db(cursor: Any, thread_id: int, telegram_id: int) -> None: + """Обновление данных по пользователю в таблице users. Добавление айди чата приватного с ботом """ + cursor.execute("UPDATE users SET telegram_thread_id = %s WHERE telegram_id = %s", (thread_id, telegram_id)) + + +def user_search(cursor: Any, message_thread_id: int) -> tuple: + """Поиск пользователя по id в таблице users """ + cursor.execute("SELECT * FROM users WHERE telegram_thread_id = %s", (message_thread_id,)) + return cursor.fetchone() + + +def adding_well(cursor: Any, well: int) -> None: + """ Запись курса доллара в таблицу USD_RUB """ + cursor.execute("REPLACE INTO USD_RUB (id, well) VALUES (%s, %s)", (1, well)) + + +def getting_course(cursor: Any) -> tuple: + """ Получение курса из таблицы USD_RUB """ + cursor.execute("SELECT * FROM USD_RUB WHERE id = 1;") + return cursor.fetchone() + + +def installation_one_question(cursor: Any, telegram_id: int) -> None: + """ Установка единицы в столбце question_time, чтобы блокировать дальнейшие отправки """ + new = 1 + cursor.execute("UPDATE users SET question_time = %s WHERE telegram_id = %s", (new, telegram_id)) + + +def installation_zero_question(cursor: Any, telegram_id: int) -> None: + """ Установка нуля в столбце question_time, чтобы разблокировать дальнейшие отправки вопросов """ + new = 0 + cursor.execute("UPDATE users SET question_time = %s WHERE telegram_id = %s", (new, telegram_id)) + + +def status_question(cursor: Any, telegram_id: int) -> tuple: + """ Получение статуса вопроса (1 или 0) """ + cursor.execute("SELECT question_time FROM users WHERE telegram_id = %s", (telegram_id,)) + return cursor.fetchone() + + +def write_hash_to_table(cursor: Any, hash_user: str, telegram_id: int) -> None: + """ Запись успешного хэша в successful_hash """ + cursor.execute("INSERT INTO successful_hash (hash_users, telegram_id) VALUES (%s, %s)", (hash_user, telegram_id)) + + +def search_hash_in_table(cursor: Any, hash_user: str,) -> bool: + """ Поиск хэша в таблице successful_hash """ + cursor.execute("SELECT EXISTS(SELECT 1 FROM successful_hash WHERE hash_users = %s)", (hash_user,)) + result = cursor.fetchone() + return result[0] if result else False + + +def number_of_streams_from_subscriptions(cursor: Any, telegram_id: int) -> None: + """ Запись 3 ед в столбец count_streams, при условии что нет активной подписки """ + new = 3 + cursor.execute( + "UPDATE users SET count_streams = count_streams + %s " + "WHERE telegram_id = %s AND (sub_datetime_end IS NULL OR sub_datetime_end = '0')", + (new, telegram_id) + ) + + +def number_of_threads_from_threads(cursor: Any, telegram_id: int, price_usd: int) -> None: + """ Плюсование на количество потоков в столбец count_streams к уже существующему значению """ + cursor.execute("UPDATE users SET count_streams = count_streams + %s WHERE telegram_id = %s", + (price_usd, telegram_id)) + + +def get_user_data(cursor: Any, telegram_id: int) -> tuple: + """ Получаем кортеж с данными по пользователю из бд из таблицы users """ + cursor.execute("SELECT * FROM users WHERE telegram_id = %s", (telegram_id,)) + return cursor.fetchone() + + +# def subscription_entry(cursor: Any, telegram_id: int, price_usd: int) -> None: +# """ Запись подписки в столбец subscription_option """ +# new = f"{price_usd} мес" +# cursor.execute( +# "UPDATE users SET subscription_option = %s WHERE telegram_id = %s " +# "AND (sub_datetime_end IS NULL OR sub_datetime_end = '0')", +# (new, telegram_id) +# ) +def subscription_entry(cursor: Any, telegram_id: int, price_usd: int) -> None: + """ Запись количества месяцев в subscription_option """ + cursor.execute("UPDATE users SET subscription_option = subscription_option + %s WHERE telegram_id = %s", + (price_usd, telegram_id)) + + +def subscription_end_record(cursor, telegram_id: int) -> None: + """ Запись даты окончания подписки в столбцы sub_datetime_end и subscription_endtime_bot """ + current_date = datetime.now() # Получение текущей даты + # Получение количества месяцев из столбца subscription_option + select_query = """SELECT subscription_option FROM users WHERE telegram_id = %s""" + cursor.execute(select_query, (telegram_id,)) + result = cursor.fetchone() + # Преобразование значения в число + if result: + subscription_option = result[0] + if isinstance(subscription_option, str): # Проверка типа данных + subscription_option = int(subscription_option.split()[0]) + else: + return + # Формирование запроса на обновление + update_query = """ + UPDATE users + SET sub_datetime_end = DATE_ADD(NOW(), INTERVAL %s MONTH), + subscription_endtime_bot = DATE_ADD(NOW(), INTERVAL %s MONTH) + WHERE telegram_id = %s + """ + cursor.execute(update_query, (subscription_option, subscription_option, telegram_id)) + + +def check_expired_subscriptions() -> list: + """ Получение списка id пользователей, у которых просрочена подписка """ + conn = create_connection() + cursor = conn.cursor() + current_date = date.today() + query = """SELECT telegram_id FROM users WHERE subscription_endtime_bot < %s""" + cursor.execute(query, (current_date,)) + results = cursor.fetchall() + expired_users = [result[0] for result in results] + return expired_users + + +def reset_user_data(telegram_id: int) -> None: + """Обнуляет данные по подписке у пользователя в таблице.""" + conn = create_connection() + cursor = conn.cursor() + update_query = """ + UPDATE users + SET sub_datetime_end = 0, + subscription_option = 0, + subscription_endtime_bot = NULL, + count_streams = 0 + WHERE telegram_id = %s + """ + cursor.execute(update_query, (telegram_id,)) + conn.commit() diff --git a/docker-compose.yaml b/docker-compose.yaml new file mode 100644 index 0000000..fb6e2be --- /dev/null +++ b/docker-compose.yaml @@ -0,0 +1,12 @@ + version: "3.9" + + services: + bot: + build: . + container_name: aiogram_bot + ports: + - "8080:8080" + environment: + - API_TOKEN=${API_TOKEN} + restart: unless-stopped + \ No newline at end of file diff --git a/main.py b/main.py new file mode 100644 index 0000000..57f9f95 --- /dev/null +++ b/main.py @@ -0,0 +1,35 @@ +import os + +from aiogram import Bot, Dispatcher +import asyncio +import bot +from utils import get_usd_rub_course, checking_and_deleting_users +from apscheduler.schedulers.asyncio import AsyncIOScheduler +from dotenv import load_dotenv + +load_dotenv() + +API_TOKEN = os.getenv('API_TOKEN') + + +# Создаем объект бота и диспетчера +bot_chat = Bot(token=API_TOKEN) +dp = Dispatcher() + + +async def main() -> None: + """ Запуск бота """ + dp.include_router(bot.router) + scheduler = AsyncIOScheduler() + # Планируем выполнение функции в 12:00, 18:00 и 00:00 планировщиком + scheduler.add_job(get_usd_rub_course, 'cron', hour='12,18,0') + # Планируем выполнение функции checking_and_deleting_users ежедневно в 00:12 + scheduler.add_job(checking_and_deleting_users, 'cron', hour=0, minute=12) + scheduler.start() + await dp.start_polling(bot_chat) + while True: + await asyncio.sleep(1) + + +if __name__ == "__main__": + asyncio.run(main()) diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..cd2c79c --- /dev/null +++ b/requirements.txt @@ -0,0 +1,8 @@ +aiogram==3.10.0 +requests==2.32.3 +mysql-connector-python==9.0.0 +qrcode==7.4.2 +APScheduler==3.10.4 +yookassa==3.3.0 +uuid +python-dotenv==1.0.1 diff --git a/states.py b/states.py new file mode 100644 index 0000000..ac334f3 --- /dev/null +++ b/states.py @@ -0,0 +1,10 @@ +from aiogram.fsm.state import State, StatesGroup + + +class QuestionStates(StatesGroup): + """Состояние, ожидания от пользователя.""" + + waiting_for_question = State() + waiting_for_hash = State() + count_flow = State() + payment_id = State() diff --git a/utils.py b/utils.py new file mode 100644 index 0000000..5fc7083 --- /dev/null +++ b/utils.py @@ -0,0 +1,125 @@ +import os +from typing import Any +import uuid +from requests.auth import HTTPBasicAuth +from yookassa import Configuration, Payment +import aiohttp +import mysql.connector +import requests +from dotenv import load_dotenv + + +load_dotenv() + + +def get_contract_ret_tron(hash_user: str, amount: int) -> bool: + """ URL для запроса инфо о транзакции tron """ + # GET запрос к API + response = requests.get(f"https://apilist.tronscanapi.com/api/transaction-info?hash={hash_user}") + response.raise_for_status() + data = response.json() # Получаем ответ в джисон + if 'trc20TransferInfo' not in data or len(data['trc20TransferInfo']) == 0: + return False # если нет ключа или он 0, прерываем функцию + amount_hash = amount * 1000000 # реальную сумму надо умножить. так указано в джон ответах + transfer_info = data['trc20TransferInfo'][0] + if transfer_info.get('to_address') == os.getenv('TO_ADRESS'): + if transfer_info.get('amount_str') == str(amount_hash): + return data.get('contractRet') == "SUCCESS" + return False + + +def get_contract_ret_arbitrum(hash_user: str, amount: int) -> bool: + """ URL для запроса инфо о транзакции Arbitrum """ + url = "https://api.arbiscan.io/api" + params = { + 'module': 'proxy', + 'action': 'eth_getTransactionReceipt', + 'txhash': hash_user, + 'apikey': os.getenv('ARBITRUM_API_KEY')} + response = requests.get(url, params=params) + data = response.json() # Получаем ответ в джисон + if 'result' not in data or data['result'] is None: + return False # Прерывание функции, если result нет или пустой + if 'logs' not in data['result'] or len(data['result']['logs']) == 0: + return False # Прерывание функции, если logs нет или пустая + amount_hash = amount * 1000000 # реальную сумму надо умножить. так указано в джон ответах + # в джисон ответе данные в hex формате. ниже идет логика перевода в читабельный формат для проверок + hex_data = data['result']['logs'][0]['data'] + hex_address = data['result']['logs'][0]['topics'][2] + hex_status = data['result']['status'] + decimal_data = int(hex_data, 16) + decimal_status = int(hex_status, 16) + address = hex_address[-40:] + if decimal_data == amount_hash: + if address == os.getenv('ARBITRUM_ADRESS'): + return decimal_status == 1 + return False + + +def create_connection() -> Any: + """ подключения к базе данных mysql """ + connection = mysql.connector.connect( + host=os.getenv('DB_HOST'), + user=os.getenv('DB_USER'), + password=os.getenv('DB_PASSWORD'), + database=os.getenv('DB_DATABASE'),) + return connection + + +async def get_usd_rub_course() -> None: + """Получает курс USD/RUB с openexchangerates.org""" + from database_queries import adding_well + async with aiohttp.ClientSession() as session: + async with session.get( + "https://openexchangerates.org/api/latest.json?" + "app_id=488b07ebd6964a71b838ea93fbebcd31&base=USD&symbols=RUB") as response: + data = await response.json() + usd_rub_course = round(data["rates"]["RUB"], 2) + conn = create_connection() + cursor = conn.cursor() + adding_well(cursor, usd_rub_course) + conn.commit() + + +async def payment_order_yukassa(price_rub: int, bot_username: str) -> dict: + """ Формирование платежки в юкассе. Формат вывода - словарь""" + Configuration.account_id = os.getenv('ACCOUNT_ID_YK') + Configuration.secret_key = os.getenv('SECRET_KEY_YK') + payment = Payment.create({ + "amount": { + "value": price_rub, + "currency": "RUB"}, + "confirmation": { + "type": "redirect", + "return_url": f"https://t.me/{bot_username}"}, + "capture": True, + "description": "Оплата подписки"}, uuid.uuid4()) + return payment + + +def check_payment_status(payment_id: str) -> str: + """ Проверка статуса платежа по айди платежки """ + shop_id = os.getenv('ACCOUNT_ID_YK') + secret_key = os.getenv('SECRET_KEY_YK') + url = f"https://api.yookassa.ru/v3/payments/{payment_id}" + headers = {"Content-Type": "application/json"} + response = requests.get(url, auth=HTTPBasicAuth(shop_id, secret_key), headers=headers) # сам запрос + if response.status_code == 200: + data = response.json() + return data['status'] + else: + raise Exception(f"Ошибка при проверке статуса платежа: {response.status_code}, {response.text}") + + +async def checking_and_deleting_users() -> None: + """ Получает список id пользователй и бот удаляет их из чата, если они там есть """ + from database_queries import check_expired_subscriptions, reset_user_data + from main import bot_chat + list_user_in_table = check_expired_subscriptions() + print(list_user_in_table) + for id_user in list_user_in_table: + try: + await bot_chat.ban_chat_member(-4226821992, id_user) + reset_user_data(id_user) + except Exception as e: + print(f"Ошибка: {e}")