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 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 __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 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 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 __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 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 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 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 test_multiple_requirements_all_registered(self):
deco = Decoration.get_decoration(RootController.force_commit)
assert len(deco.requirements) == 2, deco.requirements
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 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 test_multiple_requirements_backward_compatibility(self):
deco = Decoration.get_decoration(RootController.force_commit)
predicate = deco.requirement.predicate
assert isinstance(predicate, has_permission), predicate
