Handling Nested Forms with Dynamic Prefixes in Django

Your issue with nested formsets and dynamic prefixes is a common challenge when working with complex form structures in Django. The main problem is that you're creating the Level 3 formsets inside the loop, but only returning the last one when an error occurs.

Here's a better approach to handle this nested structure:

Restructured View Logic

PYTHONCopied
def process_activity_form(request):
    form = ActivityForm(request.POST or None)
    monthly_formset = MonthlyFormset(request.POST or None, prefix='m')
    
    # Create a dictionary to store all diff_times formsets
    diff_times_formsets = {}
    
    # Flag to track if any validation failed
    is_valid = True
    
    if request.method == 'POST':
        # First validate the main form
        if not form.is_valid():
            is_valid = False
        
        # Then validate the monthly formset
        if not monthly_formset.is_valid():
            is_valid = False
        
        # Pre-create and validate all diff_times formsets
        for i, monthly_form in enumerate(monthly_formset):
            prefix = f"{monthly_form.prefix}-dt"
            diff_times_formset = DifferentTimesFormset(request.POST, prefix=prefix)
            diff_times_formsets[monthly_form.prefix] = diff_times_formset
            
            if not diff_times_formset.is_valid():
                is_valid = False
        
        # If everything is valid, process the data
        if is_valid:
            # Save main form
            activity = form.save()
            
            # Process monthly forms
            for monthly_form in monthly_formset:
                if monthly_form.is_valid() and not monthly_form.cleaned_data.get('DELETE', False):
                    monthly_instance = monthly_form.save(commit=False)
                    monthly_instance.activity = activity
                    monthly_instance.save()
                    
                    # Process diff_times forms for this monthly form
                    diff_times_formset = diff_times_formsets[monthly_form.prefix]
                    for diff_times_form in diff_times_formset:
                        if diff_times_form.is_valid() and not diff_times_form.cleaned_data.get('DELETE', False):
                            diff_times_instance = diff_times_form.save(commit=False)
                            diff_times_instance.monthly = monthly_instance
                            diff_times_instance.save()
            
            return redirect('success_url')
    else:
        # For GET requests, initialize empty formsets
        for i, monthly_form in enumerate(monthly_formset):
            prefix = f"{monthly_form.prefix}-dt"
            diff_times_formsets[monthly_form.prefix] = DifferentTimesFormset(prefix=prefix)
    
    # Prepare context with all forms and formsets
    context = {
        'form': form,
        'monthly_formset': monthly_formset,
        'diff_times_formsets': diff_times_formsets,
    }
    
    return render(request, 'snippets/edit_activity_form.html', context)

Template Changes

You'll need to update your template to handle the dictionary of formsets:

HTMLCopied
<!-- Main form -->
<form method="post">
    {% csrf_token %}
    
    <!-- Display form errors -->
    {{ form.non_field_errors }}
    
    <!-- Main form fields -->
    {{ form.as_p }}
    
    <!-- Monthly formset -->
    {{ monthly_formset.management_form }}
    {{ monthly_formset.non_form_errors }}
    
    {% for monthly_form in monthly_formset %}
        <div class="monthly-form">
            {{ monthly_form.non_field_errors }}
            {{ monthly_form.as_p }}
            
            <!-- Different Times formset for this monthly form -->
            {% with diff_times_formset=diff_times_formsets|get_item:monthly_form.prefix %}
                {{ diff_times_formset.management_form }}
                {{ diff_times_formset.non_form_errors }}
                
                {% for diff_times_form in diff_times_formset %}
                    <div class="diff-times-form">
                        {{ diff_times_form.non_field_errors }}
                        {{ diff_times_form.as_p }}
                    </div>
                {% endfor %}
            {% endwith %}
        </div>
    {% endfor %}
    
    <button type="submit">Submit</button>
</form>

You'll need to create a custom template filter to access dictionary items:

PYTHONCopied
# In your app's templatetags/custom_filters.py
from django import template

register = template.Library()

@register.filter
def get_item(dictionary, key):
    return dictionary.get(key)

Key Improvements

1. Pre-validation: All forms and formsets are validated before any processing begins
2. Organized Storage: All Level 3 formsets are stored in a dictionary keyed by their parent form's prefix
3. Complete Context: The entire form structure is available in the context when rendering
4. Error Handling: All validation errors are preserved and can be displayed in the template

This approach ensures that when validation fails at any level, all forms and formsets are returned to the template with their respective error messages intact.