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)
