mirror of
https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot.git
synced 2026-01-20 03:40:26 +00:00
427011fe41
2) У промогрупп появится приоритет 3) У пользователя может быть несколько промогрупп, но влиять будет только с наивысшим приоритетом 4) К промокодам можно будет добавить промогруппу. Все активировавшие промокод получат её 5) При выводе пользователей с промогруппой будет также выводиться ссылка на каждого. Можно будет отследить сливы промокодов "для своих". Я в целом это добавлю во все места, где пользователь выводится в админке 6) Исправить баг исчезновения триалки при пополнении 7) Исправить падающие тесты и добавить новых 8) Трафик: 0 ГБ в тестовой подписке исправить на Трафик: Безлимит
2459 lines
84 KiB
Python
2459 lines
84 KiB
Python
from typing import List, Optional
|
||
from aiogram import types
|
||
from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
|
||
from datetime import datetime
|
||
from app.database.models import User
|
||
from sqlalchemy.ext.asyncio import AsyncSession
|
||
|
||
from app.config import settings, PERIOD_PRICES, TRAFFIC_PRICES
|
||
from app.localization.loader import DEFAULT_LANGUAGE
|
||
from app.localization.texts import get_texts
|
||
from app.utils.miniapp_buttons import build_miniapp_or_callback_button
|
||
from app.utils.pricing_utils import (
|
||
format_period_description,
|
||
apply_percentage_discount,
|
||
)
|
||
from app.utils.subscription_utils import (
|
||
get_display_subscription_link,
|
||
get_happ_cryptolink_redirect_link,
|
||
)
|
||
import logging
|
||
|
||
logger = logging.getLogger(__name__)
|
||
|
||
|
||
def _get_localized_value(values, language: str, default_language: str = "en") -> str:
|
||
if not isinstance(values, dict):
|
||
return ""
|
||
|
||
candidates = []
|
||
normalized_language = (language or "").strip().lower()
|
||
|
||
if normalized_language:
|
||
candidates.append(normalized_language)
|
||
if "-" in normalized_language:
|
||
candidates.append(normalized_language.split("-")[0])
|
||
|
||
default_language = (default_language or "").strip().lower()
|
||
if default_language and default_language not in candidates:
|
||
candidates.append(default_language)
|
||
|
||
for candidate in candidates:
|
||
if not candidate:
|
||
continue
|
||
value = values.get(candidate)
|
||
if isinstance(value, str) and value.strip():
|
||
return value
|
||
|
||
for value in values.values():
|
||
if isinstance(value, str) and value.strip():
|
||
return value
|
||
|
||
return ""
|
||
|
||
|
||
def _build_additional_buttons(additional_section, language: str) -> List[InlineKeyboardButton]:
|
||
if not isinstance(additional_section, dict):
|
||
return []
|
||
|
||
buttons = additional_section.get("buttons")
|
||
if not isinstance(buttons, list):
|
||
return []
|
||
|
||
localized_buttons: List[InlineKeyboardButton] = []
|
||
|
||
for button in buttons:
|
||
if not isinstance(button, dict):
|
||
continue
|
||
|
||
button_text = _get_localized_value(button.get("buttonText"), language)
|
||
button_link = button.get("buttonLink")
|
||
|
||
if not button_text or not button_link:
|
||
continue
|
||
|
||
localized_buttons.append(
|
||
InlineKeyboardButton(text=button_text, url=button_link)
|
||
)
|
||
|
||
return localized_buttons
|
||
|
||
|
||
_LANGUAGE_DISPLAY_NAMES = {
|
||
"ru": "🇷🇺 Русский",
|
||
"en": "🇬🇧 English",
|
||
}
|
||
|
||
def get_rules_keyboard(language: str = DEFAULT_LANGUAGE) -> InlineKeyboardMarkup:
|
||
texts = get_texts(language)
|
||
return InlineKeyboardMarkup(inline_keyboard=[
|
||
[
|
||
InlineKeyboardButton(text=texts.RULES_ACCEPT, callback_data="rules_accept"),
|
||
InlineKeyboardButton(text=texts.RULES_DECLINE, callback_data="rules_decline")
|
||
]
|
||
])
|
||
|
||
def get_channel_sub_keyboard(
|
||
channel_link: str,
|
||
language: str = DEFAULT_LANGUAGE,
|
||
) -> InlineKeyboardMarkup:
|
||
texts = get_texts(language)
|
||
return InlineKeyboardMarkup(
|
||
inline_keyboard=[
|
||
[
|
||
InlineKeyboardButton(
|
||
text=texts.t("CHANNEL_SUBSCRIBE_BUTTON", "🔗 Подписаться"),
|
||
url=channel_link,
|
||
)
|
||
],
|
||
[
|
||
InlineKeyboardButton(
|
||
text=texts.t("CHANNEL_CHECK_BUTTON", "✅ Я подписался"),
|
||
callback_data="sub_channel_check",
|
||
)
|
||
],
|
||
]
|
||
)
|
||
|
||
|
||
def get_post_registration_keyboard(language: str = DEFAULT_LANGUAGE) -> InlineKeyboardMarkup:
|
||
texts = get_texts(language)
|
||
return InlineKeyboardMarkup(inline_keyboard=[
|
||
[
|
||
InlineKeyboardButton(
|
||
text=texts.t("POST_REGISTRATION_TRIAL_BUTTON", "🚀 Подключиться бесплатно 🚀"),
|
||
callback_data="trial_activate"
|
||
)
|
||
],
|
||
[InlineKeyboardButton(text=texts.t("SKIP_BUTTON", "Пропустить ➡️"), callback_data="back_to_menu")],
|
||
])
|
||
|
||
|
||
def get_language_selection_keyboard(
|
||
current_language: Optional[str] = None,
|
||
*,
|
||
include_back: bool = False,
|
||
language: str = DEFAULT_LANGUAGE,
|
||
) -> InlineKeyboardMarkup:
|
||
available_languages = settings.get_available_languages()
|
||
|
||
buttons: List[List[InlineKeyboardButton]] = []
|
||
row: List[InlineKeyboardButton] = []
|
||
|
||
normalized_current = (current_language or "").lower()
|
||
|
||
for index, lang_code in enumerate(available_languages, start=1):
|
||
normalized_code = lang_code.lower()
|
||
display_name = _LANGUAGE_DISPLAY_NAMES.get(
|
||
normalized_code,
|
||
normalized_code.upper(),
|
||
)
|
||
|
||
prefix = "✅ " if normalized_code == normalized_current and normalized_current else ""
|
||
|
||
row.append(
|
||
InlineKeyboardButton(
|
||
text=f"{prefix}{display_name}",
|
||
callback_data=f"language_select:{normalized_code}",
|
||
)
|
||
)
|
||
|
||
if len(row) == 2:
|
||
buttons.append(row)
|
||
row = []
|
||
|
||
if row:
|
||
buttons.append(row)
|
||
|
||
if include_back:
|
||
texts = get_texts(language)
|
||
buttons.append([InlineKeyboardButton(text=texts.BACK, callback_data="back_to_menu")])
|
||
|
||
return InlineKeyboardMarkup(inline_keyboard=buttons)
|
||
|
||
|
||
def _build_text_main_menu_keyboard(
|
||
language: str,
|
||
texts,
|
||
*,
|
||
is_admin: bool,
|
||
is_moderator: bool,
|
||
) -> InlineKeyboardMarkup:
|
||
profile_text = texts.t("MENU_PROFILE", "👤 Личный кабинет")
|
||
miniapp_url = settings.get_main_menu_miniapp_url()
|
||
|
||
if miniapp_url:
|
||
profile_button = InlineKeyboardButton(
|
||
text=profile_text,
|
||
web_app=types.WebAppInfo(url=miniapp_url),
|
||
)
|
||
else:
|
||
profile_button = InlineKeyboardButton(
|
||
text=profile_text,
|
||
callback_data="menu_profile_unavailable",
|
||
)
|
||
|
||
keyboard_rows: List[List[InlineKeyboardButton]] = [[profile_button]]
|
||
|
||
if settings.is_language_selection_enabled():
|
||
keyboard_rows.append([
|
||
InlineKeyboardButton(text=texts.MENU_LANGUAGE, callback_data="menu_language")
|
||
])
|
||
|
||
support_enabled = False
|
||
try:
|
||
from app.services.support_settings_service import SupportSettingsService
|
||
|
||
support_enabled = SupportSettingsService.is_support_menu_enabled()
|
||
except Exception:
|
||
support_enabled = settings.SUPPORT_MENU_ENABLED
|
||
|
||
if support_enabled:
|
||
keyboard_rows.append([
|
||
InlineKeyboardButton(text=texts.MENU_SUPPORT, callback_data="menu_support")
|
||
])
|
||
|
||
if is_admin:
|
||
keyboard_rows.append([
|
||
InlineKeyboardButton(text=texts.MENU_ADMIN, callback_data="admin_panel")
|
||
])
|
||
elif is_moderator:
|
||
keyboard_rows.append([
|
||
InlineKeyboardButton(text="🧑⚖️ Модерация", callback_data="moderator_panel")
|
||
])
|
||
|
||
return InlineKeyboardMarkup(inline_keyboard=keyboard_rows)
|
||
|
||
|
||
def get_main_menu_keyboard(
|
||
language: str = DEFAULT_LANGUAGE,
|
||
is_admin: bool = False,
|
||
has_had_paid_subscription: bool = False,
|
||
has_active_subscription: bool = False,
|
||
subscription_is_active: bool = False,
|
||
balance_kopeks: int = 0,
|
||
subscription=None,
|
||
show_resume_checkout: bool = False,
|
||
has_saved_cart: bool = False, # Новый параметр для отображения уведомления о сохраненной корзине
|
||
*,
|
||
is_moderator: bool = False,
|
||
custom_buttons: Optional[list[InlineKeyboardButton]] = None,
|
||
) -> InlineKeyboardMarkup:
|
||
texts = get_texts(language)
|
||
|
||
if settings.is_text_main_menu_mode():
|
||
return _build_text_main_menu_keyboard(
|
||
language,
|
||
texts,
|
||
is_admin=is_admin,
|
||
is_moderator=is_moderator,
|
||
)
|
||
|
||
if settings.DEBUG:
|
||
print(f"DEBUG KEYBOARD: language={language}, is_admin={is_admin}, has_had_paid={has_had_paid_subscription}, has_active={has_active_subscription}, sub_active={subscription_is_active}, balance={balance_kopeks}")
|
||
|
||
if hasattr(texts, 'BALANCE_BUTTON') and balance_kopeks > 0:
|
||
balance_button_text = texts.BALANCE_BUTTON.format(balance=texts.format_price(balance_kopeks))
|
||
else:
|
||
balance_button_text = texts.t(
|
||
"BALANCE_BUTTON_DEFAULT",
|
||
"💰 Баланс: {balance}",
|
||
).format(balance=texts.format_price(balance_kopeks))
|
||
|
||
keyboard: list[list[InlineKeyboardButton]] = []
|
||
paired_buttons: list[InlineKeyboardButton] = []
|
||
|
||
if has_active_subscription and subscription_is_active:
|
||
connect_mode = settings.CONNECT_BUTTON_MODE
|
||
subscription_link = get_display_subscription_link(subscription)
|
||
|
||
def _fallback_connect_button() -> InlineKeyboardButton:
|
||
return InlineKeyboardButton(
|
||
text=texts.t("CONNECT_BUTTON", "🔗 Подключиться"),
|
||
callback_data="subscription_connect",
|
||
)
|
||
|
||
if connect_mode == "miniapp_subscription":
|
||
if subscription_link:
|
||
keyboard.append([
|
||
InlineKeyboardButton(
|
||
text=texts.t("CONNECT_BUTTON", "🔗 Подключиться"),
|
||
web_app=types.WebAppInfo(url=subscription_link)
|
||
)
|
||
])
|
||
else:
|
||
keyboard.append([_fallback_connect_button()])
|
||
elif connect_mode == "miniapp_custom":
|
||
keyboard.append([
|
||
InlineKeyboardButton(
|
||
text=texts.t("CONNECT_BUTTON", "🔗 Подключиться"),
|
||
web_app=types.WebAppInfo(url=settings.MINIAPP_CUSTOM_URL)
|
||
)
|
||
])
|
||
elif connect_mode == "link":
|
||
if subscription_link:
|
||
keyboard.append([
|
||
InlineKeyboardButton(
|
||
text=texts.t("CONNECT_BUTTON", "🔗 Подключиться"),
|
||
url=subscription_link
|
||
)
|
||
])
|
||
else:
|
||
keyboard.append([_fallback_connect_button()])
|
||
elif connect_mode == "happ_cryptolink":
|
||
if subscription_link:
|
||
keyboard.append([
|
||
InlineKeyboardButton(
|
||
text=texts.t("CONNECT_BUTTON", "🔗 Подключиться"),
|
||
callback_data="open_subscription_link",
|
||
)
|
||
])
|
||
else:
|
||
keyboard.append([_fallback_connect_button()])
|
||
else:
|
||
keyboard.append([_fallback_connect_button()])
|
||
|
||
happ_row = get_happ_download_button_row(texts)
|
||
if happ_row:
|
||
keyboard.append(happ_row)
|
||
paired_buttons.append(
|
||
InlineKeyboardButton(text=texts.MENU_SUBSCRIPTION, callback_data="menu_subscription")
|
||
)
|
||
|
||
keyboard.append([InlineKeyboardButton(text=balance_button_text, callback_data="menu_balance")])
|
||
|
||
show_trial = not has_had_paid_subscription and not has_active_subscription
|
||
|
||
show_buy = not has_active_subscription or not subscription_is_active
|
||
current_subscription = subscription
|
||
has_active_paid_subscription = bool(
|
||
current_subscription
|
||
and not getattr(current_subscription, "is_trial", False)
|
||
and getattr(current_subscription, "is_active", False)
|
||
)
|
||
simple_purchase_button = None
|
||
if settings.SIMPLE_SUBSCRIPTION_ENABLED:
|
||
simple_purchase_button = InlineKeyboardButton(
|
||
text=texts.MENU_SIMPLE_SUBSCRIPTION,
|
||
callback_data="simple_subscription_purchase",
|
||
)
|
||
|
||
subscription_buttons: list[InlineKeyboardButton] = []
|
||
|
||
if show_trial:
|
||
subscription_buttons.append(
|
||
InlineKeyboardButton(text=texts.MENU_TRIAL, callback_data="menu_trial")
|
||
)
|
||
|
||
if show_buy:
|
||
subscription_buttons.append(
|
||
InlineKeyboardButton(text=texts.MENU_BUY_SUBSCRIPTION, callback_data="menu_buy")
|
||
)
|
||
|
||
if subscription_buttons:
|
||
paired_buttons.extend(subscription_buttons)
|
||
if simple_purchase_button:
|
||
paired_buttons.append(simple_purchase_button)
|
||
|
||
if show_resume_checkout or has_saved_cart:
|
||
resume_callback = (
|
||
"return_to_saved_cart" if has_saved_cart else "subscription_resume_checkout"
|
||
)
|
||
paired_buttons.append(
|
||
InlineKeyboardButton(
|
||
text=texts.RETURN_TO_SUBSCRIPTION_CHECKOUT,
|
||
callback_data=resume_callback,
|
||
)
|
||
)
|
||
|
||
if custom_buttons:
|
||
for button in custom_buttons:
|
||
if isinstance(button, InlineKeyboardButton):
|
||
paired_buttons.append(button)
|
||
|
||
# Добавляем кнопки промокода и рефералов, учитывая настройки
|
||
paired_buttons.append(
|
||
InlineKeyboardButton(text=texts.MENU_PROMOCODE, callback_data="menu_promocode")
|
||
)
|
||
|
||
# Добавляем кнопку рефералов только если программа включена
|
||
if settings.is_referral_program_enabled():
|
||
paired_buttons.append(
|
||
InlineKeyboardButton(text=texts.MENU_REFERRALS, callback_data="menu_referrals")
|
||
)
|
||
|
||
# Support button is configurable (runtime via service)
|
||
try:
|
||
from app.services.support_settings_service import SupportSettingsService
|
||
support_enabled = SupportSettingsService.is_support_menu_enabled()
|
||
except Exception:
|
||
support_enabled = settings.SUPPORT_MENU_ENABLED
|
||
if support_enabled:
|
||
paired_buttons.append(
|
||
InlineKeyboardButton(text=texts.MENU_SUPPORT, callback_data="menu_support")
|
||
)
|
||
|
||
paired_buttons.append(
|
||
InlineKeyboardButton(
|
||
text=texts.t("MENU_INFO", "ℹ️ Инфо"),
|
||
callback_data="menu_info",
|
||
)
|
||
)
|
||
|
||
if settings.is_language_selection_enabled():
|
||
paired_buttons.append(
|
||
InlineKeyboardButton(text=texts.MENU_LANGUAGE, callback_data="menu_language")
|
||
)
|
||
|
||
for i in range(0, len(paired_buttons), 2):
|
||
row = paired_buttons[i : i + 2]
|
||
keyboard.append(row)
|
||
|
||
if settings.DEBUG:
|
||
print(f"DEBUG KEYBOARD: is_admin={is_admin}, добавляем админ кнопку: {is_admin}")
|
||
|
||
if is_admin:
|
||
if settings.DEBUG:
|
||
print("DEBUG KEYBOARD: Админ кнопка ДОБАВЛЕНА!")
|
||
keyboard.append([
|
||
InlineKeyboardButton(text=texts.MENU_ADMIN, callback_data="admin_panel")
|
||
])
|
||
else:
|
||
if settings.DEBUG:
|
||
print("DEBUG KEYBOARD: Админ кнопка НЕ добавлена")
|
||
# Moderator access (limited support panel)
|
||
if (not is_admin) and is_moderator:
|
||
keyboard.append([
|
||
InlineKeyboardButton(text="🧑⚖️ Модерация", callback_data="moderator_panel")
|
||
])
|
||
|
||
return InlineKeyboardMarkup(inline_keyboard=keyboard)
|
||
|
||
|
||
def get_info_menu_keyboard(
|
||
language: str = DEFAULT_LANGUAGE,
|
||
show_privacy_policy: bool = False,
|
||
show_public_offer: bool = False,
|
||
show_faq: bool = False,
|
||
show_promo_groups: bool = False,
|
||
) -> InlineKeyboardMarkup:
|
||
texts = get_texts(language)
|
||
|
||
buttons: List[List[InlineKeyboardButton]] = []
|
||
|
||
if show_faq:
|
||
buttons.append([
|
||
InlineKeyboardButton(
|
||
text=texts.t("MENU_FAQ", "❓ FAQ"),
|
||
callback_data="menu_faq",
|
||
)
|
||
])
|
||
|
||
if show_promo_groups:
|
||
buttons.append([
|
||
InlineKeyboardButton(
|
||
text=texts.t("MENU_PROMO_GROUPS_INFO", "🎯 Промогруппы"),
|
||
callback_data="menu_info_promo_groups",
|
||
)
|
||
])
|
||
|
||
if show_privacy_policy:
|
||
buttons.append([
|
||
InlineKeyboardButton(
|
||
text=texts.t("MENU_PRIVACY_POLICY", "🛡️ Политика конф."),
|
||
callback_data="menu_privacy_policy",
|
||
)
|
||
])
|
||
|
||
if show_public_offer:
|
||
buttons.append([
|
||
InlineKeyboardButton(
|
||
text=texts.t("MENU_PUBLIC_OFFER", "📄 Оферта"),
|
||
callback_data="menu_public_offer",
|
||
)
|
||
])
|
||
|
||
buttons.append([
|
||
InlineKeyboardButton(text=texts.MENU_RULES, callback_data="menu_rules")
|
||
])
|
||
|
||
server_status_mode = settings.get_server_status_mode()
|
||
server_status_text = texts.t("MENU_SERVER_STATUS", "📊 Статус серверов")
|
||
|
||
if server_status_mode == "external_link":
|
||
status_url = settings.get_server_status_external_url()
|
||
if status_url:
|
||
buttons.append([InlineKeyboardButton(text=server_status_text, url=status_url)])
|
||
elif server_status_mode == "external_link_miniapp":
|
||
status_url = settings.get_server_status_external_url()
|
||
if status_url:
|
||
buttons.append([
|
||
InlineKeyboardButton(
|
||
text=server_status_text,
|
||
web_app=types.WebAppInfo(url=status_url),
|
||
)
|
||
])
|
||
elif server_status_mode == "xray":
|
||
buttons.append([
|
||
InlineKeyboardButton(
|
||
text=server_status_text,
|
||
callback_data="menu_server_status",
|
||
)
|
||
])
|
||
|
||
buttons.append([InlineKeyboardButton(text=texts.BACK, callback_data="back_to_menu")])
|
||
|
||
return InlineKeyboardMarkup(inline_keyboard=buttons)
|
||
|
||
|
||
def get_happ_download_button_row(texts) -> Optional[List[InlineKeyboardButton]]:
|
||
if not settings.is_happ_download_button_enabled():
|
||
return None
|
||
|
||
return [
|
||
InlineKeyboardButton(
|
||
text=texts.t("HAPP_DOWNLOAD_BUTTON", "⬇️ Скачать Happ"),
|
||
callback_data="subscription_happ_download"
|
||
)
|
||
]
|
||
|
||
|
||
def get_happ_cryptolink_keyboard(
|
||
subscription_link: str,
|
||
language: str = DEFAULT_LANGUAGE,
|
||
redirect_link: Optional[str] = None,
|
||
) -> InlineKeyboardMarkup:
|
||
texts = get_texts(language)
|
||
final_redirect_link = redirect_link or get_happ_cryptolink_redirect_link(subscription_link)
|
||
|
||
buttons: List[List[InlineKeyboardButton]] = []
|
||
|
||
if final_redirect_link:
|
||
buttons.append([
|
||
InlineKeyboardButton(
|
||
text=texts.t("CONNECT_BUTTON", "🔗 Подключиться"),
|
||
url=final_redirect_link,
|
||
)
|
||
])
|
||
|
||
buttons.extend([
|
||
[
|
||
InlineKeyboardButton(
|
||
text=texts.t("HAPP_PLATFORM_IOS", "🍎 iOS"),
|
||
callback_data="happ_download_ios",
|
||
)
|
||
],
|
||
[
|
||
InlineKeyboardButton(
|
||
text=texts.t("HAPP_PLATFORM_ANDROID", "🤖 Android"),
|
||
callback_data="happ_download_android",
|
||
)
|
||
],
|
||
[
|
||
InlineKeyboardButton(
|
||
text=texts.t("HAPP_PLATFORM_MACOS", "🖥️ Mac OS"),
|
||
callback_data="happ_download_macos",
|
||
)
|
||
],
|
||
[
|
||
InlineKeyboardButton(
|
||
text=texts.t("HAPP_PLATFORM_WINDOWS", "💻 Windows"),
|
||
callback_data="happ_download_windows",
|
||
)
|
||
],
|
||
[
|
||
InlineKeyboardButton(
|
||
text=texts.t("BACK_TO_MAIN_MENU_BUTTON", "⬅️ В главное меню"),
|
||
callback_data="back_to_menu",
|
||
)
|
||
],
|
||
])
|
||
|
||
return InlineKeyboardMarkup(inline_keyboard=buttons)
|
||
|
||
|
||
def get_happ_download_platform_keyboard(language: str = DEFAULT_LANGUAGE) -> InlineKeyboardMarkup:
|
||
texts = get_texts(language)
|
||
buttons = [
|
||
[InlineKeyboardButton(text=texts.t("HAPP_PLATFORM_IOS", "🍎 iOS"), callback_data="happ_download_ios")],
|
||
[InlineKeyboardButton(text=texts.t("HAPP_PLATFORM_ANDROID", "🤖 Android"), callback_data="happ_download_android")],
|
||
[InlineKeyboardButton(text=texts.t("HAPP_PLATFORM_MACOS", "🖥️ Mac OS"), callback_data="happ_download_macos")],
|
||
[InlineKeyboardButton(text=texts.t("HAPP_PLATFORM_WINDOWS", "💻 Windows"), callback_data="happ_download_windows")],
|
||
[InlineKeyboardButton(text=texts.BACK, callback_data="happ_download_close")],
|
||
]
|
||
|
||
return InlineKeyboardMarkup(inline_keyboard=buttons)
|
||
|
||
|
||
def get_happ_download_link_keyboard(language: str, link: str) -> InlineKeyboardMarkup:
|
||
texts = get_texts(language)
|
||
buttons = [
|
||
[InlineKeyboardButton(text=texts.t("HAPP_DOWNLOAD_OPEN_LINK", "🔗 Открыть ссылку"), url=link)],
|
||
[InlineKeyboardButton(text=texts.BACK, callback_data="happ_download_back")],
|
||
]
|
||
|
||
return InlineKeyboardMarkup(inline_keyboard=buttons)
|
||
|
||
|
||
def get_back_keyboard(language: str = DEFAULT_LANGUAGE) -> InlineKeyboardMarkup:
|
||
texts = get_texts(language)
|
||
return InlineKeyboardMarkup(inline_keyboard=[
|
||
[InlineKeyboardButton(text=texts.BACK, callback_data="back_to_menu")]
|
||
])
|
||
|
||
|
||
def get_server_status_keyboard(
|
||
language: str,
|
||
current_page: int,
|
||
total_pages: int,
|
||
) -> InlineKeyboardMarkup:
|
||
texts = get_texts(language)
|
||
keyboard: list[list[InlineKeyboardButton]] = [
|
||
[
|
||
InlineKeyboardButton(
|
||
text=texts.t("SERVER_STATUS_REFRESH", "🔄 Обновить"),
|
||
callback_data=f"server_status_page:{current_page}",
|
||
)
|
||
]
|
||
]
|
||
|
||
if total_pages > 1:
|
||
nav_row: list[InlineKeyboardButton] = []
|
||
|
||
if current_page > 1:
|
||
nav_row.append(
|
||
InlineKeyboardButton(
|
||
text=texts.t("SERVER_STATUS_PREV_PAGE", "⬅️ Назад"),
|
||
callback_data=f"server_status_page:{current_page - 1}",
|
||
)
|
||
)
|
||
|
||
if current_page < total_pages:
|
||
nav_row.append(
|
||
InlineKeyboardButton(
|
||
text=texts.t("SERVER_STATUS_NEXT_PAGE", "Вперед ➡️"),
|
||
callback_data=f"server_status_page:{current_page + 1}",
|
||
)
|
||
)
|
||
|
||
if nav_row:
|
||
keyboard.append(nav_row)
|
||
|
||
keyboard.append([InlineKeyboardButton(text=texts.BACK, callback_data="back_to_menu")])
|
||
|
||
return InlineKeyboardMarkup(inline_keyboard=keyboard)
|
||
|
||
|
||
def get_insufficient_balance_keyboard(
|
||
language: str = DEFAULT_LANGUAGE,
|
||
resume_callback: str | None = None,
|
||
amount_kopeks: int | None = None,
|
||
has_saved_cart: bool = False, # Новый параметр для указания наличия сохраненной корзины
|
||
) -> InlineKeyboardMarkup:
|
||
|
||
texts = get_texts(language)
|
||
keyboard = get_payment_methods_keyboard(amount_kopeks or 0, language)
|
||
|
||
back_row_index: int | None = None
|
||
|
||
if keyboard.inline_keyboard:
|
||
last_row = keyboard.inline_keyboard[-1]
|
||
if (
|
||
len(last_row) == 1
|
||
and isinstance(last_row[0], InlineKeyboardButton)
|
||
and last_row[0].callback_data in {"menu_balance", "back_to_menu"}
|
||
):
|
||
keyboard.inline_keyboard[-1][0] = InlineKeyboardButton(
|
||
text=texts.t("PAYMENT_RETURN_HOME_BUTTON", "🏠 На главную"),
|
||
callback_data="back_to_menu",
|
||
)
|
||
back_row_index = len(keyboard.inline_keyboard) - 1
|
||
|
||
# Если есть сохраненная корзина, добавляем кнопку возврата к оформлению
|
||
if has_saved_cart:
|
||
return_row = [
|
||
InlineKeyboardButton(
|
||
text=texts.RETURN_TO_SUBSCRIPTION_CHECKOUT,
|
||
callback_data="return_to_saved_cart",
|
||
)
|
||
]
|
||
insert_index = back_row_index if back_row_index is not None else len(keyboard.inline_keyboard)
|
||
keyboard.inline_keyboard.insert(insert_index, return_row)
|
||
elif resume_callback:
|
||
return_row = [
|
||
InlineKeyboardButton(
|
||
text=texts.RETURN_TO_SUBSCRIPTION_CHECKOUT,
|
||
callback_data=resume_callback,
|
||
)
|
||
]
|
||
insert_index = back_row_index if back_row_index is not None else len(keyboard.inline_keyboard)
|
||
keyboard.inline_keyboard.insert(insert_index, return_row)
|
||
|
||
return keyboard
|
||
|
||
|
||
def get_subscription_keyboard(
|
||
language: str = DEFAULT_LANGUAGE,
|
||
has_subscription: bool = False,
|
||
is_trial: bool = False,
|
||
subscription=None
|
||
) -> InlineKeyboardMarkup:
|
||
from app.config import settings
|
||
|
||
texts = get_texts(language)
|
||
keyboard = []
|
||
|
||
if has_subscription:
|
||
subscription_link = get_display_subscription_link(subscription) if subscription else None
|
||
if subscription_link:
|
||
connect_mode = settings.CONNECT_BUTTON_MODE
|
||
|
||
if connect_mode == "miniapp_subscription":
|
||
keyboard.append([
|
||
InlineKeyboardButton(
|
||
text=texts.t("CONNECT_BUTTON", "🔗 Подключиться"),
|
||
web_app=types.WebAppInfo(url=subscription_link)
|
||
)
|
||
])
|
||
elif connect_mode == "miniapp_custom":
|
||
if settings.MINIAPP_CUSTOM_URL:
|
||
keyboard.append([
|
||
InlineKeyboardButton(
|
||
text=texts.t("CONNECT_BUTTON", "🔗 Подключиться"),
|
||
web_app=types.WebAppInfo(url=settings.MINIAPP_CUSTOM_URL)
|
||
)
|
||
])
|
||
else:
|
||
keyboard.append([
|
||
InlineKeyboardButton(text=texts.t("CONNECT_BUTTON", "🔗 Подключиться"), callback_data="subscription_connect")
|
||
])
|
||
elif connect_mode == "link":
|
||
keyboard.append([
|
||
InlineKeyboardButton(text=texts.t("CONNECT_BUTTON", "🔗 Подключиться"), url=subscription_link)
|
||
])
|
||
elif connect_mode == "happ_cryptolink":
|
||
keyboard.append([
|
||
InlineKeyboardButton(
|
||
text=texts.t("CONNECT_BUTTON", "🔗 Подключиться"),
|
||
callback_data="open_subscription_link",
|
||
)
|
||
])
|
||
else:
|
||
keyboard.append([
|
||
InlineKeyboardButton(text=texts.t("CONNECT_BUTTON", "🔗 Подключиться"), callback_data="subscription_connect")
|
||
])
|
||
elif settings.CONNECT_BUTTON_MODE == "miniapp_custom":
|
||
keyboard.append([
|
||
InlineKeyboardButton(
|
||
text=texts.t("CONNECT_BUTTON", "🔗 Подключиться"),
|
||
web_app=types.WebAppInfo(url=settings.MINIAPP_CUSTOM_URL)
|
||
)
|
||
])
|
||
else:
|
||
keyboard.append([
|
||
InlineKeyboardButton(text=texts.t("CONNECT_BUTTON", "🔗 Подключиться"), callback_data="subscription_connect")
|
||
])
|
||
|
||
happ_row = get_happ_download_button_row(texts)
|
||
if happ_row:
|
||
keyboard.append(happ_row)
|
||
|
||
if not is_trial:
|
||
keyboard.append([
|
||
InlineKeyboardButton(text=texts.MENU_EXTEND_SUBSCRIPTION, callback_data="subscription_extend")
|
||
])
|
||
keyboard.append([
|
||
InlineKeyboardButton(
|
||
text=texts.t("AUTOPAY_BUTTON", "💳 Автоплатеж"),
|
||
callback_data="subscription_autopay",
|
||
)
|
||
])
|
||
|
||
if is_trial:
|
||
keyboard.append([
|
||
InlineKeyboardButton(text=texts.MENU_BUY_SUBSCRIPTION, callback_data="subscription_upgrade")
|
||
])
|
||
else:
|
||
keyboard.append([
|
||
InlineKeyboardButton(
|
||
text=texts.t("SUBSCRIPTION_SETTINGS_BUTTON", "⚙️ Настройки подписки"),
|
||
callback_data="subscription_settings",
|
||
)
|
||
])
|
||
|
||
keyboard.append([
|
||
InlineKeyboardButton(text=texts.BACK, callback_data="back_to_menu")
|
||
])
|
||
|
||
return InlineKeyboardMarkup(inline_keyboard=keyboard)
|
||
|
||
def get_payment_methods_keyboard_with_cart(
|
||
language: str = "ru",
|
||
amount_kopeks: int = 0,
|
||
) -> InlineKeyboardMarkup:
|
||
texts = get_texts(language)
|
||
keyboard = get_payment_methods_keyboard(amount_kopeks, language)
|
||
|
||
# Добавляем кнопку "Очистить корзину"
|
||
keyboard.inline_keyboard.append([
|
||
InlineKeyboardButton(
|
||
text="🗑️ Очистить корзину и вернуться",
|
||
callback_data="clear_saved_cart"
|
||
)
|
||
])
|
||
|
||
# Добавляем кнопку возврата к оформлению подписки
|
||
keyboard.inline_keyboard.insert(-1, [ # Вставляем перед кнопкой "назад"
|
||
InlineKeyboardButton(
|
||
text=texts.RETURN_TO_SUBSCRIPTION_CHECKOUT,
|
||
callback_data="return_to_saved_cart"
|
||
)
|
||
])
|
||
|
||
return keyboard
|
||
|
||
def get_subscription_confirm_keyboard_with_cart(language: str = "ru") -> InlineKeyboardMarkup:
|
||
texts = get_texts(language)
|
||
return InlineKeyboardMarkup(inline_keyboard=[
|
||
[InlineKeyboardButton(
|
||
text="✅ Подтвердить покупку",
|
||
callback_data="subscription_confirm"
|
||
)],
|
||
[InlineKeyboardButton(
|
||
text="🗑️ Очистить корзину",
|
||
callback_data="clear_saved_cart"
|
||
)],
|
||
[InlineKeyboardButton(
|
||
text=texts.BACK,
|
||
callback_data="subscription_config_back" # Изменили на возврат к настройке
|
||
)]
|
||
])
|
||
|
||
def get_insufficient_balance_keyboard_with_cart(
|
||
language: str = "ru",
|
||
amount_kopeks: int = 0,
|
||
) -> InlineKeyboardMarkup:
|
||
# Используем обновленную версию с флагом has_saved_cart=True
|
||
keyboard = get_insufficient_balance_keyboard(
|
||
language,
|
||
amount_kopeks=amount_kopeks,
|
||
has_saved_cart=True,
|
||
)
|
||
|
||
# Добавляем кнопку очистки корзины в начало
|
||
keyboard.inline_keyboard.insert(
|
||
0,
|
||
[
|
||
InlineKeyboardButton(
|
||
text="🗑️ Очистить корзину и вернуться",
|
||
callback_data="clear_saved_cart",
|
||
)
|
||
],
|
||
)
|
||
|
||
return keyboard
|
||
|
||
def get_trial_keyboard(language: str = "ru") -> InlineKeyboardMarkup:
|
||
texts = get_texts(language)
|
||
return InlineKeyboardMarkup(inline_keyboard=[
|
||
[
|
||
InlineKeyboardButton(text=texts.t("TRIAL_ACTIVATE_BUTTON", "🎁 Активировать"), callback_data="trial_activate"),
|
||
InlineKeyboardButton(text=texts.BACK, callback_data="back_to_menu")
|
||
]
|
||
])
|
||
|
||
|
||
def get_subscription_period_keyboard(language: str = DEFAULT_LANGUAGE) -> InlineKeyboardMarkup:
|
||
texts = get_texts(language)
|
||
keyboard = []
|
||
|
||
available_periods = settings.get_available_subscription_periods()
|
||
|
||
period_texts = {
|
||
14: texts.PERIOD_14_DAYS,
|
||
30: texts.PERIOD_30_DAYS,
|
||
60: texts.PERIOD_60_DAYS,
|
||
90: texts.PERIOD_90_DAYS,
|
||
180: texts.PERIOD_180_DAYS,
|
||
360: texts.PERIOD_360_DAYS
|
||
}
|
||
|
||
for days in available_periods:
|
||
if days in period_texts:
|
||
keyboard.append([
|
||
InlineKeyboardButton(
|
||
text=period_texts[days],
|
||
callback_data=f"period_{days}"
|
||
)
|
||
])
|
||
|
||
# Кнопка "Простая покупка" была убрана из выбора периода подписки
|
||
|
||
keyboard.append([
|
||
InlineKeyboardButton(text=texts.BACK, callback_data="back_to_menu")
|
||
])
|
||
|
||
return InlineKeyboardMarkup(inline_keyboard=keyboard)
|
||
|
||
|
||
def get_traffic_packages_keyboard(language: str = DEFAULT_LANGUAGE) -> InlineKeyboardMarkup:
|
||
import logging
|
||
logger = logging.getLogger(__name__)
|
||
|
||
from app.config import settings
|
||
|
||
if settings.is_traffic_fixed():
|
||
return get_back_keyboard(language)
|
||
|
||
logger.info(f"🔍 RAW CONFIG: '{settings.TRAFFIC_PACKAGES_CONFIG}'")
|
||
|
||
all_packages = settings.get_traffic_packages()
|
||
logger.info(f"🔍 ALL PACKAGES: {all_packages}")
|
||
|
||
enabled_packages = [pkg for pkg in all_packages if pkg['enabled']]
|
||
disabled_packages = [pkg for pkg in all_packages if not pkg['enabled']]
|
||
|
||
logger.info(f"🔍 ENABLED: {len(enabled_packages)} packages")
|
||
logger.info(f"🔍 DISABLED: {len(disabled_packages)} packages")
|
||
|
||
for pkg in disabled_packages:
|
||
logger.info(f"🔍 DISABLED PACKAGE: {pkg['gb']}GB = {pkg['price']} kopeks, enabled={pkg['enabled']}")
|
||
|
||
texts = get_texts(language)
|
||
keyboard = []
|
||
|
||
traffic_packages = settings.get_traffic_packages()
|
||
|
||
for package in traffic_packages:
|
||
gb = package["gb"]
|
||
price = package["price"]
|
||
enabled = package["enabled"]
|
||
|
||
if not enabled:
|
||
continue
|
||
|
||
if gb == 0:
|
||
text = f"♾️ Безлимит - {settings.format_price(package['price'])}"
|
||
else:
|
||
text = f"📊 {gb} ГБ - {settings.format_price(package['price'])}"
|
||
|
||
keyboard.append([
|
||
InlineKeyboardButton(text=text, callback_data=f"traffic_{gb}")
|
||
])
|
||
|
||
if not keyboard:
|
||
keyboard.append([
|
||
InlineKeyboardButton(
|
||
text=texts.t("TRAFFIC_PACKAGES_NOT_CONFIGURED", "⚠️ Пакеты трафика не настроены"),
|
||
callback_data="no_traffic_packages"
|
||
)
|
||
])
|
||
|
||
keyboard.append([
|
||
InlineKeyboardButton(text=texts.BACK, callback_data="subscription_config_back")
|
||
])
|
||
|
||
return InlineKeyboardMarkup(inline_keyboard=keyboard)
|
||
|
||
def get_countries_keyboard(countries: List[dict], selected: List[str], language: str = DEFAULT_LANGUAGE) -> InlineKeyboardMarkup:
|
||
texts = get_texts(language)
|
||
keyboard = []
|
||
|
||
for country in countries:
|
||
if not country.get('is_available', True):
|
||
continue
|
||
|
||
emoji = "✅" if country['uuid'] in selected else "⚪"
|
||
|
||
if country['price_kopeks'] > 0:
|
||
price_text = f" (+{texts.format_price(country['price_kopeks'])})"
|
||
else:
|
||
price_text = " (Бесплатно)"
|
||
|
||
keyboard.append([
|
||
InlineKeyboardButton(
|
||
text=f"{emoji} {country['name']}{price_text}",
|
||
callback_data=f"country_{country['uuid']}"
|
||
)
|
||
])
|
||
|
||
if not keyboard:
|
||
keyboard.append([
|
||
InlineKeyboardButton(
|
||
text=texts.t("NO_SERVERS_AVAILABLE", "❌ Нет доступных серверов"),
|
||
callback_data="no_servers"
|
||
)
|
||
])
|
||
|
||
keyboard.extend([
|
||
[InlineKeyboardButton(text=texts.t("CONTINUE_BUTTON", "✅ Продолжить"), callback_data="countries_continue")],
|
||
[InlineKeyboardButton(text=texts.BACK, callback_data="subscription_config_back")]
|
||
])
|
||
|
||
return InlineKeyboardMarkup(inline_keyboard=keyboard)
|
||
|
||
|
||
def get_devices_keyboard(current: int, language: str = DEFAULT_LANGUAGE) -> InlineKeyboardMarkup:
|
||
texts = get_texts(language)
|
||
keyboard = []
|
||
|
||
start_devices = settings.DEFAULT_DEVICE_LIMIT
|
||
max_devices = settings.MAX_DEVICES_LIMIT if settings.MAX_DEVICES_LIMIT > 0 else 50
|
||
end_devices = min(max_devices + 1, start_devices + 10)
|
||
|
||
buttons = []
|
||
|
||
for devices in range(start_devices, end_devices):
|
||
price = max(0, devices - settings.DEFAULT_DEVICE_LIMIT) * settings.PRICE_PER_DEVICE
|
||
price_text = f" (+{texts.format_price(price)})" if price > 0 else " (вкл.)"
|
||
emoji = "✅" if devices == current else "⚪"
|
||
|
||
button_text = f"{emoji} {devices}{price_text}"
|
||
|
||
buttons.append(
|
||
InlineKeyboardButton(
|
||
text=button_text,
|
||
callback_data=f"devices_{devices}"
|
||
)
|
||
)
|
||
|
||
for i in range(0, len(buttons), 2):
|
||
if i + 1 < len(buttons):
|
||
keyboard.append([buttons[i], buttons[i + 1]])
|
||
else:
|
||
keyboard.append([buttons[i]])
|
||
|
||
keyboard.extend([
|
||
[InlineKeyboardButton(text=texts.t("CONTINUE_BUTTON", "✅ Продолжить"), callback_data="devices_continue")],
|
||
[InlineKeyboardButton(text=texts.BACK, callback_data="subscription_config_back")]
|
||
])
|
||
|
||
return InlineKeyboardMarkup(inline_keyboard=keyboard)
|
||
|
||
def _get_device_declension(count: int) -> str:
|
||
if count % 10 == 1 and count % 100 != 11:
|
||
return "устройство"
|
||
elif count % 10 in [2, 3, 4] and count % 100 not in [12, 13, 14]:
|
||
return "устройства"
|
||
else:
|
||
return "устройств"
|
||
|
||
def get_subscription_confirm_keyboard(language: str = DEFAULT_LANGUAGE) -> InlineKeyboardMarkup:
|
||
texts = get_texts(language)
|
||
return InlineKeyboardMarkup(inline_keyboard=[
|
||
[
|
||
InlineKeyboardButton(text=texts.CONFIRM, callback_data="subscription_confirm"),
|
||
InlineKeyboardButton(text=texts.CANCEL, callback_data="subscription_cancel")
|
||
]
|
||
])
|
||
|
||
|
||
def get_balance_keyboard(language: str = DEFAULT_LANGUAGE) -> InlineKeyboardMarkup:
|
||
texts = get_texts(language)
|
||
|
||
keyboard = [
|
||
[
|
||
InlineKeyboardButton(text=texts.BALANCE_HISTORY, callback_data="balance_history"),
|
||
InlineKeyboardButton(text=texts.BALANCE_TOP_UP, callback_data="balance_topup")
|
||
],
|
||
[
|
||
InlineKeyboardButton(text=texts.BACK, callback_data="back_to_menu")
|
||
]
|
||
]
|
||
|
||
return InlineKeyboardMarkup(inline_keyboard=keyboard)
|
||
|
||
|
||
def get_payment_methods_keyboard(amount_kopeks: int, language: str = DEFAULT_LANGUAGE) -> InlineKeyboardMarkup:
|
||
texts = get_texts(language)
|
||
keyboard = []
|
||
|
||
amount_kopeks = max(0, int(amount_kopeks or 0))
|
||
|
||
def _build_callback(method: str) -> str:
|
||
if amount_kopeks > 0:
|
||
return f"topup_amount|{method}|{amount_kopeks}"
|
||
return f"topup_{method}"
|
||
|
||
if settings.TELEGRAM_STARS_ENABLED:
|
||
keyboard.append([
|
||
InlineKeyboardButton(
|
||
text=texts.t("PAYMENT_TELEGRAM_STARS", "⭐ Telegram Stars"),
|
||
callback_data=_build_callback("stars")
|
||
)
|
||
])
|
||
|
||
if settings.is_yookassa_enabled():
|
||
if settings.YOOKASSA_SBP_ENABLED:
|
||
keyboard.append([
|
||
InlineKeyboardButton(
|
||
text=texts.t("PAYMENT_SBP_YOOKASSA", "🏦 Оплатить по СБП (YooKassa)"),
|
||
callback_data=_build_callback("yookassa_sbp"),
|
||
)
|
||
])
|
||
|
||
keyboard.append([
|
||
InlineKeyboardButton(
|
||
text=texts.t("PAYMENT_CARD_YOOKASSA", "💳 Банковская карта (YooKassa)"),
|
||
callback_data=_build_callback("yookassa"),
|
||
)
|
||
])
|
||
|
||
if settings.TRIBUTE_ENABLED:
|
||
keyboard.append([
|
||
InlineKeyboardButton(
|
||
text=texts.t("PAYMENT_CARD_TRIBUTE", "💳 Банковская карта (Tribute)"),
|
||
callback_data=_build_callback("tribute")
|
||
)
|
||
])
|
||
|
||
if settings.is_mulenpay_enabled():
|
||
mulenpay_name = settings.get_mulenpay_display_name()
|
||
keyboard.append([
|
||
InlineKeyboardButton(
|
||
text=texts.t(
|
||
"PAYMENT_CARD_MULENPAY",
|
||
"💳 Банковская карта ({mulenpay_name})",
|
||
).format(mulenpay_name=mulenpay_name),
|
||
callback_data=_build_callback("mulenpay")
|
||
)
|
||
])
|
||
|
||
if settings.is_wata_enabled():
|
||
keyboard.append([
|
||
InlineKeyboardButton(
|
||
text=texts.t("PAYMENT_CARD_WATA", "💳 Банковская карта (WATA)"),
|
||
callback_data=_build_callback("wata")
|
||
)
|
||
])
|
||
|
||
if settings.is_pal24_enabled():
|
||
keyboard.append([
|
||
InlineKeyboardButton(
|
||
text=texts.t("PAYMENT_CARD_PAL24", "🏦 СБП (PayPalych)"),
|
||
callback_data=_build_callback("pal24")
|
||
)
|
||
])
|
||
|
||
if settings.is_cryptobot_enabled():
|
||
keyboard.append([
|
||
InlineKeyboardButton(
|
||
text=texts.t("PAYMENT_CRYPTOBOT", "🪙 Криптовалюта (CryptoBot)"),
|
||
callback_data=_build_callback("cryptobot")
|
||
)
|
||
])
|
||
|
||
if settings.is_heleket_enabled():
|
||
keyboard.append([
|
||
InlineKeyboardButton(
|
||
text=texts.t("PAYMENT_HELEKET", "🪙 Криптовалюта (Heleket)"),
|
||
callback_data=_build_callback("heleket")
|
||
)
|
||
])
|
||
|
||
keyboard.append([
|
||
InlineKeyboardButton(
|
||
text=texts.t("PAYMENT_VIA_SUPPORT", "🛠️ Через поддержку"),
|
||
callback_data="topup_support"
|
||
)
|
||
])
|
||
|
||
if len(keyboard) == 1:
|
||
keyboard.insert(0, [
|
||
InlineKeyboardButton(
|
||
text=texts.t("PAYMENTS_TEMPORARILY_UNAVAILABLE", "⚠️ Способы оплаты временно недоступны"),
|
||
callback_data="payment_methods_unavailable"
|
||
)
|
||
])
|
||
|
||
keyboard.append([
|
||
InlineKeyboardButton(text=texts.BACK, callback_data="menu_balance")
|
||
])
|
||
|
||
return InlineKeyboardMarkup(inline_keyboard=keyboard)
|
||
|
||
def get_yookassa_payment_keyboard(
|
||
payment_id: str,
|
||
amount_kopeks: int,
|
||
confirmation_url: str,
|
||
language: str = DEFAULT_LANGUAGE
|
||
) -> InlineKeyboardMarkup:
|
||
texts = get_texts(language)
|
||
return InlineKeyboardMarkup(inline_keyboard=[
|
||
[
|
||
InlineKeyboardButton(
|
||
text=texts.t("PAY_NOW_BUTTON", "💳 Оплатить"),
|
||
url=confirmation_url
|
||
)
|
||
],
|
||
[
|
||
InlineKeyboardButton(
|
||
text=texts.t("CHECK_STATUS_BUTTON", "📊 Проверить статус"),
|
||
callback_data=f"check_yookassa_status_{payment_id}"
|
||
)
|
||
],
|
||
[
|
||
InlineKeyboardButton(
|
||
text=texts.t("MY_BALANCE_BUTTON", "💰 Мой баланс"),
|
||
callback_data="menu_balance"
|
||
)
|
||
]
|
||
])
|
||
|
||
def get_autopay_notification_keyboard(subscription_id: int, language: str = DEFAULT_LANGUAGE) -> InlineKeyboardMarkup:
|
||
texts = get_texts(language)
|
||
|
||
return InlineKeyboardMarkup(inline_keyboard=[
|
||
[
|
||
build_miniapp_or_callback_button(
|
||
text=texts.t("TOPUP_BALANCE_BUTTON", "💳 Пополнить баланс"),
|
||
callback_data="balance_topup"
|
||
)
|
||
],
|
||
[
|
||
build_miniapp_or_callback_button(
|
||
text=texts.t("MY_SUBSCRIPTION_BUTTON", "📱 Моя подписка"),
|
||
callback_data="menu_subscription"
|
||
)
|
||
]
|
||
])
|
||
|
||
def get_subscription_expiring_keyboard(subscription_id: int, language: str = DEFAULT_LANGUAGE) -> InlineKeyboardMarkup:
|
||
texts = get_texts(language)
|
||
|
||
return InlineKeyboardMarkup(inline_keyboard=[
|
||
[
|
||
build_miniapp_or_callback_button(
|
||
text=texts.MENU_EXTEND_SUBSCRIPTION,
|
||
callback_data="subscription_extend"
|
||
)
|
||
],
|
||
[
|
||
build_miniapp_or_callback_button(
|
||
text=texts.t("TOPUP_BALANCE_BUTTON", "💳 Пополнить баланс"),
|
||
callback_data="balance_topup"
|
||
)
|
||
],
|
||
[
|
||
build_miniapp_or_callback_button(
|
||
text=texts.t("MY_SUBSCRIPTION_BUTTON", "📱 Моя подписка"),
|
||
callback_data="menu_subscription"
|
||
)
|
||
]
|
||
])
|
||
|
||
def get_referral_keyboard(language: str = DEFAULT_LANGUAGE) -> InlineKeyboardMarkup:
|
||
texts = get_texts(language)
|
||
|
||
keyboard = [
|
||
[
|
||
InlineKeyboardButton(
|
||
text=texts.t("CREATE_INVITE_BUTTON", "📝 Создать приглашение"),
|
||
callback_data="referral_create_invite"
|
||
)
|
||
],
|
||
[
|
||
InlineKeyboardButton(
|
||
text=texts.t("SHOW_QR_BUTTON", "📱 Показать QR код"),
|
||
callback_data="referral_show_qr"
|
||
)
|
||
],
|
||
[
|
||
InlineKeyboardButton(
|
||
text=texts.t("REFERRAL_LIST_BUTTON", "👥 Список рефералов"),
|
||
callback_data="referral_list"
|
||
)
|
||
],
|
||
[
|
||
InlineKeyboardButton(
|
||
text=texts.t("REFERRAL_ANALYTICS_BUTTON", "📊 Аналитика"),
|
||
callback_data="referral_analytics"
|
||
)
|
||
],
|
||
[
|
||
InlineKeyboardButton(
|
||
text=texts.BACK,
|
||
callback_data="back_to_menu"
|
||
)
|
||
]
|
||
]
|
||
|
||
return InlineKeyboardMarkup(inline_keyboard=keyboard)
|
||
|
||
|
||
def get_support_keyboard(language: str = DEFAULT_LANGUAGE) -> InlineKeyboardMarkup:
|
||
texts = get_texts(language)
|
||
try:
|
||
from app.services.support_settings_service import SupportSettingsService
|
||
tickets_enabled = SupportSettingsService.is_tickets_enabled()
|
||
contact_enabled = SupportSettingsService.is_contact_enabled()
|
||
except Exception:
|
||
tickets_enabled = True
|
||
contact_enabled = True
|
||
rows: list[list[InlineKeyboardButton]] = []
|
||
# Tickets
|
||
if tickets_enabled:
|
||
rows.append([
|
||
InlineKeyboardButton(
|
||
text=texts.t("CREATE_TICKET_BUTTON", "🎫 Создать тикет"),
|
||
callback_data="create_ticket"
|
||
)
|
||
])
|
||
rows.append([
|
||
InlineKeyboardButton(
|
||
text=texts.t("MY_TICKETS_BUTTON", "📋 Мои тикеты"),
|
||
callback_data="my_tickets"
|
||
)
|
||
])
|
||
# Direct contact
|
||
if contact_enabled and settings.get_support_contact_url():
|
||
rows.append([
|
||
InlineKeyboardButton(
|
||
text=texts.t("CONTACT_SUPPORT_BUTTON", "💬 Связаться с поддержкой"),
|
||
url=settings.get_support_contact_url() or "https://t.me/"
|
||
)
|
||
])
|
||
rows.append([InlineKeyboardButton(text=texts.BACK, callback_data="back_to_menu")])
|
||
return InlineKeyboardMarkup(inline_keyboard=rows)
|
||
|
||
|
||
def get_pagination_keyboard(
|
||
current_page: int,
|
||
total_pages: int,
|
||
callback_prefix: str,
|
||
language: str = DEFAULT_LANGUAGE
|
||
) -> List[List[InlineKeyboardButton]]:
|
||
texts = get_texts(language)
|
||
keyboard = []
|
||
|
||
if total_pages > 1:
|
||
row = []
|
||
|
||
if current_page > 1:
|
||
row.append(InlineKeyboardButton(
|
||
text=texts.t("PAGINATION_PREV", "⬅️"),
|
||
callback_data=f"{callback_prefix}_page_{current_page - 1}"
|
||
))
|
||
|
||
row.append(InlineKeyboardButton(
|
||
text=f"{current_page}/{total_pages}",
|
||
callback_data="current_page"
|
||
))
|
||
|
||
if current_page < total_pages:
|
||
row.append(InlineKeyboardButton(
|
||
text=texts.t("PAGINATION_NEXT", "➡️"),
|
||
callback_data=f"{callback_prefix}_page_{current_page + 1}"
|
||
))
|
||
|
||
keyboard.append(row)
|
||
|
||
return keyboard
|
||
|
||
def get_confirmation_keyboard(
|
||
confirm_data: str,
|
||
cancel_data: str = "cancel",
|
||
language: str = DEFAULT_LANGUAGE
|
||
) -> InlineKeyboardMarkup:
|
||
texts = get_texts(language)
|
||
return InlineKeyboardMarkup(inline_keyboard=[
|
||
[
|
||
InlineKeyboardButton(text=texts.YES, callback_data=confirm_data),
|
||
InlineKeyboardButton(text=texts.NO, callback_data=cancel_data)
|
||
]
|
||
])
|
||
|
||
|
||
def get_autopay_keyboard(language: str = DEFAULT_LANGUAGE) -> InlineKeyboardMarkup:
|
||
texts = get_texts(language)
|
||
return InlineKeyboardMarkup(inline_keyboard=[
|
||
[
|
||
InlineKeyboardButton(text=texts.t("ENABLE_BUTTON", "✅ Включить"), callback_data="autopay_enable"),
|
||
InlineKeyboardButton(text=texts.t("DISABLE_BUTTON", "❌ Выключить"), callback_data="autopay_disable")
|
||
],
|
||
[
|
||
InlineKeyboardButton(text=texts.t("AUTOPAY_SET_DAYS_BUTTON", "⚙️ Настроить дни"), callback_data="autopay_set_days")
|
||
],
|
||
[
|
||
InlineKeyboardButton(text=texts.BACK, callback_data="menu_subscription")
|
||
]
|
||
])
|
||
|
||
|
||
def get_autopay_days_keyboard(language: str = DEFAULT_LANGUAGE) -> InlineKeyboardMarkup:
|
||
texts = get_texts(language)
|
||
keyboard = []
|
||
|
||
for days in [1, 3, 7, 14]:
|
||
keyboard.append([
|
||
InlineKeyboardButton(
|
||
text=f"{days} {_get_days_word(days)}",
|
||
callback_data=f"autopay_days_{days}"
|
||
)
|
||
])
|
||
|
||
keyboard.append([
|
||
InlineKeyboardButton(text=texts.BACK, callback_data="subscription_autopay")
|
||
])
|
||
|
||
return InlineKeyboardMarkup(inline_keyboard=keyboard)
|
||
|
||
|
||
def _get_days_word(days: int) -> str:
|
||
if days % 10 == 1 and days % 100 != 11:
|
||
return "день"
|
||
if 2 <= days % 10 <= 4 and not (12 <= days % 100 <= 14):
|
||
return "дня"
|
||
return "дней"
|
||
|
||
|
||
|
||
def get_extend_subscription_keyboard(language: str = DEFAULT_LANGUAGE) -> InlineKeyboardMarkup:
|
||
texts = get_texts(language)
|
||
keyboard = []
|
||
|
||
periods = [
|
||
(14, texts.PERIOD_14_DAYS),
|
||
(30, texts.PERIOD_30_DAYS),
|
||
(60, texts.PERIOD_60_DAYS),
|
||
(90, texts.PERIOD_90_DAYS)
|
||
]
|
||
|
||
for days, text in periods:
|
||
keyboard.append([
|
||
InlineKeyboardButton(text=text, callback_data=f"extend_period_{days}")
|
||
])
|
||
|
||
keyboard.append([
|
||
InlineKeyboardButton(text=texts.BACK, callback_data="menu_subscription")
|
||
])
|
||
|
||
return InlineKeyboardMarkup(inline_keyboard=keyboard)
|
||
|
||
|
||
def get_add_traffic_keyboard(
|
||
language: str = DEFAULT_LANGUAGE,
|
||
subscription_end_date: datetime = None,
|
||
discount_percent: int = 0,
|
||
) -> InlineKeyboardMarkup:
|
||
from app.utils.pricing_utils import get_remaining_months
|
||
from app.config import settings
|
||
texts = get_texts(language)
|
||
|
||
months_multiplier = 1
|
||
period_text = ""
|
||
if subscription_end_date:
|
||
months_multiplier = get_remaining_months(subscription_end_date)
|
||
if months_multiplier > 1:
|
||
period_text = f" (за {months_multiplier} мес)"
|
||
|
||
packages = settings.get_traffic_packages()
|
||
enabled_packages = [pkg for pkg in packages if pkg['enabled']]
|
||
|
||
if not enabled_packages:
|
||
return InlineKeyboardMarkup(inline_keyboard=[
|
||
[InlineKeyboardButton(
|
||
text=texts.t("NO_TRAFFIC_PACKAGES", "❌ Нет доступных пакетов"),
|
||
callback_data="no_traffic_packages"
|
||
)],
|
||
[InlineKeyboardButton(
|
||
text=texts.BACK,
|
||
callback_data="menu_subscription"
|
||
)]
|
||
])
|
||
|
||
buttons = []
|
||
|
||
for package in enabled_packages:
|
||
gb = package['gb']
|
||
price_per_month = package['price']
|
||
discounted_per_month, discount_per_month = apply_percentage_discount(
|
||
price_per_month,
|
||
discount_percent,
|
||
)
|
||
total_price = discounted_per_month * months_multiplier
|
||
total_discount = discount_per_month * months_multiplier
|
||
|
||
if gb == 0:
|
||
if language == "ru":
|
||
text = f"♾️ Безлимитный трафик - {total_price//100} ₽{period_text}"
|
||
else:
|
||
text = f"♾️ Unlimited traffic - {total_price//100} ₽{period_text}"
|
||
else:
|
||
if language == "ru":
|
||
text = f"📊 +{gb} ГБ трафика - {total_price//100} ₽{period_text}"
|
||
else:
|
||
text = f"📊 +{gb} GB traffic - {total_price//100} ₽{period_text}"
|
||
|
||
if discount_percent > 0 and total_discount > 0:
|
||
text += f" (скидка {discount_percent}%: -{total_discount//100}₽)"
|
||
|
||
buttons.append([
|
||
InlineKeyboardButton(text=text, callback_data=f"add_traffic_{gb}")
|
||
])
|
||
|
||
buttons.append([
|
||
InlineKeyboardButton(
|
||
text=texts.BACK,
|
||
callback_data="menu_subscription"
|
||
)
|
||
])
|
||
|
||
return InlineKeyboardMarkup(inline_keyboard=buttons)
|
||
|
||
def get_change_devices_keyboard(
|
||
current_devices: int,
|
||
language: str = DEFAULT_LANGUAGE,
|
||
subscription_end_date: datetime = None,
|
||
discount_percent: int = 0,
|
||
) -> InlineKeyboardMarkup:
|
||
from app.utils.pricing_utils import get_remaining_months
|
||
from app.config import settings
|
||
texts = get_texts(language)
|
||
|
||
months_multiplier = 1
|
||
period_text = ""
|
||
if subscription_end_date:
|
||
months_multiplier = get_remaining_months(subscription_end_date)
|
||
if months_multiplier > 1:
|
||
period_text = f" (за {months_multiplier} мес)"
|
||
|
||
device_price_per_month = settings.PRICE_PER_DEVICE
|
||
|
||
buttons = []
|
||
|
||
min_devices = 1
|
||
max_devices = settings.MAX_DEVICES_LIMIT if settings.MAX_DEVICES_LIMIT > 0 else 20
|
||
|
||
start_range = max(1, min(current_devices - 3, max_devices - 6))
|
||
end_range = min(max_devices + 1, max(current_devices + 4, 7))
|
||
|
||
for devices_count in range(start_range, end_range):
|
||
if devices_count == current_devices:
|
||
emoji = "✅"
|
||
action_text = " (текущее)"
|
||
price_text = ""
|
||
elif devices_count > current_devices:
|
||
emoji = "➕"
|
||
additional_devices = devices_count - current_devices
|
||
|
||
current_chargeable = max(0, current_devices - settings.DEFAULT_DEVICE_LIMIT)
|
||
new_chargeable = max(0, devices_count - settings.DEFAULT_DEVICE_LIMIT)
|
||
chargeable_devices = new_chargeable - current_chargeable
|
||
|
||
if chargeable_devices > 0:
|
||
price_per_month = chargeable_devices * device_price_per_month
|
||
discounted_per_month, discount_per_month = apply_percentage_discount(
|
||
price_per_month,
|
||
discount_percent,
|
||
)
|
||
total_price = discounted_per_month * months_multiplier
|
||
price_text = f" (+{total_price//100}₽{period_text})"
|
||
if discount_percent > 0 and discount_per_month * months_multiplier > 0:
|
||
price_text += (
|
||
f" (скидка {discount_percent}%:"
|
||
f" -{(discount_per_month * months_multiplier)//100}₽)"
|
||
)
|
||
action_text = ""
|
||
else:
|
||
price_text = " (бесплатно)"
|
||
action_text = ""
|
||
else:
|
||
emoji = "➖"
|
||
action_text = ""
|
||
price_text = " (без возврата)"
|
||
|
||
button_text = f"{emoji} {devices_count} устр.{action_text}{price_text}"
|
||
|
||
buttons.append([
|
||
InlineKeyboardButton(text=button_text, callback_data=f"change_devices_{devices_count}")
|
||
])
|
||
|
||
if current_devices < start_range or current_devices >= end_range:
|
||
current_button = f"✅ {current_devices} устр. (текущее)"
|
||
buttons.insert(0, [
|
||
InlineKeyboardButton(text=current_button, callback_data=f"change_devices_{current_devices}")
|
||
])
|
||
|
||
buttons.append([
|
||
InlineKeyboardButton(
|
||
text=texts.BACK,
|
||
callback_data="subscription_settings"
|
||
)
|
||
])
|
||
|
||
return InlineKeyboardMarkup(inline_keyboard=buttons)
|
||
|
||
def get_confirm_change_devices_keyboard(new_devices_count: int, price: int, language: str = DEFAULT_LANGUAGE) -> InlineKeyboardMarkup:
|
||
texts = get_texts(language)
|
||
|
||
return InlineKeyboardMarkup(inline_keyboard=[
|
||
[
|
||
InlineKeyboardButton(
|
||
text=texts.t("CONFIRM_CHANGE_BUTTON", "✅ Подтвердить изменение"),
|
||
callback_data=f"confirm_change_devices_{new_devices_count}_{price}"
|
||
)
|
||
],
|
||
[
|
||
InlineKeyboardButton(
|
||
text=texts.CANCEL,
|
||
callback_data="subscription_settings"
|
||
)
|
||
]
|
||
])
|
||
|
||
|
||
def get_reset_traffic_confirm_keyboard(price_kopeks: int, language: str = DEFAULT_LANGUAGE) -> InlineKeyboardMarkup:
|
||
from app.config import settings
|
||
|
||
if settings.is_traffic_fixed():
|
||
return get_back_keyboard(language)
|
||
|
||
texts = get_texts(language)
|
||
return InlineKeyboardMarkup(inline_keyboard=[
|
||
[
|
||
InlineKeyboardButton(
|
||
text=f"✅ Сбросить за {settings.format_price(price_kopeks)}",
|
||
callback_data="confirm_reset_traffic"
|
||
)
|
||
],
|
||
[
|
||
InlineKeyboardButton(
|
||
text=texts.t("PENDING_CANCEL_BUTTON", "⌛ Отмена"),
|
||
callback_data="menu_subscription",
|
||
)
|
||
]
|
||
])
|
||
|
||
def get_manage_countries_keyboard(
|
||
countries: List[dict],
|
||
selected: List[str],
|
||
current_subscription_countries: List[str],
|
||
language: str = DEFAULT_LANGUAGE,
|
||
subscription_end_date: datetime = None,
|
||
discount_percent: int = 0,
|
||
) -> InlineKeyboardMarkup:
|
||
from app.utils.pricing_utils import get_remaining_months
|
||
|
||
texts = get_texts(language)
|
||
|
||
months_multiplier = 1
|
||
if subscription_end_date:
|
||
months_multiplier = get_remaining_months(subscription_end_date)
|
||
logger.info(f"🔍 Расчет для управления странами: осталось {months_multiplier} месяцев до {subscription_end_date}")
|
||
|
||
buttons = []
|
||
total_cost = 0
|
||
|
||
for country in countries:
|
||
if not country.get('is_available', True):
|
||
continue
|
||
|
||
uuid = country['uuid']
|
||
name = country['name']
|
||
price_per_month = country['price_kopeks']
|
||
|
||
discounted_per_month, discount_per_month = apply_percentage_discount(
|
||
price_per_month,
|
||
discount_percent,
|
||
)
|
||
|
||
if uuid in current_subscription_countries:
|
||
if uuid in selected:
|
||
icon = "✅"
|
||
else:
|
||
icon = "➖"
|
||
else:
|
||
if uuid in selected:
|
||
icon = "➕"
|
||
total_cost += discounted_per_month * months_multiplier
|
||
else:
|
||
icon = "⚪"
|
||
|
||
if uuid not in current_subscription_countries and uuid in selected:
|
||
total_price = discounted_per_month * months_multiplier
|
||
if months_multiplier > 1:
|
||
price_text = (
|
||
f" ({discounted_per_month//100}₽/мес × {months_multiplier} = {total_price//100}₽)"
|
||
)
|
||
logger.info(
|
||
"🔍 Сервер %s: %.2f₽/мес × %s мес = %.2f₽ (скидка %.2f₽)",
|
||
name,
|
||
discounted_per_month / 100,
|
||
months_multiplier,
|
||
total_price / 100,
|
||
(discount_per_month * months_multiplier) / 100,
|
||
)
|
||
else:
|
||
price_text = f" ({total_price//100}₽)"
|
||
if discount_percent > 0 and discount_per_month * months_multiplier > 0:
|
||
price_text += (
|
||
f" (скидка {discount_percent}%:"
|
||
f" -{(discount_per_month * months_multiplier)//100}₽)"
|
||
)
|
||
display_name = f"{icon} {name}{price_text}"
|
||
else:
|
||
display_name = f"{icon} {name}"
|
||
|
||
buttons.append([
|
||
InlineKeyboardButton(
|
||
text=display_name,
|
||
callback_data=f"country_manage_{uuid}"
|
||
)
|
||
])
|
||
|
||
if total_cost > 0:
|
||
apply_text = f"✅ Применить изменения ({total_cost//100} ₽)"
|
||
logger.info(f"🔍 Общая стоимость новых серверов: {total_cost/100}₽")
|
||
else:
|
||
apply_text = "✅ Применить изменения"
|
||
|
||
buttons.append([
|
||
InlineKeyboardButton(text=apply_text, callback_data="countries_apply")
|
||
])
|
||
|
||
buttons.append([
|
||
InlineKeyboardButton(
|
||
text=texts.BACK,
|
||
callback_data="menu_subscription"
|
||
)
|
||
])
|
||
|
||
return InlineKeyboardMarkup(inline_keyboard=buttons)
|
||
|
||
def get_device_selection_keyboard(language: str = DEFAULT_LANGUAGE) -> InlineKeyboardMarkup:
|
||
from app.config import settings
|
||
texts = get_texts(language)
|
||
|
||
keyboard = [
|
||
[
|
||
InlineKeyboardButton(text=texts.t("DEVICE_GUIDE_IOS", "📱 iOS (iPhone/iPad)"), callback_data="device_guide_ios"),
|
||
InlineKeyboardButton(text=texts.t("DEVICE_GUIDE_ANDROID", "🤖 Android"), callback_data="device_guide_android")
|
||
],
|
||
[
|
||
InlineKeyboardButton(text=texts.t("DEVICE_GUIDE_WINDOWS", "💻 Windows"), callback_data="device_guide_windows"),
|
||
InlineKeyboardButton(text=texts.t("DEVICE_GUIDE_MAC", "🎯 macOS"), callback_data="device_guide_mac")
|
||
],
|
||
[
|
||
InlineKeyboardButton(text=texts.t("DEVICE_GUIDE_ANDROID_TV", "📺 Android TV"), callback_data="device_guide_tv"),
|
||
InlineKeyboardButton(text=texts.t("DEVICE_GUIDE_APPLE_TV", "📺 Apple TV"), callback_data="device_guide_appletv")
|
||
]
|
||
]
|
||
|
||
if settings.CONNECT_BUTTON_MODE == "guide":
|
||
keyboard.append([
|
||
InlineKeyboardButton(text=texts.t("SHOW_SUBSCRIPTION_LINK", "📋 Показать ссылку подписки"), callback_data="open_subscription_link")
|
||
])
|
||
|
||
keyboard.append([
|
||
InlineKeyboardButton(text=texts.BACK, callback_data="menu_subscription")
|
||
])
|
||
|
||
return InlineKeyboardMarkup(inline_keyboard=keyboard)
|
||
|
||
|
||
def get_connection_guide_keyboard(
|
||
subscription_url: str,
|
||
app: dict,
|
||
device_type: str,
|
||
language: str = DEFAULT_LANGUAGE,
|
||
has_other_apps: bool = False,
|
||
) -> InlineKeyboardMarkup:
|
||
from app.handlers.subscription import create_deep_link
|
||
texts = get_texts(language)
|
||
|
||
keyboard = []
|
||
|
||
if 'installationStep' in app and 'buttons' in app['installationStep']:
|
||
app_buttons = []
|
||
for button in app['installationStep']['buttons']:
|
||
button_text = _get_localized_value(button.get('buttonText'), language)
|
||
button_link = button.get('buttonLink')
|
||
|
||
if not button_text or not button_link:
|
||
continue
|
||
|
||
app_buttons.append(
|
||
InlineKeyboardButton(text=f"📥 {button_text}", url=button_link)
|
||
)
|
||
if len(app_buttons) == 2:
|
||
keyboard.append(app_buttons)
|
||
app_buttons = []
|
||
|
||
if app_buttons:
|
||
keyboard.append(app_buttons)
|
||
|
||
additional_before_buttons = _build_additional_buttons(
|
||
app.get('additionalBeforeAddSubscriptionStep'),
|
||
language,
|
||
)
|
||
|
||
for button in additional_before_buttons:
|
||
keyboard.append([button])
|
||
|
||
connect_link = create_deep_link(app, subscription_url)
|
||
|
||
if connect_link:
|
||
connect_button = InlineKeyboardButton(
|
||
text=texts.t("CONNECT_BUTTON", "🔗 Подключиться"),
|
||
url=connect_link,
|
||
)
|
||
elif settings.is_happ_cryptolink_mode():
|
||
connect_button = InlineKeyboardButton(
|
||
text=texts.t("CONNECT_BUTTON", "🔗 Подключиться"),
|
||
callback_data="open_subscription_link",
|
||
)
|
||
else:
|
||
connect_button = InlineKeyboardButton(
|
||
text=texts.t("CONNECT_BUTTON", "🔗 Подключиться"),
|
||
url=subscription_url,
|
||
)
|
||
|
||
keyboard.append([connect_button])
|
||
|
||
additional_after_buttons = _build_additional_buttons(
|
||
app.get('additionalAfterAddSubscriptionStep'),
|
||
language,
|
||
)
|
||
|
||
for button in additional_after_buttons:
|
||
keyboard.append([button])
|
||
|
||
if has_other_apps:
|
||
keyboard.append([
|
||
InlineKeyboardButton(
|
||
text=texts.t("OTHER_APPS_BUTTON", "📋 Другие приложения"),
|
||
callback_data=f"app_list_{device_type}",
|
||
)
|
||
])
|
||
|
||
keyboard.extend([
|
||
[
|
||
InlineKeyboardButton(text=texts.t("CHOOSE_ANOTHER_DEVICE", "📱 Выбрать другое устройство"), callback_data="subscription_connect")
|
||
],
|
||
[
|
||
InlineKeyboardButton(text=texts.t("BACK_TO_SUBSCRIPTION", "⬅️ К подписке"), callback_data="menu_subscription")
|
||
]
|
||
])
|
||
|
||
return InlineKeyboardMarkup(inline_keyboard=keyboard)
|
||
|
||
|
||
def get_app_selection_keyboard(
|
||
device_type: str,
|
||
apps: list,
|
||
language: str = DEFAULT_LANGUAGE
|
||
) -> InlineKeyboardMarkup:
|
||
texts = get_texts(language)
|
||
keyboard = []
|
||
|
||
for app in apps:
|
||
app_name = app['name']
|
||
if app.get('isFeatured', False):
|
||
app_name = f"⭐ {app_name}"
|
||
|
||
keyboard.append([
|
||
InlineKeyboardButton(
|
||
text=app_name,
|
||
callback_data=f"app_{device_type}_{app['id']}"
|
||
)
|
||
])
|
||
|
||
keyboard.extend([
|
||
[
|
||
InlineKeyboardButton(text=texts.t("CHOOSE_ANOTHER_DEVICE", "📱 Выбрать другое устройство"), callback_data="subscription_connect")
|
||
],
|
||
[
|
||
InlineKeyboardButton(text=texts.t("BACK_TO_SUBSCRIPTION", "⬅️ К подписке"), callback_data="menu_subscription")
|
||
]
|
||
])
|
||
|
||
return InlineKeyboardMarkup(inline_keyboard=keyboard)
|
||
|
||
|
||
def get_specific_app_keyboard(
|
||
subscription_url: str,
|
||
app: dict,
|
||
device_type: str,
|
||
language: str = DEFAULT_LANGUAGE
|
||
) -> InlineKeyboardMarkup:
|
||
from app.handlers.subscription import create_deep_link
|
||
texts = get_texts(language)
|
||
|
||
keyboard = []
|
||
|
||
if 'installationStep' in app and 'buttons' in app['installationStep']:
|
||
app_buttons = []
|
||
for button in app['installationStep']['buttons']:
|
||
button_text = _get_localized_value(button.get('buttonText'), language)
|
||
button_link = button.get('buttonLink')
|
||
|
||
if not button_text or not button_link:
|
||
continue
|
||
|
||
app_buttons.append(
|
||
InlineKeyboardButton(text=f"📥 {button_text}", url=button_link)
|
||
)
|
||
if len(app_buttons) == 2:
|
||
keyboard.append(app_buttons)
|
||
app_buttons = []
|
||
|
||
if app_buttons:
|
||
keyboard.append(app_buttons)
|
||
|
||
additional_before_buttons = _build_additional_buttons(
|
||
app.get('additionalBeforeAddSubscriptionStep'),
|
||
language,
|
||
)
|
||
|
||
for button in additional_before_buttons:
|
||
keyboard.append([button])
|
||
|
||
connect_link = create_deep_link(app, subscription_url)
|
||
|
||
if connect_link:
|
||
connect_button = InlineKeyboardButton(
|
||
text=texts.t("CONNECT_BUTTON", "🔗 Подключиться"),
|
||
url=connect_link,
|
||
)
|
||
elif settings.is_happ_cryptolink_mode():
|
||
connect_button = InlineKeyboardButton(
|
||
text=texts.t("CONNECT_BUTTON", "🔗 Подключиться"),
|
||
callback_data="open_subscription_link",
|
||
)
|
||
else:
|
||
connect_button = InlineKeyboardButton(
|
||
text=texts.t("CONNECT_BUTTON", "🔗 Подключиться"),
|
||
url=subscription_url,
|
||
)
|
||
|
||
keyboard.append([connect_button])
|
||
|
||
additional_after_buttons = _build_additional_buttons(
|
||
app.get('additionalAfterAddSubscriptionStep'),
|
||
language,
|
||
)
|
||
|
||
for button in additional_after_buttons:
|
||
keyboard.append([button])
|
||
|
||
keyboard.extend([
|
||
[
|
||
InlineKeyboardButton(text=texts.t("OTHER_APPS_BUTTON", "📋 Другие приложения"), callback_data=f"app_list_{device_type}")
|
||
],
|
||
[
|
||
InlineKeyboardButton(text=texts.t("CHOOSE_ANOTHER_DEVICE", "📱 Выбрать другое устройство"), callback_data="subscription_connect")
|
||
],
|
||
[
|
||
InlineKeyboardButton(text=texts.t("BACK_TO_SUBSCRIPTION", "⬅️ К подписке"), callback_data="menu_subscription")
|
||
]
|
||
])
|
||
|
||
return InlineKeyboardMarkup(inline_keyboard=keyboard)
|
||
|
||
def get_extend_subscription_keyboard_with_prices(language: str, prices: dict) -> InlineKeyboardMarkup:
|
||
texts = get_texts(language)
|
||
keyboard = []
|
||
|
||
available_periods = settings.get_available_renewal_periods()
|
||
|
||
for days in available_periods:
|
||
if days not in prices:
|
||
continue
|
||
|
||
price_info = prices[days]
|
||
|
||
if isinstance(price_info, dict):
|
||
final_price = price_info.get("final")
|
||
original_price = price_info.get("original", 0)
|
||
if final_price is None:
|
||
final_price = price_info.get("original", 0)
|
||
else:
|
||
final_price = price_info
|
||
original_price = price_info
|
||
|
||
period_display = format_period_description(days, language)
|
||
|
||
# Show discount if there is one
|
||
if original_price > final_price and original_price > 0:
|
||
discount_percent = ((original_price - final_price) * 100) // original_price
|
||
button_text = (
|
||
f"📅 {period_display} - "
|
||
f"<s>{texts.format_price(original_price)}</s> "
|
||
f"{texts.format_price(final_price)} "
|
||
f"(-{discount_percent}%)"
|
||
)
|
||
# Add fire emojis for 360 days
|
||
if days == 360:
|
||
button_text = f"🔥 {button_text} 🔥"
|
||
else:
|
||
button_text = f"📅 {period_display} - {texts.format_price(final_price)}"
|
||
|
||
keyboard.append([
|
||
InlineKeyboardButton(
|
||
text=button_text,
|
||
callback_data=f"extend_period_{days}"
|
||
)
|
||
])
|
||
|
||
keyboard.append([
|
||
InlineKeyboardButton(text=texts.BACK, callback_data="menu_subscription")
|
||
])
|
||
|
||
return InlineKeyboardMarkup(inline_keyboard=keyboard)
|
||
|
||
def get_cryptobot_payment_keyboard(
|
||
payment_id: str,
|
||
local_payment_id: int,
|
||
amount_usd: float,
|
||
asset: str,
|
||
bot_invoice_url: str,
|
||
language: str = DEFAULT_LANGUAGE
|
||
) -> InlineKeyboardMarkup:
|
||
texts = get_texts(language)
|
||
return InlineKeyboardMarkup(inline_keyboard=[
|
||
[
|
||
InlineKeyboardButton(
|
||
text=texts.t("PAY_WITH_COINS_BUTTON", "🪙 Оплатить"),
|
||
url=bot_invoice_url
|
||
)
|
||
],
|
||
[
|
||
InlineKeyboardButton(
|
||
text=texts.t("CHECK_STATUS_BUTTON", "📊 Проверить статус"),
|
||
callback_data=f"check_cryptobot_{local_payment_id}"
|
||
)
|
||
],
|
||
[
|
||
InlineKeyboardButton(
|
||
text=texts.t("MY_BALANCE_BUTTON", "💰 Мой баланс"),
|
||
callback_data="menu_balance"
|
||
)
|
||
]
|
||
])
|
||
|
||
def get_devices_management_keyboard(
|
||
devices: List[dict],
|
||
pagination,
|
||
language: str = DEFAULT_LANGUAGE
|
||
) -> InlineKeyboardMarkup:
|
||
texts = get_texts(language)
|
||
|
||
keyboard = []
|
||
|
||
for i, device in enumerate(devices):
|
||
platform = device.get('platform', 'Unknown')
|
||
device_model = device.get('deviceModel', 'Unknown')
|
||
device_info = f"{platform} - {device_model}"
|
||
|
||
if len(device_info) > 25:
|
||
device_info = device_info[:22] + "..."
|
||
|
||
keyboard.append([
|
||
InlineKeyboardButton(
|
||
text=f"🔄 {device_info}",
|
||
callback_data=f"reset_device_{i}_{pagination.page}"
|
||
)
|
||
])
|
||
|
||
if pagination.total_pages > 1:
|
||
nav_row = []
|
||
|
||
if pagination.has_prev:
|
||
nav_row.append(
|
||
InlineKeyboardButton(
|
||
text=texts.t("PAGINATION_PREV", "⬅️"),
|
||
callback_data=f"devices_page_{pagination.prev_page}"
|
||
)
|
||
)
|
||
|
||
nav_row.append(
|
||
InlineKeyboardButton(
|
||
text=f"{pagination.page}/{pagination.total_pages}",
|
||
callback_data="current_page"
|
||
)
|
||
)
|
||
|
||
if pagination.has_next:
|
||
nav_row.append(
|
||
InlineKeyboardButton(
|
||
text=texts.t("PAGINATION_NEXT", "➡️"),
|
||
callback_data=f"devices_page_{pagination.next_page}"
|
||
)
|
||
)
|
||
|
||
keyboard.append(nav_row)
|
||
|
||
keyboard.append([
|
||
InlineKeyboardButton(
|
||
text=texts.t("RESET_ALL_DEVICES_BUTTON", "🔄 Сбросить все устройства"),
|
||
callback_data="reset_all_devices"
|
||
)
|
||
])
|
||
|
||
keyboard.append([
|
||
InlineKeyboardButton(
|
||
text=texts.BACK,
|
||
callback_data="subscription_settings"
|
||
)
|
||
])
|
||
|
||
return InlineKeyboardMarkup(inline_keyboard=keyboard)
|
||
|
||
|
||
def get_updated_subscription_settings_keyboard(language: str = DEFAULT_LANGUAGE, show_countries_management: bool = True) -> InlineKeyboardMarkup:
|
||
from app.config import settings
|
||
|
||
texts = get_texts(language)
|
||
keyboard = []
|
||
|
||
if show_countries_management:
|
||
keyboard.append([
|
||
InlineKeyboardButton(text=texts.t("ADD_COUNTRIES_BUTTON", "🌐 Добавить страны"), callback_data="subscription_add_countries")
|
||
])
|
||
|
||
if settings.is_traffic_selectable():
|
||
keyboard.append([
|
||
InlineKeyboardButton(text=texts.t("RESET_TRAFFIC_BUTTON", "🔄 Сбросить трафик"), callback_data="subscription_reset_traffic")
|
||
])
|
||
keyboard.append([
|
||
InlineKeyboardButton(text=texts.t("SWITCH_TRAFFIC_BUTTON", "🔄 Переключить трафик"), callback_data="subscription_switch_traffic")
|
||
])
|
||
|
||
if settings.is_devices_selection_enabled():
|
||
keyboard.append([
|
||
InlineKeyboardButton(
|
||
text=texts.t("CHANGE_DEVICES_BUTTON", "📱 Изменить устройства"),
|
||
callback_data="subscription_change_devices"
|
||
)
|
||
])
|
||
|
||
keyboard.append([
|
||
InlineKeyboardButton(
|
||
text=texts.t("MANAGE_DEVICES_BUTTON", "🔧 Управление устройствами"),
|
||
callback_data="subscription_manage_devices"
|
||
)
|
||
])
|
||
|
||
keyboard.append([
|
||
InlineKeyboardButton(text=texts.BACK, callback_data="menu_subscription")
|
||
])
|
||
|
||
return InlineKeyboardMarkup(inline_keyboard=keyboard)
|
||
|
||
|
||
def get_device_reset_confirm_keyboard(device_info: str, device_index: int, page: int, language: str = DEFAULT_LANGUAGE) -> InlineKeyboardMarkup:
|
||
texts = get_texts(language)
|
||
|
||
return InlineKeyboardMarkup(inline_keyboard=[
|
||
[
|
||
InlineKeyboardButton(
|
||
text=texts.t("RESET_DEVICE_CONFIRM_BUTTON", "✅ Да, сбросить это устройство"),
|
||
callback_data=f"confirm_reset_device_{device_index}_{page}"
|
||
)
|
||
],
|
||
[
|
||
InlineKeyboardButton(
|
||
text=texts.CANCEL,
|
||
callback_data=f"devices_page_{page}"
|
||
)
|
||
]
|
||
])
|
||
|
||
|
||
def get_device_management_help_keyboard(language: str = DEFAULT_LANGUAGE) -> InlineKeyboardMarkup:
|
||
texts = get_texts(language)
|
||
|
||
return InlineKeyboardMarkup(inline_keyboard=[
|
||
[
|
||
InlineKeyboardButton(
|
||
text=texts.t("DEVICE_CONNECTION_HELP", "❓ Как подключить устройство заново?"),
|
||
callback_data="device_connection_help"
|
||
)
|
||
],
|
||
[
|
||
InlineKeyboardButton(
|
||
text=texts.t("MANAGE_DEVICES_BUTTON", "🔧 Управление устройствами"),
|
||
callback_data="subscription_manage_devices"
|
||
)
|
||
],
|
||
[
|
||
InlineKeyboardButton(
|
||
text=texts.t("BACK_TO_SUBSCRIPTION", "⬅️ К подписке"),
|
||
callback_data="menu_subscription"
|
||
)
|
||
]
|
||
])
|
||
|
||
|
||
# ==================== TICKET KEYBOARDS ====================
|
||
|
||
def get_ticket_cancel_keyboard(language: str = DEFAULT_LANGUAGE) -> InlineKeyboardMarkup:
|
||
texts = get_texts(language)
|
||
return InlineKeyboardMarkup(inline_keyboard=[
|
||
[
|
||
InlineKeyboardButton(
|
||
text=texts.t("CANCEL_TICKET_CREATION", "❌ Отменить создание тикета"),
|
||
callback_data="cancel_ticket_creation"
|
||
)
|
||
]
|
||
])
|
||
|
||
|
||
def get_my_tickets_keyboard(
|
||
tickets: List[dict],
|
||
current_page: int = 1,
|
||
total_pages: int = 1,
|
||
language: str = DEFAULT_LANGUAGE,
|
||
page_prefix: str = "my_tickets_page_"
|
||
) -> InlineKeyboardMarkup:
|
||
texts = get_texts(language)
|
||
keyboard = []
|
||
|
||
for ticket in tickets:
|
||
status_emoji = ticket.get('status_emoji', '❓')
|
||
# Override status emoji for closed tickets in admin list
|
||
if ticket.get('is_closed', False):
|
||
status_emoji = '✅'
|
||
title = ticket.get('title', 'Без названия')[:25]
|
||
button_text = f"{status_emoji} #{ticket['id']} {title}"
|
||
|
||
keyboard.append([
|
||
InlineKeyboardButton(
|
||
text=button_text,
|
||
callback_data=f"view_ticket_{ticket['id']}"
|
||
)
|
||
])
|
||
|
||
# Пагинация
|
||
if total_pages > 1:
|
||
nav_row = []
|
||
|
||
if current_page > 1:
|
||
nav_row.append(
|
||
InlineKeyboardButton(
|
||
text=texts.t("PAGINATION_PREV", "⬅️"),
|
||
callback_data=f"{page_prefix}{current_page - 1}"
|
||
)
|
||
)
|
||
|
||
nav_row.append(
|
||
InlineKeyboardButton(
|
||
text=f"{current_page}/{total_pages}",
|
||
callback_data="current_page"
|
||
)
|
||
)
|
||
|
||
if current_page < total_pages:
|
||
nav_row.append(
|
||
InlineKeyboardButton(
|
||
text=texts.t("PAGINATION_NEXT", "➡️"),
|
||
callback_data=f"{page_prefix}{current_page + 1}"
|
||
)
|
||
)
|
||
|
||
keyboard.append(nav_row)
|
||
|
||
keyboard.append([
|
||
InlineKeyboardButton(text=texts.BACK, callback_data="menu_support")
|
||
])
|
||
|
||
return InlineKeyboardMarkup(inline_keyboard=keyboard)
|
||
|
||
|
||
def get_ticket_view_keyboard(
|
||
ticket_id: int,
|
||
is_closed: bool = False,
|
||
language: str = DEFAULT_LANGUAGE
|
||
) -> InlineKeyboardMarkup:
|
||
texts = get_texts(language)
|
||
keyboard = []
|
||
|
||
if not is_closed:
|
||
keyboard.append([
|
||
InlineKeyboardButton(
|
||
text=texts.t("REPLY_TO_TICKET", "💬 Ответить"),
|
||
callback_data=f"reply_ticket_{ticket_id}"
|
||
)
|
||
])
|
||
|
||
if not is_closed:
|
||
keyboard.append([
|
||
InlineKeyboardButton(
|
||
text=texts.t("CLOSE_TICKET", "🔒 Закрыть тикет"),
|
||
callback_data=f"close_ticket_{ticket_id}"
|
||
)
|
||
])
|
||
|
||
keyboard.append([
|
||
InlineKeyboardButton(text=texts.BACK, callback_data="my_tickets")
|
||
])
|
||
|
||
return InlineKeyboardMarkup(inline_keyboard=keyboard)
|
||
|
||
|
||
def get_ticket_reply_cancel_keyboard(language: str = DEFAULT_LANGUAGE) -> InlineKeyboardMarkup:
|
||
texts = get_texts(language)
|
||
return InlineKeyboardMarkup(inline_keyboard=[
|
||
[
|
||
InlineKeyboardButton(
|
||
text=texts.t("CANCEL_REPLY", "❌ Отменить ответ"),
|
||
callback_data="cancel_ticket_reply"
|
||
)
|
||
]
|
||
])
|
||
|
||
|
||
# ==================== ADMIN TICKET KEYBOARDS ====================
|
||
|
||
def get_admin_tickets_keyboard(
|
||
tickets: List[dict],
|
||
current_page: int = 1,
|
||
total_pages: int = 1,
|
||
language: str = DEFAULT_LANGUAGE,
|
||
scope: str = "all",
|
||
*,
|
||
back_callback: str = "admin_submenu_support"
|
||
) -> InlineKeyboardMarkup:
|
||
texts = get_texts(language)
|
||
keyboard = []
|
||
|
||
# Разделяем открытые/закрытые
|
||
open_rows = []
|
||
closed_rows = []
|
||
for ticket in tickets:
|
||
status_emoji = ticket.get('status_emoji', '❓')
|
||
if ticket.get('is_closed', False):
|
||
status_emoji = '✅'
|
||
user_name = ticket.get('user_name', 'Unknown')
|
||
username = ticket.get('username')
|
||
telegram_id = ticket.get('telegram_id')
|
||
# Сформируем компактное отображение: Имя (@username | ID)
|
||
name_parts = [user_name[:15]]
|
||
contact_parts = []
|
||
if username:
|
||
contact_parts.append(f"@{username}")
|
||
if telegram_id:
|
||
contact_parts.append(str(telegram_id))
|
||
if contact_parts:
|
||
name_parts.append(f"({' | '.join(contact_parts)})")
|
||
name_display = ' '.join(name_parts)
|
||
title = ticket.get('title', 'Без названия')[:20]
|
||
locked_emoji = ticket.get('locked_emoji', '')
|
||
button_text = f"{status_emoji} #{ticket['id']} {locked_emoji} {name_display}: {title}".replace(" ", " ")
|
||
row = [InlineKeyboardButton(text=button_text, callback_data=f"admin_view_ticket_{ticket['id']}")]
|
||
if ticket.get('is_closed', False):
|
||
closed_rows.append(row)
|
||
else:
|
||
open_rows.append(row)
|
||
|
||
# Scope switcher
|
||
switch_row = []
|
||
switch_row.append(InlineKeyboardButton(text=texts.t("OPEN_TICKETS", "🔴 Открытые"), callback_data="admin_tickets_scope_open"))
|
||
switch_row.append(InlineKeyboardButton(text=texts.t("CLOSED_TICKETS", "🟢 Закрытые"), callback_data="admin_tickets_scope_closed"))
|
||
keyboard.append(switch_row)
|
||
|
||
if open_rows and scope in ("all", "open"):
|
||
keyboard.append([
|
||
InlineKeyboardButton(
|
||
text=texts.t("ADMIN_CLOSE_ALL_OPEN_TICKETS", "🔒 Закрыть все открытые"),
|
||
callback_data="admin_tickets_close_all_open"
|
||
)
|
||
])
|
||
keyboard.append([InlineKeyboardButton(text=texts.t("OPEN_TICKETS_HEADER", "Открытые тикеты"), callback_data="noop")])
|
||
keyboard.extend(open_rows)
|
||
if closed_rows and scope in ("all", "closed"):
|
||
keyboard.append([InlineKeyboardButton(text=texts.t("CLOSED_TICKETS_HEADER", "Закрытые тикеты"), callback_data="noop")])
|
||
keyboard.extend(closed_rows)
|
||
|
||
# Пагинация
|
||
if total_pages > 1:
|
||
nav_row = []
|
||
|
||
if current_page > 1:
|
||
nav_row.append(
|
||
InlineKeyboardButton(
|
||
text=texts.t("PAGINATION_PREV", "⬅️"),
|
||
callback_data=f"admin_tickets_page_{scope}_{current_page - 1}"
|
||
)
|
||
)
|
||
|
||
nav_row.append(
|
||
InlineKeyboardButton(
|
||
text=f"{current_page}/{total_pages}",
|
||
callback_data="current_page"
|
||
)
|
||
)
|
||
|
||
if current_page < total_pages:
|
||
nav_row.append(
|
||
InlineKeyboardButton(
|
||
text=texts.t("PAGINATION_NEXT", "➡️"),
|
||
callback_data=f"admin_tickets_page_{scope}_{current_page + 1}"
|
||
)
|
||
)
|
||
|
||
keyboard.append(nav_row)
|
||
|
||
keyboard.append([
|
||
InlineKeyboardButton(text=texts.BACK, callback_data=back_callback)
|
||
])
|
||
|
||
return InlineKeyboardMarkup(inline_keyboard=keyboard)
|
||
|
||
|
||
def get_admin_ticket_view_keyboard(
|
||
ticket_id: int,
|
||
is_closed: bool = False,
|
||
language: str = DEFAULT_LANGUAGE,
|
||
*,
|
||
is_user_blocked: bool = False
|
||
) -> InlineKeyboardMarkup:
|
||
texts = get_texts(language)
|
||
keyboard = []
|
||
|
||
if not is_closed:
|
||
keyboard.append([
|
||
InlineKeyboardButton(
|
||
text=texts.t("REPLY_TO_TICKET", "💬 Ответить"),
|
||
callback_data=f"admin_reply_ticket_{ticket_id}"
|
||
)
|
||
])
|
||
|
||
if not is_closed:
|
||
keyboard.append([
|
||
InlineKeyboardButton(
|
||
text=texts.t("CLOSE_TICKET", "🔒 Закрыть тикет"),
|
||
callback_data=f"admin_close_ticket_{ticket_id}"
|
||
)
|
||
])
|
||
|
||
# Блок-контролы: когда не заблокирован — показать два варианта, когда заблокирован — только "Разблокировать"
|
||
if is_user_blocked:
|
||
keyboard.append([
|
||
InlineKeyboardButton(text=texts.t("UNBLOCK", "✅ Разблокировать"), callback_data=f"admin_unblock_user_ticket_{ticket_id}")
|
||
])
|
||
else:
|
||
keyboard.append([
|
||
InlineKeyboardButton(text=texts.t("BLOCK_FOREVER", "🚫 Заблокировать"), callback_data=f"admin_block_user_perm_ticket_{ticket_id}"),
|
||
InlineKeyboardButton(text=texts.t("BLOCK_BY_TIME", "⏳ Блок по времени"), callback_data=f"admin_block_user_ticket_{ticket_id}")
|
||
])
|
||
|
||
keyboard.append([
|
||
InlineKeyboardButton(text=texts.BACK, callback_data="admin_tickets")
|
||
])
|
||
|
||
return InlineKeyboardMarkup(inline_keyboard=keyboard)
|
||
|
||
|
||
def get_admin_ticket_reply_cancel_keyboard(language: str = DEFAULT_LANGUAGE) -> InlineKeyboardMarkup:
|
||
texts = get_texts(language)
|
||
return InlineKeyboardMarkup(inline_keyboard=[
|
||
[
|
||
InlineKeyboardButton(
|
||
text=texts.t("CANCEL_REPLY", "❌ Отменить ответ"),
|
||
callback_data="cancel_admin_ticket_reply"
|
||
)
|
||
]
|
||
])
|