• 20 hours
  • Medium

Free online content available in this course.

course.header.alt.is_video

course.header.alt.is_certifying

Got it!

Last updated on 12/12/19

Ajoutez des relations entre les modèles

Log in or subscribe for free to enjoy all this course has to offer!

Dans le chapitre précédent vous avez appris à créer votre premier modèle ! Dans celui-ci nous irons plus loin puisque vous ajouterez trois autres modèles. Vous apprendrez également à ajouter des liaisons un à un (one to one), plusieurs à  un (many to one) et plusieurs à plusieurs (many to many). C'est parti !

Ajout des trois modèles

Avant de lire ma proposition, prenez exemple sur le modèle Artist pour créer les suivants en vous appuyant sur le diagramme SQL.

Lisez également la documentation pour trouver la manière de créer les champs souhaités.

Vous avez fini ? Voici mon code :

class Contact(models.Model):
    email = models.EmailField(max_length=100)
    name = models.CharField(max_length=200)


class Album(models.Model):
    reference = models.IntegerField(null=True)
    created_at = models.DateTimeField(auto_now_add=True)
    available = models.BooleanField(default=True)
    title = models.CharField(max_length=200)
    picture = models.URLField()


class Booking(models.Model):
    created_at = models.DateTimeField(auto_now_add=True)
    contacted = models.BooleanField(default=False)

Reprenons pas à pas...

Le modèle Contact

class Contact(models.Model):
    email = models.EmailField(max_length=100)
    name = models.CharField(max_length=200)

Contact comprend deux champs, un pour l'email et l'autre pour le nom de la personne. Les modèles de Django possèdent deux classes très utiles pour cela : EmailField et CharField.

A quoi servent-elles ? Existe-t-il un type de données "EMAIL" en PostgreSQL ?

Non, ces deux champs seront stockés de la même manière en tant que VARCHAR. Mais ils vous seront très utiles lorsque vous créerez le formulaire de contact ! En effet, Django facilite la vie des développeurs en contenant de nombreux validateurs surpuissants. Je m'explique ! Imaginez qu'un utilisateur entre son adresse e-mail dans le formulaire de contact. Si l'adresse est valide, pas de souci. Mais que se passe-t-il s'il oublie un point ? Une arobase ? L'adresse sera fausse et le disquaire ne pourra pas le contacter. Tristesse ! Afin d'éviter ce scénario catastrophe, Django propose de valider automatiquement les données. Nous en reparlerons.

Le modèle Album

class Album(models.Model):
    reference = models.IntegerField(null=True)
    created_at = models.DateTimeField(auto_now_add=True)
    available = models.BooleanField(default=True)
    title = models.CharField(max_length=200)
    picture = models.URLField()

Que de nouveaux champs ! Commentons-les :

  • IntegerField : seul un entier est accepté. A travers le paramètre null=True, j'indique que ce champ est optionnel puisque le disquaire peut choisir de le laisser vide.

  • DateTimeField : la date et l'heure de création de l'album. Le paramètre auto_now_add=True assigne automatiquement la valeur du champ à la date du jour et à l'heure du premier enregistrement de l’objet.

  • BooleanField : un booléen dont la valeur par défaut est fixée àTrue. Nous effectuerons des recherches en utilisant ce filtre donc il est important qu'une valeur par défaut soit donnée.

  • URLField : une chaîne de caractères qui sera de forme "URL".

Le modèle Booking

class Booking(models.Model):
    created_at = models.DateTimeField(auto_now_add=True)
    contacted = models.BooleanField(default=False)

Nous avons déjà vu dans les paragraphes précédents les classes DateTimeField et BooleanField donc je ne reviendrai pas dessus.

Remarquez simplement que j'ai de nouveau indiqué une valeur par défaut au champ contacted. Pourquoi ? Car lors d'une nouvelle réservation, le client n'est pas encore contacté ! Le disquaire cochera la case "contacté" lorsque ce sera fait.

Bien bien, vous avez tous les modèles qu'il vous faut ! Passons désormais à l'étape suivante : les liaisons entre les tables.

Ajout des relations

Dans le chapitre précédent, j'ai expliqué que le champ id était ajouté par défaut à la création de toute nouvelle table. Si vous regardez de plus près la requête SQL, vous verrez que ce champ est également désigné comme étant la clé primaire :

CREATE TABLE store_artist (
    "id" serial NOT NULL PRIMARY KEY,
    "name" varchar(200) NOT NULL UNIQUE
);

Nul besoin, donc, d'ajouter la clé primaire aux tables : c'est déjà fait ! 🎁

Pour rappel, les trois types de relations dans une table SQL sont les suivantes :

  • un à un (one to one) : un objet A possède un objet B. Autrement dit, une tasse a une soucoupe et une soucoupe appartient à une tasse. Dans notre projet, un album a une réservation et une réservation appartient à un album.

  • plusieurs à un (many to one) : un objet A possède plusieurs objets B et ce dernier n'appartient qu'à l'objet A. Autrement dit, un service de table compte plusieurs assiettes et une assiette appartient à un service. Dans notre projet, un contact a plusieurs réservations et une réservation appartient à un contact.

  • plusieurs à plusieurs (many to many) : un objet A possède plusieurs objets B et un objet B appartient à plusieurs objets A. Autrement dit, des assiettes ont plusieurs couverts et les couverts appartiennent à plusieurs assiettes. Dans notre projet, un album appartient à plusieurs artistes et un artiste possède plusieurs albums.

Comme d'habitude, Django nous facilite la vie. Voyons comment ajouter les relations !

Relation un à un

Les relations se déclarent dans la classe qui contient la clé étrangère. Commençons par les réservations qui ont deux relations : one to one et many to one.

Utilisez la classe OneToOneField pour déclarer une relation un à un :

models.py

class Booking(models.Model):
    ...
    album = models.OneToOneField(Album)

Et voilà, vous n'avez plus rien à faire ! :)

Relation plusieurs à un

Une réservation appartient à un contact et ce dernier peut en avoir plusieurs. La clé étrangère sera donc dans la table store_booking :

models.py

class Booking(models.Model):
    ...
    contact = models.ForeignKey(Contact, on_delete=models.CASCADE)

J'ai ajouté un paramètre optionnel, on_delete=models.CASCADE, qui supprime toutes les réservations faites par un contact si ce dernier est supprimé. Mais pas l'inverse (heureusement !) : si une réservation est supprimée, le contact reste dans la base ! En savoir plus

Relation plusieurs à plusieurs

Enfin, ajoutons la relation entre les artistes et les albums :

models.py

class Album(models.Model):
    ...
    artists = models.ManyToManyField(Artist, related_name='albums', blank=True)

Le paramètre related_name indique le nom à utiliser pour la relation inverse depuis l'objet lié vers celui-ci. Nous reviendrons sur ce point lorsque je vous montrerai comment trouver les albums liés à un artiste et inversement.

Nos modèles sont créés et les relations sont faites ! Pourtant, les tables ne sont pas encore créées dans la base de données. Comment faire ? Découvrez-le dans le prochain chapitre !

Code de ce chapitre

Retrouvez l'intégralité du code de ce chapitre sur le dépôt GitHub.

Example of certificate of achievement
Example of certificate of achievement