def register_view_impl(cfg, factory, name, context, template, route_name, layout, permission): chain = [] # permission if permission != NO_PERMISSION_REQUIRED and permission is not None: chain.append(PermissionRenderer(permission, factory)) # view if template is None: render = ViewRenderer(viewMapper(factory, 'render')) else: render = TemplateRenderer(viewMapper(factory, 'update'), template) factory.__view_renderer__ = render chain.append(render) # layout if layout is unset: layout = None try: if issubclass(factory, View): layout = '' except: pass if layout is not None: chain.append(LayoutRenderer(layout)) # register view if isexception(context): view_classifier = IExceptionViewClassifier else: view_classifier = IViewClassifier sm = cfg.registry request_iface = IRequest if route_name is not None: request_iface = sm.getUtility(IRouteRequest, name=route_name) pview = PyramidView(chain) factory.__renderer__ = pview pview.__config_action__ = cfg.action sm.registerAdapter( pview, (view_classifier, request_iface, context or interface.Interface), IView, name)
def register_view_impl(config, factory, name, context, template, route_name, layout, permission): if layout is unset: layout = None try: if issubclass(factory, View): layout = '' except: pass if template is not None: renderer = Renderer(template, layout=layout).bind( viewMapper(factory, 'update')) else: renderer = SimpleRenderer(layout=layout).bind( viewMapper(factory, 'render')) factory.__renderer__ = renderer # add 'subpath' support if inspect.isclass(factory): subpath_traverse = getattr(factory, '__subpath_traverse__', None) if subpath_traverse is not None: renderer = subpathWrapper( viewInstanceMapper(factory), renderer, subpath_traverse) # build pyramid view if permission == '__no_permission_required__': permission = None sm = config.registry if callable(permission): def pyramidview(context, request): if permission(context, request): return renderer(context, request) msg = getattr(request, 'authdebug_message', 'Unauthorized: %s failed permission check'%factory) raise HTTPForbidden(msg) elif permission: def pyramidview(context, request): if checkPermission(permission, context, request): return renderer(context, request) msg = getattr(request, 'authdebug_message', 'Unauthorized: %s failed permission check'%factory) raise HTTPForbidden(msg) else: pyramidview = renderer # register view if context is None: context = interface.Interface if isexception(context): view_classifier = IExceptionViewClassifier else: view_classifier = IViewClassifier sm = config.registry request_iface = IRequest if route_name is not None: request_iface = sm.getUtility(IRouteRequest, name=route_name) sm.registerAdapter( pyramidview, (view_classifier, request_iface, context), IView, name)
def register(permission=permission, renderer=renderer): # the discrim_func above is guaranteed to have been called already order = view_intr['order'] preds = view_intr['predicates'] phash = view_intr['phash'] request_iface = IRequest if route_name is not None: request_iface = self.registry.queryUtility(IRouteRequest, name=route_name) if request_iface is None: # route configuration should have already happened in # phase 2 raise ConfigurationError( 'No route named %s found for view registration' % route_name) if renderer is None: # use default renderer if one exists (reg'd in phase 1) if self.registry.queryUtility(IRendererFactory) is not None: renderer = renderers.RendererHelper( name=None, package=self.package, registry=self.registry ) if permission is None: # intent: will be None if no default permission is registered # (reg'd in phase 1) permission = self.registry.queryUtility(IDefaultPermission) # added by discrim_func above during conflict resolving preds = view_intr['predicates'] order = view_intr['order'] phash = view_intr['phash'] # __no_permission_required__ handled by _secure_view deriver = ViewDeriver( registry=self.registry, permission=permission, predicates=preds, attr=attr, renderer=renderer, wrapper_viewname=wrapper, viewname=name, accept=accept, order=order, phash=phash, package=self.package, mapper=mapper, decorator=decorator, http_cache=http_cache, ) derived_view = deriver(view) derived_view.__discriminator__ = lambda *arg: discriminator # __discriminator__ is used by superdynamic systems # that require it for introspection after manual view lookup; # see also MultiView.__discriminator__ view_intr['derived_callable'] = derived_view registered = self.registry.adapters.registered # A multiviews is a set of views which are registered for # exactly the same context type/request type/name triad. Each # consituent view in a multiview differs only by the # predicates which it possesses. # To find a previously registered view for a context # type/request type/name triad, we need to use the # ``registered`` method of the adapter registry rather than # ``lookup``. ``registered`` ignores interface inheritance # for the required and provided arguments, returning only a # view registered previously with the *exact* triad we pass # in. # We need to do this three times, because we use three # different interfaces as the ``provided`` interface while # doing registrations, and ``registered`` performs exact # matches on all the arguments it receives. old_view = None for view_type in (IView, ISecuredView, IMultiView): old_view = registered((IViewClassifier, request_iface, r_context), view_type, name) if old_view is not None: break isexc = isexception(context) def regclosure(): if hasattr(derived_view, '__call_permissive__'): view_iface = ISecuredView else: view_iface = IView self.registry.registerAdapter( derived_view, (IViewClassifier, request_iface, context), view_iface, name ) if isexc: self.registry.registerAdapter( derived_view, (IExceptionViewClassifier, request_iface, context), view_iface, name) is_multiview = IMultiView.providedBy(old_view) old_phash = getattr(old_view, '__phash__', DEFAULT_PHASH) if old_view is None: # - No component was yet registered for any of our I*View # interfaces exactly; this is the first view for this # triad. regclosure() elif (not is_multiview) and (old_phash == phash): # - A single view component was previously registered with # the same predicate hash as this view; this registration # is therefore an override. regclosure() else: # - A view or multiview was already registered for this # triad, and the new view is not an override. # XXX we could try to be more efficient here and register # a non-secured view for a multiview if none of the # multiview's consituent views have a permission # associated with them, but this code is getting pretty # rough already if is_multiview: multiview = old_view else: multiview = MultiView(name) old_accept = getattr(old_view, '__accept__', None) old_order = getattr(old_view, '__order__', MAX_ORDER) multiview.add(old_view, old_order, old_accept, old_phash) multiview.add(derived_view, order, accept, phash) for view_type in (IView, ISecuredView): # unregister any existing views self.registry.adapters.unregister( (IViewClassifier, request_iface, r_context), view_type, name=name) if isexc: self.registry.adapters.unregister( (IExceptionViewClassifier, request_iface, r_context), view_type, name=name) self.registry.registerAdapter( multiview, (IViewClassifier, request_iface, context), IMultiView, name=name) if isexc: self.registry.registerAdapter( multiview, (IExceptionViewClassifier, request_iface, context), IMultiView, name=name) renderer_type = getattr(renderer, 'type', None) # gard against None intrspc = self.introspector if ( renderer_type is not None and tmpl_intr is not None and intrspc is not None and intrspc.get('renderer factories', renderer_type) is not None ): # allow failure of registered template factories to be deferred # until view execution, like other bad renderer factories; if # we tried to relate this to an existing renderer factory # without checking if it the factory actually existed, we'd end # up with a KeyError at startup time, which is inconsistent # with how other bad renderer registrations behave (they throw # a ValueError at view execution time) tmpl_intr.relate('renderer factories', renderer.type)
def register(permission=permission, renderer=renderer): # the discrim_func above is guaranteed to have been called already order = view_intr['order'] preds = view_intr['predicates'] phash = view_intr['phash'] request_iface = IRequest if route_name is not None: request_iface = self.registry.queryUtility(IRouteRequest, name=route_name) if request_iface is None: # route configuration should have already happened in # phase 2 raise ConfigurationError( 'No route named %s found for view registration' % route_name) if renderer is None: # use default renderer if one exists (reg'd in phase 1) if self.registry.queryUtility(IRendererFactory) is not None: renderer = renderers.RendererHelper(name=None, package=self.package, registry=self.registry) if permission is None: # intent: will be None if no default permission is registered # (reg'd in phase 1) permission = self.registry.queryUtility(IDefaultPermission) # added by discrim_func above during conflict resolving preds = view_intr['predicates'] order = view_intr['order'] phash = view_intr['phash'] # __no_permission_required__ handled by _secure_view deriver = ViewDeriver( registry=self.registry, permission=permission, predicates=preds, attr=attr, renderer=renderer, wrapper_viewname=wrapper, viewname=name, accept=accept, order=order, phash=phash, package=self.package, mapper=mapper, decorator=decorator, http_cache=http_cache, ) derived_view = deriver(view) derived_view.__discriminator__ = lambda *arg: discriminator # __discriminator__ is used by superdynamic systems # that require it for introspection after manual view lookup; # see also MultiView.__discriminator__ view_intr['derived_callable'] = derived_view registered = self.registry.adapters.registered # A multiviews is a set of views which are registered for # exactly the same context type/request type/name triad. Each # consituent view in a multiview differs only by the # predicates which it possesses. # To find a previously registered view for a context # type/request type/name triad, we need to use the # ``registered`` method of the adapter registry rather than # ``lookup``. ``registered`` ignores interface inheritance # for the required and provided arguments, returning only a # view registered previously with the *exact* triad we pass # in. # We need to do this three times, because we use three # different interfaces as the ``provided`` interface while # doing registrations, and ``registered`` performs exact # matches on all the arguments it receives. old_view = None for view_type in (IView, ISecuredView, IMultiView): old_view = registered((IViewClassifier, request_iface, r_context), view_type, name) if old_view is not None: break isexc = isexception(context) def regclosure(): if hasattr(derived_view, '__call_permissive__'): view_iface = ISecuredView else: view_iface = IView self.registry.registerAdapter( derived_view, (IViewClassifier, request_iface, context), view_iface, name) if isexc: self.registry.registerAdapter( derived_view, (IExceptionViewClassifier, request_iface, context), view_iface, name) is_multiview = IMultiView.providedBy(old_view) old_phash = getattr(old_view, '__phash__', DEFAULT_PHASH) if old_view is None: # - No component was yet registered for any of our I*View # interfaces exactly; this is the first view for this # triad. regclosure() elif (not is_multiview) and (old_phash == phash): # - A single view component was previously registered with # the same predicate hash as this view; this registration # is therefore an override. regclosure() else: # - A view or multiview was already registered for this # triad, and the new view is not an override. # XXX we could try to be more efficient here and register # a non-secured view for a multiview if none of the # multiview's consituent views have a permission # associated with them, but this code is getting pretty # rough already if is_multiview: multiview = old_view else: multiview = MultiView(name) old_accept = getattr(old_view, '__accept__', None) old_order = getattr(old_view, '__order__', MAX_ORDER) multiview.add(old_view, old_order, old_accept, old_phash) multiview.add(derived_view, order, accept, phash) for view_type in (IView, ISecuredView): # unregister any existing views self.registry.adapters.unregister( (IViewClassifier, request_iface, r_context), view_type, name=name) if isexc: self.registry.adapters.unregister( (IExceptionViewClassifier, request_iface, r_context), view_type, name=name) self.registry.registerAdapter( multiview, (IViewClassifier, request_iface, context), IMultiView, name=name) if isexc: self.registry.registerAdapter( multiview, (IExceptionViewClassifier, request_iface, context), IMultiView, name=name) renderer_type = getattr(renderer, 'type', None) # gard against None intrspc = self.introspector if (renderer_type is not None and tmpl_intr is not None and intrspc is not None and intrspc.get( 'renderer factories', renderer_type) is not None): # allow failure of registered template factories to be deferred # until view execution, like other bad renderer factories; if # we tried to relate this to an existing renderer factory # without checking if it the factory actually existed, we'd end # up with a KeyError at startup time, which is inconsistent # with how other bad renderer registrations behave (they throw # a ValueError at view execution time) tmpl_intr.relate('renderer factories', renderer.type)