def validate_keys(self, key_mapping):
for pos, mapping in key_mapping.iteritems():
if pos <= 0:
raise errors.wrong_type('keys', 'numeric positions')
if not isinstance(mapping, dict):
raise errors.wrong_type('keys', 'dict-like structures')
self.funckey_validator.validate(mapping)
def _check_invalid_parameters(line):
if line.context.strip() == '':
raise errors.missing('context')
try:
line.device_slot = int(line.device_slot)
except ValueError:
raise errors.wrong_type('device_slot', 'positive numeric', device_slot=line.device_slot)
if line.device_slot <= 0:
raise errors.wrong_type('device_slot', 'positive numeric', device_slot=line.device_slot)
def _validate_parameters(self, parameters):
if parameters['offset'] < 0:
raise errors.wrong_type('offset', 'positive number')
if parameters['limit'] is not None and parameters['limit'] <= 0:
raise errors.wrong_type('limit', 'positive number')
if parameters['direction'] not in self.SORT_DIRECTIONS.keys():
raise errors.invalid_direction(parameters['direction'])
def _validate_invalid_parameters(user_line):
if not isinstance(user_line.user_id, int):
raise errors.wrong_type('user_id', 'positive integer')
if not isinstance(user_line.line_id, int):
raise errors.wrong_type('line_id', 'positive integer')
if hasattr(user_line, 'main_user') and not isinstance(user_line.main_user, bool):
raise errors.wrong_type('main_user', 'boolean')
if hasattr(user_line, 'main_line') and not isinstance(user_line.main_line, bool):
raise errors.wrong_type('main_line', 'boolean')
def _extract_numeric(self, name, arguments):
value = arguments.get(name, None)
if value:
if not value.isdigit():
raise errors.wrong_type(name, 'positive number')
value = int(value)
if value < 0:
raise errors.wrong_type(name, 'positive number')
self.extracted[name] = value
def _extract_numeric(self, name, arguments):
value = arguments.get(name, None)
if value:
if not value.isdigit():
raise errors.wrong_type(name, 'positive number')
value = int(value)
if value < 0:
raise errors.wrong_type(name, 'positive number')
self.extracted[name] = value
def validate_option(self, option):
if not isinstance(option, Iterable):
raise errors.wrong_type('options', 'list of pair of strings')
if not len(option) == 2:
raise errors.wrong_type('options', 'list of pair of strings')
for i in option:
if not isinstance(i, (str, six.text_type)):
raise errors.wrong_type('options',
"value '{}' is not a string".format(i))
def _validate_parameters(self, parameters):
if parameters['offset'] < 0:
raise errors.wrong_type('offset', 'positive number')
if parameters['limit'] is not None and parameters['limit'] <= 0:
raise errors.wrong_type('limit', 'positive number')
if parameters['direction'] not in self.SORT_DIRECTIONS.keys():
raise errors.invalid_direction(parameters['direction'])
def _check_invalid_parameters(self, device):
if device.ip and not self.IP_REGEX.match(device.ip):
raise errors.wrong_type('ip', 'IP address', ip=device.ip)
if device.mac and not self.MAC_REGEX.match(device.mac):
raise errors.wrong_type('mac', 'MAC address', mac=device.mac)
if device.options is not None:
if not isinstance(device.options, dict):
raise errors.wrong_type('options', 'dict-like structure', options=device.options)
elif 'switchboard' in device.options and not isinstance(device.options['switchboard'], bool):
raise errors.wrong_type('options.switchboard', 'boolean', switchboard=device.options['switchboard'])
def validate(self, device):
options = device.options or {}
if not isinstance(options, dict):
raise errors.wrong_type('options',
'dict-like structure',
options=options)
if 'switchboard' in options and not isinstance(options['switchboard'],
bool):
raise errors.wrong_type('options.switchboard',
'boolean',
options=options)
def _extract_datetime(datetime_key, request_args):
if datetime_key in request_args:
try:
return _decode_datetime(request_args[datetime_key])
except ValueError:
raise errors.wrong_type(datetime_key, 'datetime')
raise errors.missing(datetime_key)
def _check_invalid_parameters(user):
if not user.firstname:
raise errors.missing('firstname')
if user.mobile_phone_number and not MOBILE_PHONE_NUMBER_REGEX.match(user.mobile_phone_number):
raise errors.wrong_type('mobile_phone_number', 'numeric phone number')
if user.password is not None and len(user.password) < 4:
raise errors.minimum_length('password', 4)
def validate_invalid_parameters(extension):
if not extension.exten:
raise errors.missing('exten')
if not extension.context:
raise errors.missing('context')
if extension.commented not in [True, False]:
raise errors.wrong_type('commented', 'boolean')
def _extract_datetime(datetime_key, request_args):
if datetime_key in request_args:
try:
return _decode_datetime(request_args[datetime_key])
except ValueError:
raise errors.wrong_type(datetime_key, 'datetime')
raise errors.missing(datetime_key)
def validate(self, model):
values = getattr(model, self.field)
for value in values:
if not self.regex.match(value):
message = "{} string matching regex '{}'".format(
value, self.regex.pattern)
raise errors.wrong_type(self.field, message)
def validate(self, model):
value = getattr(model, self.field)
if not self.regex.match(value):
if self.message:
message = self.message
else:
message = "string matching regex '{}'".format(
self.regex.pattern)
raise errors.wrong_type(self.field, message)
def parse(self, value):
if value == "":
return None
if not value.isdigit():
raise errors.wrong_type(self.csv_name, 'integer')
return int(value)
def validate_caller_id(user, required=False):
if user.caller_id:
if not CALLER_ID_REGEX.match(user.caller_id):
raise errors.wrong_type('caller_id', 'formatted caller id string')
elif required:
raise errors.missing('caller_id')
def convert_numeric(self, key, value):
if not value.isdigit():
raise errors.wrong_type(key, "positive number")
return int(value)
def validate_text(self, text, field):
if text is not None:
for char in self.INVALID_CHARS:
if char in text:
raise errors.wrong_type(field, self.INVALID_CHARS_MSG,
**{field: text})
def _validate_exten(extension):
if not extension.exten.isdigit():
raise errors.wrong_type('exten', 'numeric string')
return extension.exten
def validate_options(self, options):
if not isinstance(options, Iterable):
raise errors.wrong_type('options', 'list of pair of strings')
