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