def validate(self, playload):
person_helper = PersonHelper()
generic_helper = GenericHelper()
cnpj = playload.get('cnpj')
cpf = playload.get('cpf')
birth_date = playload.get('birth_date')
gender = playload.get('gender')
_id = playload.get('id')
name = playload.get('name')
_type = playload.get('type')
if cnpj and not person_helper.validate_cnpj(cnpj):
self.add_error('cnpj', 'CNPJ invalido.')
if cpf and not person_helper.validate_cpf(cpf):
self.add_error('cpf', 'CPF invalido.')
if birth_date and not generic_helper.str_date_check(birth_date, '-'):
self.add_error(
'birth_date',
'Data de nascimento precisa estár no formato dd-mm-aaaa.')
if gender and not (gender == 'Masculino' or gender == 'Feminino'):
self.add_error('gender',
'O gênero precisa ser "Masculino" ou "Feminino".')
if _id and not _id.isnumeric():
self.add_error('id', 'O ID precisa ser um inteiro.')
return self.valid()
def validate(self, cnpj):
helper = PersonHelper()
if not cnpj:
self.add_error('cnpj', 'CNPJ é obrigatorio.')
return self.valid()
if not helper.validate_cnpj(cnpj):
self.add_error('cnpj', 'CNPJ invalido.')
return self.valid()
def validate(self, cpf):
helper = PersonHelper()
if not cpf:
self.add_error('cpf', 'CPF é obrigatorio.')
return self.valid()
if not helper.validate_cpf(cpf):
self.add_error('cpf', 'CPF invalido.')
return self.valid()
def validate(self, data):
helper = PersonHelper()
generic_helper = GenericHelper()
_id = data.get('id')
_type = data.get('type')
birth_date = data.get('birth_date')
name = data.get('name')
surname = data.get('surname')
gender = data.get('gender')
cpf = data.get('cpf')
company_name = data.get('company_name')
cnpj = data.get('cnpj')
if not _id:
self.add_error('id', 'ID é obrigatorio.')
if _id and type(_id) != int:
self.add_error('id', 'ID precisa ser um inteiro.')
if not _type:
self.add_error('type', 'O tipo de pessoa é obrigatorio.')
if _type and type(_type) != str:
self.add_error('type', 'O tipo de pessoa precisa ser uma string.')
if _type and not (_type == 'Pessoa Fisica'
or _type == 'Pessoa Juridica'):
self.add_error(
'type',
'O tipo de pessoa precisa ser "Pessoa Fisica" ou "Pessoa Juridica".'
)
if not (birth_date == None or type(birth_date) == str):
self.add_error('birth_date',
'Birth date precisa ser uma string ou null.')
if birth_date and not generic_helper.str_date_check(birth_date):
self.add_error(
'birth_date',
'A data de nascimento precisa estar no formato dd/mm/yyyy.')
if not (name == None or type(name) == str):
self.add_error('name', 'Name precisa ser uma string ou null.')
if not (surname == None or type(surname) == str):
self.add_error('surname',
'Surname precisa ser uma string ou null.')
if not (gender == None or type(gender) == str):
self.add_error('gender', 'Gender precisa ser uma string ou null.')
if not (cpf == None or type(cpf) == str):
self.add_error('cpf', 'CPF precisa ser uma string ou null.')
if cpf and type(cpf) == str and not helper.validate_cpf(cpf):
self.add_error('cpf', 'CPF invalido.')
if not (company_name == None or type(company_name) == str):
self.add_error('company_name',
'Company name precisa ser uma string ou null.')
if not (cnpj == None or type(cnpj) == str):
self.add_error('cnpj', 'CNPJ precisa ser uma string ou null.')
if cnpj and type(cnpj) == str and not helper.validate_cnpj(cnpj):
self.add_error('cnpj', 'CNPJ invalido.')
return self.valid()
def validate(self, data):
helper = PersonHelper()
person_id = data.get('person_id')
neighborhood = data.get('neighborhood')
street = data.get('street')
number = data.get('number')
complement = data.get('complement')
city = data.get('city')
if not person_id:
self.add_error('person_id', 'O ID da pessoa é obrigatorio.')
if person_id and type(person_id) != int:
self.add_error('person_id', 'O ID da pessoa precisa ser um inteiro.')
if not (neighborhood == None or type(neighborhood) == str):
self.add_error('neighborhood', 'O bairro precisa ser uma string ou null.')
if not (street == None or type(street) == str):
self.add_error('street', 'A rua precisa ser uma string ou null.')
if not (number == None or type(number) == str):
self.add_error('number', 'O número precisa ser uma string ou null.')
if not (complement == None or type(complement) == str):
self.add_error('complement', 'O complemento precisa ser uma string ou null.')
if not (city == None or type(city) == str):
self.add_error('city', 'O cidade precisa ser uma string ou null.')
return self.valid()
def create_person(self):
contract = CreatePersonContract()
playload = request.json
if not (contract.validate(playload)):
return ResultModel('Problema nos parametros enviados.', False,
contract.errors).to_dict(), 406
playload = GenericHelper().captalize_full_dict(playload)
repository = PersonRepository()
cpf = playload.get('cpf')
cnpj = playload.get('cnpj')
helper = PersonHelper()
if cpf:
playload['cpf'] = helper.remove_characters(cpf)
if cnpj:
playload['cnpj'] = helper.remove_characters(cnpj)
person = repository.create_person(playload)
status_result = SetStatusResponseHandler()
return status_result.default(person)
def create_user_person_address(self, first_admin=False):
helper = Helper()
contract = CreateUserAndpersonAndAddressContract()
playload = request.json
if not (contract.validate(playload)):
return ResultModel('Envie todos parametros obrigatorios.', False,
contract.errors).to_dict(), 406
user_dto = playload.get('user')
person_dto = helper.captalize_full_dict(playload.get('person'))
address_dto = helper.captalize_full_dict(playload.get('address'))
user_repository = UserRepository()
person_repository = PersonRepository()
address_repository = AddressRepository()
status_result = SetStatusResponseHandler()
user_exist = user_repository.get_by_username(user_dto.get('username'))
if user_exist['message'] != 'Nome de usuario não encontrado.':
if user_exist.get('exeption'):
return user_exist, 500
elif user_exist['message'] == 'Pesquisa realizada com sucesso.':
username = user_dto.get('username')
return ResultModel(f'Usuario "{username}" já existe.', False,
True).to_dict(), 406
return user_exist, 406
if user_dto.get(
'is_admin') and not Admin().is_admin() and not first_admin:
return ResultModel(
'Só um administrador pode criar outro administrador.', False,
contract.errors).to_dict(), 406
cpf = person_dto.get('cpf')
cnpj = person_dto.get('cnpj')
person_helper = PersonHelper()
if cpf:
person_dto['cpf'] = person_helper.remove_characters(cpf)
exist_cpf = person_repository.get_by_cpf_or_cnpj(
person_dto['type'], person_dto['cpf'])['data']['result']
if exist_cpf:
return ResultModel(f'O CPF "{cpf}" já foi cadastrado.', False,
True).to_dict(), 406
elif cnpj:
person_dto['cnpj'] = person_helper.remove_characters(cnpj)
exist_cnpj = person_repository.get_by_cpf_or_cnpj(
person_dto['type'], person_dto['cnpj'])['data']['result']
if exist_cnpj:
return ResultModel(f'O CNPJ "{cnpj}" já foi cadastrado.',
False, True).to_dict(), 406
person = person_repository.create_person(person_dto)
if not person['data']['result']:
return status_result.default(person)
person = person['data']['result']
address_dto['person_id'] = person.get('id')
address = address_repository.create_address(address_dto)
if not address['data']['result']:
return status_result.default(address)
address = address['data']['result']
user_repository.create(user_dto)
user_dto['person_id'] = person['id']
user = user_repository.create(user_dto)
if user['error']:
return status_result.default(user)
user = user['data']['result']
result = dict(
user=user,
person=person,
address=address,
)
return result, 201