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()