def post(self, request, format=None):
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 get_user_posts(self, request, pk=None):
try:
posts = Post.objects.all().filter(author=pk)
serializer = PostSerializer(posts, many=True)
return Response(serializer.data, status=status.HTTP_200_OK)
except Exception as e:
print(e)
return Response({}, status=status.HTTP_400_BAD_REQUEST)
def post_like_view(request):
serializer = PostLikeSerializer(data=request.data)
if serializer.is_valid(raise_exception=True):
data = serializer.validated_data
post_id = data.get("id")
if Post.objects.filter(pk=post_id).count() > 0 :#and FollowRequest.objects.filter(sender=request.user , receiver=Post.objects.filter(pk=post_id).first().author , accepted=True).exists():
post = Post.objects.get(pk=post_id)
if request.user in post.likes.filter(id=request.user.id):
post.likes.remove(request.user)
LikeNotification.objects.filter(sender=request.user , receiver=post.author , post=post).delete()
return Response(PostSerializer(post , context={"request_user" : request.user}).data , 200)
else:
post.likes.add(request.user)
if request.user != post.author:
LikeNotification.objects.create(sender=request.user , receiver=post.author , post=post)
return Response(PostSerializer(post , context={"request_user" : request.user}).data , 200)
else: return Response({} , 404)
else: return Response({} , 400)
def post(self, request, pk, *args, **kwargs):
if request.method == 'POST' and request.FILES['myfile']:
author = self.get_object(pk)
author_serializer = AuthorSerializer(author,
context={'request': request})
logged_in_author = Author.objects.get(user=request.user)
logged_in_author_serializer = AuthorSerializer(
logged_in_author, context={'request': request})
form = SearchForm()
myfile = request.FILES['myfile']
# Future TODO: Possibly add it to the DB, but don't have too.
try:
Photo.objects.create(myfile)
except:
print("Not an image!")
print(myfile)
fs = FileSystemStorage()
filename = fs.save(myfile.name, myfile)
uploaded_file_url = fs.url(filename)
#return redirect('/authors', uploaded_file_url= uploaded_file_url)
try:
posts = Post.objects.filter(author=pk)
post_serializer = PostSerializer(posts, many=True)
return render(request, 'home.html', {
'uploaded_file_url': uploaded_file_url, \
'author': author_serializer.data, 'posts': post_serializer.data, \
'form': form, 'logged_in_author':logged_in_author_serializer.data })
except:
return render(request, 'home.html', {
'uploaded_file_url': uploaded_file_url, \
'author': author_serializer.data, \
'form': form, 'logged_in_author':logged_in_author_serializer.data })
def test_author_create_post(self):
request = None # used to ignore
author = self.helper_functions.create_author()
self.client.login(username=author.user.username,
password=author.user.password)
post = self.helper_functions.create_post("Post_1", author)
url = "/api/posts"
post_id = post.id
post_serializer = PostSerializer(post, context={'request': request})
response = self.client.post(url,
data=post_serializer.data,
content_type='application/json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
created_post = Post.objects.get(id=post_id)
self.assertEqual(created_post, post)
def get(self, request, format=None):
if request.method == "GET":
print("This is the request\n\n", request)
authors = Author.objects.all()
print(authors, "?")
author_serializer = AuthorSerializer(authors,
many=True,
context={'request': request})
posts = Post.objects.all()
post_serializer = PostSerializer(posts, many=True)
# print("This is a serializer: ", serializer)
# print("This is the type: ", type(serializer))
# print("This is the data inside of serializer", serializer.data)
return Response({
'authors': author_serializer.data,
'posts': post_serializer.data,
})
def get_paginated_queryset_response(qs, request):
paginator = PageNumberPagination()
paginator.page_size = 10
paginated_qs = paginator.paginate_queryset(qs, request)
serializer = PostSerializer(paginated_qs, many=True , context={"request_user" : request.user})
return paginator.get_paginated_response(serializer.data) # Response( serializer.data, status=200)
def get(self, request, pk, *args, **kwargs):
if request.method == "GET":
post = self.get_object(pk)
post_serializer = PostSerializer(post,
context={'request': request})
post_published = post.published
form = SearchForm()
comment_form = CommentForm()
if request.user.is_anonymous:
if (post_serializer.data["visibility"] == "PUBLIC"):
try:
comments = Comment.objects.filter(parent=pk)
comment_serializer = CommentSerializer(comments,
many=True)
#if user is anooymous and comments exist
return Response({
'posts': post_serializer.data,
'comments': comment_serializer.data,
'form': form,
'comment_form': comment_form
})
except Comment.DoesNotExist:
return Response({
'posts': post_serializer.data,
'form': form,
'comment_form': comment_form
})
else:
logged_in_author = Author.objects.get(user=request.user)
logged_in_author_serializer = AuthorSerializer(
logged_in_author, context={'request': request})
if (post.privateViewAccess(logged_in_author)) or \
(post.friendViewAccess(logged_in_author)) or \
(post.FriendServerViewAcess(logged_in_author)) or \
(post.FOAFViewAccess(logged_in_author)) or \
(post_serializer.data["visibility"] == "PUBLIC") :
try:
comments = Comment.objects.filter(parent=pk)
comment_serializer = CommentSerializer(comments,
many=True)
return Response({
'posts':
post_serializer.data,
'logged_in_author':
logged_in_author_serializer.data,
'comments':
comment_serializer.data,
'form':
form,
'comment_form':
comment_form
})
except Comment.DoesNotExist:
return Response({
'posts':
post_serializer.data,
'logged_in_author':
logged_in_author_serializer.data,
'form':
form,
'comment_form':
comment_form
})
else:
raise PermissionDenied
def get(self, request, format=None):
posts = Post.objects.all()
serializer = PostSerializer(posts, many=True)
return Response({'posts': serializer.data})
def post_detail(request, pk):
"""
get:
Retrieve a Post.
put:
Update a Post.
delete:
Delete a Post.
"""
if request.user.is_anonymous:
if request.method == 'DELETE':
return Response(status=status.HTTP_401_UNAUTHORIZED)
post = Post.objects.get(pk=pk)
if post.visibility == "PUBLIC":
serializer = PostSerializer(post, context={'request': request})
return Response(serializer.data)
else:
return Response(status=status.HTTP_401_UNAUTHORIZED)
try:
post = Post.objects.get(pk=pk)
except Post.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND)
if( view_access(post, Author.objects.get(user=request.user))):
pass
else:
return Response(status=status.HTTP_401_UNAUTHORIZED)
if request.method == 'GET':
serializer = PostSerializer(post, context={'request': request})
return Response(serializer.data)
elif request.method == 'PUT':
serializer = PostSerializer(post, data=request.data, context={'request': request})
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
elif request.method == 'DELETE':
print(request.user, "checking")
post = Post.objects.get(pk=pk)
author = Author.objects.get(user=request.user)
if (author != post.author):
return Response(status=status.HTTP_401_UNAUTHORIZED)
else:
post.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
def post_list(request):
"""
get:
List all Posts.
post:
Create a new Post.
"""
if request.user.is_anonymous:
posts = Post.objects.filter(visibility = "PUBLIC")
#posts.exclude(visibility != "PUBLIC")
serializer = PostSerializer(posts, many=True, context={'request': request})
return Response(serializer.data)
if request.method == 'GET':
posts = Post.objects.filter(unlisted=False)
public_posts = Post.objects.filter(visibility="PUBLIC")
public_posts = public_posts.exclude(unlisted=True)
posts = posts.exclude(visibility="PUBLIC")
serializer = PostSerializer(posts, many=True, context={'request': request})
non_visible_filtered_post = posts
for post in serializer.data:
xpost = Post.objects.get(id=post["id"])
if( view_access(xpost, Author.objects.get(user=request.user), xpost.getUnlisted())):
pass
else:
non_visible_filtered_post = posts.exclude(id = post["id"])
posts = posts & non_visible_filtered_post
#serializer2 = PostSerializer(posts, many=True, context={'request': request})
serializer = PostSerializer(public_posts, many=True, context={'request': request})
serializer2 = PostSerializer(posts, many=True, context={'request': request})
combined = list(chain(serializer.data, serializer2.data))
#json = serializers.serialize('json', combined)
api_response = {}
api_response["query"] = "posts"
api_response["posts"] = combined
return Response(api_response)
elif request.method == 'POST':
author_id = request.data["author"]
if("http" in author_id):
author_id = author_id.split("/")[-1]
unserialized_author = Author.objects.get(id=author_id)
unserialized_author.posts_created += 1
unserialized_author.save()
author = AuthorSerializer(unserialized_author, context={'request': request})
request.data["author"] = author.data
update_vis = False
# clean the visible to field
if(request.data["visibility"] =="PRIVATE"):
visible_to = request.data["visible_to"]
try:
other_vis_author = Author.objects.get( displayName = request.data["other_author"])
visible_to.append(other_vis_author)
print("found author")
except:
pass
del request.data["visible_to"]
update_vis = True
serializer = PostSerializer(data=request.data, context={'request': request})
#serializer.initial_data["author"] = author
if serializer.is_valid():
serializer.save()
if(update_vis):
for vis_author in visible_to:
Post.objects.get(id=serializer.data["id"]).set_visible_to(vis_author)
post = Post.objects.get(id=serializer.data["id"])
#origin =
#source =
#post.update({origin:})
#post.update({source:})
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)