Création du modèle

Le principe est de créer une classe par table de la base de données :

• cette classe est rajoutée dans le fichier models.py.
• cette classe doit dériver de django.db.models.Model et définit tous les champs.

Exemple de modèle défini dans models.py :

from django.db import models
class MyObject(models.Model):
    label = models.CharField(max_length = 5)
    description = models.CharField(max_length = 100)
  

Par défaut, chaque modèle définit un champ id qui s'autoincrémente, c'est à dire qu'il définit implicitement un champ : id = models.AutoField(primary_key=True). Si on définit explicitement un champ comme étant une clef primaire (avec l'argument primary_key = True), ce champ id par défaut n'est plus présent.

Types de champs avec arguments (ces arguments s'appliquent souvent à beaucoup types de champs, pas seulement à celui utilisé ici) :

• models.BooleanField() : champ booléen.
• models.IntegerField() : champ entier.
• models.DecimalField(max_digits = 10, decimal_places = 3) : champ décimal indiquant le nombre de chiffres total et après la virgule.
• models.FloatField() : champ float.
• models.CharField(max_length = 10) : champ chaîne de caractères.
• models.DateField() : champ date.
• models.DateTimeField(auto_now_add = True) : champ date + temps rempli à la création (type date de création).
• models.DateTimeField(auto_now = True) : champ date + temps rempli à la création et à chaque mise à jour (type dernière date de modification).
• models.EmailField(help_text = 'Votre mail') : champ de type mail.
• models.BinaryField(null = True) : champ pour stocker des données binaire (type blob).
• models.FileField(null = True) : champ pour stocker un fichier.
• models.FilePathField(null= True) : champ pour stocker le chemin d'un fichier.

Arguments que l'on peut passer en plus :

• en premier argument, on peut donner un nom au champ : myField = models.CharField('Mon nom', max_length = 10).
• db_column = 'monNom' : le nom de la colonne à utiliser dans la base, à la place du nom du champ.
• null = True : le champ peut être nul (par défaut, False).
• blank = True : le champ peut rester non rempli dans le formulaire (par défaut, False).
• default = 0 : valeur par défaut, si le champ n'est pas rempli.
• max_length = 10 : la longueur maximum du champ.
• choices = (('FR', 'France'), ('US', 'Etats-Unis')) : les possibilités de valeurs de ce champ, avec à la fois les valeurs dans la base et les valeurs affichées (comme select html).
• primary_key = True
• unique = True : le champ doit avoir une contrainte d'unicité dans la base.
• db_index = True : créer un index pour ce champ dans la base.
• help_text = 'numero de telephone' : commentaire sur le champ.

Création d'un objet :

• création de l'objet : myObject = MyObject(); myObject.field1 = 'abc'; myObject.field2 = 123;
• sauvegarde dans la base : myObject.save()

Duplication d'un objet existant : on lève l'objet et on met sa clef primaire à None :

myObj = MyModel.objects.get(id = 5)
myObj.pk = None
myObj.save()
  

attention : si c'est un objet hérité, il faut mettre à la fois pk et id à None.

Pour détuire un objet de la base :

myObj = MyModel.objects.get(id = 5)
myObj.delete()
  

attention : par défaut, ça fait un delete cascade !

Méthodes à rajouter aux classes modèles :

• rajouter une méthode __str__, en python 3, ou __unicode__ en python 2 si on veut renvoyer une représentation de l'objet, ce qui est quasi-indispensable.

Propriété additionnelles qu'on peut rajouter à l'objet modèle :

• On peut rajouter une inner classe Meta (utiliser exactement ce nom-là !) qui contient des propriétés, par exemple :

  class MyObject(models.Model):
      class Meta:
          db_table = 'ma_table'
      

• db_table = 'ma_table' : nom à donner à la table dans la base au lieu d'un nom dérivé de la classe.
• managed = False : django ne manage pas la table, la création et la mise à jour du schéma de la table doivent être faits manuellement. Le défaut est True.
• index_together = [['col1', 'col2']] : liste des listes de champs à indexer ensemble (ici, création d'un index sur la paire (col1, col2)).
• unique_together = [['col1', 'col2']] : liste des listes de champs sur lesquelles mettre une contrainte d'unicité (ici, unicité sur la paire (col1, col2)).

On prend comme exemple le modèle suivant :

• Destination (id, ville).
• Voyage (id, destination_id, prix) en relation n-1 avec Destination.
• Voyageur (id, nom) en relation n-n avec Voyage à travers Participation (voyageur_id, voyage_id, nombre_valises).

Relation 1-n :

• On utilise un champ avec le type ForeignKey et la classe en argument.
• exemple en reprenant les tables ci-dessus :

  from django.db.models import Model, CharField, FloatField, ForeignKey
  class Destination(Model):
      ville = CharField(max_length = 10)
  class Voyage(Model):
      destination = ForeignKey(Destination)
      prix = FloatField()
      

• pour créer un objet, on peut faire :

  dest = Destination.objects.get(ville = 'Paris')
  voyage = Voyage(destination = dest, prix = 100)
  voyage.save()
      

Relation n-n :

• On utilise un champ avec le type ManyToManyField et la classe en argument et on peut la mettre dans n'importe laquelle des 2 classes en relations, mais seulement dans l'une d'entre elle !
• exemple en reprenant les tables ci-dessus, si la table de relation n'a pas de propriété :

  from django.db.models import Model, CharField, FloatField, ManyToManyField
  class Voyage(Model):
      prix = FloatField()
  class Voyageur(Model):
      nom = CharField(max_length = 10)
      participation = ManyToManyField(Voyage)
      

• exemple avec des propriété sur la table de relation :

  class Voyage(Model):
      destination = ForeignKey(Destination)
      prix = FloatField()
  class Voyageur(Model):
      nom = CharField(max_length = 10)
      particip = ManyToManyField(Voyage, through = 'Participation')
  class Participation(Model):
      voyage = ForeignKey(Voyage)
      voyageur = ForeignKey(Voyageur)
      nombre_valises = IntegerField()
      

• Pour créer une relation, on peut faire :

  pers = Voyageur.objects.get(nom = 'Jean')
  voy = Voyage.objects.get(id = 2)
  part = Participation(voyage = voy, voyageur = pers, nombre_valises = 3)
  part.save()
      

Migrations quand on crée ou on change le modèle :

• manage.py makemigrations myApp : crée un fichier python de migration dans le directory migrations de l'application.
• manage.py sqlmigrate myApp 0003 : affiche le sql correspondant à la 3ème migration de l'application myApp.
• manage.py check myApp : vérifie l'application.
• manage.py migrate myApp : applique toutes les migrations qui ne l'ont pas encore été (suivi dans la table django_migrations).
• en routine, on utilise donc makemigrations, puis migrate.

Pour créer un objet dans la base à la main :

• démarrer un shell avec manage.py shell
• faire dedans : from myApp.models import *
• puis obj = MyModel(); obj.prop1 = value1, obj.prop2 = value2; ...
• puis obj.save().
• on peut aussi faire : MyModel(prop1 = value1, prop2 = value2, ...).save().

Mise à jour des objets :

• une fois qu'on a récupérer un objet, on peut changer ses propriétés et faire ensuite obj.save() pour mettre à jour la base.

Pour faire tourner un script qui utilise les modèles du projet myProject, il faut mettre au début du script :

os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'myProject.settings')
import django
django.setup()
  

(si on n'est pas dans myProject, rajouter aussi avant sys.path.append('/le/chemin/vers/myProject').