Django_Models

Qu’est ce que c’est DJANGO
DJANGO est un framework web basé sur (python ).Sa force est qu’ il
est extrêmement bien conçu .DJANGO est à la fois simple et puissant
.Il tire le maximum du PYTHON et vous permet d’écrire un application
5 fois plus vite qu’avec les frameworks classiques .

Le but de cet article est de vous donner un avant gout du Django par la pratique.
Problème:
Une école vous demande de lui programmer un petit logiciel permettant
des répondre aux exigences suivantes .
1 .Lister tous les étudiants inscrits
2 .Lister tous les professeurs inscrits
3 .Pour chaque étudiant permettre un accès
à la liste de ses cours ainsi qu’a la liste
de ses cours du jour .

4 .Pour chaque professeur ,accéder à la liste des cours
qu’il dispense , ainsi que les étudiants qui suivent
ses cours .

1 .Installation de DJANGO.
Je ne vais pas détailler  cette partie , vous pouvez avoir toutes
les informations sur le site de DJANGO    http://docs.djangoproject.com

Pour cette seconde partie toutes les manipulations sont faites sur  UBUNTU ,
,naturellement vous pouvez aussi travailler sous WINDOW ,
mais laissez tomber , WINDOW c’est pour les nulls 😉

2 .Création d’un nouveau projet DJANGO
command>
alioune@alioune-laptop:~$ django-admin.py startproject mysite
resultat>

alioune@alioune-laptop:~/mysite$ ls
__init__.py manage.py settings.py urls.py

2 .Création d ‘un nouveau site
command>
alioune@alioune-laptop:~/mysite$ ./manage.py startapp xaleyi
resultat>
alioune@alioune-laptop:~/mysite$ ls
__init__.py __init__.pyc manage.py settings.py settings.pyc urls.py xaleyi

command>
cd xaleyi
resultat>
alioune@alioune-laptop:~/mysite/xaleyi$ ls
__init__.py models.py views.py

3 .Création des models de données
Étudiants:
Nous créons un model (Etudiants) avec  les deux attributs:
(age , nom)

Professeurs:
Le model de données qui décrit un professeur de ce collège avec la liste des attributs suivants:
(nom,email)

Cours:
Le model qui décrit un cours , avec les attributs:
(lang ,date_start ,date_end , professeur , etudiants)

Nous obtenons le programme suivant :

———————————————–

from django.db import models
from datetime import date
from datetime import datetime
# Create your models here.

# Class Model pour Etudiant
class Etudiants(models.Model):
    nom =models.CharField (max_length=200)
    age =models.IntegerField ()
    # Liste des cours de l'etudiant
    @property
    def cours(self):
        # All cours
       return  self.cours_set.all()

    # Liste des cours du jours pour l'etudiant
    @property
    def cours_today(self):

        # List of availables cours  to day
        from datetime import date
        # Today
        td = date.today()
         return self.cours_set.filter (
            date_start__year  =td.year  ,
            date_start__month =td.month ,
            date_start__day   =td.day)
# Le model Professeur 
class Professeurs (models.Model):
    nom = models.CharField (max_length =200)
    email =models.EmailField ()

    # La liste des cours qui sont dispensé par le professeur
    @property
    def cours(self):
        # List of cours
        return self.cours_set.all ()
    # Pour un cours donné la liste des etudiants
    # qui suivent le cour en question 
    def get_studiants_cour (cour):
        # Find list estudiants  into cours 
        return cour.etudiants.all ()

    # Couple  de liste  (cour  , etudiants ) dispensés
    # par le professeur
    @property
    def cours_and_etd(self):
        # Return List of cours  , and 
        # for each cour  get the list of etudiant 
        cour_list = self.cours
        return  [ (cour , self.get_studiants_cour(cour))
        for cour in cour_list]

# Cour Model
class Cours (models.Model):
      lang = models.CharField (max_length=200)
      matiere =models.CharField (max_length =200)
      professeur =models.ForeignKey (Professeurs)
      etudiants  =models.ManyToManyField(Etudiants)
      date_start =models.DateTimeField (auto_now_add =True)
      date_end  =models.DateTimeField (auto_now_add =True)

———————————————–

4 .Synchronisation des données dans la base

La première chose à  faire ici , est de définir la base de  données que vous utilisez à partir  du (settings.py).

A .Configuration de la base de données:
command> vim settings.py
change>
DATABASE_ENGINE = »sqlite3″
DATABASE_NAME = »xaleyi.db »

B .Déclaration de l’application au niveau du settings.py.
command>
vim settings.py
change >
INSTALLED_APPS = (
‘django.contrib.auth’,
‘django.contrib.contenttypes’,
‘django.contrib.sessions’,
‘django.contrib.sites’,
‘mysite.xaleyi’
)

C .Prévisualisation des tables qui seront crées par le systeme
Vous pouvez également prévisualiser les données (SQL) avant
de synchroniser avec votre base de données.

command>
alioune@alioune-laptop:~/mysite$ ./manage.py sql xaleyi

resultat>
BEGIN;
CREATE TABLE « xaleyi_etudiants » (
« id » integer NOT NULL PRIMARY KEY,
« nom » varchar(200) NOT NULL,
« age » integer NOT NULL
)
;
CREATE TABLE « xaleyi_professeurs » (
« id » integer NOT NULL PRIMARY KEY,
« nom » varchar(200) NOT NULL,
« email » varchar(75) NOT NULL
)
;
CREATE TABLE « xaleyi_cours » (
« id » integer NOT NULL PRIMARY KEY,
« lang » varchar(200) NOT NULL,
« matiere » varchar(200) NOT NULL,
« professeur_id » integer NOT NULL REFERENCES « xaleyi_professeurs » (« id »),
« date_start » datetime NOT NULL,
« date_end » datetime NOT NULL
)
;
CREATE TABLE « xaleyi_cours_etudiants » (
« id » integer NOT NULL PRIMARY KEY,
« cours_id » integer NOT NULL REFERENCES « xaleyi_cours » (« id »),
« etudiants_id » integer NOT NULL REFERENCES « xaleyi_etudiants » (« id »),
UNIQUE (« cours_id », « etudiants_id »)
)
;
COMMIT;

D .Synchronisation avec la base.
command>
manage.py syncdb

resultat>
alioune@alioune-laptop:~/mysite$ ./manage.py syncdb
Creating table xaleyi_etudiants
Creating table xaleyi_professeurs
Creating table xaleyi_cours
Installing index for xaleyi.Cours model
alioune@alioune-laptop:~/mysite$

E .Insertion de quelques données dans votre model (Histoire de tester les
Fonctionnalitésde base ).

Nous allons ajouter quelques données  dans nos tables .Notez que ce n’est pas la meilleure  manière d’effectuer des testes .Car DJANGO gère bien les testes pour vos models de données , nous y reviendrons .

alioune@alioune-laptop:~/mysite$ ./manage.py shell
Python 2.6.2 (release26-maint, Apr 19 2009, 01:56:41)
[GCC 4.3.3] on linux2
Type « help », « copyright », « credits » or « license » for more information.
(InteractiveConsole)
>>> import mysite
>>>

F .Importer les models de données
>>> import mysite
>>> from xaleyi.models import Etudiants , Professeurs , Cours
>>>

G .Ajouter des données aux model _Etudiants_
>>> Etudiants.objects.create (
… nom = »Alioune »,
… age = 25 )

> Etudiants.objects.create (
… nom = « Charle »,
… age = 15 )

H .Agile Teste
DJANGO introduit également ce qu’on appelle le
Agile Testing .Sous JDANGO  vous pouvez créer des fichiers
de testes , et laisser le manager exécuter ces testes pour vous.
Vous allez voir que c’est quelque chose de très pratique.
Moi le model de test que je préfère c’est d’hériter
de (unittest) ,

H -1.Créer un fichier de teste (tests.py) dans le répertoire (xeleyi).

Sur les dernières versions de DJANGO  , ce  fichier est automatiquement crée  ,si vous utilisez des versions  antérieures  , créez vous même ce fichier dans votre projet .Pour moi  ce sera dans le dossier  (xaleyi).


H -2 .Éditer votre fichier avec les lignes de codes ci-dessous

Éditez le fichier (tests.py)  et mettez  y le code suivant :

———————————————————

import unittest
from xaleyi.models import Etudiants , Professeurs , Cours
from datetime import datetime
class  XaleyiTestCase (unittest.TestCase):

     def setup (self):
        """Setup Xeleyi Application"""
        print "Setup"
     # Testons  l'ajout d'un etudaint
     def testadd_studiants (self): 
        print "Add  Etudiants"
        Etudiants.objects.create (
        nom  ="Alioune",
        age  =25
        )
        Etudiants.objects.create (
        nom ="Awa",
        age =25)
     # Testons  l'ajout d'un nouveau professeur
     def testadd_professeurs (self): 
        Professeurs.objects.create(
        nom = "Souleymane Bechir Diagne" ,
        email ="sbcd@mydomain.org")

        Professeurs.objects.create (
        nom ="Guido van Russum" ,
        email = "guido@mydomain.org")

     # Testons l'ajout  d'un nouveau cour
     def testadd_cours (self):
        dt_start = datetime.now ()
        dt_end   = dt_start + timedelta (hours = 2)
        p = Professeurs.objects.get (nom__contains ="Souleymane")
        etudiants =Etudiants.objects.all ()
        c =Cours.objects.create (
        professeur  =p ,
        date_start  =dt_start ,
        date_end    =dt_end )
        c.etudiants=Etudiants.objects.all ()
        c.save ()
     # Testons la liste des cours pour un etudiant
     def testetudiant_cours (self, etudiant):
        return etudiant.cours
     # Testons les cours du jour pour un etudiant 
     def testetudiant_cour_today (self,etudiant):
        return etudiant.cours_today
     # Testons la liste des cours pour pour un professeur
     def testprofesseur_cours (self, professeur):
        return professeur.cours
     # Testons la liste des cours ainsi que la liste des
     # etudiants correspondant pour le professeur
     def testprofesseur_cours_and_etd (self, professeur):
        return  professeur.cours_and_etd

———————————————————

H-3 Exécution des testes .

Lancez le fichier de testes ci -dessus ,à partir du manager

command>.alioune@alioune-laptop:~/mysite$ ./manage.py test xaleyi

résultat>

Creating test database…
Creating table auth_permission
Creating table auth_group
Creating table auth_user
Creating table auth_message
Creating table django_content_type
Creating table django_session
Creating table django_site
Creating table xaleyi_etudiants
Creating table xaleyi_professeurs
Creating table xaleyi_cours
Installing index for auth.Permission model
Installing index for auth.Message model
Installing index for xaleyi.Cours model
Add Etudiants
Add professeurs
Add cours
date_start : 2010-04-16 07:11:47.637098
date_end : 2010-04-16 09:11:00
.
———————————————————————-
Ran 1 test in 0.014s

OK
Destroying test database…

I -Donnez à vos models ,une presentation plus explicites
Sous DJANGO , vos pouver ameliorer vos models en redefinissant
la methode (__unicode__())
Pour l’application (xaleyi) voici ce que donnne le (models.py)
apres amelioration.

—————————————————————————————-

from django.db import models
from datetime import date
from datetime import datetime
# Create your models here.
class Etudiants(models.Model):
    nom =models.CharField (max_length=200)
    age =models.IntegerField ()

    @property
    def cours(self):
        # All cours
       return  self.cours_set.all()
    # La liste des etudiants du jour
    @property
    def cours_today(self):
        from datetime import date
        dt = date.today()  
        return  self.cours_set.filter (
            date_start__year  = dt.year  ,
            date_start__month = dt.month ,
            date_start__day   = dt.day)
    # Personnalisation de l'affichage du model
    # avec la methode unicode
    def __unicode__(self):
        return  "%s : %s" %(
            self.nom ,self.age)

class Professeurs (models.Model):
    nom = models.CharField (max_length =200)
    email =models.EmailField ()

    @property
    def cours(self):
        # List of cours
        return self.cours_set.all ()

    def get_studiants_cour (cour 
        return cour.etudiants.all ()
    @property
    def cours_and_etd(self):
        cour_list = self.cours
        return  [ (cour , studiant_cour (cour))
            for cour in cour_list]
    # Personnalisation de l'affichage du professeur avec la methode unicode
    def __unicode__(self):
        return  "%s : %s"%(
            self.nom  ,self.email)

class Cours (models.Model):
      lang = models.CharField (max_length=200)
      matiere =models.CharField (max_length =200)
      professeur =models.ForeignKey (Professeurs)
      etudiants  =models.ManyToManyField(Etudiants)
      date_start =models.DateTimeField (auto_now_add =True)
      date_end  =models.DateTimeField (auto_now_add =True)
      # Personnalisation de l'affichage des cours
      def __unicode__(self):
        return "[%s] : [%s]"% (
        unicode(self.professeur) , " ,".join (
        [unicode(e)  for e in self.etudiants.all()]))


------------------------------------------------------

J -Affiner notre modules de teste:
Vous vous rapellez des fonctionnalités que notre logiciel devra repondre?.
Alors Afin de prendre en compte ses fonctionnalites , nous allons creer
des fonctions suplementaires à l’interieur de (tests.py) .
L’objectif etants d’ajouter au logiciel les elements suivants :

J -1 .Lister tous les (Etudiants)
J -2 .Lister tous les (Professeurs)
J -3 .Pour chaque etudiants la liste de ses cours
J -4 .Pour chaque professeurs la liste de ses cours
J -5 .Permettre à un etudiant de lister ses cours
d’aujourhui

Au final notre module (tests.py) ressemble à ca :

————————————————————————

import unittest
from xaleyi.models import Etudiants , Professeurs , Cours
from datetime import datetime
class  XaleyiTestCase (unittest.TestCase):

     def setup (self):
        """Setup Xeleyi Application"""
        print "Setup" 

     def _testadd_studiants (self): 
        print "Add  Etudiants"
        Etudiants.objects.create (
        nom  ="Alioune",
        age  =25
        )
        Etudiants.objects.create (
        nom ="Awa",
        age =25)

     def _testadd_professeurs (self):
        Professeurs.objects.create(
        nom = "Souleymane Bechir Diagne" ,
        email ="sbcd@mydomain.org")

        Professeurs.objects.create (
        nom ="Guido van Russum" ,
        email = "guido@mydomain.org")
     def _testadd_cours (self):
        from datetime import date , timedelta
        dt_start = datetime.now ()
        dt_end   = dt_start + timedelta (hours =2)
        p = Professeurs.objects.get (nom__contains ="Souleymane")
        etudiants =Etudiants.objects.all ()
        c =Cours.objects.create (
        professeur  =p ,
        date_start  =dt_start ,
        date_end    =dt_end )
        c.etudiants=Etudiants.objects.all ()
        c.save ()
     def _testetudiant_cours (self, etudiant):
        return etudiant.cours
     def _testetudiant_cour_today (self,etudiant):
        return etudiant.cours_today
     def _testprofesseur_cours (self, professeur):
        return professeur.cours
     def _testprofesseur_cours_and_etd (self, professeur)
        return  professeur.cours_and_etd
     def testall (self):
        """
        Only the folloing method  will be executed  by 
        django . The test Class only test methods whose 
        name begins  with  lower-case  tests.
        """
        # Methode qui va executer nos methodes de testes
        self._testadd_studiants ()
        self._testadd_professeurs ()
        self._testadd_cours ()
        etu = Etudiants.objects.all ()[0]
        print "\n ETUDIANT : %s" %etu
        print "\n COURS ALL :%s"%self._testetudiant_cours (etu)
        print "\n COURS TODAY  :%s"%self._testetudiant_cour_today (etu)
        prof  = Professeurs.objects.all()[1]
        print "\n PROF:%s "%prof
        print "\n ALL COURS: %s"%self._testprofesseur_cours(prof)
        print "\n COURS AND ETUDIANTS : %s "%self._testprofesseur_cours_and_etd (prof)
------------------------------------------

Et voila , votre logiciel est presque terminé .Tout ce qui reste est de gerer les vues pour traiter les requetes clients  , voir pour le reste l’article DJANGO_VIEWS  et DJANGO_URLS .

--------------------------------------------------------
Publicités

1 Response to “Django_Models”


  1. 1 Mr WordPress avril 13, 2010 à 10:11

    Hi, this is a comment.
    To delete a comment, just log in, and view the posts’ comments, there you will have the option to edit or delete them.


Laisser un commentaire

Entrez vos coordonnées ci-dessous ou cliquez sur une icône pour vous connecter:

Logo WordPress.com

Vous commentez à l'aide de votre compte WordPress.com. Déconnexion / Changer )

Image Twitter

Vous commentez à l'aide de votre compte Twitter. Déconnexion / Changer )

Photo Facebook

Vous commentez à l'aide de votre compte Facebook. Déconnexion / Changer )

Photo Google+

Vous commentez à l'aide de votre compte Google+. Déconnexion / Changer )

Connexion à %s





%d blogueurs aiment cette page :