def get_all_users(self):
user = UserRepository()
playload = Paginate().include_paginate_args_playload(request)
users = user.get_all(playload)
status_result = SetStatusResponseHandler()
return status_result.default(users)
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 get_by_id(self, _id):
contract = GetByIdUserContract()
if not (contract.validate(_id)):
return ResultModel('Envie todos parametros obrigatorios.', False,
contract.errors).to_dict(), 406
repository = UserRepository()
user = repository.get_by_id(_id)
return user
def get_by_id(self, _id):
contract = GetByIdUserContract()
if not (contract.validate(_id)):
return ResultModel('Envie todos parametros obrigatorios.', False,
contract.errors).to_dict(), 406
repository = UserRepository()
user = repository.get_by_id(_id)
status_result = SetStatusResponseHandler()
return status_result.default(user)
def delete_user(self):
contract = DeleteUserContract()
playload = request.json
if not (contract.validate(playload)):
return ResultModel('Envie todos parametros obrigatorios.', False,
contract.errors).to_dict(), 406
repository = UserRepository()
user = repository.delete(playload.get('id'))
return user
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
user = UserRepository()
new_user = user.create(playload.get('username'),
playload.get('password'),
playload.get('is_admin'))
return new_user
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 update_user(self):
contract = UpdateUserContract()
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 editar outro administrador.', False,
contract.errors).to_dict(), 406
repository = UserRepository()
user = repository.update(playload.get('id'), playload.get('username'),
playload.get('password'),
playload.get('is_admin'))
status_result = SetStatusResponseHandler()
return status_result.default(user)
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 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 get_by_username(self, username):
repository = UserRepository()
user = repository.get_by_username(username)
return user
def get_all_users(self):
user = UserRepository()
users = user.get_all()
return users
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