def _provided(self): name = self.context.name provided = self.provided() if name: info = _("${provided} utility named '${name}'", mapping={"provided": provided, "name": name}) else: info = _("${provided} utility", mapping={"provided": provided}) return info
def _provided(self): name = self.context.name provided = self.provided() if name: info = _("${provided} utility named '${name}'", mapping={ "provided": provided, "name": name }) else: info = _("${provided} utility", mapping={"provided": provided}) return info
def addSiteManager(self): """Convert a possible site to a site >>> from zope.traversing.interfaces import IContainmentRoot >>> from zope.interface import implements >>> class PossibleSite(object): ... implements(IContainmentRoot) ... def setSiteManager(self, sm): ... from zope.interface import directlyProvides ... directlyProvides(self, zope.component.interfaces.ISite) >>> folder = PossibleSite() >>> from zope.publisher.browser import TestRequest >>> request = TestRequest() Now we'll make our folder a site: >>> MakeSite(folder, request).addSiteManager() Now verify that we have a site: >>> zope.component.interfaces.ISite.providedBy(folder) 1 Note that we've also redirected the request: >>> request.response.getStatus() 302 >>> request.response.getHeader('location') '++etc++site/@@SelectedManagementView.html' If we try to do it again, we'll fail: >>> MakeSite(folder, request).addSiteManager() Traceback (most recent call last): ... UserError: This is already a site """ if zope.component.interfaces.ISite.providedBy(self.context): raise UserError(_(u'This is already a site')) # We don't want to store security proxies (we can't, # actually), so we have to remove proxies here before passing # the context to the SiteManager. bare = removeSecurityProxy(self.context) sm = LocalSiteManager(bare) self.context.setSiteManager(sm) self.request.response.redirect( "++etc++site/@@SelectedManagementView.html")
class UtilityAdding(ComponentAdding): """Adding subclass used for adding utilities.""" menu_id = None title = _("Add Utility") def nextURL(self): v = zope.component.queryMultiAdapter((self.added_object, self.request), name="addRegistration.html") if v is not None: url = zope.component.absoluteURL(self.added_object, self.request) return url + "/@@addRegistration.html" return super(UtilityAdding, self).nextURL()
def render(self): url = component.getMultiAdapter( (self.context.component, self.request), name='absolute_url') try: url = url() except TypeError: # pragma: no cover url = "" cname = getattr(self.context.component, '__name__', '') if not cname: # pragma: no cover cname = _("(unknown name)") if url: url += "/@@SelectedManagementView.html" return { "cname": cname, "url": url, "info": self._provided(), "comment": self._comment() }
def render(self): url = component.getMultiAdapter((self.context.component, self.request), name='absolute_url') try: url = url() except TypeError: url = "" cname = getattr(self.context.component, '__name__', '') if not cname: cname = _("(unknown name)") if url: url += "/@@SelectedManagementView.html" return { "cname": cname, "url": url, "info": self._provided(), "comment": self._comment() }
def label(self): return _("Register a $classname", mapping=dict(classname=self.context.__class__.__name__) )
def _comment(self): comment = self.context.info or '' if comment: comment = _("comment: ${comment}", mapping={"comment": comment}) return comment
def label(self): return _("Register a $classname", mapping=dict(classname=self.context.__class__.__name__))
class AddUtilityRegistration(form.Form): """View for registering utilities Normally, the provided interface and name are input. A subclass can provide an empty 'name' attribute if the component should always be registered without a name. A subclass can provide a 'provided' attribute if a component should always be registered with the same interface. """ component.adapts(None, zope.publisher.interfaces.browser.IBrowserRequest) form_fields = form.Fields( schema.Choice( __name__='provided', title=_("Provided interface"), description=_("The interface provided by the utility"), vocabulary="Utility Component Interfaces", required=True, ), schema.TextLine( __name__='name', title=_("Register As"), description=_("The name under which the utility will be known."), required=False, default=u'', missing_value=u''), schema.Text(__name__='comment', title=_("Comment"), required=False, default=u'', missing_value=u''), ) name = provided = None prefix = 'field' # in hopes of making old tests pass. :) def __init__(self, context, request): if self.name is not None: self.form_fields = self.form_fields.omit('name') if self.provided is not None: self.form_fields = self.form_fields.omit('provided') super(AddUtilityRegistration, self).__init__(context, request) def update(self): # hack to make work with old tests if 'UPDATE_SUBMIT' in self.request.form: warnings.warn("Old test needs to be updated.", DeprecationWarning) self.request.form['field.actions.register'] = 'Register' self.request.form['field.comment'] = u'' super(AddUtilityRegistration, self).update() @property def label(self): return _("Register a $classname", mapping=dict(classname=self.context.__class__.__name__)) @form.action(_("Register")) def register(self, action, data): sm = component.getSiteManager(self.context) name = self.name if name is None: name = data['name'] provided = self.provided if provided is None: provided = data['provided'] # We have to remove the security proxy to save the registration sm.registerUtility(removeSecurityProxy(self.context), provided, name, data['comment'] or '') if 'UPDATE_SUBMIT' in self.request.form: # Backward compat until 3.5 self.request.response.redirect('@@SelectedManagementView.html') return self.request.response.redirect('@@registration.html')