| 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()) |