def admin_pg_cc(request, nrop):
template = get_template('pg/adminpg/comprobante_confirmado.html')
preinscripcion = PreinscripcionGeneral.objects.get(nro_de_preinscripto=nrop)
user = preinscripcion.usuarioqueconfirma
contexto = {'preinscripcion' : preinscripcion, 'user': user }
pdf = render_to_pdf('pg/adminpg/comprobante_confirmado.html', contexto)
if pdf:
response = HttpResponse(pdf, content_type='application/pdf')
filename = "Comprobante_Preinscripcion"
content = "inline; filename='%s'" % (filename)
#download = request.GET.get("download")
#return response
#if download:
# content = "attachment; filename='%s'" % (filename)
#response['Content-Disposition'] = content
return response
return HttpResponse("ERROR AL GENERAR EL COMPROBANTE")
####
python类get_template()的实例源码
def test_wkhtmltopdf(self):
"""Should run wkhtmltopdf to generate a PDF"""
title = 'A test template.'
template = loader.get_template('sample.html')
temp_file = render_to_temporary_file(template, context={'title': title})
try:
# Standard call
pdf_output = wkhtmltopdf(pages=[temp_file.name])
self.assertTrue(pdf_output.startswith(b'%PDF'), pdf_output)
# Single page
pdf_output = wkhtmltopdf(pages=temp_file.name)
self.assertTrue(pdf_output.startswith(b'%PDF'), pdf_output)
# Unicode
pdf_output = wkhtmltopdf(pages=[temp_file.name], title=u'?')
self.assertTrue(pdf_output.startswith(b'%PDF'), pdf_output)
# Invalid arguments
self.assertRaises(CalledProcessError,
wkhtmltopdf, pages=[])
finally:
temp_file.close()
def render_field(self, field, parent_style):
if isinstance(field._field, serializers.HiddenField):
return ''
style = dict(self.default_style[field])
style.update(field.style)
if 'template_pack' not in style:
style['template_pack'] = parent_style.get('template_pack', self.template_pack)
style['renderer'] = self
# Get a clone of the field with text-only value representation.
field = field.as_form_field()
if style.get('input_type') == 'datetime-local' and isinstance(field.value, six.text_type):
field.value = field.value.rstrip('Z')
if 'template' in style:
template_name = style['template']
else:
template_name = style['template_pack'].strip('/') + '/' + style['base_template']
template = loader.get_template(template_name)
context = {'field': field, 'style': style}
return template_render(template, context)
def render(self, data, accepted_media_type=None, renderer_context=None):
"""
Render serializer data and return an HTML form, as a string.
"""
renderer_context = renderer_context or {}
form = data.serializer
style = renderer_context.get('style', {})
if 'template_pack' not in style:
style['template_pack'] = self.template_pack
style['renderer'] = self
template_pack = style['template_pack'].strip('/')
template_name = template_pack + '/' + self.base_template
template = loader.get_template(template_name)
context = {
'form': form,
'style': style
}
return template_render(template, context)
def send_summary(report_pk):
report = Report.objects.get(pk=report_pk)
daily = report.get_daily()
messages = []
questions = daily.report.question_set.active()
surveys = daily.survey_set.all()
for user in report.stakeholders:
context = Context({'user': user,
'daily': daily,
'surveys': surveys,
'questions': questions})
context['SITE_URL'] = settings.SITE_URL
subject = render_to_string('email/summary_subject.txt', context)
text = get_template('email/summary.txt')
html = get_template('email/summary.html')
text_content = text.render(context)
html_content = html.render(context)
messages.append([subject, text_content, html_content, settings.DEFAULT_FROM_EMAIL, [user.email]])
send_mass_html_mail(messages)
daily.summary_submitted = now()
daily.save()
def input_form(request):
"""
Course Addition Tool Endpoints
"""
if not request.user.is_authenticated():
return HttpResponseRedirect('/admin/login/?next=%s' % request.path)
VC1 = VEDACat()
VC1.institution_list()
inst_list = json.dumps(VC1.inst_list)
template = loader.get_template('course_form.html')
context = RequestContext(request, ({
'institution_list': inst_list
}))
return HttpResponse(template.render(context))
def do_loadmacros(parser, token):
try:
tag_name, filename = token.split_contents()
except IndexError:
m = ("'%s' tag requires at least one argument (macro name)"
% token.contents.split()[0])
raise template.TemplateSyntaxError(m)
if filename[0] in ('"', "'") and filename[-1] == filename[0]:
filename = filename[1:-1]
t = get_template(filename)
macros = t.nodelist.get_nodes_by_type(DefineMacroNode)
## Metadata of each macro are stored in a new attribute
## of 'parser' class. That way we can access it later
## in the template when processing 'usemacro' tags.
_setup_macros_dict(parser)
for macro in macros:
parser._macros[macro.name] = macro
return LoadMacrosNode()
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 index(request):
indices = ES_Manager.get_indices()
template = loader.get_template('account.html')
ds = Datasets().activate_dataset(request.session)
datasets = sort_datasets(ds.get_datasets(),indices)
datasets = get_allowed_datasets(datasets, request.user)
# TODO: We should check if the model is actually present on the disk
sem_models = ModelRun.objects.all().filter(run_status='completed').order_by('-pk')
try:
request.session['model']
except KeyError:
if len(sem_models):
request.session['model'] = str(sem_models[0].id)
return HttpResponse(template.render({'STATIC_URL':STATIC_URL, 'datasets':datasets,'models':sem_models},request))
def index(request):
# Define selected mapping
ds = Datasets().activate_dataset(request.session)
dataset = ds.get_index()
mapping = ds.get_mapping()
es_m = ds.build_manager(ES_Manager)
fields = get_fields(es_m)
searches = [{'id':search.pk,'desc':search.description} for search in
Search.objects.filter(author=request.user, dataset__index=dataset, dataset__mapping=mapping)]
template = loader.get_template('grammar_builder.html')
return HttpResponse(template.render({'STATIC_URL':STATIC_URL,
'searches':searches,
'features':fields},request))
def get_table(request):
polarity = request.GET['polarity']
if request.GET['is_test'] == 'true':
inclusive_test_grammar = json.loads(request.GET['inclusive_test_grammar'])
#exclusive_test_grammar = json.loads(request.GET['exclusive_test_grammar'])
layers = ['id'] + sorted(extract_layers(inclusive_test_grammar))
else:
inclusive_id = int(request.GET['inclusive_grammar_id'])
exclusive_id = int(request.GET['exclusive_grammar_id'])
inclusive_metaquery = generate_metaquery_dict(inclusive_id, request.user, component={})
exclusive_metaquery = generate_metaquery_dict(exclusive_id, request.user, component={})
layers = ['id'] + sorted(extract_layers(inclusive_metaquery) | extract_layers(exclusive_metaquery))
template = loader.get_template('grammar_builder_table.html')
return HttpResponse(template.render({'features':layers, 'polarity':polarity},request))
def index(request):
template = loader.get_template('mwe_miner.html')
lexicons = []
runs = []
for run in Run.objects.all().filter(user=request.user).order_by('-pk'):
try:
groups = json.loads(run.results).values()
num_mwes = sum(len(group['mwes']) for group in groups)
setattr(run,'num_groups',len(groups))
setattr(run,'num_mwes',num_mwes)
# setattr(run,'committed',len({approved_candidate.candidate for approved_candidate in approved_term_candidates} & {committed_candidate.term for committed_candidate in Term.objects.filter(author=request.user)}))
except ValueError as e:
print 'Exception', e
pass
runs.append(run)
for lexicon in Lexicon.objects.all().filter(author=request.user):
setattr(lexicon,'size',Word.objects.all().filter(lexicon=lexicon.id).count())
lexicons.append(lexicon)
# Define selected mapping
ds = Datasets().activate_dataset(request.session)
es_m = ds.build_manager(ES_Manager)
fields = es_m.get_column_names()
return HttpResponse(template.render({'lexicons':lexicons,'STATIC_URL':STATIC_URL,'runs':runs,'fields':fields},request))
def cluster_query(request):
params = request.POST
ds = Datasets().activate_dataset(request.session)
es_m = ds.build_manager(ES_Manager)
es_m.build(params)
cluster_m = ClusterManager(es_m,params)
clustering_data = convert_clustering_data(cluster_m)
template_params = {'STATIC_URL': STATIC_URL,
'URL_PREFIX': URL_PREFIX,
'clusters': clustering_data}
template = loader.get_template('cluster_results.html')
return HttpResponse(template.render(template_params, request))
def import_supervisors(request):
# configure template
csv = create_temp_copy(request.FILES['datafile'].temporary_file_path())
enc = get_variable(request, 'encoding')
email = get_variable(request, 'email_notification')
write_last_parameter(request.user, 'dbbackend.database_supervisors.email', email)
if len(email) == 0:
email = None
t = threading.Thread(target=dbimport.queue_import_supervisors, args=(csv, enc), kwargs={'email': email})
t.setDaemon(True)
t.start()
template = loader.get_template('message.html')
context = applist.template_context()
context['message'] = "Started import of supervisors... Check 'Table status' page for progress."
context['back_link'] = "/dbbackend/tablestatus"
context['back_text'] = "Table status"
return HttpResponse(template.render(context, request))
def import_scholarships(request):
# configure template
csv = create_temp_copy(request.FILES['datafile'].temporary_file_path())
enc = get_variable(request, 'encoding')
email = get_variable(request, 'email_notification')
write_last_parameter(request.user, 'dbbackend.database_scholarships.email', email)
if len(email) == 0:
email = None
t = threading.Thread(target=dbimport.queue_import_scholarships, args=(csv, enc), kwargs={'email': email})
t.setDaemon(True)
t.start()
template = loader.get_template('message.html')
context = applist.template_context()
context['message'] = "Started import of scholarships... Check 'Table status' page for progress."
context['back_link'] = "/dbbackend/tablestatus"
context['back_text'] = "Table status"
return HttpResponse(template.render(context, request))
def import_associatedrole(request):
# configure template
csv = create_temp_copy(request.FILES['datafile'].temporary_file_path())
enc = get_variable(request, 'encoding')
email = get_variable(request, 'email_notification')
write_last_parameter(request.user, 'dbbackend.database_associatedrole.email', email)
if len(email) == 0:
email = None
t = threading.Thread(target=dbimport.queue_import_associatedrole, args=(csv, enc), kwargs={'email': email})
t.setDaemon(True)
t.start()
template = loader.get_template('message.html')
context = applist.template_context()
context['message'] = "Started import of associate role... Check 'Table status' page for progress."
context['back_link'] = "/dbbackend/tablestatus"
context['back_text'] = "Table status"
return HttpResponse(template.render(context, request))
def import_coursedefs(request):
# configure template
csv = create_temp_copy(request.FILES['datafile'].temporary_file_path())
year = int(get_variable(request, 'year', def_value='1900'))
enc = get_variable(request, 'encoding')
email = get_variable(request, 'email_notification')
write_last_parameter(request.user, 'dbbackend.database_coursedefs.email', email)
if len(email) == 0:
email = None
t = threading.Thread(target=dbimport.queue_import_coursedefs, args=(year, csv, enc), kwargs={'email': email})
t.setDaemon(True)
t.start()
template = loader.get_template('message.html')
context = applist.template_context()
context['message'] = "Started import of course definitions... Check 'Table status' page for progress."
context['back_link'] = "/dbbackend/tablestatus"
context['back_text'] = "Table status"
return HttpResponse(template.render(context, request))
def import_bulk(request):
# configure template
csv = request.FILES['datafile'].temporary_file_path()
email = get_variable(request, 'email_notification')
write_last_parameter(request.user, 'dbbackend.database_bulk.email', email)
if len(email) == 0:
email = None
msg = dbimport.import_bulk(csv, email)
template = loader.get_template('message.html')
context = applist.template_context()
if msg is None:
context['message'] = "Successful bulk import!"
else:
context['message'] = "Failed to bulk import: " + msg
context['back_link'] = "/"
context['back_text'] = "Start"
return HttpResponse(template.render(context, request))
def search_by_paper(request):
# get parameters
response, paper = get_variable_with_error(request, 'supervisors', 'paper', as_list=False)
if response is not None:
return response
# get year from earliest start date
max_years = get_max_years()
# configure template
template = loader.get_template('supervisors/search_by_paper.html')
context = applist.template_context('supervisors')
context['papers'] = get_papers(paper)
context['max_years'] = int(max_years) if max_years is not None else YEARS_BACK
context['scholarships'] = get_scholarships()
context['last_programs'] = read_last_parameter(request.user, 'supervisors.search_by_paper.programs', PROGRAM_TYPES)
context['last_supervisor_type'] = read_last_parameter(request.user, 'supervisors.search_by_paper.supervisor_type', SUPERVISOR_TYPES)
context['last_study_type'] = read_last_parameter(request.user, 'supervisors.search_by_paper.study_type', STUDY_TYPES)
context['last_only_current'] = read_last_parameter(request.user, 'supervisors.search_by_paper.only_current', True)
context['last_min_months'] = read_last_parameter(request.user, 'supervisors.search_by_paper.min_months', -1)
context['last_scholarship'] = read_last_parameter(request.user, 'supervisors.search_by_paper.scholarship', DEFAULT_SCHOLARSHIP)
context['last_sort_column'] = read_last_parameter(request.user, 'supervisors.search_by_paper.sort_column', "supervisor")
context['last_sort_order'] = read_last_parameter(request.user, 'supervisors.search_by_paper.sort_order', "asc")
return HttpResponse(template.render(context, request))
