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