def product_comment(self, request, pk):
if request.method == 'GET':
comments = Comment.objects.filter(product_id=pk)
serializer = CommentSerializer(comments, many=True)
return Response(serializer.data)
elif request.method == 'POST':
serializer = CommentSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
serializer.save()
return Response('OK')
def comment_list(request):
if request.method == 'GET':
comments = Comment.objects.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)
return Response({'error': serializer.errors},
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def topic_details(request, topic_id):
if request.method == "GET":
topic = Topic.objects.get(pk=topic_id)
comments = topic.comments
ser = CommentSerializer(comments, many=True)
return JsonResponse(ser.data, safe=False)
elif request.method == "POST":
data = JSONParser().parse(request)
ser = CommentSerializer(data=data)
if ser.is_valid():
ser.save()
return JsonResponse(ser.data, status=201)
return JsonResponse(ser.errors, status=400)
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):
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 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(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 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 comment_by_photo(request, pk):
try:
photo = Photo.objects.get(id=pk)
except Photo.DoesNotExist as e:
return Response({'error': str(e)})
if request.method == 'GET':
serializer = CommentSerializer(photo.comments.all(), 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)
return Response({'error': serializer.errors},
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
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 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, 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 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 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 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):
comData = request.data.get('data')
if comData:
serializer = CommentSerializer(data=comData)
if serializer.is_valid():
serializer.save()
comData = request.data.get('update')
if comData:
_comment = CommentModel.objects.get(id=int(comData['id']))
_comment.endorse = comData['endorse']
_comment.oppose = comData['oppose']
_comment.save()
snippets = CommentModel.objects.all().order_by('-id')[:100]
serializer = CommentSerializer(snippets, many=True)
return Response(serializer.data)
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):
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(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 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 get(self, request, pk, page=1, format=None):
try:
comments = PostModel.objects.get(pk=pk).get_comments()
except CommentModel.DoesNotExist:
raise Http404("Post does not exist!")
comments = paginate(comments, page, 15)
serializer = CommentSerializer(comments, many=True)
return Response(serializer.data)
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 get(self, request):
comments = Comment.objects.all()
if 'order_by' in request.query_params:
comments = comments.order_by(request.query_params['order_by'])
serializer = CommentSerializer(comments, many=True)
return Response(serializer.data)
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 report_comment_detail(request, pk):
report = Report.objects.get(pk=pk)
comment = Comment.objects.filter(report_fk=report.pk)
if request.method == 'GET':
serializer = CommentSerializer(comment, many=True)
return JSONResponse(serializer.data)
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 create(self, request, *args, **kwargs):
comment_data = request.data
new_comment = Comment.objects.create(body=comment_data['body'],
post=Post.objects.get(id=comment_data['post']),
owner=self.request.user)
new_comment.save()
serializer = CommentSerializer(new_comment)
return Response(serializer.data)
def comment_replies(request, pk1, pk2):
try:
comment = Comment.objects.get(id=pk2)
except Comment.DoesNotExist as e:
return Response(status=status.HTTP_404_NOT_FOUND)
if request.method == 'GET':
replies = comment.replies
serializer = CommentSerializer(replies, many=True)
return Response(serializer.data, status=status.HTTP_200_OK)
if request.method == 'POST':
serializer = CommentSerializer(data=request.data)
if serializer.is_valid():
serializer.save(created_by=request.user,
directed_to_id=pk2,
post_id=pk1)
return Response(serializer.data, status=status.HTTP_200_OK)
return Response(serializer.errors,
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)
