def display(self, items, filter=False, level=0, icons=False):
if level == 2:
template = ViewPageTemplateFile("listing_table.pt")
else:
template = ViewPageTemplateFile("listing_macro.pt")
if filter:
folders = []
for item in items:
if item['item'].is_folderish or item[
'portal_type'] == 'PoiTracker':
folders.append(item)
return template(self, items=folders, level=level, icons=icons)
return template(self, items=items, level=level, icons=icons)
class DateFilterWidget(form.PageForm):
macro_template = NamedTemplate("alchemist.form")
template = ViewPageTemplateFile("templates/date-input-search.pt")
def __init__(self, context, request, table_id, field_id):
self.prefix = "form_%s_%s" % (table_id, field_id)
super(DateFilterWidget, self).__init__(context, request)
class IDateRangeSchema(interface.Interface):
range_start_date = schema.Date(
title=_(u"From"),
description=_(u"Leave blank or set lower limit"),
required=False)
range_end_date = schema.Date(
title=_(u"To"),
description=_(u"Leave blank or set upper limit"),
required=False)
macro_template = NamedTemplate("alchemist.form")
template = ViewPageTemplateFile("templates/date-input-search.pt")
form_fields = form.Fields(IDateRangeSchema, render_context=True)
form_fields["range_start_date"].custom_widget = DateWidget
form_fields["range_end_date"].custom_widget = DateWidget
def setUpWidgets(self, ignore_request=False, cookie=None):
class context:
range_start_date = None
range_end_date = None
self.adapters = {
self.IDateRangeSchema: context,
}
self.widgets = form.setUpWidgets(self.form_fields,
self.prefix,
self.context,
self.request,
form=self,
adapters=self.adapters,
ignore_request=True)
@form.action(_(u"Ok"), name="ok")
def handle_ok(self, action, data):
#Handled by Javascript
pass
@form.action(_(u"Clear"), name="clear")
def handle_clear(self, action, data):
#Handled by Javascript
pass
class MetaView(BrowserView):
""" Show meta data on comment."""
template = ViewPageTemplateFile('meta.pt')
def __call__(self):
return self.template()
class TextDateWidget(SelectDateWidget):
"""Simple date widget input in a text field.
"""
__call__ = ViewPageTemplateFile("templates/text-date-widget.pt")
def hasInput(self):
"""Widgets need to determine whether the request contains an input
value for them """
return (self.date_name in self.request.form)
def _getFormInput(self):
"""extract the input value from the submitted form """
return (self._getFieldInput(self.date_name))
def _getFieldInput(self, name):
return self.request.form.get(name, self._missing)
def _toFieldValue(self, date):
"""convert the input value to an value suitable for the field."""
if (date == self.context.missing_value) and self.required:
return self.context.missing_value
else:
try:
return datetime.datetime.strptime(date, "%Y-%m-%d").date()
except ValueError, e:
if date == "":
return
raise ConversionError(_(u"Incorrect string data for date"), e)
class TextDateTimeWidget(TextDateWidget):
__call__ = ViewPageTemplateFile("templates/text-datetime-widget.pt")
@property
def time_name(self):
return self.name.replace(".", "__") + "__time"
def hasInput(self):
return ((self.date_name in self.request.form
and self.time_name in self.request.form)
or (self.name in self.request.form))
def _hasPartialInput(self):
return (self.date_name in self.request.form
or self.time_name in self.request.form)
def _getFormInput(self):
"""extract the input value from the submitted form """
if not self.time_name in self.request.form:
return self._getFieldInput(self.name).split(" ")
return (self._getFieldInput(self.date_name),
self._getFieldInput(self.time_name))
def _toFormValue(self, value):
"""Convert a field value to a string that can be inserted into the form.
"""
if (value == self.context.missing_value) and self.required:
value = datetime.datetime.now()
try:
return (datetime.datetime.strftime(value, "%Y-%m-%d"),
datetime.datetime.strftime(value, "%H:%M"))
except:
#log.error("TextDateTimeWidget._toFormValue(%s) FAILED" % (value))
#debug.log_exc(sys.exc_info(), log_handler=log.error)
return ("", "12:00")
def _toFieldValue(self, (date, time)):
if (date == self._missing or time == self._missing):
if self.required:
return self.context.missing_value
else:
if date + time == self._missing:
return None
else:
return self.context.missing_value
else:
try:
d = datetime.datetime.strptime(date, "%Y-%m-%d")
t = datetime.datetime.strptime(time, "%H:%M")
return datetime.datetime(
year=d.year,
month=d.month,
day=d.day,
hour=t.hour,
minute=t.minute,
)
except ValueError, e:
raise ConversionError(
_("Incorrect string data for date and time"), e)
class LookupRecipientSource(object):
implements(IRecipientSource)
name = 'group_recipient_lookup'
form_label = 'Send to'
def __init__(self, context, request):
self.context = context
self.request = request
self.settings = get_recipient_settings(context, self.name)
def available_groups(self):
groups = []
for id, data in self.settings:
for g in data['settingsdata']:
groups.append({'value': g, 'label': g})
return groups
def lookup(self):
group = self.request.get('megaphone-group-select')
json_data = getUtility(IGroupSource, self.name)
if group:
return json_data[group]
return []
snippet = ViewPageTemplateFile('user_select_snippet.pt')
def render_form(self):
if self.available_groups():
return self.snippet()
else:
return ''
class SlidesWidget(SimpleInputWidget):
"""
this widget pretty much is the same as the Slides view
In itself, it does not provide any data manipulatation, but
it does provide the correct urls to perform the editing action
for each slide
"""
template = ViewPageTemplateFile('browser/slides.pt')
def __init__(self, field, request):
SimpleInputWidget.__init__(self, field, request)
# field/settings/context
self.slider_url = self.context.context.context.absolute_url()
# field/settings
self.settings = self.context.context
# since this uses the same .pt file
self.css = slider_settings_css(self.settings)
def __call__(self):
return self.template(self)
def hasInput(self):
"""
data should never change here....
"""
return False
class EditorialStatusFlag(ViewletBase):
"""A flag informing about the editorial status.
It only shows up if unlocked, i.e. editorial work has to be
done."""
template = ViewPageTemplateFile('statusflag.pt')
def locked(self):
return IEditorialHistory(self.context).locked
def status(self):
curr = IEditorialHistory(self.context).getCurrentEditorialStatus()
vocReg = getVocabularyRegistry()
voc = vocReg.get(self.context, 'quotationtool.editorial.Status')
if curr:
status = curr.status
else:
status = 'needs_revision'
return _('editorial-statusflag-title',
u"Editorial Status: $STATUS",
mapping={'STATUS': translate(voc.getTermByToken(status).title, context=self.request)})
def render(self):
return self.template()
class LookupRecipientSource(object):
implements(IRecipientSource)
name = 'group_recipient_lookup'
form_label = 'Your letter will be sent to:'
def __init__(self, context, request):
self.context = context
self.request = request
self.settings = get_recipient_settings(context, self.name)
def lookup(self):
json_data = getUtility(IGroupSource, self.name)
info = []
for id_, entry in self.settings:
if entry['recipient_type'] == self.name:
info += json_data[entry['label']]
return info
snippet = ViewPageTemplateFile('form_snippet.pt')
def render_form(self):
recipients = [r for r in self.lookup()]
if len(recipients):
return self.snippet(recipients=recipients)
return ''
class ImageInputWidget(FileWidget):
"""
render a inputwidget that displays the current
image and lets you choose to delete, replace or just
leave the current image as is.
"""
_missing = u""
__call__ = ViewPageTemplateFile("templates/image-widget.pt")
@property
def update_action_name(self):
return self.name + ".up_action"
@property
def upload_name(self):
return self.name.replace(".", "_") + "_file"
@property
def imageURL(self):
return "./file-image/%s" % self.context.__name__
def empty_field(self):
return self._data is None
def _getFieldInput(self, name):
return self.request.form.get(name, self._missing)
def _getFormInput(self):
"""extract the input value from the submitted form """
return (self._getFieldInput(self.update_action_name),
self._getFieldInput(self.upload_name))
def _toFieldValue(self, (update_action, upload)):
"""convert the input value to an value suitable for the field.
Check the update_action if we should leave the data alone,
delete or replace it.
"""
if update_action == u"update":
if upload is None or upload == "":
if self._data is None:
return self.context.missing_value
else:
raise ConversionError(
_("Form upload is not a file object"))
try:
seek = upload.seek
read = upload.read
except AttributeError, e:
raise ConversionError(
_("Form upload is not a file object"), e)
else:
seek(0)
data = read()
if data or getattr(upload, "filename", ""):
return data
else:
return self.context.missing_value
class WorkItemLabel(BrowserView):
""" General label for work items"""
template = ViewPageTemplateFile('workitem_label.pt')
def __call__(self):
return self.template()
class PigeonholeSchemaListing(crud.CrudForm):
""" The combined pigeonhole edit + add forms.
"""
@lazy_property
def description(self):
if self.get_items():
return _(
u'The following custom metadata schemas are available for '
u'your site.')
else:
return _(u'Click the "Add Schema" button to begin creating '
u' a new metadata schema.')
template = ViewPageTemplateFile('schema_listing.pt')
view_schema = field.Fields(IPigeonholeSchemaSettings).select(
'title', 'types', 'condition')
addform_factory = crud.NullForm
editform_factory = PigeonholeSchemaEditForm
def _schema_collection(self):
registry = getUtility(IRegistry)
return registry.collectionOfInterface(IPigeonholeSchemaSettings,
prefix=REGISTRY_BASE_PREFIX)
def get_items(self):
""" Look up all existing schemas in the registry.
"""
return self._schema_collection().items()
def remove(self, (name, item)):
""" Remove a schema.
"""
del self._schema_collection()[name]
class DetailsView(BibliographyView, BrowserView):
"""Details of the item."""
template = ViewPageTemplateFile('details.pt')
def getFieldTuples(self):
iface = IBiblatexEntry
value_adapter = interfaces.IEntryBibtexRepresentation(self.context)
_type = getEntryTypeSafely(getattr(self.context, 'entry_type'))
tuples = [('entry_type',
iface['entry_type'].title,
getattr(self.context, 'entry_type'))
]
flds = getRequiredTuple(_type.required)
flds += getTuple(_type.optional)
for fld in flds:
tuples.append((fld,
iface[fld].title,
value_adapter.getField(fld))
)
tuples.append(('Id',
iface['__name__'].title,
self.context.__name__
))
return tuples
class NotationBaseView(BrowserView):
cssClass = u'notation'
template = ViewPageTemplateFile('notation.pt')
def __call__(self):
return self.template()
class OneTimeEditWidget(TextAreaWidget):
"""
a text area that is meant to be used once in between edit.
when you open an edit form it displays the last entry that
was made and an empty texarea input that will get stored.
"""
__call__ = ViewPageTemplateFile("templates/one-time-textinput-widget.pt")
class OGViewlet(ViewletBase):
template = ViewPageTemplateFile('ogviewlet.pt')
def render(self):
return self.template()
def metatags(self):
return IOpengraphMetatags(self.context).metatags.items()
class DetailsView(BrowserView, RenderQuotation):
"""The @@details view which can be called from within a zpt.
"""
template = ViewPageTemplateFile('details.pt')
def __call__(self):
return self.template()
class RequirementView(schooltool.skin.containers.ContainerView):
"""A Requirement view."""
__used_for__ = schooltool.requirement.interfaces.IRequirement
index_title = _("Requirement index")
def __init__(self, context, request, depth=None):
schooltool.skin.containers.ContainerView.__init__(
self, context, request)
self.depth = depth
if self.depth is None:
self.depth = int(request.get('DEPTH', 3))
def _search(self, searchstr, context):
results = []
for item in context.values():
if searchstr.lower() in item.title.lower():
results.append(item)
results += self._search(searchstr, item)
return results
def update(self):
if 'SEARCH' in self.request and 'CLEAR_SEARCH' not in self.request:
searchstr = self.request['SEARCH'].lower()
if self.request.get('RECURSIVE'):
results = self._search(searchstr, self.context)
else:
results = [
item for item in self.context.values()
if searchstr in item.title.lower()
]
extra_url = "&SEARCH=%s" % urllib.quote(self.request['SEARCH'])
else:
self.request.form['SEARCH'] = ''
results = self.context.values()
extra_url = ""
self.batch = IterableBatch(results,
self.request,
sort_by='title',
extra_url=extra_url)
def listContentInfo(self):
children = []
if self.depth < 1:
return []
for child in self.batch:
if schooltool.requirement.interfaces.IRequirement.providedBy(
child):
info = {}
info['child'] = child
thread = RequirementView(child, self.request, self.depth - 1)
info['thread'] = thread.subthread()
children.append(info)
return children
subthread = ViewPageTemplateFile('subthread.pt')
class DbxrefPatternWidgetView:
template = ViewPageTemplateFile('dbxrefpattern.pt')
def __init__(self, context, request):
self.context = context
self.request = request
def __call__(self):
return self.template()
class OrderedMultiSelectWidget(OrderedMultiSelectWidget):
"""A multi-selection widget with ordering support."""
_missing = []
template = ViewPageTemplateFile("orderedSelectionList.pt")
def _toFieldValue(self, input):
value = super(OrderedMultiSelectWidget, self)._toFieldValue(input)
return tuple(value)
class TextDateTimeWidget(TextDateWidget):
__call__ = ViewPageTemplateFile('templates/textdatetimewidget.pt')
@property
def time_name(self):
return self.name.replace(".", "__") + '__time'
def hasInput(self):
return (self.date_name in self.request.form
and self.time_name in self.request.form)
def _hasPartialInput(self):
return (self.date_name in self.request.form
or self.time_name in self.request.form)
def _getFormInput(self):
"""extract the input value from the submitted form """
return (self._getFieldInput(self.date_name),
self._getFieldInput(self.time_name))
def _toFormValue(self, value):
"""convert a field value to a string that can be inserted into the form"""
if (value == self.context.missing_value) and self.required:
d = datetime.datetime.now()
return (datetime.datetime.strftime(d, "%Y-%m-%d"),
datetime.datetime.strftime(d, "%H:%M"))
else:
try:
return (datetime.datetime.strftime(value, "%Y-%m-%d"),
datetime.datetime.strftime(value, "%H:%M"))
except:
return ('', '')
def _toFieldValue(self, (date, time)):
if (date == self._missing or time == self._missing):
if self.required:
return self.context.missing_value
else:
if date + time == self._missing:
return None
else:
return self.context.missing_value
else:
try:
d = datetime.datetime.strptime(date, "%Y-%m-%d")
t = datetime.datetime.strptime(time, "%H:%M")
return datetime.datetime(
year=d.year,
month=d.month,
day=d.day,
hour=t.hour,
minute=t.minute,
)
except ValueError, e:
raise ConversionError(
_(u"Incorrect string data for date and time"), e)
class TinyDisplayWidget(DisplayWidget):
template = ViewPageTemplateFile('tinydisplaywidget.pt')
def __call__(self):
if self._renderedValueSet():
value = self._data
else:
value = ""
return self.template(name=self.context.__name__, value=value)
class VocabulariesIndex(browser.BungeniBrowserView):
render = ViewPageTemplateFile("templates/vocabularies.pt")
def __init__(self, context, request):
return super(VocabulariesIndex, self).__init__(context, request)
def __call__(self):
return self.render()
class ListView(BrowserView, RenderQuotation):
"""The @@list view which can be called from within a zpt."""
limit = 200
template = ViewPageTemplateFile('list.pt')
def __call__(self):
return self.template()
class OnlineHelpTopicView(BrowserView):
"""View for one particular help topic."""
def topicContent(self):
""" render the source of the help topic """
source = createObject(self.context.type, self.context.source)
view = getMultiAdapter((source, self.request))
html = view.render()
return html
renderTopic = ViewPageTemplateFile('helptopic.pt')
class SiteRSSViewlet(ViewletBase):
implements(ISiteRSSViewlet)
_links = None
@property
def prefs(self):
portal = getUtility(IPloneSiteRoot)
return ISiteRSSSchema(portal)
def _update_links(self):
# get urls
items = self.prefs.rss_items
additional_items = self.prefs.additional_rss_items
if not (items or additional_items):
self.allowed = False
else:
self.allowed = True
portal = getUtility(IPloneSiteRoot)
request = self.request
# using portal_catalog to be able to get the Title
catalog = getToolByName(self, 'portal_catalog')
self._links = []
portal_id = portal.getId()
for item in items:
if item.strip().startswith('/'):
# add portal ID before item
item = "/" + portal_id + item
topics = catalog(path={'query': item, 'depth': 0})
if len(topics) == 1:
self._links.append({
'url':
topics[0].getURL() + '/RSS',
'title':
safe_unicode(topics[0].Title)
})
for item in additional_items:
if item:
try:
url, title = item.split(' ', 1)
except ValueError:
continue
self._links.append({'url': url, 'title': title})
def links(self):
return self._links
def update(self):
super(SiteRSSViewlet, self).update()
if self._links is None:
self._update_links()
render = ViewPageTemplateFile('rsslinks.pt')
class SignUpViewlet(ViewletBase):
""" A viewlet for the provider used on the login form. """
template = ViewPageTemplateFile('signup_viewlet.pt')
def render(self):
return self.template()
def quotationtoolURL(self):
# use hooks because component lookup error if error is context
return absoluteURL(hooks.getSite(), self.request)
class ImageInputWidget(DefaultFileInputWidget):
'''
render a inputwidget that displays the current
image and lets you choose to delete, replace or just
leave the current image as is.
'''
__call__ = ViewPageTemplateFile("templates/image-widget.pt")
@property
def imageURL(self):
return "./file-image/%s" % self.context.__name__
class XapianSettings(browser.BungeniBrowserView):
render = ViewPageTemplateFile("templates/xapian-settings.pt")
def __init__(self, context, request):
return super(XapianSettings, self).__init__(context, request)
def __call__(self):
if self.request.method == "POST":
IndexReset().start()
return self.render()
class FeedViewlet(ResourceViewletBase, ViewletBase):
"""Base class for feed links eg. RSS, Atom"""
_feed_type = None
_href = None
index = ViewPageTemplateFile("templates/feed-resource.pt")
def getURL(self):
return self._href
def getType(self):
return self._feed_type
