finalised backend

2025-12-15 17:18:27 +03:00
parent 036741c0bf
commit c20626c179
10 changed files with 652 additions and 0 deletions
@@ -0,0 +1,143 @@
+"""
+DI контейнер на основе dishka
+"""
+from dishka import Container, Provider, Scope, provide
+from fastapi import Request
+from sqlalchemy.ext.asyncio import AsyncSession
+from contextlib import asynccontextmanager
+
+from src.infrastructure.database.base import AsyncSessionLocal
+from src.infrastructure.repositories.postgresql.user_repository import PostgreSQLUserRepository
+from src.infrastructure.repositories.postgresql.collection_repository import PostgreSQLCollectionRepository
+from src.infrastructure.repositories.postgresql.document_repository import PostgreSQLDocumentRepository
+from src.infrastructure.repositories.postgresql.conversation_repository import PostgreSQLConversationRepository
+from src.infrastructure.repositories.postgresql.message_repository import PostgreSQLMessageRepository
+from src.infrastructure.repositories.postgresql.collection_access_repository import PostgreSQLCollectionAccessRepository
+from src.domain.repositories.user_repository import IUserRepository
+from src.domain.repositories.collection_repository import ICollectionRepository
+from src.domain.repositories.document_repository import IDocumentRepository
+from src.domain.repositories.conversation_repository import IConversationRepository
+from src.domain.repositories.message_repository import IMessageRepository
+from src.domain.repositories.collection_access_repository import ICollectionAccessRepository
+from src.infrastructure.external.yandex_ocr import YandexOCRService
+from src.infrastructure.external.deepseek_client import DeepSeekClient
+from src.application.services.document_parser_service import DocumentParserService
+from src.application.use_cases.user_use_cases import UserUseCases
+from src.application.use_cases.collection_use_cases import CollectionUseCases
+from src.application.use_cases.document_use_cases import DocumentUseCases
+from src.application.use_cases.conversation_use_cases import ConversationUseCases
+from src.application.use_cases.message_use_cases import MessageUseCases
+from src.domain.entities.user import User
+
+
+class DatabaseProvider(Provider):
+    @provide(scope=Scope.REQUEST)
+    @asynccontextmanager
+    async def get_db(self) -> AsyncSession:
+        async with AsyncSessionLocal() as session:
+            try:
+                yield session
+            finally:
+                await session.close()
+
+
+class RepositoryProvider(Provider):
+    @provide(scope=Scope.REQUEST)
+    def get_user_repository(self, session: AsyncSession) -> IUserRepository:
+        return PostgreSQLUserRepository(session)
+
+    @provide(scope=Scope.REQUEST)
+    def get_collection_repository(self, session: AsyncSession) -> ICollectionRepository:
+        return PostgreSQLCollectionRepository(session)
+
+    @provide(scope=Scope.REQUEST)
+    def get_document_repository(self, session: AsyncSession) -> IDocumentRepository:
+        return PostgreSQLDocumentRepository(session)
+
+    @provide(scope=Scope.REQUEST)
+    def get_conversation_repository(self, session: AsyncSession) -> IConversationRepository:
+        return PostgreSQLConversationRepository(session)
+
+    @provide(scope=Scope.REQUEST)
+    def get_message_repository(self, session: AsyncSession) -> IMessageRepository:
+        return PostgreSQLMessageRepository(session)
+
+    @provide(scope=Scope.REQUEST)
+    def get_collection_access_repository(self, session: AsyncSession) -> ICollectionAccessRepository:
+        return PostgreSQLCollectionAccessRepository(session)
+
+
+class ServiceProvider(Provider):
+    @provide(scope=Scope.APP)
+    def get_ocr_service(self) -> YandexOCRService:
+        return YandexOCRService()
+
+    @provide(scope=Scope.APP)
+    def get_deepseek_client(self) -> DeepSeekClient:
+        return DeepSeekClient()
+
+    @provide(scope=Scope.APP)
+    def get_parser_service(self, ocr_service: YandexOCRService) -> DocumentParserService:
+        return DocumentParserService(ocr_service)
+
+
+class AuthProvider(Provider):
+    @provide(scope=Scope.REQUEST)
+    async def get_current_user(self, request: Request, user_repo: IUserRepository) -> User:
+        from src.presentation.middleware.auth_middleware import get_current_user
+        return await get_current_user(request, user_repo)
+
+
+class UseCaseProvider(Provider):
+    @provide(scope=Scope.REQUEST)
+    def get_user_use_cases(
+        self,
+        user_repo: IUserRepository
+    ) -> UserUseCases:
+        return UserUseCases(user_repo)
+
+    @provide(scope=Scope.REQUEST)
+    def get_collection_use_cases(
+        self,
+        collection_repo: ICollectionRepository,
+        access_repo: ICollectionAccessRepository,
+        user_repo: IUserRepository
+    ) -> CollectionUseCases:
+        return CollectionUseCases(collection_repo, access_repo, user_repo)
+
+    @provide(scope=Scope.REQUEST)
+    def get_document_use_cases(
+        self,
+        document_repo: IDocumentRepository,
+        collection_repo: ICollectionRepository,
+        parser_service: DocumentParserService
+    ) -> DocumentUseCases:
+        return DocumentUseCases(document_repo, collection_repo, parser_service)
+
+    @provide(scope=Scope.REQUEST)
+    def get_conversation_use_cases(
+        self,
+        conversation_repo: IConversationRepository,
+        collection_repo: ICollectionRepository,
+        access_repo: ICollectionAccessRepository
+    ) -> ConversationUseCases:
+        return ConversationUseCases(conversation_repo, collection_repo, access_repo)
+
+    @provide(scope=Scope.REQUEST)
+    def get_message_use_cases(
+        self,
+        message_repo: IMessageRepository,
+        conversation_repo: IConversationRepository
+    ) -> MessageUseCases:
+        return MessageUseCases(message_repo, conversation_repo)
+
+
+def create_container() -> Container:
+    container = Container()
+    container.add_provider(DatabaseProvider())
+    container.add_provider(RepositoryProvider())
+    container.add_provider(ServiceProvider())
+    container.add_provider(AuthProvider())
+    container.add_provider(UseCaseProvider())
+    return container
+