class PTComponent(object):
def __init__(self, content, request=None):
self.context = content
self.request = request
index = ViewPageTemplateFile("view.pt")
default = ViewPageTemplateFile("default.pt")
nothing = ViewPageTemplateFile("nothing.pt")
class View(object):
__call__ = ViewPageTemplateFile('view.pt')
change_template = ViewPageTemplateFile('change.pt')
@property
def todo(self):
return ITODO(self.context)
def add(self):
subject = self.request.get('subject')
ob = Item()
ob.subject = subject
name = INameChooser(self.todo).chooseName(u"", ob)
self.todo[name] = ob
notify(ObjectModifiedEvent(self.todo))
def listing(self):
absolute_url = u"'" + absoluteURL(self.context, self.request) + u"'"
result = [u'<ol class="todo_list">']
for key in self.todo:
key_str = u"'" + key + u"'"
item = self.todo[key]
if item.closed:
subject = u'<del>' + item.subject + u'</del>'
else:
subject = item.subject
result.append(
u'<li><span onclick="todo.change(this, %s, %s)" class="todo_item">%s </span></li>' % (
absolute_url, key_str, subject or u'...'))
result.append(u'</ol>')
return u''.join(result)
def change(self):
key = self.request.get('item_key')
self.item = self.todo.get(key)
subject = self.request.get('subject')
if key and self.item and subject:
self.item.subject = subject
raw_closed = self.request.get('closed')
if raw_closed == 'true':
self.item.closed = True
elif raw_closed == 'false':
self.item.closed = False
notify(ObjectModifiedEvent(self.todo))
return self.change_template()
def remove(self):
key = self.request.get('item_key')
if self.todo.get(key):
del self.todo[key]
notify(ObjectModifiedEvent(self.todo))
class FlourishPersonFilterWidget(PersonFilterWidget):
template = ViewPageTemplateFile('f_person_filter.pt')
def filter(self, items):
if 'CLEAR_SEARCH' in self.request:
for parameter in self.parameters:
self.request.form[parameter] = ''
return items
if 'SEARCH_GROUP' in self.request:
group = self.groupContainer().get(self.request['SEARCH_GROUP'])
if group:
int_ids = getUtility(IIntIds)
keys = set(
[int_ids.queryId(person) for person in group.members])
items = [item for item in items if item['id'] in keys]
if 'SEARCH_TITLE' in self.request:
search_title = self.request['SEARCH_TITLE']
query = buildQueryString(search_title)
if query:
catalog = ICatalog(self.source)
result = catalog['text'].apply(query)
items = [item for item in items if item['id'] in result]
return items
class InstitutionView(DefaultView):
"""
"""
index = ViewPageTemplateFile(_path_to_dx_default_template())
def __call__(self):
# Don't redirect if user can edit institution
# Don't use api.user.has_permission since the method breaks robot tests
if api.user.get_permissions(
obj=self.context).get("Modify portal content"):
api.portal.show_message(
_("You see this page because you have permissions to edit it. "
"Otherwise you would have been redirected to Meetings folder. "
"To see the Meetings view, click on Meetings folder."),
request=self.request,
type="info",
)
return super(InstitutionView, self).__call__()
institution = api.portal.get_navigation_root(self.context)
meeting_folder_brains = api.content.find(
context=institution,
object_provides=IMeetingsFolder.__identifier__)
if not meeting_folder_brains:
return super(InstitutionView, self).__call__()
url = meeting_folder_brains[0].getURL()
self.request.response.redirect(url)
return ""
def updateWidgets(self, prefix=None):
super(InstitutionView, self).updateWidgets(prefix)
self.widgets[
'password'].value = self.context.password and '********************' or '-'
class PersonPreferencesView(form.EditForm):
"""View used for editing person preferences."""
fields = field.Fields(IPersonPreferences)
fields['cal_periods'].widgetFactory = CalendarPeriodsWidgetFactory
fields['cal_public'].widgetFactory = CalendarPublicWidgetFactory
template = ViewPageTemplateFile('person_preferences.pt')
@property
def label(self):
person = self.context.__parent__
return _(u'Change preferences for ${person_full_name}',
mapping={'person_full_name': person.title})
@button.buttonAndHandler(_("Apply"))
def handle_edit_action(self, action):
data, errors = self.extractData()
if errors:
self.status = self.formErrorsMessage
return
self.applyChanges(data)
self.redirectToPerson()
@button.buttonAndHandler(_("Cancel"))
def handle_cancel_action(self, action):
self.redirectToPerson()
def updateActions(self):
super(PersonPreferencesView, self).updateActions()
self.actions['apply'].addClass('button-ok')
self.actions['cancel'].addClass('button-cancel')
def redirectToPerson(self):
url = absoluteURL(self.context.__parent__, self.request)
self.request.response.redirect(url)
def DisplayViewFactory(name,
schema,
label,
permission,
layer,
template,
default_template,
bases,
for_,
fields,
fulledit_path=None,
fulledit_label=None):
class_ = SimpleViewClass(template, used_for=schema, bases=bases, name=name)
class_.schema = schema
class_.label = label
class_.fieldNames = fields
class_.fulledit_path = fulledit_path
if fulledit_path and (fulledit_label is None):
fulledit_label = "Full display"
class_.fulledit_label = fulledit_label
class_.generated_form = ViewPageTemplateFile(default_template)
defineChecker(
class_,
NamesChecker(("__call__", "__getitem__", "browserDefault"),
permission))
if layer is None:
layer = IDefaultBrowserLayer
sm = zope.component.getGlobalSiteManager()
sm.registerAdapter(class_, (for_, layer), Interface, name)
def ViewletManager(name, interface, template=None, bases=()):
"""
Create and return a new viewlet manager class that implements
:class:`zope.viewlet.interfaces.IViewletManager`.
:param str name: The name of the generated class.
:param interface: The additional interface the class will implement.
:keyword tuple bases: The base classes to extend.
"""
attrDict = {'__name__': name}
if template is not None:
attrDict['template'] = ViewPageTemplateFile(template)
if ViewletManagerBase not in bases:
# Make sure that we do not get a default viewlet manager mixin, if the
# provided base is already a full viewlet manager implementation.
if not (len(bases) == 1
and interfaces.IViewletManager.implementedBy(bases[0])):
bases = bases + (ViewletManagerBase, )
ViewletManagerCls = type(
'<ViewletManager providing %s>' % interface.getName(), bases, attrDict)
zope.interface.classImplements(ViewletManagerCls, interface)
return ViewletManagerCls
class OrderedMultiSelectWidget(ItemsMultiEditWidgetBase):
"""A multi-selection widget with ordering support."""
template = ViewPageTemplateFile('orderedSelectionList.pt')
def choices(self):
"""Return a set of tuples (text, value) that are available."""
# Not all content objects must necessarily support the attributes
if hasattr(self.context.context, self.context.__name__):
available_values = self.context.get(self.context.context)
else:
available_values = []
return [{'text': self.textForValue(term), 'value': term.token}
for term in self.vocabulary
if term.value not in available_values]
def selected(self):
"""Return a list of tuples (text, value) that are selected."""
# Get form values
values = self._getFormValue()
# Not all content objects must necessarily support the attributes
if hasattr(self.context.context, self.context.__name__):
# merge in values from content
for value in self.context.get(self.context.context):
if value not in values:
values.append(value)
terms = [self.vocabulary.getTerm(value)
for value in values]
return [{'text': self.textForValue(term), 'value': term.token}
for term in terms]
def __call__(self):
return self.template()
class PersonTableFilter(table.ajax.IndexedTableFilter, PersonFilterWidget):
template = ViewPageTemplateFile('f_person_table_filter.pt')
title = _('First name, last name or username')
@property
def search_title_id(self):
return self.manager.html_id + "-title"
@property
def search_group_id(self):
return self.manager.html_id + "-group"
@property
def parameters(self):
return (self.search_title_id, self.search_group_id)
groupContainer = PersonFilterWidget.groupContainer
groups = PersonFilterWidget.groups
active = PersonFilterWidget.active
extra_url = PersonFilterWidget.extra_url
def filter(self, results):
if self.ignoreRequest:
return results
return PersonFilterWidget.filter(self, results)
def SimpleViewletClass(template,
offering=None,
bases=(),
attributes=None,
name=u''):
"""A function that can be used to generate a viewlet from a set of
information.
"""
# Get the current frame
if offering is None:
offering = sys._getframe(1).f_globals
# Create the base class hierarchy
bases += (simple, ViewletBase)
attrs = {
'index': ViewPageTemplateFile(template, offering),
'__name__': name
}
if attributes:
attrs.update(attributes)
# Generate a derived view class.
class_ = type("SimpleViewletClass from %s" % template, bases, attrs)
return class_
def AddViewFactory(name, schema, label, permission, layer,
template, default_template, bases, for_,
fields, content_factory, arguments,
keyword_arguments, set_before_add, set_after_add):
class_ = SimpleViewClass(
template, used_for=schema, bases=bases, name=name)
class_.schema = schema
class_.label = label
class_.fieldNames = fields
class_._factory_or_id = content_factory
class_._factory = property(_getFactory, _setFactory)
class_._arguments = arguments
class_._keyword_arguments = keyword_arguments
class_._set_before_add = set_before_add
class_._set_after_add = set_after_add
class_.generated_form = ViewPageTemplateFile(default_template)
defineChecker(class_,
NamesChecker(
("__call__", "__getitem__",
"browserDefault", "publishTraverse"),
permission,
)
)
if layer is None:
layer = IDefaultBrowserLayer
s = zope.component.getGlobalSiteManager()
s.registerAdapter(class_, (for_, layer), Interface, name)
class UpdateCartView(CartViewMixin, BrowserView, P5Mixin):
"""Re-renders just the cart after user takes an AJAX action."""
index = ViewPageTemplateFile('templates/checkout_cart.pt')
cart_is_editable = True
def update(self):
try:
if 'add' in self.request.form:
cart_id = self.request.form['add']
self.cart[cart_id].quantity += 1
if 'change' in self.request.form:
cart_id = self.request.form['change']
self.cart[cart_id].quantity = int(
self.request.form['quantity'])
if 'remove' in self.request.form:
cart_id = self.request.form['remove']
self.cart[cart_id].quantity = 0
if 'del' in self.request.form:
cart_id = self.request.form['del']
self.cart[cart_id].quantity -= 1
except OutOfStock:
self.cart_warnings = {
cart_id: 'Not enough items in stock.',
}
self.validate_cart()
def __call__(self):
self.update()
return self.index()
def render(self):
if not self.__updated:
raise UpdateNotCalled
pageTemplate = ViewPageTemplateFile(self.pageTemplateFileName)
retval = pageTemplate(self)
return retval
class DisplayChildrenPodTemplateProvider(ContentProviderBase):
template = ViewPageTemplateFile("children_pod_template.pt")
@property
def name(self):
""" """
return self.__name__
@property
def value(self):
""" """
return self.render()
@property
def label(self):
return ""
def get_children(self):
return self.context.get_children_pod_template()
def render_child(self, child):
return "{0} ({1})".format(child.Title(), child.absolute_url())
def render(self):
return self.template()
class NITFBasicTile(BasicTile):
"""A tile that shows general information about news articles.
"""
index = ViewPageTemplateFile('templates/nitf.pt')
def accepted_ct(self):
return ['collective.nitf.content']
def populate_with_object(self, obj):
super(NITFBasicTile, self).populate_with_object(obj)
data_mgr = ITileDataManager(self)
data = data_mgr.get()
data['subtitle'] = obj.subtitle
data['section'] = obj.section
img = obj.getImage()
if img:
data['image_description'] = img.Description() or img.Title()
data_mgr.set(data)
def thumbnail(self, field, scales):
scale = field.get('scale', 'large')
return scales.scale('image', scale)
def variacao_titulo(self):
tamanhos = {
u'Normal': None,
u'Grande': 'grande',
u'Gigante': 'gigante'
}
if self.data['variacao_titulo']:
return tamanhos[self.data['variacao_titulo']]
class Editor(zeit.edit.browser.editor.Editor):
render = ViewPageTemplateFile('editor.pt')
def __call__(self):
config = zope.app.appsetup.product.getProductConfiguration(
'zeit.content.cp')
zeit.content.cp.browser.resources.RemoteURLResource(
zeit.content.cp.browser.resources.lib,
'/repository' + config['layout-css-path']).need()
return super(Editor, self).__call__()
@property
def form_css_class(self):
if not self.has_permission('zeit.content.cp.EditArea'):
return 'create-area-forbidden'
def has_permission(self, permission):
return self.request.interaction.checkPermission(
permission, self.context)
def validate(self, area):
validation_class, validation_messages = (
zeit.edit.browser.view.validate(area))
css_class = ['editable-area']
if validation_class:
css_class.append(validation_class)
css_class = ' '.join(css_class)
return dict(class_=css_class, messages=validation_messages)
class CountrySelectionWidget(WithTemplateWidget):
template = ViewPageTemplateFile('templates/country-selection-widget.pt')
def getVocabulary(self):
return self.context.vocabulary
def required(self):
return self.context.required
def testMacroExtension(self):
# This test demonstrates how macro extension allows a macro to extend
# and re-offer a slot for a client template to fill.
outer = ViewPageTemplateFile('outer.pt')
intermediate = ViewPageTemplateFile('intermediate.pt')
inner = ViewPageTemplateFile('inner.pt')
context = Context()
request = TestRequest()
view = View(context, request)
self.failUnless('outer body slot' in outer(view))
namespace = inner.pt_getContext(view, request)
namespace['outer'] = outer
namespace['intermediate'] = intermediate
result = inner.pt_render(namespace)
self.assertEquals(result.replace("\r\n", "\n"), EXPECTED)
class CheckoutThankYou(CheckoutFormBase):
""" Renders the Thank You Page """
index = ViewPageTemplateFile('../templates/checkout_thankyou.pt')
def handle_submit(self):
pass
def render(self):
return self.index()
class DisclaimerWidget(CheckBoxWidget):
""" Widget for accept terms of use in user registration """
template = ViewPageTemplateFile('browser/templates/disclaimer-widget.pt')
def __call__(self):
val = super(DisclaimerWidget, self).__call__()
self.val = val
return self.template()
class ReferenceDetailsHeading(zeit.cms.browser.objectdetails.Details):
template = ViewPageTemplateFile(pkg_resources.resource_filename(
'zeit.cms.browser', 'object-details-heading.pt'))
def __init__(self, context, request):
super(ReferenceDetailsHeading, self).__init__(context.target, request)
def __call__(self):
return self.template()
def JavaScriptViewlet(path):
"""Create a viewlet that can simply insert a javascript link."""
src = os.path.join(os.path.dirname(__file__), 'javascript_viewlet.pt')
klass = type('JavaScriptViewlet', (ResourceViewletBase, ViewletBase), {
'index': ViewPageTemplateFile(src),
'_path': path
})
return klass
class DisclaimerPermissionWidget(CheckBoxWidget):
""" Widget for permission to be contacted by email """
template = ViewPageTemplateFile(
'browser/templates/disclaimer-permission-widget.pt')
def __call__(self):
val = super(DisclaimerPermissionWidget, self).__call__()
self.val = val
return self.template()
class ObjectWidgetView:
template = ViewPageTemplateFile('objectwidget.pt')
def __init__(self, context, request):
self.context = context
self.request = request
def __call__(self):
return self.template()
def CSSBundleViewlet(items):
"""Create a viewlet that can simply insert css links."""
src = os.path.join(os.path.dirname(__file__), 'css_bundle_viewlet.pt')
klass = type('CSSBundleViewlet',
(CSSResourceBundleViewletBase, ViewletBase), {
'index': ViewPageTemplateFile(src),
'_items': items
})
return klass
class NITFTile(BasicTile):
"""A tile that shows information about a News Article."""
index = ViewPageTemplateFile('nitf.pt')
is_configurable = True
is_editable = True
is_droppable = True
short_name = _(u'msg_short_name_nitf', u'News Article')
def accepted_ct(self):
"""Return a list of content types accepted by the tile."""
return ['collective.nitf.content']
def populate_with_object(self, obj):
super(BasicTile, self).populate_with_object(obj)
if INITF.providedBy(obj):
image = obj.image()
data = dict(
title=obj.title,
description=obj.description,
subtitle=obj.subtitle,
section=obj.section,
uuid=IUUID(obj),
date=True,
subjects=True,
image=self.get_image_data(image),
media_producer=obj.media_producer(),
)
# clear scales as new image is getting saved
self.clear_scales()
data_mgr = ITileDataManager(self)
data_mgr.set(data)
def _get_field_configuration(self, field):
"""Return a dict with the configuration of the field. This is a
helper function to deal with the ugliness of the internal data
structure.
"""
fields = self.get_configured_fields()
return [f for f in fields if f['id'] == field][0]
@property
def title_tag(self):
field = self._get_field_configuration('title')
tag, title, href = field['htmltag'], field['content'], self.getURL()
return u"""
<{tag}>
<a href="{href}">{title}</a>
</{tag}>
""".format(tag=tag, title=title, href=href)
class Details(zeit.cms.browser.objectdetails.Details):
index = ViewPageTemplateFile(
pkg_resources.resource_filename('zeit.content.video.browser',
'object-details-body.pt'))
def __call__(self):
return self.index()
@property
def graphical_preview_url(self):
return self.context.video_still
class LinkWidget(zope.formlib.widget.BrowserWidget):
__call__ = ViewPageTemplateFile('manual.pt')
# Must be set in setUpWidgets, because zope.formlib API provides no access
# to the form from the widget, major sigh.
key = None
@property
def href(self):
terms = zope.component.getMultiAdapter(
(LINK_SOURCE(None), self.request), zope.browser.interfaces.ITerms)
return terms.getTerm(self.key).title
def CSSViewlet(path, media="all", rel="stylesheet"):
"""Create a viewlet that can simply insert a CSS link."""
src = os.path.join(os.path.dirname(__file__), 'css_viewlet.pt')
klass = type(
'CSSViewlet', (CSSResourceViewletBase, ViewletBase), {
'index': ViewPageTemplateFile(src),
'_path': path,
'_media': media,
'_rel': rel
})
return klass
class ManageDocumentTopics:
template = ViewPageTemplateFile("topics.pt")
def __call__(self):
if self.request.get("submit"):
topics = self.request.get("topics")
if topics:
topics = [x.strip() for x in topics.split(",")]
self.context.update_topics(topics)
self.request.response.redirect(".")
self.titles = ", ".join([x.title for x in self.context.get_topics()])
return self.template()
class JazShopPFGCallback(BrowserView):
""" Redirect to form's thank-you page, if available. """
index = ViewPageTemplateFile('thanks.pt')
def __call__(self):
order_id = self.request.form.get('order_id')
error = self.request.form.get('error', None)
self.error = None
mail_not_sent = self.request.form.get('mail_not_sent', None)
self.mail_not_sent = None
if error != None:
error.replace("_", " ") # decode error message
self.error = error
if mail_not_sent != None:
mail_not_sent.replace("_", " ") # decode error message
self.mail_not_sent = mail_not_sent
self.cart_items = []
self.cart_data = []
self.amount = 0
self.ship_method = None
self.ship_charge = None
self.taxes = None
if order_id:
# get cart data from stored order
data = get_order_from_id(order_id)
self.cart_items = data['items'].items()
for order_item in self.cart_items:
href = resolve_uid(order_item[1]['uid']).absolute_url()
self.cart_data.append({
'href': href,
'quantity': order_item[1]['quantity'],
'price': order_item[1]['price'],
'name': order_item[1]['name']
})
self.amount += order_item[1]['quantity'] * order_item[1][
'price']
if 'ship_charge' in data:
self.amount += data['ship_charge']
self.ship_charge = data['ship_charge']
if 'taxes' in data:
for tax_entry in data['taxes']:
self.amount += tax_entry['tax']
self.taxes = data['taxes']
if 'ship_method' in data:
self.ship_method = data['ship_method']
return self.index()
