Dans l'article précédent, nous avons conçu la structure de notre futur portfolio. Aujourd'hui, nous allons démarrer le projet django et y modéliser cette structure grâce aux modèles.

Previously on this blog

Nous avons réflechi sur le schéma conceptuel de notre application. Après avoir listé toutes les données à stocker et les relations entre elles, nous nouss sommes arrêtés sur ce diagramme :

Créer un projet django

Maintenant que nous avons conçu l'architecture de notre application, les choses sérieuses peuvent commencer. Nous allons créer notre projet django. Pour cette étape, vous devez posséder quelques bases en python et avoir un environnement de développement django opérationnel. Si ce n'est pas le cas, je vous invite à installer django en suivant ce tutoriel (windows) ou celui-ci (officiel, en anglais).

La première étape consiste à créer la base de données (on utilisera mySQL) et l'utilisateur avec laquelle django communiquera. Vous pouvez le faire par le biais de phpmyadmin. Nommons-la "website".

Puis, dans le projet dédié à vos projets django, nous allons créer notre application (website) et son unique module (portfolio).

$ django-admin.py startproject website
$ cd website
$ django-admin startapp portfolio

A la racine du projet (website), nous allons créer deux répertoires :

• templates/, qui accueuillera les pages HTML dont on aura besoin plus tard.
• media/, où seront placés les images, css, javascript...

Enfin, toujours à la racine, créez un répertoire apps/ qui renfermera les différents modules. Ici, nous n'avons qu'un seul module, mais cela permettra de faire évoluer notre application plus simplement si vous voulez ajouter un nouveau module par la suite (Un blog par exemple !). Déplacez le répertoire portfolio/ dans ce répertoire apps/, dans lequel vous aurez pris soin de créer un fichier __init__.py vide (vous pouvez copier / coller ce fichier depuis un autre répertoire).

Vous devez alors avoir l'architecture suivante :

.
|-- __init__.py
|-- apps
|   |-- __init__.py
|   `-- portfolio
|       |-- __init__.py
|       |-- models.py
|       `-- views.py
|-- manage.py
|-- media
|-- settings.py
|-- templates
`-- urls.py

Vérifions que le projet fonctionne bien. Tapez la commande suivante pour démarrer le serveur de développement :

$ manage.py runserver

Et, à l'aide de votre navigateur, allezà l'adresse

$ http://localhost:8000

Tout fonctionne ? Parfait !

Paramétrer l'application

Maintenant, paramétrons correctement l'application en éditant le fichier settings.py.

Nous allons tout d'abord créer, en haut du fichier, une constante PROJECT_PATH qui contiendra le path global du projet.

import os.path
PROJECT_PATH = os.path.dirname(os.path.abspath(__file__))

Editez les lignes suivantes pour ajuster la langue et le fuseau horraire :

TIME_ZONE = 'Europe/Paris'
LANGUAGE_CODE = 'fr-fr'

On ajoute notre répertoire média (path et url) ainsi que celui de la future interface d'administration :

MEDIA_ROOT = os.path.join(PROJECT_PATH, 'media/')
MEDIA_URL = '/media/'
ADMIN_MEDIA_PREFIX = '/media/admin/'

On ajoute notre répertoire de templates :

TEMPLATE_DIRS = (
os.path.join(PROJECT_PATH, 'templates'),
)

Et enfin, on ajoute notre module à la liste des applications installées :

INSTALLED_APPS = ('django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.sites',
    'django.contrib.messages',
    'django.contrib.admin',
    'website.apps.portfolio',
)

Les modèles

Maintenant, éditons le fichier models.py de notre application afin d'y introduire le schéma que nous avons défini. Chaque table correspond à une classe possédant des attributs.

Commençons par la création en elle-même :

class Crea(models.Model):
    title = models.CharField(max_length=200)
    slug = models.CharField(max_length=200)
    overview = models.TextField()
    description = models.TextField()

    thumb = models.ImageField(upload_to='img/crea/thumb/')
    creation_date = models.DateTimeField()
    link = models.URLField()
    tags = models.ManyToManyField('Tag')
    picts = models.OneToManyField('Pict')

    class Meta:
        verbose_name = _('Creation')
        verbose_name_plural = _('Creations')<

    def __unicode__(self):
        return self.title

Nous avons ajouté deux champs qui n'étaient pas dans le diagramme. Il s'agit des relations. Une ManyToMany pour les tags (un tag peut être lié à plusieurs créations) et un OneToMany pour les images (une image n'est liée qu'à une seule création). C'est django qui générera tout seul la table de relation nécessaire (pour le many to many).

Passons aux tags :

class Tag(models.Model):
    name = models.CharField(max_length=200)
    slug = models.SlugField(max_length=200)

    def __unicode__(self):
        return self.tag

Et enfin, les images :

class Pict(models.Model):
    pict = models.ImageField(upload_to='creas/')
    rank = models.IntegerField()
    crea = models.ForeignKey('Crea')

    class Meta:
        verbose_name = _('Image')
        verbose_name_plural = _('Images')

    def __unicode__(self)
        return self.get_absolute_url()

Pour en savoir plus sur les différents champs utilisés dans ces modèles, je vous invite à consulter la documentation qui recence toutes les possibilités d'attributs.

Une fois que le fichier models.py a été édité, vérifions que nous n'avons pas commis d'erreur :

$ manage.py validate

Puis, synchronisons le tout avec la base de données. Django va alors créer une table par classe (plus une pour la relation entre tags et créations, donc).

$ manage.py syncdb

Les modèles sont prêts ! Dans le prochain article, nous installerons l'interface d'administration qui nous permettra d'y insérer nos premières données !