Vladless
289 lines
10 KiB
Python
289 lines
10 KiB
Python
import asyncio
|
|
import uuid
|
|
from datetime import datetime, timedelta
|
|
|
|
import asyncpg
|
|
from aiogram import F, Router
|
|
from aiogram.fsm.context import FSMContext
|
|
from aiogram.fsm.state import State, StatesGroup
|
|
from aiogram.types import CallbackQuery, InlineKeyboardButton, InlineKeyboardMarkup, Message
|
|
from loguru import logger
|
|
|
|
from bot import bot, dp
|
|
from config import CONNECT_ANDROID, CONNECT_IOS, DATABASE_URL, DOWNLOAD_ANDROID, DOWNLOAD_IOS, PUBLIC_LINK, SERVERS
|
|
from database import add_connection, get_balance, store_key, update_balance
|
|
from handlers.instructions.instructions import send_instructions
|
|
from handlers.keys.key_utils import create_key_on_server
|
|
from handlers.profile import process_callback_view_profile
|
|
from handlers.texts import KEY, KEY_TRIAL, NULL_BALANCE, RENEWAL_PLANS, key_message_success
|
|
from handlers.utils import sanitize_key_name
|
|
|
|
router = Router()
|
|
|
|
|
|
class Form(StatesGroup):
|
|
waiting_for_server_selection = State()
|
|
waiting_for_key_name = State()
|
|
viewing_profile = State()
|
|
waiting_for_message = State()
|
|
|
|
|
|
@dp.callback_query(F.data == "create_key")
|
|
async def process_callback_create_key(callback_query: CallbackQuery, state: FSMContext):
|
|
tg_id = callback_query.from_user.id
|
|
|
|
try:
|
|
await bot.delete_message(
|
|
chat_id=tg_id, message_id=callback_query.message.message_id
|
|
)
|
|
except Exception:
|
|
pass
|
|
|
|
server_id = "все сервера"
|
|
await state.update_data(selected_server_id=server_id)
|
|
await select_server(callback_query, state)
|
|
await callback_query.answer()
|
|
|
|
|
|
async def select_server(callback_query: CallbackQuery, state: FSMContext):
|
|
|
|
conn = await asyncpg.connect(DATABASE_URL)
|
|
try:
|
|
existing_connection = await conn.fetchrow(
|
|
"SELECT trial FROM connections WHERE tg_id = $1",
|
|
callback_query.from_user.id,
|
|
)
|
|
finally:
|
|
await conn.close()
|
|
|
|
trial_status = existing_connection["trial"] if existing_connection else 0
|
|
|
|
if trial_status == 1:
|
|
await bot.send_message(
|
|
chat_id=callback_query.from_user.id,
|
|
text=KEY,
|
|
parse_mode="HTML",
|
|
reply_markup=InlineKeyboardMarkup(
|
|
inline_keyboard=[
|
|
[
|
|
InlineKeyboardButton(
|
|
text="✅ Да, подключить новое устройство",
|
|
callback_data="confirm_create_new_key",
|
|
)
|
|
],
|
|
[
|
|
InlineKeyboardButton(
|
|
text="↩️ Назад", callback_data="cancel_create_key"
|
|
)
|
|
],
|
|
]
|
|
),
|
|
)
|
|
await state.update_data(creating_new_key=True)
|
|
else:
|
|
await bot.send_message(
|
|
chat_id=callback_query.from_user.id, text=KEY_TRIAL, parse_mode="HTML"
|
|
)
|
|
await state.set_state(Form.waiting_for_key_name)
|
|
|
|
await callback_query.answer()
|
|
|
|
|
|
@dp.callback_query(F.data == "confirm_create_new_key")
|
|
async def confirm_create_new_key(callback_query: CallbackQuery, state: FSMContext):
|
|
tg_id = callback_query.from_user.id
|
|
|
|
logger.info(f"User {tg_id} confirmed creation of a new key.")
|
|
|
|
balance = await get_balance(tg_id)
|
|
if balance < RENEWAL_PLANS["1"]["price"]:
|
|
replenish_button = InlineKeyboardButton(
|
|
text="Перейти в профиль", callback_data="view_profile"
|
|
)
|
|
keyboard = InlineKeyboardMarkup(inline_keyboard=[[replenish_button]])
|
|
await callback_query.message.edit_text(NULL_BALANCE, reply_markup=keyboard)
|
|
await state.clear()
|
|
return
|
|
|
|
logger.info(f"Balance for user {tg_id} is sufficient. Asking for device name.")
|
|
|
|
await callback_query.message.edit_text(
|
|
"🔑 Пожалуйста, введите имя подключаемого устройства:"
|
|
)
|
|
await state.set_state(Form.waiting_for_key_name)
|
|
logger.info(f"State set to waiting_for_key_name for user {tg_id}")
|
|
await state.update_data(creating_new_key=True)
|
|
|
|
await callback_query.answer()
|
|
|
|
|
|
@dp.callback_query(F.data == "cancel_create_key")
|
|
async def cancel_create_key(callback_query: CallbackQuery, state: FSMContext):
|
|
await process_callback_view_profile(callback_query, state)
|
|
await callback_query.answer()
|
|
|
|
|
|
@router.message(Form.waiting_for_key_name)
|
|
async def handle_key_name_input(message: Message, state: FSMContext):
|
|
tg_id = message.from_user.id
|
|
key_name = sanitize_key_name(message.text)
|
|
|
|
logger.info(f"User {tg_id} is attempting to create a key with the name: {key_name}")
|
|
|
|
if not key_name:
|
|
await message.bot.send_message(
|
|
tg_id, "📝 Пожалуйста, назовите устройство на английском языке."
|
|
)
|
|
logger.warning(f"User {tg_id} entered an invalid key name: {key_name}")
|
|
return
|
|
|
|
conn = await asyncpg.connect(DATABASE_URL)
|
|
try:
|
|
logger.info(
|
|
f"Checking if key name '{key_name}' already exists in the database."
|
|
)
|
|
existing_key = await conn.fetchrow(
|
|
"SELECT * FROM keys WHERE email = $1", key_name.lower()
|
|
)
|
|
if existing_key:
|
|
await message.bot.send_message(
|
|
tg_id,
|
|
"❌ Упс! Это имя уже используется. Выберите другое уникальное название для ключа.",
|
|
)
|
|
logger.warning(
|
|
f"Key name '{key_name}' already exists in the database for user {tg_id}."
|
|
)
|
|
await state.set_state(Form.waiting_for_key_name)
|
|
return
|
|
finally:
|
|
await conn.close()
|
|
|
|
client_id = str(uuid.uuid4())
|
|
email = key_name.lower()
|
|
current_time = datetime.utcnow()
|
|
expiry_time = None
|
|
|
|
conn = await asyncpg.connect(DATABASE_URL)
|
|
try:
|
|
logger.info(f"Checking trial status for user {tg_id}.")
|
|
existing_connection = await conn.fetchrow(
|
|
"SELECT trial FROM connections WHERE tg_id = $1", tg_id
|
|
)
|
|
finally:
|
|
await conn.close()
|
|
|
|
trial_status = existing_connection["trial"] if existing_connection else 0
|
|
|
|
if trial_status == 0:
|
|
expiry_time = current_time + timedelta(days=1, hours=3)
|
|
logger.info(f"Assigned 1-day trial to user {tg_id}.")
|
|
else:
|
|
balance = await get_balance(tg_id)
|
|
if balance < RENEWAL_PLANS["1"]["price"]:
|
|
replenish_button = InlineKeyboardButton(
|
|
text="Перейти в профиль", callback_data="view_profile"
|
|
)
|
|
keyboard = InlineKeyboardMarkup(inline_keyboard=[[replenish_button]])
|
|
await message.bot.send_message(
|
|
tg_id,
|
|
"💳 Недостаточно средств для создания подписки на новое устройство. Пополните баланс в личном кабинете.",
|
|
reply_markup=keyboard,
|
|
)
|
|
logger.warning(f"User {tg_id} has insufficient funds for key creation.")
|
|
await state.clear()
|
|
return
|
|
|
|
await update_balance(tg_id, -RENEWAL_PLANS["1"]["price"])
|
|
expiry_time = current_time + timedelta(days=30, hours=3)
|
|
logger.info(f"User {tg_id} balance deducted for key creation.")
|
|
|
|
expiry_timestamp = int(expiry_time.timestamp() * 1000)
|
|
public_link = f"{PUBLIC_LINK}{email}"
|
|
|
|
logger.info(f"Generated public link for the key: {public_link}")
|
|
|
|
button_profile = InlineKeyboardButton(
|
|
text="👤 Личный кабинет", callback_data="view_profile"
|
|
)
|
|
button_iphone = InlineKeyboardButton(
|
|
text="🍏 Подключить", url=f"{CONNECT_IOS}{public_link}"
|
|
)
|
|
button_android = InlineKeyboardButton(
|
|
text="🤖 Подключить",
|
|
url=f"{CONNECT_ANDROID}{public_link}",
|
|
)
|
|
|
|
button_download_ios = InlineKeyboardButton(text="🍏 Скачать", url=DOWNLOAD_IOS)
|
|
button_download_android = InlineKeyboardButton(
|
|
text="🤖 Скачать",
|
|
url=DOWNLOAD_ANDROID,
|
|
)
|
|
|
|
keyboard = InlineKeyboardMarkup(
|
|
inline_keyboard=[
|
|
[button_download_ios, button_download_android],
|
|
[button_iphone, button_android],
|
|
[button_profile],
|
|
]
|
|
)
|
|
|
|
remaining_time = expiry_time - current_time
|
|
days = remaining_time.days
|
|
key_message = key_message_success(public_link, f"⏳ Осталось дней: {days} 📅")
|
|
|
|
logger.info(f"Sending key message to user {tg_id} with the public link.")
|
|
|
|
await message.bot.send_message(
|
|
tg_id, key_message, parse_mode="HTML", reply_markup=keyboard
|
|
)
|
|
|
|
try:
|
|
tasks = []
|
|
for server_id in SERVERS:
|
|
tasks.append(
|
|
asyncio.create_task(
|
|
create_key_on_server(
|
|
server_id, tg_id, client_id, email, expiry_timestamp
|
|
)
|
|
)
|
|
)
|
|
|
|
await asyncio.gather(*tasks)
|
|
|
|
conn = await asyncpg.connect(DATABASE_URL)
|
|
try:
|
|
logger.info(f"Updating trial status for user {tg_id} in the database.")
|
|
existing_connection = await conn.fetchrow(
|
|
"SELECT * FROM connections WHERE tg_id = $1", tg_id
|
|
)
|
|
if existing_connection:
|
|
await conn.execute(
|
|
"UPDATE connections SET trial = 1 WHERE tg_id = $1", tg_id
|
|
)
|
|
else:
|
|
await add_connection(tg_id, 0, 1)
|
|
finally:
|
|
await conn.close()
|
|
|
|
logger.info(f"Storing key for user {tg_id} in the database.")
|
|
await store_key(
|
|
tg_id, client_id, email, expiry_timestamp, public_link, "all_servers"
|
|
)
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error while creating the key for user {tg_id}: {e}")
|
|
await message.bot.send_message(tg_id, f"❌ Ошибка при создании ключа: {e}")
|
|
|
|
await state.clear()
|
|
|
|
|
|
@dp.callback_query(F.data == "instructions")
|
|
async def handle_instructions(callback_query: CallbackQuery):
|
|
await send_instructions(callback_query)
|
|
|
|
|
|
@dp.callback_query(F.data == "back_to_main")
|
|
async def handle_back_to_main(callback_query: CallbackQuery, state: FSMContext):
|
|
await process_callback_view_profile(callback_query, state)
|
|
await callback_query.answer()
|