Debian Codegraph @

django/contrib/admin/options.py

raw
1 import copy
2 import enum
3 import json
4 import re
5 import warnings
6 from functools import partial, update_wrapper
7 from urllib.parse import parse_qsl
8 from urllib.parse import quote as urlquote
9 from urllib.parse import urlsplit
10
11 from django import forms
12 from django.conf import settings
13 from django.contrib import messages
14 from django.contrib.admin import helpers, widgets
15 from django.contrib.admin.checks import (
16 BaseModelAdminChecks,
17 InlineModelAdminChecks,
18 ModelAdminChecks,
19 )
20 from django.contrib.admin.exceptions import DisallowedModelAdminToField, NotRegistered
21 from django.contrib.admin.templatetags.admin_urls import add_preserved_filters
22 from django.contrib.admin.utils import (
23 NestedObjects,
24 construct_change_message,
25 flatten_fieldsets,
26 get_deleted_objects,
27 lookup_spawns_duplicates,
28 model_format_dict,
29 model_ngettext,
30 quote,
31 unquote,
32 )
33 from django.contrib.admin.widgets import AutocompleteSelect, AutocompleteSelectMultiple
34 from django.contrib.auth import get_permission_codename
35 from django.core.exceptions import (
36 BadRequest,
37 FieldDoesNotExist,
38 FieldError,
39 PermissionDenied,
40 ValidationError,
41 )
42 from django.core.paginator import Paginator
43 from django.db import models, router, transaction
44 from django.db.models.constants import LOOKUP_SEP
45 from django.db.models.functions import Cast
46 from django.forms.formsets import DELETION_FIELD_NAME, all_valid
47 from django.forms.models import (
48 BaseInlineFormSet,
49 inlineformset_factory,
50 modelform_defines_fields,
51 modelform_factory,
52 modelformset_factory,
53 )
54 from django.forms.widgets import CheckboxSelectMultiple, SelectMultiple
55 from django.http import HttpResponseRedirect
56 from django.http.response import HttpResponseBase
57 from django.template.response import SimpleTemplateResponse, TemplateResponse
58 from django.urls import reverse
59 from django.utils.decorators import method_decorator
60 from django.utils.deprecation import RemovedInDjango60Warning
61 from django.utils.html import format_html
62 from django.utils.http import urlencode
63 from django.utils.safestring import mark_safe
64 from django.utils.text import (
65 capfirst,
66 format_lazy,
67 get_text_list,
68 smart_split,
69 unescape_string_literal,
70 )
71 from django.utils.translation import gettext as _
72 from django.utils.translation import ngettext
73 from django.views.decorators.csrf import csrf_protect
74 from django.views.generic import RedirectView
75
76 IS_POPUP_VAR = "_popup"
77 TO_FIELD_VAR = "_to_field"
78 IS_FACETS_VAR = "_facets"
79
80
81 class ShowFacets(enum.Enum):
82 NEVER = "NEVER"
83 ALLOW = "ALLOW"
84 ALWAYS = "ALWAYS"
85
86
87 HORIZONTAL, VERTICAL = 1, 2
88
89
90 def get_content_type_for_model(obj):
91 # Since this module gets imported in the application's root package,
92 # it cannot import models from other applications at the module level.
93 from django.contrib.contenttypes.models import ContentType
94
95 return ContentType.objects.get_for_model(obj, for_concrete_model=False)
96
97
98 def get_ul_class(radio_style):
99 return "radiolist" if radio_style == VERTICAL else "radiolist inline"
100
101
102 class IncorrectLookupParameters(Exception):
103 pass
104
105
106 # Defaults for formfield_overrides. ModelAdmin subclasses can change this
107 # by adding to ModelAdmin.formfield_overrides.
108
109 FORMFIELD_FOR_DBFIELD_DEFAULTS = {
110 models.DateTimeField: {
111 "form_class": forms.SplitDateTimeField,
112 "widget": widgets.AdminSplitDateTime,
113 },
114 models.DateField: {"widget": widgets.AdminDateWidget},
115 models.TimeField: {"widget": widgets.AdminTimeWidget},
116 models.TextField: {"widget": widgets.AdminTextareaWidget},
117 models.URLField: {"widget": widgets.AdminURLFieldWidget},
118 models.IntegerField: {"widget": widgets.AdminIntegerFieldWidget},
119 models.BigIntegerField: {"widget": widgets.AdminBigIntegerFieldWidget},
120 models.CharField: {"widget": widgets.AdminTextInputWidget},
121 models.ImageField: {"widget": widgets.AdminFileWidget},
122 models.FileField: {"widget": widgets.AdminFileWidget},
123 models.EmailField: {"widget": widgets.AdminEmailInputWidget},
124 models.UUIDField: {"widget": widgets.AdminUUIDInputWidget},
125 }
126
127 csrf_protect_m = method_decorator(csrf_protect)
128
129
130 class BaseModelAdmin(metaclass=forms.MediaDefiningClass):
131 """Functionality common to both ModelAdmin and InlineAdmin."""
132
133 autocomplete_fields = ()
134 raw_id_fields = ()
135 fields = None
136 exclude = None
137 fieldsets = None
138 form = forms.ModelForm
139 filter_vertical = ()
140 filter_horizontal = ()
141 radio_fields = {}
142 prepopulated_fields = {}
143 formfield_overrides = {}
144 readonly_fields = ()
145 ordering = None
146 sortable_by = None
147 view_on_site = True
148 show_full_result_count = True
149 checks_class = BaseModelAdminChecks
150
151 def check(self, **kwargs):
152 return self.checks_class().check(self, **kwargs)
153
154 def __init__(self):
155 # Merge FORMFIELD_FOR_DBFIELD_DEFAULTS with the formfield_overrides
156 # rather than simply overwriting.
157 overrides = copy.deepcopy(FORMFIELD_FOR_DBFIELD_DEFAULTS)
158 for k, v in self.formfield_overrides.items():
159 overrides.setdefault(k, {}).update(v)
160 self.formfield_overrides = overrides
161
162 def formfield_for_dbfield(self, db_field, request, **kwargs):
163 """
164 Hook for specifying the form Field instance for a given database Field
165 instance.
166
167 If kwargs are given, they're passed to the form Field's constructor.
168 """
169 # If the field specifies choices, we don't need to look for special
170 # admin widgets - we just need to use a select widget of some kind.
171 if db_field.choices:
172 return self.formfield_for_choice_field(db_field, request, **kwargs)
173
174 # ForeignKey or ManyToManyFields
175 if isinstance(db_field, (models.ForeignKey, models.ManyToManyField)):
176 # Combine the field kwargs with any options for formfield_overrides.
177 # Make sure the passed in **kwargs override anything in
178 # formfield_overrides because **kwargs is more specific, and should
179 # always win.
180 if db_field.__class__ in self.formfield_overrides:
181 kwargs = {**self.formfield_overrides[db_field.__class__], **kwargs}
182
183 # Get the correct formfield.
184 if isinstance(db_field, models.ForeignKey):
185 formfield = self.formfield_for_foreignkey(db_field, request, **kwargs)
186 elif isinstance(db_field, models.ManyToManyField):
187 formfield = self.formfield_for_manytomany(db_field, request, **kwargs)
188
189 # For non-raw_id fields, wrap the widget with a wrapper that adds
190 # extra HTML -- the "add other" interface -- to the end of the
191 # rendered output. formfield can be None if it came from a
192 # OneToOneField with parent_link=True or a M2M intermediary.
193 if formfield and db_field.name not in self.raw_id_fields:
194 try:
195 related_modeladmin = self.admin_site.get_model_admin(
196 db_field.remote_field.model
197 )
198 except NotRegistered:
199 wrapper_kwargs = {}
200 else:
201 wrapper_kwargs = {
202 "can_add_related": related_modeladmin.has_add_permission(
203 request
204 ),
205 "can_change_related": related_modeladmin.has_change_permission(
206 request
207 ),
208 "can_delete_related": related_modeladmin.has_delete_permission(
209 request
210 ),
211 "can_view_related": related_modeladmin.has_view_permission(
212 request
213 ),
214 }
215 formfield.widget = widgets.RelatedFieldWidgetWrapper(
216 formfield.widget,
217 db_field.remote_field,
218 self.admin_site,
219 **wrapper_kwargs,
220 )
221
222 return formfield
223
224 # If we've got overrides for the formfield defined, use 'em. **kwargs
225 # passed to formfield_for_dbfield override the defaults.
226 for klass in db_field.__class__.mro():
227 if klass in self.formfield_overrides:
228 kwargs = {**copy.deepcopy(self.formfield_overrides[klass]), **kwargs}
229 return db_field.formfield(**kwargs)
230
231 # For any other type of field, just call its formfield() method.
232 return db_field.formfield(**kwargs)
233
234 def formfield_for_choice_field(self, db_field, request, **kwargs):
235 """
236 Get a form Field for a database Field that has declared choices.
237 """
238 # If the field is named as a radio_field, use a RadioSelect
239 if db_field.name in self.radio_fields:
240 # Avoid stomping on custom widget/choices arguments.
241 if "widget" not in kwargs:
242 kwargs["widget"] = widgets.AdminRadioSelect(
243 attrs={
244 "class": get_ul_class(self.radio_fields[db_field.name]),
245 }
246 )
247 if "choices" not in kwargs:
248 kwargs["choices"] = db_field.get_choices(
249 include_blank=db_field.blank, blank_choice=[("", _("None"))]
250 )
251 return db_field.formfield(**kwargs)
252
253 def get_field_queryset(self, db, db_field, request):
254 """
255 If the ModelAdmin specifies ordering, the queryset should respect that
256 ordering. Otherwise don't specify the queryset, let the field decide
257 (return None in that case).
258 """
259 try:
260 related_admin = self.admin_site.get_model_admin(db_field.remote_field.model)
261 except NotRegistered:
262 return None
263 else:
264 ordering = related_admin.get_ordering(request)
265 if ordering is not None and ordering != ():
266 return db_field.remote_field.model._default_manager.using(db).order_by(
267 *ordering
268 )
269 return None
270
271 def formfield_for_foreignkey(self, db_field, request, **kwargs):
272 """
273 Get a form Field for a ForeignKey.
274 """
275 db = kwargs.get("using")
276
277 if "widget" not in kwargs:
278 if db_field.name in self.get_autocomplete_fields(request):
279 kwargs["widget"] = AutocompleteSelect(
280 db_field, self.admin_site, using=db
281 )
282 elif db_field.name in self.raw_id_fields:
283 kwargs["widget"] = widgets.ForeignKeyRawIdWidget(
284 db_field.remote_field, self.admin_site, using=db
285 )
286 elif db_field.name in self.radio_fields:
287 kwargs["widget"] = widgets.AdminRadioSelect(
288 attrs={
289 "class": get_ul_class(self.radio_fields[db_field.name]),
290 }
291 )
292 kwargs["empty_label"] = (
293 kwargs.get("empty_label", _("None")) if db_field.blank else None
294 )
295
296 if "queryset" not in kwargs:
297 queryset = self.get_field_queryset(db, db_field, request)
298 if queryset is not None:
299 kwargs["queryset"] = queryset
300
301 return db_field.formfield(**kwargs)
302
303 def formfield_for_manytomany(self, db_field, request, **kwargs):
304 """
305 Get a form Field for a ManyToManyField.
306 """
307 # If it uses an intermediary model that isn't auto created, don't show
308 # a field in admin.
309 if not db_field.remote_field.through._meta.auto_created:
310 return None
311 db = kwargs.get("using")
312
313 if "widget" not in kwargs:
314 autocomplete_fields = self.get_autocomplete_fields(request)
315 if db_field.name in autocomplete_fields:
316 kwargs["widget"] = AutocompleteSelectMultiple(
317 db_field,
318 self.admin_site,
319 using=db,
320 )
321 elif db_field.name in self.raw_id_fields:
322 kwargs["widget"] = widgets.ManyToManyRawIdWidget(
323 db_field.remote_field,
324 self.admin_site,
325 using=db,
326 )
327 elif db_field.name in [*self.filter_vertical, *self.filter_horizontal]:
328 kwargs["widget"] = widgets.FilteredSelectMultiple(
329 db_field.verbose_name, db_field.name in self.filter_vertical
330 )
331 if "queryset" not in kwargs:
332 queryset = self.get_field_queryset(db, db_field, request)
333 if queryset is not None:
334 kwargs["queryset"] = queryset
335
336 form_field = db_field.formfield(**kwargs)
337 if (
338 isinstance(form_field.widget, SelectMultiple)
339 and form_field.widget.allow_multiple_selected
340 and not isinstance(
341 form_field.widget, (CheckboxSelectMultiple, AutocompleteSelectMultiple)
342 )
343 ):
344 msg = _(
345 "Hold down “Control”, or “Command” on a Mac, to select more than one."
346 )
347 help_text = form_field.help_text
348 form_field.help_text = (
349 format_lazy("{} {}", help_text, msg) if help_text else msg
350 )
351 return form_field
352
353 def get_autocomplete_fields(self, request):
354 """
355 Return a list of ForeignKey and/or ManyToMany fields which should use
356 an autocomplete widget.
357 """
358 return self.autocomplete_fields
359
360 def get_view_on_site_url(self, obj=None):
361 if obj is None or not self.view_on_site:
362 return None
363
364 if callable(self.view_on_site):
365 return self.view_on_site(obj)
366 elif hasattr(obj, "get_absolute_url"):
367 # use the ContentType lookup if view_on_site is True
368 return reverse(
369 "admin:view_on_site",
370 kwargs={
371 "content_type_id": get_content_type_for_model(obj).pk,
372 "object_id": obj.pk,
373 },
374 current_app=self.admin_site.name,
375 )
376
377 def get_empty_value_display(self):
378 """
379 Return the empty_value_display set on ModelAdmin or AdminSite.
380 """
381 try:
382 return mark_safe(self.empty_value_display)
383 except AttributeError:
384 return mark_safe(self.admin_site.empty_value_display)
385
386 def get_exclude(self, request, obj=None):
387 """
388 Hook for specifying exclude.
389 """
390 return self.exclude
391
392 def get_fields(self, request, obj=None):
393 """
394 Hook for specifying fields.
395 """
396 if self.fields:
397 return self.fields
398 # _get_form_for_get_fields() is implemented in subclasses.
399 form = self._get_form_for_get_fields(request, obj)
400 return [*form.base_fields, *self.get_readonly_fields(request, obj)]
401
402 def get_fieldsets(self, request, obj=None):
403 """
404 Hook for specifying fieldsets.
405 """
406 if self.fieldsets:
407 return self.fieldsets
408 return [(None, {"fields": self.get_fields(request, obj)})]
409
410 def get_inlines(self, request, obj):
411 """Hook for specifying custom inlines."""
412 return self.inlines
413
414 def get_ordering(self, request):
415 """
416 Hook for specifying field ordering.
417 """
418 return self.ordering or () # otherwise we might try to *None, which is bad ;)
419
420 def get_readonly_fields(self, request, obj=None):
421 """
422 Hook for specifying custom readonly fields.
423 """
424 return self.readonly_fields
425
426 def get_prepopulated_fields(self, request, obj=None):
427 """
428 Hook for specifying custom prepopulated fields.
429 """
430 return self.prepopulated_fields
431
432 def get_queryset(self, request):
433 """
434 Return a QuerySet of all model instances that can be edited by the
435 admin site. This is used by changelist_view.
436 """
437 qs = self.model._default_manager.get_queryset()
438 # TODO: this should be handled by some parameter to the ChangeList.
439 ordering = self.get_ordering(request)
440 if ordering:
441 qs = qs.order_by(*ordering)
442 return qs
443
444 def get_sortable_by(self, request):
445 """Hook for specifying which fields can be sorted in the changelist."""
446 return (
447 self.sortable_by
448 if self.sortable_by is not None
449 else self.get_list_display(request)
450 )
451
452 # RemovedInDjango60Warning: when the deprecation ends, replace with:
453 # def lookup_allowed(self, lookup, value, request):
454 def lookup_allowed(self, lookup, value, request=None):
455 from django.contrib.admin.filters import SimpleListFilter
456
457 model = self.model
458 # Check FKey lookups that are allowed, so that popups produced by
459 # ForeignKeyRawIdWidget, on the basis of ForeignKey.limit_choices_to,
460 # are allowed to work.
461 for fk_lookup in model._meta.related_fkey_lookups:
462 # As ``limit_choices_to`` can be a callable, invoke it here.
463 if callable(fk_lookup):
464 fk_lookup = fk_lookup()
465 if (lookup, value) in widgets.url_params_from_lookup_dict(
466 fk_lookup
467 ).items():
468 return True
469
470 relation_parts = []
471 prev_field = None
472 parts = lookup.split(LOOKUP_SEP)
473 for part in parts:
474 try:
475 field = model._meta.get_field(part)
476 except FieldDoesNotExist:
477 # Lookups on nonexistent fields are ok, since they're ignored
478 # later.
479 break
480 if not prev_field or (
481 prev_field.is_relation
482 and field not in model._meta.parents.values()
483 and field is not model._meta.auto_field
484 and (
485 model._meta.auto_field is None
486 or part not in getattr(prev_field, "to_fields", [])
487 )
488 and (field.is_relation or not field.primary_key)
489 ):
490 relation_parts.append(part)
491 if not getattr(field, "path_infos", None):
492 # This is not a relational field, so further parts
493 # must be transforms.
494 break
495 prev_field = field
496 model = field.path_infos[-1].to_opts.model
497
498 if len(relation_parts) <= 1:
499 # Either a local field filter, or no fields at all.
500 return True
501 valid_lookups = {self.date_hierarchy}
502 # RemovedInDjango60Warning: when the deprecation ends, replace with:
503 # for filter_item in self.get_list_filter(request):
504 list_filter = (
505 self.get_list_filter(request) if request is not None else self.list_filter
506 )
507 for filter_item in list_filter:
508 if isinstance(filter_item, type) and issubclass(
509 filter_item, SimpleListFilter
510 ):
511 valid_lookups.add(filter_item.parameter_name)
512 elif isinstance(filter_item, (list, tuple)):
513 valid_lookups.add(filter_item[0])
514 else:
515 valid_lookups.add(filter_item)
516
517 # Is it a valid relational lookup?
518 return not {
519 LOOKUP_SEP.join(relation_parts),
520 LOOKUP_SEP.join(relation_parts + [part]),
521 }.isdisjoint(valid_lookups)
522
523 def to_field_allowed(self, request, to_field):
524 """
525 Return True if the model associated with this admin should be
526 allowed to be referenced by the specified field.
527 """
528 try:
529 field = self.opts.get_field(to_field)
530 except FieldDoesNotExist:
531 return False
532
533 # Always allow referencing the primary key since it's already possible
534 # to get this information from the change view URL.
535 if field.primary_key:
536 return True
537
538 # Allow reverse relationships to models defining m2m fields if they
539 # target the specified field.
540 for many_to_many in self.opts.many_to_many:
541 if many_to_many.m2m_target_field_name() == to_field:
542 return True
543
544 # Make sure at least one of the models registered for this site
545 # references this field through a FK or a M2M relationship.
546 registered_models = set()
547 for model, admin in self.admin_site._registry.items():
548 registered_models.add(model)
549 for inline in admin.inlines:
550 registered_models.add(inline.model)
551
552 related_objects = (
553 f
554 for f in self.opts.get_fields(include_hidden=True)
555 if (f.auto_created and not f.concrete)
556 )
557 for related_object in related_objects:
558 related_model = related_object.related_model
559 remote_field = related_object.field.remote_field
560 if (
561 any(issubclass(model, related_model) for model in registered_models)
562 and hasattr(remote_field, "get_related_field")
563 and remote_field.get_related_field() == field
564 ):
565 return True
566
567 return False
568
569 def has_add_permission(self, request):
570 """
571 Return True if the given request has permission to add an object.
572 Can be overridden by the user in subclasses.
573 """
574 opts = self.opts
575 codename = get_permission_codename("add", opts)
576 return request.user.has_perm("%s.%s" % (opts.app_label, codename))
577
578 def has_change_permission(self, request, obj=None):
579 """
580 Return True if the given request has permission to change the given
581 Django model instance, the default implementation doesn't examine the
582 `obj` parameter.
583
584 Can be overridden by the user in subclasses. In such case it should
585 return True if the given request has permission to change the `obj`
586 model instance. If `obj` is None, this should return True if the given
587 request has permission to change *any* object of the given type.
588 """
589 opts = self.opts
590 codename = get_permission_codename("change", opts)
591 return request.user.has_perm("%s.%s" % (opts.app_label, codename))
592
593 def has_delete_permission(self, request, obj=None):
594 """
595 Return True if the given request has permission to delete the given
596 Django model instance, the default implementation doesn't examine the
597 `obj` parameter.
598
599 Can be overridden by the user in subclasses. In such case it should
600 return True if the given request has permission to delete the `obj`
601 model instance. If `obj` is None, this should return True if the given
602 request has permission to delete *any* object of the given type.
603 """
604 opts = self.opts
605 codename = get_permission_codename("delete", opts)
606 return request.user.has_perm("%s.%s" % (opts.app_label, codename))
607
608 def has_view_permission(self, request, obj=None):
609 """
610 Return True if the given request has permission to view the given
611 Django model instance. The default implementation doesn't examine the
612 `obj` parameter.
613
614 If overridden by the user in subclasses, it should return True if the
615 given request has permission to view the `obj` model instance. If `obj`
616 is None, it should return True if the request has permission to view
617 any object of the given type.
618 """
619 opts = self.opts
620 codename_view = get_permission_codename("view", opts)
621 codename_change = get_permission_codename("change", opts)
622 return request.user.has_perm(
623 "%s.%s" % (opts.app_label, codename_view)
624 ) or request.user.has_perm("%s.%s" % (opts.app_label, codename_change))
625
626 def has_view_or_change_permission(self, request, obj=None):
627 return self.has_view_permission(request, obj) or self.has_change_permission(
628 request, obj
629 )
630
631 def has_module_permission(self, request):
632 """
633 Return True if the given request has any permission in the given
634 app label.
635
636 Can be overridden by the user in subclasses. In such case it should
637 return True if the given request has permission to view the module on
638 the admin index page and access the module's index page. Overriding it
639 does not restrict access to the add, change or delete views. Use
640 `ModelAdmin.has_(add|change|delete)_permission` for that.
641 """
642 return request.user.has_module_perms(self.opts.app_label)
643
644
645 class ModelAdmin(BaseModelAdmin):
646 """Encapsulate all admin options and functionality for a given model."""
647
648 list_display = ("__str__",)
649 list_display_links = ()
650 list_filter = ()
651 list_select_related = False
652 list_per_page = 100
653 list_max_show_all = 200
654 list_editable = ()
655 search_fields = ()
656 search_help_text = None
657 date_hierarchy = None
658 save_as = False
659 save_as_continue = True
660 save_on_top = False
661 paginator = Paginator
662 preserve_filters = True
663 show_facets = ShowFacets.ALLOW
664 inlines = ()
665
666 # Custom templates (designed to be over-ridden in subclasses)
667 add_form_template = None
668 change_form_template = None
669 change_list_template = None
670 delete_confirmation_template = None
671 delete_selected_confirmation_template = None
672 object_history_template = None
673 popup_response_template = None
674
675 # Actions
676 actions = ()
677 action_form = helpers.ActionForm
678 actions_on_top = True
679 actions_on_bottom = False
680 actions_selection_counter = True
681 checks_class = ModelAdminChecks
682
683 def __init__(self, model, admin_site):
684 self.model = model
685 self.opts = model._meta
686 self.admin_site = admin_site
687 super().__init__()
688
689 def __str__(self):
690 return "%s.%s" % (self.opts.app_label, self.__class__.__name__)
691
692 def __repr__(self):
693 return (
694 f"<{self.__class__.__qualname__}: model={self.model.__qualname__} "
695 f"site={self.admin_site!r}>"
696 )
697
698 def get_inline_instances(self, request, obj=None):
699 inline_instances = []
700 for inline_class in self.get_inlines(request, obj):
701 inline = inline_class(self.model, self.admin_site)
702 if request:
703 if not (
704 inline.has_view_or_change_permission(request, obj)
705 or inline.has_add_permission(request, obj)
706 or inline.has_delete_permission(request, obj)
707 ):
708 continue
709 if not inline.has_add_permission(request, obj):
710 inline.max_num = 0
711 inline_instances.append(inline)
712
713 return inline_instances
714
715 def get_urls(self):
716 from django.urls import path
717
718 def wrap(view):
719 def wrapper(*args, **kwargs):
720 return self.admin_site.admin_view(view)(*args, **kwargs)
721
722 wrapper.model_admin = self
723 return update_wrapper(wrapper, view)
724
725 info = self.opts.app_label, self.opts.model_name
726
727 return [
728 path("", wrap(self.changelist_view), name="%s_%s_changelist" % info),
729 path("add/", wrap(self.add_view), name="%s_%s_add" % info),
730 path(
731 "<path:object_id>/history/",
732 wrap(self.history_view),
733 name="%s_%s_history" % info,
734 ),
735 path(
736 "<path:object_id>/delete/",
737 wrap(self.delete_view),
738 name="%s_%s_delete" % info,
739 ),
740 path(
741 "<path:object_id>/change/",
742 wrap(self.change_view),
743 name="%s_%s_change" % info,
744 ),
745 # For backwards compatibility (was the change url before 1.9)
746 path(
747 "<path:object_id>/",
748 wrap(
749 RedirectView.as_view(
750 pattern_name="%s:%s_%s_change"
751 % ((self.admin_site.name,) + info)
752 )
753 ),
754 ),
755 ]
756
757 @property
758 def urls(self):
759 return self.get_urls()
760
761 @property
762 def media(self):
763 extra = "" if settings.DEBUG else ".min"
764 js = [
765 "vendor/jquery/jquery%s.js" % extra,
766 "jquery.init.js",
767 "core.js",
768 "admin/RelatedObjectLookups.js",
769 "actions.js",
770 "urlify.js",
771 "prepopulate.js",
772 "vendor/xregexp/xregexp%s.js" % extra,
773 ]
774 return forms.Media(js=["admin/js/%s" % url for url in js])
775
776 def get_model_perms(self, request):
777 """
778 Return a dict of all perms for this model. This dict has the keys
779 ``add``, ``change``, ``delete``, and ``view`` mapping to the True/False
780 for each of those actions.
781 """
782 return {
783 "add": self.has_add_permission(request),
784 "change": self.has_change_permission(request),
785 "delete": self.has_delete_permission(request),
786 "view": self.has_view_permission(request),
787 }
788
789 def _get_form_for_get_fields(self, request, obj):
790 return self.get_form(request, obj, fields=None)
791
792 def get_form(self, request, obj=None, change=False, **kwargs):
793 """
794 Return a Form class for use in the admin add view. This is used by
795 add_view and change_view.
796 """
797 if "fields" in kwargs:
798 fields = kwargs.pop("fields")
799 else:
800 fields = flatten_fieldsets(self.get_fieldsets(request, obj))
801 excluded = self.get_exclude(request, obj)
802 exclude = [] if excluded is None else list(excluded)
803 readonly_fields = self.get_readonly_fields(request, obj)
804 exclude.extend(readonly_fields)
805 # Exclude all fields if it's a change form and the user doesn't have
806 # the change permission.
807 if (
808 change
809 and hasattr(request, "user")
810 and not self.has_change_permission(request, obj)
811 ):
812 exclude.extend(fields)
813 if excluded is None and hasattr(self.form, "_meta") and self.form._meta.exclude:
814 # Take the custom ModelForm's Meta.exclude into account only if the
815 # ModelAdmin doesn't define its own.
816 exclude.extend(self.form._meta.exclude)
817 # if exclude is an empty list we pass None to be consistent with the
818 # default on modelform_factory
819 exclude = exclude or None
820
821 # Remove declared form fields which are in readonly_fields.
822 new_attrs = dict.fromkeys(
823 f for f in readonly_fields if f in self.form.declared_fields
824 )
825 form = type(self.form.__name__, (self.form,), new_attrs)
826
827 defaults = {
828 "form": form,
829 "fields": fields,
830 "exclude": exclude,
831 "formfield_callback": partial(self.formfield_for_dbfield, request=request),
832 **kwargs,
833 }
834
835 if defaults["fields"] is None and not modelform_defines_fields(
836 defaults["form"]
837 ):
838 defaults["fields"] = forms.ALL_FIELDS
839
840 try:
841 return modelform_factory(self.model, **defaults)
842 except FieldError as e:
843 raise FieldError(
844 "%s. Check fields/fieldsets/exclude attributes of class %s."
845 % (e, self.__class__.__name__)
846 )
847
848 def get_changelist(self, request, **kwargs):
849 """
850 Return the ChangeList class for use on the changelist page.
851 """
852 from django.contrib.admin.views.main import ChangeList
853
854 return ChangeList
855
856 def get_changelist_instance(self, request):
857 """
858 Return a `ChangeList` instance based on `request`. May raise
859 `IncorrectLookupParameters`.
860 """
861 list_display = self.get_list_display(request)
862 list_display_links = self.get_list_display_links(request, list_display)
863 # Add the action checkboxes if any actions are available.
864 if self.get_actions(request):
865 list_display = ["action_checkbox", *list_display]
866 sortable_by = self.get_sortable_by(request)
867 ChangeList = self.get_changelist(request)
868 return ChangeList(
869 request,
870 self.model,
871 list_display,
872 list_display_links,
873 self.get_list_filter(request),
874 self.date_hierarchy,
875 self.get_search_fields(request),
876 self.get_list_select_related(request),
877 self.list_per_page,
878 self.list_max_show_all,
879 self.list_editable,
880 self,
881 sortable_by,
882 self.search_help_text,
883 )
884
885 def get_object(self, request, object_id, from_field=None):
886 """
887 Return an instance matching the field and value provided, the primary
888 key is used if no field is provided. Return ``None`` if no match is
889 found or the object_id fails validation.
890 """
891 queryset = self.get_queryset(request)
892 model = queryset.model
893 field = (
894 model._meta.pk if from_field is None else model._meta.get_field(from_field)
895 )
896 try:
897 object_id = field.to_python(object_id)
898 return queryset.get(**{field.name: object_id})
899 except (model.DoesNotExist, ValidationError, ValueError):
900 return None
901
902 def get_changelist_form(self, request, **kwargs):
903 """
904 Return a Form class for use in the Formset on the changelist page.
905 """
906 defaults = {
907 "formfield_callback": partial(self.formfield_for_dbfield, request=request),
908 **kwargs,
909 }
910 if defaults.get("fields") is None and not modelform_defines_fields(
911 defaults.get("form")
912 ):
913 defaults["fields"] = forms.ALL_FIELDS
914
915 return modelform_factory(self.model, **defaults)
916
917 def get_changelist_formset(self, request, **kwargs):
918 """
919 Return a FormSet class for use on the changelist page if list_editable
920 is used.
921 """
922 defaults = {
923 "formfield_callback": partial(self.formfield_for_dbfield, request=request),
924 **kwargs,
925 }
926 return modelformset_factory(
927 self.model,
928 self.get_changelist_form(request),
929 extra=0,
930 fields=self.list_editable,
931 **defaults,
932 )
933
934 def get_formsets_with_inlines(self, request, obj=None):
935 """
936 Yield formsets and the corresponding inlines.
937 """
938 for inline in self.get_inline_instances(request, obj):
939 yield inline.get_formset(request, obj), inline
940
941 def get_paginator(
942 self, request, queryset, per_page, orphans=0, allow_empty_first_page=True
943 ):
944 return self.paginator(queryset, per_page, orphans, allow_empty_first_page)
945
946 def log_addition(self, request, obj, message):
947 """
948 Log that an object has been successfully added.
949
950 The default implementation creates an admin LogEntry object.
951 """
952 from django.contrib.admin.models import ADDITION, LogEntry
953
954 return LogEntry.objects.log_actions(
955 user_id=request.user.pk,
956 queryset=[obj],
957 action_flag=ADDITION,
958 change_message=message,
959 single_object=True,
960 )
961
962 def log_change(self, request, obj, message):
963 """
964 Log that an object has been successfully changed.
965
966 The default implementation creates an admin LogEntry object.
967 """
968 from django.contrib.admin.models import CHANGE, LogEntry
969
970 return LogEntry.objects.log_actions(
971 user_id=request.user.pk,
972 queryset=[obj],
973 action_flag=CHANGE,
974 change_message=message,
975 single_object=True,
976 )
977
978 def log_deletion(self, request, obj, object_repr):
979 """
980 Log that an object will be deleted. Note that this method must be
981 called before the deletion.
982
983 The default implementation creates an admin LogEntry object.
984 """
985 warnings.warn(
986 "ModelAdmin.log_deletion() is deprecated. Use log_deletions() instead.",
987 RemovedInDjango60Warning,
988 stacklevel=2,
989 )
990 from django.contrib.admin.models import DELETION, LogEntry
991
992 return LogEntry.objects.log_action(
993 user_id=request.user.pk,
994 content_type_id=get_content_type_for_model(obj).pk,
995 object_id=obj.pk,
996 object_repr=object_repr,
997 action_flag=DELETION,
998 )
999
1000 def log_deletions(self, request, queryset):
1001 """
1002 Log that objects will be deleted. Note that this method must be called
1003 before the deletion.
1004
1005 The default implementation creates admin LogEntry objects.
1006 """
1007 from django.contrib.admin.models import DELETION, LogEntry
1008
1009 # RemovedInDjango60Warning.
1010 if type(self).log_deletion != ModelAdmin.log_deletion:
1011 warnings.warn(
1012 "The usage of log_deletion() is deprecated. Implement log_deletions() "
1013 "instead.",
1014 RemovedInDjango60Warning,
1015 stacklevel=2,
1016 )
1017 return [self.log_deletion(request, obj, str(obj)) for obj in queryset]
1018
1019 return LogEntry.objects.log_actions(
1020 user_id=request.user.pk,
1021 queryset=queryset,
1022 action_flag=DELETION,
1023 )
1024
1025 def action_checkbox(self, obj):
1026 """
1027 A list_display column containing a checkbox widget.
1028 """
1029 attrs = {
1030 "class": "action-select",
1031 "aria-label": format_html(
1032 _("Select this object for an action - {}"), str(obj)
1033 ),
1034 }
1035 checkbox = forms.CheckboxInput(attrs, lambda value: False)
1036 return checkbox.render(helpers.ACTION_CHECKBOX_NAME, str(obj.pk))
1037
1038 @staticmethod
1039 def _get_action_description(func, name):
1040 try:
1041 return func.short_description
1042 except AttributeError:
1043 return capfirst(name.replace("_", " "))
1044
1045 def _get_base_actions(self):
1046 """Return the list of actions, prior to any request-based filtering."""
1047 actions = []
1048 base_actions = (self.get_action(action) for action in self.actions or [])
1049 # get_action might have returned None, so filter any of those out.
1050 base_actions = [action for action in base_actions if action]
1051 base_action_names = {name for _, name, _ in base_actions}
1052
1053 # Gather actions from the admin site first
1054 for name, func in self.admin_site.actions:
1055 if name in base_action_names:
1056 continue
1057 description = self._get_action_description(func, name)
1058 actions.append((func, name, description))
1059 # Add actions from this ModelAdmin.
1060 actions.extend(base_actions)
1061 return actions
1062
1063 def _filter_actions_by_permissions(self, request, actions):
1064 """Filter out any actions that the user doesn't have access to."""
1065 filtered_actions = []
1066 for action in actions:
1067 callable = action[0]
1068 if not hasattr(callable, "allowed_permissions"):
1069 filtered_actions.append(action)
1070 continue
1071 permission_checks = (
1072 getattr(self, "has_%s_permission" % permission)
1073 for permission in callable.allowed_permissions
1074 )
1075 if any(has_permission(request) for has_permission in permission_checks):
1076 filtered_actions.append(action)
1077 return filtered_actions
1078
1079 def get_actions(self, request):
1080 """
1081 Return a dictionary mapping the names of all actions for this
1082 ModelAdmin to a tuple of (callable, name, description) for each action.
1083 """
1084 # If self.actions is set to None that means actions are disabled on
1085 # this page.
1086 if self.actions is None or IS_POPUP_VAR in request.GET:
1087 return {}
1088 actions = self._filter_actions_by_permissions(request, self._get_base_actions())
1089 return {name: (func, name, desc) for func, name, desc in actions}
1090
1091 def get_action_choices(self, request, default_choices=models.BLANK_CHOICE_DASH):
1092 """
1093 Return a list of choices for use in a form object. Each choice is a
1094 tuple (name, description).
1095 """
1096 choices = [] + default_choices
1097 for func, name, description in self.get_actions(request).values():
1098 choice = (name, description % model_format_dict(self.opts))
1099 choices.append(choice)
1100 return choices
1101
1102 def get_action(self, action):
1103 """
1104 Return a given action from a parameter, which can either be a callable,
1105 or the name of a method on the ModelAdmin. Return is a tuple of
1106 (callable, name, description).
1107 """
1108 # If the action is a callable, just use it.
1109 if callable(action):
1110 func = action
1111 action = action.__name__
1112
1113 # Next, look for a method. Grab it off self.__class__ to get an unbound
1114 # method instead of a bound one; this ensures that the calling
1115 # conventions are the same for functions and methods.
1116 elif hasattr(self.__class__, action):
1117 func = getattr(self.__class__, action)
1118
1119 # Finally, look for a named method on the admin site
1120 else:
1121 try:
1122 func = self.admin_site.get_action(action)
1123 except KeyError:
1124 return None
1125
1126 description = self._get_action_description(func, action)
1127 return func, action, description
1128
1129 def get_list_display(self, request):
1130 """
1131 Return a sequence containing the fields to be displayed on the
1132 changelist.
1133 """
1134 return self.list_display
1135
1136 def get_list_display_links(self, request, list_display):
1137 """
1138 Return a sequence containing the fields to be displayed as links
1139 on the changelist. The list_display parameter is the list of fields
1140 returned by get_list_display().
1141 """
1142 if (
1143 self.list_display_links
1144 or self.list_display_links is None
1145 or not list_display
1146 ):
1147 return self.list_display_links
1148 else:
1149 # Use only the first item in list_display as link
1150 return list(list_display)[:1]
1151
1152 def get_list_filter(self, request):
1153 """
1154 Return a sequence containing the fields to be displayed as filters in
1155 the right sidebar of the changelist page.
1156 """
1157 return self.list_filter
1158
1159 def get_list_select_related(self, request):
1160 """
1161 Return a list of fields to add to the select_related() part of the
1162 changelist items query.
1163 """
1164 return self.list_select_related
1165
1166 def get_search_fields(self, request):
1167 """
1168 Return a sequence containing the fields to be searched whenever
1169 somebody submits a search query.
1170 """
1171 return self.search_fields
1172
1173 def get_search_results(self, request, queryset, search_term):
1174 """
1175 Return a tuple containing a queryset to implement the search
1176 and a boolean indicating if the results may contain duplicates.
1177 """
1178
1179 # Apply keyword searches.
1180 def construct_search(field_name):
1181 if field_name.startswith("^"):
1182 return "%s__istartswith" % field_name.removeprefix("^"), None
1183 elif field_name.startswith("="):
1184 return "%s__iexact" % field_name.removeprefix("="), None
1185 elif field_name.startswith("@"):
1186 return "%s__search" % field_name.removeprefix("@"), None
1187 # Use field_name if it includes a lookup.
1188 opts = queryset.model._meta
1189 lookup_fields = field_name.split(LOOKUP_SEP)
1190 # Go through the fields, following all relations.
1191 prev_field = None
1192 for i, path_part in enumerate(lookup_fields):
1193 if path_part == "pk":
1194 path_part = opts.pk.name
1195 try:
1196 field = opts.get_field(path_part)
1197 except FieldDoesNotExist:
1198 # Use valid query lookups.
1199 if prev_field and prev_field.get_lookup(path_part):
1200 if path_part == "exact" and not isinstance(
1201 prev_field, (models.CharField, models.TextField)
1202 ):
1203 field_name_without_exact = "__".join(lookup_fields[:i])
1204 alias = Cast(
1205 field_name_without_exact,
1206 output_field=models.CharField(),
1207 )
1208 alias_name = "_".join(lookup_fields[:i])
1209 return f"{alias_name}_str", alias
1210 else:
1211 return field_name, None
1212 else:
1213 prev_field = field
1214 if hasattr(field, "path_infos"):
1215 # Update opts to follow the relation.
1216 opts = field.path_infos[-1].to_opts
1217 # Otherwise, use the field with icontains.
1218 return "%s__icontains" % field_name, None
1219
1220 may_have_duplicates = False
1221 search_fields = self.get_search_fields(request)
1222 if search_fields and search_term:
1223 str_aliases = {}
1224 orm_lookups = []
1225 for field in search_fields:
1226 lookup, str_alias = construct_search(str(field))
1227 orm_lookups.append(lookup)
1228 if str_alias:
1229 str_aliases[lookup] = str_alias
1230
1231 if str_aliases:
1232 queryset = queryset.alias(**str_aliases)
1233
1234 term_queries = []
1235 for bit in smart_split(search_term):
1236 if bit.startswith(('"', "'")) and bit[0] == bit[-1]:
1237 bit = unescape_string_literal(bit)
1238 or_queries = models.Q.create(
1239 [(orm_lookup, bit) for orm_lookup in orm_lookups],
1240 connector=models.Q.OR,
1241 )
1242 term_queries.append(or_queries)
1243 queryset = queryset.filter(models.Q.create(term_queries))
1244 may_have_duplicates |= any(
1245 lookup_spawns_duplicates(self.opts, search_spec)
1246 for search_spec in orm_lookups
1247 )
1248 return queryset, may_have_duplicates
1249
1250 def get_preserved_filters(self, request):
1251 """
1252 Return the preserved filters querystring.
1253 """
1254 match = request.resolver_match
1255 if self.preserve_filters and match:
1256 current_url = "%s:%s" % (match.app_name, match.url_name)
1257 changelist_url = "admin:%s_%s_changelist" % (
1258 self.opts.app_label,
1259 self.opts.model_name,
1260 )
1261 if current_url == changelist_url:
1262 preserved_filters = request.GET.urlencode()
1263 else:
1264 preserved_filters = request.GET.get("_changelist_filters")
1265
1266 if preserved_filters:
1267 return urlencode({"_changelist_filters": preserved_filters})
1268 return ""
1269
1270 def construct_change_message(self, request, form, formsets, add=False):
1271 """
1272 Construct a JSON structure describing changes from a changed object.
1273 """
1274 return construct_change_message(form, formsets, add)
1275
1276 def message_user(
1277 self, request, message, level=messages.INFO, extra_tags="", fail_silently=False
1278 ):
1279 """
1280 Send a message to the user. The default implementation
1281 posts a message using the django.contrib.messages backend.
1282
1283 Exposes almost the same API as messages.add_message(), but accepts the
1284 positional arguments in a different order to maintain backwards
1285 compatibility. For convenience, it accepts the `level` argument as
1286 a string rather than the usual level number.
1287 """
1288 if not isinstance(level, int):
1289 # attempt to get the level if passed a string
1290 try:
1291 level = getattr(messages.constants, level.upper())
1292 except AttributeError:
1293 levels = messages.constants.DEFAULT_TAGS.values()
1294 levels_repr = ", ".join("`%s`" % level for level in levels)
1295 raise ValueError(
1296 "Bad message level string: `%s`. Possible values are: %s"
1297 % (level, levels_repr)
1298 )
1299
1300 messages.add_message(
1301 request, level, message, extra_tags=extra_tags, fail_silently=fail_silently
1302 )
1303
1304 def save_form(self, request, form, change):
1305 """
1306 Given a ModelForm return an unsaved instance. ``change`` is True if
1307 the object is being changed, and False if it's being added.
1308 """
1309 return form.save(commit=False)
1310
1311 def save_model(self, request, obj, form, change):
1312 """
1313 Given a model instance save it to the database.
1314 """
1315 obj.save()
1316
1317 def delete_model(self, request, obj):
1318 """
1319 Given a model instance delete it from the database.
1320 """
1321 obj.delete()
1322
1323 def delete_queryset(self, request, queryset):
1324 """Given a queryset, delete it from the database."""
1325 queryset.delete()
1326
1327 def save_formset(self, request, form, formset, change):
1328 """
1329 Given an inline formset save it to the database.
1330 """
1331 formset.save()
1332
1333 def save_related(self, request, form, formsets, change):
1334 """
1335 Given the ``HttpRequest``, the parent ``ModelForm`` instance, the
1336 list of inline formsets and a boolean value based on whether the
1337 parent is being added or changed, save the related objects to the
1338 database. Note that at this point save_form() and save_model() have
1339 already been called.
1340 """
1341 form.save_m2m()
1342 for formset in formsets:
1343 self.save_formset(request, form, formset, change=change)
1344
1345 def render_change_form(
1346 self, request, context, add=False, change=False, form_url="", obj=None
1347 ):
1348 app_label = self.opts.app_label
1349 preserved_filters = self.get_preserved_filters(request)
1350 form_url = add_preserved_filters(
1351 {"preserved_filters": preserved_filters, "opts": self.opts}, form_url
1352 )
1353 view_on_site_url = self.get_view_on_site_url(obj)
1354 has_editable_inline_admin_formsets = False
1355 for inline in context["inline_admin_formsets"]:
1356 if (
1357 inline.has_add_permission
1358 or inline.has_change_permission
1359 or inline.has_delete_permission
1360 ):
1361 has_editable_inline_admin_formsets = True
1362 break
1363 context.update(
1364 {
1365 "add": add,
1366 "change": change,
1367 "has_view_permission": self.has_view_permission(request, obj),
1368 "has_add_permission": self.has_add_permission(request),
1369 "has_change_permission": self.has_change_permission(request, obj),
1370 "has_delete_permission": self.has_delete_permission(request, obj),
1371 "has_editable_inline_admin_formsets": (
1372 has_editable_inline_admin_formsets
1373 ),
1374 "has_file_field": context["adminform"].form.is_multipart()
1375 or any(
1376 admin_formset.formset.is_multipart()
1377 for admin_formset in context["inline_admin_formsets"]
1378 ),
1379 "has_absolute_url": view_on_site_url is not None,
1380 "absolute_url": view_on_site_url,
1381 "form_url": form_url,
1382 "opts": self.opts,
1383 "content_type_id": get_content_type_for_model(self.model).pk,
1384 "save_as": self.save_as,
1385 "save_on_top": self.save_on_top,
1386 "to_field_var": TO_FIELD_VAR,
1387 "is_popup_var": IS_POPUP_VAR,
1388 "app_label": app_label,
1389 }
1390 )
1391 if add and self.add_form_template is not None:
1392 form_template = self.add_form_template
1393 else:
1394 form_template = self.change_form_template
1395
1396 request.current_app = self.admin_site.name
1397
1398 return TemplateResponse(
1399 request,
1400 form_template
1401 or [
1402 "admin/%s/%s/change_form.html" % (app_label, self.opts.model_name),
1403 "admin/%s/change_form.html" % app_label,
1404 "admin/change_form.html",
1405 ],
1406 context,
1407 )
1408
1409 def _get_preserved_qsl(self, request, preserved_filters):
1410 query_string = urlsplit(request.build_absolute_uri()).query
1411 return parse_qsl(query_string.replace(preserved_filters, ""))
1412
1413 def response_add(self, request, obj, post_url_continue=None):
1414 """
1415 Determine the HttpResponse for the add_view stage.
1416 """
1417 opts = obj._meta
1418 preserved_filters = self.get_preserved_filters(request)
1419 preserved_qsl = self._get_preserved_qsl(request, preserved_filters)
1420 obj_url = reverse(
1421 "admin:%s_%s_change" % (opts.app_label, opts.model_name),
1422 args=(quote(obj.pk),),
1423 current_app=self.admin_site.name,
1424 )
1425 # Add a link to the object's change form if the user can edit the obj.
1426 if self.has_change_permission(request, obj):
1427 obj_repr = format_html('<a href="{}">{}</a>', urlquote(obj_url), obj)
1428 else:
1429 obj_repr = str(obj)
1430 msg_dict = {
1431 "name": opts.verbose_name,
1432 "obj": obj_repr,
1433 }
1434 # Here, we distinguish between different save types by checking for
1435 # the presence of keys in request.POST.
1436
1437 if IS_POPUP_VAR in request.POST:
1438 to_field = request.POST.get(TO_FIELD_VAR)
1439 if to_field:
1440 attr = str(to_field)
1441 else:
1442 attr = obj._meta.pk.attname
1443 value = obj.serializable_value(attr)
1444 popup_response_data = json.dumps(
1445 {
1446 "value": str(value),
1447 "obj": str(obj),
1448 }
1449 )
1450 return TemplateResponse(
1451 request,
1452 self.popup_response_template
1453 or [
1454 "admin/%s/%s/popup_response.html"
1455 % (opts.app_label, opts.model_name),
1456 "admin/%s/popup_response.html" % opts.app_label,
1457 "admin/popup_response.html",
1458 ],
1459 {
1460 "popup_response_data": popup_response_data,
1461 },
1462 )
1463
1464 elif "_continue" in request.POST or (
1465 # Redirecting after "Save as new".
1466 "_saveasnew" in request.POST
1467 and self.save_as_continue
1468 and self.has_change_permission(request, obj)
1469 ):
1470 msg = _("The {name} “{obj}” was added successfully.")
1471 if self.has_change_permission(request, obj):
1472 msg += " " + _("You may edit it again below.")
1473 self.message_user(request, format_html(msg, **msg_dict), messages.SUCCESS)
1474 if post_url_continue is None:
1475 post_url_continue = obj_url
1476 post_url_continue = add_preserved_filters(
1477 {
1478 "preserved_filters": preserved_filters,
1479 "preserved_qsl": preserved_qsl,
1480 "opts": opts,
1481 },
1482 post_url_continue,
1483 )
1484 return HttpResponseRedirect(post_url_continue)
1485
1486 elif "_addanother" in request.POST:
1487 msg = format_html(
1488 _(
1489 "The {name} “{obj}” was added successfully. You may add another "
1490 "{name} below."
1491 ),
1492 **msg_dict,
1493 )
1494 self.message_user(request, msg, messages.SUCCESS)
1495 redirect_url = request.path
1496 redirect_url = add_preserved_filters(
1497 {
1498 "preserved_filters": preserved_filters,
1499 "preserved_qsl": preserved_qsl,
1500 "opts": opts,
1501 },
1502 redirect_url,
1503 )
1504 return HttpResponseRedirect(redirect_url)
1505
1506 else:
1507 msg = format_html(
1508 _("The {name} “{obj}” was added successfully."), **msg_dict
1509 )
1510 self.message_user(request, msg, messages.SUCCESS)
1511 return self.response_post_save_add(request, obj)
1512
1513 def response_change(self, request, obj):
1514 """
1515 Determine the HttpResponse for the change_view stage.
1516 """
1517
1518 if IS_POPUP_VAR in request.POST:
1519 opts = obj._meta
1520 to_field = request.POST.get(TO_FIELD_VAR)
1521 attr = str(to_field) if to_field else opts.pk.attname
1522 value = request.resolver_match.kwargs["object_id"]
1523 new_value = obj.serializable_value(attr)
1524 popup_response_data = json.dumps(
1525 {
1526 "action": "change",
1527 "value": str(value),
1528 "obj": str(obj),
1529 "new_value": str(new_value),
1530 }
1531 )
1532 return TemplateResponse(
1533 request,
1534 self.popup_response_template
1535 or [
1536 "admin/%s/%s/popup_response.html"
1537 % (opts.app_label, opts.model_name),
1538 "admin/%s/popup_response.html" % opts.app_label,
1539 "admin/popup_response.html",
1540 ],
1541 {
1542 "popup_response_data": popup_response_data,
1543 },
1544 )
1545
1546 opts = self.opts
1547 preserved_filters = self.get_preserved_filters(request)
1548 preserved_qsl = self._get_preserved_qsl(request, preserved_filters)
1549
1550 msg_dict = {
1551 "name": opts.verbose_name,
1552 "obj": format_html('<a href="{}">{}</a>', urlquote(request.path), obj),
1553 }
1554 if "_continue" in request.POST:
1555 msg = format_html(
1556 _(
1557 "The {name} “{obj}” was changed successfully. You may edit it "
1558 "again below."
1559 ),
1560 **msg_dict,
1561 )
1562 self.message_user(request, msg, messages.SUCCESS)
1563 redirect_url = request.path
1564 redirect_url = add_preserved_filters(
1565 {
1566 "preserved_filters": preserved_filters,
1567 "preserved_qsl": preserved_qsl,
1568 "opts": opts,
1569 },
1570 redirect_url,
1571 )
1572 return HttpResponseRedirect(redirect_url)
1573
1574 elif "_addanother" in request.POST:
1575 msg = format_html(
1576 _(
1577 "The {name} “{obj}” was changed successfully. You may add another "
1578 "{name} below."
1579 ),
1580 **msg_dict,
1581 )
1582 self.message_user(request, msg, messages.SUCCESS)
1583 redirect_url = reverse(
1584 "admin:%s_%s_add" % (opts.app_label, opts.model_name),
1585 current_app=self.admin_site.name,
1586 )
1587 redirect_url = add_preserved_filters(
1588 {
1589 "preserved_filters": preserved_filters,
1590 "preserved_qsl": preserved_qsl,
1591 "opts": opts,
1592 },
1593 redirect_url,
1594 )
1595 return HttpResponseRedirect(redirect_url)
1596
1597 else:
1598 msg = format_html(
1599 _("The {name} “{obj}” was changed successfully."), **msg_dict
1600 )
1601 self.message_user(request, msg, messages.SUCCESS)
1602 return self.response_post_save_change(request, obj)
1603
1604 def _response_post_save(self, request, obj):
1605 if self.has_view_or_change_permission(request):
1606 post_url = reverse(
1607 "admin:%s_%s_changelist" % (self.opts.app_label, self.opts.model_name),
1608 current_app=self.admin_site.name,
1609 )
1610 preserved_filters = self.get_preserved_filters(request)
1611 post_url = add_preserved_filters(
1612 {"preserved_filters": preserved_filters, "opts": self.opts}, post_url
1613 )
1614 else:
1615 post_url = reverse("admin:index", current_app=self.admin_site.name)
1616 return HttpResponseRedirect(post_url)
1617
1618 def response_post_save_add(self, request, obj):
1619 """
1620 Figure out where to redirect after the 'Save' button has been pressed
1621 when adding a new object.
1622 """
1623 return self._response_post_save(request, obj)
1624
1625 def response_post_save_change(self, request, obj):
1626 """
1627 Figure out where to redirect after the 'Save' button has been pressed
1628 when editing an existing object.
1629 """
1630 return self._response_post_save(request, obj)
1631
1632 def response_action(self, request, queryset):
1633 """
1634 Handle an admin action. This is called if a request is POSTed to the
1635 changelist; it returns an HttpResponse if the action was handled, and
1636 None otherwise.
1637 """
1638
1639 # There can be multiple action forms on the page (at the top
1640 # and bottom of the change list, for example). Get the action
1641 # whose button was pushed.
1642 try:
1643 action_index = int(request.POST.get("index", 0))
1644 except ValueError:
1645 action_index = 0
1646
1647 # Construct the action form.
1648 data = request.POST.copy()
1649 data.pop(helpers.ACTION_CHECKBOX_NAME, None)
1650 data.pop("index", None)
1651
1652 # Use the action whose button was pushed
1653 try:
1654 data.update({"action": data.getlist("action")[action_index]})
1655 except IndexError:
1656 # If we didn't get an action from the chosen form that's invalid
1657 # POST data, so by deleting action it'll fail the validation check
1658 # below. So no need to do anything here
1659 pass
1660
1661 action_form = self.action_form(data, auto_id=None)
1662 action_form.fields["action"].choices = self.get_action_choices(request)
1663
1664 # If the form's valid we can handle the action.
1665 if action_form.is_valid():
1666 action = action_form.cleaned_data["action"]
1667 select_across = action_form.cleaned_data["select_across"]
1668 func = self.get_actions(request)[action][0]
1669
1670 # Get the list of selected PKs. If nothing's selected, we can't
1671 # perform an action on it, so bail. Except we want to perform
1672 # the action explicitly on all objects.
1673 selected = request.POST.getlist(helpers.ACTION_CHECKBOX_NAME)
1674 if not selected and not select_across:
1675 # Reminder that something needs to be selected or nothing will happen
1676 msg = _(
1677 "Items must be selected in order to perform "
1678 "actions on them. No items have been changed."
1679 )
1680 self.message_user(request, msg, messages.WARNING)
1681 return None
1682
1683 if not select_across:
1684 # Perform the action only on the selected objects
1685 queryset = queryset.filter(pk__in=selected)
1686
1687 response = func(self, request, queryset)
1688
1689 # Actions may return an HttpResponse-like object, which will be
1690 # used as the response from the POST. If not, we'll be a good
1691 # little HTTP citizen and redirect back to the changelist page.
1692 if isinstance(response, HttpResponseBase):
1693 return response
1694 else:
1695 return HttpResponseRedirect(request.get_full_path())
1696 else:
1697 msg = _("No action selected.")
1698 self.message_user(request, msg, messages.WARNING)
1699 return None
1700
1701 def response_delete(self, request, obj_display, obj_id):
1702 """
1703 Determine the HttpResponse for the delete_view stage.
1704 """
1705 if IS_POPUP_VAR in request.POST:
1706 popup_response_data = json.dumps(
1707 {
1708 "action": "delete",
1709 "value": str(obj_id),
1710 }
1711 )
1712 return TemplateResponse(
1713 request,
1714 self.popup_response_template
1715 or [
1716 "admin/%s/%s/popup_response.html"
1717 % (self.opts.app_label, self.opts.model_name),
1718 "admin/%s/popup_response.html" % self.opts.app_label,
1719 "admin/popup_response.html",
1720 ],
1721 {
1722 "popup_response_data": popup_response_data,
1723 },
1724 )
1725
1726 self.message_user(
1727 request,
1728 _("The %(name)s “%(obj)s” was deleted successfully.")
1729 % {
1730 "name": self.opts.verbose_name,
1731 "obj": obj_display,
1732 },
1733 messages.SUCCESS,
1734 )
1735
1736 if self.has_change_permission(request, None):
1737 post_url = reverse(
1738 "admin:%s_%s_changelist" % (self.opts.app_label, self.opts.model_name),
1739 current_app=self.admin_site.name,
1740 )
1741 preserved_filters = self.get_preserved_filters(request)
1742 post_url = add_preserved_filters(
1743 {"preserved_filters": preserved_filters, "opts": self.opts}, post_url
1744 )
1745 else:
1746 post_url = reverse("admin:index", current_app=self.admin_site.name)
1747 return HttpResponseRedirect(post_url)
1748
1749 def render_delete_form(self, request, context):
1750 app_label = self.opts.app_label
1751
1752 request.current_app = self.admin_site.name
1753 context.update(
1754 to_field_var=TO_FIELD_VAR,
1755 is_popup_var=IS_POPUP_VAR,
1756 media=self.media,
1757 )
1758
1759 return TemplateResponse(
1760 request,
1761 self.delete_confirmation_template
1762 or [
1763 "admin/{}/{}/delete_confirmation.html".format(
1764 app_label, self.opts.model_name
1765 ),
1766 "admin/{}/delete_confirmation.html".format(app_label),
1767 "admin/delete_confirmation.html",
1768 ],
1769 context,
1770 )
1771
1772 def get_inline_formsets(self, request, formsets, inline_instances, obj=None):
1773 # Edit permissions on parent model are required for editable inlines.
1774 can_edit_parent = (
1775 self.has_change_permission(request, obj)
1776 if obj
1777 else self.has_add_permission(request)
1778 )
1779 inline_admin_formsets = []
1780 for inline, formset in zip(inline_instances, formsets):
1781 fieldsets = list(inline.get_fieldsets(request, obj))
1782 readonly = list(inline.get_readonly_fields(request, obj))
1783 if can_edit_parent:
1784 has_add_permission = inline.has_add_permission(request, obj)
1785 has_change_permission = inline.has_change_permission(request, obj)
1786 has_delete_permission = inline.has_delete_permission(request, obj)
1787 else:
1788 # Disable all edit-permissions, and override formset settings.
1789 has_add_permission = has_change_permission = has_delete_permission = (
1790 False
1791 )
1792 formset.extra = formset.max_num = 0
1793 has_view_permission = inline.has_view_permission(request, obj)
1794 prepopulated = dict(inline.get_prepopulated_fields(request, obj))
1795 inline_admin_formset = helpers.InlineAdminFormSet(
1796 inline,
1797 formset,
1798 fieldsets,
1799 prepopulated,
1800 readonly,
1801 model_admin=self,
1802 has_add_permission=has_add_permission,
1803 has_change_permission=has_change_permission,
1804 has_delete_permission=has_delete_permission,
1805 has_view_permission=has_view_permission,
1806 )
1807 inline_admin_formsets.append(inline_admin_formset)
1808 return inline_admin_formsets
1809
1810 def get_changeform_initial_data(self, request):
1811 """
1812 Get the initial form data from the request's GET params.
1813 """
1814 initial = dict(request.GET.items())
1815 for k in initial:
1816 try:
1817 f = self.opts.get_field(k)
1818 except FieldDoesNotExist:
1819 continue
1820 # We have to special-case M2Ms as a list of comma-separated PKs.
1821 if isinstance(f, models.ManyToManyField):
1822 initial[k] = initial[k].split(",")
1823 return initial
1824
1825 def _get_obj_does_not_exist_redirect(self, request, opts, object_id):
1826 """
1827 Create a message informing the user that the object doesn't exist
1828 and return a redirect to the admin index page.
1829 """
1830 msg = _("%(name)s with ID “%(key)s” doesn’t exist. Perhaps it was deleted?") % {
1831 "name": opts.verbose_name,
1832 "key": unquote(object_id),
1833 }
1834 self.message_user(request, msg, messages.WARNING)
1835 url = reverse("admin:index", current_app=self.admin_site.name)
1836 return HttpResponseRedirect(url)
1837
1838 @csrf_protect_m
1839 def changeform_view(self, request, object_id=None, form_url="", extra_context=None):
1840 if request.method in ("GET", "HEAD", "OPTIONS", "TRACE"):
1841 return self._changeform_view(request, object_id, form_url, extra_context)
1842
1843 with transaction.atomic(using=router.db_for_write(self.model)):
1844 return self._changeform_view(request, object_id, form_url, extra_context)
1845
1846 def _changeform_view(self, request, object_id, form_url, extra_context):
1847 to_field = request.POST.get(TO_FIELD_VAR, request.GET.get(TO_FIELD_VAR))
1848 if to_field and not self.to_field_allowed(request, to_field):
1849 raise DisallowedModelAdminToField(
1850 "The field %s cannot be referenced." % to_field
1851 )
1852
1853 if request.method == "POST" and "_saveasnew" in request.POST:
1854 object_id = None
1855
1856 add = object_id is None
1857
1858 if add:
1859 if not self.has_add_permission(request):
1860 raise PermissionDenied
1861 obj = None
1862
1863 else:
1864 obj = self.get_object(request, unquote(object_id), to_field)
1865
1866 if request.method == "POST":
1867 if not self.has_change_permission(request, obj):
1868 raise PermissionDenied
1869 else:
1870 if not self.has_view_or_change_permission(request, obj):
1871 raise PermissionDenied
1872
1873 if obj is None:
1874 return self._get_obj_does_not_exist_redirect(
1875 request, self.opts, object_id
1876 )
1877
1878 fieldsets = self.get_fieldsets(request, obj)
1879 ModelForm = self.get_form(
1880 request, obj, change=not add, fields=flatten_fieldsets(fieldsets)
1881 )
1882 if request.method == "POST":
1883 form = ModelForm(request.POST, request.FILES, instance=obj)
1884 formsets, inline_instances = self._create_formsets(
1885 request,
1886 form.instance,
1887 change=not add,
1888 )
1889 form_validated = form.is_valid()
1890 if form_validated:
1891 new_object = self.save_form(request, form, change=not add)
1892 else:
1893 new_object = form.instance
1894 if all_valid(formsets) and form_validated:
1895 self.save_model(request, new_object, form, not add)
1896 self.save_related(request, form, formsets, not add)
1897 change_message = self.construct_change_message(
1898 request, form, formsets, add
1899 )
1900 if add:
1901 self.log_addition(request, new_object, change_message)
1902 return self.response_add(request, new_object)
1903 else:
1904 self.log_change(request, new_object, change_message)
1905 return self.response_change(request, new_object)
1906 else:
1907 form_validated = False
1908 else:
1909 if add:
1910 initial = self.get_changeform_initial_data(request)
1911 form = ModelForm(initial=initial)
1912 formsets, inline_instances = self._create_formsets(
1913 request, form.instance, change=False
1914 )
1915 else:
1916 form = ModelForm(instance=obj)
1917 formsets, inline_instances = self._create_formsets(
1918 request, obj, change=True
1919 )
1920
1921 if not add and not self.has_change_permission(request, obj):
1922 readonly_fields = flatten_fieldsets(fieldsets)
1923 else:
1924 readonly_fields = self.get_readonly_fields(request, obj)
1925 admin_form = helpers.AdminForm(
1926 form,
1927 list(fieldsets),
1928 # Clear prepopulated fields on a view-only form to avoid a crash.
1929 (
1930 self.get_prepopulated_fields(request, obj)
1931 if add or self.has_change_permission(request, obj)
1932 else {}
1933 ),
1934 readonly_fields,
1935 model_admin=self,
1936 )
1937 media = self.media + admin_form.media
1938
1939 inline_formsets = self.get_inline_formsets(
1940 request, formsets, inline_instances, obj
1941 )
1942 for inline_formset in inline_formsets:
1943 media += inline_formset.media
1944
1945 if add:
1946 title = _("Add %s")
1947 elif self.has_change_permission(request, obj):
1948 title = _("Change %s")
1949 else:
1950 title = _("View %s")
1951 context = {
1952 **self.admin_site.each_context(request),
1953 "title": title % self.opts.verbose_name,
1954 "subtitle": str(obj) if obj else None,
1955 "adminform": admin_form,
1956 "object_id": object_id,
1957 "original": obj,
1958 "is_popup": IS_POPUP_VAR in request.POST or IS_POPUP_VAR in request.GET,
1959 "to_field": to_field,
1960 "media": media,
1961 "inline_admin_formsets": inline_formsets,
1962 "errors": helpers.AdminErrorList(form, formsets),
1963 "preserved_filters": self.get_preserved_filters(request),
1964 }
1965
1966 # Hide the "Save" and "Save and continue" buttons if "Save as New" was
1967 # previously chosen to prevent the interface from getting confusing.
1968 if (
1969 request.method == "POST"
1970 and not form_validated
1971 and "_saveasnew" in request.POST
1972 ):
1973 context["show_save"] = False
1974 context["show_save_and_continue"] = False
1975 # Use the change template instead of the add template.
1976 add = False
1977
1978 context.update(extra_context or {})
1979
1980 return self.render_change_form(
1981 request, context, add=add, change=not add, obj=obj, form_url=form_url
1982 )
1983
1984 def add_view(self, request, form_url="", extra_context=None):
1985 return self.changeform_view(request, None, form_url, extra_context)
1986
1987 def change_view(self, request, object_id, form_url="", extra_context=None):
1988 return self.changeform_view(request, object_id, form_url, extra_context)
1989
1990 def _get_edited_object_pks(self, request, prefix):
1991 """Return POST data values of list_editable primary keys."""
1992 pk_pattern = re.compile(
1993 r"{}-\d+-{}$".format(re.escape(prefix), self.opts.pk.name)
1994 )
1995 return [value for key, value in request.POST.items() if pk_pattern.match(key)]
1996
1997 def _get_list_editable_queryset(self, request, prefix):
1998 """
1999 Based on POST data, return a queryset of the objects that were edited
2000 via list_editable.
2001 """
2002 object_pks = self._get_edited_object_pks(request, prefix)
2003 queryset = self.get_queryset(request)
2004 validate = queryset.model._meta.pk.to_python
2005 try:
2006 for pk in object_pks:
2007 validate(pk)
2008 except ValidationError:
2009 # Disable the optimization if the POST data was tampered with.
2010 return queryset
2011 return queryset.filter(pk__in=object_pks)
2012
2013 @csrf_protect_m
2014 def changelist_view(self, request, extra_context=None):
2015 """
2016 The 'change list' admin view for this model.
2017 """
2018 from django.contrib.admin.views.main import ERROR_FLAG
2019
2020 app_label = self.opts.app_label
2021 if not self.has_view_or_change_permission(request):
2022 raise PermissionDenied
2023
2024 try:
2025 cl = self.get_changelist_instance(request)
2026 except IncorrectLookupParameters:
2027 # Wacky lookup parameters were given, so redirect to the main
2028 # changelist page, without parameters, and pass an 'invalid=1'
2029 # parameter via the query string. If wacky parameters were given
2030 # and the 'invalid=1' parameter was already in the query string,
2031 # something is screwed up with the database, so display an error
2032 # page.
2033 if ERROR_FLAG in request.GET:
2034 return SimpleTemplateResponse(
2035 "admin/invalid_setup.html",
2036 {
2037 "title": _("Database error"),
2038 },
2039 )
2040 return HttpResponseRedirect(request.path + "?" + ERROR_FLAG + "=1")
2041
2042 # If the request was POSTed, this might be a bulk action or a bulk
2043 # edit. Try to look up an action or confirmation first, but if this
2044 # isn't an action the POST will fall through to the bulk edit check,
2045 # below.
2046 action_failed = False
2047 selected = request.POST.getlist(helpers.ACTION_CHECKBOX_NAME)
2048
2049 actions = self.get_actions(request)
2050 # Actions with no confirmation
2051 if (
2052 actions
2053 and request.method == "POST"
2054 and "index" in request.POST
2055 and "_save" not in request.POST
2056 ):
2057 if selected:
2058 response = self.response_action(
2059 request, queryset=cl.get_queryset(request)
2060 )
2061 if response:
2062 return response
2063 else:
2064 action_failed = True
2065 else:
2066 msg = _(
2067 "Items must be selected in order to perform "
2068 "actions on them. No items have been changed."
2069 )
2070 self.message_user(request, msg, messages.WARNING)
2071 action_failed = True
2072
2073 # Actions with confirmation
2074 if (
2075 actions
2076 and request.method == "POST"
2077 and helpers.ACTION_CHECKBOX_NAME in request.POST
2078 and "index" not in request.POST
2079 and "_save" not in request.POST
2080 ):
2081 if selected:
2082 response = self.response_action(
2083 request, queryset=cl.get_queryset(request)
2084 )
2085 if response:
2086 return response
2087 else:
2088 action_failed = True
2089
2090 if action_failed:
2091 # Redirect back to the changelist page to avoid resubmitting the
2092 # form if the user refreshes the browser or uses the "No, take
2093 # me back" button on the action confirmation page.
2094 return HttpResponseRedirect(request.get_full_path())
2095
2096 # If we're allowing changelist editing, we need to construct a formset
2097 # for the changelist given all the fields to be edited. Then we'll
2098 # use the formset to validate/process POSTed data.
2099 formset = cl.formset = None
2100
2101 # Handle POSTed bulk-edit data.
2102 if request.method == "POST" and cl.list_editable and "_save" in request.POST:
2103 if not self.has_change_permission(request):
2104 raise PermissionDenied
2105 FormSet = self.get_changelist_formset(request)
2106 modified_objects = self._get_list_editable_queryset(
2107 request, FormSet.get_default_prefix()
2108 )
2109 formset = cl.formset = FormSet(
2110 request.POST, request.FILES, queryset=modified_objects
2111 )
2112 if formset.is_valid():
2113 changecount = 0
2114 with transaction.atomic(using=router.db_for_write(self.model)):
2115 for form in formset.forms:
2116 if form.has_changed():
2117 obj = self.save_form(request, form, change=True)
2118 if obj._state.adding:
2119 raise BadRequest("list_editable does not allow adding.")
2120 self.save_model(request, obj, form, change=True)
2121 self.save_related(request, form, formsets=[], change=True)
2122 change_msg = self.construct_change_message(
2123 request, form, None
2124 )
2125 self.log_change(request, obj, change_msg)
2126 changecount += 1
2127 if changecount:
2128 msg = ngettext(
2129 "%(count)s %(name)s was changed successfully.",
2130 "%(count)s %(name)s were changed successfully.",
2131 changecount,
2132 ) % {
2133 "count": changecount,
2134 "name": model_ngettext(self.opts, changecount),
2135 }
2136 self.message_user(request, msg, messages.SUCCESS)
2137
2138 return HttpResponseRedirect(request.get_full_path())
2139
2140 # Handle GET -- construct a formset for display.
2141 elif cl.list_editable and self.has_change_permission(request):
2142 FormSet = self.get_changelist_formset(request)
2143 formset = cl.formset = FormSet(queryset=cl.result_list)
2144
2145 # Build the list of media to be used by the formset.
2146 if formset:
2147 media = self.media + formset.media
2148 else:
2149 media = self.media
2150
2151 # Build the action form and populate it with available actions.
2152 if actions:
2153 action_form = self.action_form(auto_id=None)
2154 action_form.fields["action"].choices = self.get_action_choices(request)
2155 media += action_form.media
2156 else:
2157 action_form = None
2158
2159 selection_note_all = ngettext(
2160 "%(total_count)s selected", "All %(total_count)s selected", cl.result_count
2161 )
2162
2163 context = {
2164 **self.admin_site.each_context(request),
2165 "module_name": str(self.opts.verbose_name_plural),
2166 "selection_note": _("0 of %(cnt)s selected") % {"cnt": len(cl.result_list)},
2167 "selection_note_all": selection_note_all % {"total_count": cl.result_count},
2168 "title": cl.title,
2169 "subtitle": None,
2170 "is_popup": cl.is_popup,
2171 "to_field": cl.to_field,
2172 "cl": cl,
2173 "media": media,
2174 "has_add_permission": self.has_add_permission(request),
2175 "opts": cl.opts,
2176 "action_form": action_form,
2177 "actions_on_top": self.actions_on_top,
2178 "actions_on_bottom": self.actions_on_bottom,
2179 "actions_selection_counter": self.actions_selection_counter,
2180 "preserved_filters": self.get_preserved_filters(request),
2181 **(extra_context or {}),
2182 }
2183
2184 request.current_app = self.admin_site.name
2185
2186 return TemplateResponse(
2187 request,
2188 self.change_list_template
2189 or [
2190 "admin/%s/%s/change_list.html" % (app_label, self.opts.model_name),
2191 "admin/%s/change_list.html" % app_label,
2192 "admin/change_list.html",
2193 ],
2194 context,
2195 )
2196
2197 def get_deleted_objects(self, objs, request):
2198 """
2199 Hook for customizing the delete process for the delete view and the
2200 "delete selected" action.
2201 """
2202 return get_deleted_objects(objs, request, self.admin_site)
2203
2204 @csrf_protect_m
2205 def delete_view(self, request, object_id, extra_context=None):
2206 if request.method in ("GET", "HEAD", "OPTIONS", "TRACE"):
2207 return self._delete_view(request, object_id, extra_context)
2208
2209 with transaction.atomic(using=router.db_for_write(self.model)):
2210 return self._delete_view(request, object_id, extra_context)
2211
2212 def _delete_view(self, request, object_id, extra_context):
2213 "The 'delete' admin view for this model."
2214 app_label = self.opts.app_label
2215
2216 to_field = request.POST.get(TO_FIELD_VAR, request.GET.get(TO_FIELD_VAR))
2217 if to_field and not self.to_field_allowed(request, to_field):
2218 raise DisallowedModelAdminToField(
2219 "The field %s cannot be referenced." % to_field
2220 )
2221
2222 obj = self.get_object(request, unquote(object_id), to_field)
2223
2224 if not self.has_delete_permission(request, obj):
2225 raise PermissionDenied
2226
2227 if obj is None:
2228 return self._get_obj_does_not_exist_redirect(request, self.opts, object_id)
2229
2230 # Populate deleted_objects, a data structure of all related objects that
2231 # will also be deleted.
2232 (
2233 deleted_objects,
2234 model_count,
2235 perms_needed,
2236 protected,
2237 ) = self.get_deleted_objects([obj], request)
2238
2239 if request.POST and not protected: # The user has confirmed the deletion.
2240 if perms_needed:
2241 raise PermissionDenied
2242 obj_display = str(obj)
2243 attr = str(to_field) if to_field else self.opts.pk.attname
2244 obj_id = obj.serializable_value(attr)
2245 self.log_deletions(request, [obj])
2246 self.delete_model(request, obj)
2247
2248 return self.response_delete(request, obj_display, obj_id)
2249
2250 object_name = str(self.opts.verbose_name)
2251
2252 if perms_needed or protected:
2253 title = _("Cannot delete %(name)s") % {"name": object_name}
2254 else:
2255 title = _("Delete")
2256
2257 context = {
2258 **self.admin_site.each_context(request),
2259 "title": title,
2260 "subtitle": None,
2261 "object_name": object_name,
2262 "object": obj,
2263 "deleted_objects": deleted_objects,
2264 "model_count": dict(model_count).items(),
2265 "perms_lacking": perms_needed,
2266 "protected": protected,
2267 "opts": self.opts,
2268 "app_label": app_label,
2269 "preserved_filters": self.get_preserved_filters(request),
2270 "is_popup": IS_POPUP_VAR in request.POST or IS_POPUP_VAR in request.GET,
2271 "to_field": to_field,
2272 **(extra_context or {}),
2273 }
2274
2275 return self.render_delete_form(request, context)
2276
2277 def history_view(self, request, object_id, extra_context=None):
2278 "The 'history' admin view for this model."
2279 from django.contrib.admin.models import LogEntry
2280 from django.contrib.admin.views.main import PAGE_VAR
2281
2282 # First check if the user can see this history.
2283 model = self.model
2284 obj = self.get_object(request, unquote(object_id))
2285 if obj is None:
2286 return self._get_obj_does_not_exist_redirect(
2287 request, model._meta, object_id
2288 )
2289
2290 if not self.has_view_or_change_permission(request, obj):
2291 raise PermissionDenied
2292
2293 # Then get the history for this object.
2294 app_label = self.opts.app_label
2295 action_list = (
2296 LogEntry.objects.filter(
2297 object_id=unquote(object_id),
2298 content_type=get_content_type_for_model(model),
2299 )
2300 .select_related()
2301 .order_by("action_time")
2302 )
2303
2304 paginator = self.get_paginator(request, action_list, 100)
2305 page_number = request.GET.get(PAGE_VAR, 1)
2306 page_obj = paginator.get_page(page_number)
2307 page_range = paginator.get_elided_page_range(page_obj.number)
2308
2309 context = {
2310 **self.admin_site.each_context(request),
2311 "title": _("Change history: %s") % obj,
2312 "subtitle": None,
2313 "action_list": page_obj,
2314 "page_range": page_range,
2315 "page_var": PAGE_VAR,
2316 "pagination_required": paginator.count > 100,
2317 "module_name": str(capfirst(self.opts.verbose_name_plural)),
2318 "object": obj,
2319 "opts": self.opts,
2320 "preserved_filters": self.get_preserved_filters(request),
2321 **(extra_context or {}),
2322 }
2323
2324 request.current_app = self.admin_site.name
2325
2326 return TemplateResponse(
2327 request,
2328 self.object_history_template
2329 or [
2330 "admin/%s/%s/object_history.html" % (app_label, self.opts.model_name),
2331 "admin/%s/object_history.html" % app_label,
2332 "admin/object_history.html",
2333 ],
2334 context,
2335 )
2336
2337 def get_formset_kwargs(self, request, obj, inline, prefix):
2338 formset_params = {
2339 "instance": obj,
2340 "prefix": prefix,
2341 "queryset": inline.get_queryset(request),
2342 }
2343 if request.method == "POST":
2344 formset_params.update(
2345 {
2346 "data": request.POST.copy(),
2347 "files": request.FILES,
2348 "save_as_new": "_saveasnew" in request.POST,
2349 }
2350 )
2351 return formset_params
2352
2353 def _create_formsets(self, request, obj, change):
2354 "Helper function to generate formsets for add/change_view."
2355 formsets = []
2356 inline_instances = []
2357 prefixes = {}
2358 get_formsets_args = [request]
2359 if change:
2360 get_formsets_args.append(obj)
2361 for FormSet, inline in self.get_formsets_with_inlines(*get_formsets_args):
2362 prefix = FormSet.get_default_prefix()
2363 prefixes[prefix] = prefixes.get(prefix, 0) + 1
2364 if prefixes[prefix] != 1 or not prefix:
2365 prefix = "%s-%s" % (prefix, prefixes[prefix])
2366 formset_params = self.get_formset_kwargs(request, obj, inline, prefix)
2367 formset = FormSet(**formset_params)
2368
2369 def user_deleted_form(request, obj, formset, index, inline):
2370 """Return whether or not the user deleted the form."""
2371 return (
2372 inline.has_delete_permission(request, obj)
2373 and "{}-{}-DELETE".format(formset.prefix, index) in request.POST
2374 )
2375
2376 # Bypass validation of each view-only inline form (since the form's
2377 # data won't be in request.POST), unless the form was deleted.
2378 if not inline.has_change_permission(request, obj if change else None):
2379 for index, form in enumerate(formset.initial_forms):
2380 if user_deleted_form(request, obj, formset, index, inline):
2381 continue
2382 form._errors = {}
2383 form.cleaned_data = form.initial
2384 formsets.append(formset)
2385 inline_instances.append(inline)
2386 return formsets, inline_instances
2387
2388
2389 class InlineModelAdmin(BaseModelAdmin):
2390 """
2391 Options for inline editing of ``model`` instances.
2392
2393 Provide ``fk_name`` to specify the attribute name of the ``ForeignKey``
2394 from ``model`` to its parent. This is required if ``model`` has more than
2395 one ``ForeignKey`` to its parent.
2396 """
2397
2398 model = None
2399 fk_name = None
2400 formset = BaseInlineFormSet
2401 extra = 3
2402 min_num = None
2403 max_num = None
2404 template = None
2405 verbose_name = None
2406 verbose_name_plural = None
2407 can_delete = True
2408 show_change_link = False
2409 checks_class = InlineModelAdminChecks
2410 classes = None
2411
2412 def __init__(self, parent_model, admin_site):
2413 self.admin_site = admin_site
2414 self.parent_model = parent_model
2415 self.opts = self.model._meta
2416 self.has_registered_model = admin_site.is_registered(self.model)
2417 super().__init__()
2418 if self.verbose_name_plural is None:
2419 if self.verbose_name is None:
2420 self.verbose_name_plural = self.opts.verbose_name_plural
2421 else:
2422 self.verbose_name_plural = format_lazy("{}s", self.verbose_name)
2423 if self.verbose_name is None:
2424 self.verbose_name = self.opts.verbose_name
2425
2426 @property
2427 def media(self):
2428 extra = "" if settings.DEBUG else ".min"
2429 js = ["vendor/jquery/jquery%s.js" % extra, "jquery.init.js", "inlines.js"]
2430 if self.filter_vertical or self.filter_horizontal:
2431 js.extend(["SelectBox.js", "SelectFilter2.js"])
2432 return forms.Media(js=["admin/js/%s" % url for url in js])
2433
2434 def get_extra(self, request, obj=None, **kwargs):
2435 """Hook for customizing the number of extra inline forms."""
2436 return self.extra
2437
2438 def get_min_num(self, request, obj=None, **kwargs):
2439 """Hook for customizing the min number of inline forms."""
2440 return self.min_num
2441
2442 def get_max_num(self, request, obj=None, **kwargs):
2443 """Hook for customizing the max number of extra inline forms."""
2444 return self.max_num
2445
2446 def get_formset(self, request, obj=None, **kwargs):
2447 """Return a BaseInlineFormSet class for use in admin add/change views."""
2448 if "fields" in kwargs:
2449 fields = kwargs.pop("fields")
2450 else:
2451 fields = flatten_fieldsets(self.get_fieldsets(request, obj))
2452 excluded = self.get_exclude(request, obj)
2453 exclude = [] if excluded is None else list(excluded)
2454 exclude.extend(self.get_readonly_fields(request, obj))
2455 if excluded is None and hasattr(self.form, "_meta") and self.form._meta.exclude:
2456 # Take the custom ModelForm's Meta.exclude into account only if the
2457 # InlineModelAdmin doesn't define its own.
2458 exclude.extend(self.form._meta.exclude)
2459 # If exclude is an empty list we use None, since that's the actual
2460 # default.
2461 exclude = exclude or None
2462 can_delete = self.can_delete and self.has_delete_permission(request, obj)
2463 defaults = {
2464 "form": self.form,
2465 "formset": self.formset,
2466 "fk_name": self.fk_name,
2467 "fields": fields,
2468 "exclude": exclude,
2469 "formfield_callback": partial(self.formfield_for_dbfield, request=request),
2470 "extra": self.get_extra(request, obj, **kwargs),
2471 "min_num": self.get_min_num(request, obj, **kwargs),
2472 "max_num": self.get_max_num(request, obj, **kwargs),
2473 "can_delete": can_delete,
2474 **kwargs,
2475 }
2476
2477 base_model_form = defaults["form"]
2478 can_change = self.has_change_permission(request, obj) if request else True
2479 can_add = self.has_add_permission(request, obj) if request else True
2480
2481 class DeleteProtectedModelForm(base_model_form):
2482 def hand_clean_DELETE(self):
2483 """
2484 We don't validate the 'DELETE' field itself because on
2485 templates it's not rendered using the field information, but
2486 just using a generic "deletion_field" of the InlineModelAdmin.
2487 """
2488 if self.cleaned_data.get(DELETION_FIELD_NAME, False):
2489 using = router.db_for_write(self._meta.model)
2490 collector = NestedObjects(using=using)
2491 if self.instance._state.adding:
2492 return
2493 collector.collect([self.instance])
2494 if collector.protected:
2495 objs = []
2496 for p in collector.protected:
2497 objs.append(
2498 # Translators: Model verbose name and instance
2499 # representation, suitable to be an item in a
2500 # list.
2501 _("%(class_name)s %(instance)s")
2502 % {"class_name": p._meta.verbose_name, "instance": p}
2503 )
2504 params = {
2505 "class_name": self._meta.model._meta.verbose_name,
2506 "instance": self.instance,
2507 "related_objects": get_text_list(objs, _("and")),
2508 }
2509 msg = _(
2510 "Deleting %(class_name)s %(instance)s would require "
2511 "deleting the following protected related objects: "
2512 "%(related_objects)s"
2513 )
2514 raise ValidationError(
2515 msg, code="deleting_protected", params=params
2516 )
2517
2518 def is_valid(self):
2519 result = super().is_valid()
2520 self.hand_clean_DELETE()
2521 return result
2522
2523 def has_changed(self):
2524 # Protect against unauthorized edits.
2525 if not can_change and not self.instance._state.adding:
2526 return False
2527 if not can_add and self.instance._state.adding:
2528 return False
2529 return super().has_changed()
2530
2531 defaults["form"] = DeleteProtectedModelForm
2532
2533 if defaults["fields"] is None and not modelform_defines_fields(
2534 defaults["form"]
2535 ):
2536 defaults["fields"] = forms.ALL_FIELDS
2537
2538 return inlineformset_factory(self.parent_model, self.model, **defaults)
2539
2540 def _get_form_for_get_fields(self, request, obj=None):
2541 return self.get_formset(request, obj, fields=None).form
2542
2543 def get_queryset(self, request):
2544 queryset = super().get_queryset(request)
2545 if not self.has_view_or_change_permission(request):
2546 queryset = queryset.none()
2547 return queryset
2548
2549 def _has_any_perms_for_target_model(self, request, perms):
2550 """
2551 This method is called only when the ModelAdmin's model is for an
2552 ManyToManyField's implicit through model (if self.opts.auto_created).
2553 Return True if the user has any of the given permissions ('add',
2554 'change', etc.) for the model that points to the through model.
2555 """
2556 opts = self.opts
2557 # Find the target model of an auto-created many-to-many relationship.
2558 for field in opts.fields:
2559 if field.remote_field and field.remote_field.model != self.parent_model:
2560 opts = field.remote_field.model._meta
2561 break
2562 return any(
2563 request.user.has_perm(
2564 "%s.%s" % (opts.app_label, get_permission_codename(perm, opts))
2565 )
2566 for perm in perms
2567 )
2568
2569 def has_add_permission(self, request, obj):
2570 if self.opts.auto_created:
2571 # Auto-created intermediate models don't have their own
2572 # permissions. The user needs to have the change permission for the
2573 # related model in order to be able to do anything with the
2574 # intermediate model.
2575 return self._has_any_perms_for_target_model(request, ["change"])
2576 return super().has_add_permission(request)
2577
2578 def has_change_permission(self, request, obj=None):
2579 if self.opts.auto_created:
2580 # Same comment as has_add_permission().
2581 return self._has_any_perms_for_target_model(request, ["change"])
2582 return super().has_change_permission(request)
2583
2584 def has_delete_permission(self, request, obj=None):
2585 if self.opts.auto_created:
2586 # Same comment as has_add_permission().
2587 return self._has_any_perms_for_target_model(request, ["change"])
2588 return super().has_delete_permission(request, obj)
2589
2590 def has_view_permission(self, request, obj=None):
2591 if self.opts.auto_created:
2592 # Same comment as has_add_permission(). The 'change' permission
2593 # also implies the 'view' permission.
2594 return self._has_any_perms_for_target_model(request, ["view", "change"])
2595 return super().has_view_permission(request)
2596
2597
2598 class StackedInline(InlineModelAdmin):
2599 template = "admin/edit_inline/stacked.html"
2600
2601
2602 class TabularInline(InlineModelAdmin):
2603 template = "admin/edit_inline/tabular.html"