¿Múltiples modelos en un solo ModelForm de django?

¿Es posible tener varios modelos incluidos en un solo ModelFormen django? Estoy intentando crear un formulario de edición de perfil. Así que necesito incluir algunos campos del modelo de usuario y del modelo de perfil de usuario . Actualmente estoy usando 2 formularios como este

class UserEditForm(ModelForm):

    class Meta:
        model = User
        fields = ("first_name", "last_name")

class UserProfileForm(ModelForm):

    class Meta:
        model = UserProfile
        fields = ("middle_name", "home_phone", "work_phone", "cell_phone")

¿Hay alguna forma de consolidarlos en un formulario o solo necesito crear un formulario y manejar la carga de la base de datos y guardarme?

Puede mostrar ambos formularios en la plantilla dentro de un <form>elemento html. Luego, procese los formularios por separado en la vista. Aún podrá usar form.save()y no tendrá que procesar la carga de la base de datos y guardarlo.

En este caso, no debería necesitarlo, pero si va a utilizar formularios con los mismos nombres de campo, busque en el prefixkwarg los formularios de django. (Respondí una pregunta al respecto aquí ).

Puede intentar utilizar estos fragmentos de código:

class CombinedFormBase(forms.Form):
    form_classes = []

    def __init__(self, *args, **kwargs):
        super(CombinedFormBase, self).__init__(*args, **kwargs)
        for f in self.form_classes:
            name = f.__name__.lower()
            setattr(self, name, f(*args, **kwargs))
            form = getattr(self, name)
            self.fields.update(form.fields)
            self.initial.update(form.initial)

    def is_valid(self):
        isValid = True
        for f in self.form_classes:
            name = f.__name__.lower()
            form = getattr(self, name)
            if not form.is_valid():
                isValid = False
        # is_valid will trigger clean method
        # so it should be called after all other forms is_valid are called
        # otherwise clean_data will be empty
        if not super(CombinedFormBase, self).is_valid() :
            isValid = False
        for f in self.form_classes:
            name = f.__name__.lower()
            form = getattr(self, name)
            self.errors.update(form.errors)
        return isValid

    def clean(self):
        cleaned_data = super(CombinedFormBase, self).clean()
        for f in self.form_classes:
            name = f.__name__.lower()
            form = getattr(self, name)
            cleaned_data.update(form.cleaned_data)
        return cleaned_data

Ejemplo de uso:

class ConsumerRegistrationForm(CombinedFormBase):
    form_classes = [RegistrationForm, ConsumerProfileForm]

class RegisterView(FormView):
    template_name = "register.html"
    form_class = ConsumerRegistrationForm

    def form_valid(self, form):
        # some actions...
        return redirect(self.get_success_url())

Erikbwork y yo tuvimos el problema de que solo se puede incluir un modelo en una vista basada en clases genérica. Encontré una forma similar de abordarlo como Miao, pero más modular.

Escribí un Mixin para que puedas usar todas las vistas genéricas basadas en clases. Defina modelo, campos y ahora también child_model y child_field, y luego puede ajustar los campos de ambos modelos en una etiqueta como describe Zach.

class ChildModelFormMixin: 
    ''' extends ModelFormMixin with the ability to include ChildModelForm '''
    child_model = ""
    child_fields = ()
    child_form_class = None

    def get_child_model(self):
        return self.child_model

    def get_child_fields(self):
        return self.child_fields

    def get_child_form(self):
        if not self.child_form_class:
            self.child_form_class = model_forms.modelform_factory(self.get_child_model(), fields=self.get_child_fields())
        return self.child_form_class(**self.get_form_kwargs())

    def get_context_data(self, **kwargs):
        if 'child_form' not in kwargs:
            kwargs['child_form'] = self.get_child_form()
        return super().get_context_data(**kwargs)

    def post(self, request, *args, **kwargs):
        form = self.get_form()
        child_form = self.get_child_form()

        # check if both forms are valid
        form_valid = form.is_valid()
        child_form_valid = child_form.is_valid()

        if form_valid and child_form_valid:
            return self.form_valid(form, child_form)
        else:
            return self.form_invalid(form)

    def form_valid(self, form, child_form):
        self.object = form.save()
        save_child_form = child_form.save(commit=False)
        save_child_form.course_key = self.object
        save_child_form.save()

        return HttpResponseRedirect(self.get_success_url())

Ejemplo de uso:

class ConsumerRegistrationUpdateView(UpdateView):
    model = Registration
    fields = ('firstname', 'lastname',)
    child_model = ConsumerProfile
    child_fields = ('payment_token', 'cart',)

O con ModelFormClass:

class ConsumerRegistrationUpdateView(UpdateView):
    model = Registration
    fields = ('firstname', 'lastname',)
    child_model = ConsumerProfile
    child_form_class = ConsumerProfileForm

Hecho. Espero que ayude a alguien.

Probablemente debería echar un vistazo a los conjuntos de formularios en línea . Los conjuntos de formularios en línea se utilizan cuando sus modelos están relacionados por una clave externa.

Puede consultar mi respuesta aquí para un problema similar.

Habla sobre cómo combinar el registro y el perfil de usuario en un formulario, pero se puede generalizar a cualquier combinación de ModelForm.

Solía django betterforms 's multiforme y MultiModelForm en mi proyecto. Sin embargo, el código se puede mejorar. Por ejemplo, depende de django.six, que no es compatible con 3. +, pero todos estos se pueden solucionar fácilmente

Esta pregunta ha aparecido varias veces en StackOverflow, así que creo que es hora de encontrar una forma estandarizada de lidiar con esto.