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 post(self):
contract = LoginContract()
playload = request.json
if not (contract.validate(playload)):
return ResultModel('Envie todos parametros obrigatorios.', False,
contract.errors).to_dict(), 406
password = playload.get('password')
bcrypt = Bcrypt(current_app)
crypt_password = bcrypt.generate_password_hash(password).decode(
'utf-8')
repository = UserRepository()
user = repository.get_by_username(playload.get('username'),
True)['data']['result']
if not user:
ResultModel('Usuario não existe.', False, True)
if not user or not bcrypt.check_password_hash(user['password'],
password):
return ResultModel('Credenciais incorretas.', False,
True).to_dict(), 406
data = {'userId': user['id'], 'is_admin': user['is_admin']}
expires = datetime.timedelta(
days=current_app.config.get('TOKEN_DAYS_EXPIRES'))
token = create_access_token(identity=user['id'],
expires_delta=expires,
user_claims=data)
return ResultModel('Sucesso na geração do token.', token,
False).to_dict(), 201
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 create(self, playload):
try:
user_id = playload.get('user_id')
profile_system_id = playload.get('profile_system_id')
user_id_exist = UserRepository().get_by_id(user_id)
if not user_id_exist['data']['result']['id']:
return ResultModel(f'O ID {user_id} de usuário não existe.',
False, True).to_dict()
profile_system_id_exist = ProfileSystemRepository().get_by_id(
profile_system_id)
if not profile_system_id_exist['data']['result']['id']:
return ResultModel(
f'O ID {profile_system_id} de perfil de sistema não existe.',
False, True).to_dict()
user_profile_system_exist = UserProfileSystem.query.filter_by(
user_id=user_id, profile_system_id=profile_system_id).first()
if user_profile_system_exist:
return ResultModel(f'Esses dados já foram cadastrados.', False,
True).to_dict()
user_profile_system = UserProfileSystem(playload)
db.session.add(user_profile_system)
db.session.commit()
data = marshal(user_profile_system, user_profile_system_fields)
return ResultModel('Criado com sucesso.', data, False).to_dict()
except Exception as e:
return ResultModel('Não foi possivel criar.', False, True,
str(e)).to_dict()
def get_by_id(self, _id):
contract = GetByIdProfileSystemAndDependenciesContract()
if not (contract.validate(_id)):
return ResultModel('Parametro incorreto.', False,
contract.errors).to_dict(), 406
_id = int(_id)
repo_prof_sys = ProfileSystemRepository()
profile_system_db_result = repo_prof_sys.get_by_id(_id)
if not profile_system_db_result['data']['result']['id']:
return ResultModel('ID não encontrado.', False,
contract.errors).to_dict(), 406
profile_system = profile_system_db_result['data']['result']
repo_prof_permi = ProfilePermissionRepository()
_filter = dict(profile_system_id=_id)
filter_dto = Paginate().include_paginate_args_playload(
request, _filter)
profile_permission = repo_prof_permi.get_search_by_params(
filter_dto)['data']['result']
repo_user_prof_system = UserProfileSystemRepository()
user_profile_system = repo_user_prof_system.get_search_by_params(
filter_dto)['data']['result']
data = dict(profile_system=profile_system,
profile_permission=profile_permission,
user_profile_system=user_profile_system)
result = ResultModel('Pesquisa realizada com sucesso.', data,
False).to_dict()
status_result = SetStatusResponseHandler()
return status_result.default(data)
def update_address(address_dict):
try:
_id = address_dict.get('id')
person_id = address_dict.get('person_id')
neighborhood = address_dict.get('neighborhood')
street = address_dict.get('street')
number = address_dict.get('number')
complement = address_dict.get('complement')
city = address_dict.get('city')
address = Address.query.get(_id)
if not address:
return ResultModel('Não foi possivel alterar o endereço.',
False, True).to_dict()
address.id = _id
address.person_id = person_id
address.neighborhood = neighborhood
address.street = street
address.number = number
address.complement = complement
address.city = city
address.modification_date = datetime.datetime.utcnow()
db.session.add(address)
db.session.commit()
data = marshal(address, address_fields)
return ResultModel('Endereço alterada com sucesso.', data,
False).to_dict()
except Exception as e:
return ResultModel('Não foi possivel alterar o endereço.', False,
True, str(e)).to_dict()
def create(self, playload):
try:
name = playload.get('name')
system_id = playload.get('system_id')
system_repository = SystemRepository()
system_exist = system_repository.get_search_by_params(
{'id': system_id})
if not system_exist['data']['result']:
return ResultModel(f'Não existe sistema com id "{system_id}".',
False, True).to_dict()
system_permission_exist = SystemPermission.query.filter_by(
name=name, system_id=system_id).first()
if system_permission_exist:
return ResultModel(f'A permissão "{name}" já existe.', False,
True).to_dict()
system_permission = SystemPermission(playload)
db.session.add(system_permission)
db.session.commit()
data = marshal(system_permission, system_permission_fields)
return ResultModel('Permissão criado com sucesso.', data,
False).to_dict()
except Exception as e:
return ResultModel('Não foi possivel criar a permissão.', False,
True, str(e)).to_dict()
def get_by_id(self, _id):
try:
users = User.query.get(_id).first()
data = marshal(users, users_fields)
return ResultModel('Pesquisa realizada com sucesso.', data, False).to_dict()
except Exception as e:
return ResultModel('Não foi possivel realizar a pesquisa.', False, True, str(e)).to_dict()
def get_by_id(self, _id, witch_dates=False):
try:
profile_system = ProfileSystem.query.get(_id)
data = marshal(profile_system, profile_system_fields)
return ResultModel('Pesquisa realizada com sucesso.', data, False).to_dict(profile_system)
except Exception as e:
return ResultModel('Não foi possivel realizar a pesquisa.', False, True, str(e)).to_dict()
def create_multiples(self, playload):
try:
profile_system_id = playload.get('profile_system_id')
users_ids = playload.get('users_ids')
system_id = playload.get('system_id')
exist_profile_system_id = ProfileSystemRepository().get_by_id(
profile_system_id)
if not exist_profile_system_id['data']['result']['id']:
err_exist_ps_id = ResultErrorModel().add_error(
'profile_system_id',
f'O ID {profile_system_id} não existe')
return ResultModel(f'ID invalido.', False,
err_exist_ps_id.errors).to_dict()
exist_users = UserRepository().search_multiples_ids(
{'ids': users_ids})
if len(exist_users['data']['result']) != len(users_ids):
err_user = ResultErrorModel()
users_invalid_ids = users_ids.copy()
for user in exist_users['data']['result']:
if user.get('id') in users_invalid_ids:
users_invalid_ids.remove(user.get('id'))
for invalid_id in users_invalid_ids:
err_user.add_error('system_permision_id',
f'O ID {invalid_id} não existe')
return ResultModel(f'Dados invalidos.', False,
err_user.errors).to_dict()
users_is_registered = UserProfileSystem.query\
.filter(UserProfileSystem.user_id.in_(users_ids))\
.filter_by( system_id=system_id, profile_system_id=profile_system_id)
if users_is_registered.count():
users_registered = users_is_registered.all()
for user_registered in users_registered:
if users_ids.__contains__(user_registered.user_id):
users_ids.remove(user_registered.user_id)
if not users_ids:
return ResultModel(
f'Usuarios já foram cadastrados anteriormente.', False,
True).to_dict()
data = []
for user_id in users_ids:
new_user_profile_system = UserProfileSystem(
dict(profile_system_id=profile_system_id,
user_id=user_id,
system_id=system_id))
db.session.add(new_user_profile_system)
data.append(new_user_profile_system)
db.session.flush()
db.session.commit()
data = marshal(data, user_profile_system_fields)
return ResultModel('Sucesso ao inserir usuarios no perfil.', data,
False).to_dict()
except Exception as e:
return ResultModel('Não foi possivel inserir usuarios no perfil.',
False, True, str(e)).to_dict()
def insert(self, data):
try:
track = Track(data)
db.session.add(track)
db.session.commit()
return ResultModel('Sucesso', True, False).to_dict()
except Exception as e:
return ResultModel('Falha ao salvar dados', False, True,
str(e)).to_dict()
def get_all(self, playload):
try:
paginate_filter = playload.get('paginate')
profile_system = ProfileSystem.query.filter().paginate(**paginate_filter)
data_paginate = marshal(profile_system, PAGINATE)
data = marshal(profile_system.items, profile_system_fields)
return ResultModel('Pesquisa realizada com sucesso.', data, False).to_dict(data_paginate)
except Exception as e:
return ResultModel('Não foi possivel realizar a pesquisa.', False, True, str(e)).to_dict()
def search_multiples_ids(self, playload):
try:
ids = playload.get('ids')
users = User.query.filter(User.id.in_(ids)).all()
data_paginate = marshal(users, PAGINATE)
data = marshal(users, users_fields)
return ResultModel('Pesquisa realizada com sucesso.', data, False).to_dict(data_paginate)
except Exception as e:
return ResultModel('Não foi possivel realizar a pesquisa.', False, True, str(e)).to_dict()
def create_address(data_address):
try:
address = Address(data_address)
db.session.add(address)
db.session.commit()
address_result = marshal(address, address_fields)
return ResultModel('Endereço criado com sucesso.', address_result,
False).to_dict()
except Exception as e:
return ResultModel('Não foi possivel criar endereço.', False, True,
str(e)).to_dict()
def get_all_persons(playload):
try:
data_paginate = playload.get('paginate')
persons = Person.query.filter().paginate(**data_paginate)
data_pagination = marshal(persons, PAGINATE)
data = marshal(persons.items, person_fields)
return ResultModel('Pesquisa realizada com sucesso.', data,
False).to_dict(data_pagination)
except Exception as e:
return ResultModel('Não foi possivel realizar a pesquisa.', False,
True, str(e)).to_dict()
def get_by_id(self, playload):
try:
_id = playload.get('id')
track = Track.query.get(_id)
if not track:
return ResultModel('ID não encontrado', False, True).to_dict()
result = marshal(track, TRACK_DTO)
return ResultModel('Sucesso', result, False).to_dict()
except Exception as e:
return ResultModel('Problema ao acessar banco de dados', False,
True, str(e)).to_dict()
def delete(self, _id):
try:
user = User.query.get(_id)
if not user:
return ResultModel('Usuario não existe.', False, True).to_dict()
db.session.delete(user)
db.session.commit()
data = marshal(user, users_fields)
return ResultModel('Usuario deletado com sucesso.', data, False).to_dict()
except Exception as e:
return ResultModel('Não foi possivel deletar o usuario.', False, True, str(e)).to_dict()
def delete(self, _id):
try:
user_profile_system = UserProfileSystem.query.get(_id)
if not user_profile_system:
return ResultModel('Não encontrado.', False, True).to_dict()
db.session.delete(user_profile_system)
db.session.commit()
data = marshal(user_profile_system, user_profile_system_fields)
return ResultModel('Deletado com sucesso.', data, False).to_dict()
except Exception as e:
return ResultModel('Não foi possivel deletar.', False, True,
str(e)).to_dict()
def get_search_by_params(self, playload, witch_dates=False):
try:
paginate_filter = playload.get('paginate') or None
data_filter = playload.get('data')
user_profile_system = UserProfileSystem.query.filter_by(
**data_filter).all()
data = marshal(user_profile_system, user_profile_system_fields)
return ResultModel('Pesquisa realizada com sucesso.', data,
False).to_dict()
except Exception as e:
return ResultModel('Não foi possivel realizar a pesquisa.', False,
True, str(e)).to_dict()
def delete(self, _id):
try:
profile_permission = ProfilePermission.query.get(_id)
if not profile_permission:
return ResultModel('Não encontrado.', False, True).to_dict()
db.session.delete(profile_permission)
db.session.commit()
data = marshal(profile_permission, profile_permission_fields)
return ResultModel('Deletado com sucesso.', data, False).to_dict()
except Exception as e:
return ResultModel('Não foi possivel deletar.', False, True,
str(e)).to_dict()
def get_multiples_profile_system_id(self, playload, witch_dates=False):
try:
profile_system_ids = playload.get('profile_system_ids')
profile_permission = ProfilePermission.query.filter(
ProfilePermission.profile_system_id.in_(
profile_system_ids)).all()
data = marshal(profile_permission, profile_permission_fields)
return ResultModel('Pesquisa realizada com sucesso.', data,
False).to_dict()
except Exception as e:
return ResultModel('Não foi possivel realizar a pesquisa.', False,
True, str(e)).to_dict()
def delete_person(person_id):
try:
person = Person.query.get(person_id)
if person:
db.session.delete(person)
db.session.commit()
data = marshal(person, person_fields)
return ResultModel('Pessoa deletada com sucesso.', data,
False).to_dict()
except Exception as e:
return ResultModel('Não foi possivel deletar a pessoa.', False,
True, str(e)).to_dict()
def get_by_username(self, username, witch_password=False):
try:
schemas_user = users_fields
if witch_password:
schemas_user = users_fields_with_pass
users = User.query.filter_by(username=username).first()
data = marshal(users, schemas_user)
return ResultModel('Pesquisa realizada com sucesso.', data,
False).to_dict()
except Exception as e:
return ResultModel('Não foi possivel realizar a pesquisa.', False,
True, str(e)).to_dict()
def get_search_by_params(self, playload, witch_dates=False):
try:
paginate_filter = playload.get('paginate')
data_filter = playload.get('data')
person = Person.query.filter_by(**data_filter).paginate(
**paginate_filter)
data_paginate = marshal(person, PAGINATE)
data = marshal(person.items, person_fields)
return ResultModel('Pesquisa realizada com sucesso.', data,
False).to_dict(data_paginate)
except Exception as e:
return ResultModel('Não foi possivel realizar a pesquisa.', False,
True, str(e)).to_dict()
def create(self):
contract = CreateProfileSystemAndDependenciesContract()
playload = request.json
if not (contract.validate(playload)):
return ResultModel('Problema nos parametros enviados.', False,
contract.errors).to_dict(), 406
system_id = playload.get('system_id')
repo_prof_sys = ProfileSystemRepository()
profile_system_dto = dict(
system_id=system_id,
name=playload.get('name_profile_system'),
description=playload.get('description_profile_system'))
profile_system_db_result = repo_prof_sys.create(profile_system_dto)
status_result = SetStatusResponseHandler()
if (not profile_system_db_result['data']['result']):
return status_result.default(profile_system_db_result)
profile_system = profile_system_db_result['data']['result']
profile_system_id = profile_system.get('id')
system_permisions_ids = playload.get('system_permisions_ids')
dto_multiple_profile_permission = dict(
profile_system_id=profile_system_id,
system_permisions_ids=system_permisions_ids)
repo_prof_permis = ProfilePermissionRepository()
prof_permis_db_result = repo_prof_permis.create(
dto_multiple_profile_permission)
if (not prof_permis_db_result['data']['result']):
return status_result.default(prof_permis_db_result)
profile_permission = prof_permis_db_result['data']['result']
repo_user_prof_sys = UserProfileSystemRepository()
users_ids = playload.get('users_ids')
user_profile_system_dto = dict(users_ids=users_ids,
profile_system_id=profile_system_id)
user_prof_sys_db_result = repo_user_prof_sys.create_multiples(
user_profile_system_dto)
if (not user_prof_sys_db_result['data']['result']):
return status_result.default(user_prof_sys_db_result)
user_profile_system = user_prof_sys_db_result['data']['result']
data = dict(profile_system=profile_system,
profile_permission=profile_permission,
user_profile_system=user_profile_system)
result = ResultModel(
'Sucesso na criação do perfil de sistema e suas dependencias.',
data, False).to_dict()
return status_result.created(result)
def get_by_id(self, data_dict):
try:
_id = data_dict.get('id')
schema_address = address_fields
address = Address.query.get(_id)
if not address:
return ResultModel('Endereço não encontrado.', False,
True).to_dict()
data = marshal(address, schema_address)
return ResultModel('Pesquisa realizada com sucesso.', data,
False).to_dict()
except Exception as e:
return ResultModel('Não foi possivel realizar a pesquisa.', False,
True, str(e)).to_dict()
def search_multiples_ids(self, playload):
try:
page = playload.get('page')
per_page = playload.get('per_page')
ids = playload.get('ids')
system_permission = SystemPermission.query.filter(
SystemPermission.id.in_(ids)).all()
data_paginate = marshal(system_permission, PAGINATE)
data = marshal(system_permission, system_permission_fields)
return ResultModel('Pesquisa realizada com sucesso.', data,
False).to_dict(data_paginate)
except Exception as e:
return ResultModel('Não foi possivel realizar a pesquisa.', False,
True, str(e)).to_dict()
def delete(self, _id):
try:
system_permission = SystemPermission.query.get(_id)
if not system_permission:
return ResultModel('Permissão não encontrado.', False,
True).to_dict()
db.session.delete(system_permission)
db.session.commit()
data = marshal(system_permission, system_permission_fields)
return ResultModel('Permissão deletado com sucesso.', data,
False).to_dict()
except Exception as e:
return ResultModel('Não foi possivel deletar a permissão.', False,
True, str(e)).to_dict()
def create_user(self):
contract = CreateUserContract()
playload = request.json
if not (contract.validate(playload)):
return ResultModel('Envie todos parametros obrigatorios.', False,
contract.errors).to_dict(), 406
if playload.get('is_admin') and not Admin().is_admin():
return ResultModel(
'Só um administrador pode criar outro administrador.', False,
contract.errors).to_dict(), 406
user = UserRepository()
new_user = user.create(playload)
status_result = SetStatusResponseHandler()
return status_result.created(new_user)
def create(self, username, password, is_admin):
try:
user = User.query.filter_by(username=username).first()
if user:
return ResultModel(f'Usuario "{username}" já existe.', False,
True).to_dict()
user = User(username, password, is_admin)
db.session.add(user)
db.session.commit()
data = marshal(user, users_fields)
return ResultModel('Usuario criado com sucesso.', data,
False).to_dict()
except Exception as e:
return ResultModel('Não foi possivel criar o usuario.', False,
True, str(e)).to_dict()