def test_show_likes(self):
"""Does messages the user liked show up?"""
u3 = User.signup("testuser3", "*****@*****.**", "password3", None)
u3.id = 4545
u4 = User.signup("abcdef", "*****@*****.**", "password4", None)
u4.id = 5656
db.session.add_all([u3, u4])
db.session.commit()
m1 = Message(text='message one for testuser1', user_id=1212)
m1.id = 111
m2 = Message(text='message one for testuser2', user_id=2323)
m2.id = 222
m3 = Message(text='message two for testuser2', user_id=2323)
m3.id = 333
m4 = Message(text='message one for testuser3', user_id=4545)
m4.id = 444
m5 = Message(text='message one for abcdef', user_id=5656)
m5.id = 555
db.session.add_all([m1, m2, m3, m4, m5])
db.session.commit()
l1 = Likes(user_id=1212, message_id=222)
l1.id = 12
l2 = Likes(user_id=1212, message_id=444)
l2.id = 34
l3 = Likes(user_id=1212, message_id=555)
l3.id = 45
db.session.add_all([l1, l2, l3])
db.session.commit()
with self.client as c:
with c.session_transaction() as sess:
sess[CURR_USER_KEY] = self.u1.id
resp = c.get(f"/users/{self.u1.id}/likes")
html = resp.get_data(as_text=True)
self.assertEqual(resp.status_code, 200)
self.assertIn('message one for testuser2', html)
self.assertIn('message one for testuser3', html)
self.assertIn('message one for abcdef', html)
self.assertNotIn('message one for testuser1', html)
self.assertNotIn('message two for testuser2', html)
def setUp(self):
"""Create test client, add sample data"""
User.query.delete()
Message.query.delete()
Follows.query.delete()
Likes.query.delete()
# OR
# db.drop_all()
# db.create_all()
self.client = app.test_client()
self.testuser_1 = User.signup(username="******",
email="*****@*****.**",
password="******",
image_url=None)
self.testuser_2 = User.signup(username="******",
email="*****@*****.**",
password="******",
image_url=None)
db.session.commit()
self.testuser_1.following.append(self.testuser_2)
self.testmessage_1 = Message(text="This is the first test message!",
user_id=self.testuser_1.id)
self.testmessage_2 = Message(text="This is the second test message!",
user_id=self.testuser_2.id)
db.session.add(self.testmessage_1)
db.session.add(self.testmessage_2)
db.session.commit()
like_1 = Likes(user_id=self.testuser_1.id,
message_id=self.testmessage_2.id)
like_2 = Likes(user_id=self.testuser_2.id,
message_id=self.testmessage_1.id)
db.session.add(like_1)
db.session.add(like_2)
db.session.commit()
def add_like():
ret = {"error": 0}
try:
report_id = int(request.form['report_id'])
user_id = int(request.form['user_id'])
value = int(request.form['value'])
flag_value = int(request.form["flag_value"])
# check if like for same report exists by this user
like = Likes.query.filter_by(user=user_id).\
filter_by(report=report_id).first()
if like:
print "[add_like] User already had liked/disliked this report"
like.value = value
else:
like = Likes(report_id, user_id, value, flag_value)
db.session.add(like)
db.session.commit()
ret["msg"] = "The Like and flag is added successfully"
except Exception as exp:
print("add_like() :: exp: %s" % exp)
print(traceback.format_exc())
ret["error"] = 1
ret["msg"] = "Got exception: %s" % exp
return json.dumps(ret)
def test_is_liked_by(self):
"""Does the is_liked_by work"""
u = self.user
u2 = User(email="*****@*****.**",
username="******",
password="******")
m = Message(user_id=u.id, text='test content')
db.session.add_all([u2, m])
db.session.commit()
#not like
self.assertEqual(len(u2.likes), 0)
self.assertEqual(len(m.likes_users), 0)
self.assertEqual(u2.is_like(m), False)
self.assertEqual(m.is_liked_by(u2), False)
like = Likes(user_id=u2.id, message_id=m.id)
db.session.add(like)
db.session.commit()
self.assertEqual(len(u2.likes), 1)
self.assertEqual(len(m.likes_users), 1)
self.assertEqual(u2.is_like(m), True)
self.assertEqual(m.is_liked_by(u2), True)
def setUp(self):
db.drop_all()
db.create_all()
self.client = app.test_client()
user_1 = User.signup("user1",'*****@*****.**','password')
user_2 = User.signup("user2",'*****@*****.**','password')
user_3 = User.signup("user3",'*****@*****.**','password')
db.session.add_all([user_1,user_2,user_3])
db.session.commit()
self.user_1 = user_1
self.user_2 = user_2
self.user_3 = user_3
area_1 = Area(city="Irvine", state="CA")
self.user_2.areas.append(area_1)
db.session.commit()
self.area_1 = area_1
area_2 = Area(city="Irvine", state="CA")
self.user_3.areas.append(area_2)
db.session.commit()
self.area_2 = area_2
d = {"googlePlaceId":"ChIJ9f9zhYDb3IARfXSrxrDSdq4","name":"Lazy Dog Restaurant & Bar","address":"address"}
rest_1 = Restaurant(name=d['name'],address=d['address'], google_place_id=d['googlePlaceId'],user_id=self.user_3.id, area_id=self.area_2.id)
db.session.add(rest_1)
db.session.commit()
self.rest_1 = rest_1
like = Likes(user_id=user_3.id, restaurant_id=rest_1.id)
db.session.add(like)
db.session.commit()
def test_users_likes_logged_in(self):
"""A logged in user should be able to see any user's liked warbles"""
user1_id = self.user1.id
user2_id = self.user2.id
message = Message(text="Test warble to like",
timestamp=None,
user_id=user1_id)
db.session.add(message)
db.session.commit()
like = Likes(user_id=user2_id, message_id=message.id)
db.session.add(like)
db.session.commit()
with self.client as c:
with c.session_transaction() as sess:
sess[CURR_USER_KEY] = user1_id
resp = c.get(f'/users/{user2_id}/likes')
html = resp.get_data(as_text=True)
self.assertEqual(resp.status_code, 200)
self.assertIn("Test warble to like", html)
def likepost(post_id):
if request.method=="POST":
like=Likes(current_user.id,post_id)
db.session.add(like)
db.session.commit()
count=countlikes(post_id)
return jsonify(response=[{'message':'Post Liked','Likes':count}])
def test_delete_messages_likes(self):
"""test if message got deleted by the user and it deletes from likes table"""
u = User(email="*****@*****.**",
username="******",
password="******")
db.session.add(u)
db.session.commit()
u2 = User(email="*****@*****.**",
username="******",
password="******")
db.session.add(u2)
db.session.commit()
follow = Follows(user_being_followed_id=u.id, user_following_id=u2.id)
db.session.add(follow)
db.session.commit()
m = Message(text="warblewarble", user_id=u.id)
db.session.add(m)
db.session.commit()
l = Likes(user_that_liked=u2.id, message_liked=m.id)
db.session.add(l)
db.session.commit()
self.assertEqual(len(u2.likes), 1)
db.session.delete(m)
db.session.commit()
self.assertEqual(len(u2.likes), 0)
self.assertEqual(len(u.messages), 0)
def setUp(self):
"""Create test client, add sample data."""
db.drop_all()
db.create_all()
user = User.signup(username="******",
email="*****@*****.**",
password="******",
image_url=None)
user.id = 1000
self.user_id = user.id
db.session.commit()
message = Message(text="Test Message", user_id=1000)
message.id = 2000
self.message_id = message.id
db.session.add(message)
db.session.commit()
self.user1 = User.query.get(self.user_id)
like = Likes(user_id=self.user1.id, message_id=self.message_id)
like.id = 2000
self.like_id = like.id
db.session.add(like)
db.session.commit()
self.client = app.test_client()
def test_show_likes(self):
msg1 = Message(text="Message 1", user_id=self.testuser1.id)
msg2 = Message(text="Message 2", user_id=self.testuser1.id)
db.session.add_all([msg1, msg2])
db.session.commit()
# user2 likes user1's message
likes = Likes(user_id=self.testuser2.id, message_id=msg1.id)
db.session.add(likes)
db.session.commit()
invalid_id = self.testuser1.id + self.testuser2.id
with self.client as c:
# log in
with c.session_transaction() as sess:
sess[CURR_USER_KEY] = self.testuser1.id
resp = c.get(f"/users/{invalid_id}/likes")
self.assertEqual(resp.status_code, 404)
resp = c.get(f"/users/{self.testuser2.id}/likes")
html = resp.get_data(as_text=True)
self.assertEqual(resp.status_code, 200)
self.assertIn("Message 1", html)
self.assertNotIn("Message 2", html)
self.assertIn(self.testuser1.username, html)
self.assertIn(self.testuser2.username, html)
def message_like(message_id):
"""Like or stop liking a message"""
# must be logged in to like or stop liking a message
if not g.user:
flash("Access unauthorized.", "danger")
return redirect("/")
# if the logged in user already likes the message, stop liking
if message_id in [like.id for like in g.user.likes]:
like_to_delete = Likes.query.filter(
Likes.user_id == g.user.id,
Likes.message_id == message_id).first()
db.session.delete(like_to_delete)
db.session.commit()
# if the message is not authored by the user, like it
elif message_id not in [msg.id for msg in g.user.messages]:
like_to_add = Likes(user_id=g.user.id, message_id=message_id)
db.session.add(like_to_add)
db.session.commit()
# if the message is authored by the logged in user, take them down a peg
else:
flash("You can't like your own warble", "danger")
return redirect('/')
def get(self, post_id):
"""
get: Get
Args:
self: This object
post_id: Post ID
"""
if not self.user:
return self.redirect('/login')
key = db.Key.from_path('Post', int(post_id), parent=blog_key())
b = db.get(key)
if not b:
self.render('notfound.html')
return
#
# Check that user IDs do not match
#
user_id = self.user.key().id()
if b.user_id == user_id:
return self.redirect('/blog/%s' % str(b.key().id()))
if b.is_liked_by_user(user_id) == 'Liked':
return self.redirect('/blog/%s' % str(b.key().id()))
l = Likes(parent=blog_key(),
post_id=int(post_id),
user_id=int(user_id))
l.put()
self.redirect('/blog/%s' % str(b.key().id()))
def add_like(msg_id):
"""Add a like to a message"""
if g.user:
new_like = Likes(user_id=g.user.id, message_id=msg_id)
db.session.add(new_like)
db.session.commit()
return redirect(f'/messages/{msg_id}')
def setup_recommendations_and_likes(self):
"""This method sets up recommendationss to be tested in
other test methods.
"""
r1 = Recommendation(
title="Fire Doughnuts in Canada",
content=
"Ever tried jerk flavored doughnuts?, then you haven't lived!. Marley's yard gotchu!",
business_name="Marleys Yard",
business_address="2345 67 Ave NW",
business_city="Edmonton",
business_state="Alberta",
business_country="Canada",
business_rating=4,
user_id=self.testuser_id)
r2 = Recommendation(
id=365,
title="Deep Dish Pizza in Edmonton, Canada",
content=
"Looking for delicious deep dish pizza?, Chicago 001 has the best on Whyte Ave",
business_name="Chicago 001",
business_address="1946 Whyte Ave NW",
business_city="Edmonton",
business_state="Alberta",
business_country="Canada",
business_rating=5,
user_id=self.u2id)
db.session.add_all([r1, r2])
db.session.commit()
l1 = Likes(user_id=self.testuser_id, recommendation_id=365)
db.session.add(l1)
db.session.commit()
def likepost(post_id):
if request.method == "POST":
like = Likes(session['userid'], post_id)
db.session.add(like)
db.session.commit()
count = countlikes(post_id)
return jsonify(response=[{'message': 'Post Liked'}])
def add_like(message_id):
""" Add like to "likes" table"""
if not g.user:
flash("Access unauthorized.", "danger")
return redirect("/")
# query for record in "likes" table that matches user id and message id of
# tweet the user just clicked on the thumbs up icon. if record found returns
# that record, if record not found returns None.
like_rec_test = Likes.query.filter(Likes.user_id == g.user.id,
Likes.message_id == message_id).first()
# if record found, user clicked on icon for messaged already "liked", therefore
# user wants to "unlike" message so remove record from likes table. If none, this
# is a new "like"
if like_rec_test:
db.session.delete(like_rec_test)
db.session.commit()
return redirect("/")
# if matching record not found in likes table create new
# entry in likes table
like = Likes(user_id=g.user.id, message_id=message_id)
db.session.add(like)
db.session.commit()
return redirect("/")
def set_up_likes(self):
"""set up likes"""
like = Likes(user_id=self.user_id, message_id=self.message_id)
like.id = 4000
self.like_id = like.id
db.session.add(like)
db.session.commit()
def like_message(message_id):
"""Like another users message"""
if not g.user:
flash("Access unauthorized.", "danger")
return redirect("/")
message = Message.query.get_or_404(message_id)
if g.user.id == message.user.id:
flash("Cannot like your own message", "danger")
return redirect("/")
#check if user already liked warble
already_liked = Likes.query.filter(Likes.user_id == g.user.id).filter(
Likes.message_id == message.id).first()
if already_liked:
flash("You have already liked that post", "danger")
return redirect("/")
like = Likes(user_id=g.user.id, message_id=message.id)
db.session.add(like)
db.session.commit()
return jsonify(data=f""" <form
action="/users/remove_like/{message.id}"
method="post"
id="messages-form"
>
<button class="btn btn-sm btn-danger">
<i class="fas fa-heart"></i>
</button>
</form>""")
def like_message(review_id):
"""Like/"cheers" a message."""
if not g.user:
flash("Access unauthorized.", "danger")
return redirect("/")
#prevent user from liking their own message
# m = Message.query.get(message_id)
# if m in g.user.messages:
# flash("You cannot like your own message.", "danger")
# return redirect ("/")
#logic to unlike if the liked message is already an instance of the Likes class
if Likes.query.filter_by(user_id=g.user.id, reviews_id=review_id).all():
liked_msg=Likes.query.filter_by(user_id=g.user.id, reviews_id=review_id).one()
db.session.delete(liked_msg)
db.session.commit()
return redirect('/')
#like the message otherwise
liked_msg=Likes(user_id=g.user.id, reviews_id=review_id)
db.session.add(liked_msg)
db.session.commit()
return redirect("/")
def test_message_like_logged_in_already_liked(self):
"""A logged in user should be able to stop liking a message."""
user1 = User(username="******", password="******", email="*****@*****.**")
db.session.add(user1)
db.session.commit()
message = Message(text='Like me.', user_id=user1.id)
db.session.add(message)
db.session.commit()
follow = Follows(user_being_followed_id=user1.id, user_following_id=self.testuser.id)
db.session.add(follow)
db.session.commit()
like = Likes(user_id=self.testuser.id, message_id=message.id)
db.session.add(like)
db.session.commit()
message_id = message.id
with self.client as c:
with c.session_transaction() as sess:
sess[CURR_USER_KEY] = self.testuser.id
resp = c.post(f'/users/add_like/{message_id}', follow_redirects=True)
html = resp.get_data(as_text=True)
self.assertEqual(resp.status_code, 200)
self.assertNotIn('btn-primary', html)
def add_like_message(message_id):
# If user is logged in:
# If user_id & message_id is not in liked table (i.e., not already marked as liked)
# Add entry into Like_table
# Add flash message to indicate "Message was liked"
# Else:
# remove entry from the Like table
# Notes: - Add logic to '/' template to reflect if message has been liked
# - In profile view run query to get count total of likes and pass that value to profile template view for display
if not g.user:
flash("Access unauthorized.", "danger")
return redirect("/")
else:
like = Likes.query.filter_by(user_id=g.user.id,
message_id=message_id).first()
if like == None:
print('The value returnded for Likes search whas none')
like = Likes(user_id=g.user.id, message_id=message_id)
db.session.add(like)
db.session.commit()
else: # Record was unliked so remove entry in Likes table
db.session.delete(like)
db.session.commit()
return redirect('/')
def add_remove_like(message_id):
"""Add/Remove liked Warble to/from "likes" table"""
like_ids = [like.id for like in g.user.likes]
# Get the user_id from message_id
user = db.session.query(
Message.user_id).filter(Message.id == message_id).first()
# un-like a warble
if message_id in like_ids:
like = Likes.query.filter_by(message_id=message_id,
user_id=g.user.id).first()
db.session.delete(like)
db.session.commit()
return redirect("/")
# add a "like"
else:
# (a user may not "like" their own post)
if user.user_id != g.user.id:
like = Likes(user_id=g.user.id, message_id=message_id)
db.session.add(like)
db.session.commit()
return redirect("/")
def like_or_unlike_message(message_id):
""" like or unlike a message """
if not g.user:
flash("Access unauthorized.", "danger")
return redirect("/")
message = Message.query.get_or_404(message_id)
if g.user.id == message.user_id:
return redirect(request.referrer)
else:
like = Likes.query.filter_by(message_id=message_id).filter_by(
user_id=g.user.id).first()
if like:
db.session.delete(like)
else:
new_like = Likes(user_id=g.user.id, message_id=message_id)
db.session.add(new_like)
db.session.commit()
return redirect(request.referrer)
def get(self):
login = self.read_cookie('login')
uid = None
if login:
uid = int(login)
user = Users.get_by_id(uid)
post_id = self.request.get("p")
if post_id:
if uid:
post = Post.get_by_id(int(post_id))
if int(uid) == int(post.user.key().id()):
#your own post
self.redirect("/blog/" + post_id + "?e=like_own")
else:
likes = db.GqlQuery(
"select * from Likes where user = :1 and post = :2",
user.key(), post.key())
if likes.count() == 0:
new_like = Likes(post=post, user=user)
new_like.put()
self.redirect("/blog/" + str(post.key().id()))
else:
self.redirect("/blog/" + post_id + "?e=like_alrd")
else:
self.redirect("/blog/" + post_id + "?e=like_permission")
else:
self.redirect("/blog")
def test_message_model(self):
"""test the Message model"""
u1 = User.signup("test1", "*****@*****.**", "password", None)
u2 = User.signup("test2", "*****@*****.**", "password", None)
db.session.commit()
u1_id = u1.id
u2_id = u2.id
msg1 = Message(text="msgtext", timestamp=None, user_id=u1_id)
db.session.add(msg1)
db.session.commit()
msg1_id = msg1.id
self.assertEqual(msg1.user, u1)
self.assertEqual(len(u1.messages), 1)
self.assertEqual(u1.messages[0].text, "msgtext")
# test Likes model
like = Likes(user_id=u2_id, message_id=msg1_id)
db.session.add(like)
db.session.commit()
self.assertEqual(len(u2.likes), 1)
self.assertEqual(u2.likes[0], msg1)
# test function is_liked_by for User model
self.assertEqual(msg1.is_liked_by(u2), True)
def messages_add_like(message_id):
"""Add like to a message"""
if not g.user:
flash("Access unauthorized.", "danger")
return redirect("/")
msg = Message.query.get_or_404(message_id)
if g.user.id == msg.user_id:
flash("Can not like your own message!" , "danger")
return redirect('/')
if g.user.is_like(msg):
# alrealy like this message, unlike it
Likes.query.filter(Likes.user_id==g.user.id , Likes.message_id==msg.id).delete()
db.session.commit()
return redirect('/')
# like this message
like = Likes(user_id = g.user.id , message_id=message_id)
db.session.add(like)
db.session.commit()
return redirect('/')
def like_msg(message_id):
"""Like another users post."""
if not g.user:
flash("Access unauthorized.", "danger")
return redirect("/")
try:
message = Message.query.get(message_id)
if message.user_id == g.user.id:
return redirect(request.referrer)
like = Likes(user_id=g.user.id, message_id=message_id)
db.session.add(like)
db.session.commit()
return redirect(request.referrer)
except (IntegrityError, InvalidRequestError):
db.session.rollback()
liked_msg = Likes.query.get(message_id)
db.session.delete(liked_msg)
db.session.commit()
return redirect(request.referrer)
def test_show_likes(self):
with self.client as c:
with c.session_transaction() as sess:
sess[CURR_USER_KEY] = self.testuser.id
"""Create user and message to like"""
tempuser = User.signup(username="******",
email="*****@*****.**",
password="******",
image_url=None)
db.session.add(tempuser)
db.session.commit()
user = db.session.query(User).filter_by(username="******").first()
message = Message(text="Testmessage",user_id=user.id)
db.session.add(message)
db.session.commit()
testmessage = db.session.query(Message).first()
user = db.session.query(User).filter_by(username="******").first()
templike = Likes(user_id=self.testuser.id, message_id=testmessage.id)
db.session.add(templike)
db.session.commit()
testuser = db.session.query(User).filter_by(username='******').first()
self.assertEqual(testuser.likes[0].id, message.id)
resp = c.get(f"/users/{self.testuser.id}/likes")
self.assertEqual(resp.status_code, 200)
html = resp.get_data(as_text=True)
self.assertIn('<div class="message-area">', html)
def create_like(current_user, post_id):
userID = current_user.userID
postID = post_id
like = Likes(userID = userID, postID = postID)
db.session.add(like)
db.session.commit(like)
return jsonify ({'message': 'You liked a user post'})
def post(self):
cookie_user = self.get_user_from_cookie()
if cookie_user:
postID = self.request.get('postID')
post_obj = Post.get_by_id(int(postID))
like_obj = Likes.query(Likes.post == post_obj.key).get()
if post_obj.user == cookie_user.key:
self.write(json.dumps(({'like_count': -1})))
else:
if like_obj:
liked_by = like_obj.user_id
for u_id in liked_by:
if u_id == cookie_user.key.id():
self.write(json.dumps(({'like_count': -2})))
return
like_obj.like_count += 1
liked_by.append(cookie_user.key.id())
like_obj.put()
self.write(
json.dumps(({
'like_count': like_obj.like_count
})))
else:
like_obj = Likes(post=post_obj.key, like_count=1)
like_obj.user_id.append(cookie_user.key.id())
like_obj.put()
time.sleep(0.2)
self.write(
json.dumps(({
'like_count': like_obj.like_count
})))
else:
return None
