Debian Codegraph @

django/contrib/admin/widgets.py

raw
1 """
2 Form Widget classes specific to the Django admin site.
3 """
4
5 import copy
6 import json
7
8 from django import forms
9 from django.conf import settings
10 from django.core.exceptions import ValidationError
11 from django.core.validators import URLValidator
12 from django.db.models import CASCADE, UUIDField
13 from django.urls import reverse
14 from django.urls.exceptions import NoReverseMatch
15 from django.utils.html import smart_urlquote
16 from django.utils.http import urlencode
17 from django.utils.text import Truncator
18 from django.utils.translation import get_language
19 from django.utils.translation import gettext as _
20
21
22 class FilteredSelectMultiple(forms.SelectMultiple):
23 """
24 A SelectMultiple with a JavaScript filter interface.
25
26 Note that the resulting JavaScript assumes that the jsi18n
27 catalog has been loaded in the page
28 """
29
30 class Media:
31 js = [
32 "admin/js/core.js",
33 "admin/js/SelectBox.js",
34 "admin/js/SelectFilter2.js",
35 ]
36
37 def __init__(self, verbose_name, is_stacked, attrs=None, choices=()):
38 self.verbose_name = verbose_name
39 self.is_stacked = is_stacked
40 super().__init__(attrs, choices)
41
42 def get_context(self, name, value, attrs):
43 context = super().get_context(name, value, attrs)
44 context["widget"]["attrs"]["class"] = "selectfilter"
45 if self.is_stacked:
46 context["widget"]["attrs"]["class"] += "stacked"
47 context["widget"]["attrs"]["data-field-name"] = self.verbose_name
48 context["widget"]["attrs"]["data-is-stacked"] = int(self.is_stacked)
49 return context
50
51
52 class BaseAdminDateWidget(forms.DateInput):
53 class Media:
54 js = [
55 "admin/js/calendar.js",
56 "admin/js/admin/DateTimeShortcuts.js",
57 ]
58
59 def __init__(self, attrs=None, format=None):
60 attrs = {"class": "vDateField", "size": "10", **(attrs or {})}
61 super().__init__(attrs=attrs, format=format)
62
63
64 class AdminDateWidget(BaseAdminDateWidget):
65 template_name = "admin/widgets/date.html"
66
67
68 class BaseAdminTimeWidget(forms.TimeInput):
69 class Media:
70 js = [
71 "admin/js/calendar.js",
72 "admin/js/admin/DateTimeShortcuts.js",
73 ]
74
75 def __init__(self, attrs=None, format=None):
76 attrs = {"class": "vTimeField", "size": "8", **(attrs or {})}
77 super().__init__(attrs=attrs, format=format)
78
79
80 class AdminTimeWidget(BaseAdminTimeWidget):
81 template_name = "admin/widgets/time.html"
82
83
84 class AdminSplitDateTime(forms.SplitDateTimeWidget):
85 """
86 A SplitDateTime Widget that has some admin-specific styling.
87 """
88
89 template_name = "admin/widgets/split_datetime.html"
90
91 def __init__(self, attrs=None):
92 widgets = [BaseAdminDateWidget, BaseAdminTimeWidget]
93 # Note that we're calling MultiWidget, not SplitDateTimeWidget, because
94 # we want to define widgets.
95 forms.MultiWidget.__init__(self, widgets, attrs)
96
97 def get_context(self, name, value, attrs):
98 context = super().get_context(name, value, attrs)
99 context["date_label"] = _("Date:")
100 context["time_label"] = _("Time:")
101 return context
102
103
104 class AdminRadioSelect(forms.RadioSelect):
105 template_name = "admin/widgets/radio.html"
106
107
108 class AdminFileWidget(forms.ClearableFileInput):
109 template_name = "admin/widgets/clearable_file_input.html"
110
111
112 def url_params_from_lookup_dict(lookups):
113 """
114 Convert the type of lookups specified in a ForeignKey limit_choices_to
115 attribute to a dictionary of query parameters
116 """
117 params = {}
118 if lookups and hasattr(lookups, "items"):
119 for k, v in lookups.items():
120 if callable(v):
121 v = v()
122 if isinstance(v, (tuple, list)):
123 v = ",".join(str(x) for x in v)
124 elif isinstance(v, bool):
125 v = ("0", "1")[v]
126 else:
127 v = str(v)
128 params[k] = v
129 return params
130
131
132 class ForeignKeyRawIdWidget(forms.TextInput):
133 """
134 A Widget for displaying ForeignKeys in the "raw_id" interface rather than
135 in a <select> box.
136 """
137
138 template_name = "admin/widgets/foreign_key_raw_id.html"
139
140 def __init__(self, rel, admin_site, attrs=None, using=None):
141 self.rel = rel
142 self.admin_site = admin_site
143 self.db = using
144 super().__init__(attrs)
145
146 def get_context(self, name, value, attrs):
147 context = super().get_context(name, value, attrs)
148 rel_to = self.rel.model
149 if self.admin_site.is_registered(rel_to):
150 # The related object is registered with the same AdminSite
151 related_url = reverse(
152 "admin:%s_%s_changelist"
153 % (
154 rel_to._meta.app_label,
155 rel_to._meta.model_name,
156 ),
157 current_app=self.admin_site.name,
158 )
159
160 params = self.url_parameters()
161 if params:
162 related_url += "?" + urlencode(params)
163 context["related_url"] = related_url
164 context["link_title"] = _("Lookup")
165 # The JavaScript code looks for this class.
166 css_class = "vForeignKeyRawIdAdminField"
167 if isinstance(self.rel.get_related_field(), UUIDField):
168 css_class += " vUUIDField"
169 context["widget"]["attrs"].setdefault("class", css_class)
170 else:
171 context["related_url"] = None
172 if context["widget"]["value"]:
173 context["link_label"], context["link_url"] = self.label_and_url_for_value(
174 value
175 )
176 else:
177 context["link_label"] = None
178 return context
179
180 def base_url_parameters(self):
181 limit_choices_to = self.rel.limit_choices_to
182 if callable(limit_choices_to):
183 limit_choices_to = limit_choices_to()
184 return url_params_from_lookup_dict(limit_choices_to)
185
186 def url_parameters(self):
187 from django.contrib.admin.views.main import TO_FIELD_VAR
188
189 params = self.base_url_parameters()
190 params.update({TO_FIELD_VAR: self.rel.get_related_field().name})
191 return params
192
193 def label_and_url_for_value(self, value):
194 key = self.rel.get_related_field().name
195 try:
196 obj = self.rel.model._default_manager.using(self.db).get(**{key: value})
197 except (ValueError, self.rel.model.DoesNotExist, ValidationError):
198 return "", ""
199
200 try:
201 url = reverse(
202 "%s:%s_%s_change"
203 % (
204 self.admin_site.name,
205 obj._meta.app_label,
206 obj._meta.model_name,
207 ),
208 args=(obj.pk,),
209 )
210 except NoReverseMatch:
211 url = "" # Admin not registered for target model.
212
213 return Truncator(obj).words(14), url
214
215
216 class ManyToManyRawIdWidget(ForeignKeyRawIdWidget):
217 """
218 A Widget for displaying ManyToMany ids in the "raw_id" interface rather than
219 in a <select multiple> box.
220 """
221
222 template_name = "admin/widgets/many_to_many_raw_id.html"
223
224 def get_context(self, name, value, attrs):
225 context = super().get_context(name, value, attrs)
226 if self.admin_site.is_registered(self.rel.model):
227 # The related object is registered with the same AdminSite
228 context["widget"]["attrs"]["class"] = "vManyToManyRawIdAdminField"
229 return context
230
231 def url_parameters(self):
232 return self.base_url_parameters()
233
234 def label_and_url_for_value(self, value):
235 return "", ""
236
237 def value_from_datadict(self, data, files, name):
238 value = data.get(name)
239 if value:
240 return value.split(",")
241
242 def format_value(self, value):
243 return ",".join(str(v) for v in value) if value else ""
244
245
246 class RelatedFieldWidgetWrapper(forms.Widget):
247 """
248 This class is a wrapper to a given widget to add the add icon for the
249 admin interface.
250 """
251
252 template_name = "admin/widgets/related_widget_wrapper.html"
253
254 def __init__(
255 self,
256 widget,
257 rel,
258 admin_site,
259 can_add_related=None,
260 can_change_related=False,
261 can_delete_related=False,
262 can_view_related=False,
263 ):
264 self.needs_multipart_form = widget.needs_multipart_form
265 self.attrs = widget.attrs
266 self.widget = widget
267 self.rel = rel
268 # Backwards compatible check for whether a user can add related
269 # objects.
270 if can_add_related is None:
271 can_add_related = admin_site.is_registered(rel.model)
272 self.can_add_related = can_add_related
273 # XXX: The UX does not support multiple selected values.
274 multiple = getattr(widget, "allow_multiple_selected", False)
275 if not isinstance(widget, AutocompleteMixin):
276 self.attrs["data-context"] = "available-source"
277 self.can_change_related = not multiple and can_change_related
278 # XXX: The deletion UX can be confusing when dealing with cascading deletion.
279 cascade = getattr(rel, "on_delete", None) is CASCADE
280 self.can_delete_related = not multiple and not cascade and can_delete_related
281 self.can_view_related = not multiple and can_view_related
282 # so we can check if the related object is registered with this AdminSite
283 self.admin_site = admin_site
284
285 def __deepcopy__(self, memo):
286 obj = copy.copy(self)
287 obj.widget = copy.deepcopy(self.widget, memo)
288 obj.attrs = self.widget.attrs
289 memo[id(self)] = obj
290 return obj
291
292 @property
293 def is_hidden(self):
294 return self.widget.is_hidden
295
296 @property
297 def media(self):
298 return self.widget.media
299
300 @property
301 def choices(self):
302 return self.widget.choices
303
304 @choices.setter
305 def choices(self, value):
306 self.widget.choices = value
307
308 def get_related_url(self, info, action, *args):
309 return reverse(
310 "admin:%s_%s_%s" % (info + (action,)),
311 current_app=self.admin_site.name,
312 args=args,
313 )
314
315 def get_context(self, name, value, attrs):
316 from django.contrib.admin.views.main import IS_POPUP_VAR, TO_FIELD_VAR
317
318 rel_opts = self.rel.model._meta
319 info = (rel_opts.app_label, rel_opts.model_name)
320 related_field_name = self.rel.get_related_field().name
321 url_params = "&".join(
322 "%s=%s" % param
323 for param in [
324 (TO_FIELD_VAR, related_field_name),
325 (IS_POPUP_VAR, 1),
326 ]
327 )
328 context = {
329 "rendered_widget": self.widget.render(name, value, attrs),
330 "is_hidden": self.is_hidden,
331 "name": name,
332 "url_params": url_params,
333 "model": rel_opts.verbose_name,
334 "model_name": rel_opts.model_name,
335 "can_add_related": self.can_add_related,
336 "can_change_related": self.can_change_related,
337 "can_delete_related": self.can_delete_related,
338 "can_view_related": self.can_view_related,
339 "model_has_limit_choices_to": self.rel.limit_choices_to,
340 }
341 if self.can_add_related:
342 context["add_related_url"] = self.get_related_url(info, "add")
343 if self.can_delete_related:
344 context["delete_related_template_url"] = self.get_related_url(
345 info, "delete", "__fk__"
346 )
347 if self.can_view_related or self.can_change_related:
348 context["view_related_url_params"] = f"{TO_FIELD_VAR}={related_field_name}"
349 context["change_related_template_url"] = self.get_related_url(
350 info, "change", "__fk__"
351 )
352 return context
353
354 def value_from_datadict(self, data, files, name):
355 return self.widget.value_from_datadict(data, files, name)
356
357 def value_omitted_from_data(self, data, files, name):
358 return self.widget.value_omitted_from_data(data, files, name)
359
360 def id_for_label(self, id_):
361 return self.widget.id_for_label(id_)
362
363
364 class AdminTextareaWidget(forms.Textarea):
365 def __init__(self, attrs=None):
366 super().__init__(attrs={"class": "vLargeTextField", **(attrs or {})})
367
368
369 class AdminTextInputWidget(forms.TextInput):
370 def __init__(self, attrs=None):
371 super().__init__(attrs={"class": "vTextField", **(attrs or {})})
372
373
374 class AdminEmailInputWidget(forms.EmailInput):
375 def __init__(self, attrs=None):
376 super().__init__(attrs={"class": "vTextField", **(attrs or {})})
377
378
379 class AdminURLFieldWidget(forms.URLInput):
380 template_name = "admin/widgets/url.html"
381
382 def __init__(self, attrs=None, validator_class=URLValidator):
383 super().__init__(attrs={"class": "vURLField", **(attrs or {})})
384 self.validator = validator_class()
385
386 def get_context(self, name, value, attrs):
387 try:
388 self.validator(value if value else "")
389 url_valid = True
390 except ValidationError:
391 url_valid = False
392 context = super().get_context(name, value, attrs)
393 context["current_label"] = _("Currently:")
394 context["change_label"] = _("Change:")
395 context["widget"]["href"] = (
396 smart_urlquote(context["widget"]["value"]) if url_valid else ""
397 )
398 context["url_valid"] = url_valid
399 return context
400
401
402 class AdminIntegerFieldWidget(forms.NumberInput):
403 class_name = "vIntegerField"
404
405 def __init__(self, attrs=None):
406 super().__init__(attrs={"class": self.class_name, **(attrs or {})})
407
408
409 class AdminBigIntegerFieldWidget(AdminIntegerFieldWidget):
410 class_name = "vBigIntegerField"
411
412
413 class AdminUUIDInputWidget(forms.TextInput):
414 def __init__(self, attrs=None):
415 super().__init__(attrs={"class": "vUUIDField", **(attrs or {})})
416
417
418 # Mapping of lowercase language codes [returned by Django's get_language()] to
419 # language codes supported by select2.
420 # See django/contrib/admin/static/admin/js/vendor/select2/i18n/*
421 SELECT2_TRANSLATIONS = {
422 x.lower(): x
423 for x in [
424 "ar",
425 "az",
426 "bg",
427 "ca",
428 "cs",
429 "da",
430 "de",
431 "el",
432 "en",
433 "es",
434 "et",
435 "eu",
436 "fa",
437 "fi",
438 "fr",
439 "gl",
440 "he",
441 "hi",
442 "hr",
443 "hu",
444 "id",
445 "is",
446 "it",
447 "ja",
448 "km",
449 "ko",
450 "lt",
451 "lv",
452 "mk",
453 "ms",
454 "nb",
455 "nl",
456 "pl",
457 "pt-BR",
458 "pt",
459 "ro",
460 "ru",
461 "sk",
462 "sr-Cyrl",
463 "sr",
464 "sv",
465 "th",
466 "tr",
467 "uk",
468 "vi",
469 ]
470 }
471 SELECT2_TRANSLATIONS.update({"zh-hans": "zh-CN", "zh-hant": "zh-TW"})
472
473
474 def get_select2_language():
475 lang_code = get_language()
476 supported_code = SELECT2_TRANSLATIONS.get(lang_code)
477 if supported_code is None and lang_code is not None:
478 # If 'zh-hant-tw' is not supported, try subsequent language codes i.e.
479 # 'zh-hant' and 'zh'.
480 i = None
481 while (i := lang_code.rfind("-", 0, i)) > -1:
482 if supported_code := SELECT2_TRANSLATIONS.get(lang_code[:i]):
483 return supported_code
484 return supported_code
485
486
487 class AutocompleteMixin:
488 """
489 Select widget mixin that loads options from AutocompleteJsonView via AJAX.
490
491 Renders the necessary data attributes for select2 and adds the static form
492 media.
493 """
494
495 url_name = "%s:autocomplete"
496
497 def __init__(self, field, admin_site, attrs=None, choices=(), using=None):
498 self.field = field
499 self.admin_site = admin_site
500 self.db = using
501 self.choices = choices
502 self.attrs = {} if attrs is None else attrs.copy()
503 self.i18n_name = get_select2_language()
504
505 def get_url(self):
506 return reverse(self.url_name % self.admin_site.name)
507
508 def build_attrs(self, base_attrs, extra_attrs=None):
509 """
510 Set select2's AJAX attributes.
511
512 Attributes can be set using the html5 data attribute.
513 Nested attributes require a double dash as per
514 https://select2.org/configuration/data-attributes#nested-subkey-options
515 """
516 attrs = super().build_attrs(base_attrs, extra_attrs=extra_attrs)
517 attrs.setdefault("class", "")
518 attrs.update(
519 {
520 "data-ajax--cache": "true",
521 "data-ajax--delay": 250,
522 "data-ajax--type": "GET",
523 "data-ajax--url": self.get_url(),
524 "data-app-label": self.field.model._meta.app_label,
525 "data-model-name": self.field.model._meta.model_name,
526 "data-field-name": self.field.name,
527 "data-theme": "admin-autocomplete",
528 "data-allow-clear": json.dumps(not self.is_required),
529 "data-placeholder": "", # Allows clearing of the input.
530 "lang": self.i18n_name,
531 "class": attrs["class"]
532 + (" " if attrs["class"] else "")
533 + "admin-autocomplete",
534 }
535 )
536 return attrs
537
538 def optgroups(self, name, value, attr=None):
539 """Return selected options based on the ModelChoiceIterator."""
540 default = (None, [], 0)
541 groups = [default]
542 has_selected = False
543 selected_choices = {
544 str(v) for v in value if str(v) not in self.choices.field.empty_values
545 }
546 if not self.is_required and not self.allow_multiple_selected:
547 default[1].append(self.create_option(name, "", "", False, 0))
548 remote_model_opts = self.field.remote_field.model._meta
549 to_field_name = getattr(
550 self.field.remote_field, "field_name", remote_model_opts.pk.attname
551 )
552 to_field_name = remote_model_opts.get_field(to_field_name).attname
553 choices = (
554 (getattr(obj, to_field_name), self.choices.field.label_from_instance(obj))
555 for obj in self.choices.queryset.using(self.db).filter(
556 **{"%s__in" % to_field_name: selected_choices}
557 )
558 )
559 for option_value, option_label in choices:
560 selected = str(option_value) in value and (
561 has_selected is False or self.allow_multiple_selected
562 )
563 has_selected |= selected
564 index = len(default[1])
565 subgroup = default[1]
566 subgroup.append(
567 self.create_option(
568 name, option_value, option_label, selected_choices, index
569 )
570 )
571 return groups
572
573 @property
574 def media(self):
575 extra = "" if settings.DEBUG else ".min"
576 i18n_file = (
577 ("admin/js/vendor/select2/i18n/%s.js" % self.i18n_name,)
578 if self.i18n_name
579 else ()
580 )
581 return forms.Media(
582 js=(
583 "admin/js/vendor/jquery/jquery%s.js" % extra,
584 "admin/js/vendor/select2/select2.full%s.js" % extra,
585 )
586 + i18n_file
587 + (
588 "admin/js/jquery.init.js",
589 "admin/js/autocomplete.js",
590 ),
591 css={
592 "screen": (
593 "admin/css/vendor/select2/select2%s.css" % extra,
594 "admin/css/autocomplete.css",
595 ),
596 },
597 )
598
599
600 class AutocompleteSelect(AutocompleteMixin, forms.Select):
601 pass
602
603
604 class AutocompleteSelectMultiple(AutocompleteMixin, forms.SelectMultiple):
605 pass