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