Vladless
670 lines
26 KiB
Python
670 lines
26 KiB
Python
import asyncio
|
|
import uuid
|
|
|
|
from datetime import datetime, timedelta
|
|
from typing import Any
|
|
|
|
import pytz
|
|
|
|
from aiogram import F, Router
|
|
from aiogram.fsm.context import FSMContext
|
|
from aiogram.types import CallbackQuery, InlineKeyboardButton, Message, FSInputFile
|
|
from aiogram.utils.keyboard import InlineKeyboardBuilder
|
|
from py3xui import AsyncApi
|
|
|
|
from bot import bot
|
|
from config import (
|
|
ADMIN_PASSWORD,
|
|
ADMIN_USERNAME,
|
|
CONNECT_PHONE_BUTTON,
|
|
NOTIFY_EXTRA_DAYS,
|
|
PUBLIC_LINK,
|
|
RENEWAL_PRICES,
|
|
SUPPORT_CHAT_URL,
|
|
TRIAL_TIME,
|
|
TRIAL_TIME_DISABLE,
|
|
USE_COUNTRY_SELECTION,
|
|
USE_NEW_PAYMENT_FLOW,
|
|
)
|
|
from database import (
|
|
add_connection,
|
|
check_connection_exists,
|
|
create_temporary_data,
|
|
get_balance,
|
|
get_key_details,
|
|
get_trial,
|
|
store_key,
|
|
update_balance,
|
|
update_trial,
|
|
check_server_name_by_cluster,
|
|
)
|
|
from handlers.buttons import (
|
|
BACK,
|
|
CONNECT_DEVICE,
|
|
CONNECT_PHONE,
|
|
MAIN_MENU,
|
|
PAYMENT,
|
|
PC_BUTTON,
|
|
SUPPORT,
|
|
TV_BUTTON,
|
|
)
|
|
from handlers.keys.key_utils import create_client_on_server, create_key_on_cluster
|
|
from handlers.payments.robokassa_pay import handle_custom_amount_input
|
|
from handlers.payments.yookassa_pay import process_custom_amount_input
|
|
from handlers.texts import (
|
|
CREATING_CONNECTION_MSG,
|
|
DISCOUNTS,
|
|
INSUFFICIENT_FUNDS_MSG,
|
|
SELECT_COUNTRY_MSG,
|
|
SELECT_TARIFF_PLAN_MSG,
|
|
key_message_success,
|
|
)
|
|
from handlers.utils import edit_or_send_message, generate_random_email, get_least_loaded_cluster
|
|
from logger import logger
|
|
from panels.three_xui import delete_client
|
|
|
|
|
|
router = Router()
|
|
|
|
moscow_tz = pytz.timezone("Europe/Moscow")
|
|
|
|
|
|
class Form(FSMContext):
|
|
waiting_for_server_selection = "waiting_for_server_selection"
|
|
waiting_for_key_name = "waiting_for_key_name"
|
|
viewing_profile = "viewing_profile"
|
|
waiting_for_message = "waiting_for_message"
|
|
|
|
|
|
@router.callback_query(F.data == "create_key")
|
|
async def confirm_create_new_key(callback_query: CallbackQuery, state: FSMContext, session: Any):
|
|
tg_id = callback_query.message.chat.id
|
|
await handle_key_creation(tg_id, state, session, callback_query)
|
|
|
|
|
|
async def handle_key_creation(
|
|
tg_id: int,
|
|
state: FSMContext,
|
|
session: Any,
|
|
message_or_query: Message | CallbackQuery,
|
|
):
|
|
"""Создание ключа с учётом выбора тарифного плана."""
|
|
current_time = datetime.now(moscow_tz)
|
|
|
|
if not TRIAL_TIME_DISABLE:
|
|
trial_status = await get_trial(tg_id, session)
|
|
if trial_status in [0, -1]:
|
|
extra_days = NOTIFY_EXTRA_DAYS if trial_status == -1 else 0
|
|
expiry_time = current_time + timedelta(days=TRIAL_TIME + extra_days)
|
|
logger.info(f"Доступен {TRIAL_TIME + extra_days}-дневный пробный период пользователю {tg_id}.")
|
|
await edit_or_send_message(
|
|
target_message=message_or_query if isinstance(message_or_query, Message) else message_or_query.message,
|
|
text=CREATING_CONNECTION_MSG,
|
|
reply_markup=None,
|
|
)
|
|
await state.update_data(is_trial=True)
|
|
await create_key(tg_id, expiry_time, state, session, message_or_query)
|
|
return
|
|
|
|
builder = InlineKeyboardBuilder()
|
|
for index, (plan_id, price) in enumerate(RENEWAL_PRICES.items()):
|
|
discount_text = ""
|
|
if DISCOUNTS and plan_id in DISCOUNTS:
|
|
discount_percentage = DISCOUNTS[plan_id]
|
|
discount_text = f" ({discount_percentage}% скидка)"
|
|
if index == len(RENEWAL_PRICES) - 1:
|
|
discount_text = f" ({discount_percentage}% 🔥)"
|
|
builder.row(
|
|
InlineKeyboardButton(
|
|
text=f"📅 {plan_id} мес. - {price}₽{discount_text}",
|
|
callback_data=f"select_plan_{plan_id}",
|
|
)
|
|
)
|
|
builder.row(InlineKeyboardButton(text=MAIN_MENU, callback_data="profile"))
|
|
|
|
if isinstance(message_or_query, CallbackQuery):
|
|
target_message = message_or_query.message
|
|
else:
|
|
target_message = message_or_query
|
|
|
|
await edit_or_send_message(
|
|
target_message=target_message,
|
|
text=SELECT_TARIFF_PLAN_MSG,
|
|
reply_markup=builder.as_markup(),
|
|
media_path=None,
|
|
)
|
|
|
|
await state.update_data(tg_id=tg_id)
|
|
await state.set_state(Form.waiting_for_server_selection)
|
|
|
|
|
|
@router.callback_query(F.data.startswith("select_plan_"))
|
|
async def select_tariff_plan(callback_query: CallbackQuery, session: Any, state: FSMContext):
|
|
tg_id = callback_query.message.chat.id
|
|
plan_id = callback_query.data.split("_")[-1]
|
|
plan_price = RENEWAL_PRICES.get(plan_id)
|
|
if plan_price is None:
|
|
await callback_query.message.answer("🚫 Неверный тарифный план.")
|
|
return
|
|
duration_days = int(plan_id) * 30
|
|
balance = await get_balance(tg_id)
|
|
if balance < plan_price:
|
|
required_amount = plan_price - balance
|
|
await create_temporary_data(
|
|
session,
|
|
tg_id,
|
|
"waiting_for_payment",
|
|
{
|
|
"plan_id": plan_id,
|
|
"plan_price": plan_price,
|
|
"duration_days": duration_days,
|
|
"required_amount": required_amount,
|
|
},
|
|
)
|
|
if USE_NEW_PAYMENT_FLOW == "YOOKASSA":
|
|
await process_custom_amount_input(callback_query, session)
|
|
elif USE_NEW_PAYMENT_FLOW == "ROBOKASSA":
|
|
await handle_custom_amount_input(callback_query, session)
|
|
else:
|
|
builder = InlineKeyboardBuilder()
|
|
builder.row(InlineKeyboardButton(text=PAYMENT, callback_data="pay"))
|
|
builder.row(InlineKeyboardButton(text=MAIN_MENU, callback_data="profile"))
|
|
await edit_or_send_message(
|
|
target_message=callback_query.message,
|
|
text=INSUFFICIENT_FUNDS_MSG.format(required_amount=required_amount),
|
|
reply_markup=builder.as_markup(),
|
|
media_path=None,
|
|
)
|
|
return
|
|
builder = InlineKeyboardBuilder()
|
|
builder.row(InlineKeyboardButton(text="⏳ Подождите...", callback_data="creating_key"))
|
|
|
|
await edit_or_send_message(
|
|
target_message=callback_query.message,
|
|
text=CREATING_CONNECTION_MSG,
|
|
reply_markup=builder.as_markup(),
|
|
)
|
|
|
|
expiry_time = datetime.now(moscow_tz) + timedelta(days=duration_days)
|
|
await state.update_data(plan_id=plan_id)
|
|
await create_key(tg_id, expiry_time, state, session, callback_query, plan=int(plan_id))
|
|
|
|
async def create_key(
|
|
tg_id: int,
|
|
expiry_time: datetime,
|
|
state: FSMContext | None,
|
|
session: Any,
|
|
message_or_query: Message | CallbackQuery | None = None,
|
|
old_key_name: str = None,
|
|
plan: int = None,
|
|
):
|
|
"""Создаёт ключ с заданным сроком действия."""
|
|
|
|
target_message = message_or_query.message if isinstance(message_or_query, CallbackQuery) else message_or_query
|
|
if not await check_connection_exists(tg_id):
|
|
await add_connection(tg_id, balance=0.0, trial=0, session=session)
|
|
logger.info(f"[Connection] Подключение создано для пользователя {tg_id}")
|
|
|
|
if USE_COUNTRY_SELECTION:
|
|
logger.info("[Country Selection] USE_COUNTRY_SELECTION включен. Получение наименее загруженного кластера")
|
|
least_loaded_cluster = await get_least_loaded_cluster()
|
|
logger.info(f"[Country Selection] Наименее загруженный кластер: {least_loaded_cluster}. Получаем список серверов")
|
|
servers = await session.fetch(
|
|
"SELECT server_name, api_url FROM servers WHERE cluster_name = $1",
|
|
least_loaded_cluster,
|
|
)
|
|
if not servers:
|
|
logger.error(f"Нет серверов в кластере {least_loaded_cluster}")
|
|
error_message = "❌ Нет доступных серверов для создания ключа."
|
|
if target_message:
|
|
await edit_or_send_message(
|
|
target_message=target_message, text=error_message, reply_markup=None, media_path=None
|
|
)
|
|
else:
|
|
await bot.send_message(chat_id=tg_id, text=error_message)
|
|
return
|
|
|
|
available_servers = []
|
|
tasks = []
|
|
for server in servers:
|
|
server_info = {
|
|
"server_name": server["server_name"],
|
|
"api_url": server["api_url"],
|
|
}
|
|
task = asyncio.create_task(check_server_availability(server_info))
|
|
tasks.append(task)
|
|
|
|
results = await asyncio.gather(*tasks, return_exceptions=True)
|
|
|
|
for server, result in zip(servers, results):
|
|
if result is True:
|
|
available_servers.append(server["server_name"])
|
|
|
|
if not available_servers:
|
|
logger.error(f"Нет доступных серверов в кластере {least_loaded_cluster}")
|
|
error_message = "❌ Нет доступных серверов для создания ключа."
|
|
if target_message:
|
|
await edit_or_send_message(
|
|
target_message=target_message, text=error_message, reply_markup=None, media_path=None
|
|
)
|
|
else:
|
|
await bot.send_message(chat_id=tg_id, text=error_message)
|
|
return
|
|
|
|
logger.info(f"[Country Selection] Список доступных серверов: {available_servers}")
|
|
|
|
builder = InlineKeyboardBuilder()
|
|
ts = int(expiry_time.timestamp())
|
|
for country in available_servers:
|
|
if old_key_name:
|
|
callback_data = f"select_country|{country}|{ts}|{old_key_name}"
|
|
else:
|
|
callback_data = f"select_country|{country}|{ts}"
|
|
builder.row(InlineKeyboardButton(text=country, callback_data=callback_data))
|
|
builder.row(InlineKeyboardButton(text=MAIN_MENU, callback_data="profile"))
|
|
|
|
if target_message:
|
|
await edit_or_send_message(
|
|
target_message=target_message,
|
|
text=SELECT_COUNTRY_MSG,
|
|
reply_markup=builder.as_markup(),
|
|
media_path=None,
|
|
)
|
|
else:
|
|
await bot.send_message(
|
|
chat_id=tg_id,
|
|
text=SELECT_COUNTRY_MSG,
|
|
reply_markup=builder.as_markup(),
|
|
)
|
|
return
|
|
|
|
while True:
|
|
key_name = generate_random_email()
|
|
logger.info(f"[Key Generation] Сгенерировано имя ключа: {key_name} для пользователя {tg_id}")
|
|
existing_key = await get_key_details(key_name, session)
|
|
if not existing_key:
|
|
break
|
|
logger.warning(f"[Key Generation] Имя ключа {key_name} уже существует. Генерация нового.")
|
|
|
|
client_id = str(uuid.uuid4())
|
|
email = key_name.lower()
|
|
expiry_timestamp = int(expiry_time.timestamp() * 1000)
|
|
public_link = f"{PUBLIC_LINK}{email}/{tg_id}"
|
|
|
|
try:
|
|
least_loaded_cluster = await get_least_loaded_cluster()
|
|
tasks = [
|
|
asyncio.create_task(
|
|
create_key_on_cluster(least_loaded_cluster, tg_id, client_id, email, expiry_timestamp, plan)
|
|
)
|
|
]
|
|
await asyncio.gather(*tasks, return_exceptions=True)
|
|
logger.info(f"[Key Creation] Ключ создан на кластере {least_loaded_cluster} для пользователя {tg_id}")
|
|
await store_key(
|
|
tg_id,
|
|
client_id,
|
|
email,
|
|
expiry_timestamp,
|
|
public_link,
|
|
least_loaded_cluster,
|
|
session,
|
|
)
|
|
|
|
data = {}
|
|
if state:
|
|
data = await state.get_data()
|
|
|
|
if data.get("is_trial"):
|
|
trial_status = await get_trial(tg_id, session)
|
|
if trial_status in [0, -1]:
|
|
await update_trial(tg_id, 1, session)
|
|
if data.get("plan_id"):
|
|
plan_price = RENEWAL_PRICES.get(data["plan_id"])
|
|
await update_balance(tg_id, -plan_price, session)
|
|
logger.info(f"[Database] Ключ сохранён в базе данных для пользователя {tg_id}")
|
|
except Exception as e:
|
|
logger.error(f"[Error] Ошибка при создании ключа для пользователя {tg_id}: {e}")
|
|
error_message = "❌ Произошла ошибка при создании подписки. Пожалуйста, попробуйте снова."
|
|
if target_message:
|
|
await edit_or_send_message(
|
|
target_message=target_message, text=error_message, reply_markup=None, media_path=None
|
|
)
|
|
else:
|
|
await bot.send_message(chat_id=tg_id, text=error_message)
|
|
return
|
|
|
|
builder = InlineKeyboardBuilder()
|
|
if CONNECT_PHONE_BUTTON:
|
|
builder.row(InlineKeyboardButton(text=CONNECT_PHONE, callback_data=f"connect_phone|{key_name}"))
|
|
builder.row(
|
|
InlineKeyboardButton(text=PC_BUTTON, callback_data=f"connect_pc|{email}"),
|
|
InlineKeyboardButton(text=TV_BUTTON, callback_data=f"connect_tv|{email}"),
|
|
)
|
|
else:
|
|
builder.row(
|
|
InlineKeyboardButton(
|
|
text=CONNECT_DEVICE,
|
|
callback_data=f"connect_device|{key_name}",
|
|
)
|
|
)
|
|
builder.row(InlineKeyboardButton(text=SUPPORT, url=SUPPORT_CHAT_URL))
|
|
builder.row(InlineKeyboardButton(text=MAIN_MENU, callback_data="profile"))
|
|
|
|
expiry_time_local = expiry_time.replace(tzinfo=None).astimezone(moscow_tz)
|
|
remaining_time = expiry_time_local - datetime.now(moscow_tz)
|
|
days = remaining_time.days
|
|
key_message_text = key_message_success(public_link, f"⏳ Осталось дней: {days} 📅")
|
|
|
|
default_media_path = "img/pic.jpg"
|
|
|
|
if target_message:
|
|
await edit_or_send_message(
|
|
target_message=target_message,
|
|
text=key_message_text,
|
|
reply_markup=builder.as_markup(),
|
|
media_path=default_media_path,
|
|
)
|
|
|
|
else:
|
|
photo = FSInputFile(default_media_path)
|
|
await bot.send_photo(
|
|
chat_id=tg_id,
|
|
photo=photo,
|
|
caption=key_message_text,
|
|
reply_markup=builder.as_markup(),
|
|
)
|
|
if state:
|
|
await state.clear()
|
|
|
|
|
|
@router.callback_query(F.data.startswith("change_location|"))
|
|
async def change_location_callback(callback_query: CallbackQuery, session: Any):
|
|
try:
|
|
data = callback_query.data.split("|")
|
|
if len(data) < 2:
|
|
await callback_query.answer("❌ Некорректные данные", show_alert=True)
|
|
return
|
|
|
|
old_key_name = data[1]
|
|
record = await get_key_details(old_key_name, session)
|
|
if not record:
|
|
await callback_query.answer("❌ Ключ не найден", show_alert=True)
|
|
return
|
|
|
|
expiry_timestamp = record["expiry_time"]
|
|
ts = int(expiry_timestamp / 1000)
|
|
|
|
current_server = record["server_id"]
|
|
|
|
cluster_info = await check_server_name_by_cluster(current_server, session)
|
|
if not cluster_info:
|
|
await callback_query.answer("❌ Кластер для текущего сервера не найден", show_alert=True)
|
|
return
|
|
|
|
cluster_name = cluster_info["cluster_name"]
|
|
|
|
servers = await session.fetch(
|
|
"SELECT server_name, api_url FROM servers WHERE cluster_name = $1 AND server_name != $2",
|
|
cluster_name,
|
|
current_server,
|
|
)
|
|
if not servers:
|
|
await callback_query.answer("❌ Доступных серверов в кластере не найдено", show_alert=True)
|
|
return
|
|
|
|
available_servers = []
|
|
tasks = []
|
|
for server in servers:
|
|
server_info = {
|
|
"server_name": server["server_name"],
|
|
"api_url": server["api_url"],
|
|
}
|
|
task = asyncio.create_task(check_server_availability(server_info))
|
|
tasks.append(task)
|
|
|
|
results = await asyncio.gather(*tasks, return_exceptions=True)
|
|
|
|
for server, result in zip(servers, results):
|
|
if result is True:
|
|
available_servers.append(server["server_name"])
|
|
|
|
if not available_servers:
|
|
await callback_query.answer("❌ Нет доступных серверов для смены локации", show_alert=True)
|
|
return
|
|
|
|
logger.info(f"Доступные страны для смены локации: {available_servers}")
|
|
|
|
builder = InlineKeyboardBuilder()
|
|
for country in available_servers:
|
|
callback_data = f"select_country|{country}|{ts}|{old_key_name}"
|
|
builder.row(InlineKeyboardButton(text=country, callback_data=callback_data))
|
|
builder.row(InlineKeyboardButton(text=BACK, callback_data=f"view_key|{old_key_name}"))
|
|
|
|
await edit_or_send_message(
|
|
target_message=callback_query.message,
|
|
text="🌍 Пожалуйста, выберите новую локацию для вашей подписки:",
|
|
reply_markup=builder.as_markup(),
|
|
media_path=None,
|
|
)
|
|
except Exception as e:
|
|
logger.error(f"Ошибка при смене локации для пользователя {callback_query.from_user.id}: {e}")
|
|
await callback_query.answer("❌ Ошибка смены локации. Попробуйте снова.", show_alert=True)
|
|
|
|
|
|
@router.callback_query(F.data.startswith("select_country|"))
|
|
async def handle_country_selection(callback_query: CallbackQuery, session: Any, state: FSMContext):
|
|
"""
|
|
Обрабатывает выбор страны.
|
|
Формат callback data:
|
|
select_country|{selected_country}|{ts} [|{old_key_name} (опционально)]
|
|
Если передан old_key_name – значит, происходит смена локации.
|
|
"""
|
|
data = callback_query.data.split("|")
|
|
if len(data) < 3:
|
|
await callback_query.message.answer("❌ Некорректные данные. Попробуйте снова.")
|
|
return
|
|
|
|
selected_country = data[1]
|
|
try:
|
|
ts = int(data[2])
|
|
except ValueError:
|
|
await callback_query.message.answer("❌ Некорректное время истечения. Попробуйте снова.")
|
|
return
|
|
|
|
expiry_time = datetime.fromtimestamp(ts, tz=moscow_tz)
|
|
|
|
old_key_name = data[3] if len(data) > 3 else None
|
|
|
|
tg_id = callback_query.from_user.id
|
|
logger.info(f"Пользователь {tg_id} выбрал страну: {selected_country}")
|
|
logger.info(f"Получено время истечения (timestamp): {ts}")
|
|
|
|
await finalize_key_creation(tg_id, expiry_time, selected_country, state, session, callback_query, old_key_name)
|
|
|
|
|
|
async def finalize_key_creation(
|
|
tg_id: int,
|
|
expiry_time: datetime,
|
|
selected_country: str,
|
|
state: FSMContext | None,
|
|
session: Any,
|
|
callback_query: CallbackQuery,
|
|
old_key_name: str = None,
|
|
):
|
|
"""Финализирует создание ключа с выбором стран."""
|
|
|
|
if not await check_connection_exists(tg_id):
|
|
await add_connection(tg_id, balance=0.0, trial=0, session=session)
|
|
logger.info(f"[Connection] Подключение создано для пользователя {tg_id}")
|
|
|
|
expiry_time = expiry_time.astimezone(moscow_tz)
|
|
|
|
if old_key_name:
|
|
old_key_details = await get_key_details(old_key_name, session)
|
|
if not old_key_details:
|
|
await callback_query.message.answer("❌ Ключ не найден. Попробуйте снова.")
|
|
return
|
|
|
|
key_name = old_key_name
|
|
client_id = old_key_details["client_id"]
|
|
email = old_key_details["email"]
|
|
expiry_timestamp = old_key_details["expiry_time"]
|
|
public_link = old_key_details["key"]
|
|
else:
|
|
while True:
|
|
key_name = generate_random_email()
|
|
existing_key = await get_key_details(key_name, session)
|
|
if not existing_key:
|
|
break
|
|
logger.warning(f"Key name '{key_name}' already exists for user {tg_id}. Generating a new one.")
|
|
|
|
client_id = str(uuid.uuid4())
|
|
email = key_name.lower()
|
|
expiry_timestamp = int(expiry_time.timestamp() * 1000)
|
|
public_link = f"{PUBLIC_LINK}{email}/{tg_id}"
|
|
|
|
try:
|
|
server_info = await session.fetchrow(
|
|
"SELECT api_url, inbound_id, server_name FROM servers WHERE server_name = $1",
|
|
selected_country,
|
|
)
|
|
|
|
if not server_info:
|
|
raise ValueError(f"Сервер {selected_country} не найден.")
|
|
|
|
if old_key_name:
|
|
old_server_id = old_key_details.get("server_id")
|
|
if old_server_id:
|
|
old_server_info = await session.fetchrow(
|
|
"SELECT api_url, inbound_id, server_name FROM servers WHERE server_name = $1",
|
|
old_server_id,
|
|
)
|
|
|
|
if old_server_info:
|
|
xui = AsyncApi(
|
|
old_server_info["api_url"],
|
|
username=ADMIN_USERNAME,
|
|
password=ADMIN_PASSWORD,
|
|
logger=logger,
|
|
)
|
|
deletion_success = await delete_client(
|
|
xui,
|
|
old_server_info["inbound_id"],
|
|
email,
|
|
client_id,
|
|
)
|
|
if not deletion_success:
|
|
logger.warning(f"Не удалось удалить клиента с сервера {old_server_id}, но продолжаем процесс.")
|
|
|
|
semaphore = asyncio.Semaphore(2)
|
|
await create_client_on_server(
|
|
server_info=server_info,
|
|
tg_id=tg_id,
|
|
client_id=client_id,
|
|
email=email,
|
|
expiry_timestamp=expiry_timestamp,
|
|
semaphore=semaphore,
|
|
)
|
|
|
|
logger.info(f"Key created on server {selected_country} for user {tg_id}.")
|
|
|
|
if old_key_name:
|
|
await session.execute(
|
|
"""
|
|
UPDATE keys
|
|
SET server_id = $1
|
|
WHERE tg_id = $2 AND email = $3
|
|
""",
|
|
selected_country,
|
|
tg_id,
|
|
old_key_name,
|
|
)
|
|
else:
|
|
created_at = int(datetime.now(moscow_tz).timestamp() * 1000)
|
|
await session.execute(
|
|
"""
|
|
INSERT INTO keys (tg_id, client_id, email, created_at, expiry_time, key, server_id)
|
|
VALUES ($1, $2, $3, $4, $5, $6, $7)
|
|
""",
|
|
tg_id,
|
|
client_id,
|
|
email,
|
|
created_at,
|
|
expiry_timestamp,
|
|
public_link,
|
|
selected_country,
|
|
)
|
|
data = await state.get_data()
|
|
if data.get("is_trial"):
|
|
trial_status = await get_trial(tg_id, session)
|
|
if trial_status in [0, -1]:
|
|
await update_trial(tg_id, 1, session)
|
|
if data.get("plan_id"):
|
|
plan_price = RENEWAL_PRICES.get(data["plan_id"])
|
|
await update_balance(tg_id, -plan_price, session)
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error while creating the key for user {tg_id}: {e}")
|
|
await callback_query.message.answer("❌ Произошла ошибка при создании подписки. Пожалуйста, попробуйте снова.")
|
|
return
|
|
|
|
builder = InlineKeyboardBuilder()
|
|
builder.row(InlineKeyboardButton(text=SUPPORT, url=SUPPORT_CHAT_URL))
|
|
if CONNECT_PHONE_BUTTON:
|
|
builder.row(InlineKeyboardButton(text=CONNECT_PHONE, callback_data=f"connect_phone|{key_name}"))
|
|
builder.row(
|
|
InlineKeyboardButton(text=PC_BUTTON, callback_data=f"connect_pc|{email}"),
|
|
InlineKeyboardButton(text=TV_BUTTON, callback_data=f"connect_tv|{email}"),
|
|
)
|
|
else:
|
|
builder.row(
|
|
InlineKeyboardButton(
|
|
text=CONNECT_DEVICE,
|
|
callback_data=f"connect_device|{key_name}",
|
|
)
|
|
)
|
|
builder.row(InlineKeyboardButton(text=MAIN_MENU, callback_data="profile"))
|
|
|
|
remaining_time = expiry_time - datetime.now(moscow_tz)
|
|
days = remaining_time.days
|
|
key_message_text = key_message_success(public_link, f"⏳ Осталось дней: {days} 📅")
|
|
|
|
default_media_path = "img/pic.jpg"
|
|
|
|
await edit_or_send_message(
|
|
target_message=callback_query.message,
|
|
text=key_message_text,
|
|
reply_markup=builder.as_markup(),
|
|
media_path=default_media_path,
|
|
)
|
|
|
|
if state:
|
|
await state.clear()
|
|
|
|
async def check_server_availability(server_info: dict) -> bool:
|
|
"""
|
|
Проверяет доступность сервера через API.
|
|
|
|
Args:
|
|
server_info (dict): Информация о сервере (api_url, username, password).
|
|
|
|
Returns:
|
|
bool: True, если сервер доступен, False в противном случае.
|
|
"""
|
|
try:
|
|
xui = AsyncApi(
|
|
server_info["api_url"],
|
|
username=ADMIN_USERNAME,
|
|
password=ADMIN_PASSWORD,
|
|
logger=logger,
|
|
)
|
|
await asyncio.wait_for(xui.login(), timeout=5.0)
|
|
logger.info(f"Сервер {server_info.get('server_name', 'unknown')} доступен.")
|
|
return True
|
|
except asyncio.TimeoutError:
|
|
logger.warning(f"Сервер {server_info.get('server_name', 'unknown')} не ответил вовремя.")
|
|
return False
|
|
except Exception as e:
|
|
logger.warning(f"Сервер {server_info.get('server_name', 'unknown')} недоступен: {e}")
|
|
return False
|