def put(self, id):
username, first_name, last_name, is_active = self.update_params()
user = User.query.filter(User.id == id).first()
if user is not None:
if username:
User.query.filter_by(id=id).update({'username': username})
if first_name:
User.query.filter_by(id=id).update({'first_name': first_name})
if last_name:
User.query.filter_by(id=id).update({'last_name': last_name})
if is_active:
User.query.filter_by(id=id).update({'is_active': is_active})
db.session.commit()
user = User.query.filter(User.id == id).first()
db.session.commit()
user_json = User.serialize(user)
response = BasicSchema(result=user_json,
status_code=HTTPStatus.CREATED)
return response.make_response(BasicResponseSchema().dump(response))
else:
raise BasicError(message='Users not found',
status=HTTPStatus.NOT_FOUND)
def get(self, id):
try:
user = User.query.filter_by(id=id).first()
user_json = User.serialize(user)
response = BasicSchema(result=user_json)
return BasicResponseSchema().dump(response)
except Exception as e:
raise BasicError(message='User not found',
status=HTTPStatus.NOT_FOUND)
def delete(self, id):
user = User.query.filter(User.id == id).first()
if user is not None:
User.query.filter(User.id == id).delete()
db.session.commit()
return '', HTTPStatus.NO_CONTENT
else:
raise BasicError(message='User not found',
status=HTTPStatus.NOT_FOUND)
def delete(self, id):
post = Post.query.filter(Post.id == id).first()
if post is not None:
Post.query.filter(Post.id == id).delete()
db.session.commit()
return '', HTTPStatus.NO_CONTENT
else:
raise BasicError(message='Post not found',
status=HTTPStatus.NOT_FOUND)
def get(self, id):
try:
post = Post.query.filter_by(id=id).first()
post_json = Post.serialize(post)
response = BasicSchema(result=post_json)
return BasicResponseSchema().dump(response)
except Exception as e:
raise BasicError(message='Post not found',
status=HTTPStatus.NOT_FOUND)
def delete(self, userId):
"""delete specific user posts"""
if Post.query.filter(Post.userId == userId).count():
Post.query.filter(Post.userId == userId).delete()
db.session.commit()
return '', HTTPStatus.NO_CONTENT
else:
raise BasicError(message='Users not found',
status=HTTPStatus.NOT_FOUND)
def auth_error(status):
message = 'Unauthorized Access' if status == 401 else 'Forbidden'
basic_error = BasicError(message=message, status=status)
basic_response = BasicSchema(error=basic_error)
response = jsonify(BasicResponseSchema().dump(basic_response))
response.status_code = basic_error.status
logger.warning(f'Error was occurred: {basic_error}')
return response
def error_handler(error):
basic_error = error if isinstance(error, BasicError) \
else BasicError(message='Internal Server Error')
basic_response = BasicSchema(error=basic_error)
response = jsonify(BasicResponseSchema().dump(basic_response))
response.status_code = basic_error.status
logger.warning(f'Error was occurred: {error}')
return response
def get(self, userId):
"""viewing posts of a specific user"""
if Post.query.filter(Post.userId == userId).count():
posts = Post.query.filter(Post.userId == userId)
posts_json = [Post.serialize(q) for q in posts]
response = BasicSchema(result=posts_json)
return BasicResponseSchema().dump(response)
else:
raise BasicError(message='Posts not found',
status=HTTPStatus.NOT_FOUND)
def put(self, id):
title, body, userId = self.update_params()
post = Post.query.filter(Post.id == id).first()
if post is not None:
if title:
Post.query.filter_by(id=id).update({'title': title})
if body:
Post.query.filter_by(id=id).update({'body': body})
if userId:
Post.query.filter_by(id=id).update({'userId': userId})
db.session.commit()
post = Post.query.filter(Post.id == id).first()
db.session.commit()
post_json = Post.serialize(post)
response = BasicSchema(result=post_json)
return BasicResponseSchema().dump(response)
else:
raise BasicError(message='Post not found',
status=HTTPStatus.NOT_FOUND)