def validate_object(self, key, value_schema, value): if not isinstance(value, dict): raise ValidationError( "Field '%s' is of type 'object', received '%s' (%s)" % (key, str(value), type(value))) if not value_schema.get("properties"): # no validation on this object return for subkey, subvalue in value_schema["properties"].items(): if subkey in value: self.validate_field(subkey, subvalue, value[subkey]) elif subvalue.get("required", False) and not self._from_find: # if the field is required and we haven't pulled from find, # throw an exception raise ValidationError("Field '%s' is required but not found!" % subkey) # Check for additional properties if not value_schema.get("additionalProperties", True): extra = set(value.keys()) - set(value_schema["properties"].keys()) if len(extra) > 0: raise ValidationError( "Additional properties are not allowed: %s" % ', '.join(list(extra)))
def new_post(): json_post = request.json title = json_post.get('title') body = json_post.get('body') tags = json_post.get('tags') photos = json_post.get('nameList') if body is None or body == '': raise ValidationError('post does not have a body') if title is None or title == '': raise ValidationError('post does not have a title') post = Post(title=title, body=body) if tags: for name in re.split('[,,]', tags): tag = Tag.query.filter_by(name=name).first() if tag is None: tag = Tag(name=name) db.session.add(tag) db.session.commit() post.tags.append(tag) if photos: for name in photos: photo = Photo(name=name) db.session.add(photo) db.session.commit() post.photos.append(photo) db.session.add(post) db.session.commit() response = jsonify(Post.to_json(post)) response.status_code = 201 response.headers['Location'] = url_for('api.get_post', id=post.id, _external=True) return response
def f(value, field=None): if len(value) < min_: raise ValidationError( _('Value must be at least %d characters long') % min_) if max_ is not None and len(value) > max_: raise ValidationError( _('Value must be no more than %d characters long') % max_)
def validateCadastro(pedido, n_simafic, qtd_items): success = True error = "Dados Incorretos!" if not (len(pedido) <= 7 and patternPedido.match(pedido)): success = False raise ValidationError( "O pedido só pode conter números e no máximo 10 digitos!", error) pass if not (patternSimafic.match(n_simafic)): raise ValidationError( "Código SIMAFIC [{}] está fora do formato padrão!".format( n_simafic), error) success = False pass if not (len(qtd_items) < 10 and qtd_items.isdigit()): raise ValidationError( "O campo quantidade só pode contar numeros e no máximo 10 digitos.", error) success = False pass if (not validaSimaficXLS(n_simafic)): raise ValidationError("Código SIMAFIC não encontrado na planilha.", "Simafic Incorreto!") success = False pass return success
def new_comment_reply(id): json_reply = request.json try: body = json_reply.get('body') to = json_reply.get('to') except AttributeError: raise ValidationError('wrong format') if body is None or body == '': raise ValidationError('reply does not have a body or receiver') if to is None or to == '': raise ValidationError('reply does not have a receiver') reply = Reply(body=body) reply.to = to comment = Comment.query.get_or_404(id) reply.comment = comment if g.current_user: reply.author = g.current_user.username reply.from_admin = True else: try: author = json_reply.get('author') except AttributeError: raise ValidationError('reply does not have a author') if author is None or reply == '': raise ValidationError('reply does not have a author') reply.author = author to_admin = json_reply.get('to_admin', False) if to_admin: reply.is_read=False db.session.add(reply) db.session.commit() response = jsonify(reply.to_json()) response.status_code = 201 response.headers['Location'] = url_for('api.get_comment_replies', id=comment.id, _external=True) return response
def _validate(self, payload, key=None): """helper function, gives a payload and validate the format either raise an exception or do nothing. Optional: key, only validate if the payload can fill into key value pair """ if not self.validator: return # no validation required if not key: # validates the whole payload try: if isinstance(self.validator, list): # a list of keys for key in self.validator: if not (key in payload): raise Exception() else: # dict. key: payload keys, value: type # Check instance type matchs for key in self.validator: if (not (key in payload)) or (not isinstance( payload[key], self.validator[key])): raise Exception() except: raise ValidationError( 'Wrong payload format: p:{}, v:{}'.format( payload, self.validator)) else: # only validate for key pair if isinstance(self.validator, dict): if key in self.validator and (not isinstance( payload, self.validator[key])): raise ValidationError( 'Wrong value format for key. K: {}, format: {}'.format( payload, self.validator[key]))
def validate_instructor_nb(nb_file): """Ensures there is at least one BEGIN SOLUTION TAG in uploaded nb Should prevent accidentally uploading a student NB """ solution_text = "BEGIN SOLUTION" found = False raw = nb_file.file.read() nb_file.file.seek(0) try: # TODO: as_verion = 4? should this come from the nb somehow? nb = nbformat.reads(raw, as_version=4) except Exception as e: log.exception(e) raise ValidationError(str(e)) for cell in nb['cells']: if solution_text in cell['source']: log.info("Found solution cell") return raise ValidationError("No Solution Cells Found in uploaded notebook!"\ " Are you sure this is the instructor version?")
def new_post_comment(id): json_comment = request.json try: body = json_comment.get('body') except AttributeError: raise ValidationError('comment does not have a body') if body is None or body == '': raise ValidationError('comment does not have a body') comment = Comment(body=body) post = Post.query.get_or_404(id) comment.post = post comment.floor = len(post.comments) if g.current_user: comment.author = g.current_user.username comment.is_read = True comment.from_admin = True else: try: author = json_comment.get('author') except AttributeError: raise ValidationError('comment does not have a author') if author is None or author == '': raise ValidationError('comment does not have a author') comment.author = author db.session.add(comment) db.session.commit() response = jsonify(comment.to_json()) response.status_code = 201 response.headers['Location'] = url_for('api.get_post_comments', id=post.id, _external=True) return response
def validate_simple(self, key, value_type, value): ''' Validate a simple field (not an object or array) against a schema. ''' if value_type == "any": # can be anything pass elif value_type == "number" or value_type == "integer": # special case: can be an int or a float valid_types = [int, float, long] matches = [ klass for klass in valid_types if isinstance(value, klass) ] if len(matches) == 0: raise ValidationError( "Field '%s' is of type '%s', received '%s' (%s)" % (key, value_type, str(value), type(value))) elif value_type in ValidTypes: if not isinstance(value, ValidTypes[value_type]): raise ValidationError( "Field '%s' is of type '%s', received '%s' (%s)" % (key, value_type, str(value), type(value))) # TODO: check other things like maximum, etc. else: # unknown type raise InvalidSchemaException("Unknown type '%s'!" % value_type)
def validate(self, data: Dict): super(Policy, self).validate(data) effect = data.get('effect') action = data.get('action') resource = data.get('resource') if effect not in ['allow', 'deny']: raise ValidationError( message=f'unsupported effect "{effect}"' ) if action != '*' and int(action) not in [action.value for action in ActionTypes]: raise ValidationError( message=f'unsupported action "{action}"' ) if resource != '*': resource_obj = next( (resource for resource in Resource.get(filters={'name': [resource]})), None ) if not resource_obj: raise ValidationError( message=f'Resource Not Found "{resource}"' )
def validate(self, value): if value is None and self.required: raise ValidationError('Field is required') if value or isinstance(value, bool): if not type(value) == int: raise ValidationError('Gender must contain only numbers') if value not in GENDERS: raise ValidationError(f'Gender must contain only numbers from: {prettify_dict(GENDERS)}')
def confirm_email(current_user, confirmation_key): if current_user.email_confirmed: raise ValidationError("Email already confirmed") if current_user.email_confirmation_key == confirmation_key: current_user.email_confirmed = True current_user.save() else: raise ValidationError("Invalid confirmation key!")
def validate(self, value): if not (value or self.nullable): raise ValidationError('field "{}" cannot be empty'.format( self.name)) if not isinstance(value, self.type): raise ValidationError('field "{}", invalid type "{}"'.format( self.name, self.type))
def f(value, field=None): if len(value) < min_: raise ValidationError( _('Value must be at least %(min)d characters long') % {'min': min_}) if max_ is not None and len(value) > max_: raise ValidationError( _('Value must be no more than %(max)d characters long') % {'max': max_})
def validate(self, value): if not isinstance(value, self.type): raise ValidationError('invalid value type of field "gender"') if not value and value != UNKNOWN and not self.nullable: ValidationError('field "gender" cannot be empty') if value not in GENDERS: raise ValidationError('invalid value of field "gender"')
def validate(self, value): super().validate(value) if value or isinstance(value, bool): if not type(value) in (int, str): raise ValidationError('Phone must be a string or number') if len(str(value)) != self.number_length: raise ValidationError(f'Phone length must be {self.number_length}') if not str(value).startswith('7'): raise ValidationError('Phone must start with 7')
def __init__(self, value, suit): """Initializes a card""" if value not in CARD_VALUES: raise ValidationError( message='Card value {value} is invalid'.format(value=value)) if suit not in CARD_SUITS: raise ValidationError(message='Card suit {suit} is invalid'.format( suit=suit)) self.value = value self.suit = suit
def check_user_input_keys(cls, deserialized_json): # Check if deserialized_json only contains valid keys. for key in cls.REQUIRED_FIELDS: if key not in deserialized_json: raise ValidationError(f'Field "{key}" is required.') # Check if all the fields are allowed. for key in deserialized_json: if key not in cls.ALLOWED_FIELDS: raise ValidationError(f'Field "{key}" is not allowed.')
def validate(username, email, password, background, country, tshirt_size=None, gender=None): if not email or "." not in email or "@" not in email: raise ValidationError("You must have a valid email!") if not utils.email.is_valid_email(email): raise ValidationError("You're lying") if background not in utils.select.BackgroundKeys: raise ValidationError("Invalid Background") if country not in utils.select.CountryKeys: raise ValidationError("Invalid Background") if tshirt_size and (tshirt_size not in utils.select.TShirts): raise ValidationError("Invalid T-shirt size") if gender and (gender not in ["M", "F"]): raise ValidationError("Invalid gender") if password is not None: if len(password) < 6: raise ValidationError("Password is too short.") if username is not None: if not username or len(username) > 50: raise ValidationError("Invalid username") if get_user(username=username): raise ValidationError("That username has already been taken.")
def validate(self, value): super(BirthDayField, self).validate(value) if value: try: value = datetime.strptime(value, DATE_FORMAT).date() except ValueError: raise ValidationError('invalid date format') if (value + relativedelta(years=70)) < datetime.now().date(): raise ValidationError('too old')
def validate_products_offset(offset): result = None if offset.isnumeric(): if int(offset) < 0: raise ValidationError("OFFSET_CANNOT_BE_A_NEGATIVE_NUMBER")# 음수 금지 result = int(offset) else: raise ValidationError("OFFSET_MUST_BE_AN_INTEGER") return result
def __init__(self, email, password, access_level=0): if not self.is_mail_correct(email): raise ValidationError('This email address seems to be incorrect') if not self.is_password_strong(password): raise ValidationError('The password is not strong enough') self.email = email self.access_level = access_level self.pass_hash = security.generate_secret_hash(password)
def from_json( json_post ): ''' 从 JSON 格式数据创建一篇博客文章 ''' body = json_post.get('body') title = json_post.get('title') if body is None or body == '': raise ValidationError('post does not have a body') if title is None or title == '': raise ValidationError('post does not have a title') return Post( body=body,title=title )
def validate_string(value, min_length=None, max_length=None): try: value = str(value) except ValueError: raise ValidationError('Not a string.') if ((min_length is not None and len(value) < min_length) or (max_length is not None and len(value) > max_length)): raise ValidationError('Invalid value.') return value
def validate_products_is_sold(is_sold): result = None if is_sold: if is_sold.isnumeric(): is_sold = int(is_sold) if is_sold != 0 and is_sold != 1: raise ValidationError("IS_SOLD_MUST_BE_IN_[0, 1, None]") else: raise ValidationError("IS_SOLD_CANNOT_BE_A_STRING") return result
def validate_products_is_discounted(is_discounted): result = None if is_discounted: if is_discounted.isnumeric(): is_discounted = int(is_discounted) if is_discounted != 0 and is_discounted != 1: raise ValidationError("IS_DISCOUNTED_MUST_BE_IN_[0, 1, None]") else: raise ValidationError("IS_DISCOUNTED_CANNOT_BE_A_STRING") return result
def __init__(self, player_count): self.hands = [] if player_count < 2: raise ValidationError('Not enough players - Minimum is 2') if player_count > 10: raise ValidationError('Too many players - Maximum is 10') self.deck = [ Card(value, suit) for value in CARD_VALUES for suit in CARD_SUITS ] random.shuffle(self.deck) for player in range(player_count): self.hands.append(self.draw_hand())
def validateInfoScan(responsavel, caixa, pedido): success = True error = "Dados Incorretos!" if not (responsavel): success = False raise ValidationError( "O Campo [Responsável pela contagem] deve ser preenchido.", error) if not caixa: success = False raise ValidationError("O Campo [Numero da Caixa] deve ser preenchido.", error) return success
def validate_products_product_id(product_id): result = None if product_id: if product_id.isnumeric(): if int(product_id) < 1: raise ValidationError("PRODUCT_ID_MUST_BE_GREATER_THAN_1") result = int(product_id) else: raise ValidationError("PRODUCT_ID_MUST_BE_A_NUMBER") return result
def reset_password(token, password): if len(password) < 6: raise ValidationError("Password is too short!") try: user = User.get(User.password_reset_token == token) if user.password_reset_expired < datetime.now(): raise ValidationError("Token expired") user.set_password(password) user.password_reset_token = None user.save() except User.DoesNotExist: raise ValidationError("Invalid reset token!")
def properties_draft3(validator, properties, instance, schema): if not validator.is_type(instance, "object"): return for property, subschema in iteritems(properties): if property in instance: for error in validator.descend( instance[property], subschema, path=property, schema_path=property, ): yield error elif subschema.get("required", False): error = ValidationError("%r is a required property" % property) error._set( validator="required", validator_value=subschema["required"], instance=instance, schema=schema, ) error.path.appendleft(property) error.schema_path.extend([property, "required"]) yield error