La validation de formulaires et de champs¶
La validation de formulaire intervient lorsque les données sont nettoyées. Si vous souhaitez personnaliser ce processus, il y a plusieurs points d’entrée où des changements peuvent se faire, chacun visant un objectif différent. Trois types de méthodes de nettoyage sont exécutés durant le traitement d’un formulaire. Elles sont normalement exécutées lorsque la méthodeis_valid() d’un formulaire est appelée. Il y a d’autres opérations qui peuvent aussi provoquer le nettoyage et la validation (l’accès à l’attributerrors ou l’appel direct àfull_clean()), mais en principe, cela ne fait pas partie du processus normal.
En général, toute méthode de nettoyage peut générer l’exceptionValidationError si un problème survient lors du traitement des valeurs, en passant des informations adéquates au constructeur deValidationError.Voir ci-dessous pour les bonnes pratiques de génération deValidationError. Si aucune exceptionValidationError n’est produite, la méthode doit renvoyer la valeur nettoyée (normalisée) sous forme d’objet Python.
La plupart de la validation peut se faire à l’aide devalidateurs, des fonctions utilitaires pouvant être réutilisées. Il s’agit de fonctions (ou objets exécutables) acceptant un seul paramètre et générant une exceptionValidationError en cas de saisie non valide. Les validateurs sont exécutés après l’appel aux méthodesto_python etvalidate du champ.
La validation d’un formulaire est partagée en plusieurs étapes, qui peuvent être personnalisées ou surchargées :
La méthode
to_python()d’un champFieldest la première étape de toute validation. Elle transforme la valeur dans le bon type de données et génèreValidationErrorsi ce n’est pas possible. Cette méthode accepte la valeur brute provenant du composant et renvoie la valeur convertie. Par exemple, un champFloatFieldtransforme la donnée en un objet Pythonfloatou génère une exceptionValidationError.La méthode
validate()d’un champFieldse charge de la validation spécifique du champ qui ne convient pas pour un validateur. Elle accepte une valeur ayant déjà été convertie dans le bon type et génère une exceptionValidationErroren cas d’erreur. Cette méthode ne renvoie rien et ne doit pas modifier la valeur. Elle peut être surchargée pour gérer de la logique de validation que vous ne pouvez ou ne voulez pas placer dans un validateur.La méthode
run_validators()d’un champ lance tous les validateurs du champ et rassemble toutes les erreurs dans une seule exceptionValidationError. Il n’est en principe pas utile de surcharger cette méthode.La méthode
clean()d’une sous-classe de champ est responsable de l’exécution deto_python(),validate()etrun_validators()dans le bon ordre et de la propagation des erreurs. Si à tout moment l’une de ces méthodes génère une exceptionValidationError, la validation s’arrête et cette erreur est propagée. Cette méthode renvoie les données nettoyées qui sont ensuite insérées dans le dictionnairecleaned_datadu formulaire.La méthode
clean_<nom_du_champ>()est appelée pour une sous-classe de formulaire – où<nom_du_champ>est remplacé par le nom de l’attribut de champ de formulaire. Cette méthode s’occupe de tout nettoyage spécifique à cet attribut, sans considération du type de champ concerné. Cette méthode ne reçoit aucun paramètre. Vous devez chercher vous-même la valeur du champ dansself.cleaned_dataet vous rappeler qu’il s’agira à ce moment d’un objet Python, pas de la chaîne initialement soumise avec le formulaire (la valeur figure danscleaned_dataparce que la méthode généraleclean()du champ aura déjà nettoyé la valeur une première fois).Par exemple, si vous souhaitiez valider que le contenu d’un champ
CharFieldnomméserialnumberest unique,clean_serialnumber()serait le bon endroit pour le faire. Vous n’avez pas besoin d’un champ spécifique (c’est unCharField), mais vous avez besoin d’une séquence de validation propre au champ de formulaire et, si possible, de nettoyer/normaliser les données.La valeur renvoyée par cette méthode remplace la valeur existante dans
cleaned_data, il doit donc s’agir soit de la valeur decleaned_data(même si cette méthode ne l’a pas modifiée), soit d’une nouvelle valeur propre.La méthode
clean()de la sous-classe de formulaire peut effectuer toute validation nécessitant d’accéder à plusieurs champs de formulaire. C’est ici que vous pouvez placer des contrôles du genre : si le champAest renseigné , le champBdoit contenir une adresse de messagerie valide. Cette méthode peut renvoyer un dictionnaire complètement différent si elle le souhaite, et ce résultat sera utilisé comme contenu decleaned_data.Comme les méthodes de validation des champs ont été exécutées au moment où
clean()est appelée, vous avez aussi accès à l’attributerrorsdu formulaire qui contient toutes les erreurs générées lors du nettoyage individuel des champs.Notez que toute erreur générée par votre version de
Form.clean()ne sera associée à aucun champ particulier. Elles sont attribuées à un « champ » spécial nommé__all__auquel il est possible d’accéder par la méthodenon_field_errors()en cas de besoin. Si vous souhaitez lier une erreur à un champ spécifique du formulaire, vous devrez appeleradd_error().Notez également qu’il faut tenir compte de considérations particulières lors de la surcharge de la méthode
clean()d’une sous-classe deModelForm(voir ladocumentation de ModelForm pour plus d’informations).
Ces méthodes sont exécutées dans l’ordre metnionné ci-dessus, un champ après l’autre. C’est-à-dire que pour chaque champ du formulaire (dans l’ordre où ils ont été déclarés dans la définition du formulaire), la méthodeField.clean() (ou sa version surchargée) est exécutée, puisclean_<nom_du_champ>(). Finalement, après que ces deux méthodes ont été exécutées pour chaque champ, la méthodeForm.clean() ou sa version surchargée est exécutée dans tous les cas, même si les méthodes précédentes ont généré des erreurs.
Des exemples pour chacune de ces méthodes sont présentés ci-dessous.
Comme mentionné, chacune de ces méthodes peut générer une exceptionValidationError. Pour chaque champ, si la méthodeField.clean() gènère une erreurValidationError, la méthode de nettoyage spécifique au champ n’est pas appelée. Cependant, les méthodes de nettoyage de tous les autres champs sont tout de même exécutées.
Génération deValidationError¶
Pour une plus grande flexibilité des messages d’erreur et pour qu’il soit plus facile de les surcharger, voici quelques lignes de conduite :
Fournissez un
coded’erreur descriptif au constructeur :# GoodValidationError(_('Invalid value'),code='invalid')# BadValidationError(_('Invalid value'))
Ne fusionnez pas les variables dans les messages ; utilisez des substituants ainsi que le paramètre
paramsdu constructeur :# GoodValidationError(_('Invalid value:%(value)s'),params={'value':'42'},)# BadValidationError(_('Invalid value:%s')%value)
Préférez la substitution par clé de dictionnaire plutôt que le formatage positionnel. Cela permet de placer les variables dans n’importe quel ordre ou même de les omettre entièrement lors de la réécriture d’un message :
# GoodValidationError(_('Invalid value:%(value)s'),params={'value':'42'},)# BadValidationError(_('Invalid value:%s'),params=('42',),)
Englobez le message dans un appel
gettextpour activer sa traduction :# GoodValidationError(_('Invalid value'))# BadValidationError('Invalid value')
Pour résumer le tout :
raiseValidationError(_('Invalid value:%(value)s'),code='invalid',params={'value':'42'},)
Le respect de ces lignes de conduite est particulièrement utile si vous écrivez des formulaires, des champs de formulaire ou des champs de modèle réutilisables.
Même si ce n’est pas recommandé, si vous vous trouvez à la fin de la chaîne de validation (par ex. la méthodeclean() de votre formulaire) et que vous savez que vous n’aurezjamais besoin de surcharger le message d’erreur, vous pouvez toujours opter pour la version plus directe :
ValidationError(_('Invalid value:%s')%value)
Les méthodesForm.errors.as_data() etForm.errors.as_json() bénéficient grandement d’objetsValidationError complètement renseignés (avec un nomcode et un dictionnaireparams).
Génération de plusieurs erreurs¶
Si vous détectez plusieurs erreurs durant une méthode de nettoyage et que vous souhaitiez toutes les signaler à celui qui a soumis le formulaire, il est possible de transmettre une liste d’erreurs au constructeur deValidationError.
Comme mentionné plus haut, il est recommandé de passer une liste d’instancesValidationError avec les paramètrescode etparams, mais une liste de chaînes fera aussi l’affaire :
# GoodraiseValidationError([ValidationError(_('Error 1'),code='error1'),ValidationError(_('Error 2'),code='error2'),])# BadraiseValidationError([_('Error 1'),_('Error 2'),])
Utilisation de la validation en pratique¶
Les sections précédentes ont expliqué comment fonctionne la validation de manière générale pour les formulaires. Comme il est parfois plus simple de remettre les choses à leur place en examinant du code en contexte, voici une série de petits exemples qui font usage de chacune des fonctionnalités présentées précédemment.
Utilisation des validateurs¶
Les champs de formulaire (et de modèle) de Django gèrent des fonctions et classes utilitaires connus sous le nom de validateurs. Un validateur est un objet exécutable acceptant une valeur et ne renvoyant rien du tout si la valeur est valide ou générant une exceptionValidationError si elle ne l’est pas. Ces validateurs peuvent être transmis à un constructeur de champ par l’intermédiaire du paramètrevalidators du champ ou définis dans une classeField par leur attributdefault_validators.
Des validateurs peuvent être employés pour valider des valeurs d’un champ ; examinons par exemple le champSlugField de Django :
fromdjango.coreimportvalidatorsfromdjango.formsimportCharFieldclassSlugField(CharField):default_validators=[validators.validate_slug]
Comme vous pouvez le voir,SlugField est unCharField doté d’un validateur particulier validant que le texte soumis obéit à certaines règles textuelles. Cela peut aussi se faire lors de la définition du champ, ainsi :
slug=forms.SlugField()
est équivalent à :
slug=forms.CharField(validators=[validators.validate_slug])
Des cas courants comme la validation d’une adresse électronique ou d’une expression régulière peuvent être traités avec des classes de validation existantes de Django. Par exemple,validators.validate_slug est une instance deRegexValidator construite avec son premier paramètre équivalent au motif^[-a-zA-Z0-9_]+$. Consultez la section sur l”écriture de validateurs pour voir une liste de ce qui est déjà disponible et pour des exemples de la façon d’écrire un validateur.
Nettoyage par défaut des champs de formulaire¶
Créons tout d’abord un champ de formulaire personnalisé qui valide que sa valeur d’entrée est une chaîne contenant des adresses électroniques séparées par des virgules. La classe complète ressemble à ceci :
fromdjangoimportformsfromdjango.core.validatorsimportvalidate_emailclassMultiEmailField(forms.Field):defto_python(self,value):"""Normalize data to a list of strings."""# Return an empty list if no input was given.ifnotvalue:return[]returnvalue.split(',')defvalidate(self,value):"""Check if value consists only of valid emails."""# Use the parent's handling of required fields, etc.super().validate(value)foremailinvalue:validate_email(email)
Pour chaque formulaire utilisant ce champ, ces méthodes seront exécutées avant que quoi que ce soit puisse être fait avec les données du champ. Il s’agit de nettoyage spécifique à ce type de champ, quelle que soit la manière dont il sera utilisé par la suite.
Créons un formulaireContactForm pour montrer comment ce champ peut être utilisé :
classContactForm(forms.Form):subject=forms.CharField(max_length=100)message=forms.CharField()sender=forms.EmailField()recipients=MultiEmailField()cc_myself=forms.BooleanField(required=False)
UtilisezMultiEmailField comme n’importe quel autre champ. Lorsque la méthodeis_valid() est appelée pour le formulaire, la méthodeMultiEmailField.clean() sera aussi exécutée dans le contexte du processus de nettoyage, et celle-ci appellera à son tour les méthodes personnaliséesto_python() etvalidate().
Nettoyage d’un attribut de champ spécifique¶
En poursuivant l’exemple précédent, supposons que dans notre formulaireContactForm, nous aimerions être certain que le champrecipients contienne toujours l’adresse"fred@example.com". Il s’agit de validation spécifique à notre formulaire, ce qui explique que nous ne voulions pas la placer dans la classe génériqueMultiEmailField. Au lieu de cela, nous écrivons une méthode de nettoyage qui agit sur le champrecipients, comme ceci :
fromdjangoimportformsfromdjango.core.exceptionsimportValidationErrorclassContactForm(forms.Form):# Everything as before....defclean_recipients(self):data=self.cleaned_data['recipients']if"fred@example.com"notindata:raiseValidationError("You have forgotten about Fred!")# Always return a value to use as the new cleaned data, even if# this method didn't change it.returndata
Nettoyage et validation de champs qui dépendent l’un de l’autre¶
Supposons que nous ajoutions une autre exigence à notre formulaire de contact : si le champcc_myself vautTrue, le champsubject doit contenir le mot"help". Nous effectuons de la validation s’appliquant à plus d’un champ à la fois, c’est pourquoi la méthodeclean() du formulaire est le bon endroit pour cela. Remarquez que nous parlons bien maintenant de la méthodeclean() du formulaire, alors qu’auparavant nous avions écrit une méthodeclean() pour un champ. Il est important de bien faire la différence entre le champ et le formulaire lorsqu’il s’agit de la validation de contenu. Les champs sont des points de données uniques, les formulaires sont des ensembles de champs.
Au moment où la méthodeclean() du formulaire est appelée, toutes les méthodes de nettoyage de chaque champ auront déjà été exécutées (cf. les deux sections précédentes), ce qui fait queself.cleaned_data sera rempli par toute donnée ayant respecté la validation jusque là. Il faut donc aussi se rappeler de tenir compte du fait que les champs que vous souhaitez valider pourraient ne pas avoir passé l’étape préalable de la vérification au niveau du champ individuel.
Il y a deux manières de signaler des erreurs à ce stade. La méthode probablement la plus courante est d’afficher l’erreur au sommet du formulaire. Pour créer une telle erreur, vous pouvez générer une exceptionValidationError à partir de la méthodeclean(). Par exemple :
fromdjangoimportformsfromdjango.core.exceptionsimportValidationErrorclassContactForm(forms.Form):# Everything as before....defclean(self):cleaned_data=super().clean()cc_myself=cleaned_data.get("cc_myself")subject=cleaned_data.get("subject")ifcc_myselfandsubject:# Only do something if both fields are valid so far.if"help"notinsubject:raiseValidationError("Did not send for 'help' in the subject despite ""CC'ing yourself.")
Dans ce code, si l’erreur de validation est générée, le formulaire affichera un message d’erreur au sommet du formulaire (dans le cas normal) décrivant le problème. De telles erreurs sont des erreurs non liées à des champs qui sont affichées dans les gabarits par{{form.non_field_errors}}.
L’appel àsuper().clean() dans l’exemple de code garantit que toute logique de validation dans les classes parentes est conservée. Si votre formulaire hérite d’un autre qui ne renvoie pas de dictionnairecleaned_data dans sa méthodeclean() (c’est facultatif), n’attribuez pas le résultat de l’appel àsuper() àcleaned_data et utilisez plutôtself.cleaned_data:
defclean(self):super().clean()cc_myself=self.cleaned_data.get("cc_myself")...
La seconde approche pour signaler les erreurs de validation pourrait impliquer d’attribuer le message d’erreur à l’un des champs. Dans ce cas, attribuons un message d’erreur à la fois aux deux lignes « subject » et « cc_myself » dans l’affichage du formulaire. Soyez prudent si vous faites cela en pratique, car cela pourrait amener de la confusion dans la présentation du formulaire. Nous montrons ici ce qui est possible, mais nous vous laissons la responsabilité de constater vous-même ce qui est faisable dans votre contexte particulier. Notre nouveau code (remplaçant l’exemple précédent) ressemble à ceci :
fromdjangoimportformsclassContactForm(forms.Form):# Everything as before....defclean(self):cleaned_data=super().clean()cc_myself=cleaned_data.get("cc_myself")subject=cleaned_data.get("subject")ifcc_myselfandsubjectand"help"notinsubject:msg="Must put 'help' in subject when cc'ing yourself."self.add_error('cc_myself',msg)self.add_error('subject',msg)
Le second paramètre deadd_error() peut être une chaîne, ou de préférence une instance deValidationError. ConsultezGénération de ValidationError pour plus de détails. Notez queadd_error() enlève automatiquement le champ decleaned_data.
