981 lines
42 KiB
Python
981 lines
42 KiB
Python
from __future__ import annotations
|
||
|
||
from dataclasses import dataclass
|
||
from sqlalchemy import select
|
||
from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
|
||
|
||
from app.config import PAYMENT_PRODUCT_PLAN_SPECS, PaymentPlanSettings, Settings
|
||
from app.db.base import utcnow
|
||
from app.db.models import BotSetting
|
||
|
||
|
||
@dataclass(frozen=True, slots=True)
|
||
class BotConfigFieldSpec:
|
||
key: str
|
||
label: str
|
||
section: str
|
||
prompt: str
|
||
description: str
|
||
placeholder: str = ""
|
||
is_secret_like: bool = False
|
||
|
||
|
||
@dataclass(slots=True)
|
||
class BotConfigSnapshot:
|
||
bot_brand_name: str
|
||
bot_public_username: str
|
||
bot_support_url: str
|
||
bot_terms_url: str
|
||
bot_support_ticket_link: str
|
||
payment_review_link: str
|
||
bot_start_image_enabled: bool
|
||
bot_start_image_path: str
|
||
referral_enabled: bool
|
||
referral_discount_percent: int
|
||
referral_bonus_days: int
|
||
payment_plans_raw: str
|
||
payment_product_plans_raw: str
|
||
payment_transfer_text: str
|
||
payment_support_text: str
|
||
payment_plan_traffic_limit_gb: int
|
||
payment_plan_traffic_reset_period: str
|
||
payment_internal_squad_uuids_raw: str
|
||
payment_vpn_squad_uuids_raw: str
|
||
payment_white_squad_uuids_raw: str
|
||
payment_external_squad_uuid: str
|
||
payment_username_prefix: str
|
||
payment_user_tag: str
|
||
notification_enabled: bool = True
|
||
notification_days_before: str = "1,3"
|
||
notification_check_interval_hours: int = 6
|
||
fallback_support_ticket_chat_id: int | None = None
|
||
fallback_support_ticket_thread_id: int | None = None
|
||
fallback_payment_review_chat_id: int | None = None
|
||
fallback_payment_review_thread_id: int | None = None
|
||
|
||
@property
|
||
def bot_public_username_normalized(self) -> str:
|
||
return self.bot_public_username.strip().removeprefix("@")
|
||
|
||
@property
|
||
def payment_external_squad_uuid_normalized(self) -> str | None:
|
||
value = self.payment_external_squad_uuid.strip()
|
||
return value or None
|
||
|
||
@property
|
||
def payment_username_prefix_normalized(self) -> str:
|
||
normalized = "".join(
|
||
ch for ch in self.payment_username_prefix.strip() if ch.isalnum() or ch in "_-"
|
||
)
|
||
return normalized[:12] or "Oreol"
|
||
|
||
@property
|
||
def payment_user_tag_normalized(self) -> str | None:
|
||
normalized = "".join(
|
||
ch for ch in self.payment_user_tag.strip().upper() if ch.isalnum() or ch == "_"
|
||
)
|
||
return normalized[:16] or None
|
||
|
||
@property
|
||
def payment_internal_squad_uuids(self) -> list[str]:
|
||
return self._parse_csv_list(self.payment_internal_squad_uuids_raw)
|
||
|
||
@property
|
||
def payment_vpn_squad_uuids(self) -> list[str]:
|
||
return self._parse_csv_list(self.payment_vpn_squad_uuids_raw)
|
||
|
||
@property
|
||
def payment_white_squad_uuids(self) -> list[str]:
|
||
return self._parse_csv_list(self.payment_white_squad_uuids_raw)
|
||
|
||
@property
|
||
def notification_days_list(self) -> list[int]:
|
||
values: list[int] = []
|
||
for raw_part in self.notification_days_before.split(","):
|
||
part = raw_part.strip()
|
||
if part.isdigit():
|
||
day = int(part)
|
||
if day > 0:
|
||
values.append(day)
|
||
return sorted(set(values), reverse=True) if values else [1, 3]
|
||
|
||
@property
|
||
def payment_plans(self) -> list[PaymentPlanSettings]:
|
||
product_plans = self._parse_product_plans(
|
||
self.payment_product_plans_raw,
|
||
default_days=30,
|
||
)
|
||
if product_plans:
|
||
return product_plans
|
||
|
||
values: list[PaymentPlanSettings] = []
|
||
for raw_part in self.payment_plans_raw.split(","):
|
||
part = raw_part.strip()
|
||
if not part:
|
||
continue
|
||
|
||
fragments = [fragment.strip() for fragment in part.split(":")]
|
||
if len(fragments) != 2 or not fragments[0].isdigit() or not fragments[1].isdigit():
|
||
continue
|
||
|
||
days = int(fragments[0])
|
||
amount_rub = int(fragments[1])
|
||
if days <= 0 or amount_rub <= 0:
|
||
continue
|
||
|
||
values.append(
|
||
PaymentPlanSettings(
|
||
code=f"{days}d",
|
||
days=days,
|
||
amount_rub=amount_rub,
|
||
)
|
||
)
|
||
|
||
return sorted(values, key=lambda item: item.days)
|
||
|
||
@staticmethod
|
||
def _parse_csv_list(raw_value: str) -> list[str]:
|
||
values: list[str] = []
|
||
for raw_part in raw_value.split(","):
|
||
part = raw_part.strip()
|
||
if part:
|
||
values.append(part)
|
||
return values
|
||
|
||
@staticmethod
|
||
def _parse_product_plans(
|
||
raw_value: str,
|
||
*,
|
||
default_days: int,
|
||
) -> list[PaymentPlanSettings]:
|
||
values: list[PaymentPlanSettings] = []
|
||
seen_codes: set[str] = set()
|
||
|
||
for raw_part in raw_value.split(","):
|
||
part = raw_part.strip()
|
||
if not part:
|
||
continue
|
||
|
||
fragments = [fragment.strip() for fragment in part.split(":")]
|
||
|
||
# Legacy format: code:amount (2 fields)
|
||
if len(fragments) == 2:
|
||
code, raw_amount = fragments
|
||
pairs = [(str(default_days), raw_amount)]
|
||
# Standard format: code:days:amount (3 fields)
|
||
elif len(fragments) == 3:
|
||
code = fragments[0]
|
||
pairs = [(fragments[1], fragments[2])]
|
||
# Extended format: code:days1:amount1:days2:amount2:... (odd ≥ 5)
|
||
elif len(fragments) >= 5 and len(fragments) % 2 == 1:
|
||
code = fragments[0]
|
||
pairs = [
|
||
(fragments[i], fragments[i + 1])
|
||
for i in range(1, len(fragments), 2)
|
||
]
|
||
else:
|
||
continue
|
||
|
||
normalized_code = code.lower()
|
||
spec = PAYMENT_PRODUCT_PLAN_SPECS.get(normalized_code)
|
||
if spec is None or normalized_code in seen_codes:
|
||
continue
|
||
|
||
title, description, squad_groups = spec
|
||
use_duration_suffix = len(pairs) > 1
|
||
for raw_days, raw_amount in pairs:
|
||
if not raw_days.isdigit() or not raw_amount.isdigit():
|
||
continue
|
||
|
||
days = int(raw_days)
|
||
amount_rub = int(raw_amount)
|
||
if days <= 0 or amount_rub <= 0:
|
||
continue
|
||
|
||
plan_code = f"{normalized_code}_{days}" if use_duration_suffix else normalized_code
|
||
values.append(
|
||
PaymentPlanSettings(
|
||
code=plan_code,
|
||
days=days,
|
||
amount_rub=amount_rub,
|
||
title=title,
|
||
description=description,
|
||
squad_groups=squad_groups,
|
||
)
|
||
)
|
||
|
||
seen_codes.add(normalized_code)
|
||
|
||
return values
|
||
|
||
@staticmethod
|
||
def _compact_text(raw_value: str, *, max_length: int = 80) -> str:
|
||
normalized = " ".join(raw_value.split()).strip()
|
||
if not normalized:
|
||
return "-"
|
||
if len(normalized) <= max_length:
|
||
return normalized
|
||
return f"{normalized[: max_length - 3]}..."
|
||
|
||
@property
|
||
def support_ticket_chat_id(self) -> int | None:
|
||
parsed_chat_id, _ = Settings._parse_private_topic_link(self.bot_support_ticket_link)
|
||
return parsed_chat_id if parsed_chat_id is not None else self.fallback_support_ticket_chat_id
|
||
|
||
@property
|
||
def support_ticket_message_thread_id(self) -> int | None:
|
||
_, parsed_thread_id = Settings._parse_private_topic_link(self.bot_support_ticket_link)
|
||
return (
|
||
parsed_thread_id
|
||
if parsed_thread_id is not None
|
||
else self.fallback_support_ticket_thread_id
|
||
)
|
||
|
||
@property
|
||
def payment_review_chat_id(self) -> int | None:
|
||
parsed_chat_id, _ = Settings._parse_private_topic_link(self.payment_review_link)
|
||
return parsed_chat_id if parsed_chat_id is not None else self.fallback_payment_review_chat_id
|
||
|
||
@property
|
||
def payment_review_message_thread_id(self) -> int | None:
|
||
_, parsed_thread_id = Settings._parse_private_topic_link(self.payment_review_link)
|
||
return (
|
||
parsed_thread_id
|
||
if parsed_thread_id is not None
|
||
else self.fallback_payment_review_thread_id
|
||
)
|
||
|
||
|
||
class StaticBotConfigService:
|
||
def __init__(self, settings: Settings) -> None:
|
||
self._settings = settings
|
||
|
||
async def get_snapshot(self) -> BotConfigSnapshot:
|
||
return BotConfigSnapshot(
|
||
bot_brand_name=self._settings.bot_brand_name,
|
||
bot_public_username=self._settings.bot_public_username,
|
||
bot_support_url=self._settings.bot_support_url,
|
||
bot_terms_url=self._settings.bot_terms_url,
|
||
bot_support_ticket_link=self._settings.bot_support_ticket_link,
|
||
payment_review_link=self._settings.payment_review_link,
|
||
bot_start_image_enabled=self._settings.bot_start_image_enabled,
|
||
bot_start_image_path=self._settings.bot_start_image_path,
|
||
referral_enabled=True,
|
||
referral_discount_percent=self._settings.referral_discount_percent,
|
||
referral_bonus_days=self._settings.referral_bonus_days,
|
||
payment_plans_raw=self._settings.payment_plans_raw,
|
||
payment_product_plans_raw=self._settings.payment_product_plans_raw,
|
||
payment_transfer_text=self._settings.payment_transfer_text,
|
||
payment_support_text=self._settings.payment_support_text,
|
||
payment_plan_traffic_limit_gb=self._settings.payment_plan_traffic_limit_gb,
|
||
payment_plan_traffic_reset_period=self._settings.payment_plan_traffic_reset_period,
|
||
notification_enabled=True,
|
||
notification_days_before="1,3",
|
||
notification_check_interval_hours=6,
|
||
payment_internal_squad_uuids_raw=self._settings.payment_internal_squad_uuids_raw,
|
||
payment_vpn_squad_uuids_raw=self._settings.payment_vpn_squad_uuids_raw,
|
||
payment_white_squad_uuids_raw=self._settings.payment_white_squad_uuids_raw,
|
||
payment_external_squad_uuid=self._settings.payment_external_squad_uuid,
|
||
payment_username_prefix=self._settings.payment_username_prefix,
|
||
payment_user_tag=self._settings.payment_user_tag,
|
||
fallback_support_ticket_chat_id=self._settings.support_ticket_chat_id,
|
||
fallback_support_ticket_thread_id=self._settings.support_ticket_message_thread_id,
|
||
fallback_payment_review_chat_id=self._settings.payment_review_chat_id,
|
||
fallback_payment_review_thread_id=self._settings.payment_review_message_thread_id,
|
||
)
|
||
|
||
|
||
class BotConfigService(StaticBotConfigService):
|
||
FIELD_SPECS: dict[str, BotConfigFieldSpec] = {
|
||
"bot_brand_name": BotConfigFieldSpec(
|
||
key="bot_brand_name",
|
||
label="Название бренда",
|
||
section="brand",
|
||
prompt="Введите новое название бренда.",
|
||
description="Используется в главной панели и пользовательских сообщениях.",
|
||
placeholder="OREOL VPN",
|
||
),
|
||
"bot_public_username": BotConfigFieldSpec(
|
||
key="bot_public_username",
|
||
label="Username бота",
|
||
section="brand",
|
||
prompt="Введите username бота без @. Для очистки отправьте `-`.",
|
||
description="Нужен для генерации реферальных ссылок.",
|
||
placeholder="oreol_vpn_bot",
|
||
),
|
||
"bot_start_image_enabled": BotConfigFieldSpec(
|
||
key="bot_start_image_enabled",
|
||
label="Стартовая картинка",
|
||
section="brand",
|
||
prompt="Введите `on` или `off`.",
|
||
description="Включает или выключает бренд-картинку в панели и выдаче доступа.",
|
||
placeholder="on",
|
||
),
|
||
"bot_start_image_path": BotConfigFieldSpec(
|
||
key="bot_start_image_path",
|
||
label="Путь к картинке",
|
||
section="brand",
|
||
prompt="Введите путь к изображению. Для очистки отправьте `-`.",
|
||
description="Можно указать относительный путь от корня проекта.",
|
||
placeholder="assets/main.png",
|
||
),
|
||
"payment_plans_raw": BotConfigFieldSpec(
|
||
key="payment_plans_raw",
|
||
label="Тарифы и цены",
|
||
section="pricing",
|
||
prompt="Введите тарифы в формате `30:250,180:600,365:1000`.",
|
||
description="Каждая пара - это `дни:цена_в_рублях`.",
|
||
placeholder="30:250,180:600,365:1000",
|
||
),
|
||
"payment_product_plans_raw": BotConfigFieldSpec(
|
||
key="payment_product_plans_raw",
|
||
label="Типы подписок и цены",
|
||
section="pricing",
|
||
prompt=(
|
||
"Введите типы подписок в формате "
|
||
"`vpn_white:30:450:180:2200:365:4000,white:30:250,vpn:30:200`.\n"
|
||
"Каждый продукт: `код:дни1:цена1:дни2:цена2:...`"
|
||
),
|
||
description=(
|
||
"Если заполнено, заменяет обычные PAYMENT_PLANS. "
|
||
"Коды: vpn_white, white, vpn. Формат: `код:дни1:цена1[:дни2:цена2:...]`."
|
||
),
|
||
placeholder="vpn_white:30:450:180:2200:365:4000,white:30:250:180:1200,vpn:30:200:180:1000",
|
||
),
|
||
"payment_plan_traffic_limit_gb": BotConfigFieldSpec(
|
||
key="payment_plan_traffic_limit_gb",
|
||
label="Лимит трафика, GB",
|
||
section="pricing",
|
||
prompt="Введите лимит трафика в гигабайтах. `0` = безлимит.",
|
||
description="Применяется к тарифам, создаваемым ботом.",
|
||
placeholder="0",
|
||
),
|
||
"payment_plan_traffic_reset_period": BotConfigFieldSpec(
|
||
key="payment_plan_traffic_reset_period",
|
||
label="Стратегия сброса трафика",
|
||
section="pricing",
|
||
prompt="Введите стратегию, например `NO_RESET`.",
|
||
description="Значение передаётся в Remnawave.",
|
||
placeholder="NO_RESET",
|
||
),
|
||
"referral_enabled": BotConfigFieldSpec(
|
||
key="referral_enabled",
|
||
label="Реферальная система",
|
||
section="referral",
|
||
prompt="Введите `on` или `off`.",
|
||
description="Включает или выключает ввод рефкода и начисление реферальных бонусов.",
|
||
placeholder="on",
|
||
),
|
||
"referral_discount_percent": BotConfigFieldSpec(
|
||
key="referral_discount_percent",
|
||
label="Скидка по рефкоду, %",
|
||
section="referral",
|
||
prompt="Введите размер скидки в процентах от 0 до 100.",
|
||
description="Применяется к покупателю перед оплатой.",
|
||
placeholder="5",
|
||
),
|
||
"referral_bonus_days": BotConfigFieldSpec(
|
||
key="referral_bonus_days",
|
||
label="Бонус рефереру, дней",
|
||
section="referral",
|
||
prompt="Введите количество бонусных дней. `0` отключает бонус.",
|
||
description="Начисляется после подтверждённой оплаты по рефкоду.",
|
||
placeholder="7",
|
||
),
|
||
"bot_support_url": BotConfigFieldSpec(
|
||
key="bot_support_url",
|
||
label="Ссылка на поддержку",
|
||
section="links",
|
||
prompt="Введите URL поддержки. Для очистки отправьте `-`.",
|
||
description="Кнопка быстрой связи с поддержкой в пользовательской панели.",
|
||
placeholder="https://t.me/your_support_account",
|
||
),
|
||
"bot_terms_url": BotConfigFieldSpec(
|
||
key="bot_terms_url",
|
||
label="Ссылка на Terms",
|
||
section="links",
|
||
prompt="Введите URL правил использования. Для очистки отправьте `-`.",
|
||
description="Открывается из раздела условий использования.",
|
||
placeholder="https://example.com/terms",
|
||
),
|
||
"bot_support_ticket_link": BotConfigFieldSpec(
|
||
key="bot_support_ticket_link",
|
||
label="Ссылка на чат тикетов",
|
||
section="links",
|
||
prompt="Введите приватную ссылку на чат/топик тикетов. Для очистки отправьте `-`.",
|
||
description="Формат: `https://t.me/c/<chat>/<topic>/<message>`.",
|
||
placeholder="https://t.me/c/1234567890/2/3",
|
||
),
|
||
"payment_review_link": BotConfigFieldSpec(
|
||
key="payment_review_link",
|
||
label="Ссылка на очередь оплат",
|
||
section="links",
|
||
prompt="Введите приватную ссылку на чат/топик проверки оплат. Для очистки отправьте `-`.",
|
||
description="Формат: `https://t.me/c/<chat>/<topic>/<message>`.",
|
||
placeholder="https://t.me/c/1234567890/56/57",
|
||
),
|
||
"payment_transfer_text": BotConfigFieldSpec(
|
||
key="payment_transfer_text",
|
||
label="Инструкция по оплате",
|
||
section="texts",
|
||
prompt="Введите текст с реквизитами или инструкцией перевода.",
|
||
description="Показывается пользователю после выбора тарифа.",
|
||
placeholder="Карта 0000 0000 0000 0000; банк OREOL; получатель OREOL VPN",
|
||
),
|
||
"payment_support_text": BotConfigFieldSpec(
|
||
key="payment_support_text",
|
||
label="Текст поддержки по оплате",
|
||
section="texts",
|
||
prompt="Введите текст, который бот покажет при проблемах с оплатой.",
|
||
description="Используется при отклонении оплаты и ошибках выдачи доступа.",
|
||
placeholder="Если оплата прошла, но доступ не выдался, напишите в поддержку.",
|
||
),
|
||
"payment_internal_squad_uuids_raw": BotConfigFieldSpec(
|
||
key="payment_internal_squad_uuids_raw",
|
||
label="UUID внутренних групп",
|
||
section="provisioning",
|
||
prompt="Введите UUID внутренних групп через запятую.",
|
||
description="Эти группы назначаются пользователю в Remnawave.",
|
||
placeholder="11111111-1111-1111-1111-111111111111",
|
||
),
|
||
"payment_vpn_squad_uuids_raw": BotConfigFieldSpec(
|
||
key="payment_vpn_squad_uuids_raw",
|
||
label="UUID VPN-групп",
|
||
section="provisioning",
|
||
prompt="Введите UUID squad для тарифа VPN через запятую.",
|
||
description="Назначается тарифам `vpn` и `vpn_white`.",
|
||
placeholder="11111111-1111-1111-1111-111111111111",
|
||
),
|
||
"payment_white_squad_uuids_raw": BotConfigFieldSpec(
|
||
key="payment_white_squad_uuids_raw",
|
||
label="UUID групп белых списков",
|
||
section="provisioning",
|
||
prompt="Введите UUID squad для белых списков через запятую.",
|
||
description="Назначается тарифам `white` и `vpn_white`.",
|
||
placeholder="22222222-2222-2222-2222-222222222222",
|
||
),
|
||
"payment_external_squad_uuid": BotConfigFieldSpec(
|
||
key="payment_external_squad_uuid",
|
||
label="UUID внешней группы",
|
||
section="provisioning",
|
||
prompt="Введите UUID внешней группы. Для очистки отправьте `-`.",
|
||
description="Необязательный внешний squad для новых пользователей.",
|
||
placeholder="11111111-1111-1111-1111-111111111111",
|
||
),
|
||
"payment_username_prefix": BotConfigFieldSpec(
|
||
key="payment_username_prefix",
|
||
label="Префикс логина",
|
||
section="provisioning",
|
||
prompt="Введите префикс логина для новых пользователей Remnawave.",
|
||
description="Итоговый логин строится как `<prefix>-<telegram_id>-<name>`.",
|
||
placeholder="Oreol",
|
||
),
|
||
"payment_user_tag": BotConfigFieldSpec(
|
||
key="payment_user_tag",
|
||
label="Tag пользователей",
|
||
section="provisioning",
|
||
prompt="Введите tag для создаваемых пользователей. Для очистки отправьте `-`.",
|
||
description="Опциональный tag в Remnawave.",
|
||
placeholder="BOT",
|
||
),
|
||
"notification_enabled": BotConfigFieldSpec(
|
||
key="notification_enabled",
|
||
label="Уведомления об истечении",
|
||
section="notifications",
|
||
prompt="Введите `on` или `off`.",
|
||
description="Включает или выключает уведомления о скором истечении подписки.",
|
||
placeholder="on",
|
||
),
|
||
"notification_days_before": BotConfigFieldSpec(
|
||
key="notification_days_before",
|
||
label="Дни до истечения",
|
||
section="notifications",
|
||
prompt="Введите дни через запятую, например `1,3`.",
|
||
description="За сколько дней до истечения отправлять уведомления.",
|
||
placeholder="1,3",
|
||
),
|
||
"notification_check_interval_hours": BotConfigFieldSpec(
|
||
key="notification_check_interval_hours",
|
||
label="Интервал проверки, ч",
|
||
section="notifications",
|
||
prompt="Введите интервал проверки в часах.",
|
||
description="Как часто бот проверяет подписки на истечение.",
|
||
placeholder="6",
|
||
),
|
||
}
|
||
|
||
SECTION_LABELS: dict[str, str] = {
|
||
"brand": "Бренд",
|
||
"pricing": "Тарифы",
|
||
"referral": "Рефералка",
|
||
"links": "Ссылки",
|
||
"texts": "Тексты",
|
||
"provisioning": "Provisioning",
|
||
"notifications": "Уведомления",
|
||
}
|
||
|
||
def __init__(
|
||
self,
|
||
*,
|
||
settings: Settings,
|
||
session_factory: async_sessionmaker[AsyncSession],
|
||
) -> None:
|
||
super().__init__(settings)
|
||
self._session_factory = session_factory
|
||
|
||
async def get_snapshot(self) -> BotConfigSnapshot:
|
||
overrides = await self._get_overrides()
|
||
|
||
return BotConfigSnapshot(
|
||
bot_brand_name=str(overrides.get("bot_brand_name", self._settings.bot_brand_name)),
|
||
bot_public_username=str(overrides.get("bot_public_username", self._settings.bot_public_username)),
|
||
bot_support_url=str(overrides.get("bot_support_url", self._settings.bot_support_url)),
|
||
bot_terms_url=str(overrides.get("bot_terms_url", self._settings.bot_terms_url)),
|
||
bot_support_ticket_link=str(overrides.get("bot_support_ticket_link", self._settings.bot_support_ticket_link)),
|
||
payment_review_link=str(overrides.get("payment_review_link", self._settings.payment_review_link)),
|
||
bot_start_image_enabled=self._parse_bool(
|
||
overrides.get("bot_start_image_enabled"),
|
||
default=self._settings.bot_start_image_enabled,
|
||
),
|
||
bot_start_image_path=str(overrides.get("bot_start_image_path", self._settings.bot_start_image_path)),
|
||
referral_enabled=self._parse_bool(
|
||
overrides.get("referral_enabled"),
|
||
default=True,
|
||
),
|
||
referral_discount_percent=self._parse_int(
|
||
overrides.get("referral_discount_percent"),
|
||
default=self._settings.referral_discount_percent,
|
||
),
|
||
referral_bonus_days=self._parse_int(
|
||
overrides.get("referral_bonus_days"),
|
||
default=self._settings.referral_bonus_days,
|
||
),
|
||
payment_plans_raw=str(overrides.get("payment_plans_raw", self._settings.payment_plans_raw)),
|
||
payment_product_plans_raw=str(
|
||
overrides.get(
|
||
"payment_product_plans_raw",
|
||
self._settings.payment_product_plans_raw,
|
||
)
|
||
),
|
||
payment_transfer_text=str(overrides.get("payment_transfer_text", self._settings.payment_transfer_text)),
|
||
payment_support_text=str(overrides.get("payment_support_text", self._settings.payment_support_text)),
|
||
payment_plan_traffic_limit_gb=self._parse_int(
|
||
overrides.get("payment_plan_traffic_limit_gb"),
|
||
default=self._settings.payment_plan_traffic_limit_gb,
|
||
),
|
||
payment_plan_traffic_reset_period=str(
|
||
overrides.get(
|
||
"payment_plan_traffic_reset_period",
|
||
self._settings.payment_plan_traffic_reset_period,
|
||
)
|
||
),
|
||
payment_internal_squad_uuids_raw=str(
|
||
overrides.get(
|
||
"payment_internal_squad_uuids_raw",
|
||
self._settings.payment_internal_squad_uuids_raw,
|
||
)
|
||
),
|
||
payment_vpn_squad_uuids_raw=str(
|
||
overrides.get(
|
||
"payment_vpn_squad_uuids_raw",
|
||
self._settings.payment_vpn_squad_uuids_raw,
|
||
)
|
||
),
|
||
payment_white_squad_uuids_raw=str(
|
||
overrides.get(
|
||
"payment_white_squad_uuids_raw",
|
||
self._settings.payment_white_squad_uuids_raw,
|
||
)
|
||
),
|
||
payment_external_squad_uuid=str(
|
||
overrides.get(
|
||
"payment_external_squad_uuid",
|
||
self._settings.payment_external_squad_uuid,
|
||
)
|
||
),
|
||
payment_username_prefix=str(
|
||
overrides.get("payment_username_prefix", self._settings.payment_username_prefix)
|
||
),
|
||
payment_user_tag=str(overrides.get("payment_user_tag", self._settings.payment_user_tag)),
|
||
notification_enabled=self._parse_bool(
|
||
overrides.get("notification_enabled"),
|
||
default=True,
|
||
),
|
||
notification_days_before=str(overrides.get("notification_days_before", "1,3")),
|
||
notification_check_interval_hours=self._parse_int(
|
||
overrides.get("notification_check_interval_hours"),
|
||
default=6,
|
||
),
|
||
fallback_support_ticket_chat_id=self._settings.support_ticket_chat_id,
|
||
fallback_support_ticket_thread_id=self._settings.support_ticket_message_thread_id,
|
||
fallback_payment_review_chat_id=self._settings.payment_review_chat_id,
|
||
fallback_payment_review_thread_id=self._settings.payment_review_message_thread_id,
|
||
)
|
||
|
||
async def update_setting(
|
||
self,
|
||
*,
|
||
key: str,
|
||
raw_value: str,
|
||
updated_by_telegram_id: int,
|
||
) -> str:
|
||
spec = self.FIELD_SPECS.get(key)
|
||
if spec is None:
|
||
raise ValueError("Неизвестная настройка.")
|
||
|
||
normalized_value = self._normalize_value(key, raw_value)
|
||
|
||
async with self._session_factory() as session:
|
||
record = await session.scalar(
|
||
select(BotSetting).where(BotSetting.key == key)
|
||
)
|
||
if record is None:
|
||
record = BotSetting(key=key)
|
||
session.add(record)
|
||
|
||
record.value = normalized_value
|
||
record.updated_by_telegram_id = updated_by_telegram_id
|
||
record.updated_at = utcnow()
|
||
await session.commit()
|
||
|
||
return normalized_value
|
||
|
||
@classmethod
|
||
def get_spec(cls, key: str) -> BotConfigFieldSpec | None:
|
||
return cls.FIELD_SPECS.get(key)
|
||
|
||
@classmethod
|
||
def get_specs_for_section(cls, section: str) -> list[BotConfigFieldSpec]:
|
||
return [spec for spec in cls.FIELD_SPECS.values() if spec.section == section]
|
||
|
||
@classmethod
|
||
def get_sections(cls) -> list[tuple[str, str]]:
|
||
return list(cls.SECTION_LABELS.items())
|
||
|
||
@classmethod
|
||
def get_section_label(cls, section: str) -> str:
|
||
return cls.SECTION_LABELS.get(section, section)
|
||
|
||
@classmethod
|
||
def format_value(cls, *, snapshot: BotConfigSnapshot, key: str) -> str:
|
||
value = getattr(snapshot, key, "")
|
||
|
||
if key in {"bot_start_image_enabled", "referral_enabled", "notification_enabled"}:
|
||
return "on" if bool(value) else "off"
|
||
|
||
if key == "bot_public_username":
|
||
normalized = snapshot.bot_public_username_normalized
|
||
return f"@{normalized}" if normalized else "-"
|
||
|
||
if key in {
|
||
"bot_support_url",
|
||
"bot_terms_url",
|
||
"bot_support_ticket_link",
|
||
"payment_review_link",
|
||
"bot_start_image_path",
|
||
"payment_product_plans_raw",
|
||
"payment_vpn_squad_uuids_raw",
|
||
"payment_white_squad_uuids_raw",
|
||
"payment_external_squad_uuid",
|
||
"payment_user_tag",
|
||
"payment_username_prefix",
|
||
"payment_internal_squad_uuids_raw",
|
||
"payment_vpn_squad_uuids_raw",
|
||
"payment_white_squad_uuids_raw",
|
||
"payment_plans_raw",
|
||
"payment_product_plans_raw",
|
||
"payment_plan_traffic_reset_period",
|
||
"bot_brand_name",
|
||
"notification_days_before",
|
||
}:
|
||
return cls._compact_text(str(value))
|
||
|
||
if key == "payment_plan_traffic_limit_gb":
|
||
amount = int(value or 0)
|
||
return "0 GB (unlimited)" if amount <= 0 else f"{amount} GB"
|
||
|
||
if key == "referral_discount_percent":
|
||
return f"{max(int(value or 0), 0)}%"
|
||
|
||
if key == "referral_bonus_days":
|
||
return f"{max(int(value or 0), 0)} days"
|
||
|
||
if key == "notification_check_interval_hours":
|
||
return f"{max(int(value or 6), 1)} ч"
|
||
|
||
if key in {"payment_transfer_text", "payment_support_text"}:
|
||
return cls._compact_text(str(value), max_length=120)
|
||
|
||
return cls._compact_text(str(value))
|
||
|
||
@staticmethod
|
||
def _compact_text(raw_value: str, *, max_length: int = 80) -> str:
|
||
normalized = " ".join(raw_value.split()).strip()
|
||
if not normalized:
|
||
return "-"
|
||
if len(normalized) <= max_length:
|
||
return normalized
|
||
return f"{normalized[: max_length - 3]}..."
|
||
|
||
async def _get_overrides(self) -> dict[str, str]:
|
||
async with self._session_factory() as session:
|
||
rows = await session.execute(select(BotSetting))
|
||
return {
|
||
row.key: row.value
|
||
for row in rows.scalars().all()
|
||
}
|
||
|
||
def _normalize_value(self, key: str, raw_value: str) -> str:
|
||
value = raw_value.strip()
|
||
if key in {
|
||
"bot_support_url",
|
||
"bot_terms_url",
|
||
"bot_support_ticket_link",
|
||
"payment_review_link",
|
||
"bot_start_image_path",
|
||
"payment_external_squad_uuid",
|
||
"payment_user_tag",
|
||
"bot_public_username",
|
||
} and value == "-":
|
||
return ""
|
||
|
||
if key == "bot_brand_name":
|
||
if not value:
|
||
raise ValueError("Название бренда не может быть пустым.")
|
||
return value[:80]
|
||
|
||
if key == "bot_public_username":
|
||
return value.removeprefix("@")
|
||
|
||
if key == "bot_start_image_enabled":
|
||
return "true" if self._parse_bool_token(value) else "false"
|
||
|
||
if key == "bot_start_image_path":
|
||
return value
|
||
|
||
if key == "payment_plans_raw":
|
||
plans = self._parse_payment_plans(value)
|
||
return ",".join(f"{plan.days}:{plan.amount_rub}" for plan in plans)
|
||
|
||
if key == "payment_product_plans_raw":
|
||
plans = self._parse_product_plans(value)
|
||
# Re-serialize: group plans by product code prefix
|
||
product_groups: dict[str, list[PaymentPlanSettings]] = {}
|
||
for plan in plans:
|
||
# Extract product code from plan code (e.g. "vpn_white" from "vpn_white_30")
|
||
product_code = "_".join(plan.code.split("_")[:-1]) if "_" in plan.code and plan.code.split("_")[-1].isdigit() else plan.code
|
||
product_groups.setdefault(product_code, []).append(plan)
|
||
parts = []
|
||
for product_code, group_plans in product_groups.items():
|
||
pairs = ":".join(f"{p.days}:{p.amount_rub}" for p in group_plans)
|
||
parts.append(f"{product_code}:{pairs}")
|
||
return ",".join(parts)
|
||
|
||
if key == "payment_plan_traffic_limit_gb":
|
||
amount = self._parse_non_negative_int(value, "Лимит трафика")
|
||
return str(amount)
|
||
|
||
if key == "payment_plan_traffic_reset_period":
|
||
if not value:
|
||
raise ValueError("Стратегия сброса трафика не может быть пустой.")
|
||
return value.upper()
|
||
|
||
if key == "referral_enabled":
|
||
return "true" if self._parse_bool_token(value) else "false"
|
||
|
||
if key == "referral_discount_percent":
|
||
amount = self._parse_non_negative_int(value, "Размер скидки")
|
||
if amount > 100:
|
||
raise ValueError("Размер скидки должен быть в диапазоне от 0 до 100.")
|
||
return str(amount)
|
||
|
||
if key == "referral_bonus_days":
|
||
amount = self._parse_non_negative_int(value, "Размер бонуса")
|
||
return str(amount)
|
||
|
||
if key in {
|
||
"bot_support_url",
|
||
"bot_terms_url",
|
||
"bot_support_ticket_link",
|
||
"payment_review_link",
|
||
}:
|
||
return value
|
||
|
||
if key in {"payment_transfer_text", "payment_support_text"}:
|
||
if not value:
|
||
raise ValueError("Текст не может быть пустым.")
|
||
return value[:4000]
|
||
|
||
if key == "payment_internal_squad_uuids_raw":
|
||
normalized_parts = [part.strip() for part in value.split(",") if part.strip()]
|
||
if not normalized_parts:
|
||
raise ValueError("Нужно указать хотя бы один UUID внутренней группы.")
|
||
return ",".join(normalized_parts)
|
||
|
||
if key in {"payment_vpn_squad_uuids_raw", "payment_white_squad_uuids_raw"}:
|
||
normalized_parts = [part.strip() for part in value.split(",") if part.strip()]
|
||
if not normalized_parts:
|
||
raise ValueError("Нужно указать хотя бы один UUID группы.")
|
||
return ",".join(normalized_parts)
|
||
|
||
if key == "payment_external_squad_uuid":
|
||
return value
|
||
|
||
if key == "payment_username_prefix":
|
||
if not value:
|
||
raise ValueError("Префикс логина не может быть пустым.")
|
||
return value[:32]
|
||
|
||
if key == "payment_user_tag":
|
||
return value
|
||
|
||
if key == "notification_enabled":
|
||
return "true" if self._parse_bool_token(value) else "false"
|
||
|
||
if key == "notification_days_before":
|
||
parts = [p.strip() for p in value.split(",") if p.strip().isdigit() and int(p.strip()) > 0]
|
||
if not parts:
|
||
raise ValueError("Нужно указать хотя бы один день, например `1,3`.")
|
||
return ",".join(parts)
|
||
|
||
if key == "notification_check_interval_hours":
|
||
amount = self._parse_non_negative_int(value, "Интервал проверки")
|
||
if amount < 1:
|
||
raise ValueError("Интервал должен быть не менее 1 часа.")
|
||
return str(amount)
|
||
|
||
raise ValueError("Настройка пока не поддерживается.")
|
||
|
||
@staticmethod
|
||
def _parse_int(raw_value: object | None, *, default: int) -> int:
|
||
try:
|
||
return int(str(raw_value).strip())
|
||
except (TypeError, ValueError):
|
||
return default
|
||
|
||
@staticmethod
|
||
def _parse_bool(raw_value: object | None, *, default: bool) -> bool:
|
||
if raw_value is None:
|
||
return default
|
||
try:
|
||
return BotConfigService._parse_bool_token(str(raw_value))
|
||
except ValueError:
|
||
return default
|
||
|
||
@staticmethod
|
||
def _parse_bool_token(raw_value: str) -> bool:
|
||
normalized = raw_value.strip().lower()
|
||
if normalized in {"1", "true", "on", "yes", "y", "да", "вкл"}:
|
||
return True
|
||
if normalized in {"0", "false", "off", "no", "n", "нет", "выкл"}:
|
||
return False
|
||
raise ValueError("Введите `on` или `off`.")
|
||
|
||
@staticmethod
|
||
def _parse_non_negative_int(raw_value: str, label: str) -> int:
|
||
if not raw_value.strip().isdigit():
|
||
raise ValueError(f"{label} должен быть целым неотрицательным числом.")
|
||
return int(raw_value.strip())
|
||
|
||
@staticmethod
|
||
def _parse_product_plans(raw_value: str) -> list[PaymentPlanSettings]:
|
||
values: list[PaymentPlanSettings] = []
|
||
seen_codes: set[str] = set()
|
||
|
||
for raw_part in raw_value.split(","):
|
||
part = raw_part.strip()
|
||
if not part:
|
||
continue
|
||
|
||
fragments = [fragment.strip() for fragment in part.split(":")]
|
||
|
||
# Legacy: code:amount (2 fields)
|
||
if len(fragments) == 2:
|
||
code, raw_amount = fragments
|
||
pairs = [("30", raw_amount)]
|
||
# Standard: code:days:amount (3 fields)
|
||
elif len(fragments) == 3:
|
||
code = fragments[0]
|
||
pairs = [(fragments[1], fragments[2])]
|
||
# Extended: code:days1:amount1:days2:amount2:... (odd ≥ 5)
|
||
elif len(fragments) >= 5 and len(fragments) % 2 == 1:
|
||
code = fragments[0]
|
||
pairs = [
|
||
(fragments[i], fragments[i + 1])
|
||
for i in range(1, len(fragments), 2)
|
||
]
|
||
else:
|
||
raise ValueError(
|
||
"Типы подписок: `код:дни1:цена1[:дни2:цена2:...]`, "
|
||
"например `vpn_white:30:450:180:2200,white:30:250,vpn:30:200`."
|
||
)
|
||
|
||
normalized_code = code.lower()
|
||
spec = PAYMENT_PRODUCT_PLAN_SPECS.get(normalized_code)
|
||
if spec is None:
|
||
raise ValueError("Неизвестный код подписки. Доступны: vpn_white, white, vpn.")
|
||
if normalized_code in seen_codes:
|
||
raise ValueError("Коды подписок не должны повторяться.")
|
||
|
||
title, description, squad_groups = spec
|
||
use_duration_suffix = len(pairs) > 1
|
||
for raw_days, raw_amount in pairs:
|
||
if not raw_days.isdigit() or not raw_amount.isdigit():
|
||
raise ValueError("Дни и цена должны быть целыми положительными числами.")
|
||
|
||
days = int(raw_days)
|
||
amount_rub = int(raw_amount)
|
||
if days <= 0 or amount_rub <= 0:
|
||
raise ValueError("У подписок дни и цена должны быть больше нуля.")
|
||
|
||
plan_code = f"{normalized_code}_{days}" if use_duration_suffix else normalized_code
|
||
values.append(
|
||
PaymentPlanSettings(
|
||
code=plan_code,
|
||
days=days,
|
||
amount_rub=amount_rub,
|
||
title=title,
|
||
description=description,
|
||
squad_groups=squad_groups,
|
||
)
|
||
)
|
||
|
||
seen_codes.add(normalized_code)
|
||
|
||
if not values:
|
||
raise ValueError("Нужно указать хотя бы один тип подписки.")
|
||
|
||
return values
|
||
|
||
@staticmethod
|
||
def _parse_payment_plans(raw_value: str) -> list[PaymentPlanSettings]:
|
||
values: list[PaymentPlanSettings] = []
|
||
for raw_part in raw_value.split(","):
|
||
part = raw_part.strip()
|
||
if not part:
|
||
continue
|
||
|
||
fragments = [fragment.strip() for fragment in part.split(":")]
|
||
if len(fragments) != 2 or not fragments[0].isdigit() or not fragments[1].isdigit():
|
||
raise ValueError(
|
||
"Тарифы должны быть в формате `дни:цена`, например `30:250,180:600`."
|
||
)
|
||
|
||
days = int(fragments[0])
|
||
amount_rub = int(fragments[1])
|
||
if days <= 0 or amount_rub <= 0:
|
||
raise ValueError("У тарифов дни и цена должны быть больше нуля.")
|
||
|
||
values.append(
|
||
PaymentPlanSettings(
|
||
code=f"{days}d",
|
||
days=days,
|
||
amount_rub=amount_rub,
|
||
)
|
||
)
|
||
|
||
if not values:
|
||
raise ValueError("Нужно указать хотя бы один тариф.")
|
||
|
||
return sorted(values, key=lambda item: item.days)
|