def edit(request, template, model_class, ctx=None,
link=None, linkfield='code', queryset=None, **kwargs):
formset, msg, objects = process_modelformset(request, model_class,
queryset=queryset, **kwargs)
if ctx is None:
ctx = {}
ctx.update({
'formset_text': mark_safe(form_set_as_table(formset, link, linkfield)),
'formset': formset,
'objects': objects,
'error_msg': msg,
'can_add': kwargs.get('extra', 1) != 0,
})
return render(request, template, ctx)
python类mark_safe()的实例源码
def wikilink(value):
"""
Produce wiki style links to other pages within the database, for use in
comments fields: {{ a_note|wikilink|truncatewords_html:5 }}
Note that it's better to use truncatewords_html with this filter, rather
than plain truncatewords
"""
WIKILINK_RE = re.compile(r"""
(?P<lead>\s|^) # possible leading whitespace
(?P<wikilink>/ # an initial /
(\w+/)+ # multiples of any number of identifier chars + /
)
""",
re.VERBOSE)
def wikilink_sub_callback(match_obj):
link = match_obj.group("wikilink")
lead = match_obj.group("lead")
return '%s<a href="%s">%s</a>' % (lead, escape(link), escape(link))
return mark_safe(WIKILINK_RE.sub(wikilink_sub_callback, value))
def smart_personal_names(self, value):
names_lst = []
for pn in value.split(' and '):
try:
last_name, first_name = pn.split(', ')
name = "<span class='name'><span class='lastName'>%s</span>" \
", <span class='firstName'>%s</span></span>" \
% (last_name, first_name)
names_lst.append(name)
except ValueError:
names_lst.append(pn)
if len(names_lst) > 2:
return mark_safe('%s and %s' %
(', '.join(names_lst[:-1]),
names_lst[-1]))
return mark_safe(' and '.join(names_lst))
def get_form_params(self, new_params=None, remove=None):
if new_params is None:
new_params = {}
if remove is None:
remove = []
p = dict(self.request.GET.items()).copy()
arr_keys = list(p.keys())
for r in remove:
for k in arr_keys:
if k.startswith(r):
del p[k]
for k, v in new_params.items():
if v is None:
if k in p:
del p[k]
else:
p[k] = v
return mark_safe(''.join(
'<input type="hidden" name="%s" value="%s"/>' % (k, v) for k, v in p.items() if v))
def view_block(context, block_name, *args, **kwargs):
if 'admin_view' not in context:
return ""
admin_view = context['admin_view']
nodes = []
method_name = 'block_%s' % block_name
for view in [admin_view] + admin_view.plugins:
if hasattr(view, method_name) and callable(getattr(view, method_name)):
block_func = getattr(view, method_name)
result = block_func(context, nodes, *args, **kwargs)
if result and (
isinstance(result, str)
or sys.version_info.major < 3 and isinstance(result, unicode)
):
nodes.append(result)
if nodes:
return mark_safe(''.join(nodes))
else:
return ""
def _get_new_field_html(self, field_name):
try:
f, attr, value = lookup_field(field_name, self.org_obj, self)
except (AttributeError, ObjectDoesNotExist):
return EMPTY_CHANGELIST_VALUE
else:
allow_tags = False
if f is None:
allow_tags = getattr(attr, 'allow_tags', False)
boolean = getattr(attr, 'boolean', False)
if boolean:
allow_tags = True
text = boolean_icon(value)
else:
text = smart_text(value)
else:
if isinstance(f.rel, models.ManyToOneRel):
field_val = getattr(self.org_obj, f.name)
if field_val is None:
text = EMPTY_CHANGELIST_VALUE
else:
text = field_val
else:
text = display_for_field(value, f)
return mark_safe(text) if allow_tags else conditional_escape(text)
def render_flatpage(request, f):
"""
Internal interface to the flat page view.
"""
# If registration is required for accessing this page, and the user isn't
# logged in, redirect to the login page.
if f.registration_required and not request.user.is_authenticated:
from django.contrib.auth.views import redirect_to_login
return redirect_to_login(request.path)
if f.template_name:
template = loader.select_template((f.template_name, DEFAULT_TEMPLATE))
else:
template = loader.get_template(DEFAULT_TEMPLATE)
# To avoid having to always use the "|safe" filter in flatpage templates,
# mark the title and content as already safe (since they are raw HTML
# content in the first place).
f.title = mark_safe(f.title)
f.content = mark_safe(f.content)
response = HttpResponse(template.render({'flatpage': f}, request))
return response
def get_context(self, name, value, attrs):
context = super(ForeignKeyRawIdWidget, self).get_context(name, value, attrs)
rel_to = self.rel.model
if rel_to in self.admin_site._registry:
# The related object is registered with the same AdminSite
related_url = reverse(
'admin:%s_%s_changelist' % (
rel_to._meta.app_label,
rel_to._meta.model_name,
),
current_app=self.admin_site.name,
)
params = self.url_parameters()
if params:
related_url += '?' + '&'.join(
'%s=%s' % (k, v) for k, v in params.items(),
)
context['related_url'] = mark_safe(related_url)
context['link_title'] = _('Lookup')
# The JavaScript code looks for this class.
context['widget']['attrs'].setdefault('class', 'vForeignKeyRawIdAdminField')
if context['widget']['value']:
context['link_label'], context['link_url'] = self.label_and_url_for_value(value)
return context
def label_tag(self):
classes = []
contents = conditional_escape(force_text(self.field.label))
if self.is_checkbox:
classes.append('vCheckboxLabel')
if self.field.field.required:
classes.append('required')
if not self.is_first:
classes.append('inline')
attrs = {'class': ' '.join(classes)} if classes else {}
# checkboxes should not have a label suffix as the checkbox appears
# to the left of the label.
return self.field.label_tag(
contents=mark_safe(contents), attrs=attrs,
label_suffix='' if self.is_checkbox else None,
)
def contact_link(self, booking):
url = self.get_admin_url(booking.contact)
return mark_safe("<a href='{}'>{}</a>".format(url, booking.contact.name))
def album_link(self, booking):
url = self.get_admin_url(booking.album)
return mark_safe("<a href='{}'>{}</a>".format(url, booking.album.title))
def album_link(self, booking):
url = self.get_admin_url(booking.album)
return mark_safe("<a href='{}'>{}</a>".format(url, booking.album.title))
def button(url, txt):
template = '<div style="padding: 30px;"><a target="_blank" href="{0}" style="{1}" class="button">{2}</a></div>'
html = template.format(url, get_styles(), txt)
return mark_safe(html)
def get_help_text(self):
return mark_safe(self.help_text)
def get_description(self):
return mark_safe(self.description)
def prosemirror(content, headingoffset=0):
"""
Render prosemirror content as html with a specified header level.
1 is h1, 2 is h2, ...
"""
return mark_safe(render(content, headingoffset))
def validate(self, request=None):
"""Check validity of configuration and Page template"""
self.config.validate()
try:
context = self.get_validation_context(request=request)
self.render(context)
except:
tb_info = traceback.format_exc()
msg = (
'An error occurred trying to render the Page:\n'
'<br/><pre>{0}</pre>'.format(tb_info)
)
raise ValidationError(mark_safe(msg))
def validate(self, request=None):
try:
self.get_redirect_location()
except:
tb_info = traceback.format_exc()
msg = (
'An error occurred trying to render the Page:\n'
'<br/><pre>{0}</pre>'.format(tb_info)
)
raise ValidationError(mark_safe(msg))
def sync_status(page):
"""Synchronization status of the Page"""
if not page:
return None
status_parts = []
if page.is_dirty:
status_parts.append(
'<span style="color:black; font-weight:bold">'
'Changed in Admin!'
'</span>'
)
dump_status = PageFileDumper(page).status()
if dump_status == SyncStatus.NO_CHANGES:
dump_text = 'File is synced'
dump_color = 'green'
elif dump_status == SyncStatus.MODIFIED:
dump_text = 'File content differs'
dump_color = 'orange'
elif dump_status == SyncStatus.ADDED:
dump_text = 'File is missing'
dump_color = 'red'
else: # Unknown sync status
dump_text = '?'
dump_color = 'black'
status_parts.append(
'<span style="color: {0}">{1}</span>'.format(
dump_color, dump_text
)
)
return mark_safe('<br>'.join(status_parts))
def get_bookmarklet_url(request):
scheme = 'http' if settings.DEBUG else 'https'
host = request.META['HTTP_HOST']
return mark_safe('javascript:' + render_to_string(
'bookmarklet.js',
{
'base_url': f'{scheme}://{host}'
},
request=request
).replace('\n', '').replace('"', '"'))
