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()
