def render_message(self, user_data): file_ = 'templates/message_text.txt'; file_html = 'templates/message_text.html'; template = get_template(file_) template_html = get_template(file_html) if isinstance(user_data, dict): try: context = user_data plain_ = render_context(template, context) html_ = render_context(template_html, context) # return (plain_,html_) user_email = user_data.get("email", "*****@*****.**") to_list.append(user_email) email_conn = SMTP(host, port) email_conn.ehlo() email_conn.starttls() email_conn.login(email, password) the_msg = MIMEMultipart("alternative") the_msg['Subject'] = "hello I work" the_msg["From"] = email the_msg["to"] = user_email part_1 = MIMEText(plain_, 'plain') part_2 = MIMEText(html_, 'html') the_msg.attach(part_1) the_msg.attach(part_2) email_conn.sendmail(email, to_list, the_msg.as_string()) email_conn.quit() except SMTPException: print("error ocured") return None return (None, None)
def message_user(self): file_ = 'templates/email_message.txt' file_html = 'templates/email_message.html' template = get_template(file_) template_html = get_template(file_html) context = {"name": "Justin", "date": None, "total": None} print(render_context(template, context)) print(render_context(template_html, context)) return None
def render_message(self, user_data): file_ = 'templates\email_message.txt' file_html = 'templates\email_message.html' template = get_template(file_) template_html = get_template(file_html) if isinstance(user_data, dict): plain_ = render_context(template, user_data) html_ = render_context(template_html, user_data) return plain_, html_ return None, None
def render_message(self, user_data): template = get_template(r'templates\email_message.txt') template_html = get_template(r'templates\email_message.html') if isinstance(user_data, dict): context = user_data plain = render_context(template, context) html = render_context(template_html, context) return (plain, html) return (None, None)
def render_message(self, user_data): file_ = 'templates/email_message.txt' file_html = 'templates/email_message.html' template = get_template(file_) template_html = get_template(file_html) if isinstance(user_data, dict): context = user_data plain_ = render_context(template, context) html_ = render_context(template_html, context) return (plain_, html_) return (None, None)
def render_message(self, user_data): file_ = "templates/email_message.txt" file_html = "templates/email_message.html" template = get_template(file_) template_html = get_template(file_html) if isinstance(user_data, dict): context = user_data # user comes as a dictionary. plain_ = render_context(template, context) html_ = render_context(template_html, context) return(plain_,html_) return (None,None) # returned in case user_id and email are both None (not passed when the function is called.)
def render_message(self, user_data): file_ = 'templates/email_message.txt' file_html = 'templates/email_message.html' template = get_template(file_) template_html = get_template(file_html) if isinstance(user_data, dict): context = user_data plain_ = render_context(template, context) html_ = render_context(template_html, context) return (plain_, html_) return (None, None)
def render_message(self, user_data): file_ = "templates/email_messages.txt" file_html = "templates/email_messages.html" template = get_template(file_) template_html = get_template(file_html) if isinstance(user_data, dict): #is a dictionary context = user_data plain_ = render_context(template, context) html_ = render_context(template_html, context) return (plain_, html_ ) #underscores used so that they are known as a variable return (None, None) #tuple
def render_message(self,user_id = None, user_email = None): self.user_data = self.get_user_data(user_id = user_id,user_email=user_email) if isinstance(self.user_data,dict): file_txt = "templates/email_txt.txt" file_html = "templates/email_html.html" template_txt = get_template(file_txt) template_html = get_template(file_html) context = self.user_data plain_= render_context(template_txt,context) html_ = render_context(template_html,context) return (plain_,html_) return None
def message_user(self): file_ = 'templates/email_message.txt' file_html = 'templates/email_message.html' template = get_template(file_) template_html = get_template(file_html) context = { "name": "Justin", "date": None, "total": None } print(render_context(template, context)) print(render_context(template_html, context)) return None
def render_message(self,user_data): #create a message path = 'templates/email_message.txt' path_html = 'templates/email_message.html' template = get_template(path) template_html = get_template(path_html) date_text = get_date() total_random = get_random_int() if isinstance(user_data, dict): context = user_data msg_txt = render_context(template, context) msg_html = render_context(template_html, context) return msg_txt, msg_html return (None, None)
class Tabs(MultiFieldSet): """Display FieldSet using http://jqueryui.com/demos/tabs/: .. sourcecode:: python >>> from testing import * >>> tabs = Tabs('my_tabs', ... ('tab1', 'My first tab', fs1), ... footer='<input type="submit" name="%(id)s" />') >>> tabs.append('tab2', 'The second', fs2) >>> tabs.tab1 = tabs.tab1.bind(obj1) >>> tabs.tab2.rebind(obj2) >>> print tabs.render(selected=2) #doctest: +ELLIPSIS +NORMALIZE_WHITESPACE <div id="my_tabs_..."> <ul> <li><a href="#tab1_...">My first tab</a></li> <li><a href="#tab2_...">The second</a></li> </ul> <div id="tab1_...">... </div> <div id="tab2_...">... </div> </div> <script type="text/javascript"> jQuery.fa.tabs('my_tabs_...', {"selected": 2}); </script> <BLANKLINE> """ template = templates.get_template('/forms/tabs.mako')
class DateFieldRenderer(fields.DateFieldRenderer): """Use http://jqueryui.com/demos/datepicker/: .. sourcecode:: python >>> from testing import fs >>> print fs.date.render() #doctest: +ELLIPSIS +NORMALIZE_WHITESPACE <input type="text" autocomplete="off" size="10" value="" id="Sample--date" name="Sample--date" /> <script type="text/javascript"> jQuery.fa.datepicker('Sample--date', {"dateFormat": "yy-mm-dd"}); </script>... """ template = templates.get_template('/renderers/date.mako') jq_options = dict(dateFormat='yy-mm-dd') def render(self, **kwargs): value = self.value or '' value = value and value.split()[0] or '' kwargs.update( name=self.name, value=value, jq_options=dumps(self.jq_options), ) return literal(self.template.render(**kwargs)) def _serialized_value(self): value = self.params.getone(self.name) or '' return value
def render_message(self, user_data): file_ = 'templates/email_message.txt' if isinstance(user_data, dict): context = user_data template = get_template(file_) plain_ = render_context(template, context) return plain_ return None
def jQueryFieldRenderer(plugin, show_input=False, tag='div', renderer=fields.TextFieldRenderer, resources_prefix=None, resources=[], **jq_options): """Extending jQuery.fa: .. sourcecode:: python >>> from testing import fs >>> renderer = jQueryFieldRenderer('myplugin', option1=True, option2=['a', 'b']) >>> field = fs.title.set(renderer=renderer) >>> print field.render() #doctest: +ELLIPSIS +NORMALIZE_WHITESPACE <div style="display:none;"><input autocomplete="off" id="Sample--title" name="Sample--title" type="text" /></div> <div id="Sample--title_myplugin"></div> <script type="text/javascript"> jQuery.fa.myplugin('Sample--title', {"option2": ["a", "b"], "options": [], "option1": true}); </script>... Then in your javascript code: .. sourcecode:: javascript jQuery.fa.extend({ myplugin: function(field, plugin, options) { // do what you want } }); Where field is the input, plugin the empty div and options the jq_options passed to the renderer. """ template_name = jq_options.get('_template', 'jquery') template=templates.get_template('/renderers/%s.mako' % template_name) class Renderer(renderer): def render(self, **kwargs): if 'autocomplete' in kwargs: kwargs.pop('autocomplete') html = renderer.render(self, autocomplete='off', **kwargs) kwargs.update(self.jq_options) options = dict( tag=tag, html=html, plugin=plugin, name=self.name, show_input=show_input, resources=[url(r, prefix=self.resources_prefix) for r in resources], ) try: options.update(options=dumps(kwargs)) except TypeError: options.update(options={}) try: return literal(self.template.render_unicode(**options)) except: raise ValueError('Invalid options: %s' % options) return type('%sPluginRenderer' % plugin.title(), (Renderer,), dict(template=template, jq_options=jq_options, resources_prefix=resources_prefix))
class DateTimeFieldRenderer(DateFieldRenderer, fields.TimeFieldRenderer): """Use http://jqueryui.com/demos/datepicker/""" format = '%Y-%m-%d %H:%M:%S' template = templates.get_template('/renderers/date.mako') jq_options = dict(dateFormat='yy-mm-dd') def render(self, **kwargs): return h.content_tag('span', DateFieldRenderer.render(self, **kwargs) + literal(' ') + \ literal(fields.TimeFieldRenderer._render(self, **kwargs))) def _serialized_value(self): date = DateFieldRenderer._serialized_value(self) if date: return date + ' ' + fields.TimeFieldRenderer._serialized_value(self) else: return ''
class Renderer(fields.TextFieldRenderer): template=templates.get_template('/renderers/sortable.mako') def render_readonly(self): return ', '.join(self.raw_value.split(sep)) def render(self, **kwargs): value=self.value.strip(sep) tokens = value and value.split(sep) or '' tokens = [(v, v) for v in tokens] kwargs.update( name=self.name, sep=sep, value=value, tokens=tokens, show_input=show_input, jq_options=dumps(jq_options), ) return literal(self.template.render(**kwargs))
def message_user(self, user_id=None, email=None, subject="Hi there"): user = self.get_user_data(user_id=user_id, email=email) file_ = 'templates/email_message.txt' if user: context = user template = get_template(file_) print(render_context(template, context)) plain_ = self.render_message(user) user_email = user.get('email', '*****@*****.**') try: email_conn = SMTP(host, port) email_conn.ehlo() email_conn.starttls() the_msg = MIMEMultipart() the_msg['Subject'] = subject the_msg['From'] = from_list part_1 = MIMEText(plain_, 'plain') the_msg.attach(part_1) email_conn.login(username, password) email_conn.sendmail(from_list, user_email, the_msg.as_string()) email_conn.quit() except SMTPAuthenticationError: print("error sending message") return None
class MultiFieldSet(object): """Display more than one FieldSet: .. sourcecode:: python >>> from testing import * >>> fs = MultiFieldSet('my_fieldsets', ... ('fs1', '', fs1)) >>> fs.append('fs2', 'Second fieldset', fs2) >>> fs.fs1 = fs.fs1.bind(obj1) >>> fs.fs2.rebind(obj2) >>> print fs.render() #doctest: +ELLIPSIS +NORMALIZE_WHITESPACE <div id="my_fieldsets_..."> <fieldset id="fs1_..."> <div> ... </div> </fieldset> <fieldset id="fs2_..."> <legend><a href="#fs2_...">Second fieldset</a></legend> <div> ... """ template = templates.get_template('/forms/multifieldset.mako') def __init__(self, id, *fieldsets, **options): if not isinstance(id, basestring): raise TypeError('id must be a string. got %r' % (id,)) self._id = id self._fs = [] self._fs_dict = {} self._bound_pk = None self._options = options self._readonly = False self._engine = None self._focus = False self._original_cls = None for fs in fieldsets: if not isinstance(fs, (tuple, list)) or len(fs) != 3: raise ValueError('A form is defined by (id, title, form) got %r' % (fs,)) self.append(*fs) def jsonify(self): fields = [] for fs in self._fs: for f in fs.render_fields.values(): fields.append((f.key, f.model_value)) return dict(fields) #def _get_bound_pk(self): # for fs in self._fs: # return fs._bound_pk #def _set_bound_pk(self, value): # for fs in self._fs: # fs._bound_pk = value _bound_pk = MultiFieldSetProperty('_bound_pk') focus = MultiFieldSetProperty('focus') engine = MultiFieldSetProperty('engine') readonly = MultiFieldSetProperty('readonly') @property def model(self): if self._fs: return self._fs_dict.get(self._fs[0][0]).model @property def errors(self): errors = {} for fs in self._fs_dict.values(): errors.update(fs.errors) return errors @property def render_fields(self): fields = {} for fs in self._fs_dict.values(): fields.update(fs.render_fields) return fields def __getattr__(self, attr): if attr in self._fs_dict: return self._fs_dict.get(attr) else: raise AttributeError(attr) def append(self, id, title, fs): """add a fieldset to tabs""" fs.__name__ = id self._fs.append((id, title)) self._fs_dict[id] = fs def get(self, fs): if isinstance(fs, basestring): fs = self._fs_dict[fs] return fs def bind(self, model=None, session=None, data=None): """Bind fieldsets to model. All sub-fieldsets are bound to model.""" news = [] for id, title in self._fs: fs = self.get(id) fs = fs.bind(model=model, data=data, session=session) if model is None: model = fs.model news.append((id, title, fs)) return self.__class__(self._id, *news, **self._options.copy()) def rebind(self, model=None, session=None, data=None): """Bind fieldsets to model. All sub-fieldsets are bound to model.""" for id, title in self._fs: fs = self.get(id) fs.rebind(model=model, data=data, session=session) if model is None: model = fs.model def copy(self): news = [] for id, title in self._fs: fs = self.get(id) fs = fs.bind(model=fs.model) news.append((id, title, fs)) return self.__class__(self._id, *news, **self._options.copy()) def validate(self, *ids): """Validate fieldsets. If no ids is provided, all fieldsets are validate.""" fieldsets = [] ids = ids or self._fs_dict.keys() for id in ids: fieldsets.append(self.get(id)) validated = [fs.validate() for fs in fieldsets] if False in validated: return False return True def sync(self, *ids): """Sync fieldsets. If no ids is provided, all fieldsets are validate.""" ids = ids or self._fs_dict.keys() for id in ids: self.get(id).sync() def render(self, *ids, **options): fieldsets = [] if ids: ids = [self.get(id).__name__ for id in ids] else: ids = self._fs_dict.keys() for id, title in self._fs: if id in ids: fs = self._fs_dict[id] fs.focus = False fieldsets.append(dict(id=id, title=title, fs=fs)) kwargs = dict(footer='', header='') kwargs.update(self._options) return self.template.render_unicode(id=self._id, rid=str(random())[2:], fieldsets=fieldsets, options=dumps(options), **kwargs)
from data_class import UserManager from utils.templates import get_template, render_context parser = ArgumentParser(prog="hungry") parser.add_argument("type", type=str, choices=['view', 'message']) #parser.add_argument("did_send", type=str, choices=['true', 'false']) parser.add_argument('-id', '--user_id', type=int) parser.add_argument('-e', '--email', type=str) args = parser.parse_args() if args.type == "view": print(UserManager().get_user_data(user_id=args.user_id)) print(UserManager().get_user_data(email=args.email)) elif args.type == "message": file_='templates.email_message.txt' file_html= 'templates/email_message.html' template = get_templates(file_) template_html - get_template(file_html) context={ "name","Justin", "date",None, "total",None } print(render_context(template,context)) print(render_context(template_html,context)) print("send message")
from argparse import ArgumentParser from data_manager import read_data from utils.templates import get_template, adjust_string parser = ArgumentParser(prog="project") parser.add_argument("type", type=str, choices=['view', 'message']) parser.add_argument('-id', '--user_id', type=int) parser.add_argument('-e', '--email', type=str) args = parser.parse_args() #print(args) #print(args.user_id) print(read_data(user_id=args.user_id, email=args.email)) if args.type == "view": print(read_data(user_id=args.user_id)) print(read_data(email=args.email)) elif args.type == "message": file_ = 'utils/template/email_message.txt' file_html = 'utils/template/email_message.html' template_content = get_template(file_) template_content_html = get_template(file_html) context = { "insert_name": "Bohdan", "insert_total": 55.3, "insert_date": "27/11/2017" } print(adjust_string(template_content, context)) print(adjust_string(template_content_html, context))
class Accordion(MultiFieldSet): """Work like :class:`~fa.jquery.forms.Tabs` but use http://jqueryui.com/demos/accordion/ """ template = templates.get_template('/forms/accordion.mako')