class UserScheme(BaseModelScheme):
user_id = Str()
email = Email(required=True,
allow_none=False,
validate=[
validate.Email(error='Incorrect email address'),
lambda value: _valid_unique('User', 'email', value)
])
password = Str(validate=[validate.Length(max=72)])
is_admin = Bool()
last_login = DateTime()
is_active = Bool()
created_on = DateTime()
phone = Str(required=True,
allow_none=False,
validate=[
validate.Regexp(PHONE_REGEXP),
lambda value: _valid_unique('User', 'phone', value)
])
logo_file_uuid = FileSchemeField(model.FileModel,
'User',
'logo',
required=False)
logo = Nested('FileModelScheme', many=False)
class Meta:
model = model.User
fields = ('email', 'passwd', 'is_admin', 'is_active', 'logo_file_uuid')
class UserRegistrationSchema(Schema):
full_name = Str(required=True,
error_messages={'required': MSG_FIELD_REQUIRED})
email = Email(required=True,
error_messages={'required': MSG_FIELD_REQUIRED})
password = Str(required=True,
error_messages={'required': MSG_FIELD_REQUIRED})
class UserSchema(Schema):
full_name = Str(required=True,
error_messages={'required': 'Campo obrigatório'})
email = Email(required=True,
error_messages={'required': 'Campo obrigatório'})
cpf_cnpj = Str()
active = Boolean()
class AccountSchema(Schema):
login = String(required=True, validate=Length(min=4))
password = String(required=True, load_only=True, validate=Length(min=4))
password_repeat = String(required=True,
load_only=True,
validate=Length(min=4))
last_name = String(required=True)
first_name = String(required=True)
email = Email(required=True)
captcha_token = String(required=True,
data_key='g-recaptcha-response',
validate=[Length(min=1, error='captcha missing')])
class Meta:
unknown = EXCLUDE
@post_load
def check_password_repeat(self, data):
if 'password' and 'password_repeat' in data:
if data['password'] != data['password_repeat']:
raise ValidationError("Passwords don't match", 'password')
else:
del data['password_repeat']
return data
class UserSchema(Schema):
id = Str()
full_name = Str(required=True,
error_messages={'required': MSG_FIELD_REQUIRED})
email = Email(required=True,
error_messages={'required': MSG_FIELD_REQUIRED})
active = Boolean()
class LoginSchema(Schema):
email = Email(
required=True, error_messages={'required': MSG_FIELD_REQUIRED}
)
senha = Str(
required=True, error_messages={'required': MSG_FIELD_REQUIRED}
)
class RegistrationSchema(Base):
custom_errors = {
"email_exists": "Email address already exists.",
"password_len": "Password must be between {min} and {max} characters long.",
"password_req_chars": "Password must contain letters and numbers.",
"password_is_email": "Password cannot be the same as your email address."
}
first_name = String(
required=True,
allow_none=False,
validate=ForbidBlankStr(forbid_whitespace_str=True)
)
last_name = String(
required=True,
allow_none=False,
validate=ForbidBlankStr(forbid_whitespace_str=True)
)
email_address = Email(required=True, allow_none=False)
min_password_len, max_password_len = 8, 50
password = String(
required=True,
allow_none=False,
validate=Length(
min=min_password_len,
max=max_password_len,
error=custom_errors["password_len"]
)
)
@validates("email_address")
def is_unique(self, email_address):
with db:
if User.retrieve(email_address) is not None:
raise ValidationError(
RegistrationSchema.custom_errors["email_exists"]
)
@validates("password")
def has_letters_and_nums(self, password):
if not has_alphanum_chars(password):
raise ValidationError(
RegistrationSchema.custom_errors["password_req_chars"]
)
@validates_schema
def password_is_not_email(self, data):
if data.get("password") == data.get("email_address"):
raise ValidationError(
message=RegistrationSchema.custom_errors["password_is_email"],
field_name="password"
)
@post_load
def register_user(self, data):
return User.instantiate(**data)
class LoginSchema(Schema):
email = Email(required=True,
error_messages={'required': MSG_FIELD_REQUIRED})
password = Str(required=True,
error_messages={'required': MSG_FIELD_REQUIRED})
class Meta:
unknown = EXCLUDE
class ResellerRegisterSchema(Schema):
name = Str(required=True, error_messages=SCHEMA_MESSAGE_REQUIRED)
last_name = Str(required=True, error_messages=SCHEMA_MESSAGE_REQUIRED)
cpf = Str(required=True,
validate=Length(max=11),
error_messages=SCHEMA_MESSAGE_REQUIRED)
email = Email(required=True, error_messages=SCHEMA_MESSAGE_REQUIRED)
password = Str(required=True, error_messages=SCHEMA_MESSAGE_REQUIRED)
class ForgotPasswordSchema(Schema):
email = Email(required=True)
captcha_token = String(required=True,
data_key='g-recaptcha-response',
validate=[Length(min=1, error='captcha missing')])
class Meta:
unknown = EXCLUDE
class UserSchema(Schema):
class Meta:
unknown = EXCLUDE
include = {"id": Integer(dump_only=True)}
name = String(required=True)
email = Email()
phone = String()
class Agent(Thing):
id = ma_fields.UUID(dump_only=True)
name = SanitizedStr(validate=ma_validate.Length(max=STR_SM_SIZE))
tax_id = SanitizedStr(lower=True,
validate=ma_validate.Length(max=STR_SM_SIZE),
data_key='taxId')
country = EnumField(enums.Country)
telephone = Phone()
email = Email()
class UserUpdateSchema(Schema):
full_name = Str()
user_name = Str()
email = Email()
date_of_born = Date()
address = Nested(AddressSchema)
phone = Str()
admin = Boolean()
active = Boolean()
class SignUpSchema(Schema):
email = Email(required=True, allow_none=False)
password = String(required=True, allow_none=False)
confirmPassword = String(required=True, allow_none=False)
@post_load
def validate_passwords(self, data):
if data['confirmPassword'] != data['password']:
raise ValidationError('Password do not match!')
return data
class UserInfoSchemeModify(BaseModelScheme):
passwd = Str()
email = Email()
class Meta:
model = model.User
fields = ('passwd', 'email', 'logo_file_uuid',
'alert_payment_received', 'alert_license_expired',
'alert_license_will_expired', 'alert_license_purchased',
'first_name', 'last_name')
class AdminSchema(Schema):
__entity__ = Admin
admin_id = String(required=True, allow_none=False, length=45)
admin_password = String(required=True, allow_none=False, length=93)
admin_type = Enum(
required=True, allow_none=False, enum=["ROOT", "ADMINISTRATION", "INTERVIEW"]
)
admin_email = Email(required=True, allow_none=False)
admin_name = String(required=True, allow_none=False, length=13)
class UserSchema(Schema):
id = Integer(dump_only=True)
first_name = String(required=True, validate=Length(1, 64))
last_name = String(required=True, validate=Length(1, 64))
birth_date = Date(required=True)
email = Email(required=True)
password = String(required=True, validate=Length(5, 32), load_only=True)
created_at = DateTime(dump_only=True)
updated_at = DateTime(dump_only=True)
deleted_at = DateTime(dump_only=True)
class ApplicantStatusSchema(Schema):
__entity__ = ApplicantStatus
applicant_email = Email(missing=None)
receipt_code = Integer(missing=None)
is_paid = Boolean(missing=False)
is_printed_application_arrived = Boolean(missing=False)
is_passed_first_apply = Boolean(missing=False)
is_final_submit = Boolean(missing=False)
exam_code = String(missing=None, length=6)
class SignUpSchema(Schema):
name = String(required=False, allow_none=False)
email = Email(required=True, allow_none=False)
password = String(required=True, allow_none=False)
confirmPassword = String(required=True, allow_none=False)
@post_load
def validate_passwords(self, data):
if data["confirmPassword"] != data["password"]:
raise ValidationError("Password do not match!")
return data
class BasicUserSchema(Schema):
email = Email(required=True)
first_name = Str(required=True, validate=Length(max=100))
last_name = Str(required=True, validate=Length(max=100))
@pre_load
def make_data(self, data, **kwargs):
data['email'] = data.pop('email').lower().strip()
data['first_name'] = data.pop('first_name').strip()
data['last_name'] = data.pop('last_name').strip()
return data
class ResellerCreateSchema(Schema):
name = Str(required=True, error_messages=SCHEMA_MESSAGE_REQUIRED)
last_name = Str(required=True, error_messages=SCHEMA_MESSAGE_REQUIRED)
cpf = Str(required=True,
validate=Length(max=11),
error_messages=SCHEMA_MESSAGE_REQUIRED)
email = Email(required=True, error_messages=SCHEMA_MESSAGE_REQUIRED)
password = Str(required=True, error_messages=SCHEMA_MESSAGE_REQUIRED)
active = Boolean(required=True, error_messages=SCHEMA_MESSAGE_REQUIRED)
roles = List(Str(maxlenght=100), error_messages=SCHEMA_MESSAGE_REQUIRED)
purchases = List(Nested(ResellerPurchaseCreateSchema))
class UserPostRequestSchema(StrictSchema):
first_name = String(required=True, validate=validate.Length(max=128))
last_name = String(required=True, validate=validate.Length(max=128))
email = Email(required=True,
validate=[
validate.Length(max=254),
validate.Email(), validate_unique_user_email
],
allow_none=False)
organisation_id = Integer(required=True,
validate=validate_organisation_exists)
class AuthoritySchema(BaseSchema):
name = String(required=True, validate=validate.Length(max=200))
service = String(validate=validate.Length(max=200))
email = Email()
contact_name = String(data_key='contactName',
validate=validate.Length(max=200))
site_url = URL(data_key='siteURL')
phone = String(validate=validate.Length(max=200))
purpose = String(required=True)
interval_before = String(data_key='intervalBefore',
validate=validate_duration)
class UserSchema(Schema):
full_name = Str(required=True,
error_messages={"required": MSG_FIELD_REQUIRED})
user_name = Str(required=True,
error_messages={"required": MSG_FIELD_REQUIRED})
email = Email(required=True,
error_messages={"required": MSG_FIELD_REQUIRED})
date_of_born = Date()
address = Nested(AddressSchema)
phone = Str()
admin = Boolean()
active = Boolean()
class UserUpdateSchema(ma.Schema):
name = String()
email = Email()
password = String(load_only=True)
@validates_schema(skip_on_field_errors=True)
def hashing_password(self, data, **kwargs):
if data.get("password"):
hashed_pass = password_hash(data.get("password"))
data.update(password=hashed_pass)
class Customer(Schema):
class Meta:
ordered = True
_id = UUID(required=False, allow_none=False, missing=uuid.uuid4)
name = String(required=True, description='Nome do cliente.', validate=Length(min=1, max=100))
email = Email(required=True, description='Email do client')
password = String(required=True, description='Senha do cliente.', validate=Length(min=1, max=100))
document = String(required=True, description='Documento do cliente.', validate=Length(min=1, max=100))
created_at = DateTime(required=False, allow_none=True, description='Criado em.', missing=datetime.now,
format=DATETIME_FORMAT)
updated_at = DateTime(required=False, allow_none=True, description='Atualizado em.', format=DATETIME_FORMAT)
class UserUpdateSchema(Schema):
nome = Str()
email = Email()
cpf = Str()
dataNascimento = Str()
sexo = Str()
telefone = Str()
endereco = Str()
cidade = Str()
estado = Str()
senha = Str()
ativo = Boolean()
class CollaboratorSchema(Schema):
id = Str()
name = Str(
required=True,
error_messages={'required': MSG_FIELD_REQUIRED}
)
email = Email(
required=True,
error_messages={'required': MSG_FIELD_REQUIRED}
)
cpf = Str()
rf = Str()
active = Boolean()
class EmailTemplateScheme(BaseModelScheme):
name = Str(validate=validate.Regexp(NAME_REGEXP))
subject = Str()
email_from = Email()
email_cc = Emails(allow_none=True, required=False)
content_text = Str()
content_html = Str()
hint = Str()
class Meta:
model = model.EmailTemplate
fields = ('name', 'subject', 'email_from', 'email_cc', 'content_text',
'content_html', 'hint')
class ApplicantSchema(Schema):
__entity__ = Applicant
email = Email(required=True, allow_none=False)
password = String(required=True, allow_none=False, length=93)
applicant_name = String(missing=None, length=13)
sex = Enum(missing=None, enum=["MALE", "FEMALE"])
birth_date = Date(missing=None)
parent_name = String(missing=None, length=13)
parent_tel = String(missing=None, regex=r"01\d\d{3,4}\d{4}")
applicant_tel = String(missing=None, regex=r"01\d\d{3,4}\d{4}")
address = String(missing=None, length=500)
post_code = String(missing=None, length=5)
image_path = String(missing=None, length=256)
