Django Class-Based View Mixins

filters.py

from django_filters.filterset import FilterSet, FilterSetMetaclass

def filterset_factory(model, filterset=FilterSet, fields=None, exclude=None,
                      filter_for_field=None):
    """
    Build a ``FilterSet`` class for a specified model with the specified
    options.
    """
    attrs = {'model': model}
    if fields is not None:
        attrs['fields'] = fields
    if exclude is not None:
        attrs['exclude'] = exclude
    parent = (object,)
    if hasattr(filterset, 'Meta'):
        parent = (form.Meta, object)
    Meta = type('Meta', parent, attrs)
    class_name = model.__name__ + 'FilterSet'
    filterset_attrs = {
        'Meta': Meta,
    }
    if filter_for_field is not None:
        filterset_attrs['filter_for_field'] = filter_for_field
    return FilterSetMetaclass(class_name, (filterset,), filterset_attrs)


class DjangoFiltersMixin(object):
    """
    Filter a ``QuerySet`` with a given ``FilterSet`` in a ``ListView``.
    """
    filterset_context_name = 'filter'
    filterset_class = None
    def get_filterset_class(self, model):
        if self.filterset_class is not None:
            return self.filterset_class
        return filterset_factory(model)

    def get_filterset(self, queryset):
        if not getattr(self, '_filterset', None):
            filterset_class = self.get_filterset_class(queryset.model)
            data = self.request.GET or None
            self._filterset = filterset_class(data, queryset=queryset)
        return self._filterset

    def get_queryset(self):
        queryset = super(DjangoFiltersMixin, self).get_queryset()
        filterset = self.get_filterset(queryset)
        return filterset.qs

    def get_filterset_context_name(self):
        return self.filterset_context_name

    def get_context_data(self, **kwargs):
        context = super(DjangoFiltersMixin, self).get_context_data(**kwargs)
        filterset_var = self.get_filterset_context_name()
        filterset = self.get_filterset(self.object_list)
        context[filterset_var] = filterset
        return context

search.py

from haystack.query import SearchQuerySet

class HaystackSearchMixin(object):
    """
    Adds full-text searching to a model view.
    """
    search_site = None
    search_param = 'term'

    def get_search_site(self):
        return self.search_site

    def get_search_param(self):
        return self.search_param

    def get_search_term(self):
        search_param = self.get_search_param()
        return self.request.REQUEST.get(search_param, None)

    def get_queryset(self):
        queryset = super(HaystackSearchMixin, self).get_queryset()
        query = self.get_search_term(self)
        if query:
            sqs = SearchQuerySet(site=self.get_search_site()).models(queryset.model)
            sqs = sqs.auto_query(query).load_all()
            queryset = queryset.filter(pk__in=[result.object.pk for result in sqs.all()])
        return queryset

user_form.py

class UserFormMixin(object):
    def get_form_kwargs(self):
        kwargs = super(UserFormMixin, self).get_form_kwargs()
        kwargs.update({
            'user': self.request.user,
        })
        return kwargs