def _jinja2_url_for_other_page(page, remove=None, **kwargs):
args = MultiDict()
if request.view_args is not None and request.view_args != [] and request.view_args != {}:
args.update(convert_type(request.view_args.copy()))
if request.args is not None and request.args != [] and request.args != {}:
args.update(convert_type(request.args.to_dict(flat=False)))
# Process removes
if remove is not None:
if isinstance(remove, (basestring, int)):
args.poplist(remove)
elif isinstance(remove, list):
for item in remove:
if isinstance(item, (basestring, int)):
args.poplist(item)
elif isinstance(item, tuple):
key, value = item
arg_values = args.poplist(key)
if arg_values is not None and arg_values != []:
new_values = [i for i in arg_values if not equal_args(i, value)]
args.setlist(key, new_values)
else:
raise ValueError
elif isinstance(remove, dict):
for key, value in remove.items():
if isinstance(value, (basestring, int)):
arg_values = args.poplist(key)
new_values = [i for i in arg_values if not equal_args(i, value)]
args.setlist(key, new_values)
elif isinstance(value, (list, tuple)):
arg_values = args.poplist(key)
if arg_values is not None and arg_values != []:
new_values = [i for i in arg_values if not equal_args(i, value)]
args.setlist(key, new_values)
else:
if current_app.debug:
print("Could not parse value : {}".format(value))
raise ValueError
else:
raise ValueError
if kwargs is not None:
args.update(convert_type(kwargs.copy()))
# Remove duplicates
for key in args.keys():
items = args.poplist(key)
items = [convert_type(item) for item in items]
items = list(set(items))
args.setlist(key, items)
return url_for(page, **args)
def validate(self, values):
"""
Validate the given dict of values against the validators and post validators of this schema. This dict should be a
dict with list values or an instance of a werkzeug `MultiDict`.
Any parameter that is not explicitely validated will be returned as extra values.
If a parameter is found it is passed to the validator's :meth:`~framework.validators.schema.Validator.validate` method that will either
return a valid output or trigger a validation error.
After individual validators are processed, the resulting valid parameters are passed to each `post_validators`.
Each post validator can change the resulting values or trigger a validation error.
When a validation error is triggered, an entry is added to the error dict mapping the field name that produced the error
to an instance of :exc:`~framework.validators.errors.Invalid` (containing the error message and error value).
After those steps, the validated values, the validation errors and the extra values dicts are returned.
:param values: The dict of values to validate against this schema
:type values: dict
:return: The dict of validated values, The dict of error messages, The dict of extra values
:rtype: a tuple (dict, dict)
"""
# Ensure we have a **new** dict with lists as values if it's a werkzeug MultiDict
# we are going to pop values from it...
values = MultiDict(values)
new_values = {}
error_values = {}
for name, validator in self.validators.iteritems():
# Determine the key to fetch from the received values
field = validator.field or name
# Get the list of values, which may be empty if the field was not present or contain some values
if validator.startswith:
value = [(x, values[x]) for x in values.iterkeys() if x.startswith(validator.startswith)]
else:
value = values.poplist(field)
try:
value = validator.validate(value)
if value is not NO_VALUE:
new_values[name] = value
except Invalid, e:
error_values[e.field or field] = e
