def send_collaborator_added_email(request, user, submitter, project_name, role, email_recipients): fields = { 'username': user.username, 'project': project_name, 'submitter': submitter.username, 'role': role } subject = render( 'email/collaborator-added.subject.txt', fields, request=request ) body = render( 'email/collaborator-added.body.txt', fields, request=request ) for recipient in email_recipients: request.task(send_email).delay( subject, body, recipient=_compute_recipient(recipient), ) return fields
def send_email_verification_email(request, user, email): token_service = request.find_service(ITokenService, name='email') token = token_service.dumps({ "action": "email-verify", "email.id": email.id, }) fields = { 'token': token, 'email_address': email.email, 'n_hours': token_service.max_age // 60 // 60, } subject = render( 'email/verify-email.subject.txt', fields, request=request ) body = render( 'email/verify-email.body.txt', fields, request=request ) request.task(send_email).delay( subject, body, recipient=_compute_recipient(user, email=email.email), ) return fields
def send_termination_mail(request, user): mailer = get_mailer(request) support_email = request.registry.settings.get('mail.support_email', '*****@*****.**') site_name = request.registry.settings.get("site.name", "eduID") context = { 'support_mail': support_email, 'displayName': user.get_display_name() } message = Message( subject=_("{site_name} account termination").format( site_name=site_name), sender=request.registry.settings.get("mail.default_sender"), recipients=[user.get_mail()], body=render( "templates/termination_email.txt.jinja2", context, request, ), html=render( "templates/termination_email.html.jinja2", context, request, ), ) # Development if request.registry.settings.get("development", '') == 'true': print message.body else: mailer.send(message) log.debug("Sent termination mail to user {!r} with address {!s}.".format(user, user.get_mail())) request.stats.count('dashboard/email_send_termination_mail', 1)
def generate(request, user): """ Generate an email for a user password reset request. :param request: the current request :type request: pyramid.request.Request :param user: the user to whom to send the reset code :type user: h.models.User :returns: a 4-element tuple containing: recipients, subject, text, html """ serializer = request.registry.password_reset_serializer code = serializer.dumps(user.username) context = { 'username': user.username, 'reset_code': code, 'reset_link': request.route_url('account_reset_with_code', code=code) } subject = _('Reset your password') text = render('h:templates/emails/reset_password.txt.jinja2', context, request=request) html = render('h:templates/emails/reset_password.html.jinja2', context, request=request) return [user.email], subject, text, html
def send_verification_mail(request, email, code=None): mailer = get_mailer(request) if code is None: code = new_verification_code(request, "mailAliases", email, request.context.user, hasher=get_short_hash) verification_link = generate_verification_link(request, code, "mailAliases") site_name = request.registry.settings.get("site.name", "eduID") context = { "email": email, "verification_link": verification_link, "site_url": request.context.safe_route_url("home"), "site_name": site_name, "code": code, } message = Message( subject=_("{site_name} confirmation email").format(site_name=site_name), sender=request.registry.settings.get("mail.default_sender"), recipients=[email], body=render("templates/verification_email.txt.jinja2", context, request), html=render("templates/verification_email.html.jinja2", context, request), ) mailer.send(message)
def testRenderInlineCached(self): self.config.add_renderer(name='chart', factory='chartfood.InlineChartRenderer') cache = DummyCache() rendered = render('chart', {'datasource_url': 'http://test.com/data', 'cache': cache, 'container_id': 'foo'}) expected = '\n'.join(( self.inline_prefix, " containerId: 'foo',", " chartType: 'LineChart',", " dataSourceUrl: 'http://test.com/data',", self.inline_postfix)) self.assertEqual(rendered, expected) cache['http://test.com/data'] = self.day_score rendered = render('chart', {'datasource_url': 'http://test.com/data', 'cache': cache, 'container_id': 'foo'}) expected = '\n'.join(( self.inline_prefix, " containerId: 'foo',", " chartType: 'LineChart',", " dataTable: {},".format(self.day_score_json), self.inline_postfix)) self.assertEqual(rendered, expected)
def email_preview(context, request): notification_email_data = { 'document_title': 'A very important article', 'document_path': 'http://example.com/article?some-long=query', 'parent_text': 'This is the parent comment', 'parent_user': '******', 'parent_tags': 'comment, important, news', 'parent_timestamp': datetime.now() - timedelta(hours=1), 'parent_user_profile': 'https://hypothes.is/u/toby', 'parent_path': 'https://hypothes.is/a/123456789', 'reply_text': 'This is a reply to the parent comment', 'reply_user': '******', 'reply_timestamp': datetime.now(), 'reply_user_profile': 'https://hypothes.is/u/anna', 'reply_path': 'http://hypothes.is/a/abcdefghijk', } return { 'emails': ( { 'title': 'Notification Email', 'subject': render(ReplyTemplate.subject, notification_email_data, request), 'text': render(ReplyTemplate.text_template, notification_email_data, request), 'html': render(ReplyTemplate.html_template, notification_email_data, request), }, ) }
def generate(): achievements = Achievement.get_achievements_by_user_for_today(user) def ea(achievement): try: #print "evaluating "+`achievement["id"]` return Achievement.evaluate(user, achievement["id"]) except FormularEvaluationException as e: return { "error": "Cannot evaluate formular: " + e.message, "id" : achievement["id"] } except Exception as e: tb = traceback.format_exc() return { "error": tb, "id" : achievement["id"] } check = lambda x : x!=None and not x.has_key("error") and (x["hidden"]==False or x["level"]>0) evaluatelist = [ea(achievement) for achievement in achievements] ret = { "achievements" : { x["id"] : x for x in evaluatelist if check(x) }, "achievement_errors" : { x["id"] : x for x in evaluatelist if x!=None and x.has_key("error") } } if return_object: return render("json",ret),ret else: return render("json",ret)
def start(self, context, request, appstruct, **kw): user = get_current() source = appstruct['source'] targets = appstruct['targets'] if can_access(user, source) and all(can_access(user, target) for target in targets): diff_bodies = {} source_view = renderers.render( source.templates.get('diff', None), {'object': source}, request) for target in targets: target_view = renderers.render( target.templates.get('diff', None), {'object': target}, request) soupt, textdiff = html_diff_wrapper.render_html_diff( source_view, target_view) diff_bodies[target] = (textdiff, get_oid(target)) return {'context_view': source_view, 'contents': diff_bodies} return {}
def _add_modal(self, explanations, process, soup, tag, context, request): context_oid = get_oid(context) dace_ui_api = get_current_registry().getUtility(IDaceUIAPI, 'dace_ui_api') explanationitemaction = None explanationitem_actions = process.get_actions('explanationitem') if explanationitem_actions: explanationitemaction = explanationitem_actions[0] if explanationitemaction: values = {'url': request.resource_url(context, '@@explanationjson', query={'op': 'getform', 'itemid': tag['data-item']}), 'item': explanations[tag['data-item']], } body = renderers.render(self.explanation_template, values, request) explanation_item_soup = BeautifulSoup(body) actionurl_update = dace_ui_api.updateaction_viewurl( request=request, action_uid=str(get_oid(explanationitemaction)), context_uid=str(context_oid)) values = {'url': actionurl_update, 'item': explanations[tag['data-item']], } modal_body = renderers.render(self.modal_template, values, request) explanation_item_modal_soup = BeautifulSoup(modal_body) soup.body.append(explanation_item_modal_soup.body) tag.append(explanation_item_soup.body) tag.body.unwrap()
def test_with_request_content_type_notset(self): from pyramid.renderers import render from mootiro_web.crypto import enable_crypto enable_crypto(self.config, rsa_key=self.rsa_key) request = testing.DummyRequest() render('json.encrypted', {'a': 1}, request) self.assertEqual(request.response.content_type, 'application/json')
def send_password_reset_email(request, user): token_service = request.find_service(ITokenService, name='password') token = token_service.dumps({ 'action': 'password-reset', 'user.id': str(user.id), 'user.last_login': str(user.last_login), 'user.password_date': str(user.password_date), }) fields = { 'token': token, 'username': user.username, 'n_hours': token_service.max_age // 60 // 60, } subject = render( 'email/password-reset.subject.txt', fields, request=request, ) body = render( 'email/password-reset.body.txt', fields, request=request, ) request.task(send_email).delay(body, [user.email], subject) # Return the fields we used, in case we need to show any of them to the # user return fields
def repr_filter(filter_data, request, template_type='default'): filter_schema = FilterSchema() global_template = FILTER_TEMPLATES['global'][template_type] filter_template = FILTER_TEMPLATES['filter'][template_type] all_filters = [] for filter_ in filter_data: filter_values = [] for child in filter_schema.children: name = child.name value = filter_.get(name, _marker) if hasattr(child, 'repr_value') and \ value is not _marker: filter_values.append( child.repr_value( value, request, template_type)) values = {'bodies': filter_values} all_filters.append(renderers.render( filter_template, values, request)) values = {'bodies': all_filters} body = renderers.render( global_template, values, request) return body
def test_render(self): from pyramid.renderers import render from mootiro_web.crypto import enable_crypto enable_crypto(self.config, rsa_key=self.rsa_key) result_normal = render('json', {'a': 1}) result_encrypted = render('json.encrypted', {'a': 1}) self.assertNotEqual(result_normal, result_encrypted)
def export_chat(chat_id: int, user_id: int): settings = app.conf["PYRAMID_REGISTRY"].settings log.info("Starting export for chat %s, user %s." % (chat_id, user_id)) with db_session() as db, TemporaryDirectory() as workspace: start_time = datetime.datetime.now() chat = db.query(Chat).filter(Chat.id == chat_id).one() user = db.query(User).filter(User.id == user_id).one() try: chat_user = db.query(ChatUser).filter(and_(ChatUser.chat_id == chat_id, ChatUser.user_id == user_id)).one() except NoResultFound: # ChatUser has probably been deleted since the export was triggered. delete_expired_export.apply_async((chat_id, user_id), countdown=5) raise chat_export = db.query(ChatExport).filter(and_(ChatExport.chat_id == chat_id, ChatExport.user_id == user_id)).one() if export_chat.request.id and chat_export.celery_task_id != export_chat.request.id: raise RuntimeError("Current task ID doesn't match value in database.") message_count = db.query(func.count("*")).select_from(Message).filter(Message.chat_id == chat_id).scalar() page_count = int(math.ceil(message_count/MESSAGES_PER_PAGE)) filename = "%s.zip" % chat.url file_in_workspace = os.path.join(workspace, filename) with ZipFile(file_in_workspace, "w", ZIP_DEFLATED) as f: f.write(resource_filename("cherubplay", "static/cherubplay2.css"), "cherubplay2.css") f.write(resource_filename("cherubplay", "static/logo.png"), "logo.png") for n in range(page_count): log.info("Processing page %s of %s." % (n+1, page_count)) messages = ( db.query(Message) .filter(Message.chat_id == chat_id) .order_by(Message.id) .offset(n * MESSAGES_PER_PAGE).limit(MESSAGES_PER_PAGE).all() ) f.writestr("%s.html" % (n+1), render("export/chat.mako", { "chat": chat, "user": user, "chat_user": chat_user, "messages": messages, "current_page": n+1, "messages_per_page": MESSAGES_PER_PAGE, "message_count": message_count, })) f.writestr("%s.json" % (n+1), render("json", messages)) f.writestr("chat.json", render("json", chat)) f.writestr("chat_user.json", render("json", chat_user)) chat_export.filename = filename chat_export.generated = start_time chat_export.expires = datetime.datetime.now() + datetime.timedelta(int(settings["export.expiry_days"])) pathlib.Path(os.path.join(app.conf["PYRAMID_REGISTRY"].settings["export.destination"], chat_export.file_directory)).mkdir(parents=True, exist_ok=True) os.rename(file_in_workspace, os.path.join(app.conf["PYRAMID_REGISTRY"].settings["export.destination"], chat_export.file_path)) log.info("Finished export for chat %s, user %s." % (chat_id, user_id))
def columns(context, request, *args, **kwargs): api = kwargs['api'] group_name = kwargs['group_name'] util = request.registry.getUtility(IViewGroup, name = group_name) response = {} #Col 1 col_one_name = kwargs['col_one'] #Required col_one_va = util.get(col_one_name, None) if col_one_va: response['column_one'] = col_one_va(context, request, api = api) else: response['column_one'] = "Error: Can't find view action '%s' in group '%s'." % (col_one_name, group_name) #Col 2 col_two_name = kwargs.get('col_two', None) if not col_two_name: return render('../templates/snippets/one_column.pt', response, request = request) col_two_va = util.get(col_two_name, None) if col_two_va: response['column_two'] = col_two_va(context, request, api = api) else: response['column_two'] = "Error: Can't find view action '%s' in group '%s'." % (col_two_name, group_name) return render('../templates/snippets/two_columns.pt', response, request = request)
def main_view(context, request): """ Main site page view. Renders main template with angularjs app. It returns to renderer only number of checked presentations """ if request.method == 'GET': return Response( render('templates/index.pt', {'count': context.count}, request)) settings = request.registry.settings rule = request.POST.get('check_rule', None) validation_error = validate_rule(rule) if validation_error: request.response.status_code = 400 return Response(render('json', validation_error, request)) max_allowed_size = int(settings.get('max_allowed_size', 15000000)) upload_file = request.POST.get('file', None) validation_error = validate_upload_file(upload_file, max_allowed_size) if validation_error: request.response.status_code = 400 return Response(render('json', validation_error, request)) jobs_manager = settings['jobs_manager'] info = jobs_manager.add_new_job(upload_file.file, rule) request.response.status_code = info.pop('status_code') context.increment() return Response(render('json', info, request))
def email_preview(context, request): notification_email_data = { 'document_title': 'A very important article', 'document_path': 'http://example.com/article?some-long=query', 'parent_text': 'This is the parent comment', 'parent_user': '******', 'parent_tags': 'comment, important, news', 'parent_timestamp': '17 November at 15:47', 'parent_user_profile': 'https://hypothes.is/u/toby', 'parent_path': 'https://hypothes.is/a/123456789', 'reply_text': 'This is a reply to the parent comment', 'reply_user': '******', 'reply_timestamp': '23 December 2013 at 15:47', 'reply_user_profile': 'https://hypothes.is/u/anna', 'reply_path': 'http://hypothes.is/a/abcdefghijk', } return { 'emails': ( { 'title': 'Notification Email', 'subject': render(reply_template.SUBJECT_TEMPLATE, notification_email_data, request), 'text': render(reply_template.TXT_TEMPLATE, notification_email_data, request), 'html': render(reply_template.HTML_TEMPLATE, notification_email_data, request), }, ) }
def password_reminder(email, request): """ For an email address, find the corresponding team and send a password reset token. If no team is found send an email that no user was found for this address. """ mailer = get_mailer(request) team = DBSession.query(Team).filter(Team.email == email).first() if team: # send mail with reset token team.reset_token = random_token() html = render('mail_password_reset_valid.mako', {'team': team}, request=request) recipients = [team.email] else: # send mail with information that no team was found for that address. html = render('mail_password_reset_invalid.mako', {'email': email}, request=request) recipients = [email] competition = request.registry.settings['competition_title'] message = Message(subject="Password Reset for %s" % competition, recipients=recipients, html=html, ) mailer.send(message) return team
def send_reset_password_mail(request, user, reset_password_link): """ Send an email with the instructions for resetting password """ mailer = get_mailer(request) site_name = request.registry.settings.get("site.name", "eduID") password_reset_timeout = int(request.registry.settings.get("password_reset_timeout", "120")) / 60 email = user.get_mail() context = { "email": email, "reset_password_link": reset_password_link, "password_reset_timeout": password_reset_timeout, "site_url": request.route_url("home"), "site_name": site_name, } message = Message( subject=_("Reset your {site_name} password").format( site_name=site_name), sender=request.registry.settings.get("mail.default_sender"), recipients=[email], body=render( "templates/reset-password-email.txt.jinja2", context, request, ), html=render( "templates/reset-password-email.html.jinja2", context, request, ), ) mailer.send(message)
def generate(request, id, email, activation_code): """ Generate an email for a user signup. :param request: the current request :type request: pyramid.request.Request :param id: the new user's primary key ID :type id: int :param email: the new user's email address :type email: text :param activation_code: the activation code :type activation_code: text :returns: a 4-element tuple containing: recipients, subject, text, html """ context = { "activate_link": request.route_url("activate", id=id, code=activation_code) } subject = _("Please activate your account") text = render("h:templates/emails/signup.txt.jinja2", context, request=request) html = render("h:templates/emails/signup.html.jinja2", context, request=request) return [email], subject, text, html
def send_bplan_submission_confirmation_email(event): """Notify office worker and creator about created bplan version.""" if not hasattr(event.registry, 'messenger'): # ease testing return messenger = event.registry.messenger proposal_version = event.object if not _is_proposal_creation_finished(proposal_version): return appstruct = _get_appstruct(proposal_version) process_settings = _get_all_process_settings(proposal_version) if process_settings['plan_number'] == 0 or \ process_settings['office_worker_email'] is None: return templates_values = _get_templates_values(process_settings, appstruct) subject = 'Ihre Stellungnahme zum Bebauungsplan {plan_number}, ' \ '{participation_kind} von {participation_start_date:%d/%m/%Y} ' \ '- {participation_end_date:%d/%m/%Y}.' \ .format(**process_settings) messenger.send_mail(subject, [appstruct['email']], '*****@*****.**', render('adhocracy_meinberlin:templates/' 'bplan_submission_confirmation.txt.mako', templates_values)) messenger.send_mail(subject, [process_settings['office_worker_email']], '*****@*****.**', render('adhocracy_meinberlin:templates/' 'bplan_submission_confirmation.txt.mako', templates_values))
def generate(request, email, incontext_link): """ Generate an email to notify the group admin when a group member flags an annotation. :param request: the current request :type request: pyramid.request.Request :param email: the group admin's email address :type email: text :param incontext_link: the direct link to the flagged annotation :type incontext_link: text :returns: a 4-element tuple containing: recipients, subject, text, html """ context = {"incontext_link": incontext_link} subject = _("An annotation has been flagged") text = render( "h:templates/emails/flag_notification.txt.jinja2", context, request=request ) html = render( "h:templates/emails/flag_notification.html.jinja2", context, request=request ) return [email], subject, text, html
def ergebnisse_view(request): session = request.session set_language(request) lang = get_language(request) uid = 0 last_updated = '' if 'uid' in session: if session['uid'] is not None: uid = session['uid'] conn = pymysql.connect(host=config['host'], port=config['port'], user=config['user'], passwd=config['pw'], db=config['db']) cur = conn.cursor() resT = get_select_taxa(cur, lang) sql_last_update = """SELECT DATE_FORMAT(`date`, '%d.%m.%Y %H:%i:%s') FROM Sync_Transfer_Log""" cur.execute(sql_last_update) for row in cur.fetchall(): last_updated = row[0] cur.close() conn.close() resS = get_select_states(lang) message = request.session.pop_flash() if len(message) < 1: result = render('templates/%s/ergebnisse/ergebnisse.pt' % lang, {'uid': uid, 'lan': lang, 'select_taxa': resT, 'select_states': resS,'last_updated': last_updated}, request=request) else: message = message[0] result = render('templates/%s/ergebnisse/ergebnisse.pt' % lang, {'uid': uid, 'lan': lang, 'select_taxa': resT, 'select_states': resS, 'last_updated': last_updated, 'message': message}, request=request) response = Response(result) return response
def forbidden_view(context, request): user = authenticated_userid(request) if user is not None: try: reason = context.explanation except AttributeError: reason = 'unknown' logger.debug("User %s tripped Forbidden view, request %s, " "reason %s"%(str(user), str(request), str(reason))) if request.db.settings.find_one({'key':'maintenance_mode'}).get('value', False): msg = request.db.settings.find_one({'key':'maintenance_message'}) if msg is not None: msg = msg['value'] response = Response(render('templates/maintenance.jinja2', {'request': request,'maintenance_msg': msg})) request.session.delete() response.status_int = 200 else: response = Response(render('templates/forbidden.jinja2', {})) response.status_int = 403 return response if user is None and (request.is_xhr or request.headers.get('content-type') == 'application/json'): response = Response(render('templates/forbidden.jinja2', {})) response.status_int = 403 return response logger.debug("No user and forbidden access! --> redirect to login") loginurl = request.route_url('login', _query=(('next', request.path),)) return HTTPFound(location=loginurl)
def render_reply_notification(request, annotation, parent): # Render e-mail parts tmap = create_template_map(request, annotation, parent) text = render(TXT_TEMPLATE, tmap, request).strip() html = render(HTML_TEMPLATE, tmap, request).strip() subject = render(SUBJECT_TEMPLATE, tmap, request).strip() recipients = get_recipients(request, parent) return subject, text, html, recipients
def navigation_sections(context, request, va, **kwargs): """ Navigation sections. These doesn't work for unauthenticated currently. """ api = kwargs['api'] if not api.userid: return u"" state = va.kwargs['state'] response = {} response['api'] = api response['state'] = state response['section_title'] = va.title response['toggle_id'] = '%s-%s' % (context.uid, state) if request.cookies.get(response['toggle_id']): response['closed_section'] = True return render('templates/sidebars/navigation_section.pt', response, request = request) context_path = resource_path(context) query = dict( workflow_state = state, path = context_path, ) #Meeting or root context? if ISiteRoot.providedBy(context): query['content_type'] = 'Meeting' #Note that None is not a valid query. This view shouldn't be called for unauthenticated. query['view_meeting_userids'] = api.userid else: query['content_type'] = 'AgendaItem' #Principals taken from this context will be okay for a query within the meetings query['allowed_to_view'] = {'operator': 'or', 'query': api.context_effective_principals(context)} query['sort_index'] = 'order' def _count_query(path, content_type, unread = False): """ Returns number of an item, possbly unread only. """ query = {} query['path'] = path query['content_type'] = content_type if content_type == 'Proposal': query['workflow_state'] = {'query':('published', 'retracted', 'unhandled', 'voting', 'approved', 'denied'), 'operator':'or'} if unread: query['unread'] = api.userid return api.search_catalog(**query)[0] def _in_current_context(path, context_path): path = path.split('/') context_path = context_path.split('/') if len(path) > len(context_path): path = path[0:len(context_path)] return path == context_path response['brains'] = api.get_metadata_for_query(**query) response['context_path'] = context_path response['count_query'] = _count_query response['closed_section'] = False response['in_current_context'] = _in_current_context return render('templates/sidebars/navigation_section.pt', response, request = request)
def test_mails(self): user = User(u"test") user.data["token"] = "123" values = {"user": user, "url":"uuu", "password": "******"} render("nive_userdb.userview:mails/notify.pt", values) render("nive_userdb.userview:mails/signup.pt", values) render("nive_userdb.userview:mails/verifymail.pt", values) render("nive_userdb.userview:mails/mailpass.pt", values) render("nive_userdb.userview:mails/resetpass.pt", values)
def approvalqueue(context, request): if context.user.isAdmin: result = GetSubmittedProfiles(request, context.user) submitted= ifilter(methodcaller("isSubmitted"), result) approved = ifilter(methodcaller("isReviewed"), result) else: submitted, approved = [], [] return {"success": True , "html": {"submitted":render("larryslist:admin/templates/ajax/approvalqueue.html", {'profiles': submitted}, request).strip() , "approved":render("larryslist:admin/templates/ajax/approvalqueue.html", {'profiles': approved}, request).strip()}}
def send_templated_mail(request, recipients, template, context, sender=None): """Send out templatized HTML and plain text emails. Each HTML email should have a plain text fallback. Premailer package is used to convert any CSS styles in HTML email messages to inline, so that email clients display them. The email is assembled from three different templates: * Read subject from a subject specific template $template.subject.txt * Generate HTML email from HTML template, $template.body.html * Generate plain text email from HTML template, $template.body.txt Make sure you have configured your template engine (Jinja 2) to read TXT templates beside HTML. :param request: HTTP request, passed to the template engine. Request configuration is used to get hold of the configured mailer. :param recipients: List of recipient emails :param template: Template filename base string for template tripled (subject, HTML body, plain text body). For example ``email/my_message`` would map to templates ``email/my_message.subject.txt``, ``email/my_message.body.txt``, ``email/my_message.body.html`` :param context: Template context variables as a dict :param sender: Override the sender email - if not specific use the default set in the config as ``mail.default_sender`` """ assert recipients assert len(recipients) > 0 assert type(recipients) != str, "Please give a list of recipients, not a string" for r in recipients: assert r, "Received empty recipient when sending out email {}".format(template) subject = render(template + ".subject.txt", context, request=request) subject = subject.strip() html_body = render(template + ".body.html", context, request=request) text_body = render(template + ".body.txt", context, request=request) if not sender: sender = request.registry.settings["mail.default_sender"] # Add enveloped From: sender_name = request.registry.settings.get("mail.default_sender_name") if sender_name: sender = formataddr((str(Header(sender_name, 'utf-8')), sender)) # Inline CSS styles html_body = premailer.transform(html_body) message = Message(subject=subject, sender=sender, recipients=recipients, body=text_body, html=html_body) mailer = get_mailer(request) mailer.send(message)
def __call__(self, api): return render('templates/community_sidebar.pt', dict(api=api), request=self.request)
def to_json(value): """ A json filter for jinja2 """ return render('json', value)
def test_tmplcache(self): text = DummyText() text.useCache = True html = render("nive_markdowntext:mtext.pt", {"context": text}) self.assert_(html) self.assert_(html.find(text.data.tcache) != -1)
def prep_views(chosen_frontend, config): # some logic (NOT all) has been moved to views to be more 'pyramid-y' config.scan('src.sgd.frontend.yeastgenome.views.misc_views') config.scan('src.sgd.frontend.yeastgenome.views.locus_views') # misc pages from misc_views config.add_route('healthcheck', '/healthcheck') config.add_route('redirect_no_overview', '/{ignore}/overview') config.add_route('redirect_no_overview_long', '/{ignore_a}/{ignore_b}/overview') config.add_route('home', '/') config.add_route('blast_fungal', '/blast-fungal') config.add_route('blast_sgd', '/blast-sgd') config.add_route('patmatch', '/nph-patmatch') config.add_route('seq_tools', '/seqTools') config.add_route('blog_post', '/blog/{slug}') config.add_route('blog_index', '/blog') config.add_route('blog_archive', '/blog/archive/{year}') config.add_route('blog_category', '/blog/category/{category}') config.add_route('blog_tag', '/blog/tag/{tag}') config.add_route('colleague_show', '/colleague/{identifier}') config.add_route('downloads', '/downloads') config.add_route('interaction_search', '/interaction-search') config.add_route('download_list', '/download-list') config.add_route('snapshot', '/genomesnapshot') config.add_route('style_guide', '/style-guide') config.add_route('suggestion', '/suggestion') config.add_route('variant_viewer', '/variant-viewer') config.add_route('search', '/search') config.add_route('primer3', '/primer3') # config.add_route('example', '/example') # locus pages from locus_views config.add_route('locus', '/locus/{identifier}') config.add_route('sequence_details', '/locus/{identifier}/sequence') config.add_route('protein_details', '/locus/{identifier}/protein') config.add_route('go_details', '/locus/{identifier}/go') config.add_route('phenotype_details', '/locus/{identifier}/phenotype') config.add_route('interaction_details', '/locus/{identifier}/interaction') config.add_route('regulation_details', '/locus/{identifier}/regulation') config.add_route('expression_details', '/locus/{identifier}/expression') config.add_route('literature_details', '/locus/{identifier}/literature') config.add_route('curator_sequence', '/curator/locus/{identifier}/sequence') # references config.add_route('references_this_week', '/reference/recent') config.add_route('reference', '/reference/{identifier}') config.add_route('phenotype', '/phenotype/{identifier}') # public CI config.add_route('new_gene_name_reservation', 'reserved_name/new') config.add_route('new_colleague', 'colleague_update') config.add_route('author', '/author/{identifier}') config.add_view( lambda request: chosen_frontend.response_wrapper('author', request) (getattr(chosen_frontend, 'author')(request.matchdict['identifier'])), renderer=chosen_frontend.get_renderer('author'), route_name='author') config.add_route('strain', '/strain/{identifier}') config.add_view( lambda request: chosen_frontend.response_wrapper('strain', request) (getattr(chosen_frontend, 'strain')(request.matchdict['identifier'])), renderer=chosen_frontend.get_renderer('strain'), route_name='strain') config.add_route('redirect', '/redirect/{page}') config.add_view(lambda request: getattr(chosen_frontend, 'redirect') (page=request.matchdict['page'], params=request.GET), renderer=chosen_frontend.get_renderer('redirect'), route_name='redirect') config.add_route('header', '/header') config.add_view(lambda request: {'header': render('static/templates/header.jinja2', {})}, renderer=chosen_frontend.get_renderer('header'), route_name='header') config.add_route('footer', '/footer') config.add_view(lambda request: {'footer': render('static/templates/footer.jinja2', {})}, renderer=chosen_frontend.get_renderer('footer'), route_name='footer') config.add_route('download_table', '/download_table') config.add_view( lambda request: chosen_frontend.response_wrapper( 'download_table', request) (getattr(chosen_frontend, 'download_table') (response=request.response, header_info=None if 'headers' not in request.POST else json.loads( request.POST['headers']), data=None if 'data' not in request.POST else json.loads(request.POST['data']), display_name=None if 'display_name' not in request.POST else request. POST['display_name'])), renderer=chosen_frontend.get_renderer('download_table'), route_name='download_table') config.add_route('download_image', '/download_image') config.add_view(lambda request: chosen_frontend.response_wrapper( 'download_image', request) (getattr(chosen_frontend, 'download_image') (response=request.response, data=None if 'data' not in request.POST else request.POST['data'], display_name=None if 'display_name' not in request.POST else request.POST['display_name'])), renderer=chosen_frontend.get_renderer('download_image'), route_name='download_image') config.add_route('download_citations', '/download_citations') config.add_view( lambda request: chosen_frontend.response_wrapper( 'download_citations', request) (getattr(chosen_frontend, 'download_citations') (response=request.response, reference_ids=[] if 'reference_ids' not in request.POST else request. POST['reference_ids'].split(','), display_name=None if 'display_name' not in request.POST else request.POST[ 'display_name'])), renderer=chosen_frontend.get_renderer('download_citations'), route_name='download_citations') config.add_route('download_sequence', '/download_sequence') config.add_view( lambda request: chosen_frontend.response_wrapper( 'download_sequence', request) (getattr(chosen_frontend, 'download_sequence') (response=request.response, sequence=None if 'sequence' not in request.POST else request.POST['sequence'], header=None if 'header' not in request.POST else request.POST['header'], filename=None if 'filename' not in request.POST else request.POST['filename'])), renderer=chosen_frontend.get_renderer('download_sequence'), route_name='download_sequence') config.add_route('analyze', '/analyze') config.add_view( lambda request: chosen_frontend.response_wrapper('analyze', request) (getattr(chosen_frontend, 'analyze') (bioent_ids=None if 'bioent_ids' not in request.POST else json.loads( request.POST['bioent_ids']), list_name=None if 'list_name' not in request.POST else request.POST['list_name'])), renderer=chosen_frontend.get_renderer('analyze'), route_name='analyze') config.add_route('enrichment', '/enrichment') config.add_view(lambda request: chosen_frontend.response_wrapper( 'enrichment', request)(getattr(chosen_frontend, 'enrichment') (bioent_ids=None if 'bioent_ids' not in request.json_body else request.json_body['bioent_ids'])), renderer=chosen_frontend.get_renderer('enrichment'), route_name='enrichment') # observable root of the ontology, must be redirected to the ypo page config.add_route('phenotype_ontology_apo', '/observable/APO:0000017') config.add_view( lambda request: chosen_frontend.response_wrapper( 'phenotype_ontology', request) (getattr(chosen_frontend, 'phenotype_ontology')()), renderer=chosen_frontend.get_renderer('phenotype_ontology'), route_name='phenotype_ontology_apo') config.add_route('observable', '/observable/{identifier}') config.add_view(lambda request: chosen_frontend.response_wrapper( 'observable', request) (getattr(chosen_frontend, 'observable') (biocon_repr=request.matchdict['identifier'].lower())), renderer=chosen_frontend.get_renderer('observable'), route_name='observable') config.add_route('phenotype_ontology', '/ontology/phenotype/ypo') config.add_view( lambda request: chosen_frontend.response_wrapper( 'phenotype_ontology', request) (getattr(chosen_frontend, 'phenotype_ontology')()), renderer=chosen_frontend.get_renderer('phenotype_ontology'), route_name='phenotype_ontology') config.add_route('ecnumber', '/ecnumber/{identifier}') config.add_view( lambda request: chosen_frontend.response_wrapper('ecnumber', request) (getattr(chosen_frontend, 'ecnumber') (biocon_repr=request.matchdict['identifier'].lower())), renderer=chosen_frontend.get_renderer('ecnumber'), route_name='ecnumber') config.add_route('go', '/go/{identifier}') config.add_view( lambda request: chosen_frontend.response_wrapper('go', request) (getattr(chosen_frontend, 'go') (biocon_repr=request.matchdict['identifier'].lower())), renderer=chosen_frontend.get_renderer('go'), route_name='go') config.add_route('go_ontology', '/ontology/go/{identifier}') config.add_view(lambda request: chosen_frontend.response_wrapper( 'go_ontology', request) (getattr(chosen_frontend, 'go_ontology') (biocon_repr=request.matchdict['identifier'].lower())), renderer=chosen_frontend.get_renderer('go_ontology'), route_name='go_ontology') config.add_route('chemical', '/chemical/{identifier}') config.add_view( lambda request: chosen_frontend.response_wrapper('chemical', request) (getattr(chosen_frontend, 'chemical') (chemical_repr=request.matchdict['identifier'].lower())), renderer=chosen_frontend.get_renderer('chemical'), route_name='chemical') config.add_route('domain', '/domain/{identifier}') config.add_view( lambda request: chosen_frontend.response_wrapper('domain', request) (getattr(chosen_frontend, 'domain') (domain_repr=request.matchdict['identifier'].lower())), renderer=chosen_frontend.get_renderer('domain'), route_name='domain') config.add_route('reserved_name', '/reservedname/{identifier}') config.add_view( lambda request: chosen_frontend.response_wrapper( 'reserved_name', request) (getattr(chosen_frontend, 'reserved_name') (reserved_name_repr=request.matchdict['identifier'].lower())), renderer=chosen_frontend.get_renderer('reserved_name'), route_name='reserved_name') config.add_route('dataset', '/dataset/{identifier}') config.add_view( lambda request: chosen_frontend.response_wrapper('dataset', request) (getattr(chosen_frontend, 'dataset') (bioitem_repr=request.matchdict['identifier'].lower())), renderer=chosen_frontend.get_renderer('dataset'), route_name='dataset') config.add_route('contig', '/contig/{identifier}') config.add_view( lambda request: chosen_frontend.response_wrapper('contig', request) (getattr(chosen_frontend, 'contig') (contig_repr=request.matchdict['identifier'].lower())), renderer=chosen_frontend.get_renderer('contig'), route_name='contig') config.add_route('keyword', '/keyword/{identifier}') config.add_view( lambda request: chosen_frontend.response_wrapper('keyword', request) (getattr(chosen_frontend, 'keyword') (keyword_repr=request.matchdict['identifier'].lower())), renderer=chosen_frontend.get_renderer('keyword'), route_name='keyword') config.add_route('locus_list', '/locus/{list_name}') config.add_view(lambda request: chosen_frontend.response_wrapper( 'locus_list', request)(getattr(chosen_frontend, 'locus_list') (list_name=request.matchdict['list_name'])), renderer=chosen_frontend.get_renderer('locus_list'), route_name='locus_list') config.add_route('experiment', '/experiment/{identifier}') config.add_view( lambda request: chosen_frontend.response_wrapper( 'experiment', request) (getattr(chosen_frontend, 'experiment') (experiment_repr=request.matchdict['identifier'].lower())), renderer=chosen_frontend.get_renderer('experiment'), route_name='experiment') config.add_route('backend', '/backend/*url') config.add_view( lambda request: chosen_frontend.response_wrapper('backend', request) (getattr(chosen_frontend, 'backend') (url_repr=request.matchdict['url'], args=request.GET, request=request )), renderer='json', route_name='backend') config.add_route('send_email', '/send_data') config.add_view(send_message, route_name='send_email') config.add_route('search_sequence_objects', '/search_sequence_objects') config.add_view( lambda request: chosen_frontend.response_wrapper( 'search_sequence_objects', request) (getattr(chosen_frontend, 'search_sequence_objects') (params=request.GET)), renderer=chosen_frontend.get_renderer('search_sequence_objects'), route_name='search_sequence_objects') config.add_route('get_sequence_object', '/get_sequence_object/{id}') config.add_view( lambda request: chosen_frontend.response_wrapper( 'get_sequence_object', request) (getattr(chosen_frontend, 'get_sequence_object') (locus_repr=request.matchdict['id'].lower())), renderer=chosen_frontend.get_renderer('get_sequence_object'), route_name='get_sequence_object') config.add_route('do_blast', '/run_blast') config.add_view(do_blast, route_name='do_blast') config.add_route('do_patmatch', '/run_patmatch') config.add_view(do_patmatch, route_name='do_patmatch') config.add_route('do_seq_analysis', '/run_seqtools') config.add_view(do_seq_analysis, route_name='do_seq_analysis')
def login_form_view(request): logged_in = authenticated_userid(request) return render('templates/login.pt', {'loggedin': logged_in}, request)
def header(self): header_str = render('templates/header.jinja2', {}) return {'header': header_str}
format = form.data.get('format', 'json') try: results = store.execute_sparql(querystr, format=format) if format == 'json': results_json = json.dumps(results, indent=4) elif format == 'xml': try: results_json = serializeXML(results) except: raise except Exception, e: results_json = str(e) raise #results_json = json.dumps([x for x in results]) request.response.content_type = 'text/html' return render( 'models/rdf/templates/sparql_query.jinja2', { 'title': 'sparql', 'form': FormRenderer(form), 'query': querystr, 'results': results_json, }, request) @view_config(permission='view', route_name='deniz', renderer='models/rdf/templates/deniz.jinja2') def deniz(request): return {'title': 'browse'}
def _get_step4_informations(self, context, request): return renderers.render(self.step4_template, {'context': context}, request)
def _get_step3_informations(self, context, request): time_delta = None working_group = context.working_group process = working_group.improvement_cycle_proc is_closed = 'closed' in working_group.state user = get_current() working_group_states = [ _(get_states_mapping(user, working_group, s)) for s in working_group.state ] if 'amendable' in context.state and process: subprocesses = process['work'].sub_processes date_iteration = None if subprocesses: date_iteration = subprocesses[-1]['timer'].eventKind.time_date today = datetime.datetime.now() if date_iteration is not None and date_iteration > today: time_delta = date_iteration - today time_delta = days_hours_minutes(time_delta) return renderers.render( self.step3_1_template, { 'context': context, 'working_group_states': working_group_states, 'is_closed': is_closed, 'duration': time_delta, 'process': process }, request) elif 'votes for publishing' in context.state: ballot = working_group.vp_ballot today = datetime.datetime.now(tz=pytz.UTC) if ballot.finished_at is not None and ballot.finished_at > today: time_delta = ballot.finished_at - today time_delta = days_hours_minutes(time_delta) return renderers.render( self.step3_3_template, { 'context': context, 'working_group_states': working_group_states, 'is_closed': is_closed, 'duration': time_delta, 'process': process, 'ballot_report': ballot.report }, request) elif 'votes for amendments' in context.state: voters = [] [ voters.extend(b.report.voters) for b in working_group.amendments_ballots ] voters = list(set(voters)) ballot = working_group.amendments_ballots[-1] today = datetime.datetime.now(tz=pytz.UTC) if ballot.finished_at is not None and ballot.finished_at > today: time_delta = ballot.finished_at - today time_delta = days_hours_minutes(time_delta) return renderers.render( self.step3_2_template, { 'context': context, 'working_group_states': working_group_states, 'is_closed': is_closed, 'duration': time_delta, 'process': process, 'ballot_report': ballot.report, 'voters': voters }, request) elif 'open to a working group' in context.state: participants_mini = getSite().participants_mini work_mode = getattr(working_group, 'work_mode', None) if work_mode: participants_mini = work_mode.participants_mini return renderers.render( self.step3_0_template, { 'context': context, 'process': process, 'min_members': participants_mini }, request) return _('Information unvailable.')
def send_email(mailer, to, from_, subject, template, **data): m = mailer.new(to=to, subject=subject, author=from_, sender=from_) m.rich = render("mailers/%s" % template, data) m.plain = html2text(m.rich) m.send()
def _get_step4_informations(self, context, request): user = get_current() return renderers.render(self.step4_0_template, { 'context': context, 'support': context.evaluation(user) }, request)
def chrome(env): registry = env['registry'] request = env['request'] asset_env = registry.queryUtility(IWebAssetsEnvironment) settings = registry.settings develop = asbool(settings.get('webassets.debug', False)) # Root the request at the app url app_url = urlparse(args[1]) request.host = app_url.netloc request.scheme = app_url.scheme app_url = urlunparse(app_url) # Fully-qualify the static asset url asset_url = urlparse(asset_env.url) if not asset_url.netloc: asset_url = ( request.scheme, request.host, asset_url.path, asset_url.params, asset_url.query, asset_url.fragment, ) asset_url = urlunparse(asset_url) # Configure the load path and output url asset_env.append_path(resolve('h:').abspath(), asset_url) asset_env.url = asset_url def getUrl(url): if not develop: rel = make_relative(request, url) if rel != url: return "chrome.extension.getURL('public/%s')" % rel return '"%s"' % url if develop: # Load the app from the development server. app_expr = "'%s'" % app_url else: # Load the app from the extension bundle. app_expr = "chrome.extension.getURL('public/app.html')" # Build the app html app(env, base_url=app_url) embed = render( 'h:templates/embed.txt', { 'app': app_expr, 'inject': '[%s]' % ', '.join([getUrl(url) for url in asset_env['inject'].urls()]), 'jquery': getUrl(asset_env['jquery'].urls()[0]), 'raf': getUrl(asset_env['raf'].urls()[0]), }, request=request, ) embed_js_file = join(asset_env.directory, 'js/embed.js') with open(embed_js_file, 'w', 'utf-8-sig') as f: f.write(embed) # Chrome is strict about the format of the version string ext_version = '.'.join(version.replace('-', '.').split('.')[:4]) manifest_file = resolve('h:browser/chrome/manifest.json').abspath() manifest_renderer = PageTextTemplateFile(manifest_file) manifest = manifest_renderer(src=asset_url, version=ext_version) manifest_json_file = join('./build/chrome', 'manifest.json') with open(manifest_json_file, 'w', 'utf-8-sig') as f: f.write(manifest) # Due to Content Security Policy, the web font script cannot be inline. webfont = resolve('h:templates/webfont.js').abspath() copyfile(webfont, join(asset_env.directory, 'webfont.js'))
def datatables_view(request): query = build_query(request) objects = query.all() return render('models/templates/_table.jinja2', dict(value=objects), request)
def _callFUT(self, renderer_name, value, request=None, package=None): from pyramid.renderers import render return render(renderer_name, value, request=request, package=package)
def render_template(self, renderer, **kwargs): return TemplateStructure(render(renderer, kwargs, self.request))
def render_html(request, template, datas): """ Compile the current template with the given datas """ return render(template, datas, request)
def __call__(self): xml = render(self._template, dict(view=self), request=self.request) response = Response(xml, content_type="application/atom+xml") return response
def render_sms(self, template_context): return render("wallet/sms/confirm_phone_number.txt", template_context, request=self.request)
def footer(self): footer_str = render('templates/footer.jinja2', {}) return {'footer': footer_str}
def proposal_listing(context, request, va, **kw): """ Get proposals for a specific context. """ return render('templates/proposals/listing.pt', proposal_response(context, request, va, **kw), request=request)
def makotest(self): name = 'Pylons Developer' return render('/test.mako', extra_vars={'name': name})
def toolbar_tween(request): root_path = request.route_path(ROOT_ROUTE_NAME) request.exc_history = exc_history remote_addr = request.remote_addr if (request.path.startswith(root_path) or (not remote_addr in hosts)): return handler(request) toolbar = DebugToolbar(request, panel_classes) request.debug_toolbar = toolbar _handler = handler for panel in toolbar.panels: _handler = panel.wrap_handler(_handler) try: response = _handler(request) except Exception: if exc_history is not None: tb = get_traceback(info=sys.exc_info(), skip=1, show_hidden_frames=False, ignore_system_exceptions=True) for frame in tb.frames: exc_history.frames[frame.id] = frame exc_history.tracebacks[tb.id] = tb body = tb.render_full(request).encode('utf-8', 'replace') response = Response(body, status=500) toolbar.process_response(response) qs = {'token': exc_history.token, 'tb': str(tb.id)} msg = 'Exception at %s\ntraceback url: %s' exc_url = request.route_url(EXC_ROUTE_NAME, _query=qs) exc_msg = msg % (request.url, exc_url) logger.exception(exc_msg) return response else: logger.exception('Exception at %s' % request.url) raise else: if intercept_redirects: # Intercept http redirect codes and display an html page with a # link to the target. if response.status_int in redirect_codes: redirect_to = response.location redirect_code = response.status_int if redirect_to: content = render( 'pyramid_debugtoolbar:templates/redirect.mako', { 'redirect_to': redirect_to, 'redirect_code': redirect_code }, request=request) content = content.encode(response.charset) response.content_length = len(content) response.location = None response.app_iter = [content] response.status_int = 200 toolbar.process_response(response) return response finally: # break circref del request.debug_toolbar
def toolbar_view(request): viewer_username = authenticated_userid(request) return render('templates/toolbar.pt', {'viewer_username': viewer_username}, request)
def dispatcher(app, request): result = redirect_view(request) body = render('pyramid_debugtoolbar:templates/redirect.dbtmako', result) return Response(body)
def latest_view(request): latest = Idea.ideas_bunch(Idea.idea_id.desc(), with_joinedload=False) return render('templates/latest.pt', {'latest': latest}, request)
def render(self, since: datetime.datetime): """Render some sample content.""" from websauna.system.user.models import User request = self.request users = request.dbsession.query(User).all() return render("newsletter/demo_newsletter.html", value={"users": users}, request=self.request)
def polls_menu(context, request, va, **kw): return render(va.kwargs['renderer'], {}, request = request)
def generate(request, notification): """ Generate an email for a reply notification. :param request: the current request :type request: pyramid.request.Request :param notification: the reply notification data structure :type notification: h.notifications.reply.Notification :returns: a 4-element tuple containing: recipients, subject, text, html """ document_title = notification.document.title if not document_title: document_title = notification.parent.target_uri parent_user = notification.parent_user parent_user_url = request.route_url("stream.user_query", user=parent_user.username) parent_user_display_name = parent_user.display_name or parent_user.username reply_url = links.incontext_link(request, notification.reply) if not reply_url: reply_url = request.route_url("annotation", id=notification.reply.id) reply_user = notification.reply_user reply_user_url = request.route_url("stream.user_query", user=reply_user.username) reply_user_display_name = reply_user.display_name or reply_user.username unsubscribe_token = _unsubscribe_token(request, parent_user) unsubscribe_url = request.route_url("unsubscribe", token=unsubscribe_token) if notification.reply_user.authority != request.default_authority: reply_user_url = None if notification.parent_user.authority != request.default_authority: parent_user_url = None context = { "document_title": document_title, "document_url": notification.parent.target_uri, "parent": notification.parent, "parent_user_display_name": parent_user_display_name, "parent_user_url": parent_user_url, "reply": notification.reply, "reply_url": reply_url, "reply_user_display_name": reply_user_display_name, "reply_user_url": reply_user_url, "unsubscribe_url": unsubscribe_url, } subject = "{user} has replied to your annotation".format( user=reply_user_display_name) text = render("h:templates/emails/reply_notification.txt.jinja2", context, request=request) html = render("h:templates/emails/reply_notification.html.jinja2", context, request=request) return [notification.parent_user.email], subject, text, html
def test_tmpl(self): text = DummyText() html = render("nive_markdowntext:mtext.pt", {"context": text}) self.assert_(html) self.assert_(html.find(text.HTML()) != -1)
def render(self, context:Resource, request:Request) -> str: """Return HTML code for this button.""" template_context = dict(context=context, button=self) return render(self.template, template_context, request=request)