984 lines
36 KiB
Python
984 lines
36 KiB
Python
from __future__ import annotations
|
||
|
||
import html
|
||
import logging
|
||
from dataclasses import dataclass
|
||
from datetime import datetime, timedelta, timezone
|
||
from math import ceil
|
||
from uuid import uuid4
|
||
|
||
from sqlalchemy import func, select
|
||
from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
|
||
|
||
from app.config import PaymentPlanSettings, Settings
|
||
from app.db.base import utcnow
|
||
from app.db.models import PaymentOrder, ReferralBonus, ReferralInvite, TelegramUser
|
||
from app.schemas.remnawave import RemnawaveUser
|
||
from app.services.bot_config_service import BotConfigSnapshot, StaticBotConfigService
|
||
from app.services.remnawave_client import RemnawaveApiClient, RemnawaveApiError
|
||
from app.services.sync_service import SyncService
|
||
|
||
|
||
PENDING_PAYMENT_STATUS = "PENDING"
|
||
REVIEW_PAYMENT_STATUS = "REVIEW"
|
||
PROCESSING_PAYMENT_STATUS = "PROCESSING"
|
||
REJECTED_PAYMENT_STATUS = "REJECTED"
|
||
FULFILLED_PAYMENT_STATUS = "FULFILLED"
|
||
REFERRAL_BONUS_PENDING_STATUS = "PENDING"
|
||
REFERRAL_BONUS_PROCESSING_STATUS = "PROCESSING"
|
||
REFERRAL_BONUS_APPLIED_STATUS = "APPLIED"
|
||
|
||
logger = logging.getLogger(__name__)
|
||
|
||
|
||
@dataclass(slots=True)
|
||
class PaymentPlan:
|
||
code: str
|
||
title: str
|
||
description: str
|
||
duration_days: int
|
||
amount_rub: int
|
||
discount_percent: int
|
||
original_amount_rub: int
|
||
applied_referral_code: str = ""
|
||
traffic_limit_bytes: int = 0
|
||
traffic_limit_strategy: str = "NO_RESET"
|
||
internal_squad_uuids: list[str] | None = None
|
||
external_squad_uuid: str | None = None
|
||
|
||
@property
|
||
def is_ready(self) -> bool:
|
||
return bool(self.internal_squad_uuids) and self.duration_days > 0 and self.amount_rub > 0
|
||
|
||
|
||
@dataclass(slots=True)
|
||
class CreatedPaymentOrder:
|
||
order_uuid: str
|
||
provision_username: str
|
||
plan: PaymentPlan
|
||
transfer_text: str
|
||
extends_existing_access: bool = False
|
||
|
||
|
||
@dataclass(slots=True)
|
||
class StoredPaymentOrder:
|
||
order_uuid: str
|
||
telegram_id: int
|
||
plan_title: str
|
||
plan_duration_days: int
|
||
amount_rub: int
|
||
provision_username: str
|
||
status: str
|
||
|
||
|
||
@dataclass(slots=True)
|
||
class IssuedAccess:
|
||
telegram_id: int
|
||
username: str
|
||
subscription_url: str
|
||
expire_at: datetime
|
||
short_uuid: str
|
||
remnawave_user_uuid: str
|
||
traffic_limit_bytes: int
|
||
referral_bonus: ReferralBonusGrant | None = None
|
||
is_renewal: bool = False
|
||
|
||
|
||
@dataclass(slots=True)
|
||
class ReferralBonusGrant:
|
||
inviter_telegram_id: int
|
||
bonus_days: int
|
||
status: str
|
||
total_applied_days: int = 0
|
||
expire_at: datetime | None = None
|
||
applied_to_user_uuid: str | None = None
|
||
|
||
|
||
@dataclass(slots=True)
|
||
class AppliedReferralBonus:
|
||
telegram_id: int
|
||
total_bonus_days: int
|
||
expire_at: datetime
|
||
applied_to_user_uuid: str
|
||
|
||
|
||
@dataclass(slots=True)
|
||
class PaymentAdminStats:
|
||
pending_orders: int = 0
|
||
review_orders: int = 0
|
||
pending_referral_bonuses: int = 0
|
||
|
||
|
||
class PaymentService:
|
||
def __init__(
|
||
self,
|
||
*,
|
||
settings: Settings,
|
||
session_factory: async_sessionmaker[AsyncSession],
|
||
remnawave_client: RemnawaveApiClient,
|
||
sync_service: SyncService,
|
||
config_service: StaticBotConfigService | None = None,
|
||
) -> None:
|
||
self._settings = settings
|
||
self._session_factory = session_factory
|
||
self._remnawave_client = remnawave_client
|
||
self._sync_service = sync_service
|
||
self._config_service = config_service or StaticBotConfigService(settings)
|
||
|
||
async def _get_config(self) -> BotConfigSnapshot:
|
||
return await self._config_service.get_snapshot()
|
||
|
||
async def get_available_plans(self, *, telegram_id: int) -> list[PaymentPlan]:
|
||
config = await self._get_config()
|
||
applied_referral_code = await self._get_applied_referral_code(
|
||
telegram_id,
|
||
config=config,
|
||
)
|
||
return [
|
||
self._build_plan(
|
||
plan,
|
||
applied_referral_code=applied_referral_code,
|
||
config=config,
|
||
)
|
||
for plan in config.payment_plans
|
||
]
|
||
|
||
async def create_order(
|
||
self,
|
||
*,
|
||
telegram_id: int,
|
||
username: str | None,
|
||
first_name: str | None,
|
||
last_name: str | None,
|
||
language_code: str | None,
|
||
plan_code: str,
|
||
) -> CreatedPaymentOrder:
|
||
config = await self._get_config()
|
||
applied_referral_code = await self._get_applied_referral_code(
|
||
telegram_id,
|
||
config=config,
|
||
)
|
||
plan = self._get_plan_by_code(
|
||
plan_code,
|
||
applied_referral_code=applied_referral_code,
|
||
config=config,
|
||
)
|
||
if not plan.is_ready:
|
||
raise ValueError(
|
||
"Покупка не настроена. Проверьте PAYMENT_PLANS и PAYMENT_INTERNAL_SQUAD_UUIDS."
|
||
)
|
||
|
||
existing_accesses = await self._sync_service.get_cached_users_for_telegram(telegram_id)
|
||
order_uuid = str(uuid4())
|
||
invoice_payload = f"manual:{plan.code}:{order_uuid}"
|
||
provision_username = self._build_provision_username(
|
||
config=config,
|
||
order_uuid=order_uuid,
|
||
telegram_id=telegram_id,
|
||
username=username,
|
||
first_name=first_name,
|
||
)
|
||
|
||
async with self._session_factory() as session:
|
||
user = await self._upsert_telegram_user(
|
||
session,
|
||
telegram_id=telegram_id,
|
||
username=username,
|
||
first_name=first_name,
|
||
last_name=last_name,
|
||
language_code=language_code,
|
||
)
|
||
session.add(
|
||
PaymentOrder(
|
||
order_uuid=order_uuid,
|
||
telegram_user_id=user.id,
|
||
telegram_id=telegram_id,
|
||
plan_code=plan.code,
|
||
plan_title=plan.title,
|
||
plan_duration_days=plan.duration_days,
|
||
traffic_limit_bytes=plan.traffic_limit_bytes,
|
||
traffic_limit_strategy=plan.traffic_limit_strategy,
|
||
amount_stars=plan.amount_rub,
|
||
currency="RUB",
|
||
status=PENDING_PAYMENT_STATUS,
|
||
invoice_payload=invoice_payload,
|
||
provision_username=provision_username,
|
||
error_message=applied_referral_code or None,
|
||
)
|
||
)
|
||
await session.commit()
|
||
|
||
return CreatedPaymentOrder(
|
||
order_uuid=order_uuid,
|
||
provision_username=provision_username,
|
||
plan=plan,
|
||
transfer_text=config.payment_transfer_text.strip(),
|
||
extends_existing_access=bool(existing_accesses),
|
||
)
|
||
|
||
async def get_order_for_user(self, *, order_uuid: str, telegram_id: int) -> StoredPaymentOrder:
|
||
async with self._session_factory() as session:
|
||
order = await session.scalar(
|
||
select(PaymentOrder).where(
|
||
PaymentOrder.order_uuid == order_uuid,
|
||
PaymentOrder.telegram_id == telegram_id,
|
||
)
|
||
)
|
||
if order is None:
|
||
raise ValueError("Заказ не найден.")
|
||
|
||
return StoredPaymentOrder(
|
||
order_uuid=order.order_uuid,
|
||
telegram_id=order.telegram_id,
|
||
plan_title=order.plan_title,
|
||
plan_duration_days=order.plan_duration_days,
|
||
amount_rub=order.amount_stars,
|
||
provision_username=order.provision_username,
|
||
status=order.status,
|
||
)
|
||
|
||
async def mark_order_under_review(self, *, order_uuid: str, telegram_id: int) -> StoredPaymentOrder:
|
||
async with self._session_factory() as session:
|
||
order = await session.scalar(
|
||
select(PaymentOrder)
|
||
.where(
|
||
PaymentOrder.order_uuid == order_uuid,
|
||
PaymentOrder.telegram_id == telegram_id,
|
||
)
|
||
.with_for_update()
|
||
)
|
||
if order is None:
|
||
raise ValueError("Заказ не найден.")
|
||
if order.status == REVIEW_PAYMENT_STATUS:
|
||
raise ValueError("Чек уже отправлен на проверку.")
|
||
if order.status == PROCESSING_PAYMENT_STATUS:
|
||
raise ValueError("Заказ уже обрабатывается модератором.")
|
||
if order.status == FULFILLED_PAYMENT_STATUS:
|
||
raise ValueError("Этот заказ уже подтверждён.")
|
||
if order.status == REJECTED_PAYMENT_STATUS:
|
||
raise ValueError("Этот заказ уже отклонён. Создайте новый платёж.")
|
||
if order.status != PENDING_PAYMENT_STATUS:
|
||
raise ValueError("Некорректный статус заказа для отправки чека.")
|
||
|
||
order.status = REVIEW_PAYMENT_STATUS
|
||
order.updated_at = utcnow()
|
||
await session.commit()
|
||
|
||
return StoredPaymentOrder(
|
||
order_uuid=order.order_uuid,
|
||
telegram_id=order.telegram_id,
|
||
plan_title=order.plan_title,
|
||
plan_duration_days=order.plan_duration_days,
|
||
amount_rub=order.amount_stars,
|
||
provision_username=order.provision_username,
|
||
status=order.status,
|
||
)
|
||
|
||
async def revert_order_to_pending(self, *, order_uuid: str, telegram_id: int) -> None:
|
||
async with self._session_factory() as session:
|
||
order = await session.scalar(
|
||
select(PaymentOrder)
|
||
.where(
|
||
PaymentOrder.order_uuid == order_uuid,
|
||
PaymentOrder.telegram_id == telegram_id,
|
||
)
|
||
.with_for_update()
|
||
)
|
||
if order is None or order.status != REVIEW_PAYMENT_STATUS:
|
||
return
|
||
|
||
order.status = PENDING_PAYMENT_STATUS
|
||
order.updated_at = utcnow()
|
||
await session.commit()
|
||
|
||
async def approve_order(self, *, order_uuid: str) -> IssuedAccess:
|
||
order = await self._claim_order_for_approval(order_uuid)
|
||
config = await self._get_config()
|
||
is_renewal = False
|
||
|
||
try:
|
||
remote_user: RemnawaveUser | None = None
|
||
if order.remnawave_user_uuid:
|
||
try:
|
||
remote_user = await self._remnawave_client.get_user_by_uuid(
|
||
order.remnawave_user_uuid
|
||
)
|
||
except RemnawaveApiError as exc:
|
||
if exc.status_code != 404:
|
||
raise
|
||
remote_user = None
|
||
|
||
if remote_user is None:
|
||
try:
|
||
remote_user = await self._remnawave_client.get_user_by_username(
|
||
order.provision_username
|
||
)
|
||
except RemnawaveApiError as exc:
|
||
if exc.status_code != 404:
|
||
raise
|
||
|
||
if remote_user is None:
|
||
remote_users = await self._remnawave_client.get_users_by_telegram_id(
|
||
order.telegram_id
|
||
)
|
||
remote_user = self._select_referral_bonus_target(remote_users)
|
||
|
||
if remote_user is None:
|
||
remote_user = await self._create_remnawave_user(order, config=config)
|
||
else:
|
||
is_renewal = True
|
||
remote_user = await self._extend_remnawave_user(
|
||
order,
|
||
remote_user,
|
||
config=config,
|
||
)
|
||
except RemnawaveApiError as exc:
|
||
await self._restore_review_after_failed_approval(order.order_uuid, exc.message)
|
||
raise
|
||
|
||
await self._save_fulfilled_order(order.order_uuid, remote_user)
|
||
own_bonus = None
|
||
try:
|
||
own_bonus = await self.apply_pending_referral_bonuses(
|
||
telegram_id=order.telegram_id,
|
||
refresh_cache=False,
|
||
)
|
||
except RemnawaveApiError as exc:
|
||
logger.warning(
|
||
"Could not apply pending referral bonus for telegram_id=%s: %s",
|
||
order.telegram_id,
|
||
exc.message,
|
||
)
|
||
|
||
try:
|
||
await self._sync_service.refresh_cached_users_for_telegram(
|
||
telegram_id=order.telegram_id,
|
||
)
|
||
except RemnawaveApiError:
|
||
# Access is already issued at this point; cache can be refreshed later.
|
||
pass
|
||
|
||
expire_at = remote_user.expire_at
|
||
if own_bonus is not None and own_bonus.applied_to_user_uuid == str(remote_user.uuid):
|
||
expire_at = own_bonus.expire_at
|
||
|
||
referral_bonus = await self._grant_referral_bonus(order, config=config)
|
||
|
||
return IssuedAccess(
|
||
telegram_id=order.telegram_id,
|
||
username=remote_user.username,
|
||
subscription_url=remote_user.subscription_url,
|
||
expire_at=expire_at,
|
||
short_uuid=remote_user.short_uuid,
|
||
remnawave_user_uuid=str(remote_user.uuid),
|
||
traffic_limit_bytes=remote_user.traffic_limit_bytes,
|
||
referral_bonus=referral_bonus,
|
||
is_renewal=is_renewal,
|
||
)
|
||
|
||
async def reject_order(self, *, order_uuid: str, reason: str | None = None) -> StoredPaymentOrder:
|
||
async with self._session_factory() as session:
|
||
order = await session.scalar(
|
||
select(PaymentOrder)
|
||
.where(PaymentOrder.order_uuid == order_uuid)
|
||
.with_for_update()
|
||
)
|
||
if order is None:
|
||
raise ValueError("Заказ не найден.")
|
||
if order.status == FULFILLED_PAYMENT_STATUS:
|
||
raise ValueError("Подтверждённый заказ нельзя отклонить.")
|
||
if order.status == PROCESSING_PAYMENT_STATUS:
|
||
raise ValueError("Заказ уже обрабатывается другим модератором.")
|
||
if order.status == PENDING_PAYMENT_STATUS:
|
||
raise ValueError("Чек ещё не отправлен на проверку.")
|
||
if order.status == REJECTED_PAYMENT_STATUS:
|
||
raise ValueError("Заказ уже отклонён.")
|
||
|
||
order.status = REJECTED_PAYMENT_STATUS
|
||
order.error_message = reason or "Платёж отклонён"
|
||
order.updated_at = utcnow()
|
||
await session.commit()
|
||
|
||
return StoredPaymentOrder(
|
||
order_uuid=order.order_uuid,
|
||
telegram_id=order.telegram_id,
|
||
plan_title=order.plan_title,
|
||
plan_duration_days=order.plan_duration_days,
|
||
amount_rub=order.amount_stars,
|
||
provision_username=order.provision_username,
|
||
status=order.status,
|
||
)
|
||
|
||
async def get_referral_code_for_order(self, *, order_uuid: str) -> str:
|
||
order = await self._get_order(order_uuid)
|
||
return order.error_message or ""
|
||
|
||
def build_transfer_text(self, *, order: CreatedPaymentOrder) -> str:
|
||
lines = [
|
||
"<b>Оплата тарифа</b>",
|
||
"",
|
||
f"<b>{html.escape(order.plan.title)}</b>",
|
||
html.escape(order.plan.description),
|
||
"",
|
||
f"Сумма к переводу: <b>{order.plan.amount_rub} ₽</b>",
|
||
]
|
||
if order.plan.applied_referral_code:
|
||
lines.append(
|
||
f"Реферальный код: <code>{order.plan.applied_referral_code}</code> "
|
||
f"(<b>-{order.plan.discount_percent}%</b>)"
|
||
)
|
||
if order.extends_existing_access:
|
||
lines.extend(
|
||
[
|
||
"",
|
||
(
|
||
"<blockquote>"
|
||
"У вас уже есть доступ. После подтверждения оплаты бот автоматически "
|
||
"продлит текущую подписку на выбранный срок."
|
||
"</blockquote>"
|
||
),
|
||
]
|
||
)
|
||
lines.extend(
|
||
[
|
||
"",
|
||
"<b>Реквизиты</b>",
|
||
(
|
||
"<blockquote>"
|
||
f"{html.escape(order.transfer_text or 'Укажите реквизиты в PAYMENT_TRANSFER_TEXT.')}"
|
||
"</blockquote>"
|
||
),
|
||
"",
|
||
"После перевода нажмите кнопку ниже и отправьте чек следующим сообщением.",
|
||
]
|
||
)
|
||
return "\n".join(lines)
|
||
|
||
def _get_plan_by_code(
|
||
self,
|
||
plan_code: str,
|
||
*,
|
||
applied_referral_code: str,
|
||
config: BotConfigSnapshot,
|
||
) -> PaymentPlan:
|
||
for plan in config.payment_plans:
|
||
if plan.code == plan_code:
|
||
return self._build_plan(
|
||
plan,
|
||
applied_referral_code=applied_referral_code,
|
||
config=config,
|
||
)
|
||
|
||
raise ValueError("Тариф не найден.")
|
||
|
||
def _build_plan(
|
||
self,
|
||
plan_settings: PaymentPlanSettings,
|
||
*,
|
||
applied_referral_code: str,
|
||
config: BotConfigSnapshot,
|
||
) -> PaymentPlan:
|
||
discount_percent = max(config.referral_discount_percent, 0) if applied_referral_code else 0
|
||
discounted_amount = self._apply_discount(
|
||
amount_rub=plan_settings.amount_rub,
|
||
discount_percent=discount_percent,
|
||
)
|
||
traffic_limit_bytes = max(config.payment_plan_traffic_limit_gb, 0) * 1024**3
|
||
return PaymentPlan(
|
||
code=plan_settings.code,
|
||
title=f"{config.bot_brand_name} на {plan_settings.days} дней",
|
||
description=f"Доступ к VPN на {plan_settings.days} дней",
|
||
duration_days=plan_settings.days,
|
||
amount_rub=discounted_amount,
|
||
discount_percent=discount_percent,
|
||
original_amount_rub=plan_settings.amount_rub,
|
||
applied_referral_code=applied_referral_code,
|
||
traffic_limit_bytes=traffic_limit_bytes,
|
||
traffic_limit_strategy=config.payment_plan_traffic_reset_period.strip() or "NO_RESET",
|
||
internal_squad_uuids=config.payment_internal_squad_uuids,
|
||
external_squad_uuid=config.payment_external_squad_uuid_normalized,
|
||
)
|
||
|
||
@staticmethod
|
||
def _apply_discount(*, amount_rub: int, discount_percent: int) -> int:
|
||
if discount_percent <= 0:
|
||
return amount_rub
|
||
return max(1, ceil(amount_rub * (100 - discount_percent) / 100))
|
||
|
||
async def _get_applied_referral_code(
|
||
self,
|
||
telegram_id: int,
|
||
*,
|
||
config: BotConfigSnapshot | None = None,
|
||
) -> str:
|
||
resolved_config = config or await self._get_config()
|
||
if not resolved_config.referral_enabled:
|
||
return ""
|
||
summary = await self._sync_service.get_referral_summary(telegram_id)
|
||
return summary.applied_referral_code.strip().upper()
|
||
|
||
async def apply_pending_referral_bonuses(
|
||
self,
|
||
*,
|
||
telegram_id: int,
|
||
refresh_cache: bool = True,
|
||
) -> AppliedReferralBonus | None:
|
||
config = await self._get_config()
|
||
if not config.referral_enabled:
|
||
return None
|
||
|
||
claimed_bonuses = await self._claim_pending_referral_bonuses(telegram_id)
|
||
if not claimed_bonuses:
|
||
return None
|
||
|
||
total_bonus_days = sum(max(bonus.bonus_days, 0) for bonus in claimed_bonuses)
|
||
if total_bonus_days <= 0:
|
||
await self._restore_claimed_referral_bonuses(
|
||
[bonus.id for bonus in claimed_bonuses],
|
||
status=REFERRAL_BONUS_PENDING_STATUS,
|
||
)
|
||
return None
|
||
|
||
remote_users = await self._remnawave_client.get_users_by_telegram_id(telegram_id)
|
||
target_user = self._select_referral_bonus_target(remote_users)
|
||
if target_user is None:
|
||
await self._restore_claimed_referral_bonuses(
|
||
[bonus.id for bonus in claimed_bonuses],
|
||
status=REFERRAL_BONUS_PENDING_STATUS,
|
||
)
|
||
return None
|
||
|
||
current_expire_at = target_user.expire_at
|
||
if current_expire_at.tzinfo is None:
|
||
current_expire_at = current_expire_at.replace(tzinfo=timezone.utc)
|
||
next_expire_at = max(current_expire_at, datetime.now(timezone.utc)) + timedelta(
|
||
days=total_bonus_days
|
||
)
|
||
|
||
try:
|
||
updated_user = await self._remnawave_client.update_user(
|
||
{
|
||
"uuid": str(target_user.uuid),
|
||
"expireAt": next_expire_at.isoformat().replace("+00:00", "Z"),
|
||
"description": (
|
||
f"Referral bonus applied by Telegram bot "
|
||
f"({total_bonus_days} days)"
|
||
),
|
||
}
|
||
)
|
||
except RemnawaveApiError:
|
||
await self._restore_claimed_referral_bonuses(
|
||
[bonus.id for bonus in claimed_bonuses],
|
||
status=REFERRAL_BONUS_PENDING_STATUS,
|
||
)
|
||
raise
|
||
|
||
await self._mark_referral_bonuses_applied(
|
||
[bonus.id for bonus in claimed_bonuses],
|
||
applied_to_user_uuid=str(updated_user.uuid),
|
||
)
|
||
|
||
if refresh_cache:
|
||
try:
|
||
await self._sync_service.refresh_cached_users_for_telegram(
|
||
telegram_id=telegram_id,
|
||
)
|
||
except RemnawaveApiError:
|
||
pass
|
||
|
||
return AppliedReferralBonus(
|
||
telegram_id=telegram_id,
|
||
total_bonus_days=total_bonus_days,
|
||
expire_at=updated_user.expire_at,
|
||
applied_to_user_uuid=str(updated_user.uuid),
|
||
)
|
||
|
||
async def get_admin_stats(self) -> PaymentAdminStats:
|
||
async with self._session_factory() as session:
|
||
pending_orders = await session.scalar(
|
||
select(func.count(PaymentOrder.id)).where(
|
||
PaymentOrder.status == PENDING_PAYMENT_STATUS
|
||
)
|
||
)
|
||
review_orders = await session.scalar(
|
||
select(func.count(PaymentOrder.id)).where(
|
||
PaymentOrder.status == REVIEW_PAYMENT_STATUS
|
||
)
|
||
)
|
||
pending_referral_bonuses = await session.scalar(
|
||
select(func.count(ReferralBonus.id)).where(
|
||
ReferralBonus.status == REFERRAL_BONUS_PENDING_STATUS
|
||
)
|
||
)
|
||
|
||
return PaymentAdminStats(
|
||
pending_orders=int(pending_orders or 0),
|
||
review_orders=int(review_orders or 0),
|
||
pending_referral_bonuses=int(pending_referral_bonuses or 0),
|
||
)
|
||
|
||
async def _get_order(self, order_uuid: str) -> PaymentOrder:
|
||
async with self._session_factory() as session:
|
||
order = await session.scalar(
|
||
select(PaymentOrder).where(PaymentOrder.order_uuid == order_uuid)
|
||
)
|
||
if order is None:
|
||
raise ValueError("Заказ не найден.")
|
||
return order
|
||
|
||
async def _claim_order_for_approval(self, order_uuid: str) -> PaymentOrder:
|
||
async with self._session_factory() as session:
|
||
order = await session.scalar(
|
||
select(PaymentOrder)
|
||
.where(PaymentOrder.order_uuid == order_uuid)
|
||
.with_for_update()
|
||
)
|
||
if order is None:
|
||
raise ValueError("Заказ не найден.")
|
||
if order.status == PENDING_PAYMENT_STATUS:
|
||
raise ValueError("Чек ещё не отправлен на проверку.")
|
||
if order.status == PROCESSING_PAYMENT_STATUS:
|
||
raise ValueError("Заказ уже обрабатывается другим модератором.")
|
||
if order.status == REJECTED_PAYMENT_STATUS:
|
||
raise ValueError("Заказ уже отклонён.")
|
||
if order.status == FULFILLED_PAYMENT_STATUS:
|
||
raise ValueError("Этот заказ уже подтверждён.")
|
||
if order.status != REVIEW_PAYMENT_STATUS:
|
||
raise ValueError("Некорректный статус заказа для подтверждения.")
|
||
|
||
order.status = PROCESSING_PAYMENT_STATUS
|
||
order.updated_at = utcnow()
|
||
await session.commit()
|
||
return order
|
||
|
||
async def _create_remnawave_user(
|
||
self,
|
||
order: PaymentOrder,
|
||
*,
|
||
config: BotConfigSnapshot,
|
||
) -> RemnawaveUser:
|
||
expire_at = datetime.now(timezone.utc) + timedelta(days=order.plan_duration_days)
|
||
body: dict[str, object] = {
|
||
"username": order.provision_username,
|
||
"expireAt": expire_at.isoformat().replace("+00:00", "Z"),
|
||
"trafficLimitBytes": order.traffic_limit_bytes,
|
||
"trafficLimitStrategy": order.traffic_limit_strategy,
|
||
"telegramId": order.telegram_id,
|
||
"description": f"Created by Telegram bot manual payment {order.order_uuid}",
|
||
"activeInternalSquads": config.payment_internal_squad_uuids,
|
||
}
|
||
if config.payment_user_tag_normalized:
|
||
body["tag"] = config.payment_user_tag_normalized
|
||
if config.payment_external_squad_uuid_normalized:
|
||
body["externalSquadUuid"] = config.payment_external_squad_uuid_normalized
|
||
return await self._remnawave_client.create_user(body)
|
||
|
||
async def _extend_remnawave_user(
|
||
self,
|
||
order: PaymentOrder,
|
||
remote_user: RemnawaveUser,
|
||
*,
|
||
config: BotConfigSnapshot,
|
||
) -> RemnawaveUser:
|
||
current_expire_at = remote_user.expire_at
|
||
if current_expire_at.tzinfo is None:
|
||
current_expire_at = current_expire_at.replace(tzinfo=timezone.utc)
|
||
|
||
base_expire_at = max(current_expire_at, datetime.now(timezone.utc))
|
||
next_expire_at = base_expire_at + timedelta(days=order.plan_duration_days)
|
||
|
||
traffic_limit_bytes = order.traffic_limit_bytes
|
||
if traffic_limit_bytes <= 0:
|
||
traffic_limit_bytes = remote_user.traffic_limit_bytes
|
||
|
||
body: dict[str, object] = {
|
||
"uuid": str(remote_user.uuid),
|
||
"username": remote_user.username,
|
||
"expireAt": next_expire_at.isoformat().replace("+00:00", "Z"),
|
||
"trafficLimitBytes": traffic_limit_bytes,
|
||
"trafficLimitStrategy": order.traffic_limit_strategy,
|
||
"telegramId": order.telegram_id,
|
||
"description": f"Updated by Telegram bot manual payment {order.order_uuid}",
|
||
"activeInternalSquads": config.payment_internal_squad_uuids,
|
||
}
|
||
if config.payment_user_tag_normalized:
|
||
body["tag"] = config.payment_user_tag_normalized
|
||
if config.payment_external_squad_uuid_normalized:
|
||
body["externalSquadUuid"] = config.payment_external_squad_uuid_normalized
|
||
return await self._remnawave_client.update_user(body)
|
||
|
||
async def _save_fulfilled_order(self, order_uuid: str, remote_user: RemnawaveUser) -> None:
|
||
async with self._session_factory() as session:
|
||
order = await session.scalar(
|
||
select(PaymentOrder).where(PaymentOrder.order_uuid == order_uuid)
|
||
)
|
||
if order is None:
|
||
return
|
||
order.status = FULFILLED_PAYMENT_STATUS
|
||
order.remnawave_user_uuid = str(remote_user.uuid)
|
||
order.subscription_url = remote_user.subscription_url
|
||
order.error_message = None
|
||
order.paid_at = utcnow()
|
||
order.fulfilled_at = utcnow()
|
||
order.updated_at = utcnow()
|
||
await session.commit()
|
||
|
||
async def _save_order_error(self, order_uuid: str, error_message: str) -> None:
|
||
async with self._session_factory() as session:
|
||
order = await session.scalar(
|
||
select(PaymentOrder).where(PaymentOrder.order_uuid == order_uuid)
|
||
)
|
||
if order is None:
|
||
return
|
||
order.error_message = error_message
|
||
order.updated_at = utcnow()
|
||
await session.commit()
|
||
|
||
async def _restore_review_after_failed_approval(
|
||
self,
|
||
order_uuid: str,
|
||
error_message: str,
|
||
) -> None:
|
||
async with self._session_factory() as session:
|
||
order = await session.scalar(
|
||
select(PaymentOrder)
|
||
.where(PaymentOrder.order_uuid == order_uuid)
|
||
.with_for_update()
|
||
)
|
||
if order is None:
|
||
return
|
||
|
||
if order.status == PROCESSING_PAYMENT_STATUS:
|
||
order.status = REVIEW_PAYMENT_STATUS
|
||
order.error_message = error_message
|
||
order.updated_at = utcnow()
|
||
await session.commit()
|
||
|
||
async def _grant_referral_bonus(
|
||
self,
|
||
order: PaymentOrder,
|
||
*,
|
||
config: BotConfigSnapshot,
|
||
) -> ReferralBonusGrant | None:
|
||
if not config.referral_enabled:
|
||
return None
|
||
|
||
bonus_days = max(config.referral_bonus_days, 0)
|
||
if bonus_days <= 0:
|
||
return None
|
||
|
||
inviter_telegram_id = await self._get_inviter_telegram_id(order.telegram_id)
|
||
if inviter_telegram_id is None or inviter_telegram_id == order.telegram_id:
|
||
return None
|
||
|
||
await self._create_referral_bonus(
|
||
inviter_telegram_id=inviter_telegram_id,
|
||
invited_telegram_id=order.telegram_id,
|
||
source_order_uuid=order.order_uuid,
|
||
bonus_days=bonus_days,
|
||
)
|
||
|
||
try:
|
||
applied_bonus = await self.apply_pending_referral_bonuses(
|
||
telegram_id=inviter_telegram_id,
|
||
)
|
||
except RemnawaveApiError as exc:
|
||
logger.warning(
|
||
"Could not apply referral bonus for inviter=%s after order=%s: %s",
|
||
inviter_telegram_id,
|
||
order.order_uuid,
|
||
exc.message,
|
||
)
|
||
applied_bonus = None
|
||
|
||
if applied_bonus is None:
|
||
return ReferralBonusGrant(
|
||
inviter_telegram_id=inviter_telegram_id,
|
||
bonus_days=bonus_days,
|
||
status=REFERRAL_BONUS_PENDING_STATUS,
|
||
)
|
||
|
||
return ReferralBonusGrant(
|
||
inviter_telegram_id=inviter_telegram_id,
|
||
bonus_days=bonus_days,
|
||
status=REFERRAL_BONUS_APPLIED_STATUS,
|
||
total_applied_days=applied_bonus.total_bonus_days,
|
||
expire_at=applied_bonus.expire_at,
|
||
applied_to_user_uuid=applied_bonus.applied_to_user_uuid,
|
||
)
|
||
|
||
async def _get_inviter_telegram_id(self, invited_telegram_id: int) -> int | None:
|
||
async with self._session_factory() as session:
|
||
return await session.scalar(
|
||
select(ReferralInvite.inviter_telegram_id).where(
|
||
ReferralInvite.invited_telegram_id == invited_telegram_id
|
||
)
|
||
)
|
||
|
||
async def _create_referral_bonus(
|
||
self,
|
||
*,
|
||
inviter_telegram_id: int,
|
||
invited_telegram_id: int,
|
||
source_order_uuid: str,
|
||
bonus_days: int,
|
||
) -> None:
|
||
async with self._session_factory() as session:
|
||
existing = await session.scalar(
|
||
select(ReferralBonus).where(
|
||
ReferralBonus.source_order_uuid == source_order_uuid
|
||
)
|
||
)
|
||
if existing is not None:
|
||
return
|
||
|
||
session.add(
|
||
ReferralBonus(
|
||
inviter_telegram_id=inviter_telegram_id,
|
||
invited_telegram_id=invited_telegram_id,
|
||
source_order_uuid=source_order_uuid,
|
||
bonus_days=bonus_days,
|
||
status=REFERRAL_BONUS_PENDING_STATUS,
|
||
)
|
||
)
|
||
await session.commit()
|
||
|
||
async def _claim_pending_referral_bonuses(self, telegram_id: int) -> list[ReferralBonus]:
|
||
async with self._session_factory() as session:
|
||
bonuses = list(
|
||
(
|
||
await session.scalars(
|
||
select(ReferralBonus)
|
||
.where(
|
||
ReferralBonus.inviter_telegram_id == telegram_id,
|
||
ReferralBonus.status == REFERRAL_BONUS_PENDING_STATUS,
|
||
)
|
||
.order_by(ReferralBonus.created_at.asc(), ReferralBonus.id.asc())
|
||
.with_for_update()
|
||
)
|
||
).all()
|
||
)
|
||
if not bonuses:
|
||
return []
|
||
|
||
for bonus in bonuses:
|
||
bonus.status = REFERRAL_BONUS_PROCESSING_STATUS
|
||
bonus.updated_at = utcnow()
|
||
await session.commit()
|
||
return bonuses
|
||
|
||
async def _restore_claimed_referral_bonuses(
|
||
self,
|
||
bonus_ids: list[int],
|
||
*,
|
||
status: str,
|
||
) -> None:
|
||
if not bonus_ids:
|
||
return
|
||
|
||
async with self._session_factory() as session:
|
||
bonuses = list(
|
||
(
|
||
await session.scalars(
|
||
select(ReferralBonus)
|
||
.where(ReferralBonus.id.in_(bonus_ids))
|
||
.with_for_update()
|
||
)
|
||
).all()
|
||
)
|
||
for bonus in bonuses:
|
||
bonus.status = status
|
||
bonus.updated_at = utcnow()
|
||
await session.commit()
|
||
|
||
async def _mark_referral_bonuses_applied(
|
||
self,
|
||
bonus_ids: list[int],
|
||
*,
|
||
applied_to_user_uuid: str,
|
||
) -> None:
|
||
if not bonus_ids:
|
||
return
|
||
|
||
async with self._session_factory() as session:
|
||
bonuses = list(
|
||
(
|
||
await session.scalars(
|
||
select(ReferralBonus)
|
||
.where(ReferralBonus.id.in_(bonus_ids))
|
||
.with_for_update()
|
||
)
|
||
).all()
|
||
)
|
||
for bonus in bonuses:
|
||
bonus.status = REFERRAL_BONUS_APPLIED_STATUS
|
||
bonus.applied_to_user_uuid = applied_to_user_uuid
|
||
bonus.applied_at = utcnow()
|
||
bonus.updated_at = utcnow()
|
||
await session.commit()
|
||
|
||
@staticmethod
|
||
def _select_referral_bonus_target(
|
||
remote_users: list[RemnawaveUser],
|
||
) -> RemnawaveUser | None:
|
||
if not remote_users:
|
||
return None
|
||
|
||
def _sort_key(user: RemnawaveUser) -> tuple[int, datetime, str]:
|
||
expire_at = user.expire_at
|
||
if expire_at.tzinfo is None:
|
||
expire_at = expire_at.replace(tzinfo=timezone.utc)
|
||
return (0 if user.status.upper() == "ACTIVE" else 1, expire_at, user.username)
|
||
|
||
return sorted(remote_users, key=_sort_key)[0]
|
||
|
||
async def _upsert_telegram_user(
|
||
self,
|
||
session: AsyncSession,
|
||
*,
|
||
telegram_id: int,
|
||
username: str | None,
|
||
first_name: str | None,
|
||
last_name: str | None,
|
||
language_code: str | None,
|
||
) -> TelegramUser:
|
||
record = await session.scalar(
|
||
select(TelegramUser).where(TelegramUser.telegram_id == telegram_id)
|
||
)
|
||
|
||
if record is None:
|
||
record = TelegramUser(telegram_id=telegram_id)
|
||
session.add(record)
|
||
|
||
record.username = username
|
||
record.first_name = first_name
|
||
record.last_name = last_name
|
||
record.language_code = language_code
|
||
record.is_admin = self._settings.is_admin(telegram_id)
|
||
record.last_seen_at = utcnow()
|
||
record.updated_at = utcnow()
|
||
|
||
await session.flush()
|
||
return record
|
||
|
||
def _build_provision_username(
|
||
self,
|
||
*,
|
||
config: BotConfigSnapshot,
|
||
order_uuid: str,
|
||
telegram_id: int,
|
||
username: str | None,
|
||
first_name: str | None,
|
||
) -> str:
|
||
base_name = username or first_name or "user"
|
||
normalized_name = "".join(
|
||
ch for ch in base_name if ch.isalnum() or ch in "_-"
|
||
).strip("-_")
|
||
if not normalized_name:
|
||
normalized_name = "user"
|
||
|
||
prefix = config.payment_username_prefix_normalized or "Oreol"
|
||
unique_suffix = order_uuid.replace("-", "")[:6]
|
||
provision_username = f"{prefix}-{telegram_id}-{unique_suffix}-{normalized_name}"
|
||
return provision_username[:36]
|