Source code for src.share_kernel.infrastructure.base_django_repo

import uuid
from abc import abstractmethod
from typing import Generic, Type, TypeVar

from django.db import models

from src.share_kernel.domain.base_aggregate import AggregateRoot
from src.share_kernel.domain.base_repository import Repository
from src.share_kernel.domain.exceptions import EntityNotFoundException

TAggregate = TypeVar("TAggregate", bound=AggregateRoot)
TModel = TypeVar("TModel", bound=models.Model)




class DjangoRepository(Repository[TAggregate], Generic[TAggregate, TModel]):
    """
    Implémentation de base d'un repository Django.
    Fournit le mapping entre le modèle Django (ORM) et l'agrégat domaine.
    """

    aggregate_class: Type[TAggregate]
    model_class: Type[TModel]



    def get_by_id(self, entity_id: uuid.UUID) -> TAggregate | None:
        try:
            model_instance = self.model_class.objects.get(pk=entity_id)
            return self._to_aggregate(model_instance)
        except self.model_class.DoesNotExist:
            return None




    def get_by_id_or_raise(self, entity_id: uuid.UUID) -> TAggregate:
        aggregate = self.get_by_id(entity_id)
        if aggregate is None:
            raise EntityNotFoundException(self.aggregate_class.__name__, entity_id)
        return aggregate




    def save(self, entity: TAggregate) -> None:
        model_instance = self._to_model(entity)
        model_instance.save()




    def delete(self, entity_id: uuid.UUID) -> None:
        self.model_class.objects.filter(pk=entity_id).delete()




    @abstractmethod
    def _to_aggregate(self, model_instance: TModel) -> TAggregate:
        """Convertit un modèle ORM en agrégat domaine."""
        raise NotImplementedError




    @abstractmethod
    def _to_model(self, aggregate: TAggregate) -> TModel:
        """Convertit un agrégat domaine en modèle ORM."""
        raise NotImplementedError