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 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):
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 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 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 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)
class FeedSerializer(serializers.HyperlinkedModelSerializer):
class Meta:
model = Feed
fields = ('post', 'post_link')
post = PostSerializer(read_only=False)
post_link = serializers.HyperlinkedRelatedField(
source='post',
view_name='posts:post_detail',
lookup_field='pk',
many=False,
read_only=True,
lookup_url_kwarg='post_id')
class UserSerializer(serializers.HyperlinkedModelSerializer):
# profile = serializers.HyperlinkedRelatedField( # new
# many=False, view_name='profile-detail', read_only=True)
bio = serializers.ReadOnlyField(source='profile.bio')
date_joined = serializers.ReadOnlyField(source='profile.date_joined')
# posts = serializers.PrimaryKeyRelatedField(many=True, queryset=Post.objects.all())
posts = PostSerializer(many=True)
class Meta:
model = User
fields = [
'url', 'id', 'email', 'username', 'bio', 'date_joined', 'posts'
]
def post(self, request, pk):
# 여러장의 이미지를 받아서
# 특정 pk에 해당하는 Post에 연결되는 PostImage를 생성
# /posts/1/images/
post = Post.objects.get(pk=pk)
for image in request.data.getlist('image'):
data = {'image' : image}
serializer = PostImageCreateSerializer(data=data)
if serializer.is_valid():
serializer.save(post=post)
serializer = PostSerializer(post)
return Response(serializer.data)
def upvote(self, request, pk=None):
serializer = PostUpvoteSerializer(data={'post': pk},
context={'request': request})
if serializer.is_valid():
serializer.save()
post = Post.objects.get(pk=pk)
return Response(
PostSerializer(post, context={
'request': request
}).data)
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def put(self, request, pk, format=None):
try:
realty = Post.objects.get(
id=pk, user=self.request.user
)
except Post.DoesNotExist:
return Response(
{
'detail': 'Post does not exists'
},
status=status.HTTP_400_BAD_REQUEST
)
serializer = PostSerializer(realty, 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_nearby(request, format=None):
if request.method == 'POST':
jsondata = json.loads(request.body)
min_lat = jsondata['min_lat']
min_lon = jsondata['min_lon']
max_lat = jsondata['max_lat']
max_lon = jsondata['max_lon']
queryset = Post.objects.filter(lat__gt=min_lat,
lat__lt=max_lat,
lon__gt=min_lon,
lon__lt=max_lon).order_by('id')
serializer = PostSerializer(queryset,
many=True) # serializing the result
return JsonResponse(serializer.data)
def test_posts_limited_to_user(self):
"""Test retrieving posts for user"""
user2 = get_user_model().objects.create_user('*****@*****.**',
'adminPASS@123')
sample_post(user=user2)
sample_post(user=self.user)
res = self.client.get(POSTS_URL, {'user': self.user.id})
posts = Post.objects.filter(user=self.user)
serializer = PostSerializer(posts, many=True)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(len(posts), 1)
self.assertEqual(res.data, serializer.data)
def test_filter_posts_by_categories(self):
"""Test returning posts with specific category"""
category01 = sample_category(user=self.user, name='Cat 01')
category02 = sample_category(user=self.user, name='Cat 02')
post1 = sample_post(user=self.user,
title='Post 01',
category=category01)
post2 = sample_post(user=self.user,
title='Post 02',
category=category02)
post3 = sample_post(user=self.user, title='Post 03')
res = self.client.get(
POSTS_URL,
{'categories': '{},{}'.format(category01.id, category02.id)})
serializer1 = PostSerializer(post1)
serializer2 = PostSerializer(post2)
serializer3 = PostSerializer(post3)
self.assertIn(serializer1.data, res.data)
self.assertIn(serializer2.data, res.data)
self.assertNotIn(serializer3.data, res.data)
def retrieve(self, request, *args, **kwargs):
query = self.request.query_params.get('query')
if query == 'posts':
author = self.get_object()
serializer = PostSerializer(author.posts.all(), many=True)
return Response(serializer.data)
if query == 'likes':
like = Like.objects.filter(author=self.get_object())
serializer = LikeSerializer(like, many=True)
return Response(serializer.data)
instance = self.get_object()
serializer = self.get_serializer(instance)
return Response(serializer.data)
def handle_editing_post(self, content):
post = Post.objects.get(pk=content['id'])
if self.user == post.author:
post.content = content['content']
post.save()
post_data = PostSerializer(post).data
async_to_sync(self.channel_layer.group_send)(
self.room_group_name,
{
'type': 'send_event_to_client',
'event_type': 'EDITED_POST',
'content': post_data,
}
)
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 create_post(self, request, **kwargs):
try:
group = Group.objects.get(**kwargs)
except Group.DoesNotExist:
return response404('Group')
self.check_object_permissions(request=request, obj=group)
serializer = PostSerializer(data=request.data, partial=True)
if not serializer.is_valid():
return response406({
**serializer.errors, 'message': 'Błąd walidacji'
})
post = serializer.save(group=group, owner=request.user)
file = request.FILES.get('file', None)
image = request.FILES.get('image', None)
if file:
post.file = file
post.save()
if image:
post.image = image
post.save()
return response200({
**serializer.data, 'message':
'Pomyślnie utworzono post'
})
class NotificationSerializer(serializers.ModelSerializer):
from_user = UserSerializer()
post = PostSerializer()
to_user = UserSerializer()
class Meta:
model = Notification
fields = [
'created_at',
'from_user',
'id',
'post',
'to_user',
'type',
]
def get(self, request, pk, **kwargs):
try:
queryset = Post.objects.get(id=pk, author=self.request.user)
except Post.DoesNotExist:
return Response(
{
'detail': 'Post does not exists'
},
status=status.HTTP_400_BAD_REQUEST
)
realty = PostSerializer(queryset)
return Response(realty.data)
class NotificationSerializer(serializers.ModelSerializer):
from_user = UserSerializer()
post = PostSerializer()
to_user = UserSerializer()
class Meta:
model = Notification
fields = [
"created_at",
"from_user",
"id",
"post",
"to_user",
"type",
]
def get(self, request):
user = IsLoggedIn(request)
if user is not None:
feed_posts_ids = list()
posts = Post.objects.all()
for post in posts:
if user in post.stream.followed_by.all():
feed_posts_ids.append(post.id)
elif post.author in user.following.all():
feed_posts_ids.append(post.id)
feed_posts = Post.objects.filter(id__in=feed_posts_ids)
serializer = PostSerializer(feed_posts, many=True)
return Response(serializer.data)
else:
return Response(status=status.HTTP_401_UNAUTHORIZED)
def update_post(request, post_id):
if request.user.is_authenticated:
post = get_object_or_404(Post, pk=post_id)
if post.user == request.user:
if request.data.get('caption'):
post.caption = request.data.get('caption')
post.save()
post = PostSerializer(post, many=False)
return Response(post.data)
else:
return Response({"caption": "this field is required"})
else:
return Response("You dont\'t have permission to update this post")
else:
return Response("Authentication credentials not provided")
def updatePostUpvote(request, format=None):
if request.method == 'PATCH':
jsondata = json.loads(request.body)
post_id = jsondata['post_id']
operate = jsondata['operate']
post = Post.objects.get(id=post_id)
upvote = post.upvotes
if operate == 'increase':
upvote = upvote + 1
elif (operate == 'decrease' and upvote > 0):
upvote = upvote - 1
post.upvotes = upvote
post.save()
new_post = Post.objects.get(id=post_id)
serializer = PostSerializer(new_post)
return JsonResponse(serializer.data)
class UserSerializer(serializers.ModelSerializer):
posts = PostSerializer(many=True)
communities = CommunitySerializer(many=True)
class Meta:
model = User
fields = [
"id",
"email",
"first_name",
"last_name",
"date_joined",
"groups",
"posts",
"communities",
]
def post_detail(self, request, **kwargs):
post = get_object_or_404(Post, id=kwargs.get('post_id'))
self.check_object_permissions(request, post.group)
response_data = {
'post':
PostSerializer(post, context={
"host": request.get_host()
}).data,
'comments':
CommentSerializer(Comment.objects.filter(post=post),
context={
"host": request.get_host()
},
many=True).data
}
return JsonResponse(data=response_data, status=200, safe=False)
def create_post(request):
'''
Create a post to the server. Input should be in the format:
{"title": "title1",
"expiration_time": 10080, # in minutes Optional by default the post is valid 7 days
"topic": ["Politics"],
"content": "Bla Bla Bla"}
'''
if request.method == 'GET':
posts = Post.objects.all()
# update all the time to exipire
for item in posts:
t = item.time_to_expire() # get time to expire
t = timezone.timedelta(seconds=int(t))
serializer = PostSerializer(item)
queryset_comment = Comment.objects.filter(
post=serializer.data['id']
) # find all the comment related to a post
queryset_preference = Preference.objects.filter(
post=serializer.data['id']
) # find all the preference related to a post
update_time(queryset_comment, t, CommentSerializer)
update_time(queryset_preference, t, PreferenceSerializer)
serializer = PostSerializer(posts, many=True)
return Response(serializer.data)
elif request.method == 'POST':
data_mutable = request.data.copy() #make the QueryDict mutable
data_mutable['owner'] = request.user.id # set the current user as user
serializer = PostSerializer(data=data_mutable)
if serializer.is_valid():
serializer.save(owner=request.user) # set the current user as user
r = {
'User ID': request.user.id,
'message': 'Successfully created Post',
'Data': serializer.data,
}
return Response(r)
return Response(serializer.errors)
def create_post(request):
if request.user.is_authenticated:
if request.data.get("is_video") == "YES":
is_video = True
else:
is_video = False
post = Post(user=request.user,
video_url=request.data.get("post_url"),
post_image=request.data.get("image"),
is_video=is_video,
caption=request.data.get("caption"))
post.save()
post = PostSerializer(post, many=False)
return Response(post.data)
else:
return Response({"message": "Authentication details not provided"},
status=HTTP_401_UNAUTHORIZED)
def posts_list(self, request, **kwargs):
group = get_object_or_404(Group, id=kwargs.get('group_id'))
self.check_object_permissions(request, group)
try:
posts = Post.objects.filter(group=group).order_by('-date_posted')
except Post.DoesNotExist():
return Response(
data={'message': 'Posts in this group were not found'},
status=status.HTTP_406_NOT_ACCEPTABLE)
users_posts = PostSerializer(posts,
many=True,
context={
'host': request.get_host()
}).data
paginator = PageNumberPagination()
data = paginator.paginate_queryset(users_posts, request)
return paginator.get_paginated_response(data=data)
def cancel_upvote(self, request, pk=None):
try:
post = Post.objects.get(pk=pk)
instance = PostUpvote.objects.get(post=post,
voter=self.request.user)
self.perform_destroy(instance)
return Response(
PostSerializer(post, context={
'request': request
}).data)
except ObjectDoesNotExist:
return Response(
{
'status': 'Not Fount',
'message': 'This upvote is not exist.'
},
status=status.HTTP_404_NOT_FOUND)
def get(self, request, format=None):
try:
user = self.request.user
user_profile = User.objects.get(id=user.id)
user = User.objects.get(id=self.request.user.id)
serializer = UserFollowerSerializer(user_profile.following.all(), many=True)
newData = []
for i in user_profile.following.all():
data = PostsModel.objects.filter(username=i.following_user_id.id)
serializer = PostSerializer(data, many=True)
newData = newData + serializer.data
return Response({'username': user.username, 'data': newData})
except:
return Response({'post': 'There was an error. Please check your data and try again.'})
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)
class ProfileSerializer(serializers.ModelSerializer):
posts = PostSerializer(many=True, read_only=True)
class Meta:
model = User
fields = ('id', 'username', 'first_name', 'last_name', 'posts')
extra_kwargs = {
'password': {
'required': False,
'write_only': True
},
'email': {
'required': False
},
'username': {
'required': False
}
}
def post(self, request):
body = request.data.get('body')
result = {}
post_records = Post.objects.filter(
Q(title__icontains=body) | Q(body__icontains=body))
result['post'] = PostSerializer(post_records, many=True).data
chanel_records = Chanel.objects.filter(
Q(description__icontains=body) | Q(identifier__icontains=body))
result['chanel'] = ChanelSerializer(chanel_records, many=True).data
user_records = User.objects.filter(
Q(first_name__icontains=body) | Q(last_name__icontains=body)
| Q(email__icontains=body) | Q(username__icontains=body))
result['user'] = UserSerializer(user_records, many=True).data
return JsonResponse(data={
'data': result,
'success': True
},
status=HTTP_200_OK)
class QuestionWithTopAnswerSerializer(serializers.ModelSerializer):
post = PostSerializer()
topics = TopicSerializer(many=True)
answer = serializers.SerializerMethodField('get_top_answer')
class Meta:
model = Question
fields = ('id', 'question', 'topics', 'post', 'answer')
def get_top_answer(self, obj):
post = obj.post
try:
answer = post.child_posts.all().order_by('-total_vote')[0]
except:
answer = None
serializer = PostSerializer(answer)
return serializer.data
