Réduire la complexité des modèles Django avec des objets de valeur
Implémentation du modèle d'objet de valeur
Martin Fowler définit les objets de valeur de la manière suivante :
Un petit objet simple, comme de l'argent ou une plage de dates, dont l'égalité n'est pas basée sur l'identité.
D'accord, mais qu'est-ce que ça veut dire ?
La chose importante à propos des objets de valeur est qu'ils sont égaux les uns aux autres s'ils ont les mêmes informations, pas seulement s'ils sont le même objet en mémoire. Ainsi, deux objets de valeur qui représentent la même date ou la même somme d'argent seraient considérés comme égaux. De plus, les objets de valeur sont déclarés comme immuables, ce qui signifie que leurs valeurs ne peuvent pas être modifiées après leur création, ce qui garantit davantage la cohérence des données dans une application.
L'utilisation d'objets de valeur permet d'éviter le problème de «l'obsession primitive», qui se produit lorsque nous utilisons des types de données de base comme des entiers ou des chaînes à la place de structures de données plus significatives. Par exemple, utiliser une chaîne pour représenter une adresse e-mail. En utilisant des objets de valeur, nous pouvons créer des représentations de données plus significatives et autonomes.
Le concept d'objets de valeur provient de la conception pilotée par le domaine (DDD) et est utilisé avec des entités et des agrégats pour modéliser des modèles de domaine. Dans cet article, je vais démontrer l'utilisation des objets de valeur avec des modèles Django bruts. Cela peut servir de première étape utile vers une meilleure architecture ou simplement comme une mesure de refactorisation qui aide à garder les modèles concis et moins complexes.
Pour illustrer l'utilisation des objets de valeur dans les modèles Django, examinons un scénario courant : décrire les dates de début et de fin d'un événement. Une implémentation de base de ceci pourrait ressembler à ce qui suit :
class Appointment(models.Model):
start = models.DateTimeField(null=True)
end = models.DateTimeField(null=True)
Par exemple, vous devrez peut-être vérifier si un rendez-vous en chevauche un autre ou déterminer s'il commence avant ou après un autre événement.
Pour gérer ces scénarios, nous pouvons utiliser un objet de valeur personnalisé pour décrire la plage de dates d'un rendez-vous.
@dataclass(frozen=True) (1)
class DateRange:
start: datetime
end: datetime
def __post_init__(self) -> None: (2)
if self.start >= self.end:
raise ValueError("Can not end before starting.")
def __str__(self) -> str:
return f"DateRange({self.start} - {self.end})"
def __add__(self, other: timedelta) -> "DateRange": (3)
if isinstance(other, timedelta):
return DateRange(self.start + other, self.end + other)
raise TypeError()
def hour_later(self) -> "DateRange": (4)
return self + timedelta(hours=1)
@property
def duration(self) -> timedelta: (5)
return self.end - self.start
def overlaps(self, date_range: "DateRange") -> bool: (5)
return (self.start <= date_range.end
and self.end >= date_range.start)
def starts_before(self, date_range: "DateRange") -> bool: (5)
return self.start < date_range.start
def range(self, step: timedelta) -> Iterator[datetime]: (5)
current_datetime = self.start
while current_datetime <= self.end:
yield current_datetime
current_datetime = current_datetime + step
- Validation de base pour s'assurer que le modèle est toujours dans un état valide.
- L'ajout de deux plages de dates n'a pas de sens, nous remplaçons donc l'
+opérateur pour permettre la reprogrammation. Puisque notre classe est immuable, nous devons retourner un nouvel objet. - Comme alternative plus détaillée, nous pouvons utiliser des méthodes précédemment déclarées pour créer des fonctions qui utilisent le "langage métier", ce qui rend le code plus facile à comprendre.
- Des utilitaires communs pourraient être cachés derrière une interface simple.
class Appointment(models.Model):
_start = models.DateTimeField(null=True) (1)
_end = models.DateTimeField(null=True)
objects = CustomManager()
@property
def date_range(self) -> DateRange: (2)
return DateRange(self._start, self._end)
@date_range.setter
def date_range(self, value: DateRange) -> None: (3)
self._start = value.start
self._end = value.end
@classmethod
def new_in_date_range(cls, date_range: DateRange): (4)
return cls(_start=date_range.start, _end=date_range.end)
- La propriété Getter renvoie l'
DateRangeobjet de valeur. - Permet d'affecter un
DateRangeobjet à unAppointment. - La
new_in_date_rangeméthode est une méthode de fabrique qui crée de nouveauxAppointmentobjets avec unDateRangeobjet de valeur.
class CustomManager(models.Manager):
def get_queryset(self):
return CustomQuerySet(self.model, using=self._db)
def in_range(self, date_range: DateRange):
return self.get_queryset().filter(
_start__gt=date_range.start,
_end__lt=date_range.end
)
class CustomQuerySet(models.QuerySet):
def filter(self, *args, **kwargs):
date_range = kwargs.get("date_range")
if date_range and isinstance(date_range, DateRange):
kwargs["_start"] = date_range.start
kwargs["_end"] = date_range.end
return super().filter(*args, **kwargs)
Voici d'autres exemples d'objets de valeur :
- Argent : Deux montants de devises différentes ne peuvent pas être additionnés.
- Taux de TVA : Une distinction peut être faite entre un
VatRatede "0" et unVatRatede "NOT_APPLIES", même s'ils sont tous les deux évalués à 0. - Fuseau horaire
- Adresse.
![Qu'est-ce qu'une liste liée, de toute façon? [Partie 1]](https://post.nghiatu.com/assets/images/m/max/724/1*Xokk6XOjWyIGCBujkJsCzQ.jpeg)



































