Esempio n. 1
0
    def form_valid(self, form):
        if form.instance.target_date <= timezone.now():
            return render(self.request, 'coplay/message.html',
                              {'message': 'תאריך היעד חייב להיות בעתיד' + str(
                                  form.instance.target_date),
                               'rtl': 'dir="rtl"'})
        form.instance.parent = self.discussion
        form.instance.responsible = self.request.user
        resp = super(CreateTaskView, self).form_valid(form)
        form.instance.parent.unlock()
        

        t = Template("""
        {{task.responsible.get_full_name|default:task.responsible.username}} הבטיח/ה ש :\n
        "{{task.goal_description}} "\n  עד {{task.target_date | date:"d/n/Y H:i"}}
        """)
        
        trunkated_subject_and_detailes = t.render(Context({"task": form.instance}))
      
        discussion_task_email_updates(form.instance,
                                         trunkated_subject_and_detailes,
                                         self.request.user,
                                         trunkated_subject_and_detailes)
        
        self.discussion.start_follow(self.request.user)
        
        
        return resp
Esempio n. 2
0
def test_custom_bound_field():
    from django.forms.boundfield import BoundField

    extra = 'xyxyxyxyxyx'

    class CustomBoundField(BoundField):
        @property
        def auto_id(self):
            return extra

    class MyCharField(forms.CharField):
        def get_bound_field(self, form, field_name):
            return CustomBoundField(form, self, field_name)

    class MyForm(forms.Form):
        f = MyCharField()

        def __init__(self, *args, **kwargs):
            super(MyForm, self).__init__(*args, **kwargs)
            self.helper = FormHelper()
            self.helper.layout = Layout('f')

    template = Template('{% load crispy_forms_tags %}\n{% crispy form "bootstrap3" %}')
    rendered = template.render(Context({'form': MyForm(data={'f': 'something'})}))

    assert extra in rendered
Esempio n. 3
0
    def test_cached_show_placeholder_preview(self):
        from django.core.cache import cache

        cache.clear()
        page = create_page('Test', 'col_two.html', 'en', published=True)
        placeholder = page.placeholders.all()[0]
        add_plugin(placeholder, TextPlugin, 'en', body='<b>Test</b>')
        request = RequestFactory().get('/')
        user = User(username="******", password="******", is_superuser=True, is_staff=True, is_active=True)
        user.save()
        request.current_page = page.publisher_public
        request.user = user
        template = Template(
            "{% load cms_tags %}{% show_placeholder slot page 'en' 1 %}")
        context = RequestContext(request, {'page': page, 'slot': placeholder.slot})
        with self.assertNumQueries(5):
            output = template.render(context)
        self.assertIn('<b>Test</b>', output)
        add_plugin(placeholder, TextPlugin, 'en', body='<b>Test2</b>')
        request = RequestFactory().get('/?preview')
        request.current_page = page
        request.user = user
        context = RequestContext(request, {'page': page, 'slot': placeholder.slot})
        with self.assertNumQueries(5):
            output = template.render(context)
        self.assertIn('<b>Test2</b>', output)
Esempio n. 4
0
def render_and_email(to_list, subject, text_template = None, html_template = None, context_dic = None):
    '''
    This method gets a list of recipients, a subject text, text_template (for showing in web readers and mobile apps),
    an HTML_template for displaying in browsers and a context dictionary, renders templates with context
    and sends an email.
    Note that if text_template is a filename, method loads it, otherwise uses it as string (And same for html_template).
    '''

    from_email = '*****@*****.**'
    context = Context(context_dic)

    if text_template:
        try:
            plaintext = get_template(text_template)
        except:
            plaintext = Template(text_template)
        text_content = plaintext.render(context)
    else:
        text_content = '(EMPTY)'

    msg = EmailMultiAlternatives(subject, text_content, from_email, to_list)

    if html_template:
        try:
            htmly = get_template(html_template)
        except:
            htmly = Template(html_template)
        html_content = htmly.render(context)
        msg.attach_alternative(html_content, "text/html")

    msg.send()
Esempio n. 5
0
def conflict(request, target=None, template_name='409.html'):
    """
    409 error handler.

    Templates: :template:`409.html`
    Context:
        target
            The model to save
        saved
            The object stored in the db that produce the conflict or None if not found (ie. deleted)
        request_path
            The path of the requested URL (e.g., '/app/pages/bad_page/')

    """
    try:
        template = loader.get_template(template_name)
    except TemplateDoesNotExist:
        template = Template(
            '<h1>Conflict</h1>'
            '<p>The request was unsuccessful due to a conflict. '
            'The object changed during the transaction.</p>')
    try:
        saved = target.__class__.objects.get(pk=target.pk)
    except target.__class__.DoesNotExists:
        saved = None
    ctx = RequestContext(request, {'target': target,
                                   'saved': saved,
                                   'request_path': request.path})
    return ConflictResponse(template.render(ctx))
Esempio n. 6
0
    def test_render_model_add_block(self):
        from django.core.cache import cache
        from cms.test_utils.project.sampleapp.models import Category

        cache.clear()
        page = create_page('Test', 'col_two.html', 'en', published=True)
        template = Template(
            "{% load cms_tags %}{% render_model_add_block category %}wrapped{% endrender_model_add_block %}")
        user = self._create_user("admin", True, True)
        request = RequestFactory().get('/')
        request.user = user
        request.current_page = page
        request.session = {}
        request.toolbar = CMSToolbar(request)
        request.toolbar.edit_mode = True
        request.toolbar.is_staff = True
        context = RequestContext(request, {'category': Category()})
        with self.assertNumQueries(0):
            output = template.render(context)
        expected = 'cms_plugin cms_plugin-sampleapp-category-add-0 '
        'cms_render_model_add'
        self.assertIn(expected, output)

        # Now test that it does NOT render when not in edit mode
        request = RequestFactory().get('/')
        request.user = user
        request.current_page = page
        request.session = {}
        request.toolbar = CMSToolbar(request)
        context = RequestContext(request, {'category': Category()})
        with self.assertNumQueries(0):
            output = template.render(context)
        expected = 'wrapped'
        self.assertEqual(expected, output)
Esempio n. 7
0
 def test_template_creation(self):
     self.assertObjectDoesNotExist(Stack.objects.all(), code='foobar')
     self.assertObjectDoesNotExist(Placeholder.objects.all(), slot='foobar')
     t = Template('{% load stack_tags %}{% stack "foobar" %}')
     t.render(self.get_context('/'))
     self.assertObjectExist(Stack.objects.all(), code='foobar', creation_method=Stack.CREATION_BY_TEMPLATE)
     self.assertObjectExist(Placeholder.objects.all(), slot='foobar')
Esempio n. 8
0
 def test_amp_in_link_with_class(self):
     page = Page(name='Explore')
     html = ('<p><a class="external something" '
                'href="http://example.org/?t=1&amp;i=2">hi</a></p>')
     template = Template(html_to_template_text(html))
     rendered = template.render(Context({'page': page}))
     self.failUnless('http://example.org/?t=1&amp;i=2' in rendered)
Esempio n. 9
0
        def get_rendered(value):
            request = self.request_factory.get('/')
            t = Template(self.loadstatement + '{{ value|rendered|safe }}')
            c = Context({'value': value, 'request': request})
            rendered = t.render(c)

            return rendered
Esempio n. 10
0
    def test_cached_show_placeholder_sekizai(self):
        from django.core.cache import cache

        cache.clear()
        from cms.test_utils import project

        User = get_user_model()

        template_dir = os.path.join(os.path.dirname(project.__file__), 'templates', 'alt_plugin_templates',
                                    'show_placeholder')
        page = create_page('Test', 'col_two.html', 'en')
        placeholder = page.placeholders.all()[0]
        add_plugin(placeholder, TextPlugin, 'en', body='HIDDEN')
        request = RequestFactory().get('/')
        request.user = User()
        request.current_page = page
        with SettingsOverride(TEMPLATE_DIRS=[template_dir]):
            template = Template(
                "{% load cms_tags sekizai_tags %}{% show_placeholder slot page 'en' 1 %}{% render_block 'js' %}")
            context = RequestContext(request, {'page': page, 'slot': placeholder.slot})
            output = template.render(context)
            self.assertIn('JAVASCRIPT', output)
            context = RequestContext(request, {'page': page, 'slot': placeholder.slot})
            output = template.render(context)
            self.assertIn('JAVASCRIPT', output)
Esempio n. 11
0
File: views.py Progetto: msylw/quiz
def get_random_question(exp, uuid):
    experiment = Experiment.objects.get(id=exp)

    questions = Question.objects.filter(experiment=experiment)
    question_template = Template(experiment.template.template)

    all_questions = len(questions)

    try:
        user = User.objects.get(uuid=uuid)
        questions = questions.exclude(answer__user=user)
    except:
        pass

    questions = questions.order_by('?')

    if len(questions) > 0:
        question = questions[0]

        question_data = question.question.split("\n")
        question_id = question.id

        question_text = question_template.render(
                            Context({"question": question_data}))
    else:
        question_id = -1
        question_text = "Finished!"

    return {"id": question_id,
            "text": question_text,
            "left": len(questions),
            "all": all_questions,
            "percent": (all_questions - len(questions)) * 100 / all_questions,
            "time": time()}
    def test_raises_if_the_required_arguments_are_not_passed(self):
        # Setup
        request = self.request_factory.get('/')
        request.user = self.u1
        ForumPermissionHandlerMiddleware().process_request(request)
        context = Context({'request': request})

        templates = [
            '{% get_permission \'can_download_files\' request.user as user_can_download_files %}'
            '{% if user_can_download_files %}CAN_DOWNLOAD{% else %}CANNOT_DOWNLOAD{% endif %}',

            '{% get_permission \'can_edit_post\' request.user as user_can_edit_post %}'
            '{% if user_can_edit_post %}CAN_EDIT{% else %}CANNOT_EDIT{% endif %}',

            '{% get_permission \'can_edit_post\' request.user as user_can_edit_post %}'
            '{% if user_can_edit_post %}CAN_EDIT{% else %}CANNOT_EDIT{% endif %}',

            '{% get_permission \'can_add_post\' request.user as user_can_add_post %}'
            '{% if user_can_add_post %}CAN_ADD_POST{% else %}CANNOT_ADD_POST{% endif %}',

            '{% get_permission \'can_vote_in_poll\' request.user as user_can_vote_in_poll %}'
            '{% if user_can_vote_in_poll %}CAN_VOTE{% else %}CANNOT_VOTE{% endif %}',
        ]

        # Run & check
        for raw_template in templates:
            t = Template(self.loadstatement + raw_template)
            with pytest.raises(TypeError):
                t.render(context)
Esempio n. 13
0
def update_task_status_description( task , description, user, result_picture = None):
        
    if user is None:
        return None, 'no user provided'
    
    if description is None:
        return None, 'no description'

    if user != task.responsible:
        return None, 'only the responsible can update the description'
    
    poll_for_task_complition( task)
    if( task.final_state):
        return None, 'target date passed'
        
    task.status_description = description
    task.result_picture = result_picture
    task.save()
    
    task.parent.save()#verify that the entire disscusion is considered updated
    
    t = Template("""
    {{task.responsible.get_full_name|default:task.responsible.username}} הודיע/ה ש :\n
    "{{task.get_status_description}} "\n
    """)
    
    trunkated_subject_and_detailes = t.render(Context({"task": task}))
    
    discussion_task_email_updates(task,
                                  trunkated_subject_and_detailes,
                                  user,
                                  trunkated_subject_and_detailes)
        
    return task, None
Esempio n. 14
0
def send_notification(email, context, settings_value, subject):
    notification_template = Template(get_settings_value(settings_value))
    notification_context = context
    message = notification_template.render(notification_context)
    subject = subject
    to = [email]
    send_mail(subject, message, settings.DEFAULT_FROM_EMAIL, to, True)
Esempio n. 15
0
 def test_compiled_file_already_exists_file_is_not_written_again(self):
     template = Template("""
     {% load coldbrew %}
     {% coffeescript "scripts/test-already-exists.coffee" %}
     """)
     # Render it once.
     compiled_filename = template.render(RequestContext({})).strip()
     first_access = os.path.getatime("%s/%s" % (settings.STATIC_ROOT, compiled_filename))
     # ...and delete it.
     os.remove("%s/%s" % (settings.STATIC_ROOT, compiled_filename))
     
     # Now render it agian.
     compiled_filename_again = template.render(RequestContext({})).strip()
     second_access = os.path.getatime("%s/%s" % (settings.STATIC_ROOT, compiled_filename_again))
     
     # The file will have been accessed again.
     self.assertGreater(second_access, first_access)
     
     # Render it a third time - this time the file will already exist.
     compiled_filename_yet_again = template.render(RequestContext({})).strip()
     third_access = os.path.getatime("%s/%s" % (settings.STATIC_ROOT, compiled_filename_yet_again))
     
     # Since the file already existed, we won't have written again
     self.assertEqual(third_access, second_access)
     
     # ...and finally delete the file now that the test is over.
     os.remove("%s/%s" % (settings.STATIC_ROOT, compiled_filename_yet_again))
Esempio n. 16
0
def conflict(request, target=None, template_name='409.html'):
    """409 error handler.

    :param request: Request

    :param template_name: `409.html`

    :param target: The model to save

    """
    try:
        template = loader.get_template(template_name)
    except TemplateDoesNotExist:
        template = Template(
            '<h1>Conflict</h1>'
            '<p>The request was unsuccessful due to a conflict. '
            'The object changed during the transaction.</p>')
    try:
        saved = target.__class__._default_manager.get(pk=target.pk)
    except target.__class__.DoesNotExist:
        saved = None
    ctx = {'target': target,
           'saved': saved,
           'request_path': request.path}

    return ConflictResponse(template.render(ctx))
Esempio n. 17
0
def tag_simple_page(context, *args, **kwargs):
    #collect params
    template_name = kwargs.get('template_name', 'common/tag_simple_page.html')
    position_nav_mask = kwargs.get('position_nav_mask', 15)
    position_content_mask = kwargs.get('position_content_mask', 15)
    extra_pos = kwargs.get('extra_pos', 0)
    #old versionget('extra_pos', 0)

    la = len(args)
    if la > 0:
        position_content_mask = args[0]
    if la > 1:
        position_nav_mask = args[1]
    if la > 2 and len(args[2]) > 0:
        template_name = args[2]
    if la > 3:
        extra_pos = args[3]

    request = context['request']
    sps = []

    if hasattr(request, 'simple_page') and request.simple_page:
        for sp in request.simple_page:
            if sp.position_nav & position_nav_mask > 0 and sp.position_content & position_content_mask > 0 and sp.extra_pos == extra_pos:
                if sp.is_content_template:
                    t = Template(sp.content)
                    c = Context(context)
                    sp.content = t.render(c)

                sps.append(sp)

    return render_to_string(template_name, {'sps': sps}, context_instance=context)
Esempio n. 18
0
 def test_direct_embed_tag(self):
     template = Template("""
         {% load embed_video_tags %}
         {% video "http://www.youtube.com/watch?v=jsrRJyHBvzw" "large" %}
     """)
     rendered = u'<iframe width="960" height="720" src="http://www.youtube.com/embed/jsrRJyHBvzw?wmode=opaque" frameborder="0" allowfullscreen></iframe>'
     self.assertEqual(template.render(self._grc()).strip(), rendered)
Esempio n. 19
0
    def test_can_render_a_list_of_forums_according_to_their_minimum_tree_level(self):
        # Setup
        forums = Forum.objects.all()

        request = self.request_factory.get('/')
        middleware = SessionMiddleware()
        middleware.process_request(request)
        request.session.save()

        request.user = self.user
        ForumPermissionMiddleware().process_request(request)
        t = Template(self.loadstatement + '{% forum_list forums %}')
        c = Context({'forums': forums, 'request': request})
        expected_out = render_to_string(
            'machina/forum/forum_list.html',
            {
                'forums': forums,
                'user': self.user,
                'root_level': 0,
                'root_level_middle': 1,
                'root_level_sub': 2,
            }
        )
        # Run
        rendered = t.render(c)
        # Check
        assert rendered != ''
        assert rendered == expected_out
Esempio n. 20
0
    def render_text(self):
        """Return the text rendering if the filetype is md or txt"""
        if self.get_email_type() == 'html':
            return None

        template = Template(self.get_template())
        return template.render(Context(self.payload))
Esempio n. 21
0
def user_follow_start_email_updates(follower_user, following_user, inverse_following):



    t = Template("""
        {{follower_user.get_full_name|default:follower_user.username}} התחיל/ה לעקוב אחרי פתיחת הפעילויות שלך
        """)
        
    subject = t.render(Context({"follower_user": follower_user}))

    
    html_message = render_to_string("coplay/user_follow_email_update.html",
                                    {'ROOT_URL': kuterless.settings.SITE_URL,
                                     'follower_user': follower_user,
                                     'html_title': string_to_email_subject(subject),
                                     'details': subject,
                                     'inverse_following': inverse_following})
    

#    with open( "output.html" , "w") as debug_file:
#        debug_file.write(html_message)
    
    if following_user.email != None:
        send_html_message(subject, html_message,
                              '*****@*****.**',
                              [following_user.email])
Esempio n. 22
0
def update_task_description(request, pk):
    if request.method == 'POST': # If the form has been submitted...
        form = UpdateTaskForm(request.POST) # A form bound to the POST data
        if form.is_valid(): # All validation rules pass
            # Process the data in form.cleaned_data# Process the data in form.cleaned_data
            try:
                task = Task.objects.get(id=int(pk))
            except Task.DoesNotExist:
                return HttpResponse('Task not found')
            user = request.user
            if user == task.responsible:
                task.update_status_description(
                    form.cleaned_data['status_description'])
                
                t = Template("""
                {{task.responsible.get_full_name|default:task.responsible.username}} הודיע/ה ש :\n
                "{{task.get_status_description}} "\n
                """)
                
                trunkated_subject_and_detailes = t.render(Context({"task": task}))
                
                discussion_task_email_updates(task,
                                              trunkated_subject_and_detailes,
                                              request.user,
                                              trunkated_subject_and_detailes)
                
                

            return HttpResponseRedirect(
                task.get_absolute_url()) # Redirect after POST

    return HttpResponseRedirect('coplay_root') # Redirect after POST
Esempio n. 23
0
def user_follow_start_email_updates(follower_user, following_user, inverse_following):

    t = Template("""
        {{follower_user.get_full_name|default:follower_user.username}} התחיל/ה לעקוב אחרי פתיחת הפעילויות שלך
        """)
        
    subject = t.render(Context({"follower_user": follower_user}))

    
    html_message = render_to_string("coplay/user_follow_email_update.html",
                                    {'ROOT_URL': kuterless.settings.SITE_URL,
                                     'follower_user': follower_user,
                                     'html_title': string_to_email_subject(subject),
                                     'details': subject,
                                     'inverse_following': inverse_following})
    

#    with open( "output.html" , "w") as debug_file:
#        debug_file.write(html_message)
    
    if following_user.email != None and following_user.userprofile.recieve_updates:
        send_html_message(subject, html_message,
                              '*****@*****.**',
                              [following_user.email])

    post_update_to_user(following_user.id, 
                 header = string_to_email_subject(subject),
                 content = subject, 
                 sender_user_id = follower_user.id,  
                 details_url = reverse('coplay:user_coplay_report', kwargs={'username': follower_user}))
Esempio n. 24
0
    def test_lookup_in_staticfiles_dirs(self):

        template = Template("""
        {% load less %}
        {% less "another_test.less" %}
        """)
        compiled_filename_re = re.compile(r"LESS_CACHE/another_test-[a-f0-9]{12}.css")
        compiled_filename = template.render(self._get_request_context()).strip()
        self.assertTrue(bool(compiled_filename_re.match(compiled_filename)))

        compiled_path = os.path.join(self.django_settings.STATIC_ROOT, compiled_filename)
        compiled_content = open(compiled_path).read().strip()
        compiled = """#header-from-staticfiles-dir h1 {
  color: red;
}"""
        self.assertEquals(compiled_content, compiled)

        template = Template("""
        {% load less %}
        {% less "prefix/another_test.less" %}
        """)
        compiled_filename_re = re.compile(r"LESS_CACHE/prefix/another_test-[a-f0-9]{12}.css")
        compiled_filename = template.render(self._get_request_context()).strip()
        self.assertTrue(bool(compiled_filename_re.match(compiled_filename)))

        compiled_path = os.path.join(self.django_settings.STATIC_ROOT, compiled_filename)
        compiled_content = open(compiled_path).read().strip()
        compiled = """#header-from-staticfiles-dir-with-prefix h1 {
  color: red;
}"""
        self.assertEquals(compiled_content, compiled)
Esempio n. 25
0
 def test_embed_whitelist_reject(self):
     html = ('<span class="plugin embed">&lt;iframe src="http://evil.com"'
             '&gt;&lt;/iframe&gt;</span>')
     template = Template(html_to_template_text(html))
     rendered = template.render(Context())
     self.failUnless(('The embedded URL is not on the list of approved '
                      'providers') in rendered)
Esempio n. 26
0
def user_glimpsed_another_user_s_discussion( user, discussion , views_counter = 0):
            
    t = Template("""
    {{user.get_full_name|default:user.username}} צפה/תה בפעילות שלך "{{discussion.title}}" בפעם ה {{views_counter}}
    """)
    
#     t = Template("""
#     צפה/תה ב "{{discussion.title}}" בפעם ה {{views_counter}}
#     """)    
    trunkated_subject_and_detailes = t.render(Context({"discussion": discussion,
                                                       'user': user,
                                                       'views_counter': views_counter}))
                                                        
    mailing_list = []
    mailing_list.append(discussion.owner)

    discussion_email_updates(   discussion = discussion, 
                                 subject = trunkated_subject_and_detailes, 
                                 logged_in_user = user, 
                                 details = trunkated_subject_and_detailes, 
                                 url_id = '', 
                                 mailing_list = mailing_list)

    user.account.deposit_and_return_transaction_if_ok( title = u"צפיה בפעילות של מישהו אחר", 
                                                       positive_item_price = 2, 
                                                       url = discussion.get_absolute_url()) 
Esempio n. 27
0
    def test_cached_show_placeholder_sekizai(self):
        from django.core.cache import cache

        cache.clear()
        from cms.test_utils import project

        template_dir = os.path.join(os.path.dirname(project.__file__), 'templates', 'alt_plugin_templates',
                                    'show_placeholder')
        page = create_page('Test', 'col_two.html', 'en')
        placeholder = page.placeholders.all()[0]
        add_plugin(placeholder, TextPlugin, 'en', body='HIDDEN')
        request = RequestFactory().get('/')
        request.user = self.get_staff_user_with_no_permissions()
        request.current_page = page
        if DJANGO_1_7:
            override = {'TEMPLATE_DIRS': [template_dir], 'CMS_TEMPLATES': []}
        else:
            override = {'TEMPLATES': deepcopy(settings.TEMPLATES)}
            override['TEMPLATES'][0]['DIRS'] = [template_dir]
        with self.settings(**override):
            template = Template(
                "{% load cms_tags sekizai_tags %}{% show_placeholder slot page 'en' 1 %}{% render_block 'js' %}")
            context = RequestContext(request, {'page': page, 'slot': placeholder.slot})
            output = template.render(context)
            self.assertIn('JAVASCRIPT', output)
            context = RequestContext(request, {'page': page, 'slot': placeholder.slot})
            output = template.render(context)
            self.assertIn('JAVASCRIPT', output)
Esempio n. 28
0
    def render_html(self):
        """Return rendered HTML if the email is html or md"""
        if self.get_email_type() not in ['html', 'md']:
            return None

        # render content and fix urls/emails
        template = self.get_template()
        template = Template(template)
        template = template.render(Context(self.payload))
        if not self.urls_resolved:
            template = self.fix_urls(template)
        if self.get_email_type() == 'md':
            template = markdown(template)
        self.payload['site'] = Site.objects.get_current()

        if not self.use_base_template:
            return template

        base_template = (
            "{{% extends '{base_template}' %}}{{% block {block_name} %}}\n"
            "{template}\n"
            "{{% endblock %}}"
        ).format(
            base_template=settings.EMAILMELD_BASE_TEMPLATE,
            block_name="content",
            template=template,
        )

        base_template = Template(base_template)
        base_template = base_template.render(Context(self.payload))

        return base_template
Esempio n. 29
0
    def render(self, context):
        filepath = self.filepath
        if not self.legacy_filepath:
            filepath = filepath.resolve(context)

        if not include_is_allowed(filepath):
            if settings.DEBUG:
                return "[Didn't have permission to include file]"
            else:
                return '' # Fail silently for invalid includes.
        try:
            fp = open(filepath, 'r')
            output = fp.read()
            fp.close()
        except IOError:
            output = ''
        if self.parsed:
            try:
                t = Template(output, name=filepath)
                return t.render(context)
            except TemplateSyntaxError, e:
                if settings.DEBUG:
                    return "[Included template had syntax error: %s]" % e
                else:
                    return '' # Fail silently for invalid included templates.
Esempio n. 30
0
 def render_to_response(self, context, **response_kwargs):
     if self.template_string:
         context = RequestContext(self.request, context)
         template = Template(self.template_string)
         return HttpResponse(template.render(context))
     else:
         return super(ClassDetail, self).render_to_response(context, **response_kwargs)
Esempio n. 31
0
 def test_embed_whitelist_accept(self):
     html = ('<span class="plugin embed">&lt;iframe '
             'src="http://www.youtube.com/embed/JVRsWAjvQSg"'
             '&gt;&lt;/iframe&gt;</span>')
     template = Template(html_to_template_text(html))
     rendered = template.render(Context())
     self.failUnless(
         '<iframe src="http://www.youtube.com/embed/JVRsWAjvQSg"></iframe>'
         in rendered)
Esempio n. 32
0
 def get_message(self, context):
     '''
     Build response message with passed context
     :param context: required an obj instance to display information
                     {user} and {reply_to} to generate correct response
     :return:
     '''
     t = Template(self.message)
     return t.render(Context(context))
Esempio n. 33
0
 def test_tag_backend_variable_soundcloud(self):
     template = Template("""
         {% load embed_video_tags %}
         {% video 'https://soundcloud.com/glassnote/mumford-sons-i-will-wait' as soundcloud %}
             {{ soundcloud.backend }}
         {% endvideo %}
     """)
     rendered = 'SoundCloudBackend'
     self.assertEqual(template.render(self._grc()).strip(), rendered)
Esempio n. 34
0
 def test_tag_backend_variable_youtube(self):
     template = Template("""
         {% load embed_video_tags %}
         {% video 'http://www.youtube.com/watch?v=jsrRJyHBvz' as youtube %}
             {{ youtube.backend }}
         {% endvideo %}
     """)
     rendered = 'YoutubeBackend'
     self.assertEqual(template.render(self._grc()).strip(), rendered)
Esempio n. 35
0
 def test_tag_backend_variable_vimeo(self):
     template = Template("""
         {% load embed_video_tags %}
         {% video 'https://vimeo.com/72304002' as vimeo %}
             {{ vimeo.backend }}
         {% endvideo %}
     """)
     rendered = 'VimeoBackend'
     self.assertEqual(template.render(self._grc()).strip(), rendered)
Esempio n. 36
0
 def test_template_creation(self):
     self.assertObjectDoesNotExist(Stack.objects.all(), code='foobar')
     self.assertObjectDoesNotExist(Placeholder.objects.all(), slot='foobar')
     t = Template('{% load stack_tags %}{% stack "foobar" %}')
     t.render(self.get_context('/'))
     self.assertObjectExist(Stack.objects.all(),
                            code='foobar',
                            creation_method=Stack.CREATION_BY_TEMPLATE)
     self.assertObjectExist(Placeholder.objects.all(), slot='foobar')
Esempio n. 37
0
 def send(self, email, context={}):
     template = Template(self.body)
     message = EmailMessage(self.subject,
                         template.render(Context(context)),
                         from_email=config.email,
                         to=[email],
                         bcc=[config.email],
                         headers={'Reply-To': config.email})
     message.send()
Esempio n. 38
0
        def get_rendered(poll, user):
            request = self.request_factory.get('/')
            request.user = user
            t = Template(self.loadstatement +
                         '{% if poll|has_been_completed_by:request.user %}'
                         'HAS_VOTED{% else %}HAS_NOT_VOTED{% endif %}')
            c = Context({'poll': poll, 'request': request})
            rendered = t.render(c)

            return rendered
Esempio n. 39
0
 def test_missing_required_perm_arguments(self):
     tmpl = """
     {% if perm.permitter_test.CanEditObject %}
         fail
     {% endif %}
     """
     req = HttpRequest()
     req.user = User()
     tmpl, ctx = Template(tmpl), RequestContext(req)
     self.assertRaises(KeyError, lambda: tmpl.render(ctx))
Esempio n. 40
0
 def test_user_size(self):
     template = Template("""
         {% load embed_video_tags %}
         {% video 'http://www.youtube.com/watch?v=jsrRJyHBvzw' as ytb %}
             {% video ytb '800x800' %}
         {% endvideo %}
     """)
     rendered = u'''<iframe width="800" height="800" src="http://www.youtube.com/embed/jsrRJyHBvzw?wmode=opaque"
     frameborder="0" allowfullscreen></iframe>'''
     self.assertEqual(template.render(self._grc()).strip(), rendered)
        def get_rendered(topics, user):
            request = self.get_request()
            request.user = user
            ForumPermissionMiddleware().process_request(request)
            t = Template(
                self.loadstatement + '{% get_unread_topics topics request.user as unread_topics %}')
            c = Context({'topics': topics, 'request': request})
            rendered = t.render(c)

            return c, rendered
Esempio n. 42
0
    def test_tag_vimeo(self):
        template = Template("""
            {% load embed_video_tags %}
            {% video 'https://vimeo.com/72304002' as vimeo %}
                {{ vimeo.url }}
            {% endvideo %}
        """)
        rendered = 'http://player.vimeo.com/video/72304002'

        self.assertEqual(template.render(self._grc()).strip(), rendered)
Esempio n. 43
0
    def test_tag_youtube(self):
        template = Template("""
            {% load embed_video_tags %}
            {% video 'http://www.youtube.com/watch?v=jsrRJyHBvzw' as ytb %}
                {{ ytb.url }}
            {% endvideo %}
        """)
        rendered = 'http://www.youtube.com/embed/jsrRJyHBvzw?wmode=opaque'

        self.assertEqual(template.render(self._grc()).strip(), rendered)
    def test_link_to_tag(self):
        a = Page(name='Front Page', region=self.region)
        a.content = (u'<a href="tags/cats">dummy</a>')
        a.save()

        context = Context({'page': a, 'region': self.region})
        template = Template(html_to_template_text(a.content, context))
        html = template.render(context)
        self.assertEqual(html,
                         u'<a href="tags/cats" class="tag_link">dummy</a>')
Esempio n. 45
0
 def test_inclusion_tag4(self):
     ''' Test the show_es_gene_section tag - given a range
     on a sequence '''
     t = Template('{% load gene_tags %}' +
                  '{% show_es_gene_section seqid=seqid ' +
                  'start_pos=start_pos end_pos=end_pos%}')
     context = {'seqid': '1', 'start_pos': 2431888, 'end_pos': 2880054}
     c = Context(context)
     rendered = t.render(c)
     self.assertIn("PANK4", rendered)
Esempio n. 46
0
 def test_inclusion_tag2(self):
     ''' Test the show_es_gene_section tag - given a gene symbol '''
     t = Template('{% load gene_tags %}' +
                  '{% show_es_gene_section gene_symbol=gene %}')
     context = {'gene': 'PTPN22'}
     c = Context(context)
     rendered = t.render(c)
     self.assertIn("PTPN22", rendered)
     self.assertIn("9652", rendered)
     self.assertIn("protein_coding", rendered)
Esempio n. 47
0
def _template_render_and_send(subject, source, user, screenName, new_username):
    t = Template(source)
    body = t.render(
        Context({
            'user': user,
            'screenName': screenName,
            'new_username': new_username,
        }))
    mail_services.plain_send_mail(user.email, subject, body,
                                  settings.ADMAIL_FROM_EMAIL)
Esempio n. 48
0
    def test_embed(self):
        template = Template("""
            {% load embed_video_tags %}
            {% video 'http://www.youtube.com/watch?v=jsrRJyHBvzw' as ytb %}
                {{ ytb|embed:'large' }}
            {% endvideo %}
        """)
        rendered = '<iframe width="960" height="720" src="http://www.youtube.com/embed/jsrRJyHBvzw?wmode=opaque" frameborder="0" allowfullscreen></iframe>'

        self.assertEqual(template.render(self._grc()).strip(), rendered)
Esempio n. 49
0
 def test_tag_youtube_with_query(self):
     # Test KEY=VALUE arguments when used as a tag block.
     template = Template("""
         {% load embed_video_tags %}
         {% video 'http://www.youtube.com/watch?v=jsrRJyHBvzw' rel=0 as ytb %}
             {{ ytb.url }}
         {% endvideo %}
     """)
     rendered = 'http://www.youtube.com/embed/jsrRJyHBvzw?wmode=opaque&rel=0'
     self.assertEqual(template.render(self._grc()).strip(), rendered)
Esempio n. 50
0
 def test_can_provide_the_last_post_of_a_forum(self):
     # Setup
     t = Template(self.loadstatement +
                  '{% get_forum_last_post forum user as var %}')
     c = Context({'forum': self.forum_1, 'user': self.user})
     # Run
     rendered = t.render(c)
     # Check
     assert rendered == ''
     assert c['var'] == self.post_1
Esempio n. 51
0
    def _add_css_styles(self, epub_book):
        """Adds default css styles and custom css text if exists in config"""

        book_css = []

        try:
            epub_book.add_item(
                ebooklib.epub.EpubItem(
                    uid='default.css',
                    content=self._get_default_style(),
                    file_name='{}/{}'.format(STYLES_DIR, 'default.css'),
                    media_type='text/css'
                )
            )
            book_css.append('default.css')
        except Exception as e:
            logger.info('Default style was not added %s.', e)

        if self.theme_name:
            content = self._get_theme_style()

            if self.theme_name == 'custom':
                try:
                    data = json.loads(self.config['theme']['custom'].encode('utf8'))

                    tmpl = Template(content)
                    content = tmpl.render(data)
                except:
                    logger.exception("Fails with custom theme.")

            item = ebooklib.epub.EpubItem(
                uid='theme.css',
                content=content,
                file_name='{}/{}'.format(STYLES_DIR, 'theme.css'),
                media_type='text/css'
            )

            epub_book.add_item(item)
            book_css.append('theme.css')

        # we need to add css from publishing settings screen
        settings_style = self.config.get('settings', {}).get('styling', None)

        if settings_style:
            item = ebooklib.epub.EpubItem(
                uid='custom_style.css',
                content=settings_style,
                file_name='{}/{}'.format(STYLES_DIR, 'custom_style.css'),
                media_type='text/css'
            )

            epub_book.add_item(item)
            book_css.append('custom_style.css')

        return book_css
Esempio n. 52
0
 def test_inclusion_tag3(self):
     ''' Test the show_es_gene_section tag - given a position
     on a sequence '''
     t = Template('{% load gene_tags %}' +
                  '{% show_es_gene_section seqid=seqid start_pos=pos %}')
     context = {'seqid': '1', 'pos': 113813811}
     c = Context(context)
     rendered = t.render(c)
     self.assertIn("PTPN22", rendered)
     self.assertIn("9652", rendered)
     self.assertIn("protein_coding", rendered)
Esempio n. 53
0
 def test_endless_include(self):
     """ Should detect endless loops and give an error message
     """
     a = Page(name='Front Page')
     a.content = '<a class="plugin includepage" href="Front_Page">dummy</a>'
     a.save()
     context = Context({'page': a})
     template = Template(html_to_template_text(a.content, context))
     html = template.render(context)
     self.failUnless(('Unable to include <a href="/Front_Page">Front Page'
                      '</a>: endless include loop') in html)
Esempio n. 54
0
 def test_template_creation(self):
     self.assertObjectDoesNotExist(StaticPlaceholder.objects.all(),
                                   code='foobar')
     self.assertObjectDoesNotExist(Placeholder.objects.all(), slot='foobar')
     t = Template('{% load cms_tags %}{% static_placeholder "foobar" %}')
     t.render(self.get_context('/'))
     self.assertObjectExist(
         StaticPlaceholder.objects.all(),
         code='foobar',
         creation_method=StaticPlaceholder.CREATION_BY_TEMPLATE)
     self.assertEqual(Placeholder.objects.filter(slot='foobar').count(), 2)
Esempio n. 55
0
    def test_inline_coffeescript(self):
        template = Template("""
        {% load coldbrew %}
        {% inlinecoffeescript %}console.log "Hello, World"
        {% endinlinecoffeescript %}
        """)
        hopeful_result = u"""(function() {\n
  console.log("Hello, World");\n
}).call(this);"""
        actual_result = template.render(RequestContext({})).strip()
        self.assertEqual(actual_result, hopeful_result)
    def test_single_page_template(self):
        for x in range(0, self.perpage):
            get_user_model().objects.create(username="******" % x)

        paginator = Paginator(get_user_model().objects.all(), per_page=self.perpage)

        t = Template('{% load pagination %}{% pagination page_obj %}')
        c = Context({"page_obj": paginator.page(1)})
        output = t.render(c)
        regex = re.compile(r'^\s*$', re.MULTILINE)
        self.assertRegexpMatches(output, regex)
Esempio n. 57
0
 def test_local(self):
     self.assertObjectDoesNotExist(StaticPlaceholder.objects.all(), code='foobar')
     self.assertObjectDoesNotExist(Placeholder.objects.all(), slot='foobar')
     t = Template('{% load cms_tags %}{% static_placeholder "foobar" site or %}No Content{% endstatic_placeholder %}')
     rendered = t.render(self.get_context('/'))
     self.assertIn("No Content", rendered)
     for p in Placeholder.objects.all():
         add_plugin(p, 'TextPlugin', 'en', body='test')
     rendered = t.render(self.get_context('/'))
     self.assertNotIn("No Content", rendered)
     self.assertEqual(StaticPlaceholder.objects.filter(site_id__isnull=False, code='foobar').count(), 1)
Esempio n. 58
0
 def test_include_nonexistant(self):
     """ Should give an error message when including nonexistant page
     """
     a = Page(name='Front Page')
     a.content = '<a class="plugin includepage" href="New page">dummy</a>'
     a.save()
     context = Context({'page': a})
     template = Template(html_to_template_text(a.content, context))
     html = template.render(context)
     self.failUnless(('Unable to include <a href="/New_page"'
                      ' class="missing_link">New page</a>') in html)
Esempio n. 59
0
        def get_rendered(post, user):
            request = self.get_request()
            request.user = user
            t = Template(
                self.loadstatement +
                '{% if post|posted_by:request.user %}OWNER{% else %}NO_OWNER{% endif %}'
            )
            c = Context({'post': post, 'request': request})
            rendered = t.render(c)

            return rendered
Esempio n. 60
0
 def test_can_translate_a_given_url_in_another_language(self):
     # Setup
     url = reverse('public:journal:journal_list')
     request = self.factory.get(url)
     request.resolver_match = resolve(url)
     t = Template(self.loadstatement + '{% trans_current_url "en" %}')
     c = Context({'request': request})
     # Run
     rendered = t.render(c)
     # Check
     self.assertEqual(rendered, '/en/journals/')