📒

M2i Django
Introduction
Framework python permettant de créer des applications web, rapidement et
sécurisé.
Il contient tout ce dont vous avez besoin ! Un serveur web, un ORM puissant,
un moteur de gabarit, un client de test et beaucoup d'autres fonctionnalités qui
vous faciliteront la vie !
Django follows the Model-Template-View (MTV) architecture. MTV differs from
the Model-View-Controller (MVC) architecture in the sense that the Controller part is
already implemented by the framework itself through templates.
The Django MTV architecture is composed of the following components:

Model: it defines the logical data structure. In practice, a model is a Python

class, which represents a single table in the database. All the classes
representing the logical structure of the database are stored in a script
named models.py.

View: it defines the business logic, in the sense that it communicates with the
model and translates it into a format readable by the Template. A view is a
Python function, which takes a request as input and returns a Web
response as output. All the functions representing the business logic are
stored in a script named views.py.

Template: it defines the structure or the layout of a file, such as a HTML file. It
is a text document or a Python string encoded through the Django
template language. All the templates are stored in a subdirectory of the App
named templates.

M2i Django 1
 Commencer un projet

python -m django startproject <nomdemonprojet>

Cette commande va générer une architecture de fichiers pour notre projet.

manage.py : pour l'exécution des commandes de gestion liées à notre projet.
__init__.py : fichier vide qui indique c'est un package python

settings.py : contient toute la configuration du projet. Fichier de référence !

urls.py : regroupe le mapping des urls
wsgi.py : fichier pour le déploiement
Django contient un web server : aucune installation de server est nécessaire.
Commande pour lancer l'application :

python manage.py runserver

Hit CTRL + BREAK to stop the development server.

settings.py

M2i Django 2
 INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'gag'
]

Ces apps sont là par défaut.

Models
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.

from django.db import models

class Person(models.Model):
first_name = models.CharField(max_length = 30)
last_name = models.CharField(max_length = 30)

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 ;

Base de données
Although you can use Django without a database, it comes with an object-relational
mapper in which you describe your database layout in Python code.

On peut utiliser plusieurs types de base de données avec Django.

Le champ  id  est ajouté automatiquement, mais peut-être modifié.

Héritage

M2i Django 3
 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.

Il y a plusieurs commandes utiles pour interagir avec les migrations et manipuler le

schéma de base de données avec Django :

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.

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.
MySQL ne crée pas de transactions pour les opérations de modification de schéma,
ce qui signifie que si une migration ne parvient pas à s’appliquer, vous devrez
défaire manuellement les modifications pour essayer de nouveau (il est impossible
de revenir à un point de sauvegarde antérieur).

En outre, MySQL réécrit entièrement les tables pour presque toutes les opérations
de schéma et a généralement besoin d’un temps d’exécution proportionnel au
nombre de lignes des tables pour ajouter ou supprimer des colonnes. Sur une
machine un peu lente, cela peut prendre plus d’une minute par million de lignes ;
l’ajout de quelques colonnes à une table de quelques millions d’entrées pourrait
bloquer votre site pendant plus de dix minutes.
Enfin, MySQL a des tailles limites relativement petites pour la longueur des noms
de colonnes, tables et index, ainsi qu’une limite sur la taille combinée de toutes les
colonnes qu’un index recouvre. Cela signifie que des index qui sont possibles sur
d’autres bases de données ne pourront pas toujours être créés avec MySQL.

URLs

A table of contents for your app, it contains a mapping between URL patterns and
Python callback functions.

M2i Django 4
 from django.urls import path

from . import views

urlpatterns = [
path('articles/<int:year>/', views.year_archive),
path('articles/<int:year>/<int:month>/', views.month_archive),
path('articles/<int:year>/<int:month>/<int:pk>/', views.article_detail),
]

Créer une view

A view function, or “view” for short, is simply a Python function that takes a web
request and returns a web response. This response can be the HTML contents of a
Web page, or a redirect, or a 404 error, or an XML document, or an image, etc.

from django.http import HttpResponse

def hello(request):
text = """<h1>welcome to my app !</h1>"""
return HttpResponse(text)

Formulaires

En HTML, un formulaire est un ensemble d’éléments à l’intérieur des

balises  <form>...</form>  qui permettent à un visiteur d’effectuer des actions comme
saisir du texte, sélectionner des options, manipuler des objets ou des contrôles, et
ainsi de suite, puis d’envoyer ces informations au serveur.

GET  et  POST  sont les seules méthodes HTTP à utiliser dans les formulaires.
Le formulaire de connexion de Django est renvoyé en utilisant la méthode  POST , par
laquelle le navigateur regroupe les données du formulaire, les encode pour la
transmission, les envoie au serveur, puis reçoit la réponse en retour.
GET , en revanche, regroupe les données fournies dans une chaîne et l’utilise pour
composer une URL. L’URL contient l’adresse à laquelle les données doivent être
envoyées, ainsi que les clés et les valeurs fournies.

Toute requête pouvant être utilisée pour modifier l’état du système, par exemple
une requête qui applique des changements en base de données, devrait

M2i Django 5
 utiliser  POST .  GET  ne devrait être employée que pour des requêtes qui n’affectent
pas l’état du système.

GET ne conviendrait pas non plus pour un formulaire de changement de mot de

passe, car le mot de passe apparaîtrait en clair dans l’URL ainsi que dans
l’historique du navigateur et les journaux du serveur. Elle ne conviendrait pas non
plus pour des données volumineuses ou pour des données binaires telles que pour
une image.

Pour créer un formulaire en Django, on utilise la classe form.

Supposons que vous vouliez créer un formulaire simple sur votre site dans le but
d’obtenir le nom de l’utilisateur.

<form action="/your-name/" method="post">

<label for="your_name">Your name: </label>
<input id="your_name" type="text" name="your_name" value="{{ current_name }}">
<input type="submit" value="OK">
</form>

Le navigateur saura alors qu’il doit renvoyer les données du formulaire vers
l’URL  /your-name/ , en utilisant la méthode  POST . Il affichera un champ de texte
libellé « Your name: » et un bouton intitulé « OK ». Si le contexte de gabarit contient
une variable  current_name , celle-ci sera utilisée pour pré-remplir le champ  your_name .
Lorsque le formulaire aura été envoyé, la requête  POST  envoyée au serveur
contiendra les données du formulaire.

from django import forms

class NameForm(forms.Form):
your_name = forms.CharField(label='Your name', max_length=100)

ou :

class Category():
#chaque champ du formulaire
#...
#...

M2i Django 6
 redirect() & render()
redirect() : Renvoie une réponse  HttpResponseRedirect  à l’URL correspondant aux
paramètres transmis.

render() : The render() function has two mandatory arguments you must pass to it
when calling the function. These are the request, and template_name parameters.

Admin

Django a déjà une interface graphique pour la gestion administrative.

Sécurité
Django intègre tout un système de configuration.

API REST

Django REST Framework est une librairie pour facilite l'implémentation des API.
A REST API is a standardized way to provide data to other applications. Those
applications can then use the data however they want. Sometimes, APIs also offer
a way for other applications to make changes to the data.
Un endpoint est une URL sur laquelle on réalise différents appels. Selon la
méthode HTTP utilisée (GET, POST, PATCH, DELETE), une partie de code va être
exécutée et retourner un résultat.
To do list pour créer une REST API :

1. Set up Django

2. Create a model in the database that the Django ORM will manage

3. Set up the Django REST Framework

4. Serialize the model from step 2

5. Create the URI endpoints to view the serialized data

On ajoute rest_framework au INSTALLED_APPS

Serialize class

M2i Django 7
 Serializers in Django REST Framework are responsible for converting objects into
data types understandable by javascript and front-end frameworks. Serializers also
provide deserialization, allowing parsed data to be converted back into complex
types, after first validating the incoming data. The serializers in REST framework
work very similarly to Django’s Form and ModelForm classes. The two major
serializers that are most popularly used
are ModelSerializer and HyperLinkedModelSerialzer.
https://www.geeksforgeeks.org/serializers-django-rest-framework/

Mixins
Les mixins permet de faire des hiérarchies d'héritage. C'est une classe qui contient
une combinaison de méthodes d'autres classes.

:
staticfiles

@login_required
@user_passes_test
is_valid : You need to call  is_valid  during deserialization process before write data to
DB.  is_valid  perform validation of input data and confirm that this data contain all
required fields and all fields have correct types. If validation process
succeded  is_valid  set  validated_data  dictionary which is used for creation or updating
data in DB. Otherwise serializer's property  errors  will contain information about errors
in input data, and you can send this information as HTTP response in your view.

M2i Django 8