Debian Codegraph @

django/contrib/admin/helpers.py

raw
1 import json
2
3 from django import forms
4 from django.contrib.admin.utils import (
5 display_for_field,
6 flatten_fieldsets,
7 help_text_for_field,
8 label_for_field,
9 lookup_field,
10 quote,
11 )
12 from django.core.exceptions import ObjectDoesNotExist
13 from django.db.models.fields.related import (
14 ForeignObjectRel,
15 ManyToManyRel,
16 OneToOneField,
17 )
18 from django.forms.utils import flatatt
19 from django.template.defaultfilters import capfirst, linebreaksbr
20 from django.urls import NoReverseMatch, reverse
21 from django.utils.functional import cached_property
22 from django.utils.html import conditional_escape, format_html
23 from django.utils.safestring import mark_safe
24 from django.utils.translation import gettext
25 from django.utils.translation import gettext_lazy as _
26
27 ACTION_CHECKBOX_NAME = "_selected_action"
28
29
30 class ActionForm(forms.Form):
31 action = forms.ChoiceField(label=_("Action:"))
32 select_across = forms.BooleanField(
33 label="",
34 required=False,
35 initial=0,
36 widget=forms.HiddenInput({"class": "select-across"}),
37 )
38
39
40 class AdminForm:
41 def __init__(
42 self,
43 form,
44 fieldsets,
45 prepopulated_fields,
46 readonly_fields=None,
47 model_admin=None,
48 ):
49 self.form, self.fieldsets = form, fieldsets
50 self.prepopulated_fields = [
51 {"field": form[field_name], "dependencies": [form[f] for f in dependencies]}
52 for field_name, dependencies in prepopulated_fields.items()
53 ]
54 self.model_admin = model_admin
55 if readonly_fields is None:
56 readonly_fields = ()
57 self.readonly_fields = readonly_fields
58
59 def __repr__(self):
60 return (
61 f"<{self.__class__.__qualname__}: "
62 f"form={self.form.__class__.__qualname__} "
63 f"fieldsets={self.fieldsets!r}>"
64 )
65
66 def __iter__(self):
67 for name, options in self.fieldsets:
68 yield Fieldset(
69 self.form,
70 name,
71 readonly_fields=self.readonly_fields,
72 model_admin=self.model_admin,
73 **options,
74 )
75
76 @property
77 def errors(self):
78 return self.form.errors
79
80 @property
81 def non_field_errors(self):
82 return self.form.non_field_errors
83
84 @property
85 def fields(self):
86 return self.form.fields
87
88 @property
89 def is_bound(self):
90 return self.form.is_bound
91
92 @property
93 def media(self):
94 media = self.form.media
95 for fs in self:
96 media += fs.media
97 return media
98
99
100 class Fieldset:
101 def __init__(
102 self,
103 form,
104 name=None,
105 readonly_fields=(),
106 fields=(),
107 classes=(),
108 description=None,
109 model_admin=None,
110 ):
111 self.form = form
112 self.name, self.fields = name, fields
113 self.classes = " ".join(classes)
114 self.description = description
115 self.model_admin = model_admin
116 self.readonly_fields = readonly_fields
117
118 @property
119 def media(self):
120 return forms.Media()
121
122 @cached_property
123 def is_collapsible(self):
124 if any(field in self.fields for field in self.form.errors):
125 return False
126 return "collapse" in self.classes
127
128 def __iter__(self):
129 for field in self.fields:
130 yield Fieldline(
131 self.form, field, self.readonly_fields, model_admin=self.model_admin
132 )
133
134
135 class Fieldline:
136 def __init__(self, form, field, readonly_fields=None, model_admin=None):
137 self.form = form # A django.forms.Form instance
138 if not hasattr(field, "__iter__") or isinstance(field, str):
139 self.fields = [field]
140 else:
141 self.fields = field
142 self.has_visible_field = not all(
143 field in self.form.fields and self.form.fields[field].widget.is_hidden
144 for field in self.fields
145 )
146 self.model_admin = model_admin
147 if readonly_fields is None:
148 readonly_fields = ()
149 self.readonly_fields = readonly_fields
150
151 def __iter__(self):
152 for i, field in enumerate(self.fields):
153 if field in self.readonly_fields:
154 yield AdminReadonlyField(
155 self.form, field, is_first=(i == 0), model_admin=self.model_admin
156 )
157 else:
158 yield AdminField(self.form, field, is_first=(i == 0))
159
160 def errors(self):
161 return mark_safe(
162 "\n".join(
163 self.form[f].errors.as_ul()
164 for f in self.fields
165 if f not in self.readonly_fields
166 ).strip("\n")
167 )
168
169
170 class AdminField:
171 def __init__(self, form, field, is_first):
172 self.field = form[field] # A django.forms.BoundField instance
173 self.is_first = is_first # Whether this field is first on the line
174 self.is_checkbox = isinstance(self.field.field.widget, forms.CheckboxInput)
175 self.is_readonly = False
176
177 def label_tag(self):
178 classes = []
179 contents = conditional_escape(self.field.label)
180 if self.is_checkbox:
181 classes.append("vCheckboxLabel")
182
183 if self.field.field.required:
184 classes.append("required")
185 if not self.is_first:
186 classes.append("inline")
187 attrs = {"class": " ".join(classes)} if classes else {}
188 # checkboxes should not have a label suffix as the checkbox appears
189 # to the left of the label.
190 return self.field.label_tag(
191 contents=mark_safe(contents),
192 attrs=attrs,
193 label_suffix="" if self.is_checkbox else None,
194 )
195
196 def errors(self):
197 return mark_safe(self.field.errors.as_ul())
198
199
200 class AdminReadonlyField:
201 def __init__(self, form, field, is_first, model_admin=None):
202 # Make self.field look a little bit like a field. This means that
203 # {{ field.name }} must be a useful class name to identify the field.
204 # For convenience, store other field-related data here too.
205 if callable(field):
206 class_name = field.__name__ if field.__name__ != "<lambda>" else ""
207 else:
208 class_name = field
209
210 if form._meta.labels and class_name in form._meta.labels:
211 label = form._meta.labels[class_name]
212 else:
213 label = label_for_field(field, form._meta.model, model_admin, form=form)
214
215 if form._meta.help_texts and class_name in form._meta.help_texts:
216 help_text = form._meta.help_texts[class_name]
217 else:
218 help_text = help_text_for_field(class_name, form._meta.model)
219
220 if field in form.fields:
221 is_hidden = form.fields[field].widget.is_hidden
222 else:
223 is_hidden = False
224
225 self.field = {
226 "name": class_name,
227 "label": label,
228 "help_text": help_text,
229 "field": field,
230 "is_hidden": is_hidden,
231 }
232 self.form = form
233 self.model_admin = model_admin
234 self.is_first = is_first
235 self.is_checkbox = False
236 self.is_readonly = True
237 self.empty_value_display = model_admin.get_empty_value_display()
238
239 def label_tag(self):
240 attrs = {}
241 if not self.is_first:
242 attrs["class"] = "inline"
243 label = self.field["label"]
244 return format_html(
245 "<label{}>{}{}</label>",
246 flatatt(attrs),
247 capfirst(label),
248 self.form.label_suffix,
249 )
250
251 def get_admin_url(self, remote_field, remote_obj):
252 url_name = "admin:%s_%s_change" % (
253 remote_field.model._meta.app_label,
254 remote_field.model._meta.model_name,
255 )
256 try:
257 url = reverse(
258 url_name,
259 args=[quote(remote_obj.pk)],
260 current_app=self.model_admin.admin_site.name,
261 )
262 return format_html('<a href="{}">{}</a>', url, remote_obj)
263 except NoReverseMatch:
264 return str(remote_obj)
265
266 def contents(self):
267 from django.contrib.admin.templatetags.admin_list import _boolean_icon
268
269 field, obj, model_admin = (
270 self.field["field"],
271 self.form.instance,
272 self.model_admin,
273 )
274 try:
275 f, attr, value = lookup_field(field, obj, model_admin)
276 except (AttributeError, ValueError, ObjectDoesNotExist):
277 result_repr = self.empty_value_display
278 else:
279 if field in self.form.fields:
280 widget = self.form[field].field.widget
281 # This isn't elegant but suffices for contrib.auth's
282 # ReadOnlyPasswordHashWidget.
283 if getattr(widget, "read_only", False):
284 return widget.render(field, value)
285 if f is None:
286 if getattr(attr, "boolean", False):
287 result_repr = _boolean_icon(value)
288 else:
289 if hasattr(value, "__html__"):
290 result_repr = value
291 else:
292 result_repr = linebreaksbr(value)
293 else:
294 if isinstance(f.remote_field, ManyToManyRel) and value is not None:
295 result_repr = ", ".join(map(str, value.all()))
296 elif (
297 isinstance(f.remote_field, (ForeignObjectRel, OneToOneField))
298 and value is not None
299 ):
300 result_repr = self.get_admin_url(f.remote_field, value)
301 else:
302 result_repr = display_for_field(value, f, self.empty_value_display)
303 result_repr = linebreaksbr(result_repr)
304 return conditional_escape(result_repr)
305
306
307 class InlineAdminFormSet:
308 """
309 A wrapper around an inline formset for use in the admin system.
310 """
311
312 def __init__(
313 self,
314 inline,
315 formset,
316 fieldsets,
317 prepopulated_fields=None,
318 readonly_fields=None,
319 model_admin=None,
320 has_add_permission=True,
321 has_change_permission=True,
322 has_delete_permission=True,
323 has_view_permission=True,
324 ):
325 self.opts = inline
326 self.formset = formset
327 self.fieldsets = fieldsets
328 self.model_admin = model_admin
329 if readonly_fields is None:
330 readonly_fields = ()
331 self.readonly_fields = readonly_fields
332 if prepopulated_fields is None:
333 prepopulated_fields = {}
334 self.prepopulated_fields = prepopulated_fields
335 self.classes = " ".join(inline.classes) if inline.classes else ""
336 self.has_add_permission = has_add_permission
337 self.has_change_permission = has_change_permission
338 self.has_delete_permission = has_delete_permission
339 self.has_view_permission = has_view_permission
340
341 def __iter__(self):
342 if self.has_change_permission:
343 readonly_fields_for_editing = self.readonly_fields
344 else:
345 readonly_fields_for_editing = self.readonly_fields + flatten_fieldsets(
346 self.fieldsets
347 )
348
349 for form, original in zip(
350 self.formset.initial_forms, self.formset.get_queryset()
351 ):
352 view_on_site_url = self.opts.get_view_on_site_url(original)
353 yield InlineAdminForm(
354 self.formset,
355 form,
356 self.fieldsets,
357 self.prepopulated_fields,
358 original,
359 readonly_fields_for_editing,
360 model_admin=self.opts,
361 view_on_site_url=view_on_site_url,
362 )
363 for form in self.formset.extra_forms:
364 yield InlineAdminForm(
365 self.formset,
366 form,
367 self.fieldsets,
368 self.prepopulated_fields,
369 None,
370 self.readonly_fields,
371 model_admin=self.opts,
372 )
373 if self.has_add_permission:
374 yield InlineAdminForm(
375 self.formset,
376 self.formset.empty_form,
377 self.fieldsets,
378 self.prepopulated_fields,
379 None,
380 self.readonly_fields,
381 model_admin=self.opts,
382 )
383
384 def fields(self):
385 fk = getattr(self.formset, "fk", None)
386 empty_form = self.formset.empty_form
387 meta_labels = empty_form._meta.labels or {}
388 meta_help_texts = empty_form._meta.help_texts or {}
389 for i, field_name in enumerate(flatten_fieldsets(self.fieldsets)):
390 if fk and fk.name == field_name:
391 continue
392 if not self.has_change_permission or field_name in self.readonly_fields:
393 form_field = empty_form.fields.get(field_name)
394 widget_is_hidden = False
395 if form_field is not None:
396 widget_is_hidden = form_field.widget.is_hidden
397 yield {
398 "name": field_name,
399 "label": meta_labels.get(field_name)
400 or label_for_field(
401 field_name,
402 self.opts.model,
403 self.opts,
404 form=empty_form,
405 ),
406 "widget": {"is_hidden": widget_is_hidden},
407 "required": False,
408 "help_text": meta_help_texts.get(field_name)
409 or help_text_for_field(field_name, self.opts.model),
410 }
411 else:
412 form_field = empty_form.fields[field_name]
413 label = form_field.label
414 if label is None:
415 label = label_for_field(
416 field_name, self.opts.model, self.opts, form=empty_form
417 )
418 yield {
419 "name": field_name,
420 "label": label,
421 "widget": form_field.widget,
422 "required": form_field.required,
423 "help_text": form_field.help_text,
424 }
425
426 def inline_formset_data(self):
427 verbose_name = self.opts.verbose_name
428 return json.dumps(
429 {
430 "name": "#%s" % self.formset.prefix,
431 "options": {
432 "prefix": self.formset.prefix,
433 "addText": gettext("Add another %(verbose_name)s")
434 % {
435 "verbose_name": capfirst(verbose_name),
436 },
437 "deleteText": gettext("Remove"),
438 },
439 }
440 )
441
442 @property
443 def forms(self):
444 return self.formset.forms
445
446 @cached_property
447 def is_collapsible(self):
448 if any(self.formset.errors):
449 return False
450 return "collapse" in self.classes
451
452 def non_form_errors(self):
453 return self.formset.non_form_errors()
454
455 @property
456 def is_bound(self):
457 return self.formset.is_bound
458
459 @property
460 def total_form_count(self):
461 return self.formset.total_form_count
462
463 @property
464 def media(self):
465 media = self.opts.media + self.formset.media
466 for fs in self:
467 media += fs.media
468 return media
469
470
471 class InlineAdminForm(AdminForm):
472 """
473 A wrapper around an inline form for use in the admin system.
474 """
475
476 def __init__(
477 self,
478 formset,
479 form,
480 fieldsets,
481 prepopulated_fields,
482 original,
483 readonly_fields=None,
484 model_admin=None,
485 view_on_site_url=None,
486 ):
487 self.formset = formset
488 self.model_admin = model_admin
489 self.original = original
490 self.show_url = original and view_on_site_url is not None
491 self.absolute_url = view_on_site_url
492 super().__init__(
493 form, fieldsets, prepopulated_fields, readonly_fields, model_admin
494 )
495
496 def __iter__(self):
497 for name, options in self.fieldsets:
498 yield InlineFieldset(
499 self.formset,
500 self.form,
501 name,
502 self.readonly_fields,
503 model_admin=self.model_admin,
504 **options,
505 )
506
507 def needs_explicit_pk_field(self):
508 return (
509 # Auto fields are editable, so check for auto or non-editable pk.
510 self.form._meta.model._meta.auto_field
511 or not self.form._meta.model._meta.pk.editable
512 # The pk can be editable, but excluded from the inline.
513 or (
514 self.form._meta.exclude
515 and self.form._meta.model._meta.pk.name in self.form._meta.exclude
516 )
517 or
518 # Also search any parents for an auto field. (The pk info is
519 # propagated to child models so that does not need to be checked
520 # in parents.)
521 any(
522 parent._meta.auto_field or not parent._meta.model._meta.pk.editable
523 for parent in self.form._meta.model._meta.all_parents
524 )
525 )
526
527 def pk_field(self):
528 return AdminField(self.form, self.formset._pk_field.name, False)
529
530 def fk_field(self):
531 fk = getattr(self.formset, "fk", None)
532 if fk:
533 return AdminField(self.form, fk.name, False)
534 else:
535 return ""
536
537 def deletion_field(self):
538 from django.forms.formsets import DELETION_FIELD_NAME
539
540 return AdminField(self.form, DELETION_FIELD_NAME, False)
541
542
543 class InlineFieldset(Fieldset):
544 def __init__(self, formset, *args, **kwargs):
545 self.formset = formset
546 super().__init__(*args, **kwargs)
547
548 def __iter__(self):
549 fk = getattr(self.formset, "fk", None)
550 for field in self.fields:
551 if not fk or fk.name != field:
552 yield Fieldline(
553 self.form, field, self.readonly_fields, model_admin=self.model_admin
554 )
555
556
557 class AdminErrorList(forms.utils.ErrorList):
558 """Store errors for the form/formsets in an add/change view."""
559
560 def __init__(self, form, inline_formsets):
561 super().__init__()
562
563 if form.is_bound:
564 self.extend(form.errors.values())
565 for inline_formset in inline_formsets:
566 self.extend(inline_formset.non_form_errors())
567 for errors_in_inline_form in inline_formset.errors:
568 self.extend(errors_in_inline_form.values())