def email_send_bcc(text_template, html_template, data, subject, emails, headers=None):
"""
Send an HTML/Plaintext email with the following fields.
text_template: URL to a Django template for the text email's contents
html_template: URL to a Django tempalte for the HTML email's contents
data: The context to pass to the templates
subject: The subject of the email
emails: The addresses to send the email to
headers: A dict of additional headers to send to the message
"""
text = get_template(text_template)
html = get_template(html_template)
text_content = text.render(data)
html_content = html.render(data)
subject = settings.EMAIL_SUBJECT_PREFIX + subject
headers = {} if headers is None else headers
msg = EmailMultiAlternatives(subject, text_content, settings.EMAIL_FROM, [settings.EMAIL_FROM], headers=headers, bcc=emails)
msg.attach_alternative(html_content, "text/html")
logger.debug("Emailing {} to {}".format(subject, emails))
msg.send()
return msg
def handle(self, *args, **options):
message = options.get('message')
verbosity = options.get('verbosity')
get_template('templated_email/notice.email')
if not message:
raise CommandError(_('message must be included in options'))
# get all users
users = User.objects.all()
for user in users:
name = user.get_full_name()
if not name or len(name) == 0:
name = user.email
if verbosity:
self.stdout.write(_(
'Emailing name: %(name)s, email: %(email)s')
% {'name': name, 'email': user.email})
# send each email separately so users cannot see eachother
send_templated_mail(
template_name='notice',
from_email='*****@*****.**',
recipient_list=[user.email],
context={
'username': user.username,
'full_name': name,
'message': message
}, )
def render_template(request, template_name, vars = {}, include_user=True):
vars_with_user = prepare_vars(request, vars)
language = translation.get_language().split('-')[0].lower()
fallback_language = getattr(settings, 'I18N_TEMPLATES_FALLBACK_LANGUAGE', 'en')
default_language = getattr(settings, 'LANGUAGE_CODE', 'en').split('-')[0].lower()
if not include_user:
del vars_with_user['user']
dyn_tpl = '%s.html' % template_name
dyn_tpl_i18n = 'i18n/%s/%s.html' % (language, template_name)
dyn_tpl_fallback_i18n = 'i18n/%s/%s.html' % (fallback_language, template_name)
dyn_tpl_default_i18n = 'i18n/%s/%s.html' % (default_language, template_name)
i18n_tpl = 'helios/templates/i18n/%s/%s.html' % (language, template_name)
template_name = 'helios/templates/%s.html' % template_name
tpls = [dyn_tpl_i18n, dyn_tpl_fallback_i18n, dyn_tpl_default_i18n, dyn_tpl,
i18n_tpl, template_name]
tpls.reverse()
tpl = None
while not tpl:
try:
tpl = tpls.pop()
loader.get_template(tpl)
except (TemplateDoesNotExist, TemplateSyntaxError), e:
tpl = None
last_exc = e
except IndexError:
raise last_exc
def send(self):
'''
Returns True/False
'''
try:
s = loader.get_template(self.subject)
t = loader.get_template(self.template)
except Exception as e:
print e
headers = {}
if self.reply_to:
headers.update({'Reply-To': self.reply_to})
self.context['settings'] = settings
subject = s.render(Context(self.context))
content = t.render(Context(self.context))
msg = EmailMultiAlternatives(subject, content, self.from_email, self.to, self.bcc, headers=headers)
msg.attach_alternative(content, getattr(settings, 'EMAIL_MIMETYPE', 'text/plain'))
if self.attachments[0]:
for file_doc in self.attachments:
file_name = file_doc.name
msg.attach(file_name.split('/')[-1], file_doc.read(), 'application/pdf')
try:
msg.send(fail_silently=False)
except Exception, e:
print 'Exception: ', e
return False
def moderate_tags(html):
"""replaces instances of <a> and <img>
with "item in moderation" alerts
"""
from askbot.conf import settings
soup = BeautifulSoup(html, 'html5lib')
replaced = False
if settings.MODERATE_LINKS:
links = soup.find_all('a')
if links:
template = get_template('widgets/moderated_link.jinja')
aviso = BeautifulSoup(template.render(), 'html5lib').find('body')
map(lambda v: v.replaceWith(aviso), links)
replaced = True
if settings.MODERATE_IMAGES:
images = soup.find_all('img')
if images:
template = get_template('widgets/moderated_link.jinja')
aviso = BeautifulSoup(template.render(), 'html5lib').find('body')
map(lambda v: v.replaceWith(aviso), images)
replaced = True
if replaced:
return force_text(soup.find('body').renderContents(), 'utf-8')
return html
def comment_post_save(sender, instance, **kwargs):
return #BUG: Unfinished
print "SIGNAL comment_post_save:", sender, instance, kwargs
# if not kwargs.get('created', False):
# return
print "signal new comment %s" %(instance.pk)
template = loader.get_template('irontickets/email/ticket_comment_new.txt')
subjecttemplate = loader.get_template('irontickets/email/ticket_comment_new_subject.txt')
current_site = Site.objects.get_current()
#BUG: Docs say this should return the ticket object, but it returns None.
ticket = instance.content_object
context = Context({
'comment': instance,
'ticket': ticket,
'site': current_site,
'proto': settings.IT_USE_PROTO,
})
subject = subjecttemplate.render(context)
message = template.render(context)
recipients = instance.recipient_list()
#BUG: fail_silently should be True in production
send_mail(subject, message, '*****@*****.**' %(instance.pk), recipients, fail_silently=False)
def buscarImovel(request):
if request.method == 'POST': # If the form has been submitted...
form = BuscarForm(request.POST) # A form bound to the POST data
if form.is_valid():
quartos = form.cleaned_data['Quartos']
banheiros = form.cleaned_data['Banheiros']
salas = form.cleaned_data['Salas']
garagemVagas = form.cleaned_data['GaragemVagas']
tipo_Imovel = form.cleaned_data['Tipo_Imovel']
if(quartos == 1 and banheiros == 1 and salas == 1 and garagemVagas == 1):
Consultas = Imovel.objects.all()
else:
Consultas = Imovel.objects.filter(Quartos=quartos)
Consultas = Consultas.filter(Banheiros=banheiros)
Consultas = Consultas.filter(Salas=salas)
Consultas = Consultas.filter(GaragemVagas=garagemVagas)
Consultas = Consultas.filter(Tipos_de_Imoveis=tipo_Imovel)
template = loader.get_template('Imobiliaria/buscarImovel.html')
parametros = RequestContext(request,{'imovel': Consultas, 'form': form})
return HttpResponse(template.render(parametros))
else:
form = BuscarForm() # An unbound form
Imoveis = []
template = loader.get_template('Imobiliaria/buscarImovel.html')
parametros = RequestContext(request,{'imovel': Imoveis, 'form': form})
return HttpResponse(template.render(parametros))
def as_bootstrap(form_or_field, layout='vertical,false'):
"""
Render a field or a form according to Bootstrap guidelines
"""
params = split(layout, ",")
layout = str(params[0]).lower()
try:
float = str(params[1]).lower() == "float"
except IndexError:
float = False
if isinstance(form_or_field, BaseForm):
return get_template("bootstrap_toolkit/form.html").render(
Context({
'form': form_or_field,
'layout': layout,
'float': float,
})
)
elif isinstance(form_or_field, BoundField):
return get_template("bootstrap_toolkit/field.html").render(
Context({
'field': form_or_field,
'layout': layout,
'float': float,
})
)
else:
# Display the default
return settings.TEMPLATE_STRING_IF_INVALID
def ticket_post_save(sender, instance, **kwargs):
print "SIGNAL ticket_post_save:", sender, instance, kwargs
if not kwargs.get('created', False):
return
print "signal new ticket %s" %(instance.pk)
template = loader.get_template('irontickets/email/ticket_new.txt')
subjecttemplate = loader.get_template('irontickets/email/ticket_new_subject.txt')
current_site = Site.objects.get_current()
context = Context({
'ticket': instance,
'site': current_site,
'proto': settings.IT_USE_PROTO,
})
subject = subjecttemplate.render(context)
message = template.render(context)
recipients = instance.recipient_list()
#BUG: fail_silently should be True in production
send_mail(subject, message, '*****@*****.**' %(instance.pk), recipients, fail_silently=False)
def send_warning_email(date=None, url=None, addr=None, job_name=None):
"""
Args:
date: A datetime object representing when the run will expire
url: The url to the detail page of the export
addr: The email address to which the email will be sent
Returns: None
"""
subject = "Your EventKit DataPack is set to expire."
to = [addr]
from_email = getattr(
settings,
'DEFAULT_FROM_EMAIL',
'Eventkit Team <*****@*****.**>'
)
ctx = {'url': url, 'date': str(date), 'job_name': job_name}
text = get_template('email/expiration_warning.txt').render(ctx)
html = get_template('email/expiration_warning.html').render(ctx)
try:
msg = EmailMultiAlternatives(subject, text, to=to, from_email=from_email)
msg.attach_alternative(html, "text/html")
msg.send()
except Exception as e:
logger.error("Encountered an error when sending status email: {}".format(e))
def send_claim_email(request, list_id):
if request.method == "POST":
listing = Listing.objects.get(pk=list_id)
if listing.email != '':
emails = ['emails/claim_email.html', 'emails/claim_email_2.html']
choice = random.choice(emails)
logger.debug('Listing claim sending email to : ' + listing.email + ' with ' + choice)
t = get_template(choice)
context = RequestContext(request, {'listing': listing})
content = t.render(context)
msg = EmailMessage('Picasso - Claim your Business', content, '*****@*****.**',
[listing.email])
msg.content_subtype = "html"
msg.send()
return HttpResponse(json.dumps({'fail': False}), content_type='application/json')
elif request.POST.get('email', '') != '':
listing.email = request.POST.get('email', '')
listing.save()
emails = ['emails/claim_email.html', 'emails/claim_email_2.html']
choice = random.choice(emails)
logger.debug('Listing claim sending email to : ' + listing.email + ' with ' + choice)
t = get_template(choice)
context = RequestContext(request, {'listing': listing})
content = t.render(context)
msg = EmailMessage('Picasso - Claim your Business', content, '*****@*****.**',
[listing.email])
msg.content_subtype = "html"
msg.send()
return HttpResponse(json.dumps({'fail': False}), content_type='application/json')
else:
return HttpResponse(json.dumps({'fail': True}), content_type='application/json')
return HttpResponse("")
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 send_email(context_data, from_email, to_email, template_subject, template_text):
"""
Send an email with specified content.
Arguments:
context_data (dict): data to be passed to templates.
from_email (str): sender's email.
to_email (list): list of addresses to send an email to.
template_subject (str): path to a subject template, e.g. 'ctms/email/subject.txt'
template_text (str): path to a body template, e.g. 'ctms/email/text.txt'
"""
context = Context(context_data)
subj_template = loader.get_template(template_subject)
rendered_subj = subj_template.render(context)
text_template = loader.get_template(template_text)
rendered_text = text_template.render(context)
send_mail(
rendered_subj,
rendered_text,
from_email,
to_email,
fail_silently=True
)
def leaveGroup(request):
student = None
students = Student.objects.all()
for e in students:
if e.user.username == request.user.username :
student = e
break
if student.groupId is None :
template = get_template('Submission/noGroup.html')
context = RequestContext(request, {
'studentUserName' : request.user.username,
'numberOfStudentsPerGroup' : no_of_students_per_group
})
return HttpResponse(template.render(context))
currentGroup = student.groupId.groupName
template = get_template('Submission/leaveGroup.html')
context = RequestContext(request, {
'studentUserName' : request.user.username,
'currentGroup' : currentGroup,
'numberOfStudentsPerGroup' : no_of_students_per_group
})
return HttpResponse(template.render(context))
def aboutMyGroup(request):
student = None
students = Student.objects.all()
for e in students:
if e.user.username == request.user.username :
student = e
break
if student.groupId is None :
template = get_template('Submission/noGroup.html')
context = RequestContext(request, {
'studentUserName' : request.user.username,
'numberOfStudentsPerGroup' : no_of_students_per_group
})
return HttpResponse(template.render(context))
group_name = student.groupId.groupName
group_members = student.groupId.student_set.all()
group_username = student.groupId.groupId
group_password = student.groupId.groupPassword
group_desc = student.groupId.groupDesc
template = get_template('Submission/aboutMyGroup.html')
context = RequestContext(request, {
'studentUserName' : request.user.username,
'groupName' : group_name,
'groupMembers' : group_members,
'groupUsername' : group_username,
'groupPassword' : group_password,
'group_desc' : group_desc,
'numberOfStudentsPerGroup' : no_of_students_per_group
})
return HttpResponse(template.render(context))
def enviar_mail_activacion(usuario):
# Se genera token con email del usuario.
token_link = generar_token(usuario.email, url=True)
token_clave = generar_token(usuario.id)
# Creación de URL de confirmación
confirm_url = FRONTEND_URL + 'activar-cuenta/' + token_link
# Obtención de templates html y txt de emails.
htmly = loader.get_template('emails/html/confirmar_cuenta.html')
text = loader.get_template('emails/txt/confirmar_cuenta.txt')
# Definición de variables de contexto
variables = {
'usuario': usuario,
'confirm_url': confirm_url,
'clave': token_clave
}
html_content = htmly.render(variables)
text_content = text.render(variables)
# Creación y envío de email.
msg = EmailMultiAlternatives(
'Bienvenido a Manos por gotas',
text_content,
to=[usuario.email]
)
msg.attach_alternative(html_content, "text/html")
msg.send()
def enviar_mail_reiniciar_password(usuario):
# Se genera token con email del usuario.
token_link = generar_token(usuario.email, url=True)
# Creación de URL de confirmación
reset_url = FRONTEND_URL + 'reset-password/' + token_link
# Obtención de templates html y txt de emails.
htmly = loader.get_template('emails/html/reiniciar_password.html')
text = loader.get_template('emails/txt/reiniciar_password.txt')
# Definición de variables de contexto
variables = {
'usuario': usuario,
'reset_url': reset_url,
}
html_content = htmly.render(variables)
text_content = text.render(variables)
# Creación y envío de email.
msg = EmailMultiAlternatives(
'Reiniciar contraseña',
text_content,
to=[usuario.email]
)
msg.attach_alternative(html_content, "text/html")
msg.send()
def item_delete(request, num_iid):
top_session = request.session['top_session'] if 'top_session' in request.session else False
t = loader.get_template('templates/finish_op.html')
if top_session:
sql = "delete from taobao_items where num_iid=%s"
result = store.execute(sql, num_iid)
if result > 0:
item_del_method = 'taobao.item.delete'
res_data = call_taobao_api(item_del_method, num_iid=num_iid, session=top_session)
res_dict = read_taobao_response(res_data)
c = Context({
'BACK_URL': SHOP_DETAIL_URL,
'finish_status': "成功"
})
return HttpResponse(t.render(c))
else:
c = Context({
'BACK_URL': SHOP_DETAIL_URL,
'finish_status': "失败"
})
return HttpResponse(t.render(c))
else:
t = loader.get_template('templates/jump_taobao_signup.html')
c = Context({
'CALLBACK_URL': CALLBACK_URL,
})
return HttpResponse(t.render(c))
def login(request):
tokenStr = request.COOKIES.get('access_token', '')
username = request.POST.get('username', '')
password = request.POST.get('password', '')
print 'token: ' + tokenStr
print 'username: '******'password: '******'/et/profile/')
return response
else:
if username and password:
## login with username and password, redirect to profile page
respJson = loginBackend(username, password)
if respJson['error_code'] != 0:
template = loader.get_template('login.html')
return HttpResponse(template.render(Context({}), request))
else:
##redirect to profile
response = redirect('/et/profile/')
response.set_cookie('access_token', respJson['access_token'])
return response
else:
##display login page
template = loader.get_template('login.html')
return HttpResponse(template.render(Context({}), request))
def test_filter_syntax06(self):
"""
Raise TemplateSyntaxError when trying to access a filter containing
an illegal character
"""
with self.assertRaises(TemplateSyntaxError):
get_template('filter-syntax06')
def handle(self, *args, **options):
plaintext = get_template('email/weekly.txt')
htmly = get_template('email/weekly.html')
all_users = User.objects.exclude(extra__emails=False)
for user in all_users:
# start by finding the ideas posted by a user
commented_on_ideas = user.get_profile().comments_on_owned_ideas(7)
self.stdout.write("user %s\n" %user)
for idea in commented_on_ideas:
self.stdout.write("you've got new comments on: %s\n" % idea.idea)
#new_slates = user.slates.all()
new_slates = user.slates.filter(
date_created__gte = datetime.date.today()-datetime.timedelta(7)
)
self.stdout.write("you've joined %i slates \n" % len(new_slates))
d = Context({ 'user': user })
#actually send the e-mail
if new_slates and commented_on_ideas:
subject, from_email, to = 'Weekly Digest', '*****@*****.**', user.email
text_content = plaintext.render(d)
html_content = htmly.render(d)
msg = EmailMultiAlternatives(subject, text_content, from_email, [to])
msg.attach_alternative(html_content, "text/html")
if "final" in args:
try:
msg.send()
except:
self.stdout.write("failed to send email")
else:
self.stdout.write("test success")
def forget_password(self, request):
email = request.DATA.get('email', False)
# validate posted params
errors = {}
if not email:
errors['email'] = 'Required'
pattern = r"(^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$)"
if not re.match(pattern, email):
errors['email'] = 'Please input valid email address.'
if not errors:
user = User.objects.filter(username=email).first()
if user:
user_code, created = UserCode.objects.get_or_create(user=user, code=random_key(), is_signup=False)
reg_url = settings.DOMAIN + 'api/password_reset/' + user_code.code + '/'
plaintext = get_template('pw_reset.txt')
htmly = get_template('pw_reset.html')
d = Context({'url': reg_url})
subject, from_email, to = 'Password Reset [InAppTranslation]', '*****@*****.**', user.username
text_content = plaintext.render(d)
html_content = htmly.render(d)
msg = EmailMultiAlternatives(subject, text_content, from_email, [to])
msg.attach_alternative(html_content, "text/html")
msg.send()
return Response({'status': 'success'})
else:
errors['email'] = "We can't find any user with the email."
return Response(errors, status=status.HTTP_400_BAD_REQUEST)
def __init__(self, request):
self.csUser = self.getCardSpringUser(request)
self.fbUser = FBUser.objects.get(fb_id = self.csUser.fbID)
self.cards = Cards.objects.filter(csID = self.csUser.csID)
self.myRewards = MyRewards.objects.filter(csID = self.csUser.csID)
email = self.fbUser.email
firstname = self.fbUser.first_name
print "self.csuser.emailed = " + str(self.csUser.emailed)
if not self.csUser.emailed:
print "sending email"
from_email = '*****@*****.**'
to = email
subject = "Welcome to Tivly!"
try:
plaintext = get_template('welcome_to.txt')
htmly = get_template('welcome_to.html')
d = Context({ 'firstname': firstname })
text_content = plaintext.render(d)
html_content = htmly.render(d)
msg = EmailMultiAlternatives(subject, text_content, from_email, [to])
msg.attach_alternative(html_content, "text/html")
msg.send()
self.csUser.emailed = True
self.csUser.save()
print "message sent to %s" % email
except Exception as e:
print "email failed"
print str(e)
def register(request):
if request.method == 'POST':
form = SignUpForm(request.POST) # create form object
if form.is_valid():
username = form.cleaned_data.get('username')
email = form.cleaned_data.get('email')
password = form.cleaned_data.get('password')
subject, from_email, to = 'Welcome to BavBooks', '*****@*****.**', email
plaintext = get_template('Welcome.txt')
htmly = get_template('Welcome.html')
text_content = plaintext.render()
html_content = htmly.render()
msg = EmailMultiAlternatives(subject, text_content, from_email, [to])
msg.attach_alternative(html_content, "text/html")
num=msg.send()
if num==1:
User.objects.create_user(username=username, password=password, email=email)
user = authenticate(username=username, password=password)
auth.login(request, user)
messages.add_message(request, messages.SUCCESS, 'Your account were successfully created.')
return HttpResponseRedirect('/')
else :
messages.add_message(request, messages.ERROR, 'There was some problems while creating your account. Please review some fields before submiting again.')
return render(request, 'Registration.html', { 'form': form })
else:
messages.add_message(request, messages.ERROR, 'There was some problems while creating your account. Please review some fields before submiting again.')
return render(request, 'Registration.html', { 'form': form })
else:
return render(request, 'Registration.html', { 'form': SignUpForm() })
def diff(request, sha=''):
repo = Repo("/home/ibkim/project/python/mysite", odbt=GitCmdObjectDB)
try:
commit = repo.commit(sha)
except BadObject:
tpl = loader.get_template('error.html')
ctx = Context( {'error': 'Bad ObjectError',} )
return HttpResponse(tpl.render(ctx))
diff = commit.diff( commit.hexsha + '~1', None, True)
AddDiff = []
DelDiff = []
ReDiff = []
ModDiff = []
# HTML formatting
for entry in diff.iter_change_type('M'):
if entry.deleted_file or entry.new_file or entry.renamed:
continue
htmldiff = parse_from_memory(entry.diff, True, True)
ModDiff.append({'diff': htmldiff,})
for entry in diff.iter_change_type('A'):
AddDiff.append(entry)
for entry in diff.iter_change_type('D'):
DelDiff.append(entry)
for entry in diff.iter_change_type('R'):
ReDiff.append(entry)
tpl = loader.get_template('diff.html')
ctx = Context( {'add': AddDiff, 'del': DelDiff, 'rename': ReDiff, 'modify': ModDiff} )
return HttpResponse(tpl.render(ctx))
def save(self, *args, **kwargs):
"""
Ensure that the message instance has been correctly defined before
saving to the databse.
"""
# Check if supplied templates exist before saving
templates = [self.subject_template, self.text_template, self.html_template]
for template in templates:
if template:
# If a template has been specified, ensure it exists
try:
loader.get_template(template)
except TemplateDoesNotExist:
raise ValidationError(_(u'Template does not exist: %s') % \
template)
recipients = self.recipients
# Ensure the recipients list is a list type
if not type(recipients).__name__ == 'list':
raise ValidationError(_(u'Recipients must be a list.'))
# Ensure there is at least one recipient
if not len(recipients):
raise ValidationError(_(u'At least one recipient must be provided.'))
# Allow the message instance to save
super(MailifyMessage, self).save(*args, **kwargs)
def render(element, markup_classes=None):
"""
Internal render function used by boostrap filters
"""
classes = {'label': '', 'value': '', 'single_value': ''}
if markup_classes:
classes.update(markup_classes)
if isinstance(element, BoundField):
# InputField
add_input_classes(element)
template = get_template('bootstrapform/field.jinja')
context = {'field': element, 'form': element.form, 'classes': classes}
elif getattr(element, 'management_form', None):
# FormSet
for form in element.forms:
for field in form.visible_fields():
add_input_classes(field)
template = get_template('bootstrapform/formset.jinja')
context = {'formset': element, 'classes': classes}
else:
# Form
for field in element.visible_fields():
add_input_classes(field)
template = get_template('bootstrapform/form.jinja')
context = {'form': element, 'classes': classes}
return mark_safe(template.render(context))
def send_email(subject, template_name, to=[], context={}, from_email=settings.AWS_SES_RETURN_PATH):
context = Context(context)
plaintext = get_template('emails/' + template_name + '.txt').render(context)
htmly = get_template('emails/' + template_name + '.html').render(context)
email = EmailMultiAlternatives(subject, plaintext, from_email, to)
email.attach_alternative(htmly, "text/html")
email.send()
def build_template(self):
try:
t = loader.get_template('search_configuration/solr.xml')
except TemplateDoesNotExist:
t = loader.get_template('search_configuration/solr_base.xml')
c = self.build_context()
return t.render(c)
def get(self, request, order_id, receipt_code):
order_id = int(order_id)
order_confirmed = request.session.pop('order_confirmed', None)
try:
order = Order.objects.prefetch_related('billing_address', 'shipping_address', 'payment_method',
'currency', 'items').get(id=order_id, receipt_code=receipt_code)
except Order.DoesNotExist:
raise Http404()
if order_confirmed:
# Sending order confirmation email to user's billing email address
context = Context(
{'order': order, 'user': request.user, 'SITE_NAME': self.get_config('SITE_NAME'), 'DOMAIN': self.get_config('DOMAIN')})
msg_subject = get_template("sales/email/order_confirmation_subject.txt").render(context)
context = Context({'order': order, 'user': request.user,
'SITE_NAME': self.get_config('SITE_NAME'), 'DOMAIN': self.get_config('SITE_NAME')})
msg_text = get_template("sales/email/order_confirmation.html").render(context)
to_email = '%s <%s>' % (order.billing_address.get_name(), order.billing_address.email)
send_mail(msg_subject, msg_text, [to_email], True)
self.order_id = order_id
self.receipt_code = receipt_code
return super(CheckoutReceiptView, self).get(request, order=order, order_confirmed=order_confirmed)
def template_from_user(user, version):
template = 'activity/emails/developer.txt'
if (not version.addon.authors.filter(pk=user.pk).exists() and
acl.is_user_any_kind_of_reviewer(user)):
template = 'activity/emails/from_reviewer.txt'
return loader.get_template(template)
def not_found(request):
t = get_template('404.html')
return HttpResponse(t.render())
def test_attributes_configuration(self):
assert reverse(
"brasilio_auth:activation_complete") == ActivationView.success_url
assert "brasilio_auth/activation_failed.html" == ActivationView.template_name
assert get_template(ActivationView.template_name)
def gerar_xml_r9011(request, pk, versao=None):
from emensageriapro.settings import BASE_DIR
if pk:
r9011_evttotalcontrib = get_object_or_404(r9011evtTotalContrib, id=pk)
if not versao or versao == '|':
versao = r9011_evttotalcontrib.versao
evento = 'r9011evtTotalContrib'[5:]
arquivo = 'xsd/efdreinf/%s/%s.xsd' % (versao, evento)
import os.path
if os.path.isfile(BASE_DIR + '/' + arquivo):
xmlns = get_xmlns(arquivo)
else:
from django.contrib import messages
messages.warning(
request, '''
Não foi capturar o XMLNS pois o XSD do
evento não está contido na pasta!''')
xmlns = ''
r9011_evttotalcontrib_lista = r9011evtTotalContrib.objects. \
filter(id=pk).all()
r9011_regocorrs_lista = r9011regOcorrs.objects. \
filter(r9011_evttotalcontrib_id__in=listar_ids(r9011_evttotalcontrib_lista)).all()
r9011_infototalcontrib_lista = r9011infoTotalContrib.objects. \
filter(r9011_evttotalcontrib_id__in=listar_ids(r9011_evttotalcontrib_lista)).all()
r9011_rtom_lista = r9011RTom.objects. \
filter(r9011_infototalcontrib_id__in=listar_ids(r9011_infototalcontrib_lista)).all()
r9011_infocrtom_lista = r9011infoCRTom.objects. \
filter(r9011_rtom_id__in=listar_ids(r9011_rtom_lista)).all()
r9011_rprest_lista = r9011RPrest.objects. \
filter(r9011_infototalcontrib_id__in=listar_ids(r9011_infototalcontrib_lista)).all()
r9011_rrecrepad_lista = r9011RRecRepAD.objects. \
filter(r9011_infototalcontrib_id__in=listar_ids(r9011_infototalcontrib_lista)).all()
r9011_rcoml_lista = r9011RComl.objects. \
filter(r9011_infototalcontrib_id__in=listar_ids(r9011_infototalcontrib_lista)).all()
r9011_rcprb_lista = r9011RCPRB.objects. \
filter(r9011_infototalcontrib_id__in=listar_ids(r9011_infototalcontrib_lista)).all()
context = {
'xmlns': xmlns,
'versao': versao,
'base': r9011_evttotalcontrib,
'r9011_evttotalcontrib_lista': r9011_evttotalcontrib_lista,
'pk': int(pk),
'r9011_evttotalcontrib': r9011_evttotalcontrib,
'r9011_regocorrs_lista': r9011_regocorrs_lista,
'r9011_infototalcontrib_lista': r9011_infototalcontrib_lista,
'r9011_rtom_lista': r9011_rtom_lista,
'r9011_infocrtom_lista': r9011_infocrtom_lista,
'r9011_rprest_lista': r9011_rprest_lista,
'r9011_rrecrepad_lista': r9011_rrecrepad_lista,
'r9011_rcoml_lista': r9011_rcoml_lista,
'r9011_rcprb_lista': r9011_rcprb_lista,
}
t = get_template('r9011_evttotalcontrib.xml')
xml = t.render(context)
return xml
def view(request, link_title):
if not request.user.is_authenticated():
return redirect('/accounts/login/?next=%s' % request.path)
page_template = get_template('content_page.html')
widget_row_template = get_template('widget_row.html')
try:
v = View.objects.get(link_title=link_title)
except View.DoesNotExist or View.MultipleObjectsReturned:
return HttpResponse(status=404)
if GroupDisplayPermission.objects.count() == 0:
# no groups
page_list = v.pages.all()
sliding_panel_list = v.sliding_panel_menus.all()
visible_widget_list = Widget.objects.filter(page__in=page_list.iterator()).values_list('pk', flat=True)
visible_custom_html_panel_list = CustomHTMLPanel.objects.all().values_list('pk', flat=True)
visible_chart_list = Chart.objects.all().values_list('pk', flat=True)
visible_control_element_list = ControlItem.objects.all().values_list('pk', flat=True)
else:
page_list = v.pages.filter(groupdisplaypermission__hmi_group__in=request.user.groups.iterator()).distinct()
sliding_panel_list = v.sliding_panel_menus.filter(
groupdisplaypermission__hmi_group__in=request.user.groups.iterator()).distinct()
visible_widget_list = Widget.objects.filter(
groupdisplaypermission__hmi_group__in=request.user.groups.iterator(),
page__in=page_list.iterator()).values_list('pk', flat=True)
visible_custom_html_panel_list = CustomHTMLPanel.objects.filter(
groupdisplaypermission__hmi_group__in=request.user.groups.iterator()).values_list('pk', flat=True)
visible_chart_list = Chart.objects.filter(
groupdisplaypermission__hmi_group__in=request.user.groups.iterator()).values_list('pk', flat=True)
visible_control_element_list = GroupDisplayPermission.objects.filter(
hmi_group__in=request.user.groups.iterator()).values_list('control_items', flat=True)
panel_list = sliding_panel_list.filter(position__in=(1, 2,))
control_list = sliding_panel_list.filter(position=0)
pages_html = ""
for page in page_list:
current_row = 0
has_chart = False
widgets = []
widget_rows_html = ""
for widget in page.widget_set.all():
# check if row has changed
if current_row != widget.row:
# render new widget row and reset all loop variables
widget_rows_html += widget_row_template.render(
{'row': current_row, 'has_chart': has_chart, 'widgets': widgets,
'visible_control_element_list': visible_control_element_list}, request)
current_row = widget.row
has_chart = False
widgets = []
if widget.pk not in visible_widget_list:
continue
if not widget.visable:
continue
if widget.chart:
if not widget.chart.visable():
continue
if widget.chart.pk not in visible_chart_list:
continue
has_chart = True
widgets.append(widget)
elif widget.control_panel:
widgets.append(widget)
elif widget.process_flow_diagram:
widgets.append(widget)
elif widget.custom_html_panel:
if widget.custom_html_panel.pk not in visible_custom_html_panel_list:
continue
widgets.append(widget)
widget_rows_html += widget_row_template.render({'row': current_row,
'has_chart': has_chart,
'widgets': widgets,
'visible_control_element_list': visible_control_element_list},
request)
pages_html += page_template.render({'page': page, 'widget_rows_html': widget_rows_html}, request)
c = {
'page_list': page_list,
'pages_html': pages_html,
'panel_list': panel_list,
'control_list': control_list,
'user': request.user,
'visible_control_element_list': visible_control_element_list,
'view_title': v.title,
'version_string': core_version
}
#logger.info('open hmi', request.user)
return TemplateResponse(request, 'view.html', c)
def hello(request):
get_template('hello.html')
name = 'hello html'
return render_to_response('hello.html', {'name': name})
def __str__(self):
tpl = get_template(self.template)
return mark_safe(tpl.render(context=self.get_context()))
def prepare_rendered_badge(self, obj):
t = loader.get_template('search/badge.html')
return t.render({'object': obj})
def template(self):
return loader.get_template('sitemap.xml')
def prepare_rendered_search_result(self, obj):
t = loader.get_template(self.template_name)
return t.render({'object': obj})
# print(x)
# # users = User.objects.all().values_list('username', 'first_name', 'last_name', 'email')
# for trans in x:
# writer.writerow([trans.date, trans.type, trans.description, trans.amount])
#
# return response
#
from .utils import link_callback
from django.template.loader import get_template
from xhtml2pdf import pisa
def get_case_report(request,slug):
case = Case.objects.get(slug=slug)
results = trans_service.get_case_report(instance=case)
template = get_template('report/end_of_case.html')
html_string = render_to_string('report/end_of_case.html', {'results': results})
html = template.render(results)
print(html)
response = HttpResponse(content_type='application/pdf')
response['Content-Disposition'] = 'attachment; filename="report.pdf"'
pisa_status = pisa.CreatePDF(
html_string, dest=response, link_callback=link_callback)
if pisa_status.err:
return HttpResponse('We had some errors <pre>' + html + '</pre>')
return response
def render_pdf_view(request):
template_path = 'user_printer.html'
def render(self, field, options):
template = loader.get_template(self.template)
context = {}
context['field'] = field
context['options'] = options
return template.render(context)
def flag(request, name, repo, arch):
pkg = get_object_or_404(Package.objects.normal(),
pkgname=name, repo__name__iexact=repo, arch__name=arch)
if pkg.flag_date is not None:
# already flagged. do nothing.
return render(request, 'packages/flagged.html', {'pkg': pkg})
# find all packages from (hopefully) the same PKGBUILD
pkgs = Package.objects.normal().filter(
pkgbase=pkg.pkgbase, flag_date__isnull=True,
repo__testing=pkg.repo.testing,
repo__staging=pkg.repo.staging).order_by(
'pkgname', 'repo__name', 'arch__name')
authenticated = request.user.is_authenticated
if request.POST:
form = FlagForm(request.POST, authenticated=authenticated)
if form.is_valid() and form.cleaned_data['website'] == '':
# save the package list for later use
flagged_pkgs = list(pkgs)
# find a common version if there is one available to store
versions = set((pkg.pkgver, pkg.pkgrel, pkg.epoch)
for pkg in flagged_pkgs)
if len(versions) == 1:
version = versions.pop()
else:
version = ('', '', 0)
message = form.cleaned_data['message']
ip_addr = request.META.get('REMOTE_ADDR')
if authenticated:
email = request.user.email
else:
email = form.cleaned_data['email']
@transaction.atomic
def perform_updates():
current_time = now()
pkgs.update(flag_date=current_time)
# store our flag request
flag_request = FlagRequest(created=current_time,
user_email=email, message=message,
ip_address=ip_addr, pkgbase=pkg.pkgbase,
repo=pkg.repo, pkgver=version[0], pkgrel=version[1],
epoch=version[2], num_packages=len(flagged_pkgs))
if authenticated:
flag_request.user = request.user
flag_request.save()
perform_updates()
maints = pkg.maintainers
if not maints:
toemail = settings.NOTIFICATIONS
subject = f'Orphan {pkg.repo.name} package [{pkg.pkgname}] marked out-of-date'
else:
toemail = []
subject = f'{pkg.repo.name} package [{pkg.pkgname}] marked out-of-date'
for maint in maints:
if maint.userprofile.notify is True:
toemail.append(maint.email)
if toemail:
# send notification email to the maintainers
tmpl = loader.get_template('packages/outofdate.txt')
ctx = {
'email': email,
'message': message,
'pkg': pkg,
'packages': flagged_pkgs,
}
msg = EmailMessage(subject,
tmpl.render(ctx),
'Arch Website Notification <*****@*****.**>',
toemail)
msg.send(fail_silently=True)
return redirect('package-flag-confirmed', name=name, repo=repo, arch=arch)
else:
form = FlagForm(authenticated=authenticated)
context = {
'package': pkg,
'packages': pkgs,
'form': form
}
return render(request, 'packages/flag.html', context)
def generate_static_sku_detail_html(sku_id):
"""
生成静态商品详情页面
:param sku_id: 商品sku id
"""
# 商品分类菜单
categories = get_categories()
# 获取当前sku的信息
sku = SKU.objects.get(id=sku_id)
sku.images = sku.skuimage_set.all()
# 面包屑导航信息中的频道
goods = sku.goods
goods.channel = goods.category1.goodschannel_set.all()[0]
# 构建当前商品的规格键
# sku_key = [规格1参数id， 规格2参数id， 规格3参数id, ...]
sku_specs = sku.skuspecification_set.order_by('spec_id')
sku_key = []
for spec in sku_specs:
sku_key.append(spec.option.id)
# 获取当前商品的所有SKU
skus = goods.sku_set.all()
# 构建不同规格参数（选项）的sku字典
# spec_sku_map = {
# (规格1参数id, 规格2参数id, 规格3参数id, ...): sku_id,
# (规格1参数id, 规格2参数id, 规格3参数id, ...): sku_id,
# ...
# }
spec_sku_map = {}
for s in skus:
# 获取sku的规格参数
s_specs = s.skuspecification_set.order_by('spec_id')
# 用于形成规格参数-sku字典的键
key = []
for spec in s_specs:
key.append(spec.option.id)
# 向规格参数-sku字典添加记录
spec_sku_map[tuple(key)] = s.id
# 获取当前商品的规格信息
# specs = [
# {
# 'name': '屏幕尺寸',
# 'options': [
# {'value': '13.3寸', 'sku_id': xxx},
# {'value': '15.4寸', 'sku_id': xxx},
# ]
# },
# {
# 'name': '颜色',
# 'options': [
# {'value': '银色', 'sku_id': xxx},
# {'value': '黑色', 'sku_id': xxx}
# ]
# },
# ...
# ]
specs = goods.goodsspecification_set.order_by('id')
# 若当前sku的规格信息不完整，则不再继续
if len(sku_key) < len(specs):
return
for index, spec in enumerate(specs):
# 复制当前sku的规格键
key = sku_key[:]
# 该规格的选项
options = spec.specificationoption_set.all()
for option in options:
# 在规格参数sku字典中查找符合当前规格的sku
key[index] = option.id
option.sku_id = spec_sku_map.get(tuple(key))
spec.options = options
# 渲染模板，生成静态html文件
context = {
'categories': categories,
'goods': goods,
'specs': specs,
'sku': sku
}
template = loader.get_template('detail.html')
html_text = template.render(context)
file_path = os.path.join(settings.GENERATED_STATIC_HTML_FILES_DIR, 'goods/' + str(sku_id) + '.html')
with open(file_path, 'w') as f:
f.write(html_text)
def get_template(self, context, **kwargs):
template = get_template([
'cascade/templatetags/section-selector.html',
])
return template.template.name
def index(request):
context = {}
context['segment'] = 'index'
html_template = loader.get_template('index.html')
return HttpResponse(html_template.render(context, request))
def restringirAcceso(request):
miPlantilla = loader.get_template("restringirAcceso.html")
return HttpResponse(miPlantilla.render({}, request))
def load(request):
template = loader.get_template('weather/index.html')
context = {"test": "TEXT!",
"list": 123,
"name":"Alex"}
return HttpResponse(template.render(context, request))
def predict(request):
global crime_type
cursor, conn = db_conn()
if (not crime_type):
query_crime_type = 'SELECT distinct `Primary Type` as primary_type \
FROM testdb.temp_crime_data_grouped_weekly \
GROUP BY `Primary Type`'
result_crime_type = extract_data(cursor, query_crime_type)
for row in result_crime_type:
if (row[0] not in crime_type):
crime_type.append(row[0])
if (not models):
print('inside models')
for each_crime_type in crime_type:
models[each_crime_type] = forecast(conn, each_crime_type)
template = loader.get_template('predict.html')
print(ans)
assault_lat = ans['ASSAULT']['LAT'].tolist()
assault_lon = ans['ASSAULT']['LON'].tolist()
assault_val = ans['ASSAULT']['PREDICTED_NUM_CRIMES'].tolist()
assault_zip = ans['ASSAULT']['ZIP'].tolist()
assault_len = [x for x in range(0, len(assault_lat))]
robbery_lat = ans['ROBBERY']['LAT'].tolist()
robbery_lon = ans['ROBBERY']['LON'].tolist()
robbery_val = ans['ROBBERY']['PREDICTED_NUM_CRIMES'].tolist()
robbery_len = [x for x in range(0, len(robbery_lat))]
robbery_zip = ans['ROBBERY']['ZIP'].tolist()
homicide_lat = ans['HOMICIDE']['LAT'].tolist()
homicide_lon = ans['HOMICIDE']['LON'].tolist()
homicide_val = ans['HOMICIDE']['PREDICTED_NUM_CRIMES'].tolist()
homicide_len = [x for x in range(0, len(homicide_lat))]
homicide_zip = ans['HOMICIDE']['ZIP'].tolist()
theft_lat = ans['THEFT']['LAT'].tolist()
theft_lon = ans['THEFT']['LON'].tolist()
theft_val = ans['THEFT']['PREDICTED_NUM_CRIMES'].tolist()
theft_len = [x for x in range(0, len(theft_lat))]
theft_zip = ans['THEFT']['ZIP'].tolist()
battery_lat = ans['BATTERY']['LAT'].tolist()
battery_lon = ans['BATTERY']['LON'].tolist()
battery_val = ans['BATTERY']['PREDICTED_NUM_CRIMES'].tolist()
battery_len = [x for x in range(0, len(battery_lat))]
battery_zip = ans['BATTERY']['ZIP'].tolist()
burglary_lat = ans['BURGLARY']['LAT'].tolist()
burglary_lon = ans['BURGLARY']['LON'].tolist()
burglary_val = ans['BURGLARY']['PREDICTED_NUM_CRIMES'].tolist()
burglary_len = [x for x in range(0, len(burglary_lat))]
burglary_zip = ans['BURGLARY']['ZIP'].tolist()
sexual_assault_lat = ans['CRIM SEXUAL ASSAULT']['LAT'].tolist()
sexual_assault_lon = ans['CRIM SEXUAL ASSAULT']['LON'].tolist()
sexual_assault_val = ans['CRIM SEXUAL ASSAULT'][
'PREDICTED_NUM_CRIMES'].tolist()
sexual_assault_len = [x for x in range(0, len(sexual_assault_val))]
sexual_zip = ans['CRIM SEXUAL ASSAULT']['ZIP'].tolist()
context = {
'ans': ans,
'assault_lat': assault_lat,
'assault_lon': assault_lon,
'assault_val': assault_val,
'assault_len': assault_len,
'assault_zip': assault_zip,
'robbery_lat': robbery_lat,
'robbery_lon': robbery_lon,
'robbery_val': robbery_val,
'robbery_len': robbery_len,
'robbery_zip': robbery_zip,
'homicide_lat': homicide_lat,
'homicide_lon': homicide_lon,
'homicide_val': homicide_val,
'homicide_len': homicide_len,
'homicide_zip': homicide_zip,
'theft_lat': theft_lat,
'theft_lon': theft_lon,
'theft_val': theft_val,
'theft_len': theft_len,
'theft_zip': theft_zip,
'battery_lat': battery_lat,
'battery_lon': battery_lon,
'battery_val': battery_val,
'battery_len': battery_len,
'battery_zip': battery_zip,
'burglary_lat': burglary_lat,
'burglary_lon': burglary_lon,
'burglary_val': burglary_val,
'burglary_len': burglary_len,
'burglary_zip': burglary_zip,
'sexual_assault_lat': sexual_assault_lat,
'sexual_assault_lon': sexual_assault_lon,
'sexual_assault_val': sexual_assault_val,
'sexual_assault_len': sexual_assault_len,
'sexual_zip': sexual_zip
}
return HttpResponse(template.render(context, request))
def index(request):
template = loader.get_template('anas/nav.html')
return HttpResponse(template.render())
def geo_obj_index(request):
template = loader.get_template('obj/geo_obj_index.html')
context = {}
return HttpResponse(template.render(context,request))
def index(request):
template = loader.get_template('counselorEditor/index.html')
context = {
}
return HttpResponse(template.render(context, request))
def professorsView(request):
inside_professors = connection.cursor()
inside_professors.execute("""
SELECT p.*
FROM beldsi_base.professors_professors p
WHERE p.isdualjobholder = 0
;
""")
inProfessors = inside_professors.fetchall()
dualJobholderProfessors = connection.cursor()
dualJobholderProfessors.execute("""
SELECT p.*
FROM beldsi_base.professors_professors p
WHERE p.isdualjobholder = 1
;
""")
dualJobProfessors = dualJobholderProfessors.fetchall()
dualProfessors = connection.cursor()
dualProfessors.execute("""
SELECT p.*
FROM beldsi_base.professors_professors2 p
;
""")
professors2 = dualProfessors.fetchall()
dual_job_holder = connection.cursor()
dual_job_holder.execute("""
SELECT * FROM beldsi_base.professors_dual_job_holder;
""")
professors3 = dual_job_holder.fetchall()
# ВЫБОРКА ПУНКТОВ МЕНЮ
menu_main = connection.cursor()
menu_main.execute("""
SELECT * FROM beldsi_base.professors_menu_main;
""")
menuMain = menu_main.fetchall()
# ВЫБОРКА ПОД-ПУНКТОВ МЕНЮ
menu_item = connection.cursor()
menu_item.execute("""
SELECT * FROM beldsi_base.professors_menu_item;
""")
menuItem = menu_item.fetchall()
# Внимание! Если хочешь не иметь проблем с CSRF
# то везде используй RequestContext!
templ = get_template('professors.html')
html = templ.render(
RequestContext(
request, {
'inProfessors': inProfessors,
'dualJobProfessors': dualJobProfessors,
'professors2': professors2,
'professors3': professors3,
'menuMain': menuMain,
'menuItem': menuItem,
}))
return HttpResponse(html)
def trends(request):
global data_crimes_per_year
global crime_type
global raw_crime_data
global year
global trends_crime_data
global location_crimes_per_year
global arrest_crimes_per_year
global trend_location_data
global trend_arrest_data
cursor, conn = db_conn()
# if(raw_crime_data.empty):
# extract_raw_crime_data(conn)
# raw_crime_data['year'] = raw_crime_data['Date'].str[6:10]
# raw_crime_data['month'] = raw_crime_data['Date'].str[:2]
# raw_crime_data['day'] = raw_crime_data['Date'].str[3:5]
# raw_crime_data['time'] = raw_crime_data['Date'].str[11:]
if (not data_crimes_per_year):
query_crimes_per_year = "SELECT `Primary Type`, year, SUM(num_crimes) as NUM_CRIMES \
FROM testdb.temp_crime_data_grouped_weekly \
WHERE year NOT LIKE '2001'\
GROUP BY `Primary Type`, year\
ORDER BY year"
data_crimes_per_year = extract_data(cursor, query_crimes_per_year)
if (not location_crimes_per_year):
query_location_crimes_per_year = """SELECT * FROM testdb.crimes_by_location_description
WHERE `Location Description` IN ('ABANDONED BUILDING', 'STREET', 'ALLEY', 'SIDEWALK', 'APARTMENT', 'RESIDENCE', 'SMALL RETAIL STORE')
ORDER BY record_year, `Location Description`"""
location_crimes_per_year = extract_data(
cursor, query_location_crimes_per_year)
if (not arrest_crimes_per_year):
query_arrest_crimes_per_year = """SELECT * FROM testdb.Arrest_Count_By_Year
ORDER BY `Year`, `Primary Type`"""
arrest_crimes_per_year = extract_data(cursor,
query_arrest_crimes_per_year)
weekdata = ['first', 'second']
for row in data_crimes_per_year:
if (row[0] not in crime_type):
crime_type.append(row[0])
if (row[1] not in year):
year.append(row[1])
if (row[1] in trends_crime_data):
trends_crime_data[row[1]][row[0]] = row[2]
else:
trends_crime_data[row[1]] = {row[0]: row[2]}
locations_list = []
trend_location_data = {
'2012': [],
'2013': [],
'2014': [],
'2015': [],
'2016': [],
'2017': []
}
#trend_location_data = {'2012': []}
for row in location_crimes_per_year:
if (row[1] not in locations_list):
locations_list.append(row[1])
if (str(row[2]) in trend_location_data):
trend_location_data[str(row[2])].append(row[0])
#type_list = []
trend_arrest_data = {
'ASSAULT': [],
'BATTERY': [],
'BURGULARY': [],
'CRIM SEXUAL ASSAULT': [],
'HOMICIDE': [],
'ROBBERY': [],
'THEFT': []
}
for row in arrest_crimes_per_year:
if (str(row[1]) in trend_arrest_data):
trend_arrest_data[str(row[1])].append(row[2])
print(locations_list)
print(trends_crime_data)
print(trend_location_data)
print(trend_arrest_data)
template = loader.get_template('trends.html')
context = {
'crime_type': crime_type,
'year': year,
'weekdata': weekdata,
'crime_data': trends_crime_data,
'location_data': trend_location_data,
'locations_list': locations_list,
'arrest_data': trend_arrest_data
}
return HttpResponse(template.render(context, request))
def product_detail(request, pk):
product = get_object_or_404(Product, pk=pk)
template = loader.get_template('product_detail.html')
context = {'product': product}
return HttpResponseRedirect(
reverse('productos:product_detail', args=(product.pk)))
def view_geo_obj(request, id=None):
instance = get_object_or_404(GeoObject, id=id)
context = {"GeoObj":instance}
template = loader.get_template('obj/view_geom.html')
return HttpResponse(template.render(context,request))
def index(request):
context = {}
template = loader.get_template('app/report.html')
return HttpResponse(template.render(context, request))
def hello_world(request):
product = Product.objects.order_by('id')
template = loader.get_template('index.html')
context = {'product': product}
return HttpResponse(template.render(context, request))
def gentella_html(request):
context = {}
load_template = request.path.split('/')[-1]
template = loader.get_template('app/' + load_template)
return HttpResponse(template.render(context, request))
def all_plans(request):
template = loader.get_template('plan/all_plans.html')
context = {'plans': Plan.all()}
return HttpResponse(template.render(context, request))
