init

src/infrastructure/database/repositories/legal_entity_repository.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+from typing import Any
+
+from fastapi import status
+from sqlalchemy import func, select, update
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.exc import IntegrityError, SQLAlchemyError
+
+from src.application.abstractions.repositories import ILegalEntityRepository
+from src.application.contracts import ILogger
+from src.application.domain.entities.organization import LegalEntityEntity
+from src.application.domain.exceptions import ApplicationException
+from src.infrastructure.database.models import LegalEntityModel
+
+
+class LegalEntityRepository(ILegalEntityRepository):
+    def __init__(self, session: AsyncSession, logger: ILogger):
+        self._session = session
+        self._logger = logger
+
+    def _to_entity(self, m: LegalEntityModel) -> LegalEntityEntity:
+        return LegalEntityEntity(
+            id=m.id,
+            user_id=m.user_id,
+            name=m.name,
+            short_name=m.short_name,
+            inn=m.inn,
+            ogrn=m.ogrn,
+            kpp=m.kpp,
+            legal_address=m.legal_address,
+            actual_address=m.actual_address,
+            bank_details=m.bank_details,
+            contact_person=m.contact_person,
+            contact_phone=m.contact_phone,
+            status=m.status,
+            kyc_verified=m.kyc_verified,
+            kyc_verified_at=m.kyc_verified_at,
+            encrypted_mnemonic=m.encrypted_mnemonic,
+            created_by=m.created_by,
+            created_at=m.created_at,
+            updated_at=m.updated_at,
+        )
+
+    async def create(
+        self,
+        *,
+        user_id: str,
+        name: str,
+        short_name: str | None,
+        inn: str,
+        ogrn: str | None,
+        kpp: str | None,
+        legal_address: str | None,
+        actual_address: str | None,
+        bank_details: dict[str, Any] | None,
+        contact_person: str | None,
+        contact_phone: str | None,
+        status: str,
+        kyc_verified: bool,
+        kyc_verified_at,
+        created_by: str | None,
+    ) -> LegalEntityEntity:
+        entity = LegalEntityModel(
+            user_id=user_id,
+            name=name,
+            short_name=short_name,
+            inn=inn,
+            ogrn=ogrn,
+            kpp=kpp,
+            legal_address=legal_address,
+            actual_address=actual_address,
+            bank_details=bank_details,
+            contact_person=contact_person,
+            contact_phone=contact_phone,
+            status=status,
+            kyc_verified=kyc_verified,
+            kyc_verified_at=kyc_verified_at,
+            created_by=created_by,
+        )
+        self._session.add(entity)
+        try:
+            await self._session.flush()
+            return self._to_entity(entity)
+        except IntegrityError:
+            raise ApplicationException(status_code=409, message='Organization with this INN or user already exists')
+        except SQLAlchemyError as exc:
+            self._logger.exception(str(exc))
+            raise ApplicationException(status_code=500, message='Database error')
+
+    async def get_by_id(self, organization_id: str) -> LegalEntityEntity:
+        res = await self._session.execute(select(LegalEntityModel).where(LegalEntityModel.id == organization_id))
+        m = res.scalar_one_or_none()
+        if m is None:
+            raise ApplicationException(status_code=404, message='Organization not found')
+        return self._to_entity(m)
+
+    async def list_all(self, *, limit: int, offset: int) -> list[LegalEntityEntity]:
+        res = await self._session.execute(
+            select(LegalEntityModel).order_by(LegalEntityModel.created_at.desc()).limit(limit).offset(offset)
+        )
+        return [self._to_entity(m) for m in res.scalars().all()]
+
+    async def count_all(self) -> int:
+        res = await self._session.execute(select(func.count()).select_from(LegalEntityModel))
+        return int(res.scalar_one())
+
+    async def update(self, organization_id: str, *, values: dict[str, Any]) -> LegalEntityEntity:
+        if not values:
+            return await self.get_by_id(organization_id)
+        await self._session.execute(
+            update(LegalEntityModel).where(LegalEntityModel.id == organization_id).values(**values)
+        )
+        await self._session.flush()
+        return await self.get_by_id(organization_id)
+
+    async def set_encrypted_mnemonic(self, organization_id: str, encrypted_mnemonic: str) -> None:
+        await self._session.execute(
+            update(LegalEntityModel)
+            .where(LegalEntityModel.id == organization_id)
+            .values(encrypted_mnemonic=encrypted_mnemonic)
+        )
+        await self._session.flush()