feat: add subscription and transaction repositories

- Implemented SubscriptionRepository with methods to get, create, and update subscriptions.
- Added BalanceTXRepository for creating and retrieving balance transactions.
- Introduced a test script for simulating Pally webhook for local testing.

repositories/bills.py

@@ -1,7 +1,7 @@
-from sqlalchemy import select
+from sqlalchemy import select, update
 from sqlalchemy.ext.asyncio import AsyncSession
 
-from db.models.bills import Bill, BillStatus
+from db.models.bills import Bill, DepositStatus
 
 
 class BillsRepository:
@@ -17,9 +17,15 @@ class BillsRepository:
         *,
         creator_id: int,
         amount: int,
-        status: BillStatus | None = BillStatus.NEW,
+        status: DepositStatus | None = DepositStatus.PENDING,
     ) -> Bill:
         bill = Bill(creator_id=creator_id, amount=amount, status=status)
         session.add(bill)
         await session.commit()
         return bill
+
+    async def update_bill_status(self, session: AsyncSession, bill_id: int, status: DepositStatus):
+        stmt = update(Bill).where(Bill.id == bill_id).values(status=status).returning(Bill)
+        result = await session.execute(stmt)
+        await session.commit()
+        return result.scalar_one_or_none()

repositories/subscriptions.py

@@ -0,0 +1,74 @@
+from datetime import datetime
+
+from sqlalchemy import select, update
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from db.models.subscriptions import Subscription, SubscriptionStatus
+
+
+class SubscriptionRepository:
+    async def get_subscription_by_user_id(
+        self, session: AsyncSession, user_id: int
+    ) -> Subscription | None:
+        stmt = select(Subscription).where(Subscription.user_id == user_id)
+        res = await session.execute(stmt)
+        return res.scalar_one_or_none()
+
+    async def create_subscription(
+        self,
+        session: AsyncSession,
+        *,
+        user_id: int,
+        end_date: datetime,
+        devices: int,
+        duration_days: int,
+        plan_price_paid: int,
+        whitelists: bool,
+        autorenew: bool = False,
+        status: SubscriptionStatus = SubscriptionStatus.EXPIRED,
+    ) -> Subscription:
+        subscription = Subscription(
+            user_id=user_id,
+            end_date=end_date,
+            autorenew=autorenew,
+            status=status,
+            devices=devices,
+            whitelists=whitelists,
+            duration_days=duration_days,
+            plan_price_paid=plan_price_paid,
+        )
+        session.add(subscription)
+        await session.commit()
+
+        return subscription
+
+    async def update_sub(
+        self,
+        session: AsyncSession,
+        user_id: int,
+        *,
+        end_date: datetime,
+        devices: int,
+        whitelists: bool,
+        duration_days: int,
+        plan_price_paid: int,
+        autorenew: bool = False,
+        status: SubscriptionStatus = SubscriptionStatus.ACTIVE,
+    ) -> Subscription | None:
+        stmt = (
+            update(Subscription)
+            .where(Subscription.user_id == user_id)
+            .values(
+                end_date=end_date,
+                autorenew=autorenew,
+                status=status,
+                devices=devices,
+                whitelists=whitelists,
+                duration_days=duration_days,
+                plan_price_paid=plan_price_paid,
+            )
+            .returning(Subscription)
+        )
+        result = await session.execute(stmt)
+        await session.commit()
+        return result.scalar_one_or_none()

repositories/transactions.py

@@ -0,0 +1,41 @@
+from datetime import datetime, timezone
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from db.models.transactions import BalanceTransaction, BalanceTxType
+
+
+class BalanceTXRepository:
+    async def create(
+        self,
+        session: AsyncSession,
+        user_id: int,
+        amount: int,
+        tx_type: BalanceTxType,
+        balance_before: int,
+        balance_after: int,
+        description: str,
+    ) -> BalanceTransaction:
+        created_at = datetime.now(timezone.UTC)
+        tx = BalanceTransaction(
+            user_id=user_id,
+            amount=amount,
+            tx_type=tx_type,
+            balance_before=balance_before,
+            balance_after=balance_after,
+            description=description,
+            created_at=created_at,
+        )
+        session.add(tx)
+        await session.commit()
+
+        return tx
+
+    async def get_transactions_by_id(
+        self, session: AsyncSession, user_id: int, limit: int = 50
+    ) -> list[BalanceTransaction]:
+        stmt = select(BalanceTransaction).where(BalanceTransaction.user_id == user_id).limit(limit)
+        res = await session.execute(stmt)
+
+        return list(res.scalars().all())

repositories/users.py

@@ -1,7 +1,10 @@
+import datetime
+
 from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from db.models import User
+from db.models.transactions import BalanceTransaction, BalanceTxType
 from schemas.users import NewUserDTO
 
 
@@ -61,12 +64,60 @@ class UserRepository:
         return user
 
     async def increase_user_balance(
-        self, session: AsyncSession, user_id: int, amount: int
+        self,
+        session: AsyncSession,
+        user_id: int,
+        amount: int,
+        tx_type: BalanceTxType,
+        description: str,
     ) -> User | None:
         user = await self.get_user_by_id(session, user_id=user_id)
         if not user:
             return None
+
+        created_at = datetime.datetime.now(datetime.UTC)
+        transaction = BalanceTransaction(
+            user_id=user_id,
+            amount=amount,
+            tx_type=tx_type,
+            balance_before=user.balance,
+            balance_after=user.balance + amount,
+            description=description,
+            created_at=created_at,
+        )
+
         user.balance += amount
 
+        session.add(transaction)
+
+        await session.commit()
+        return user
+
+    async def decrease_user_balance(
+        self,
+        session: AsyncSession,
+        user_id: int,
+        amount: int,
+        tx_type: BalanceTxType,
+        description: str,
+    ) -> User | None:
+        user = await self.get_user_by_id(session, user_id=user_id)
+        if not user or user.balance < amount:
+            return None
+
+        created_at = datetime.datetime.now(datetime.timezone.UTC)
+        transaction = BalanceTransaction(
+            user_id=user_id,
+            amount=amount,
+            tx_type=tx_type,
+            balance_before=user.balance,
+            balance_after=user.balance + amount,
+            description=description,
+            created_at=created_at,
+        )
+
+        user.balance -= amount
+        session.add(transaction)
+
         await session.commit()
         return user