def html_output(self, rendered_input):
t = loader.get_template_from_string(self.html_output_format)
c = loader.Context({
'input': rendered_input,
'icon': self.icon.as_html()
})
return mark_safe(t.render(c))
def get(self, request, *args, **kwargs):
self.object_list = ['----------'] + list(
self.get_queryset(**self.get_queryset_kwargs()))
template = self.get_template()
context = loader.Context(
self.get_context_data(object_list=self.object_list))
return HttpResponse(template.render(context))
def render(self):
context = loader.Context({
'data_cadastro': self.data_cadastro,
'conteudo': self.conteudo,
'criado_por': self.criado_por,
'icon_name': self.icon_name,
})
template = loader.get_template_from_string(self.get_template())
return template.render(context)
def render(self, value, record, bound_column):
v = getattr(record, bound_column.accessor)
conf = self.conf.get(v, None)
# add a tip text
attrs = conf.get('attrs', AttributeDict())
attrs.add_class('tip')
attrs.attr('title', value)
template = loader.get_template_from_string(
"<span {{ attrs }}>{{ value }}</span>")
return template.render(
loader.Context({
'value': conf.get('icon', None) or value,
'attrs': attrs.as_html()
}))
def render(self, context):
field = self.field.resolve(context)
kwargs = resolve_kwargs(self.kwargs, context)
attrs = AttributeDict(resolve_kwargs(self.attrs, context))
# merge attrs
for key, value in field.field.widget.attrs.items():
attrs.attr(key, value)
field.field.widget.attrs = attrs
template = loader.get_template(
kwargs.pop('template', 'forms/input.html'))
kwargs.update({'field': field})
context = loader.Context(kwargs)
return template.render(context)
def render(self, name, value, attrs=None):
"""Render plain text input or widget with extra fields.
Extra fields are 'required' and 'has_comment'.
"""
# plain text area
output = super(ShortTextInput, self).render(name, value, attrs)
# add 'required' and 'has_comment' fields
context = dict(name=name, is_required=self.is_required,
has_comment=self.has_comment)
template = loader.get_template_from_string(REQUIRED_COMMENT_TPL)
rendered = template.render(context=loader.Context(dict_=context))
output = rendered + output
output = '<fieldset>' + output + '</fieldset>'
return output
def render(self, name, value, attrs=None, choices=()):
output = []
value = force_str(value) or ''
attrs = self.build_attrs(attrs)
t = loader.get_template_from_string(self.output_html)
for id, label in list(chain(self.choices, choices)):
check = lambda v: force_str(v) in value
radio = RadioInput(attrs, check_test=check)
output.append(
t.render(
loader.Context({
"field": radio.render(name, id),
"label": mark_safe("%s" % label)
})))
return mark_safe(" ".join(output))
def SendMail(to, template, params={}, templateFromFile=True, dkimKeys=None, dkimSelector=None):
"""
sends email to @to
if @templateFromFile == True message will be taken from @template _file_ and
from @template as a string else.
template should have header and content section
(separated with mail.utils.HEADER_TAG, mail.utils.CONTENT_TAG). For example:
{% load email_tags %}
{% email_header %} # will be replaced with mail.utils.HEADER_TAG[0]
Subject: foo
To: [email protected]
From: [email protected]
{% email_endheader %} # mail.utils.HEADER_TAG[1]
{% email_content %} # mail.utils.CONTENT_TAG[0]
blahblahblah
{% email_endcontent %} # mail.utils.CONTENT_TAG[1]
@params are used tor rendering the template
@dkimKeys is a pair (private=priv_key, public=pub_key).
if None, settings.EMAIL_DKIM_KEYS will be taken.
if there aren't such keys, the mail won't be signed with dkim!
@dkimSelector is a selector for dkim. if None, settings.EMAIL_DKIM_SELECTOR will be taken
"""
if not settings.ENABLE_EMAIL:
return
fr = "*****@*****.**"
params.update({ "to_email": to,
"fr_email": fr,
"hostAddr": settings.CURRENT_HOST })
if templateFromFile:
rawmsg = templates.render_to_string(template, params)
else:
t = templates.Template(template)
rawmsg = t.render(templates.Context(params))
rawmsg = rawmsg.replace("\r\n", "\n")
rawheaders = _ExtractTags(rawmsg, HEADER_TAG, exactlyOne=True)
if rawheaders:
headers = {}
for rawh in rawheaders.split("\n"):
if rawh.strip() == "":
continue
header = rawh.split(": ")
if len(header) != 2:
raise MailErr("Something wrong with header: got {} tokens: {}".format(len(header), header))
headers[header[0].strip()] = header[1].strip()
else:
headers = {}
content = _ExtractTags(rawmsg, CONTENT_TAG, exactlyOne=True)
if not content:
raise NoMailContent("Content is empty")
msg = MIMEText(content)
for hname, hval in headers.items():
msg[hname] = hval
if dkimKeys:
rsaKeys = dkimKeys
elif settings.EMAIL_DKIM_KEYS:
rsaKeys = settings.EMAIL_DKIM_KEYS
else:
rsaKeys = None
if rsaKeys:
dkimmsg = dkim.DKIM(str(msg).encode("utf-8"))
if dkimSelector:
dkimsel = dkimSelector
else:
dkimsel = settings.EMAIL_DKIM_SELECTOR
dkimsel = dkimsel.encode("utf-8")
dkimdomain = settings.EMAIL_DKIM_DOMAIN.encode("utf-8")
dkimkey = rsaKeys.private.encode("utf-8")
sig = dkimmsg.sign(dkimsel, dkimdomain, dkimkey).decode('ascii')
sigh, sigc = tuple(sig.split(': ', 1))
msg[sigh] = sigc
sm = smtplib.SMTP("localhost")
sm.sendmail(fr, to, str(msg))
sm.quit()
def render_email(self, **kwargs):
template = loader.get_template(self.get_email_template_names())
context = loader.Context(self.get_email_context_data(**kwargs))
return template.render(context)
def as_html(self):
""" Render item tag. """
template = loader.get_template_from_string(Icon.get_template())
context = loader.Context(self.get_context_data())
return mark_safe(template.render(context))
