def get_post_comments(user, post_id):
post = Post.find_by_id(post_id)
if not post:
return not_found('Post not found.')
cursor = request.args.get('cursor')
items_per_page = current_app.config['ITEMS_PER_PAGE']
nextCursor = None
query = ''
if cursor == '0':
query = post.comments.order_by(
Post.created_on.desc()).limit(items_per_page + 1).all()
else:
cursor = urlsafe_base64(cursor, from_base64=True)
query = post.comments.order_by(Post.created_on.desc()).filter(
Post.created_on < cursor).limit(items_per_page + 1).all()
if len(query) > items_per_page:
nextCursor = urlsafe_base64(query[items_per_page -
1].created_on.isoformat())
comments = []
for c in query[:items_per_page]:
comment = c.to_dict(user)
comment['parent'] = PostSchema(only=(
'id',
'body',
'author',
)).dump(c.parent)
comments.append(comment)
return {'data': comments, 'nextCursor': nextCursor}
def update_like(user, post_id):
post = Post.find_by_id(post_id)
if not post:
return not_found('Post not found')
try:
if post.is_liked_by(user):
post.likes.remove(user)
db.session.delete(
Notification.find_by_attr(subject='like', item_id=post.id))
else:
post.likes.append(user)
db.session.add(
user.add_notification('like',
item_id=post.id,
id=post.author.id,
post_id=post.id))
post.save()
except (exc.IntegrityError, ValueError):
db.session.rollback()
return server_error('Something went wrong, please try again.')
else:
return jsonify(post.to_dict(user))
def get_profile(user, username):
user = User.find_by_identity(username)
if user:
return jsonify(UserSchema().dump(user))
return not_found('User not found.')
def delete_user(id):
try:
user = User.find_by_id(id)
if user is None:
return not_found('User does not exist.')
user.delete()
return jsonify({'message': 'Successfully deleted user.'})
except Exception as error:
return jsonify({'message': error})
def get_post(user, post_id):
try:
print(post_id)
post = Post.find_by_id(post_id)
if not post:
return not_found('Post not found')
except Exception:
return server_error('Something went wrong, please try again.')
else:
return jsonify(PostSchema().dump(post))
def delete_group(id):
try:
group = Group.find_by_id(id)
if not group:
return not_found('Group does not exist.')
group.delete()
return {'message': 'Successfully deleted group.'}
except Exception as error:
return {'message': error}
def create_message(user):
req_data = request.get_json()
user_id = request.args.get('user', None, int)
if not req_data:
return bad_request("No request data provided")
try:
a_user = User.find_by_id(user_id)
if not a_user:
return not_found('User not found.')
chat = user.get_chat(a_user)
if not chat:
chat = Chat(user1_id=user.id, user2_id=a_user.id)
db.session.add(chat)
db.session.commit()
message = Message()
message.body = json.dumps(req_data.get('body'))
message.author_id = user.id
message.created_on = datetime.utcnow()
message.chat_id = chat.id
db.session.add(message)
lrm = LastReadMessage.find_by_pk(user.id, chat.id)
if lrm:
lrm.timestamp = datetime.utcnow()
else:
lrm = LastReadMessage()
lrm.user_id = user.id
lrm.chat_id = chat.id
lrm.timestamp = message.created_on
db.session.add(lrm)
user.add_notification(subject='message',
item_id=message.id,
id=a_user.id)
user.save()
except (IntegrityError, ProgrammingError, AttributeError, ValueError) as e:
db.session.rollback()
print(e)
return server_error('Something went wrong, please try again.')
else:
response = jsonify(MessageSchema().dump(message))
response.status_code = 201
response.headers['Location'] = url_for('messages.get_messages',
user=user,
user_id=a_user.id)
return response
def get_tag(user):
tag_name = request.args.get('name')
try:
tag = Tag.query.filter_by(name=tag_name).first()
except Exception as e:
db.session.rollback()
print(e)
return server_error('An unexpected error occured.')
if tag:
return tag.to_dict(user)
return not_found(f'Tag with name "{tag_name}" does not exist.')
def get_profile(user, username):
a_user = Profile.find_by_username(username).user
if a_user:
profile = UserSchema(only=(
'id',
'profile',
'followers',
'following',
)).dump(a_user)
if user.profile.username != username:
profile['isFollowing'] = user.is_following(a_user)
return jsonify(profile)
return not_found('User not found.')
def delete_comment(user, post_id, comment_id):
comment = Comment.find_by_id(comment_id)
if not comment:
return not_found('Comment not found.')
if comment.user_id != user.id:
return error_response(401, 'Not authorized for that action.')
try:
comment.delete()
except (exc.IntegrityError, ValueError):
db.session.rollback()
return server_error('Something went wrong, please try again.')
else:
return jsonify(CommentSchema().dump(comment.id))
def unfollow(user, id):
followed = User.find_by_id(id)
if not followed:
return not_found('User not found')
user.unfollow(followed)
try:
user.save()
except (exc.IntegrityError, ValueError):
db.session.rollback()
return server_error('Something went wrong, please try again.')
else:
return jsonify(UserSchema(
many=True, only=('id',)).dump(user.followed.all()))
def delete_notification(user, notif_id):
try:
notif = Notification.find_by_id(notif_id)
if not notif:
return not_found('Notification not found.')
if user.id != notif.owner_id:
return error_response(403, "Not allowed!")
notif.delete()
return {'message': 'Successfully removed.'}
except (IntegrityError, ValueError) as e:
db.session.rollback()
print(e)
return server_error('Something went wrong, please try again.')
def delete_post(user, post_id):
post = Post.find_by_id(post_id)
if not post:
return not_found('Post not found.')
if post.user_id != user.id:
return error_response(401, "You cannot delete someone else's post.")
try:
post.delete()
except (exc.IntegrityError, ValueError):
db.session.rollback()
return server_error('Something went wrong, please try again.')
else:
return jsonify(PostSchema().dump(post.id))
def get_post(user, post_id):
try:
post = Post.find_by_id(post_id)
if not post:
return not_found('Post not found')
except Exception:
return server_error('Something went wrong, please try again.')
else:
post_dict = post.to_dict(user)
post_dict['isLiked'] = post.is_liked_by(user)
if user.id != post.author.id:
post_dict['author']['isFollowing'] = user.is_following(post.author)
return jsonify(post_dict)
def get_chat_messages(user):
username = request.args.get('username', '')
cursor = request.args.get('cursor')
items_per_page = current_app.config['ITEMS_PER_PAGE']
a_user = Profile.find_by_username(username).user
nextCursor = None
msgs = None
if not a_user:
return not_found('User not found.')
try:
query = user.get_chat_messages(a_user)
chat = user.get_chat(a_user)
if cursor == '0':
msgs = query.limit(items_per_page + 1).all()
else:
cursor = urlsafe_base64(cursor, from_base64=True)
msgs = query.filter(
Message.created_on < cursor).limit(items_per_page + 1).all()
if len(msgs) > items_per_page:
nextCursor = urlsafe_base64(msgs[items_per_page -
1].created_on.isoformat())
# check if lrm exist
if chat:
lrm = LastReadMessage.find_by_pk(user.id, chat.id)
if lrm:
lrm.timestamp = datetime.utcnow()
else:
lrm = LastReadMessage()
lrm.user_id = user.id
lrm.chat_id = chat.id
lrm.timestamp = datetime.utcnow()
lrm.save()
except Exception as e:
db.session.rollback()
print(e)
return server_error('Something went wrong, please try again.')
else:
return {
'data': MessageSchema(many=True).dump(msgs[:items_per_page]),
'nextCursor': nextCursor
}
def update_comment_like(user, post_id, comment_id):
comment = Comment.find_by_id(comment_id)
if not comment:
return not_found('Comment not found')
if comment.is_liked_by(user):
comment.likes.remove(user)
else:
comment.likes.append(user)
try:
comment.save()
except (exc.IntegrityError, ValueError):
db.session.rollback()
return server_error('Something went wrong, please try again.')
else:
return jsonify(CommentSchema().dump(comment))
def get_comments(user, post_id, page=1):
post = Post.find_by_id(post_id)
if not post:
return not_found('Post not found.')
try:
comments = Comment.query.with_parent(post).order_by(
Comment.created_on.desc()).paginate(
page, current_app.config['ITEMS_PER_PAGE'])
except (exc.IntegrityError, ValueError):
db.session.rollback()
return server_error('Something went wrong, please try again.')
else:
return {
'comments': CommentSchema(many=True).dump(comments.items),
'hasNext': comments.has_next,
}
def update_like(user, post_id):
post = Post.find_by_id(post_id)
if not post:
return not_found('Post not found')
try:
if post.is_liked_by(user):
post.likes.remove(user)
else:
post.likes.append(user)
post.save()
except (exc.IntegrityError, ValueError):
db.session.rollback()
return server_error('Something went wrong, please try again.')
else:
return jsonify(PostSchema().dump(post))
def update_post(user, post_id):
post_data = request.get_json()
post = Post.find_by_id(post_id)
if not post:
return not_found('Post not found.')
if post.user_id != user.id:
return error_response(401, "You cannot update someone else's post.")
post.body = post_data.get('post')
try:
post.save()
except (exc.IntegrityError, ValueError):
db.session.rollback()
return server_error('Something went wrong, please try again.')
else:
return jsonify(PostSchema().dump(post))
def get_liked_posts(user, username):
"""Get a users list of liked posts"""
a_user = Profile.find_by_username(username).user
if not a_user:
return not_found('User not found.')
cursor = request.args.get('cursor')
items_per_page = current_app.config['ITEMS_PER_PAGE']
nextCursor = None
posts = None
try:
query = a_user.likes.order_by(Post.created_on.desc())
if cursor == '0':
posts = query.limit(items_per_page + 1).all()
else:
cursor = urlsafe_base64(cursor, from_base64=True)
posts = query.filter(
Post.created_on < cursor).limit(items_per_page + 1).all()
except (exc.IntegrityError, ValueError) as e:
db.session.rollback()
print(e)
return server_error('Something went wrong, please try again.')
if len(posts) > items_per_page:
nextCursor = urlsafe_base64(
posts[items_per_page - 1].created_on.isoformat())
liked_posts = []
for p in posts[:items_per_page]:
post = p.to_dict(user)
if p.parent:
post['parent'] = PostSchema(
only=('id', 'body', 'author',)).dump(p.parent)
liked_posts.append(post)
return {
'data': liked_posts,
'nextCursor': nextCursor,
'total': query.count(),
}
def follow(user, id):
to_follow = User.find_by_id(id)
if not to_follow:
return not_found('User not found')
user.follow(to_follow)
db.session.add(
user.add_notification(
subject='follow', item_id=user.id, id=to_follow.id))
try:
user.save()
except (exc.IntegrityError, ValueError):
db.session.rollback()
return server_error('Something went wrong, please try again.')
else:
following = UserSchema(only=('id', 'profile',)).dump(to_follow)
following['isFollowing'] = user.is_following(to_follow)
return jsonify(following)
def get_followers(user, username):
"""Get list of users following a user"""
a_user = Profile.find_by_username(username).user
if not a_user:
return not_found('User not found.')
cursor = request.args.get('cursor')
items_per_page = current_app.config['ITEMS_PER_PAGE']
nextCursor = None
followers = None
try:
query = a_user.followers.order_by(User.id.desc())
if cursor == '0':
followers = query.limit(items_per_page + 1).all()
else:
cursor = int(urlsafe_base64(cursor, from_base64=True))
followers = query.filter(
User.id < cursor).limit(items_per_page + 1).all()
except (exc.IntegrityError, ValueError):
db.session.rollback()
return server_error('Something went wrong, please try again.')
else:
if len(followers) > items_per_page:
nextCursor = urlsafe_base64(str(followers[items_per_page - 1].id))
user_followers = []
for a_user in followers[:items_per_page]:
follower = UserSchema(only=('id', 'profile',)).dump(a_user)
follower['isFollowing'] = user.is_following(a_user)
user_followers.append(follower)
return {
'data': user_followers,
'total': query.count(),
'nextCursor': nextCursor,
}
def unfollow(user, id):
followed = User.find_by_id(id)
if not followed:
return not_found('User not found')
user.unfollow(followed)
notif = Notification.find_by_attr(subject='follow', item_id=user.id)
if (notif):
db.session.delete(notif)
try:
user.save()
except (exc.IntegrityError, ValueError):
db.session.rollback()
return server_error('Something went wrong, please try again.')
else:
follow = UserSchema(only=('id', 'profile',)).dump(followed)
follow['isFollowing'] = user.is_following(followed)
return jsonify(follow)
def delete_message(user, msg_id):
del_for_user = request.args.get('userOnly')
try:
message = Message.find_by_id(msg_id)
if not message:
return not_found('Message not found.')
if del_for_user:
user.delete_message_for_me(message)
return {'message': 'Successfully deleted for you.'}
if user.id != message.author_id:
return error_response(403, "Cannot delete another user's message.")
db.session.delete(
Notification.find_by_attr(subject='message', item_id=msg_id))
message.delete()
return {'message': 'Successfully deleted.'}
except (IntegrityError, ValueError):
db.session.rollback()
return server_error('Something went wrong, please try again.')
def delete_post(user, post_id):
post = Post.find_by_id(post_id)
if not post:
return not_found('Post not found.')
if post.user_id != user.id:
return error_response(401, "You cannot delete someone else's post.")
post_notif = Notification.find_by_attr(subject='post', item_id=post.id)
comment_notif = Notification.find_by_attr(subject='comment',
item_id=post.id)
[db.session.delete(notif) for notif in post_notif] if post_notif \
else db.session.delete(comment_notif)
try:
post.delete()
except (exc.IntegrityError, ValueError):
db.session.rollback()
return server_error('Something went wrong, please try again.')
else:
return {'message': 'Post was successfuly deleted.'}
def get_user_posts(user, username):
"""Get a users list of posts"""
a_user = Profile.find_by_username(username).user
if not a_user:
return not_found('User not found.')
cursor = request.args.get('cursor')
items_per_page = current_app.config['ITEMS_PER_PAGE']
nextCursor = None
posts = None
try:
query = Post.query.with_parent(a_user).filter(
Post.comment_id.is_(None)).order_by(Post.created_on.desc())
if cursor == '0':
posts = query.limit(items_per_page + 1).all()
else:
cursor = urlsafe_base64(cursor, from_base64=True)
posts = query.filter(
Post.created_on < cursor).limit(items_per_page + 1).all()
except (exc.IntegrityError, ValueError) as e:
db.session.rollback()
print(e)
return server_error('Something went wrong, please try again.')
if len(posts) > items_per_page:
nextCursor = urlsafe_base64(
posts[items_per_page - 1].created_on.isoformat())
return {
'data': [post.to_dict(user) for post in posts[:items_per_page]],
'nextCursor': nextCursor,
'total': query.count(),
}
def get_group(id):
"""Get a single group"""
group = Group.find_by_id(id)
if group is None:
return not_found('Group not found!')
return jsonify(GroupSchema().dump(group))
def get_user(id):
"""Get a single user"""
user = User.find_by_id(id)
if user is None:
return not_found('User not found!')
return jsonify(UserSchema().dump(user))
