Django Admin Chained Filters

Django's admin interface doesn't natively support dynamic/chained filters that update based on the selection of another filter. The built-in list filters work independently of each other.

To implement chained filters where one filter's options depend on another filter's selection, you'll need to use a third-party package or implement a custom JavaScript solution.

Options for Implementation

1. Using a Custom SimpleListFilter

You can create a custom filter that takes into account the current request parameters:

PYTHONCopied
from django.contrib import admin
from django.utils.translation import gettext_lazy as _

class RegionFilter(admin.SimpleListFilter):
    title = _('Region')
    parameter_name = 'region'
    
    def lookups(self, request, model_admin):
        return [(r.id, r.name) for r in Region.objects.all()]
    
    def queryset(self, request, queryset):
        if self.value():
            return queryset.filter(region_id=self.value())
        return queryset

class CityFilter(admin.SimpleListFilter):
    title = _('City')
    parameter_name = 'city'
    
    def lookups(self, request, model_admin):
        # Check if a region filter is applied
        region_id = request.GET.get('region')
        if region_id:
            # Only show cities from the selected region
            return [(c.id, c.name) for c in City.objects.filter(region_id=region_id)]
        return [(c.id, c.name) for c in City.objects.all()]
    
    def queryset(self, request, queryset):
        if self.value():
            return queryset.filter(city_id=self.value())
        return queryset

class MyModelAdmin(admin.ModelAdmin):
    list_filter = (RegionFilter, CityFilter)

However, this approach still requires a page reload when selecting a filter, and the second filter won't dynamically update its options without refreshing the page.

2. Using formfield_for_foreignkey for Form Filtering

For forms (add/change views), you can use formfield_for_foreignkey to filter related fields:

PYTHONCopied
class MyModelAdmin(admin.ModelAdmin):
    def formfield_for_foreignkey(self, db_field, request, **kwargs):
        if db_field.name == "city":
            # Get the region from the request or instance
            region_id = request.GET.get('region')
            if region_id:
                kwargs["queryset"] = City.objects.filter(region_id=region_id)
        return super().formfield_for_foreignkey(db_field, request, **kwargs)

3. Third-Party Solutions

For true dynamic chained filters, consider using a third-party package like:

• django-admin-autocomplete-filter
• django-admin-list-filter-dropdown
• django-smart-selects

These packages provide JavaScript-enhanced filters that can update dynamically based on other selections without requiring a page reload.

Conclusion

Django's built-in admin filters don't support dynamic chaining out of the box. For the best user experience with chained filters, you'll need to either:

1. Implement a custom JavaScript solution
2. Use a third-party package designed for this purpose
3. Accept the limitation that filters will only update after a page reload

The most common approach is to use a third-party package that handles the JavaScript interactions needed for true dynamic filtering.