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