def test_partial_update_comment(self):
C_ID = 10
C_HTML = "<p> Updated comment. </p>"
U_ID = 3
U_NAME = "user_" + str(U_ID)
U_PASS = "******" + str(U_ID)
A_ID = 3
C_PAR = 1
url = '/api/update/comment/'
data = {'id': C_ID, 'html': C_HTML}
# Test login.
success = self.client.login(username=U_NAME, password=U_PASS)
self.assertTrue(success)
# Perform update.
response = self.client.post(url, data, format='json')
# Test status code.
self.assertEqual(response.status_code, status.HTTP_200_OK)
# Test response data can be serialized.
serializer = CommentSerializer(data=response.data)
self.assertTrue(serializer.is_valid(), msg=str(serializer.errors))
# Test response data is correct.
self.assertEqual(response.data['id'], C_ID)
self.assertEqual(response.data['user']['id'], U_ID)
self.assertEqual(response.data['user']['username'], U_NAME)
self.assertEqual(response.data['answer'], A_ID)
self.assertEqual(response.data['parent'], C_PAR)
self.assertEqual(response.data['html'], C_HTML)
def test_get_comments_correctly(self):
A_ID = 2
response = self.client.get('/api/' + str(A_ID) + '/comment')
# Test response says GET request succeeded.
self.assertEqual(response.status_code, status.HTTP_200_OK)
# Test response data can be serialized.
serializer = CommentSerializer(data=response.data, many=True)
self.assertTrue(serializer.is_valid(), msg=str(serializer.errors))
# Test response data is correct.
for i in range(0, 4):
data = response.data[i]
parent_id = None
if i > 1:
parent_id = i - 1
self.assertEqual(data['id'], A_ID * 4 + i)
self.assertEqual(data['answer'], A_ID)
self.assertEqual(data['user']['id'], i)
self.assertEqual(data['user']['username'], "user_" + str(i))
self.assertEqual(data['parent'], parent_id)
self.assertEqual(data['html'], "<p> This is a dummy comment <\p>")
def test_new_comment_inserted_correctly(self):
U_ID = 3
U_NAME = "user_" + str(U_ID)
A_ID = 4
C_HTML = "<p> Test insert comment. </p>"
url = '/api/submit/comment/'
data = {
'user': {
'id': U_ID,
'username': U_NAME
},
'answer': str(A_ID),
'html': C_HTML
}
response = self.client.post(url, data, format='json')
# Test response says comment created successfully
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
# Test response data can be serialized.
serializer = CommentSerializer(data=response.data)
self.assertTrue(serializer.is_valid(), msg=str(serializer.errors))
# Test response data is correct.
self.assertEqual(response.data['id'], 1)
self.assertEqual(response.data['user']['id'], U_ID)
self.assertEqual(response.data['user']['username'], U_NAME)
self.assertEqual(response.data['answer'], A_ID)
self.assertEqual(response.data['html'], C_HTML)
def add_comment(request):
response_object = {}
if request.method == "POST":
serializer = CommentSerializer(data=request.data)
if serializer.is_valid():
comment = serializer.save(user_id=request.user)
count = comment.getCountForComment()
comment.creation_timestamp = get_time_difference(
comment.creation_timestamp)
c = comment.__dict__
comment_data = {
"id": comment.id,
"comment": comment.comment,
"username": comment.user_id.username,
"fullname": comment.user_id.full_name,
"creation_timestamp": comment.creation_timestamp
}
response_object = {
"status": HTTP_201_CREATED,
"total_comments": count,
"comment": comment_data
}
else:
response_object = failed_object(HTTP_400_BAD_REQUEST,
serializer.errors)
return Response(response_object)
def post(self, request):
serializer = CommentSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
else:
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def put(self, request, pk):
comment = self.get_object(pk)
serializer = CommentSerializer(instance=comment, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors)
def put(self, request, post_pk, comment_pk, format=None):
data = request.data
# ensure user is authenticated
if (not request.user.is_authenticated()):
return Response({'message':'Not authenticated'}, status=status.HTTP_401_UNAUTHORIZED)
try:
post = Post.objects.get(id=post_pk)
except Post.DoesNotExist as e:
return Response({"message":"Post does not exist"}, status=status.HTTP_404_NOT_FOUND)
try:
comment = Comment.objects.get(id=comment_pk)
except Comment.DoesNotExist as e:
return Response({"message":"Comment does not exist"}, status=status.HTTP_404_NOT_FOUND)
try:
loggedInAuthor = Author.objects.get(user=request.user)
except Author.DoesNotExist as e:
return Response({"message":"Author does not exist"}, status=status.HTTP_401_UNAUTHORIZED)
# only allow author of the comment to modify it
if loggedInAuthor != comment.author:
return Response({"message": "User is not the author of this comment & is not allowed to update this comment"}, status=status.HTTP_403_FORBIDDEN)
serializer = CommentSerializer(comment, data=data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_200_OK)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def create_comment(request):
serialized = CommentSerializer(data=request.data)
if serialized.is_valid(raise_exception=True):
serialized.save()
response = {"data": serialized.data}
return Response(response, status=201)
return Response({"message": "Error - not created"}, status=400)
def post(self, request, post_id):
request.data['post_id'] = post_id
request.data['author_id'] = request.user.pk
serializer = CommentSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, pk):
try:
serializer = CommentSerializer(data=request.data)
serializer.save(created_by=self.request.user)
return Response(serializer.data, status=status.HTTP_201_CREATED)
except Exception as e:
return Response({'errors': str(e)},
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def post(self, request):
"""
This view should serialized passed data, save comment in database and return object instance.
"""
serializer = CommentSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def put(self, request, pk1, pk2):
try:
instance = self.get_post(pk1=pk1).comments.get(id=pk2)
except Comment.DoesNotExist:
raise Http404
serializer = CommentSerializer(instance=instance, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors)
def operate_news(request):
phone_number = request.POST["phone_number"]
if not check_token(request.POST["token"], phone_number):
return Response(data={'detail': 'unauthorized'},
status=status.HTTP_401_UNAUTHORIZED)
id_ = request.POST.get('id', '')
operation = request.POST.get('operation', '')
try:
news = News.objects.get(id=id_)
except News.DoesNotExist:
return Response(data={'detail': 'news does not exist'},
status=status.HTTP_400_BAD_REQUEST)
if operation == 'DELETE':
if news.commit_person_id == phone_number:
for comment in news.comment_set.iterator():
comment.delete()
news.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
else:
return Response(data="this message's owner is not you",
status=status.HTTP_401_UNAUTHORIZED)
elif operation == 'COMMENT':
serializer = CommentSerializer(data=request.data)
if serializer.is_valid():
serializer.save(commit_person_id=phone_number, news=news)
news.comments_number += 1
news.save()
return Response(status=status.HTTP_204_NO_CONTENT)
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
elif operation == 'UNCOMMENT':
comment = Comment.objects.get(id=request.POST['comment_id'])
if comment.commit_person_id == phone_number:
comment.delete()
news.comments_number -= 1
news.save()
return Response(status=status.HTTP_204_NO_CONTENT)
return Response(status.HTTP_401_UNAUTHORIZED)
elif operation == 'FOLLOW':
person = Person.objects.get(phone_number=phone_number)
news.followers.add(person)
news.following_number += 1
news.save()
return Response(status=status.HTTP_204_NO_CONTENT)
elif operation == 'UNFOLLOW':
person = Person.objects.get(phone_number=phone_number)
news.followers.remove(person)
news.following_number -= 1
news.save()
return Response(status=status.HTTP_204_NO_CONTENT)
elif operation == 'SHARE':
news.share_number += 1
news.save()
return Response(status=status.HTTP_204_NO_CONTENT)
def comment_create(request, image_pk):
"""
Create comment for the image.
"""
if request.method == 'POST':
serializer = CommentSerializer(data=request.data)
if serializer.is_valid():
serializer.save(created_by=request.user)
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def put(self, request, pk, pk2):
if self.exist(pk, pk2) == False:
return Response(status=status.HTTP_404_NOT_FOUND)
comment = Comment.objects.get(id=pk2)
if request.user != comment.created_by:
return Response(status=status.HTTP_401_UNAUTHORIZED)
serializer = CommentSerializer(instance=comment, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_200_OK)
return Response(serializer.errors)
def put(self, request, id):
comment = self.get_object(id)
serializer = CommentSerializer(comment,
data=request.data,
partial=True)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def put(self, request, id, format=None):
data = JSONParser().parse(request)
comment = self.get_object(id)
comment_serializer = CommentSerializer(comment, data=data)
if comment_serializer.is_valid():
comment_serializer.save()
return Response(comment_serializer.data)
else:
return Response(status=status.HTTP_400_BAD_REQUEST)
def post(self, request, ticket_id):
ticket = Ticket.objects.get(id=ticket_id)
res = json.loads(request.body)
serialized_comment = CommentSerializer(data=res)
if serialized_comment.is_valid():
new_comment = serialized_comment.save()
ticket.comments.add(new_comment)
ticket.save()
return Response(serialized_comment.data)
else:
return Response(serialized_comment.errors,
status=status.HTTP_400_BAD_REQUEST)
def post(self, request, post_id):
curAuthor = Author.objects.get(id=request.user.id)
post = Post.objects.get(pk=post_id) # pylint: disable=maybe-no-member
data = request.data
data['author'] = curAuthor.id
data['post'] = post.postid
serializer = CommentSerializer(data=data)
if serializer.is_valid():
serializer.save()
#Todo: response success message on json format
return Response()
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def update_comment(request, pk):
comment_obj = get_object_or_404(Comment, pk=pk)
serialized = CommentSerializer(
comment_obj,
data=request.data,
partial=True,
)
if serialized.is_valid(raise_exception=True):
serialized.save()
response = {"data": serialized.data, "message": "All good, updated"}
return Response(response, status=200)
return Response({"Error - not updated"}, status=400)
def operate_news(request):
phone_number = request.POST["phone_number"]
if not check_token(request.POST["token"], phone_number):
return Response(data={"detail": "unauthorized"}, status=status.HTTP_401_UNAUTHORIZED)
id_ = request.POST.get("id", "")
operation = request.POST.get("operation", "")
try:
news = News.objects.get(id=id_)
except News.DoesNotExist:
return Response(data={"detail": "news does not exist"}, status=status.HTTP_400_BAD_REQUEST)
if operation == "DELETE":
if news.commit_person_id == phone_number:
for comment in news.comment_set.iterator():
comment.delete()
news.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
else:
return Response(data="this message's owner is not you", status=status.HTTP_401_UNAUTHORIZED)
elif operation == "COMMENT":
serializer = CommentSerializer(data=request.data)
if serializer.is_valid():
serializer.save(commit_person_id=phone_number, news=news)
news.comments_number += 1
news.save()
return Response(status=status.HTTP_204_NO_CONTENT)
else:
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
elif operation == "UNCOMMENT":
comment = Comment.objects.get(id=request.POST["comment_id"])
if comment.commit_person_id == phone_number:
comment.delete()
news.comments_number -= 1
news.save()
return Response(status=status.HTTP_204_NO_CONTENT)
return Response(status.HTTP_401_UNAUTHORIZED)
elif operation == "FOLLOW":
person = Person.objects.get(phone_number=phone_number)
news.followers.add(person)
news.following_number += 1
news.save()
return Response(status=status.HTTP_204_NO_CONTENT)
elif operation == "UNFOLLOW":
person = Person.objects.get(phone_number=phone_number)
news.followers.remove(person)
news.following_number -= 1
news.save()
return Response(status=status.HTTP_204_NO_CONTENT)
elif operation == "SHARE":
news.share_number += 1
news.save()
return Response(status=status.HTTP_204_NO_CONTENT)
def comment_list(request):
if request.method == 'GET':
comment = Comment.objects.all()
serializer = CommentSerializer(comment, many=True)
return JSONResponse(serializer.data)
elif request.method == 'POST':
data = JSONParser().parse(request)
serializer = CommentSerializer(data=data)
if serializer.is_valid():
serializer.save()
return JSONResponse(serializer.data, status=201)
return JSONResponse(serializer.errors, status=400)
def post(self, request, pk):
user = request.user.pk
content = request.data.get("content")
data = {"user": user, "post": pk, "content": content}
serializer = CommentSerializer(data=data, many=False)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def post(self, request):
"""
{
"text": "teste de comentário",
"author": "John",
"post": 2,
}
"""
serializer = CommentSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def get(self, request, pk1, pk2):
try:
comment = self.get_post(pk1=pk1).comments.get(id=pk2)
except Comment.DoesNotExist:
raise Http404
serializer = CommentSerializer(comment)
return Response(serializer.data, status=status.HTTP_200_OK)
def get(self, request):
try:
comments = Comment.objects.all()
serializer = CommentSerializer(comments, many=True)
return JsonResponse(serializer.data, safe=False)
except:
return JsonResponse({"status":"505"}, safe=False)
def get(self, request, category_id, discussion_id, topic_id):
# category = Category.objects.get(id=category_id)
# discussion = Discussion.objects.get(id=discussion_id)
# topic = Topic.objects.filter(id=topic_id)
comments = Comment.objects.filter(topic_id=topic_id)
serializer = CommentSerializer(comments, many=True)
return Response(serializer.data)
def get_context_data(self, **kwargs):
user = self.request.user
project = self.get_object()
permissions = Authorization.all_permissions(user, project)
# On filtre les signalements selon leur statut et l'utilisateur courant
features = Feature.handy.availables(
user=user, project=project).order_by('-created_on')
# On filtre les commentaire selon les signalements visibles
last_comments = Comment.objects.filter(
project=project,
feature_id__in=[feat.feature_id
for feat in features]).order_by('-created_on')[0:5]
serialized_comments = CommentSerializer(last_comments, many=True).data
serilized_projects = ProjectDetailedSerializer(project).data
context = super().get_context_data(**kwargs)
context['project'] = serilized_projects
context['title'] = project.title
context['user'] = user
context['last_comments'] = serialized_comments
context['last_features'] = features[0:5]
context['features'] = features
context['permissions'] = permissions
context['feature_types'] = project.featuretype_set.all()
context['is_suscriber'] = Subscription.is_suscriber(user, project)
return context
def post(self, request, pk, *args, **kwargs):
if not request.user.is_authenticated:
return Response({'error': 'Authorization failed, log in with your credentials!'})
data = request.data
comment = Comment.objects.create(text=data['text'], author=request.user, on_car_id=pk)
ser = CommentSerializer(comment)
return Response(ser.data, status=status.HTTP_200_OK)
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
project = self.get_object()
user = self.request.user
permissions = Authorization.all_permissions(user, project)
last_comments = Comment.objects.filter(
project=project
).order_by('-created_on')[0:5]
serialized_comments = CommentSerializer(last_comments, many=True).data
features = Feature.objects.filter(
project=project
).order_by('-created_on')
serilized_projects = ProjectDetailedSerializer(project).data
context['project'] = serilized_projects
context['user'] = user
context['last_comments'] = serialized_comments
context['last_features'] = features[0:5]
context['features'] = features
context['permissions'] = permissions
context['feature_types'] = project.featuretype_set.all()
context['is_suscriber'] = Subscription.is_suscriber(user, project)
# EDC
layers = Layer.objects.filter(project=project)
serialized_layers = LayerSerializer(layers, many=True)
context['layers'] = serialized_layers.data
return context
def get(self, request, pk):
try:
post = Post.objects.get(id=pk)
except Post.DoesNotExist as e:
return Response(status=status.HTTP_404_NOT_FOUND)
comments = post.comments.filter(directed_to__isnull=True)
serializer = CommentSerializer(comments, many=True)
return Response(serializer.data, status=status.HTTP_200_OK)
def get(self, request):
try:
comments = Comment.objects.all()
serializer = CommentSerializer(comments, many=True)
return Response(serializer.data, status=status.HTTP_200_OK)
except:
return Response({"": ""},
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def get_comments(self, request, *args, **kwargs):
post = self.get_object()
if 'pk' in kwargs:
comments = Comment.objects.filter(post=post, id=int(kwargs['pk']))
else:
comments = Comment.objects.filter(post=post)
serializer = CommentSerializer(instance=comments, many=True)
return Response({'data': serializer.data})
def comment_detail(request, pk):
try:
comment = Comment.objects.get(pk=pk)
except Comment.DoesNotExist:
return HttpResponse(status=404)
if request.method == 'GET':
serializer = CommentSerializer(comment)
return JSONResponse(serializer.data)
elif request.method == 'PUT':
data = JSONParser().parse(request)
serializer = CommentSerializer(comment, data=data)
if serializer.is_valid():
serializer.save()
return JSONResponse(serializer.data)
return JSONResponse(serializer.errors, status=400)
elif request.method == 'DELETE':
comment.delete()
return HttpResponse(status=204)
def comments_list(request, article_pk):
"""
Get comments
:param request:
:param article_pk
"""
try:
article = Article.objects.get(pk=article_pk)
except Article.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND)
if request.method == 'GET':
comments = article.comments.all()
serializer = CommentSerializer(comments, many=True)
return Response(serializer.data)
elif request.method == 'POST':
serializer = CommentSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
else:
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def operate_message(request):
phone_number = request.POST.get("phone_number", "")
if not check_token(request.POST.get("token", ""), phone_number):
return Response(data={"detail": "unauthorized"}, status=status.HTTP_401_UNAUTHORIZED)
id_ = request.POST.get("id", "")
operation = request.POST.get("operation", "")
try:
message = Message.objects.get(id=id_)
except Message.DoesNotExist:
return Response(data={"detail": "message does not exist"}, status=status.HTTP_400_BAD_REQUEST)
if operation == "DELETE":
if message.commit_person_id == phone_number:
for comment in message.comment_set.iterator():
comment.delete()
message.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
else:
return Response(data="this message's owner is not you", status=status.HTTP_400_BAD_REQUEST)
elif operation == "COMMENT":
serializer = CommentSerializer(data=request.data)
if serializer.is_valid():
serializer.save(commit_person_id=phone_number, message=message)
message.comments_number += 1
message.save()
return Response(status=status.HTTP_204_NO_CONTENT)
else:
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
elif operation == "UNCOMMENT":
serializer = Comment.objects.get(id=request.POST["comment_id"])
if serializer.commit_person_id == phone_number:
serializer.delete()
message.comments_number -= 1
message.save()
return Response(status=status.HTTP_204_NO_CONTENT)
return Response(status.HTTP_401_UNAUTHORIZED)
elif operation == "SHARE":
message.share_number += 1
message.save()
return Response(status=status.HTTP_204_NO_CONTENT)
def post(self, request, post_pk, format=None):
# ensure user is authenticated
if (not request.user.is_authenticated()):
print "NOT AUTHENTICATED"
return Response({'message':'Not authenticated'}, status=status.HTTP_401_UNAUTHORIZED)
data = request.data
try:
post = Post.objects.get(id=post_pk)
except Post.DoesNotExist as e:
return Response({"message":"Post does not exist"}, status=status.HTTP_404_NOT_FOUND)
# check if request is from remote node, if so handle it
remoteNode = getRemoteNode(request.user)
if remoteNode != None:
# is a remote node / author
if ((post.visibility == Post.SERVER_ONLY) | (post.visibility == Post.ME_ONLY)):
return Response({"message": "This node & authors on this node are not allowed to see this post & thus cannot comment"}, status=status.HTTP_403_FORBIDDEN)
else:
author_serializer = AuthorSerializer(data["author"])
try:
author = Author.objects.get(id=author_serializer.data["id"])
except Author.DoesNotExist as e:
author = Author.objects.create(id=author_serializer.data["id"])
print author_serializer.data
for key in author_serializer.data.keys():
if author_serializer.data[key] != None:
if key == 'host':
author.host = author_serializer.data[key]
elif key == 'displayName':
author.displayName = author_serializer.data[key]
elif key == 'github':
author.github = author_serializer.data[key]
author.save()
else:
# author = Author.objects.get(user=request.user)
author_serializer = AuthorSerializer(data["author"])
try:
author = Author.objects.get(id=author_serializer.data["id"])
except Author.DoesNotExist as e:
return Response({"message": "The author given in the post does not exist locally."}, status=status.HTTP_400_BAD_REQUEST)
author_id = author.id
try:
if (isAllowed(post_pk, author_id)):
print "IS ALLOWED COMMENT POST"
serializer = CommentSerializer(data=data)
if serializer.is_valid():
print "DEBUG : API - views.py - CommentList"
serializer.validated_data["author"] = author
serializer.validated_data["published"] = timezone.now()
serializer.validated_data["post"] = Post.objects.get(pk=post_pk)
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
else:
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
else:
print "NOT ALLOWED COMMENT POST"
return Response({"message": "User is not allowed to see this post/comment"}, status=status.HTTP_403_FORBIDDEN)
except Post.DoesNotExist as e:
return Response({"message":"Corresponding post does not exist"}, status=status.HTTP_404_NOT_FOUND)
