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)
