def test_create_like_for_comment(self):
"""Test creation of Like object for comment"""
Like()
like = Like(author=self.author,
object=self.comment,
object_type=Like.LIKE_COMMENT,
object_id=self.comment.split('/')[-1],
author_id=self.author_id)
self.assertEqual(like.type, 'like')
def test_create_like_for_post(self):
"""Test creation of Like object for post"""
Like()
like = Like(author=self.author,
object=self.post,
object_type=Like.LIKE_POST,
object_id=self.post.split('/')[-1],
author_id=self.author_id)
self.assertEqual(like.type, 'like')
def post(self, request):
if request.user.is_anonymous:
return Http404
try:
like = get_object_or_404(Like, author=request.user, photo=self.photo)
like.delete()
except Http404:
like = Like(author=request.user, photo=self.photo)
like.save()
return HttpResponse(self.photo.likes.count())
def test_add_like(self):
liker = User.objects.create_user("sample_user", "*****@*****.**", "1234")
popular = User.objects.create_user("popular_user", "*****@*****.**", "1234")
# test adding the like
like = Like()
like.user = liker
like.content_object = popular
like.save()
self.assertEqual(like.content_object, popular)
def post(self, request, *args, **kwargs):
user = request.user
like = Like.objects.filter(review_like_id=self.kwargs['id'],
user_like=user)
if len(like) == 0:
like = Like(review_like_id=self.kwargs['id'], user_like=user)
like.save()
else:
like[0].delete()
return Response(status=200)
def create_like(self, user, content_type_pk, object_id):
"""
creates the like object
useful method to create the like object without having the model instance
content_type_pk is the primary key of the content type
"""
from likes.models import Like
ct = ContentType.objects.get(pk=content_type_pk)
content_object = ct.get_object_for_this_type(id=object_id)
like = Like(user=user, content_object=content_object)
like.save()
return like
def like_view(request, slug):
if request.method == "POST":
post = Post.objects.get(slug=slug)
account = Account.objects.get(user=request.user)
qs = Like.objects.filter(post=post).filter(account=account)
if not qs.exists():
like = Like()
like.account = account
like.post = post
like.save()
post.likes += 1
post.save()
if like.account != post.account:
notf = Notification()
notf.account = post.account
notf.post = post
content = like.account.user.first_name + ' ' + like.account.user.last_name + ' liked your post.'
notf.content = content
notf.save()
else:
like = Like.objects.get(post=post, account=account)
like.delete()
post.likes -= 1
post.save()
return HttpResponseRedirect(post.get_absolute_url)
return HttpResponseRedirect('/posts/')
def seed_likes():
likes_count = db.session.query(func.count(Like.id)).scalar()
likes_to_seed = 30
user_ids = [user[0] for user in db.session.query(User.id).all()]
article_ids = [
article[0] for article in db.session.query(Article.id).all()
]
for i in range(likes_count, likes_to_seed):
user_id = random.choice(user_ids)
liked_article_ids = [
user[0] for user in Like.query.filter_by(
user_id=user_id).with_entities(Like.article_id).all()
]
non_liked_articles = [
a[0] for a in db.session.query(Article.id).filter(
Article.id.notin_(liked_article_ids)).all()
]
# Article.id.notin_ same as ~Article.id.in_
if len(non_liked_articles) == 0:
sys.stdout.write('This user liked all articles')
pass
article_id = random.choice(non_liked_articles)
db.session.add(Like(user_id=user_id, article_id=article_id))
db.session.commit()
def setUpTestData(cls):
EventType.objects.create(
event_name='blblbl',
content_type=ContentType.objects.get_for_model(Like),
created=True)
EventType.objects.create(
event_name='blblbla',
content_type=ContentType.objects.get_for_model(Award),
created=True)
AwardType.objects.create(
award_name='blabla',
related_content=ContentType.objects.get_for_model(Post),
related_value=10,
target=ContentType.objects.get_for_model(Like))
cls.test_users = [User(username='******'.format(i)) for i in range(10)]
for user in cls.test_users:
user.save()
post = Post.objects.bulk_create(
[Post(content='test content', author_id=1)])
# will not throw pre and post save
likes = []
for i in range(10):
likes.append(
Like(author_id=cls.test_users[i].id,
content_type=ContentType.objects.get_for_model(Post),
object=1))
likes[i].save()
def create(self, request, *args, **kwargs):
serializer = LikeSerializerForCreate(data=request.data,
context={'request': request})
if not serializer.is_valid():
return Response(
{
'message': 'Please check input.',
'errors': serializer.errors,
},
status=status.HTTP_400_BAD_REQUEST)
#instance, created = serializer.get_or_create()
#if created:
# NotificationService.send_like_notification(instance)
# use Message Queue to create Like in DB
if serializer.validated_data['content_type'] == 'comment':
content_type_int = 0
model_class = Comment
else:
content_type_int = 1
model_class = Tweet
object_id = serializer.validated_data['object_id']
LikeService.async_create_like(content_type_int, object_id,
request.user.id)
instance = Like(
content_type=ContentType.objects.get_for_model(model_class),
object_id=object_id,
user=request.user,
)
return Response(
LikeSerializer(instance).data,
status=status.HTTP_201_CREATED,
)
def post(self, *args, **kwargs):
like = self.post_object.likes.filter(author=self.request.user).first()
if like is None:
like = Like()
like.author = self.request.user
like.post = self.post_object
like.save()
else:
like.delete()
return HttpResponse(Like.objects.filter(post=self.post_object).count())
def create(self, validated_data):
like, created = Like.like(self.context['request'].user,
validated_data['content_type'],
validated_data['object'].pk)
send_signals(created=created,
request=self.context['request'],
like=like,
obj=validated_data['object'])
return like
def like_article(article_slug):
user = current_identity
article = Article.query.filter_by(slug=article_slug).options(load_only('id', 'title')).first()
if Like.query.filter_by(article_id=article.id, user_id=user.id).count() == 0:
like = Like(article_id=article.id, user_id=user.id)
db.session.add(like)
db.session.commit()
return get_success_response('You are now liking %s' % article.title)
else:
return get_error_response('Permission denied, You already liked this article')
def question_detail(request, id):
question = get_object_or_404(Question, id=id)
name = ''
if question.author.is_superuser:
name = 'Admin'
user = request.user
if request.method == 'POST' and user.id is not None:
question_likes = question.likes.all().filter(author__id=user.id)
if question_likes.all().count() == 0:
like = Like(author=user, question=question)
like.save()
else:
for l in question_likes:
l.delete()
context = {
'question': question,
'name': name,
'likes': question.likes.all().count(),
'user': user,
}
return render(request, 'questions/question.html', context)
def like(request):
post_id = request.POST.get('post_id', False)
customer_id = request.POST.get('customer_id', False)
post = Post.objects.get(id=post_id)
customer = Customer.objects.get(id=customer_id)
like = Like.objects.filter(post=post, customer=customer_id)
if like.exists():
like.delete()
nlikes = len(Like.objects.filter(post_id=post_id))
data = nlikes
notifi2 = Notification.objects.filter(customer_id=customer_id,
post_id=post_id,
status=2)
notifi2.delete()
else:
like2 = Like()
like2.customer = customer
like2.post = post
like2.save()
nlikes = len(Like.objects.filter(post_id=post_id))
data = nlikes
notifi = Notification()
notifi.customer_id = post.customer.id
notifi.createtime = timezone.now()
notifi.customer_user = customer
notifi.description = customer.fullname + " đã yêu thích bài viết của bạn..."
notifi.post = post
notifi.status = 2
notifi.save()
return HttpResponse(data)
def get_context_data(self, **kwargs):
context = super(PhotoListView, self).get_context_data(**kwargs)
if self.request.user.is_authenticated:
photo_liked = [photo for photo in Photo.objects.all() if Like.is_user_liked(photo, self.request.user)]
context['photo_liked'] = photo_liked
return context
import pytest
from django.urls import reverse
from accounts.models import UserAccount
from factories import RecipeFactory, UserFactory
from likes.models import Like
# add test to get info from recipe detail page
# ------------------------------------------------ Tests
pytestmark = pytest.mark.django_db
like_url = Like.get_create_url()
class TestLikeRecipeCreateView:
class TestAuthenticatedUsers:
def test_like_page_render(self, api_client):
new_user = UserAccount()
api_client.force_authenticate(new_user)
like_page_render = api_client.get(like_url)
assert like_page_render.status_code == 405
def test_like_post_request(self, api_client):
new_user = UserFactory()
api_client.force_authenticate(new_user)
new_recipe = RecipeFactory()
data = {'recipe': new_recipe.id}
response = api_client.post(like_url, data)
assert response.status_code == 200
def test_get_create_url():
assert Like.get_create_url() == reverse('likes:like')
def get(self, request, *args, **kwargs):
Like(owner_id=request.session['id'],post_id=request.GET.get('id')).save()
return redirect(reverse('posts:posts-list'))
def _add_sample_likes(self, liker, liked):
like = Like(user=liker, content_object=liked)
like.save()
def likes_update(request, pk=None):
topic = get_object_or_404(Topic, id=pk)
like = None
if topic.topic_likes.filter(topic=topic, author=request.user).count() == 1:
like = topic.topic_likes.get(topic=topic, author=request.user)
if like == None:
like = Like()
like.author = request.user
like.topic = topic
like.save()
return HttpResponse("Дизлайк")
else:
if like.is_archive:
like.is_archive = False
like.save()
return HttpResponse("Лайк")
else:
like.is_archive = True
like.save()
return HttpResponse("Дизлайк")
def create(self, validated_data):
validated_data["user"] = self.context['request'].user
like = Like(**validated_data)
like.save()
return like
