Les formulaires groupés sont une couche d’abstraction pour travailler avec plusieurs formulaires sur une même page. On peut comparer cela à un tableau de données. Admettons que l’on dispose du formulaire suivant :
\n>>> from django import forms\n>>> class ArticleForm(forms.Form):\n... title = forms.CharField()\n... pub_date = forms.DateField()\n...\nIl peut être souhaitable de permettre à l’utilisateur de créer plusieurs articles à la fois. Pour créer des formulaires groupés à partir d’un formulaire ArticleForm, voici comment procéder :
>>> from django.forms import formset_factory\n>>> ArticleFormSet = formset_factory(ArticleForm)\nVous avez maintenant créé une classe de formulaires groupés nommée ArticleFormSet. En créant une instance de cette classe, cela vous donne la possibilité d’effectuer une itération sur les formulaires du groupe et de les afficher tout comme vous le feriez pour un formulaire habituel :
>>> formset = ArticleFormSet()\n>>> for form in formset:\n... print(form)\n...\n<div><label for="id_form-0-title">Title:</label><input type="text" name="form-0-title" id="id_form-0-title"></div>\n<div><label for="id_form-0-pub_date">Pub date:</label><input type="text" name="form-0-pub_date" id="id_form-0-pub_date"></div>\nComme vous le voyez, un seul formulaire vierge a été affiché. Le nombre de formulaires vierges affichés dépend du paramètre extra. Par défaut, formset_factory() définit un seul formulaire supplémentaire ; l’exemple suivant crée une classe de formulaires groupés pour afficher deux formulaires vierges :
>>> ArticleFormSet = formset_factory(ArticleForm, extra=2)\nFormsets can be iterated and indexed, accessing forms in the order they were\ncreated. You can reorder the forms by overriding the default\n__iter__() and __getitem__() methods if needed.\n(For more information on implementing these methods, see the\nPython documentation on sequences.)
Les données initiales sont le moteur essentiel qui fait l’intérêt des formulaires groupés. Comme on peut le voir ci-dessus, vous pouvez définir le nombre de formulaires supplémentaires. Cela signifie que vous pouvez indiquer aux formulaires groupés combien de formulaires supplémentaires doivent être affichés en plus des formulaires générés à partir des données initiales. Examinons un exemple plus en détails :
\n>>> import datetime\n>>> from django.forms import formset_factory\n>>> from myapp.forms import ArticleForm\n>>> ArticleFormSet = formset_factory(ArticleForm, extra=2)\n>>> formset = ArticleFormSet(\n... initial=[\n... {\n... "title": "Django is now open source",\n... "pub_date": datetime.date.today(),\n... }\n... ]\n... )\n\n>>> for form in formset:\n... print(form)\n...\n<div><label for="id_form-0-title">Title:</label><input type="text" name="form-0-title" value="Django is now open source" id="id_form-0-title"></div>\n<div><label for="id_form-0-pub_date">Pub date:</label><input type="text" name="form-0-pub_date" value="2023-02-11" id="id_form-0-pub_date"></div>\n<div><label for="id_form-1-title">Title:</label><input type="text" name="form-1-title" id="id_form-1-title"></div>\n<div><label for="id_form-1-pub_date">Pub date:</label><input type="text" name="form-1-pub_date" id="id_form-1-pub_date"></div>\n<div><label for="id_form-2-title">Title:</label><input type="text" name="form-2-title" id="id_form-2-title"></div>\n<div><label for="id_form-2-pub_date">Pub date:</label><input type="text" name="form-2-pub_date" id="id_form-2-pub_date"></div>\nNous avons maintenant trois formulaires qui s’affichent. Un pour les données initiales que nous lui avons transmises et deux formulaires supplémentaires. Notez également que nous transmettons une liste de dictionnaires comme données initiales.
\nSI vous utilisez initial dans l’affichage de formulaires groupés, vous devez passer la même valeur initial lors du traitement de ces formulaires au moment de l’envoi des données pour permettre la détection des formulaires modifiés par l’utilisateur. Par exemple, vous pourriez avoir quelque chose comme : ArticleFormSet(request.POST, initial=[...]).
Le paramètre max_num de formset_factory() donne la possibilité de restreindre le nombre de formulaires que les formulaires groupés vont afficher :
>>> from django.forms import formset_factory\n>>> from myapp.forms import ArticleForm\n>>> ArticleFormSet = formset_factory(ArticleForm, extra=2, max_num=1)\n>>> formset = ArticleFormSet()\n>>> for form in formset:\n... print(form)\n...\n<div><label for="id_form-0-title">Title:</label><input type="text" name="form-0-title" id="id_form-0-title"></div>\n<div><label for="id_form-0-pub_date">Pub date:</label><input type="text" name="form-0-pub_date" id="id_form-0-pub_date"></div>\nSi la valeur de max_num est plus grande que le nombre d’objets existants dans les données initiales, un maximum de extra formulaires vierges supplémentaires seront ajoutés au formulaire groupé, tant que le nombre total de formulaires n’excède pas max_num. Par exemple, si extra=2 et max_num=2 et que le formulaire groupé est initialisé avec un élément initial, on verra s’afficher un formulaire pour l’élément initial et un formulaire vierge.
Si le nombre d’éléments dans les données initiales dépasse max_num, tous les formulaires correspondant aux données initiales seront affichés quelle que soit la valeur de max_num et aucun formulaire supplémentaire ne sera affiché. Par exemple, si extra=3 et max_num=1 et que le formulaire groupé est initialisé avec deux éléments, ce sont deux formulaires avec les données initiales qui seront affichés.
Une valeur max_num None (par défaut) place une limite élevée du nombre de formulaires affichés (1000). En pratique, cela équivaut à aucune limite.
Par défaut, max_num ne s’applique qu’au nombre de formulaires affichés et non pas à la validation. Si validate_max=True est transmis à formset_factory(), max_num s’applique alors à la validation. Voir validate_max.
Le paramètre absolute_max de formset_factory() permet de limiter le nombre de formulaires pouvant être instanciés lors de la soumission de données POST. Ceci protège contre les attaques par épuisement de la mémoire qui utilisent des requêtes POST trafiquées :
>>> from django.forms.formsets import formset_factory\n>>> from myapp.forms import ArticleForm\n>>> ArticleFormSet = formset_factory(ArticleForm, absolute_max=1500)\n>>> data = {\n... "form-TOTAL_FORMS": "1501",\n... "form-INITIAL_FORMS": "0",\n... }\n>>> formset = ArticleFormSet(data)\n>>> len(formset.forms)\n1500\n>>> formset.is_valid()\nFalse\n>>> formset.non_form_errors()\n['Please submit at most 1000 forms.']\nLorsque absolute_max vaut None, la valeur par défaut est de max_num + 1000 (si max_num vaut None, sa valeur par défaut est de 2000).
Si absolute_max est plus petit que max_num, une erreur ValueError est générée.
La validation des formulaires groupés est presque identique à celle d’un formulaire Form normal. L’objet de formulaires groupés contient une méthode is_valid afin de fournir une manière agile de valider tous les formulaires du groupe :
>>> from django.forms import formset_factory\n>>> from myapp.forms import ArticleForm\n>>> ArticleFormSet = formset_factory(ArticleForm)\n>>> data = {\n... "form-TOTAL_FORMS": "1",\n... "form-INITIAL_FORMS": "0",\n... }\n>>> formset = ArticleFormSet(data)\n>>> formset.is_valid()\nTrue\nNous n’avons fourni aucune donnée aux formulaires groupés ce qui aboutit à un formulaire valide. Les formulaires groupés sont assez intelligents pour ne pas prendre en compte des formulaires supplémentaires qui n’ont pas été modifiés. Si nous passons un article non valable :
\n>>> data = {\n... "form-TOTAL_FORMS": "2",\n... "form-INITIAL_FORMS": "0",\n... "form-0-title": "Test",\n... "form-0-pub_date": "1904-06-16",\n... "form-1-title": "Test",\n... "form-1-pub_date": "", # <-- this date is missing but required\n... }\n>>> formset = ArticleFormSet(data)\n>>> formset.is_valid()\nFalse\n>>> formset.errors\n[{}, {'pub_date': ['This field is required.']}]\nComme on peut le voir, formset.errors est une liste composée d’éléments correspondants à chaque formulaire du groupe. La validation s’est faite pour chacun des deux formulaires, et le message d’erreur attendu apparaît pour le second.
Tout comme pour l’utilisation de formulaires normaux, chaque champ de formulaire groupé peut inclure des attributs HTML tels que maxlength pour la validation par le navigateur. Cependant, les champs de formulaires groupés n’incluront pas l’attribut required car cette validation pourrait être incorrecte lors de l’ajout ou de la suppression de formulaires.
Pour contrôler le nombre d’erreurs dans les formulaires groupés, nous pouvons utiliser la méthode total_error_count:
>>> # Using the previous example\n>>> formset.errors\n[{}, {'pub_date': ['This field is required.']}]\n>>> len(formset.errors)\n2\n>>> formset.total_error_count()\n1\nNous pouvons aussi vérifier si les données des formulaires diffèrent des données initiales (c’est-à-dire si le formulaire a été envoyé sans aucune donnée) :
\n>>> data = {\n... "form-TOTAL_FORMS": "1",\n... "form-INITIAL_FORMS": "0",\n... "form-0-title": "",\n... "form-0-pub_date": "",\n... }\n>>> formset = ArticleFormSet(data)\n>>> formset.has_changed()\nFalse\nManagementForm)Lien vers cette rubrique#Vous avez peut-être remarqué les données supplémentaires (form-TOTAL_FORMS, form-INITIAL_FORMS) qui étaient requises dans les données de formulaires groupés ci-dessus. Ces données sont exigées par le formulaire de gestion. Celui-ci est utilisé par les formulaires groupés pour gérer l’ensemble des formulaires contenus dans le groupe. Si vous ne fournissez pas ces données de gestion, le jeu de formulaires ne sera pas valide :
>>> data = {\n... "form-0-title": "Test",\n... "form-0-pub_date": "",\n... }\n>>> formset = ArticleFormSet(data)\n>>> formset.is_valid()\nFalse\nCes données servent à conserver la trace du nombre d’instances de formulaires qui sont affichées. Si vous ajoutez de nouveaux formulaires par JavaScript, il est aussi nécessaire d’incrémenter les champs de comptage de ce formulaire. D’un autre côté, si vous utilisez JavaScript pour permettre la suppression d’objets existants, vous devez alors vous assurer que ceux qui sont supprimés soient correctement marqués comme « à supprimer » en incluant le paramètre form-#-DELETE dans les données d’envoi POST. Il est prévu que tous les formulaires soient présents dans les données POST quoi qu’il arrive.
Le formulaire de gestion est disponible sous forme d’attribut de l’objet de formulaires groupés. Lorsque vous affichez des formulaires groupés dans un gabarit, vous pouvez inclure toutes les données de gestion en affichant {{ my_formset.management_form }} (en remplaçant le nom de vos formulaires groupés en conséquence).
total_form_count et initial_form_countLien vers cette rubrique#BaseFormSet possède quelques méthodes étroitement liées aux données total_form_count et initial_form_count du formulaire de gestion ManagementForm.
total_form_count renvoie le nombre total de formulaires du groupe de formulaires. initial_form_count renvoie le nombre de formulaires du groupe qui ont été pré-remplis et est également utilisé pour déterminer le nombre de formulaires requis. Vous n’aurez probablement jamais à surcharger l’une de ces méthodes, mais prenez garde à bien comprendre ce qu’elles font si vous deviez le faire.
empty_formLien vers cette rubrique#BaseFormSet fournit un attribut supplémentaire empty_form qui renvoie une instance de formulaire avec le préfixe __prefix__ pour faciliter l’utilisation de formulaires dynamiques avec JavaScript.
error_messagesLien vers cette rubrique#L’argument error_messages vous permet de surcharger les messages par défaut que le jeu de formulaires va produire. Passez un dictionnaire dont les clés correspondent aux messages d’erreur que vous souhaitez surcharger. Ces clés sont : 'too_few_forms', 'too_many_forms' et 'missing_management_form'. Les messages d’erreur 'too_few_forms' et 'too_many_forms' peuvent contenir %(num)d, ce qui sera remplacé respectivement par min_num et max_num.
Par exemple, voici le message d’erreur par défaut lorsque le formulaire de gestion est manquant :
\n>>> formset = ArticleFormSet({})\n>>> formset.is_valid()\nFalse\n>>> formset.non_form_errors()\n['ManagementForm data is missing or has been tampered with. Missing fields: form-TOTAL_FORMS, form-INITIAL_FORMS. You may need to file a bug report if the issue persists.']\nEt voici un message d’erreur personnalisé :
\n>>> formset = ArticleFormSet(\n... {}, error_messages={"missing_management_form": "Sorry, something went wrong."}\n... )\n>>> formset.is_valid()\nFalse\n>>> formset.non_form_errors()\n['Sorry, something went wrong.']\nLes formulaires groupés ont une méthode clean similaire à celle d’une classe Form. C’est là que vous pouvez définir votre propre validation agissant au niveau des formulaires groupés :
>>> from django.core.exceptions import ValidationError\n>>> from django.forms import BaseFormSet\n>>> from django.forms import formset_factory\n>>> from myapp.forms import ArticleForm\n\n>>> class BaseArticleFormSet(BaseFormSet):\n... def clean(self):\n... """Checks that no two articles have the same title."""\n... if any(self.errors):\n... # Don't bother validating the formset unless each form is valid on its own\n... return\n... titles = set()\n... for form in self.forms:\n... if self.can_delete and self._should_delete_form(form):\n... continue\n... title = form.cleaned_data.get("title")\n... if title in titles:\n... raise ValidationError("Articles in a set must have distinct titles.")\n... titles.add(title)\n...\n\n>>> ArticleFormSet = formset_factory(ArticleForm, formset=BaseArticleFormSet)\n>>> data = {\n... "form-TOTAL_FORMS": "2",\n... "form-INITIAL_FORMS": "0",\n... "form-0-title": "Test",\n... "form-0-pub_date": "1904-06-16",\n... "form-1-title": "Test",\n... "form-1-pub_date": "1912-06-23",\n... }\n>>> formset = ArticleFormSet(data)\n>>> formset.is_valid()\nFalse\n>>> formset.errors\n[{}, {}]\n>>> formset.non_form_errors()\n['Articles in a set must have distinct titles.']\nLa méthode clean des formulaires groupés est appelée après les méthodes Form.clean des formulaires individuels. Les erreurs produites à ce niveau sont accessibles par la méthode non_form_errors() sur l’objet des formulaires groupés.
Les erreurs non liées au formulaire sont produites avec une classe supplémentaire nonform pour aider à les distinguer des autres erreurs spécifiques au formulaire. Par exemple, {{ formset.non_form_errors }} donnera quelque chose comme :
<ul class="errorlist nonform">\n <li>Articles in a set must have distinct titles.</li>\n</ul>\nDjango fournit plusieurs manières de valider le nombre minimum ou maximum de formulaires soumis. Les applications ayant besoin d’une validation plus adaptée du nombre de formulaires peuvent utiliser la validation personnalisée de formulaires groupés.
\nvalidate_maxLien vers cette rubrique#Si validate_max=True est transmis à formset_factory(), la validation vérifiera également que le nombre de formulaires dans les données reçues moins ceux marqués pour la suppression ne dépasse pas max_num.
>>> from django.forms import formset_factory\n>>> from myapp.forms import ArticleForm\n>>> ArticleFormSet = formset_factory(ArticleForm, max_num=1, validate_max=True)\n>>> data = {\n... "form-TOTAL_FORMS": "2",\n... "form-INITIAL_FORMS": "0",\n... "form-0-title": "Test",\n... "form-0-pub_date": "1904-06-16",\n... "form-1-title": "Test 2",\n... "form-1-pub_date": "1912-06-23",\n... }\n>>> formset = ArticleFormSet(data)\n>>> formset.is_valid()\nFalse\n>>> formset.errors\n[{}, {}]\n>>> formset.non_form_errors()\n['Please submit at most 1 form.']\nvalidate_max=True valide strictement la valeur de max_num, même si cette valeur a été dépassée en raison d’un nombre de données initiales trop important.
Le message d’erreur peut être personnalisé en passant le message 'too_many_forms' dans l’argument error_messages.
validate_minLien vers cette rubrique#Si validate_min=True est passé à formset_factory(), la validation vérifiera également que le nombre de formulaires dans les données reçues moins ceux marqués pour la suppression est supérieur ou égal à min_num.
>>> from django.forms import formset_factory\n>>> from myapp.forms import ArticleForm\n>>> ArticleFormSet = formset_factory(ArticleForm, min_num=3, validate_min=True)\n>>> data = {\n... "form-TOTAL_FORMS": "2",\n... "form-INITIAL_FORMS": "0",\n... "form-0-title": "Test",\n... "form-0-pub_date": "1904-06-16",\n... "form-1-title": "Test 2",\n... "form-1-pub_date": "1912-06-23",\n... }\n>>> formset = ArticleFormSet(data)\n>>> formset.is_valid()\nFalse\n>>> formset.errors\n[{}, {}]\n>>> formset.non_form_errors()\n['Please submit at least 3 forms.']\nLe message d’erreur peut être personnalisé en passant le message 'too_few_forms' dans l’argument error_messages.
La méthode formset_factory() fournit deux paramètres facultatifs can_order et can_delete pour faciliter le tri et la suppression de formulaires dans des formulaires groupés.
can_orderLien vers cette rubrique#Valeur par défaut : False
Ce paramètre permet de créer des formulaires groupés qui peuvent être triés :
\n>>> from django.forms import formset_factory\n>>> from myapp.forms import ArticleForm\n>>> ArticleFormSet = formset_factory(ArticleForm, can_order=True)\n>>> formset = ArticleFormSet(\n... initial=[\n... {"title": "Article #1", "pub_date": datetime.date(2008, 5, 10)},\n... {"title": "Article #2", "pub_date": datetime.date(2008, 5, 11)},\n... ]\n... )\n>>> for form in formset:\n... print(form)\n...\n<div><label for="id_form-0-title">Title:</label><input type="text" name="form-0-title" value="Article #1" id="id_form-0-title"></div>\n<div><label for="id_form-0-pub_date">Pub date:</label><input type="text" name="form-0-pub_date" value="2008-05-10" id="id_form-0-pub_date"></div>\n<div><label for="id_form-0-ORDER">Order:</label><input type="number" name="form-0-ORDER" value="1" id="id_form-0-ORDER"></div>\n<div><label for="id_form-1-title">Title:</label><input type="text" name="form-1-title" value="Article #2" id="id_form-1-title"></div>\n<div><label for="id_form-1-pub_date">Pub date:</label><input type="text" name="form-1-pub_date" value="2008-05-11" id="id_form-1-pub_date"></div>\n<div><label for="id_form-1-ORDER">Order:</label><input type="number" name="form-1-ORDER" value="2" id="id_form-1-ORDER"></div>\n<div><label for="id_form-2-title">Title:</label><input type="text" name="form-2-title" id="id_form-2-title"></div>\n<div><label for="id_form-2-pub_date">Pub date:</label><input type="text" name="form-2-pub_date" id="id_form-2-pub_date"></div>\n<div><label for="id_form-2-ORDER">Order:</label><input type="number" name="form-2-ORDER" id="id_form-2-ORDER"></div>\nCeci ajoute un champ supplémentaire à chaque formulaire. Ce nouveau champ s’appelle ORDER et est de type forms.IntegerField. Pour les formulaires générés à partir des données initiales, ces champs reçoivent automatiquement une valeur numérique. Voyons ce qui se passe si l’utilisateur modifie ces valeurs :
>>> data = {\n... "form-TOTAL_FORMS": "3",\n... "form-INITIAL_FORMS": "2",\n... "form-0-title": "Article #1",\n... "form-0-pub_date": "2008-05-10",\n... "form-0-ORDER": "2",\n... "form-1-title": "Article #2",\n... "form-1-pub_date": "2008-05-11",\n... "form-1-ORDER": "1",\n... "form-2-title": "Article #3",\n... "form-2-pub_date": "2008-05-01",\n... "form-2-ORDER": "0",\n... }\n\n>>> formset = ArticleFormSet(\n... data,\n... initial=[\n... {"title": "Article #1", "pub_date": datetime.date(2008, 5, 10)},\n... {"title": "Article #2", "pub_date": datetime.date(2008, 5, 11)},\n... ],\n... )\n>>> for form in formset.ordered_forms:\n... print(form.cleaned_data)\n...\n{'title': 'Article #3', 'pub_date': datetime.date(2008, 5, 1), 'ORDER': 0}\n{'title': 'Article #2', 'pub_date': datetime.date(2008, 5, 11), 'ORDER': 1}\n{'title': 'Article #1', 'pub_date': datetime.date(2008, 5, 10), 'ORDER': 2}\nBrut\nBaseFormSet fournit également un attribut ordering_widget et une méthode get_ordering_widget() qui permet de contrôler le composant utilisé avec can_order.
ordering_widgetLien vers cette rubrique#Par défaut : NumberInput
Définissez ordering_widget pour indiquer la classe de composant à utiliser avec can_order:
>>> from django.forms import BaseFormSet, formset_factory\n>>> from myapp.forms import ArticleForm\n>>> class BaseArticleFormSet(BaseFormSet):\n... ordering_widget = HiddenInput\n...\n\n>>> ArticleFormSet = formset_factory(\n... ArticleForm, formset=BaseArticleFormSet, can_order=True\n... )\nget_ordering_widgetLien vers cette rubrique#Surchargez get_ordering_widget() si vous avez besoin de fournir une instance de composant à utiliser avec can_order:
>>> from django.forms import BaseFormSet, formset_factory\n>>> from myapp.forms import ArticleForm\n>>> class BaseArticleFormSet(BaseFormSet):\n... def get_ordering_widget(self):\n... return HiddenInput(attrs={"class": "ordering"})\n...\n\n>>> ArticleFormSet = formset_factory(\n... ArticleForm, formset=BaseArticleFormSet, can_order=True\n... )\ncan_deleteLien vers cette rubrique#Valeur par défaut : False
Ce paramètre permet de créer des formulaires groupés où l’on peut choisir des formulaires à supprimer :
\n>>> from django.forms import formset_factory\n>>> from myapp.forms import ArticleForm\n>>> ArticleFormSet = formset_factory(ArticleForm, can_delete=True)\n>>> formset = ArticleFormSet(\n... initial=[\n... {"title": "Article #1", "pub_date": datetime.date(2008, 5, 10)},\n... {"title": "Article #2", "pub_date": datetime.date(2008, 5, 11)},\n... ]\n... )\n>>> for form in formset:\n... print(form)\n...\n<div><label for="id_form-0-title">Title:</label><input type="text" name="form-0-title" value="Article #1" id="id_form-0-title"></div>\n<div><label for="id_form-0-pub_date">Pub date:</label><input type="text" name="form-0-pub_date" value="2008-05-10" id="id_form-0-pub_date"></div>\n<div><label for="id_form-0-DELETE">Delete:</label><input type="checkbox" name="form-0-DELETE" id="id_form-0-DELETE"></div>\n<div><label for="id_form-1-title">Title:</label><input type="text" name="form-1-title" value="Article #2" id="id_form-1-title"></div>\n<div><label for="id_form-1-pub_date">Pub date:</label><input type="text" name="form-1-pub_date" value="2008-05-11" id="id_form-1-pub_date"></div>\n<div><label for="id_form-1-DELETE">Delete:</label><input type="checkbox" name="form-1-DELETE" id="id_form-1-DELETE"></div>\n<div><label for="id_form-2-title">Title:</label><input type="text" name="form-2-title" id="id_form-2-title"></div>\n<div><label for="id_form-2-pub_date">Pub date:</label><input type="text" name="form-2-pub_date" id="id_form-2-pub_date"></div>\n<div><label for="id_form-2-DELETE">Delete:</label><input type="checkbox" name="form-2-DELETE" id="id_form-2-DELETE"></div>\nUn peu comme pour can_order, ce paramètre ajoute un nouveau champ DELETE de type forms.BooleanField à chaque formulaire. Lorsque les données reviennent et que certains de ces champs ont une valeur « vrai », il est possible d’accéder aux formulaires concernés avec deleted_forms:
>>> data = {\n... "form-TOTAL_FORMS": "3",\n... "form-INITIAL_FORMS": "2",\n... "form-0-title": "Article #1",\n... "form-0-pub_date": "2008-05-10",\n... "form-0-DELETE": "on",\n... "form-1-title": "Article #2",\n... "form-1-pub_date": "2008-05-11",\n... "form-1-DELETE": "",\n... "form-2-title": "",\n... "form-2-pub_date": "",\n... "form-2-DELETE": "",\n... }\n\n>>> formset = ArticleFormSet(\n... data,\n... initial=[\n... {"title": "Article #1", "pub_date": datetime.date(2008, 5, 10)},\n... {"title": "Article #2", "pub_date": datetime.date(2008, 5, 11)},\n... ],\n... )\n>>> [form.cleaned_data for form in formset.deleted_forms]\n[{'title': 'Article #1', 'pub_date': datetime.date(2008, 5, 10), 'DELETE': True}]\nSi vous utilisez un ModelFormSet, les instances de modèle correspondant aux formulaires supprimés seront supprimées lorsque formset.save () sera appelée.
Si vous appelez formset.save(commit=False), les objets ne seront pas supprimés automatiquement. Vous devrez appeler delete() pour chacun des formset.deleted_objects afin que la suppression soit effective :
>>> instances = formset.save(commit=False)\n>>> for obj in formset.deleted_objects:\n... obj.delete()\n...\nD’autre part, si vous utilisez un FormSet simple, c’est à vous de gérer formset.deleted_forms, par exemple dans la méthode save() de votre formulaire groupé, car il n’existe pas de notion générale sur ce qu’implique la suppression d’un formulaire.
BaseFormSet fournit également un attribut deletion_widget et une méthode get_deletion_widget() qui permet de contrôler le composant utilisé avec can_delete.
deletion_widgetLien vers cette rubrique#Par défaut : CheckboxInput
Définissez deletion_widget pour indiquer la classe de composant à utiliser avec can_delete:
>>> from django.forms import BaseFormSet, formset_factory\n>>> from myapp.forms import ArticleForm\n>>> class BaseArticleFormSet(BaseFormSet):\n... deletion_widget = HiddenInput\n...\n\n>>> ArticleFormSet = formset_factory(\n... ArticleForm, formset=BaseArticleFormSet, can_delete=True\n... )\nget_deletion_widgetLien vers cette rubrique#Surchargez get_deletion_widget() si vous avez besoin de fournir une instance de composant à utiliser avec can_delete:
>>> from django.forms import BaseFormSet, formset_factory\n>>> from myapp.forms import ArticleForm\n>>> class BaseArticleFormSet(BaseFormSet):\n... def get_deletion_widget(self):\n... return HiddenInput(attrs={"class": "deletion"})\n...\n\n>>> ArticleFormSet = formset_factory(\n... ArticleForm, formset=BaseArticleFormSet, can_delete=True\n... )\ncan_delete_extraLien vers cette rubrique#Valeur par défaut : True
Lorsque can_delete=True, la définition de can_delete_extra=False enlève la possibilité de supprimer les formulaires supplémentaires.
L’ajout de champs supplémentaires aux formulaires groupés est simple à effectuer. La classe de base des formulaires groupés offre une méthode add_fields. Vous pouvez surcharger cette méthode pour ajouter vos propres champs ou même pour redéfinir les champs/attributs par défaut des champs de tri et de suppression :
>>> from django.forms import BaseFormSet\n>>> from django.forms import formset_factory\n>>> from myapp.forms import ArticleForm\n>>> class BaseArticleFormSet(BaseFormSet):\n... def add_fields(self, form, index):\n... super().add_fields(form, index)\n... form.fields["my_field"] = forms.CharField()\n...\n\n>>> ArticleFormSet = formset_factory(ArticleForm, formset=BaseArticleFormSet)\n>>> formset = ArticleFormSet()\n>>> for form in formset:\n... print(form)\n...\n<div><label for="id_form-0-title">Title:</label><input type="text" name="form-0-title" id="id_form-0-title"></div>\n<div><label for="id_form-0-pub_date">Pub date:</label><input type="text" name="form-0-pub_date" id="id_form-0-pub_date"></div>\n<div><label for="id_form-0-my_field">My field:</label><input type="text" name="form-0-my_field" id="id_form-0-my_field"></div>\nIl arrive parfois qu’une classe de formulaire accepte des paramètres personnalisés, comme MyArticleForm. Vous pouvez transmettre ce paramètre lors de l’instanciation du jeu de formulaires :
>>> from django.forms import BaseFormSet\n>>> from django.forms import formset_factory\n>>> from myapp.forms import ArticleForm\n\n>>> class MyArticleForm(ArticleForm):\n... def __init__(self, *args, user, **kwargs):\n... self.user = user\n... super().__init__(*args, **kwargs)\n...\n\n>>> ArticleFormSet = formset_factory(MyArticleForm)\n>>> formset = ArticleFormSet(form_kwargs={"user": request.user})\nLe paramètre form_kwargs peut aussi dépendre de l’instance de formulaire spécifique. La classe de base du jeu de formulaires fournit une méthode get_form_kwargs. Celle-ci accepte un seul paramètre, l’indice du formulaire dans le jeu de formulaire. Cet indice vaut None pour le formulaire vide empty_form:
>>> from django.forms import BaseFormSet\n>>> from django.forms import formset_factory\n\n>>> class BaseArticleFormSet(BaseFormSet):\n... def get_form_kwargs(self, index):\n... kwargs = super().get_form_kwargs(index)\n... kwargs["custom_kwarg"] = index\n... return kwargs\n...\n\n>>> ArticleFormSet = formset_factory(MyArticleForm, formset=BaseArticleFormSet)\n>>> formset = ArticleFormSet()\nDans le rendu HTML, les jeux de formulaires ajoutent un préfixe devant chaque nom de champ. Par défaut, le préfixe est 'form', mais il peut être personnalisé à l’aide du paramètre prefix du jeu de formulaires.
Par exemple, dans le cas par défaut, on pourrait voir :
\n<label for="id_form-0-title">Title:</label>\n<input type="text" name="form-0-title" id="id_form-0-title">\nMais avec ArticleFormset(prefix='article'), cela deviendra :
<label for="id_article-0-title">Title:</label>\n<input type="text" name="article-0-title" id="id_article-0-title">\nCeci est utile lorsqu’on veut utiliser plus d’un jeu de formulaires dans une vue.
\nLes jeux de formulaires possèdent les attributs et méthodes suivantes associées à leur rendu :
\nIndique le moteur de rendu à utiliser pour le jeu de formulaires. Contient par défaut le moteur de rendu défini dans le réglage FORM_RENDERER.
Le nom du gabarit produit si le jeu de formulaire est forcé à une chaîne, par ex. via print(formset) ou dans un gabarit via {{ formset }}.
Par défaut, une propriété renvoyant la valeur formset_template_name du producteur. Vous pouvez la définir à un nom de gabarit afin de la surcharger pour une classe de jeu de formulaires particulière.
Ce gabarit sera utilisé pour produire le formulaire de gestion du jeu de formulaires, puis chaque formulaire du jeu en respectant le gabarit défini par l’attribut template_name du formulaire.
Le nom du gabarit à utiliser lors de l’appel à as_div(). Par défaut, il s’agit de 'django/forms/formsets/div.html'. Ce gabarit produit le formulaire de gestion du jeu de formulaires, puis chaque formulaire du jeu en respectant la méthode as_div() du formulaire.
Le nom du gabarit à utiliser lors de l’appel à as_p(). Par défaut, il s’agit de "django/forms/formsets/p.html". Ce gabarit produit le formulaire de gestion du jeu de formulaires, puis chaque formulaire du jeu en respectant la méthode as_p() du formulaire.
Le nom du gabarit à utiliser lors de l’appel à as_table(). Par défaut, il s’agit de "django/forms/formsets/table.html". Ce gabarit produit le formulaire de gestion du jeu de formulaires, puis chaque formulaire du jeu en respectant la méthode as_table() du formulaire.
Le nom du gabarit à utiliser lors de l’appel à as_ul(). Par défaut, il s’agit de "django/forms/formsets/ul.html". Ce gabarit produit le formulaire de gestion du jeu de formulaires, puis chaque formulaire du jeu en respectant la méthode as_ul() du formulaire.
Renvoie le contexte pour la production du jeu de formulaires dans un gabarit.
\nLe contexte disponible est :
\nformset: l’instance du jeu de formulaire.
La méthode de production est appelée par __str__ ainsi que par les méthodes as_div(), as_p(), as_ul() et as_table(). Tous les arguments sont facultatifs et valent par défaut :
template_name: template_name
context: la valeur renvoyée par get_context()
renderer: la valeur renvoyée par renderer
Produit le jeu de formulaires avec le gabarit template_name_div.
Produit le jeu de formulaires avec le gabarit template_name_p.
Produit le jeu de formulaires avec le gabarit template_name_table.
Produit le jeu de formulaires avec le gabarit template_name_ul.
L’utilisation de formulaires groupés dans une vue n’est pas très différent de l’utilisation d’une classe Form habituelle. La seule chose à laquelle il faut être attentif est de ne pas oublier d’inclure le formulaire de gestion dans le gabarit. Examinons un exemple de vue :
from django.forms import formset_factory\nfrom django.shortcuts import render\nfrom myapp.forms import ArticleForm\n\n\ndef manage_articles(request):\n ArticleFormSet = formset_factory(ArticleForm)\n if request.method == "POST":\n formset = ArticleFormSet(request.POST, request.FILES)\n if formset.is_valid():\n # do something with the formset.cleaned_data\n pass\n else:\n formset = ArticleFormSet()\n return render(request, "manage_articles.html", {"formset": formset})\nLe gabarit manage_articles.html pourrait ressembler à ceci :
<form method="post">\n {{ formset.management_form }}\n <table>\n {% for form in formset %}\n {{ form }}\n {% endfor %}\n </table>\n</form>\nToutefois, le code ci-dessus peut être légèrement raccourci en laissant les formulaires groupés se charger eux-mêmes du formulaire de gestion :
\n<form method="post">\n <table>\n {{ formset }}\n </table>\n</form>\nLe code ci-dessus aboutit à l’appel de la méthode BaseFormSet.render() de la classe du jeu de formulaires. Ceci produit le jeu de formulaires en utilisant le gabarit défini par l’attribut template_name. Tout comme pour les formulaires, le jeu de formulaires est produit avec as_div par défaut, mais les méthodes utilitaires as_p, as_ul et as_table sont aussi disponibles. La production du jeu de formulaires peut être personnalisée en spécifiant l’attribut template_name ou plus généralement en surchargeant le gabarit par défaut.
can_delete et can_orderLien vers cette rubrique#Si vous affichez manuellement les champs dans le gabarit, vous pouvez afficher le paramètre can_delete avec {{ form.DELETE }}:
<form method="post">\n {{ formset.management_form }}\n {% for form in formset %}\n <ul>\n <li>{{ form.title }}</li>\n <li>{{ form.pub_date }}</li>\n {% if formset.can_delete %}\n <li>{{ form.DELETE }}</li>\n {% endif %}\n </ul>\n {% endfor %}\n</form>\nDe la même façon, si les formulaires groupés peuvent être triés (can_order=True), il est possible d’afficher le champ de tri avec {{ form.ORDER }}.
Il est possible d’utiliser plus d’un objet de formulaires groupés dans une vue. Les formulaires groupés ont un comportement très semblable à celui des formulaires. Ceci dit, vous pouvez utiliser l’attribut prefix afin de préfixer les noms de champs des formulaires groupés avec une valeur donnée, ce qui permettra d’envoyer plusieurs ensembles de formulaires groupés à une vue sans conflit de nommage. Voyons un peu comment cela pourrait être fait :
from django.forms import formset_factory\nfrom django.shortcuts import render\nfrom myapp.forms import ArticleForm, BookForm\n\n\ndef manage_articles(request):\n ArticleFormSet = formset_factory(ArticleForm)\n BookFormSet = formset_factory(BookForm)\n if request.method == "POST":\n article_formset = ArticleFormSet(request.POST, request.FILES, prefix="articles")\n book_formset = BookFormSet(request.POST, request.FILES, prefix="books")\n if article_formset.is_valid() and book_formset.is_valid():\n # do something with the cleaned_data on the formsets.\n pass\n else:\n article_formset = ArticleFormSet(prefix="articles")\n book_formset = BookFormSet(prefix="books")\n return render(\n request,\n "manage_articles.html",\n {\n "article_formset": article_formset,\n "book_formset": book_formset,\n },\n )\nLes formulaires groupés seraient ensuite affichés comme d’habitude. Il est important de relever que vous devez indiquer prefix dans tous les cas (POST ou non), afin que l’affichage et le traitement des données puissent se faire correctement.
Chaque prefix de jeu de formulaires remplace le préfixe par défaut form qui est ajouté à chaque attribut HTML name et id des champs de formulaire.