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