python类Context()的实例源码

def gen_sudo_script(role_list, sudo_list):
        # receive role_list = [role1, role2] sudo_list = [sudo1, sudo2]
        # return sudo_alias={'NETWORK': '/sbin/ifconfig, /ls'} sudo_user={'user1': ['NETWORK', 'SYSTEM']}
        sudo_alias = {}
        sudo_user = {}
        for sudo in sudo_list:
            sudo_alias[sudo.name] = sudo.commands

        for role in role_list:
            sudo_user[role.name] = ','.join(sudo_alias.keys())

        sudo_j2 = get_template('jperm/role_sudo.j2')
        sudo_content = sudo_j2.render(Context({"sudo_alias": sudo_alias, "sudo_user": sudo_user}))
        sudo_file = NamedTemporaryFile(delete=False)
        sudo_file.write(sudo_content)
        sudo_file.close()
        return sudo_file.name

def build_messages(self, data):
        """
        Build email and SMS messages using the custom templates and webhook 
        data.
        """

        messages = {}

        if self.text_message:
            messages['text'] = Template(self.text_message).render(Context(data))

        if self.html_message:
            messages['html'] = Template(self.html_message).render(Context(data))

        if self.sms_message:
            messages['sms'] = Template(self.sms_message).render(Context(data))

        return messages

def scheduleSandboxDeployment(request, sbr):
    """
    Given a newly created sandbox request, schedule the deployment with the backend. This
    will also handle any quota checking, notifications, and environment specific prep.
    """
    if sbr.sandbox.playground.environment == 'locl':
        # local deploy, no formal request
        sbr.request_status = 'avl'
        sbr.save()
    else:
        # environment deploy, let's kick it to the admins
        sandbox_request_uri = request.build_absolute_uri(reverse('admin:cocreate_sandboxrequest_change', args=(sbr.id,)))
        mail_admins(
            "Sandbox Request for Review",
            "There's a new request for review at " + sandbox_request_uri,
            html_message = get_template("sandboxRequestToAdmins.html").render(Context({"sandbox_request_uri": sandbox_request_uri}))
        )

def instructions(request):
    if request.user.is_authenticated() and request.user.is_turker:

         # Has the user passed the initial test yet?
        if len(QuizHistory.objects.filter(user=request.user,correct=True)) == 0:
            return HttpResponseRedirect("/webapp/rules")

        record = InstructionView()
        record.user = request.user
        record.date_time = timezone.now()
        record.save()

        return render(request,"turk_instructions_2.html", Context(_getPaymentContext()))

    record = InstructionView()
    record.user = request.user
    record.date_time = timezone.now()
    record.save()
    return render(request, "turk_instructions_2.html")

def orchidExistingPlayer(request):
    if request.user.is_authenticated():
        logout(request)

    users = EVUser.objects.filter(experiment__experiment_name=ORCHID_SHOWCASE)

    if request.method == "GET":

        users = sorted(users,key=lambda user:user.username)

        return render(request,"orchid_existing_player.html", Context({"users" : users}))

    else:

        if "user" in request.POST:
            username = request.POST["user"]
            try:
                user = authenticate(username=username,password=ORCHID_PASSWORD)
                login(request, user)
                return HttpResponseRedirect ("/webapp/home/")
            except:
                return render(request,"orchid_existing_player.html", Context({"users" : users,"error_message" : "Something went wrong. Try again."}))
        else:
            return render(request,"orchid_existing_player.html", Context({"users" : users,"error_message" : "Please select a user."}))

def orchidNewGame(request):


        previousBest = request.user.best_monthly_score
        profit = request.user.balance - request.user.treatment.user_initial_balance

        game = request.user.current_day / request.user.treatment.getNumberOfDays()

        if profit > previousBest or game == 1:
            request.user.best_monthly_score = profit
            c = Context({"new_best" : profit, "game":game })
        else:
            c = Context({"old_best" : previousBest,"profit" : profit, "game":game })

        request.user.energy_units = request.user.treatment.user_initial_energy_units
        request.user.balance = request.user.treatment.user_initial_balance
        request.user.save()

        return render(request, "reset_page_orchid.html",c)

def template_render(template, context=None, request=None):
    """
    Passing Context or RequestContext to Template.render is deprecated in 1.9+,
    see https://github.com/django/django/pull/3883 and
    https://github.com/django/django/blob/1.9/django/template/backends/django.py#L82-L84

    :param template: Template instance
    :param context: dict
    :param request: Request instance
    :return: rendered template as SafeText instance
    """
    if isinstance(template, Template):
        if request:
            context = RequestContext(request, context)
        else:
            context = Context(context)
        return template.render(context)
    # backends template, e.g. django.template.backends.django.Template
    else:
        return template.render(context, request=request)

def page_not_found(request, template_name='404.html'):
    context = {
        'request_path': request.path,
        'error': {
            'title': _('Page not found'),
            'message': _("We tried but couldn't find this page, sorry."),
        },
    }

    try:
        template = loader.get_template(template_name)
        body = template.render(context, request)
        content_type = None

    except TemplateDoesNotExist:
        template = Engine().from_string(
            '<h1>Not Found</h1>'
            '<p>The requested URL {{ request_path }} was not found on this server.</p>')
        body = template.render(Context(context))
        content_type = 'text/html'

    return HttpResponseNotFound(body, content_type=content_type)

def inclusion_tag(file_name, context_class=Context, takes_context=False):
    def wrap(func):
        @functools.wraps(func)
        def method(self, context, nodes, *arg, **kwargs):
            _dict = func(self, context, nodes, *arg, **kwargs)
            from django.template.loader import get_template, select_template
            if isinstance(file_name, Template):
                t = file_name
            elif not isinstance(file_name, basestring) and is_iterable(file_name):
                t = select_template(file_name)
            else:
                t = get_template(file_name)

            _dict['autoescape'] = context.autoescape
            _dict['use_l10n'] = context.use_l10n
            _dict['use_tz'] = context.use_tz
            _dict['admin_view'] = context['admin_view']

            csrf_token = context.get('csrf_token', None)
            if csrf_token is not None:
                _dict['csrf_token'] = csrf_token
            nodes.append(t.render(_dict))

        return method
    return wrap

def get(self, request, object_id):
        model_fields = [f.name for f in self.opts.fields]
        fields = [f for f in request.GET['fields'].split(',') if f in model_fields]
        defaults = {
            "form": self.form,
            "fields": fields,
            "formfield_callback": self.formfield_for_dbfield,
        }
        form_class = modelform_factory(self.model, **defaults)
        form = form_class(instance=self.org_obj)

        helper = FormHelper()
        helper.form_tag = False
        helper.include_media = False
        form.helper = helper

        s = '{% load i18n crispy_forms_tags %}<form method="post" action="{{action_url}}">{% crispy form %}' + \
            '<button type="submit" class="btn btn-success btn-block btn-sm">{% trans "Apply" %}</button></form>'
        t = template.Template(s)
        c = template.Context({'form': form, 'action_url': self.model_admin_url('patch', self.org_obj.pk)})

        return HttpResponse(t.render(c))

def render(self, name, value, attrs=None):
        if value is None:
            value = ""
        if VERSION < (1, 11):
            final_attrs = self.build_attrs(attrs, name=name)
        else:
            final_attrs = self.build_attrs(attrs, {'name': name})

        if "class" not in final_attrs:
            final_attrs["class"] = ""
        final_attrs["class"] += " wmd-input"
        template = loader.get_template(self.template)

        # Compatibility fix:
        # see https://github.com/timmyomahony/django-pagedown/issues/42
        context = {
            "attrs": flatatt(final_attrs),
            "body": conditional_escape(force_unicode(value)),
            "id": final_attrs["id"],
            "show_preview": self.show_preview,
        }
        context = Context(context) if VERSION < (1, 9) else context
        return template.render(context)

def get_context_data(self,**kwargs):
        context = super(GiftCertificatePDFView,self).get_context_data(**kwargs)

        template = getConstant('vouchers__giftCertPDFTemplate')

        # For security reasons, the following tags are removed from the template before parsing:
        # {% extends %}{% load %}{% debug %}{% include %}{% ssi %}
        content = re.sub('\{%\s*((extends)|(load)|(debug)|(include)|(ssi))\s+.*?\s*%\}','',template.content)

        t = Template(content)

        rendered_content = t.render(Context(context))

        context.update({
            'header': template.subject,
            'content': rendered_content
        })

        return context

def template_render(template, context=None, request=None):
    """
    Passing Context or RequestContext to Template.render is deprecated in 1.9+,
    see https://github.com/django/django/pull/3883 and
    https://github.com/django/django/blob/1.9rc1/django/template/backends/django.py#L82-L84

    :param template: Template instance
    :param context: dict
    :param request: Request instance
    :return: rendered template as SafeText instance
    """
    if django.VERSION < (1, 8) or isinstance(template, Template):
        if request:
            context = RequestContext(request, context)
        else:
            context = Context(context)
        return template.render(context)
    # backends template, e.g. django.template.backends.django.Template
    else:
        return template.render(context, request=request)

def gen_sudo_script(role_list, sudo_list):
        # receive role_list = [role1, role2] sudo_list = [sudo1, sudo2]
        # return sudo_alias={'NETWORK': '/sbin/ifconfig, /ls'} sudo_user={'user1': ['NETWORK', 'SYSTEM']}
        sudo_alias = {}
        sudo_user = {}
        for sudo in sudo_list:
            sudo_alias[sudo.name] = sudo.commands

        for role in role_list:
            sudo_user[role.name] = ','.join(sudo_alias.keys())

        sudo_j2 = get_template('jperm/role_sudo.j2')
        sudo_content = sudo_j2.render(Context({"sudo_alias": sudo_alias, "sudo_user": sudo_user}))
        sudo_file = NamedTemporaryFile(delete=False)
        sudo_file.write(sudo_content)
        sudo_file.close()
        return sudo_file.name

def get_dynamic_desc(self, language):
        if language == "en":
            template = Template(self.description_en)
        else:
            template = Template(self.description_de)
        context = Context({
            "advisor": self.advisor,
            "afterparty_location": self.afterparty_time,
            "afterparty_time": self.afterparty_time,
            "appetizer_time": self.appetizer_time,
            "event_date": self.date,
            "dessert_time": self.dessert_time,
            "end_registration": self.end_registration,
            "event_name": self.name,
            "event_semester": self.semester,
            "main_course_time": self.main_course_time,
        })
        dyn_desc = template.render(context)
        return dyn_desc

def site_email(to, template, context, subject):
    template = template
    subject = subject
    to = to
    from_email = settings.SENDER_EMAIL
    #context = Context(context)

    html_message = get_template('emails/' + template + '.html').render(context)
    message = strip_tags(html_message)

    send_mail(
        subject=subject,
        message=message,
        from_email=from_email,
        recipient_list=to,
        html_message=html_message
    )

def render_string(self, template_name, **kwargs):
        #template_path = self.get_template_path()
        #if not template_path:
            #frame = sys._getframe(0)
            #web_file = frame.f_code.co_filename
            #while frame.f_code.co_filename == web_file:
                #frame = frame.f_back
            #template_path = os.path.dirname(frame.f_code.co_filename)
        #with RequestHandler._template_loader_lock:
            #if template_path not in RequestHandler._template_loaders:
                #loader = self.create_template_loader(template_path)
                #RequestHandler._template_loaders[template_path] = loader
            #else:
                #loader = RequestHandler._template_loaders[template_path]
        #t = loader.load(template_name)
        #namespace = self.get_template_namespace()
        #namespace.update(kwargs)
        #return t.generate(**namespace)
        with io.open(template_name, mode='r',encoding='UTF-8') as f:
            html = f.read()
        template_strings = Template(html)
        return template_strings.render(context=Context(dict_=kwargs))

def create_from_inquiry(self, inquiry, recipient, data):
        exists = InquiryRequest.objects.filter(inquiry=inquiry,
                                               recipient=recipient).exists()
        if exists:
            return

        slug = self.get_random_unique_slug()
        ir = InquiryRequest(
            slug=slug,
            inquiry=inquiry,
            recipient=recipient,
        )
        template = inquiry.template
        context = self.make_context(ir, template, data)
        template_context = Context(context)
        ir.from_email = template.get_from_email(template_context)
        ir.subject = template.get_subject(template_context)
        ir.body = template.get_body(template_context)
        ir.intro = template.get_intro(template_context)
        ir.context = context
        ir.save()
        return ir

def page_not_found(request, template_name='404.html'):
    context = {
        'request_path': request.path,
        'error': {
            'title': _('Page not found'),
            'message': _("We tried but couldn't find this page, sorry."),
        },
    }

    try:
        template = loader.get_template(template_name)
        body = template.render(context, request)
        content_type = None

    except TemplateDoesNotExist:
        template = Engine().from_string(
            '<h1>Not Found</h1>'
            '<p>The requested URL {{ request_path }} was not found on this server.</p>')
        body = template.render(Context(context))
        content_type = 'text/html'

    return HttpResponseNotFound(body, content_type=content_type)