def send(send_item):
from html2text import html2text
from requests.exceptions import HTTPError
permanent_errors = [401, 404]
broadcast, individual, custom_data, attach_temp_folder = send_item
# [[xxx.yyy]] -> {{=xxx.yy}}
raw_html_body = sub(r'(\[\[)(\w+\.\w+)(\]\])', r'{{=\2}}',
broadcast.body.body)
# [[xxx.yyy]] -> {{=xxx.yy}}
raw_subject = sub(r'(\[\[)(\w+\.\w+)(\]\])', r'{{=\2}}', broadcast.subject)
context = dict(custom_data.custom_data)
# @TODO: filter individual properties before asign to data
context.update(data=individual)
subject = render(raw_subject, context=context)
html_body = render(raw_html_body, context=context)
text_body = html2text(html_body.decode('utf-8'))
domain = broadcast.domain_
data = {
'from': broadcast.sender.from_line,
'to': individual.send_email,
'subject': subject,
'html': html_body,
'text': text_body
}
files = get_files(broadcast.attachments, attach_temp_folder, context)
try:
r = api_send_message(domain, dict(data=data, files=files))
r.raise_for_status()
except HTTPError as err:
if not r.status_code in permanent_errors:
raise HTTPError(err.message)
return (individual.id, r.json())
def build_message_from_template(self, event_type, render_html=True, **kwargs):
from gluon.html import XML
from gluon.template import render
path = self.request.folder + "/" + "private/email_templates/" + event_type + ".html"
template = str(XML(open(path).read()))
if not template:
logger.warning(
"App notification message, you need to define an email template for %s event \n %s"
% (event_type, str(kwargs))
)
self.render = lambda text: render(text, context=dict(event_type=event_type, **kwargs))
try:
if render_html:
html_message = self.render(template)
import html2text
plain_message = html2text.html2text(html_message)
except Exception as e:
html_message = ""
logger.warning("Render email template %s. Please, edit the email template carefully" % event_type)
logger.warning(str(e))
return dict(message=[plain_message, html_message], reply_to=self.config.take("smtp.reply_to"))
def render(self, filename, context):
# print "xxx TvizREnderer: " + filename
try:
templatetxt = open(template_file(filename), 'r').read()
except Exception as e:
logging.error("HtmlRenderer: Error reading: " + filename)
raise e
try:
outputhtml = template.render(content= templatetxt, context = context)
except Exception as e:
logging.error("HtmlRenderer: Error rendering: " + filename)
raise e
outfile = html_file('tanda.html')
try:
out = codecs.open(outfile, 'w')
out.write(outputhtml)
out.close()
except:
logging.error("HtmlRenderer: Error writing to file: " + outfile)
def build_message_from_template(self, event_type, **kwargs):
template = self.emailtemplate.entity(template_key=event_type)
if not template:
return dict(message="Movuca notification message, you need to define an email template for %s event \n %s" % (event_type, str(kwargs)), subject="New notification from Movuca CMS")
# if template.detect_links:
# from gluon import MARKMIN
# self.pre_render = lambda value: str(MARKMIN(value))
# else:
self.pre_render = lambda value: value
from gluon.template import render
from gluon import current
self.render = lambda text: render(text, context=dict(theme_name=self.config.theme.name, CURL=self.db.CURL, event_type=event_type, event_info=current.event_info, **kwargs))
# >>> from gluon.template import render
# >>> render(str(MARKMIN("{{=number}} Bruno http://dfdfd.com")), context={"number":1})
# '<p>1 Bruno <a href="http://dfdfd.com">http://dfdfd.com</a></p>'
pre_html_message = self.pre_render(template.html_text)
html_message = self.render(pre_html_message)
plain_message = self.render(template.plain_text)
# TODO: Include Attachment
return dict(message=[plain_message, "<html>%s</html>" % html_message], subject=template.subject_text % kwargs, reply_to=template.reply_to or "Undisclosed Recipients", bcc=template.copy_to or "")
def show():
import os
template = EmailTemplate(db, auth)
template.render(None)
html_template = template.show(request.args(0))
if html_template is None:
raise PRETTYHTTP(403, T("Page not found"))
return XML(render(html_template, path=os.path.join(request.folder, 'views'), context=globals()))
def _create_message(db, from_, body):
data = {'me_from': from_, 'me_body': body}
mid = db.chat.insert(**data)
data['id'] = str(mid)
data['me_html'] = render(MESSAGE_TEMPLATE, context={'message': data})
db(db.chat.id == mid).update(me_html=data['me_html'])
return data
def _create_message(db, from_, body):
data = {'me_from': from_, 'me_body': body}
mid = db.chat.insert(**data)
data['id'] = str(mid)
data['me_html'] = render(MESSAGE_TEMPLATE, context={'message': data})
db(db.chat.id == mid).update(me_html=data['me_html'])
return data
def testRun(self):
self.assertEqual(render(content='{{for i in range(n):}}{{=i}}{{pass}}',
context=dict(n=3)), '012')
self.assertEqual(render(content='{{if n>2:}}ok{{pass}}',
context=dict(n=3)), 'ok')
self.assertEqual(
render(content='{{try:}}{{n/0}}{{except:}}fail{{pass}}',
context=dict(n=3)), 'fail')
self.assertEqual(render(content='{{="<&>"}}'), '<&>')
self.assertEqual(render(content='"abc"'), '"abc"')
self.assertEqual(render(content='"a\'bc"'), '"a\'bc"')
self.assertEqual(render(content='"a\"bc"'), '"a\"bc"')
self.assertEqual(render(content=r'''"a\"bc"'''), r'"a\"bc"')
self.assertEqual(render(content=r'''"""abc\""""'''), r'"""abc\""""')
def render(self):
""" Render """
title = 'Error undefined'
short_message = ''
if str(self.status)[0] == '1':
short_message = "That’s not an error."
if self.status == 100:
short_message = "Continue"
elif str(self.status)[0] == '2':
short_message = "That’s not an error."
if self.status == 200:
title = 'OK'
elif self.status == 201:
title = 'Created'
elif self.status == 202:
title = 'Accepted'
elif str(self.status)[0] == '3':
short_message = "That’s not an error."
elif str(self.status)[0] == '4':
short_message = "That’s an error."
if self.status == 400:
title = 'Bad Request'
elif self.status == 401:
title = 'Unauthorized'
elif self.status == 403:
title = 'Forbidden'
elif self.status == 404:
title = 'Not Found'
elif self.status == 405:
title = 'Method Not Allowed'
elif str(self.status)[0] == '5':
short_message = "That’s an error."
if self.status == 500:
title = 'Internal Server Error'
elif self.status == 501:
title = 'Not Implemented'
elif self.status == 502:
title = 'Bad Gateway'
elif self.status == 503:
title = 'Service Unavailable'
elif self.status == 504:
title = 'Gateway Timeout'
elif self.status == 505:
title = 'Method Not Allowed'
# Choose html dode according with the lang
path = self.request.folder + '/' + 'private/http_status_code'
status_file = path + '/status.html'
content = str(open(status_file).read())
return render(content, context=dict(status_code=self.status, title=title, short_message=short_message,
full_message=self.full_message, link=self.link))
def show():
page = StaticPage(db, auth)
page.render(None)
html_page = page.show(slug_key=request.args(0))
if html_page is None:
raise PRETTYHTTP(403, T("Page not found"))
import os
new_render = lambda text: render(text, path=os.path.join(request.folder, 'views'), context=dict(**globals()))
return new_render(html_page)
def testRun(self):
self.assertEqual(
render(content='{{for i in range(n):}}{{=i}}{{pass}}',
context=dict(n=3)), '012')
self.assertEqual(
render(content='{{if n>2:}}ok{{pass}}', context=dict(n=3)), 'ok')
self.assertEqual(
render(content='{{try:}}{{n/0}}{{except:}}fail{{pass}}',
context=dict(n=3)), 'fail')
self.assertEqual(render(content='{{="<&>"}}'), '<&>')
self.assertEqual(render(content='"abc"'), '"abc"')
self.assertEqual(render(content='"a\'bc"'), '"a\'bc"')
self.assertEqual(render(content='"a\"bc"'), '"a\"bc"')
self.assertEqual(render(content=r'''"a\"bc"'''), r'"a\"bc"')
self.assertEqual(render(content=r'''"""abc\""""'''), r'"""abc\""""')
def _create_message(db, from_, body):
color = False
if(body[:7] == "/roll d"):
color = True
len_body = len(body)
randnum = "rolls " + str(random.randrange(1,(int(body[7:]) +1)))
else:
randnum = body
data = {'me_from': from_, 'me_body': randnum}
mid = db.chat.insert(**data)
data['id'] = str(mid)
if (color==False):
data['me_html'] = render(MESSAGE_TEMPLATE, context={'message': data})
else:
data['me_html'] = render(COLOR_MESSAGE_TEMPLATE, context={'message':data})
db(db.chat.id == mid).update(me_html=data['me_html'])
return data
def _create_message(db, from_, body):
color = False
if (body[:7] == "/roll d"):
color = True
len_body = len(body)
randnum = "rolls " + str(random.randrange(1, (int(body[7:]) + 1)))
else:
randnum = body
data = {'me_from': from_, 'me_body': randnum}
mid = db.chat.insert(**data)
data['id'] = str(mid)
if (color == False):
data['me_html'] = render(MESSAGE_TEMPLATE, context={'message': data})
else:
data['me_html'] = render(COLOR_MESSAGE_TEMPLATE,
context={'message': data})
db(db.chat.id == mid).update(me_html=data['me_html'])
return data
def _create_message(db, from_, body):
data = {'me_from': from_, 'me_body': body}
mid = db.chat.insert(**data)
data['id'] = str(mid)
if current.session.auth.user.first_name == from_ :
MESSAGE_TEMPLATE = ("""<div style="text-align:right" class="message" id="m{{ =message['id'] }}">""" """<b>{{ =message['me_from'] }}: </b>""" """<pre>{{ =message['me_body'] }}</pre></div>""")
else:
MESSAGE_TEMPLATE = ("""<div style="text-align:left" class="message" id="m{{ =message['id'] }}">""" """<b>{{ =message['me_from'] }}: </b>""" """<pre>{{ =message['me_body'] }}</pre></div>""")
data['me_html'] = render(MESSAGE_TEMPLATE, context={'message': data})
db(db.chat.id == mid).update(me_html=data['me_html'])
return data
def xml(self):
from gluon.template import render
if self.accepted:
return "Your payment was processed successfully"
elif self.errors:
return "There was an processing error"
else:
context = dict(amount=self.amount,
signature=self.signature, pk=self.pk,
currency_symbol=self.currency_symbol,
security_notice=self.security_notice,
disclosure_notice=self.disclosure_notice)
return render(content=self.template, context=context)
def xml(self):
from gluon.template import render
if self.accepted:
return "Your payment was processed successfully"
elif self.errors:
return "There was an processing error"
else:
context = dict(amount=self.amount,
signature=self.signature, pk=self.pk,
currency_symbol=self.currency_symbol,
security_notice=self.security_notice,
disclosure_notice=self.disclosure_notice)
return render(content=self.template, context=context)
def build_message_from_template(self, event_type, lang=None, render_html=True, **kwargs):
lang = lang or self.T.accepted_language
template = self.db((self.db.t_email_template.f_template_key == event_type) &
(self.db.t_email_template.f_lang_code == lang)).select().first()
if not template:
template = self.db((self.db.t_email_template.f_template_key == event_type) &
(self.db.t_email_template.f_lang_code == self.config.take('general.default_language'))).select().first()
logger.warning("App notification message, you need to define an email template for %s event \n %s" % (event_type, str(kwargs)))
self.render = lambda text: render(text, context=dict(event_type=event_type, **kwargs))
try:
if render_html:
html_message = self.render(template.f_html_text)
else:
html_message = template.f_html_text
except Exception as e:
html_message = ''
logger.warning("Render html_message template %s. Please, edit the email template carefully" % event_type)
logger.warning(str(e))
try:
if render_html:
subject_text = self.render(template.f_subject_text)
else:
subject_text = template.f_subject_text
except Exception as e:
subject_text = ''
logger.warning("Render subject_text template %s. Please, edit the email template carefully" % event_type)
logger.warning(str(e))
try:
if render_html:
plain_message = self.render(template.f_plain_text)
else:
plain_message = template.f_plain_text
except Exception as e:
plain_message = ''
logger.warning("Render plain_message template %s. Please, edit the email template carefully" % event_type)
logger.warning(str(e))
return dict(message=[plain_message, html_message],
subject=subject_text % kwargs, reply_to=template.f_reply_to or "Undisclosed Recipients",
bcc=template.f_copy_to or "", attachments=[template.f_attachment_file] or "")
def build_message_from_template(self, event_type, **kwargs):
template = self.emailtemplate.entity(template_key=event_type)
if not template:
return dict(
message=
"Movuca notification message, you need to define an email template for %s event \n %s"
% (event_type, str(kwargs)),
subject="New notification from Movuca CMS")
# if template.detect_links:
# from gluon import MARKMIN
# self.pre_render = lambda value: str(MARKMIN(value))
# else:
self.pre_render = lambda value: value
from gluon.template import render
from gluon import current
self.render = lambda text: render(
text,
context=dict(theme_name=self.config.theme.name,
CURL=self.db.CURL,
event_type=event_type,
event_info=current.event_info,
**kwargs))
# >>> from gluon.template import render
# >>> render(str(MARKMIN("{{=number}} Bruno http://dfdfd.com")), context={"number":1})
# '<p>1 Bruno <a href="http://dfdfd.com">http://dfdfd.com</a></p>'
pre_html_message = self.pre_render(template.html_text)
html_message = self.render(pre_html_message)
plain_message = self.render(template.plain_text)
# TODO: Include Attachment
return dict(message=[plain_message,
"<html>%s</html>" % html_message],
subject=template.subject_text % kwargs,
reply_to=template.reply_to or "Undisclosed Recipients",
bcc=template.copy_to or "")
def render_sys_notification(self,
sys_notification,
title='',
subject='',
description='',
comments='',
customers_orders_id=None,
invoices_id=None,
invoices_payments_id=None,
workshops_products_customers_id=None):
"""
Render notification email
:param sys_notifications_id: db.sys_notifications.id
:param title: Email title
:param subject: Email subject
:param description: Email description
:param comments: Email comments
:param customers_orders_id: db.customers_orders.id
:param invoices_id: db.invoices.id
:param invoices_payments_id: db.invoices_payments.id
:param workshops_products_customers_id: db.workshops_products_customers.id
:return: html message for sys_notification
"""
from gluon.template import render
T = current.T
db = current.db
request = current.request
DATETIME_FORMAT = current.DATETIME_FORMAT
logo = self._render_email_template_get_logo()
if sys_notification == 'order_created':
from os_order import Order
order = Order(customers_orders_id)
notification = db.sys_notifications(Notification='order_created')
# title
title = notification.NotificationTitle
# description
au = db.auth_user()
description = DIV(
T('A new order has been received:'), BR(), BR(),
TABLE(
TR(
TD(B(T('Order'))),
TD(
A(
'#',
order.order.id,
_href=URL('orders',
'edit',
vars={'coID': order.order.id},
scheme=True,
host=True),
))),
TR(TD(B(T('Order status'))), TD(order.order.Status)),
TR(TD(B(T('Order date'))), TD(order.order.DateCreated)),
TR(
TD(B(T('Customer'))),
TD(
A(order.get_customer_name(),
_href=URL('customers',
'edit',
args=order.order.auth_customer_id,
scheme=True,
host=True))),
),
TR(
TD(B(T('CustomerID'))),
TD(order.order.auth_customer_id),
)))
# content
template_content = notification.NotificationTemplate
content = self._render_email_template_order(
template_content, customers_orders_id)
# Check for order message
if order.order.CustomerNote:
comments = DIV(
T("The customer provided the following message with the order:"
), BR(), BR(),
XML(order.order.CustomerNote.replace('\n', '<br>')))
context = dict(logo=logo,
title=title,
description=description,
content=content,
comments=comments,
footer='',
request=request)
template_name = 'default.html'
template_path = os.path.join(request.folder, 'views', 'templates',
'email')
template = os.path.join(template_path, template_name)
message = render(filename=template,
path=template_path,
context=context)
return message
def render_email_template(self,
email_template,
title='',
subject='',
description='',
comments='',
template_content=None,
auth_user_id=None,
customers_orders_id=None,
invoices_id=None,
invoices_payments_id=None,
classes_otc_id=None,
classes_otc_sub_avail_id=None,
workshops_products_customers_id=None,
return_html=False):
"""
Renders default email template
uses the render function from gluon.template instead of response.render
response throws a RestrictedError when run from the scheduler or shell...
and we do want scheduled emails to be rendered :)
"""
# from gluon.template import parse_template
from gluon.template import render
db = current.db
T = current.T
DATETIME_FORMAT = current.DATETIME_FORMAT
error = False
error_msg = ''
request = current.request
logo = self._render_email_template_get_logo()
template_name = 'default.html'
template_path = os.path.join(request.folder, 'views', 'templates',
'email')
# Get template
if template_content is None:
# Get email template from db
template_content = self.get_email_template(email_template)
# Render template
if email_template == 'order_received':
subject = T('Order received')
# do some pre-processing to show the correct order info
content = self._render_email_template_order(
template_content, customers_orders_id)
# Check for order message
from os_order import Order
order = Order(customers_orders_id)
if order.order.CustomerNote:
comments = DIV(
T("We received the following message with your order:"),
BR(), BR(),
XML(order.order.CustomerNote.replace('\n', '<br>')))
elif email_template == 'order_delivered':
subject = T('Order delivered')
# do some pre-processing to show the correct order info
content = self._render_email_template_order(
template_content, customers_orders_id)
elif email_template == 'payment_recurring_failed':
subject = T('Recurring payment failed')
content = self._render_email_template_payment_recurring_failed(
template_content)
elif email_template == 'teacher_sub_requests_daily_summary':
result = self._render_email_template_teacher_sub_requests_daily_summary(
template_content, auth_user_id)
title = T("Daily summary - open classes")
description = result['description']
content = result['content']
error = result['error']
error_msg = result['error_msg']
elif email_template == 'teacher_sub_request_open_reminder':
result = self._render_email_template_teacher_sub_request_open_reminder(
template_content, classes_otc_id)
title = T("A friendly reminder")
description = result['description']
content = result['content']
error = result['error']
error_msg = result['error_msg']
elif email_template == 'teacher_sub_offer_declined':
result = self._render_email_template_teacher_sub_offer(
template_content, classes_otc_sub_avail_id)
title = T("Substitute offer declined")
description = result['description']
content = result['content']
elif email_template == 'teacher_sub_offer_accepted':
result = self._render_email_template_teacher_sub_offer(
template_content, classes_otc_sub_avail_id)
title = T("Thank you for teaching this class")
description = result['description']
content = result['content']
elif email_template == 'workshops_info_mail':
wspc = db.workshops_products_customers(
workshops_products_customers_id)
wsp = db.workshops_products(wspc.workshops_products_id)
ws = db.workshops(wsp.workshops_id)
subject = ws.Name
title = ws.Name
result = self._render_email_workshops_info_mail(wspc, wsp, ws)
content = result['content']
description = result['description']
elif (email_template == 'sys_verify_email'
or email_template == 'sys_reset_password'):
template_name = 'default_simple.html'
content = XML(template_content)
subject = subject
else:
template_name = 'default.html'
content = XML(template_content)
subject = subject
footer = XML(self.get_email_template('sys_email_footer'))
template = os.path.join(template_path, template_name)
context = dict(logo=logo,
title=title,
description=description,
content=content,
comments=comments,
footer=footer,
request=request)
html_message = render(filename=template,
path=template_path,
context=context)
if return_html:
return dict(html_message=html_message,
error=error,
error_msg=error_msg)
else:
msgID = db.messages.insert(msg_content=html_message,
msg_subject=subject)
return msgID
def render_resetmail(self,email):
path = abspath('applications', current.request.application, 'views')
return render(filename=path+'/reset_mail.html' , context=dict(text='https://' + current.request.env.http_host + URL(r=current.request,c='default',f='user',args=['reset_password']) + '/%(key)s', email=email))
def testWithDummyFileSystem(self):
from os.path import join as pjoin
import contextlib
from gluon._compat import StringIO
from gluon.restricted import RestrictedError
@contextlib.contextmanager
def monkey_patch(module, fn_name, patch):
try:
unpatch = getattr(module, fn_name)
except AttributeError:
unpatch = None
setattr(module, fn_name, patch)
try:
yield
finally:
if unpatch is None:
delattr(module, fn_name)
else:
setattr(module, fn_name, unpatch)
def dummy_open(path, mode):
if path == pjoin('views', 'layout.html'):
return StringIO("{{block left_sidebar}}left{{end}}"
"{{include}}"
"{{block right_sidebar}}right{{end}}")
elif path == pjoin('views', 'layoutbrackets.html'):
return StringIO("[[block left_sidebar]]left[[end]]"
"[[include]]"
"[[block right_sidebar]]right[[end]]")
elif path == pjoin('views', 'default', 'index.html'):
return StringIO("{{extend 'layout.html'}}"
"{{block left_sidebar}}{{super}} {{end}}"
"to"
"{{block right_sidebar}} {{super}}{{end}}")
elif path == pjoin('views', 'default', 'indexbrackets.html'):
return StringIO("[[extend 'layoutbrackets.html']]"
"[[block left_sidebar]][[super]] [[end]]"
"to"
"[[block right_sidebar]] [[super]][[end]]")
elif path == pjoin('views', 'default', 'missing.html'):
return StringIO("{{extend 'wut'}}"
"{{block left_sidebar}}{{super}} {{end}}"
"to"
"{{block right_sidebar}} {{super}}{{end}}")
elif path == pjoin('views', 'default', 'noescape.html'):
return StringIO("""{{=NOESCAPE('<script></script>')}}""")
raise IOError
with monkey_patch(template, 'open', dummy_open):
self.assertEqual(
render(filename=pjoin('views', 'default', 'index.html'),
path='views'),
'left to right')
self.assertEqual(
render(filename=pjoin('views', 'default', 'indexbrackets.html'),
path='views', delimiters=('[[', ']]')),
'left to right')
self.assertRaises(
RestrictedError,
render,
filename=pjoin('views', 'default', 'missing.html'),
path='views')
response = template.DummyResponse()
response.delimiters = ('[[', ']]')
self.assertEqual(
render(filename=pjoin('views', 'default', 'indexbrackets.html'),
path='views', context={'response': response}),
'left to right')
self.assertEqual(
render(filename=pjoin('views', 'default', 'noescape.html'),
context={'NOESCAPE': template.NOESCAPE}),
'<script></script>')
def testEqualWrite(self):
"test generation of response.write from ="
self.assertEqual(render(content='{{=2+2}}'), '4')
self.assertEqual(render(content='{{="abc"}}'), 'abc')
# whitespace is stripped
self.assertEqual(render(content='{{ ="abc"}}'), 'abc')
self.assertEqual(render(content='{{ ="abc" }}'), 'abc')
self.assertEqual(render(content='{{pass\n="abc" }}'), 'abc')
# = recognized only at the beginning of a physical line
self.assertEqual(render(
content='{{xyz = "xyz"\n="abc"\n="def"\n=xyz }}'), 'abcdefxyz')
# = in python blocks
self.assertEqual(render(content='{{if True:\n="abc"\npass }}'), 'abc')
self.assertEqual(
render(content='{{if True:\n="abc"\npass\n="def" }}'), 'abcdef')
self.assertEqual(
render(content='{{if False:\n="abc"\npass\n="def" }}'), 'def')
self.assertEqual(render(
content='{{if True:\n="abc"\nelse:\n="def"\npass }}'), 'abc')
self.assertEqual(render(
content='{{if False:\n="abc"\nelse:\n="def"\npass }}'), 'def')
# codeblock-leading = handles internal newlines, escaped or not
self.assertEqual(render(content='{{=list((1,2,3))}}'), '[1, 2, 3]')
self.assertEqual(render(content='{{=list((1,2,\\\n3))}}'), '[1, 2, 3]')
self.assertEqual(render(content='{{=list((1,2,\n3))}}'), '[1, 2, 3]')
# ...but that means no more = operators in the codeblock
self.assertRaises(SyntaxError, render, content='{{="abc"\n="def" }}')
# = embedded in codeblock won't handle newlines in its argument
self.assertEqual(
render(content='{{pass\n=list((1,2,\\\n3))}}'), '[1, 2, 3]')
self.assertRaises(
SyntaxError, render, content='{{pass\n=list((1,2,\n3))}}')
def render_email_cadastro(parametros):
caminho = os.path.join(request.folder, "views", "email_cadastro.html")
with open(caminho, "r") as template:
message = render(content=template.read(), context=parametros)
return message
'''
Created on Jun 26, 2012
@author: tolga
'''
from gluon import template
from gluon import P
def f(x):
return P(x * x)
if __name__ == '__main__':
STR = '''
<html>
{{for x in [1,2,3]:}}
<h1> {{=x}} {{=f(x)}} </h1>
{{pass}}
</html>
'''
print template.render(content=STR, context = dict(x='z', f=f))
def render_email_template(self,
email_template,
title='',
subject='',
description='',
comments='',
template_content=None,
customers_orders_id=None,
invoices_id=None,
invoices_payments_id=None,
workshops_products_customers_id=None,
return_html=False):
"""
Renders default email template
uses the render function from gluon.template instead of response.render
response throws a RestrictedError when run from the scheduler or shell...
and we do want scheduled emails to be rendered :)
"""
# from gluon.template import parse_template
from gluon.template import render
db = current.db
T = current.T
DATETIME_FORMAT = current.DATETIME_FORMAT
get_sys_property = current.globalenv['get_sys_property']
request = current.request
logo = self._render_email_template_get_logo()
template_name = 'default.html'
template_path = os.path.join(request.folder, 'views', 'templates',
'email')
if template_content is None:
# Get email template from settings
template_content = get_sys_property(email_template)
if email_template == 'email_template_order_received':
subject = T('Order received')
# do some pre-processing to show the correct order info
content = self._render_email_template_order(
template_content, customers_orders_id)
# Check for order message
from os_order import Order
order = Order(customers_orders_id)
if order.order.CustomerNote:
comments = DIV(
T("We received the following message with your order:"),
BR(), BR(),
XML(order.order.CustomerNote.replace('\n', '<br>')))
elif email_template == 'email_template_order_delivered':
subject = T('Order delivered')
# do some pre-processing to show the correct order info
content = self._render_email_template_order(
template_content, customers_orders_id)
elif email_template == 'email_template_payment_recurring_failed':
subject = T('Recurring payment failed')
content = self._render_email_template_payment_recurring_failed(
template_content)
elif email_template == 'workshops_info_mail':
wspc = db.workshops_products_customers(
workshops_products_customers_id)
wsp = db.workshops_products(wspc.workshops_products_id)
ws = db.workshops(wsp.workshops_id)
subject = ws.Name
title = ws.Name
result = self._render_email_workshops_info_mail(wspc, wsp, ws)
content = result['content']
description = result['description']
elif (email_template == 'email_template_sys_verify_email'
or email_template == 'email_template_sys_reset_password'):
template_name = 'default_simple.html'
content = XML(template_content)
subject = subject
else:
template_name = 'default.html'
content = XML(template_content)
subject = subject
footer = XML(get_sys_property('email_template_sys_footer'))
template = os.path.join(template_path, template_name)
context = dict(logo=logo,
title=title,
description=description,
content=content,
comments=comments,
footer=footer,
request=request)
message = render(filename=template,
path=template_path,
context=context)
if return_html:
return message
else:
msgID = db.messages.insert(msg_content=message,
msg_subject=subject)
return msgID
def testWithDummyFileSystem(self):
from os.path import join as pjoin
import contextlib
from pydal._compat import StringIO
from gluon.restricted import RestrictedError
@contextlib.contextmanager
def monkey_patch(module, fn_name, patch):
try:
unpatch = getattr(module, fn_name)
except AttributeError:
unpatch = None
setattr(module, fn_name, patch)
try:
yield
finally:
if unpatch is None:
delattr(module, fn_name)
else:
setattr(module, fn_name, unpatch)
def dummy_open(path, mode):
if path == pjoin('views', 'layout.html'):
return StringIO("{{block left_sidebar}}left{{end}}"
"{{include}}"
"{{block right_sidebar}}right{{end}}")
elif path == pjoin('views', 'layoutbrackets.html'):
return StringIO("[[block left_sidebar]]left[[end]]"
"[[include]]"
"[[block right_sidebar]]right[[end]]")
elif path == pjoin('views', 'default', 'index.html'):
return StringIO("{{extend 'layout.html'}}"
"{{block left_sidebar}}{{super}} {{end}}"
"to"
"{{block right_sidebar}} {{super}}{{end}}")
elif path == pjoin('views', 'default', 'indexbrackets.html'):
return StringIO("[[extend 'layoutbrackets.html']]"
"[[block left_sidebar]][[super]] [[end]]"
"to"
"[[block right_sidebar]] [[super]][[end]]")
elif path == pjoin('views', 'default', 'missing.html'):
return StringIO("{{extend 'wut'}}"
"{{block left_sidebar}}{{super}} {{end}}"
"to"
"{{block right_sidebar}} {{super}}{{end}}")
elif path == pjoin('views', 'default', 'noescape.html'):
return StringIO("""{{=NOESCAPE('<script></script>')}}""")
raise IOError
with monkey_patch(template, 'open', dummy_open):
self.assertEqual(
render(filename=pjoin('views', 'default', 'index.html'),
path='views'), 'left to right')
self.assertEqual(
render(filename=pjoin('views', 'default',
'indexbrackets.html'),
path='views',
delimiters=('[[', ']]')), 'left to right')
self.assertRaises(RestrictedError,
render,
filename=pjoin('views', 'default',
'missing.html'),
path='views')
response = template.DummyResponse()
response.delimiters = ('[[', ']]')
self.assertEqual(
render(filename=pjoin('views', 'default',
'indexbrackets.html'),
path='views',
context={'response': response}), 'left to right')
self.assertEqual(
render(filename=pjoin('views', 'default', 'noescape.html'),
context={'NOESCAPE': template.NOESCAPE}),
'<script></script>')
def testEqualWrite(self):
"test generation of response.write from ="
self.assertEqual(render(content='{{=2+2}}'), '4')
self.assertEqual(render(content='{{="abc"}}'), 'abc')
# whitespace is stripped
self.assertEqual(render(content='{{ ="abc"}}'), 'abc')
self.assertEqual(render(content='{{ ="abc" }}'), 'abc')
self.assertEqual(render(content='{{pass\n="abc" }}'), 'abc')
# = recognized only at the beginning of a physical line
self.assertEqual(
render(content='{{xyz = "xyz"\n="abc"\n="def"\n=xyz }}'),
'abcdefxyz')
# = in python blocks
self.assertEqual(render(content='{{if True:\n="abc"\npass }}'), 'abc')
self.assertEqual(render(content='{{if True:\n="abc"\npass\n="def" }}'),
'abcdef')
self.assertEqual(
render(content='{{if False:\n="abc"\npass\n="def" }}'), 'def')
self.assertEqual(
render(content='{{if True:\n="abc"\nelse:\n="def"\npass }}'),
'abc')
self.assertEqual(
render(content='{{if False:\n="abc"\nelse:\n="def"\npass }}'),
'def')
# codeblock-leading = handles internal newlines, escaped or not
self.assertEqual(render(content='{{=list((1,2,3))}}'), '[1, 2, 3]')
self.assertEqual(render(content='{{=list((1,2,\\\n3))}}'), '[1, 2, 3]')
self.assertEqual(render(content='{{=list((1,2,\n3))}}'), '[1, 2, 3]')
# ...but that means no more = operators in the codeblock
self.assertRaises(SyntaxError, render, content='{{="abc"\n="def" }}')
# = embedded in codeblock won't handle newlines in its argument
self.assertEqual(render(content='{{pass\n=list((1,2,\\\n3))}}'),
'[1, 2, 3]')
self.assertRaises(SyntaxError,
render,
content='{{pass\n=list((1,2,\n3))}}')
def render_email_confirma(form, template_file):
caminho = os.path.join(request.folder, "views", template_file)
with open(caminho, "r") as template:
message = render(content=template.read(), context=form.vars)
return message
def render_verifymail(self,email,name):
path = abspath('applications', current.request.application, 'views')
url = "%(scheme)s://%(host)s%(urlrequest)s" % {'scheme':current.request.env.wsgi_url_scheme,'host':current.request.env.http_host,'urlrequest':URL(current.request.application, 'default', 'user', args=['verify_email'])+'/%(key)s'}
return render(filename=path+'/verify_mail.html', context=dict(text=url, email=email, name=name ))
def main_wsgi_app(environ, start_response):
import gluon
common_context = {key:getattr(gluon,key) for key in dir(gluon)}
have_databases = False
try:
try:
current.request = request = Request(environ)
response = session = None
request_folder = request.folder
# if client requested a static page
if request.controller == 'static':
current.response = None
current.session = None
static_folder = os_path_join(request_folder,'static')
n = 3 if request.items[2].startswith('_') else 2
filename = os_path_join(static_folder,*request.items[n:])
if not filename.startswith(static_folder+'/'): raise HTTP(404)
if not os_path_exists(filename): raise HTTP(404)
stream_file_or_304_or_206(filename, environ=environ) # raise HTTP 200
# if instead client requested a dynamic page
else:
# build context and inject variables into context
runner = CodeRunner(common_context.copy())
# inject request specific variables into context
runner.context['request'] = request
runner.context['response'] = current.response = response = Response()
runner.context['session'] = current.session = session = Session()
runner.context['T'] = current.T = translator(
os_path_join(request_folder,'languages'),
request.environ.get('HTTP_ACCEPT_LANGUAGE'))
# check if there is a database folder and set the folder
database_folder = os_path_join(request_folder,'databases')
have_databases = os_path_exists(database_folder)
if have_databases:
BaseAdapter.set_folder(os_path_join(request_folder, 'databases'))
# raise an error if the controller file is missing
controllers_folder = os_path_join(request_folder,'controllers')
controller_filename = os_path_join(controllers_folder,request.controller+'.py')
if not controller_filename.startswith(controllers_folder+'/'): raise HTTP(404)
if not os_path_exists(controller_filename): raise HTTP(404)
# import models, ugly but faster than glob
models_folder = os_path_join(request_folder,'models')
if os_path_exists(models_folder):
for filename in sorted(filter(lambda x: x[-3:]=='.py',os.listdir(models_folder))):
runner.import_code(models_folder+os.sep+filename)
# run controller action
view_context = runner.context.copy()
content = runner.import_code(controller_filename, request.function)
# optionally run view
func_ext = request.function+'.'+request.extension
if isinstance(content, dict):
view_context.update(content)
template_folder = os_path_join(request_folder,'views')
# maybe a response.view is specified
if response.view:
template_filename = os_path_join(template_folder,response.view)
# or maybe not
else:
template_filename = os_path_join(template_folder,request.controller,func_ext)
# if the view exists use it
if os_path_exists(template_filename):
content = render(filename=template_filename, path = template_folder, context = view_context)
# else but represent the context as a dict (generic views?)
else:
content = repr(view_context)
# set the content type
response.headers["Content-type"] = contenttype(func_ext)
raise HTTP(response.status, content, headers=response.headers)
# if a HTTP is raised, everything is ok, return
except HTTP, http:
if response:
# commit databases, if any
have_databases = have_databases and response.auto_commit
if have_databases:
session._try_store_in_db(request, response)
BaseAdapter.close_all_instances('commit')
have_databases = False
# save session, if changed
session._try_store_in_cookie_or_file(request, response)
# deal with cookies
if hasattr(response,'_cookies'):
http.cookies2headers(response.cookies)
return http.to(start_response, env=environ)
# there was an error
except Exception, err:
# maybe log the ticket
if isinstance(err, RestrictedError):
ticket = err.log(request)
# or maybe not
else:
print traceback.format_exc()
#request.logger.error(traceback.format_exc())
ticket = 'unknown'
# return HTTP 500
return HTTP(500, ticket).to(start_response, env=environ)
def render_email_confirma(form, template_file):
caminho = os.path.join(request.folder, "views", template_file)
with open(caminho, "r") as template:
message = render(content=template.read(), context=form.vars)
return message
#import pdb; pdb.set_trace()
ans = lookup_title(item[2], target_page)
if ans:
return ans
return None
def build_menu(menu_list, li_active='current', _class='nav', ul_class=None,
li_class=None):
menu = MENU(menu_list, _id=_class, _class=_class, li_active=li_active,
ul_class=None, li_class=None)
return menu
if __name__ == "__main__":
source_dir = '.'
target_dir = '..'
if len(sys.argv) != 2:
sys.exit("Usage: make_page.py page (e.g. index.html")
target_page = sys.argv[1]
menu = build_menu(build_menu_list(top_pages, target_page))
#print menu
from gluon.storage import Storage
vars = dict(batch_title='Trap Ground Allotment Association',
batch_sub_title=lookup_title(top_pages, target_page), batch_menu=menu)
output_page = render(filename=target_page, path=source_dir,
context=vars)
dest = open('%s/%s'%(target_dir,target_page), 'w')
dest.write(output_page)
dest.close
