def post_list(request):
if request.method == 'GET':
posts = Post.objects.all()
content = request.GET.get('content', None)
if content is not None:
posts = posts.filter(content__icontains=content)
posts_serializer = PostSerializer(posts, many=True)
return JsonResponse(posts_serializer.data, safe=False)
elif request.method == 'POST':
comment_list = []
post_data = JSONParser().parse(request)
post_serializer = PostSerializer(data=post_data, many=True)
if post_serializer.is_valid():
# print(post_serializer.data)
for i in post_serializer.data:
str = []
# print(i.get('content'))
str.append('*' + i.get('content') + '*')
# comment_list.append('*' + i.get('content') + '*')
trustNumber, resultBoolean = model_predict_comment(
model_dict['SARNNKerasCPU'], model_path, str)
print(trustNumber)
print(resultBoolean)
i.update(resultInNumber=trustNumber)
i.update(resultInBoolean=resultBoolean)
# model_predict_comment(model_dict['SARNNKerasCPU'],model_path,comment_list)
# post_serializer.save()
return JsonResponse(post_serializer.data,
status=status.HTTP_201_CREATED,
safe=False)
return JsonResponse(post_serializer.data,
status=status.HTTP_400_BAD_REQUEST)
elif request.method == 'PUT':
post_data = JSONParser().parse(request)
post_serializer = PostSerializer(data=post_data, many=True)
print(post_serializer)
if post_serializer.is_valid():
post_serializer.save()
return JsonResponse(post_serializer.data, safe=False)
return JsonResponse(post_serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
elif request.method == 'DELETE':
count = Post.objects.all().delete()
return JsonResponse(
{'message': '{} posts were deleted successfully'.format(count[0])},
status=status.HTTP_204_NO_CONTENT)
def update(self, request, pk, *args, **kwargs):
partial = kwargs.pop('partial', False)
instance = get_object_or_404(Post, pk=pk)
serializer = PostSerializer(instance,
data=request.data,
partial=partial)
try:
serializer.is_valid(raise_exception=True)
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
except ValidationError as e:
return Response({'detail': e.detail},
status=status.HTTP_400_BAD_REQUEST)
def post_update(request):
if request.session.has_key('username'):
if request.method == "POST":
print(request.session['username'])
data = JSONParser().parse(request)
post = Post.objects.get(id=data['target_id'])
if post.author == request.session['username']:
if 'title' in data:
post.title = data["title"]
else:
data['title'] = post.title
if 'content' in data:
post.content = data["content"]
else:
data['content'] = post.content
post.save()
data["author"] = request.session['username']
serializer = PostSerializer(post, data=data)
if serializer.is_valid():
serializer.save()
return JsonResponse(serializer.data)
return JsonResponse(serializer.errors, status=400)
else:
return JsonResponse("It's not yours to update!", safe=False)
else:
return JsonResponse("You should login first", safe=False)
def post(self, request):
serializer = PostSerializer(data=request.data)
if serializer.is_valid():
serializer.save(author=request.user)
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors)
def post(self, request):
serializer = PostSerializer(data=request.data, context={'request':request})
if serializer.is_valid():
serializer.save()
request.user.update_last_action()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def put(self, request, pk, *args, **kwargs):
queryset = Post.objects.get(pk=pk)
serializer = PostSerializer(queryset, data=request.data)
if serializer.is_valid():
serializer.save()
return Response({"Message": "Saved Form !"}, status=HTTP_200_OK)
return Response(serializer.errors, status=HTTP_400_BAD_REQUEST)
def posts_list(request):
if request.method == 'GET':
# get all posts
posts = Post.objects.all()
title = request.GET.get('title', None) # ( the title is passed as a parameter )
# if title is in the parameters, then filter the posts with the title
if title is not None:
posts = posts.filter(title__icontains=title)
# we serialize the posts and return a JsonResponse with the serialized data
posts_serializer = PostSerializer(posts, many=True)
return JsonResponse(posts_serializer.data, safe=False)
elif request.method == 'POST':
# we parse thr request to get the post data and then we serialize it
post_data = JSONParser().parse(request)
post_serializer = PostSerializer(data=post_data)
# if the serializer is valid we save the serialized data (our post) and we return it with a status of 201
if post_serializer.is_valid():
post_serializer.save()
return JsonResponse(post_serializer.data, status=status.HTTP_201_CREATED)
# else we return the error raised from the serialization with a satus of 400
return JsonResponse(post_serializer.errors, status=status.HTTP_400_BAD_REQUEST)
elif request.method == 'DELETE':
count = Post.objects.all().delete()
return JsonResponse({'message': f"{count} posts were deleted successfully !"}, status=status.HTTP_204_NO_CONTENT)
def post(self, request):
post = request.data
serializer = PostSerializer(data=post,
context={'request': request})
if serializer.is_valid(raise_exception=True):
serializer.save()
return Response({"success": f"Post created successfully"})
def posts_details(request, pk): # Here pk corresponds to the id
try:
post = Post.objects.get(pk=pk) # get the post with the matching id
except Post.DoesNotExist:
# if it does not exist, return the error message with 404
return JsonResponse({'message': 'There is no post with such id'}, status=status.HTTP_404_NOT_FOUND)
# return the post with the id if the method is get
if request.method == 'GET':
post_serializer = PostSerializer(post)
return JsonResponse(post_serializer.data, status=status.HTTP_200_OK)
# delete it if the method is DELETE
elif request.method == 'DELETE':
post.delete()
return JsonResponse({'message': 'post deleted successfully !'}, status=status.HTTP_204_NO_CONTENT)
elif request.method == 'PUT':
# we parse the data ( passed as a parameter ) and the we serialize it to the post with the matching id
post_data = JSONParser().parse(request)
post_serializer = PostSerializer(post, data=post_data)
# if the serialization is valid, save it
if post_serializer.is_valid():
post_serializer.save()
return JsonResponse(post_serializer.data)
# else return a bad request status code
return JsonResponse(post_serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def put(self, request, pk, format=None, **kwargs):
post = self.get_objects(pk)
serializer = PostSerializer(post, data=request.data, **kwargs)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def update_post(self, request, **kwargs):
try:
post = Post.objects.get(**kwargs)
except Post.DoesNotExist:
return response404('Post')
self.check_object_permissions(request=request, obj=post)
file = request.FILES.get('file', None)
image = request.FILES.get('image', None)
if file:
post.file = file
post.save()
request.data.pop('post')
if image:
post.image = image
post.save()
request.data.pop('image')
serializer = PostSerializer(post, data=request.data, partial=True)
if not serializer.is_valid():
return response406({
**serializer.errors, 'message': 'Błąd walidacji'
})
serializer.update(post, serializer.validated_data)
return response200({
**serializer.data, 'message':
'Pomyślnie zaktualizowano posta'
})
def post(self, request, *args, **kwargs):
serializer = PostSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=HTTP_201_CREATED)
else:
return Response(serializer.errors, status=HTTP_400_BAD_REQUEST)
def put(self, request, pk, *args, **kwargs):
post = Post.objects.get(pk=pk)
serializer = PostSerializer(post, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=HTTP_400_BAD_REQUEST)
def post(self, request, format=None):
serializer = PostSerializer(data=request.data)
if serializer.is_valid():
post = serializer.save(user=request.user)
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post_detail(request, post_id):
try:
post = Post.objects.get(pk=post_id)
except Post.DoesNotExist:
return Response({"message": "requested post not found"},
status=status.HTTP_404_NOT_FOUND)
if request.method == 'GET':
serializer = PostSerializer(post)
return Response({"data": serializer.data})
if request.method == 'DELETE':
post.delete()
return Response({"message": "Post has been deleted !"},
status=status.HTTP_204_NO_CONTENT)
if request.method == 'PUT':
serializer = PostSerializer(post, data=request.data)
if serializer.is_valid():
serializer.save()
return Response({
"message": "update post successfully",
"data": serializer.data
})
return Response({"message": "update post failed"},
status=status.HTTP_400_BAD_REQUEST)
def delete(self, request, format=None):
serializer = PostSerializer(data=request.data)
if serializer.is_valid():
obj = Post.objects.filter(id=serializer.data['id'])
obj.delete()
return Response(stastus=status.HTTP_204_NO_CONTENT)
return Response(status=status.HTTP_400_BAD_REQUEST)
def post(self, request, format=None):
data = JSONParser().parse(request)
data["user"] = request.user.id
serializer = PostSerializer(data=data, context={'request': request})
if serializer.is_valid():
serializer.save()
return JsonResponse(serializer.data, status=201)
return JsonResponse(serializer.errors, status=400)
def put(self, request, pk, format=None):
objects = self.get_object()
serializer = PostSerializer(objects, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(data={'message': "Update Failed"},
status=status.HTTP_400_BAD_REQUEST)
def post(self, request, format=None):
user = request.user
post_serializer = PostSerializer(data=request.data, context={'user': user})
if post_serializer.is_valid():
post_serializer.save()
response = Response(post_serializer.data, status.HTTP_201_CREATED)
else:
response = Response(post_serializer.errors, status.HTTP_400_BAD_REQUEST)
return response
def patch(self, request, pk, format=None):
"""
Partial update a post instance
"""
post = self.get_object(pk)
serializer = PostSerializer(post, 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 create(self, request, topic_id):
topic = get_object_or_404(TopicModel, pk=topic_id)
data = dict(request.data)
data['topic'] = topic.topic_id
data['user'] = request.user_id
serializer = PostSerializer(data=data)
if serializer.is_valid():
post = serializer.save()
return Response({'post_id': post.post_id}, status=201)
return Response(serializer.errors, status=422)
def singlePost(request, uuid):
'''GET returns a single post
POST inserts a post
PUT insert/updates a post
DELETE deletes the post'''
if request.method == 'GET':
try:
post = Post.objects.get(post_id=uuid)
except:
return Response(status=status.HTTP_404_NOT_FOUND)
print(post)
serializer = PostSerializer(post)
return Response({"post": serializer.data})
# elif request.method == 'POST':
# form = PostForm(data=request.POST)
# print(form.errors)
# if form.is_valid():
# post = form.save(commit=False)
# post.author = Author.objects.get(user=request.user.id)
# post.published = timezone.now()
# post.save()
# print(post)
# serializer = PostSerializer(post)
# return Response({"post": serializer.data})
elif request.method == 'PUT':
try:
post = Post.objects.get(post_id=uuid)
except:
#TODO - this doesn't work
#make new post
# I don't think this should exist anymore
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
# serializer = PostSerializer(data=request.data)
# if serializer.is_valid():
# print("I want to make a new post")
# serializer.save(author=request.user)
# return Response(serializer.data)
# print("errors: %s"%serializer.errors)
# return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
serializer = PostSerializer(post, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
elif request.method == 'DELETE':
try:
post = Post.objects.get(post_id=uuid)
deleted = Post.objects.get(post_id=uuid).delete()
return Response("Post deleted", status=status.HTTP_200_OK)
except:
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def put(self, request, pk, format=None):
note = self.get_object(pk)
if request.user.id == note.user_id:
serializer = PostSerializer(note, data=request.data, partial=True)
print(request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
else:
return Response({}, status=status.HTTP_400_BAD_REQUEST)
def create(self, request):
serializer = PostSerializer(data=request.data)
if serializer.is_valid():
# Assign the currently logged user as the owner
serializer.save(owner=request.user)
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):
post = get_object_or_404(Post, pk=pk)
if request.user.is_superuser or request.user.username == post.owner.username:
serializer = PostSerializer(instance=post, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_200_OK)
else:
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
else:
return Response(status=status.HTTP_401_UNAUTHORIZED)
def test_invalid_post_serializer():
invalid_serializer_data = {
"author": "",
"title": "Coding",
"entry": "Today I coded my first line of code"
}
serializer = PostSerializer(data=invalid_serializer_data)
assert not serializer.is_valid()
assert serializer.validated_data == {}
assert serializer.data == invalid_serializer_data
assert serializer.errors == {"author": ["This field may not be null."]}
def delete(self, request, pk):
saved_post = get_object_or_404(Post.objects.all(), pk=pk)
data = request.data
serializer = PostSerializer(instance=saved_post,
context={'request': request},
data=data, partial=True)
if serializer.is_valid(raise_exception=True):
serializer.delete(saved_post)
return Response({
"success": "Post deleted!"
})
def post(self, request):
if request.user is not None and request.user.is_active:
request.data[u'owner'] = request.user.pk
request.data[u'published'] = True
serializer = PostSerializer(data=request.data)
if serializer.is_valid():
new_post = serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
else:
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
return Response(status=status.HTTP_401_UNAUTHORIZED)
def create_post(self, request, **kwargs):
print(request.data)
group = get_object_or_404(Group, id=kwargs.get('group_id'))
self.check_object_permissions(request, group)
serializer = PostSerializer(context={"host": request.get_host()},
data=request.data)
if not serializer.is_valid():
return Response(data=serializer.errors,
status=status.HTTP_406_NOT_ACCEPTABLE)
serializer.save(owner=request.user, group=group)
return Response(data=serializer.data, status=status.HTTP_201_CREATED)
def posts(request):
if request.method == "GET":
posts = Post.objects.order_by('-pub_date')
serializer = PostSerializer(posts, many=True)
return Response(serializer.data)
elif request.method == "POST":
serializer = PostSerializer(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 post_list(request):
if request.method == 'GET':
queryset = Post.objects.all()
serializer = PostSerializer(queryset, many=True)
return JsonResponse(serializer.data, safe=False)
if request.method == 'POST':
data = JSONParser.parse(request)
serializer = PostSerializer(data=data)
if serializer.is_valid():
serializer.save()
return JsonResponse(serializer.data, status=201)
return JsonResponse(serializer.errors, status=400)
def edit_post(self, request, **kwargs):
post = Post.objects.get(id=kwargs.get('post_id'))
self.check_object_permissions(request, post)
serializer = PostSerializer(post,
request.data,
context={"host": request.get_host()},
partial=True)
if not serializer.is_valid():
print(serializer.errors)
return Response(data=serializer.errors,
status=status.HTTP_406_NOT_ACCEPTABLE)
serializer.update(post, serializer.validated_data)
return Response(data=serializer.data, status=status.HTTP_200_OK)
def patch(self, request, pk):
post = Post.objects.get(pk=pk)
if post.author != request.user:
return Response(
{"message": "You are not allowed to edit this post"},
status=status.HTTP_403_FORBIDDEN,
)
serializer = PostSerializer(post, data=request.data, partial=True)
if not serializer.is_valid():
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
serializer.save()
return Response(serializer.data, status=status.HTTP_200_OK)
def post_create(request):
if request.session.has_key('username'):
if request.method == "POST":
data = JSONParser().parse(request)
post = Post.objects.create(title=data["title"],
content=data["content"],
author=request.session['username'])
data["author"] = request.session['username']
serializer = PostSerializer(post, data=data)
if serializer.is_valid():
serializer.save()
return JsonResponse(serializer.data)
return JsonResponse(serializer.errors, status=400)
else:
return JsonResponse("You should login first", safe=False)
def post_create(request):
"""
Create a new post.
"""
if request.method == 'POST':
request_data = request.data
request_data.update({
'user': request.user.id,
})
serializer = PostSerializer(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 post_list(request):
"""
List all code posts, or create a new post.
"""
if request.method == 'GET':
posts = Post.objects.all()
serializer = PostSerializer(posts, many=True)
return JsonResponse(serializer.data, safe=False)
elif request.method == 'POST':
data = JSONParser().parse(request)
serializer = PostSerializer(data=data)
if serializer.is_valid():
serializer.save()
return JsonResponse(serializer.data, status=201)
return JsonResponse(serializer.errors, status=400)
