def post(self, *args, **kwargs):
req_data = request.get_json() or None
data, errors, result = None, None, None
schema = PlanetRegistrationSchema()
if req_data is None:
return resp_data_invalid('Planets', [], msg=MSG_INVALID_DATA)
data, errors = schema.load(req_data)
if errors:
return resp_data_invalid('Planets', errors)
try:
model = Planet(**data)
model.save()
except NotUniqueError:
return resp_already_exists('Planets', 'planet')
except ValidationError as e:
return resp_exception('Planets',
msg=MSG_INVALID_DATA,
description=e.__str__())
except Exception as e:
return resp_exception('Planets', description=e.__str__())
schema = PlanetSchema()
result = schema.dump(model)
# statuscode 200
return resp_ok('Planets',
MSG_RESOURCE_CREATED.format('Planet'),
data=result.data)
def patch(self, user_id):
data = user_id or None
if data is None or data is ' ':
return resp_data_invalid('Users', [], msg=MSG_NO_DATA)
try:
user = get_user_by_id(user_id)
user.active = True
user.save()
except DoesNotExist as e:
return resp_does_not_exist('Users', 'Usuário')
except FieldDoesNotExist as e:
return resp_exception('Users', description=e.__str__())
except NotUniqueError:
return resp_already_exists('Users', 'usuário')
except ValidationError as e:
return resp_exception('Users',
msg=MSG_INVALID_DATA,
description=e.__str__()
)
return resp_ok('Users', MSG_RESOURCE_ACTIVE.format('Usuário'))
def delete(self, rf):
# Fetch collaborator by rf
collaborator = get_collaborator_by_rf(rf)
if not isinstance(collaborator, Collaborator):
return collaborator
try:
collaborator.active = False
collaborator.save()
except NotUniqueError:
return resp_already_exists(
'CollaboratorServices',
'colaborador'
)
except ValidationError as e:
return resp_exception(
'CollaboratorServices',
msg=MSG_INVALID_DATA,
description=e.__str__()
)
except Exception as e:
return resp_exception(
'CollaboratorServices',
description=e.__str__()
)
return resp_ok(
'CollaboratorServices',
MSG_RESOURCE_DELETED.format('Colaborador')
)
def delete(self, user_id):
# Busco o usuário na coleção users pelo seu id
user = get_user_by_id(user_id)
# se não for uma instancia do modelo User retorno uma resposta
# da requisição http do flask
if not isinstance(user, User):
return user
try:
user.active = False
user.save()
except NotUniqueError:
return resp_already_exists('Users', 'usuário')
except ValidationError as e:
return resp_exception('Users',
msg=MSG_INVALID_DATA,
description=e.__str__())
except Exception as e:
return resp_exception('Users', description=e.__str__())
return resp_ok('Users', MSG_RESOURCE_DELETED.format('Usuário'))
def post(self, *args, **kwargs):
# Inicializo todas as variaveis utilizadas
req_data = request.get_json() or None
data, errors, result = None, None, None
password, confirm_password = None, None
schema = UserRegistrationSchema()
# Se meus dados postados forem Nulos retorno uma respota inválida
if req_data is None:
return resp_data_invalid('Users', [], msg=MSG_NO_DATA)
password = req_data.get('password', None)
confirm_password = req_data.get('confirm_password', None)
# verifico através de uma função a senha e a confirmação da senha
# Se as senhas não são iguais retorno uma respota inválida
if not check_password_in_signup(password, confirm_password):
errors = {'password': MSG_PASSWORD_DIDNT_MATCH}
return resp_data_invalid('Users', errors)
# Desserialização os dados postados ou melhor meu payload
data, errors = schema.load(req_data)
# Se houver erros retorno uma resposta inválida
if errors:
return resp_data_invalid('Users', errors)
# Crio um hash da minha senha
hashed = hashpw(password.encode('utf-8'), gensalt(12))
# Salvo meu modelo de usuário com a senha criptografada e email em lower case
# Qualquer exceção ao salvar o modelo retorno uma resposta em JSON
# ao invés de levantar uma exception no servidor
try:
data['password'] = hashed
data['email'] = data['email'].lower()
model = User(**data)
model.save()
except NotUniqueError:
return resp_already_exists('Users', 'fornecedor')
except ValidationError as e:
return resp_exception('Users', msg=MSG_INVALID_DATA, description=e)
except Exception as e:
return resp_exception('Users', description=e)
# Realizo um dump dos dados de acordo com o modelo salvo
schema = UserSchema()
result = schema.dump(model)
# Retorno 200 o meu endpoint
return resp_ok(
'Users',
MSG_RESOURCE_CREATED.format('Usuário'),
data=result.data,
)
def post(self, *args, **kwargs):
# Initialize variables
#print(request.json)
req_data = request.get_json(force=True) or None
#print(req_data)
data, errors, result = None, None, None
password, confirm_password = None, None
schema = CollaboratorRegistrationSchema()
# When datas are null
if req_data is None:
return resp_data_invalid('CollaboratorsServices', [], msg=MSG_NO_DATA)
password = req_data.get('password', None)
confirm_password = req_data.pop('confirm_password', None)
req_data['rf'] = random.randint(100000,999999)
# Verify passwords provided
if not check_password_in_signup(password, confirm_password):
errors = {'password': MSG_PASSWORD_WRONG}
return resp_data_invalid('CollaboratorsServices', errors)
# Desserialize data
data, errors = schema.load(req_data)
# Return invalid response when there is a error
if errors:
return resp_data_invalid('CollaboratorsServices', errors)
# Create hash
hashed = hashpw(password.encode('utf-8'), gensalt(12))
# Save the model. If get Exception, return JSON response.
try:
data['password'] = hashed
data['email'] = data['email'].lower()
model = Collaborator(**data)
model.save()
except NotUniqueError:
return resp_already_exists('CollaboratorsServices', 'colaborador')
except ValidationError as e:
return resp_exception('CollaboratorsServices', msg=MSG_INVALID_DATA, description=e)
except Exception as e:
return resp_exception('CollaboratorsServices', description=e)
# Dump data of model
schema = CollaboratorSchema()
result = schema.dump(model)
return resp_ok(
'CollaboratorsServices', MSG_RESOURCE_CREATED.format('Colaborador'), data=result.data,
)
def put(self, user_id):
result = None
schema = UserSchema()
update_schema = UserUpdateSchema()
req_data = request.get_json() or None
email = None
if req_data is None:
return resp_data_invalid('Users', [], msg=MSG_NO_DATA)
user = get_user_by_id(user_id)
if not isinstance(user, User):
return user
# carrega os dados de acordo com o schema de atualização
data, errors = update_schema.load(req_data)
# em caso de erros retorno uma resposta 422 com os erros de
# validação do schema
if errors:
return resp_data_invalid('Users', errors)
email = data.get('email', None)
if email and exists_email_in_users(email, user):
return resp_data_invalid('Users', [{
'email': [MSG_ALREADY_EXISTS.format('usuário')]
}])
try:
# para cada chave dentro do dados do update schema
# atribuimos seu valor
for i in data.keys():
user[i] = data[i]
user.save()
except NotUniqueError:
return resp_already_exists('Users', 'usuário')
except ValidationError as e:
return resp_exception('Users',
msg=MSG_INVALID_DATA,
description=e.__str__())
except Exception as e:
return resp_exception('Users', description=e.__str__())
result = schema.dump(user)
return resp_ok('Users',
MSG_RESOURCE_UPDATED.format('Usuário'),
data=result.data)
def post(self, *args, **kwargs):
'''
Create an user
payload:
{
"name": "Lucas Simon",
"email": "*****@*****.**",
"password": "******"
}
'''
req_data = request.get_json() or None
schema = UserCreateSchema()
if req_data is None:
return resp_form_invalid('Users', [], msg=_MSG312)
data, errors = schema.load(req_data)
if errors:
return resp_form_invalid('Users', errors)
if exists_email_in_database(data.get('email')):
errors = {
'errors': {
'email': [_MSG302]
}
}
return resp_form_invalid('Users', errors)
# TODO: Encrypt password with bcrypt
try:
model = User(**data)
model.save()
except NotUniqueError:
return resp_already_exists('Users', 'usuário')
except ValidationError as e:
return resp_exception('Users', msg=_MSG300, description=e)
except Exception as e:
return resp_exception('Users', description=e)
schema = UserSchema()
result = schema.dump(model)
return resp_ok(
'Users', _MSG200.format('Usuário'), data=result.data
)
def put(self, user_id):
result = None
schema = UserSchema()
update_schema = UserUpdateSchema()
req_data = request.get_json() or None
email = None
if req_data is None:
return resp_data_invalid('Users', [], msg=MSG_NO_DATA)
user = get_user_by_id(user_id)
if not isinstance(user, User):
return user
data, errors = update_schema.load(req_data)
if errors:
return resp_data_invalid('Users', errors)
email = data.get('email', None)
if email and exists_email_in_users(email, user):
return resp_data_invalid(
'Users', [{'email': [MSG_ALREADY_EXISTS.format('usuário')]}]
)
try:
for i in data.keys():
user[i] = data[i]
user.save()
except NotUniqueError:
return resp_already_exists('Users', 'usuário')
except ValidationError as e:
return resp_exception('Users', msg=MSG_INVALID_DATA, description=e.__str__())
except Exception as e:
return resp_exception('Users', description=e.__str__())
result = schema.dump(user)
return resp_ok(
'Users', MSG_RESOURCE_UPDATED.format('Usuário'), data=result.data
)
def save_model(model, resource="Resource", desc="Recurso"):
try:
return model.save()
except NotUniqueError as e:
return resp_already_exists(resource, desc)
except ValidationError as e:
return resp_data_invalid(resource,
msg=MSG_INVALID_DATA,
description=e.__str__())
except Exception as e:
return resp_exception(resource, description=e)
def post(self, *args, **kwargs):
req_data = request.get_json() or None
data, errors, result = None, None, None
senha, confirma_senha = None, None
schema = UserSchema()
if req_data is None:
return resp_data_invalid('Users', [], msg=MSG_NO_DATA)
senha = req_data.get('senha', None)
confirma_senha = req_data.pop('confirma_senha', None)
if not check_password_in_signup(senha, confirma_senha):
errors = {'senha': MSG_PASSWORD_DIDNT_MATCH}
return resp_data_invalid('Users', errors)
data, errors = schema.load(req_data)
if errors:
return resp_data_invalid('Users', errors)
hashed = hashpw(senha.encode('utf-8'), gensalt(12))
try:
data['senha'] = hashed
data['email'] = data['email'].lower()
model = User(**data)
model.save()
except NotUniqueError:
return resp_already_exists('Users', 'usuario')
except ValidationError as e:
return resp_exception('Users', description=str(e),msg=MSG_INVALID_DATA)
except Exception as e:
return resp_exception('Users', description=str(e), msg=MSG_INVALID_DATA)
schema = UserSchema()
result = schema.dump(model)
return resp_ok(
'Users', MSG_RESOURCE_CREATED.format('Usuário'), data=result.data,
)
def put(self, user_id):
result = None
schema = UserSchema(many=True)
update_schema = UserUpdateSchema()
req_data = request.json or None
email = None
if req_data is None:
return resp_invalid_data('Users', {}, msg=MSG_NO_DATA)
confirm_password = req_data.pop('confirm_password')
if not check_password_in_singup(req_data.get('password'),
confirm_password):
errors = {'password': MSG_PASSWORD_DIDNT_MATCH}
return resp_invalid_data('Users', errors)
try:
query = get_user_by_id(user_id)
user = schema.dump(query)
data = update_schema.load(req_data)
except IntegrityError:
return resp_invalid_data('Users', IntegrityError.orig)
email = data.get('email', None)
if email and exists_email_in_user(email, user):
return resp_ok('Users',
{'email': MSG_ALREADY_EXISTS.format('user')})
try:
query.update(request.json)
current_app.db.session.commit()
except IntegrityError as err:
return resp_already_exists('Users', err.orig)
except ValidationError as err:
return resp_exception('Users', description=err.__str__())
except Exception as err:
return resp_exception('Users', description=err.__str__())
result = re.search("'.*'", str(data.keys())).group()
return resp_ok('Users',
MSG_RESOURCE_UPDATED.format('Fields'),
data=result)
def delete(self, planet_id):
planet = get_planet_by_id(planet_id)
try:
planet.delete()
except NotUniqueError:
return resp_already_exists('Planets', 'planet')
except ValidationError as e:
return resp_exception('Planets',
msg=MSG_INVALID_DATA,
description=e.__str__())
except Exception as e:
return resp_exception('Planets', description=e.__str__())
return resp_ok('Planets', MSG_RESOURCE_DELETED.format('Planet'))
def get(self, user_id):
user = get_user_by_id(user_id)
if not isinstance(user, User):
return user
try:
user.ativo = False
user.save()
except NotUniqueError:
return resp_already_exists('Users', 'usuário')
except ValidationError as e:
return resp_exception('Users', msg=MSG_INVALID_DATA, description=e.__str__())
except Exception as e:
return resp_exception('Users', description=e.__str__())
return resp_ok('Users', MSG_RESOURCE_INATIVO.format('Usuário'))
def post(self, *args, **kwargs):
# Inicializo todas as variaveis utilizadas
req_data = request.get_json() or None
data, errors, result = None, None, None
# password, confirm_password = None, None
schema = PlanetRegistrationSchema()
# Se meus dados postados forem Nulos retorno uma respota inválida
if req_data is None:
return resp_data_invalid('Planets', [], msg=MSG_INVALID_DATA)
# Desserialização os dados postados ou melhor meu payload
data, errors = schema.load(req_data)
# Se houver erros retorno uma resposta inválida
if errors:
return resp_data_invalid('Planets', errors)
try:
model = Planet(**data)
model.save()
except NotUniqueError:
return resp_already_exists('Planets', 'local')
except ValidationError as e:
return resp_exception('Planets', msg=MSG_INVALID_DATA, description=e.__str__())
except Exception as e:
return resp_exception('Planets', description=e.__str__())
# Realizo um dump dos dados de acordo com o modelo salvo
schema = PlanetSchema()
result = schema.dump(model)
# Retorno 200 o meu endpoint
return resp_ok(
'Planets', MSG_RESOURCE_CREATED.format('Planet'), data=result.data
)
def delete(self, user_id):
user = get_user('Users', object_id=user_id)
if not isinstance(user, User):
return user
user.active = False
try:
user.save()
except NotUniqueError as e:
return resp_already_exists('Users', 'usuário')
except ValidationError as e:
return resp_exception(
'Users', msg=_MSG300, description=e
)
except Exception as e:
return resp_exception('Users', description=e)
return resp_ok('Users', _MSG203.format('Usuário'))
def put(self, user_id):
req_data = request.get_json() or None
if req_data is None:
return resp_form_invalid('Users', [], msg=_MSG312)
schema = UpdateUserSchema()
user = get_user('Users', object_id=user_id)
if not isinstance(user, User):
return user
data, errors = schema.load(req_data)
if errors:
return resp_form_invalid('Users', errors)
try:
for i in data.keys():
user[i] = data[i]
user.save()
except NotUniqueError as e:
return resp_already_exists('Users', 'usuário')
except ValidationError as e:
return resp_exception('Users', msg=_MSG300, description=e)
except Exception as e:
return resp_exception('Users', description=e)
schema = UserSchema()
result = schema.dump(user)
return resp_ok(
'Users', _MSG202.format('Usuário'), data=result.data
)
def register_user(payload):
if payload is None:
return resp_data_invalid('Users', [], msg=MSG_NO_DATA)
schema = UserRegistrationSchema()
try:
data = schema.load(payload)
except ValidationError as error:
return resp_data_invalid('Users', error.messages)
password = payload.get('password', None)
data['password'] = hashpw(password.encode('utf-8'), gensalt(12))
data['email'] = data['email'].lower()
try:
full_name, password, email = data['full_name'], data['password'], data[
'email']
user = User(full_name=full_name, password=password, email=email)
save_changes(user)
except IntegrityError:
return resp_already_exists('Users', "usuário")
except Exception as e:
return resp_exception('Users', description=e)
schema = UserSchema()
result = schema.dump(user)
extras = {
'token': create_access_token(identity=email),
'refresh': create_refresh_token(identity=email)
}
return resp_ok('Users',
MSG_RESOURCE_CREATED.format('Usuário'),
data=result,
**extras)
def put(self, planet_id):
result = None
schema = PlanetSchema()
update_schema = PlanetUpdateSchema()
req_data = request.get_json() or None
planet = get_planet_by_id(planet_id)
data, errors = update_schema.load(req_data)
if errors:
return resp_data_invalid('Planets', errors)
try:
for i in data.keys():
planet[i] = data[i]
planet.save()
except NotUniqueError:
return resp_already_exists('Planets', 'planet')
except ValidationError as e:
return resp_exception('Planets',
msg=MSG_INVALID_DATA,
description=e.__str__())
except Exception as e:
return resp_exception('Planets', description=e.__str__())
result = schema.dump(planet)
return resp_ok('Planets',
MSG_RESOURCE_UPDATED.format('Planet'),
data=result.data)
def test_resp_already_exists_raises_error():
with pytest.raises(ValueError):
resp_already_exists(None, None)
def test_resp_already_exists_response_status_code_400():
resp = resp_already_exists('pytest', 'Some description')
assert resp.status_code == 400
def test_resp_already_exists_response():
description = 'Some description'
resp = resp_already_exists('pytest', description)
message = resp.json.get('message')
assert message == MSG_ALREADY_EXISTS.format(description)
def put(self, user_id):
result = None
schema = UserSchema()
update_schema = UserUpdateSchema()
req_data = request.get_json() or None
email = None
current_user = get_user_by_email(get_jwt_identity())
if not isinstance(current_user, User):
return current_user
if not (current_user.is_active()) and current_user.is_admin():
return resp_notallowed_user('Users')
# Valido se o payload está vazio
if req_data is None:
return resp_data_invalid('Users', [], msg=MSG_NO_DATA)
# Busco o usuário na coleção users pelo seu id
user = get_user_by_id(user_id)
# se não for uma instancia do modelo User retorno uma resposta
# da requisição http do flask
if not isinstance(user, User):
return user
# carrego meus dados de acordo com o schema de atualização
data, errors = update_schema.load(req_data)
# em caso de erros retorno uma resposta 422 com os erros de
# validação do schema
if errors:
return resp_data_invalid('Users', errors)
email = data.get('email', None)
# Valido se existe um email na coleção de usuários
if email and exists_email_in_users(email, user):
return resp_data_invalid('Users', [{
'email': [MSG_ALREADY_EXISTS.format('usuário')]
}])
try:
# para cada chave dentro do dados do update schema
# atribuimos seu valor
for i in data.keys():
user[i] = data[i]
user.save()
except NotUniqueError:
return resp_already_exists('Users', 'usuário')
except ValidationError as e:
return resp_exception('Users',
msg=MSG_INVALID_DATA,
description=e.__str__())
except Exception as e:
return resp_exception('Users', description=e.__str__())
result = schema.dump(user)
return resp_ok('Users',
MSG_RESOURCE_UPDATED.format('Usuário'),
data=result.data)
def post(self, user_id, *args, **kwargs):
'''
Create settings forecast notification
payload:
{
"address": "Londres, UK",
"period": {
"start": "08:00",
"end": "19:00"
},
"days": {
"sunday": true,
"monday": true,
"tuesday": true,
"wednesday": true,
"thursday": true,
"friday": true,
"saturday": true
},
"notification": "07:00"
}
'''
user = get_user('Forecasts Settings', object_id=user_id)
if not isinstance(user, User):
return user
req_data = request.get_json() or None
schema = ForecastSettingsSchema()
if req_data is None:
return resp_form_invalid('Forecasts Settings', [], msg=_MSG312)
req_data['user_id'] = '{}'.format(user_id)
data, errors = schema.load(req_data)
if errors:
return resp_form_invalid('Forecasts Settings', errors)
try:
model = Forecast(**data)
model.save()
except NotUniqueError:
return resp_already_exists('Forecasts Settings', 'usuário')
except ValidationError as e:
return resp_exception('Forecasts Settings',
msg=_MSG300,
description=e)
except Exception as e:
return resp_exception('Forecasts Settings', description=e)
result = schema.dump(model)
return resp_ok('Forecasts Settings',
_MSG200.format('Configurações do clima'),
data=result.data)
def post(self, *args, **kwargs):
# Inicializo todas as variaveis utilizadas
req_data = request.get_json() or None
data, errors, result = None, None, None
password, confirm_password = None, None
schema = UserRegistrationSchema()
# Se meus dados postados forem Nulos retorno uma respota inválida
if req_data is None:
return resp_data_invalid('Users', [], msg=MSG_NO_DATA)
password = req_data.get('password', None)
confirm_password = req_data.pop('confirm_password', None)
# verifico através de uma função a senha e a confirmação da senha
# Se as senhas não são iguais retorno uma respota inválida
if not check_password_in_signup(password, confirm_password):
errors = {'password': MSG_PASSWORD_WRONG}
return resp_data_invalid('Users', errors)
# Desserialização os dados postados ou melhor meu payload
data, errors = schema.load(req_data)
# Se houver erros retorno uma resposta inválida
if errors:
return resp_data_invalid('Users', errors)
# Crio um hash da minha senha
hashed = hashpw(password.encode('utf-8'), gensalt(12))
# Salvo meu modelo de usuário com a senha criptografada e email em
# lower case Qualquer exceção ao salvar o modelo retorno uma resposta
# em JSON ao invés de levantar uma exception no servidor
try:
data['password'] = hashed
data['email'] = data['email'].lower()
model = User(**data)
model.save()
except NotUniqueError:
return resp_already_exists('Users', 'usuário')
except ValidationError as e:
return resp_exception('Users', msg=MSG_INVALID_DATA, description=e)
# Realizo um dump dos dados de acordo com o modelo salvo
schema = UserSchema()
result = schema.dump(model)
if current_app.config.get('ENABLE_AMQP'):
try:
# exp = datetime.utcnow() + relativedelta(days=2)
# payload = {'id': '{}'.format(model.id), 'exp':exp}
producer = signup.ProducerSignUp(
current_app.
config.
get('SIGNUP_QUEUE')
)
producer.publish(result.data)
except Exception as e:
return resp_exception('Users', description=MSG_EXCEPTION)
# Retorno 200 o meu endpoint
return resp_ok(
'Users', MSG_RESOURCE_CREATED.format('Usuário'), data=result.data,
)
