def update_person(person_dict):
try:
helper = GenericHelper()
birth_date = person_dict.get('birth_date')
if birth_date:
birth_date = helper.str_date_to_datetime(birth_date)
_id = person_dict.get('id')
_type = person_dict.get('type')
name = person_dict.get('name')
surname = person_dict.get('surname')
gender = person_dict.get('gender')
cpf = person_dict.get('cpf')
company_name = person_dict.get('company_name')
cnpj = person_dict.get('cnpj')
person = Person.query.get(_id)
if person:
person.type = _type
person.birth_date = birth_date
person.name = name
person.surname = surname
person.gender = gender
person.cpf = cpf
person.company_name = company_name
person.cnpj = cnpj
person.modification_date = datetime.datetime.utcnow()
db.session.add(person)
db.session.commit()
data = marshal(person, person_fields)
return ResultModel('Pessoa alterada com sucesso.', data,
False).to_dict()
except Exception as e:
return ResultModel('Não foi possivel alterar a pessoa.', False,
True, str(e)).to_dict()
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 create_person(data_person):
try:
helper = GenericHelper()
birth_date = data_person.get('birth_date')
cpf = data_person.get('cpf')
cnpj = data_person.get('cnpj')
if birth_date:
data_person['birth_date'] = helper.str_date_to_datetime(
birth_date)
if cpf:
find_cpf = Person.query.filter_by(cpf=cpf).first()
if find_cpf:
return ResultModel(
'Não foi possivel criar pessoa.', False,
[dict(name='cpf', error='O CPF já foi cadastrado.')
]).to_dict()
elif cnpj:
find_cnpj = Person.query.filter_by(cnpj=cnpj).first()
if find_cnpj:
return ResultModel(
'Não foi possivel criar pessoa.', False,
[dict(name='cnpj', error='O CNPJ já foi cadastrado.')
]).to_dict()
person = Person(data_person)
db.session.add(person)
db.session.commit()
person_result = marshal(person, person_fields)
return ResultModel('Pessoa criada com sucesso.', person_result,
False).to_dict()
except Exception as e:
return ResultModel('Não foi possivel criar pessoa.', False, True,
str(e)).to_dict()
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 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 update_person(self):
contract = UpdatePersonContract()
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()
person = repository.update_person(playload)
status_result = SetStatusResponseHandler()
return status_result.default(person)
def get_by_params(self):
contract = GetByParamsPersonContract()
playload = request.args
if not (contract.validate(playload)):
return ResultModel('Parametro incorreto.', False,
contract.errors).to_dict(), 406
generic_helper = GenericHelper()
params_filter = {}
_id = playload.get('id')
cnpj = playload.get('cnpj')
cpf = playload.get('cpf')
birth_date = playload.get('birth_date')
gender = playload.get('gender')
name = playload.get('name')
_type = playload.get('type')
if _id:
params_filter['id'] = int(_id)
if cnpj:
params_filter['cnpj'] = cnpj
if cpf:
params_filter['cpf'] = cpf
if birth_date:
params_filter['birth_date'] = generic_helper.str_date_to_datetime(
birth_date)
if gender:
params_filter['gender'] = gender
if name:
params_filter['name'] = name
if _type:
params_filter['type'] = _type
params_filter = Paginate().include_paginate_args_playload(
request, params_filter)
repository = PersonRepository()
systems = repository.get_search_by_params(params_filter)
status_result = SetStatusResponseHandler()
return status_result.default(systems)
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