def test_list_display_for_value(self):
display_value = display_for_value([1, 2, 3], self.empty_value)
self.assertEqual(display_value, '1, 2, 3')
display_value = display_for_value([1, 2, 'buckle', 'my', 'shoe'],
self.empty_value)
self.assertEqual(display_value, '1, 2, buckle, my, shoe')
def test_list_display_for_value(self):
display_value = display_for_value([1, 2, 3], self.empty_value)
self.assertEqual(display_value, "1, 2, 3")
display_value = display_for_value([1, 2, "buckle", "my", "shoe"],
self.empty_value)
self.assertEqual(display_value, "1, 2, buckle, my, shoe")
def semantic_display_for_field(value, field, empty_value_display):
from .templatetags.semantic_admin_list import _semantic_boolean_icon
if getattr(field, "flatchoices", None):
return dict(field.flatchoices).get(value, empty_value_display)
# BooleanField needs special-case null-handling, so it comes before the
# general null test.
# BEGIN CUSTOMIZATION
elif isinstance(field, models.BooleanField):
return _semantic_boolean_icon(value)
# END CUSTOMIZATION
elif value is None:
return empty_value_display
elif isinstance(field, models.DateTimeField):
return formats.localize(timezone.template_localtime(value))
elif isinstance(field, (models.DateField, models.TimeField)):
return formats.localize(value)
elif isinstance(field, models.DecimalField):
return formats.number_format(value, field.decimal_places)
elif isinstance(field, (models.IntegerField, models.FloatField)):
return formats.number_format(value)
elif isinstance(field, models.FileField) and value:
return format_html('<a href="{}">{}</a>', value.url, value)
elif isinstance(field, JSONField) and value:
try:
return json.dumps(value, ensure_ascii=False, cls=field.encoder)
except TypeError:
return display_for_value(value, empty_value_display)
else:
return display_for_value(value, empty_value_display)
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_list_display_for_value_boolean(self):
self.assertEqual(
display_for_value(True, '', boolean=True),
'<img src="/static/admin/img/icon-yes.svg" alt="True">')
self.assertEqual(
display_for_value(False, '', boolean=True),
'<img src="/static/admin/img/icon-no.svg" alt="False">')
self.assertEqual(display_for_value(True, ''), 'True')
self.assertEqual(display_for_value(False, ''), 'False')
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_list_display_for_value_boolean(self):
self.assertEqual(
display_for_value(True, '', boolean=True),
'<img src="/static/admin/img/icon-yes.svg" alt="True">'
)
self.assertEqual(
display_for_value(False, '', boolean=True),
'<img src="/static/admin/img/icon-no.svg" alt="False">'
)
self.assertEqual(display_for_value(True, ''), 'True')
self.assertEqual(display_for_value(False, ''), 'False')
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 admin_display_for_value(value):
if StrictVersion(django.get_version()) >= StrictVersion('1.9'):
from django.contrib.admin.utils import display_for_value
return display_for_value(value, '-')
else:
try:
from django.contrib.admin.utils import display_for_value
return display_for_value(value)
except ImportError:
from django.contrib.admin.util import display_for_value
return display_for_value(value)
def admin_display_for_value(value):
if StrictVersion(django.get_version()) >= StrictVersion('1.9'):
from django.contrib.admin.utils import display_for_value
return display_for_value(value, '-')
else:
try:
from django.contrib.admin.utils import display_for_value
return display_for_value(value)
except ImportError:
from django.contrib.admin.util import display_for_value
return display_for_value(value)
def display_for_field_mod(value, field, empty_value_display):
if isinstance(field, models.JSONField) and value:
try:
return json.dumps(value, ensure_ascii=False, cls=field.encoder)
except TypeError:
return utils.display_for_value(value, empty_value_display)
return display_for_field(value, field, empty_value_display)
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 last_known_activity_time(self, obj):
from django.contrib.admin.utils import display_for_value
# We sort by -created by default, so first() gives us the last one, or
# None.
user_log = (UserLog.objects.filter(user=obj).values_list(
'created', flat=True).first())
return display_for_value(user_log, '')
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 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 last_known_activity_time(self, obj):
from django.contrib.admin.utils import display_for_value
# We sort by -created by default, so first() gives us the last one, or
# None.
user_log = (
UserLog.objects.filter(user=obj)
.values_list('created', flat=True).first())
return display_for_value(user_log, '')
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 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 items_for_result(view, result):
"""
Generates the actual list of data.
"""
model_admin = view.model_admin
for field_name in view.list_display:
empty_value_display = ""
row_classes = ["field-%s" % field_name]
try:
f, attr, value = lookup_field(field_name, result, 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:
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, 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)
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))
yield format_html("<td{}>{}</td>", row_class, result_repr)
def items_for_result(cl, result, form):
"""
Generates the actual list of data.
"""
for field_name in cl.list_display:
try:
f, attr, value = lookup_field(field_name, result, cl.model_admin)
except ObjectDoesNotExist:
result_repr = EMPTY_CHANGELIST_VALUE
else:
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)
yield result_repr
def action_csv_export(self, request, queryset):
result = ''
def _quote_csv(col_html):
u = html.strip_tags(str(col_html))
u = u.rstrip('\n\r') # remove trailing \n
# drop spaces at the begining of the line:
u = re.sub('^[ \t\n\r\f\v]+', '', u, flags=re.MULTILINE)
u = re.sub('[ \t\n\r\f\v]*\n', '\n', u) # remove duplicates \n
# Unquote
u = u.replace('"', '"').replace(''', "'")
# Do the actual escaping/quoting (quotes doubling for libreoffice)
return '"' + u.replace('"', '""') + '"'
header_done = False
for row in queryset:
if not header_done:
for i, field_name in enumerate(self.list_display):
text, attr = label_for_field(
field_name, type(row), self, True)
if i: # not first column
result += ','
result += _quote_csv(text)
result += '\n'
header_done = True
for i, field_name in enumerate(self.list_display):
if i: # not first column
result += ','
f, attr, value = lookup_field(field_name, row, self)
if value is None:
continue
if f is None:
col_html = display_for_value(value, False)
else:
col_html = display_for_field(value, f)
result += _quote_csv(col_html)
result += '\n'
return HttpResponse(result, content_type='text/csv; charset=utf-8')
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 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 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 display_confirmed(self, obj):
return format_html(
display_for_value(obj.confirmed_on is not None, None, boolean=True) +
(" " + date_format(obj.confirmed_on, 'DATETIME_FORMAT', use_l10n=True)
if obj.confirmed_on else ""))
def last_login(self, obj):
if obj.role_id:
return display_for_value(obj.role.last_login, "-")
else:
return "-"
def display_confirmed(self, obj):
return format_html(
display_for_value(obj.confirmed_on is not None, None, boolean=True) +
(" " + date_format(obj.confirmed_on, 'DATETIME_FORMAT', use_l10n=True)
if obj.confirmed_on else ""))
def is_supervisor(self, obj):
value = any(g for g in obj.groups.all() if len(g.name) == 2)
return display_for_value(value, None, boolean=True)
def test_list_display_for_value(self):
display_value = display_for_value([1, 2, 3], self.empty_value)
self.assertEqual(display_value, '1, 2, 3')
display_value = display_for_value([1, 2, 'buckle', 'my', 'shoe'], self.empty_value)
self.assertEqual(display_value, '1, 2, buckle, my, shoe')
def report(modeladmin, request, queryset):
header = []
linhas = []
style = []
for field in fields:
field_detail = field.split(':')
field_name = field_detail[0]
text, attr = label_for_field(field_name,
modeladmin.model,
model_admin=modeladmin,
return_attr=True)
if len(fields) < 3:
align = "text-align: %s;" % 'left'
width = '"width: %s; %s"' % ('400px', align)
else:
align = "text-align: %s;" % (
field_detail[2] if len(field_detail) > 2 else 'center')
width = '"width: %s; %s"' % (
field_detail[1] if len(field_detail) > 1 else '300px',
align)
style.append(width)
header.append(
'<th class="border-top border-bottom" style=%s><b>%s</b></th>'
% (width, text))
for obj in queryset:
line = ''
fieldno = 0
for field in fields:
field_detail = field.split(':')
field_name = field_detail[0]
f, attr, value = lookup_field(field_name, obj, modeladmin)
#print(f, attr, value)
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, None)
result_repr = nvl(strip_tags(result_repr), ' ')
line += '<td style=%s>%s</td>' % (style[fieldno], result_repr)
fieldno += 1
linhas.append(line)
print(linhas)
template = get_template(template_name)
html = template.render({
'title': title,
'header': header,
'linhas': linhas,
})
result = io.BytesIO()
pdf = pisaDocument(
io.BytesIO(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('Erro na geração do relatório<pre>%s</pre>' %
cgi.escape(html))
from __future__ import unicode_literals
def mptt_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
# #### MPTT ADDITION START
# figure out which field to indent
mptt_indent_field = getattr(cl.model_admin, "mptt_indent_field", None)
if not mptt_indent_field:
for field_name in cl.list_display:
try:
f = cl.lookup_opts.get_field(field_name)
except FieldDoesNotExist:
if mptt_indent_field is None and field_name != "action_checkbox":
mptt_indent_field = field_name
else:
# first model field, use this one
mptt_indent_field = field_name
break
# figure out how much to indent
mptt_level_indent = getattr(
cl.model_admin, "mptt_level_indent", MPTT_ADMIN_LEVEL_INDENT
)
# #### MPTT ADDITION END
for field_index, field_name in enumerate(cl.list_display):
# #### MPTT SUBSTITUTION START
empty_value_display = cl.model_admin.get_empty_value_display()
# #### MPTT SUBSTITUTION END
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"]
allow_tags = getattr(attr, "allow_tags", False)
boolean = getattr(attr, "boolean", False)
# #### MPTT SUBSTITUTION START
result_repr = display_for_value(value, empty_value_display, boolean)
# #### MPTT SUBSTITUTION END
if allow_tags:
warnings.warn(
"Deprecated allow_tags attribute used on field {}. "
"Use django.utils.safestring.format_html(), "
"format_html_join(), or mark_safe() instead.".format(
field_name
),
RemovedInDjango20Warning,
)
result_repr = mark_safe(result_repr)
if isinstance(value, (datetime.date, datetime.time)):
row_classes.append("nowrap")
else:
# #### MPTT SUBSTITUTION START
is_many_to_one = isinstance(f.remote_field, models.ManyToOneRel)
if is_many_to_one:
# #### MPTT SUBSTITUTION END
field_val = getattr(result, f.name)
if field_val is None:
result_repr = empty_value_display
else:
result_repr = field_val
else:
# #### MPTT SUBSTITUTION START
result_repr = display_for_field(value, f, empty_value_display)
# #### MPTT SUBSTITUTION END
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))
# #### MPTT ADDITION START
if field_name == mptt_indent_field:
level = getattr(result, result._mptt_meta.level_attr)
padding_attr = mark_safe(
' style="padding-%s:%spx"'
% (
"right" if get_language_bidi() else "left",
8 + mptt_level_indent * level,
)
)
else:
padding_attr = ""
# #### MPTT ADDITION END
# 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)
if cl.is_popup:
opener = format_html(' data-popup-opener="{}"', value)
else:
opener = ""
link_or_text = format_html(
'<a href="{}"{}>{}</a>', url, opener, result_repr
)
# #### MPTT SUBSTITUTION START
yield format_html(
"<{}{}{}>{}</{}>",
table_tag,
row_class,
padding_attr,
link_or_text,
table_tag,
)
# #### MPTT SUBSTITUTION END
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_str(bf.errors) + force_str(bf))
# #### MPTT SUBSTITUTION START
yield format_html("<td{}{}>{}</td>", row_class, padding_attr, result_repr)
# #### MPTT SUBSTITUTION END
if form and not form[cl.model._meta.pk.name].is_hidden:
yield format_html("<td>{}</td>", force_str(form[cl.model._meta.pk.name]))
def serialize(self, changelist, **options):
"""
Сериализация табличного представления.
Пример выходных данных для таблицы сокращений:
{
"data":[
{
"level": "0",
"item_weight": "64",
"socrname": "",
"scname": " ",
"id": 0
},
{
"level": "1",
"item_weight": "64",
"socrname": "Автономный округ",
"scname": "АО",
"id": 101
}
]
}
"""
if not isinstance(changelist, ChangeList):
raise TypeError('\'{0}\' is not {1} instance'.format(changelist, ChangeList))
self.options = options
self.changelist = changelist
self.stream = options.pop("stream", six.StringIO())
self.selected_fields = options.pop("fields", None)
self.use_natural_keys = options.pop("use_natural_keys", False)
self.use_natural_foreign_keys = options.pop('use_natural_foreign_keys', False) or self.use_natural_keys
self.use_natural_primary_keys = options.pop('use_natural_primary_keys', False)
self.start_serialization()
self.first = True
# для каждой записи в таблице
for obj in self.changelist.result_list:
self.start_object(obj)
# для каждого поля в записи
for field_name in self.changelist.list_display:
if field_name == 'action_checkbox':
continue
# получаем представление поля
try:
f, attr, value = lookup_field(field_name, obj, self.changelist.model_admin)
except ObjectDoesNotExist:
result_repr = EMPTY_CHANGELIST_VALUE
else:
if f is None:
result_repr = display_for_value(value, False)
else:
if isinstance(f.rel, models.ManyToOneRel):
field_val = getattr(obj, 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)
self._current[field_name] = mark_safe(force_text(result_repr))
self.end_object(obj)
if self.first:
self.first = False
self.end_serialization()
return self.getvalue()
def is_supervisor(self, obj):
value = any(g for g in obj.groups.all() if len(g.name) == 2)
return display_for_value(value, None, boolean=True)
def test_list_display_for_value(self):
display_value = display_for_value([1, 2, 3], self.empty_value)
self.assertEqual(display_value, "1, 2, 3")
display_value = display_for_value([1, 2, "buckle", "my", "shoe"], self.empty_value)
self.assertEqual(display_value, "1, 2, buckle, my, shoe")
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_name in cl.list_display:
row_classes = ['field-%s' % field_name]
if (field_name != "send"):
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_classes = ['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_classes.append('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_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)
result_id = escapejs(value)
link_or_text = format_html(
'<a href="{0}"{1}>{2}</a>', url,
format_html(
' onclick="opener.dismissRelatedLookupPopup(window, '{0}'); return false;"',
result_id) if cl.is_popup else '', result_repr)
yield format_html('<{0}{1}>{2}</{3}>', 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{0}>{1}</td>', row_class, result_repr)
else:
row_class = mark_safe(' class="%s"' % ' '.join(row_classes))
yield format_html('<td{0}><a href="{1}">{2}</a></td>', row_class,
cl.url_for_sendCredential(result), "Send")
if form and not form[cl.model._meta.pk.name].is_hidden:
yield format_html('<td>{0}</td>',
force_text(form[cl.model._meta.pk.name]))
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_name in cl.list_display:
row_classes = ['field-%s' % field_name]
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_classes = ['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_classes.append('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_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)
result_id = escapejs(value)
link_or_text = format_html(
'<a href="{}"{}>{}</a>',
url,
format_html(
' onclick="opener.dismissRelatedLookupPopup(window, '
''{}'); return false;"', result_id
) 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]))
def mptt_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
# #### MPTT ADDITION START
# figure out which field to indent
mptt_indent_field = getattr(cl.model_admin, 'mptt_indent_field', None)
if not mptt_indent_field:
for field_name in cl.list_display:
try:
f = cl.lookup_opts.get_field(field_name)
except models.FieldDoesNotExist:
if (mptt_indent_field is None and
field_name != 'action_checkbox'):
mptt_indent_field = field_name
else:
# first model field, use this one
mptt_indent_field = field_name
break
# figure out how much to indent
mptt_level_indent = getattr(cl.model_admin, 'mptt_level_indent', MPTT_ADMIN_LEVEL_INDENT)
# #### MPTT ADDITION END
for field_index, field_name in enumerate(cl.list_display):
# #### MPTT SUBSTITUTION START
empty_value_display = get_empty_value_display(cl)
# #### MPTT SUBSTITUTION END
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']
allow_tags = getattr(attr, 'allow_tags', False)
boolean = getattr(attr, 'boolean', False)
# #### MPTT SUBSTITUTION START
try:
# Changed in Django 1.9, now takes 3 arguments
result_repr = display_for_value(
value, empty_value_display, boolean)
except TypeError:
result_repr = display_for_value(value, boolean)
# #### MPTT SUBSTITUTION END
if allow_tags:
warnings.warn(
"Deprecated allow_tags attribute used on field {}. "
"Use django.utils.safestring.format_html(), "
"format_html_join(), or mark_safe() instead.".format(field_name),
RemovedInDjango20Warning
)
result_repr = mark_safe(result_repr)
if isinstance(value, (datetime.date, datetime.time)):
row_classes.append('nowrap')
else:
# #### MPTT SUBSTITUTION START
is_many_to_one = isinstance(f, models.ManyToOneRel)
if is_many_to_one:
# #### MPTT SUBSTITUTION END
field_val = getattr(result, f.name)
if field_val is None:
result_repr = empty_value_display
else:
result_repr = field_val
else:
# #### MPTT SUBSTITUTION START
try:
result_repr = display_for_field(value, f, "")
except TypeError:
# Changed in Django 1.9, now takes 3 arguments
result_repr = display_for_field(
value, f, empty_value_display)
# #### MPTT SUBSTITUTION END
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))
# #### MPTT ADDITION START
if field_name == mptt_indent_field:
level = getattr(result, result._mptt_meta.level_attr)
padding_attr = mark_safe(' style="padding-%s:%spx"' % (
'right' if get_language_bidi() else 'left',
8 + mptt_level_indent * level))
else:
padding_attr = ''
# #### MPTT ADDITION END
# 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)
if cl.is_popup:
if django.VERSION < (1, 10):
opener = format_html(
' onclick="opener.dismissRelatedLookupPopup(window, '{}');'
' return false;"', value
)
else:
opener = format_html(
' data-popup-opener="{}"', value
)
else:
opener = ''
link_or_text = format_html(
'<a href="{}"{}>{}</a>',
url,
opener,
result_repr)
# #### MPTT SUBSTITUTION START
yield format_html('<{}{}{}>{}</{}>',
table_tag,
row_class,
padding_attr,
link_or_text,
table_tag)
# #### MPTT SUBSTITUTION END
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))
# #### MPTT SUBSTITUTION START
yield format_html('<td{}{}>{}</td>', row_class, padding_attr, result_repr)
# #### MPTT SUBSTITUTION END
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]))
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)
primary_button = None
if field_name == modeladmin.get_list_display_add_buttons(request):
primary_button = view.button_helper.get_primary_button(result)
if primary_button is not None and primary_button.get("url"):
yield format_html(
'<td{}><div class="title-wrapper"><a href="{}" title="{}">{}</a></div></td>',
row_attrs_flat,
primary_button["url"],
primary_button.get("title", ""),
result_repr,
)
else:
yield format_html("<td{}>{}</td>", row_attrs_flat, result_repr)
def mptt_items_for_result(cl, result, form):
"""
Generates the actual list of data.
"""
# each key in the returned result is the name of the model's field as
# follows:
# * "action_checkbox"
# * "title_with_class"
yielded_result = {}
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):
# #### MPTT SUBSTITUTION START
empty_value_display = get_empty_value_display(cl)
# #### MPTT SUBSTITUTION END
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']
allow_tags = getattr(attr, 'allow_tags', False)
boolean = getattr(attr, 'boolean', False)
# #### MPTT SUBSTITUTION START
try:
# Changed in Django 1.9, now takes 3 arguments
result_repr = display_for_value(value, empty_value_display,
boolean)
except TypeError:
result_repr = display_for_value(value, boolean)
# #### MPTT SUBSTITUTION END
if allow_tags:
warnings.warn(
"Deprecated allow_tags attribute used on field {}. "
"Use django.utils.safestring.format_html(), "
"format_html_join(), or mark_safe() instead.".format(
field_name), RemovedInDjango20Warning)
result_repr = mark_safe(result_repr)
if isinstance(value, (datetime.date, datetime.time)):
row_classes.append('nowrap')
else:
# #### MPTT SUBSTITUTION START
is_many_to_one = isinstance(remote_field(f),
models.ManyToOneRel)
if is_many_to_one:
# #### MPTT SUBSTITUTION END
field_val = getattr(result, f.name)
if field_val is None:
result_repr = empty_value_display
else:
result_repr = field_val
else:
# #### MPTT SUBSTITUTION START
try:
result_repr = display_for_field(value, f)
except TypeError:
# Changed in Django 1.9, now takes 3 arguments
result_repr = display_for_field(
value, f, empty_value_display)
# #### MPTT SUBSTITUTION END
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):
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)
yielded_result[field_name] = {
'row_class': row_class,
'repr': result_repr,
}
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))
yielded_result[field_name] = {
'row_class': row_class,
'repr': result_repr,
}
_, _, _id = lookup_field('id', result, cl.model_admin)
yielded_result['id'] = _id
# ctype = Document | Folder
yielded_result['ctype'] = str(result.polymorphic_ctype)
if (str(result.polymorphic_ctype) == 'Document'):
yielded_result['text'] = result.get_real_instance().text
yielded_result['title'] = str(result.title)
yield yielded_result
def items_for_result(cl, result, form):
"""
Generate 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 str(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 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(str(bf.errors) + str(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>', form[cl.model._meta.pk.name])
def mptt_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
# #### MPTT ADDITION START
# figure out which field to indent
mptt_indent_field = getattr(cl.model_admin, 'mptt_indent_field', None)
if not mptt_indent_field:
for field_name in cl.list_display:
try:
f = cl.lookup_opts.get_field(field_name)
except models.FieldDoesNotExist:
if (mptt_indent_field is None and
field_name != 'action_checkbox'):
mptt_indent_field = field_name
else:
# first model field, use this one
mptt_indent_field = field_name
break
# #### MPTT ADDITION END
# figure out how much to indent
mptt_level_indent = getattr(cl.model_admin, 'mptt_level_indent', MPTT_ADMIN_LEVEL_INDENT)
for field_name in cl.list_display:
empty_value_display = cl.model_admin.get_empty_value_display()
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:
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']
allow_tags = getattr(attr, 'allow_tags', False)
boolean = getattr(attr, 'boolean', False)
result_repr = display_for_value(value, empty_value_display, boolean)
if allow_tags:
warnings.warn(
"Deprecated allow_tags attribute used on field {}. "
"Use django.utils.safestring.format_html(), "
"format_html_join(), or mark_safe() instead.".format(field_name),
RemovedInDjango20Warning
)
result_repr = mark_safe(result_repr)
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))
# #### MPTT ADDITION START
if field_name == mptt_indent_field:
level = getattr(result, result._mptt_meta.level_attr)
padding_attr = ' style=padding-%s:%spx' % (
'right' if get_language_bidi() else 'left',
5 + mptt_level_indent * level)
else:
padding_attr = ''
# #### MPTT ADDITION END
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)
result_id = escapejs(value)
link_or_text = format_html(
'<a href="{}"{}>{}</a>',
url,
format_html(
' onclick="opener.dismissRelatedLookupPopup(window, '
''{}'); return false;"', result_id
) if cl.is_popup else '',
result_repr)
yield format_html('<{}{}{}>{}</{}>',
table_tag,
row_class,
padding_attr,
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, padding_attr, 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]))
def items_for_result(self):
# 1. Removed "nowrap" CSS-class
# 2. Removed <th> from table body
# 3. Add "display_editable_field" function
first = True
pk = self.cl.lookup_opts.pk.attname
for field_index, field_name in enumerate(self.cl.list_display):
empty_value_display = self.cl.model_admin.get_empty_value_display()
row_classes = [
"field-%s" %
admin_list._coerce_field_name(field_name, field_index)
]
try:
f, attr, value = lookup_field(field_name, self.obj,
self.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)
else:
if isinstance(f.remote_field, models.ManyToOneRel):
field_val = getattr(self.obj, 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)
row_class = mark_safe(" class='%s'" % " ".join(row_classes))
# If list_display_links not defined, add the link tag to the first field
if self._link_in_col(first, field_name):
first = False
# Display link to the result's change_view if the url exists, else
# display just the result's representation.
try:
url = self.cl.url_for_result(self.obj)
except NoReverseMatch:
link_or_text = result_repr
else:
url = add_preserved_filters(
{
"preserved_filters": self.cl.preserved_filters,
"opts": self.cl.opts
}, url)
# Convert the pk to something that can be used in Javascript.
# Problem cases are non-ASCII strings.
if self.cl.to_field:
attr = str(self.cl.to_field)
else:
attr = pk
value = self.obj.serializable_value(attr)
link_or_text = format_html(
'<a href="{}"{}>{}</a>', url,
format_html(' data-popup-opener="{}"', value)
if self.cl.is_popup else '', result_repr)
yield format_html("<td{}>{}</td>", row_class, link_or_text)
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 (self.form and field_name in self.form.fields and not (
field_name == self.cl.model._meta.pk.name
and self.form[self.cl.model._meta.pk.name].is_hidden)):
result_repr = self.display_editable_field(field_name)
yield format_html("<td{}>{}</td>", row_class, result_repr)
if self.form and not self.form[self.cl.model._meta.pk.name].is_hidden:
yield format_html("<td>{}</td>",
self.form[self.cl.model._meta.pk.name])
def my_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_name in cl.list_display:
empty_value_display = cl.model_admin.get_empty_value_display()
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:
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"]
allow_tags = getattr(attr, "allow_tags", False)
boolean = getattr(attr, "boolean", False)
result_repr = display_for_value(value, empty_value_display, boolean)
if allow_tags:
warnings.warn(
"Deprecated allow_tags attribute used on field {}. "
"Use django.utils.safestring.format_html(), "
"format_html_join(), or mark_safe() instead.".format(field_name),
RemovedInDjango20Warning,
)
result_repr = mark_safe(result_repr)
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)
result_id = escapejs(value)
link_or_text = format_html(
'<a href="{}"{}>{}</a>',
url,
format_html(
' onclick="opener.dismissRelatedLookupPopup(window, ' ''{}'); return false;"', result_id
)
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]))
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]))
def test_empty_values_display_for_value(self):
display_value = display_for_value("", self.empty_value)
self.assertEqual(display_value, self.empty_value)
display_value = display_for_value(None, self.empty_value)
self.assertEqual(display_value, self.empty_value)
