# Django 1.8.18.dev20170123152445 documentation

# Source code for django.contrib.admin.options

    import copy
    import operator
    import warnings
    from collections import OrderedDict
    from functools import partial, reduce, update_wrapper

    from django import forms
    from django.conf import settings
    from django.contrib import messages
    from django.contrib.admin import helpers, validation, widgets
    from django.contrib.admin.checks import (
        BaseModelAdminChecks, InlineModelAdminChecks, ModelAdminChecks,
    )
    from django.contrib.admin.exceptions import DisallowedModelAdminToField
    from django.contrib.admin.templatetags.admin_static import static
    from django.contrib.admin.templatetags.admin_urls import add_preserved_filters
    from django.contrib.admin.utils import (
        NestedObjects, flatten_fieldsets, get_deleted_objects,
        lookup_needs_distinct, model_format_dict, quote, unquote,
    )
    from django.contrib.auth import get_permission_codename
    from django.core import checks
    from django.core.exceptions import (
        FieldDoesNotExist, FieldError, ImproperlyConfigured, PermissionDenied,
        ValidationError,
    )
    from django.core.paginator import Paginator
    from django.core.urlresolvers import reverse
    from django.db import models, router, transaction
    from django.db.models.constants import LOOKUP_SEP
    from django.db.models.fields import BLANK_CHOICE_DASH
    from django.db.models.fields.related import ForeignObjectRel
    from django.db.models.sql.constants import QUERY_TERMS
    from django.forms.formsets import DELETION_FIELD_NAME, all_valid
    from django.forms.models import (
        BaseInlineFormSet, inlineformset_factory, modelform_defines_fields,
        modelform_factory, modelformset_factory,
    )
    from django.forms.widgets import CheckboxSelectMultiple, SelectMultiple
    from django.http import Http404, HttpResponseRedirect
    from django.http.response import HttpResponseBase
    from django.template.response import SimpleTemplateResponse, TemplateResponse
    from django.utils import six
    from django.utils.decorators import method_decorator
    from django.utils.deprecation import RemovedInDjango19Warning
    from django.utils.encoding import force_text, python_2_unicode_compatible
    from django.utils.html import escape, escapejs
    from django.utils.http import urlencode
    from django.utils.safestring import mark_safe
    from django.utils.text import capfirst, get_text_list
    from django.utils.translation import string_concat, ugettext as _, ungettext
    from django.views.decorators.csrf import csrf_protect

    IS_POPUP_VAR = '_popup'
    TO_FIELD_VAR = '_to_field'

    HORIZONTAL, VERTICAL = 1, 2

    def get_content_type_for_model(obj):
        # Since this module gets imported in the application's root package,
        # it cannot import models from other applications at the module level.
        from django.contrib.contenttypes.models import ContentType
        return ContentType.objects.get_for_model(obj, for_concrete_model=False)

    def get_ul_class(radio_style):
        return 'radiolist' if radio_style == VERTICAL else 'radiolist inline'

    class IncorrectLookupParameters(Exception):
        pass

    # Defaults for formfield_overrides. ModelAdmin subclasses can change this
    # by adding to ModelAdmin.formfield_overrides.

    FORMFIELD_FOR_DBFIELD_DEFAULTS = {
        models.DateTimeField: {
            'form_class': forms.SplitDateTimeField,
            'widget': widgets.AdminSplitDateTime
        },
        models.DateField: {'widget': widgets.AdminDateWidget},
        models.TimeField: {'widget': widgets.AdminTimeWidget},
        models.TextField: {'widget': widgets.AdminTextareaWidget},
        models.URLField: {'widget': widgets.AdminURLFieldWidget},
        models.IntegerField: {'widget': widgets.AdminIntegerFieldWidget},
        models.BigIntegerField: {'widget': widgets.AdminBigIntegerFieldWidget},
        models.CharField: {'widget': widgets.AdminTextInputWidget},
        models.ImageField: {'widget': widgets.AdminFileWidget},
        models.FileField: {'widget': widgets.AdminFileWidget},
        models.EmailField: {'widget': widgets.AdminEmailInputWidget},
    }

    csrf_protect_m = method_decorator(csrf_protect)

    class BaseModelAdmin(six.with_metaclass(forms.MediaDefiningClass)):
        """Functionality common to both ModelAdmin and InlineAdmin."""

        raw_id_fields = ()
        fields = None
        exclude = None
        fieldsets = None
        form = forms.ModelForm
        filter_vertical = ()
        filter_horizontal = ()
        radio_fields = {}
        prepopulated_fields = {}
        formfield_overrides = {}
        readonly_fields = ()
        ordering = None
        view_on_site = True
        show_full_result_count = True

        # Validation of ModelAdmin definitions
        # Old, deprecated style:
        validator_class = None
        default_validator_class = validation.BaseValidator
        # New style:
        checks_class = BaseModelAdminChecks

        @classmethod
        def validate(cls, model):
            warnings.warn(
                'ModelAdmin.validate() is deprecated. Use "check()" instead.',
                RemovedInDjango19Warning)
            if cls.validator_class:
                validator = cls.validator_class()
            else:
                validator = cls.default_validator_class()
            validator.validate(cls, model)

        @classmethod
        def check(cls, model, **kwargs):
            if cls.validator_class:
                warnings.warn(
                    'ModelAdmin.validator_class is deprecated. '
                    'ModelAdmin validators must be converted to use '
                    'the system check framework.',
                    RemovedInDjango19Warning)
                validator = cls.validator_class()
                try:
                    validator.validate(cls, model)
                except ImproperlyConfigured as e:
                    return [checks.Error(e.args[0], hint=None, obj=cls)]
                else:
                    return []
            else:
                return cls.checks_class().check(cls, model, **kwargs)

        def __init__(self):
            overrides = FORMFIELD_FOR_DBFIELD_DEFAULTS.copy()
            overrides.update(self.formfield_overrides)
            self.formfield_overrides = overrides

        def formfield_for_dbfield(self, db_field, **kwargs):
            """
            Hook for specifying the form Field instance for a given database Field
            instance.

            If kwargs are given, they're passed to the form Field's constructor.
            """
            request = kwargs.pop("request", None)

            # If the field specifies choices, we don't need to look for special
            # admin widgets - we just need to use a select widget of some kind.
            if db_field.choices:
                return self.formfield_for_choice_field(db_field, request, **kwargs)

            # ForeignKey or ManyToManyFields
            if isinstance(db_field, (models.ForeignKey, models.ManyToManyField)):
                # Combine the field kwargs with any options for formfield_overrides.
                # Make sure the passed in **kwargs override anything in
                # formfield_overrides because **kwargs is more specific, and should
                # always win.
                if db_field.__class__ in self.formfield_overrides:
                    kwargs = dict(self.formfield_overrides[db_field.__class__], **kwargs)

                # Get the correct formfield.
                if isinstance(db_field, models.ForeignKey):
                    formfield = self.formfield_for_foreignkey(db_field, request, **kwargs)
                elif isinstance(db_field, models.ManyToManyField):
                    formfield = self.formfield_for_manytomany(db_field, request, **kwargs)

                # For non-raw_id fields, wrap the widget with a wrapper that adds
                # extra HTML -- the "add other" interface -- to the end of the
                # rendered output. formfield can be None if it came from a
                # OneToOneField with parent_link=True or a M2M intermediary.
                if formfield and db_field.name not in self.raw_id_fields:
                    related_modeladmin = self.admin_site._registry.get(db_field.rel.to)
                    wrapper_kwargs = {}
                    if related_modeladmin:
                        wrapper_kwargs.update(
                            can_add_related=related_modeladmin.has_add_permission(request),
                            can_change_related=related_modeladmin.has_change_permission(request),
                            can_delete_related=related_modeladmin.has_delete_permission(request),
                        )
                    formfield.widget = widgets.RelatedFieldWidgetWrapper(
                        formfield.widget, db_field.rel, self.admin_site, **wrapper_kwargs
                    )

                return formfield

            # If we've got overrides for the formfield defined, use 'em. **kwargs
            # passed to formfield_for_dbfield override the defaults.
            for klass in db_field.__class__.mro():
                if klass in self.formfield_overrides:
                    kwargs = dict(copy.deepcopy(self.formfield_overrides[klass]), **kwargs)
                    return db_field.formfield(**kwargs)

            # For any other type of field, just call its formfield() method.
            return db_field.formfield(**kwargs)

        def formfield_for_choice_field(self, db_field, request=None, **kwargs):
            """
            Get a form Field for a database Field that has declared choices.
            """
            # If the field is named as a radio_field, use a RadioSelect
            if db_field.name in self.radio_fields:
                # Avoid stomping on custom widget/choices arguments.
                if 'widget' not in kwargs:
                    kwargs['widget'] = widgets.AdminRadioSelect(attrs={
                        'class': get_ul_class(self.radio_fields[db_field.name]),
                    })
                if 'choices' not in kwargs:
                    kwargs['choices'] = db_field.get_choices(
                        include_blank=db_field.blank,
                        blank_choice=[('', _('None'))]
                    )
            return db_field.formfield(**kwargs)

        def get_field_queryset(self, db, db_field, request):
            """
            If the ModelAdmin specifies ordering, the queryset should respect that
            ordering.  Otherwise don't specify the queryset, let the field decide
            (returns None in that case).
            """
            related_admin = self.admin_site._registry.get(db_field.rel.to, None)
            if related_admin is not None:
                ordering = related_admin.get_ordering(request)
                if ordering is not None and ordering != ():
                    return db_field.rel.to._default_manager.using(db).order_by(*ordering)
            return None

        def formfield_for_foreignkey(self, db_field, request=None, **kwargs):
            """
            Get a form Field for a ForeignKey.
            """
            db = kwargs.get('using')
            if db_field.name in self.raw_id_fields:
                kwargs['widget'] = widgets.ForeignKeyRawIdWidget(db_field.rel,
                                        self.admin_site, using=db)
            elif db_field.name in self.radio_fields:
                kwargs['widget'] = widgets.AdminRadioSelect(attrs={
                    'class': get_ul_class(self.radio_fields[db_field.name]),
                })
                kwargs['empty_label'] = _('None') if db_field.blank else None

            if 'queryset' not in kwargs:
                queryset = self.get_field_queryset(db, db_field, request)
                if queryset is not None:
                    kwargs['queryset'] = queryset

            return db_field.formfield(**kwargs)

        def formfield_for_manytomany(self, db_field, request=None, **kwargs):
            """
            Get a form Field for a ManyToManyField.
            """
            # If it uses an intermediary model that isn't auto created, don't show
            # a field in admin.
            if not db_field.rel.through._meta.auto_created:
                return None
            db = kwargs.get('using')

            if db_field.name in self.raw_id_fields:
                kwargs['widget'] = widgets.ManyToManyRawIdWidget(db_field.rel,
                                        self.admin_site, using=db)
                kwargs['help_text'] = ''
            elif db_field.name in (list(self.filter_vertical) + list(self.filter_horizontal)):
                kwargs['widget'] = widgets.FilteredSelectMultiple(
                    db_field.verbose_name,
                    db_field.name in self.filter_vertical
                )

            if 'queryset' not in kwargs:
                queryset = self.get_field_queryset(db, db_field, request)
                if queryset is not None:
                    kwargs['queryset'] = queryset

            form_field = db_field.formfield(**kwargs)
            if isinstance(form_field.widget, SelectMultiple) and not isinstance(form_field.widget, CheckboxSelectMultiple):
                msg = _('Hold down "Control", or "Command" on a Mac, to select more than one.')
                help_text = form_field.help_text
                form_field.help_text = string_concat(help_text, ' ', msg) if help_text else msg
            return form_field

        def get_view_on_site_url(self, obj=None):
            if obj is None or not self.view_on_site:
                return None

            if callable(self.view_on_site):
                return self.view_on_site(obj)
            elif self.view_on_site and hasattr(obj, 'get_absolute_url'):
                # use the ContentType lookup if view_on_site is True
                return reverse('admin:view_on_site', kwargs={
                    'content_type_id': get_content_type_for_model(obj).pk,
                    'object_id': obj.pk
                })

        @property
        def declared_fieldsets(self):
            warnings.warn(
                "ModelAdmin.declared_fieldsets is deprecated and "
                "will be removed in Django 1.9.",
                RemovedInDjango19Warning, stacklevel=2
            )

            if self.fieldsets:
                return self.fieldsets
            elif self.fields:
                return [(None, {'fields': self.fields})]
            return None

        def get_fields(self, request, obj=None):
            """
            Hook for specifying fields.
            """
            return self.fields

        def get_fieldsets(self, request, obj=None):
            """
            Hook for specifying fieldsets.
            """
            # We access the property and check if it triggers a warning.
            # If it does, then it's ours and we can safely ignore it, but if
            # it doesn't then it has been overridden so we must warn about the
            # deprecation.
            with warnings.catch_warnings(record=True) as w:
                warnings.simplefilter("always")
                declared_fieldsets = self.declared_fieldsets
            if len(w) != 1 or not issubclass(w[0].category, RemovedInDjango19Warning):
                warnings.warn(
                    "ModelAdmin.declared_fieldsets is deprecated and "
                    "will be removed in Django 1.9.",
                    RemovedInDjango19Warning
                )
                if declared_fieldsets:
                    return declared_fieldsets

            if self.fieldsets:
                return self.fieldsets
            return [(None, {'fields': self.get_fields(request, obj)})]

        def get_ordering(self, request):
            """
            Hook for specifying field ordering.
            """
            return self.ordering or ()  # otherwise we might try to *None, which is bad ;)

        def get_readonly_fields(self, request, obj=None):
            """
            Hook for specifying custom readonly fields.
            """
            return self.readonly_fields

        def get_prepopulated_fields(self, request, obj=None):
            """
            Hook for specifying custom prepopulated fields.
            """
            return self.prepopulated_fields

        def get_queryset(self, request):
            """
            Returns a QuerySet of all model instances that can be edited by the
            admin site. This is used by changelist_view.
            """
            qs = self.model._default_manager.get_queryset()
            # TODO: this should be handled by some parameter to the ChangeList.
            ordering = self.get_ordering(request)
            if ordering:
                qs = qs.order_by(*ordering)
            return qs

        def lookup_allowed(self, lookup, value):
            from django.contrib.admin.filters import SimpleListFilter

            model = self.model
            # Check FKey lookups that are allowed, so that popups produced by
            # ForeignKeyRawIdWidget, on the basis of ForeignKey.limit_choices_to,
            # are allowed to work.
            for l in model._meta.related_fkey_lookups:
                # As ``limit_choices_to`` can be a callable, invoke it here.
                if callable(l):
                    l = l()
                for k, v in widgets.url_params_from_lookup_dict(l).items():
                    if k == lookup and v == value:
                        return True

            parts = lookup.split(LOOKUP_SEP)

            # Last term in lookup is a query term (__exact, __startswith etc)
            # This term can be ignored.
            if len(parts) > 1 and parts[-1] in QUERY_TERMS:
                parts.pop()

            # Special case -- foo__id__exact and foo__id queries are implied
            # if foo has been specifically included in the lookup list; so
            # drop __id if it is the last part. However, first we need to find
            # the pk attribute name.
            rel_name = None
            for part in parts[:-1]:
                try:
                    field = model._meta.get_field(part)
                except FieldDoesNotExist:
                    # Lookups on non-existent fields are ok, since they're ignored
                    # later.
                    return True
                if hasattr(field, 'rel'):
                    if field.rel is None:
                        # This property or relation doesn't exist, but it's allowed
                        # since it's ignored in ChangeList.get_filters().
                        return True
                    model = field.rel.to
                    if hasattr(field.rel, 'get_related_field'):
                        rel_name = field.rel.get_related_field().name
                    else:
                        rel_name = None
                elif isinstance(field, ForeignObjectRel):
                    model = field.related_model
                    rel_name = model._meta.pk.name
                else:
                    rel_name = None
            if rel_name and len(parts) > 1 and parts[-1] == rel_name:
                parts.pop()

            if len(parts) == 1:
                return True
            clean_lookup = LOOKUP_SEP.join(parts)
            valid_lookups = [self.date_hierarchy]
            for filter_item in self.list_filter:
                if isinstance(filter_item, type) and issubclass(filter_item, SimpleListFilter):
                    valid_lookups.append(filter_item.parameter_name)
                elif isinstance(filter_item, (list, tuple)):
                    valid_lookups.append(filter_item[0])
                else:
                    valid_lookups.append(filter_item)
            return clean_lookup in valid_lookups

        def to_field_allowed(self, request, to_field):
            """
            Returns True if the model associated with this admin should be
            allowed to be referenced by the specified field.
            """
            opts = self.model._meta

            try:
                field = opts.get_field(to_field)
            except FieldDoesNotExist:
                return False

            # Always allow referencing the primary key since it's already possible
            # to get this information from the change view URL.
            if field.primary_key:
                return True

            # Allow reverse relationships to models defining m2m fields if they
            # target the specified field.
            for many_to_many in opts.many_to_many:
                if many_to_many.m2m_target_field_name() == to_field:
                    return True

            # Make sure at least one of the models registered for this site
            # references this field through a FK or a M2M relationship.
            registered_models = set()
            for model, admin in self.admin_site._registry.items():
                registered_models.add(model)
                for inline in admin.inlines:
                    registered_models.add(inline.model)

            related_objects = (
                f for f in opts.get_fields(include_hidden=True)
                if (f.auto_created and not f.concrete)
            )
            for related_object in related_objects:
                related_model = related_object.related_model
                remote_field = related_object.field.rel
                if (any(issubclass(model, related_model) for model in registered_models) and
                        hasattr(remote_field, 'get_related_field') and
                        remote_field.get_related_field() == field):
                    return True

            return False

        def has_add_permission(self, request):
            """
            Returns True if the given request has permission to add an object.
            Can be overridden by the user in subclasses.
            """
            opts = self.opts
            codename = get_permission_codename('add', opts)
            return request.user.has_perm("%s.%s" % (opts.app_label, codename))

        def has_change_permission(self, request, obj=None):
            """
            Returns True if the given request has permission to change the given
            Django model instance, the default implementation doesn't examine the
            `obj` parameter.

            Can be overridden by the user in subclasses. In such case it should
            return True if the given request has permission to change the `obj`
            model instance. If `obj` is None, this should return True if the given
            request has permission to change *any* object of the given type.
            """
            opts = self.opts
            codename = get_permission_codename('change', opts)
            return request.user.has_perm("%s.%s" % (opts.app_label, codename))

        def has_delete_permission(self, request, obj=None):
            """
            Returns True if the given request has permission to change the given
            Django model instance, the default implementation doesn't examine the
            `obj` parameter.

            Can be overridden by the user in subclasses. In such case it should
            return True if the given request has permission to delete the `obj`
            model instance. If `obj` is None, this should return True if the given
            request has permission to delete *any* object of the given type.
            """
            opts = self.opts
            codename = get_permission_codename('delete', opts)
            return request.user.has_perm("%s.%s" % (opts.app_label, codename))

        def has_module_permission(self, request):
            """
            Returns True if the given request has any permission in the given
            app label.

            Can be overridden by the user in subclasses. In such case it should
            return True if the given request has permission to view the module on
            the admin index page and access the module's index page. Overriding it
            does not restrict access to the add, change or delete views. Use
            `ModelAdmin.has_(add|change|delete)_permission` for that.
            """
            return request.user.has_module_perms(self.opts.app_label)

    @python_2_unicode_compatible
    class ModelAdmin(BaseModelAdmin):
        "Encapsulates all admin options and functionality for a given model."

        list_display = ('__str__',)
        list_display_links = ()
        list_filter = ()
        list_select_related = False
        list_per_page = 100
        list_max_show_all = 200
        list_editable = ()
        search_fields = ()
        date_hierarchy = None
        save_as = False
        save_on_top = False
        paginator = Paginator
        preserve_filters = True
        inlines = []

        # Custom templates (designed to be over-ridden in subclasses)
        add_form_template = None
        change_form_template = None
        change_list_template = None
        delete_confirmation_template = None
        delete_selected_confirmation_template = None
        object_history_template = None

        # Actions
        actions = []
        action_form = helpers.ActionForm
        actions_on_top = True
        actions_on_bottom = False
        actions_selection_counter = True

        # validation
        # Old, deprecated style:
        default_validator_class = validation.ModelAdminValidator
        # New style:
        checks_class = ModelAdminChecks

        def __init__(self, model, admin_site):
            self.model = model
            self.opts = model._meta
            self.admin_site = admin_site
            super(ModelAdmin, self).__init__()

        def __str__(self):
            return "%s.%s" % (self.model._meta.app_label, self.__class__.__name__)

        def get_inline_instances(self, request, obj=None):
            inline_instances = []
            for inline_class in self.inlines:
                inline = inline_class(self.model, self.admin_site)
                if request:
                    if not (inline.has_add_permission(request) or
                            inline.has_change_permission(request, obj) or
                            inline.has_delete_permission(request, obj)):
                        continue
                    if not inline.has_add_permission(request):
                        inline.max_num = 0
                inline_instances.append(inline)

            return inline_instances

        def get_urls(self):
            from django.conf.urls import url

            def wrap(view):
                def wrapper(*args, **kwargs):
                    return self.admin_site.admin_view(view)(*args, **kwargs)
                return update_wrapper(wrapper, view)

            info = self.model._meta.app_label, self.model._meta.model_name

            urlpatterns = [
                url(r'^$', wrap(self.changelist_view), name='%s_%s_changelist' % info),
                url(r'^add/$', wrap(self.add_view), name='%s_%s_add' % info),
                url(r'^(.+)/history/$', wrap(self.history_view), name='%s_%s_history' % info),
                url(r'^(.+)/delete/$', wrap(self.delete_view), name='%s_%s_delete' % info),
                url(r'^(.+)/$', wrap(self.change_view), name='%s_%s_change' % info),
            ]
            return urlpatterns

        def urls(self):
            return self.get_urls()
        urls = property(urls)

        @property
        def media(self):
            extra = '' if settings.DEBUG else '.min'
            js = [
                'core.js',
                'jquery%s.js' % extra,
                'jquery.init.js',
                'admin/RelatedObjectLookups.js',
            ]
            if self.actions is not None:
                js.append('actions%s.js' % extra)
            if self.prepopulated_fields:
                js.extend(['urlify.js', 'prepopulate%s.js' % extra])
            return forms.Media(js=[static('admin/js/%s' % url) for url in js])

        def get_model_perms(self, request):
            """
            Returns a dict of all perms for this model. This dict has the keys
            ``add``, ``change``, and ``delete`` mapping to the True/False for each
            of those actions.
            """
            return {
                'add': self.has_add_permission(request),
                'change': self.has_change_permission(request),
                'delete': self.has_delete_permission(request),
            }

        def get_fields(self, request, obj=None):
            if self.fields:
                return self.fields
            form = self.get_form(request, obj, fields=None)
            return list(form.base_fields) + list(self.get_readonly_fields(request, obj))

        def get_form(self, request, obj=None, **kwargs):
            """
            Returns a Form class for use in the admin add view. This is used by
            add_view and change_view.
            """
            if 'fields' in kwargs:
                fields = kwargs.pop('fields')
            else:
                fields = flatten_fieldsets(self.get_fieldsets(request, obj))
            if self.exclude is None:
                exclude = []
            else:
                exclude = list(self.exclude)
            exclude.extend(self.get_readonly_fields(request, obj))
            if self.exclude is None and hasattr(self.form, '_meta') and self.form._meta.exclude:
                # Take the custom ModelForm's Meta.exclude into account only if the
                # ModelAdmin doesn't define its own.
                exclude.extend(self.form._meta.exclude)
            # if exclude is an empty list we pass None to be consistent with the
            # default on modelform_factory
            exclude = exclude or None
            defaults = {
                "form": self.form,
                "fields": fields,
                "exclude": exclude,
                "formfield_callback": partial(self.formfield_for_dbfield, request=request),
            }
            defaults.update(kwargs)

            if defaults['fields'] is None and not modelform_defines_fields(defaults['form']):
                defaults['fields'] = forms.ALL_FIELDS

            try:
                return modelform_factory(self.model, **defaults)
            except FieldError as e:
                raise FieldError('%s. Check fields/fieldsets/exclude attributes of class %s.'
                                 % (e, self.__class__.__name__))

        def get_changelist(self, request, **kwargs):
            """
            Returns the ChangeList class for use on the changelist page.
            """
            from django.contrib.admin.views.main import ChangeList
            return ChangeList

        def get_object(self, request, object_id, from_field=None):
            """
            Returns an instance matching the field and value provided, the primary
            key is used if no field is provided. Returns ``None`` if no match is
            found or the object_id fails validation.
            """
            queryset = self.get_queryset(request)
            model = queryset.model
            field = model._meta.pk if from_field is None else model._meta.get_field(from_field)
            try:
                object_id = field.to_python(object_id)
                return queryset.get(**{field.name: object_id})
            except (model.DoesNotExist, ValidationError, ValueError):
                return None

        def get_changelist_form(self, request, **kwargs):
            """
            Returns a Form class for use in the Formset on the changelist page.
            """
            defaults = {
                "formfield_callback": partial(self.formfield_for_dbfield, request=request),
            }
            defaults.update(kwargs)
            if (defaults.get('fields') is None
                    and not modelform_defines_fields(defaults.get('form'))):
                defaults['fields'] = forms.ALL_FIELDS

            return modelform_factory(self.model, **defaults)

        def get_changelist_formset(self, request, **kwargs):
            """
            Returns a FormSet class for use on the changelist page if list_editable
            is used.
            """
            defaults = {
                "formfield_callback": partial(self.formfield_for_dbfield, request=request),
            }
            defaults.update(kwargs)
            return modelformset_factory(self.model,
                self.get_changelist_form(request), extra=0,
                fields=self.list_editable, **defaults)

        def _get_formsets(self, request, obj):
            """
            Helper function that exists to allow the deprecation warning to be
            executed while this function continues to return a generator.
            """
            for inline in self.get_inline_instances(request, obj):
                yield inline.get_formset(request, obj)

        def get_formsets(self, request, obj=None):
            warnings.warn(
                "ModelAdmin.get_formsets() is deprecated and will be removed in "
                "Django 1.9. Use ModelAdmin.get_formsets_with_inlines() instead.",
                RemovedInDjango19Warning, stacklevel=2
            )
            return self._get_formsets(request, obj)

        def get_formsets_with_inlines(self, request, obj=None):
            """
            Yields formsets and the corresponding inlines.
            """
            # We call get_formsets() [deprecated] and check if it triggers a
            # warning. If it does, then it's ours and we can safely ignore it, but
            # if it doesn't then it has been overridden so we must warn about the
            # deprecation.
            with warnings.catch_warnings(record=True) as w:
                warnings.simplefilter("always")
                formsets = self.get_formsets(request, obj)

            if len(w) != 1 or not issubclass(w[0].category, RemovedInDjango19Warning):
                warnings.warn(
                    "ModelAdmin.get_formsets() is deprecated and will be removed in "
                    "Django 1.9. Use ModelAdmin.get_formsets_with_inlines() instead.",
                    RemovedInDjango19Warning, stacklevel=2
                )
                if formsets:
                    zipped = zip(formsets, self.get_inline_instances(request, None))
                    for formset, inline in zipped:
                        yield formset, inline
            else:
                for inline in self.get_inline_instances(request, obj):
                    yield inline.get_formset(request, obj), inline

        def get_paginator(self, request, queryset, per_page, orphans=0, allow_empty_first_page=True):
            return self.paginator(queryset, per_page, orphans, allow_empty_first_page)

        def log_addition(self, request, object):
            """
            Log that an object has been successfully added.

            The default implementation creates an admin LogEntry object.
            """
            from django.contrib.admin.models import LogEntry, ADDITION
            LogEntry.objects.log_action(
                user_id=request.user.pk,
                content_type_id=get_content_type_for_model(object).pk,
                object_id=object.pk,
                object_repr=force_text(object),
                action_flag=ADDITION
            )

        def log_change(self, request, object, message):
            """
            Log that an object has been successfully changed.

            The default implementation creates an admin LogEntry object.
            """
            from django.contrib.admin.models import LogEntry, CHANGE
            LogEntry.objects.log_action(
                user_id=request.user.pk,
                content_type_id=get_content_type_for_model(object).pk,
                object_id=object.pk,
                object_repr=force_text(object),
                action_flag=CHANGE,
                change_message=message
            )

        def log_deletion(self, request, object, object_repr):
            """
            Log that an object will be deleted. Note that this method must be
            called before the deletion.

            The default implementation creates an admin LogEntry object.
            """
            from django.contrib.admin.models import LogEntry, DELETION
            LogEntry.objects.log_action(
                user_id=request.user.pk,
                content_type_id=get_content_type_for_model(object).pk,
                object_id=object.pk,
                object_repr=object_repr,
                action_flag=DELETION
            )

        def action_checkbox(self, obj):
            """
            A list_display column containing a checkbox widget.
            """
            return helpers.checkbox.render(helpers.ACTION_CHECKBOX_NAME, force_text(obj.pk))
        action_checkbox.short_description = mark_safe('<input type="checkbox" id="action-toggle" />')
        action_checkbox.allow_tags = True

        def get_actions(self, request):
            """
            Return a dictionary mapping the names of all actions for this
            ModelAdmin to a tuple of (callable, name, description) for each action.
            """
            # If self.actions is explicitly set to None that means that we don't
            # want *any* actions enabled on this page.
            if self.actions is None or IS_POPUP_VAR in request.GET:
                return OrderedDict()

            actions = []

            # Gather actions from the admin site first
            for (name, func) in self.admin_site.actions:
                description = getattr(func, 'short_description', name.replace('_', ' '))
                actions.append((func, name, description))

            # Then gather them from the model admin and all parent classes,
            # starting with self and working back up.
            for klass in self.__class__.mro()[::-1]:
                class_actions = getattr(klass, 'actions', [])
                # Avoid trying to iterate over None
                if not class_actions:
                    continue
                actions.extend(self.get_action(action) for action in class_actions)

            # get_action might have returned None, so filter any of those out.
            actions = filter(None, actions)

            # Convert the actions into an OrderedDict keyed by name.
            actions = OrderedDict(
                (name, (func, name, desc))
                for func, name, desc in actions
            )

            return actions

        def get_action_choices(self, request, default_choices=BLANK_CHOICE_DASH):
            """
            Return a list of choices for use in a form object.  Each choice is a
            tuple (name, description).
            """
            choices = [] + default_choices
            for func, name, description in six.itervalues(self.get_actions(request)):
                choice = (name, description % model_format_dict(self.opts))
                choices.append(choice)
            return choices

        def get_action(self, action):
            """
            Return a given action from a parameter, which can either be a callable,
            or the name of a method on the ModelAdmin.  Return is a tuple of
            (callable, name, description).
            """
            # If the action is a callable, just use it.
            if callable(action):
                func = action
                action = action.__name__

            # Next, look for a method. Grab it off self.__class__ to get an unbound
            # method instead of a bound one; this ensures that the calling
            # conventions are the same for functions and methods.
            elif hasattr(self.__class__, action):
                func = getattr(self.__class__, action)

            # Finally, look for a named method on the admin site
            else:
                try:
                    func = self.admin_site.get_action(action)
                except KeyError:
                    return None

            if hasattr(func, 'short_description'):
                description = func.short_description
            else:
                description = capfirst(action.replace('_', ' '))
            return func, action, description

        def get_list_display(self, request):
            """
            Return a sequence containing the fields to be displayed on the
            changelist.
            """
            return self.list_display

        def get_list_display_links(self, request, list_display):
            """
            Return a sequence containing the fields to be displayed as links
            on the changelist. The list_display parameter is the list of fields
            returned by get_list_display().
            """
            if self.list_display_links or self.list_display_links is None or not list_display:
                return self.list_display_links
            else:
                # Use only the first item in list_display as link
                return list(list_display)[:1]

        def get_list_filter(self, request):
            """
            Returns a sequence containing the fields to be displayed as filters in
            the right sidebar of the changelist page.
            """
            return self.list_filter

        def get_search_fields(self, request):
            """
            Returns a sequence containing the fields to be searched whenever
            somebody submits a search query.
            """
            return self.search_fields

        def get_search_results(self, request, queryset, search_term):
            """
            Returns a tuple containing a queryset to implement the search,
            and a boolean indicating if the results may contain duplicates.
            """
            # Apply keyword searches.
            def construct_search(field_name):
                if field_name.startswith('^'):
                    return "%s__istartswith" % field_name[1:]
                elif field_name.startswith('='):
                    return "%s__iexact" % field_name[1:]
                elif field_name.startswith('@'):
                    return "%s__search" % field_name[1:]
                else:
                    return "%s__icontains" % field_name

            use_distinct = False
            search_fields = self.get_search_fields(request)
            if search_fields and search_term:
                orm_lookups = [construct_search(str(search_field))
                               for search_field in search_fields]
                for bit in search_term.split():
                    or_queries = [models.Q(**{orm_lookup: bit})
                                  for orm_lookup in orm_lookups]
                    queryset = queryset.filter(reduce(operator.or_, or_queries))
                if not use_distinct:
                    for search_spec in orm_lookups:
                        if lookup_needs_distinct(self.opts, search_spec):
                            use_distinct = True
                            break

            return queryset, use_distinct

        def get_preserved_filters(self, request):
            """
            Returns the preserved filters querystring.
            """
            match = request.resolver_match
            if self.preserve_filters and match:
                opts = self.model._meta
                current_url = '%s:%s' % (match.app_name, match.url_name)
                changelist_url = 'admin:%s_%s_changelist' % (opts.app_label, opts.model_name)
                if current_url == changelist_url:
                    preserved_filters = request.GET.urlencode()
                else:
                    preserved_filters = request.GET.get('_changelist_filters')

                if preserved_filters:
                    return urlencode({'_changelist_filters': preserved_filters})
            return ''

        def construct_change_message(self, request, form, formsets):
            """
            Construct a change message from a changed object.
            """
            change_message = []
            if form.changed_data:
                change_message.append(_('Changed %s.') % get_text_list(form.changed_data, _('and')))

            if formsets:
                for formset in formsets:
                    for added_object in formset.new_objects:
                        change_message.append(_('Added %(name)s "%(object)s".')
                                              % {'name': force_text(added_object._meta.verbose_name),
                                                 'object': force_text(added_object)})
                    for changed_object, changed_fields in formset.changed_objects:
                        change_message.append(_('Changed %(list)s for %(name)s "%(object)s".')
                                              % {'list': get_text_list(changed_fields, _('and')),
                                                 'name': force_text(changed_object._meta.verbose_name),
                                                 'object': force_text(changed_object)})
                    for deleted_object in formset.deleted_objects:
                        change_message.append(_('Deleted %(name)s "%(object)s".')
                                              % {'name': force_text(deleted_object._meta.verbose_name),
                                                 'object': force_text(deleted_object)})
            change_message = ' '.join(change_message)
            return change_message or _('No fields changed.')

        def message_user(self, request, message, level=messages.INFO, extra_tags='',
                         fail_silently=False):
            """
            Send a message to the user. The default implementation
            posts a message using the django.contrib.messages backend.

            Exposes almost the same API as messages.add_message(), but accepts the
            positional arguments in a different order to maintain backwards
            compatibility. For convenience, it accepts the `level` argument as
            a string rather than the usual level number.
            """

            if not isinstance(level, int):
                # attempt to get the level if passed a string
                try:
                    level = getattr(messages.constants, level.upper())
                except AttributeError:
                    levels = messages.constants.DEFAULT_TAGS.values()
                    levels_repr = ', '.join('`%s`' % l for l in levels)
                    raise ValueError('Bad message level string: `%s`. '
                            'Possible values are: %s' % (level, levels_repr))

            messages.add_message(request, level, message, extra_tags=extra_tags,
                    fail_silently=fail_silently)

        def save_form(self, request, form, change):
            """
            Given a ModelForm return an unsaved instance. ``change`` is True if
            the object is being changed, and False if it's being added.
            """
            return form.save(commit=False)

        def save_model(self, request, obj, form, change):
            """
            Given a model instance save it to the database.
            """
            obj.save()

        def delete_model(self, request, obj):
            """
            Given a model instance delete it from the database.
            """
            obj.delete()

        def save_formset(self, request, form, formset, change):
            """
            Given an inline formset save it to the database.
            """
            formset.save()

        def save_related(self, request, form, formsets, change):
            """
            Given the ``HttpRequest``, the parent ``ModelForm`` instance, the
            list of inline formsets and a boolean value based on whether the
            parent is being added or changed, save the related objects to the
            database. Note that at this point save_form() and save_model() have
            already been called.
            """
            form.save_m2m()
            for formset in formsets:
                self.save_formset(request, form, formset, change=change)

        def render_change_form(self, request, context, add=False, change=False, form_url='', obj=None):
            opts = self.model._meta
            app_label = opts.app_label
            preserved_filters = self.get_preserved_filters(request)
            form_url = add_preserved_filters({'preserved_filters': preserved_filters, 'opts': opts}, form_url)
            view_on_site_url = self.get_view_on_site_url(obj)
            context.update({
                'add': add,
                'change': change,
                'has_add_permission': self.has_add_permission(request),
                'has_change_permission': self.has_change_permission(request, obj),
                'has_delete_permission': self.has_delete_permission(request, obj),
                'has_file_field': True,  # FIXME - this should check if form or formsets have a FileField,
                'has_absolute_url': view_on_site_url is not None,
                'absolute_url': view_on_site_url,
                'form_url': form_url,
                'opts': opts,
                'content_type_id': get_content_type_for_model(self.model).pk,
                'save_as': self.save_as,
                'save_on_top': self.save_on_top,
                'to_field_var': TO_FIELD_VAR,
                'is_popup_var': IS_POPUP_VAR,
                'app_label': app_label,
            })
            if add and self.add_form_template is not None:
                form_template = self.add_form_template
            else:
                form_template = self.change_form_template

            request.current_app = self.admin_site.name

            return TemplateResponse(request, form_template or [
                "admin/%s/%s/change_form.html" % (app_label, opts.model_name),
                "admin/%s/change_form.html" % app_label,
                "admin/change_form.html"
            ], context)

        def response_add(self, request, obj, post_url_continue=None):
            """
            Determines the HttpResponse for the add_view stage.
            """
            opts = obj._meta
            pk_value = obj._get_pk_val()
            preserved_filters = self.get_preserved_filters(request)
            msg_dict = {'name': force_text(opts.verbose_name), 'obj': force_text(obj)}
            # Here, we distinguish between different save types by checking for
            # the presence of keys in request.POST.

            if IS_POPUP_VAR in request.POST:
                to_field = request.POST.get(TO_FIELD_VAR)
                if to_field:
                    attr = str(to_field)
                else:
                    attr = obj._meta.pk.attname
                value = obj.serializable_value(attr)
                return SimpleTemplateResponse('admin/popup_response.html', {
                    'pk_value': escape(pk_value),  # for possible backwards-compatibility
                    'value': escape(value),
                    'obj': escapejs(obj)
                })

            elif "_continue" in request.POST:
                msg = _('The %(name)s "%(obj)s" was added successfully. You may edit it again below.') % msg_dict
                self.message_user(request, msg, messages.SUCCESS)
                if post_url_continue is None:
                    post_url_continue = reverse('admin:%s_%s_change' %
                                                (opts.app_label, opts.model_name),
                                                args=(quote(pk_value),),
                                                current_app=self.admin_site.name)
                post_url_continue = add_preserved_filters(
                    {'preserved_filters': preserved_filters, 'opts': opts},
                    post_url_continue
                )
                return HttpResponseRedirect(post_url_continue)

            elif "_addanother" in request.POST:
                msg = _('The %(name)s "%(obj)s" was added successfully. You may add another %(name)s below.') % msg_dict
                self.message_user(request, msg, messages.SUCCESS)
                redirect_url = request.path
                redirect_url = add_preserved_filters({'preserved_filters': preserved_filters, 'opts': opts}, redirect_url)
                return HttpResponseRedirect(redirect_url)

            else:
                msg = _('The %(name)s "%(obj)s" was added successfully.') % msg_dict
                self.message_user(request, msg, messages.SUCCESS)
                return self.response_post_save_add(request, obj)

        def response_change(self, request, obj):
            """
            Determines the HttpResponse for the change_view stage.
            """

            if IS_POPUP_VAR in request.POST:
                to_field = request.POST.get(TO_FIELD_VAR)
                attr = str(to_field) if to_field else obj._meta.pk.attname
                # Retrieve the `object_id` from the resolved pattern arguments.
                value = request.resolver_match.args[0]
                new_value = obj.serializable_value(attr)
                return SimpleTemplateResponse('admin/popup_response.html', {
                    'action': 'change',
                    'value': escape(value),
                    'obj': escapejs(obj),
                    'new_value': escape(new_value),
                })

            opts = self.model._meta
            pk_value = obj._get_pk_val()
            preserved_filters = self.get_preserved_filters(request)

            msg_dict = {'name': force_text(opts.verbose_name), 'obj': force_text(obj)}
            if "_continue" in request.POST:
                msg = _('The %(name)s "%(obj)s" was changed successfully. You may edit it again below.') % msg_dict
                self.message_user(request, msg, messages.SUCCESS)
                redirect_url = request.path
                redirect_url = add_preserved_filters({'preserved_filters': preserved_filters, 'opts': opts}, redirect_url)
                return HttpResponseRedirect(redirect_url)

            elif "_saveasnew" in request.POST:
                msg = _('The %(name)s "%(obj)s" was added successfully. You may edit it again below.') % msg_dict
                self.message_user(request, msg, messages.SUCCESS)
                redirect_url = reverse('admin:%s_%s_change' %
                                       (opts.app_label, opts.model_name),
                                       args=(pk_value,),
                                       current_app=self.admin_site.name)
                redirect_url = add_preserved_filters({'preserved_filters': preserved_filters, 'opts': opts}, redirect_url)
                return HttpResponseRedirect(redirect_url)

            elif "_addanother" in request.POST:
                msg = _('The %(name)s "%(obj)s" was changed successfully. You may add another %(name)s below.') % msg_dict
                self.message_user(request, msg, messages.SUCCESS)
                redirect_url = reverse('admin:%s_%s_add' %
                                       (opts.app_label, opts.model_name),
                                       current_app=self.admin_site.name)
                redirect_url = add_preserved_filters({'preserved_filters': preserved_filters, 'opts': opts}, redirect_url)
                return HttpResponseRedirect(redirect_url)

            else:
                msg = _('The %(name)s "%(obj)s" was changed successfully.') % msg_dict
                self.message_user(request, msg, messages.SUCCESS)
                return self.response_post_save_change(request, obj)

        def response_post_save_add(self, request, obj):
            """
            Figure out where to redirect after the 'Save' button has been pressed
            when adding a new object.
            """
            opts = self.model._meta
            if self.has_change_permission(request, None):
                post_url = reverse('admin:%s_%s_changelist' %
                                   (opts.app_label, opts.model_name),
                                   current_app=self.admin_site.name)
                preserved_filters = self.get_preserved_filters(request)
                post_url = add_preserved_filters({'preserved_filters': preserved_filters, 'opts': opts}, post_url)
            else:
                post_url = reverse('admin:index',
                                   current_app=self.admin_site.name)
            return HttpResponseRedirect(post_url)

        def response_post_save_change(self, request, obj):
            """
            Figure out where to redirect after the 'Save' button has been pressed
            when editing an existing object.
            """
            opts = self.model._meta

            if self.has_change_permission(request, None):
                post_url = reverse('admin:%s_%s_changelist' %
                                   (opts.app_label, opts.model_name),
                                   current_app=self.admin_site.name)
                preserved_filters = self.get_preserved_filters(request)
                post_url = add_preserved_filters({'preserved_filters': preserved_filters, 'opts': opts}, post_url)
            else:
                post_url = reverse('admin:index',
                                   current_app=self.admin_site.name)
            return HttpResponseRedirect(post_url)

        def response_action(self, request, queryset):
            """
            Handle an admin action. This is called if a request is POSTed to the
            changelist; it returns an HttpResponse if the action was handled, and
            None otherwise.
            """

            # There can be multiple action forms on the page (at the top
            # and bottom of the change list, for example). Get the action
            # whose button was pushed.
            try:
                action_index = int(request.POST.get('index', 0))
            except ValueError:
                action_index = 0

            # Construct the action form.
            data = request.POST.copy()
            data.pop(helpers.ACTION_CHECKBOX_NAME, None)
            data.pop("index", None)

            # Use the action whose button was pushed
            try:
                data.update({'action': data.getlist('action')[action_index]})
            except IndexError:
                # If we didn't get an action from the chosen form that's invalid
                # POST data, so by deleting action it'll fail the validation check
                # below. So no need to do anything here
                pass

            action_form = self.action_form(data, auto_id=None)
            action_form.fields['action'].choices = self.get_action_choices(request)

            # If the form's valid we can handle the action.
            if action_form.is_valid():
                action = action_form.cleaned_data['action']
                select_across = action_form.cleaned_data['select_across']
                func = self.get_actions(request)[action][0]

                # Get the list of selected PKs. If nothing's selected, we can't
                # perform an action on it, so bail. Except we want to perform
                # the action explicitly on all objects.
                selected = request.POST.getlist(helpers.ACTION_CHECKBOX_NAME)
                if not selected and not select_across:
                    # Reminder that something needs to be selected or nothing will happen
                    msg = _("Items must be selected in order to perform "
                            "actions on them. No items have been changed.")
                    self.message_user(request, msg, messages.WARNING)
                    return None

                if not select_across:
                    # Perform the action only on the selected objects
                    queryset = queryset.filter(pk__in=selected)

                response = func(self, request, queryset)

                # Actions may return an HttpResponse-like object, which will be
                # used as the response from the POST. If not, we'll be a good
                # little HTTP citizen and redirect back to the changelist page.
                if isinstance(response, HttpResponseBase):
                    return response
                else:
                    return HttpResponseRedirect(request.get_full_path())
            else:
                msg = _("No action selected.")
                self.message_user(request, msg, messages.WARNING)
                return None

        def response_delete(self, request, obj_display, obj_id):
            """
            Determines the HttpResponse for the delete_view stage.
            """

            opts = self.model._meta

            if IS_POPUP_VAR in request.POST:
                return SimpleTemplateResponse('admin/popup_response.html', {
                    'action': 'delete',
                    'value': escape(obj_id),
                })

            self.message_user(request,
                _('The %(name)s "%(obj)s" was deleted successfully.') % {
                    'name': force_text(opts.verbose_name),
                    'obj': force_text(obj_display),
                }, messages.SUCCESS)

            if self.has_change_permission(request, None):
                post_url = reverse('admin:%s_%s_changelist' %
                                   (opts.app_label, opts.model_name),
                                   current_app=self.admin_site.name)
                preserved_filters = self.get_preserved_filters(request)
                post_url = add_preserved_filters(
                    {'preserved_filters': preserved_filters, 'opts': opts}, post_url
                )
            else:
                post_url = reverse('admin:index',
                                   current_app=self.admin_site.name)
            return HttpResponseRedirect(post_url)

        def render_delete_form(self, request, context):
            opts = self.model._meta
            app_label = opts.app_label

            request.current_app = self.admin_site.name
            context.update(
                to_field_var=TO_FIELD_VAR,
                is_popup_var=IS_POPUP_VAR,
            )

            return TemplateResponse(request,
                self.delete_confirmation_template or [
                    "admin/{}/{}/delete_confirmation.html".format(app_label, opts.model_name),
                    "admin/{}/delete_confirmation.html".format(app_label),
                    "admin/delete_confirmation.html"
                ], context)

        def get_inline_formsets(self, request, formsets, inline_instances,
                                obj=None):
            inline_admin_formsets = []
            for inline, formset in zip(inline_instances, formsets):
                fieldsets = list(inline.get_fieldsets(request, obj))
                readonly = list(inline.get_readonly_fields(request, obj))
                prepopulated = dict(inline.get_prepopulated_fields(request, obj))
                inline_admin_formset = helpers.InlineAdminFormSet(inline, formset,
                    fieldsets, prepopulated, readonly, model_admin=self)
                inline_admin_formsets.append(inline_admin_formset)
            return inline_admin_formsets

        def get_changeform_initial_data(self, request):
            """
            Get the initial form data.
            Unless overridden, this populates from the GET params.
            """
            initial = dict(request.GET.items())
            for k in initial:
                try:
                    f = self.model._meta.get_field(k)
                except FieldDoesNotExist:
                    continue
                # We have to special-case M2Ms as a list of comma-separated PKs.
                if isinstance(f, models.ManyToManyField):
                    initial[k] = initial[k].split(",")
            return initial

        @csrf_protect_m
        @transaction.atomic
        def changeform_view(self, request, object_id=None, form_url='', extra_context=None):

            to_field = request.POST.get(TO_FIELD_VAR, request.GET.get(TO_FIELD_VAR))
            if to_field and not self.to_field_allowed(request, to_field):
                raise DisallowedModelAdminToField("The field %s cannot be referenced." % to_field)

            model = self.model
            opts = model._meta
            add = object_id is None

            if add:
                if not self.has_add_permission(request):
                    raise PermissionDenied
                obj = None

            else:
                obj = self.get_object(request, unquote(object_id), to_field)

                if not self.has_change_permission(request, obj):
                    raise PermissionDenied

                if obj is None:
                    raise Http404(_('%(name)s object with primary key %(key)r does not exist.') % {
                        'name': force_text(opts.verbose_name), 'key': escape(object_id)})

                if request.method == 'POST' and "_saveasnew" in request.POST:
                    return self.add_view(request, form_url=reverse('admin:%s_%s_add' % (
                        opts.app_label, opts.model_name),
                        current_app=self.admin_site.name))

            ModelForm = self.get_form(request, obj)
            if request.method == 'POST':
                form = ModelForm(request.POST, request.FILES, instance=obj)
                if form.is_valid():
                    form_validated = True
                    new_object = self.save_form(request, form, change=not add)
                else:
                    form_validated = False
                    new_object = form.instance
                formsets, inline_instances = self._create_formsets(request, new_object, change=not add)
                if all_valid(formsets) and form_validated:
                    self.save_model(request, new_object, form, not add)
                    self.save_related(request, form, formsets, not add)
                    if add:
                        self.log_addition(request, new_object)
                        return self.response_add(request, new_object)
                    else:
                        change_message = self.construct_change_message(request, form, formsets)
                        self.log_change(request, new_object, change_message)
                        return self.response_change(request, new_object)
            else:
                if add:
                    initial = self.get_changeform_initial_data(request)
                    form = ModelForm(initial=initial)
                    formsets, inline_instances = self._create_formsets(request, self.model(), change=False)
                else:
                    form = ModelForm(instance=obj)
                    formsets, inline_instances = self._create_formsets(request, obj, change=True)

            adminForm = helpers.AdminForm(
                form,
                list(self.get_fieldsets(request, obj)),
                self.get_prepopulated_fields(request, obj),
                self.get_readonly_fields(request, obj),
                model_admin=self)
            media = self.media + adminForm.media

            inline_formsets = self.get_inline_formsets(request, formsets, inline_instances, obj)
            for inline_formset in inline_formsets:
                media = media + inline_formset.media

            context = dict(self.admin_site.each_context(request),
                title=(_('Add %s') if add else _('Change %s')) % force_text(opts.verbose_name),
                adminform=adminForm,
                object_id=object_id,
                original=obj,
                is_popup=(IS_POPUP_VAR in request.POST or
                          IS_POPUP_VAR in request.GET),
                to_field=to_field,
                media=media,
                inline_admin_formsets=inline_formsets,
                errors=helpers.AdminErrorList(form, formsets),
                preserved_filters=self.get_preserved_filters(request),
            )

            context.update(extra_context or {})

            return self.render_change_form(request, context, add=add, change=not add, obj=obj, form_url=form_url)

        def add_view(self, request, form_url='', extra_context=None):
            return self.changeform_view(request, None, form_url, extra_context)

        def change_view(self, request, object_id, form_url='', extra_context=None):
            return self.changeform_view(request, object_id, form_url, extra_context)

        @csrf_protect_m
        def changelist_view(self, request, extra_context=None):
            """
            The 'change list' admin view for this model.
            """
            from django.contrib.admin.views.main import ERROR_FLAG
            opts = self.model._meta
            app_label = opts.app_label
            if not self.has_change_permission(request, None):
                raise PermissionDenied

            list_display = self.get_list_display(request)
            list_display_links = self.get_list_display_links(request, list_display)
            list_filter = self.get_list_filter(request)
            search_fields = self.get_search_fields(request)

            # Check actions to see if any are available on this changelist
            actions = self.get_actions(request)
            if actions:
                # Add the action checkboxes if there are any actions available.
                list_display = ['action_checkbox'] + list(list_display)

            ChangeList = self.get_changelist(request)
            try:
                cl = ChangeList(request, self.model, list_display,
                    list_display_links, list_filter, self.date_hierarchy,
                    search_fields, self.list_select_related, self.list_per_page,
                    self.list_max_show_all, self.list_editable, self)

            except IncorrectLookupParameters:
                # Wacky lookup parameters were given, so redirect to the main
                # changelist page, without parameters, and pass an 'invalid=1'
                # parameter via the query string. If wacky parameters were given
                # and the 'invalid=1' parameter was already in the query string,
                # something is screwed up with the database, so display an error
                # page.
                if ERROR_FLAG in request.GET.keys():
                    return SimpleTemplateResponse('admin/invalid_setup.html', {
                        'title': _('Database error'),
                    })
                return HttpResponseRedirect(request.path + '?' + ERROR_FLAG + '=1')

            # If the request was POSTed, this might be a bulk action or a bulk
            # edit. Try to look up an action or confirmation first, but if this
            # isn't an action the POST will fall through to the bulk edit check,
            # below.
            action_failed = False
            selected = request.POST.getlist(helpers.ACTION_CHECKBOX_NAME)

            # Actions with no confirmation
            if (actions and request.method == 'POST' and
                    'index' in request.POST and '_save' not in request.POST):
                if selected:
                    response = self.response_action(request, queryset=cl.get_queryset(request))
                    if response:
                        return response
                    else:
                        action_failed = True
                else:
                    msg = _("Items must be selected in order to perform "
                            "actions on them. No items have been changed.")
                    self.message_user(request, msg, messages.WARNING)
                    action_failed = True

            # Actions with confirmation
            if (actions and request.method == 'POST' and
                    helpers.ACTION_CHECKBOX_NAME in request.POST and
                    'index' not in request.POST and '_save' not in request.POST):
                if selected:
                    response = self.response_action(request, queryset=cl.get_queryset(request))
                    if response:
                        return response
                    else:
                        action_failed = True

            # If we're allowing changelist editing, we need to construct a formset
            # for the changelist given all the fields to be edited. Then we'll
            # use the formset to validate/process POSTed data.
            formset = cl.formset = None

            # Handle POSTed bulk-edit data.
            if (request.method == "POST" and cl.list_editable and
                    '_save' in request.POST and not action_failed):
                FormSet = self.get_changelist_formset(request)
                formset = cl.formset = FormSet(request.POST, request.FILES, queryset=cl.result_list)
                if formset.is_valid():
                    changecount = 0
                    for form in formset.forms:
                        if form.has_changed():
                            obj = self.save_form(request, form, change=True)
                            self.save_model(request, obj, form, change=True)
                            self.save_related(request, form, formsets=[], change=True)
                            change_msg = self.construct_change_message(request, form, None)
                            self.log_change(request, obj, change_msg)
                            changecount += 1

                    if changecount:
                        if changecount == 1:
                            name = force_text(opts.verbose_name)
                        else:
                            name = force_text(opts.verbose_name_plural)
                        msg = ungettext("%(count)s %(name)s was changed successfully.",
                                        "%(count)s %(name)s were changed successfully.",
                                        changecount) % {'count': changecount,
                                                        'name': name,
                                                        'obj': force_text(obj)}
                        self.message_user(request, msg, messages.SUCCESS)

                    return HttpResponseRedirect(request.get_full_path())

            # Handle GET -- construct a formset for display.
            elif cl.list_editable:
                FormSet = self.get_changelist_formset(request)
                formset = cl.formset = FormSet(queryset=cl.result_list)

            # Build the list of media to be used by the formset.
            if formset:
                media = self.media + formset.media
            else:
                media = self.media

            # Build the action form and populate it with available actions.
            if actions:
                action_form = self.action_form(auto_id=None)
                action_form.fields['action'].choices = self.get_action_choices(request)
            else:
                action_form = None

            selection_note_all = ungettext('%(total_count)s selected',
                'All %(total_count)s selected', cl.result_count)

            context = dict(
                self.admin_site.each_context(request),
                module_name=force_text(opts.verbose_name_plural),
                selection_note=_('0 of %(cnt)s selected') % {'cnt': len(cl.result_list)},
                selection_note_all=selection_note_all % {'total_count': cl.result_count},
                title=cl.title,
                is_popup=cl.is_popup,
                to_field=cl.to_field,
                cl=cl,
                media=media,
                has_add_permission=self.has_add_permission(request),
                opts=cl.opts,
                action_form=action_form,
                actions_on_top=self.actions_on_top,
                actions_on_bottom=self.actions_on_bottom,
                actions_selection_counter=self.actions_selection_counter,
                preserved_filters=self.get_preserved_filters(request),
            )
            context.update(extra_context or {})

            request.current_app = self.admin_site.name

            return TemplateResponse(request, self.change_list_template or [
                'admin/%s/%s/change_list.html' % (app_label, opts.model_name),
                'admin/%s/change_list.html' % app_label,
                'admin/change_list.html'
            ], context)

        @csrf_protect_m
        @transaction.atomic
        def delete_view(self, request, object_id, extra_context=None):
            "The 'delete' admin view for this model."
            opts = self.model._meta
            app_label = opts.app_label

            to_field = request.POST.get(TO_FIELD_VAR, request.GET.get(TO_FIELD_VAR))
            if to_field and not self.to_field_allowed(request, to_field):
                raise DisallowedModelAdminToField("The field %s cannot be referenced." % to_field)

            obj = self.get_object(request, unquote(object_id), to_field)

            if not self.has_delete_permission(request, obj):
                raise PermissionDenied

            if obj is None:
                raise Http404(
                    _('%(name)s object with primary key %(key)r does not exist.') %
                    {'name': force_text(opts.verbose_name), 'key': escape(object_id)}
                )

            using = router.db_for_write(self.model)

            # Populate deleted_objects, a data structure of all related objects that
            # will also be deleted.
            (deleted_objects, model_count, perms_needed, protected) = get_deleted_objects(
                [obj], opts, request.user, self.admin_site, using)

            if request.POST:  # The user has already confirmed the deletion.
                if perms_needed:
                    raise PermissionDenied
                obj_display = force_text(obj)
                attr = str(to_field) if to_field else opts.pk.attname
                obj_id = obj.serializable_value(attr)
                self.log_deletion(request, obj, obj_display)
                self.delete_model(request, obj)

                return self.response_delete(request, obj_display, obj_id)

            object_name = force_text(opts.verbose_name)

            if perms_needed or protected:
                title = _("Cannot delete %(name)s") % {"name": object_name}
            else:
                title = _("Are you sure?")

            context = dict(
                self.admin_site.each_context(request),
                title=title,
                object_name=object_name,
                object=obj,
                deleted_objects=deleted_objects,
                model_count=dict(model_count).items(),
                perms_lacking=perms_needed,
                protected=protected,
                opts=opts,
                app_label=app_label,
                preserved_filters=self.get_preserved_filters(request),
                is_popup=(IS_POPUP_VAR in request.POST or
                          IS_POPUP_VAR in request.GET),
                to_field=to_field,
            )
            context.update(extra_context or {})

            return self.render_delete_form(request, context)

        def history_view(self, request, object_id, extra_context=None):
            "The 'history' admin view for this model."
            from django.contrib.admin.models import LogEntry
            # First check if the user can see this history.
            model = self.model
            obj = self.get_object(request, unquote(object_id))
            if obj is None:
                raise Http404(_('%(name)s object with primary key %(key)r does not exist.') % {
                    'name': force_text(model._meta.verbose_name),
                    'key': escape(object_id),
                })

            if not self.has_change_permission(request, obj):
                raise PermissionDenied

            # Then get the history for this object.
            opts = model._meta
            app_label = opts.app_label
            action_list = LogEntry.objects.filter(
                object_id=unquote(object_id),
                content_type=get_content_type_for_model(model)
            ).select_related().order_by('action_time')

            context = dict(self.admin_site.each_context(request),
                title=_('Change history: %s') % force_text(obj),
                action_list=action_list,
                module_name=capfirst(force_text(opts.verbose_name_plural)),
                object=obj,
                opts=opts,
                preserved_filters=self.get_preserved_filters(request),
            )
            context.update(extra_context or {})

            request.current_app = self.admin_site.name

            return TemplateResponse(request, self.object_history_template or [
                "admin/%s/%s/object_history.html" % (app_label, opts.model_name),
                "admin/%s/object_history.html" % app_label,
                "admin/object_history.html"
            ], context)

        def _create_formsets(self, request, obj, change):
            "Helper function to generate formsets for add/change_view."
            formsets = []
            inline_instances = []
            prefixes = {}
            get_formsets_args = [request]
            if change:
                get_formsets_args.append(obj)
            for FormSet, inline in self.get_formsets_with_inlines(*get_formsets_args):
                prefix = FormSet.get_default_prefix()
                prefixes[prefix] = prefixes.get(prefix, 0) + 1
                if prefixes[prefix] != 1 or not prefix:
                    prefix = "%s-%s" % (prefix, prefixes[prefix])
                formset_params = {
                    'instance': obj,
                    'prefix': prefix,
                    'queryset': inline.get_queryset(request),
                }
                if request.method == 'POST':
                    formset_params.update({
                        'data': request.POST,
                        'files': request.FILES,
                        'save_as_new': '_saveasnew' in request.POST
                    })
                formsets.append(FormSet(**formset_params))
                inline_instances.append(inline)
            return formsets, inline_instances

    class InlineModelAdmin(BaseModelAdmin):
        """
        Options for inline editing of ``model`` instances.

        Provide ``fk_name`` to specify the attribute name of the ``ForeignKey``
        from ``model`` to its parent. This is required if ``model`` has more than
        one ``ForeignKey`` to its parent.
        """
        model = None
        fk_name = None
        formset = BaseInlineFormSet
        extra = 3
        min_num = None
        max_num = None
        template = None
        verbose_name = None
        verbose_name_plural = None
        can_delete = True
        show_change_link = False

        checks_class = InlineModelAdminChecks

        def __init__(self, parent_model, admin_site):
            self.admin_site = admin_site
            self.parent_model = parent_model
            self.opts = self.model._meta
            self.has_registered_model = admin_site.is_registered(self.model)
            super(InlineModelAdmin, self).__init__()
            if self.verbose_name is None:
                self.verbose_name = self.model._meta.verbose_name
            if self.verbose_name_plural is None:
                self.verbose_name_plural = self.model._meta.verbose_name_plural

        @property
        def media(self):
            extra = '' if settings.DEBUG else '.min'
            js = ['jquery%s.js' % extra, 'jquery.init.js', 'inlines%s.js' % extra]
            if self.prepopulated_fields:
                js.extend(['urlify.js', 'prepopulate%s.js' % extra])
            if self.filter_vertical or self.filter_horizontal:
                js.extend(['SelectBox.js', 'SelectFilter2.js'])
            return forms.Media(js=[static('admin/js/%s' % url) for url in js])

        def get_extra(self, request, obj=None, **kwargs):
            """Hook for customizing the number of extra inline forms."""
            return self.extra

        def get_min_num(self, request, obj=None, **kwargs):
            """Hook for customizing the min number of inline forms."""
            return self.min_num

        def get_max_num(self, request, obj=None, **kwargs):
            """Hook for customizing the max number of extra inline forms."""
            return self.max_num

        def get_formset(self, request, obj=None, **kwargs):
            """Returns a BaseInlineFormSet class for use in admin add/change views."""
            if 'fields' in kwargs:
                fields = kwargs.pop('fields')
            else:
                fields = flatten_fieldsets(self.get_fieldsets(request, obj))
            if self.exclude is None:
                exclude = []
            else:
                exclude = list(self.exclude)
            exclude.extend(self.get_readonly_fields(request, obj))
            if self.exclude is None and hasattr(self.form, '_meta') and self.form._meta.exclude:
                # Take the custom ModelForm's Meta.exclude into account only if the
                # InlineModelAdmin doesn't define its own.
                exclude.extend(self.form._meta.exclude)
            # If exclude is an empty list we use None, since that's the actual
            # default.
            exclude = exclude or None
            can_delete = self.can_delete and self.has_delete_permission(request, obj)
            defaults = {
                "form": self.form,
                "formset": self.formset,
                "fk_name": self.fk_name,
                "fields": fields,
                "exclude": exclude,
                "formfield_callback": partial(self.formfield_for_dbfield, request=request),
                "extra": self.get_extra(request, obj, **kwargs),
                "min_num": self.get_min_num(request, obj, **kwargs),
                "max_num": self.get_max_num(request, obj, **kwargs),
                "can_delete": can_delete,
            }

            defaults.update(kwargs)
            base_model_form = defaults['form']

            class DeleteProtectedModelForm(base_model_form):
                def hand_clean_DELETE(self):
                    """
                    We don't validate the 'DELETE' field itself because on
                    templates it's not rendered using the field information, but
                    just using a generic "deletion_field" of the InlineModelAdmin.
                    """
                    if self.cleaned_data.get(DELETION_FIELD_NAME, False):
                        using = router.db_for_write(self._meta.model)
                        collector = NestedObjects(using=using)
                        if self.instance.pk is None:
                            return
                        collector.collect([self.instance])
                        if collector.protected:
                            objs = []
                            for p in collector.protected:
                                objs.append(
                                    # Translators: Model verbose name and instance representation,
                                    # suitable to be an item in a list.
                                    _('%(class_name)s %(instance)s') % {
                                        'class_name': p._meta.verbose_name,
                                        'instance': p}
                                )
                            params = {'class_name': self._meta.model._meta.verbose_name,
                                      'instance': self.instance,
                                      'related_objects': get_text_list(objs, _('and'))}
                            msg = _("Deleting %(class_name)s %(instance)s would require "
                                    "deleting the following protected related objects: "
                                    "%(related_objects)s")
                            raise ValidationError(msg, code='deleting_protected', params=params)

                def is_valid(self):
                    result = super(DeleteProtectedModelForm, self).is_valid()
                    self.hand_clean_DELETE()
                    return result

            defaults['form'] = DeleteProtectedModelForm

            if defaults['fields'] is None and not modelform_defines_fields(defaults['form']):
                defaults['fields'] = forms.ALL_FIELDS

            return inlineformset_factory(self.parent_model, self.model, **defaults)

        def get_fields(self, request, obj=None):
            if self.fields:
                return self.fields
            form = self.get_formset(request, obj, fields=None).form
            return list(form.base_fields) + list(self.get_readonly_fields(request, obj))

        def get_queryset(self, request):
            queryset = super(InlineModelAdmin, self).get_queryset(request)
            if not self.has_change_permission(request):
                queryset = queryset.none()
            return queryset

        def has_add_permission(self, request):
            if self.opts.auto_created:
                # We're checking the rights to an auto-created intermediate model,
                # which doesn't have its own individual permissions. The user needs
                # to have the change permission for the related model in order to
                # be able to do anything with the intermediate model.
                return self.has_change_permission(request)
            return super(InlineModelAdmin, self).has_add_permission(request)

        def has_change_permission(self, request, obj=None):
            opts = self.opts
            if opts.auto_created:
                # The model was auto-created as intermediary for a
                # ManyToMany-relationship, find the target model
                for field in opts.fields:
                    if field.rel and field.rel.to != self.parent_model:
                        opts = field.rel.to._meta
                        break
            codename = get_permission_codename('change', opts)
            return request.user.has_perm("%s.%s" % (opts.app_label, codename))

        def has_delete_permission(self, request, obj=None):
            if self.opts.auto_created:
                # We're checking the rights to an auto-created intermediate model,
                # which doesn't have its own individual permissions. The user needs
                # to have the change permission for the related model in order to
                # be able to do anything with the intermediate model.
                return self.has_change_permission(request, obj)
            return super(InlineModelAdmin, self).has_delete_permission(request, obj)

    class StackedInline(InlineModelAdmin):
        template = 'admin/edit_inline/stacked.html'

    class TabularInline(InlineModelAdmin):
        template = 'admin/edit_inline/tabular.html'