Ajout des modèles à notre application

Les modèles Django

Comme avec beaucoup de frameworks web, les modèles Django sont des classes qui héritent d'une classe du framework (classe qui s'appelle… Model !). En faisant hériter vos modèles de cette fameuse classe, vous leur conférez, de facto, toutes les propriétés et méthodes relatives aux modèles (gestion de l'ORM, etc.).

Syntaxe de déclaration d'un modèle

Vous l'aurez compris, c'est dans le fichier models.py de notre application que nous allons créer tous nos modèles. Voici la syntaxe :

from django.db import models

class MonModel(models.Model):
    """
    La doc de mon modèle.
    """
    un_champ_texte = models.CharField(max_length=150)

Types de champs disponibles

En créant un modèle Django, nous allons utiliser le système d'ORM du framework. En d'autres termes, Django propose quelques types de champs (~ d'attributs) disponibles pour utilisation dans nos modèles, qu'il se chargera de mapper automatiquement avec les champs de base de données. En voici une liste non-exhaustive :

Nous n'allons pas lister ici tous les champs qu'il est possible d'utiliser dans un modèle. Une liste exhaustive est disponible sur la documentation officielle de Django, section Model field reference.

Chaque type de champ admet un certain nombre de paramétrages, que Django appelle des options. Nous n'allons pas non-plus tous les lister, mais voici les plus utilisés :

• null=True|False : Permet de spécifier si le champ correspondant en BDD peut être NULL ou pas.
• blank=True|False : Permet de spécifier si, dans les formulaires de l'application, le champ peut être laissé vide ou pas.
• max_length=<int> : Permet de spécifier la longueur maximale d'un CharField (généralement, la limite est de 255 caractères)
• default=<int|str|boolean...> : Permet de spécifier une valeur par défaut pour le champ

Voici un exemple d'utilisation de ces options dans le cadre de la déclaration d'un modèle :

from django.db import models

class MonModel(models.Model):
    un_champ_texte = models.CharField(max_length=150, null=True, blank=True, default="Coucou")

Modèles de notre application

OK, nous connaissons maintenant les principales caractéristiques de modèles et la syntaxe de leur déclaration.

Nous pouvons à présent créer une première version de nos modèles :

# -*-coding: UTF-8-*-
from django.db import models
from django.contrib.auth.models import User

class Team(models.Model):
    """
    Une équipe scrum est un ensemble de personnes qui travaillent sur un projet.
    """
    members = models.ManyToManyField(User)
    name = models.CharField(max_length=150)

class Project(models.Model):
    """
    La représentation d'un projet dans le système.
    Un projet est pris en charge par une équipe.
    """
    team = models.ForeignKey(Team)
    name = models.CharField(max_length=150)

class ProductBacklog(models.Model):
    """
    Un backlog produit Scrum contient un ensemble de user stories.
    Chaque backlog est systématiquement rattaché à un projet.
    """
    team = models.ForeignKey(Team)
    name = models.CharField(max_length=150)

class Sprint(models.Model):
    """
	Le sprint est une itération en Scrum, réalisée par une équipe.
	Dand un sprint, une équipe peut travailler sur plusieurs projets.
    """
    team = models.ForeignKey(Team)
    begin_date = models.DateTimeField()
    end_date = models.DateTimeField()

class UserStory(models.Model):
    """
    Une user story est une demande client.
    """
    product_backlog = models.ForeignKey(ProductBacklog)
    name = models.CharField(max_length=255)
    description = models.TextField()

Création des tables de base de données

Nous avons à présent de jolis modèles, mais rien pour stocker les données qui en découleront. Pour pallier ce problème, nous allons faire dans le classique : nous utiliserons une base de données relationnelle.

Pour éviter d'avoir à installer un serveur de BDD comme PostgreSQL ou MySQL, nous allons utiliser SQLite. Sachant que puisque nous utilisons un ORM, nous serons libre, plus tard, notamment si le projet obtient le succès qu'il mérite (☺), de switcher très simplement vers un autre SGBD, en modifiant juste la configuration de notre projet.

Pour utiliser SQLite, nous n'avons rien de spécial à faire, si ce n'est de fournir le nom du fichier de BDD à Django dans notre fichier de configuration.

Modification du fichier settings.py

Pour préciser à Django que nous souhaitons utiliser SQLite, nous allons modifier le fichier settings.py de notre projet. Ouvrez le fichier, cherchez la variable DATABASES, et modifiez là pour qu'elle ressemble à ceci :

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': 'scrum_db',
    }
}

Tant que nous sommes sur le fichier settings.py, modifions également la section INSTALLED_APPS, pour préciser à Django que nous souhaitons aussi utiliser, dans ce projet, notre application chistera :

INSTALLED_APPS = (
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.sites',
    'django.contrib.messages',
    'django.contrib.staticfiles',

    'chistera'
)

Sauvegardez le fichier.

Syncdb

OK, Django sait maintenant où écrire ses données !

Nous allons maintenant lui demander de créer les tables de la base de données pour nous, à partir des informations que nous lui avons fournies dans les modèles de nos applications (en l’occurrence, de notre application, puisque notre projet n'en comporte qu'une pour le moment).

Nous allons encore une fois utiliser la commande python manage.py, avec l'argument syncdb :

$ python manage.py syncdb

Django commence alors à créer les tables de la base de données, et vous demande quelques informations pour y insérer quelques données :

Creating tables ...
Creating table auth_permission
Creating table auth_group_permissions
Creating table auth_group
Creating table auth_user_groups
Creating table auth_user_user_permissions
Creating table auth_user
Creating table django_content_type
Creating table django_session
Creating table django_site
Creating table chistera_team
Creating table chistera_project
Creating table chistera_productbacklog
Creating table chistera_sprint
Creating table chistera_userstory

You just installed Django's auth system, which means you don't have any superusers defined.
Would you like to create one now? (yes/no): yes
Username (leave blank to use 'pascal'):
Email address: contact@formation-django.fr
Password:
Password (again):
Superuser created successfully.
Installing custom SQL ...
Installing indexes ...
Installed 0 object(s) from 0 fixture(s)

OK, notre base de données est à présent créée, et comporte les tables nécessaires au fonctionnement de notre application. Si vous listez le contenu du répertoire de votre projet, vous devez y voir un nouveau fichier, nommé scrum_db. C'est notre base de données SQLite !

Par curiosité, vous pouvez ouvrir votre base de données SQLite pour voir ce qu'elle contient. Plusieurs outils existent : à moindre frais, vous pouvez utiliser le plugin Firefox SQLite Manager !

Instaler SQLite Manager pour Firefox

Modèles, BDD : check !

Notre projet et notre application prennent forme ! Nous allons maintenant voir comment disposer, en quelques secondes, d'une interface d'administration puissante permettant d'éditer nos données : c'est l'objet du tutoriel sur le scaffolding avec Django.

Testez vos connaissances

class Page(models.Model):
    author = models.ForeignKey(User, null=True, blank=True, verbose_name="auteur")
    title = models.CharField(max_length=255, blank=True)

• ← Création d'une application