def new_like():
user_id = request.json.get("user_id", None)
existing_user = User.get_or_none(User.id == user_id)
chef_id = request.json.get("chef_id", None)
existing_chef = Chef.get_or_none(Chef.id == chef_id)
existing_like = Like.get_or_none(Like.user_id == user_id,
Like.chef_id == chef_id)
if existing_user == None:
return jsonify({
"message": "User does not exist",
"status": "failed"
}), 400
if existing_chef == None:
return jsonify({
"message": "Chef does not exist",
"status": "failed"
}), 400
if existing_user and existing_chef:
if existing_like:
return jsonify({
"message": "User already liked this chef",
"status": "failed"
}), 400
else:
new_like = Like(user=user_id, chef=chef_id)
if new_like.save():
return jsonify({
"message": "Liked successfully",
"status": "Success"
})
def like(self, status):
"""
user: UserProfile - User liking the status
Returns True if the action was successful
"""
# Check if the user already liked it
if Like.get_or_none(user=self.user, status=status):
return False
# First we create the like object
Like.create(
user=self.user,
status=status,
)
# Update the counter in the object
Status.update({
Status.favourites_count: Status.favourites_count + 1
}).where(Status.id == status.id)
# Create a redis notification
like_status(status, self.user)
return True
def create_like(user_id):
liked_user = User.get_by_id(user_id) # Check if user exists
has_photo = Like.able_to_like(
g.current_user.id) # Check if user has profile image
is_blocked = User.user_is_blocked(g.current_user.id,
user_id) # Check if user was blocked
if is_blocked:
abort(http.HTTPStatus.FORBIDDEN)
if not has_photo:
abort(http.HTTPStatus.FORBIDDEN)
if liked_user and has_photo:
Like.like(g.current_user.id, user_id)
# If user is not blocked [blocked, blocker]
# Notification
if not is_blocked:
text = Notification.notification_text('like', g.current_user)
notification = Notification.from_dict({
"user_id": user_id,
"text": text,
"type": "like"
})
notification.create()
return jsonify(ok=True)
abort(http.HTTPStatus.BAD_REQUEST)
def post(self, post_id):
if not self.user:
return self.redirect('/login')
key = ndb.Key('Post', int(post_id), parent=utils.blog_key())
postEnt = key.get()
if not postEnt:
self.error(404)
return self.render('404.html')
if self.user:
if postEnt.author == self.user.name:
error = "You cannot like your own post"
url = '/blog/%s?error=%s' % (str(postEnt.key.id()), error)
self.redirect(url)
return
else:
query = Like.query(Like.userId == self.user.key.id(),
Like.postId == key.id()).get()
if query:
error = "You already like the post"
self.redirect('/blog/%s?error=%s' %
(str(postEnt.key.id()), error))
return
else:
l = Like(parent=utils.like_key(),
userId=self.user.key.id(),
postId=key.id())
l.put()
postEnt.likes += 1
postEnt.put()
time.sleep(0.1)
self.redirect('/blog/%s' % str(postEnt.key.id()))
def test_get_all_event_joined_by_user_1(self):
"""
Test get_all_ongoing_event_by_user
Case1: user has joined some events
"""
latitude = 40.730610
longitude = -73.935242
for i in range(5):
latitude += 0.01
longitude += 0.01
time = datetime.strptime("2020-12-12 12:12:12", "%Y-%m-%d %H:%M:%S")
tmp_event = Event(user=self.useremail,
name="testevent" + str(i),
address="address" + str(i),
zipcode=10025,
event_time=time,
longitude=longitude,
latitude=latitude)
tmp_event.category = "test"
tmp_event_id = Event.create_event(tmp_event)
self.event_ids.append(tmp_event_id)
join = Join(self.useremail, tmp_event_id)
Join.create_join(join)
if i % 2 == 0:
like = Like(self.useremail, tmp_event_id)
Like.create_like(like)
result = Event.get_all_event_joined_by_user(self.useremail)
for res in result:
self.assertTrue(res.event_id in self.event_ids)
self.assertEqual(5, len(result))
def get_posts_likes():
try:
# get data from client - contains a post id
data = request.get_json()
# tries to get post by its id
post = Post.get(Post.id == data['post'], Post.soft_delete == False)
# iterate through all of the posts likes, convert each like
# to a dictionary, remove the users password, and append to the list
likes_list = []
for like in post.likes:
like_dict = model_to_dict(like)
Like.remove_passwords(like_dict)
likes_list.append(like_dict)
return jsonify(data=likes_list,
status={
'code': 200,
'message': 'Succesfully got likes.'
})
# exception thrown if the post doesnt exist
except DoesNotExist:
return jsonify(data={},
status={
'code': 404,
'message': 'Failure to get resource.'
})
def users_can_chat(user_id):
sender_id = g.current_user.id
receiver_id = user_id
if (Like.is_liked(sender_id, receiver_id) and Like.is_liked(receiver_id, sender_id)) \
and not (User.user_is_blocked(sender_id, receiver_id) or User.user_is_blocked(receiver_id, sender_id)):
return jsonify(ok=True)
return jsonify(ok=False)
def test_get_all_event_liked_by_user_1(self):
"""
Test get_all_event_liked_by_user
Case1: user exists, and user has liked some events
"""
latitude = 40.730610
longitude = -73.935242
for i in range(10):
time = datetime.strptime("2020-12-12 12:12:12", "%Y-%m-%d %H:%M:%S")
tmp_event = Event(user=self.useremail,
name="testevent" + str(i),
address="address" + str(i),
zipcode=10025,
event_time=time,
longitude=longitude + i,
latitude=latitude + i)
tmp_event.category = "test"
tmp_event_id = Event.create_event(tmp_event)
self.event_ids.append(tmp_event_id)
like = Like(self.useremail, tmp_event_id)
Like.create_like(like)
result = Event.get_all_event_liked_by_user(self.useremail)
for res in result:
self.assertTrue(res.event_id in self.event_ids)
self.assertEqual(10, len(result))
def get(self, post_id):
key = db.Key.from_path('Post', int(post_id), parent=blog_key())
post = db.get(key)
if self.user and self.user.key().id() == post.user_id:
error = "Sorry, you cannot like your own post."
self.render('base.html', access_error=error)
elif not self.user:
self.redirect('/login')
else:
user_id = self.user.key().id()
post_id = post.key().id()
like = Like.all().filter('user_id =',
user_id).filter('post_id =',
post_id).get()
if like:
self.redirect('/' + str(post.key().id()))
else:
like = Like(parent=key,
user_id=self.user.key().id(),
post_id=post.key().id())
post.likes += 1
like.put()
post.put()
self.redirect('/' + str(post.key().id()))
def get(self):
jinja = jinja2.get_jinja2(app=self.app)
valores_plantilla = {}
if self.request.GET.keys():
usuario = Usuario.recuperar(self.request, "id_usuario")
libro = Libro.recuperar(self.request, "id_libro")
like = Like(libro=libro.key, usuario=usuario.key)
tiene_likes = Like.query(Like.libro == libro.key,
Like.usuario == usuario.key)
if libro.creador == usuario.key:
print("NO PUEDES DAR LIKE A TU LIBRO")
else:
if tiene_likes.count() == 0:
print("LE DISTE LIKE")
like.put()
else:
print("YA TIENE TU LIKE")
return self.redirect('/?id={}'.format(usuario.key.urlsafe()),
body={"mira": "pepe"})
else:
self.redirect('/')
def like(tid):
u = current_user()
Like.like(u.id, tid)
t = Topic.one(id=tid)
Topic.update(tid, heat=t.heat + 3)
flash('点赞影评成功')
return redirect(url_for('.detail', tid=tid))
def post(self):
if not self.user:
return self.redirect('/blog')
subject = self.request.get('subject')
content = self.request.get('content')
user_id = self.read_secure_cookie('user_id')
if subject and content:
p = Post(parent=blog_key(),
user_id=user_id,
subject=subject,
content=content)
p.put()
like_count = 0
post_id = str(p.key().id())
l = Like(like_count=like_count,
post_id=post_id) # Create the like entity for this post
l.put()
time.sleep(0.1)
return self.redirect('/blog/%s' % str(p.key().id()))
else:
error = "subject and content, please!"
self.render("newpost.html",
subject=subject,
content=content,
error=error)
def test_get_like_by_user_2(self) -> None:
"""
Test get_like_by_user: user doesn’t exist
"""
Like.create_like(Like(self.user, self.event))
likes = Like.get_like_by_user('1')
events = [like.event for like in likes]
self.assertListEqual(events, [])
def test_get_like_by_user_1(self) -> None:
"""
Test get_like_by_user: user exists
"""
Like.create_like(Like(self.user, self.event))
likes = Like.get_like_by_user(self.user)
events = [like.event for like in likes]
self.assertListEqual(events, [self.event])
def test_get_like_by_event_1(self) -> None:
"""
Test get_like_by_event: event exists
"""
Like.create_like(Like(self.user, self.event))
likes = Like.get_like_by_event(self.event)
users = [like.user for like in likes]
self.assertListEqual(users, [self.user])
def test_get_like_by_event_2(self) -> None:
"""
Test get_like_by_event: event doesn’t exist
"""
Like.create_like(Like(self.user, self.event))
likes = Like.get_like_by_event('1')
users = [like.user for like in likes]
self.assertListEqual(users, [])
def test_get_post_likes(self):
self.db.session.add(Like(id=1, user_id=1, post_id="1"))
self.db.session.add(Like(id=2, user_id=2, post_id="1"))
response = self.app.get("/post/1/likes")
self.assertEqual(response.status_code, 200)
like_list = json.loads(str(response.data, "utf8"))
self.assertEqual(type(like_list), list)
self.assertDictEqual(like_list[0], {"id": "1", "user_id": "1", "post_id": "1"})
def setUp(self):
self.db = tested_db
self.db.create_all()
self.db.session.add(User(id=1, name="Alice"))
self.db.session.add(User(id=2, name="Bob"))
self.db.session.add(Post(id=1, user_id=1, text="Post1"))
self.db.session.add(Post(id=2, user_id=1, text="Post2"))
self.db.session.add(Like(id=1, user_id=2, post_id=1))
self.db.session.add(Like(id=2, user_id=2, post_id=2))
self.db.session.commit()
self.app = tested_app.test_client()
def get_likes():
params = request.args
if 'user_id' in params:
posts = Like.get_posts_liked_by(params['user_id'])
if posts is None:
return jsonify({'error': 'User not found'}), 400
return jsonify(posts), 200
elif 'post_id' in params:
users = Like.get_likes_of_post(params['post_id'])
if users is None:
return jsonify({'error': 'Post not found'}), 400
return jsonify(users), 200
likes = Like.get_all_likes()
return jsonify(likes), 200
def add_like():
id = int(request.args.get('id'))
u = current_user()
t = Topic.one(id=id)
user = User.one(id=t.user_id)
form = {'topic_id': t.id, 'num': 1}
l = Like.one(topic_id=t.id, user_id=u.id)
if l is None:
Like.new(form, u.id)
send_like(u, user, id, '')
else:
Like.delete(l.id)
return redirect(url_for('.detail_like', id=t.id))
def get(self, blog_id):
if self.user:
username = self.user.name
key = db.Key.from_path("Blog", int(blog_id), parent=blog_key())
post = db.get(key)
if not post:
self.redirect("/accessdenied")
likes = Like.by_blog_id(post)
unlikes = Unlike.by_blog_id(post)
post_comments = Comment.all_by_blog_id(post)
comments_count = Comment.count_by_blog_id(post)
if self.user:
self.render("post.html",
post=post,
likes=likes,
unlikes=unlikes,
post_comments=post_comments,
comments_count=comments_count,
username=username)
else:
self.render("post.html",
post=post,
likes=likes,
unlikes=unlikes,
post_comments=post_comments,
comments_count=comments_count)
def get(self, post_id):
key = db.Key.from_path('Post', int(post_id), parent=blog_key())
post = db.get(key)
# Post variable to regenerate front page with posts.
posts = db.GqlQuery(
"select * from Post order by created desc limit 10")
# Render front again with error if user tries to unlike thier own post.
if self.user and self.user.key().id() == post.user_id:
error = "Sorry, you cannot unlike your own post."
self.render('front.html', posts=posts, access_error=error)
elif not self.user:
self.redirect('/login')
else:
user_id = self.user.key().id()
post_id = post.key().id()
# Filter to see which posts a user has already liked.
l = Like.all().filter('user_id =',
user_id).filter('post_id =', post_id).get()
# Remove like value by 1 and render post page again.
if l:
l.delete()
post.likes -= 1
post.put()
self.redirect('/' + str(post.key().id()))
else:
self.redirect('/' + str(post.key().id()))
def liked(self, user_id):
l = Like.one(topic_id=self.id, user_id=user_id)
print('topic liked', user_id, self.id, l)
if l is None:
return False
else:
return True
def get(self, post_id, post_user_id):
""" If the user is signed in and authored the post, delete the post and
redirect the user to the homepage. Otherwise, send non-signed in users
to the login page. For all other cases go back to the current page with
a permission error. """
if self.user and self.user.key().id() == int(post_user_id):
postkey = db.Key.from_path('Post', int(post_id), parent=blog_key())
post = db.get(postkey)
comments = Comment.all().filter('post =', postkey)
likes = Like.all().filter('post_id =', post.key().id())
if post:
delete_dependents(comments=comments, likes=likes)
post.delete()
return self.redirect('/')
elif not self.user:
return self.redirect("/login")
else:
postkey = db.Key.from_path('Post', int(post_id), parent=blog_key())
post = db.get(postkey)
error_msg = "You do not have permission to delete this post"
comments = db.GqlQuery(
"select * from Comment where ancestor is :1 order by created desc limit 10", postkey) # NOQA
self.render("permalink.html", post=post, comments=comments,
error_msg=error_msg)
def get(self, post_id):
""" If the user is signed in and has authored the post render the
basetemplate with an error message as they can't unlike their own posts.
Pass the user to the sign in page if the user isn't signed in.
Lookup whether the user has liked the post. If liked, delete the like
from the db and deincrement the like_count in the post model """
postkey = db.Key.from_path('Post', int(post_id), parent=blog_key())
post = db.get(postkey)
if post is not None:
if self.user and self.user.key().id() == post.user_id:
self.write("You cannot unlike your own post")
elif not self.user:
return self.redirect('/login')
else:
user_id = self.user.key().id()
post_id = post.key().id()
l = LikeModel.all().filter(
'user_id =', user_id).filter('post_id =', post_id).get()
if l:
l.delete()
post.like_count -= 1
post.put()
return self.redirect('/' + str(post.key().id()))
else:
self.redirect('/' + str(post.key().id()))
async def get(self, user):
#r = await aioredis.create_connection(
# f"redis://{os.environ.get('REDIS_HOST', 'localhost')}",
# loop=IOLoop.current().asyncio_loop,
# encoding='utf-8'
#)
local = self.get_argument('media_ids', False)
max_id = self.get_argument('max_id', None)
since_id = self.get_argument('since_id', None)
limit = self.get_argument('limit', 20)
statuses = []
errors = 0
for post in TimelineManager(user).query(since_id=since_id,
max_id=max_id,
local=True,
limit=limit):
status = Status.get_or_none(id=int(post))
if status:
json_data = status.to_json()
count = await self.application.objects.count(
Like.select().join(UserProfile).switch(Like).join(
Status).switch(Like).where(Like.user.id == user.id,
Like.status.id == status))
if count:
json_data["favourited"] = True
statuses.append(json_data)
self.write(json.dumps(statuses, default=str))
def get(self, post_id):
key = db.Key.from_path('Post', int(post_id), parent=blog_key())
post = db.get(key)
if not (post is None) and self.user and self.user.key().id(
) == post.user.key().id():
if post:
db.delete(key)
time.sleep(0.1)
self.redirect('/')
else:
self.response.out.write("Not a valid post!")
# otherwise if the user is not logged in take them to the
# login page
elif not self.user:
self.redirect("/login")
else:
error = "You cannot delete other user's posts"
likes = like = Like.all().filter('post_id =', post_id).get()
comments_count = Comment.count_by_post_id(post)
post_comments = Comment.all_by_post_id(post)
self.render("post.html",
post=post,
likes=likes,
comments_count=comments_count,
post_comments=post_comments,
error=error)
def get(self, user_key):
""" Get all posts of a given user
:param user_key:
Key of the user we want to get all posts
"""
user = User.get(user_key)
posts = Post.get_all(user=user)
pagination = Pagination(self.request.GET.get('p'), posts.count())
if pagination and pagination.is_valid():
posts = posts.fetch(limit=pagination.posts_per_page,
offset=pagination.offset)
nb_likes = Like.get_nb_likes_per_posts(posts)
nb_comments = Comment.get_nb_comments_per_posts(posts)
self.render("posts/user.html",
userposts=user,
posts=posts,
nb_likes=nb_likes,
nb_comments=nb_comments,
pagination=pagination)
else:
self.abort(404, "Invalid page number")
def get(self, post_id):
post_key = db.Key.from_path('Post', int(post_id))
post = db.get(post_key)
#Get all comments for post id
comments = Comment.all().filter('post =', post_key)
comments.order("-created")
#check if post exists
if not self.post_exists(post_id):
page_error = 'This post does not exist !'
return self.render('login-form.html', page_error = page_error)
user_id = self.read_secure_cookie('user_id')
author_id = post.author.key().id()
edit = False
#check if logged in user is the author of the post
#if the user is the author he can edit and/or delete the post
if user_id:
if (long(user_id) == author_id):
edit = True
#number of likes
post = Post.by_id(post_id)
likes = Like.all().filter('post =', post).count()
self.render("permalink.html", post = post, comments = comments, edit = edit, likes = likes)
def get(self, post_id):
key = db.Key.from_path('Post', int(post_id), parent=blog_key())
post = db.get(key)
comments_count = Comment.count_by_post_id(post)
post_comments = Comment.all_by_post_id(post)
if post:
if self.user and self.user.key().id() == post.user.key().id():
error = "You cannot dislike your own post"
self.render("post.html",
post=post,
comments_count=comments_count,
post_comments=post_comments,
error=error)
elif not self.user:
self.redirect('/login')
else:
l = Like.all().filter('user ='******'post =', post).get()
if l:
l.delete()
post.likes -= 1
post.put()
self.redirect('/post/' + str(post.key().id()))
else:
self.redirect('/post/' + str(post.key().id()))
def post(self, submission_id, **kwargs):
'''
allows the user to add a like to a blog entry.
the user is only allowed to like a post once
'''
submission = kwargs['submission']
for like in submission.likes:
if self.user.key().id() == like.user.key().id():
self.redirect('/%s' % submission_id)
return
like = Like(submission=submission, user=self.user)
like.put()
time.sleep(0.1)
self.redirect('/%s' % submission_id)
def post(self, submission_id, **kwargs):
'''
delete the appropriate submission instance in the db, and
also delete all of its associated comments and likes in the db
'''
submission = kwargs['submission']
comments = Comment.all().filter('submission =', submission)
likes = Like.all().filter('submission =', submission)
db.delete(submission)
db.delete(comments)
db.delete(likes)
time.sleep(0.1)
self.redirect('/')
def post(self):
"""The post request is made when someone clicks on like button"""
if self.authenticated():
post_id = self.request.get("like")
post = Post.get_by_id(int(post_id))
# creator of the post can not like his/her own posts
if not post.author.username == self.user.username:
likes = post.likes.get()
if likes:
# user can not like a post more than once
if not likes.voter.username == self.user.username:
like_new = Like(post = post, voter = self.user)
like_new.put()
else:
like_new = Like(post = post, voter = self.user)
like_new.put()
self.redirect("/blog")
else:
#if the user is not authenticated perform login page redirect
self.login_redirect()
