def ajax_like(request): try: qid = int(request.POST.get("id")) except TypeError: return JsonResponse(dict()) type_ = request.POST.get("type") if type_ == "question": object_class = Question elif type_ == "answer": object_class = Answer else: return JsonResponse(dict()) object_ = get_object_or_404(object_class, id=qid) if object_.likes.filter(user=request.user).count() == 0: like = Like(user=request.user, content_object=object_class.objects.get(id=qid)) like.save() object_.likes_count += 1 object_.save() else: object_.likes.filter(user=request.user).delete() object_.likes_count -= 1 object_.save() return JsonResponse({ "likes_count": object_.likes_count, })
def like_change(): """ 更改用户是否喜欢的相关信息 :return: """ uid = request.args.get('uid') mid = request.args.get('mid') like_type = request.args.get('type') name = request.args.get('name') state = request.args.get('state') if uid == '0': return json.dumps({'status': 0, 'msg': 'user not found'}) user = User.objects(id=ObjectId(uid)).first() if not user: return json.dumps({'status': 0, 'msg': 'user not found'}) try: if state == 'true': # add Like(user=user, type=like_type, value=mid, name=name).save() else: # del Like.objects(Q(user=user) & Q(type=like_type) & Q(value=mid)).delete() except Exception, e: return json.dumps({ 'status': 2, 'msg': 'exception happened:' + e.message })
def init_db(): """ init test data """ Role.insert_roles() User.generate_fake() PostType.insert_types() Post.generate_fake() Comment.generate_fake() Like.generate_fake() Message.generate_fake()
def like(id): post = Post.query.get_or_404(id) if current_user in [like_.user for like_ in post.likes]: return redirect(url_for('main.index')) like = Like() like.post = post like.user = current_user._get_current_object() db.session.add(like) db.session.commit() return redirect(url_for('main.index'))
def like(): like_forsql = Like() like_forsql.Like_Type = 1 db.session.add(like_forsql) db.session.commit() like_count = Like.query.filter(Like.Like_Type == 1).count() cancellike = Like.query.filter(Like.Like_Type == 0).count() like_count = like_count - cancellike back_data = {'like_count': like_count} return jsonify(back_data)
def like_post(request, pk): like = Like.objects.filter(user_id=request.user.userprofile.id, post_id=pk).first() if like: like.delete() else: post = Post.objects.get(pk=pk) like = Like(user=request.user.userprofile) like.post = post like.save() return redirect('post details', pk)
def like(request, id=None): member = User.objects.get(id=id) user = request.user if Like.objects.filter(member=member, user=user).exists(): return Response({ 'success': 'already liked', 'status': status.HTTP_400_BAD_REQUEST }) like = Like(member=member, user=user) like.save() return Response({'success': 'liked', 'status': status.HTTP_200_OK})
def like(id): get_likes = Like.get_likes(id) valid_string = f'{current_user.id}:{id}' for like in get_likes: to_str = f'{like}' if valid_string == to_str: return redirect(url_for('main.blogs', id=id)) else: continue new_vote = Like(user=current_user, blog_id=id) new_vote.save() return redirect(url_for('main.blogs', id=id))
def dellike(request, pk): if request.method == 'POST': # いいね追加 if "add_like" in request.POST: add_like = Like(article_id=pk, user_id=request.user.id) add_like.save() return redirect("accounts:mylike", pk=request.user.id) # いいね削除 elif "del_like" in request.POST: del_like = Like.objects.get(article_id=pk, user_id=request.user.id) del_like.delete() return redirect("accounts:mylike", pk=request.user.id)
def new_like(photo_id): data = json.loads(request.data) photo = Photo.query.get(photo_id) user_id = photo.user_id like = Like() like.photo_id = photo_id like.user_id = user_id try: db.session.add(like) db.session.commit() return jsonify(message=f"Liked a photo with the id of {id}."), 201 except: return jsonify(error=f"Error liking a photo with the id of {id}."), 404
def post(self, user): # grab the form form = LikeForm(self.request.params) username = user # grab the user (for their key) user = User.query(User.username == username).get() if user is None: self.redirect('/user/login') return # grab the post via what should be it's key try: post = Key(urlsafe=form.key.data).get() except Exception as e: post = None if post is None: self.redirect('/') return if user.username == post.author: error = 'you can\'t like or unlike you own post' self.render("index.html", error=error) return # is the post liked by this user already? try: liked = Like.query(Like.owner == user.key, Like.post == Key(urlsafe=form.key.data)).get() except Exception as e: print e.message liked = None # let's set the Like entity up and like the post try: if liked is None: # hasn't been liked yet liked = Like(owner=user.key, post=Key(urlsafe=form.key.data), liked=True) liked.put() else: liked.liked = True if liked.liked is False else False liked.put() # inc/dec the post likes if liked.liked is True: post.likes += 1 else: post.likes -= 1 post.put() # go back to the post! self.redirect('/post/view?key=%s' % post.key.urlsafe()) return except Exception as e: # go back to the post even if we fail to like it self.redirect('/post/view?key=%s' % post.key.urlsafe()) return
def addlike(request): username = request.session.get('username') data = { 'status': '200', 'msg': 'ok', } if not username: data['status'] = '302' data['msg'] = '用户未登录' print('用户未登录') return JsonResponse(data) moviesid = request.GET.get('id') print(moviesid) movie = Movies.objects.filter(pk=moviesid).first() print('movie', movie) user = User.objects.filter(u_name=username).first() love_item = Like.objects.filter(like_user=user).filter( like_movies=movie).first() print('love_item', love_item) if not love_item: love_item = Like() love_item.like_user = user love_item.like_movies = movie love_item.save() movie.like_num += 1 movie.save() else: love_item.delete() movie.like_num -= 1 movie.save() data['num'] = movie.like_num return JsonResponse(data)
def get_likes(num): res = [] count = db.movie.count() query = db.movie.find({}, { '_id': 1, 'title': 1 }).skip(count / randint(1, 10)).limit(num) for i in xrange(num): like = Like() like.type = 'movie' like.name = query[i]['title'] like.value = query[i]['_id'] res.append(like) return res
def add_like(post_uid): user = get_user() try: try: like = Like.get(user=user, post=Post.get(uid=post_uid)) return jsonify({'error': False, 'message': 'Post successfully liked.'}), 200 except: pass new_like = Like(user=user, post=Post.get(uid=post_uid)) new_like.save() return jsonify({'error': False, 'message': 'Post successfully liked.'}), 200 except: return jsonify({'error': True, 'message': 'An unknown error occurred.'}), 500
def like_post(post_id): print(request) data = request.json # obtaining the post_id from the POST boy rather than URL params post_id = data['post_id'] user_id = getUserID() post = Post.query.get(post_id) # ensure the target post exists if post: # check if the user has already liked the post like = Like.query.filter_by(user_id=user_id, post_id=post_id).first() if like == None: print(post) like = Like(user_id, post_id) db.session.add(like) db.session.commit() likes = Like.query.filter_by(post_id=post_id).count() return jsonify({"message": "Post liked!", "likes": likes}) else: # unlike post db.session.delete(like) db.session.commit() likes = Like.query.filter_by(post_id=post_id).count() return jsonify({"message": "Post unliked :(", "likes": likes}) else: return jsonify({ 'code': -1, "message": "Post does not exist", 'errors': [] })
def like(): like = Like(user_id=request.form.get("user_id"), article_id=request.form.get("article_id")) article = Article.query.get(request.form.get("article_id")) database.session.add(like) database.session.commit() return render_template("jquery/like.html", like=like, article=article)
def index(): form = PostForm() if form.validate_on_submit(): post = Post(body=form.post.data, author=current_user) db.session.add(post) db.session.commit() like = Like(user_id=current_user.id, post_id=post.id) db.session.add(like) db.session.commit() flash(_('Your post is now live!')) return redirect(url_for('index')) page = request.args.get('page', 1, type=int) posts = current_user.followed_posts().paginate( page, app.config['POSTS_PER_PAGE'], False) next_url = url_for('index', page=posts.next_num) if posts.has_next else None prev_url = url_for('index', page=posts.prev_num) if posts.has_prev else None return render_template('index.html', title='Home', form=form, posts=posts.items, next_url=next_url, prev_url=prev_url, Like=Like, index_url=True)
def like_comment(username, post): user = User.query.filter_by(username=username).first_or_404() post = Post.query.filter_by(id=post).first_or_404() l = Like(user_id=user.id, post_id=post.id, liked_id=current_user.id) db.session.add(l) db.session.commit() return redirect(url_for('post', post_id=post.id))
def post(self): try: user = check_user_session(request) product_id = request.args.get('product_id') product = Product.query.get(product_id) if product is None: raise Exception("Product is missing") if product.id not in [like.product_id for like in user.likes]: # add like like = Like(user_id=user.id, product_id=product.id) db.session.add(like) db.session.commit() return {'status': 'ok', 'message': 'Product liked'}, 201 else: # remove like like = Like.query.filter(Like.user_id == user.id, Like.product_id == product_id).first() db.session.delete(like) db.session.commit() return {'status': 'ok', 'message': 'Product disliked'}, 201 except jwt.ExpiredSignatureError as e: return {'status': 'fail', 'message': str(e)}, 401 except Exception as e: return {'status': 'fail', 'message': str(e)}, 400
def post(self, request, *args, **kwargs): id = request.POST.get('id', None) user = request.POST.get('user', None) liked = Like.objects.filter(post=id, user=user) if liked: liked.delete() else: like = Like(post=Post.objects.filter(id=id).first(), user=User.objects.filter(id=user).first()) like.save() data = {'text': 'text'} return JsonResponse(data)
def post_like(id): story_id = Story.query.get(id).id user_id = User.query.filter_by(username=request.json['user']).first().id like = Like.query.filter(Like.story_id == id).filter( Like.user_id == user_id).first() # count = 1 if like: like.count = like.count + 1 db.session.add(like) db.session.commit() return like.to_dict() else: new_like = Like(user_id, story_id, count=1) db.session.add(new_like) db.session.commit() return new_like.to_dict()
def add_items(): u1 = User(id=1, username='******', password='******', email='*****@*****.**') u2 = User(id=2, username='******', password='******', email='*****@*****.**') u3 = User(id=3, username='******', password='******', email='*****@*****.**') ad = User(id=4, username='******', password='******', email='*****@*****.**') pr1 = Preference(preference_name='kfc') c1 = Club(id=1, club_name='yuanhuo', president_id=1) c2 = Club(id=2, club_name='feiying', president_id=2) po1 = Post(id=1, title='one', text='jd is too strong', club_id=1) po2 = Post(id=2, title='two', text="let's compliment jd", club_id=2) po3 = Post(id=3, title='three', text="why not compliment jd", club_id=2) co1 = Comment(user_id=3, post_id=1, content='i think so.') like1 = Like(user_id=1, post_id=1) u1.preferences.append(pr1) u1.followed_clubs.append(c1) u2.managed_clubs.append(c1) u2.collected_posts.append(po3) db.session.add_all([ad, u1, u2, u3, pr1, po1, po2, po3, co1, like1, c1, c2]) db.session.commit()
def like(id): user = get_JWT_user() user.update_last_activity() post = Post.query.get(id) if not post: raise NotFound like = Like.query.filter_by(post_id=id, user_id=user.id).first() if like is None: like = Like(post=post, author=user) like.liked = True db.session.add(like) try: db.session.commit() except Exception: return try_later() return {"like": {"id": like.id}}, 201
def seed_likes(): demo = Like(user_id=User.query.filter_by(username='******').first().id, count=1, story_id=Story.query.get(1).id) demo1 = Like(user_id=User.query.filter_by(username='******').first().id, count=1, story_id=Story.query.get(2).id) demo2 = Like(user_id=User.query.filter_by(username='******').first().id, count=1, story_id=Story.query.get(2).id) db.session.add(demo) db.session.add(demo1) db.session.add(demo2) db.session.commit()
def like_post(current_user, post_id): """Creates a like relationship where the current users likes the post with id <post_id> """ print('x') post = Post.query.filter_by(id=post_id).first() print(post.id) user_id = current_user.id print(user_id) if post == None: return jsonify_errors(['This post does not exist']) if request.method == 'POST': pre_existing_relationship = Like.query.filter_by( postid=post_id, userid=current_user.id).first() print(pre_existing_relationship) if pre_existing_relationship == None: like = Like(postid=post_id, userid=user_id) db.session.add(like) db.session.commit() number_of_likes = len(Like.query.filter_by(postid=post_id).all()) return jsonify({ 'message': 'You like that Post', 'likes': number_of_likes }) else: number_of_likes = len(Like.query.filter_by(postid=post_id).all()) return jsonify({ 'message': 'You already like that Post', 'likes': number_of_likes })
def setUp(self): with current_app.test_request_context(): self.users = [ User(email='*****@*****.**', name='User 1').save(), User(email='*****@*****.**', name='User 2').save(), User(email='*****@*****.**', name='User 3').save(), ] self.post = Post(title='Post 1',body='Body 4', summary='Body 4', n_likes=3, author_id=self.users[0].id).save() self.likes = [ Like(user_id=self.users[0].id, post_id=self.post.id).save(), Like(user_id=self.users[1].id, post_id=self.post.id).save(), Like(user_id=self.users[2].id, post_id=self.post.id).save(), ]
def createLike(): req_data = request.get_json() postId = req_data['postId'] userId = req_data['userId'] try: like = Like( postId=postId, userId=userId, ) db.session.add(like) db.session.commit() return {'like': like.to_dict()} except IntegrityError: return {'errors': 'User already likes'}, 404
def add_like(id): incoming = request.get_json() like = Like(user_id=id, post_id=incoming) db.session.add(like) db.session.commit() return jsonify({"msg": 'Add like successful'})
def handleLikes(movieId, profileId): if request.method == 'DELETE': like = Like.query.filter(Like.profileId == profileId, Like.movieId == movieId).first() db.session.delete(like) elif request.method == 'POST': data = request.get_json() like = Like(profileId=profileId, movieId=movieId, upvoteDownvote=data["upvoteDownvote"]) db.session.add(like) else: data = request.get_json() like = Like.query.filter(Like.profileId == profileId, Like.movieId == movieId).first() like.upvoteDownvote = data["upvoteDownvote"] db.session.commit() return {"success": "success"}
def post(self, user): # grab the form form = PostDeleteForm(self.request.params) # validate csrf if not self.validate_csrf(form.csrf_token.data): form.csrf_token.data = self.generate_csrf() self.r(form, flashes=flash('Please submit the form again.')) return # get the post please try: post = Key(urlsafe=form.key.data).get() except: post = None # as usual, this really shouldn't # be None unless unnatural navigation if post is None: self.redirect('/') return # the post exists, is it owned by the user? if post.author != user: self.redirect('/') return # check if the user is the owner or not if post.author != user: self.redirect('/') return # everything checks out so let's remove the post # first though, we need to remove the comments # assoc with the post and the likes # TODO query these entities to make sure they are removed comments = Comment.query(ancestor=post.key).fetch() ks = put_multi(comments) delete_multi(ks) likes = Like.query(Like.post == post.key).fetch() ks = put_multi(likes) delete_multi(ks) # got everything else removed, let's # remove the post try: post.key.delete() self.redirect('/') return except Exception as e: # let them try again form.csrf_token.data = self.generate_csrf() self.r(form, post, flashes=flash()) return
def get(self): # get the user user = self.validate_user() # we have the user and need to access their key to see if they liked the post # if they are not signed in then we don't show if they liked or not if user is not None: user = User.query(User.username == user).get() if user is not None: user = user.key # get the post key k = self.request.get('key', None) if k is None: self.redirect('/') return # create our form data for likes/comments formData = { 'key': k, 'csrf_token': self.generate_csrf() } # create our comment form form = CommentForm(data=formData) # create our like form like_form = LikeForm(data=formData) # try to retrieve the post based on the key try: post = Key(urlsafe=k).get() except: post = None # don't have the comments yet, or likes comments = None liked = None if post is not None: # grab the comments please comments = Comment.query(ancestor=post.key).order(-Comment.created).fetch() # grab likes # we also need to see if this user has "liked" the post already liked = Like.query(Like.owner == user, Like.post == post.key).get() self.r(form, like_form, post, comments, liked)
print post_user db_post = Post(description=post["description"], creation_date=datetime.datetime.now(), user=post_user, picture=None) picture_path = "post_pictures/%s" % path_leaf(post["picture"]) post_picture = open("instagram/media/" + picture_path, "r") db_post.picture.save(picture_path, File(post_picture)) db_post.save() likes = post["likes"] for like in likes: db_like = Like() db_like.user = InstagramUser.objects.filter(username=like)[0] db_like.post = db_post db_like.save() comments = post["comments"] for comment in comments: comment_user = InstagramUser.objects.filter(username=comment["user"])[0] db_comment = Comment() db_comment.comment = comment["comment"] db_comment.creation_date = datetime.datetime.now() db_comment.user = comment_user db_comment.post = db_post db_comment.save() posts_file.close()