def create(msgid):
entry = catalog.dict.get(msgid, None)
# is_valid_translation = True if entry and entry.translated() else False
# is_valid_translation = True if entry and entry.msgstr is not u"" or None \
# and not entry.obsolete else False
is_valid_translation = utils.is_translated(entry)
# if translated:
# print "\n\n", str(is_valid_translation), ", "
# print "Test= ", msg, translated, "==", encode(translated.msgstr), \
# ", file=", str(translated.pfile), "obs=", str(translated.obsolete), "\n"
if is_valid_translation:
msg_target = entry.msgstr
else:
msg_target = _(msgid)
if not is_valid_translation:
css_class = 'rosetta-inpage-todo'
elif entry and 'fuzzy' in entry.flags:
css_class = 'rosetta-inpage-fuzzy'
else:
css_class = 'rosetta-inpage-foo'
return {
'show': show_message(msgid, view_locale),
'hash': rosetta_inpage.hash_text(msgid),
'source': mark_safe(msg), # the source message
'msg': mark_safe(msg_target), # the translated message
'translated': is_valid_translation,
'fuzzy': False if entry and 'fuzzy' not in entry.flags else True,
'css_class': css_class
}
def djfrontend_ga(account=None):
"""
Returns Google Analytics asynchronous snippet.
Use DJFRONTEND_GA_SETDOMAINNAME to set domain for multiple, or cross-domain tracking.
Set DJFRONTEND_GA_SETALLOWLINKER to use _setAllowLinker method on target site for cross-domain tracking.
Included in HTML5 Boilerplate.
"""
if account is None:
account = getattr(settings, 'DJFRONTEND_GA', False)
if account:
if getattr(settings, 'TEMPLATE_DEBUG', False):
return ''
else:
if getattr(settings, 'DJFRONTEND_GA_SETDOMAINNAME', False):
if getattr(settings, 'DJFRONTEND_GA_SETALLOWLINKER', False):
return mark_safe(
'<script>(function(i,s,o,g,r,a,m){i["GoogleAnalyticsObject"]=r;i[r]=i[r]||function(){(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)})(window,document,"script","//www.google-analytics.com/analytics.js","ga");ga("require", "linker");ga("linker:autoLink", ["%s"]);ga("create", "%s", "auto", {"allowLinker": true});ga("send", "pageview");</script>' %
(settings.DJFRONTEND_GA_SETDOMAINNAME, account))
else:
return mark_safe(
'<script>(function(i,s,o,g,r,a,m){i["GoogleAnalyticsObject"]=r;i[r]=i[r]||function(){(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)})(window,document,"script","//www.google-analytics.com/analytics.js","ga");ga("create", "%s", "%s");ga("send", "pageview");</script>' %
(account, settings.DJFRONTEND_GA_SETDOMAINNAME))
else:
return mark_safe(
'<script>(function(i,s,o,g,r,a,m){i["GoogleAnalyticsObject"]=r;i[r]=i[r]||function(){(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)})(window,document,"script","//www.google-analytics.com/analytics.js","ga");ga("create", "%s", "auto");ga("send", "pageview");</script>' % account)
else:
return ''
def render(self, value, record, bound_column):
if not self.links:
raise NotImplementedError('Links not assigned.')
if not isinstance(self.links, (list, tuple,dict)):
raise NotImplementedError('Links must be an iterable.')
links = []
for link in self.links:
title = link['title']
url = link['url']
attrs = link['attrs'] if 'attrs' in link else None
if 'args' in link:
args = [a.resolve(record) if isinstance(a, A) else a for a in link['args']]
else:
args = None
attrs = AttributeDict(attrs if attrs is not None else self.attrs.get('a', {}))
try:
attrs['href'] = urlresolvers.reverse(url, args=args)
except urlresolvers.NoReverseMatch:
attrs['href'] = url
links.append('<a {attrs}>{text}</a>'.format(
attrs=attrs.as_html(),
text=mark_safe(title)
))
return mark_safe(self.delimiter.join(links))
def algorithm(value, cycles_count):
result_counts_list = []
is_y_multiple = 0
for obj_num in iter_func:
if obj_num < cabinet_cells_num:
if cabinet_cells_num % max_cabinet_rows_nums == 0:
is_y_multiple += max_cabinet_rows_nums
result_list.append(
format_html(structure_template.cabinet_structure_rows_template,
mark_safe(create_cabinet_cells_func(obj_num, is_y_multiple))))
else:
is_y_multiple_result_num = value - value % max_cabinet_rows_nums # 计算(1) 如果随机数为y的倍数
if cycles_count == is_y_multiple_result_num // max_cabinet_rows_nums: # 计算(2)
cycles_count_generator = imap(lambda x: (x * max_cabinet_rows_nums), range(cycles_count))
rack_tag_num = 0 # 为了控制前端机柜编号是可以逐渐叠加
for cycles_num in cycles_count_generator:
rack_tag_num += max_cabinet_rows_nums
result_counts_list.append(rack_tag_num)
result_list.append(
format_html(structure_template.cabinet_structure_rows_template,
mark_safe(create_cabinet_cells_func(cycles_num, rack_tag_num))))
result_list.append(
format_html(structure_template.cabinet_structure_rows_template,
mark_safe(
create_cabinet_cells_func(
result_counts_list[-1],
result_counts_list[-1] + (value - is_y_multiple_result_num)
))))
break
return algorithm(cabinet_cells_num, is_y_multiple_result_num // max_cabinet_rows_nums)
def _job_result(request, job):
statusdir = job.statusdir
result = {}
try:
stderr_file = statusdir + "/stderr"
stdout_file = statusdir + "/stdout"
exit_code_file = statusdir + "/exit"
pig_script_file = statusdir + "/script.pig"
python_udf_file = statusdir + "/pythonudf.py"
error = request.fs.read(stderr_file, 0, request.fs.stats(stderr_file).size)
stdout = request.fs.read(stdout_file, 0, request.fs.stats(stdout_file).size)
exit_code = request.fs.read(exit_code_file, 0, request.fs.stats(exit_code_file).size)
pig_script = request.fs.read(pig_script_file, 0, request.fs.stats(pig_script_file).size)
try:
result['python_script'] = mark_safe(request.fs.read(python_udf_file, 0, request.fs.stats(python_udf_file).size))
except:
pass
result['error'] = mark_safe(error)
result['stdout'] = mark_safe(stdout)
result['exit'] = mark_safe(exit_code)
result['pig_script'] = mark_safe(pig_script)
if job.job_type == job.SYNTAX_CHECK:
result['stdout'] = result['error']
except:
raise Http404("Script data has been deleted.")
return result
def inline_static_file(path, minify=None):
"""
Outputs the [minified] contents of a given static file.
For example, to display the minified CSS file "``inline.css``"::
<style>
{% inline_static_file 'inline.css' 'css' %}
</style>
The optional ``minify`` argument can be one of css, js, or html.
"""
p = finders.find(path)
if not p:
raise RuntimeError('path=%s not found' % path)
elif os.path.isdir(p):
raise RuntimeError('path=%s is not a file' % path)
with open(p, encoding='utf-8') as f:
if minify == 'js':
return mark_safe(js_minify(f.read()))
elif minify == 'css':
return mark_safe(css_minify(f.read()))
elif minify == 'html':
return mark_safe(html_minify(f.read()))
else:
return mark_safe(f.read())
def checkbox_or_radio(context, field, label=None, **attrs):
if isinstance(field, BoundField):
attrs['name'] = field.name
if 'value' in attrs:
attrs['checked'] = (field.value() == attrs['value'])
elif isinstance(field, str):
attrs['name'] = field
if not label:
attrs.setdefault('id', get_field_id(context, attrs.get('name')))
return mark_safe(tags.input(**attrs))
input_attrs_keys = ['value', 'name', 'type', 'checked', 'id']
label_attrs = attrs.copy()
input_attrs = {}
for key in input_attrs_keys:
value = attrs.get(key)
if value:
input_attrs[key] = value
del label_attrs[key]
checkbox = tags.input(**input_attrs) + ' ' + tags.span(label)
return mark_safe(tags.label(checkbox, **label_attrs))
def get_breadcrumbs(index_instance_node, simple=False, single_link=False, include_count=False):
"""
Return a joined string of HTML anchors to every index instance's
parent from the root of the tree to the index instance
"""
result = []
if single_link:
# Return the entire breadcrumb path as a single HTML anchor
simple = True
for instance in index_instance_node.get_ancestors():
result.append(get_instance_link(instance, simple=simple))
result.append(get_instance_link(index_instance_node, simple=simple))
output = []
if include_count:
output.append('(%d)' % index_instance_node.documents.count())
if single_link:
# Return the entire breadcrumb path as a single HTML anchor
output.insert(
0, get_instance_link(
index_instance_node=index_instance_node, text=(
' / '.join(result)
)
)
)
return mark_safe(' '.join(output))
else:
output.insert(0, ' / '.join(result))
return mark_safe(' '.join(output))
def as_container(self, context=None):
""" this basically is here for compatibility reasons with the django-containerfield app. """
ret = mark_safe('<span class="wording-container" ' + self.get_container_attrs() + '>')
ret += self.get_text(context=context)
ret += mark_safe('</span>')
return ret
def get_avatar_urls_uncached(self, request, user, size=None):
"""Return the avatar urls.
Args:
request (django.http.HttpRequest):
The HTTP request.
user (django.contrib.auth.models.User):
The user.
size (int, optional):
The requested avatar size.
Returns:
dict:
A dictionary of avatars. If ``use_2x`` was specified at
initialization, a high-DPI avatar will be supplied.
"""
urls = {
'1x': mark_safe('http://example.com/avatar.png'),
'2x': None,
}
if self.use_2x:
urls['2x'] = mark_safe('http://example.com/[email protected]')
return urls
def qualified_mark(value):
if value is None:
return mark_safe('<span class="maybe-qualified">?</span>')
elif value is True:
return mark_safe('<span class="qualified">✔</span> TAK')
else:
return mark_safe('<span class="not-qualified">✘</span> NIE')
def description_as_html(self, description, params):
user = self.activity.user
if user:
name = user.get_display_name()
else:
name = 'Sentry'
fmt = u'<span class="avatar-container">{}</span> <strong>{}</strong>'
author = mark_safe(fmt.format(
self.avatar_as_html(),
escape(name),
))
an_issue = u'<a href="{}">an issue</a>'.format(
escape(self.get_group_link()),
)
context = {
'author': author,
'an issue': an_issue,
}
context.update(params)
return mark_safe(description.format(**context))
def inline_work_list(works):
allworks = []
for w in works:
text = inline_work(w)
if w.composers.exists():
text = mark_safe(u"%s by %s" % (text, inline_composer(w.composers.all()[0])))
allworks.append(text)
return mark_safe(u", ".join(allworks))
def block_title(slug, user, textblocks, wrapper_type="edit"):
if slug in textblocks:
block = textblocks[slug]
if wrapper_type == "edit":
return admin_inline(mark_safe(block.title), user, block.id)
else:
return mark_safe(block.title)
return slug
def label_from_instance(self, obj):
"""
Creates labels which represent the tree level of each node when
generating option labels.
"""
level = getattr(obj, obj._mptt_meta.level_attr)
level_indicator = mark_safe(conditional_escape(self.level_indicator) * level)
return mark_safe(u'%s %s' % (level_indicator, conditional_escape(smart_unicode(obj))))
def generated_field(self, obj):
if obj.pk:
if obj.generated:
view = mark_safe('<a href="{url}">View details</a>'.format(url=reverse('synthetic:configuration_detail', args=[obj.pk])))
delete = mark_safe('<a href="{url}">Delete data</a>'.format(url=reverse('synthetic:configuration_delete', args=[obj.pk])))
return mark_safe('{view} {detail}'.format(view=view, detail=delete))
else:
return mark_safe('<a href="{url}">Generate data</a>'.format(url=reverse('synthetic:configuration_generate', args=[obj.pk])))
def common_variables(request):
return {
# 'debug': True,
'show_admin': has_perm(request.user, 'admin_view'),
'show_new_article': has_perm(request.user, 'article_new'),
'website_name': website_name(),
'downvote_sign': mark_safe('▼'),
'upvote_sign': mark_safe('▲'),
}
def test_format_html(self):
self.assertEqual(
html.format_html("{} {} {third} {fourth}",
"< Dangerous >",
html.mark_safe("<b>safe</b>"),
third="< dangerous again",
fourth=html.mark_safe("<i>safe again</i>")
),
"< Dangerous > <b>safe</b> < dangerous again <i>safe again</i>"
)
def __init__(self, *args, **kwargs):
super(LayoutPaginaAdminForm, self).__init__(*args, **kwargs)
self.fields['logo_cabecalho'].label = mark_safe('<a href="#" onclick="window.open(\'/admin/configuracao/layoutlogo/\'+'
'$(\'#id_logo_cabecalho\').val() + \'/\', \'_blank\');'
'return true;">Logo do cabecalho</a> (185x150)')
self.fields['logo_rodape'].label = mark_safe('<a href="#" onclick="window.open(\'/admin/configuracao/layoutlogo/\'+'
'$(\'#id_logo_rodape\').val() + \'/\', \'_blank\');'
'return true;">Logo do rodape</a> (150x150)')
def two_pages_decorated_with_errors(submission, errors):
pages = submission.first_two_pages or ''
if 'rev' not in errors.keys():
return mark_safe('<pre>%s</pre>' % escape(pages))
result = '<pre>\n'
for line in pages.split('\n'):
result += escape(line)
result += '\n'
result += '</pre>pre>\n'
return mark_safe(result)
def geocoding_result_link(self, obj):
if obj.has_result:
return mark_safe(
'<a href="%s/geocoding/results?task=%s" target="_blank" title="View Geocoding Results"><i class="fa fa-map-marker fa-lg"></i></a>'
% (ROOT_APP_URL, obj.id)
)
else:
return mark_safe(
'<a href="%s/geocoding/setup?task=%s" title="Go Geocoding"><i class="fa fa-arrow-circle-right fa-lg"></i></a>'
% (ROOT_APP_URL, obj.id)
)
def render_column(self, row, column):
if column == "heading":
ret = mark_safe("<p>{0}</p>".format(row.linked_breadcrumbs))
if row.related_by_pos:
ret += mark_safe("<p>{0}</p>".format(
render_to_string("semantic_fields/other_pos.html", {
'instance': row
})))
return ret
return super(SearchTable, self).render_column(row, column)
def survey(request, survey_id):
# 404 if the survey doesn't exist.
survey = get_object_or_404(Survey, id=survey_id)
# Does a receipt for printing exist?
receipt = len(str(survey.receipt))
# Build the form
fields = survey.getQuestions()
form = SurveyForm(request.POST or None, fields = fields, survey = survey)
if form.is_valid():
response = Response(survey=survey)
response.save()
for (question, answer) in form.answers():
response.answer_set.create(question_id=question, answer=answer)
confirmation = survey.getConfirmation()
if receipt:
# Do the printing
path = survey.receipt.path
printer = cups.Connection()
printer.printFile(settings.QUESTIONNAIRE_PRINTER, path, 'Questionnaire receipt', {})
# Does participant already exist?
participant = Participant()
#if participant.doesParticipantExist(form.cleaned_data['participant_phone']):
# pass #If the participant exists already then abort.
if 'participant_name' in request.POST and request.POST['participant_name'] is not u'':
participant.name = form.cleaned_data['participant_name']
participant.save()
if 'participant_phone' in request.POST and request.POST['participant_phone'] is not u'':
participant.phone = form.cleaned_data['participant_phone']
participant.save()
text_message = TextMessage()
text_message.participant = participant
text_message.save()
text = survey.text_message % str(text_message.code)
data = {
'username': '******',
'password': settings.SMS_PASSWORD,
'recipient': '45' + str(form.cleaned_data['participant_phone']),
'text': text,
'from': 'DSE',
'callback': 'http://esf.studerende.dk'+reverse('questionnaire:callback'),
'reply': 'extended',
}
# Send the text message and parse the response.
xmlresponse = urllib2.urlopen('https://api.sms1919.dk/rpc/push/', urllib.urlencode(data)).read()
soup = BeautifulSoup(xmlresponse)
sms_id = soup.result.messageid.contents
text_message.uuid = "".join(unicode(item) for item in sms_id)
text_message.save()
context = {'name': survey.name, 'confirmation': mark_safe(confirmation), 'receipt': receipt, 'redirect': reverse('questionnaire:survey', kwargs={'survey_id': survey_id})}
return render(request, 'questionnaire/confirmation.html', context)
introduction = survey.getIntroduction()
context = {'name': survey.name, 'introduction': mark_safe(introduction), 'form': form}
return render(request, 'questionnaire/form.html', context)
def get_queryset(self):
user_list = get_user_list(self.request.session['user_id'])
objects = []
if user_list is not None:
for obj in user_list:
values = []
values.append(mark_safe('<input type="checkbox" class="checkboxes" value="%s" name="list"/>' % obj.identify))
values.append(obj.identify)
values.append(mark_safe(u'<a href="/user/user=%s">%s</a>' % (obj.identify, obj.get_full_name())))
objects.append(values)
return objects
def get_json(object):
"""
Get the json.
:param object: The class instance.
:return: 'json string'
"""
if hasattr(object, 'dict') and callable(object.dict):
return mark_safe(json.dumps(object.dict()))
elif isinstance(object, dict):
return mark_safe(json.dumps(object))
else:
return mark_safe(json.dumps(object.__dict__))
def get_queryset(self):
activity_type_list = get_activity_type_list()
objects = []
for obj in activity_type_list:
values =[]
values.append(mark_safe('<input type="checkbox" class="checkboxes" value="1" id="%s"/>' % obj.identify))
values.append(obj.identify)
values.append(mark_safe(u'<a href="/activity_type/activity_type=%s/edit/">%s</a>' % (obj.identify, obj.name)))
objects.append(values)
return objects
def _process_non_formset_answers_for_edit(self, json_questions):
answers = {}
for question in json_questions:
answer = question.get('answer')
question_id = question.get('id')
if answer and question_id:
answers["question_%i" % question_id] = mark_safe(answer) # answers are escaped before saving
extra = question.get('extra')
if extra:
extra_answer = extra.get('answer')
if extra_answer:
answers['question_%i_extra-%s' % (question_id, answer)] = mark_safe(extra_answer)
return answers
def __init__(self, *args, **kwargs):
super(CrossConnectionAdminForm, self).__init__(*args, **kwargs)
self.id = None
if 'instance' in kwargs and kwargs['instance']:
self.id = kwargs['instance'].id
# Adicionando link para o label do campo de Origem
self.fields['origem'].label = mark_safe('<a href="#" onclick="window.open(\'/admin/rede/ifcconector/\'+$(\''
'#id_origem\').val() + \'/\', \'_blank\');return true;">Origem</a>')
# Adicionando link para o label do campo de Destino
self.fields['destino'].label = mark_safe('<a href="#" onclick="window.open(\'/admin/rede/ifcconector/\'+$(\''
'#id_destino\').val() + \'/\', \'_blank\');return true;">Destino</a>')
def add_class(value, css_class):
string = unicode(value)
match = class_re.search(string)
if match:
m = re.search(r'^%s$|^%s\s|\s%s\s|\s%s$' % (
css_class, css_class, css_class, css_class), match.group(1))
print match.group(1)
if not m:
return mark_safe(class_re.sub(match.group(1) + " " + css_class,
string))
else:
return mark_safe(string.replace(' ', ' class="%s" ' % css_class, 1))
return value
def euro(amount, min=None, round=False):
"""
Euro amount.
"""
if min:
amount = -amount
if amount == '':
raise ValueError('|euro filter applied to empty string (perhaps the variable was not found)')
try:
if round:
return mark_safe('€ %d' % float(amount))
return mark_safe('€ %.2f' % float(amount))
except ValueError:
raise ValueError('|euro filter should be applied to something that can be cast to a float (got %s)' % amount)
def submit_history_form_link(self, form_id, form_name):
url = reverse('render_form_data', args=[self.domain, form_id])
return html.mark_safe("<a class='ajax_dialog' href='%s'"
"target='_blank'>%s</a>" %
(url, html.escape(form_name)))
def markdown_to_html(md):
html = markdown(md)
allowed_tags = bleach.ALLOWED_TAGS + ['p', 'pre', 'span'
] + ['h%d' % i for i in range(1, 7)]
html = bleach.clean(html, tags=allowed_tags)
return mark_safe(html)
def color_bg(self):
return mark_safe(
'<div style="width:30px; height:30px; background-color:%s;" ></div>'
% (self.color_code))
def format_html(format_string, *args, **kwargs):
args_safe = map(conditional_escape, args)
kwargs_safe = dict((k, conditional_escape(v)) for (k, v) in kwargs.items())
return mark_safe(format_string.format(*args_safe, **kwargs_safe))
def escape_latex(value): return mark_safe(latex.escape(value))
def get_identifier(cls, instance):
render_type = instance.glossary.get('render_type')
return mark_safe(dict(cls.CHOICES).get(render_type, ''))
def dumps_htmlsafe(value):
return mark_safe(_default_escaped_encoder.encode(value))
def get_thumbnail(self, obj):
return mark_safe(
f'<img src="{obj.file.url}", width=50px/>'
) # mark_safe import 한거임
def get_thumbnail(
self, obj
): # 사용자에게 썸네일을 어드민 패널에서 보여주기 위함. 패널에서만 쓸 것이라 얜 model 아닌 admin 에 만들어주엇다.
return mark_safe(f'<img width="30px" src="{obj.file.url}" />')
def render_raw(self):
self.get_template_context()
output = ''.join([form._renderer['inline']() for form in self.obj])
return mark_safe(output)
def get_message_as_markdown(self):
#print(mark_safe(markdown(self.message,safe_mode='escape')))
return mark_safe(markdown(markdown(self.message,safe_mode='escape')).replace("<img",'<img class="img-fluid mx-auto d-block"'))
def body_html(self):
return mark_safe(markdown_to_html(self.text, self.images.all()))
def get_thumbnail(self, obj):
return mark_safe(f'<img width="50px" src="{obj.file.url}"/>')
def get_message_as_markdown(self):
return mark_safe(markdown(self.message, safe_mode='escape'))
def render_revision_form(self,
request,
obj,
version,
context,
revert=False,
recover=False):
"""Renders the object revision form."""
model = self.model
opts = model._meta
object_id = obj.pk
# Generate the model form.
ModelForm = self.get_form(request, obj)
formsets = []
if request.method == "POST":
# This section is copied directly from the model admin change view
# method. Maybe one day there will be a hook for doing this better.
form = ModelForm(request.POST,
request.FILES,
instance=obj,
initial=self.get_revision_form_data(
request, obj, version))
if form.is_valid():
form_validated = True
new_object = self.save_form(request, form, change=True)
else:
form_validated = False
new_object = obj
prefixes = {}
for FormSet, inline in zip(self.get_formsets(request, new_object),
self.inline_instances):
prefix = FormSet.get_default_prefix()
prefixes[prefix] = prefixes.get(prefix, 0) + 1
if prefixes[prefix] != 1:
prefix = "%s-%s" % (prefix, prefixes[prefix])
formset = FormSet(request.POST,
request.FILES,
instance=new_object,
prefix=prefix,
queryset=inline.queryset(request))
# _ _ _ ____ ___ ____ _ _ ____ _ _ ___
# | | | |__| | | |__| | | | | |
# |_|_| | | | |___ | | |__| |__| |
# this is not copy pasted:
# Strip extra empty forms from the formset.
empty_forms = []
post_keys = request.POST.keys()
for f in formset.forms:
# the forms that can be removed, are not in the request.POST
# we can find them by their prefix
matches_prefix = lambda var: var.find(f.prefix
) == 0 or None
if first_match(matches_prefix, post_keys) is None:
empty_forms.append(f)
else:
# the form must be cleaned, which they aren't yet because
# we just created them
f.full_clean()
# modify form settings of formset.
num_forms = formset.total_form_count() - len(empty_forms)
formset.forms = filter(lambda x: x not in empty_forms,
formset.forms)
formset.total_form_count = lambda: num_forms
# end of non copy pasted piece
# Add this hacked formset to the form.
formsets.append(formset)
if all_valid(formsets) and form_validated:
self.save_model(request, new_object, form, change=True)
form.save_m2m()
for formset in formsets:
self.save_formset(request, form, formset, change=True)
# _ _ _ ____ ___ ____ _ _ ____ _ _ ___
# | | | |__| | | |__| | | | | |
# |_|_| | | | |___ | | |__| |__| |
# this is not copy pasted:
self.update_draft(version, request)
change_message = _(u"Publisher message %(datetime)s") % {
"datetime":
format(version.revision.date_created,
_(settings.DATETIME_FORMAT))
}
self.log_change(request, new_object, change_message)
self.message_user(
request,
_(u'%(model)s "%(name)s" publisher message.') % {
"model": force_unicode(opts.verbose_name),
"name": unicode(obj)
})
# end of not copy pasted code
# Redirect to the model change form.
if revert:
return HttpResponseRedirect("../../")
elif recover:
return HttpResponseRedirect("../../%s/" % object_id)
else:
assert False
else:
# This is a mutated version of the code in the standard model admin
# change_view. Once again, a hook for this kind of functionality
# would be nice. Unfortunately, it results in doubling the number
# of queries required to construct the formets.
form = ModelForm(instance=obj,
initial=self.get_revision_form_data(
request, obj, version))
prefixes = {}
revision_versions = version.revision.version_set.all()
for FormSet, inline in zip(self.get_formsets(request, obj),
self.inline_instances):
# This code is standard for creating the formset.
prefix = FormSet.get_default_prefix()
prefixes[prefix] = prefixes.get(prefix, 0) + 1
if prefixes[prefix] != 1:
prefix = "%s-%s" % (prefix, prefixes[prefix])
formset = FormSet(instance=obj,
prefix=prefix,
queryset=inline.queryset(request))
# Now we hack it to push in the data from the revision!
try:
fk_name = FormSet.fk.name
except AttributeError:
# This is a GenericInlineFormset, or similar.
fk_name = FormSet.ct_fk_field.name
# _ _ _ ____ ___ ____ _ _ ____ _ _ ___
# | | | |__| | | |__| | | | | |
# |_|_| | | | |___ | | |__| |__| |
# this is not copy pasted:
related_versions = [
(related_version.object_id, related_version)
for related_version in revision_versions
if ContentType.objects.get_for_id(
related_version.content_type_id).model_class() ==
FormSet.model
and unicode(related_version.field_dict[fk_name]) ==
unicode(object_id)
]
# all items that do not have their id filled in must stay.
# if they do in fact have an id, we only want the last one,
# no duplicates.
related_versions = [(key, value) for (key, value) in related_versions if key == 'None'] + \
dict([(key, value) for (key, value) in related_versions if key != 'None']).items()
initial = []
for related_obj in formset.queryset:
related_versions_dict = dict(related_versions)
if unicode(related_obj.pk) in related_versions_dict:
initial.append(
related_versions_dict.pop(unicode(
related_obj.pk)).field_dict)
else:
initial_data = model_to_dict(related_obj)
initial_data["DELETE"] = True
initial.append(initial_data)
for (key, related_version) in related_versions:
initial_row = related_version.field_dict
try:
del initial_row["id"]
except KeyError:
# when multiple inlines with the same model but a different
# querysets are on a page, it could happen that we allready
# deleted the id.
pass
# we didn't convert related_versions to a dict so there can be
# duplicate keys in the thingy
if not initial_row in initial:
initial.append(initial_row)
# end of non copy pasted piece
# Reconstruct the forms with the new revision data.
formset.initial = initial
formset.forms = [
formset._construct_form(n) for n in xrange(len(initial))
]
# Add this hacked formset to the form.
formsets.append(formset)
# Generate admin form helper.
adminForm = helpers.AdminForm(form,
self.get_fieldsets(request, obj),
self.prepopulated_fields,
self.get_readonly_fields(request, obj),
model_admin=self)
media = self.media + adminForm.media
# Generate formset helpers.
inline_admin_formsets = []
for inline, formset in zip(self.inline_instances, formsets):
fieldsets = list(inline.get_fieldsets(request, obj))
readonly = list(inline.get_readonly_fields(request, obj))
inline_admin_formset = helpers.InlineAdminFormSet(inline,
formset,
fieldsets,
readonly,
model_admin=self)
inline_admin_formsets.append(inline_admin_formset)
media = media + inline_admin_formset.media
# Generate the context.
context.update({
"adminform":
adminForm,
"object_id":
object_id,
"original":
obj,
"is_popup":
False,
"media":
mark_safe(media),
"inline_admin_formsets":
inline_admin_formsets,
"errors":
helpers.AdminErrorList(form, formsets),
"app_label":
opts.app_label,
"add":
False,
"change":
True,
"has_add_permission":
self.has_add_permission(request),
"has_change_permission":
self.has_change_permission(request, obj),
"has_delete_permission":
self.has_delete_permission(request, obj),
"has_file_field":
True,
"has_absolute_url":
getattr(self.model, 'get_absolute_url', False),
"ordered_objects":
opts.get_ordered_objects(),
"form_url":
mark_safe(request.path),
"opts":
opts,
"content_type_id":
ContentType.objects.get_for_model(self.model).id,
"save_as":
False,
"save_on_top":
self.save_on_top,
"changelist_url":
reverse("admin:%s_%s_changelist" %
(opts.app_label, opts.module_name)),
"change_url":
reverse("admin:%s_%s_change" % (opts.app_label, opts.module_name),
args=(obj.pk, )),
"history_url":
reverse("admin:%s_%s_history" % (opts.app_label, opts.module_name),
args=(obj.pk, )),
"recoverlist_url":
reverse("admin:%s_%s_recoverlist" %
(opts.app_label, opts.module_name))
})
# Render the form.
if revert:
form_template = self.revision_form_template
elif recover:
form_template = self.recover_form_template
else:
assert False
return render_to_response(form_template, context,
template.RequestContext(request))
def render_fields(form, *fields):
return mark_safe(''.join(form[field].renderer() for field in fields))
def get_image(self, obj):
if obj.image:
return mark_safe(
f'<img src={obj.image.url} width="50" height="60" style="background-size: cover;">'
)
return '-'
def get_from_example_as_markdown(self):
return mark_safe(
markdown(self.from_example,
extensions=['tables'],
safe_mode='escape'))
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.fields['image'].help_text = mark_safe(
'<span style="color: red; font-family: Arial sens-serif; font-size: 16px;">Загружайте изображение с'
' мин. разрешением {}x{}, и макс. {}x{}</style>'.format(
*self.MIN_RESOLUTION, *self.MAX_RESOLUTION))
def history_form_view(self,
request,
object_id,
version_id,
extra_context=None):
request.current_app = self.admin_site.name
original_opts = self.model._meta
model = getattr(
self.model,
self.model._meta.simple_history_manager_attribute).model
obj = get_object_or_404(
model, **{
original_opts.pk.attname: object_id,
"history_id": version_id
}).instance
obj._state.adding = False
if not self.has_change_permission(request, obj):
raise PermissionDenied
if SIMPLE_HISTORY_EDIT:
change_history = True
else:
change_history = False
if "_change_history" in request.POST and SIMPLE_HISTORY_EDIT:
history = utils.get_history_manager_for_model(obj)
obj = history.get(pk=version_id).instance
formsets = []
form_class = self.get_form(request, obj)
if request.method == "POST":
form = form_class(request.POST, request.FILES, instance=obj)
if form.is_valid():
new_object = self.save_form(request, form, change=True)
self.save_model(request, new_object, form, change=True)
form.save_m2m()
self.log_change(
request,
new_object,
self.construct_change_message(request, form, formsets),
)
return self.response_change(request, new_object)
else:
form = form_class(instance=obj)
admin_form = helpers.AdminForm(
form,
self.get_fieldsets(request, obj),
self.prepopulated_fields,
self.get_readonly_fields(request, obj),
model_admin=self,
)
model_name = original_opts.model_name
url_triplet = self.admin_site.name, original_opts.app_label, model_name
context = {
"title":
_("Revert %s") % force_text(obj),
"adminform":
admin_form,
"object_id":
object_id,
"original":
obj,
"is_popup":
False,
"media":
mark_safe(self.media + admin_form.media),
"errors":
helpers.AdminErrorList(form, formsets),
"app_label":
original_opts.app_label,
"original_opts":
original_opts,
"changelist_url":
reverse("%s:%s_%s_changelist" % url_triplet),
"change_url":
reverse("%s:%s_%s_change" % url_triplet, args=(obj.pk, )),
"history_url":
reverse("%s:%s_%s_history" % url_triplet, args=(obj.pk, )),
"change_history":
change_history,
# Context variables copied from render_change_form
"add":
False,
"change":
True,
"has_add_permission":
self.has_add_permission(request),
"has_change_permission":
self.has_change_permission(request, obj),
"has_delete_permission":
self.has_delete_permission(request, obj),
"has_file_field":
True,
"has_absolute_url":
False,
"form_url":
"",
"opts":
model._meta,
"content_type_id":
ContentType.objects.get_for_model(self.model).id,
"save_as":
self.save_as,
"save_on_top":
self.save_on_top,
"root_path":
getattr(self.admin_site, "root_path", None),
}
context.update(self.admin_site.each_context(request))
context.update(extra_context or {})
extra_kwargs = {}
return self.render_history_view(request,
self.object_history_form_template,
context, **extra_kwargs)
def image_tag(self):
return mark_safe('<img src="%s" width="50" height="50"/>' %
(self.image.url))
def get_title(self, obj):
return mark_safe("<a href='{0}' target='_blank'>{1}</a>".format(
obj.source_url, obj.title))
def _get_level_indicator(self, obj):
level = getattr(obj, obj._mptt_meta.level_attr) - self.base_level
if level > 0:
return mark_safe(conditional_escape(self.level_indicator) * level)
else:
return ''
def clinician_notes_image(self):
return mark_safe(
'<a href="%(url)s">'
'<img src="%(url)s" style="padding-right:150px" width="150" height="100" />'
'</a>' % {'url': self.image.url})
def get_image(self, obj): return mark_safe(u'<img src="%s" style="width:200px;height:200px;"/>' % (obj.image.url))
class CustomLinkTable(tables.Table):
last_name = tables.LinkColumn(
'person',
text=mark_safe('<i class="glyphicon glyphicon-pencil"></i>'),
args=[A('pk')])
def get_html_badge(self):
name = escape(self.name)
color = escape(self.color)
html = '<span class="badge badge-primary" style="background-color: %s">%s</span>' % (
color, name)
return mark_safe(html)
def get_thumbnail(self, obj):
print(obj.file.url)
return mark_safe(f"<img width='70px' src='{obj.file.url}'/>")
def get_html_badge(self):
name = escape(self.amount)
color = escape(self.color)
# html = '<span class="badge badge-pill badge-primary" style="background-color: %s">$%s</span>' % (color, name)
html = '<span class="badge badge-pill badge-info">$%s</span>' % name
return mark_safe(html)
def image_thumb(self):
return mark_safe(
'<img src="{}" alt="" style="width: 256px; height: auto;" />'.
format(self.image.url))
