Exemplo n.º 1
0
 def post(self):
     post_id = int(self.request.get('post_id'))
     user_id = int(self.request.get('user_id'))
     post_username = self.request.get('username')
     message = ''
     u = self.current_user()
     if u:
         # check if user is not liking own post
         if u.username != post_username:
             # check if post was already liked
             likes = Like.all().filter('post_id =', post_id).filter(
                 'username ='******'/view?p=%s&u=%s&#likes' %
                               (post_id, user_id))
             else:
                 message = 'You can only like a post once'
         else:
             message = 'You cannot like your own post'
         self.redirect('/view?p=%s&u=%s&m=%s&#likes' %
                       (post_id, user_id, message))
     else:
         self.redirect('/login')
Exemplo n.º 2
0
 def get(self, post_id):
     if self.good_cookie_exists():
         #  put the user id and post_id into the Like entity
         #  go to success page, which will have link to home
         h = self.request.cookies.get('user')
         curusor = h.split("|")[0]
         # make sure user doesn't own post
         post_key = db.Key.from_path(
             'Post', int(post_id))  # returning something, but what???
         if db.get(post_key) is not None:  # if post exists, continue
             owns = self.user_owns_post(post_key)
             if owns:  # if user owns the post, end
                 self.redirect("/")
                 return
             else:  # otherwise post exists and user is not owner
                 likes = Like.all().filter("post_id = ",
                                           str(post_id)).filter(
                                               "user = "******"/")  # UI blocks multiple liking as well
                     return
                 else:
                     # new Like entity
                     l = Like(post_id=post_id, user=curusor)
                     l.put()  # commit entry
                     self.render("successlike.html", loul="liked")
         else:
             self.redirect("/")
             return
     else:
         self.redirect("/login")
         return
Exemplo n.º 3
0
    def get(self, post_id):
        if not self.user:
            return self.redirect('/login')

        key = ndb.Key('Post', int(post_id), parent=models.blog_key())
        post = key.get()

        if not post:
            self.error(404)
            return

        like_obj = Like.query(Like.post == post.key).get()

        if post.author == self.user.key:
            self.write("You can not like your own post")
        else:
            if like_obj:
                authors = like_obj.author
                for author in authors:
                    if (author == self.user.key):
                        return self.redirect("/blog/%s" % str(post.key.id()))
                like_obj.like_count += 1
                authors.append(self.user.key)
                like_obj.put()
                self.redirect('/')
            else:
                like_obj = Like(post=post.key, like_count=1)
                like_obj.author.append(self.user.key)
                like_obj.put()
                self.redirect('/')
Exemplo n.º 4
0
    def post(self, post_id):
        # Prevent users from liking their own posts
        post = self.secure_interaction(post_id,
                                       error_type="like",
                                       match_user=False)
        if post:
            user_id = self.check_for_user()
            # Determine if the user has liked the post before
            like = Like.by_user_post(user_id, str(post.key().id()))
            # If they have liked the post before remove the like and decrease
            # the post likes
            if like:
                post.likes -= 1
                like.delete()
                post.put()
            else:
                # If they have not liked the post before then add a like and
                # increase the post likes
                post.likes += 1
                l = Like(parent=blog_key(),
                         user_id=user_id,
                         post_id=str(post.key().id()))
                l.put()
                post.put()

            self.redirect('/post/%s' % str(post.key().id()))
Exemplo n.º 5
0
 def get(self, post_id):
     # check if logged in and get username.
     username = self.check_login(self.request.cookies.get('user_id'))
     if not username:
         self.redirect('/login')
     else:
         # get the post.
         post = db.get(db.Key.from_path('Post', int(post_id)))
         # if post belongs to user, show alert.
         if post.username == username:
             self.render('alerts.html',
                         alert='You cannot like your own post',
                         path='/%s' % post_id)
         else:
             already_like = Like.all().filter('username='******'post_id=', post_id).get()
             # if user hasn't liked the post, create like.
             if not already_like:
                 l = Like(username=username, post_id=post_id)
                 l.put()
                 self.render('alerts.html',
                             alert='Like added to post',
                             path='/%s' % post_id)
             # if user has already liked the post, show alert.
             else:
                 self.render('alerts.html',
                             alert='You can only like a post once',
                             path='/%s' % post_id)
Exemplo n.º 6
0
 def post(self, post_id):
     post = Post.get_by_id(int(post_id))
     if post and post.author.key().id() == self.user.key().id():
         self.error(404)
     else:
         like = Like(post=post, user=self.user)
         like.put()
         time.sleep(1)
         self.redirect('/{}'.format(post_id))
Exemplo n.º 7
0
    def post(self, post_id):
        key = db.Key.from_path('Post', int(post_id))
        post = self.get_post(key)

        # check that
        #   post exists,
        #   user is not liking his own post,
        #   user didn't like this post
        if post and self.user.username != post.author.username and\
            not post.liked(self.user):
            like = Like(user = self.user, post = post)
            like.put()
            self.response.out.write(json.dumps({}))
    def post(self, post_id):
        """ handles post request """
        action = self.request.get("like-button")
        user = self.logged_in_user()
        post = Post.post_by_id(post_id)

        if action == 'like':
            like = Like(post=post, user=user)
            like.put()
        else:
            like = user.likes.filter("post =", post).get()
            like.delete()
        self.redirect('/' + post_id)
Exemplo n.º 9
0
    def like_update(cls, post_id, user_id):
        error_msg = ''
        post = Post.get_by_id(post_id)
        current_like = Like.all().filter('post_id =', post_id).filter('user_id =', int(user_id)).get()
        if user_id != post.created_by:
            if not current_like:  # if there is no record, adding a record with value=True
                l = Like(user_id=int(user_id), post_id=int(post_id), like_value=True)
                l.put()
                return l, error_msg

            current_like.like_value = not current_like.like_value
            current_like.put()
        else:
            error_msg = 'You cannot like your own post'
        return current_like, error_msg
Exemplo n.º 10
0
    def post(self, post_id):
        key = db.Key.from_path('Post', int(post_id), parent=blog_key())
        post = db.get(key)

        if not post:
            self.error(404)
            return

        c = ""

        if (self.user):
            if (self.request.get('like')
                    and self.request.get('like') == "update"):
                likes = db.GqlQuery("select * from Like where post_id = " +
                                    post_id + " and user_id = " +
                                    str(self.user.key().id()))
                if self.user.key().id() == post.user_id:
                    self.redirect("/blog/" + post_id +
                                  "?error=You cannot like your own " +
                                  "post.!!")
                    return
                elif likes.count() == 0:
                    l = Like(parent=blog_key(),
                             user_id=self.user.key().id(),
                             post_id=int(post_id))
                    l.put()

            if (self.request.get('comment')):
                c = Comment(parent=blog_key(),
                            user_id=self.user.key().id(),
                            post_id=int(post_id),
                            comment=self.request.get('comment'))
                c.put()
        else:
            self.redirect("/login?error=You need to login before " +
                          "performing edit, like or commenting.!!")
            return

        comments = db.GqlQuery("select * from Comment where post_id = " +
                               post_id + "order by created desc")

        likes = db.GqlQuery("select * from Like where post_id=" + post_id)

        self.render("permalink.html",
                    post=post,
                    comments=comments,
                    noOfLikes=likes.count(),
                    new=c)
Exemplo n.º 11
0
 def post(self):
   """
   Post method to like and unlike blogs
   """
   if self.user:
     if self.request.get("like_blog"):
       _blog_id = self.request.get("like_blog")
       user = self.user
       user_id = user.key.id()
       _user = User.by_id(int(user_id))
       _blog = Blog.get_by_id(int(_blog_id))
       like = Like(user=user.key, blog=_blog.key)
       like.like = 1
       like_key = like.put()
       blog = _blog.key.get()
       blog.likes.append(like_key)
       blog.put()
       self.redirect('/')
     if self.request.get("dislike"):
       _blog_id = self.request.get("dislike")
       user = self.user
       user_id = user.key.id()
       _user = User.by_id(int(user_id))
       _blog = Blog.get_by_id(int(_blog_id))
       like = Like.query(Like.user == user.key, Like.blog == _blog.key).get()
       like_key = like.key
       blog = _blog.key.get()
       blog.likes.remove(like_key)
       blog.put()
       like_key.delete()
       self.redirect('/')
   else:
     self.redirect('/login')
Exemplo n.º 12
0
 def get(self, action, post_id):
     if self.validate(action, post_id):
         params = {}
         like = Like(post=self.blog_post, liked_by=self.user)
         key = like.put()
         # get updated object
         params['post'] = db.get(key).post
         self.render("permalink.html", **params)
Exemplo n.º 13
0
def like_boker(user_key, boker_key, explicitly_shared=False):
    """Like a boker"""

    user = User.get_by_key_name(user_key)
    boker = Boker.get(boker_key)
    boker_owner = boker.user

    if user and boker and not Like.already_like(user, boker):
        # Create like
        like = Like(user=user, boker=boker)
        like.put()

        # Update like numbers
        boker.num_like += 1
        boker.put()

        if not settings.DEBUG:
            # Post to FB
            try:
                boker_url = "%s/boker/%s" % (settings.APP_DOMAIN, boker.key().id())
                graph = facebook.GraphAPI(user.access_token)
                graph.request('me/og.likes',
                        post_args={'object': boker_url, 'fb:explicitly_shared': str(explicitly_shared).lower()})
            except Exception as e:
                print e

            # Notify Boker owner
            if user != boker_owner:
                try:
                    boker_url = encode_url("/boker/%s" % boker.key().id())
                    graph = facebook.GraphAPI(settings.FACEBOOK_APP_ACCESS_TOKEN)
                    graph.request('%s/notifications' % boker_owner.id,
                                   post_args={
                                            'href': '?to=' + boker_url,
                                            'template': '@[%s] menyukai boker anda.' % user.id,
                                            })
                except Exception as e:
                    print e

        else:
            logging.info('Runtask: post_like_story...')
Exemplo n.º 14
0
 def get(self, post_id):
     if user_logged_in(self):
         key = db.Key.from_path('Post', int(post_id), parent=post_key())
         post = db.get(key)
         if not post:
             return self.error(404)
         if not user_owns_post(self, post):
             self.redirect('/')
         if post.liked(self.user):
             l = db.GqlQuery(
                 "SELECT * FROM Like WHERE author=:user AND parent_post=:post",
                 user=self.user,
                 post=post).get()
             l.delete()
             self.redirect('/blog')
         else:
             l = Like(author=self.user, parent_post=post)
             l.put()
             self.redirect('/blog')
     else:
         return self.redirect('/')
Exemplo n.º 15
0
 def set_like(self,branch_urlsafe_key,like_value):
     
     if branch_urlsafe_key is None or branch_urlsafe_key == '':
         return False, ['invalid_parameters']
     
     userinfo = self.current_user_info()
     if userinfo is None:
         return False, ['unauthenticated']
     
     branch_key = ndb.Key(urlsafe=branch_urlsafe_key)
     
     like_key = Like.create_key(branch_key,userinfo.username)
     like = like_key.get()
     
     if like is None:
         branch = branch_key.get()
         like = Like(key=like_key,username=userinfo.username,branch=branch_key,branchauthorname=branch.authorname)
     
     like.value = int(like_value)
     
     like.put()
     
     return True, like
Exemplo n.º 16
0
    def post(self, post_id, post):

        # If user made post, don't allow them to like it
        if self.user.key().id() == post.user_key.key().id():
            return self.redirect('/post/%s' % str(post.key().id()))

        # Retrieve likes by the user for the post
        likes = Like.all()
        likes.filter("post_key =", post.key())
        likes.filter("user_key =", self.user.key())

        # Check if user already liked the post
        liked = likes.count() > 0

        # If user hasn't liked, create like else redirect to post page
        if not liked:
            like = Like(parent=blog_key(),
                        post_key=post.key(),
                        user_key=self.user.key())
            like.put()

            self.redirect('/post/%s' % str(post.key().id()))
        else:
            self.redirect('/post/%s' % str(post.key().id()))
Exemplo n.º 17
0
    def post(self, username, post_slug):
        if not self.logged_in():
            return self.redirect('/login')

        value = self.request.get('like')
        post = Post.find_by_user_and_slug(username, post_slug)
        same_user = self.user.username == username

        if same_user or not (value in ['Like', 'Dislike'] or post):
            return self.redirect('/dashboard')

        bool_val = True if value == 'Like' else False
        like_exist = post.find_like_by_user(self.user)

        if like_exist:
            if like_exist.value != bool_val:
                like_exist.value = like_exist.value != True  #Swap T/F values
                if like_exist.put():
                    post.likes += 1 if bool_val else -1
                    post.dislikes -= 1 if bool_val else -1
                    post.put()
            else:
                like_exist.key.delete()
                if bool_val:
                    post.likes -= 1
                else:
                    post.dislikes -= 1
                post.put()
        else:
            like = Like(value=bool_val, parent=post.key, author=self.user.key)
            if like.put():
                if bool_val:
                    post.likes += 1
                else:
                    post.dislikes += 1
                post.put()
        self.write(post.render_likes(self.user))
Exemplo n.º 18
0
    def post(self, post_id, b, err):
        if self.user:
            blog_comment = self.request.get("blog-comment")
            blog_comment = blog_comment.replace('\n', '<br>')

            like = self.request.get('like')
            dislike = self.request.get('dislike')

            comment_edit = self.request.get('edit-comment')
            #comment_del = self.request.get('delete-comment')

            # Allows the user to like or dislike the posts only once.
            # But user can dislike after liking the post and vice-versa.
            # User cannot like, dislike their own posts.
            if like or dislike:
                likes = ndb.gql(
                    " SELECT * FROM Like"
                    " WHERE like_blog = :num1"
                    " AND like_user = :num2",
                    num1=b.key,
                    num2=self.user.key).get()
                if b.blog_author.get().name != self.user.name:
                    if likes:
                        if likes.like_dislike == 1:
                            if like:
                                post_id += '-1'
                                self.redirect('/edit/%s' % post_id)
                            else:
                                for l in b.blog_likes:
                                    if l == likes.key:
                                        b.blog_likes.remove(l)
                                        b.put()
                                likes.key.delete()
                                post_id += '-0'
                                self.redirect('/edit/%s' % post_id)
                        else:
                            if like:
                                for l in b.blog_likes:
                                    if l == likes.key:
                                        b.blog_likes.remove(l)
                                        b.put()
                                likes.key.delete()
                                post_id += '-0'
                                self.redirect('/edit/%s' % post_id)
                            else:
                                post_id += '-2'
                                self.redirect('/edit/%s' % post_id)
                    else:
                        like_blog = b.key
                        like_user = self.user.key
                        if like:
                            like_dislike = 1
                        else:
                            like_dislike = 0
                        likes = Like(like_blog=like_blog,
                                     like_user=like_user,
                                     like_dislike=like_dislike)
                        likes.put()
                        b.blog_likes.append(likes.key)
                        b.put()
                        post_id += '-0'
                        self.redirect('/edit/%s' % post_id)
                else:
                    post_id += '-3'
                    self.redirect('/edit/%s' % post_id)

            # edit a comment
            elif comment_edit:
                self.redirect('/edit-comment/%s' % str(comment_edit))

            # Post new comments
            else:
                if blog_comment:
                    comments = Comment(comment_blog=b.key,
                                       user_name=self.user.key,
                                       comment_content=blog_comment)
                    comments.put()
                    comments.comment_id = str(comments.key.id())
                    comments.put()
                    b.blog_comments.append(comments.key)
                    b.put()
                    post_id += '-0'
                    self.redirect('/edit/%s' % post_id)
                else:
                    post_id += '-0'
                    self.redirect('/edit/%s' % post_id)

        # Users visting this page, if not logged in, have the option to login.
        else:
            self.redirect('/')