mirror of
https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot.git
synced 2026-01-20 20:00:25 +00:00
232 lines
7.4 KiB
Python
232 lines
7.4 KiB
Python
import logging
|
||
from datetime import datetime
|
||
from typing import Optional
|
||
from urllib.parse import quote, urlparse, urlunparse
|
||
from sqlalchemy import select, delete, func
|
||
from sqlalchemy.ext.asyncio import AsyncSession
|
||
from app.database.models import Subscription, User
|
||
from app.config import settings
|
||
|
||
logger = logging.getLogger(__name__)
|
||
|
||
|
||
async def ensure_single_subscription(db: AsyncSession, user_id: int) -> Optional[Subscription]:
|
||
result = await db.execute(
|
||
select(Subscription)
|
||
.where(Subscription.user_id == user_id)
|
||
.order_by(Subscription.created_at.desc())
|
||
)
|
||
subscriptions = result.scalars().all()
|
||
|
||
if len(subscriptions) <= 1:
|
||
return subscriptions[0] if subscriptions else None
|
||
|
||
latest_subscription = subscriptions[0]
|
||
old_subscriptions = subscriptions[1:]
|
||
|
||
logger.warning(f"🚨 Обнаружено {len(subscriptions)} подписок у пользователя {user_id}. Удаляем {len(old_subscriptions)} старых.")
|
||
|
||
for old_sub in old_subscriptions:
|
||
await db.delete(old_sub)
|
||
logger.info(f"🗑️ Удалена подписка ID {old_sub.id} от {old_sub.created_at}")
|
||
|
||
await db.commit()
|
||
await db.refresh(latest_subscription)
|
||
|
||
logger.info(f"✅ Оставлена подписка ID {latest_subscription.id} от {latest_subscription.created_at}")
|
||
return latest_subscription
|
||
|
||
|
||
async def update_or_create_subscription(
|
||
db: AsyncSession,
|
||
user_id: int,
|
||
**subscription_data
|
||
) -> Subscription:
|
||
existing_subscription = await ensure_single_subscription(db, user_id)
|
||
|
||
if existing_subscription:
|
||
for key, value in subscription_data.items():
|
||
if hasattr(existing_subscription, key):
|
||
setattr(existing_subscription, key, value)
|
||
|
||
existing_subscription.updated_at = datetime.utcnow()
|
||
await db.commit()
|
||
await db.refresh(existing_subscription)
|
||
|
||
logger.info(f"🔄 Обновлена существующая подписка ID {existing_subscription.id}")
|
||
return existing_subscription
|
||
|
||
else:
|
||
subscription_defaults = dict(subscription_data)
|
||
autopay_enabled = subscription_defaults.pop(
|
||
"autopay_enabled", None
|
||
)
|
||
autopay_days_before = subscription_defaults.pop(
|
||
"autopay_days_before", None
|
||
)
|
||
|
||
new_subscription = Subscription(
|
||
user_id=user_id,
|
||
autopay_enabled=(
|
||
settings.is_autopay_enabled_by_default()
|
||
if autopay_enabled is None
|
||
else autopay_enabled
|
||
),
|
||
autopay_days_before=(
|
||
settings.DEFAULT_AUTOPAY_DAYS_BEFORE
|
||
if autopay_days_before is None
|
||
else autopay_days_before
|
||
),
|
||
**subscription_defaults
|
||
)
|
||
|
||
db.add(new_subscription)
|
||
await db.commit()
|
||
await db.refresh(new_subscription)
|
||
|
||
logger.info(f"🆕 Создана новая подписка ID {new_subscription.id}")
|
||
return new_subscription
|
||
|
||
|
||
async def cleanup_duplicate_subscriptions(db: AsyncSession) -> int:
|
||
result = await db.execute(
|
||
select(Subscription.user_id)
|
||
.group_by(Subscription.user_id)
|
||
.having(func.count(Subscription.id) > 1)
|
||
)
|
||
users_with_duplicates = result.scalars().all()
|
||
|
||
total_deleted = 0
|
||
|
||
for user_id in users_with_duplicates:
|
||
subscriptions_result = await db.execute(
|
||
select(Subscription)
|
||
.where(Subscription.user_id == user_id)
|
||
.order_by(Subscription.created_at.desc())
|
||
)
|
||
subscriptions = subscriptions_result.scalars().all()
|
||
|
||
for old_subscription in subscriptions[1:]:
|
||
await db.delete(old_subscription)
|
||
total_deleted += 1
|
||
logger.info(f"🗑️ Удалена дублирующаяся подписка ID {old_subscription.id} пользователя {user_id}")
|
||
|
||
await db.commit()
|
||
logger.info(f"🧹 Очищено {total_deleted} дублирующихся подписок")
|
||
|
||
return total_deleted
|
||
|
||
|
||
def get_display_subscription_link(subscription: Optional[Subscription]) -> Optional[str]:
|
||
if not subscription:
|
||
return None
|
||
|
||
base_link = getattr(subscription, "subscription_url", None)
|
||
|
||
if settings.is_happ_cryptolink_mode():
|
||
crypto_link = getattr(subscription, "subscription_crypto_link", None)
|
||
return crypto_link or base_link
|
||
|
||
return base_link
|
||
|
||
|
||
def get_happ_cryptolink_redirect_link(subscription_link: Optional[str]) -> Optional[str]:
|
||
if not subscription_link:
|
||
return None
|
||
|
||
template = settings.get_happ_cryptolink_redirect_template()
|
||
if not template:
|
||
return None
|
||
|
||
encoded_link = quote(subscription_link, safe="")
|
||
replacements = {
|
||
"{subscription_link}": encoded_link,
|
||
"{link}": encoded_link,
|
||
"{subscription_link_raw}": subscription_link,
|
||
"{link_raw}": subscription_link,
|
||
}
|
||
|
||
replaced = False
|
||
for placeholder, value in replacements.items():
|
||
if placeholder in template:
|
||
template = template.replace(placeholder, value)
|
||
replaced = True
|
||
|
||
if replaced:
|
||
return template
|
||
|
||
if template.endswith(("=", "?", "&")):
|
||
return f"{template}{encoded_link}"
|
||
|
||
return f"{template}{encoded_link}"
|
||
|
||
|
||
def convert_subscription_link_to_happ_scheme(subscription_link: Optional[str]) -> Optional[str]:
|
||
if not subscription_link:
|
||
return None
|
||
|
||
parsed_link = urlparse(subscription_link)
|
||
|
||
if parsed_link.scheme.lower() == "happ":
|
||
return subscription_link
|
||
|
||
if not parsed_link.scheme:
|
||
return subscription_link
|
||
|
||
return urlunparse(parsed_link._replace(scheme="happ"))
|
||
|
||
|
||
def resolve_hwid_device_limit(subscription: Optional[Subscription]) -> Optional[int]:
|
||
"""Return a device limit value for RemnaWave payloads when selection is enabled."""
|
||
|
||
if subscription is None:
|
||
return None
|
||
|
||
if not settings.is_devices_selection_enabled():
|
||
forced_limit = settings.get_disabled_mode_device_limit()
|
||
return forced_limit
|
||
|
||
limit = getattr(subscription, "device_limit", None)
|
||
if limit is None or limit <= 0:
|
||
return None
|
||
|
||
return limit
|
||
|
||
|
||
def resolve_hwid_device_limit_for_payload(
|
||
subscription: Optional[Subscription],
|
||
) -> Optional[int]:
|
||
"""Return the device limit that should be sent to RemnaWave APIs.
|
||
|
||
When device selection is disabled and no explicit override is configured,
|
||
RemnaWave should continue receiving the subscription's stored limit so the
|
||
external panel stays aligned with the bot configuration.
|
||
"""
|
||
|
||
resolved_limit = resolve_hwid_device_limit(subscription)
|
||
|
||
if resolved_limit is not None:
|
||
return resolved_limit
|
||
|
||
if subscription is None:
|
||
return None
|
||
|
||
fallback_limit = getattr(subscription, "device_limit", None)
|
||
if fallback_limit is None or fallback_limit <= 0:
|
||
return None
|
||
|
||
return fallback_limit
|
||
|
||
|
||
def resolve_simple_subscription_device_limit() -> int:
|
||
"""Return the effective device limit for simple subscription flows."""
|
||
|
||
if settings.is_devices_selection_enabled():
|
||
return int(getattr(settings, "SIMPLE_SUBSCRIPTION_DEVICE_LIMIT", 0) or 0)
|
||
|
||
forced_limit = settings.get_disabled_mode_device_limit()
|
||
if forced_limit is not None:
|
||
return forced_limit
|
||
|
||
return int(getattr(settings, "SIMPLE_SUBSCRIPTION_DEVICE_LIMIT", 0) or 0)
|