Initial commit

src/infrastructure/database/repositories/__init__.py

@@ -0,0 +1 @@
+from src.infrastructure.database.repositories.user_repository import UserRepository

src/infrastructure/database/repositories/user_repository.py

@@ -0,0 +1,114 @@
+from __future__ import annotations
+from fastapi import status
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.exc import IntegrityError, SQLAlchemyError
+from src.application.contracts import ILogger
+from src.application.domain.exceptions import ApplicationException
+from src.application.abstractions.repositories import IUserRepository
+from src.application.domain.entities import UserEntity
+from src.infrastructure.database.models import UserModel
+
+
+class UserRepository(IUserRepository):
+    def __init__(self, session: AsyncSession, logger: ILogger):
+        self._session = session
+        self._logger = logger
+
+    async def create_user(self, email: str, password_hash: str) -> UserEntity:
+        user = UserModel(email=email, password_hash=password_hash)
+        self._session.add(user)
+        try:
+            await self._session.flush()
+            return UserEntity(
+                id=user.id,
+                email=user.email,
+                created_at=user.created_at,
+                kyc_verified=user.kyc_verified,
+                is_deleted=user.is_deleted
+            )
+
+        except IntegrityError:
+            self._logger.error(f'User already exists with email {user.email}')
+            raise ApplicationException(
+                status_code=status.HTTP_409_CONFLICT,
+                message='User with this email already exists',
+            )
+
+        except SQLAlchemyError as exception:
+            self._logger.exception(str(exception))
+            raise ApplicationException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                message=f'Database error: {str(exception)}',
+            )
+
+    async def get_user_by_email(self, email: str) -> UserEntity:
+        try:
+            stmt = (
+                select(UserModel)
+                .where(
+                    UserModel.email == email,
+                    UserModel.is_deleted.is_(False),
+                )
+            )
+
+            result = await self._session.execute(stmt)
+            user: UserModel | None = result.scalar_one_or_none()
+
+            if user is None:
+                self._logger.warning(f'User not found with email {email}')
+                raise ApplicationException(status_code=status.HTTP_404_NOT_FOUND, message='User not found',)
+
+            return UserEntity(
+                id=user.id,
+                email=user.email,
+                password_hash=user.password_hash,
+                first_name=user.first_name,
+                middle_name=user.middle_name,
+                last_name=user.last_name,
+                birth_date=user.birth_date,
+                crypto_wallet=user.crypto_wallet,
+                phone=user.phone,
+                bik=user.bik,
+                account_number=user.account_number,
+                card_number=user.card_number,
+                inn=user.inn,
+                kyc_verified_at=user.kyc_verified_at,
+                kyc_verified=user.kyc_verified,
+                is_deleted=user.is_deleted,
+                created_at=user.created_at,
+                updated_at=user.updated_at,
+            )
+
+        except ApplicationException:
+            raise
+
+        except SQLAlchemyError as exception:
+            self._logger.exception(str(exception))
+            raise ApplicationException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                message=f'Database error: {str(exception)}',
+            )
+
+    async def exists_by_email(self, email: str) -> bool:
+        try:
+            stmt = (
+                select(UserModel.id)
+                .where(
+                    UserModel.email == email,
+                    UserModel.is_deleted.is_(False),
+                )
+                .limit(1)
+            )
+
+            result = await self._session.execute(stmt)
+            return result.scalar_one_or_none() is not None
+
+        except SQLAlchemyError as exception:
+            self._logger.exception(str(exception))
+            raise ApplicationException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                message=f'Database error: {str(exception)}',
+            )
+
+