Les projets sont organisés suivant une hiérarchie de répertoires et de fichiers organisés en arbre.

Environnement de développement pour Django

Il est fortement conseillé d'installer un environnement de programmation python.
Ce dernier sera lié au projet et pourra être mis à jour facilement sans toucher au système d'exploitation.

Installation des librairies à partir des dépôts ou des sources

• De préférence on utilisera le dépôt PyPi (Packages Python).
• Quand cela est nécessaire, depuis les sources.
• Dans certain cas, le gestionnaire de package du système d'exploitation.
• Enfin en combinant 1, 2, 3

1. Choisir un répertoire pour contenir le projet entier
2. Installer ensuite un environnement python avec au moins le paquet django

Projet Django

Un projet Django est contenu dans un répertoire BASE_DIR qui portera le nom du projet par exemple demo
Les répertoires des applications qui seront plus tard installées se trouveront à ce niveau.
Une simple commande permet de générer un squelette composé généralement des fichiers suivants:

.
└── demo
    ├── demo
    │   ├── asgi.py
    │   ├── __init__.py
    │   ├── settings.py
    │   ├── urls.py
    │   └── wsgi.py
    └── manage.py
    

• manage.py: ‣ la boîte à outils de Django
• Un répertoire demo (nom du projet) est l'application principale composée des fichiers suivants:
  • __init__.py: ‣ marque le répertoire comme un paquet python
  • wsgi.py: ‣ module de l'application en mode wsgi
  • asgi.py: ‣ module de l'application en mode asgi
  • urls.py: ‣ module de routage (liens vers les pages)
  • settings.py: ‣ module de configuration de l'application./ma
  • On placera à ce niveau les répertoires suivants:
    • Répertoire static: ‣ (css, image, icon, javascript, webfont, etc ...)
    • Répertoire templates: ‣ (fichiers de gabari généralement en html)

Application Django

Une application de Django s'insère dans le répertoire BASE_DIR demo par exemple boutique.
Une simple commande permet de générer un squelette composé des fichiers suivants:

.
└── demo
    ├── boutique
    │   ├── admin.py
    │   ├── apps.py
    │   ├── __init__.py
    │   ├── migrations
    │   │   └── __init__.py
    │   ├── models.py
    │   ├── tests.py
    │   └── views.py
    ├── demo
    ...
    └── manage.py
    

• test.py: ‣ module de test
• apps.py: ‣ module de configuration de l'application
• admin.py: ‣ module d'administration de la base de données (back end)
• views.py: ‣ module de traitement des requêtes et des réponses HTTP
• models.py: ‣ module de gestion la gestion de la base de données
• On placera à ce niveau, si besoin, les répertoires suivants:
  • Répertoire static: ‣ (css, image, icon, javascript, webfont, etc ...)
  • Répertoire templates: ‣ (fichiers de gabari généralement en html)
• On placera à ce niveau, en fonction des applications installées les modules:
  • forms.py: ‣ Formulaires de saisie
  • filters.py: ‣ Filtres des requêtes ORM de Django (django-filter)
  • signals.py: ‣ Répartiteur de signaux (récupérer des actions executées ailleurs dans un projet)
  • tasks.py: ‣ Gestionnaire de tâches (django-celery-beat)

Principes pour développer un projet Django

1. Créer l'environnement python dans un répertoire:
   $> python -m venv .venv
2. Démarrer l'environnement python et installer django:
   $> source .venv/bin/python (démarrer l'environnement python)
   (.venv) $> pip install django
3. Le projet est créé avec la commande suivante:
   (.venv) $> django-admin startproject demo
4. Faire une première migration pour créer la base de donées (sqlite3 par défaut):
   (.venv) $> cd demo (se placer dans le répertoire projet)
   (.venv) $> python manage.py migrate
5. Créer le super utilisateur pour l'administration du back end:
   (.venv) $> python manage.py createsuperuser
6. On peut maintenant lancer le serveur de développement:
   (.venv) $> python manage.py runserver
7. Tester les adresse suivantes:
   http://127.0.0.1:8000/admin/ (Administration du back end)
   http://127.0.0.1:8000 (Le site front end)
8. Tout est prêt pour commencer son projet

Prendre un IDE pour éditer le projet

• Spyder + Anaconda (libre)
• Eclipse + pydev (libre)
• Pycharm (libre pour python mais payant pour django
• Visualstudio (libre)

Modifier les variables du projet et adapter le settings.py

1. Par défaut le mode DEBUG = True, on le laisse tel que en mode développement
2. Ajouter boutique dans la liste des applications installées: INSTALLED_APPS

   INSTALLED_APPS = [
       ...
       'boutique',
   ]
               

3. Configurer l'accès à la base de données par défaut c'est sqlite3: DATABASES
4. Configuration du fuseau horaire: TIME_ZONE
5. Changer la langue: LANGUAGE_CODE
6. Paramétrer les fichiers statiques: STATIC_URL et STATICFILES_DIRS
7. Indiquer les dossiers templates: TEMPLATES
8. Indiquer les dossiers média: MEDIA_URL et MEDIA_ROOT

On est prêt pour créer une application et créer une première page

1. (.venv) $> python manage.py startapp boutique (création de l'application boutique)
2. Créer une route vers la page home dans demo/url.py:

   from boutique import views
   urlpatterns = [
       ...
       path('', 'views.home', name='home'),
   [
               

3. Créer une fonction home dans boutique/views:

   def home(request):
       return render(request, 'boutique/home.html')
               

4. Créer la template dans boutique/templates/boutique/home.html:
   (.venv) $> mkdir -p boutique/templates/boutique
   (.venv) $> echo "Bonjour tout le monde" > boutique/templates/boutique/home.html
5. Le rendu de la page home est alors visible en 127.0.0.1:8000

Données

La base de données est générée à partir du module models.py

• Exemple création de la table articles dans boutique/models.py:

  class Article(models.Model):
      name = models.CharField("Name", max_length=200, null=True, blank=False)
      #description = models.TextField("Description", null=True, blank=True)
          

• Procéder à la migation à chaque modification ou mise à jour des models.

  (.venv) $> python manage.py makemigrations
  (.venv) $> python manage.py migrate
          

Administration de la base de données

• Il suffit d'enregistrer le modèle dans le module boutique/admin.py

  from boutique import models
  admin.site.register(models.Article)
          

• Le rendu de la page admin est alors visible en 127.0.0.1:8000/admin

Formulaires de saisie

Les formulaires de saisie s'insèrent dans le module boutique/forms.py

from django import forms
from boutique import models

class ArticleForm(forms.ModelForm):

    class Meta:
        model = models.Article
        fields = ['name', 'description', ]
    

Traitement d'un formulaire

Le traitement du formulaire se place dans le module boutique/views.py
On créera sa route dans boutique/urls.py

• La route:

  urlpatterns = [
      ...
      path('article/', 'views.article', name='article'),
   ]
          

• La vue:

  ...
  from boutique.forms import ArticleForm
  
  def article(request):
      formulaire = ArticleForm()
      return render(request, 'boutique/article.html', context={'formulaire': ArticleForm()})
          

• La template dans boutique/article.html

  {{ formulaire.as_p }}
          

• Le rendu de la page article est alors visible en 127.0.0.1:8000/article/

Architecture MVT, (Model-View-Template)

• Model: le modèle définit la structure et la gestion de la base de données
  • Django ORM (Object Relational Mapping)
  • Modèles de données définis par des classes Python
• View: une vue reçoit les requêtes HTTP et renvoie les réponses HTTP.
  • accède aux données requises pour satisfaire les requêtes par une fonction ou classe python via les modèles
  • formate la réponse aux templates ou rendu html
• Template
  • interface html ou rendu visuel
  • langage de balisage personnel
  • interfaces dynamiques et interactives

Principe DRY (Don’t Repeat Yourself)

• environnement de travail propre et gérable
• un espace unique pour stocker chaque objet distinct
• supprime les redondances pour se concentrer sur la logique de l'application

Authentification et sécurité

• un système d'authentification utilisateur complet et sécurisé
• comptes d'utilisateurs, groupes d'utilisateurs et sessions
• un système de sécurité de pointe contre les failles de sécurité courantes

DRF (Django REST Framework)

• une boîte à outils de composants pour créer des API RESTFUL
• Une API est une interface permettant d'interagir avec des bases de données.
• Les API RESTFUL sont utilisées pour répertorier, modifier, créer et supprimer des données sur des serveurs Web

Fonctionnalités

• développement rapide d’applications web complexes.
• suppression les tâches rébarbatives et répétitives.
• assure des applications sécurisés et faciles à maintenir.
• supporte les opérations de caches et de bases de données.
• couvre à la fois le front end et le back end de l'application.
  • back end: gestion base de données côté serveur (Administration Django ORM).
  • front end: interface utilisateur (html, css, javascript).

Pour mémoire

• Date de création 2000
• Open source depuis 2005
• Framework web le plus utilisé dans le monde
  • Instagram
  • Spotify
  • Washington Post
  • DropBox
  • Mozilla
  • YouTube
  • Pinterest
  • National Geographic