def items_for_result(view, result):
"""
Generates the actual list of data.
"""
modeladmin = view.model_admin
for field_name in view.list_display:
empty_value_display = modeladmin.get_empty_value_display(field_name)
row_classes = ['field-%s' % field_name]
try:
f, attr, value = lookup_field(field_name, result, modeladmin)
except ObjectDoesNotExist:
result_repr = empty_value_display
else:
empty_value_display = getattr(
attr, 'empty_value_display', empty_value_display)
if f is None or f.auto_created:
allow_tags = getattr(attr, 'allow_tags', False)
boolean = getattr(attr, 'boolean', False)
if boolean or not value:
allow_tags = True
if django.VERSION >= (1, 9):
result_repr = display_for_value(
value, empty_value_display, boolean)
else:
result_repr = display_for_value(value, boolean)
# Strip HTML tags in the resulting text, except if the
# function has an "allow_tags" attribute set to True.
if allow_tags:
result_repr = mark_safe(result_repr)
if isinstance(value, (datetime.date, datetime.time)):
row_classes.append('nowrap')
else:
if isinstance(f, models.ManyToOneRel):
field_val = getattr(result, f.name)
if field_val is None:
result_repr = empty_value_display
else:
result_repr = field_val
else:
if django.VERSION >= (1, 9):
result_repr = display_for_field(
value, f, empty_value_display)
else:
result_repr = display_for_field(value, f)
if isinstance(f, (
models.DateField, models.TimeField, models.ForeignKey)
):
row_classes.append('nowrap')
if force_text(result_repr) == '':
result_repr = mark_safe(' ')
row_classes.extend(
modeladmin.get_extra_class_names_for_field_col(result, field_name)
)
row_attrs = modeladmin.get_extra_attrs_for_field_col(result, field_name)
row_attrs['class'] = ' ' . join(row_classes)
row_attrs_flat = flatatt(row_attrs)
yield format_html('<td{}>{}</td>', row_attrs_flat, result_repr)
def items_for_result(view, result):
"""
Generates the actual list of data.
"""
modeladmin = view.model_admin
for field_name in view.list_display:
empty_value_display = modeladmin.get_empty_value_display(field_name)
row_classes = ['field-%s' % field_name]
try:
f, attr, value = lookup_field(field_name, result, modeladmin)
except ObjectDoesNotExist:
result_repr = empty_value_display
else:
empty_value_display = getattr(attr, 'empty_value_display',
empty_value_display)
if f is None or f.auto_created:
allow_tags = getattr(attr, 'allow_tags', False)
boolean = getattr(attr, 'boolean', False)
if boolean or not value:
allow_tags = True
if django.VERSION >= (1, 9):
result_repr = display_for_value(value, empty_value_display,
boolean)
else:
result_repr = display_for_value(value, boolean)
# Strip HTML tags in the resulting text, except if the
# function has an "allow_tags" attribute set to True.
if allow_tags:
result_repr = mark_safe(result_repr)
if isinstance(value, (datetime.date, datetime.time)):
row_classes.append('nowrap')
else:
if isinstance(f, models.ManyToOneRel):
field_val = getattr(result, f.name)
if field_val is None:
result_repr = empty_value_display
else:
result_repr = field_val
else:
if django.VERSION >= (1, 9):
result_repr = display_for_field(
value, f, empty_value_display)
else:
result_repr = display_for_field(value, f)
if isinstance(
f,
(models.DateField, models.TimeField, models.ForeignKey)):
row_classes.append('nowrap')
if force_text(result_repr) == '':
result_repr = mark_safe(' ')
row_classes.extend(
modeladmin.get_extra_class_names_for_field_col(result, field_name))
row_attrs = modeladmin.get_extra_attrs_for_field_col(
result, field_name)
row_attrs['class'] = ' '.join(row_classes)
row_attrs_flat = flatatt(row_attrs)
yield format_html('<td{}>{}</td>', row_attrs_flat, result_repr)
def test_number_formats_display_for_field(self):
display_value = display_for_field(12345.6789, models.FloatField(), self.empty_value)
self.assertEqual(display_value, '12345.6789')
display_value = display_for_field(Decimal('12345.6789'), models.DecimalField(), self.empty_value)
self.assertEqual(display_value, '12345.6789')
display_value = display_for_field(12345, models.IntegerField(), self.empty_value)
self.assertEqual(display_value, '12345')
def test_number_formats_with_thousand_separator_display_for_field(self):
display_value = display_for_field(12345.6789, models.FloatField(), self.empty_value)
self.assertEqual(display_value, "12,345.6789")
display_value = display_for_field(Decimal("12345.6789"), models.DecimalField(), self.empty_value)
self.assertEqual(display_value, "12,345.6789")
display_value = display_for_field(12345, models.IntegerField(), self.empty_value)
self.assertEqual(display_value, "12,345")
def test_number_formats_with_thousand_seperator_display_for_field(self):
display_value = display_for_field(12345.6789, models.FloatField())
self.assertEqual(display_value, '12,345.6789')
display_value = display_for_field(Decimal('12345.6789'), models.DecimalField())
self.assertEqual(display_value, '12,345.6789')
display_value = display_for_field(12345, models.IntegerField())
self.assertEqual(display_value, '12,345')
def test_number_formats_with_thousand_separator_display_for_field(self):
display_value = display_for_field(12345.6789, models.FloatField(), self.empty_value)
self.assertEqual(display_value, '12,345.6789')
display_value = display_for_field(Decimal('12345.6789'), models.DecimalField(), self.empty_value)
self.assertEqual(display_value, '12,345.6789')
display_value = display_for_field(12345, models.IntegerField(), self.empty_value)
self.assertEqual(display_value, '12,345')
def test_number_formats_display_for_field(self):
display_value = display_for_field(12345.6789, models.FloatField())
self.assertEqual(display_value, '12345.6789')
display_value = display_for_field(Decimal('12345.6789'),
models.DecimalField())
self.assertEqual(display_value, '12345.6789')
display_value = display_for_field(12345, models.IntegerField())
self.assertEqual(display_value, '12345')
def get_result_and_row_class(cl, field_name, result):
if django.VERSION >= (1, 9):
empty_value_display = cl.model_admin.get_empty_value_display()
else:
from django.contrib.admin.views.main import EMPTY_CHANGELIST_VALUE
empty_value_display = EMPTY_CHANGELIST_VALUE
row_classes = ['field-%s' % field_name]
try:
f, attr, value = lookup_field(field_name, result, cl.model_admin)
except ObjectDoesNotExist:
result_repr = empty_value_display
else:
if django.VERSION >= (1, 9):
empty_value_display = getattr(attr, 'empty_value_display',
empty_value_display)
if f is None:
if field_name == 'action_checkbox':
row_classes = ['action-checkbox']
allow_tags = getattr(attr, 'allow_tags', False)
boolean = getattr(attr, 'boolean', False)
if django.VERSION >= (1, 9):
result_repr = display_for_value(value, empty_value_display,
boolean)
else:
result_repr = display_for_value(value, boolean)
# Strip HTML tags in the resulting text, except if the
# function has an "allow_tags" attribute set to True.
# WARNING: this will be deprecated in Django 2.0
if allow_tags:
result_repr = mark_safe(result_repr)
if isinstance(value, (datetime.date, datetime.time)):
row_classes.append('nowrap')
else:
related_field_name = 'rel' if django.VERSION <= (
2, 0) else 'remote_field'
if isinstance(getattr(f, related_field_name), models.ManyToOneRel):
field_val = getattr(result, f.name)
if field_val is None:
result_repr = empty_value_display
else:
result_repr = field_val
else:
if django.VERSION >= (1, 9):
result_repr = display_for_field(value, f,
empty_value_display)
else:
result_repr = display_for_field(value, f)
if isinstance(
f,
(models.DateField, models.TimeField, models.ForeignKey)):
row_classes.append('nowrap')
if force_str(result_repr) == '':
result_repr = mark_safe(' ')
row_class = mark_safe(' class="%s"' % ' '.join(row_classes))
return result_repr, row_class
def get_result_and_row_class(cl, field_name, result):
if django.VERSION >= (1, 9):
empty_value_display = cl.model_admin.get_empty_value_display()
else:
from django.contrib.admin.views.main import EMPTY_CHANGELIST_VALUE
empty_value_display = EMPTY_CHANGELIST_VALUE
row_classes = ['field-%s' % field_name]
try:
f, attr, value = lookup_field(field_name, result, cl.model_admin)
except ObjectDoesNotExist:
result_repr = empty_value_display
else:
if django.VERSION >= (1, 9):
empty_value_display = getattr(
attr, 'empty_value_display', empty_value_display)
if f is None:
if field_name == 'action_checkbox':
row_classes = ['action-checkbox']
allow_tags = getattr(attr, 'allow_tags', False)
boolean = getattr(attr, 'boolean', False)
if django.VERSION >= (1, 9):
result_repr = display_for_value(
value, empty_value_display, boolean)
else:
result_repr = display_for_value(value, boolean)
# Strip HTML tags in the resulting text, except if the
# function has an "allow_tags" attribute set to True.
# WARNING: this will be deprecated in Django 2.0
if allow_tags:
result_repr = mark_safe(result_repr)
if isinstance(value, (datetime.date, datetime.time)):
row_classes.append('nowrap')
else:
related_field_name = 'rel' if django.VERSION <= (2, 0) else 'remote_field'
if isinstance(getattr(f, related_field_name), models.ManyToOneRel):
field_val = getattr(result, f.name)
if field_val is None:
result_repr = empty_value_display
else:
result_repr = field_val
else:
if django.VERSION >= (1, 9):
result_repr = display_for_field(
value, f, empty_value_display)
else:
result_repr = display_for_field(value, f)
if isinstance(f, (models.DateField, models.TimeField,
models.ForeignKey)):
row_classes.append('nowrap')
if force_str(result_repr) == '':
result_repr = mark_safe(' ')
row_class = mark_safe(' class="%s"' % ' '.join(row_classes))
return result_repr, row_class
def test_number_formats_display_for_field(self):
display_value = display_for_field(12345.6789, models.FloatField(),
self.empty_value)
self.assertEqual(display_value, "12345.6789")
display_value = display_for_field(Decimal("12345.6789"),
models.DecimalField(),
self.empty_value)
self.assertEqual(display_value, "12345.6789")
display_value = display_for_field(12345, models.IntegerField(),
self.empty_value)
self.assertEqual(display_value, "12345")
def test_null_display_for_field(self):
"""
Regression test for #12550: display_for_field should handle None
value.
"""
display_value = display_for_field(None, models.CharField(), self.empty_value)
self.assertEqual(display_value, self.empty_value)
display_value = display_for_field(None, models.CharField(
choices=(
(None, "test_none"),
)
), self.empty_value)
self.assertEqual(display_value, "test_none")
display_value = display_for_field(None, models.DateField(), self.empty_value)
self.assertEqual(display_value, self.empty_value)
display_value = display_for_field(None, models.TimeField(), self.empty_value)
self.assertEqual(display_value, self.empty_value)
display_value = display_for_field(None, models.BooleanField(null=True), self.empty_value)
expected = '<img src="%sadmin/img/icon-unknown.svg" alt="None" />' % settings.STATIC_URL
self.assertHTMLEqual(display_value, expected)
display_value = display_for_field(None, models.DecimalField(), self.empty_value)
self.assertEqual(display_value, self.empty_value)
display_value = display_for_field(None, models.FloatField(), self.empty_value)
self.assertEqual(display_value, self.empty_value)
display_value = display_for_field(None, models.JSONField(), self.empty_value)
self.assertEqual(display_value, self.empty_value)
def contents(self):
from django.contrib.admin.templatetags.admin_list import _boolean_icon
from django.contrib.admin.views.main import EMPTY_CHANGELIST_VALUE
field, obj, model_admin = self.field['field'], self.form.instance, self.model_admin
try:
f, attr, value = lookup_field(field, obj, model_admin)
except (AttributeError, ValueError, ObjectDoesNotExist):
result_repr = EMPTY_CHANGELIST_VALUE
else:
if f is None:
boolean = getattr(attr, "boolean", False)
if boolean:
result_repr = _boolean_icon(value)
else:
result_repr = smart_text(value)
if getattr(attr, "allow_tags", False):
result_repr = mark_safe(result_repr)
else:
result_repr = linebreaksbr(result_repr)
else:
if isinstance(f.remote_field, ManyToManyRel) and value is not None:
result_repr = ", ".join(map(six.text_type, value.all()))
else:
result_repr = display_for_field(value, f)
return conditional_escape(result_repr)
def contents(self):
from django.contrib.admin.templatetags.admin_list import _boolean_icon
field, obj, model_admin = self.field['field'], self.form.instance, self.model_admin
try:
f, attr, value = lookup_field(field, obj, model_admin)
except (AttributeError, ValueError, ObjectDoesNotExist):
result_repr = self.empty_value_display
else:
if f is None:
boolean = getattr(attr, "boolean", False)
if boolean:
result_repr = _boolean_icon(value)
else:
if hasattr(value, "__html__"):
result_repr = value
else:
result_repr = force_text(value)
if getattr(attr, "allow_tags", False):
warnings.warn(
"Deprecated allow_tags attribute used on %s. "
"Use django.utils.html.format_html(), format_html_join(), "
"or django.utils.safestring.mark_safe() instead." % attr,
RemovedInDjango20Warning
)
result_repr = mark_safe(value)
else:
result_repr = linebreaksbr(result_repr)
else:
if isinstance(f.remote_field, ManyToManyRel) and value is not None:
result_repr = ", ".join(map(six.text_type, value.all()))
else:
result_repr = display_for_field(value, f, self.empty_value_display)
result_repr = linebreaksbr(result_repr)
return conditional_escape(result_repr)
def export_as_csv(modeladmin, request, queryset):
response = HttpResponse(content_type='text/csv')
response[
'Content-Disposition'] = 'attachment; filename=%s.csv' % modeladmin.opts.db_table
writer = csv.writer(response)
if header:
fields_header = []
for field_name in fields:
text, attr = label_for_field(field_name,
modeladmin.model,
model_admin=modeladmin,
return_attr=True)
fields_header.append(text.capitalize())
writer.writerow(fields_header)
for obj in queryset:
line = []
for field_name in fields:
f, attr, value = lookup_field(field_name, obj, modeladmin)
if f is None or f.auto_created:
boolean = getattr(attr, 'boolean', False)
result_repr = display_for_value(value, boolean)
else:
if isinstance(f.rel, models.ManyToOneRel):
field_val = getattr(obj, f.name)
if field_val is None:
result_repr = '-'
else:
result_repr = field_val
else:
result_repr = display_for_field(value, f, '-')
line.append(strip_tags(u'%s' % result_repr))
writer.writerow(line)
return response
def test_display_for_field_with_legacy_formatting(legacy_formatting, settings,
value, expected):
settings.USE_L10N = True
# This locale has no definitions in py-moneyed, so it will work for localized money representation.
settings.LANGUAGE_CODE = "cs"
settings.DECIMAL_PLACES_DISPLAY = {}
assert admin_utils.display_for_field(value, MONEY_FIELD, "") == expected
def contents(self):
from django.contrib.admin.templatetags.admin_list import _boolean_icon
field, obj, model_admin = self.field['field'], self.form.instance, self.model_admin
try:
f, attr, value = lookup_field(field, obj, model_admin)
except (AttributeError, ValueError, ObjectDoesNotExist):
result_repr = self.empty_value_display
else:
if f is None:
boolean = getattr(attr, "boolean", False)
if boolean:
result_repr = _boolean_icon(value)
else:
if hasattr(value, "__html__"):
result_repr = value
else:
result_repr = smart_text(value)
if getattr(attr, "allow_tags", False):
warnings.warn(
"Deprecated allow_tags attribute used on %s. "
"Use django.utils.safestring.format_html(), "
"format_html_join(), or mark_safe() instead." % attr,
RemovedInDjango20Warning
)
result_repr = mark_safe(value)
else:
result_repr = linebreaksbr(result_repr)
else:
if isinstance(f.remote_field, ManyToManyRel) and value is not None:
result_repr = ", ".join(map(six.text_type, value.all()))
else:
result_repr = display_for_field(value, f, self.empty_value_display)
result_repr = linebreaksbr(result_repr)
return conditional_escape(result_repr)
def items_for_result(view, result, request):
"""
Generates the actual list of data.
"""
modeladmin = view.model_admin
for field_name in view.list_display:
empty_value_display = modeladmin.get_empty_value_display(field_name)
row_classes = ['field-%s' % field_name, 'title']
try:
f, attr, value = lookup_field(field_name, result, modeladmin)
except ObjectDoesNotExist:
result_repr = empty_value_display
else:
empty_value_display = getattr(attr, 'empty_value_display',
empty_value_display)
if f is None or f.auto_created:
allow_tags = getattr(attr, 'allow_tags', False)
boolean = getattr(attr, 'boolean', False)
if boolean or not value:
allow_tags = True
result_repr = display_for_value(value, empty_value_display,
boolean)
# Strip HTML tags in the resulting text, except if the
# function has an "allow_tags" attribute set to True.
if allow_tags:
result_repr = mark_safe(result_repr)
if isinstance(value, (datetime.date, datetime.time)):
row_classes.append('nowrap')
else:
if isinstance(f, models.ManyToOneRel):
field_val = getattr(result, f.name)
if field_val is None:
result_repr = empty_value_display
else:
result_repr = field_val
else:
result_repr = display_for_field(value, f,
empty_value_display)
if isinstance(
f,
(models.DateField, models.TimeField, models.ForeignKey)):
row_classes.append('nowrap')
if force_str(result_repr) == '':
result_repr = mark_safe(' ')
row_classes.extend(
modeladmin.get_extra_class_names_for_field_col(result, field_name))
row_attrs = modeladmin.get_extra_attrs_for_field_col(
result, field_name)
row_attrs['class'] = ' '.join(row_classes)
row_attrs_flat = flatatt(row_attrs)
if field_name == modeladmin.get_list_display_add_buttons(request):
edit_url = view.url_helper.get_action_url('edit', result.pk)
yield format_html(
'<td{}><div class="title-wrapper"><a href="{}" title="{}">{}</a></div></td>',
row_attrs_flat, edit_url,
_('Edit this %s') % view.verbose_name, result_repr)
else:
yield format_html('<td{}>{}</td>', row_attrs_flat, result_repr)
def items_for_result(cl, item):
results = []
for field_index, field_name in enumerate(cl.list_display):
if field_name == 'action_checkbox':
continue
empty_value_display = cl.model_admin.get_empty_value_display()
try:
f, attr, value = lookup_field(field_name, item, cl.model_admin)
except ObjectDoesNotExist:
result_repr = empty_value_display
else:
empty_value_display = getattr(attr, 'empty_value_display',
empty_value_display)
if f is None or f.auto_created:
boolean = getattr(attr, 'boolean', False)
result_repr = display_for_value(value, empty_value_display,
boolean)
else:
if isinstance(f.remote_field, models.ManyToOneRel):
field_val = getattr(item, f.name)
if field_val is None:
result_repr = empty_value_display
else:
result_repr = field_val
else:
result_repr = display_for_field(value, f,
empty_value_display)
results.append(result_repr)
return results
def items_for_result(cl, result, form, template, request):
pk = cl.lookup_opts.pk.attname
for field_name in cl.list_display:
empty_value_display = cl.model_admin.get_empty_value_display()
row_class = ''
try:
f, attr, value = lookup_field(field_name, result, cl.model_admin)
except (AttributeError, ObjectDoesNotExist):
result_repr = empty_value_display
else:
if f is None:
allow_tags = getattr(attr, 'allow_tags', False)
boolean = getattr(attr, 'boolean', False)
if boolean:
allow_tags = True
result_repr = _boolean_icon(value)
else:
result_repr = smart_text(value)
# Strip HTML tags in the resulting text, except if the
# function has an "allow_tags" attribute set to True.
if not allow_tags:
result_repr = escape(result_repr)
else:
result_repr = mark_safe(result_repr)
else:
if value is None:
result_repr = empty_value_display
if isinstance(f.rel, models.ManyToOneRel):
result_repr = escape(getattr(result, f.name))
else:
result_repr = display_for_field(value, f)
if isinstance(f, models.DateField) \
or isinstance(f, models.TimeField):
row_class = ' class="nowrap"'
if force_text(result_repr) == '':
result_repr = mark_safe(' ')
if field_name in cl.list_display_links:
url = cl.url_for_result(result)
# Convert the pk to something that can be used in Javascript.
# Problem cases are long ints (23L) and non-ASCII strings.
if cl.to_field:
attr = str(cl.to_field)
else:
attr = pk
value = result.serializable_value(attr)
result_id = repr(force_text(value))[1:]
yield render_template(result, template, request, cl)
else:
# By default the fields come from ModelAdmin.list_editable,
# but if we pull the fields out of the form instead of
# list_editable custom admins
# can provide fields on a per request basis
if form and field_name in form.fields:
bf = form[field_name]
result_repr = mark_safe(force_text(bf.errors) + force_text(bf))
else:
result_repr = conditional_escape(result_repr)
if form:
yield mark_safe(force_text(form[cl.model._meta.pk.name]))
def get_field_contents(self, field, obj):
from django.contrib.admin.templatetags.admin_list import _boolean_icon
model_admin = self
try:
f, attr, value = lookup_field(field, obj, self)
except (AttributeError, ValueError, ObjectDoesNotExist):
result_repr = get_empty_value_display(self)
else:
if f is None:
boolean = getattr(attr, "boolean", False)
if boolean:
result_repr = _boolean_icon(value)
else:
result_repr = smart_text(value)
if getattr(attr, "allow_tags", False):
result_repr = mark_safe(result_repr)
else:
result_repr = linebreaksbr(result_repr)
else:
if isinstance(f.rel, ManyToManyRel) and value is not None:
result_repr = ", ".join(map(six.text_type, value.all()))
else:
result_repr = display_for_field(value, f, "")
return conditional_escape(result_repr)
def contents(self):
from django.contrib.admin.templatetags.admin_list import _boolean_icon
from django.contrib.admin.views.main import EMPTY_CHANGELIST_VALUE
field, obj, model_admin = self.field[
'field'], self.form.instance, self.model_admin
try:
f, attr, value = lookup_field(field, obj, model_admin)
except (AttributeError, ValueError, ObjectDoesNotExist):
result_repr = EMPTY_CHANGELIST_VALUE
else:
if f is None:
boolean = getattr(attr, "boolean", False)
if boolean:
result_repr = _boolean_icon(value)
else:
result_repr = smart_text(value)
if getattr(attr, "allow_tags", False):
result_repr = mark_safe(result_repr)
else:
result_repr = linebreaksbr(result_repr)
else:
if isinstance(f.rel, ManyToManyRel) and value is not None:
result_repr = ", ".join(map(six.text_type, value.all()))
else:
result_repr = display_for_field(value, f)
result_repr = linebreaksbr(result_repr)
return conditional_escape(result_repr)
def contents(self):
from django.contrib.admin.templatetags.admin_list import _boolean_icon
field, obj, model_admin = self.field['field'], self.form.instance, self.model_admin
try:
f, attr, value = lookup_field(field, obj, model_admin)
except (AttributeError, ValueError, ObjectDoesNotExist):
result_repr = self.empty_value_display
else:
if field in self.form.fields:
widget = self.form[field].field.widget
# This isn't elegant but suffices for contrib.auth's
# ReadOnlyPasswordHashWidget.
if getattr(widget, 'read_only', False):
return widget.render(field, value)
if f is None:
if getattr(attr, 'boolean', False):
result_repr = _boolean_icon(value)
else:
if hasattr(value, "__html__"):
result_repr = value
else:
result_repr = linebreaksbr(value)
else:
if isinstance(f.remote_field, ManyToManyRel) and value is not None:
result_repr = ", ".join(map(str, value.all()))
else:
result_repr = display_for_field(value, f, self.empty_value_display)
result_repr = linebreaksbr(result_repr)
return conditional_escape(result_repr)
def contents(self):
from django.contrib.admin.templatetags.admin_list import _boolean_icon
field, obj, model_admin = self.field[
'field'], self.form.instance, self.model_admin
try:
f, attr, value = lookup_field(field, obj, model_admin)
except (AttributeError, ValueError, ObjectDoesNotExist):
result_repr = self.empty_value_display
else:
if field in self.form.fields:
widget = self.form[field].field.widget
# This isn't elegant but suffices for contrib.auth's
# ReadOnlyPasswordHashWidget.
if getattr(widget, 'read_only', False):
return widget.render(field, value)
if f is None:
if getattr(attr, 'boolean', False):
result_repr = _boolean_icon(value)
else:
if hasattr(value, "__html__"):
result_repr = value
else:
result_repr = linebreaksbr(value)
else:
if isinstance(f.remote_field,
ManyToManyRel) and value is not None:
result_repr = ", ".join(map(str, value.all()))
else:
result_repr = display_for_field(value, f,
self.empty_value_display)
result_repr = linebreaksbr(result_repr)
return conditional_escape(result_repr)
def contents(self):
from django.contrib.admin.templatetags.admin_list import _boolean_icon
field, obj, model_admin = self.field[
'field'], self.form.instance, self.model_admin
try:
f, attr, value = lookup_field(field, obj, model_admin)
except (AttributeError, ValueError, ObjectDoesNotExist):
result_repr = self.empty_value_display
else:
if f is None:
if getattr(attr, 'boolean', False):
result_repr = _boolean_icon(value)
else:
if hasattr(value, "__html__"):
result_repr = value
else:
result_repr = linebreaksbr(value)
else:
if isinstance(f.remote_field,
ManyToManyRel) and value is not None:
result_repr = ", ".join(map(str, value.all()))
else:
result_repr = display_for_field(value, f,
self.empty_value_display)
result_repr = linebreaksbr(result_repr)
return conditional_escape(result_repr)
def test_display_for_field_returns_empty_display_when_value_is_none(self):
EMPTY_DISPLAY = 'EMPTY'
instance = EnumChoiceField(enum_class=CharTestEnum)
result = display_for_field(None, instance, EMPTY_DISPLAY)
self.assertEqual(EMPTY_DISPLAY, result)
def test_null_display_for_field(self):
"""
Regression test for #12550: display_for_field should handle None
value.
"""
display_value = display_for_field(None, models.CharField())
self.assertEqual(display_value, EMPTY_CHANGELIST_VALUE)
display_value = display_for_field(
None, models.CharField(choices=((None, "test_none"), )))
self.assertEqual(display_value, "test_none")
display_value = display_for_field(None, models.DateField())
self.assertEqual(display_value, EMPTY_CHANGELIST_VALUE)
display_value = display_for_field(None, models.TimeField())
self.assertEqual(display_value, EMPTY_CHANGELIST_VALUE)
# Regression test for #13071: NullBooleanField has special
# handling.
display_value = display_for_field(None, models.NullBooleanField())
expected = '<img src="%sadmin/img/icon-unknown.gif" alt="None" />' % settings.STATIC_URL
self.assertHTMLEqual(display_value, expected)
display_value = display_for_field(None, models.DecimalField())
self.assertEqual(display_value, EMPTY_CHANGELIST_VALUE)
display_value = display_for_field(None, models.FloatField())
self.assertEqual(display_value, EMPTY_CHANGELIST_VALUE)
def test_null_display_for_field(self):
"""
Regression test for #12550: display_for_field should handle None
value.
"""
display_value = display_for_field(None, models.CharField())
self.assertEqual(display_value, EMPTY_CHANGELIST_VALUE)
display_value = display_for_field(None, models.CharField(
choices=(
(None, "test_none"),
)
))
self.assertEqual(display_value, "test_none")
display_value = display_for_field(None, models.DateField())
self.assertEqual(display_value, EMPTY_CHANGELIST_VALUE)
display_value = display_for_field(None, models.TimeField())
self.assertEqual(display_value, EMPTY_CHANGELIST_VALUE)
# Regression test for #13071: NullBooleanField has special
# handling.
display_value = display_for_field(None, models.NullBooleanField())
expected = '<img src="%sadmin/img/icon-unknown.gif" alt="None" />' % settings.STATIC_URL
self.assertHTMLEqual(display_value, expected)
display_value = display_for_field(None, models.DecimalField())
self.assertEqual(display_value, EMPTY_CHANGELIST_VALUE)
display_value = display_for_field(None, models.FloatField())
self.assertEqual(display_value, EMPTY_CHANGELIST_VALUE)
def custom_display_for_JSONfield(value, field, empty_value_display):
"""
Overriding display_for_field to correctly render JSONField READonly fields
in django-admin. Relevant when DJSTRIPE_USE_NATIVE_JSONFIELD is False
Note: This does not handle invalid JSON. That should be handled by the JSONField itself
"""
# we manually JSON serialise in case field is from jsonfield module
if isinstance(field, JSONField) and value:
try:
return json.dumps(value)
except TypeError:
return display_for_value(value, empty_value_display)
return display_for_field(value, field, empty_value_display)
def last_run_with_link(self, obj):
value = display_for_field(obj.last_run,
obj._meta.get_field('last_run'), '')
log_id = obj.log_set.latest('run_date').id
try:
# Old way
reversed_url = reverse('chronograph_log_change', args=(log_id, ))
except:
# New way
reversed_url = reverse('admin:chronograph_log_change',
args=(log_id, ))
return '<a href="%s">%s</a>' % (reversed_url, value)
def test_json_display_for_field(self):
tests = [
({'a': {'b': 'c'}}, '{"a": {"b": "c"}}'),
(['a', 'b'], '["a", "b"]'),
('a', '"a"'),
({'a': '你好 世界'}, '{"a": "你好 世界"}'),
({('a', 'b'): 'c'}, "{('a', 'b'): 'c'}"), # Invalid JSON.
]
for value, display_value in tests:
with self.subTest(value=value):
self.assertEqual(
display_for_field(value, models.JSONField(), self.empty_value),
display_value,
)
def test_display_for_field_returns_readable_value_when_choice_builder_is_redefined(
self):
class TestEnum(Enum):
FOO = 'foo'
BAR = 'bar'
def choice_builder(choice):
return choice.value, choice.value.upper()
instance = EnumChoiceField(enum_class=TestEnum,
choice_builder=choice_builder)
result = display_for_field(TestEnum.FOO, instance, None)
self.assertEqual(choice_builder(TestEnum.FOO)[1], result)
def test_values_from_lookup_field(self):
"""
Regression test for #12654: lookup_field
"""
SITE_NAME = "example.com"
TITLE_TEXT = "Some title"
CREATED_DATE = datetime.min
ADMIN_METHOD = "admin method"
SIMPLE_FUNCTION = "function"
INSTANCE_ATTRIBUTE = "attr"
class MockModelAdmin:
def get_admin_value(self, obj):
return ADMIN_METHOD
def simple_function(obj):
return SIMPLE_FUNCTION
site_obj = Site(domain=SITE_NAME)
article = Article(
site=site_obj,
title=TITLE_TEXT,
created=CREATED_DATE,
)
article.non_field = INSTANCE_ATTRIBUTE
verifications = (
("site", SITE_NAME),
("created", localize(CREATED_DATE)),
("title", TITLE_TEXT),
("get_admin_value", ADMIN_METHOD),
(simple_function, SIMPLE_FUNCTION),
("test_from_model", article.test_from_model()),
("non_field", INSTANCE_ATTRIBUTE),
)
mock_admin = MockModelAdmin()
for name, value in verifications:
field, attr, resolved_value = lookup_field(name, article,
mock_admin)
if field is not None:
resolved_value = display_for_field(resolved_value, field,
self.empty_value)
self.assertEqual(value, resolved_value)
def report(modeladmin, request, queryset):
results = {'header': [], 'results': []}
for field_name in fields:
text, attr = label_for_field(field_name,
modeladmin.model,
model_admin=modeladmin,
return_attr=True)
results['header'].append(text.capitalize())
for obj in queryset:
line = []
for field_name in fields:
f, attr, value = lookup_field(field_name, obj, modeladmin)
if f is None or f.auto_created:
boolean = getattr(attr, 'boolean', False)
result_repr = display_for_value(value, boolean)
else:
if isinstance(f.rel, models.ManyToOneRel):
field_val = getattr(obj, f.name)
if field_val is None:
result_repr = '-'
else:
result_repr = field_val
else:
result_repr = display_for_field(value, f, '-')
line.append(strip_tags(u'%s' % result_repr))
results['results'].append(line)
template = get_template(template_name)
html = template.render(
RequestContext(request, {
'header': header,
'results': results,
}))
result = StringIO.StringIO()
pdf = pisaDocument(
StringIO.StringIO(html.encode("UTF-8")),
dest=result,
link_callback=lambda uri, rel: os.path.join(
settings.MEDIA_ROOT, uri.replace(settings.MEDIA_URL, "")))
if not pdf.err:
return HttpResponse(result.getvalue(),
content_type='application/pdf')
return HttpResponse('We had some errors<pre>%s</pre>' %
cgi.escape(html))
def test_values_from_lookup_field(self):
"""
Regression test for #12654: lookup_field
"""
SITE_NAME = 'example.com'
TITLE_TEXT = 'Some title'
CREATED_DATE = datetime.min
ADMIN_METHOD = 'admin method'
SIMPLE_FUNCTION = 'function'
INSTANCE_ATTRIBUTE = 'attr'
class MockModelAdmin(object):
def get_admin_value(self, obj):
return ADMIN_METHOD
def simple_function(obj):
return SIMPLE_FUNCTION
site_obj = Site(domain=SITE_NAME)
article = Article(
site=site_obj,
title=TITLE_TEXT,
created=CREATED_DATE,
)
article.non_field = INSTANCE_ATTRIBUTE
verifications = (('site', SITE_NAME),
('created', localize(CREATED_DATE)), ('title',
TITLE_TEXT),
('get_admin_value', ADMIN_METHOD), (simple_function,
SIMPLE_FUNCTION),
('test_from_model', article.test_from_model()),
('non_field', INSTANCE_ATTRIBUTE))
mock_admin = MockModelAdmin()
for name, value in verifications:
field, attr, resolved_value = lookup_field(name, article,
mock_admin)
if field is not None:
resolved_value = display_for_field(resolved_value, field,
self.empty_value)
self.assertEqual(value, resolved_value)
def getter(self, obj):
last_obj = obj
related_name = None
for related_name in related_names:
last_obj = obj
try:
obj = getattr(obj, "get_%s_display" % related_name)()
except AttributeError:
obj = getattr(obj, related_name, None)
if callable(obj):
obj = obj()
elif isinstance(last_obj, models.Model):
f, attr, value = lookup_field(related_name, last_obj, self)
empty_value_display = self.get_empty_value_display()
empty_value_display = getattr(attr, 'empty_value_display',
empty_value_display)
obj = display_for_field(value, f, empty_value_display)
return obj
def contents(self):
"""
:return: type, value and correct values of field
"""
field_type = 'text'
value = ''
correct_values, modelfield = None, None
if self.field_name in self.admin_cls.list_display:
try:
modelfield, attr, val = \
admin.utils.lookup_field(self.field_name, self.obj,
self.admin_cls)
except (AttributeError, ValueError, ObjectDoesNotExist):
result_repr = EMPTY_CHANGELIST_VALUE
else:
if modelfield is None:
boolean = getattr(attr, "boolean", False)
if boolean:
result_repr = 't' if val else 'f'
field_type = 'checkbox'
else:
result_repr = smart_text(val)
if getattr(attr, "allow_tags", False):
result_repr = mark_safe(result_repr)
else:
result_repr = linebreaksbr(result_repr,
autoescape=True)
else:
result_repr = display_for_field(val, modelfield)
value = conditional_escape(result_repr)
if modelfield:
if isinstance(modelfield, models.BooleanField):
field_type = 'checkbox'
value = 't' if val else 'f'
if isinstance(modelfield,
(models.IntegerField, models.CharField)) \
and modelfield.choices:
field_type = 'select'
value = val
correct_values = dict(modelfield.choices)
return field_type, value, correct_values
def items_for_result(result, dashboard_module: ObjectsList):
"""
Generate the actual list of data.
"""
row_classes = []
for field_index, field_name in enumerate(dashboard_module.list_display):
try:
f, attr, value = lookup_field(field_name, result, dashboard_module)
except ObjectDoesNotExist:
result_repr = None
else:
empty_value_display = None
if f is None or f.auto_created:
if field_name == 'action_checkbox':
row_classes = ['action-checkbox']
boolean = getattr(attr, 'boolean', False)
result_repr = display_for_value(value, empty_value_display,
boolean)
if isinstance(value, (datetime.date, datetime.time)):
row_classes.append('dim')
else:
if isinstance(f.remote_field, models.ManyToOneRel):
field_val = getattr(result, f.name)
if field_val is None:
result_repr = empty_value_display
else:
result_repr = field_val
else:
result_repr = display_for_field(value, f,
empty_value_display)
if isinstance(f, (models.DateField, models.TimeField)):
row_classes.append('dim')
row_class = mark_safe(' class="%s"' % ' '.join(row_classes))
yield format_html('<span{}>{}</span>', row_class, result_repr)
def inline_items_for_result(inline, result):
"""
Generates the actual list of data for the inline.
"""
list_display = inline.list_display if inline.list_display else ('__unicode__',)
ret = ''
for field_name in list_display:
row_class = mark_safe(' class="column"')
try:
f, attr, value = lookup_field(field_name, result, inline)
except ObjectDoesNotExist:
result_repr = ''
else:
if f is None:
allow_tags = getattr(attr, 'allow_tags', False)
boolean = getattr(attr, 'boolean', False)
if boolean:
allow_tags = True
result_repr = display_for_value(value, boolean)
# Strip HTML tags in the resulting text, except if the
# function has an "allow_tags" attribute set to True.
if allow_tags:
result_repr = mark_safe(result_repr)
else:
if isinstance(f.rel, models.ManyToOneRel):
field_val = getattr(result, f.name)
if field_val is None:
result_repr = ''
else:
result_repr = field_val
else:
result_repr = display_for_field(value, f)
if force_text(result_repr) == '':
result_repr = mark_safe(' ')
ret += format_html(u'<span{0}>{1}</span>', row_class, result_repr)
return ret
def get_result_and_row_class(cl, field_name, result):
row_class = ''
try:
f, attr, value = lookup_field(field_name, result, cl.model_admin)
except ObjectDoesNotExist:
result_repr = EMPTY_CHANGELIST_VALUE
else:
if f is None:
if field_name == 'action_checkbox':
row_class = mark_safe(' class="action-checkbox"')
allow_tags = getattr(attr, 'allow_tags', False)
boolean = getattr(attr, 'boolean', False)
if boolean:
allow_tags = True
result_repr = display_for_value(value, boolean)
# Strip HTML tags in the resulting text, except if the
# function has an "allow_tags" attribute set to True.
if allow_tags:
result_repr = mark_safe(result_repr)
if isinstance(value, (datetime.date, datetime.time)):
row_class = mark_safe(' class="nowrap"')
else:
if isinstance(f.rel, models.ManyToOneRel):
field_val = getattr(result, f.name)
if field_val is None:
result_repr = EMPTY_CHANGELIST_VALUE
else:
result_repr = field_val
else:
result_repr = display_for_field(value, f)
if isinstance(f, (models.DateField, models.TimeField,
models.ForeignKey)):
row_class = mark_safe(' class="nowrap"')
if force_str(result_repr) == '':
result_repr = mark_safe(' ')
return result_repr, row_class
def items_for_result(cl, result, form):
"""
Generates the actual list of data.
"""
def link_in_col(is_first, field_name, cl):
if cl.list_display_links is None:
return False
if is_first and not cl.list_display_links:
return True
return field_name in cl.list_display_links
first = True
pk = cl.lookup_opts.pk.attname
for field_index, field_name in enumerate(cl.list_display):
empty_value_display = cl.model_admin.get_empty_value_display()
row_classes = [
'field-%s' % _coerce_field_name(field_name, field_index)
]
try:
f, attr, value = lookup_field(field_name, result, cl.model_admin)
except ObjectDoesNotExist:
result_repr = empty_value_display
else:
empty_value_display = getattr(attr, 'empty_value_display',
empty_value_display)
if f is None or f.auto_created:
if field_name == 'action_checkbox':
row_classes = ['action-checkbox']
boolean = getattr(attr, 'boolean', False)
result_repr = display_for_value(value, empty_value_display,
boolean)
if isinstance(value, (datetime.date, datetime.time)):
row_classes.append('nowrap')
else:
if isinstance(f.remote_field, models.ManyToOneRel):
field_val = getattr(result, f.name)
if field_val is None:
result_repr = empty_value_display
else:
result_repr = field_val
else:
result_repr = display_for_field(value, f,
empty_value_display)
if isinstance(
f,
(models.DateField, models.TimeField, models.ForeignKey)):
row_classes.append('nowrap')
if force_text(result_repr) == '':
result_repr = mark_safe(' ')
row_class = mark_safe(' class="%s"' % ' '.join(row_classes))
# If list_display_links not defined, add the link tag to the first field
if link_in_col(first, field_name, cl):
table_tag = 'th' if first else 'td'
first = False
# Display link to the result's change_view if the url exists, else
# display just the result's representation.
try:
url = cl.url_for_result(result)
except NoReverseMatch:
link_or_text = result_repr
else:
url = add_preserved_filters(
{
'preserved_filters': cl.preserved_filters,
'opts': cl.opts
}, url)
# Convert the pk to something that can be used in Javascript.
# Problem cases are long ints (23L) and non-ASCII strings.
if cl.to_field:
attr = str(cl.to_field)
else:
attr = pk
value = result.serializable_value(attr)
link_or_text = format_html(
'<a href="{}"{}>{}</a>', url,
format_html(' data-popup-opener="{}"', value)
if cl.is_popup else '', result_repr)
yield format_html('<{}{}>{}</{}>', table_tag, row_class,
link_or_text, table_tag)
else:
# By default the fields come from ModelAdmin.list_editable, but if we pull
# the fields out of the form instead of list_editable custom admins
# can provide fields on a per request basis
if (form and field_name in form.fields
and not (field_name == cl.model._meta.pk.name
and form[cl.model._meta.pk.name].is_hidden)):
bf = form[field_name]
result_repr = mark_safe(force_text(bf.errors) + force_text(bf))
yield format_html('<td{}>{}</td>', row_class, result_repr)
if form and not form[cl.model._meta.pk.name].is_hidden:
yield format_html('<td>{}</td>',
force_text(form[cl.model._meta.pk.name]))
