Handling ManyToMany Relationships with Through Model Fields in Django Forms

To include the type field from your PersonRelation through model in your form, you'll need to modify your approach. Here are a few ways to accomplish this:

Option 1: Add a Custom Field to Your Form

PYTHONCopied
class PersonModelForm(forms.ModelForm):
    relation_type = forms.ChoiceField(choices=TypeRelation.choices, required=False)
    
    class Meta:
        model = Person
        fields = ['first', 'last', 'relation']

Then update your view:

PYTHONCopied
def form_valid(self, form):
    person = form.save(commit=False)
    person.save()
    
    relation_type = form.cleaned_data.get('relation_type', 'PARENT')
    person.relation.set(form.cleaned_data['relation'],
                        through_defaults={'type': relation_type})
    return super().form_valid(form)

Option 2: Use Formsets for More Control

For more complex scenarios, you can use inline formsets:

PYTHONCopied
from django.forms import inlineformset_factory

class PersonModelForm(forms.ModelForm):
    class Meta:
        model = Person
        fields = ['first', 'last']

PersonRelationFormSet = inlineformset_factory(
    Person, 
    PersonRelation,
    fields=('relation', 'type'),
    extra=1
)

Then in your view:

PYTHONCopied
class PersonCreateView(LoginRequiredMixin, CreateView):
    model = Person
    form_class = PersonModelForm
    template_name = 'form.html'
    
    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        if self.request.POST:
            context['relation_formset'] = PersonRelationFormSet(self.request.POST)
        else:
            context['relation_formset'] = PersonRelationFormSet()
        return context
    
    def form_valid(self, form):
        context = self.get_context_data()
        relation_formset = context['relation_formset']
        
        if form.is_valid() and relation_formset.is_valid():
            self.object = form.save()
            relation_formset.instance = self.object
            relation_formset.save()
            return redirect(self.get_success_url())
        else:
            return self.render_to_response(self.get_context_data(form=form))

In your template, you'll need to include both the form and formset:

HTMLCopied
<form method="post">
    {% csrf_token %}
    {{ form.as_p }}
    {{ relation_formset.management_form }}
    {% for relation_form in relation_formset %}
        {{ relation_form.as_p }}
    {% endfor %}
    <button type="submit">Save</button>
</form>

Option 3: Custom Form Field with Widget

For a more elegant solution, you could create a custom field that combines both the relation selection and type:

PYTHONCopied
class RelationTypeField(forms.MultiValueField):
    def __init__(self, *args, **kwargs):
        fields = (
            forms.ModelMultipleChoiceField(queryset=Person.objects.all()),
            forms.ChoiceField(choices=TypeRelation.choices)
        )
        super().__init__(fields=fields, *args, **kwargs)
    
    def compress(self, data_list):
        if data_list:
            return {'relations': data_list[0], 'type': data_list[1]}
        return None

class PersonModelForm(forms.ModelForm):
    relation_with_type = RelationTypeField()
    
    class Meta:
        model = Person
        fields = ['first', 'last']
        
    def save(self, commit=True):
        instance = super().save(commit=commit)
        if commit and self.cleaned_data.get('relation_with_type'):
            data = self.cleaned_data['relation_with_type']
            instance.relation.set(data['relations'], 
                                 through_defaults={'type': data['type']})
        return instance

Each approach has its advantages depending on your specific requirements. Option 1 is the simplest, Option 2 gives you the most flexibility (especially for multiple relations), and Option 3 provides a more integrated solution.