def get(self, post_id):
post_key = db.Key.from_path('Post', int(post_id))
post = db.get(post_key)
#Check if user is logged in
if self.user:
user_id = self.read_secure_cookie('user_id')
author_id = post.author.key().id()
u = self.user.name
#check if user has permission to like this post
if long(user_id) != author_id:
user = User.by_name(u)
user_key = self.user.key()
post = Post.by_id(post_id)
likes = Like.all().filter('post =', post)
#Check if user has already liked this post
hasLiked = False
for l in likes:
if l.user.key() == user_key:
hasLiked = True
if not hasLiked:
like = Like(user=user, post=post)
like.put()
count = Like.all().filter('post =', post).count()
#count += 1
self.render("like.html", like=like, count=count, post=post)
else:
count = Like.all().filter('post =', post).count()
page_error = "You have already liked this post"
self.render("like.html",
count=count,
page_error=page_error,
post=post)
else:
page_error = 'You can not like your own posts'
self.render('like.html', page_error=page_error, post=post)
else:
error = 'please login'
self.render('login-form.html', error=error, post=post)
def get(self, post_id):
key = db.Key.from_path('Post', int(post_id), parent=blog_key())
post = db.get(key)
if self.user and self.user.key().id() == post.user_id:
error = "Sorry, you cannot like your own post."
self.render('base.html', access_error=error)
elif not self.user:
self.redirect('/login')
else:
user_id = self.user.key().id()
post_id = post.key().id()
like = Like.all().filter('user_id =',
user_id).filter('post_id =',
post_id).get()
if like:
self.redirect('/' + str(post.key().id()))
else:
like = Like(parent=key,
user_id=self.user.key().id(),
post_id=post.key().id())
post.likes += 1
like.put()
post.put()
self.redirect('/' + str(post.key().id()))
def get(self, post_id):
key = db.Key.from_path('Post', int(post_id), parent=blog_key())
post = db.get(key)
comments_count = Comment.count_by_post_id(post)
post_comments = Comment.all_by_post_id(post)
if post:
if self.user and self.user.key().id() == post.user.key().id():
error = "You cannot dislike your own post"
self.render("post.html",
post=post,
comments_count=comments_count,
post_comments=post_comments,
error=error)
elif not self.user:
self.redirect('/login')
else:
l = Like.all().filter('user ='******'post =', post).get()
if l:
l.delete()
post.likes -= 1
post.put()
self.redirect('/post/' + str(post.key().id()))
else:
self.redirect('/post/' + str(post.key().id()))
def get(self, post_id):
key = db.Key.from_path('Post', int(post_id), parent=blog_key())
post = db.get(key)
# Post variable to regenerate front page with posts.
posts = db.GqlQuery(
"select * from Post order by created desc limit 10")
# Render front again with error if user tries to unlike thier own post.
if self.user and self.user.key().id() == post.user_id:
error = "Sorry, you cannot unlike your own post."
self.render('front.html', posts=posts, access_error=error)
elif not self.user:
self.redirect('/login')
else:
user_id = self.user.key().id()
post_id = post.key().id()
# Filter to see which posts a user has already liked.
l = Like.all().filter('user_id =',
user_id).filter('post_id =', post_id).get()
# Remove like value by 1 and render post page again.
if l:
l.delete()
post.likes -= 1
post.put()
self.redirect('/' + str(post.key().id()))
else:
self.redirect('/' + str(post.key().id()))
def get(self, post_id):
""" If the user is signed in and has authored the post render the
basetemplate with an error message as they can't unlike their own posts.
Pass the user to the sign in page if the user isn't signed in.
Lookup whether the user has liked the post. If liked, delete the like
from the db and deincrement the like_count in the post model """
postkey = db.Key.from_path('Post', int(post_id), parent=blog_key())
post = db.get(postkey)
if post is not None:
if self.user and self.user.key().id() == post.user_id:
self.write("You cannot unlike your own post")
elif not self.user:
return self.redirect('/login')
else:
user_id = self.user.key().id()
post_id = post.key().id()
l = LikeModel.all().filter(
'user_id =', user_id).filter('post_id =', post_id).get()
if l:
l.delete()
post.like_count -= 1
post.put()
return self.redirect('/' + str(post.key().id()))
else:
self.redirect('/' + str(post.key().id()))
def get(self, post_id):
key = db.Key.from_path('Post', int(post_id), parent=blog_key())
post = db.get(key)
if not (post is None) and self.user and self.user.key().id(
) == post.user.key().id():
if post:
db.delete(key)
time.sleep(0.1)
self.redirect('/')
else:
self.response.out.write("Not a valid post!")
# otherwise if the user is not logged in take them to the
# login page
elif not self.user:
self.redirect("/login")
else:
error = "You cannot delete other user's posts"
likes = like = Like.all().filter('post_id =', post_id).get()
comments_count = Comment.count_by_post_id(post)
post_comments = Comment.all_by_post_id(post)
self.render("post.html",
post=post,
likes=likes,
comments_count=comments_count,
post_comments=post_comments,
error=error)
def get(self, post_id, post_user_id):
""" If the user is signed in and authored the post, delete the post and
redirect the user to the homepage. Otherwise, send non-signed in users
to the login page. For all other cases go back to the current page with
a permission error. """
if self.user and self.user.key().id() == int(post_user_id):
postkey = db.Key.from_path('Post', int(post_id), parent=blog_key())
post = db.get(postkey)
comments = Comment.all().filter('post =', postkey)
likes = Like.all().filter('post_id =', post.key().id())
if post:
delete_dependents(comments=comments, likes=likes)
post.delete()
return self.redirect('/')
elif not self.user:
return self.redirect("/login")
else:
postkey = db.Key.from_path('Post', int(post_id), parent=blog_key())
post = db.get(postkey)
error_msg = "You do not have permission to delete this post"
comments = db.GqlQuery(
"select * from Comment where ancestor is :1 order by created desc limit 10", postkey) # NOQA
self.render("permalink.html", post=post, comments=comments,
error_msg=error_msg)
def get(self, post_id):
post_key = db.Key.from_path('Post', int(post_id))
post = db.get(post_key)
#Get all comments for post id
comments = Comment.all().filter('post =', post_key)
comments.order("-created")
#check if post exists
if not self.post_exists(post_id):
page_error = 'This post does not exist !'
return self.render('login-form.html', page_error = page_error)
user_id = self.read_secure_cookie('user_id')
author_id = post.author.key().id()
edit = False
#check if logged in user is the author of the post
#if the user is the author he can edit and/or delete the post
if user_id:
if (long(user_id) == author_id):
edit = True
#number of likes
post = Post.by_id(post_id)
likes = Like.all().filter('post =', post).count()
self.render("permalink.html", post = post, comments = comments, edit = edit, likes = likes)
def post(self, submission_id, **kwargs):
'''
delete the appropriate submission instance in the db, and
also delete all of its associated comments and likes in the db
'''
submission = kwargs['submission']
comments = Comment.all().filter('submission =', submission)
likes = Like.all().filter('submission =', submission)
db.delete(submission)
db.delete(comments)
db.delete(likes)
time.sleep(0.1)
self.redirect('/')
def post(self, post_id):
"""Delete post if given post_id exists.
If logged out user attempt to access, redirect to login page.
Args:
post_id (str): Post's id to edit.
"""
post = Post.get_by_id(int(post_id))
if post and self.user.key().id() == post.user.key().id():
post.delete()
db.delete(Like.all().filter('post = ', post))
# Delay for DB processing.
time.sleep(0.1)
return self.redirect('/blog')
def get(self, post_id):
key = db.Key.from_path('Post', int(post_id), parent=blog_key())
post = db.get(key)
if self.user and self.user.key().id() == post.user_id:
self.write("You cannot dislike your own post")
elif not self.user:
self.redirect('/login')
else:
user_id = self.user.key().id()
post_id = post.key().id()
l = Like.all().filter('user_id =', user_id).filter('post_id =', post_id).get()
if l:
l.delete()
post.likes -= 1
post.put()
self.redirect('/' + str(post.key().id()))
else:
self.redirect('/' + str(post.key().id()))
def get(self, post_id):
""" If the user is signed in and has authored the post render the
basetemplate with an error message as they can't like their own posts.
Pass the user to the sign in page if the user isn't signed in.
Lookup whether the user has liked the post. If liked, redirect the user
to the post page. Otherwise a new like can be recorded in the db and
increment the like_count in the post model. """
postkey = db.Key.from_path('Post', int(post_id), parent=blog_key())
post = db.get(postkey)
if post is not None:
if self.user and self.user.key().id() == post.user_id:
error = "Sorry, you cannot like your own post."
self.render('base.html', error=error)
elif not self.user:
return self.redirect('/login')
else:
user_id = self.user.key().id()
post_id = post.key().id()
liked = LikeModel.all().filter(
'user_id =', user_id).filter('post_id =', post_id).get()
if liked:
return self.redirect('/' + str(post.key().id()))
else:
like = LikeModel(parent=postkey,
user_id=self.user.key().id(),
post_id=post.key().id())
post.like_count += 1
like.put()
post.put()
return self.redirect('/' + str(post.key().id()))
def get(self, post_id):
key = db.Key.from_path('Post', int(post_id), parent=blog_key())
post = db.get(key)
# Post variable to regenerate front page with posts.
posts = db.GqlQuery(
"select * from Post order by created desc limit 10")
# Render front again with error if user tries to like thier own post.
if self.user and self.user.key().id() == post.user_id:
error = "Sorry, you cannot like your own post."
self.render('front.html', posts=posts, access_error=error)
elif not self.user:
self.redirect('/login')
else:
user_id = self.user.key().id()
post_id = post.key().id()
# Filter to see which posts a user has already liked.
like = Like.all().filter('user_id =',
user_id).filter('post_id =',
post_id).get()
# If user already liked post, then render page again with error.
if like:
comments = db.GqlQuery(
"select * from Comment where ancestor is :1 "
"order by created desc limit 10", key)
error = "You cannot like a post more than once"
self.render("permalink.html",
post=post,
comments=comments,
like_error=error)
# If user has not liked post, then +1 like count.
else:
like = Like(parent=key,
user_id=self.user.key().id(),
post_id=post.key().id())
post.likes += 1
like.put()
post.put()
self.redirect('/' + str(post.key().id()))
def get(self, post_id):
key = db.Key.from_path("Post", int(post_id), parent=blog_key())
post = db.get(key)
comments_count = Comment.count_by_post_id(post)
post_comments = Comment.all_by_post_id(post)
if post:
# check if the user is trying to like own post
if self.user and self.user.key().id() == post.user.key().id():
error = "You cannot like your own posts"
self.render("post.html",
post=post,
comments_count=comments_count,
post_comments=post_comments,
error=error)
elif not self.user:
self.redirect('/login')
else:
like = Like.all().filter('user ='******'post =',
post).get()
if like:
self.redirect('/post/' + str(post.key().id()))
else:
like = Like(post=post,
user=self.user)
post.likes += 1
like.put()
post.put()
self.redirect('/post/' + str(post.key().id()))
else:
self.response.out.write("Not a valid post!")
def get(self, post_id):
key = db.Key.from_path('Post', int(post_id), parent=Utils.blog_key())
post = db.get(key)
if self.user and self.user.key().id() == post.user.key().id():
error = "You cannot dislike your own post."
self.render('base.html', access_error=error)
elif not self.user:
self.redirect('/login')
else:
l = Like.all().filter('user ='******'post =', post.key()).get()
if l:
l.delete()
post.likes -= 1
post.put()
self.redirect('/blog/' + str(post.key().id()))
else:
self.redirect('/blog/' + str(post.key().id()))
def likes(self):
ms = Like.all(topic_id=self.id)
return ms
