def set_like(meme_id):
if g.current_user is None:
abort(FORBIDDEN)
if 'score' not in request.form:
abort(BAD_REQUEST)
try:
score = int(request.form['score'])
except ValueError:
abort(BAD_REQUEST)
if not (-1 <= score <= 1):
abort(BAD_REQUEST)
user = g.current_user
meme = session.query(Meme).filter(Meme.id == meme_id).first()
if meme is None:
abort(BAD_REQUEST)
like = session.query(Like).filter(
and_(Like.meme_id == meme.id, Like.user_id == user.id)).first()
old_score = 0 if like is None else like.score
if like is None:
like = Like(meme_id=meme.id, user_id=user.id, score=score)
session.add(like)
else:
like.score = score
meme.rating = meme.rating - old_score + score
session.commit()
return 'OK', CREATED
def test_unlike_message(self):
"""Does a message get unliked properly?"""
with self.client as c:
with c.session_transaction() as sess:
sess[CURR_USER_KEY] = self.testuser.id
c.post('/messages/')
testuser2 = User.signup(username="******",
email='*****@*****.**',
password="******",
image_url="/test.jpg")
db.session.add(testuser2)
db.session.commit()
new_msg = Message(text="A new message", user_id=testuser2.id)
db.session.add(new_msg)
db.session.commit()
likes = Like(user_id=self.testuser.id, message_id=new_msg.id)
db.session.add(likes)
db.session.commit()
resp = c.post(f'/messages/{new_msg.id}/unlike', follow_redirects=True)
self.assertEqual(resp.status_code, 200)
self.assertIn(b'far fa-thumbs-up', resp.data)
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)
def like_or_unlike_message(message_id):
"""Like or unlike a message."""
if not g.user:
flash("Access unauthorized.", "danger")
return redirect("/login")
message = Message.query.get(message_id)
if g.user.id == message.user_id:
flash("You can't like your messages. You noob.")
else:
like = Message.is_liked_by(g.user, message)
if like:
# Delete like
db.session.delete(like)
db.session.commit()
else:
# Add like
like = Like(user_id=g.user.id, message_id=message_id)
db.session.add(like)
# g.user.liked_messages.append(message)
# or message.likers.append(user)
db.session.commit()
return redirect("/")
def add_like(message_id):
""" Add a liked message """
# first check if the user is the one doing the liking ?
if not g.user:
flash("Access unauthorized.", "danger")
return redirect("/")
# when somebody clicks on an empty star, add it to the likes
# form = MessageForm()
# if form.validate_on_submit():
# msg = Message(text=form.text.data)
# g.user.messages.append(msg)
# db.session.commit()
newlike = Like(message_being_liked_id=message_id,
user_doing_liking_id=g.user.id)
g.user.likes.append(newlike)
# db.session.add(newlike)
db.session.commit()
# what is it being added to? the likes table?
return redirect(request.referrer) # redirect back to page you're on
def test_is_liked_by(self):
"""Does is_liked_by method return correct boolean?"""
u = User(email="*****@*****.**",
username="******",
password="******")
u2 = User(email="*****@*****.**",
username="******",
password="******")
db.session.add(u)
db.session.add(u2)
db.session.commit()
msg = Message(text="My dad makes margaritas!")
u.messages.append(msg)
db.session.commit()
msg_to_like = Message.query.first()
# gets the second user that was created (u2)
liker = User.query.order_by(User.id.desc()).first()
# gets u1
nonliker = User.query.first()
new_like = Like(user_id=liker.id, message_id=msg_to_like.id)
db.session.add(new_like)
db.session.commit()
like = Message.query.first()
self.assertEqual(like.is_liked_by(liker), True)
self.assertEqual(like.is_liked_by(nonliker), False)
def test_liking_message(self):
""" Does user like a message? """
like = Like(user_id=self.u2.id, message_id=self.m1.id)
db.session.add(like)
db.session.commit()
self.assertEqual(len(self.m1.likers), 1)
self.assertEqual(len(self.u2.liked_messages), 1)
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('/')
def messages_like_toggle(message_id):
"""Like/unlike a message."""
#TODO: think about splitting this into two routes - one that likes,
# one that unlikes. Would provide more flexibility.
if not g.user:
flash("Access unauthorized.", "danger")
return redirect("/")
if g.like_form.validate_on_submit():
like = Like.query.filter_by(message_id=message_id,
user_id=g.user.id).one_or_none()
if like:
db.session.delete(like)
else:
new_like = Like(message_id=message_id, user_id=g.user.id)
db.session.add(new_like)
db.session.commit()
####### request.referrer puts every reload in the history #######
# when using request.referrer have a fall back (e.g. homepage)
return redirect(request.referrer)
def like_message(message_id):
"""Like a message."""
# if not g.user:
# flash("Access unauthorized.", "danger")
# return redirect("/")
try:
liked = Like.query.filter_by(msg_id=message_id,
user_id=g.user.id).first()
# import pdb; pdb.set_trace()
if liked:
db.session.delete(liked)
db.session.commit()
return jsonify({"status": "DELETED"})
else:
like = Like(msg_id=message_id, user_id=g.user.id)
db.session.add(like)
db.session.commit()
return jsonify({"status": "OK"})
# cur_message = Message.query.get(message_id)
# if cur_message.user_id == g.user.id:
# return redirect(request.referrer)
# g_likes = [msg.id for msg in g.user.likes]
except (IntegrityError, InvalidRequestError):
db.session.rollback()
liked_msg = Like.query.get_or_404((g.user.id, message_id))
db.session.delete(liked_msg)
db.session.commit()
g_likes = [msg.id for msg in g.user.likes]
return redirect(request.referrer)
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
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()))
def put(self, request, pk, format=None):
try:
comment = Comment.objects.get(pk=pk)
if request.data['type'] == 'update':
if comment.user == request.user:
comment_serializer = CommentsSerializer(comment,
data=request.data)
if comment_serializer.is_valid():
comment_serializer.save()
return Response(comment_serializer.data)
else:
return Response(status.HTTP_400_BAD_REQUEST)
else:
return Response(status.HTTP_405_METHOD_NOT_ALLOWED)
elif request.data['type'] == 'like':
already_liked_user = comment.get_users
if request.user not in already_liked_user:
like = Like()
like.comment = comment
like.user = request.user
like.save()
return Response(status.HTTP_201_CREATED)
else:
return Response(status.HTTP_501_NOT_IMPLEMENTED)
elif request.data['type'] == 'unlike':
already_liked_user = comment.get_users
if request.user in already_liked_user:
like = Like.objects.get(user=request.user, comment=comment)
like.delete()
return Response(status.HTTP_201_CREATED)
else:
return Response(status.HTTP_501_NOT_IMPLEMENTED)
except Comment.DoesNotExist:
return Response(status.HTTP_404_NOT_FOUND)
def handle_like(message_id):
""" Add a like to a message when star symbol is clicked. """
""" Still need to add a button which links to this route (action/post)"""
""" Should be able to unlike a warble as well by clicking on link"""
if not g.user:
flash("Please login.", "success")
return redirect("/login")
message = Message.query.get(message_id)
like = Like.query.get((message_id, g.user.id))
if like:
db.session.delete(like)
db.session.commit()
flash("Like was removed!", "success")
elif g.user.id == message.user_id:
flash("Sorry! You can't like your own posts.", "danger")
else:
like = Like(msg_id=message_id, user_id=g.user.id)
db.session.add(like)
db.session.commit()
flash("Like was added!", "success")
return redirect("/")
def setUp(self):
'''
Set up our test client and make a new message, user and like
for each test to work with
'''
self.client = app.test_client()
new_message = Message(id=1,
text="Testing",
timestamp=datetime.datetime(
2018, 1, 1, 1, 1, 1, 1),
user_id=1)
new_user = User(id=1,
email='*****@*****.**',
username='******',
image_url='/static/images/default-pic.png',
header_image_url='/static/images/warbler-hero.jpg',
bio='Test Bio',
location='Test Location',
password='******')
new_like = Like(user_id=1, message_id=1)
db.session.add(new_message)
db.session.add(new_user)
db.session.add(new_like)
db.session.commit()
def setUp(self):
"""Before each test, add sample city, user, cafe, and like"""
City.query.delete()
User.query.delete()
Cafe.query.delete()
Like.query.delete()
city = City(**CITY_DATA)
db.session.add(city)
user = User.register(**TEST_USER_DATA)
db.session.add(user)
cafe = Cafe(**CAFE_DATA)
db.session.add(cafe)
db.session.commit()
like = Like(user_id=user.id, cafe_id=cafe.id)
db.session.add(like)
db.session.commit()
self.cafe_name = cafe.name
self.cafe_id = cafe.id
# self.cafe = cafe
self.user = user
self.like = like
def test_like_model(self):
"""Does basic model work?"""
u = User(email="*****@*****.**",
username="******",
password="******")
u2 = User(email="*****@*****.**",
username="******",
password="******")
db.session.add(u)
db.session.add(u2)
db.session.commit()
msg = Message(text="My dad makes margaritas!")
u.messages.append(msg)
db.session.commit()
msg_to_like = Message.query.first()
# gets the second user that was created (u2)
liker = User.query.order_by(User.id.desc()).first()
# gets u1
nonliker = User.query.first()
new_like = Like(user_id=liker.id, message_id=msg_to_like.id)
db.session.add(new_like)
db.session.commit()
like = Like.query.first()
self.assertEqual(like.user_id, liker.id)
self.assertEqual(like.message_id, msg_to_like.id)
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')
def get(self, topic_id):
key = getKey(topic_id)
likes = Like.query().filter(Like.topic == key, Like.createdBy == self.user_info['user_id']).fetch(1)
if len(likes) == 0:
Like(topic=key, createdBy=self.user_info['user_id'], modifiedBy=self.user_info['user_id']).put()
else:
likes[0].key.delete()
self.redirect(self.uri_for('home'))
def add_like():
"""Add like to comment."""
comment_id = request.json["comment_id"]
new_like = Like(comment_id=comment_id, user_id=g.user.id)
db.session.add(new_like)
db.session.commit()
return ({"success": {"added_like": comment_id}})
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)
def add_fam_like(content,author, poet):
"""Add a like to quote from the api - they do not have ids from the api so they must be stored in the database"""
quote = Quote.handle_api_quote(content=content, author=author)
like = Like(poet_id=poet.id, quote_id=quote.id, is_user_quote=False)
db.session.add(like)
db.session.commit()
def like(eventId):
if session.get("user"):
like = Like(session["user_id"], eventId)
db.session.add(like)
db.session.commit()
return redirect(url_for('getHome'))
else:
return redirect(url_for('login'))
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))
def test_likes_relationship(self):
""" tests if the likes relationship is functional """
l1 = Like(user_id=1000, msg_id=1000001)
db.session.add(l1)
db.session.commit()
self.assertEqual(self.m1.likes, [l1])
def add_like():
post = Post.query.get(request.form.get("post_id"))
if not post:
abort(404)
like = Like(post.id, current_user.id)
user = User.query.get(post.author.id)
user.likes_value = user.likes_value + 1
db.session.add(like)
db.session.commit()
return "1"
def test_is_liked_by_true(self):
"""Does the is_liked_by work for the message model"""
m1 = Message.query.get(99999)
u2 = User.query.get(88888)
# setting up u2 to like m1:
like = Like(user_id=88888, mes_id=99999)
db.session.add(like)
db.session.commit()
self.assertEqual(m1.is_liked_by(u2), True)
def like(request, pk):
comment = get_object_or_404(Comment, pk=pk)
topic_user = request.user.topic_user(comment.topic)
for c in Dislike.objects.filter(user=topic_user, comment=comment):
c.active = False
c.save()
if comment.liked_by.filter(pk=topic_user.pk).count() < 1:
Like(user=topic_user, comment=comment).save()
comment.save()
return HttpResponse("")
def setup_likes(self):
m1 = Message(text="trending warble", user_id=self.testuser_id)
m2 = Message(text="Eating some lunch", user_id=self.testuser_id)
m3 = Message(id=9876, text="likable warble", user_id=self.u1_id)
db.session.add_all([m1, m2, m3])
db.session.commit()
l1 = Like(user_id=self.testuser_id, message_id=9876)
db.session.add(l1)
db.session.commit()
def like_msg(id):
if not g.user:
flash("Access unauthorized.", "danger")
return redirect("/")
likes = Like(user_id=g.user.id, message_id=id)
db.session.add(likes)
db.session.commit()
# return redirect(f"/messages/{id}")
return redirect(url_for('messages_show', message_id=id))
