def validate_value(self, value): # Check if the value for this field's answer is valid. key_values = list(value.keys()) key_schema = list(o['key'] for o in self.checklist) unused_keys = copy(key_schema) for k in key_values: if k not in key_schema: raise FieldError(( "Answer Key '{0}' is not a valid" " option for this form.").format(k)) else: unused_keys.remove(k) if not isinstance(value[k], bool): raise FieldError(( "'{0}': Expected boolean, got '{1}'").format( k, type(value[k]).__name__ )) if len(unused_keys) > 0: raise FieldError(( "The following keys are missing from the answer:" "{0}").format(unused_keys)) for validator in self.validation_classes: validator.validate(value)
def check_widget(self, widget): if not isinstance(widget, dict): raise FieldError( "Invalid 'widget' definition, expected 'dictionary', got '{0}'" .format(type(widget).__name__)) try: if widget['type'] not in self.allowed_widgets: raise FieldError( ("Field '{0}' of type '{1}' does not accept the '{2}' " "widget type").format(self.id, self.type, widget['type'])) except KeyError: raise FieldError("Invalid 'widget' definition")
def validate_value(self, value): # Check if the value for this field's answer is valid. if 'option' in value and value['option'] not in self.option_values: raise FieldError( "'{0}' is not a a correct option value".format(value)) if ('option' in value and value['option'] == 'OTHER' and not value['answer']): raise FieldError({ 'id': 'section1.errors.other_option', }) for validator in self.validation_classes: validator.validate(value)
def validate_value(self, value): # Check if the value for this field's answer is valid. if value not in self.option_values: raise FieldError( "'{0}' is not a a correct option value".format(value)) for validator in self.validation_classes: validator.validate(value)
def validate(self, field): if self.value not in field: raise FieldError({ 'id': 'section1.errors.contains', 'values': { 'word': self.value } })
def validate_schema(cls, field): errors = [] expected_keys = list(cls.EXPECTED_KEYS) optional_keys = list(cls.OPTIONAL_KEYS) for key in field: if key in expected_keys: expected_keys.remove(key) else: try: optional_keys.remove(key) except ValueError: errors.append( "Key '{0}' either doesn't belong in the field schema " "or is duplicated".format(key)) for key in expected_keys: errors.append( "Required key '{0}' is missing from the field schema".format( key)) if errors: raise FieldError(errors) if not isinstance(field['values'], list): errors.append("'values' property must be a list") raise FieldError(errors) for value in field['values']: if not isinstance(value, dict): errors.append( "Every element of 'values' property must be a dictionary") continue expected_values_keys = ['key', 'value'] for key in value: if key in expected_values_keys: expected_values_keys.remove(key) else: errors.append("Key '{0}' doesn't belong in field values " "schema".format(key)) for key in expected_values_keys: errors.append("Required key '{0}' missing in field values " "schema".format(key)) if errors: raise FieldError(errors)
def validate_value(self, value): # Check if the value for this field's answer is valid. try: self.decimals except AttributeError: self.decimals = False invalid_values = [] sum = 0 for option in value.keys(): str_option_values = [str(x) for x in self.option_values] if option not in str_option_values: invalid_values.append( "'{0}' is not a a correct option value".format(option)) if value[option]: try: float_value = float(value[option]) except ValueError: invalid_values.append( "Answer for option '{0}' must be a number".format( option)) continue if not self.decimals and not float_value.is_integer(): invalid_values.append({ 'id': 'section1.errors.rank_field.only_integer', 'values': { 'option': option } }) sum += float_value if invalid_values: raise FieldError(invalid_values) if sum != self.sum_total: raise FieldError({ 'id': 'section1.errors.rank_field.add', 'values': { 'total': self.sum_total } }) for validator in self.validation_classes: validator.validate(value)
def validate_value(self, value): # Check if the value for this field's answer is valid. try: float(value) except ValueError: raise FieldError("'{0}' is not a number".format(value)) for validator in self.validation_classes: validator.validate(value)
def validate(self, field): if len(field) < int(self.value): raise FieldError({ 'id': 'section1.errors.min_length', 'values': { 'min': self.value, 'answer': len(field) } })
def validate(self, field): if int(field) > int(self.value): raise FieldError({ 'id': 'section1.errors.max_value', 'values': { 'max': self.value, 'answer': int(field) } })
def validate_schema(cls, field): allowed_types = list(cls.ALLOWED_SHAPE_TYPES) if field['shape'] not in allowed_types: raise FieldError( "Type '{0}' is not a valid shape option." " Must be one of: " "'Polygon', 'Point' or 'LineString'".format(field['shape'])) super().validate_schema(field)
def validate_value(self, value): # Check if the value for this field's answer is valid. if isinstance(value, dict): try: GEOSGeometry(json.dumps(value)) except GEOSException: raise FieldError("geoJSON geometry is not valid") except (ValueError, TypeError, GDALException): raise FieldError("malformed geoJSON") if self.shape != value['type']: raise FieldError( "geoJSON must be of type '{0}'".format(self.shape) ) else: raise FieldError("value must be an object") for validator in self.validation_classes: validator.validate(value)
def validate_value(self, value): # Check if the value for this field's answer is valid. if not re.match(self.EMAIL_RE, value): raise FieldError({ 'id': 'section1.errors.invalid_email', 'values': { 'answer': value } }) for validator in self.validation_classes: validator.validate(value)
def validate_value(self, value): # Check if the value for this field's answer is valid. invalid_values = [] for v in value: if v not in self.option_values: invalid_values.append( "'{0}' is not a a correct option value".format(v)) if invalid_values: raise FieldError(invalid_values) for validator in self.validation_classes: validator.validate(value)
def validate(self, field): for _, value in field.items(): if isinstance(value, dict): # In case field type is Rank Other value = value['value'] if value is not None and int(value) > int(self.value): raise FieldError({ 'id': 'section1.errors.rank_field.max_value', 'values': { 'max': self.value, 'answer': int(value) } })
def validate_value(self, value): # Check if the value for this field's answer is valid. try: float_value = float(value) except ValueError: raise FieldError("'{0}' is not a number".format(value)) try: self.decimals except AttributeError: self.decimals = False if not self.decimals and not float_value.is_integer(): raise FieldError({ 'id': 'section1.errors.only_integer', 'values': { 'answer': value } }) for validator in self.validation_classes: validator.validate(value)
def check_validators(self, validators, **kwargs): errors = [] for validator in validators: try: validator_class = ValidatorFactory.get_class(validator['type']) except KeyError: errors.append("Invalid validator type: '{0}'".format( validator['type'])) continue try: validator_obj = validator_class(validator, self) self.validation_classes.append(validator_obj) except ValidationError as e: errors = [] for err in e: errors.append(str(err)) raise FieldError(errors)
def validate_schema(cls, field): errors = [] expected_keys = list(cls.EXPECTED_KEYS) optional_keys = list(cls.OPTIONAL_KEYS) for key in field: if key in expected_keys: expected_keys.remove(key) else: try: optional_keys.remove(key) except ValueError: errors.append( "Key '{0}' either doesn't belong in the field schema " "or is duplicated".format(key)) for key in expected_keys: errors.append( "Required key '{0}' is missing from the field schema".format( key)) if errors: raise FieldError(errors)
def validate_value(self, value): # Check if the value for this field's answer is valid. if not isinstance(value, bool): raise FieldError("Expected boolean value, got '{0}'".format( type(value).__name__))
def check_answers(self, answers): if not isinstance(answers, dict): raise FormatError( "Expected answers to be a 'dictionary', got {0} instead" .format(type(answers).__name__)) answer_keys = answers.keys() invalid_keys = [] for key in answer_keys: try: self.fields[key.__str__()] except KeyError: invalid_keys.append( "Field '{0}' does not match any field on the form." .format(key)) continue if invalid_keys: raise FieldError(invalid_keys) errors = [] error = { 'id': '', 'message': {} } # We check for answers for each of the form's fields for key in self.fields: field = self.fields[key.__str__()] is_hidden, is_required = self.check_state(key, answers) try: answer = answers[key] except KeyError: if is_required and not is_hidden: error['id'] = key error['message'] = { "id": "section1.errors.required_field" } errors.append(copy(error)) continue # If the field is hidden we don't need the answer if is_hidden: del answers[key] continue # If there is no answer for a field we don't run validations if answer is None or answer == "": if is_required and not is_hidden: error['id'] = key error['message'] = { "id": "section1.errors.required_field" } errors.append(copy(error)) else: try: field.validate_value(answer) except FieldError as err: error['id'] = key for e in err: error['message'] = e errors.append(copy(error)) if errors: result = { 'result': 'ANSWER_ERROR', 'errors': errors } return result else: success = {} success['result'] = "OK" success['message'] = "The answer is valid." return success