') + label + literal('')
# def url(self):
# # TODO: Probably clean this up somehow...
# if self.pager is not None:
# u = self.pager._url_generator(self.pager.page, partial=True)
# else:
# u = self._url or ''
# qs = self.query_string()
# if qs:
# if '?' not in u:
# u += '?'
# u += qs
# elif '?' not in u:
# u += '?partial=True'
# return u
# def query_string(self):
# # TODO: Probably clean this up somehow...
# qs = ''
# if self.url_kwargs:
# for k, v in self.url_kwargs.items():
# qs += '&%s=%s' % (urllib.quote_plus(k), urllib.quote_plus(v))
# return qs
def get_actions(self):
"""
Returns an HTML snippet containing ``| `` elements for each "action"
defined in the grid.
"""
def get_class(text):
return text.lower().replace(' ', '-')
res = ''
for action in self.config['actions']:
if isinstance(action, basestring):
text = action
cls = get_class(text)
else:
text = action[0]
if len(action) == 2:
cls = action[1]
else:
cls = get_class(text)
res += literal(
' | %s | ' %
(cls, text))
return res
# def get_uuid(self):
# """
# .. highlight:: none
# Returns a unique identifier for a given record, in the form of an HTML
# attribute for direct inclusion in a ```` element within a template.
# An example of what this function might return would be the string::
# 'uuid="420"'
# Rattail itself will tend to use *universally-unique* IDs (true UUIDs),
# but this method may be overridden to support legacy databases with
# auto-increment IDs, etc. Really the only important thing is that the
# value returned be unique across the relevant data set.
# If the concept is unsupported, the method should return an empty
# string.
# """
# def uuid():
# if self.uuid_key and hasattr(self.model, self.uuid_key):
# return getattr(self.model, self.uuid_key)
# if hasattr(self.model, 'uuid'):
# return getattr(self.model, 'uuid')
# if hasattr(self.model, 'id'):
# return getattr(self.model, 'id')
# uuid = uuid()
# if uuid:
# return literal('uuid="%s"' % uuid)
# return ''
class ChildGridField(formalchemy.Field):
"""
Convenience class for including a child grid within a fieldset as a
read-only field.
"""
def __init__(self, name, value, *args, **kwargs):
super(ChildGridField, self).__init__(name, *args, **kwargs)
self.set(value=value)
self.set(readonly=True)
class PropertyField(formalchemy.Field):
"""
Convenience class for fields which simply involve a read-only property
value.
"""
def __init__(self, name, attr=None, *args, **kwargs):
super(PropertyField, self).__init__(name, *args, **kwargs)
if not attr:
attr = name
self.set(value=lambda x: getattr(x, attr))
self.set(readonly=True)
@accepts_none
def required(value, field=None):
if value is None or value == '':
msg = "Please provide a value"
if field:
msg = "You must provide a value for %s" % field.label()
raise formalchemy.ValidationError(msg)
def EnumFieldRenderer(enum):
"""
Adds support for enumeration fields.
"""
class Renderer(formalchemy.fields.SelectFieldRenderer):
def render_readonly(self, **kwargs):
value = self.raw_value
if value is None:
return ''
if value in enum:
return enum[value]
return value
def render(self, **kwargs):
opts = []
for value in sorted(enum):
opts.append((enum[value], value))
return formalchemy.fields.SelectFieldRenderer.render(self, opts, **kwargs)
return Renderer
def pretty_datetime(value):
"""
Formats a ``datetime.datetime`` instance and returns a "pretty"
human-readable string from it, e.g. "42 minutes ago". ``value`` is
rendered directly as a string if no date/time can be parsed from it.
"""
if not isinstance(value, datetime.datetime):
return str(value) if value else ''
value = edbob.local_time(value)
fmt = formalchemy.fields.DateTimeFieldRenderer.format
return literal('%s' % (
value.strftime(fmt),
pretty.date(value)))
class PrettyDateTimeFieldRenderer(formalchemy.fields.DateTimeFieldRenderer):
"""
Adds "pretty" date/time support for FormAlchemy.
"""
def render_readonly(self, **kwargs):
return pretty_datetime(self.raw_value)
class DateTimeFieldRenderer(formalchemy.fields.DateTimeFieldRenderer):
"""
Leverages edbob time system to coerce timestamp to local time zone before
displaying it.
"""
def render_readonly(self, **kwargs):
value = self.raw_value
if isinstance(value, datetime.datetime):
value = edbob.local_time(value)
return value.strftime(self.format)
print type(value)
return ''
FieldSet.default_renderers[formalchemy.types.DateTime] = DateTimeFieldRenderer
def AutocompleteFieldRenderer(service_url, display, width='300px', callback=None, **kwargs):
"""
Returns a field renderer class which leverages jQuery autocomplete to
provide a more user-friendly experience. This is typically used in place
of a ``SelectFieldRenderer`` when the data set is deemed too large for that
renderer.
``service_url`` is required and will ultimately be passed to the
``jQuery.autocomplete()`` function via the ``serviceUrl`` data parameter.
``display`` must be either a callable which accepts an object key as its
only positional argument, or else a tuple of the form ``(Class, 'attr')``.
``width`` is optional but is also passed to the jQuery function.
If ``callback`` is specified, it should be the name of a JavaScript
function within the containing page's scope. This is used in place of
event handlers for autocomplete fields.
"""
kwargs['service_url'] = service_url
kwargs['width'] = width
kwargs['callback'] = callback
Renderer = new.classobj('AutocompleteFieldRenderer', (_AutocompleteFieldRenderer,), kwargs)
if callable(display):
Renderer.display = classmethod(display)
else:
Renderer.display = display
return Renderer
class _AutocompleteFieldRenderer(fields.FieldRenderer):
"""
Implementation for :class:`AutocompleteFieldRenderer` class.
"""
def _display(self, value):
if callable(self.display):
return self.display(value)
if not value:
return ''
obj = Session.query(self.display[0]).get(value)
if not obj:
return ''
return getattr(obj, self.display[1])
def render(self, **kwargs):
autocompleter_name = 'autocompleter_%s' % self.name.replace('-', '_')
return formalchemy.config.engine('field_autocomplete', fieldname=self.name,
fieldvalue=self.value, display=self._display(self.value),
autocompleter=autocompleter_name,
service_url=self.service_url, width=self.width,
callback=self.callback, h=helpers, **kwargs)