Сделаны подписки и переделаны роуты

app/services/db_manager.py

@@ -9,7 +9,7 @@ from .mongo_rep import MongoDBRepository
 import random
 import string
 import logging
-import asyncio
+from uuid import UUID
 
 class DatabaseManager:
     def __init__(self, session_generator):
@@ -85,23 +85,29 @@ class DatabaseManager:
                 await session.rollback()
                 return "ERROR"
 
-    async def last_subscription(self, user_id: int):
+    async def last_subscription(self, user_id: str):
         """
-        Возвращает список подписок пользователя.
+        Возвращает последнюю подписку пользователя.
         """
         async for session in self.session_generator():
             try:
                 result = await session.execute(
                     select(Subscription)
-                    .where(Subscription.user_id == user_id)
+                    .where(Subscription.user_id == str(user_id))
                     .order_by(desc(Subscription.created_at))
+                    .limit(1)  # Применяем limit правильно
                 )
-                return result.scalars().all()
+                subscription = result.scalar_one_or_none()
+                if subscription:
+                    return subscription
+                else:
+                    return None
             except SQLAlchemyError as e:
-                self.logger.error(f"Ошибка при получении последней подписки пользователя {user_id}: {e}")
+                self.logger.error(f"Ошибка при получении подписки для пользователя {user_id}: {e}")
                 return "ERROR"
 
-    async def last_transaction(self, user_id: int):
+
+    async def last_transaction(self, user_id: UUID):
         """
         Возвращает список транзакций пользователя.
         """
@@ -109,7 +115,7 @@ class DatabaseManager:
             try:
                 result = await session.execute(
                     select(Transaction)
-                    .where(Transaction.user_id == user_id)
+                    .where(Transaction.user_id == str(user_id))
                     .order_by(desc(Transaction.created_at))
                 )
                 transactions = result.scalars().all()
@@ -121,73 +127,23 @@ class DatabaseManager:
     async def buy_sub(self, telegram_id: str, plan_id: str):
         async for session in self.session_generator():
             try:
-                result = await self.create_user(telegram_id)
-                if not result:
-                    self.logger.error(f"Пользователь с Telegram ID {telegram_id} не найден.")
-                    return "ERROR"
+                active_subscription = await self._check_active_subscription(telegram_id, session)
+                if active_subscription:
+                    self.logger.error(f"Пользователь {telegram_id} уже имеет активную подписку.")
+                    return "ACTIVE_SUBSCRIPTION_EXISTS"
+                result = await self._initialize_user_and_plan(telegram_id, plan_id)
+                if isinstance(result, str):
+                    return result  # Возвращает "ERROR", "TARIFF_NOT_FOUND" или "INSUFFICIENT_FUNDS"
 
-                # Получение тарифного плана из MongoDB
-                plan = await self.mongo_repo.get_subscription_plan(plan_id)
-                if not plan:
-                    self.logger.error(f"Тарифный план {plan_id} не найден.")
-                    return "ERROR"
+                user, plan = result
+                user.balance -= int(plan["price"])
+                session.add(user)
 
-                # Проверка достаточности средств
-                cost = int(plan["price"])
-                if result.balance < cost:
-                    self.logger.error(f"Недостаточно средств у пользователя {telegram_id} для покупки плана {plan_id}.")
-                    return "INSUFFICIENT_FUNDS"
-
-                # Списываем средства
-                result.balance -= cost
-
-                # Создаем подписку
-                expiry_date = datetime.utcnow() + relativedelta(months=plan["duration_months"])
-                server = await self.mongo_repo.get_server_with_least_clients()
-                self.logger.info(f"Выбран сервер для подписки: {server}")
-                new_subscription = Subscription(
-                    user_id=result.id,
-                    vpn_server_id=str(server['server']["name"]),
-                    plan=plan_id,
-                    expiry_date=expiry_date
-                )
-                session.add(new_subscription)
-
-                # Попытка добавить пользователя на сервер
-                # Получаем информацию о пользователе
-                user = result  # так как result уже содержит пользователя
-                if not user:
-                    self.logger.error(f"Не удалось найти пользователя для добавления на сервер.")
+                new_subscription, server = await self._create_subscription_and_add_client(user, plan, session)
+                if not new_subscription:
                     await session.rollback()
                     return "ERROR"
 
-                # Получаем сервер из MongoDB
-                server_data = await self.mongo_repo.get_server(new_subscription.vpn_server_id)
-                if not server_data:
-                    self.logger.error(f"Не удалось найти сервер с ID {new_subscription.vpn_server_id}.")
-                    await session.rollback()
-                    return "ERROR"
-
-                server_info = server_data['server']
-                url_base = f"https://{server_info['ip']}:{server_info['port']}/{server_info['secretKey']}"
-                login_data = {
-                    'username': server_info['login'],
-                    'password': server_info['password'],
-                }
-
-                panel = PanelInteraction(url_base, login_data, self.logger,server_info['certificate']['data'])
-                expiry_date_iso = new_subscription.expiry_date.isoformat()
-
-                # Добавляем на сервер
-                response = await panel.add_client(user.id, expiry_date_iso, user.username)
-
-                if response != "OK":
-                    self.logger.error(f"Ошибка при добавлении клиента {telegram_id} на сервер: {response}")
-                    # Если не получилось добавить на сервер, откатываем транзакцию
-                    await session.rollback()
-                    return "ERROR"
-
-                # Если мы здесь - значит и подписка, и добавление на сервер успешны
                 await session.commit()
                 self.logger.info(f"Подписка успешно оформлена для пользователя {telegram_id} на план {plan_id} и клиент добавлен на сервер.")
                 return "OK"
@@ -201,6 +157,79 @@ class DatabaseManager:
                 await session.rollback()
                 return "ERROR"
 
+    async def _initialize_user_and_plan(self, telegram_id, plan_id):
+        user = await self.create_user(telegram_id)
+        if not user:
+            self.logger.error(f"Пользователь с Telegram ID {telegram_id} не найден.")
+            return "ERROR"
+
+        plan = await self.mongo_repo.get_subscription_plan(plan_id)
+        if not plan:
+            self.logger.error(f"Тарифный план {plan_id} не найден.")
+            return "TARIFF_NOT_FOUND"
+
+        cost = int(plan["price"])
+        if user.balance < cost:
+            self.logger.error(f"Недостаточно средств у пользователя {telegram_id} для покупки плана {plan_id}.")
+            return "INSUFFICIENT_FUNDS"
+
+        return user, plan
+
+    async def _create_subscription_and_add_client(self, user, plan, session):
+        expiry_date = datetime.utcnow() + relativedelta(months=plan["duration_months"])
+        server = await self.mongo_repo.get_server_with_least_clients()
+        self.logger.info(f"Выбран сервер для подписки: {server}")
+
+        new_subscription = Subscription(
+            user_id=user.id,
+            vpn_server_id=str(server['server']["name"]),
+            plan=plan["name"],
+            expiry_date=expiry_date
+        )
+        session.add(new_subscription)
+
+        server_data = await self.mongo_repo.get_server(new_subscription.vpn_server_id)
+        if not server_data:
+            self.logger.error(f"Не удалось найти сервер с ID {new_subscription.vpn_server_id}.")
+            return None, None
+
+        server_info = server_data['server']
+        url_base = f"https://{server_info['ip']}:{server_info['port']}/{server_info['secretKey']}"
+        login_data = {
+            'username': server_info['login'],
+            'password': server_info['password'],
+        }
+
+        panel = PanelInteraction(url_base, login_data, self.logger, server_info['certificate']['data'])
+        expiry_date_iso = new_subscription.expiry_date.isoformat()
+
+        response = await panel.add_client(1, expiry_date_iso, user.username)
+        if response != "OK":
+            self.logger.error(f"Ошибка при добавлении клиента {user.telegram_id} на сервер: {response}")
+            return None, None
+
+        return new_subscription, server
+    
+    async def _check_active_subscription(self, telegram_id, session):
+        """
+        Проверяет наличие активной подписки у пользователя.
+
+        :param telegram_id: Telegram ID пользователя.
+        :param session: Текущая сессия базы данных.
+        :return: Объект подписки или None.
+        """
+        try:
+            result = await session.execute(
+                select(Subscription)
+                .join(User, Subscription.user_id == User.id)
+                .where(User.telegram_id == telegram_id, Subscription.expiry_date > datetime.utcnow())
+            )
+            return result.scalars().first()
+        except Exception as e:
+            self.logger.error(f"Ошибка проверки активной подписки для пользователя {telegram_id}: {e}")
+            return None
+
+
 
     @staticmethod
     def generate_string(length):