def __call__(self, request):
values = {}
extras = set()
cannot_convert = set()
form_data = {}
# All keys which show up only once in the form data get a scalar value
# in the pre-converted dictionary. All keys which show up more than
# once get a list value.
missing = object()
# Parse the items from request depending on the content type.
items = get_request_params(request)
for key, new_value in items.items():
old_value = form_data.get(key, missing)
if old_value is missing:
form_data[key] = new_value
elif isinstance(old_value, list):
old_value.append(new_value)
else:
form_data[key] = [old_value, new_value]
# Now do all the conversions.
for key, value in form_data.items():
try:
values[key] = self._converters[key](value)
except KeyError:
extras.add(key)
except (TypeError, ValueError) as e:
cannot_convert.add((key, str(e)))
# Make sure there are no unexpected values.
if len(extras) != 0:
extras = COMMASPACE.join(sorted(extras))
raise ValueError('Unexpected parameters: {}'.format(extras))
# raise BadRequestError(
# description='Unexpected parameters: {}'.format(extras))
# Make sure everything could be converted.
if len(cannot_convert) != 0:
invalid_msg = []
for param in sorted(cannot_convert):
invalid_msg.append(
'Invalid Parameter "{0}": {1}.'.format(*param))
raise ValueError(' '.join(invalid_msg))
# raise InvalidParamError(param_name=bad, msg=invalid_msg)
# Make sure nothing's missing.
value_keys = set(values)
required_keys = set(self._converters) - self._optional
if value_keys & required_keys != required_keys:
missing = COMMASPACE.join(sorted(required_keys - value_keys))
raise ValueError('Missing Parameter: {}'.format(missing))
# raise MissingParamError(param_name=missing)
return values
def __init__(self, request, converters):
"""Create a validator for the PATCH request.
:param request: The request object, which must have a .PATCH
attribute.
:param converters: A mapping of attribute names to the converter for
that attribute's type. Generally, this will be a GetterSetter
instance, but it might be something more specific for custom data
types (e.g. non-basic types like unicodes).
:raises UnknownPATCHRequestError: if the request contains an unknown
attribute, i.e. one that is not in the `attributes` mapping.
:raises ReadOnlyPATCHRequest: if the requests contains an attribute
that is defined as read-only.
"""
validationators = {}
# Parse the items from request depending on the content type.
items = get_request_params(request)
for attribute in items:
if attribute not in converters:
raise UnknownPATCHRequestError(attribute)
if converters[attribute].decoder is None:
raise ReadOnlyPATCHRequestError(attribute)
validationators[attribute] = converters[attribute]
super().__init__(**validationators)
def test_get_request_params_with_none(self):
request = FakeRequest()
self.assertEqual(helpers.get_request_params(request), 'not set')