feat: add mpre endpoints

src/infrastructure/database/repositories/order_repository.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 from dataclasses import replace
 from datetime import datetime,timezone
 from decimal import Decimal
-from sqlalchemy import select,update
+from sqlalchemy import desc,select,update
 from sqlalchemy.ext.asyncio import AsyncSession
 from src.application.abstractions.repositories.i_order_repository import IOrderRepository
 from src.application.contracts import ILogger
@@ -85,6 +85,26 @@ class OrderRepository(IOrderRepository):
         return self._to_entity(model)
 
 
+    async def get_by_id_for_user(self,*,order_id: str,user_id: str) -> OrderEntity | None:
+        stmt=select(Order).where(Order.id==order_id,Order.user_id==user_id)
+        model=await self._session.scalar(stmt)
+        if model is None:
+            return None
+        return self._to_entity(model)
+
+
+    async def list_by_user_id(self,*,user_id: str,limit: int,offset: int) -> list[OrderEntity]:
+        stmt=(
+            select(Order)
+            .where(Order.user_id==user_id)
+            .order_by(desc(Order.created_at))
+            .limit(limit)
+            .offset(offset)
+        )
+        result=await self._session.scalars(stmt)
+        return [self._to_entity(model) for model in result.all()]
+
+
     async def update_after_itpay_payment_created(self,order: OrderEntity) -> OrderEntity:
         if not order.id:
             raise ValueError('OrderEntity.id is required')

src/infrastructure/database/repositories/payment_repository.py

@@ -2,10 +2,11 @@ from __future__ import annotations
 
 from datetime import datetime
 from decimal import Decimal
-from sqlalchemy import select
+from sqlalchemy import desc,select
 from sqlalchemy.ext.asyncio import AsyncSession
 from src.application.abstractions.repositories.i_payment_repository import IPaymentRepository
 from src.application.contracts import ILogger
+from src.application.domain.entities import PaymentEntity
 from src.application.domain.enums import PaymentStatus
 from src.infrastructure.database.models.payment import Payment
 
@@ -16,6 +17,26 @@ class PaymentRepository(IPaymentRepository):
         self._logger=logger
 
 
+    @staticmethod
+    def _to_entity(model: Payment) -> PaymentEntity:
+        return PaymentEntity(
+            id=model.id,
+            created_at=model.created_at,
+            updated_at=model.updated_at,
+            user_id=model.user_id,
+            order_id=model.order_id,
+            status=model.status,
+            receipt_cloudekassir_id=model.receipt_cloudekassir_id,
+            receipt_cloudekassir_link=model.receipt_cloudekassir_link,
+            itpay_payment_id=model.itpay_payment_id,
+            itpay_paid_amount=model.itpay_paid_amount,
+            transaction_id=model.transaction_id,
+            web3_transaction_hash=model.web3_transaction_hash,
+            paid_at=model.paid_at,
+            expired_date=model.expired_date,
+        )
+
+
     async def create_completed(self,*,user_id:str,order_id:str,itpay_payment_id:str,itpay_paid_amount:str|None,transaction_id:str|None,paid_at:str|None,expired_date:str|None) -> bool:
         stmt=select(Payment).where(Payment.order_id==order_id)
         existing=await self._session.scalar(stmt)
@@ -52,6 +73,16 @@ class PaymentRepository(IPaymentRepository):
         return
 
 
+    async def update_status(self,*,order_id:str,status:PaymentStatus) -> None:
+        stmt=select(Payment).where(Payment.order_id==order_id)
+        model=await self._session.scalar(stmt)
+        if model is None:
+            return
+        model.status=status
+        await self._session.flush()
+        return
+
+
     async def update_receipt(self,*,order_id:str,receipt_cloudekassir_id:str|None,receipt_cloudekassir_link:str|None) -> None:
         stmt=select(Payment).where(Payment.order_id==order_id)
         model=await self._session.scalar(stmt)
@@ -63,3 +94,23 @@ class PaymentRepository(IPaymentRepository):
         await self._session.flush()
         return
 
+
+    async def get_by_order_id(self,order_id:str) -> PaymentEntity | None:
+        stmt=select(Payment).where(Payment.order_id==order_id)
+        model=await self._session.scalar(stmt)
+        if model is None:
+            return None
+        return self._to_entity(model)
+
+
+    async def list_by_user_id(self,*,user_id:str,limit:int,offset:int) -> list[PaymentEntity]:
+        stmt=(
+            select(Payment)
+            .where(Payment.user_id==user_id)
+            .order_by(desc(Payment.created_at))
+            .limit(limit)
+            .offset(offset)
+        )
+        result=await self._session.scalars(stmt)
+        return [self._to_entity(model) for model in result.all()]
+