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