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