${h.form(form.action_url, id=form_id or None, method='post', enctype='multipart/form-data')}
- ${form.fieldset.render()|n}
+ ${form.render_fields()|n}
% if buttons:
${buttons|n}
diff --git a/tailbone/templates/forms/form_readonly.mako b/tailbone/templates/forms/form_readonly.mako
index 0e4a73f8..c8aa0543 100644
--- a/tailbone/templates/forms/form_readonly.mako
+++ b/tailbone/templates/forms/form_readonly.mako
@@ -1,6 +1,6 @@
## -*- coding: utf-8 -*-
- ${form.fieldset.render()|n}
+ ${form.render_fields()|n}
% if buttons:
${buttons|n}
% endif
diff --git a/tailbone/templates/master/view.mako b/tailbone/templates/master/view.mako
index d419d9a8..25520036 100644
--- a/tailbone/templates/master/view.mako
+++ b/tailbone/templates/master/view.mako
@@ -1,7 +1,7 @@
## -*- coding: utf-8 -*-
<%inherit file="/base.mako" />
-<%def name="title()">${model_title}: ${unicode(instance)}
+<%def name="title()">${model_title}: ${instance_title}
<%def name="context_menu_items()">
${h.link_to("Back to {0}".format(model_title_plural), url(route_prefix))}
diff --git a/tailbone/views/email.py b/tailbone/views/email.py
new file mode 100644
index 00000000..06e05ef6
--- /dev/null
+++ b/tailbone/views/email.py
@@ -0,0 +1,196 @@
+# -*- coding: utf-8 -*-
+################################################################################
+#
+# Rattail -- Retail Software Framework
+# Copyright © 2010-2015 Lance Edgar
+#
+# This file is part of Rattail.
+#
+# Rattail is free software: you can redistribute it and/or modify it under the
+# terms of the GNU Affero General Public License as published by the Free
+# Software Foundation, either version 3 of the License, or (at your option)
+# any later version.
+#
+# Rattail is distributed in the hope that it will be useful, but WITHOUT ANY
+# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for
+# more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with Rattail. If not, see .
+#
+################################################################################
+"""
+Email Views
+"""
+
+from __future__ import unicode_literals, absolute_import
+
+from pyramid.httpexceptions import HTTPFound
+
+from rattail import mail
+
+from tailbone import forms
+from tailbone.views import MasterView, View
+from tailbone.newgrids import Grid, GridColumn
+
+
+class ProfilesView(MasterView):
+ """
+ Master view for email admin (settings/preview).
+ """
+ normalized_model_name = 'emailprofile'
+ model_title = "Email Profile"
+ model_key = 'key'
+ url_prefix = '/email/profiles'
+
+ grid_factory = Grid
+ filterable = False
+ pageable = False
+
+ creatable = False
+ editable = False
+ deletable = False
+
+ def get_data(self, session=None):
+ data = []
+ for email in mail.iter_emails(self.rattail_config):
+ key = email.key or email.__name__
+ email = email(self.rattail_config, key)
+ data.append(self.normalize(email))
+ return data
+
+ def normalize(self, email):
+ return {
+ 'key': email.key,
+ 'description': email.__doc__,
+ 'prefix': email.get_prefix(),
+ 'subject': email.get_subject(),
+ 'sender': email.get_sender(),
+ 'replyto': email.get_replyto(),
+ 'to': email.get_recips('to'),
+ 'cc': email.get_recips('cc'),
+ 'bcc': email.get_recips('bcc'),
+ }
+
+ def configure_grid(self, g):
+ g.columns = [
+ GridColumn('key'),
+ GridColumn('prefix'),
+ GridColumn('subject'),
+ ]
+
+ g.sorters['key'] = g.make_sorter('key', foldcase=True)
+ g.sorters['prefix'] = g.make_sorter('prefix', foldcase=True)
+ g.sorters['subject'] = g.make_sorter('subject', foldcase=True)
+ g.default_sortkey = 'subject'
+
+ # g.main_actions = []
+ g.more_actions = []
+
+ def get_instance(self):
+ key = self.request.matchdict['key']
+ return self.normalize(mail.get_email(self.rattail_config, key))
+
+ def get_instance_title(self, email):
+ return email['key']
+
+ def make_form(self, email, **kwargs):
+ """
+ Make a simple form for use with CRUD views.
+ """
+ # TODO: This needs all kinds of help still...
+
+ class EmailSchema(forms.Schema):
+ pass
+
+ form = forms.SimpleForm(self.request, schema=EmailSchema(), obj=email)
+ form.creating = self.creating
+ form.editing = self.editing
+ form.readonly = self.viewing
+
+ if self.creating:
+ form.cancel_url = self.get_index_url()
+ else:
+ form.cancel_url = self.get_action_url('view', email)
+
+ form.fieldset = forms.FieldSet()
+ form.fieldset.fields['key'] = forms.Field('key', value=email['key'])
+ form.fieldset.fields['prefix'] = forms.Field('prefix', value=email['prefix'], label="Subject Prefix")
+ form.fieldset.fields['subject'] = forms.Field('subject', value=email['subject'], label="Subject Text")
+ form.fieldset.fields['description'] = forms.Field('description', value=email['description'])
+ form.fieldset.fields['sender'] = forms.Field('sender', value=email['sender'], label="From")
+ form.fieldset.fields['replyto'] = forms.Field('replyto', value=email['replyto'], label="Reply-To")
+ form.fieldset.fields['to'] = forms.Field('to', value=', '.join(email['to']) if email['to'] else None)
+ form.fieldset.fields['cc'] = forms.Field('cc', value=', '.join(email['cc']) if email['cc'] else None)
+ form.fieldset.fields['bcc'] = forms.Field('bcc', value=', '.join(email['bcc']) if email['bcc'] else None)
+
+ return form
+
+ def template_kwargs_view(self, **kwargs):
+ key = self.request.matchdict['key']
+ kwargs['email'] = mail.get_email(self.rattail_config, key)
+ return kwargs
+
+
+class EmailPreview(View):
+ """
+ Lists available email templates, and can show previews of each.
+ """
+
+ def __call__(self):
+
+ # Forms submitted via POST are only used for sending emails.
+ if self.request.method == 'POST':
+ self.email_template()
+ return HTTPFound(location=self.request.get_referrer(
+ default=self.request.route_url('emailprofiles')))
+
+ # Maybe render a preview?
+ key = self.request.GET.get('key')
+ if key:
+ type_ = self.request.GET.get('type', 'html')
+ return self.preview_template(key, type_)
+
+ assert False, "should not be here"
+
+ def email_template(self):
+ recipient = self.request.POST.get('recipient')
+ if recipient:
+ keys = filter(lambda k: k.startswith('send_'), self.request.POST.iterkeys())
+ key = keys[0][5:] if keys else None
+ if key:
+ email = mail.get_email(self.rattail_config, key)
+ data = email.sample_data(self.request)
+ msg = email.make_message(data)
+
+ subject = msg['Subject']
+ del msg['Subject']
+ msg['Subject'] = "[preview] {0}".format(subject)
+
+ del msg['To']
+ del msg['Cc']
+ del msg['Bcc']
+ msg['To'] = recipient
+
+ mail.deliver_message(self.rattail_config, msg)
+
+ self.request.session.flash("Preview for '{0}' was emailed to {1}".format(key, recipient))
+
+ def preview_template(self, key, type_):
+ email = mail.get_email(self.rattail_config, key)
+ template = email.get_template(type_)
+ data = email.sample_data(self.request)
+ self.request.response.text = template.render(**data)
+ if type_ == 'txt':
+ self.request.response.content_type = b'text/plain'
+ return self.request.response
+
+
+def includeme(config):
+ ProfilesView.defaults(config)
+
+ config.add_route('email.preview', '/email/preview/')
+ config.add_view(EmailPreview, route_name='email.preview',
+ renderer='/email/preview.mako',
+ permission='admin')
diff --git a/tailbone/views/master.py b/tailbone/views/master.py
index 40990168..8b60099c 100644
--- a/tailbone/views/master.py
+++ b/tailbone/views/master.py
@@ -35,15 +35,18 @@ import formalchemy
from pyramid.renderers import get_renderer, render_to_response
from pyramid.httpexceptions import HTTPFound, HTTPNotFound
+from tailbone import forms
from tailbone.views import View
from tailbone.newgrids import filters, AlchemyGrid, GridAction
-from tailbone.forms import AlchemyForm
class MasterView(View):
"""
Base "master" view class. All model master views should derive from this.
"""
+ filterable = True
+ pageable = True
+
creatable = True
viewable = True
editable = True
@@ -115,7 +118,12 @@ class MasterView(View):
instance = self.get_instance()
form = self.make_form(instance)
return self.render_to_response('view', {
- 'instance': instance, 'form': form})
+ 'instance': instance,
+ 'form': form,
+ 'instance_title': self.get_instance_title(instance)})
+
+ def get_instance_title(self, instance):
+ return unicode(instance)
def edit(self):
"""
@@ -156,13 +164,13 @@ class MasterView(View):
##############################
@classmethod
- def get_model_class(cls):
+ def get_model_class(cls, error=True):
"""
Returns the data model class for which the master view exists.
"""
- if not hasattr(cls, 'model_class'):
+ if not hasattr(cls, 'model_class') and error:
raise NotImplementedError("You must define the `model_class` for: {0}".format(cls))
- return cls.model_class
+ return getattr(cls, 'model_class', None)
@classmethod
def get_normalized_model_name(cls):
@@ -172,7 +180,9 @@ class MasterView(View):
otherwise it will be a simple lower-cased version of the associated
model class name.
"""
- return getattr(cls, 'normalized_model_name', cls.get_model_class().__name__.lower())
+ if hasattr(cls, 'normalized_model_name'):
+ return cls.normalized_model_name
+ return cls.get_model_class().__name__.lower()
@classmethod
def get_model_key(cls):
@@ -189,7 +199,9 @@ class MasterView(View):
"""
Return a "humanized" version of the model name, for display in templates.
"""
- return getattr(cls, 'model_title', cls.model_class.__name__)
+ if hasattr(cls, 'model_title'):
+ return cls.model_title
+ return cls.model_class.__name__
@classmethod
def get_model_title_plural(cls):
@@ -313,11 +325,11 @@ class MasterView(View):
"""
return {
'width': 'full',
- 'filterable': True,
+ 'filterable': self.filterable,
'sortable': True,
'default_sortkey': getattr(self, 'default_sortkey', None),
'sortdir': getattr(self, 'sortdir', 'asc'),
- 'pageable': True,
+ 'pageable': self.pageable,
'main_actions': self.get_main_actions(),
'more_actions': self.get_more_actions(),
'checkbox': self.checkbox,
@@ -383,10 +395,14 @@ class MasterView(View):
"""
Hopefully generic kwarg generator for basic action routes.
"""
- mapper = orm.object_mapper(row)
- keys = [k.key for k in mapper.primary_key]
- values = [getattr(row, k) for k in keys]
- return dict(zip(keys, values))
+ try:
+ mapper = orm.object_mapper(row)
+ except orm.exc.UnmappedInstanceError:
+ return {self.model_key: row[self.model_key]}
+ else:
+ keys = [k.key for k in mapper.primary_key]
+ values = [getattr(row, k) for k in keys]
+ return dict(zip(keys, values))
def make_grid(self):
"""
@@ -394,10 +410,9 @@ class MasterView(View):
"""
factory = self.get_grid_factory()
key = self.get_grid_key()
- data = self.make_query()
+ data = self.get_data()
kwargs = self.make_grid_kwargs()
- grid = factory(key, self.request, data=data, model_class=self.model_class, **kwargs)
- grid._fa_grid.prettify = prettify
+ grid = factory(key, self.request, data=data, model_class=self.get_model_class(error=False), **kwargs)
self.configure_grid(grid)
grid.load_settings()
return grid
@@ -413,12 +428,17 @@ class MasterView(View):
This requirement is a result of using FormAlchemy under the hood, and
it is in fact a call to :meth:`formalchemy:formalchemy.tables.Grid.configure()`.
"""
- grid.configure()
+ if hasattr(grid, 'configure'):
+ grid.configure()
- def make_query(self, session=None):
+ def get_data(self, session=None):
"""
- Make the base query to be used for the grid. Subclasses should not
- override this method; override :meth:`query()` instead.
+ Generate the base data set for the grid. This typically will be a
+ SQLAlchemy query against the view's model class, but subclasses may
+ override this to support arbitrary data sets.
+
+ Note that if your view is typical and uses a SA model, you should not
+ override this methid, but override :meth:`query()` instead.
"""
if session is None:
session = self.Session()
@@ -484,7 +504,7 @@ class MasterView(View):
kwargs.setdefault('cancel_url', self.get_index_url())
else:
kwargs.setdefault('cancel_url', self.get_action_url('view', instance))
- form = AlchemyForm(self.request, fieldset, **kwargs)
+ form = forms.AlchemyForm(self.request, fieldset, **kwargs)
form.readonly = self.viewing
return form