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