def send(self, subject="Confirm", message="Code", expire=72, tplparams=None):
"""
Envoie (ou réenvoie) le code de confirmation.
Le titre et le message sont pris comme des templates, les variables disponibles sont {{code}}, {{expire}},
{{dest}}, et tout ce qui est contenu dans tplparams.
Args:
subject(str): Sujet du mail
message(str): Message du mail
expire(int): Nombre d'heures pour l'expiration du mail
tplparams(dict): Eléments de contexte pour le titre et le message email
"""
if tplparams is None:
tplparams = {}
if not self.code:
self.generate()
self.expire = datetime.datetime.now()+datetime.timedelta(hours=expire)
subject = Template(subject)
message = Template(message)
tplparams.update({'code': self.code, 'expire': self.expire, 'dest': self.dest})
ctx = Context(tplparams)
send_mail(subject.render(ctx), message.render(ctx), 'noreply@localhost', (self.dest, 'jmbarbier@localhost'))
self.status = "S"
self.save()
def test_cached_as(self):
counts = {'a': 0}
def inc_a():
counts['a'] += 1
return ''
qs = Post.objects.all()
t = Template("""
{% load cacheops %}
{% cached_as qs 0 'a' %}.a{{ a }}{% endcached_as %}
{% cached_as qs timeout=60 fragment_name='a' %}.a{{ a }}{% endcached_as %}
{% cached_as qs fragment_name='a' timeout=60 %}.a{{ a }}{% endcached_as %}
""")
s = t.render(Context({'a': inc_a, 'qs': qs}))
self.assertEqual(re.sub(r'\s+', '', s), '.a.a.a')
self.assertEqual(counts['a'], 1)
t.render(Context({'a': inc_a, 'qs': qs}))
self.assertEqual(counts['a'], 1)
invalidate_model(Post)
t.render(Context({'a': inc_a, 'qs': qs}))
self.assertEqual(counts['a'], 2)
def handle(self, *args, **options):
tpl = Template("""
title:{{object.title}}
subtitle:{{object.sub_title}}
slug:{{object.slug}}
featured:{{object.featured}}
status:{{object.status}}
add_date:{{object.add_date}}
pub_date:{{object.pub_date}}
mod_date:{{object.mod_date}}
project_date:{{object.project_date}}
#{{object.title}}
##{{object.sub_title}}
{{object.body}}
todo
images = models.ManyToManyField(Image, blank=True, through=ArticleImage)
files = models.ManyToManyField(File, blank=True)
vimeo = models.URLField(max_length=100, blank=True, null=True)
tags = TaggableManager(blank=True, through=TaggedArticle)
""")
for article in Article.objects.all():
c = Context({"object": article})
print tpl.render(c)
def uploadimage(request):
try:
u = request.session['user']
user_id=u.id
if request.method=='POST':
form = ImageUploadForm(request.POST,request.FILES)
if form.is_valid():
path_file,size,status = handle_upload_image(request.FILES['imagefileupload'],user_id)
width,height = size
if status:
t = Template("{status:true,imgurl:'"+path_file+"',width:"+str(width)+",height:"+str(height)+"}")
html = t.render(Context())
return HttpResponse(html)
else:
t = Template("{status:false,error:'上传失败'}")
html = t.render(Context())
return HttpResponse(html)
else:
t = Template("{status:false,error:'上传失败'}")
html = t.render(Context())
return HttpResponse(html)
return HttpResponse()
else:
raise Http404()
except Exception, e:
raise
def test_xss_error_messages(self):
###################################################
# Tests for XSS vulnerabilities in error messages #
###################################################
# The forms layer doesn't escape input values directly because error messages
# might be presented in non-HTML contexts. Instead, the message is just marked
# for escaping by the template engine. So we'll need to construct a little
# silly template to trigger the escaping.
from django.template import Template, Context
t = Template('{{ form.errors }}')
class SomeForm(Form):
field = ChoiceField(choices=[('one', 'One')])
f = SomeForm({'field': '<script>'})
self.assertHTMLEqual(t.render(Context({'form': f})), u'<ul class="errorlist"><li>field<ul class="errorlist"><li>Select a valid choice. <script> is not one of the available choices.</li></ul></li></ul>')
class SomeForm(Form):
field = MultipleChoiceField(choices=[('one', 'One')])
f = SomeForm({'field': ['<script>']})
self.assertHTMLEqual(t.render(Context({'form': f})), u'<ul class="errorlist"><li>field<ul class="errorlist"><li>Select a valid choice. <script> is not one of the available choices.</li></ul></li></ul>')
from regressiontests.forms.models import ChoiceModel
class SomeForm(Form):
field = ModelMultipleChoiceField(ChoiceModel.objects.all())
f = SomeForm({'field': ['<script>']})
self.assertHTMLEqual(t.render(Context({'form': f})), u'<ul class="errorlist"><li>field<ul class="errorlist"><li>"<script>" is not a valid value for a primary key.</li></ul></li></ul>')
def test_object_tools(self):
autodiscover()
context = template.Context({
'model': User,
'request': RequestFactory().get('/'),
})
t = Template("{% load object_tools_inclusion_tags %}{% object_tools \
model request.user %}")
# Anon user should not have any tools.
result = t.render(context)
expected_result = '\n'
self.failUnlessEqual(result, expected_result)
# User without permissions should not have any tools.
user = User()
user.save()
context['request'].user = user
result = t.render(context)
expected_result = '\n'
self.failUnlessEqual(result, expected_result)
# Superuser should have tools.
user.is_superuser = True
user.save()
result = t.render(context)
expected_result = u'\n <li><a href="/object-tools/auth/user/\
test_tool/" title=""class="historylink">Test Tool</a></li>\n\n \
<li><a href="/object-tools/auth/user/test_media_tool/" title=""\
class="historylink"></a></li>\n\n'
self.failUnlessEqual(result, expected_result)
def render_email(user, request):
"""Render an email and return its subject and body.
This function takes as arguments a QueryDict and a user. The user will
serve as the target of the mail. The QueryDict should contain a `text` and
`subject` attribute that will be used as the body and subject of the mail
respectively.
The email can optionally be customized with user information. If the user
has provided any one of the following variables:
{{ full_name }}, {{ first_name }}, {{ last_name }}, {{ email }}
then they will be rendered appropriately.
"""
c = Context({'full_name': user.realname,
'first_name': user.first_name,
'last_name': user.last_name,
'email': user.email, })
# Render the mail body
t = Template(request['text'])
body = t.render(c)
# Render the mail subject
t = Template(request['subject'])
subject = t.render(c)
return subject, body
def test_templatetag(self):
article = Article.objects.create(title='news_1_app_1_config1',
slug='news_1_app_1_config1',
section=self.ns_app_1)
request = self.get_page_request(self.page_1, self.user)
context = RequestContext(request, {'object': article, 'current_app': self.ns_app_1.namespace})
template = Template('{% load apphooks_config_tags %}{% namespace_url "example_detail" object.slug %}')
response = template.render(context)
self.assertEqual(response, os.path.join(self.page_1.get_absolute_url(), article.slug, ''))
template = Template('{% load apphooks_config_tags %}{% namespace_url "example_detail" slug=object.slug %}')
response = template.render(context)
self.assertEqual(response, os.path.join(self.page_1.get_absolute_url(), article.slug, ''))
template = Template('{% load apphooks_config_tags %}{% namespace_url "example_list" %}')
response = template.render(context)
self.assertEqual(response, self.page_1.get_absolute_url())
request = self.get_page_request(self.page_2, self.user)
context = RequestContext(request, {'object': article, 'current_app': self.ns_app_2.namespace})
template = Template('{% load apphooks_config_tags %}{% namespace_url "example_list" %}')
response = template.render(context)
self.assertEqual(response, self.page_2.get_absolute_url())
def student_view(self, context=None):
"""
The primary view of the ContentXBlock, shown to students
when viewing courses.
"""
if self.contnet_type == "content":
result = Fragment()
url = "public/html/"+self.short_name+".html"
fragment = Fragment(self.resource_string(url))
html_template = Template(self.resource_string("templates/student_view.html"))
html_context = Context({"fragment": fragment})
html_str = html_template.render(html_context)
result.add_content(html_str)
return result
elif self.contnet_type == "topnav":
html_context = Context({"source_link": self.source_link,
"prev_link": self.prev_link,
"prev_name": self.prev_name,
"toc_link": self.toc_link,
"next_link": self.next_link,
"next_name": self.next_name,
})
html_template = Template(self.resource_string("templates/student_view_topnav.html"))
fragment = Fragment(html_template.render(html_context))
return fragment
elif self.contnet_type == "header":
return
elif self.contnet_type == "footer":
return
def test_localize_templatetag_and_filter(self):
"""
Tests the {% localize %} templatetag
"""
context = Context({"value": 3.14})
template1 = Template(
"{% load l10n %}{% localize %}{{ value }}{% endlocalize %};{% localize on %}{{ value }}{% endlocalize %}"
)
template2 = Template("{% load l10n %}{{ value }};{% localize off %}{{ value }};{% endlocalize %}{{ value }}")
template3 = Template("{% load l10n %}{{ value }};{{ value|unlocalize }}")
template4 = Template("{% load l10n %}{{ value }};{{ value|localize }}")
output1 = "3,14;3,14"
output2 = "3,14;3.14;3,14"
output3 = "3,14;3.14"
output4 = "3.14;3,14"
old_localize = settings.USE_L10N
try:
activate("de")
settings.USE_L10N = False
self.assertEqual(template1.render(context), output1)
self.assertEqual(template4.render(context), output4)
settings.USE_L10N = True
self.assertEqual(template1.render(context), output1)
self.assertEqual(template2.render(context), output2)
self.assertEqual(template3.render(context), output3)
finally:
deactivate()
settings.USE_L10N = old_localize
def test_gravatar_img(self):
# Some defaults for testing
email = '*****@*****.**'
alt_text = 'some alt text'
css_class = 'gravatar-thumb'
size = 250
# Build context
context = Context({
'email': email,
'size': size,
'alt_text': alt_text,
'css_class': css_class,
})
# Default behavior
t = Template("{% load gravatar %}{% gravatar email %}")
rendered = t.render(context)
self.assertTrue(escape(get_gravatar_url(email)) in rendered)
self.assertTrue('class="gravatar"' in rendered)
self.assertTrue('alt=""' in rendered)
t = Template("{% load gravatar %}{% gravatar email size alt_text css_class %}")
rendered = t.render(context)
self.assertTrue('width="%s"' % (size,) in rendered)
self.assertTrue('height="%s"' % (size,) in rendered)
self.assertTrue('alt="%s"' % (alt_text,) in rendered)
self.assertTrue('class="%s"' % (css_class,) in rendered)
def test_send_signal_before_rendering(self):
self._signal_has_been_called = False
def on_render(sender, **kw):
self.assertEquals(kw['css_name'], '/some/path/grid-stuff.css')
self.assertEquals(
kw['css_files'],
['/media/foo.css', '/media/css/bar.css']
)
self.assertEquals(
kw['joined_content'],
"#foo{color:red}#bar{color:blue;font:11px}"
)
self._signal_has_been_called = True
t = Template('''{% load medialint_tags %}
{% cssjoin "/some/path/grid-stuff.css" %}
<link rel="stylesheet" href="/media/foo.css" />
<link rel="stylesheet" href="/media/css/bar.css" />
{% endcssjoin %}
''')
c = RequestContext({})
css_joined.connect(on_render)
t.render(c)
assert self._signal_has_been_called
css_joined.disconnect(on_render)
def test_send_signal_before_rendering(self):
self._signal_has_been_called = False
def on_render(sender, **kw):
self.assertEquals(kw['js_name'], '/path/to.js')
self.assertEquals(
kw['js_files'],
['/media/foo.js', '/media/js/bar.js']
)
self.assertEquals(
kw['joined_content'],
"var foo = 'foo';console.debug(foo);"
)
self._signal_has_been_called = True
t = Template('''{% load medialint_tags %}
{% jsjoin "/path/to.js" %}
<script type="text/javascript" src="/media/foo.js"></script>
<script type="text/javascript" src="/media/js/bar.js"></script>
{% endjsjoin %}
''')
c = RequestContext({})
js_joined.connect(on_render)
t.render(c)
assert self._signal_has_been_called
def test_01_top_not_in_nav(self):
"""
top: not in navigation
tag: show_menu 0 100 0 100
context shared: current page is aaa
context 1: root is NOT a softroot
context 2: root IS a softroot
expected result: the two node-trees should be equal
"""
top = self.get_page('top')
top.in_navigation = False
top.save()
aaa = self.get_page('aaa')
# root is NOT a soft root
context = self.get_context(aaa.get_absolute_url())
tpl = Template("{% load menu_tags %}{% show_menu 0 100 0 100 %}")
tpl.render(context)
hard_root = context['children']
# root IS a soft root
root = self.get_page('root')
root.soft_root = True
root.save()
aaa = self.get_page('aaa')
context = self.get_context(aaa.get_absolute_url())
tpl = Template("{% load menu_tags %}{% show_menu 0 100 0 100 %}")
tpl.render(context)
soft_root = context['children']
# assert the two trees are equal in terms of 'level' and 'title'
self.assertTreeQuality(hard_root, soft_root, 'level', 'title')
def test_object_with_non_ascii_repr_in_context(self):
response = self.panel.process_request(self.request)
t = Template("{{ object }}")
c = Context({"object": NonAsciiRepr()})
t.render(c)
self.panel.generate_stats(self.request, response)
self.assertIn("nôt åscíì", self.panel.content)
def test_translates_with_string_that_look_like_fmt_spec_with_trans(self):
# tests "%s"
expected = ('On dirait un spec str fmt %s mais ne devrait pas être interprété comme plus disponible')
trans_tpl = Template(
'{% load i18n %}{% trans "Looks like a str fmt spec %s but '
'should not be interpreted as such" %}'
)
self.assertEqual(trans_tpl.render(Context({})), expected)
block_tpl = Template(
'{% load i18n %}{% blocktrans %}Looks like a str fmt spec %s but '
'should not be interpreted as such{% endblocktrans %}'
)
self.assertEqual(block_tpl.render(Context({})), expected)
# tests "% o"
expected = ('On dirait un spec str fmt % o mais ne devrait pas être interprété comme plus disponible')
trans_tpl = Template(
'{% load i18n %}{% trans "Looks like a str fmt spec % o but should not be '
'interpreted as such" %}'
)
self.assertEqual(trans_tpl.render(Context({})), expected)
block_tpl = Template(
'{% load i18n %}{% blocktrans %}Looks like a str fmt spec % o but should not be '
'interpreted as such{% endblocktrans %}'
)
self.assertEqual(block_tpl.render(Context({})), expected)
def test_10_show_breadcrumb(self):
context = self.get_context(path=self.get_page(3).get_absolute_url())
tpl = Template("{% load menu_tags %}{% show_breadcrumb %}")
tpl.render(context)
nodes = context['ancestors']
self.assertEqual(len(nodes), 3)
tpl = Template("{% load menu_tags %}{% show_breadcrumb 1 %}")
tpl.render(context)
nodes = context['ancestors']
self.assertEqual(len(nodes), 2)
context = self.get_context()
tpl = Template("{% load menu_tags %}{% show_breadcrumb %}")
tpl.render(context)
nodes = context['ancestors']
self.assertEqual(len(nodes), 1)
tpl = Template("{% load menu_tags %}{% show_breadcrumb 1 %}")
tpl.render(context)
nodes = context['ancestors']
self.assertEqual(len(nodes), 0)
page1 = Page.objects.get(pk=self.get_page(1).pk)
page1.in_navigation = False
page1.save()
page2 = self.get_page(2)
context = self.get_context(path=page2.get_absolute_url())
tpl = Template("{% load menu_tags %}{% show_breadcrumb %}")
tpl.render(context)
nodes = context['ancestors']
self.assertEqual(len(nodes), 2)
self.assertEqual(nodes[0].get_absolute_url(), self.get_pages_root())
self.assertEqual(isinstance(nodes[0], NavigationNode), True)
self.assertEqual(nodes[1].get_absolute_url(), page2.get_absolute_url())
def test_not_in_navigation(self):
"""
Test for issue 521
Build the following tree:
A
|-B
|-C
\-D (not in nav)
"""
a = create_page('A', 'nav_playground.html', 'en', published=True,
in_navigation=True, reverse_id='a')
b =create_page('B', 'nav_playground.html', 'en', parent=a,
published=True, in_navigation=True)
c = create_page('C', 'nav_playground.html', 'en', parent=b,
published=True, in_navigation=True)
create_page('D', 'nav_playground.html', 'en', parent=self.reload(b),
published=True, in_navigation=False)
context = self.get_context(a.get_absolute_url())
tpl = Template("{% load menu_tags %}{% show_menu_below_id 'a' 0 100 100 100 %}")
tpl.render(context)
nodes = context['children']
self.assertEqual(len(nodes), 1, nodes)
node = nodes[0]
self.assertEqual(node.id, b.id)
children = node.children
self.assertEqual(len(children), 1, repr(children))
child = children[0]
self.assertEqual(child.id, c.id)
def test_not_in_navigation_num_queries(self):
"""
Test for issue 521
Build the following tree:
A
|-B
|-C
\-D (not in nav)
"""
a = create_page('A', 'nav_playground.html', 'en', published=True,
in_navigation=True, reverse_id='a')
b =create_page('B', 'nav_playground.html', 'en', parent=a,
published=True, in_navigation=True)
c = create_page('C', 'nav_playground.html', 'en', parent=b,
published=True, in_navigation=True)
create_page('D', 'nav_playground.html', 'en', parent=self.reload(b),
published=True, in_navigation=False)
with LanguageOverride('en'):
context = self.get_context(a.get_absolute_url())
with self.assertNumQueries(4):
"""
The 4 queries should be:
get all pages
get all page permissions
get all titles
set the menu cache key
"""
# Actually seems to run:
tpl = Template("{% load menu_tags %}{% show_menu_below_id 'a' 0 100 100 100 %}")
tpl.render(context)
def test_if_relationship_tag(self):
t = Template('{% load relationship_tags %}{% if_relationship john paul "following" %}y{% else %}n{% endif_relationship %}')
c = Context({'john': self.john, 'paul': self.paul})
rendered = t.render(c)
self.assertEqual(rendered, 'y')
t = Template('{% load relationship_tags %}{% if_relationship paul john "following" %}y{% else %}n{% endif_relationship %}')
c = Context({'john': self.john, 'paul': self.paul})
rendered = t.render(c)
self.assertEqual(rendered, 'n')
t = Template('{% load relationship_tags %}{% if_relationship paul john "followers" %}y{% else %}n{% endif_relationship %}')
c = Context({'john': self.john, 'paul': self.paul})
rendered = t.render(c)
self.assertEqual(rendered, 'y')
t = Template('{% load relationship_tags %}{% if_relationship paul john "friends" %}y{% else %}n{% endif_relationship %}')
c = Context({'john': self.john, 'paul': self.paul})
rendered = t.render(c)
self.assertEqual(rendered, 'n')
t = Template('{% load relationship_tags %}{% if_relationship john yoko "friends" %}y{% else %}n{% endif_relationship %}')
c = Context({'john': self.john, 'yoko': self.yoko})
rendered = t.render(c)
self.assertEqual(rendered, 'y')
def test_render_width_height_format_to_context(self):
url = self.get_url(100, 200, 'png')
#@@@ default format jpg
t = Template(self.get_template('100 200 png as myvar'))
c = Context({})
t.render(c)
self.failUnlessEqual(url, c['myvar'])
def test_render_tag(self):
# "%s/inclusion_tags/%s_%s.html" % (ctype.app_label, ctype.model, type)
self.context = template.Context({'object': self.obj1})
t = Template("{% load jmbo_inclusion_tags %}\
{% render_object object 'test_block' %}")
result = t.render(self.context)
expected = u'TestModel block\n'
self.failUnlessEqual(result, expected)
# "%s/%s/inclusion_tags/object_%s.html" % (ctype.app_label, ctype.model, type),
self.context = template.Context({'object': self.obj2})
t = Template("{% load jmbo_inclusion_tags %}\
{% render_object object 'test_block' %}")
result = t.render(self.context)
expected = u'BranchModel block\n'
self.failUnless(result, expected)
# "jmbo/inclusion_tags/modelbase_%s.html" % type
self.context = template.Context({'object': self.obj3})
t = Template("{% load jmbo_inclusion_tags %}\
{% render_object object 'test_block' %}")
result = t.render(self.context)
expected = u'ModelBase block\n'
self.failUnlessEqual(result, expected)
# No template was found
t = Template("{% load jmbo_inclusion_tags %}\
{% render_object object 'foobar' %}")
result = t.render(self.context)
expected_result = u''
self.failUnlessEqual(result, expected_result)
def preview(self, *uids):
from django.template import Template, Context
from django.contrib.auth.models import User
data = self.cleaned_data
if settings.ADMIN_TICKETS_STATS_EMAIL_LOAD_LIBRARY:
libs = '{%% load %s %%}' % ' '.join(settings.ADMIN_TICKETS_STATS_EMAIL_LOAD_LIBRARY)
else:
libs = ''
tSubject = Template(libs + data['subject'])
tBody = Template(libs + data['body'])
conf = models.Conference.objects.current()
output = []
for u in User.objects.filter(id__in=uids):
ctx = Context({
'user': u,
'conf': conf,
})
output.append((
tSubject.render(ctx),
tBody.render(ctx),
u,
))
return output
def handle(self, *args, **options):
csv_file = args[0]
dr = csv.DictReader(open(csv_file, "r"))
conn = get_connection()
if len(args) > 1:
from_email = args[1]
else:
contact_page = Page.objects.get(slug="contact-us")
from_email = contact_page.form.email_from
subject_tmpl = Template("")
body_tmpl = Template("")
for row in dr:
if row["message"]:
body_tmpl = Template(row["message"])
if row["subject"]:
subject_tmpl = Template(row["subject"])
kwargs = {
"subject": subject_tmpl.render(Context(row)),
"body": body_tmpl.render(Context(row)),
"from_email": from_email,
"to": [row["to"]],
"connection": conn
}
msg = EmailMessage(**kwargs)
msg.send()
def test_warning(self, warn):
tpl = Template('{% load template_warnings %}{% warn "interesting" %}')
tpl.render(Context({}))
# django calls warning a lot, so lets make sure that
# our call is used at least once
all_args = [i[0][0] for i in warn.call_args_list]
self.assertIn('"interesting"', all_args)
def generate_user_html(conn, cursor):
user_template = Template(codecs.open('templates/user_template.html', 'r+', encoding='utf-8').read())
cursor.execute('SELECT user, COUNT(DISTINCT url) AS num_posts FROM screenshots GROUP BY user ORDER by num_posts DESC;')
users = cursor.fetchall()
avatars_loaded = 0
for user_name in users:
user_name = user_name[0]
print 'Writing user page %s' % user_name
cursor.execute('select distinct user, tweet_text, url from screenshots where user=? order by ts desc', (user_name,))
screenshots = cursor.fetchall()
context_dict = {'screenshots': screenshots, 'user_name': user_name}
context = Context(context_dict)
page_render = user_template.render(context)
f = codecs.open('user/%s.html' % user_name, 'w+', encoding='utf-8')
f.write(page_render)
if avatars_loaded < 10 and not os.path.exists('user/%s.avatar' % user_name):
uo = urllib.urlopen('http://api.twitter.com/1/users/profile_image/%s.json?size=bigger' % user_name)
f = open('user/%s.avatar' % user_name, 'w+b')
f.write(uo.read())
f.close()
avatars_loaded += 1
users_template = Template(codecs.open('templates/users_template.html', 'r+', encoding='utf-8').read())
page_render = users_template.render(Context({'users': users}))
f = codecs.open('users.html', 'w+', encoding='utf-8')
f.write(page_render)
def test_tag_via_template_with_login(self):
"""
Test when user is authentificate
"""
user = self.client.login(username='******', password='******')
t = Template('{% load admin_edit_object %}{% edit_link obj%}')
obj = MyData.objects.get(id=1)
c = Context({'user': user, 'obj': obj})
self.assertEqual(t.render(c),
'<a href="/admin/hello/mydata/1/">(admin)</a>')
# Test witout obj
c = Context({'user': user})
self.assertEqual(t.render(c), '<a href="#">(admin)</a>')
resp = self.client.get(reverse('home-page', kwargs={'pk': 1}))
self.assertNotContains(resp, '<a href="#">(admin)</a>')
user = self.client.login(username='******', password='******')
t = Template('{% load admin_edit_object %}' + '{% edit_link obj %}')
obj = StorageRequests.objects.get(id=1)
c = Context({'user': user, 'obj': obj})
self.assertEqual(
t.render(c),
'<a href="/admin/hello/storagerequests/1/">(admin)</a>')
resp = self.client.get("/admin/hello/storagerequests/1/")
self.assertEqual(resp.status_code, 200)
def get_mail_data(mailtemplate_id, custom_user_id):
mailtemplate = MailTemplate.objects.get(pk=mailtemplate_id)
recipient = User.objects.get(custom_user_id=custom_user_id)
if not recipient.email:
raise UserEmailDoesNotExist("User doesn't have any email!")
ctx_dict = {'user_id': recipient.custom_user_id, 'email': recipient.email}
for json_url in mailtemplate.jsonurl_set.all():
r = requests.post(json_url,
data={'user_id': recipient.custom_user_id},
headers={'content-type': 'application/json'})
ctx_dict.update(r.json())
t = Template(mailtemplate.plain_text())
c = Context(ctx_dict, autoescape=False)
text = t.render(c)
data = {"from": str(mailtemplate.from_sender),
"to": recipient.email,
"subject": mailtemplate.subject,
"text": text}
if mailtemplate.html():
t = Template(mailtemplate.html())
c = Context(ctx_dict, autoescape=False)
html = t.render(c)
html_dict = {'html': html}
data.update(html_dict)
return data
def check_template(self, template):
"""
Tries to compile and render our template to make sure it passes.
"""
try:
t = Template("{% load messages %}" + template)
# we build a context that has dummy values for all required fields
context = {}
context['confirmation_id'] = 1
for field in self.fields.all():
required = field.constraints.all().filter(type="req_val")
# we are at a field that isn't required? pop out, these will be dealt with
# in the next block
if not required:
continue
if field.field_type == XFormField.TYPE_INT or field.field_type == XFormField.TYPE_FLOAT:
context[field.command] = "1"
else:
context[field.command] = "test"
t.render(Context(context))
except Exception as e:
raise ValidationError(str(e))
def test_model(self):
t = Template(self.get_template("as taglist for 'testapp.BetaModel'"))
c = Context({})
t.render(c)
self.assert_tags_equal(
c.get("taglist"), ["sweet", "green", "yellow"],
False)
def render(date):
t = Template('{% load spirit_tags %}'
'{{ date|shortnaturaltime }}')
return t.render(Context({
'date': date,
}))
def test_template_tags_pgettext(self):
"""{% blocktrans %} takes message contexts into account (#14806)."""
trans_real._active = local()
trans_real._translations = {}
with translation.override('de'):
# Nonexistent context
t = Template(
'{% load i18n %}{% blocktrans context "nonexistent" %}May{% endblocktrans %}'
)
rendered = t.render(Context())
self.assertEqual(rendered, 'May')
# Existing context... using a literal
t = Template(
'{% load i18n %}{% blocktrans context "month name" %}May{% endblocktrans %}'
)
rendered = t.render(Context())
self.assertEqual(rendered, 'Mai')
t = Template(
'{% load i18n %}{% blocktrans context "verb" %}May{% endblocktrans %}'
)
rendered = t.render(Context())
self.assertEqual(rendered, 'Kann')
# Using a variable
t = Template(
'{% load i18n %}{% blocktrans context message_context %}May{% endblocktrans %}'
)
rendered = t.render(Context({'message_context': 'month name'}))
self.assertEqual(rendered, 'Mai')
t = Template(
'{% load i18n %}{% blocktrans context message_context %}May{% endblocktrans %}'
)
rendered = t.render(Context({'message_context': 'verb'}))
self.assertEqual(rendered, 'Kann')
# Using a filter
t = Template(
'{% load i18n %}{% blocktrans context message_context|lower %}May{% endblocktrans %}'
)
rendered = t.render(Context({'message_context': 'MONTH NAME'}))
self.assertEqual(rendered, 'Mai')
t = Template(
'{% load i18n %}{% blocktrans context message_context|lower %}May{% endblocktrans %}'
)
rendered = t.render(Context({'message_context': 'VERB'}))
self.assertEqual(rendered, 'Kann')
# Using 'count'
t = Template(
'{% load i18n %}{% blocktrans count number=1 context "super search" %}'
'{{ number }} super result{% plural %}{{ number }} super results{% endblocktrans %}'
)
rendered = t.render(Context())
self.assertEqual(rendered, '1 Super-Ergebnis')
t = Template(
'{% load i18n %}{% blocktrans count number=2 context "super search" %}{{ number }}'
' super result{% plural %}{{ number }} super results{% endblocktrans %}'
)
rendered = t.render(Context())
self.assertEqual(rendered, '2 Super-Ergebnisse')
t = Template(
'{% load i18n %}{% blocktrans context "other super search" count number=1 %}'
'{{ number }} super result{% plural %}{{ number }} super results{% endblocktrans %}'
)
rendered = t.render(Context())
self.assertEqual(rendered, '1 anderen Super-Ergebnis')
t = Template(
'{% load i18n %}{% blocktrans context "other super search" count number=2 %}'
'{{ number }} super result{% plural %}{{ number }} super results{% endblocktrans %}'
)
rendered = t.render(Context())
self.assertEqual(rendered, '2 andere Super-Ergebnisse')
# Using 'with'
t = Template(
'{% load i18n %}{% blocktrans with num_comments=5 context "comment count" %}'
'There are {{ num_comments }} comments{% endblocktrans %}')
rendered = t.render(Context())
self.assertEqual(rendered, 'Es gibt 5 Kommentare')
t = Template(
'{% load i18n %}{% blocktrans with num_comments=5 context "other comment count" %}'
'There are {{ num_comments }} comments{% endblocktrans %}')
rendered = t.render(Context())
self.assertEqual(rendered, 'Andere: Es gibt 5 Kommentare')
# Using trimmed
t = Template(
'{% load i18n %}{% blocktrans trimmed %}\n\nThere\n\t are 5 '
'\n\n comments\n{% endblocktrans %}')
rendered = t.render(Context())
self.assertEqual(rendered, 'There are 5 comments')
t = Template(
'{% load i18n %}{% blocktrans with num_comments=5 context "comment count" trimmed %}\n\n'
'There are \t\n \t {{ num_comments }} comments\n\n{% endblocktrans %}'
)
rendered = t.render(Context())
self.assertEqual(rendered, 'Es gibt 5 Kommentare')
t = Template(
'{% load i18n %}{% blocktrans context "other super search" count number=2 trimmed %}\n'
'{{ number }} super \n result{% plural %}{{ number }} super results{% endblocktrans %}'
)
rendered = t.render(Context())
self.assertEqual(rendered, '2 andere Super-Ergebnisse')
# Misuses
with self.assertRaises(TemplateSyntaxError):
Template(
'{% load i18n %}{% blocktrans context with month="May" %}{{ month }}{% endblocktrans %}'
)
with self.assertRaises(TemplateSyntaxError):
Template(
'{% load i18n %}{% blocktrans context %}{% endblocktrans %}'
)
with self.assertRaises(TemplateSyntaxError):
Template(
'{% load i18n %}{% blocktrans count number=2 context %}'
'{{ number }} super result{% plural %}{{ number }}'
' super results{% endblocktrans %}')
def test_course_organization(self):
course_id = 'course-v1:edX+Course+100'
template = Template("{% load core_extras %}"
"{{ course_id|course_organization }}")
self.assertEqual(template.render(Context({'course_id': course_id})),
'edX')
def show(request):
t = Template(TEMPLATE)
return HttpResponse(t.render(RequestContext(request)))
def getHTML(request):
if request.user.has_perm('auth.run_db'):
javascript = '''
iconslist = {
time: 'fa fa-clock-o',
date: 'fa fa-calendar',
up: 'fa fa-chevron-up',
down: 'fa fa-chevron-down',
previous: 'fa fa-chevron-left',
next: 'fa fa-chevron-right',
today: 'fa fa-bullseye',
clear: 'fa fa-trash',
close: 'fa fa-close'
};
// Date picker
$(".vDateField").on('focusin', function() {
$(this).parent().css('position', 'relative');
$(this).datetimepicker({format: 'YYYY-MM-DD', calendarWeeks: true, icons: iconslist, locale: document.documentElement.lang});
});
$("#weekstartul li a").click(function(){
$("#weekstart1").html($(this).text() + ' <span class="caret"></span>');
$("#weekstart").val($(this).parent().index());
});
'''
context = RequestContext(request, {'javascript': javascript})
template = Template('''
{%% load i18n %%}
<form class="form-horizontal" role="form" method="post" action="{{request.prefix}}/execute/launch/createbuckets/">{%% csrf_token %%}
<input type="hidden" name="weekstart" id="weekstart" value="1">
<table>
<tr>
<td style="vertical-align:top; padding: 15px">
<button class="btn btn-primary" type="submit" value="{%% trans "launch"|capfirst %%}">{%% trans "launch"|capfirst %%}</button>
</td>
<td style="padding: 15px; width:99%%">
%s
</td>
</tr>
</table>
</form>
<script>{{ javascript|safe }}</script>
''' % (force_text(
_('''<p>Create time buckets for reporting.</p>
<div class="form-group">
<label class="col-sm-3 control-label">Start date</label>
<div class="col-sm-9">
<input class="vDateField form-control" id="start" name="start" type="text" size="12"/>
</div>
</div>
<div class="form-group">
<label class="col-sm-3 control-label">End date</label>
<div class="col-sm-9">
<input class="vDateField form-control" id="end" name="end" type="text" size="12"/>
</div>
</div>
<div class="form-group">
<label class="col-sm-3 control-label" for="weekstart1">Week starts on</label>
<div class="col-sm-9">
<div class="dropdown dropdown-submit-input">
<button class="btn btn-default dropdown-toggle form-control" id="weekstart1" value="1" type="button" data-toggle="dropdown">Monday <span class="caret"></span></button>
<ul class="dropdown-menu col-xs-12" aria-labelledby="weekstart1" id="weekstartul">
<li><a>Sunday</a></li>
<li><a>Monday</a></li>
<li><a>Tuesday</a></li>
<li><a>Wednesday</a></li>
<li><a>Thursday</a></li>
<li><a>Friday</a></li>
<li><a>Saturday</a></li>
</ul>
</div>
</div>
</div>
<div class="form-group">
<label class="col-sm-3 control-label">Day name</label>
<div class="col-sm-9">
<input class="form-control" name="format-day" type="text" size="12" value="%Y-%m-%d"/>
</div>
</div>
<div class="form-group">
<label class="col-sm-3 control-label">Week name</label>
<div class="col-sm-9">
<input class="form-control" name="format-week" type="text" size="12" value="%y W%W"/>
</div>
</div>
<div class="form-group">
<label class="col-sm-3 control-label">Month name</label>
<div class="col-sm-9">
<input class="form-control" name="format-month" type="text" size="12" value="%b %y"/>
</div>
</div>
<div class="form-group">
<label class="col-sm-3 control-label">Quarter name</label>
<div class="col-sm-9">
<input class="form-control" name="format-quarter" type="text" size="12" value="%y Q%q"/>
</div>
</div>
<div class="form-group">
<label class="col-sm-3 control-label">Year name</label>
<div class="col-sm-9">
<input class="form-control" name="format-year" type="text" size="12" value="%Y"/>
</div>
</div>
'''))))
return template.render(context)
# A list of translation strings from the above
translated = (_("launch"), _("data tables"), _("admin tables"),
_("Erase selected tables."))
else:
return None
def get_traceback_html(self):
"Return HTML version of debug 500 HTTP error page."
t = Template(TECHNICAL_500_TEMPLATE, name='Technical 500 template')
c = Context(self.get_traceback_data(), use_l10n=False)
return t.render(c)
def generate(self, project_name, app_name, model_name, template_dir,
target_dir):
"""
Render template
"""
model_names, _model_objs = self.get_models('.models', app_name)
# Filter model and model obj
model_names = model_name
model_objs = {}
for m in model_names:
model_objs[m] = _model_objs[m]
filter_context = self.get_filter_context(model_objs)
filter_field_context = self.get_filter_field_context(
model_objs, filter_context)
admin_field_context = self.get_model_field_context(model_objs)
context_dict = {
'project_name': project_name,
'app_name': app_name,
'model_names': model_names,
'filter_context': filter_context,
'filter_field_context': filter_field_context,
'admin_field_context': admin_field_context,
'old_content': '',
}
print(('-' * 78))
cprint(
'Lucommon Update App `%(app_name)s` For Project `%(project_name)s` Starting ...'
% context_dict,
'blue',
attrs=['bold'])
print(('-' * 78))
for root, dirs, files in os.walk(template_dir):
for dirname in dirs[:]:
if dirname.startswith('.') or dirname == '__pycache__':
dirs.remove(dirname)
for filename in files:
if filename.endswith(('.pyo', '.pyc', '.py.class')):
# Ignore some files as they cause various breakages.
continue
old_path = os.path.join(root, filename)
new_path = os.path.join(target_dir, filename)
bak_path = os.path.join(target_dir, '.%s' % filename)
# Only render the Python files, as we don't want to
# accidentally render Django templates files
with open(new_path, 'rb') as old_file:
old_content = old_file.read().strip()
context_dict.update({'old_content': old_content})
with open(old_path, 'rb') as template_file:
content = template_file.read()
if filename.endswith('.py'):
content = content.decode('utf-8')
template = Template(content)
context = Context(context_dict, autoescape=False)
content = template.render(context)
content = content.encode('utf-8')
if query_yes_no('Do you really want to replace the file `%s`?' % \
new_path, default='yes'):
with open(new_path, 'wb') as new_file:
new_file.write(content)
cprint("->Creating `%s` Success!" % new_path, 'green')
try:
shutil.copymode(old_path, new_path)
self.make_writeable(new_path)
except OSError:
self.stderr.write(
"Notice: Couldn't set permission bits on %s. You're "
"probably using an uncommon filesystem setup. No "
"problem." % new_path)
self.print_project_hints(context_dict)
def test_render_comment_form(self):
template = Template('{% load threadedcomments_tags %}{% render_comment_form for sites.site 1 %}')
html = sanitize_html(template.render(Context()))
self.assertIn(' name="parent" ', html)
def test_get_comment_list(self):
template = Template('{% load threadedcomments_tags %}{% get_comment_list for sites.site 1 as foo %}{{ foo|length }}')
html = template.render(Context()).strip()
self.assertEqual(html, '7')
def test_get_comment_form(self):
template = Template('{% load threadedcomments_tags %}{% get_comment_form for sites.site 1 as foo %}{{ foo.parent }}')
html = sanitize_html(template.render(Context()))
self.assertIn(' name="parent" ', html)
self.assertNotIn('<form', html)
def test_invalid_version(self):
# FIXME: should this throw an error?
t = Template('{% load fb_versions %}{% version obj "invalid" %}')
c = Context({"obj": self.F_IMAGE})
r = t.render(c)
self.assertEqual(r, "")
def test_render_comment_list(self):
template = Template('{% load threadedcomments_tags %}{% render_comment_list for sites.site 1 %}')
html = sanitize_html(template.render(Context()))
self.assertIn('Comment 7', html)
def get_absolute_url(self):
t = Template("{% load pp_url%}{% pp_url template='group.html' object=object %}")
c = Context({"object": self})
return t.render(c)
def render(self, template, context):
# Why on Earth does Django not have a TemplateTestCase yet?
t = Template(template)
c = Context(context)
return t.render(c)
def embed_link(self, obj):
if self.link is None:
return ''
template = Template(self.link)
return template.render(Context({'obj': obj}))
def get_absolute_list_url(self):
t = Template("{% load pp_url%}{% pp_url template='issues.html' object=object start=0 end=10 dimension='n' %}")
c = Context({"object": self})
return t.render(c)
def sqli(request, link=None):
# if user and password doesn't exist, returns to login page
if 'browser' not in request.session:
return HttpResponseRedirect('/')
elif not request.session['browser']:
return HttpResponseRedirect('/')
user = request.session['browser']['user']
password = request.session['browser']['password']
# link = 'SQL Injection'
target = TargetSite.objects.get(active=True)
url = target.uri
timeout = target.timeout
# logs in
try:
login = RemoteLogin(user, password, timeout, url, link=link)
except:
response = render(
request,
'nologin.html',
)
response.status_code = 401
return response
browser = login.get_browser()
elem = browser.find_element_by_xpath("//*")
source_code = elem.get_attribute("outerHTML")
page_to_render = ParseElems(source_code, )
page_to_render.clean(url)
# Detects inputs, gets the structure and generates dynamic form
fields, method, names = page_to_render.addform('{{ dynamicform }}')
if method not in ['POST',
'GET']: # if there is no form, just return the html
t = Template(page_to_render)
return HttpResponse(t.render(Context()))
# Here the dynamic form
DynamicForm = type('DynamicForm', (GenericForm, ), fields)
t = Template(page_to_render)
#ok ... let's read the data in form
if request.method == method:
request_method = request.POST if method == 'POST' else request.GET
form = DynamicForm(request_method)
if form.is_valid(): # data is ok but ... any bad attemp?
cont = 0
# Fills all forms ...
for field in fields:
# Any attack will be prosecuted!
attack_control = LinkedSite.objects.filter(linkname=link)
if attack_control:
escapes = ''.join([chr(char) for char in range(1, 32)
]) + '"%\_' + "'"
original_value = form.cleaned_data['field_' +
str(cont + 1)]
if (any(elem in original_value for elem in escapes)):
response = render(
request,
'injection.html',
)
response.status_code = 401
return response
elem = browser.find_element_by_name(names[cont])
elem.send_keys(form.cleaned_data['field_' + str(cont + 1)])
cont += 1
# ... and we send the data
elem.send_keys(Keys.RETURN)
elem = browser.find_element_by_xpath("//*")
source_code = elem.get_attribute("outerHTML")
page_to_render = ParseElems(source_code, )
page_to_render.clean(url)
# Insert again the form for next round
fields, method, names = page_to_render.addform('{{ dynamicform }}')
DynamicForm = type('DynamicForm', (GenericForm, ), fields)
t = Template(page_to_render)
return HttpResponse(t.render(Context({'dynamicform': form})))
else:
form = DynamicForm()
try: # there are hidden forms
return HttpResponse(t.render(Context({'dynamicform': form})))
except:
return HttpResponse(t.render(Context()))
def test_view(request):
template = Template(template_string=self.test_view_template)
context = Context(
dict_={'object': test_object, 'resolved_object': test_object}
)
return HttpResponse(template.render(context=context))
def test_context(self):
t1 = Template(
"""{% load reversetag revtest_dummy %}{% reverse partial "URL3" as P3 %}{% reverse partial P3 x=1 as P3_1 %}{% reverse partial P3_1 y=2 as P3_2 %}{% revtest_dummy P3_2 %}"""
)
self.assertEqual(t1.render(Context()), u"/T3/1/2/9/")
def embed_url(self, obj):
template = Template(self.source)
return template.render(Context({'obj': obj}))
def metadata_file(tempfile, record):
t = Template("{% load data %}{% metadata record %}")
c = Context({'record': record, 'request': request})
tempfile.write(smart_str(t.render(c)))
tempfile.flush()
return tempfile.name
def home(request):
# Open the session
chrome_options = Options()
chrome_options.add_argument("--headless")
# browser = webdriver.Chrome(chrome_options=chrome_options)
browser = webdriver.PhantomJS()
try:
target = TargetSite.objects.get(active=True)
except:
response = render(
request,
'404.html',
)
response.status_code = 404
return response
url = target.uri
timeout = target.timeout
browser.set_page_load_timeout(timeout)
try:
browser.get(url)
elem = browser.find_element_by_xpath("//*")
source_code = elem.get_attribute("outerHTML")
page_to_render = ParseElems(source_code, )
page_to_render.clean(url)
# user and password form
fields, method, names = page_to_render.addform('{{ dynamicform }}')
DynamicForm = type('DynamicForm', (GenericForm, ), fields)
except:
response = render(
request,
'404.html',
)
response.status_code = 404
return response
t = Template(page_to_render)
if request.method == method:
form = DynamicForm(request.POST)
if form.is_valid():
# gets user and password and sends with Selenium
user = form.cleaned_data['field_1']
password = form.cleaned_data['field_2']
try:
login = RemoteLogin(user, password, timeout, url,
link='') # log in now
except:
response = render(
request,
'nologin.html',
)
response.status_code = 401
return response
browser = login.get_browser()
elem = browser.find_element_by_xpath("//*")
source_code = elem.get_attribute("outerHTML")
page_to_render = ParseElems(source_code, )
page_to_render.clean(url)
t = Template(page_to_render)
# Stores user and password for next sessions
browser_session = {'user': user, 'password': password}
request.session['browser'] = browser_session
return HttpResponse(t.render(Context()))
else:
form = DynamicForm()
return HttpResponse(t.render(Context({'dynamicform': form})))
def _render(conf_obj, tmpl_str):
t = Template(tmpl_str)
c = Context(conf_obj)
_content = t.render(c)
return _content
def test_loop(self):
t1 = Template(
"""{% load reversetag %}{% reverse partial "URL3" as P3 %}{% reverse partial P3 x=1 as P3_1 %}{% reverse partial P3_1 y=2 as P3_2 %}{% for VAR_X in values %}{% reverse P3_2 z=VAR_X %} {% endfor %}"""
)
self.assertEqual(t1.render(Context({'values': [3, 4, 5]})),
u"/T3/1/2/3/ /T3/1/2/4/ /T3/1/2/5/ ")
def test_benefit_discount(self):
benefit = BenefitFactory(type=Benefit.PERCENTAGE, value=35.00)
template = Template("{% load offer_tags %}"
"{{ benefit|benefit_discount }}")
self.assertEqual(template.render(Context({'benefit': benefit})), '35%')
def test_get_name_obj_no_name(self):
template = Template(
'{{ user.get_full_name }}'
)
out = template.render(self.context)
self.assertEqual(out, '')
def test_template_context_processor(self):
context = RequestContext(HttpRequest()) # NB: empty request
template = Template(
'{{{{ config.{logo} }}}}'.format(logo=self.cfg_file.LOGO))
result = template.render(context)
self.assertEqual(result, self.cfg_file.url)
def render(self, request, string, context=None, site=None):
template = Template(string)
context = RequestContext(request, context)
return template.render(context)
def test_render_admin_renders_correctly_with_menu_group_separator_enabled_and_all_additional_menus(
self):
"""Test render admin renders correctly with menu group separator
enabled and all additional menus"""
user = self.create_user()
user.is_staff = True
user.is_superuser = False
user.pk = 4
request = RequestFactory().get('/rand')
setattr(request, 'user', user)
model = {
'perms': {
'add_foo': True,
'update_foo': False,
},
'object_name': 'foo',
'change_url': '/foo',
}
context = Context({
'request':
request,
'model':
model,
'user':
user,
'ADMINLTE2_MENU_FIRST': [
{
'text':
'First',
'nodes': [
{
'route': '#',
'text': 'First',
'icon': 'fa fa-circle',
},
]
},
],
'ADMINLTE2_MENU_LAST': [
{
'text':
'Last',
'nodes': [
{
'route': '#',
'text': 'Last',
'icon': 'fa fa-circle',
},
]
},
]
})
template_to_render = Template("{% load admin.admin_menu %}"
"{% render_admin_menu %}")
rendered_template = template_to_render.render(context)
self.assertIn('<li class="separator">', rendered_template)
def assert_renders(self, tmpl, context, value):
tmpl = Template(tmpl)
self.assertEqual(tmpl.render(context), value)
