def post(self, *args, **kwargs):
"""
Rota para login na API
"""
req_data = request.get_json() or None
user = None
login_schema = LoginSchema()
user_schema = UserSchema(exclude=["address"])
if req_data is None:
return resp_data_invalid("Users", [], msg=MSG_NO_DATA)
try:
data = login_schema.load(req_data)
except MarshmallowValidationError as e:
return resp_data_invalid("Users", desc=e.__str__())
user = get_user_by_user_name(data["user_name"])
if not isinstance(user, User):
return user
if checkpw(
data.get("password").encode("utf-8"),
user.password.encode("utf-8")):
extras = {
"token": create_access_token(identity=user.user_name),
"refresh": create_refresh_token(identity=user.user_name)
}
result = user_schema.dump(user)
return resp_ok("Auth", MSG_TOKEN_CREATED, data=result, **extras)
return resp_notallowed_user("Auth")
def post(self, *args, **kwargs):
req_data = request.get_json() or None
data, errors, result = None, None, None
schema = CarSchema()
if req_data is None:
return resp_data_invalid('Car', [], MSG_NO_DATA)
data, errors = schema.load(req_data)
if errors:
return resp_data_invalid('Car', [], MSG_INVALID_DATA)
try:
model = Car(**data)
model.save()
schema = CarSchema()
result = schema.dump(model)
return resp_ok('Car',
MSG_RESOURCE_CREATED.format('Car'),
data=result.data)
except Exception as e:
return resp_exception('Car', 'Exception to save car',
MSG_EXCEPTION)
def put(self, username):
req_data = request.get_json() or None
user = get_user_by_user_name(username)
if not isinstance(user, User):
return user
current_password = req_data.get("current_password")
new_password = req_data.get("new_password")
confirm_password = req_data.pop("confirm_password")
if not checkpw(current_password.encode("utf-8"),
user["password"].encode("utf-8")):
return resp_data_invalid(
"Users", "Senha atual não confere com a senha cadastrada")
if not check_password_in_signup(new_password, confirm_password):
errors = {"password": MSG_CHECK_PASSWORD_FAILED}
return resp_data_invalid("Users", errors)
new_pass_hashed = hashpw(new_password.encode("utf-8"),
gensalt(12)).decode("utf-8")
user["password"] = new_pass_hashed
save_result = save_model(user, "Users", "Usuário")
if not isinstance(save_result, User):
return save_result
return resp_ok("User",
MSG_PASSWORD_CHANGED,
data={"user_name": username})
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 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):
'''
Route to do login in API
'''
req_data = request.get_json() or None
user = None
login_schema = LoginSchema()
schema = UserSchema()
if req_data is None:
return resp_data_invalid('Users', [], msg=MSG_NO_DATA)
data, errors = login_schema.load(req_data)
if errors:
return resp_data_invalid('Users', errors)
# Buscamos nosso usuário pelo email
user = get_user_by_email(data.get('email'))
# Em caso de exceção ou não é uma instancia do Modelo de User
# retornamos a resposta
if not isinstance(user, User):
return user
# Verificamos se o usuário está ativo na plataforma. Se não ele
# não podera autenticar e não ter acesso a nada
if not user.is_active():
return resp_notallowed_user('Auth')
# Conferimos a senha informada no payload de dados com a senha cadastrada
# em nosso banco.
if checkpw(
data.get('password').encode('utf-8'),
user.password.encode('utf-8')):
# Chamamos os metodos para criar os tokens passando como identidade
# o email do nosso usuario
extras = {
'token': create_access_token(identity=user.email),
'refresh': create_refresh_token(identity=user.email)
}
result = schema.dump(user)
return resp_ok('Auth',
MSG_TOKEN_CREATED,
data=result.data,
**extras)
return resp_notallowed_user('Auth')
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 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 post(self, *args, **kwargs):
req_data = request.get_json() or None
user = None
dict_data, errors, result = None, None, None
login_schema = LoginSchema()
schema = UserSchema()
if req_data is None:
return resp_data_invalid('Users', [], msg=MSG_NO_DATA)
# data, errors = login_schema.load(req_data)
dict_data = {
"email": req_data.get('email', None),
"password": req_data.get('password', None)
}
data = json.dumps(dict_data)
if errors:
return resp_data_invalid('Users', errors)
# Buscando o usuário pelo email
user = get_user_by_email(dict_data.get('email'))
if not isinstance(user, User):
return user
# Verificando se o usuário está ativo e possui permissão
if not user.is_active():
return resp_notallowed_user('Auth')
if checkpw(dict_data.get('password').encode('utf-8'), user.password.encode('utf-8')):
extras = {
'token': create_access_token(identity=user.email),
'refresh': create_refresh_token(identity=user.email)
}
result = schema.dump(user)
return resp_ok(
'Auth', MSG_TOKEN_CREATED, data=result, **extras
)
return resp_notallowed_user('Auth')
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 post(self, *args, **kwargs):
req_data = request.get_json() or None
dict_order_data, errors, result = None, None, None
password, confirm_password = None, None
schema = OrderSchema(many=True)
if req_data is None:
return resp_data_invalid('order', [], msg=MSG_NO_DATA)
document = req_data.get('cpf_dealer', None)
value = req_data.get('order_values', None)
dict_order_data = {
"order_values": req_data.get('order_values', None),
"cpf_dealer": req_data.get('cpf_dealer', None)
}
if errors:
return resp_data_invalid('order', errors)
# try:
dict_order_data['order_code'] = generateUUID(None)
dict_order_data['order_status'] = check_approved_dealer(document)
dict_order_data['cashback'] = cashback_percentage(value)
dict_order_data['cashback_values'] = calculate_value_cashback(
value, dict_order_data['cashback'])
model = OrderModel(**dict_order_data)
model.save()
# except ValidationError as e:
# return resp_exception('order', msg=MSG_INVALID_DATA, description=e)
# except Exception as e:
# return resp_exception('order', description=e)
schema = OrderSchema()
result = schema.dump(model)
return resp_ok(
'order',
MSG_RESOURCE_CREATED.format('Order'),
data=result,
)
def post(self, *args, **kwargs):
payload = request.get_json() or None
login_schema = LoginSchema()
schema = UserSchema()
if payload is None:
return resp_data_invalid('Users', [], msg=MSG_NO_DATA)
try:
data = login_schema.load(payload)
except ValidationError as error:
return resp_data_invalid('Users', error.messages)
user = get_user_by_email(data.get('email'))
# if not instance of User return response error
if not isinstance(user, User):
log.info('%s failed to log in, email not found', data.get('email'))
return user
if not user.is_active:
log.info('%s failed to log in, inactive user', user.email)
return resp_notallowed_user('Auth')
# trick for test pass
password = user.password
if isinstance(password, str):
password = password.encode('utf-8')
if checkpw(data.get('password').encode('utf-8'), password):
extras = {
'token': create_access_token(identity=user.email),
'refresh': create_refresh_token(identity=user.email)
}
result = schema.dump(user)
log.info('%s logged in successfully', user.email)
return resp_ok('Auth', MSG_TOKEN_CREATED, data=result, **extras)
log.info('%s failed to log in', user.email)
return resp_authenticated_user('Auth')
def post(self):
req_data = request.get_json() or None
schema = UserSchema()
if req_data is None:
return resp_data_invalid('Login', [], msg=MSG_NO_DATA)
data, errors = schema.load(req_data)
if errors:
return resp_data_invalid('Login', errors)
try:
usuarioList = UsuarioModel.objects.get(cpf=data['cpf'],
password=data['password'])
return resp_ok('Login', MSG_SUCCESS,
json.loads(usuarioList.to_json()))
except DoesNotExist:
return resp_does_not_exist('Login', MSG_PASSWORD_OR_CPF_INVALID)
except Exception as e:
return resp_exception('Login', description=e.__str__())
def post(self, *args, **kwargs):
req_data = request.get_json() or None
schema = TriagemSchema()
if req_data is None:
return resp_data_invalid('Triagem', [], msg=MSG_NO_DATA)
data, errors = schema.load(req_data)
if errors:
return resp_data_invalid('Triagem', errors)
try:
triagem = TriagemModel(**data)
triagem.save()
ListaEsperaModel.objects.get(cpf=data['cpf']).delete()
ListaEsperaModel.save()
return resp_ok('Triagem', MSG_SUCCESS, {'valido': True})
except Exception as e:
return resp_exception('Triagem', description=e.__str__())
def post(self, *args, **kwargs):
req_data = request.get_json() or None
user = None
login_schema = LoginSchema()
schema = UserSchema()
if req_data is None:
return resp_data_invalid('Users', [], msg=MSG_NO_DATA)
data, errors = login_schema.load(req_data)
if errors:
return resp_data_invalid('Users', errors)
user = get_user_by_email(data.get('email'))
if not isinstance(user, User):
return user
if not user.is_active():
return resp_notallowed_user('Auth')
if checkpw(
data.get('senha').encode('utf-8'), user.senha.encode('utf-8')):
extras = {
'token': create_access_token(identity=user.email),
'refresh': create_refresh_token(identity=user.email)
}
result = schema.dump(user)
return resp_ok('Auth',
MSG_TOKEN_CREATED,
data=result.data,
**extras)
return resp_notallowed_user('Auth')
def put(self, username):
schema = UserSchema()
up_schema = UserUpdateSchema()
req_data = request.get_json() or None
user = get_user_by_user_name(username)
if not isinstance(user, User):
return user
try:
user_up = up_schema.load(req_data, unknown=EXCLUDE)
except MarshmallowValidationError as e:
return resp_data_invalid("Users", e.messages)
if user_up.get("user_name") and user_up.get("user_name") != username:
return resp_data_invalid("Users",
{"user_name": user_up.get("user_name")},
"Nao pode alterar o nome de usuário")
try:
for k, v in user_up.items():
if k == "address":
for k_addr, v_addr in v.items():
user["address"][k_addr] = v_addr
else:
user[k] = v
except Exception as e:
return resp_exception("Users-Aqui", description=e.__str__())
save_result = save_model(user, "Users", "Usuário")
if not isinstance(save_result, User):
return save_result
result = schema.dump(save_result)
return resp_ok("Users",
MSG_RESOURCE_UPDATED.format("Usuário", username),
data=result)
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 post(self, *args, **kwargs):
# Initialize variables
req_data = request.get_json(force=True) or None
data, errors, result = None, None, None
schema = PointRegistrationSchema()
# When datas are null
if req_data is None:
return resp_data_invalid('PointsServices', [], msg=MSG_NO_DATA)
collaborator = get_collaborator_by_rf(rf=req_data['rf'])
# Desserialize data
data, errors = schema.load(req_data)
# Return invalid response when there is a error
if errors:
return resp_data_invalid('PointsServices', errors)
# Save the model. If get Exception, return JSON response.
try:
model = Point(**data)
model.save()
except ValidationError as e:
return resp_exception('PointsServices', msg=MSG_INVALID_DATA, description=e)
except Exception as e:
return resp_exception('PointsServices', description=e)
# Dump data of model
schema = PointSchema()
result = schema.dump(model)
return resp_ok(
'PointsServices', MSG_RESOURCE_CREATED.format('Ponto'), data=result.data,
)
def post(self, *args, **kwargs):
req_data = request.get_json() or None
data, erros, result = None, None, None
password, confirm_password = None, None
schema = UserRegistrationSchema()
if req_data is None:
return resp_data_invalid("Users", [], msg=MSG_NO_DATA)
password = req_data.get("password")
confirm_password = req_data.pop("confirm_password")
if not check_password_in_signup(password, confirm_password):
errors = {"password": MSG_CHECK_PASSWORD_FAILED}
return resp_data_invalid("Users", errors)
try:
data = schema.load(req_data)
except MarshmallowValidationError as e:
return resp_data_invalid("Users", e.messages)
hashed = hashpw(password.encode("utf-8"), gensalt(12)).decode("utf-8")
data["password"] = hashed
data["email"] = data["email"].lower()
model = User(**data)
print(data)
save_result = save_model(model, "Users", "Usuário")
if not isinstance(save_result, User):
return save_result
schema = UserSchema()
result = schema.dump(model)
return resp_ok("Users",
MSG_RESOURCE_CREATED.format("Usuário"),
data=result)
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 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):
req_data = request.get_json() or None
schema = PacientSchema()
if req_data is None:
return resp_data_invalid('Cadastro de Paciente', [],
msg=MSG_NO_DATA)
data, errors = schema.load(req_data)
if errors:
return resp_data_invalid('Cadastro de Paciente', errors)
try:
model = PacienteModel.objects.get(cpf=data['cpf'])
print(model)
# PacienteModel.update({'_id':mongo_id}, {"$set": post}, upsert=False)
# pacient = PacienteModel(**data)
# pacient.save()
return resp_ok('Cadastro de Paciente', MSG_SUCCESS,
json.loads(model.to_json()))
except Exception as e:
return resp_exception('Cadastro de Paciente',
description=e.__str__())
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_data_invalid_response():
resp = resp_data_invalid('pytest', {})
message = resp.json.get('message')
assert message == MSG_INVALID_DATA
def test_resp_data_invalid_response_status_code_422():
resp = resp_data_invalid('pytest', {})
assert resp.status_code == 422
def test_resp_data_invalid_raises_error():
with pytest.raises(ValueError):
resp_data_invalid(None, {})
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, *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,
)
