def __init__(self, *args, **kw): super(RoutedController, self).__init__(*args, **kw) routes = [] for name in dir(self): value = getattr(self.__class__, name, None) if value is None: continue deco = None if inspect.ismethod(value): # pragma: no cover # PY2 deco = Decoration.get_decoration(value.__func__) elif inspect.isfunction(value): # pragma: no cover # PY3 deco = Decoration.get_decoration(value) if deco is None: continue if hasattr(deco, '_tgext_routes'): routes.extend(deco._tgext_routes) if routes: instance_mapper = Mapper() if self.mapper is not None: instance_mapper.extend(self.mapper.matchlist) instance_mapper.extend(routes) self.mapper = instance_mapper
def test_backward_compatibility_decorator(self): deco = Decoration.get_decoration(BasicTGController.two_validators) validated_params = sorted(list(deco.validation.validators.keys())) assert validated_params == ["a", "someemail"], validated_params deco = Decoration.get_decoration(BasicTGController.tw2form_error_handler) assert deco.validation is None, deco.validation
def __call__(self): log.debug("Registering %s for hook %s on controller %s", self.func, self.hook_name, self.controller) if self.hook_name == 'controller_wrapper': deco = Decoration.get_decoration(self.controller) deco._register_controller_wrapper(self.func) else: deco = Decoration.get_decoration(self.controller) deco._register_hook(self.hook_name, self.func)
def test_lazy_inheritance_with_3nested_template(self): milestones.renderers_ready._reset() class BaseController(tg.TGController): @tg.expose('template.html') @tg.expose('template.html', content_type='text/plain') @tg.expose('template.html', content_type='text/javascript') def func(self): pass class SubController(BaseController): @tg.expose('new_template.html', inherit=True) @tg.expose('new_template.html', content_type='text/plain') @tg.expose('new_template.html', content_type='text/javascript') def func(self): pass class SubSubController(SubController): @tg.expose('new2_template.html', inherit=True) @tg.expose('new2_template.html', content_type='text/javascript') def func(self): pass class SubSubSubController(SubSubController): @tg.expose('new3_template.html', inherit=True) def func(self): pass milestones.renderers_ready.reach() deco = Decoration.get_decoration(SubSubSubController.func) assert len(deco.engines) == 3, deco.engines assert deco.engines['text/html'][1] == 'new3_template.html', deco.engines assert deco.engines['text/plain'][1] == 'new_template.html', deco.engines assert deco.engines['text/javascript'][1] == 'new2_template.html', deco.engines
def test_no_requirements_backward_compatibility(self): deco = Decoration.get_decoration(RootController.force_commit) reqs = deco.requirements deco.requirements = [] requirement = deco.requirement deco.requirements = reqs assert requirement is None, requirement
def __call__(self, path, **params): config = tg.config._current_obj() try: func = config['_pluggable_partials_cache'][path] except: func = config['_pluggable_partials_cache'][path] = self.resolve(path) result = func(**params) if not isinstance(result, dict): return result #Expect partials not to expose more than one template available_engines = list(Decoration.get_decoration(func).engines.values()) engine_name, template_name, exclude_names = available_engines[0][:3] replaced_template = config.get('_pluggable_templates_replacements', {}).get(template_name) if replaced_template: engine_name, template_name = replaced_template.split(':', 1) #Avoid placing the doctype declaration in genshi templates render_params = {} if engine_name == 'genshi': render_params['doctype'] = None return tg_render(template_vars=result, template_engine=engine_name, template_name=template_name, **render_params)
def replace_template_hook(remainder, params, output): req = request._current_obj() try: dispatch_state = req._controller_state except: dispatch_state = req.controller_state try: if req.validation['exception']: controller = req.validation['error_handler'] else: controller = dispatch_state.method except (AttributeError, KeyError): controller = dispatch_state.method decoration = Decoration.get_decoration(controller) if 'tg.locals' in req.environ: content_type, engine, template, exclude_names = decoration.lookup_template_engine(req.environ['tg.locals'])[:4] else: content_type, engine, template, exclude_names = decoration.lookup_template_engine(req)[:4] replaced_template = config._pluggable_templates_replacements.get(template) if replaced_template: override_template(decoration.controller, replaced_template)
def replace_template_hook(remainder, params, output): req = request._current_obj() try: dispatch_state = req._controller_state except: dispatch_state = req.controller_state try: if req.validation['exception']: controller = req.validation['error_handler'] else: controller = dispatch_state.method except (AttributeError, KeyError): controller = dispatch_state.method decoration = Decoration.get_decoration(controller) if 'tg.locals' in req.environ: content_type, engine, template, exclude_names = decoration.lookup_template_engine( req.environ['tg.locals'])[:4] else: content_type, engine, template, exclude_names = decoration.lookup_template_engine( req)[:4] replaced_template = config._pluggable_templates_replacements.get(template) if replaced_template: override_template(decoration.controller, replaced_template)
def test_lazy_inheritance_with_nested_template(self): milestones.renderers_ready._reset() class BaseController(tg.TGController): @tg.expose('template.html') @tg.expose('template.html', content_type='text/plain') def func(self): pass class SubController(BaseController): @tg.expose('new_template.html', inherit=True) @tg.expose('new_template.html', content_type='text/plain') def func(self): pass class SubSubController(SubController): @tg.expose('new2_template.html', inherit=True) def func(self): pass milestones.renderers_ready.reach() deco = Decoration.get_decoration(SubSubController.func) assert len(deco.engines) == 2, deco.engines assert deco.engines['text/html'][ 1] == 'new2_template.html', deco.engines assert deco.engines['text/plain'][ 1] == 'new_template.html', deco.engines
def plugin(f, *args, **kw): results_dict = f(*args, **kw) user = args[0].user residence_var = "residence" plugins_templates = list() # un plugin est defini pour le scope et residence est defini if scope in plugins_config.mappings and residence_var in results_dict: residence_dn = Residences.get_dn_by_name(user, results_dict[residence_var]) scope_mappings = plugins_config.mappings[scope] for function in scope_mappings: plugin_name = plugin_name_from_function(function) plugin_activated = Plugins.get_by_name(user, residence_dn, plugin_name) if plugin_activated is None: continue #end if template_name = None # obtenir le nom du template à partir du decorator "expose" deco = Decoration.get_decoration(function) try: template_name = deco.engines["text/html"][1] except: pass if template_name is not None: # transformer le nom de template en chemin fichier template_path = ( tg.config['pylons.app_globals'] .dotted_filename_finder .get_dotted_filename(template_name, template_extension='.html') ) # ajouter dans les plugin templates plugins_templates.append(template_path) #end if # executer la fonction du plugin mapping_results = function(results_dict) # constuire le nom de regroupement des variable de ce plugin method_name = function.__name__ plugin_section = str.lower(plugin_name + "_" + method_name) # ajout du groupe au dictionnaire de la methode du controlleur results_dict[plugin_section] = PluginVars(mapping_results) #end for #end if # ajout des templates dans un champs spécial du dictionnaire pour le rendu results_dict["_plugins_templates"] = plugins_templates return results_dict
def notify(self, hook_name, args=None, kwargs=None, controller=None, context_config=None): """Notifies a TurboGears hook. Each function registered for the given hook will be executed, ``args`` and ``kwargs`` will be passed to the registered functions as arguments. It permits to notify both application hooks:: tg.hooks.notify('custom_global_hook') Or controller hooks:: tg.hooks.notify('before_render', args=(remainder, params, output), controller=RootController.index) """ if context_config is None: #pragma: no cover context_config = tg.config._current_obj() args = args or [] kwargs = kwargs or {} try: syswide_hooks = context_config['hooks'][hook_name] for func in syswide_hooks: func(*args, **kwargs) except KeyError: #pragma: no cover pass if controller is not None: controller = default_im_func(controller) deco = Decoration.get_decoration(controller) for func in deco.hooks.get(hook_name, []): func(*args, **kwargs)
def notify_with_value(self, hook_name, value, controller=None, context_config=None): """Notifies a TurboGears hook which is expected to return a value. hooks with values are expected to accept an input value an return a replacement for it. Each registered function will receive as input the value returned by the previous function in chain. The resulting value will be returned by the ``notify_with_value`` call itself:: app = tg.hooks.notify_with_value('before_config', app) """ if context_config is None: #pragma: no cover context_config = tg.config._current_obj() try: syswide_hooks = context_config['hooks'][hook_name] for func in syswide_hooks: value = func(value) except KeyError: #pragma: no cover pass if controller is not None: controller = default_im_func(controller) deco = Decoration.get_decoration(controller) for func in deco.hooks[hook_name]: value = func(value) return value
def __call__(self, path, **params): config = tg.config._current_obj() try: func = config['_pluggable_partials_cache'][path] except: func = config['_pluggable_partials_cache'][path] = self.resolve( path) result = func(**params) if not isinstance(result, dict): return result #Expect partials not to expose more than one template available_engines = list( Decoration.get_decoration(func).engines.values()) engine_name, template_name, exclude_names = available_engines[0][:3] replaced_template = config.get('_pluggable_templates_replacements', {}).get(template_name) if replaced_template: engine_name, template_name = replaced_template.split(':', 1) # Avoid placing the doctype declaration in Genshi and Kajiki templates render_params = {} if engine_name == 'genshi': render_params['doctype'] = None if engine_name == 'kajiki': render_params['is_fragment'] = True return tg_render(template_vars=result, template_engine=engine_name, template_name=template_name, **render_params)
def notify_with_value(self, hook_name, value, controller=None, context_config=None): """Notifies a TurboGears hook which is expected to return a value. hooks with values are expected to accept an input value an return a replacement for it. Each registered function will receive as input the value returned by the previous function in chain. The resulting value will be returned by the ``notify_with_value`` call itself:: app = tg.hooks.notify_with_value('before_config', app) """ if context_config is None: # pragma: no cover context_config = tg.config._current_obj() try: syswide_hooks = context_config['hooks'][hook_name] except KeyError: # pragma: no cover pass else: for func in syswide_hooks: value = func(value) if controller is not None: controller = default_im_func(controller) deco = Decoration.get_decoration(controller) for func in deco.hooks[hook_name]: value = func(value) return value
def __call__(self, func): deco = decorator(self.wrap, func) exposed = Decoration.get_decoration(deco) deco.signatures = self.signatures deco.helpstr = self.helpstr exposed.register_template_engine(\ 'text/xml', config.get('default_renderer', ['mako'])[0], '', [], {}) return deco
def __call__(self, func): deco = Decoration.get_decoration(func) if not hasattr(deco, '_tgext_routes'): deco._tgext_routes = [] deco._tgext_routes.append(Route(func.__name__, self.routing_path, controller=route.CURRENT_CONTROLLER, action=func.__name__, **self.routing_args)) return func
def __call__(self): log.debug("Registering %s for hook %s on controller %s", self.func, self.hook_name, self.controller) if self.hook_name == 'controller_wrapper': config = tg.config._current_obj() dedicated_wrappers = config['dedicated_controller_wrappers'] dedicated_wrappers.setdefault(self.controller, []).append(self.func) else: deco = Decoration.get_decoration(self.controller) deco._register_hook(self.hook_name, self.func)
def render_widget(mount_point, widget_name): app = c.project.app_instance(mount_point) method = getattr(app.widget(app), widget_name) with push_config(c, app=app): result = method() if isinstance(result, dict): deco = Decoration.get_decoration(method) content_type, engine, template, exclude_names = \ deco.lookup_template_engine(request) template_vars = dict((k,v) for k,v in result.iteritems() if k not in exclude_names) return render(template_vars, engine, template) return result
def test_decoration_run_hooks_backward_compatibility(self): # TODO: Remove test when Decoration.run_hooks gets removed def func(*args, **kw): pass def hook(*args, **kw): hook.did_run = True hook.did_run = False milestones.renderers_ready.reach() tg.hooks.register('before_call', hook, controller=func) deco = Decoration.get_decoration(func) deco.run_hooks(Bunch(config=None), 'before_call') assert hook.did_run is True
def replace_template_hook(remainder, params, output): req = request._current_obj() try: dispatch_state = req._controller_state except: dispatch_state = req.controller_state decoration = Decoration.get_decoration(dispatch_state.method) if 'tg.locals' in req.environ: content_type, engine, template, exclude_names = decoration.lookup_template_engine(req.environ['tg.locals'])[:4] else: content_type, engine, template, exclude_names = decoration.lookup_template_engine(req)[:4] replaced_template = config._pluggable_templates_replacements.get(template) if replaced_template: override_template(dispatch_state.method, replaced_template)
def test_lazy_inheritance(self): milestones.renderers_ready._reset() class BaseController(tg.TGController): @tg.expose('template.html') def func(self): pass class SubController(BaseController): @tg.expose(inherit=True) def func(self): pass milestones.renderers_ready.reach() deco = Decoration.get_decoration(SubController.func) assert len(deco.engines) == 1, deco.engines assert deco.engines['text/html'][1] == 'template.html', deco.engines
def __call__(self, path, **params): config = tg.config._current_obj() try: func = config['_pluggable_partials_cache'][path] except: func = config['_pluggable_partials_cache'][path] = self.resolve(path) result = func(**params) if not isinstance(result, dict): return result #Expect partials not to expose more than one template engine_name, template_name, exclude_names = Decoration.get_decoration(func).engines.values()[0][:3] replaced_template = config.get('_pluggable_templates_replacements', {}).get(template_name) if replaced_template: engine_name, template_name = replaced_template.split(':', 1) return tg_render(template_vars=result, template_engine=engine_name, template_name=template_name, doctype=None)
def add_expose_info(app, what, name, obj, options, lines): if (what != 'method' or not hasattr(obj, 'decoration') or not obj.im_class.__name__.endswith('Controller')): return deco = Decoration.get_decoration(obj) if not hasattr(deco, 'expose'): return try: # TODO: This ignores all but the first tmpl engine engine = deco.engines.values()[0] if engine[0] == 'genshi': template = engine[1] lines.append("\n") lines.append("\n") lines.append("Renders: :data:`%s`" % template) except: pass
def replace_template_hook(remainder, params, output): req = request._current_obj() try: dispatch_state = req._controller_state except: dispatch_state = req.controller_state decoration = Decoration.get_decoration(dispatch_state.method) if 'tg.locals' in req.environ: content_type, engine, template, exclude_names = decoration.lookup_template_engine( req.environ['tg.locals'])[:4] else: content_type, engine, template, exclude_names = decoration.lookup_template_engine( req)[:4] replaced_template = config._pluggable_templates_replacements.get(template) if replaced_template: override_template(dispatch_state.method, replaced_template)
def notify(self, hook_name, args=None, kwargs=None, controller=None, context_config=None): """Notifies a TurboGears hook. Each function registered for the given hook will be executed, ``args`` and ``kwargs`` will be passed to the registered functions as arguments. It permits to notify both application hooks:: tg.hooks.notify('custom_global_hook') Or controller hooks:: tg.hooks.notify('before_render', args=(remainder, params, output), controller=RootController.index) """ if context_config is None: #pragma: no cover context_config = tg.config._current_obj() args = args or [] kwargs = kwargs or {} try: syswide_hooks = context_config['hooks'][hook_name] except KeyError: # pragma: no cover pass else: for func in syswide_hooks: func(*args, **kwargs) if controller is not None: controller = default_im_func(controller) deco = Decoration.get_decoration(controller) for func in deco.hooks.get(hook_name, []): func(*args, **kwargs)
def register_controller_wrapper(self, wrapper, controller=None): """Registers a TurboGears controller wrapper. Controller Wrappers are much like a **decorator** applied to every controller. They receive the next handler in chain and are expected to return a new handler that performs whatever it requires and then calls the next handler. A simple example for a controller wrapper is a simple logging wrapper:: def controller_wrapper(caller): def call(*args, **kw): try: print 'Before handler!' return caller(*args, **kw) finally: print 'After Handler!' return call dispatch_component.register_controller_wrapper(controller_wrapper) It is also possible to register wrappers for a specific controller:: dispatch_component.register_controller_wrapper(controller_wrapper, controller=RootController.index) """ if milestones.environment_loaded.reached: log.warning( 'Controller Wrapper %s registered after environment loaded ' 'milestone has been reached, the wrapper will be used only ' 'for future TGApp instances.', wrapper) log.debug("Registering %s controller wrapper for controller: %s", wrapper, controller or 'ALL') if controller is None: self._controller_wrappers.append(wrapper) else: from tg.decorators import Decoration deco = Decoration.get_decoration(controller) deco._register_controller_wrapper(wrapper)
def test_expose_idempotent(self): base_config = TestConfig(folder = 'dispatch', values = {'use_sqlalchemy': False, 'use_toscawidgets': False, 'use_toscawidgets2': False, 'ignore_parameters': ["ignore", "ignore_me"] }) app = app_from_config(base_config) exposition = tg.expose('nonexisting') @exposition @exposition def func(*args, **kw): pass milestones.renderers_ready.reach() deco = Decoration.get_decoration(func) assert len(deco.engines) == 1, deco.engines
def register_controller_wrapper(self, wrapper, controller=None): """Registers a TurboGears controller wrapper. Controller Wrappers are much like a **decorator** applied to every controller. They receive the next handler in chain and are expected to return a new handler that performs whatever it requires and then calls the next handler. A simple example for a controller wrapper is a simple logging wrapper:: def controller_wrapper(caller): def call(*args, **kw): try: print 'Before handler!' return caller(*args, **kw) finally: print 'After Handler!' return call base_config.register_controller_wrapper(controller_wrapper) It is also possible to register wrappers for a specific controller:: base_config.register_controller_wrapper(controller_wrapper, controller=RootController.index) """ if milestones.environment_loaded.reached: log.warning('Controller Wrapper %s registered after environment loaded ' 'milestone has been reached, the wrapper will be used only ' 'for future TGApp instances.', wrapper) log.debug("Registering %s controller wrapper for controller: %s", wrapper, controller or 'ALL') if controller is None: self._controller_wrappers.append(wrapper) else: from tg.decorators import Decoration deco = Decoration.get_decoration(controller) deco._register_controller_wrapper(wrapper)
def test_expose_idempotent(self): base_config = TestConfig(folder='dispatch', values={ 'use_sqlalchemy': False, 'use_toscawidgets': False, 'use_toscawidgets2': False, 'ignore_parameters': ["ignore", "ignore_me"] }) app = app_from_config(base_config) exposition = tg.expose('nonexisting') @exposition @exposition def func(*args, **kw): pass milestones.renderers_ready.reach() deco = Decoration.get_decoration(func) assert len(deco.engines) == 1, deco.engines
def __call__(self, func): self.func = func deco = Decoration.get_decoration(func) deco.register_hook('before_render', self.hook_func) return func
def test_multiple_requirements_all_registered(self): deco = Decoration.get_decoration(RootController.force_commit) assert len(deco.requirements) == 2, deco.requirements
class BasicTGController(TGController): @expose() @validate(ColonLessGenericValidator()) def validator_without_columns(self, **kw): return tg.request.validation['errors']['_the_form'] @expose('json:') @validate(validators={"some_int": validators.Int()}) def validated_int(self, some_int): assert isinstance(some_int, int) return dict(response=some_int) @expose('json:') @validate(validators={"a": validators.Int()}) def validated_and_unvalidated(self, a, b): assert isinstance(a, int) assert isinstance(b, unicode_text) return dict(int=a, str=b) @expose() @controller_based_validate() def validate_controller_based_validator(self, *args, **kw): return 'ok' @expose('json:') @validate(validators={ "a": validators.Int(), "someemail": validators.Email() }) def two_validators(self, a=None, someemail=None, *args): errors = tg.request.validation['errors'] values = tg.request.validation['values'] return dict(a=a, someemail=someemail, errors=str(errors), values=str(values)) @expose('json:') @validate(validators={"a": validators.Int()}) def with_default_shadow(self, a, b=None): """A default value should not cause the validated value to disappear""" assert isinstance(a, int), type(a) return { 'int': a, } @expose('json:') @validate(validators={"e": ColonValidator()}) def error_with_colon(self, e): errors = tg.request.validation['errors'] return dict(errors=str(errors)) @expose('json:') @validate( validators={ "a": validators.Int(), "b": validators.Int(), "c": validators.Int(), "d": validators.Int() }) def with_default_shadow_long(self, a, b=None, c=None, d=None): """A default value should not cause the validated value to disappear""" assert isinstance(a, int), type(a) assert isinstance(b, int), type(b) assert isinstance(c, int), type(c) assert isinstance(d, int), type(d) return { 'int': [a, b, c, d], } @expose() def display_form(self, **kwargs): return str(myform.render(values=kwargs)) @expose('json:') @validate(form=myform) def process_form(self, **kwargs): kwargs['errors'] = tg.request.validation['errors'] return dict(kwargs) @expose('json:') @validate(form=myform, error_handler=process_form) def send_to_error_handler(self, **kwargs): kwargs['errors'] = tg.request.validation['errors'] return dict(kwargs) @expose('json') def tw2form_error_handler(self, **kwargs): return dict(errors=tg.request.validation['errors']) @expose('json:') @validate(form=movie_form, error_handler=tw2form_error_handler) def send_tw2_to_error_handler(self, **kwargs): return 'passed validation' @expose() @validate({'param': tw2c.IntValidator()}, error_handler=validation_errors_response) def tw2_dict_validation(self, **kwargs): return 'NO_ERROR' @expose() @validate({'param': validators.Int()}, error_handler=validation_errors_response) def formencode_dict_validation(self, **kwargs): return 'NO_ERROR' @expose('text/plain') @validate(form=FormWithFieldSet, error_handler=tw2form_error_handler) def tw2_fieldset_submit(self, **kwargs): return 'passed validation' @expose() def set_lang(self, lang=None): tg.session['tg_lang'] = lang tg.session.save() return 'ok' @expose() @validate(validators=Pwd()) def password(self, pwd1, pwd2): if tg.request.validation['errors']: return "There was an error" else: return "Password ok!" @expose('json:') @before_render( lambda rem, params, output: output.update({'GOT_ERROR': 'HOOKED'})) def hooked_error_handler(self, *args, **kw): return dict(GOT_ERROR='MISSED HOOK') @expose() @validate({'v': validators.Int()}, error_handler=hooked_error_handler) def with_hooked_error_handler(self, *args, **kw): return dict(GOT_ERROR='NO ERROR') @expose('json') @validate({'v': validators.Int()}) def check_tmpl_context_compatibility(self, *args, **kw): return dict(tmpl_errors=str(tg.tmpl_context.form_errors), errors=str(tg.request.validation['errors'])) @expose() def error_handler(self, *args, **kw): return 'ERROR HANDLER!' @expose('json:') @validate(validators={"some_int": validators.Int()}, error_handler=error_handler) def validate_other_error_handler(self, some_int): return dict(response=some_int) def unexposed_error_handler(self, uid, **kw): return 'UID: %s' % uid @expose() @validate({ 'uid': validators.Int(), 'num': validators.Int() }, error_handler=unexposed_error_handler) def validate_unexposed(self, uid, num): return 'HUH' @expose() @validate({'num': validators.Int()}, error_handler=partial(unexposed_error_handler, uid=5)) def validate_partial(self, num): return 'HUH' @expose() @validate({ 'uid': tw2c.IntValidator(), 'num': tw2c.IntValidator() }, error_handler=error_handler_function) def validate_function(self, uid, num): return 'HUH' @expose() @validate({ 'uid': validators.Int(), 'num': validators.Int() }, error_handler=ErrorHandlerCallable()) def validate_callable(self, uid, num): return 'HUH' @expose() @validate({'uid': validators.Int()}, error_handler=ErrorHandlerCallable()) @validate({'num': validators.Int()}, error_handler=abort(412, error_handler=True)) def validate_multi(self, uid, num): return str(uid + num) @expose() @validate({'uid': validators.Int()}, error_handler=abort(412, error_handler=True)) def abort_error_handler(self): return 'HUH' @expose() @validate({'uid': validators.Int()}, error_handler=validation_errors_response) def validate_json_errors(self): return 'HUH' @expose() def validate_json_errors_complex_types(self, date): tg.request.validation.values = {'date': datetime.datetime.utcnow()} return validation_errors_response() @expose() @before_call(lambda remainder, params: params.setdefault('num', 5)) def hooked_error_handler(self, uid, num): return 'UID: %s, NUM: %s' % (uid, num) @expose() @validate(ThrowAwayValidationIntentValidator(), error_handler=abort(412, error_handler=True)) def throw_away_intent(self, uid): if tg.request.validation.exception: return 'ERROR' return 'UHU?' @expose() @validate(error_handler=hooked_error_handler) def passthrough_validation(self, uid): return str(uid) @expose() @validate({'uid': validators.Int()}, error_handler=hooked_error_handler) def validate_hooked(self, uid): return 'HUH' # Decorate validate_hooked with a controller wrapper Decoration.get_decoration(hooked_error_handler)\ ._register_controller_wrapper(ControllerWrapperForErrorHandler) @expose() def manually_handle_validation(self): # This is done to check that we don't break compatibility # with external modules that perform custom validation like tgext.socketio controller = self.__class__.validate_function args = (2, 'NaN') try: output = '' validate_params = get_params_with_argspec(controller, {}, args) params = DecoratedController._perform_validate( controller, validate_params) except validation_errors as inv: handler, output = DecoratedController._handle_validation_errors( controller, args, {}, inv, None) return output @expose(content_type='text/plain') @validate({'num': Convert(int, l_('This must be a number'))}, error_handler=validation_errors_response) def post_pow2(self, num=-1): return str(num * num) @expose(content_type='text/plain') @validate({'num': Convert(int, l_('This must be a number'), default=0)}, error_handler=validation_errors_response) def post_pow2_opt(self, num=-1): return str(num * num)
def test_multiple_requirements_backward_compatibility(self): deco = Decoration.get_decoration(RootController.force_commit) predicate = deco.requirement.predicate assert isinstance(predicate, has_permission), predicate
def multiple_engines(self): deco = Decoration.get_decoration(self.multiple_engines) used_engine = deco.engines.get('text/html')[0] return dict(format=used_engine, status='ok')
def __call__(self, func): decoration = Decoration.get_decoration(func) decoration.register_hook('before_validate', self.before_validate) decoration.register_hook('before_call', self.before_call) return func
def plugin(f, *args, **kw): results_dict = f(*args, **kw) user = args[0].user residence_var = "residence" plugins_templates = list() # un plugin est defini pour le scope et residence est defini if scope in plugins_config.mappings and residence_var in results_dict: residence_dn = Residences.get_dn_by_name( user, results_dict[residence_var]) scope_mappings = plugins_config.mappings[scope] for function in scope_mappings: plugin_name = plugin_name_from_function(function) plugin_activated = Plugins.get_by_name(user, residence_dn, plugin_name) if plugin_activated is None: continue #end if template_name = None # obtenir le nom du template à partir du decorator "expose" deco = Decoration.get_decoration(function) try: template_name = deco.engines["text/html"][1] except: pass if template_name is not None: # transformer le nom de template en chemin fichier template_path = ( tg.config['pylons.app_globals'].dotted_filename_finder. get_dotted_filename(template_name, template_extension='.html')) # ajouter dans les plugin templates plugins_templates.append(template_path) #end if # executer la fonction du plugin mapping_results = function(results_dict) # constuire le nom de regroupement des variable de ce plugin method_name = function.__name__ plugin_section = str.lower(plugin_name + "_" + method_name) # ajout du groupe au dictionnaire de la methode du controlleur results_dict[plugin_section] = PluginVars(mapping_results) #end for #end if # ajout des templates dans un champs spécial du dictionnaire pour le rendu results_dict["_plugins_templates"] = plugins_templates return results_dict