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)