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
