So verwenden Sie verschachtelte Formulare in Django

Django, python, formsets

Django Formsets verwalten komplexe sich wiederholende Formularfelder in einer Ansicht. Anhand der Formulare können Sie herausfinden, wie viele Formulare ursprünglich vorhanden waren, welche geändert wurden und welche gelöscht werden müssen.
Wie Formulare und Formularmodelle stellt Django Formularmodellsätze bereit, die das Erstellen eines Formularsatzes für ein Formular vereinfachen, das mehrere Modellinstanzen verarbeitet.

Django bietet auch integrierte Formsets, die verwendet werden können, um eine Reihe von Objekten zu verarbeiten, die zu einem gemeinsamen Fremdschlüssel gehören.
In den folgenden Modellbeispielen können wir ein Inline-Formularset schreiben, um alle untergeordneten, übergeordneten oder alle untergeordneten Adressen zu behandeln.

# models.py

class Parent(models.Model):
    name = models.CharField(max_length=255)

class Child(models.Model):
    parent = models.ForeignKey(Parent)
    name = models.CharField(max_length=255)

class Address(models.Model):
    child = models.ForeignKey(Child)
    country = models.CharField(max_length=255)
    state = models.CharField(max_length=255)
    address = models.CharField(max_length=255)

# forms.py

from django.forms.models import inlineformset_factory

ChildrenFormset = inlineformset_factory(models.Parent, models.Child, extra=1)
AddressFormset = inlineformset_factory(models.Child, models.Address, extra=1)

Mit den oben beschriebenen Formsets können Sie alle untergeordneten Elemente für ein übergeordnetes Element auf einer Seite verarbeiten und alle untergeordneten Elementadressen auf einer anderen Seite verarbeiten. Wenn Sie Benutzern erlauben möchten, alle untergeordneten Elemente zusammen mit Adressen auf derselben Seite hinzuzufügen oder zu bearbeiten, müssen Sie einen vollständigen Satz von Adressformularen für jedes untergeordnete Formular im untergeordneten Formularsatz haben.
In diesem Fall ist es sinnvoll, verschachtelte Formulare zu verwenden. Ein verschachteltes Formset ist nur ein normales Inline-Formularset.
Um verschachtelte Formulare zu verarbeiten, müssen Sie die folgenden Schritte ausführen:

Schritt 1: Erstellen Sie ein einfaches Inline-Formularset

# forms.py

from django.forms.models import BaseInlineFormSet

class BaseChildrenFormset(BaseInlineFormSet):
    pass

ChildrenFormset = inlineformset_factory(models.Parent,
                                        models.Child,
                                        formset=BaseChildrenFormset,
                                        extra=1)

Schritt 2. Anhängen eines verschachtelten Formularsatzes für jedes Formular, wie unten gezeigt. Die Oberklasse BaseInlineFormSet definiert die add_fields-Methode, die für das Hinzufügen von Feldern für jedes Formular im Formset verantwortlich ist. Außerdem können wir hier die Logik schreiben, um das verschachtelte Formset zu verknüpfen.

# forms.py
class BaseChildrenFormset(BaseInlineFormSet):

    def add_fields(self, form, index):
        super(BaseChildrenFormset, self).add_fields(form, index)

        # save the formset in the 'nested' property
        form.nested = AddressFormset(
                        instance=form.instance,
                        data=form.data if form.is_bound else None,
                        files=form.files if form.is_bound else None,
                        prefix='address-%s-%s' % (
                            form.prefix,
                            AddressFormset.get_default_prefix()),
                        extra=1)

Hinweis: Hier haben wir eine neue Eigenschaft namens "form.nested" erstellt, die das verschachtelte Formset (AddressFormset) enthält.

Schritt 3: Handhabung des Formsets und verschachtelter Formsets in Ansichten

# views.py

def manage_children(request, parent_id):
    """Edit children and their addresses for a single parent."""

    parent = get_object_or_404(models.Parent, id=parent_id)

    if request.method == 'POST':
        formset = forms.ChildrenFormset(request.POST, instance=parent)
        if formset.is_valid():
            formset.save()
            return redirect('parent_view', parent_id=parent.id)
    else:
        formset = forms.ChildrenFormset(instance=parent)

    return render(request, 'manage_children.html', {
                  'parent':parent,
                  'children_formset':formset})

Schritt 4: Rendern des verschachtelten Formsets in der Vorlage

# manage_children.html (Just formset display part)

{{ children_formset.management_form }}
{{ children_formset.non_form_errors }}

{% for child_form in children_formset.forms %}
    {{ child_form }}

    {% if child_form.nested %}
        {{ child_form.nested.management_form }}
        {{ child_form.nested.non_form_errors }}

        {% for nested_form in child_form.nested.forms %}
            {{ nested_form }}
        {% endfor %}

    {% endif %}

{% endfor %}

Dabei sind mehrere Punkte zu beachten:

1. Überprüfung. Beim Validieren eines Formulars in einem Formset müssen wir auch seine Unterformulare validieren, die sich in einem verschachtelten Formset befinden.

2. Daten speichern. Wenn Sie ein Formular speichern, müssen Sie auch Ergänzungen und Änderungen an den Formularen im verschachtelten Formularsatz speichern.

Wenn die Seite gesendet wird, rufen wir formset.is_valid() auf, um die Formulare zu validieren. Wir überschreiben is_valid in unserem Formset, um auch eine Validierung für verschachtelte Formsets hinzuzufügen.

# forms.py

class BaseChildrenFormset(BaseInlineFormSet):
    ...

    def is_valid(self):
        result = super(BaseChildrenFormset, self).is_valid()

        if self.is_bound:
            for form in self.forms:
                if hasattr(form, 'nested'):
                    result = result and form.nested.is_valid()

        return result

Damit ist die Validierung von Formularen und verschachtelten Formularen abgeschlossen. Jetzt müssen wir das Gespeicherte verarbeiten. Dazu müssen Sie die save-Methode überschreiben, um das übergeordnete Formset und alle verschachtelten Formsets zu speichern.

# forms.py

class BaseChildrenFormset(BaseInlineFormSet):
    ...

    def save(self, commit=True):

        result = super(BaseChildrenFormset, self).save(commit=commit)

        for form in self.forms:
            if hasattr(form, 'nested'):
                if not self._should_delete_form(form):
                    form.nested.save(commit=commit)

        return result

Die save-Methode ist verantwortlich für das Speichern der Formulare im Formset sowie aller Formulare im verschachtelten Formset für jedes Formular.
Unter diesem Link erfahren Sie mehr über das Open-Source-Paket Django CRM (Customer Relationship Management).