Рефакторинга чуть чуть вроде

app/services/postgres_rep.py

@@ -1,7 +1,10 @@
+from datetime import datetime
+from uuid import UUID
 from sqlalchemy.future import select
 from sqlalchemy.exc import SQLAlchemyError
+from decimal import Decimal
 from sqlalchemy import desc
-from instance.model import User, Subscription, Transaction
+from instance.model import TicketMessage, User, Subscription, Transaction
 
 
 class PostgresRepository:
@@ -23,6 +26,23 @@ class PostgresRepository:
                 self.logger.error(f"Ошибка при создании пользователя {telegram_id}: {e}")
                 await session.rollback()
                 return None
+    async def get_active_subscription(self, telegram_id: int):
+        """
+        Проверяет наличие активной подписки у пользователя.
+        """
+        async for session in self.session_generator():
+            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())
+                )
+                result= result.scalars().first()
+                self.logger.info(f"Пользователь с id {telegram_id}, проверен и имеет {result}")
+                return result
+            except SQLAlchemyError as e:
+                self.logger.error(f"Ошибка проверки активной подписки для пользователя {telegram_id}: {e}")
+                return None
 
     async def get_user_by_telegram_id(self, telegram_id: int):
         """
@@ -31,61 +51,40 @@ class PostgresRepository:
         async for session in self.session_generator():
             try:
                 result = await session.execute(select(User).where(User.telegram_id == telegram_id))
-                return result.scalars().first()
+                if result:
+                    return result.scalars().first()
+                return False
             except SQLAlchemyError as e:
                 self.logger.error(f"Ошибка при получении пользователя {telegram_id}: {e}")
-                return None
+                return False
+            
 
-    async def add_transaction(self, user_id: int, amount: float):
-        """
-        Добавляет транзакцию для пользователя.
-        """
-        async for session in self.session_generator():
-            try:
-                transaction = Transaction(user_id=user_id, amount=amount)
-                session.add(transaction)
-                await session.commit()
-            except SQLAlchemyError as e:
-                self.logger.error(f"Ошибка добавления транзакции для пользователя {user_id}: {e}")
-                await session.rollback()
-
-    async def update_balance(self, telegram_id: int, amount: float):
+    async def update_balance(self, user: User, amount: float):
         """
         Обновляет баланс пользователя.
+
+        :param user: Объект пользователя.
+        :param amount: Сумма для добавления/вычитания.
+        :return: True, если успешно, иначе False.
         """
+        self.logger.info(f"Обновление баланса пользователя: id={user.id}, current_balance={user.balance}, amount={amount}")
         async for session in self.session_generator():
             try:
-                result = await session.execute(select(User).where(User.telegram_id == telegram_id))
-                user = result.scalars().first()
-                if user:
-                    user.balance += amount
-                    await session.commit()
-                    return user
-                else:
-                    self.logger.warning(f"Пользователь с Telegram ID {telegram_id} не найден.")
-                    return None
+                user = await session.get(User, user.id)  # Загружаем пользователя в той же сессии
+                if not user:
+                    self.logger.warning(f"Пользователь с ID {user.id} не найден.")
+                    return False
+                # Приведение amount к Decimal
+                user.balance += Decimal(amount)
+                await session.commit()
+                self.logger.info(f"Баланс пользователя id={user.id} успешно обновлен: new_balance={user.balance}")
+                return True
             except SQLAlchemyError as e:
-                self.logger.error(f"Ошибка при обновлении баланса: {e}")
+                self.logger.error(f"Ошибка при обновлении баланса пользователя id={user.id}: {e}")
                 await session.rollback()
-                return None
+                return False
 
-    async def last_subscription(self, user_id: int):
-        """
-        Возвращает последние подписки пользователя.
-        """
-        async for session in self.session_generator():
-            try:
-                result = await session.execute(
-                    select(Subscription)
-                    .where(Subscription.user_id == user_id)
-                    .order_by(desc(Subscription.created_at))
-                )
-                return result.scalars().all()
-            except SQLAlchemyError as e:
-                self.logger.error(f"Ошибка при получении последней подписки пользователя {user_id}: {e}")
-                return None
-
-    async def last_transaction(self, user_id: int):
+    async def get_last_transactions(self, user_id: UUID, limit: int = 10):
         """
         Возвращает последние транзакции пользователя.
         """
@@ -95,8 +94,50 @@ class PostgresRepository:
                     select(Transaction)
                     .where(Transaction.user_id == user_id)
                     .order_by(desc(Transaction.created_at))
+                    .limit(limit)
                 )
                 return result.scalars().all()
             except SQLAlchemyError as e:
-                self.logger.error(f"Ошибка при получении транзакций пользователя {user_id}: {e}")
+                self.logger.error(f"Ошибка получения транзакций пользователя {user_id}: {e}")
                 return None
+    
+    async def get_last_subscription_by_user_id(self, user_id: UUID, limit: int = 1):
+        """
+        Извлекает последнюю подписку пользователя на основании user_id.
+
+        :param user_id: UUID пользователя.
+        :return: Объект Subscription или None.
+        """
+        async for session in self.session_generator():
+            try:
+                result = await session.execute(
+                    select(Subscription)
+                    .where(Subscription.user_id == user_id)
+                    .order_by(desc(Subscription.created_at))
+                    .limit(limit)
+                )
+                subscriptions = list(result.scalars())
+                self.logger.info(f"Найдены такие подписки: {subscriptions}")
+                return subscriptions
+            except SQLAlchemyError as e:
+                self.logger.error(f"Ошибка при получении подписки для пользователя {user_id}: {e}")
+                return None
+    
+    async def add_record(self, record):
+        """
+        Добавляет запись в базу данных.
+
+        :param record: Объект записи.
+        :return: Запись или None в случае ошибки.
+        """
+        async for session in self.session_generator():
+            try:
+                session.add(record)
+                await session.commit()
+                return record
+            except SQLAlchemyError as e:
+                self.logger.error(f"Ошибка при добавлении записи: {record}: {e}")
+                await session.rollback()
+                return None
+
+