コード例 #1
0
ファイル: views.py プロジェクト: bcattle/dolores-deals
def causes(request):
	c = Context(defaultContext)
	# assert False
	c.update({
		'current_menu_choice': 'causes'
	})
	return render_to_response('causes.html', c)
コード例 #2
0
ファイル: crispy.py プロジェクト: GaretJax/csat
    def _render(self, context, form, helper, caller):
        if helper is None:
            helper = crispy.FormHelper() if not hasattr(form, 'helper') else form.helper

        is_formset = isinstance(form, BaseFormSet)
        node_context = Context(context.get_all())
        node = crispy.BasicNode(form, helper)
        context_dict = node.get_response_dict(helper, node_context, is_formset)

        node_context.update(context_dict)

        if helper and helper.layout:
            if not is_formset:
                form.form_html = helper.render_layout(form, node_context, template_pack=crispy.TEMPLATE_PACK)
            else:
                forloop = crispy.ForLoopSimulator(form)
                for f in form.forms:
                    node_context.update({'forloop': forloop})
                    form.form_html = helper.render_layout(f, node_context, template_pack=crispy.TEMPLATE_PACK)
                    forloop.iterate()

        if is_formset:
            context_dict.update({'formset': form})
        else:
            context_dict.update({'form': form})

        context = Context(context_dict)

        if context['is_formset']:
            template = crispy.whole_uni_formset_template(crispy.TEMPLATE_PACK)
        else:
            template = crispy.whole_uni_form_template(crispy.TEMPLATE_PACK)

        return template.render(context)
コード例 #3
0
ファイル: widgets.py プロジェクト: evildmp/django-widgetry
 def render(self, name, value, attrs=None, extra_context={}):
     #print "BEGIN RENDER %s: %s" % (name, value)
     template = loader.select_template(['widgetry/fk_lookup/widget.html'])
     search_url =  reverse('widgetry-search')
     admin_media_prefix = getattr(settings, 'ADMIN_MEDIA_PREFIX', None) or ''.join([settings.STATIC_URL, 'admin/'])
     # the label
     if value:
         label = self.label_for_value(value)
     else:
         label = u''
     # allow the object browsing popup
     if (self.show_edit):
         enable_edit = u'true'
     else:
         enable_edit = u'false'
     if self.content_type:
         content_type_id = self.content_type.pk
     if value is None:
         value = ''
     else:
         value = str(value)
     content_type_info = self.content_type_info
     content_type_info_json = simplejson.dumps(content_type_info)
     context = Context(locals())
     context.update(extra_context)
     r = template.render(context)
     return r
コード例 #4
0
ファイル: login.py プロジェクト: davidlivingrooms/portcullis
def user_login(request):

    error = ''

    #Read next url to be redirected to
    try:
        redirect_to = request.REQUEST["next"]
    except KeyError:
        redirect_to = "/portcullis/user_streams/"

    if request.method == 'POST':
        user = authenticate(username=request.POST["username"], password=request.POST["password"])
        if user is not None:
            if user.is_active:
                login(request, user)
                return HttpResponseRedirect(redirect_to)
            else:
                error = "Account disabled"
        else:
            error = "Invalid login";


    t = loader.get_template('login.html');
    c = Context({'user':request.user,'error':error,"redirect_to":redirect_to})
    c.update(csrf(request));
    return HttpResponse(t.render(c))
コード例 #5
0
ファイル: openaction.py プロジェクト: openpolis/open-action
    def deliver(self, recipient, sender, notice_type, extra_context):
        """ Deliver a notice to a User 

        DefaultBackend.deliver will send to the receiver (a User) a 
        notification of an action triggered by some other User on an 
        Action or on some article related to it
        """

        # Inspired from django-notification-brosner.backends.EmailBackend
        # 1. Get formatted messages
        context = Context({"recipient": recipient, "sender": sender, "notice": ugettext(notice_type.display)})
        context.update(extra_context)

        messages = self.get_formatted_messages(("short.txt", "full.txt"), notice_type.label, context)

        # 2. Render them with on-site site-wide notification templates
        subject = render_to_string(
            "notification/on_site_notice_subject.txt", {"message": messages["short.txt"]}, context
        )

        text = render_to_string("notification/on_site_notice_text.txt", {"message": messages["full.txt"]}, context)

        notice_text = u"%s%s" % (subject, text)

        # 3. Deliver notice = save new notice for User 'recipient'
        from notification.models import Notice

        Notice.objects.create(recipient=recipient, message=notice_text, notice_type=notice_type, on_site=True)
コード例 #6
0
def render_to_string(template_name, dictionary, context=None, namespace='main'):

    # see if there is an override template defined in the microsite
    template_name = microsite.get_template_path(template_name)

    context_instance = Context(dictionary)
    # add dictionary to context_instance
    context_instance.update(dictionary or {})
    # collapse context_instance to a single dictionary for mako
    context_dictionary = {}
    context_instance['settings'] = settings
    context_instance['EDX_ROOT_URL'] = settings.EDX_ROOT_URL
    context_instance['marketing_link'] = marketing_link
    context_instance['is_any_marketing_link_set'] = is_any_marketing_link_set
    context_instance['is_marketing_link_set'] = is_marketing_link_set

    # In various testing contexts, there might not be a current request context.
    request_context = get_template_request_context()
    if request_context:
        for item in request_context:
            context_dictionary.update(item)
    for item in context_instance:
        context_dictionary.update(item)
    if context:
        context_dictionary.update(context)

    # "Fix" CSRF token by evaluating the lazy object
    KEY_CSRF_TOKENS = ('csrf_token', 'csrf')
    for key in KEY_CSRF_TOKENS:
        if key in context_dictionary:
            context_dictionary[key] = unicode(context_dictionary[key])

    # fetch and render template
    template = lookup_template(namespace, template_name)
    return template.render_unicode(**context_dictionary)
コード例 #7
0
ファイル: shortcuts.py プロジェクト: BenjiLee/edx-platform
def render_to_string(template_name, dictionary, context=None, namespace='main'):

    # see if there is an override template defined in the microsite
    template_name = microsite.get_template_path(template_name)

    context_instance = Context(dictionary)
    # add dictionary to context_instance
    context_instance.update(dictionary or {})
    # collapse context_instance to a single dictionary for mako
    context_dictionary = {}
    context_instance['settings'] = settings
    context_instance['EDX_ROOT_URL'] = settings.EDX_ROOT_URL
    context_instance['marketing_link'] = marketing_link

    # In various testing contexts, there might not be a current request context.
    if edxmako.middleware.REQUEST_CONTEXT.context is not None:
        for d in edxmako.middleware.REQUEST_CONTEXT.context:
            context_dictionary.update(d)
    for d in context_instance:
        context_dictionary.update(d)
    if context:
        context_dictionary.update(context)
    # fetch and render template
    template = lookup_template(namespace, template_name)
    return template.render_unicode(**context_dictionary)
コード例 #8
0
ファイル: backend.py プロジェクト: 7Geese/django-jinja
    def render(self, context=None, request=None):
        if context is None:
            context = {}

        if request is not None:
            def _get_val():
                token = get_token(request)
                if token is None:
                    return 'NOTPROVIDED'
                else:
                    return smart_text(token)

            context["request"] = request
            context["csrf_token"] = SimpleLazyObject(_get_val)

            # Support for django context processors
            for processor in self.backend.context_processors:
                context.update(processor(request))
                
        if settings.TEMPLATE_DEBUG:
            from django.test import signals
            self.template.origin = Origin(self.template.filename)
            context_obj = Context(context)

            context_processors = {}
            if request is not None:
                for processor in self.backend.context_processors:
                    context_processors[processor.__name__] = processor(request)
            context_obj.context_processors = context_processors

            signals.template_rendered.send(sender=self, template=self.template, context=context_obj)

        return self.template.render(context)
コード例 #9
0
ファイル: django.py プロジェクト: clokep/django-render-block
def django_render_block(template, block_name, context):
    # Create a Django Context.
    context_instance = Context(context)

    # Get the underlying django.template.base.Template object.
    template = template.template

    # Bind the template to the context.
    with context_instance.bind_template(template):
        # Before trying to render the template, we need to traverse the tree of
        # parent templates and find all blocks in them.
        parent_template = _build_block_context(template, context_instance)

        try:
            return _render_template_block(template, block_name, context_instance)
        except BlockNotFound:
            # The block wasn't found in the current template.

            # If there's no parent template (i.e. no ExtendsNode), re-raise.
            if not parent_template:
                raise

            # Check the parent template for this block.
            return _render_template_block(
                parent_template, block_name, context_instance)
コード例 #10
0
def render(element, markup_classes):
    element_type = element.__class__.__name__.lower()

    if element_type == 'boundfield':
        add_input_classes(element)
        template = get_template("bootstrapform/field.html")
        context = Context({'field': element, 'classes': markup_classes, 'form': element.form})
    else:
        has_management = getattr(element, 'management_form', None)
        if has_management:
            for form in element.forms:
                for field in form.visible_fields():
                    add_input_classes(field)

            template = get_template("bootstrapform/formset.html")
            context = Context({'formset': element, 'classes': markup_classes})
        else:
            for field in element.visible_fields():
                add_input_classes(field)

            template = get_template("bootstrapform/form.html")
            context = Context({'form': element, 'classes': markup_classes})

        if django_version >= (1, 8):
            context = context.flatten()

    return template.render(context)
コード例 #11
0
ファイル: site.py プロジェクト: emacsway/django-notification
 def deliver(self, recipient, sender, notice_type, extra_context):
     # TODO: require this to be passed in extra_context
     current_site = Site.objects.get_current()
     notices_url = "{0}://{1}{2}".format(
         DEFAULT_HTTP_PROTOCOL,
         str(Site.objects.get_current()),
         urlresolvers.reverse("notification_notices"),
     )
     
     # update context with user specific translations
     context = Context({
         "user": recipient,  # Old compatible
         "recipient": recipient,
         "sender": sender,
         "notice": ugettext(notice_type.display),
         "notices_url": notices_url,
         "current_site": current_site,
     })
     context.update(extra_context)
     
     messages = self.get_formatted_messages((
         "notice.html",
     ), notice_type.label, context)
     from notification.models import Notice
     notice = Notice.objects.create(
         recipient=recipient,
         sender=sender,
         notice_type=notice_type,
         message=messages['notice.html'],
         on_site=True,
     )
コード例 #12
0
ファイル: case_studies.py プロジェクト: maoge/crate-web
def preBuild(site):

    global CASES

    # Build all the cases
    for case in site.pages():
        if case.path.startswith(DIR):

            # Skip non html cases for obvious reasons
            if not case.path.endswith('.html'):
                continue

            # Parse headers and markdown body
            headers, body = parsePost(case.data())

            # Build a context for each post
            caseContext = Context()
            caseContext.update(headers)
            caseContext['raw_body'] = body
            caseContext['path'] = case.path
            caseContext['date'] = parseDate(headers.get('date') or headers.get('created'))
            caseContext['url'] = case.absolute_final_url
            caseContext['tags'] = headers.get('tags') and [h.strip() for h in headers['tags'].split(',')] or []
            caseContext['category'] = headers.get('category') and [h.strip() for h in headers['category'].split(',')] or []
            CASES.append(caseContext)

    # Sort the cases by date
    CASES = sorted(CASES, key=lambda x: x['date'])
    CASES.reverse()

    indexes = range(0, len(CASES))

    for i in indexes:
        if i+1 in indexes: CASES[i]['prev_post'] = CASES[i+1]
        if i-1 in indexes: CASES[i]['next_post'] = CASES[i-1]
コード例 #13
0
ファイル: template.py プロジェクト: luac/django-argcache
            def render_given_args(self, resolved_args, context_attrs):
                context = self._context
                # CHANGED: func -> cached_func
                _dict = cached_func(*resolved_args)

                t = context.render_context.get(self)
                if t is None:
                    if isinstance(file_name, Template):
                        t = file_name
                    elif isinstance(getattr(file_name, 'template', None), Template):
                        t = file_name.template
                    elif not isinstance(file_name, six.string_types) and is_iterable(file_name):
                        t = context.template.engine.select_template(file_name)
                    else:
                        t = context.template.engine.get_template(file_name)
                    context.render_context[self] = t
                # CHANGED: new_context = context.new(_dict) to the following
                # five lines.  We don't want to copy the context because it
                # might be a RequestContext, even if the tag's cache doesn't
                # depend on this user.  This would be Very Bad; it could cause
                # the cache to leak data about one user to another user.  So we
                # require using a plain Context, and copy a whitelisted set of
                # attrs over, rather than using copy().
                new_context = Context(_dict)
                for attr, val in context_attrs.iteritems():
                    setattr(new_context, attr, val)
                new_context.render_context = copy(context.render_context)
                # CHANGED: removed copying the csrf_token over to the
                # new_context, because we should never do that.  If you need a
                # csrf_token in an inclusion tag, you'll have to generate your
                # own with AJAX.
                return t.render(new_context)
コード例 #14
0
 def test_tagcloud(self):
     t = get_template('taggit_templatetags2/tagcloud_include.html')
     c = Context({'forvar': None})
     t.render(c)
     self.assert_tags_equal(c.get("tags"), ["green"], False)
     self.assertEqual(c.get("tags")[0].name, "green")
     self.assertEqual(c.get("tags")[0].weight, 6.0)
コード例 #15
0
ファイル: test_context.py プロジェクト: AMontagu/django
    def test_context_comparable(self):
        """
        #21765 -- equality comparison should work
        """

        test_data = {'x': 'y', 'v': 'z', 'd': {'o': object, 'a': 'b'}}

        self.assertEqual(Context(test_data), Context(test_data))

        a = Context()
        b = Context()
        self.assertEqual(a, b)

        # update only a
        a.update({'a': 1})
        self.assertNotEqual(a, b)

        # update both to check regression
        a.update({'c': 3})
        b.update({'c': 3})
        self.assertNotEqual(a, b)

        # make contexts equals again
        b.update({'a': 1})
        self.assertEqual(a, b)
コード例 #16
0
ファイル: utils.py プロジェクト: lehins/lehins-notification
def get_formatted_message(formats, notice_type, context, medium):
    """
    Returns a dictionary with the format identifier as the key. The values are
    are fully rendered templates with the given context.
    """
    if not isinstance(context, Context):
        context = Context(context or {})
    protocol = 'https' if USE_SSL else 'http'
    current_site = Site.objects.get_current()
    base_url = u"%s://%s" % (protocol, unicode(current_site))
    context.update({
        'base_url': base_url,
        'site': current_site,
    })
    format_templates = {}
    context = apply_context_processors(context)
    for format in formats:
        # conditionally turn off autoescaping for .txt extensions in format
        if format.endswith(".txt") or format.endswith(".html"):
            context.autoescape = False
        else:
            context.autoescape = True
        format_templates[format] = render_to_string((
            'notification/%s/%s/%s' % (
                    notice_type.template_slug, medium, format),
            'notification/%s/%s' % (notice_type.template_slug, format),
            'notification/%s/%s' % (medium, format),
            'notification/%s' % format), context_instance=context)
    return format_templates
コード例 #17
0
 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)
コード例 #18
0
ファイル: views.py プロジェクト: wyuka/gymkhana-website
def index(request):
    loginerr = False
    logoutsuccess = False
    if request.GET.get("loginerr","false") == "true":
        loginerr = True
    if request.GET.get("logoutsuccess","false") == "true":
        logoutsuccess = True
    full_news_list = News.objects.all().order_by('-published_date')
    oldest_page =  math.ceil(len(full_news_list) / 6.0)

    user = None
    logged_in = request.session.get('logged_in', False)
    oldest_page_newsboard = 0
    if logged_in:
        user = User.objects.get(id=request.session.get('uid',0))
        oldest_page_newsboard = math.ceil(len(user.pinned_news.all()) / 6.0)

    c = Context({
        'loginerr': loginerr,
        'logoutsuccess': logoutsuccess,
        'logged_in': request.session.get('logged_in', False),
        'user': user,
        'oldest_page_mostrecent': oldest_page,
        'oldest_page_mostviewed': oldest_page,
        'oldest_page_newsboard': oldest_page_newsboard,
        'sidebarnews': full_news_list[:12],
    })
    c.update(csrf(request))

    return render_to_response("news.html", c)
コード例 #19
0
ファイル: django.py プロジェクト: AaronJaramillo/shopDPM
def handle_extendsnode(extendsnode, block_context=None, original=None):
    """Create a copy of Node tree of a derived template replacing
    all blocks tags with the nodes of appropriate blocks.
    Also handles {{ block.super }} tags.
    """
    if block_context is None:
        block_context = BlockContext()
    blocks = dict((n.name, n) for n in
                  extendsnode.nodelist.get_nodes_by_type(BlockNode))
    block_context.add_blocks(blocks)

    # Note: we pass an empty context when we find the parent, this breaks
    # inheritance using variables ({% extends template_var %}) but a refactor
    # will be needed to support that use-case with multiple offline contexts.
    context = Context()
    if original is not None:
        context.template = original

    compiled_parent = extendsnode.get_parent(context)
    parent_nodelist = compiled_parent.nodelist
    # If the parent template has an ExtendsNode it is not the root.
    for node in parent_nodelist:
        # The ExtendsNode has to be the first non-text node.
        if not isinstance(node, TextNode):
            if isinstance(node, ExtendsNode):
                return handle_extendsnode(node, block_context, original)
            break
    # Add blocks of the root template to block context.
    blocks = dict((n.name, n) for n in
                  parent_nodelist.get_nodes_by_type(BlockNode))
    block_context.add_blocks(blocks)

    block_stack = []
    new_nodelist = remove_block_nodes(parent_nodelist, block_stack, block_context)
    return new_nodelist
コード例 #20
0
ファイル: views.py プロジェクト: mince-t/uw_python
def my_admin(request):
    
    if request.POST:
        print "post"
        if 'operation' in request.POST.keys():
            if request.POST['operation']=='delete book':
                print "deleting book id " + request.POST['book']
                #book.objects.filter("book_id=" + request.POST['book'] ).delete()
                book.objects.get(book_id=request.POST['book']).delete()
            elif request.POST['operation']=='edit book':
                return HttpResponseRedirect("/books/my_admin/modify_book/edit/" + request.POST['book'] + "/")
            elif request.POST['operation']=='new book':
                return HttpResponseRedirect("/books/my_admin/modify_book/add//")
            elif request.POST['operation']==u'purge books':
                print 'purging books'
                book.objects.all().delete()
            elif request.POST['operation']==u'import books':
                my_admin_load_BooksDB()

            
    #t = loader.get_template('my_admin.html')
    c = Context({
        'all_books': book.objects.all().order_by("title"),
    })


    
    c.update(csrf(request))
    # ... view code here
    return render_to_response("my_admin.html", c)
コード例 #21
0
ファイル: phased_tags.py プロジェクト: arneb/django-phased
    def render(self, context):
        # our main context
        storage = Context()

        # stash the whole context if needed
        if settings.KEEP_CONTEXT:
            storage.update(flatten_context(context))

        # but check if there are variables specifically wanted
        for var_name in self.var_names:
            if var_name[0] in ('"', "'") and var_name[-1] == var_name[0]:
                var_name = var_name[1:-1]
            try:
                storage[var_name] = Variable(var_name).resolve(context)
            except VariableDoesNotExist:
                raise TemplateSyntaxError(
                    '"phased" tag got an unknown variable: %r' % var_name)

        # lastly return the pre phased template part
        return u'%(delimiter)s%(content)s%(pickled_context)s%(pickled_components)s%(delimiter)s' % {
            'content': self.content,
            'delimiter': settings.SECRET_DELIMITER,
            'pickled_context': pickle_context(backup_csrf_token(context, storage)),
            'pickled_components': pickle_components(self.components),
        }
コード例 #22
0
ファイル: dj.py プロジェクト: markuz/planetalinux
def run(script, doc, output_file=None, options={}):
    """process a Django template file"""

    # this is needed to use the Django template system as standalone
    # I need to re-import the settings at every call because I have to
    # set the TEMPLATE_DIRS variable programmatically
    from django.conf import settings

    try:
        settings.configure(DEBUG=True, TEMPLATE_DEBUG=True, TEMPLATE_DIRS=(os.path.dirname(script),))
    except EnvironmentError:
        pass
    from django.template import Context
    from django.template.loader import get_template

    # set up the Django context by using the default htmltmpl
    # datatype converters
    context = Context()
    context.update(tmpl.template_info(doc))
    context["Config"] = config.planet_options()
    t = get_template(script)

    if output_file:
        reluri = os.path.splitext(os.path.basename(output_file))[0]
        context["url"] = urlparse.urljoin(config.link(), reluri)
        f = open(output_file, "w")
        ss = t.render(context)
        if isinstance(ss, unicode):
            ss = ss.encode("utf-8")
        f.write(ss)
        f.close()
    else:
        # @@this is useful for testing purposes, but does it
        # belong here?
        return t.render(context)
コード例 #23
0
ファイル: views.py プロジェクト: Gu5HC/Anonymous_Me
def shortify_url(request):
	if request.method == 'POST':
		context = Context({})
		url = request.POST.get('url','')

		print "URL",url
		if not url:
			context['errors'] = 'No URL was supplied' # checking for the supplied url if js is off
		else: # the url has been supplied
			try:
				check_obj = URLtoHASH.objects.get(url=url) # checking if the url is already shoretened or not
				print "URL ALREADY EXISTS"
				hash_val = check_obj.hash_value
			except: # means the user entered a new url
				url_obj = URLtoHASH(url=url) # creating a new URL obj
				url_obj.save() # save to DB
				url_id = url_obj.id # getting the ID of the stored DB object
				print 'URL_ID',url_id
				hash_val = hashed_string(url_id)
				url_obj.hash_value = hash_val# saving the hashed value to the DB
				url_obj.save() # saving the changes to the DB


			print 'HASH_VALUE',hash_val
			shortened_url = urlparse.urlunparse(('http',HOSTNAME,hash_val,'','',''))
			context["success"] = shortened_url
			print shortened_url

		context.update(csrf(request))
		return render_to_response('index.html',context)
コード例 #24
0
ファイル: options.py プロジェクト: m00dy/controller
def send_email_template(template, context, to, email_from=None, html=None):
    """
    Renders an email template with this format:
        {% if subject %}Subject{% endif %}
        {% if message %}Email body{% endif %}
    
    context can be a dictionary or a template.Context instance
    """
    from django.template.loader import render_to_string
    from django.template import Context
    if isinstance(context, dict):
        context = Context(context)
    if type(to) in [str, unicode]:
        to = [to]
    
    if not 'site' in context: # fallback site value
        context.update({'site': get_controller_site()})
    
    #subject cannot have new lines
    subject = render_to_string(template, {'subject': True}, context).strip()
    message = render_to_string(template, {'message': True}, context)
    msg = EmailMultiAlternatives(subject, message, email_from, to)
    if html:
        html_message = render_to_string(html, {'message': True}, context)
        msg.attach_alternative(html_message, "text/html")
    msg.send()
コード例 #25
0
 def test_qurl_as(self):
     context = Context()
     Template(
         '{% load qurl %}'
         '{% qurl "http://sophilabs.com/?a=1" a=None as url %}'
     ).render(context)
     self.assertEqual(context.get('url'), 'http://sophilabs.com/')
コード例 #26
0
ファイル: functions.py プロジェクト: arnike/Wenix
def render_to_task(cmd, when="now"):
    
    context = Context({"cmd": cmd})
    
    taskdir = os.path.join(settings.TASKMASTER_PATH, 'tasks')
    # Lock
    lock = open(os.path.join(settings.TASKMASTER_PATH, 'addlock'))
    flock(lock, LOCK_EX)
    try:
        tasks = os.listdir(os.path.join(settings.TASKMASTER_PATH, 'tasks'))
    except OSError:
        tasks = []
        os.mkdir(os.path.join(settings.TASKMASTER_PATH, 'tasks'), 0755)
    
    tasks.sort(cmp=lambda x,y: cmp(int(x), int(y)))
    
    try:
        taskno = int(tasks[-1]) + 1
    except IndexError:
        taskno = 1
    
    # Write the task
    path = os.path.join(taskdir, str(taskno))
    context.update({"path": path})
    txt = TEMPLATE.render(context)
    #print "Writing to the path '%s' the following: %s" % (path, txt)
    h = open(path, 'w')
    h.write(txt)
    h.close()
    subprocess.call(["at", "-f", path, when])
    
    # Unlock
    flock(lock, LOCK_UN)
    lock.close()
コード例 #27
0
ファイル: email.py プロジェクト: BernadetaNegra/volontulo
def send_mail(request, templates_name, recipient_list, context=None):
    u"""Proxy for sending emails."""
    fail_silently = FAIL_SILENTLY
    auth_user = AUTH_USER
    auth_password = AUTH_PASSWORD
    connection = CONNECTION

    context = Context(context or {})
    context.update({
        'protocol': 'https' if request.is_secure() else 'http',
        'domain': get_current_site(request).domain,
    })
    text_template = get_template('emails/{}.txt'.format(templates_name))
    html_template = get_template('emails/{}.html'.format(templates_name))

    bcc = list(get_administrators_emails().values())
    connection = connection or get_connection(
        username=auth_user,
        password=auth_password,
        fail_silently=fail_silently
    )
    # required, if omitted then no emails from BCC are send
    headers = {'bcc': ','.join(bcc)}
    email = EmailMultiAlternatives(
        SUBJECTS[templates_name],
        text_template.render(context),
        FROM_ADDRESS,
        recipient_list,
        bcc,
        connection=connection,
        headers=headers
    )
    email.attach_alternative(html_template.render(context), 'text/html')

    return email.send()
コード例 #28
0
ファイル: placeholder.py プロジェクト: intexal/my-first-blog
def get_context():
    if engines is not None:
        context = Context()
        context.template = Template('')
        return context
    else:
        return {}
コード例 #29
0
ファイル: publish.py プロジェクト: mysteryhunt/spoilr
 def __init__(self, team):
     Context.__init__(self)
     self['team'] = team
     self['rounds'] = [self.round_obj(x) for x in RoundAccess.objects.filter(team=team).order_by('id')]
     self['solved_metas'] = [x.metapuzzle for x in MetapuzzleSolve.objects.filter(team=team).order_by('id')]
     self['log_entries'] = [{"entry": x} for x in TeamLog.objects.filter(team=team).order_by('-id')]
     for entry in self['log_entries']:
         msg = entry['entry'].message
         if "[[" in msg:
             entry['protected_message'] = log_entry_protect.sub('[hidden]', msg)
             entry['unprotected_message'] = log_entry_protect.sub(r'\1', msg)
     # ----- 2014-specific -----
     self['has_wl_access'] = (len(self['rounds']) > 2)
     try:
         self['gone_with_the_wind_released'] = PuzzleAccess.objects.filter(team=team, puzzle=Puzzle.objects.get(url='gone_with_the_wind')).exists()
     except:
         logger.exception('couldn\'t determine if gone_with_the_wind has been released')
         pass
     self['team_data'] = Y2014TeamData.objects.get(team=team)
     points = self['team_data'].points
     self['tickett'] = TRAIN_COST
     if points >= TRAIN_READY[2]:
         self['ticket'] = 0
         self['tickett'] = None
     elif points < DRINK_READY[-1]:
         self['ticket'] = 0
     elif points >= TRAIN_READY[1]:
         self['ticket'] = min(TRAIN_COST, max(0, points - TRAIN_READY[1]))
     elif points >= TRAIN_READY[0]:
         self['ticket'] = min(TRAIN_COST, max(0, points - TRAIN_READY[0]))
     else:
         self['ticket'] = min(TRAIN_COST, max(0, points - DRINK_READY[-1]))
     self['ticketx'] = self['ticket']*10/TRAIN_COST
コード例 #30
0
ファイル: validate_resumes.py プロジェクト: Dpetters/Umeqo
 def handle(self, *args, **options):
     for student in Student.objects.visible():
         try:
             PdfFileReader(file("%s%s" % (s.MEDIA_ROOT, str(student.resume)), "rb"),)
         except Exception as e:
             try:
                 student.deactivate()
                 
                 managers = [mail_tuple[1] for mail_tuple in s.MANAGERS]
                 
                 context = Context({
                     'student_first_name': student.first_name,
                     'student_last_name': student.last_name,
                     'student_email': student.user.email
                 })
                 context.update(get_basic_email_context())
                 
                 subject = ''.join(render_to_string('email_admin_subject.txt', {
                     'message': "Faulty resume"
                 }, context).splitlines())
 
                 body = render_to_string('faulty_resume_email_body.txt', context)
         
                 send_email(subject, body, managers)
             except Exception as e:
                 print e
コード例 #31
0
ファイル: buildbook.py プロジェクト: thesues/newsmth
        continue
    feed = Feed()
    feed.title = article['t']
    getContent(smth, articleparser, article['b'], article['gid'], feed, 0)
    getContent(smth, articleparser, article['b'], article['gid'], feed, 1)
    sumaryFeeds.append(feed)

#write data

f = open(archive + "/sm.data", "w")
cPickle.dump(sumaryFeeds, f)
f.close()

#write to html
t = Template(bookTemplate)
c = Context({"sumaryFeeds": sumaryFeeds, "today": today})
renderdHtml = t.render(c)
f = open(archive + "/sm.html", "w")
f.write(renderdHtml.encode("utf8"))
f.close()

#uniq the feed

#write to datebases
previousThread = Thread.objects.filter(date=today)
if len(previousThread) == 0:
    p = Thread.objects.create(location=archive + "sm.html",
                              mobiLocation=archive + "sm.mobi")
    p.save()
else:
    p = previousThread[0]
コード例 #32
0
ファイル: mixins.py プロジェクト: addaxagent/agent96
 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))
コード例 #33
0
ファイル: test_compat.py プロジェクト: vdasari1/RSR
 def test_dictionary_and_context_instance_kwarg(self):
     self.assertEqual(render_to_string(self.template_name, dictionary={'obj': '1'}, context_instance=Context({'obj': '2'})), 'obj:1')
コード例 #34
0
ファイル: test_compat.py プロジェクト: vdasari1/RSR
 def test_context_instance_kwarg(self):
     self.assertEqual(render_to_string(self.template_name, context_instance=Context({'obj': 'test'})), 'obj:test')
コード例 #35
0
ファイル: test_compat.py プロジェクト: vdasari1/RSR
 def test_verbatim_tag05(self):
     template = Template(self.import_tag +
         '{% verbatim %}{% endverbatim %}{% verbatim %}{% endverbatim %}'
     )
     html = template.render(Context({}))
     self.assertEqual(html, '')
コード例 #36
0
def services(request):
    all_services = Service.objects.active().order_by('name')
    context = Context({'all_services': all_services, 'title': "Services"})

    return render(request, "services/services_list.html", context)
コード例 #37
0
 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)
コード例 #38
0
 def test_node(self):
     r = HubSpotNode().render(Context())
     assert ("n.id=i;n.src='//js.hs-analytics.net/analytics/'"
             "+(Math.ceil(new Date()/r)*r)+'/1234.js';") in r
コード例 #39
0
ファイル: evaluate.py プロジェクト: Lukahm/ontask
def render_template(template_text, context_dict, action=None):
    """
    Given a template text and a context, performs the rendering of the
    template using the django template mechanism but with an additional
    pre-processing to bypass the restriction imposed by Jinja/Django that the
    variable names must start with a letter followed by a letter, number or _.

    In OnTask, the variable names are: column names, attribute names,
    or condition names. It is too restrictive to propagate the restrictions
    imposed by Jinja variables all the way to these three components. To
    hide this from the users, there is a preliminary step in which those
    variables in the template and keys in the context that do not comply with
    the syntax restriction are renamed to compliant names.

    The problem:
    We are giving two objects: a string containing a template with two markup
    structures denoting the use of variables, and a dictionary that matches
    variables to values.

    The processing of the template is done through Django template engine
    (itself based in Jinja). The syntax for the variables appearing in the
    template is highly restrictive. It only allows names starting with a
    letter followed by letter, number or '_'. No other printable symbol is
    allowed. We want to relax this last restriction.

    The solution:
    1) Parse the template and detect the use of all variables.

    2) For each variable use, transform its name into a name that is legal
       for Jinja (starts with letter followed by letter, number or '_' *)

       The transformation is based on:
       - Every non-letter or number is replaced by '_' followed by a
         letter/number as specified by the dictionary below.

       - If the original variable does not start by a letter, insert a prefix.

    3) Apply the same transformation for the keys in the given dictionary

    4) Execute the new template with the new dictionary and return the result.

    :param template_text: Text in the template to be rendered
    :param context_dict: Dictionary used by Jinja to evaluate the template
    :param action: Action object to insert in the context in case it is
    needed by any other custom template.
    :return: The rendered template
    """

    # Regular expressions detecting the use of a variable, or the
    # presence of a "{% MACRONAME variable %} construct in a string (template)
    var_use_res = [
        re.compile('(?P<mup_pre>{{\s+)(?P<vname>.+?)(?P<mup_post>\s+\}\})'),
        re.compile('(?P<mup_pre>{%\s+if\s+)(?P<vname>.+?)(?P<mup_post>\s+%\})')
    ]

    # Steps 1 and 2. Apply the tranlation process to all variables that
    # appear in the the template text
    new_template_text = template_text
    for rexpr in var_use_res:
        new_template_text = rexpr.sub(
            lambda m: m.group('mup_pre') + \
                      translate(m.group('vname')) + \
                      m.group('mup_post'),
            new_template_text)
    new_template_text = '{% load vis_include %}' + new_template_text

    # Step 3. Apply the translation process to the context keys
    new_context = dict([(translate(escape(x)), y)
                        for x, y in context_dict.items()])

    # If the number of elements in the two dictionaries is different, we have
    #  a case of collision in the translation. Need to stop immediately.
    assert len(context_dict) == len(new_context)

    if action_context_var in new_context:
        raise Exception('Name {0} is reserved.'.format(action_context_var))
    new_context[action_context_var] = action

    if viz_number_context_var in new_context:
        raise Exception('Name {0} is reserved.'.format(viz_number_context_var))
    new_context[viz_number_context_var] = 0

    # Step 4. Return the redering of the new elements
    return Template(new_template_text).render(Context(new_context))
コード例 #40
0
 def body(self):
     ctx = Context(self.get_template_vars())
     s = DjangoTemplate(self.alarm_class.body_template).render(ctx)
     return s
コード例 #41
0
def edit(request):
    # Don't use request.amo_user since it has too much caching.
    amouser = UserProfile.objects.get(pk=request.user.id)
    if request.method == 'POST':
        # ModelForm alters the instance you pass in.  We need to keep a copy
        # around in case we need to use it below (to email the user)
        original_email = amouser.email
        form = forms.UserEditForm(request.POST,
                                  request.FILES,
                                  request=request,
                                  instance=amouser)
        if form.is_valid():
            messages.success(request, _('Profile Updated'))
            if amouser.email != original_email:
                # Temporarily block email changes.
                if settings.APP_PREVIEW:
                    messages.error(
                        request, 'Error',
                        'You cannot change your email on the '
                        'developer preview site.')
                    return jingo.render(request, 'users/edit.html', {
                        'form': form,
                        'amouser': amouser
                    })

                l = {
                    'user': amouser,
                    'mail1': original_email,
                    'mail2': amouser.email
                }
                log.info(u"User (%(user)s) has requested email change from "
                         "(%(mail1)s) to (%(mail2)s)" % l)
                messages.info(
                    request, _('Email Confirmation Sent'),
                    _(u'An email has been sent to {0} to confirm your new '
                      'email address. For the change to take effect, you '
                      'need to click on the link provided in this email. '
                      'Until then, you can keep logging in with your '
                      'current email address.').format(amouser.email))

                token, hash_ = EmailResetCode.create(amouser.id, amouser.email)
                url = '%s%s' % (settings.SITE_URL,
                                reverse('users.emailchange',
                                        args=[amouser.id, token, hash_]))
                t = loader.get_template('users/email/emailchange.ltxt')
                c = {'domain': settings.DOMAIN, 'url': url}
                send_mail(_('Please confirm your email address '
                            'change at %s' % settings.DOMAIN),
                          t.render(Context(c)),
                          None, [amouser.email],
                          use_blacklist=False,
                          real_email=True)

                # Reset the original email back.  We aren't changing their
                # address until they confirm the new one
                amouser.email = original_email
            form.save()
            return redirect('users.edit')
        else:

            messages.error(
                request, _('Errors Found'),
                _('There were errors in the changes '
                  'you made. Please correct them and '
                  'resubmit.'))
    else:
        form = forms.UserEditForm(instance=amouser)
    return jingo.render(request, 'users/edit.html', {
        'form': form,
        'amouser': amouser,
        'webapp': False
    })
コード例 #42
0
    def handle(self, *args, **options):
        output = []

        time_now = timezone.now().strftime("%Y-%m-%d %H:%M")

        subject = getattr(settings, 'SUBSCRIBES_SUBJECT',
                          _('«МК-Киев». Выбор редактора'))
        from_email_name = getattr(settings, 'SUBSCRIBES_FROM_EMAIL_NAME',
                                  'no-reply')
        pretty_from_email_name = getattr(settings,
                                         'SUBSCRIBES_PRETTY_FROM_EMAIL_NAME',
                                         'МК-Киев')

        previous_day = timezone.now() - timedelta(days=1)
        try:
            articles = Article.objects.select_related().filter(
                activity=True,
                pub_date__gte=previous_day).order_by('-pub_date')
        except Article.DoesNotExist:
            raise CommandError('%s Articles does not exist' % time_now)

        # current_site = Site.objects.get_current()
        # domain = add_domain(current_site.domain, '', False)
        domain = "http://mkkiev.in.ua/"
        pretty_domain = domain.replace('http://',
                                       '').replace('https://', '').replace(
                                           '//', '').replace('www', '')
        #
        from_email = '%s <%s@%s>' % (pretty_from_email_name, from_email_name,
                                     pretty_domain)
        # print from_email
        # from_email = "*****@*****.**"
        from_email = "*****@*****.**"

        print from_email

        c = Context({
            'article_list': articles,
            'subject': subject,
            'domain': domain,
            'pretty_domain': pretty_domain
        })

        messages = []
        for template_name in ('subscribes/email.txt', 'subscribes/email.html'):
            try:
                t = get_template(template_name)
            except TemplateDoesNotExist:
                raise CommandError('%s Template "%s" does not exist' %
                                   (template_name, time_now))

            # unsubscribe link in %(unsubscribe_link)s
            messages.append(t.render(c))

        try:
            # recipient_list = Subscribe.objects.filter(activity=True, site=settings.SITE_ID).values_list('email', flat=True).order_by('?')
            recipient_list = Subscribe.objects.filter(
                activity=True).values_list('email', flat=True).order_by('?')
        except Subscribe.DoesNotExist:
            raise CommandError('%s Subscribes does not exist' % time_now)

        def gen_emails():
            for email in recipient_list:
                token = base64.encodestring(
                    hmac.new(settings.SECRET_KEY, email,
                             sha1).digest()).rstrip()
                unsubscribe_link = '%s%s?t=%s&e=%s&d=1' % (
                    domain, reverse('subscribes-index'), token, email)
                c = Context({'unsubscribe_link': unsubscribe_link})
                t = Template(messages[0])
                text_message = t.render(c)
                t = Template(messages[1])
                html_message = t.render(c)
                msg = mail.EmailMultiAlternatives(subject, text_message,
                                                  from_email, [email])
                msg.attach_alternative(html_message, 'text/html')
                yield msg

        connection = mail.get_connection(fail_silently=True)

        try:
            connection.send_messages(gen_emails())
        except SMTPException:
            raise

        output.append('%s Successfully sends mails to subscribes\n' % time_now)
        return '\n'.join(output)
コード例 #43
0
def send_now(users, label, extra_context=None, on_site=True, *args, **kwargs):
    """
    Creates a new notice.

    This is intended to be how other apps create new notices.

    notification.send(user, 'friends_invite_sent', {
        'spam': 'eggs',
        'foo': 'bar',
    )

    You can pass in on_site=False to prevent the notice emitted from being
    displayed on the site.
    """

    send = kwargs.get('send', False)

    if extra_context is None:
        extra_context = {}

    try:
        notice_type = NoticeType.objects.get(label=label)
    except (NoticeType.DoesNotExist, NoticeType.MultipleObjectsReturned):
        notice_type = None

    if notice_type:

        protocol = getattr(settings, "DEFAULT_HTTP_PROTOCOL", "http")
        current_site = Site.objects.get_current()

        notices_url = u"%s://%s%s" % (
            protocol,
            unicode(current_site),
            reverse("notification_notices"),
        )

        current_language = get_language()

        formats = (
            'full.html',
            'short.txt',
            'notice.html',
        )  # TODO make formats configurable

        for user in users:
            recipients = []
            headers = {}
            # get user language for user from language store defined in
            # NOTIFICATION_LANGUAGE_MODULE setting
            try:
                language = get_notification_language(user)
            except LanguageStoreNotAvailable:
                language = None

            if language is not None:
                # activate the user's language
                activate(language)

            # test for request in the extra_context
            if 'request' in extra_context.keys():
                context = RequestContext(extra_context['request'])
                extra_context.update({
                    "user": user,
                    "notice": ugettext(notice_type.display),
                    "notices_url": notices_url,
                    "current_site": current_site,
                })
                context.update(extra_context)
            else:
                # update context with user specific translations
                context = Context({
                    "user": user,
                    "notice": ugettext(notice_type.display),
                    "notices_url": notices_url,
                    "current_site": current_site,
                })
                context.update(extra_context)

            # get prerendered format messages
            messages = get_formatted_messages(formats, label, context)

            # Strip newlines from subject
            subject = ''.join(
                render_to_string('notification/email_subject.txt', {
                    'message': messages['short'][0],
                }, context).splitlines())

            body = render_to_string('notification/email_body.txt', {
                'message': messages['full'][0],
            }, context)

            Notice.objects.create(user=user,
                                  message=messages['notice'][0],
                                  notice_type=notice_type,
                                  on_site=on_site)
            if should_send(user, notice_type, "1",
                           send=send) and user.email:  # Email
                recipients.append(user.email)

            if messages['full'][1] == '.html':
                # headers = {'Content-Type': 'text/html'}
                content_type = 'html'
            else:
                # headers = {'Content-Type': 'text/plain'}
                content_type = 'text'

            email = EmailMessage(subject,
                                 body,
                                 settings.DEFAULT_FROM_EMAIL,
                                 recipients,
                                 headers=headers)
            email.content_subtype = content_type
            email.send()

        # reset environment to original language
        activate(current_language)
コード例 #44
0
ファイル: promotions.py プロジェクト: dahabit/django-oscar
 def render(self, context):
     linked_block = self.linked_block.resolve(context)
     template = select_template([linked_block.block.template_file, 'oscar/promotions/block_default.html'])
     args = dict(block=linked_block.block, **linked_block.block.template_context())
     context = Context(args)
     return template.render(context)
コード例 #45
0
def Promillekalkulator(request, promilleFOER, antallTIMER, vekt, kjoenn,
                       alk_type, enhet_stoer, antall):

    # Alkoholinnhold i valgt drikkevare

    if alk_type == 'øl':
        volpros = 0.047
    elif alk_type == 'hvitvin':
        volpros = 0.11
    elif alk_type == 'rødvin':
        volpros = 0.13
    elif alk_type == 'vodka':
        volpros = 0.40
    elif alk_type == 'niseks':
        volpros == 0.96
    else:
        FEIL_INPUT_ALKOHOLTYPE = '"%s" er ikke en gyldig drikkevare. Du er nødt til å velge en av drikkevarene ramset opp under innskrivingsfeltet. Gå tilbake og fyll inn på nytt.' % alk_type
        return HttpResponse(FEIL_INPUT_ALKOHOLTYPE)

    # Konstant for gutt/jente

    if kjoenn == 'babe':
        GJ_konst = 0.69
    elif kjoenn == 'kar':
        GJ_konst = 0.805
    else:
        FEIL_INPUT_KJOENN = 'Du skrev "%s" i feltet for kjønn. Du må skrive enten "babe" eller "kar".' % kjoenn
        return HttpResponse(FEIL_INPUT_KJOENN)

    # Alkoholinntak i gram

    Massetetthet_ETANOL = 791

    Inntak = volpros * enhet_stoer * antall * Massetetthet_ETANOL

    # Promille

    Promille = Inntak / (vekt * GJ_konst) + promilleFOER - 0.15 * antallTIMER

    Promille = round(Promille, 2)

    if Promille < 0:
        Promille = 0

    if Promille > 4:
        DAU = True
    else:
        DAU = False

    c = Context({
        'prom': promilleFOER,
        'prom2': Promille,
        'timer': antallTIMER,
        'dodelig': DAU,
        'kjoen': kjoenn,
        'alk_type': alk_type,
        'enhet_stoer': enhet_stoer,
        'antall': antall
    })

    return render(request, 'TEM_resultat_promille.html', c)
コード例 #46
0
def action(request, app, cls, action_name, pk=None):

    try:
        _model = apps.get_model(app, cls)
    except LookupError as e:
        return page_not_found(request, e, 'error404.html')

    for group in loader.instance_actions[_model]:
        if action_name in loader.instance_actions[_model][group]:
            break

    form_action = loader.instance_actions[_model][group][action_name]
    action_verbose_name = form_action['verbose_name']
    action_can_execute = form_action['can_execute']
    action_condition = form_action['condition']
    action_function = form_action['function']
    action_message = 'message' in form_action and form_action['message'] or None
    action_permission = '{}.{}'.format(_model._meta.app_label,
                                       action_function.__name__)
    action_input = form_action['input']
    action_display = form_action['display']
    action_style = form_action['style']
    action_redirect = form_action['redirect_to']

    obj = pk and _model.objects.all(
        request.user).distinct().get(pk=pk) or _model()
    obj.request = request
    obj._user = request.user
    title = action_verbose_name
    redirect_to = None

    if check_condition(request.user, action_condition,
                       obj) and (not action_can_execute
                                 or permissions.check_group_or_permission(
                                     request, action_permission)):
        f_return = None
        func = getattr(_model, action_function.__name__, action_function)
        form = factory.get_action_form(request, obj, form_action)
        if count_parameters_names(func) > 1 or action_input:
            if form.is_valid():
                if 'instance' in form.fields:
                    obj = form.cleaned_data['instance']
                func = getattr(obj, action_function.__name__, action_function)
                params = []
                for param in get_parameters_names(func,
                                                  include_annotated=True):
                    if param in form.cleaned_data:
                        params.append(form.cleaned_data[param])
                    else:
                        params.append(
                            get_role_value_for_action(func, request.user,
                                                      param))
                try:
                    f_return = func(*params)
                    if not action_redirect:
                        if count_parameters_names(func) > 0 or action_display:
                            redirect_to = '..'
                        else:
                            redirect_to = '.'
                    else:
                        redirect_to = Template(action_redirect).render(
                            Context({'self': obj}))
                except ValidationError as e:
                    form.add_error(None, str(e.message))
        else:
            try:
                if form.fields and form.is_valid() or not form.fields:
                    if 'instance' in form.fields:
                        obj = form.cleaned_data['instance']
                    func = getattr(obj, action_function.__name__,
                                   action_function)
                    params = []
                    for param in get_parameters_names(func,
                                                      include_annotated=True):
                        params.append(
                            get_role_value_for_action(func, request.user,
                                                      param))
                    f_return = func(*params)
                    if not action_redirect:
                        if count_parameters_names(func) > 0 or action_display:
                            redirect_to = '..'
                        else:
                            redirect_to = '.'
                    else:
                        redirect_to = Template(action_redirect).render(
                            Context({'self': obj}))
            except ValidationError as e:
                if form.fields:
                    form.add_error(None, str(e.message))
                return httprr(request, '.', e.message, error=True)

        if f_return:
            template_name = '{}.html'.format(action_function.__name__)
            return return_response(f_return, request, title, action_style,
                                   template_name)

        elif redirect_to:
            return httprr(request, redirect_to, action_message)

        if form.title == _('Form'):
            form.title = action_verbose_name
        if form.submit_label == _('Send'):
            form.submit_label = action_verbose_name
        return render(request, 'default.html', locals())
    else:
        return HttpResponseForbidden()
コード例 #47
0
    def test_english(self):
        result = self.TEMPLATE.render(Context({
            'request': Mock(LANGUAGE_CODE='en'),
        }))

        assert result.strip() == ''
コード例 #48
0
def send_emails(emails, label, extra_context=None, on_site=True):
    """
    This method accepts a list of email addresses
    as opposed to a list of users. This is a custom method
    as opposed to send(), send_now(), and queue()

    Just send the notice to a list of emails immediately.
    No new notice created here
    notification.send_emails(email_list, 'friends_invite_sent', {
        'spam': 'eggs',
        'foo': 'bar',
    )
    """
    if extra_context is None:
        extra_context = {}

    try:
        notice_type = NoticeType.objects.get(label=label)
    except:
        # Stop here because we need a notice_type
        return None

    headers = {}
    protocol = getattr(settings, "DEFAULT_HTTP_PROTOCOL", "http")
    current_site = Site.objects.get_current()

    notices_url = u"%s://%s%s" % (
        protocol,
        unicode(current_site),
        reverse("notification_notices"),
    )

    formats = (
        'full.html',
        'short.txt',
        'notice.html',
    )  # TODO make formats configurable

    # test for request in the extra_context
    if 'request' in extra_context.keys():
        context = RequestContext(extra_context['request'])
        extra_context.update({
            "notice": ugettext(notice_type.display),
            "notices_url": notices_url,
            "current_site": current_site,
        })
        context.update(extra_context)
    else:
        # update context with user specific translations
        context = Context({
            "notice": ugettext(notice_type.display),
            "notices_url": notices_url,
            "current_site": current_site,
        })
        context.update(extra_context)

    # get prerendered format messages
    messages = get_formatted_messages(formats, label, context)

    if 'admin' in label:
        subject = messages['short']
        body = messages['full']

    else:
        subject = render_to_string('notification/email_subject.txt',
                                   {'message': mark_safe(messages['short'])},
                                   context)

        body = render_to_string('notification/email_body.txt',
                                {'message': mark_safe(messages['full'])},
                                context)

    if 'reply_to' in extra_context.keys():
        reply_to = extra_context['reply_to']
        headers['Reply-To'] = reply_to
    else:
        reply_to = ''

    sender = extra_context.get('sender', '')
    if not sender:
        sender = get_setting(
            'site', 'global',
            'siteemailnoreplyaddress') or settings.DEFAULT_FROM_EMAIL
        if not sender:
            sender = settings.DEFAULT_FROM_EMAIL

    sender_display = extra_context.get('sender_display', '')
    # Add quotes around display name to prevent errors on sending
    # when display name contains comma or other control characters, - jennyq
    from_display = '"%s"<%s>' % (sender_display, sender)

    if sender_display:
        headers['From'] = from_display

    recipient_bcc = extra_context.get('recipient_bcc') or []
    content_type = 'html'

    # removing newlines
    subject = ''.join(subject.splitlines())

    for email_addr in emails:
        recipients = [email_addr]

        if recipient_bcc:
            email = EmailMessage(subject,
                                 body,
                                 sender,
                                 recipients,
                                 recipient_bcc,
                                 headers=headers)
        else:
            email = EmailMessage(subject,
                                 body,
                                 sender,
                                 recipients,
                                 headers=headers)
        email.content_subtype = content_type

        try:
            email.send(fail_silently=True)  # should we raise exception or not?
        except UnicodeError:
            pass

    to = ','.join(emails)
    bcc = ','.join(recipient_bcc)
    reply_to = reply_to or unicode()

    NoticeEmail.objects.create(emails=to,
                               sender=sender,
                               bcc=bcc,
                               title=subject,
                               content=body,
                               reply_to=reply_to,
                               from_display=from_display,
                               notice_type=notice_type)
コード例 #49
0
ファイル: views.py プロジェクト: anchun570/Mydocker
def inspect_container(request, id, template_name):
    res=json.loads(docker_api_get('/containers/%s/json' % id))
    t = loader.get_template(template_name)
    c = Context({'inspect_data':res, 'request':request, 'active':"yes"})
    return HttpResponse(t.render(c))
コード例 #50
0
    def test_no_lang(self):
        result = self.TEMPLATE.render(Context({
            'request': Mock(),
        }))

        assert result.strip() == ''
コード例 #51
0
 def test_textarea(self):
     rendered = self.template.render(Context({}))
     self.assertIn('ng-model="bai"', rendered)
     self.assertIn('hai', rendered)
コード例 #52
0
ファイル: views.py プロジェクト: m4xd34th/django-new-marana
 def list_to_html_response(self, data, title='', header=None):
     html = Engine().from_string(HTML_TEMPLATE).render(Context(locals()))
     return HttpResponse(html)
コード例 #53
0
 def test_form_some_random_user_string_482(self):
     # Regression test for https://github.com/opal/issues/482
     tpl = Template(
         '{% load forms %}{% icon "this-is-my-icon-shut-up-opal" %}')
     self.assertIn('<i class="this-is-my-icon-shut-up-opal"></i>',
                   tpl.render(Context({})))
コード例 #54
0
ファイル: views.py プロジェクト: anchun570/Mydocker
def images_list(request, template_name):
    res=json.loads(docker_api_get('/images/json'))
    t = loader.get_template(template_name)
    c = Context({'containers_list':res, 'request':request})
    return HttpResponse(t.render(c))
コード例 #55
0
 def test_fa_icon(self):
     tpl = Template('{% load forms %}{% icon "fa-eye" %}')
     self.assertIn('<i class="fa fa-eye"></i>', tpl.render(Context({})))
コード例 #56
0
 def test_render(self):
     tpl = Template('{% load forms %}{% date_of_birth_field %}')
     rendered = tpl.render(Context({}))
     self.assertIn("editing.demographics.date_of_birth", rendered)
コード例 #57
0
 def test_static(self):
     tpl = Template('{% load forms %}{% static "DogOwner.name" %}')
     rendered = tpl.render(Context({}))
     self.assertIn('editing.dog_owner.name', rendered)
コード例 #58
0
 def test_glyph_icon(self):
     tpl = Template('{% load forms %}{% icon "glyphicon-boat" %}')
     self.assertIn('<i class="glyphicon glyphicon-boat"></i>',
                   tpl.render(Context({})))
コード例 #59
0
 def test_change(self):
     tpl = Template(
         '{% load forms %}{% select label="hai" change="doStuff" model="bai" element_name="onions"%}'
     )
     rendered = tpl.render(Context({}))
     self.assertIn('ng-change="doStuff"', rendered)
コード例 #60
0
 def test_date(self):
     tpl = Template(
         '{% load forms %}{% static "Demographics.date_of_birth" %}')
     rendered = tpl.render(Context({}))
     self.assertIn('editing.demographics.date_of_birth', rendered)
     self.assertIn('shortDate', rendered)