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 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 test_responses_ok(self, client):
resp = client.post(
self.ENDPOINT,
data=dumps(dict(full_name='teste', email='*****@*****.**', password='******')),
content_type='application/json'
)
assert resp.status_code == 200
assert resp.json.get('message') == MSG_RESOURCE_CREATED.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 post(self, *args, **kwargs):
# Inicializa todas as variaveis utilizadas
req_data = request.get_json() or None
data, errors, 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', None)
confirm_password = req_data.pop('confirm_password', None)
# Verificacao da senha e confirmacao de senha
if not check_password_in_signup(password, confirm_password):
errors = {'password': MSG_PASSWORD_DIDNT_MATCH}
return resp_data_invalid('Users', errors)
# Desserializacao dos dados pelo UserregistratioSchema
try:
data = schema.load(req_data)
# Se hover erros retorna resposta invalida
except ValidationError as err:
print(err.message)
return resp_data_invalid('Users', errors=err.message)
hashed = hashpw(password.encode('utf-8'), gensalt(12))
# Salvar o modelo de usuario com a senha criptografada e o email
# em lowercase. Qualquer erro eh retornado uma resposta de erro json
# ao inves 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(resource='Users',
description=str(e),
msg=MSG_INVALID_DATA)
except Exception as e:
return resp_exception('Users', description=str(e))
# dump dos dados de acordo com o modelo salvo
schema = UserSchema()
result = schema.dump(model)
return resp_ok('Users',
MSG_RESOURCE_CREATED.format('Usuário'),
data=result)
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):
# 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):
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 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):
# 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,
)
def post(self, *args, **kwargs):
# Inicializo todas as variaveis utilizadas
req_data = request.get_json() or None
dict_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)
document = req_data.get('cpf', None)
if not check_document(document):
errors = {'cpf': MSG_DOCUMENT_NULL}
return resp_data_invalid('Users', errors)
if not exists_cpf_in_users(document):
errors = {'cpf': MSG_DOCUMENT_ALREAD_EXIST}
return resp_data_invalid('Users', errors)
if not exists_email_in_users(document):
errors = {'email': MSG_EMAIL_ALREAD_EXIST}
return resp_data_invalid('Users', errors)
# 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)
if not check_password_is_same(password, confirm_password):
errors = {'password': MSG_PASSWORD_NOT_SAME}
return resp_data_invalid('Users', errors)
dict_data = {
"full_name": req_data.get('full_name', None),
"email": req_data.get('email', None),
"password": req_data.get('password', None),
"cpf": req_data.get('cpf', None),
"active": req_data.get('active', None)
}
data = json.dumps(dict_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:
dict_data['password'] = hashed
dict_data['email'] = dict_data['email'].lower()
model = User(**dict_data)
model.save()
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,
)