def resourceDirectory(_context, name, directory, layer='default', permission='zope.Public'): if not os.path.isdir(directory): raise ConfigurationError("Directory %s does not exist" % directory) resource = DirectoryResourceFactory.resource f_cache = {} resource_factories = dict(resource.resource_factories) resource_factories['default'] = resource.default_factory for ext, factory in resource_factories.items(): if f_cache.get(factory) is not None: continue factory_info = _rd_map.get(factory) factory_info['count'] += 1 class_name = '%s%s' % (factory_info['prefix'], factory_info['count']) factory_name = '%s%s' % (factory.__name__, factory_info['count']) f_resource = makeClass(class_name, (factory.resource, ), {}) f_cache[factory] = makeClass(factory_name, (factory, ), {'resource': f_resource}) for ext, factory in resource_factories.items(): resource_factories[ext] = f_cache[factory] default_factory = resource_factories['default'] del resource_factories['default'] cdict = { 'resource_factories': resource_factories, 'default_factory': default_factory } factory_info = _rd_map.get(DirectoryResourceFactory) factory_info['count'] += 1 class_name = '%s%s' % (factory_info['prefix'], factory_info['count']) dir_factory = makeClass(class_name, (resource, ), cdict) factory = DirectoryResourceFactory(name, directory, resource_factory=dir_factory) new_classes = [ dir_factory, ] + [f.resource for f in f_cache.values()] _context.action( discriminator=('resource', name, IBrowserRequest, layer), callable=handler, args=(Presentation, 'provideResource', name, IBrowserRequest, factory, layer), ) for new_class in new_classes: _context.action(discriminator=('five:protectClass', new_class), callable=protectClass, args=(new_class, permission)) _context.action(discriminator=('five:initialize:class', new_class), callable=initializeClass, args=(new_class, ))
def resourceDirectory(_context, name, directory, layer=IDefaultBrowserLayer, permission='zope.Public'): if not os.path.isdir(directory): raise ConfigurationError( "Directory %s does not exist" % directory ) resource = DirectoryResourceFactory.resource f_cache = {} resource_factories = dict(resource.resource_factories) resource_factories['default'] = resource.default_factory for ext, factory in resource_factories.items(): if f_cache.get(factory) is not None: continue factory_info = _rd_map.get(factory) factory_info['count'] += 1 class_name = '%s%s' % (factory_info['prefix'], factory_info['count']) factory_name = '%s%s' % (factory.__name__, factory_info['count']) f_resource = makeClass(class_name, (factory.resource,), {}) f_cache[factory] = makeClass(factory_name, (factory,), {'resource':f_resource}) for ext, factory in resource_factories.items(): resource_factories[ext] = f_cache[factory] default_factory = resource_factories['default'] del resource_factories['default'] cdict = {'resource_factories':resource_factories, 'default_factory':default_factory} factory_info = _rd_map.get(DirectoryResourceFactory) factory_info['count'] += 1 class_name = '%s%s' % (factory_info['prefix'], factory_info['count']) dir_factory = makeClass(class_name, (resource,), cdict) factory = DirectoryResourceFactory(name, directory, resource_factory=dir_factory) new_classes = [dir_factory, ] + [f.resource for f in f_cache.values()] _context.action( discriminator = ('resource', name, IBrowserRequest, layer), callable = handler, args = ('registerAdapter', factory, (layer,), Interface, name, _context.info), ) for new_class in new_classes: _context.action( discriminator = ('five:protectClass', new_class), callable = protectClass, args = (new_class, permission) ) _context.action( discriminator = ('five:initialize:class', new_class), callable = initializeClass, args = (new_class,) )
def paragraphDirective(_context, targets, renderer=None, template=None, name="default", filtering = None, description=None, folderish=False, macro=None): cname = "Paragraph renderer %s" % name attrs = {} if template is not None: if macro is not None: attrs['index'] = ViewPageTemplateAndMacroFile(template) attrs['__renderer_macro__'] = macro else: attrs['index'] = ViewPageTemplateFile(template) attrs['__renderer_macro__'] = None if renderer is None: attrs['__doc__'] = description or u"default renderer" baseclasses = (ParagraphStructuredRenderer,) else: attrs['__doc__'] = description or renderer.__doc__ baseclasses = (renderer, ParagraphStructuredRenderer,) if folderish == True: baseclasses = baseclasses + (FolderishRenderer,) attrs['__name__'] = name klass = makeClass(cname, baseclasses, attrs) if filtering: klass._filtering = filtering for target in targets: adapter(_context, (klass,), provides = IParagraphRenderer, for_ = (target,IBrowserRequest), name = name, trusted=True)
def resource( _context, name, layer=IDefaultBrowserLayer, permission="zope.Public", file=None, image=None, template=None ): if (file and image) or (file and template) or (image and template) or not (file or image or template): raise ConfigurationError( "Must use exactly one of file or image or template" "attributes for resource directives" ) res = file or image or template res_type = (file and "file") or (image and "image") or (template and "template") factory_info = _factory_map.get(res_type) factory_info["count"] += 1 res_factory = factory_info["factory"] class_name = "%s%s" % (factory_info["prefix"], factory_info["count"]) new_class = makeClass(class_name, (res_factory.resource,), {}) factory = res_factory(name, res, resource_factory=new_class) _context.action( discriminator=("resource", name, IBrowserRequest, layer), callable=handler, args=("provideAdapter", (layer,), Interface, name, factory, _context.info), ) _context.action(discriminator=("five:protectClass", new_class), callable=protectClass, args=(new_class, permission)) _context.action(discriminator=("five:initialize:class", new_class), callable=initializeClass, args=(new_class,))
def concatresource(_context, name, files=None, compress_level='safe', caching='default', lmt_check_period=60.0, layer=IDefaultBrowserLayer, permission='zope.Public'): if not files: raise ConfigurationError( "Must use a files" " attribute for concatresource directives, with at least" " one file contained." ) res = files res_type = 'files' factory_info = _factory_map.get(res_type) factory_info['count'] += 1 res_factory = factory_info['factory'] if __five__: checker = None _class_name = '%s%s' % (factory_info['prefix'], factory_info['count']) new_class = makeClass(_class_name, (res_factory.resource,), {}) _context.action( discriminator = ('five:protectClass', new_class), callable = protectClass, args = (new_class, permission) ) _context.action( discriminator = ('five:initialize:class', new_class), callable = InitializeClass, args = (new_class,) ) else: new_class = res_factory.resource if permission == 'zope.Public': permission = CheckerPublic checker = NamesChecker(allowed_names, permission) factory = res_factory(res, name, compress_level, caching, lmt_check_period, resource_factory=new_class, checker=checker) if __pre_3_3__: _context.action( discriminator = ('resource', name, IBrowserRequest, layer), callable = handler, args = ('provideAdapter', (layer,), Interface, name, factory, _context.info), ) else: _context.action( discriminator = ('resource', name, IBrowserRequest, layer), callable = handler, args = ('registerAdapter', factory, (layer,), Interface, name, _context.info), )
def resourceDirectory(_context, name, directory, layer=IDefaultBrowserLayer, permission="zope.Public"): if not os.path.isdir(directory): raise ConfigurationError("Directory %s does not exist" % directory) resource = DirectoryResourceFactory.resource f_cache = {} resource_factories = dict(resource.resource_factories) resource_factories["default"] = resource.default_factory for ext, factory in resource_factories.items(): if f_cache.get(factory) is not None: continue factory_info = _rd_map.get(factory) factory_info["count"] += 1 class_name = "%s%s" % (factory_info["prefix"], factory_info["count"]) factory_name = "%s%s" % (factory.__name__, factory_info["count"]) f_resource = makeClass(class_name, (factory.resource,), {}) f_cache[factory] = makeClass(factory_name, (factory,), {"resource": f_resource}) for ext, factory in resource_factories.items(): resource_factories[ext] = f_cache[factory] default_factory = resource_factories["default"] del resource_factories["default"] cdict = {"resource_factories": resource_factories, "default_factory": default_factory} factory_info = _rd_map.get(DirectoryResourceFactory) factory_info["count"] += 1 class_name = "%s%s" % (factory_info["prefix"], factory_info["count"]) dir_factory = makeClass(class_name, (resource,), cdict) factory = DirectoryResourceFactory(name, directory, resource_factory=dir_factory) new_classes = [dir_factory] + [f.resource for f in f_cache.values()] _context.action( discriminator=("resource", name, IBrowserRequest, layer), callable=handler, args=("provideAdapter", (layer,), Interface, name, factory, _context.info), ) for new_class in new_classes: _context.action( discriminator=("five:protectClass", new_class), callable=protectClass, args=(new_class, permission) ) _context.action(discriminator=("five:initialize:class", new_class), callable=initializeClass, args=(new_class,))
def makeClassForTemplate(filename, globals=None, used_for=None, bases=(), cdict=None, name=u""): # XXX needs to deal with security from the bases? if cdict is None: cdict = {} cdict.update({"index": ZopeTwoPageTemplateFile(filename, globals), "__name__": name}) bases += (ViewMixinForTemplates,) class_ = makeClass("SimpleViewClass from %s" % filename, bases, cdict) if used_for is not None: class_.__used_for__ = used_for return class_
def makeClassForTemplate(filename, globals=None, used_for=None, bases=(), cdict=None, name=u''): # XXX needs to deal with security from the bases? if cdict is None: cdict = {} cdict.update({'index': ZopeTwoPageTemplateFile(filename, globals), '__name__': name}) bases += (ViewMixinForTemplates,) class_ = makeClass("SimpleViewClass from %s" % filename, bases, cdict) if used_for is not None: class_.__used_for__ = used_for return class_
def update(self): """ Generate a zope schema from an AT schema. """ types = getToolByName(self.context, 'portal_types') fti = types[self.portal_type] self.description = fti.Description() # Generate a class from which dummy AT instances can be made. # Cached on the types tool for per-portal dynamic schemata if not hasattr(types, '_v_at_z3c_form_classes'): types._v_at_z3c_form_classes = {} class_ = types._v_at_z3c_form_classes.get(self.portal_type) if class_ is None: factory = fti._queryFactoryMethod(self.context) class_ = factory.im_func.func_globals[factory.__name__[3:]] class_ = types._v_at_z3c_form_classes[ self.portal_type] = metaclass.makeClass( class_.__name__, (class_, ), dict( __init__=BaseObject.BaseObject.__init__)) self.instance = class_('instance').__of__(self.context) schemata = self.instance.Schemata() # Generate interfaces from the AT schemata self.schema = metaclass.makeClass( 'I' + class_.__name__, (interface.Interface, ), dict( (name, ATField(schemata['default'][name], self.instance)) for name in schemata['default'].keys())) self.additionalSchemata = ( metaclass.makeClass( 'I' + fieldset.capitalize(), (interface.Interface, ), dict( (name, ATField(schemata[fieldset][name], self.instance)) for name in schemata[fieldset].keys())) for fieldset in schemata.keys() if fieldset != 'default') return super(ATRowAddForm, self).update()
def update(self): """ Generate a zope schema from an AT schema. """ types = getToolByName(self.context, 'portal_types') fti = types[self.portal_type] self.description = fti.Description() # Generate a class from which dummy AT instances can be made. # Cached on the types tool for per-portal dynamic schemata if not hasattr(types, '_v_at_z3c_form_classes'): types._v_at_z3c_form_classes = {} class_ = types._v_at_z3c_form_classes.get(self.portal_type) if class_ is None: factory = fti._queryFactoryMethod(self.context) class_ = factory.im_func.func_globals[factory.__name__[3:]] class_ = types._v_at_z3c_form_classes[ self.portal_type] = metaclass.makeClass( class_.__name__, (class_, ), dict(__init__=BaseObject.BaseObject.__init__)) self.instance = class_('instance').__of__(self.context) schemata = self.instance.Schemata() # Generate interfaces from the AT schemata self.schema = metaclass.makeClass( 'I' + class_.__name__, (interface.Interface, ), dict((name, ATField(schemata['default'][name], self.instance)) for name in schemata['default'].keys())) self.additionalSchemata = (metaclass.makeClass( 'I' + fieldset.capitalize(), (interface.Interface, ), dict((name, ATField(schemata[fieldset][name], self.instance)) for name in schemata[fieldset].keys())) for fieldset in schemata.keys() if fieldset != 'default') return super(ATRowAddForm, self).update()
def serviceDirective( _context, method, accept, factory, for_, permission, layer=IDefaultBrowserLayer, name=u'', ): _handle_for(_context, for_) media_types = parse_accept_header(accept) for media_type in media_types: service_id = register_service(method.upper(), media_type) view_name = service_id + name # We need a service for CORS preflight processing but we don't get the # desired Accept header in the preflight request. Thus we just register # the current service_id for the given method. register_method_for_preflight(method.upper(), service_id) # Create a new class. We'll execute some security declarations on it # and don't want to modify the original class. cdict = getSecurityInfo(factory) cdict['__name__'] = view_name cdict['method'] = method.upper() new_class = makeClass(factory.__name__, (factory, BrowserView), cdict) _context.action( discriminator=('plone.rest:service', method, media_type, for_, name, layer), callable=handler, args=('registerAdapter', new_class, (for_, layer), Interface, view_name, _context.info), ) _context.action( discriminator=('plone.rest:protectClass', new_class), callable=protectClass, args=(new_class, permission) ) _context.action( discriminator=('plone.rest:InitializeClass', new_class), callable=InitializeClass, args=(new_class,) )
def __call__(self, *args): #XXX raise a sensible exception if context and request are # omitted, IOW, if someone tries to render the template not as # a view. sm = getSecurityManager() if self.permission: if not sm.checkPermission(self.permission, args[0]): raise Unauthorized('The current user does not have the ' 'required "%s" permission' % self.permission) class_ = makeClass( 'FrankensteinTTWTemplate', (TTWViewTemplateRenderer, self.view), {'__name__': self.name, '__view_name__': self.name, 'module_info': FakeModuleInfoForGrok(self.view.__module__)}) return class_(self, self.view, args)
def formControllerPage( _context, name, permission, for_, type_name, layer=browser.IDefaultBrowserLayer, template=None, class_=None, allowed_interface=None, allowed_attributes=None, attribute='__call__', menu=None, title=None): """Add the name to the class dict to make it accessible for looking up the template""" class_name = 'GeneratedFormControllerTemplateAddForm' bases = (at.FormControllerTemplateAddForm,) if class_ is not None: class_name = class_.__name__ bases = (class_, at.FormControllerTemplateAddForm) class_ = metaclass.makeClass( class_name, bases, dict(name=name, type_name=type_name)) metaconfigure.page( _context, name, permission, for_, layer=layer, template=template, class_=class_, allowed_interface=allowed_interface, allowed_attributes=allowed_attributes, attribute=attribute, menu=menu, title=title)
def cors_policy_directive( _context, allow_origin, allow_credentials, allow_methods=None, expose_headers=None, allow_headers=None, max_age=None, for_=Interface, layer=IDefaultBrowserLayer,): _handle_for(_context, for_) # Create a new policy class and store the CORS policy configuration in # class attributes. cdict = {} cdict['allow_origin'] = [o.strip() for o in allow_origin.split(',')] if allow_methods is not None: cdict['allow_methods'] = [m.strip() for m in allow_methods.split(',')] else: cdict['allow_methods'] = None cdict['allow_credentials'] = allow_credentials if expose_headers: cdict['expose_headers'] = [ h.strip() for h in expose_headers.split(',')] else: cdict['expose_headers'] = [] if allow_headers: cdict['allow_headers'] = [h.strip() for h in allow_headers.split(',')] else: cdict['allow_headers'] = [] cdict['max_age'] = max_age new_class = makeClass(CORSPolicy.__name__, (CORSPolicy,), cdict) _context.action( discriminator=('plone.rest:CORSPolicy', for_, layer), callable=handler, args=('registerAdapter', new_class, (for_, layer), ICORSPolicy, u'', _context.info), )
def resource(_context, name, layer=IDefaultBrowserLayer, permission='zope.Public', file=None, image=None, template=None): if ((file and image) or (file and template) or (image and template) or not (file or image or template)): raise ConfigurationError( "Must use exactly one of file or image or template" "attributes for resource directives" ) res = file or image or template res_type = ((file and 'file') or (image and 'image') or (template and 'template')) factory_info = _factory_map.get(res_type) factory_info['count'] += 1 res_factory = factory_info['factory'] class_name = '%s%s' % (factory_info['prefix'], factory_info['count']) new_class = makeClass(class_name, (res_factory.resource,), {}) factory = res_factory(name, res, resource_factory=new_class) _context.action( discriminator = ('resource', name, IBrowserRequest, layer), callable = handler, args = ('provideAdapter', (layer,), Interface, name, factory, _context.info), ) _context.action( discriminator = ('five:protectClass', new_class), callable = protectClass, args = (new_class, permission) ) _context.action( discriminator = ('five:initialize:class', new_class), callable = initializeClass, args = (new_class,) )
def resource(_context, name, layer=IDefaultBrowserLayer, permission='zope.Public', file=None, image=None, template=None): if ((file and image) or (file and template) or (image and template) or not (file or image or template)): raise ConfigurationError( "Must use exactly one of file or image or template" "attributes for resource directives" ) res = file or image or template res_type = ((file and 'file') or (image and 'image') or (template and 'template')) factory_info = _factory_map.get(res_type) factory_info['count'] += 1 res_factory = factory_info['factory'] class_name = '%s%s' % (factory_info['prefix'], factory_info['count']) new_class = makeClass(class_name, (res_factory.resource,), {}) factory = res_factory(name, res, resource_factory=new_class) _context.action( discriminator = ('resource', name, IBrowserRequest, layer), callable = handler, args = ('registerAdapter', factory, (layer,), Interface, name, _context.info), ) _context.action( discriminator = ('five:protectClass', new_class), callable = protectClass, args = (new_class, permission) ) _context.action( discriminator = ('five:initialize:class', new_class), callable = initializeClass, args = (new_class,) )
def portletRendererDirective(_context, portlet, class_=None, template=None, for_=Interface, layer=IDefaultBrowserLayer, view=IBrowserView, manager=IPortletManager): """Register a custom/override portlet renderer """ if class_ is None and template is None: raise TypeError("Either 'template' or 'class' must be given") if class_ is not None and template is not None: raise TypeError("'template' and 'class' cannot be specified at the same time") if template is not None: # Look up the default renderer for this portlet base_class = _default_renderers.get(portlet, None) if base_class is None: raise TypeError("Can't find default renderer for %s. " "Perhaps the portlet has not been registered yet?" % portlet.__identifier__) # Generate a subclass with 'renderer' using this template class_ = makeClass("PortletRenderer from %s" % template, (base_class, ), {'render': ViewPageTemplateFile(template)}) adapter(_context, (class_, ), provides=IPortletRenderer, for_=(for_, layer, view, manager, portlet))
def view(_context, for_=None, interface=None, methods=None, class_=None, permission=None, name=None): interface = interface or [] methods = methods or [] # If there were special permission settings provided, then use them if permission == 'zope.Public': permission = CheckerPublic require = {} for attr_name in methods: require[attr_name] = permission if interface: for iface in interface: for field_name in iface: require[field_name] = permission _context.action( discriminator = None, callable = provideInterface, args = ('', for_)) cdict = getSecurityInfo(class_) if name: cdict['__name__'] = name new_class = makeClass(class_.__name__, (class_, BrowserView), cdict) _handle_for(_context, for_) # Register the new view. _context.action( discriminator = ('view', (for_, ), name, ISOAPRequest), callable = handler, args = ('registerAdapter', new_class, (for_, ISOAPRequest), Interface, name, _context.info) ) _context.action( discriminator = ('five:protectClass', new_class), callable = protectClass, args = (new_class, permission)) for name in require: _context.action( discriminator = ('five:protectName', new_class, name), callable = protectName, args = (new_class, name, permission)) #else its private: allowed = require private_attrs = [name for name in dir(new_class) if (not name.startswith('_')) and (name not in allowed) and ismethod(getattr(new_class, name))] for attr in private_attrs: _context.action( discriminator = ('five:protectName', new_class, attr), callable = protectName, args = (new_class, attr, CheckerPrivateId)) else: for name in require: cdict.update({'__page_attribute__': name, '__name__': name}) new_class = makeClass(class_.__name__, (class_, ViewMixinForAttributes), cdict) func = getattr(new_class, name) if not func.__doc__: # cannot test for MethodType/UnboundMethod here # because of ExtensionClass if hasattr(func, 'im_func'): # you can only set a docstring on functions, not # on method objects func = func.im_func func.__doc__ = "Stub docstring to make ZPublisher work" _context.action( discriminator = ('view', (for_, ), name, ISOAPRequest), callable = handler, args = ('registerAdapter', new_class, (for_, ISOAPRequest), Interface, name, _context.info)) _context.action( discriminator = ('five:protectClass', new_class), callable = protectClass, args = (new_class, permission)) _context.action( discriminator = ('five:protectName', new_class, name), callable = protectName, args = (new_class, name, permission)) _context.action( discriminator = ('five:initialize:class', new_class), callable = initializeClass, args = (new_class, ) ) # Register the used interfaces with the interface service if for_ is not None: _context.action( discriminator = None, callable = provideInterface, args = ('', for_))
def _processWidgets(self): if self._widgets: customWidgetsObject = makeClass('CustomWidgetsMixin', (ExtensionClass.Base, ), self._widgets) self.bases = self.bases + (customWidgetsObject, )
def _processWidgets(self): if self._widgets: customWidgetsObject = makeClass( 'CustomWidgetsMixin', (ExtensionClass.Base,), self._widgets) self.bases = self.bases + (customWidgetsObject,)
def page(_context, name, permission, for_, layer=IDefaultBrowserLayer, template=None, class_=None, allowed_interface=None, allowed_attributes=None, attribute='__call__', menu=None, title=None, ): _handle_menu(_context, menu, title, [for_], name, permission) if not (class_ or template): raise ConfigurationError("Must specify a class or template") if allowed_attributes is None: allowed_attributes = [] if allowed_interface is not None: for interface in allowed_interface: allowed_attributes.extend(interface.names()) if attribute != '__call__': if template: raise ConfigurationError( "Attribute and template cannot be used together.") if not class_: raise ConfigurationError( "A class must be provided if attribute is used") if template: template = os.path.abspath(str(_context.path(template))) if not os.path.isfile(template): raise ConfigurationError("No such file", template) if class_: if attribute != '__call__': if not hasattr(class_, attribute): raise ConfigurationError( "The provided class doesn't have the specified attribute " ) cdict = getSecurityInfo(class_) cdict['__name__'] = name if template: new_class = makeClassForTemplate(template, bases=(class_, ), cdict=cdict, name=name) elif attribute != "__call__": # we're supposed to make a page for an attribute (read: # method) and it's not __call__. We thus need to create a # new class using our mixin for attributes. cdict.update({'__page_attribute__': attribute}) new_class = makeClass(class_.__name__, (class_, ViewMixinForAttributes), cdict) # in case the attribute does not provide a docstring, # ZPublisher refuses to publish it. So, as a workaround, # we provide a stub docstring func = getattr(new_class, attribute) if not func.__doc__: # cannot test for MethodType/UnboundMethod here # because of ExtensionClass if hasattr(func, 'im_func'): # you can only set a docstring on functions, not # on method objects func = func.im_func func.__doc__ = "Stub docstring to make ZPublisher work" else: # we could use the class verbatim here, but we'll execute # some security declarations on it so we really shouldn't # modify the original. So, instead we make a new class # with just one base class -- the original new_class = makeClass(class_.__name__, (class_, BrowserView), cdict) else: # template new_class = makeClassForTemplate(template, name=name) _handle_for(_context, for_) _context.action( discriminator = ('view', for_, name, IBrowserRequest, layer), callable = handler, args = ('registerAdapter', new_class, (for_, layer), Interface, name, _context.info), ) _context.action( discriminator = ('five:protectClass', new_class), callable = protectClass, args = (new_class, permission) ) if allowed_attributes: for attr in allowed_attributes: _context.action( discriminator = ('five:protectName', new_class, attr), callable = protectName, args = (new_class, attr, permission) ) _context.action( discriminator = ('five:initialize:class', new_class), callable = initializeClass, args = (new_class,) )
def __call__(self): (_context, name, for_, permission, layer, class_, allowed_interface, allowed_attributes) = self.args name = str(name) # De-unicode required = {} cdict = {} pages = {} for pname, attribute, template in self.pages: if template: cdict[pname] = ViewPageTemplateFile(template) if attribute and attribute != name: cdict[attribute] = cdict[pname] else: if not hasattr(class_, attribute): raise ConfigurationError("Undefined attribute", attribute) attribute = attribute or pname required[pname] = permission pages[pname] = attribute # This should go away, but noone seems to remember what to do. :-( if hasattr(class_, 'publishTraverse'): def publishTraverse(self, request, name, pages=pages, getattr=getattr): if name in pages: return getattr(self, pages[name]) view = component.queryMultiAdapter((self, request), name=name, default=None) if view is not None: return view m = class_.publishTraverse.__get__(self) return m(request, name) else: def publishTraverse(self, request, name, pages=pages, getattr=getattr): if name in pages: return getattr(self, pages[name]) view = component.queryMultiAdapter((self, request), name=name, default=None) if view is not None: return view raise NotFound(self, name, request) cdict['publishTraverse'] = publishTraverse if not hasattr(class_, 'browserDefault'): if self.default or self.pages: default = self.default or self.pages[0][0] cdict['browserDefault'] = ( lambda self, request, default=default: (self, (default, )) ) elif providesCallable(class_): cdict['browserDefault'] = ( lambda self, request: (self, ()) ) if class_ is not None: bases = (class_, ViewMixinForTemplates) else: bases = (ViewMixinForTemplates,) try: cname = str(name) except: cname = "GeneratedClass" cdict['__name__'] = name newclass = makeClass(cname, bases, cdict) _handle_for(_context, for_) if self.provides is not None: _context.action( discriminator = None, callable = provideInterface, args = ('', self.provides) ) _context.action( discriminator = ('view', for_, name, IBrowserRequest, layer, self.provides), callable = handler, args = ('registerAdapter', newclass, (for_, layer), self.provides, name, _context.info), ) # Security _context.action( discriminator = ('five:protectClass', newclass), callable = protectClass, args = (newclass, permission) ) if allowed_attributes: for attr in allowed_attributes: _context.action( discriminator = ('five:protectName', newclass, attr), callable = protectName, args = (newclass, attr, permission) ) # Make everything else private allowed = allowed_attributes or [] private_attrs = [name for name in dir(newclass) if (not name.startswith('_')) and (name not in allowed) and ismethod(getattr(newclass, name))] for attr in private_attrs: _context.action( discriminator = ('five:protectName', newclass, attr), callable = protectName, args = (newclass, attr, CheckerPrivateId, False) ) # Protect the class _context.action( discriminator = ('five:initialize:class', newclass), callable = InitializeClass, args = (newclass,) )
def __call__(self): (_context, name, for_, permission, layer, class_, allowed_interface, allowed_attributes) = self.args required = {} cdict = {} pages = {} for pname, attribute, template in self.pages: if template: cdict[pname] = ViewPageTemplateFile(template) if attribute and attribute != name: cdict[attribute] = cdict[pname] else: if not hasattr(class_, attribute): raise ConfigurationError("Undefined attribute", attribute) attribute = attribute or pname required[pname] = permission pages[pname] = attribute # This should go away, but noone seems to remember what to do. :-( if hasattr(class_, 'publishTraverse'): def publishTraverse(self, request, name, pages=pages, getattr=getattr): if name in pages: return getattr(self, pages[name]) view = component.queryMultiAdapter((self, request), name=name, default=None) if view is not None: return view.__of__(self) m = class_.publishTraverse.__get__(self).__of__(self) return m(request, name) else: def publishTraverse(self, request, name, pages=pages, getattr=getattr): if name in pages: return getattr(self, pages[name]) view = component.queryMultiAdapter((self, request), name=name, default=None) if view is not None: return view.__of__(self) raise NotFoundError(self, name, request) cdict['publishTraverse'] = publishTraverse if not hasattr(class_, 'browserDefault'): if self.default or self.pages: default = self.default or self.pages[0][0] cdict['browserDefault'] = ( lambda self, request, default=default: (self, (default, )) ) elif providesCallable(class_): cdict['browserDefault'] = ( lambda self, request: (self, ()) ) if class_ is not None: bases = (class_, ViewMixinForTemplates) else: bases = (ViewMixinForTemplates,) try: cname = str(name) except: cname = "GeneratedClass" newclass = makeClass(cname, bases, cdict) _handle_for(_context, for_) if self.provides is not None: _context.action( discriminator = None, callable = provideInterface, args = ('', self.provides) ) _context.action( discriminator = ('view', for_, name, IBrowserRequest, layer, self.provides), callable = handler, args = ('registerAdapter', newclass, (for_, layer), self.provides, name, _context.info), )
def page( _context, name, permission, for_, layer='default', template=None, class_=None, allowed_interface=None, allowed_attributes=None, attribute='__call__', menu=None, title=None, ): _handle_menu(_context, menu, title, [for_], name, permission) if not (class_ or template): raise ConfigurationError("Must specify a class or template") if allowed_attributes is None: allowed_attributes = [] if allowed_interface is not None: for interface in allowed_interface: attrs = [n for n, d in interface.namesAndDescriptions(1)] allowed_attributes.extend(attrs) if attribute != '__call__': if template: raise ConfigurationError( "Attribute and template cannot be used together.") if not class_: raise ConfigurationError( "A class must be provided if attribute is used") if template: template = os.path.abspath(str(_context.path(template))) if not os.path.isfile(template): raise ConfigurationError("No such file", template) if class_: if attribute != '__call__': if not hasattr(class_, attribute): raise ConfigurationError( "The provided class doesn't have the specified attribute ") cdict = getSecurityInfo(class_) if template: new_class = makeClassForTemplate(template, bases=(class_, ), cdict=cdict) elif attribute != "__call__": # we're supposed to make a page for an attribute (read: # method) and it's not __call__. We thus need to create a # new class using our mixin for attributes. cdict.update({'__page_attribute__': attribute}) new_class = makeClass(class_.__name__, (class_, ViewMixinForAttributes), cdict) # in case the attribute does not provide a docstring, # ZPublisher refuses to publish it. So, as a workaround, # we provide a stub docstring func = getattr(new_class, attribute) if not func.__doc__: # cannot test for MethodType/UnboundMethod here # because of ExtensionClass if hasattr(func, 'im_func'): # you can only set a docstring on functions, not # on method objects func = func.im_func func.__doc__ = "Stub docstring to make ZPublisher work" else: # we could use the class verbatim here, but we'll execute # some security declarations on it so we really shouldn't # modify the original. So, instead we make a new class # with just one base class -- the original new_class = makeClass(class_.__name__, (class_, BrowserView), cdict) else: # template new_class = makeClassForTemplate(template) _handle_for(_context, for_) _context.action( discriminator=('view', for_, name, IBrowserRequest, layer), callable=handler, args=(Presentation, 'provideAdapter', IBrowserRequest, new_class, name, [for_], Interface, layer, _context.info), ) _context.action(discriminator=('five:protectClass', new_class), callable=protectClass, args=(new_class, permission)) if allowed_attributes: for attr in allowed_attributes: _context.action(discriminator=('five:protectName', new_class, attr), callable=protectName, args=(new_class, attr, permission)) _context.action(discriminator=('five:initialize:class', new_class), callable=initializeClass, args=(new_class, ))
class view(zope_app_view): def __call__(self): (_context, name, for_, permission, layer, class_, allowed_interface, allowed_attributes) = self.args required = {} cdict = {} pages = {} for pname, attribute, template in self.pages: try: s = getGlobalService(Presentation) except ComponentLookupError, err: pass if template: cdict[pname] = ZopeTwoPageTemplateFile(template) if attribute and attribute != name: cdict[attribute] = cdict[pname] else: if not hasattr(class_, attribute): raise ConfigurationError("Undefined attribute", attribute) attribute = attribute or pname required[pname] = permission pages[pname] = attribute # This should go away, but noone seems to remember what to do. :-( if hasattr(class_, 'publishTraverse'): def publishTraverse(self, request, name, pages=pages, getattr=getattr): if name in pages: return getattr(self, pages[name]) view = zapi.queryView(self, name, request) if view is not None: return view m = class_.publishTraverse.__get__(self) return m(request, name) else: def publishTraverse(self, request, name, pages=pages, getattr=getattr): if name in pages: return getattr(self, pages[name]) view = zapi.queryView(self, name, request) if view is not None: return view raise NotFoundError(self, name, request) cdict['publishTraverse'] = publishTraverse if not hasattr(class_, 'browserDefault'): if self.default or self.pages: default = self.default or self.pages[0][0] cdict['browserDefault'] = ( lambda self, request, default=default: (self, (default, ))) elif providesCallable(class_): cdict['browserDefault'] = (lambda self, request: (self, ())) if class_ is not None: bases = (class_, ViewMixinForTemplates) else: bases = (ViewMixinForTemplates) try: cname = str(name) except: cname = "GeneratedClass" newclass = makeClass(cname, bases, cdict) _handle_for(_context, for_) if self.provides is not None: _context.action(discriminator=None, callable=provideInterface, args=('', self.provides)) _context.action( discriminator=('view', for_, name, IBrowserRequest, layer, self.provides), callable=handler, args=(Presentation, 'provideAdapter', IBrowserRequest, newclass, name, [for_], self.provides, layer, _context.info), )
def __call__(self): (_context, name, for_, permission, layer, class_, allowed_interface, allowed_attributes) = self.args name = str(name) # De-unicode required = {} cdict = {} pages = {} for pname, attribute, template in self.pages: if template: cdict[pname] = ViewPageTemplateFile(template) if attribute and attribute != name: cdict[attribute] = cdict[pname] else: if not hasattr(class_, attribute): raise ConfigurationError("Undefined attribute", attribute) attribute = attribute or pname required[pname] = permission pages[pname] = attribute # This should go away, but noone seems to remember what to do. :-( if hasattr(class_, 'publishTraverse'): def publishTraverse(self, request, name, pages=pages, getattr=getattr): if name in pages: return getattr(self, pages[name]) view = component.queryMultiAdapter((self, request), name=name, default=None) if view is not None: return view m = class_.publishTraverse.__get__(self) return m(request, name) else: def publishTraverse(self, request, name, pages=pages, getattr=getattr): if name in pages: return getattr(self, pages[name]) view = component.queryMultiAdapter((self, request), name=name, default=None) if view is not None: return view raise NotFound(self, name, request) cdict['publishTraverse'] = publishTraverse if not hasattr(class_, 'browserDefault'): if self.default or self.pages: default = self.default or self.pages[0][0] cdict['browserDefault'] = ( lambda self, request, default=default: (self, (default, ))) elif providesCallable(class_): cdict['browserDefault'] = (lambda self, request: (self, ())) if class_ is not None: bases = (class_, ViewMixinForTemplates) else: bases = (ViewMixinForTemplates, ) try: cname = str(name) except: cname = "GeneratedClass" cdict['__name__'] = name newclass = makeClass(cname, bases, cdict) _handle_for(_context, for_) if self.provides is not None: _context.action(discriminator=None, callable=provideInterface, args=('', self.provides)) _context.action( discriminator=('view', for_, name, IBrowserRequest, layer, self.provides), callable=handler, args=('registerAdapter', newclass, (for_, layer), self.provides, name, _context.info), ) # Security _context.action(discriminator=('five:protectClass', newclass), callable=protectClass, args=(newclass, permission)) if allowed_attributes: for attr in allowed_attributes: _context.action(discriminator=('five:protectName', newclass, attr), callable=protectName, args=(newclass, attr, permission)) # Make everything else private allowed = allowed_attributes or [] private_attrs = [ name for name in dir(newclass) if (not name.startswith('_')) and ( name not in allowed) and ismethod(getattr(newclass, name)) ] for attr in private_attrs: _context.action(discriminator=('five:protectName', newclass, attr), callable=protectName, args=(newclass, attr, CheckerPrivateId, False)) # Protect the class _context.action(discriminator=('five:initialize:class', newclass), callable=InitializeClass, args=(newclass, ))
if attribute != '__call__': if not hasattr(class_, attribute): raise ConfigurationError( "The provided class doesn't have the specified attribute " ) cdict = getSecurityInfo(class_) if template: new_class = makeClassForTemplate(template, bases=(class_, ), cdict=cdict) elif attribute != "__call__": # we're supposed to make a page for an attribute (read: # method) and it's not __call__. We thus need to create a # new class using our mixin for attributes. cdict.update({'__page_attribute__': attribute}) new_class = makeClass(class_.__name__, (class_, ViewMixinForAttributes), cdict) # in case the attribute does not provide a docstring, # ZPublisher refuses to publish it. So, as a workaround, # we provide a stub docstring func = getattr(new_class, attribute) if not func.__doc__: # cannot test for MethodType/UnboundMethod here # because of ExtensionClass if hasattr(func, 'im_func'): # you can only set a docstring on functions, not # on method objects func = func.im_func func.__doc__ = "Stub docstring to make ZPublisher work" else:
return if attribute != '__call__': if not hasattr(class_, attribute): raise ConfigurationError( "The provided class doesn't have the specified attribute ") cdict = getSecurityInfo(class_) if template: new_class = makeClassForTemplate(template, bases=(class_, ), cdict=cdict) elif attribute != "__call__": # we're supposed to make a page for an attribute (read: # method) and it's not __call__. We thus need to create a # new class using our mixin for attributes. cdict.update({'__page_attribute__': attribute}) new_class = makeClass(class_.__name__, (class_, ViewMixinForAttributes), cdict) # in case the attribute does not provide a docstring, # ZPublisher refuses to publish it. So, as a workaround, # we provide a stub docstring func = getattr(new_class, attribute) if not func.__doc__: # cannot test for MethodType/UnboundMethod here # because of ExtensionClass if hasattr(func, 'im_func'): # you can only set a docstring on functions, not # on method objects func = func.im_func func.__doc__ = "Stub docstring to make ZPublisher work" else: # we could use the class verbatim here, but we'll execute