django-extra-views

These views are powerful replacements for Django's CreateView and UpdateView. They allow you to manage a parent model form along with any number of inline formsets simultaneously, similar to the Django Admin interface.

How to use:

1. Define inline configurations by subclassing InlineFormSetFactory for each related model.
2. Pass these factory classes to the inlines list in your view.
3. In your template, access the parent form via {{ form }} and iterate through the inlines using the inlines context variable.

Template pattern:

<form method="post">
  {{ form }}
  {% for formset in inlines %}
    {{ formset }}
  {% endfor %}
  <input type="submit" value="Submit" />
</form>

from extra_views import CreateWithInlinesView, UpdateWithInlinesView, InlineFormSetFactory

class ItemInline(InlineFormSetFactory):
    model = Item
    fields = ['sku', 'price', 'name']

class ContactInline(InlineFormSetFactory):
    model = Contact
    fields = ['name', 'email']

class CreateOrderView(CreateWithInlinesView):
    model = Order
    inlines = [ItemInline, ContactInline]
    fields = ['customer', 'name']
    template_name = 'order_and_items.html'

    def get_success_url(self):
        return self.object.get_absolute_url()

class UpdateOrderView(UpdateWithInlinesView):
    model = Order
    inlines = [ItemInline, ContactInline]
    fields = ['customer', 'name']
    template_name = 'order_and_items.html

    def get_success_url(self):
        return self.object.get_absolute_url()

Use ModelFormSetView to work with django.forms.modelformset_factory(). It allows you to manage a collection of model instances through a formset.

• Configuration: Define the model and either fields (list of fields to include) or exclude (list of fields to omit). If a form_class is provided, fields and exclude are not required.
• Querysets: By default, it populates the formset with all instances of the model. Override get_queryset() to filter the instances (e.g., based on URL parameters).
• Template Context: The formset is available in the template context as formset.

from extra_views import ModelFormSetView
from my_app.models import Item

class ItemFormSetView(ModelFormSetView):
    model = Item
    fields = ['name', 'sku', 'price']
    template_name = 'item_formset.html'

    def get_queryset(self):
        sku = self.kwargs['sku']
        return super(ItemFormSetView, self).get_queryset().filter(sku=sku)

To add sorting capabilities to a Django ListView, mix in SortableListMixin.

Configuration

• Field Aliases: Use sort_fields_aliases to hide actual database field names in the URL query string. This maps a user-friendly alias to the real field name.
• Direct Fields: Alternatively, define sort_fields to show the actual field names in the query string.

Template Usage

SortableListMixin provides a sort_helper object (an instance of SortHelper) to your template context. You can use the following helper methods to generate sort links or check current state:

• {{ sort_helper.get_sort_query_by_FOO }}: Generates the query string for sorting by field FOO.
• {{ sort_helper.get_sort_query_by_FOO_asc }}: Generates the query string for ascending sort by FOO.
• {{ sort_helper.get_sort_query_by_FOO_desc }}: Generates the query string for descending sort by FOO.
• {{ sort_helper.is_sorted_by_FOO }}: Returns whether the current list is sorted by field FOO.

from django.views.generic import ListView
from extra_views import SortableListMixin

class SortableItemListView(SortableListMixin, ListView):
    sort_fields_aliases = [('name', 'by_name'), ('id', 'by_id'), ]
    model = Item

Use FormSetView when you want to display a single, non-model formset on a page. It is the formset equivalent of Django's FormView.

Key features:

• Renders the formset in the template context as the variable formset.
• Calls formset_valid(formset) upon successful POST validation, where you should implement your handling logic.
• Redirects to success_url after successful validation.

To configure the formset, you can set attributes directly on the class or use factory_kwargs, formset_kwargs, and form_kwargs to pass arguments to the underlying Django formset constructor.

from extra_views import FormSetView
from my_app.forms import AddressForm

class AddressFormSetView(FormSetView):
    template_name = 'address_formset.html'
    form_class = AddressForm
    success_url = 'success/'

    def get_initial(self):
        # return whatever you'd normally use as the initial data for your formset.
        return data

    def formset_valid(self, formset):
        # do whatever you'd like to do with the valid formset
        return super(AddressFormSetView, self).formset_valid(formset)

To add search capabilities to a Django ListView, mix in SearchableListMixin and define a search_fields list containing the model fields to search against.

By default, the view filters the object_list if a q query string parameter is provided in the URL (e.g., ?q=query).

Customizing Search

• Custom Lookups: You can provide specific lookups by using tuples in search_fields, such as [('name', 'iexact'), 'sku']. The default lookup is icontains.
• Manual Search Logic: You can override the get_search_query method to implement custom search behavior.
• Field Types: It is recommended to use only string lookups. When searching number fields, they are converted to strings before comparison to prevent errors; this behavior is controlled by the check_lookups setting on SearchableListMixin.

from django.views.generic import ListView
from extra_views import SearchableListMixin

class SearchableItemListView(SearchableListMixin, ListView):
    template_name = 'extra_views/item_list.html'
    search_fields = ['name', 'sku']
    model = Item