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))