Mise en route de Django¶

Mappeur objet / relationnel¶

Modèles de données peuvent être définis entièrement en Python. DJango met à disposition une API riche et dynamique de base de données-accès gratuitement, mais il est toujours possible d’écrire du SQL si nécessaire.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

class Band(models.Model):
    """A model of a rock band."""
    name = models.CharField(max_length=200)
    can_rock = models.BooleanField(default=True)


class Member(models.Model):
    """A model of a rock band member."""
    name = models.CharField("Member's name", max_length=200)
    instrument = models.CharField(choices=(
            ('g', "Guitar"),
            ('b', "Bass"),
            ('d', "Drums"),
        ),
        max_length=1
    )
    band = models.ForeignKey("Band")

1
2
3
4
5

from django.db import models

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

1
2
3
4
5

CREATE TABLE myapp_person (
    "id" serial NOT NULL PRIMARY KEY,
    "first_name" varchar(30) NOT NULL,
    "last_name" varchar(30) NOT NULL
);

1
2
3
4
5

INSTALLED_APPS = (
    #...
    'myapp',
    #...
)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

from django.db import models

class Musician(models.Model):
    first_name = models.CharField(max_length=50)
    last_name = models.CharField(max_length=50)
    instrument = models.CharField(max_length=100)

class Album(models.Model):
    artist = models.ForeignKey(Musician)
    name = models.CharField(max_length=100)
    release_date = models.DateField()
    num_stars = models.IntegerField()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

from django.db import models

class Person(models.Model):
    first_name = models.CharField(max_length=50)
    last_name = models.CharField(max_length=50)
    birth_date = models.DateField()

    def baby_boomer_status(self):
        "Returns the person's baby-boomer status."
        import datetime
        if self.birth_date < datetime.date(1945, 8, 1):
            return "Pre-boomer"
        elif self.birth_date < datetime.date(1965, 1, 1):
            return "Baby boomer"
        else:
            return "Post-boomer"

    def _get_full_name(self):
        "Returns the person's full name."
        return '%s %s' % (self.first_name, self.last_name)
    full_name = property(_get_full_name)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

from django.db import models

class Blog(models.Model):
    name = models.CharField(max_length=100)
    tagline = models.TextField()

    def __str__(self):              # __unicode__ on Python 2
        return self.name

class Author(models.Model):
    name = models.CharField(max_length=50)
    email = models.EmailField()

    def __str__(self):              # __unicode__ on Python 2
        return self.name

class Entry(models.Model):
    blog = models.ForeignKey(Blog)
    headline = models.CharField(max_length=255)
    body_text = models.TextField()
    pub_date = models.DateField()
    mod_date = models.DateField()
    authors = models.ManyToManyField(Author)
    n_comments = models.IntegerField()
    n_pingbacks = models.IntegerField()
    rating = models.IntegerField()

    def __str__(self):              # __unicode__ on Python 2
        return self.headline

1
2
3

>>> from blog.models import Blog
>>> b = Blog(name='Beatles Blog', tagline='All the latest Beatles news.')
>>> b.save()

1
2

>>> b5.name = 'New name'
>>> b5.save()

1
2
3
4
5
6
7
8

>>> Blog.objects
<django.db.models.manager.Manager object at ...>
>>> b = Blog(name='Foo', tagline='Bar')
>>> b.objects
Traceback:
    ...
AttributeError: "Manager isn't accessible via Blog instances."
Note

1

>>> all_entries = Entry.objects.all()

1

Entry.objects.filter(pub_date__year=2006)

1

Entry.objects.all().filter(pub_date__year=2006)

1
2
3
4
5
6
7

>>> Entry.objects.filter(
...     headline__startswith='What'
... ).exclude(
...     pub_date__gte=datetime.date.today()
... ).filter(
...     pub_date__gte=datetime(2005, 1, 30)
... )

URL et vues¶

Un schéma d’URL propre élégant est un détail important dans une application Web de haute qualité. Django encourage la belle conception de l’URL et ne met pas indésirable dans les URL, comme .php ou .asp.

Dans DJango, un module Python appelé URLconf est comme une table des matières d’application. Il contient un simple mappage entre modèles d’URL et le vues.

1
2
3
4
5
6
7
8

from django.conf.urls import url
from . import views

urlpatterns = [
    url(r'^bands/$', views.band_listing, name='band-list'),
    url(r'^bands/(\d+)/$', views.band_detail, name='band-detail'),
    url(r'^bands/search/$', views.band_search, name='band-search'),
]

1
2
3
4
5
6

from django.shortcuts import render

def band_listing(request):
    """A view of all bands."""
    bands = models.Band.objects.all()
    return render(request, 'bands/band_listing.html', {'bands': bands})

Plus: URL dispatcher

Mises à jour¶

Langage de template de Django permet aux développeurs de mettre la logique dans le code HTML :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

<html>
  <head>
    <title>Band Listing</title>
  </head>
  <body>
    <h1>All Bands</h1>
    <ul>
    {% for band in bands %}
      <li>
        <h2><a href="{{ band.get_absolute_url }}">{{ band.name }}</a></h2>
        {% if band.can_rock %}<p>This band can rock!</p>{% endif %}
      </li>
    {% endfor %}
    </ul>
  </body>
</html>

Plus: Templates

Formulaires¶

Django fournit une bibliothèque qui gère le rendu des formulaires HTML, validation des données fournies par les utilisateurs et en convertissant les données pour les types natifs de Python. Django fournit également un moyen de générer des formes de vos modèles existants et d’utiliser ces formes pour créer et mettre à jour les données.

1
2
3
4
5
6
7

from django import forms

class BandContactForm(forms.Form):
    subject = forms.CharField(max_length=100)
    message = forms.CharField()
    sender = forms.EmailField()
    cc_myself = forms.BooleanField(required=False)

Authentification¶

Django utilise un système d’authentification complet et sûr. Il gère les comptes d’utilisateurs, les groupes, les autorisations et les sessions utilisateur basée sur les cookies.

1
2
3
4
5
6
7

from django.contrib.auth.decorators import login_required
from django.shortcuts import render

@login_required
def my_protected_view(request):
    """A view that can only be accessed by logged-in users"""
    return render(request, 'protected.html', {'current_user': request.user})

Plus: User authentication in Django

Administrateur¶

Une des parties plus puissants de Django est son interface d’administration automatique. Il lit les métadonnées des modèles afin de fournir une interface utilisateur graphique puissante et prêt à l’emploi pour opérations CRUD selon le modèle.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

from django.contrib import admin
from bands.models import Band, Member

class MemberAdmin(admin.ModelAdmin):
    """Customize the look of the auto-generated admin for the Member model"""
    list_display = ('name', 'instrument')
    list_filter = ('band',)

admin.site.register(Band)  # Use the default options
admin.site.register(Member, MemberAdmin)  # Use the customized options

Plus: The Django admin site

Internationalisation¶

Django offre un support complet pour la traduction du texte dans des langues différentes, plus spécifiques aux paramètres régionaux de mise en forme des dates, des heures, des nombres et des fuseaux horaires. Il permet aux développeurs et créateurs de modèles spécifient quelles sont les parties de leurs applications doivent être traduits ou formatés pour les cultures et les langues locales, et il utilise ces crochets pour localiser des applications Web pour des utilisateurs particuliers selon leurs préférences.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

from django.shortcuts import render
from django.utils.translation import ugettext

def homepage(request):
    """
    Shows the homepage with a welcome message that is translated in the
    user's language.
    """
    message = ugettext('Welcome to our site!')
    return render(request, 'homepage.html', {'message': message})

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

{% load i18n %}
<html>
  <head>
    <title>{% trans 'Homepage - Hall of Fame' %}</title>
  </head>
  <body>
    {# Translated in the view: #}
    <h1>{{ message }}</h1>
    <p>
      {% blocktrans count member_count=bands.count %}
      Here is the only band in the hall of fame:
      {% plural %}
      Here are all the {{ member_count }} bands in the hall of fame:
      {% endblocktrans %}
    </p>
    <ul>
    {% for band in bands %}
      <li>
        <h2><a href="{{ band.get_absolute_url }}">{{ band.name }}</a></h2>
        {% if band.can_rock %}<p>{% trans 'This band can rock!' %}</p>{% endif %}
      </li>
    {% endfor %}
    </ul>
  </body>
</html>

Plus: Internationalization and localization

Sécurité¶

Django dispose de multiples protections contre :

• Détournement de clic

  Clickjacking est un type d’attaque où un site malveillant encapsule un autre site dans un cadre. Cette attaque peut entraîner par un utilisateur non averti dupé en effectuant des actions inattendues sur le site cible.

  Le X-Frame-Options middleware contenu dans un formulaire permettent un prise en charge navigateur empêcher un site d’être restitués à l’intérieur d’un cadre

• Cross site scripting (XSS)

  Les attaques XSS permettent à un utilisateur d’injecter des scripts côté client dans les navigateurs des autres utilisateurs. Ceci est habituellement réalisé en stockant les scripts malveillants dans la base de données où il sera récupéré et affiché aux autres utilisateurs, ou en obtenant les utilisateurs à cliquer sur un lien qui va provoquer JavaScript de l’attaquant à être exécuté par le navigateur de l’utilisateur. Cependant, les attaques XSS peuvent provenir de toute source non fiable des données, telles que les cookies ou les services Web, chaque fois que les données ne sont pas suffisamment filtrées avant d’y compris dans une page.

• Cross-Site Request Forgery (CSRF)

  Les attaques CSRF permettent à un utilisateur malveillant d’exécuter des actions en utilisant les informations d’identification d’un autre utilisateur sans la connaissance ou le consentement de l’utilisateur.

  CSRF protection fonctionne en recherchant un nonce dans chaque requête POST. Cela fait en sorte qu’un utilisateur malveillant ne peut pas simplement « rejouer » un POST de formulaire à votre site Web et avoir un autre utilisateur connecté sans le vouloir soumettre ce formulaire. L’utilisateur malveillant devra connaître le nonce, qui est l’utilisateur spécifique (à l’aide d’un cookie).

• Injection SQL

  Injection SQL est un type d’attaque où un utilisateur malveillant est capable d’exécuter du code arbitraire SQL sur une base de données. Cela peut entraîner dans les dossiers en cours de suppression ou de fuites de données.

• Validation d’en-tête hôte

  Django utilise le Accueil en-tête fournie par le client pour construire des URL dans certains cas. Bien que ces valeurs sont désinfectées pour prévenir des attaques Cross Site Scripting, un faux Accueil valeur peut être utilisée pour Cross-Site Request Forgery, cache attaques d’empoisonnement et l’empoisonnement des liens dans les e-mails.

  Parce que les configurations de serveur web sécurisé même apparemment sont susceptibles d’être faux Accueil en-têtes, Django valide hôte en-têtes contre le ALLOWED_HOSTS paramètre dans la méthode de``django.http.HttpRequest.get_host()``.

  Cette validation s’applique uniquement get_host(); Si votre code accède directement à partir de l’en-tête d’hôte request.META vous êtes contourner cette protection de sécurité.

• SSL/HTTPS

  Il est toujours préférable pour la sécurité, mais pas toujours pratique dans tous les cas, pour déployer votre site derrière HTTPS. Sans cela, il est possible pour les utilisateurs de réseau malveillant de renifler les informations d’authentification ou d’autres informations transférées entre le client et le serveur et dans certains cas – les attaquants réseau actif – de modifier les données qui sont envoyées dans les deux sens.

  Django fournit certains paramètres pour sécuriser votre site unser SSL/HTTPS.

Plus: Security in Django