Django

1. Qu’est ce que Django

Django est un outil qui facilite la création de meilleures applications Web plus
rapidement et avec moins de code.
(Lien documentation: https://www.djangoproject.com/ )

2. Pourquoi Django
Avec Django, vous pouvez faire passer les applications Web du concept au
lancement en quelques heures. Django prend en charge une grande partie des
tracas du développement Web, vous pouvez donc vous concentrer sur l'écriture
de votre application sans avoir à réinventer la roue. C'est gratuit et open source.
(Lien documentation: https://www.djangoproject.com/start/overview/ )

3. Comment installer Django

(Lien documentation : https://www.djangoproject.com/download/ )

3-1. Python
Python est un langage de programmation puissant et facile à apprendre. Il
dispose de structures de données de haut niveau et permet une approche simple
mais efficace de la programmation orientée objet. Parce que sa syntaxe est
élégante, que son typage est dynamique et qu'il est interprété, Python est un
langage idéal pour l'écriture de scripts et le développement rapide
d'applications dans de nombreux domaines et sur la plupart des plateformes.
(Lien documentation: https://docs.python.org/fr/3/tutorial/ ,
https://www.python.org/ , https://www.python.org/about/ )

3-1-1. Télécharger python

(Lien Téléchargement: https://www.python.org/downloads/ )

3-2. Installer Django

3-2-1. Environnement virtuels

Un environnement virtuel est un dossier qui contient une installation de Python
pour une version particulière de Python ainsi que des paquets additionnels.
( Lien documentation : https://docs.python.org/fr/3/tutorial/venv.html )

3-2-2. Installation de virtualenv

pip install virtualenv

3-2-3. Création d’un environnement virtuel

py -m venv nom_environnement_virtuel # (sur windows)
ou
python -m venv nom_environnement_virtuel # (sur macos)

Exemple :
py -m venv test_venv

3-2-3. Activation d’un environnement virtuel

cd test_venv # (On se déplace dans le dossier test_venv)
cd Scripts # (On se déplace dans le dossier Scripts)
activate # (Activation de l’environnement virtuel)
cd .. # (Retour dans le dossier précédent)
cd .. # (Retour dans le dossier précédent)

ou avec le raccourci
test_venv\Scripts\activate

3-3. Installer django (Installe la dernière version de django)

pip install django

ou en spécifiant la version de django à installer(4.1.3 par exemple)

pip install Django==4.1.3

Note : Comment mettre à jour pip

python.exe -m pip install --upgrade pip

3-4. Créer un nouveau projet

django-admin startproject nom_du_projet
Note : Liste des commandes disponible pour django-admin
django-admin help

Déplacement dans le dossier du projet

cd nom_du_projet

Lancer le server local

py manage.py runserver

Interrompre le server local

ctrl + c

3-5. Créer une application

py manage.py startapp website
ou
django-admin startapp website

Quelle est la différence entre un projet et une application ?

Une application est une application Web qui fait quelque chose – par exemple un
système de blog, une base de données publique ou une petite application de
sondage. Un projet est un ensemble de réglages et d’applications pour un site
Web particulier. Un projet peut contenir plusieurs applications. Une application
peut apparaître dans plusieurs projets.
Pour plus d’information :
https://docs.djangoproject.com/fr/4.1/intro/tutorial01/

4. Créer du projet Checknote

4-1. Activation de l’environnement virtuel
test_venv\Scripts\activate

4-1. Création du projet

django-admin startproject checknote

4-2. Création de l’application

On se place dans le dossier du projet créé
cd checknote
création de l’application noteapp
django-admin startapp noteapp

4-3. Ajout de l’application noteapp comme application dans notre projet dans le fichier
settings.py. (emplacement : checknote\settings.py)
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',

'noteapp',
]

4-4. Accès au site d’administration de django

Les Migrations:

Les migrations sont la manière par laquelle Django propage des modifications que vous
apportez à des modèles (ajout d’un champ, suppression d’un modèle, etc.) dans un
schéma de base de données.

● migrate, qui est responsable de l’exécution et de l’annulation des migrations.

● makemigrations, qui est responsable de la création de nouvelles migrations en
fonction des modifications que vous avez apportées aux modèles.
● sqlmigrate, qui affiche les instructions SQL correspondant à une migration.
● showmigrations, qui affiche la liste des migrations d’un projet ainsi que leur
état.

Vous devez imaginer les migrations comme un système de contrôle de versions pour un
schéma de base de données. makemigrations se charge de regrouper vos changements
de modèle dans des fichiers de migration individuels - comme des commits et migrate
est chargé d’appliquer les changements à la base de données.

Les fichiers de migration pour chaque application sont stockés dans un répertoire «
migrations » à l’intérieur de l’application, et sont conçus pour faire partie du code
source et de la distribution de cette application. Les migrations sont créées une fois
sur votre machine de développement, puis exécutées telles quelles sur les machines de
vos collègues, les machines de tests, et finalement sur les machines de production.
4-4-1. Migration initiale(Création des schémas par défaut dont la table des utilisateurs)
py manage.py migrate
4-4-2. Création du super utilisateur
py manage.py createsuperuser
Note : Les informations à fournir
● Nom d’utilisateur
● Email (facultatif)
● Mot de passe
● Confirmation mot de passe (Les 2 mot de passes doivent être identiques)

4-4-3. Lancement du server de développement interne de django

py manage.py runserver

Dans un navigateur : http://localhost:8000/admin ou http://127.0.0.1:8000/admin pour

accéder au site d’administration et on utilise les identifiants du super utilisateur pour
s’y connecter.

5. Configuration du site d’administration

5-1. Création de models
Modèle :
Un modèle est la source d’information unique et définitive à propos de vos données. Il
contient les champs et le comportement essentiels des données que vous stockez.
Généralement, chaque modèle correspond à une seule table de base de données.

Les bases :

● Chaque modèle est une classe Python qui hérite de django.db.models.Model.

● Chaque attribut du modèle représente un champ de base de données.
● Avec tout ça, Django vous offre une API d’accès à la base de données générée
automatiquement ;

Model Étudiant

class Etudiant(models.Model):
matricule = models.CharField(unique=True,max_length=50)
nom = models.CharField(max_length=50)
prenom = models.CharField(max_length=50)
date_nais = models.DateField()
telephone = models.CharField(unique=True, max_length=20)
classe = models.CharField(max_length=50)
def __str__(self):
 return self.nom + " " + self.prenom

Model Notes

class Note(models.Model):
etudiant = models.ForeignKey(Etudiant, on_delete=models.CASCADE)
evaluation = models.CharField(max_length=50)
. . .

class Meta:
verbose_name = "NOTE"
verbose_name_plural = "NOTES"

def __str__(self):
# return str(self.etudiant)
return self.evaluation

Création des fichier de migration

py manage.py makemigrations
Application des migrations sur la base de données
py manage.py migrate

Ajout des models sur le site d’administration (emplacement : noteapp\admin.py)

from django.contrib import admin

from .models import Etudiant, Notes

admin.site.register(Etudiant)
admin.site.register(Notes)
Création des class admin

class EtudiantAdmin(admin.ModelAdmin):
list_display = ['matricule','nom', 'prenom', 'genre', 'classe', ]
list_filter = ('nom', 'genre')
search_fields = ('nom', 'prenom',)

class NoteAdmin(admin.ModelAdmin):
list_display = ['python', 'base_donne', 'ccna', 'calculeMoyenne' ]
list_filter = ('etudiant',)
search_fields = ('etudiant__nom', 'etudiant__prenom',)

def calculeMoyenne(self, obj):

moyenne = (obj.python + obj.base_donne + obj.ccna) / 3
return moyenne

admin.site.register(Etudiant, EtudiantAdmin)
admin.site.register(Notes, NoteAdmin)

6- Création du site web

Les vues(views)

Une fonction de vue, ou vue pour faire simple, est une fonction Python acceptant une
requête web et renvoyant une réponse web. Cette réponse peut contenir le contenu
HTML d’une page web, une redirection, une erreur 404, un document XML, une image…
ou vraiment n’importe quoi d’autre. La vue elle-même contient la logique nécessaire pour
renvoyer une réponse. Ce code peut se trouver à l’emplacement de votre choix, pour
autant qu’il soit dans le chemin Python. Il n’y a pas d’autres exigences, pas de « magie »
comme on dit. Mais comme il faut bien mettre ce code quelque part, la convention est de
placer les vues dans un fichier nommé views.py se trouvant dans un projet ou un
répertoire d’application.
(Pour plus d’information : https://docs.djangoproject.com/fr/4.1/topics/http/views/)

Ecriture de nos vues (Emplacement : noteapp\views.py)

from django.shortcuts import render
from django.http import HttpResponse

from .models import *

# Create your views here.

def index(request):
return render(request, 'noteapp/index.html')

def notes(request):
note_list = Notes.objects.filter(etudiant__matricule=request.POST['matricule'])
context = {'note_list': note_list}

return render(request, 'noteapp/notes.html', context)

Les Templates(Gabarits) :
Par sa nature liée au Web, Django a besoin d’un procédé agile de génération dynamique
de HTML. L’approche la plus couramment utilisée est de se baser sur des gabarits.Un
gabarit contient la partie statique du résultat HTML souhaité ainsi qu’une certaine
syntaxe particulière définissant comment insérer le contenu dynamique.
Pour plus d’informations : https://docs.djangoproject.com/fr/4.1/topics/templates/

Gabarits

Un gabarit est un fichier texte. Il peut générer tout format basé sur du texte (HTML,
XML, CSV, etc.).
Un gabarit contient des variables qui sont remplacées par des valeurs lorsque le gabarit
est évalué, ainsi que des balises qui contrôlent la logique du gabarit.
Voici un gabarit minimal illustrant quelques principes de base. Chaque élément sera
ensuite expliqué plus loin dans ce document.

Variables

Une variable affiche une valeur à partir du contexte, qui est un objet de type
dictionnaire faisant correspondre des clés à des valeurs.
Les variables sont entourées par {{ et }} comme ceci :

Mon nom est : {{ nom }} et prénom : {{ prenom}}.

Et dans views.py on aura :

def notes(request):
 variableNom = "Touré"
variablePrenom = "Oumar"
context = {'nom': nom, 'prenom': variablePrenom}
return render(request, 'testapp/test.html', context)

Resultat dans la page html :

Mon nom est : Touré et prénom Oumar

Balises

Les balises permettent d’appliquer une logique arbitraire dans le processus de rendu.
Cette définition est volontairement vague. Par exemple, une balise peut produire du
contenu, servir de structure de contrôle telle qu’une instruction « if » ou une boucle «
for », extraire du contenu d’une base de données ou même de donner accès à d’autres
balises de gabarit.
Les balises sont entourées par {% et %}, comme ceci (quelques balises) :
{% csrf_token %}
Balise pour les urls
{% url 'nom url' %}
Balise pour faire une condition
{% if condition %} Bonjour, {{ user.username }}.{% endif %}
Balise pour parcourir un ensemble d'élément (Liste d’objet par exemple)
{% for elt in list%}
Le nom est : {{ elt.nom }}.
{% endif %}
Pour faire des commentaires
{% comment %} Ceci est un commentaire {% endcomment %}
Pour permettre le chargement de fichiers static(js, css) dans le fichier html
{% load static %}
Pour hériter d’un template
{% extends 'nom_application/nom_fichier.html' %}
Redéfinir le contenu d’un template (héritage)
{% block content %} Le contenu ici {% endblock %}

Et etc… Pour plus d’information :

https://docs.djangoproject.com/en/4.1/ref/templates/language/

Création de nos templates :

Note :
Tout d’abord, créez un répertoire nommé templates dans votre répertoire noteapp.
C’est là que Django recherche les gabarits(pour l’application noteapp).
Puis créez un répertoire nommé noteapp (exactement le nom de l’application)
Arborescence du Dossier : noteapp/templates/noteapp
Puis créez les fichier suivants : base.html, index.html et notes.html
Le template principale : base.html (chemin : noteapp/templates/noteapp/base.html)
{% load static %}
<!DOCTYPE html>
<html lang="en">
<head>
. . .
{% comment %} Intégration du fichier static css{% endcomment %}
<link rel="stylesheet" href="{% static 'noteapp/css/bootstrap.min.css'
%}">
</head>
<body>
{% comment %} Partie Logo {% endcomment %}
<div class="vr"></div>
<div class="container text-center">
<img src="{% static 'noteapp/images/logo_isc.png' %}"alt="Logo isc">
<h3>ISC BUSSINESS SCHOOL</h3>
</div>
<div class="vr"></div>
{% comment %} Le contenue des autres pages {% endcomment %}
{% block content %}
{% comment %} Le contenu pages seront ici {% endcomment %}
{% endblock content %}

{% comment %}Intégration du fichier static js {% endcomment %}

<script src="{% static 'noteapp/js/bootstrap.min.js' %}"></script>
</body>
</html>
La page d’accueil : index.html (chemin : noteapp/templates/noteapp/index.html)

{% extends 'noteapp/base.html' %}
{% load static %}

{% block content %}
<div class="card">
<div class="card-header">
<h1>Formulaire de Recherche</h1>
</div>
<div class="card-body">
<div >
<form action="{% url 'notes' %}" method="post">
{% csrf_token %}
<fieldset>
<div class="row">
<label for="matricule" class="">Numéro matricule</label>
<input type="text" class="form-control" name="matricule"
placeholder="Entrez votre numero matricule ici">
</div>
</fieldset>
<input type="submit" class="btn btn-primary" value="Chercher">
</form>
</div>
</div>
</div>
{% endblock content %}
La page notes: notes.html (chemin : noteapp/templates/noteapp/notes.html)

{% extends 'noteapp/base.html' %}
{% load static %}
{% block content %}

<div class="container">
<h2>Les Notes : </h2>

<table class="table table-striped table-bordered ">

<thead>
<tr>
<td>ETUDIANT</td>
<td>SEMESTRE</td>
<td>PYTHON</td>
<td>BASE DE DONNEES</td>
<td>CCNA</td>
</tr>
</thead>

<tbody>
{% for note in note_list %}
<tr>
<td>{{ note.etudiant }}</td>
<td>{{ note.semestre }}</td>
<td>{{ note.python }}</td>
<td>{{ note.base_donne }}</td>
<td>{{ note.ccna }}</td>
</tr>
{% endfor %}
</tbody>
</table>

</div>
{% endblock content %}
Gestion des URL

Fichier d’url principale : urls.py (chemin : checknote/urls.py)

from django.contrib import admin

from django.urls import path

from django.conf.urls import include

urlpatterns = [
path('admin/', admin.site.urls),
path('', include('noteapp.urls'))
]

Créez un fichier nommé urls.py dans le dossier noteapp (noteapp/urls.py)

from django.urls import path
from . import views

urlpatterns = [
path('', views.index, name="index"),
path('notes', views.notes, name="notes"),
]