def __init__(self) -> None:
super().__init__(
Integer(validate=Range(min=0, max=sys.maxsize)),
required=True,
validate=Length(min=3, max=3),
)
class QueueGeneralOption(BaseSchema):
key = fields.String(validate=(Length(max=128)),
required=True,
attribute='var_name')
value = fields.String(required=True, attribute='var_val')
class TitleSchema(StrictKeysSchema):
"""Title schema."""
source = fields.Str()
subtitle = fields.Str()
title = fields.Str(required=True, allow_none=False, validate=Length(min=4))
class LoginSchema(Schema):
email = String(validate=Email(), required=True)
password = String(validate=Length(min=3))
class CategorySchema(Schema):
# id = fields.String(dump_only=True)
name = fields.String(validate=Length(min=2, max=25), required=True)
description = fields.String(validate=Length(min=5, max=50))
parent = fields.Nested('self')
class CommentInputSchema(ma.Schema):
content = ma.Str(required=True, validate=Length(min=1, max=100))
upper_comment_id = ma.Integer(required=False, allow_none=True)
is_anonymous = ma.Boolean(required=True)
class UserSchema(Schema):
"""Marshmallow schema for users."""
username = String(
validate=(
Length(min=USERNAME_MIN_LENGTH, max=USERNAME_MAX_LENGTH),
Regexp(USERNAME_VALID_REGEX),
),
required=True,
)
password = String(validate=Length(min=PASSWORD_MIN_LENGTH),
required=True,
load_only=True)
email_address = Email(allow_none=True, load_only=True)
email_address_note = String(validate=Length(
max=EMAIL_ADDRESS_NOTE_MAX_LENGTH))
created_time = DateTime(dump_only=True)
bio_markdown = Markdown(max_length=BIO_MAX_LENGTH, allow_none=True)
@post_dump
def anonymize_username(self, data: dict, many: bool) -> dict:
"""Hide the username if the dumping context specifies to do so."""
# pylint: disable=unused-argument
if "username" in data and self.context.get("hide_username"):
data["username"] = "******"
return data
@validates_schema
def username_pass_not_substrings(self, data: dict, many: bool,
partial: Any) -> None:
"""Ensure the username isn't in the password and vice versa."""
# pylint: disable=unused-argument
username = data.get("username")
password = data.get("password")
if not (username and password):
return
username = username.lower()
password = password.lower()
if username in password:
raise ValidationError("Password cannot contain username")
if password in username:
raise ValidationError("Username cannot contain password")
@validates("password")
def password_not_breached(self, value: str) -> None:
"""Validate that the password is not in the breached-passwords list.
Requires check_breached_passwords be True in the schema's context.
"""
if not self.context.get("check_breached_passwords"):
return
if is_breached_password(value):
raise ValidationError(
"That password exists in a data breach (for more info, see "
'"password restrictions" below or in sidebar)')
@pre_load
def username_trim_whitespace(self, data: dict, many: bool,
partial: Any) -> dict:
"""Trim leading/trailing whitespace around the username.
Requires username_trim_whitespace be True in the schema's context.
"""
# pylint: disable=unused-argument
if not self.context.get("username_trim_whitespace"):
return data
if "username" not in data:
return data
data["username"] = data["username"].strip()
return data
@pre_load
def prepare_email_address(self, data: dict, many: bool,
partial: Any) -> dict:
"""Prepare the email address value before it's validated."""
# pylint: disable=unused-argument
if "email_address" not in data:
return data
# remove any leading/trailing whitespace
data["email_address"] = data["email_address"].strip()
# if the value is empty, convert it to None
if not data["email_address"] or data["email_address"].isspace():
data["email_address"] = None
return data
@pre_load
def prepare_bio_markdown(self, data: dict, many: bool,
partial: Any) -> dict:
"""Prepare the bio_markdown value before it's validated."""
# pylint: disable=unused-argument
if "bio_markdown" not in data:
return data
# if the value is empty, convert it to None
if not data["bio_markdown"] or data["bio_markdown"].isspace():
data["bio_markdown"] = None
return data
class ListSchema(ma.SQLAlchemyAutoSchema):
class Meta:
model = List
list_id = ma.String(required=True, validate=Length(min=1))
user = ma.Nested(UserSchema)
class ReportSchedulePostSchema(Schema):
type = fields.String(
description=type_description,
allow_none=False,
required=True,
validate=validate.OneOf(choices=tuple(key.value for key in ReportScheduleType)),
)
name = fields.String(
description=name_description,
allow_none=False,
required=True,
validate=[Length(1, 150)],
example="Daily dashboard email",
)
description = fields.String(
description=description_description,
allow_none=True,
required=False,
example="Daily sales dashboard to marketing",
)
context_markdown = fields.String(
description=context_markdown_description, allow_none=True, required=False
)
active = fields.Boolean()
crontab = fields.String(
description=crontab_description,
validate=[validate_crontab, Length(1, 1000)],
example="*/5 * * * *",
allow_none=False,
required=True,
)
timezone = fields.String(
description=timezone_description,
default="UTC",
validate=validate.OneOf(choices=tuple(all_timezones)),
)
sql = fields.String(
description=sql_description, example="SELECT value FROM time_series_table"
)
chart = fields.Integer(required=False, allow_none=True)
creation_method = EnumField(
ReportCreationMethodType,
by_value=True,
required=False,
description=creation_method_description,
)
dashboard = fields.Integer(required=False, allow_none=True)
selected_tabs = fields.List(fields.Integer(), required=False, allow_none=True)
database = fields.Integer(required=False)
owners = fields.List(fields.Integer(description=owners_description))
validator_type = fields.String(
description=validator_type_description,
validate=validate.OneOf(
choices=tuple(key.value for key in ReportScheduleValidatorType)
),
)
validator_config_json = fields.Nested(ValidatorConfigJSONSchema)
log_retention = fields.Integer(
description=log_retention_description,
example=90,
validate=[Range(min=1, error=_("Value must be greater than 0"))],
)
grace_period = fields.Integer(
description=grace_period_description,
example=60 * 60 * 4,
default=60 * 60 * 4,
validate=[Range(min=1, error=_("Value must be greater than 0"))],
)
working_timeout = fields.Integer(
description=working_timeout_description,
example=60 * 60 * 1,
default=60 * 60 * 1,
validate=[Range(min=1, error=_("Value must be greater than 0"))],
)
recipients = fields.List(fields.Nested(ReportRecipientSchema))
report_format = fields.String(
default=ReportDataFormat.VISUALIZATION,
validate=validate.OneOf(choices=tuple(key.value for key in ReportDataFormat)),
)
extra = fields.Dict(default=None,)
force_screenshot = fields.Boolean(default=False)
@validates_schema
def validate_report_references( # pylint: disable=unused-argument,no-self-use
self, data: Dict[str, Any], **kwargs: Any
) -> None:
if data["type"] == ReportScheduleType.REPORT:
if "database" in data:
raise ValidationError(
{"database": ["Database reference is not allowed on a report"]}
)
field. In Python 3, you can do multiple variables like this when defining
a field.::
class UserSchema(Schema):
name = fields.String(**STR_REQUIRED)
role = fields.Integer(**REQUIRED)
Attributes:
REQUIRED (werkzeug.datastructures.ImmutableDict): This mixin can be passed
to a Marshmallow field to make it required in a way that makes sense.
This is because Marshmallow defines ``required`` as just the key being
present and needs ``allow_none`` to not allow null values.
STR_REQUIRED (werkzeug.datastructures.ImmutableDict): This is identical to
``REQUIRED`` except that it adds a check to make sure that the string
is at least 1 character long.
"""
from marshmallow.validate import Length
from werkzeug.datastructures import ImmutableDict
REQUIRED = ImmutableDict({
'required': True,
'allow_none': False,
})
STR_REQUIRED = ImmutableDict({
'required': True,
'allow_none': False,
'validate': Length(min=1),
})
class RegistrationForm(Schema):
username = String(
required=True,
allow_none=False,
validate=[
Length(min=1, error=_('Username is required')),
Regexp(
r'^[a-zA-Z_\-0-9]+$',
error=
_('Username cannot contain space and can only contain a-z,_,0-9'
))
],
error_messages={
'required': _('Username is required'),
'null': _('Username is required')
})
password = String(
required=True,
allow_none=False,
validate=[Length(min=1, error=_('Password is required'))],
error_messages={
'required': _('Password is required'),
'null': _('Password is required')
})
confirm_password = String(
required=True,
allow_none=False,
validate=[Length(min=1, error=_('Confirm Password is required'))],
error_messages={
'required': _('Confirm Password is required'),
'null': _('Confirm Password is required')
})
name = String(required=True,
allow_none=False,
validate=[Length(min=1, error=_('Name is required'))],
error_messages={
'required': _('Name is required'),
'null': _('Name is required')
})
email = String(required=True,
allow_none=False,
validate=[
Length(min=1, error=_('Email is required')),
Email(error=_('Invalid email format'))
],
error_messages={
'required': _('Email is required'),
'null': _('Email is required')
})
referral_code = String(required=False, allow_none=True)
class Meta:
unknown = EXCLUDE
@validates('username')
def validate_username(self, username):
connect_db()
check = g.db.execute(
sa.select([User.c.id
]).where(User.c.username == username)).scalar()
if check:
raise ValidationError(
_('Username %(username)s already exists. Please input another username.',
username=username))
@validates_schema(skip_on_field_errors=True)
def validate_confirm_password(self, data, **kwargs):
password = data['password']
confirm_password = data['confirm_password']
if confirm_password != password:
raise ValidationError(_('Confirm password does not match'),
'confirm_password')
@validates('email')
def validate_email(self, email):
connect_db()
check = g.db.execute(
sa.select([User.c.id]).where(User.c.email == email)).scalar()
if check:
raise ValidationError(
_('Email %(email)s already exists. Please input another email.',
email=email))
@validates('referral_code')
def validate_referral_code(self, referral_code):
connect_db()
check = g.db.execute(
sa.select([
User.c.id
]).where(User.c.referral_code == referral_code)).scalar()
if not check:
raise ValidationError(_('Invalid referral code'))
class BookImageSchema(ma.SQLAlchemyAutoSchema):
class Meta:
model = BookImage
filename = ma.String(required=True, validate=Length(min=1))
class IAXCallNumberLimitsSchema(BaseSchema):
ip_address = fields.String(required=True,
validate=(Length(max=39)),
attribute='destination')
netmask = fields.String(required=True, validate=(Length(max=39)))
limit = fields.Integer(required=True, attribute='calllimits')
from flask import request
from marshmallow import Schema, post_dump
from marshmallow.fields import Nested, String, Boolean
from marshmallow.validate import Email, Length
from aleph.core import url_for
from aleph.model import Role
from aleph.serializers.common import BaseSchema
MIN_LENGTH = Length(min=Role.PASSWORD_MIN_LENGTH)
class RoleSchema(BaseSchema):
name = String(validate=Length(min=3))
email = String(dump_only=True)
api_key = String(dump_only=True)
password = String(validate=MIN_LENGTH, missing=None)
type = String(dump_only=True)
is_admin = Boolean(dump_only=True)
has_password = Boolean(dump_only=True)
@post_dump
def transient(self, data):
pk = str(data.get('id'))
data['links'] = {
'self': url_for('roles_api.view', id=pk)
}
data['writeable'] = str(request.authz.id) == pk
if not data['writeable']:
data.pop('password', None)
data.pop('has_password', None)
class DatasetPostSchema(Schema):
database = fields.Integer(required=True)
schema = fields.String(validate=Length(0, 250))
table_name = fields.String(required=True, allow_none=False, validate=Length(1, 250))
owners = fields.List(fields.Integer())
class ReportSchedulePutSchema(Schema):
type = fields.String(
description=type_description,
required=False,
validate=validate.OneOf(choices=tuple(key.value for key in ReportScheduleType)),
)
name = fields.String(
description=name_description, required=False, validate=[Length(1, 150)]
)
description = fields.String(
description=description_description,
allow_none=True,
required=False,
example="Daily sales dashboard to marketing",
)
context_markdown = fields.String(
description=context_markdown_description, allow_none=True, required=False
)
active = fields.Boolean(required=False)
crontab = fields.String(
description=crontab_description,
validate=[validate_crontab, Length(1, 1000)],
required=False,
)
timezone = fields.String(
description=timezone_description,
default="UTC",
validate=validate.OneOf(choices=tuple(all_timezones)),
)
sql = fields.String(
description=sql_description,
example="SELECT value FROM time_series_table",
required=False,
allow_none=True,
)
chart = fields.Integer(required=False, allow_none=True)
creation_method = EnumField(
ReportCreationMethodType,
by_value=True,
allow_none=True,
description=creation_method_description,
)
dashboard = fields.Integer(required=False, allow_none=True)
database = fields.Integer(required=False)
owners = fields.List(fields.Integer(description=owners_description), required=False)
validator_type = fields.String(
description=validator_type_description,
validate=validate.OneOf(
choices=tuple(key.value for key in ReportScheduleValidatorType)
),
allow_none=True,
required=False,
)
validator_config_json = fields.Nested(ValidatorConfigJSONSchema, required=False)
log_retention = fields.Integer(
description=log_retention_description,
example=90,
required=False,
validate=[Range(min=1, error=_("Value must be greater than 0"))],
)
grace_period = fields.Integer(
description=grace_period_description,
example=60 * 60 * 4,
required=False,
validate=[Range(min=1, error=_("Value must be greater than 0"))],
)
working_timeout = fields.Integer(
description=working_timeout_description,
example=60 * 60 * 1,
allow_none=True,
required=False,
validate=[Range(min=1, error=_("Value must be greater than 0"))],
)
recipients = fields.List(fields.Nested(ReportRecipientSchema), required=False)
report_format = fields.String(
default=ReportDataFormat.VISUALIZATION,
validate=validate.OneOf(choices=tuple(key.value for key in ReportDataFormat)),
)
force_screenshot = fields.Boolean(default=False)
from datetime import date
from marshmallow import Schema, validates_schema, validates
from marshmallow.fields import Int, Str, Date, Nested, List, Float
from marshmallow.validate import Range, Length, OneOf, ValidationError
from analyzer.db.schema import Gender
from analyzer.utils.consts import DATE_FORMAT
POSITIVE_VALUE = Range(min=0)
BASIC_STRING_LENGTH = Length(min=1, max=256)
class BaseCitizenRequestSchema(Schema):
name = Str(validate=BASIC_STRING_LENGTH, required=True)
gender = Str(validate=OneOf([gender.name for gender in Gender]), required=True)
birth_date = Date(format=DATE_FORMAT, required=True)
town = Str(validate=BASIC_STRING_LENGTH, required=True)
street = Str(validate=BASIC_STRING_LENGTH, required=True)
building = Str(validate=BASIC_STRING_LENGTH, required=True)
apartment = Int(validate=POSITIVE_VALUE, required=True)
relatives = List(Int(validate=POSITIVE_VALUE), required=True)
@validates("birth_date")
def validate_birth_date(self, value: date) -> None:
"""
Валидация на то, что дата рождения не может быть датой из будущего.
:param value: дата для валидации
"""
if value > date.today():
class GenerateTokenSchema(Schema):
"""Validate generate token input"""
username = fields.Str(required=True, validate=Length(min=1, max=255))
password = fields.Str(required=True, validate=Length(min=1, max=64))
class CommentPatchInputSchema(ma.Schema):
content = ma.Str(required=False, validate=Length(min=1, max=100))
class ReviewSchema(Schema):
feedback = fields.Str(validate=Length(3, 10))
grade = fields.Int(validate=Range(1, 100))
class RoleCreateSchema(Schema):
name = String()
password = String(validate=Length(min=Role.PASSWORD_MIN_LENGTH),
required=True)
code = String(required=True)
class AppKeysSchema(Schema):
keys = fields.List(fields.Str(),
required=True,
validate=Length(1, MAX_PER_ORGANIZATION))
class ProductSchemaAdd(Schema):
name = fields.String(validate=Length(min=2, max=50), required=True)
price = fields.Float()
count = fields.Int()
category = fields.String()
class CourseSchema(Schema):
id = fields.Integer(dump_only=True, required=True, validate=Range(min=1))
name = fields.String(required=True, validate=Length(min=1))
description = fields.String(required=True, validate=Length(min=1))
active = fields.Boolean(required=True, default=True)
diplomaList = fields.Nested('DiplomaSchema', many=True)
class PostReviewSchema(Schema):
text = fields.Str(validate=Length(1, 1024))
grade = fields.Int(validate=Range(1, 10))
class AddItemSchema(Schema):
title = fields.Str(validate=Length(1, 64), required=True)
description = fields.Str(validate=Length(1, 1024), required=True)
price = fields.Int(validate=Range(1, 1000000), required=True)
class CategorySchema(Schema):
id = fields.Int()
name = fields.Str(required=True, validate=Length(min=1, max=20, error="Name must be between 1 and 20 characters."))
created = fields.DateTime()
class EsquemaTarefas(Schema):
titulo = fields.Str(required=True, validate=Length(min=3, max=50))
descricao = fields.Str(required=True, validate=Length(min=3, max=140))
def _add_column_kwargs(self, kwargs, column):
super(CustomModelConverter, self)._add_column_kwargs(kwargs, column)
if not column.info.get('allow_blank', True):
kwargs['validate'].append(Length(min=1))
class ActivitySchema(Schema):
id = fields.Integer(required=True)
activity_name = fields.String(required=True, validate=Length(max=255))
trip_id = fields.Nested(TripSchema)
