Dies wurde in Django 1.9 mit form_kwargs behoben .

Ich habe ein Django-Formular, das so aussieht:

class ServiceForm(forms.Form):
    option = forms.ModelChoiceField(queryset=ServiceOption.objects.none())
    rate = forms.DecimalField(widget=custom_widgets.SmallField())
    units = forms.IntegerField(min_value=1, widget=custom_widgets.SmallField())

    def __init__(self, *args, **kwargs):
        affiliate = kwargs.pop('affiliate')
        super(ServiceForm, self).__init__(*args, **kwargs)
        self.fields["option"].queryset = ServiceOption.objects.filter(affiliate=affiliate)

Ich nenne dieses Formular so etwas:

form = ServiceForm(affiliate=request.affiliate)

Wo request.affiliateist der angemeldete Benutzer? Dies funktioniert wie vorgesehen.

Mein Problem ist, dass ich dieses einzelne Formular jetzt in ein Formularset verwandeln möchte. Was ich nicht herausfinden kann, ist, wie ich die Partnerinformationen beim Erstellen des Formularsatzes an die einzelnen Formulare weitergeben kann. Laut den Dokumenten muss ich so etwas tun, um daraus ein Formset zu machen:

ServiceFormSet = forms.formsets.formset_factory(ServiceForm, extra=3)

Und dann muss ich es so erstellen:

formset = ServiceFormSet()

Wie kann ich nun Affiliate = request.affiliate auf diese Weise an die einzelnen Formulare übergeben?

Ich würde functools.partial und functools.wraps verwenden :

from functools import partial, wraps
from django.forms.formsets import formset_factory

ServiceFormSet = formset_factory(wraps(ServiceForm)(partial(ServiceForm, affiliate=request.affiliate)), extra=3)

Ich denke, dies ist der sauberste Ansatz und wirkt sich in keiner Weise auf ServiceForm aus (dh indem es die Unterklasse erschwert).

Offizieller Dokumentweg

Django 2.0:

ArticleFormSet = formset_factory(MyArticleForm)
formset = ArticleFormSet(form_kwargs={'user': request.user})

https://docs.djangoproject.com/de/2.0/topics/forms/formsets/#passing-custom-parameters-to-formset-forms

Ich würde die Formularklasse dynamisch in einer Funktion erstellen, damit sie über das Schließen Zugriff auf den Partner hat:

def make_service_form(affiliate):
    class ServiceForm(forms.Form):
        option = forms.ModelChoiceField(
                queryset=ServiceOption.objects.filter(affiliate=affiliate))
        rate = forms.DecimalField(widget=custom_widgets.SmallField())
        units = forms.IntegerField(min_value=1, 
                widget=custom_widgets.SmallField())
    return ServiceForm

Als Bonus müssen Sie das Abfrageset im Optionsfeld nicht neu schreiben. Der Nachteil ist, dass Unterklassen ein wenig funky sind. (Jede Unterklasse muss auf ähnliche Weise erstellt werden.)

bearbeiten:

Als Antwort auf einen Kommentar können Sie diese Funktion an jedem Ort aufrufen, an dem Sie den Klassennamen verwenden würden:

def view(request):
    affiliate = get_object_or_404(id=request.GET.get('id'))
    formset_cls = formset_factory(make_service_form(affiliate))
    formset = formset_cls(request.POST)
    ...

Das hat bei mir funktioniert, Django 1.7:

from django.utils.functional import curry    

lols = {'lols':'lols'}
formset = modelformset_factory(MyModel, form=myForm, extra=0)
formset.form = staticmethod(curry(MyForm, lols=lols))
return formset

#form.py
class MyForm(forms.ModelForm):

    def __init__(self, lols, *args, **kwargs):

Hoffe es hilft jemandem, ich habe lange genug gebraucht, um es herauszufinden;)

Ich mag die Verschlusslösung, um "sauberer" und pythonischer zu sein (also +1 bis mmarshall Antwort), aber Django-Formulare haben auch einen Rückrufmechanismus, den Sie zum Filtern von Abfragesätzen in Formsätzen verwenden können.

Es ist auch nicht dokumentiert, was meiner Meinung nach ein Indikator ist, den die Django-Entwickler vielleicht nicht so sehr mögen.

Sie erstellen Ihr Formset also im Grunde gleich, fügen aber den Rückruf hinzu:

ServiceFormSet = forms.formsets.formset_factory(
    ServiceForm, extra=3, formfield_callback=Callback('option', affiliate).cb)

Dadurch wird eine Instanz einer Klasse erstellt, die folgendermaßen aussieht:

class Callback(object):
    def __init__(self, field_name, aff):
        self._field_name = field_name
        self._aff = aff
    def cb(self, field, **kwargs):
        nf = field.formfield(**kwargs)
        if field.name == self._field_name:  # this is 'options' field
            nf.queryset = ServiceOption.objects.filter(affiliate=self._aff)
        return nf

Dies sollte Ihnen die allgemeine Idee geben. Es ist etwas komplexer, den Rückruf zu einer Objektmethode wie dieser zu machen, bietet Ihnen jedoch etwas mehr Flexibilität als ein einfacher Funktionsrückruf.

Ich wollte dies als Kommentar zu Carl Meyers Antwort platzieren, aber da dies Punkte erfordert, habe ich es einfach hier platziert. Ich habe 2 Stunden gebraucht, um das herauszufinden, also hoffe ich, dass es jemandem hilft.

Ein Hinweis zur Verwendung der inlineformset_factory.

Ich habe diese Lösung selbst verwendet und sie hat perfekt funktioniert, bis ich sie mit der inlineformset_factory ausprobiert habe. Ich habe Django 1.0.2 ausgeführt und eine seltsame KeyError-Ausnahme erhalten. Ich habe auf den neuesten Kofferraum aktualisiert und es hat direkt funktioniert.

Ich kann es jetzt ähnlich verwenden:

BookFormSet = inlineformset_factory(Author, Book, form=BookForm)
BookFormSet.form = staticmethod(curry(BookForm, user=request.user))

Ab Commit e091c18f50266097f648efc7cac2503968e9d217 am Di Aug 14 23:44:46 2012 +0200 kann die akzeptierte Lösung nicht mehr funktionieren.

Die aktuelle Version der Funktion django.forms.models.modelform_factory () verwendet eine "Typkonstruktionstechnik", die die Funktion type () für das übergebene Formular aufruft, um den Metaklassentyp abzurufen, und dann das Ergebnis verwendet, um ein Klassenobjekt von ihm zu erstellen Tippe on the fly ::

# Instatiate type(form) in order to use the same metaclass as form.
return type(form)(class_name, (form,), form_class_attrs)

Dies bedeutet, dass sogar ein curryEd oder partialObjekt, das anstelle eines Formulars übergeben wurde, sozusagen "die Ente dazu bringt, Sie zu beißen": Es ruft eine Funktion mit den Konstruktionsparametern eines ModelFormClassObjekts auf und gibt die Fehlermeldung zurück ::

function() argument 1 must be code, not str

Um dies zu umgehen, habe ich eine Generatorfunktion geschrieben, die einen Abschluss verwendet, um eine Unterklasse einer als ersten Parameter angegebenen Klasse zurückzugeben, die dann super.__init__nach updatedem kwargs mit denjenigen aufgerufen wird, die beim Aufruf der Generatorfunktion angegeben wurden ::

def class_gen_with_kwarg(cls, **additionalkwargs):
  """class generator for subclasses with additional 'stored' parameters (in a closure)
     This is required to use a formset_factory with a form that need additional 
     initialization parameters (see http://stackoverflow.com/questions/622982/django-passing-custom-form-parameters-to-formset)
  """
  class ClassWithKwargs(cls):
      def __init__(self, *args, **kwargs):
          kwargs.update(additionalkwargs)
          super(ClassWithKwargs, self).__init__(*args, **kwargs)
  return ClassWithKwargs

Dann rufen Sie in Ihrem Code die Formularfactory als :: auf

MyFormSet = inlineformset_factory(ParentModel, Model,form = class_gen_with_kwarg(MyForm, user=self.request.user))

Vorbehalte:

• Dies wurde zumindest vorerst nur sehr wenig getestet
• Die angegebenen Parameter können die von jedem Code verwendeten Parameter überschreiben und überschreiben, der das vom Konstruktor zurückgegebene Objekt verwendet

Die Lösung von Carl Meyer sieht sehr elegant aus. Ich habe versucht, es für modelformsets zu implementieren. Ich hatte den Eindruck, dass ich keine statischen Methoden innerhalb einer Klasse aufrufen konnte, aber Folgendes funktioniert unerklärlicherweise:

class MyModel(models.Model):
  myField = models.CharField(max_length=10)

class MyForm(ModelForm):
  _request = None
  class Meta:
    model = MyModel

    def __init__(self,*args,**kwargs):      
      self._request = kwargs.pop('request', None)
      super(MyForm,self).__init__(*args,**kwargs)

class MyFormsetBase(BaseModelFormSet):
  _request = None

def __init__(self,*args,**kwargs):
  self._request = kwargs.pop('request', None)
  subFormClass = self.form
  self.form = curry(subFormClass,request=self._request)
  super(MyFormsetBase,self).__init__(*args,**kwargs)

MyFormset =  modelformset_factory(MyModel,formset=MyFormsetBase,extra=1,max_num=10,can_delete=True)
MyFormset.form = staticmethod(curry(MyForm,request=MyFormsetBase._request))

Meiner Ansicht nach, wenn ich so etwas mache:

formset = MyFormset(request.POST,queryset=MyModel.objects.all(),request=request)

Dann wird das Schlüsselwort "request" an alle Mitgliedsformulare meines Formularsatzes weitergegeben. Ich bin zufrieden, aber ich habe keine Ahnung, warum das funktioniert - es scheint falsch. Irgendwelche Vorschläge?

Ich habe einige Zeit damit verbracht, dieses Problem herauszufinden, bevor ich diesen Beitrag gesehen habe.

Die Lösung, die ich gefunden habe, war die Verschlusslösung (und diese Lösung habe ich zuvor mit Django-Modellformularen verwendet).

Ich habe die oben beschriebene curry () -Methode ausprobiert, konnte sie jedoch mit Django 1.0 nicht zum Laufen bringen, sodass ich am Ende zur Closure-Methode zurückkehrte.

Die Schließmethode ist sehr ordentlich und die einzige kleine Seltsamkeit besteht darin, dass die Klassendefinition in der Ansicht oder einer anderen Funktion verschachtelt ist. Ich denke, die Tatsache, dass dies für mich seltsam aussieht, ist ein Hangup aus meiner vorherigen Programmiererfahrung und ich denke, jemand mit einem Hintergrund in dynamischeren Sprachen würde kein Augenlid schlagen!

Ich musste etwas Ähnliches tun. Dies ähnelt der curryLösung:

def form_with_my_variable(myvar):
   class MyForm(ServiceForm):
     def __init__(self, myvar=myvar, *args, **kwargs):
       super(SeriveForm, self).__init__(myvar=myvar, *args, **kwargs)
   return MyForm

factory = inlineformset_factory(..., form=form_with_my_variable(myvar), ... )

Aufgrund dieser Antwort fand ich eine klarere Lösung:

class ServiceForm(forms.Form):
    option = forms.ModelChoiceField(
            queryset=ServiceOption.objects.filter(affiliate=self.affiliate))
    rate = forms.DecimalField(widget=custom_widgets.SmallField())
    units = forms.IntegerField(min_value=1, 
            widget=custom_widgets.SmallField())

    @staticmethod
    def make_service_form(affiliate):
        self.affiliate = affiliate
        return ServiceForm

Und laufen Sie es in Sichtweite wie

formset_factory(form=ServiceForm.make_service_form(affiliate))

Ich bin ein Neuling hier, daher kann ich keinen Kommentar hinzufügen. Ich hoffe, dass dieser Code auch funktioniert:

ServiceFormSet = formset_factory(ServiceForm, extra=3)

ServiceFormSet.formset = staticmethod(curry(ServiceForm, affiliate=request.affiliate))

zum Hinzufügen zusätzlicher Parameter zu den Formularsätzen BaseFormSetanstelle von Formularen.