init

src/infrastructure/database/repositories/user_repository.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+from datetime import datetime
+
+from fastapi import status
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.exc import IntegrityError, SQLAlchemyError
+
+from src.application.abstractions.repositories import IUserRepository
+from src.application.contracts import ILogger
+from src.application.domain.entities import UserEntity
+from src.application.domain.enums.account_type import AccountType
+from src.application.domain.exceptions import ApplicationException
+from src.infrastructure.database.models import UserModel
+
+
+class UserRepository(IUserRepository):
+    def __init__(self, session: AsyncSession, logger: ILogger):
+        self._session = session
+        self._logger = logger
+
+    def _to_entity(self, user: UserModel) -> UserEntity:
+        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,
+            encrypted_mnemonic=user.encrypted_mnemonic,
+            phone=user.phone,
+            passport_data=user.passport_data,
+            inn=user.inn,
+            erc20=user.erc20,
+            avatar_link=user.avatar_link,
+            kyc_verified=user.kyc_verified,
+            is_deleted=user.is_deleted,
+            created_at=user.created_at,
+            updated_at=user.updated_at,
+            kyc_verified_at=user.kyc_verified_at,
+            account_type=user.account_type,
+            provisioned_by=user.provisioned_by,
+            provisioned_at=user.provisioned_at,
+        )
+
+    async def create_legal_entity_user(
+        self,
+        *,
+        email: str,
+        password_hash: str,
+        provisioned_by: str,
+        provisioned_at: datetime,
+        kyc_verified: bool,
+        kyc_verified_at: datetime,
+    ) -> UserEntity:
+        user = UserModel(
+            email=email,
+            password_hash=password_hash,
+            account_type=AccountType.LEGAL_ENTITY,
+            provisioned_by=provisioned_by,
+            provisioned_at=provisioned_at,
+            kyc_verified=kyc_verified,
+            kyc_verified_at=kyc_verified_at,
+        )
+        self._session.add(user)
+        try:
+            await self._session.flush()
+            return self._to_entity(user)
+        except IntegrityError:
+            raise ApplicationException(status_code=409, message='User with this email already exists')
+        except SQLAlchemyError as exc:
+            self._logger.exception(str(exc))
+            raise ApplicationException(status_code=500, message='Database error')
+
+    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 = result.scalar_one_or_none()
+            if user is None:
+                raise ApplicationException(status_code=404, message='User not found')
+            return self._to_entity(user)
+        except ApplicationException:
+            raise
+        except SQLAlchemyError as exc:
+            self._logger.exception(str(exc))
+            raise ApplicationException(status_code=500, message='Database error')
+
+    async def exists_by_email(self, email: str) -> bool:
+        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