Django: plusieurs modèles dans un modèle à l'aide de formulaires

Je suis en train de construire un ticket de support de suivi de l'app et avoir quelques modèles que j'aimerais créer une page. Les billets d'appartenir à un Client via une ForeignKey. Les Notes appartiennent à des Billets par l'intermédiaire d'une ForeignKey ainsi. J'aimerais avoir l'option de sélection d'un Client (c'est un tout autre projet) OU la création d'un nouveau Client, puis la création d'un Ticket, et enfin la création d'une Note attribuée à un nouveau billet.

Depuis que je suis assez nouveau dans Django, j'ai tendance à travailler de manière itérative, en essayant de nouvelles fonctionnalités à chaque fois. J'ai joué avec ModelForms mais je veux cacher certains champs et faire un peu de complexes de validation. Il semble que le niveau de contrôle, je suis à la recherche pour les besoin de formsets ou tout faire à la main, avec une fastidieuse, codée à la main de modèle de page, que j'essaie d'éviter.

Est-il une caractéristique belle je suis absent? Faut-il une bonne référence ou d'exemple pour l'utilisation de formsets? J'ai passé un week-end entier sur l'API docs pour eux et je suis toujours paumé. Est-ce un problème de conception si je suis en panne et de la main-code tout?

InformationsquelleAutor neoice | 2009-02-20

83

Ce n'est vraiment pas trop difficile à mettre en œuvre avec ModelForms. Donc disons que vous avez des Formulaires A, B et C. Vous avez l'impression de chacune des formes et de la page et maintenant vous avez besoin pour gérer l'après.
```
if request.POST():
    a_valid = formA.is_valid()
    b_valid = formB.is_valid()
    c_valid = formC.is_valid()
    # we do this since 'and' short circuits and we want to check to whole page for form errors
    if a_valid and b_valid and c_valid:
        a = formA.save()
        b = formB.save(commit=False)
        c = formC.save(commit=False)
        b.foreignkeytoA = a
        b.save()
        c.foreignkeytoB = b
        c.save()
```
Ici sont les documents pour la validation personnalisée.
- btw, je ne pense pas que les jeux de formulaires sont une bonne solution pour le problème que vous avez décrit. J'ai toujours utilisé pour les représenter plusieurs instances d'un modèle. E. g. vous avez un demandeur formulaire et que vous voulez 3 références pour vous faire un formset a 3 instances du modèle de Référence.
- notez que, avec la façon dont vous le faites, l' .is_valid() l'appel n'est pas court-circuitée. Si vous voulez tout court-circuit, vous aurez besoin de retarder l'appel de la .is_valid() fonction jusqu'à ce que le "et".
InformationsquelleAutor Jason Christa
63

J'ai été dans la même situation un jour plus tôt, et voici mes 2 cents:

1) j'ai trouvé sans doute le plus court et le plus concis démonstration de plusieurs d'entrée du modèle de formulaire unique ici: http://collingrady.wordpress.com/2008/02/18/editing-multiple-objects-in-django-with-newforms/ .

En un mot: Faire un formulaire pour chaque modèle, les soumettre à la fois à un modèle à une seule <form>, à l'aide de prefix keyarg et ont la vue sur la poignée de la validation. Si il y a dépendance, assurez-vous d'enregistrer le "parent"
modèle avant de personne à charge, et l'utilisation d'un parent ID de clé étrangère avant la validation d'économiser de l'enfant modèle. Le lien de la démo.

2) Peut-être formsets peut être battu en faire, mais autant que j'ai fouillé dans, formsets sont principalement pour la saisie multiples du même modèle, qui peut éventuellement être liés à un autre modèle/modèles par des clés étrangères. Cependant, il semble y avoir pas de choix par défaut pour la saisie de plus d'un modèle de données et ce n'est pas ce formset semble être destiné.

InformationsquelleAutor Gnudiff

J'ai très récemment eu le problème et trouvé comment faire.
En supposant que vous avez trois classes de Primaire, B, C, et B,C ont une clé étrangère à la primaire

    class PrimaryForm(ModelForm):
        class Meta:
            model = Primary

    class BForm(ModelForm):
        class Meta:
            model = B
            exclude = ('primary',)

    class CForm(ModelForm):
         class Meta:
            model = C
            exclude = ('primary',)

    def generateView(request):
        if request.method == 'POST': # If the form has been submitted...
            primary_form = PrimaryForm(request.POST, prefix = "primary")
            b_form = BForm(request.POST, prefix = "b")
            c_form = CForm(request.POST, prefix = "c")
            if primary_form.is_valid() and b_form.is_valid() and c_form.is_valid(): # All validation rules pass
                    print "all validation passed"
                    primary = primary_form.save()
                    b_form.cleaned_data["primary"] = primary
                    b = b_form.save()
                    c_form.cleaned_data["primary"] = primary
                    c = c_form.save()
                    return HttpResponseRedirect("/viewer/%s/" % (primary.name))
            else:
                    print "failed"

        else:
            primary_form = PrimaryForm(prefix = "primary")
            b_form = BForm(prefix = "b")
            c_form = Form(prefix = "c")
     return render_to_response('multi_model.html', {
     'primary_form': primary_form,
     'b_form': b_form,
     'c_form': c_form,
      })

Cette méthode devrait vous permettre de faire ce que la validation dont vous avez besoin, ainsi que de générer tous les trois objets sur la même page. J'ai aussi utilisé du javascript et des champs cachés pour permettre la génération de plusieurs B,C des objets sur la même page.

Dans cet exemple, comment vous mettez-vous les clés étrangères pour les modèles B et C, point à la Primaire modèle?
Je n'ai que deux modèles que je veux montrer, sur le même formulaire. Mais je n'ai pas l'exclure = ('primaire',) déclaration. Qu'est-ce que la primaire? Si vous avez 2 modèles CustomerConfig et le Contrat. Contrat a la clé étrangère à CustomerConfig. Comme customer_config=modèles.ForeignKey('CustomerPartnerConfiguration') Ce qui est "principal"?

InformationsquelleAutor

La MultiModelForm de django-betterforms est une pratique wrapper pour faire ce qui est décrit dans Gnudiff réponse. Elle enveloppe régulière ModelForms dans une seule classe, qui est transparente (au moins pour une utilisation de base) sont utilisés comme un seul formulaire. J'ai copié un exemple de leurs docs ci-dessous.

# forms.py
from django import forms
from django.contrib.auth import get_user_model
from betterforms.multiform import MultiModelForm
from .models import UserProfile

User = get_user_model()

class UserEditForm(forms.ModelForm):
    class Meta:
        fields = ('email',)

class UserProfileForm(forms.ModelForm):
    class Meta:
        fields = ('favorite_color',)

class UserEditMultiForm(MultiModelForm):
    form_classes = {
        'user': UserEditForm,
        'profile': UserProfileForm,
    }

# views.py
from django.views.generic import UpdateView
from django.core.urlresolvers import reverse_lazy
from django.shortcuts import redirect
from django.contrib.auth import get_user_model
from .forms import UserEditMultiForm

User = get_user_model()

class UserSignupView(UpdateView):
    model = User
    form_class = UserEditMultiForm
    success_url = reverse_lazy('home')

    def get_form_kwargs(self):
        kwargs = super(UserSignupView, self).get_form_kwargs()
        kwargs.update(instance={
            'user': self.object,
            'profile': self.object.profile,
        })
        return kwargs

Juste vu django-betterforms et ses MultiModelForm de classe avant de venir à travers votre réponse. Leur solution est bien réel, mais il semble qu'il n'a pas été mis à jour en temps. Êtes-vous toujours à l'aide de cette @jozxyqk? Pas de problèmes?
il y a quelques années. À l'époque, je trouve qu'il est pratique et l'une des meilleures options. Si vous ne obtenez pas trop de fantaisie avec elle il permet de gagner du temps. Je peux imaginer quand vous voulez pour commencer à personnaliser et fait non négligeable, il serait plus facile de mettre votre propre. Facilement en mélangeant les formes et les contextes de points de vue est la première fonctionnalité que je pense vraiment que j'ai raté dans django.
Merci pour la réponse de l'homme. J'envisage seulement la fourche et peut-être mettre à jour quelques choses le long du chemin. De ce que j'ai vu jusqu'à présent, ça fonctionne très bien. Vous avez raison, c'est un énorme gain de temps.

InformationsquelleAutor jozxyqk

J'ai actuellement une solution fonctionnelle (elle passe mes tests unitaires). C'est une bonne solution à mon avis, quand vous voulez seulement ajouter un nombre limité de domaines à partir d'autres modèles.

Suis-je manqué quelque chose ?

class UserProfileForm(ModelForm):
    def __init__(self, instance=None, *args, **kwargs):
        # Add these fields from the user object
        _fields = ('first_name', 'last_name', 'email',)
        # Retrieve initial (current) data from the user object
        _initial = model_to_dict(instance.user, _fields) if instance is not None else {}
        # Pass the initial data to the base
        super(UserProfileForm, self).__init__(initial=_initial, instance=instance, *args, **kwargs)
        # Retrieve the fields from the user model and update the fields with it
        self.fields.update(fields_for_model(User, _fields))

    class Meta:
        model = UserProfile
        exclude = ('user',)

    def save(self, *args, **kwargs):
        u = self.instance.user
        u.first_name = self.cleaned_data['first_name']
        u.last_name = self.cleaned_data['last_name']
        u.email = self.cleaned_data['email']
        u.save()
        profile = super(UserProfileForm, self).save(*args,**kwargs)
        return profile

InformationsquelleAutor Paul Bormans

3

"Je veux cacher certains champs et faire un peu de complexes de validation."

Je commence avec l'intégré dans l'interface d'administration.
1. Construire la ModelForm pour afficher les champs souhaités.
2. Étendre le Formulaire avec les règles de validation du formulaire. Habituellement, c'est un clean méthode.
  
  Être sûr de cette partie fonctionne raisonnablement bien.
Une fois cela fait, vous pouvez éloigner de la intégré dans l'interface d'administration.

Alors vous pouvez tromper avec plusieurs, en partie liés à des formes sur une seule page web. C'est un tas de modèle de choses à présenter toutes les formes sur une seule page.

Alors vous devez écrire la fonction de visualisation de lire et validé les différentes forme des choses et ne les divers objet enregistre().

"Est-ce un problème de conception si je suis en panne et de la main-code tout?" Non, c'est juste beaucoup de temps pour pas beaucoup de bénéfices.
- Je ne sais pas comment, par conséquent, ne pas le faire
- Ce que plus désirez-vous? Qui semble décrire une solution. Que devrait-on dit? La question est vague, il est donc difficile de fournir le code réel. Plutôt que de se plaindre, veuillez fournir une suggestion d'amélioration. Que proposez-vous?
InformationsquelleAutor S.Lott
0

Selon la documentation de Django, en ligne jeux de formulaires sont à cet effet:
"Inline formsets est une petite couche d'abstraction sur le modèle formsets. Ces simplifier le cas de travail avec des objets liés par l'intermédiaire d'une clé étrangère".

Voir https://docs.djangoproject.com/en/dev/topics/forms/modelforms/#inline-formsets

InformationsquelleAutor user1376892

Vous devez vous connecter pour publier un commentaire.