def get(self, request): site = GetSite() template_values = {} template_values['site'] = site method_determined = False topic_id = self.request.get('topic_id') page = self.request.get('page', 1) page_size = TOPIC_PAGE_SIZE if topic_id: page_start = (int(page) - 1) * page_size replies = db.GqlQuery("SELECT * FROM Reply WHERE topic_num = :1 ORDER BY created ASC LIMIT " + str(page_start) + "," + str(page_size), int(topic_id)) replies = Reply.objects.filter(topic_num = int(topic_id)).order_by('created').all()[page_start:page_start+page_size] if replies: path = 'api/replies_show.json' template_values['replies'] = replies output = template.render(path, template_values) self.write(output) else: template_values['message'] = "Failed to get replies" path = 'api/error.json' output = template.render(path, template_values) self.response.set_status(400, 'Bad Request') self.write(output) else: template_values['message'] = "Required parameter topic_id is missing" path = 'api/error.json' output = template.render(path, template_values) self.response.set_status(400, 'Bad Request') self.write(output)
def get(self, request): site = GetSite() template_values = {} template_values['site'] = site username = self.request.get('username') if username: one = GetMemberByUsername(username) if one is not False: if one.avatar_mini_url: if (one.avatar_mini_url[0:1] == '/'): one.avatar_mini_url = 'http://' + site.domain + one.avatar_mini_url one.avatar_normal_url = 'http://' + site.domain + one.avatar_normal_url one.avatar_large_url = 'http://' + site.domain + one.avatar_large_url template_values['member'] = one path = 'api/members_show.json' output = template.render(path, template_values) self.write(output) else: template_values['message'] = "Member not found" path = 'api/error.json' output = template.render(path, template_values) self.response.set_status(400, 'Bad Request') self.write(output) else: template_values['message'] = "Required parameter username is missing" path = 'api/error.json' output = template.render(path, template_values) self.response.set_status(400, 'Bad Request') self.write(output)
def format_value(value): if getattr(value, 'is_hyperlink', False): name = six.text_type(value.obj) return mark_safe('<a href=%s>%s</a>' % (value, escape(name))) if value is None or isinstance(value, bool): return mark_safe('<code>%s</code>' % {True: 'true', False: 'false', None: 'null'}[value]) elif isinstance(value, list): if any([isinstance(item, (list, dict)) for item in value]): template = loader.get_template('rest_framework/admin/list_value.html') else: template = loader.get_template('rest_framework/admin/simple_list_value.html') context = {'value': value} return template.render(context) elif isinstance(value, dict): template = loader.get_template('rest_framework/admin/dict_value.html') context = {'value': value} return template.render(context) elif isinstance(value, six.string_types): if ( (value.startswith('http:') or value.startswith('https:')) and not re.search(r'\s', value) ): return mark_safe('<a href="{value}">{value}</a>'.format(value=escape(value))) elif '@' in value and not re.search(r'\s', value): return mark_safe('<a href="mailto:{value}">{value}</a>'.format(value=escape(value))) elif '\n' in value: return mark_safe('<pre>%s</pre>' % escape(value)) return six.text_type(value)
def dashboard(request): context = RequestContext(request) if not request.user.is_authenticated(): template = get_template('login.html') return HttpResponse(template.render(context)) context["user"] = request.user try: submission = Submission.objects.get(pk=request.user.id) except: submission = Submission(user=request.user) submission.save() if request.user.is_staff: template = get_template('staff_dashboard.html') return HttpResponse(template.render(context)) else: if request.method == 'POST': # form = SubmissionForm(request.POST, request.FILES) if all((x in request.FILES for x in ['app_form', 'app_info', 'con_form'])): newdoc = Version( application_form=request.FILES['app_form'], applicant_info=request.FILES['app_info'], consent_form=request.FILES['con_form'], submission=submission) newdoc.save() versions = Version.objects.filter(submission=submission) context["versions"] = versions context["submission"] = submission template = get_template('dashboard.html') return HttpResponse(template.render(context))
def render_(self, tpl_new, context): template = deepcopy(self.template) # Do not mess with global template for threadsafety. template.var = tpl_new # Cheat a little # Below is implementation from Django 2.1 generic IncludeNode. template = template.resolve(context) # Does this quack like a Template? if not callable(getattr(template, 'render', None)): # If not, try the cache and get_template(). template_name = template cache = context.render_context.dicts[0].setdefault(self, {}) template = cache.get(template_name) if template is None: template = context.template.engine.get_template(template_name) cache[template_name] = template # Use the base.Template of a backends.django.Template. elif hasattr(template, 'template'): template = template.template values = { name: var.resolve(context) for name, var in self.extra_context.items() } if self.isolated_context: return template.render(context.new(values)) with context.push(**values): return template.render(context)
def get(self, request): site = GetSite() template_values = {} template_values['site'] = site method_determined = False parameter_id = self.request.get('id') if parameter_id: method_determined = True if method_determined is not True: parameter_name = self.request.get('name') if parameter_name: method_determined = True if method_determined is True: if parameter_id: node = GetKindByNum('Node', int(parameter_id)) else: node = GetKindByName('Node', str(parameter_name)) if node is not False: template_values['node'] = node path = 'api/nodes_show.json' output = template.render(path, template_values) self.write(output) else: template_values['message'] = 'Node not found' path = 'api/error.json' output = template.render(path, template_values) self.write(output) else: template_values['message'] = "Required parameter id or name is missing" path = 'api/error.json' output = template.render(path, template_values) self.write(output)
def as_html(invoice): template = loader.get_template('invoicing/formatters/html.html') formatter = HTMLFormatter(invoice) data = formatter.get_data() try: return template.render(Context(data)) except TypeError: return template.render(data)
def render(self,ctx): attrs = {} if hasattr(settings,'BOOTSTRAP_HELP_BLOCK') and settings.BOOTSTRAP_HELP_BLOCK: help_inline = False else: help_inline = True if 'span' in self.kwargs: attrs['class'] = Field.SPAN % self.kwargs['span'].resolve(ctx) if 'label' in self.kwargs: label = self.kwargs['label'].resolve(ctx) else: label = None if len(self.args) > 1: template = get_template(TEMPLATE_PREFIX % "inline_field.html") contexts = tuple() for field in [f.resolve(ctx) for f in self.args]: if isinstance(field,BoundField): contexts = contexts + (_bound_field_context(field,widget_attrs=attrs.copy()),) else: contexts = contexts + (field,) help = _merge_field(contexts,'help_text') errors = _merge_field(contexts,'errors') return template.render(Context({'fields' : contexts, 'label' : label, 'help' : help, 'errors' : errors, 'help_inline': help_inline})) else: if 'prepend' in self.kwargs or 'append' in self.kwargs: if 'prepend' in self.kwargs: template = get_template(TEMPLATE_PREFIX % "addon_field_prepend.html") else: template = get_template(TEMPLATE_PREFIX % "addon_field_append.html") addon = self.kwargs.get('prepend',self.kwargs.get('append')) addon = addon.resolve(ctx) context = {'help_inline': help_inline} context['field'] = _bound_field_context(self.args[0].resolve(ctx),widget_attrs=attrs.copy()) if isinstance(addon,BoundField): context['addon'] = _bound_field_context(addon) else: context['addon'] = addon context['help'] = _merge_field([context['field'],context['addon']],'help_text') context['errors'] = _merge_field([context['field'],context['addon']],'errors') return template.render(Context(context)) else: template = get_template(TEMPLATE_PREFIX % "field.html") context = _bound_field_context(self.args[0].resolve(ctx),widget_attrs=attrs.copy()) context['help_inline'] = help_inline return template.render(Context(context))
def dashboard(request): context = RequestContext(request) if not request.user.is_authenticated(): template = get_template('login.html') return HttpResponse(template.render(context)) template = get_template('dashboard.html') return HttpResponse(template.render(context))
def test_compile_filter(monkeypatch): compile_static = pretend.call_recorder(lambda source_path: "compiled") monkeypatch.setattr("static_precompiler.utils.compile_static", compile_static) template = django.template.Template("""{% load compile_static %}{{ "source"|compile }}""") assert template.render(django.template.Context({})) == "compiled" monkeypatch.setattr("static_precompiler.settings.PREPEND_STATIC_URL", True) assert template.render(django.template.Context({})) == "/static/compiled" assert compile_static.calls == [pretend.call("source"), pretend.call("source")]
def render(self, context): table = self.table.resolve(context) if isinstance(table, tables.Table): pass elif hasattr(table, "model"): queryset = table # We've been given a queryset, create a table using its model and # render that. class OnTheFlyTable(tables.Table): class Meta: model = queryset.model attrs = {"class": "paleblue"} table = OnTheFlyTable(queryset) request = context.get('request') if request: RequestConfig(request).configure(table) else: raise ValueError("Expected table or queryset, not '%s'." % type(table).__name__) if self.template: template = self.template.resolve(context) else: template = table.template if isinstance(template, six.string_types): template = get_template(template) else: # assume some iterable was given template = select_template(template) # Contexts are basically a `MergeDict`, when you `update()`, it # internally just adds a dict to the list to attempt lookups from. This # is why we're able to `pop()` later. context.update({"table": table}) try: # HACK: # TemplateColumn benefits from being able to use the context # that the table is rendered in. The current way this is # achieved is to temporarily attach the context to the table, # which TemplateColumn then looks for and uses. table.context = context if VERSION < (1, 8): # pragma: nocover # TODO: remove after 1.7 support ends. return template.render(context) else: return template.render(context.flatten()) finally: del table.context context.pop()
def form_input(request): if request.method == 'GET': form = mainapp.forms.EndsForm() template = django.template.loader.get_template('mainapp/form_input.html') context = django.template.RequestContext(request, {'form': form,}) return django.http.HttpResponse(template.render(context)) if request.method == 'POST': form = mainapp.forms.EndsForm() template = django.template.loader.get_template('mainapp/form_input.html') context = django.template.RequestContext(request, {'form': form,}) return django.http.HttpResponse(template.render(context))
def render_tag(self, context, template_name, form=None, layout=None): template = get_template(template_name) if form is None: form = context['form'] if layout is None: if 'view' in context: view = context['view'] if hasattr(view, 'layout'): layout = view.layout if layout is None: if hasattr(form, 'layout'): layout = form.layout parts = defaultdict(dict) # part -> section -> value context.push() try: context['form'] = form context['layout'] = layout context['_viewform_template_pack'] = os.path.dirname(template_name) context['_viewform_parts'] = parts children = (node for node in self.nodelist if isinstance(node, ViewPartNode)) for partnode in children: value = partnode.render(context) context['_viewform_parts'][partnode.resolve_part(context)][partnode.section] = value return template.render(context) finally: context.pop()
def render(strName, objData, bolDebug=False): if type(_objTemplateCache[strName]) == type(" "): # template from file (render with appEngine template method) return template.render(_objTemplateCache[strName], objData, bolDebug) else: # template from string (render with django template method) return _objTemplateCache[strName].render(django.template.Context(objData))
def uni_form_css(): return {'MEDIA_URL':getattr(settings, 'STATIC_URL', 'MEDIA_URL')} template = get_template('uni_form/css_head.html') c = Context() html = template.render(c) print html return html
def render(self, context): row = self.row_variable.resolve(context) resource = row[self.resource_column] context['resource'] = resource.value context['label'] = row.get(self.label_column, resource).value if self.property_column: context['property'] = abbreviate(row[self.property_column].value) else: try: del context['property'] except KeyError: pass anchor = " <A title='{{resource}}' href='{{resource}}' {% if property %} rel='{{property}}' about='{{resource_uri}}' {% endif %} >{{label}}</A>" span = """<SPAN {% if property %} property='{{property}}' {% endif %} >{{resource}}</SPAN> """ template = Template(anchor if resource.type =='uri' else span) return template.render(context)
def render(self, context): slug = self.dynamicform_slug.resolve(context) dynamicform = DynamicForm.objects.get(slug=slug) template = get_template(dynamicform.tag_template) context['dynamicform'] = dynamicform context['form'] = dynamicform.form_class() return template.render(context)
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)
def do_crispy_form(context, form, helper=None, template_pack=TEMPLATE_PACK, is_subform=False): """ You need to pass in at least the form/formset object, and can also pass in the optional `crispy_forms.helpers.FormHelper` object. helper (optional): A `crispy_forms.helper.FormHelper` object. Usage:: {% include crispy_tags %} {% crispy form form.helper %} You can also provide the template pack as the third argument:: {% crispy form form.helper 'bootstrap' %} If the `FormHelper` attribute is named `helper` you can simply do:: {% crispy form %} {% crispy form 'bootstrap' %} """ with KeepContext(context): c = get_render(context, form, helper, template_pack, is_subform) template = get_template(c['template']) return template.render(c)
def crispy_addon(field, append="", prepend=""): """ Renders a form field using bootstrap's prepended or appended text:: {% crispy_addon form.my_field prepend="$" append=".00" %} You can also just prepend or append like so {% crispy_addon form.my_field prepend="$" %} {% crispy_addon form.my_field append=".00" %} """ if (field): context = Context({ 'field': field, 'form_show_errors': True }) template = loader.get_template('%s/layout/prepended_appended_text.html' % get_template_pack()) context['crispy_prepended_text'] = prepend context['crispy_appended_text'] = append if not prepend and not append: raise TypeError("Expected a prepend and/or append argument") return template.render(context)
def as_default_form(form): try: template = get_template(FORM_TEMPLATE) c = Context({'form': form}) return template.render(c) except TemplateDoesNotExist: raise Exception('Either set BLUETRAIN_DEFAULT_FORM in settings or provide a file at %s' % FORM_TEMPLATE)
def as_crispy_field(field, template_pack=TEMPLATE_PACK, label_class="", field_class=""): """ Renders a form field like a django-crispy-forms field:: {% load crispy_forms_tags %} {{ form.field|as_crispy_field }} or:: {{ form.field|as_crispy_field:"bootstrap" }} """ if not isinstance(field, forms.BoundField) and settings.DEBUG: raise CrispyError('|as_crispy_field got passed an invalid or inexistent field') attributes = { 'field': field, 'form_show_errors': True, 'form_show_labels': True, 'label_class': label_class, 'field_class': field_class, } helper = getattr(field.form, 'helper', None) template_path = None if helper is not None: attributes.update(helper.get_attributes(template_pack)) template_path = helper.field_template if not template_path: template_path = '%s/field.html' % template_pack template = get_template(template_path) c = Context(attributes).flatten() return template.render(c)
def render_extra_menu_items(context, obj, template='cms/toolbar/dragitem_extra_menu.html'): request = context['request'] content_renderer = context['cms_content_renderer'] template = content_renderer.get_cached_template(template) if isinstance(obj, CMSPlugin): plugin = obj plugin_class_inst = plugin.get_plugin_class_instance() items = plugin_class_inst.get_extra_local_plugin_menu_items(request, plugin) or [] plugin_classes = content_renderer.registered_plugins for plugin_class in plugin_classes: plugin_items = plugin_class().get_extra_global_plugin_menu_items(request, plugin) if plugin_items: items.extend(plugin_items) elif isinstance(obj, PlaceholderModel): items = [] plugin_classes = content_renderer.registered_plugins for plugin_class in plugin_classes: plugin_class_inst = plugin_class() plugin_items = plugin_class_inst.get_extra_placeholder_menu_items(request, obj) if plugin_items: items.extend(plugin_items) else: items = [] if not items: return '' return template.render(Context({'items': items}))
def glitter_startbody(context): """ Template tag which renders the glitter overlay and sidebar. This is only shown to users with permission to edit the page. """ user = context.get("user") path_body = "glitter/include/startbody.html" path_plus = "glitter/include/startbody_%s_%s.html" rendered = "" if user is not None and user.is_staff: templates = [path_body] # We've got a page with a glitter object: # - May need a different startbody template # - Check if user has permission to add glitter = context.get("glitter") if glitter is not None: opts = glitter.obj._meta.app_label, glitter.obj._meta.model_name template_path = path_plus % opts templates.insert(0, template_path) context["has_add_permission"] = user.has_perm("%s.%s" % opts) template = context.template.engine.select_template(templates) rendered = template.render(context) return rendered
def render(self, context): table = self.table.resolve(context) if not isinstance(table, tables.Table): raise ValueError("Expected Table object, but didn't find one.") if self.template: template = self.template.resolve(context) else: template = table.template if isinstance(template, basestring): template = get_template(template) else: # assume some iterable was given template = select_template(template) # Contexts are basically a `MergeDict`, when you `update()`, it # internally just adds a dict to the list to attempt lookups from. This # is why we're able to `pop()` later. context.update({"table": table}) try: # HACK: # TemplateColumn benefits from being able to use the context # that the table is rendered in. The current way this is # achieved is to temporarily attach the context to the table, # which TemplateColumn then looks for and uses. table.context = context return template.render(context) finally: del table.context context.pop()
def index(request): latest_items_list = Items.objects.order_by('item_id')[:100] template = loader.get_template('online_store/index.html') output = ', '.join([p.item_id for p in latest_items_list]) context = RequestContext(request, { 'latest_items_list': latest_items_list, }) return HttpResponse(template.render(context))
def get(self): """Send forms and method page to user. By default, displays a web page listing all services and methods registered on the server. Methods have links to display the actual method form. If both parameters are set, will display form for method. Query Parameters: service_path: Path to service to display method of. Optional. method_name: Name of method to display form for. Optional. """ params = {'forms_path': self.request.path.rstrip('/'), 'hostname': self.request.host, 'registry_path': self.__registry_path, } service_path = self.request.get('path', None) method_name = self.request.get('method', None) if service_path and method_name: form_template = _METHODS_TEMPLATE params['service_path'] = service_path params['method_name'] = method_name else: form_template = _FORMS_TEMPLATE self.response.out.write(template.render(form_template, params))
def as_bootstrap_horizontal(form, label_classes=""): template = get_template("bootstrap/form.html") form = _preprocess_fields(form) if label_classes == "": label_classes = "col-md-2" css_classes = { "label": label_classes, "single_container": "", "wrap": "", } for label_class in label_classes.split(" "): split_class, column_count = label_class.rsplit("-", 1) column_count = int(column_count) if column_count < 12: offset_class = "{split_class}-offset-{column_count}".format( split_class=split_class, column_count=column_count, ) wrap_class = "{split_class}-{column_count}".format( split_class=split_class, column_count=12 - column_count, ) css_classes["single_container"] += offset_class + " " + wrap_class + " " css_classes["wrap"] += wrap_class + " " c = Context({ "form": form, "css_classes": css_classes, }) return template.render(c)
def format_items(items, template_string): """ Formats the items in a list using the Django Template syntax. The template_string is used as a template to control the output. For example, you can render a certain property of each item in the list using "item.full_name" as your template The {{ }} braces will be added automatically, as they are not legal inside a template tag. In the context used to render the template, "item" is the current item and nothing else is available. """ from django.template import Template django.template.base.Variable = VariableWithUnderscoresAllowed template = Template("{{ %s }}" % template_string) django.template.base.Variable = Variable from django.template import Context result = [] for item in items: result.append(template.render(Context({'item': item}))) return result
def bootstrapform(element, bootstrap_type='vertical'): """ Render a single form, a form set or a form field as a bootstrap form. :param element: The form, formset or form field to be rendered. :param bootstrap_type: The type of bootstrap form. Can be "inline", "vertical" (default), or "horizontal". """ element_type = element.__class__.__name__.lower() template_var = 'form' if element_type == 'boundfield': add_input_classes(element) template = get_template('bootstrapform/field.html') 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") template_var = 'formset' else: for field in element.visible_fields(): add_input_classes(field) template = get_template('bootstrapform/form.html') context = { template_var: element, 'bootstrap_type': bootstrap_type } return template.render(context)
def render(self, context): table = self.table.resolve(context) if isinstance(table, tables.TableBase): pass elif hasattr(table, 'model'): queryset = table # We've been given a queryset, create a table using its model and # render that. class OnTheFlyTable(tables.Table): class Meta: model = queryset.model table = OnTheFlyTable(queryset) request = context.get('request') if request: RequestConfig(request).configure(table) else: klass = type(table).__name__ raise ValueError( 'Expected table or queryset, not {}'.format(klass)) if self.template: template = self.template.resolve(context) else: template = table.template if isinstance(template, six.string_types): template = get_template(template) else: # assume some iterable was given template = select_template(template) # Contexts are basically a `MergeDict`, when you `update()`, it # internally just adds a dict to the list to attempt lookups from. This # is why we're able to `pop()` later. context.update({'table': table}) try: # HACK: # TemplateColumn benefits from being able to use the context # that the table is rendered in. The current way this is # achieved is to temporarily attach the context to the table, # which TemplateColumn then looks for and uses. table.context = context return template.render(context.flatten()) finally: del table.context context.pop()
def character(request, id): """character details view""" template = loader.get_template('character.html') #print(get_the_id_from_the_city_name("Asshai")) this_character = Character.objects.get(pk=id) try: next = Character.objects.get(pk=int(id) + 1) except: next = None try: previous = Character.objects.get(pk=int(id) - 1) except: previous = None blank = "This section is empty, you can help to improve our community by adding to it." if this_character.s_1 == this_character.s_2 == this_character.s_3 == \ this_character.s_4 == this_character.s_5 == this_character.s_6 == \ this_character.s_7 == this_character.s_8 == this_character.s_9 == blank: this_empty_section = True else: this_empty_section = False number_of_rows = Character.objects.all().count() books = [ "A Game of Thrones", "A Clash of Kings", "A Storm of Swords", "A Feast for Crows", "A Dance with Dragons" ] seasons = [ 's_1', 's_1', 's_2', 's_3', 's_4', 's_5', 's_6', 's_7', 's_8', 's_8', 's_8' ] comments = PostACommentCharacter.objects.filter(character_id=id) number_of_comments = comments.count() message = { 'this_character': this_character, 'books': books, 'range_one': range(1, 9), 'range_two': range(0, 8), 'seasons': seasons, 'previous': previous, 'next': next, 'random_character': random.randint(1, number_of_rows), 'comments': comments, 'number_of_comments': number_of_comments, 'blank': blank, 'this_empty_section': this_empty_section } return HttpResponse(template.render(message, request=request))
def include_fragment(context, resource): """ Includes a fragment recursively, rendering it if need be. This is one method we need to be careful of injecting, so we don't mark as safe. We also need the context recursively in case any of the child templates use a variable from a parent template. context: The context object :param resource: str Template to render """ with open(os.path.join(FRAGMENTS_PATH, resource), "r") as f: template = Template(f.read()) return template.render(context)
def display(self, request, correlated=False, json=False): context = RequestContext(request) template = get_template(self.__class__.template) context['artifact_name'] = self.__class__.display_name if correlated: context['artifact_values'] = self._correlated else: context['artifact_values'] = self._artifacts context['observation'] = self._observation if not json: return template.render(context.flatten(), request) else: return context.flatten()
def render(self, context): c = self.get_render(context) if c['is_formset']: if settings.DEBUG: template = get_template('uni_form/whole_uni_formset.html') else: template = whole_uni_formset_template else: if settings.DEBUG: template = get_template('uni_form/whole_uni_form.html') else: template = whole_uni_form_template return template.render(c)
def ServerError(request, template_name=ERROR_500_TEMPLATE_NAME): """ Custom 500 handler to provide details when rendering 500.html. """ try: template = loader.get_template(template_name) except TemplateDoesNotExist: return HttpResponseServerError( "<h1>Server Error (500)</h1>", content_type="text/html" ) type_, error, _ = sys.exc_info() return HttpResponseServerError( template.render({"exception": str(type_), "error": error}) )
def bs_inline(element): element_type = element.__class__.__name__.lower() if element_type == 'boundfield': template = get_template("bootstrapform/field-inline.html") context = {'field': element} else: has_management = getattr(element, 'management_form', None) if has_management: template = get_template("bootstrapform/formset-inline.html") context = {'formset': element} else: template = get_template("bootstrapform/form-inline.html") context = {'form': element} return template.render(context)
def render_form(form): """same than {{ form|crispy }} if crispy_forms is installed. render using a bootstrap3 templating otherwise""" if 'crispy_forms' in settings.INSTALLED_APPS: from crispy_forms.templatetags.crispy_forms_filters import as_crispy_form return as_crispy_form(form) template = get_template("bootstrap/form.html") form = _preprocess_fields(form) c = Context({ "form": form, }) return template.render(c)
def selected_facets(context): request = context.request selected_facets = request.GET.getlist('selected_facets') converted_facets = {} for facet in selected_facets: f, label = facet.split(':') title = f.replace('_', ' ').title() converted_facets[title] = label if converted_facets: template = get_template('datamad2/includes/selected_facets.html') return template.render({'converted_facets': converted_facets}) return ''
def render(self, context): if self.template_pack == 'json': return self.get_render(context) c = self.get_render(context).flatten() if self.actual_helper is not None and getattr(self.actual_helper, 'template', False): template = get_template(self.actual_helper.template) else: if c['is_formset']: template = whole_uni_formset_template(self.template_pack) else: template = whole_uni_form_template(self.template_pack) return template.render(c)
def render_to_string_normal(template_name, django_context): data_dict = dict() if isinstance(django_context, django.template.context.Context): for d in reversed(django_context.dicts): if d: data_dict.update(d) data_dict.update({'request': django_context.request}) else: data_dict = django_context template = lookup.get_template(template_name) data_dict = dict( map(lambda k: (str(k), data_dict.get(k)), data_dict.keys())) result = template.render(**data_dict) return i18n.smart_unicode(result)
def edit_pers_number(request, pk): edit = Personal_number.objects.get(id=pk) template = loader.get_template('users_addons/edit_pers_number.html') if request.method == "POST": form = PersonalForm(request.POST, instance=edit) if form.is_valid(): form.save() return HttpResponseRedirect(reverse('core:pers_numbers')) else: form = PersonalForm(instance=edit) return HttpResponse( template.render({ 'edit': edit, 'form': form }, request))
def payment(request): template = loader.get_template('payment.html') data['payment_gateway'] = "paystack" #"kongapay" data[ 'merchantid'] = "pk_test_294b393b858f07d85789bc1d0029a482568cf605" #"testmerchant" data['merchantname'] = "audioApp" data['phone'] = request.POST.get('phone', 'Not Available') data['callbackurl'] = "http://fma.mobilipia.com/completed" data['amount'] = request.POST.get('amount', '0') data['email'] = request.POST.get('email', 'Not Available') uid = uuid.uuid4() data['transid'] = uid.hex.upper() data['description'] = request.POST.get('description', 'Not Available') context = {'data': data} return HttpResponse(template.render(context, request))
def navbarQueries(request): # Brand Navigation trendBrand = Brand.objects.filter(brandCategory__contains="TREN") highendBrand = Brand.objects.filter(brandCategory__contains="HIGH") drugstoreBrand = Brand.objects.filter(brandCategory__contains="DRUG") # Product Navigation context_nav = { 'trending': trendBrand, 'highend': highendBrand, 'drugstore': drugstoreBrand, } loader.get_template('product/base.html') return HttpResponse(template.render(context_nav, request))
def render(self, context): post = context.get(self.post_name, None) if post is None: return '' templates = post.get_template_names(self.template_fname) template = select_template(templates) try: html = template.render(context) except Exception, e: error = str(e) error_template = select_template(['blog/modules/error.html']) html = unicode(error_template.render(Context(dict(error=error))))
def as_crispy_field(field, template_pack=TEMPLATE_PACK): """ Renders a form field like a django-crispy-forms field:: {% load crispy_forms_tags %} {{ form.field|as_crispy_field }} or {{ form.field|as_crispy_field:"bootstrap" }} """ if not isinstance(field, forms.BoundField) and DEBUG: raise CrispyError('|as_crispy_field got passed an invalid or inexistent field') template = get_template('%s/field.html' % template_pack) c = Context({'field': field, 'form_show_errors': True}) return template.render(c)
def render(self, context): if self not in context.render_context: context.render_context[self] = ( Variable(self.form), Variable(self.helper) if self.helper else None ) form, helper = context.render_context[self] actual_form = form.resolve(context) if self.helper is not None: helper = helper.resolve(context) else: helper = actual_form.helper template = get_template(helper.template_name) c = self.get_render(context) return template.render(c)
def index(request): if request.session.get('isloggedin', False): data['authors']=Author.objects.count() data['users']=User.objects.count() data['content']=Product.objects.count() data['purchases']=Purchases.objects.count() data['username']=request.session.get("username") template = loader.get_template('manager_dashboard.html') data['view']="dashboard" context = { 'data': data } return HttpResponse(template.render(context, request)) else: return HttpResponseRedirect("login")
def test_inlinecompile_tag(monkeypatch): compiler = pretend.stub( compile_source=pretend.call_recorder(lambda *args: "compiled")) get_compiler_by_name = pretend.call_recorder(lambda *args: compiler) monkeypatch.setattr("static_precompiler.utils.get_compiler_by_name", get_compiler_by_name) template = django.template.Template( "{% load compile_static %}{% inlinecompile compiler='sass' %}source{% endinlinecompile %}" ) assert template.render(django.template.Context({})) == "compiled" assert get_compiler_by_name.calls == [pretend.call("sass")] assert compiler.compile_source.calls == [pretend.call("source")]
def bulma_field(field, extra_class=''): widget = field.field.widget html_class = extra_class.split() if isinstance(widget, INPUT_WIDGETS): html_class.insert(0, "input") elif isinstance(widget, forms.Textarea): html_class.insert(0, "textarea") elif isinstance(widget, forms.Select): html_class.insert(0, "select") template = get_template("bulma/select.html") return template.render({'field': field, 'html_class': html_class}) widget.attrs["class"] = ' '.join(html_class) return field
def issue_table(model_list): template = loader.get_template("table.html") return template.render({ 'model_list': IssueSerializer(model_list, many=True).data, 'field_list': [ 'id', 'isbn', 'title', 'series', 'valid_isbn', 'issue_number', 'publication_date', 'price', 'page_count', 'indicia_frequency', 'on_sale_date', 'rating', 'issue_number', 'reprint_of', 'indicia_publisher' ], 'foreign_field_list': [], 'table_name': 'Issue' })
def get(self, request): output = cache.get('api_nodes_all') if output is None: site = GetSite() template_values = {} template_values['site'] = site nodes = cache.get('api_nodes_all') if nodes is None: nodes = db.GqlQuery("SELECT * FROM Node") cache.set('api_nodes_all', nodes, 3600) template_values['nodes'] = nodes path = 'api/nodes_all.json' output = template.render(path, template_values) cache.set('api_nodes_all', output, 86400) self.write(output)
def history_display(history, unit, test_list, test): template = get_template("qa/history.html") c = Context({ "history": history, "unit": unit, "test_list": test_list, "test": test, "show_icons": settings.ICON_SETTINGS['SHOW_STATUS_ICONS_HISTORY'], }) return template.render(c)
def render(self, context): c = self.get_render(context) if self.actual_helper is not None and getattr(self.actual_helper, 'template', False): template = get_template(self.actual_helper.template) else: if c['is_formset']: template = whole_uni_formset_template(self.template_pack) else: template = whole_uni_form_template(self.template_pack) if django.VERSION >= (1, 8): c = c.flatten() return template.render(c)
def corpus_info(request, corpus_id): template = get_template('corpus-info.html') form = QueryForm() request.session.set_test_cookie() corpus = get_corpus_by_id(corpus_id) context = Context(request, selected=corpus, form=form) try: extra_template = django.template.loader.get_template( 'corpora/%s.html' % corpus.id) corpus_info = extra_template.render(context) except django.template.TemplateDoesNotExist: corpus_info = None context.update(dict(corpus_info=corpus_info)) response = django.http.HttpResponse(template.render(context)) return response
def notify(notification): if not notification.data: return "invalid notification" template_name = notification.data.get('template', None) if not template_name: return unicode(notification.data) try: template = get_template(join('assets', 'notification', template_name)) context = dict(notice=notification, user=notification.recipient, instance=notification.action_object, parent=notification.target, author=notification.actor) return template.render(context) except TemplateDoesNotExist: return "template does not exist: " + template_name
def NewUserS2(request, shortsign): template = loader.get_template('users_addons/NewUserS2.html') if request.method == "POST": form = CreateUserFormStage2(request.POST) if form.is_valid(): card = form.cleaned_data['card_original'] SaveCard(request, card, shortsign) return HttpResponseRedirect( reverse('core:NewUserS3', kwargs={'shortsign': shortsign})) else: form = CreateUserFormStage2() return HttpResponse( template.render({ 'shortsign': shortsign, 'form': form }, request))
def gen(): yield 1 yield 2 # Simulate that another thread is now rendering. # When the IfChangeNode stores state at 'self' it stays at '3' and skip the last yielded value below. iter2 = iter([1, 2, 3]) output2 = template.render( Context({ 'foo': range(3), 'get_value': lambda: next(iter2) })) self.assertEqual( output2, '[0,1,2,3]', 'Expected [0,1,2,3] in second parallel template, got {}'. format(output2)) yield 3
def do_term_tag(term_key, **kwargs): theme = kwargs.pop('theme', settings.IDIOTICON_THEME) context = Context() context.update(kwargs) try: context['term'] = shortcuts.get_term(term_key) template_name = 'idioticon/term_%s.html' % theme template = get_template(template_name) return template.render(context) except: if settings.TEMPLATE_DEBUG: raise return ''
def as_crispy_errors(form, template_pack=TEMPLATE_PACK): """ Renders only form errors the same way as django-crispy-forms:: {% load crispy_forms_tags %} {{ form|as_crispy_errors }} or {{ form|as_crispy_errors:"bootstrap" }} """ if isinstance(form, BaseFormSet): template = get_template('%s/errors_formset.html' % template_pack) c = Context({'formset': form}) else: template = get_template('%s/errors.html' % template_pack) c = Context({'form': form}) return template.render(c)