Introduction aux Templates Django

Les templates Django permettent de générer du contenu dynamique en utilisant le langage de templates Django (DTL). Ils séparent la structure HTML statique des données dynamiques, favorisant une architecture modulaire et maintenable. Les caractéristiques principales incluent :

• Séparation des préoccupations : Isolation de la logique métier de la logique de présentation.
• Réutilisabilité : Possibilité de partager des templates entre différentes vues et applications.
• Contenu dynamique : Utilisation de variables, boucles, et conditions via le DTL.
• Héritage et inclusion : Mécanismes pour modulariser et réutiliser le code des templates.
• Sécurité : Échappement automatique des données pour prévenir les attaques XSS.

Définition et Utilisation des Templates

Pour mettre en place un template :

1. Créez un fichier template avec l'extension .html dans le répertoire templates de votre application, par exemple modele_page.html.
2. Rédigez le contenu en utilisant le DTL pour intégrer des données dynamiques.
3. Dans la vue, utilisez la fonction render pour compiler le template avec un contexte de données.
4. Associez la vue à une URL dans la configuration des routes.

Exemple de fichier template :

<h1>{{ titre_page }}</h1>
<ul>
    {% for element in liste_elements %}
        <li>{{ element }}</li>
    {% endfor %}
</ul>

Correspondance dans la vue :

from django.shortcuts import render

def afficher_page(request):
    titre = "Bienvenue sur notre site"
    elements = ["Pomme", "Banane", "Orange"]
    return render(request, 'modele_page.html', {'titre_page': titre, 'liste_elements': elements})

Configuration des URLs :

from django.urls import path
from .views import afficher_page

urlpatterns = [
    path('page/', afficher_page, name='page_acces'),
]

Variables et Balises dans les Templates

Le DTL fournit des mécanismes pour manipuler les données :

• Variables : {{ variable }} – accès aux attributs ou éléments via le point, comme {{ objet.attribut }} ou {{ liste.0 }}.
• Balises : {% balise 'param' %} pour le contrôle du flux.
• Boucles : {% for item in collection %} ... {% endfor %} avec option {% empty %}.
• Conditions : {% if condition %} ... {% elif ... %} {% else %} {% endif %}.
• Filtres : {{ valeur|filtre:'argument' }} pour transformer les données, comme {{ date_courante|date:'d/m/Y' }}.
• Commentaires : Ligne unique {# commentaire #} ou multiple {% comment %} ... {% endcomment %}.

Balises intégrées courantes :

• block : Définit une zone modifiable dans les templates enfants.
• extends : Hérite d'un template parent.
• include : Intègre un autre template.
• load : Charge des bibliothèques de balises personnalisées.
• url : Génère des URLs à partir de noms de routes.
• csrf_token : Ajoute un jeton de sécurité pour les formulaires.

Filtres intégrés courants :

• escape : Échappe les caractères HTML.
• safe : Marque une chaîne comme sécurisée.
• slice : Découpe une liste ou une chaîne.
• join : Concatène les éléments d'une liste.
• length : Retourne la longueur d'une liste ou chaîne.

Balises de Template Personnalisées

Pour créer des balises sur mesure :

1. Dans un sous-répertoire templatetags de votre application, créez un fichier Python, par exemple mes_balises.py.
2. Définissez et enregistrez les balises via template.Library().
3. Ajoutez la bibliothèque dans les paramètres TEMPLATES sous OPTIONS.libraries.
4. Chargez la bibliothèque dans le template avec {% load mes_balises %}.

Exemple de balise personnalisée :

from django import template
from ..models import Projet

registre = template.Library()

@register.simple_tag
def compteur_projets():
    return Projet.objects.count()

Configuration dans settings.py :

TEMPLATES = [
    {
        'OPTIONS': {
            'libraries': {"mes_balises": "mon_app.templatetags.mes_balises"}
        },
    },
]

Utilisation dans un template :

{% load mes_balises %}
<div>Nombre de projets : {% compteur_projets %}</div>

Héritage et Inclusion de Templates

L'héritage permet de partager une structure commune via un template de base :

<!-- base.html -->
<html>
<head>
    <title>{% block titre %}{% endblock %}</title>
</head>
<body>
    {% block contenu %}{% endblock %}
</body>
</html>

Template enfant :

{% extends 'base.html' %}

{% block titre %}Liste des Projets{% endblock %}

{% block contenu %}
    <h1>Projets en cours</h1>
    {% include 'tableau_projets.html' %}
{% endblock %}

L'inclusion réutilise des fragments de templates :

<!-- tableau_projets.html -->
<table>
    <thead><tr><th>Nom</th><th>Description</th></tr></thead>
    <tbody><tr><td>Projet A</td><td>Description A</td></tr></tbody>
</table>

Utilisation des Fichiers Statiques

Pour intégrer des ressources CSS, JavaScript ou images :

1. Créez un répertoire static à la racine du projet avec des sous-répertoires si nécessaire.
2. Configurez les paramètres STATIC_URL et STATICFILES_DIRS dans settings.py.
3. Utilisez la balise {% static %} dans les templates après chargement avec {% load static %}.

Exemple de configuration :

STATIC_URL = "/ressources/"
STATICFILES_DIRS = [
    BASE_DIR / "static",
]

Utilisation dans un template :

{% load static %}
<link rel="stylesheet" href="{% static 'css/styles.css' %}">
<img src="{% static 'images/logo.svg' %}" alt="Logo">

Introduction aux Formulaires Django

Les formulaires Django facilitent la collecte, la validation et le traitement des données utilisateur. Ils sont adaptés pour des scénarios comme l'inscription, la connexion, ou l'édition de données.

Définition et Utilisation des Formulaires

Pour créer un formulaire standard :

from django import forms

class FormulaireAjoutProjet(forms.Form):
    nom = forms.CharField(label='Nom du projet', max_length=100, widget=forms.TextInput())
    description = forms.CharField(label='Description', widget=forms.Textarea())

Rendu dans un template :

<form action="/ajouter" method="post">
    {% csrf_token %}
    {{ formulaire.as_p }}
    <input type="submit" value="Envoyer">
</form>

Traitement dans la vue :

from .forms import FormulaireAjoutProjet
from django.shortcuts import redirect

def ajouter_projet(request):
    formulaire = FormulaireAjoutProjet(request.POST)
    if formulaire.is_valid():
        nom = formulaire.cleaned_data['nom']
        desc = formulaire.cleaned_data['description']
        # Sauvegarde en base de données
    return redirect('page_projets')

Formulaires Basés sur les Modèles

Les formulaires ModelForm génèrent automatiquement des champs à partir d'un modèle :

from django import forms
from .models import Projet

class FormulaireModeleProjet(forms.ModelForm):
    class Meta:
        model = Projet
        fields = ['nom', 'description']

Le rendu et le traitement sont similaires, avec l'avantage de sauvegarder directement via formulaire.save().

Ensembles de Formulaires

Les formsets permettent de gérer plusieurs instances d'un formulaire :

from django.forms import formset_factory
from .forms import FormulaireAjoutProjet

EnsembleProjets = formset_factory(FormulaireAjoutProjet, extra=2)

def gerer_projets(request):
    ensemble = EnsembleProjets(request.POST)
    if ensemble.is_valid():
        for formulaire in ensemble:
            # Traitement de chaque formulaire
    return redirect('page_projets')

Champs et Widgets des Formulaires

Les formulaires offrent divers champs et widgets pour personnaliser la saisie :

• Paramètres des champs : required, label, initial, widget, help_text, etc.
• Champs intégrés : CharField, IntegerField, EmailField, DateField, FileField, etc.
• Widgets : TextInput, Textarea, Select, CheckboxInput, FileInput, etc., avec options de personnalisation.