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 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 get(self, request, format=None): if request.GET.get('startID') is None: # Get all answers for a question questionID = int(request.GET.get('questionID')) question = Question.objects.get(pk=questionID) post = question.post answers = PostSerializer(post.child_posts.all(), many=True) return Response(answers.data) else: # Get 'count' answers of question from startID questionID = int(request.GET.get('questionID')) startID = int(request.GET.get('startID')) count = int(request.GET.get('count')) try: question = Question.objects.get(pk=questionID) except: return Response({'message': 'Question not exists'}, status=status.HTTP_400_BAD_REQUEST) answers = question.post.child_posts.all().order_by('-id') result = [] for answer in answers: if count <= 0: break if (startID != 0 and answer.id < startID) or (startID == 0): result.append(answer) count -= 1 serializer = PostSerializer(result, many=True) return Response(serializer.data, status=status.HTTP_200_OK)
def browse(request, n): topics = ['politics', 'health', 'sport', 'tech'] status = ['live', 'expired'] interrest = ['highestinterest', 'lowestinterest'] query_action = n.split('+') # list of actions: my_filter = {} interest = 0 for i in query_action: # Ignore spoace Cap Letter and "-" "_" action = i.lower() action = action.replace(" ", "") action = action.replace("_", "") action = action.replace("-", "") if action in topics: #find the topic to select my_action = 'topic__icontains' my_filter[my_action] = action.capitalize() elif action in status: my_action = 'status__icontains' my_filter[my_action] = action.capitalize() elif action in interrest: if action == 'highestinterest': interest = 1 else: interest = 2 queryset = Post.objects.all().filter(**my_filter) if interest == 1: queryset = queryset.annotate( total_like=Sum(F('likes') + F('dislikes'))).order_by('total_like') queryset = queryset.last() queryset = Post.objects.filter(pk=queryset.pk) elif interest == 2: queryset = queryset.annotate( total_like=Sum(F('likes') + F('dislikes'))).order_by('total_like') queryset = queryset.first() queryset = Post.objects.filter(pk=queryset.pk) if not (len(my_filter) == 0 and interest == 0): for item in queryset: # update all the time to exipire 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(queryset, many=True) return Response(serializer.data) else: return Response('No Action in ' + n + ' is recognised')
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 test_post_detail(self, client, post_factory): test_url = reverse_lazy(self.post_detail_url, args=(1,)) for http_method in ('post', 'put', 'patch', 'delete'): response = getattr(client, http_method)(test_url) assert response.status_code == status.HTTP_405_METHOD_NOT_ALLOWED url = reverse_lazy(self.post_detail_url, args=(100500,)) response = client.get(url) assert response.status_code == status.HTTP_404_NOT_FOUND draft_post = post_factory(status=Post.DRAFT) url = reverse_lazy(self.post_detail_url, args=(draft_post.id,)) response = client.get(url) assert response.status_code == status.HTTP_404_NOT_FOUND non_draft_post = post_factory(status=Post.PUBLISHED) url = reverse_lazy(self.post_detail_url, args=(non_draft_post.id,)) response = client.get(url) assert response.status_code == status.HTTP_200_OK assert response.data == PostSerializer(non_draft_post).data client.force_authenticate(draft_post.author) url = reverse_lazy(self.post_detail_url, args=(draft_post.id,)) response = client.get(url) assert response.status_code == status.HTTP_200_OK assert response.data == PostSerializer(draft_post).data
def test_post_create(self, client, faker): for http_method in ('get', 'post', 'put', 'patch', 'delete'): response = getattr(client, http_method)(self.post_create_url) assert response.status_code == status.HTTP_401_UNAUTHORIZED user = User.objects.annotate( posts_total=Count('posts') ).last() client.force_authenticate(user) for http_method in ('get', 'put', 'patch', 'delete'): response = getattr(client, http_method)(self.post_create_url) assert response.status_code == status.HTTP_405_METHOD_NOT_ALLOWED payloads = {} response = client.post(self.post_create_url, data=payloads) assert response.status_code == status.HTTP_400_BAD_REQUEST assert len(response.data['codes']) == 2 assert self.title_field in response.data assert self.body_field in response.data assert response.data.get(self.title_field) == ['This field is required.'] assert response.data.get(self.body_field) == ['This field is required.'] payloads.update({ self.title_field: faker.sentence(), self.body_field: faker.text(), self.allow_comments_field: True, }) user_posts_count = user.posts_total response = client.post(self.post_create_url, data=payloads) assert response.status_code == status.HTTP_201_CREATED assert response.data == PostSerializer(Post.objects.get(id=response.data.get('id'))).data assert response.data.get(self.status_field) == Post.PUBLISHED assert response.data.get(self.allow_comments_field) user.refresh_from_db() user.posts_total = user_posts_count + 1 payloads.update({ self.title_field: faker.sentence(), self.body_field: faker.text(), self.allow_comments_field: True, self.status_field: Post.DRAFT, }) user_posts_count = user.posts_total response = client.post(self.post_create_url, data=payloads) assert response.status_code == status.HTTP_201_CREATED assert response.data == PostSerializer(Post.objects.get(id=response.data.get('id'))).data assert response.data.get(self.status_field) == Post.DRAFT assert response.data.get(self.allow_comments_field) user.refresh_from_db() user.posts_total = user_posts_count + 1
def test_create_post_with_unique_slug(self): """Test creating post with unique slug""" post1 = sample_post(user=self.user, title='Post 01') post2 = sample_post(user=self.user, title='Post 02') serializer1 = PostSerializer(post1) serializer2 = PostSerializer(post2) self.assertNotEqual(serializer1.data['slug'], serializer2.data['slug'])
def get(self, request, format=None): team_id = request.GET.get('team') if team_id: posts = Post.objects.filter(team=team_id) serializer = PostSerializer(posts, many=True) return Response(serializer.data) posts = Post.objects.filter(user=request.user) serializer = PostSerializer(posts, many=True) return Response(serializer.data)
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 test_clear_inbox(self): """Test clearing items in Inbox""" inbox = self.create_inbox() post_1 = PostSerializer(self.post_1).data post_2 = PostSerializer(self.post_1).data inbox.items.append(post_1) inbox.items.append(post_2) self.assertEqual(len(inbox.items), 2) inbox.items.clear() self.assertEqual(len(inbox.items), 0)
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 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 test_edit_post_after_sending(self): """Test editing Post after sending to Inbox""" inbox = self.create_inbox() post_1 = PostSerializer(self.post_1).data inbox.items.append(post_1) self.assertEqual(post_1, inbox.items[0]) self.post_1.title = "Modified Title" modified_post_1 = PostSerializer(self.post_1).data self.assertEqual(post_1, inbox.items[0]) self.assertNotEqual(modified_post_1, inbox.items[0]) self.assertNotEqual(modified_post_1, post_1)
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 get(self, request, format=None, **kwargs): search_term = request.GET.get('q', '') serializer_context = {'request': request} posts = PostSerializer( Post.objects.filter(title__icontains=search_term), many=True, context=serializer_context) users = UserSerializer( User.objects.filter(username__icontains=search_term), many=True, context=serializer_context) subreddits = SubSerializer( Sub.objects.filter(title__icontains=search_term), many=True, context=serializer_context) data = { 'posts': posts.data, 'users': users.data, 'subreddits': subreddits.data, } return Response(data=data)
def home(request): if request.user.is_authenticated: user_profile = get_object_or_404(Profile, user=request.user) following_list = [] for following in user_profile.following: following_list.append(following["username"]) post_list = [] for user in following_list: u = get_object_or_404(User, username=user) posts = Post.objects.filter(user=u) for post in posts: profile = get_object_or_404(Profile, user=post.user) user_profile = ProfileSerializer(profile, many=False) is_current_user_liked = False if any(x["id"] == request.user.id for x in post.likes): is_current_user_liked = True post = PostSerializer(post, many=False) post_list.append({ "post": post.data, "is_current_user_liked": is_current_user_liked, "profile": user_profile.data }) post_list = sorted(post_list, key=lambda x: x["post"]["timestamp"], reverse=True) return Response(post_list, status=status.HTTP_200_OK) else: return Response({"error": "Authentication credential not provided"}, status=status.HTTP_401_UNAUTHORIZED)
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 search(request): if request.data.get("keyword"): post_list = [] user_list = [] posts = Post.objects.filter( caption__contains=request.data.get("keyword")) for post in posts: post = PostSerializer(post, many=False) post_list.append(post.data) post_list = sorted(post_list, key=lambda x: x["timestamp"], reverse=True) users = User.objects.filter( username__contains=request.data.get("keyword")) for user in users: user = UserSerializer(user, many=False) user_list.append(user.data) # user_list = sorted( # user_list, key=lambda x: x["last_login"], reverse=True) return Response( { "posts": { "post_result": post_list, "result_length": len(post_list) }, "users": { "user_result": user_list, "result_length": len(user_list) }, }, status=status.HTTP_200_OK) else: return Response({"keyword": "This field is required."}, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, pk, format=None): event = self.get_object(pk) postform = PostForm(request.data) if postform.is_valid(): post = postform.save(commit=False) post.author = request.user post.object_id = event.id post.object_name = event.name post.object_type = 'Event' post.object_is_private = event.is_private post.save() try: image_ids = request.data['images'] images = PostFiles.objects.filter(id__in=image_ids) for image in images: post.images.add(image) except: pass event.posts.add(post) searchindex = IndexObject('post', post.id) serializer = PostSerializer(post, context={'request': request}) return Response(serializer.data, status=status.HTTP_201_CREATED) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
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)
class CommentSerializer(serializers.ModelSerializer): created_by = UserSerializer(required=False) created_by_id = serializers.IntegerField(write_only=True, required=False, allow_null=True) post = PostSerializer(required=False, read_only=True) post_id = serializers.IntegerField(write_only=True, required=False, allow_null=True) class Meta: model = Comments fields = ( 'id', 'text', 'created_by', 'created_by_id', 'post', 'post_id', ) def create(self, validated_data): comments = Comments.objects.create(**validated_data) post_id = validated_data.get("post_id") validated_data.pop("post_id", None) post = Posts.objects.filter(id=post_id).first() comments.post = post comments.save() return comments
def get(self, request, pk, format=None): event = self.get_object(pk) posts = event.posts.all().order_by('-id') serializer = PostSerializer(posts, many=True, context={'request': request}) return Response(serializer.data)
def posts_list(request): """ List posts. """ if request.method == 'GET': data = [] nextPage = 1 previousPage = 1 customers = Post.objects.all() page = request.GET.get('page', 1) paginator = Paginator(customers, 10) try: data = paginator.page(page) except PageNotAnInteger: data = paginator.page(1) except EmptyPage: data = paginator.page(paginator.num_pages) serializer = PostSerializer(data, context={'request': request}, many=True) if data.has_next(): nextPage = data.next_page_number() if data.has_previous(): previousPage = data.previous_page_number() url = reverse('list_posts_api_v1') return Response({ 'data': serializer.data, 'count': paginator.count, 'numpages': paginator.num_pages, 'nextlink': url + '?page=' + str(nextPage), 'prevlink': url + '?page=' + str(previousPage) })
def latest(self, request): posts = paginate_queryset( Post.get_user_view(request.user.id).filter(parent=None), request, 'id', self.page_size) serializer = PostSerializer(posts, many=True) return Response(serializer.data)
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)
class ProfileSerializer(serializers.ModelSerializer): posts = serializers.PrimaryKeyRelatedField(many=True, read_only=True) post = PostSerializer(write_only=True) user_id = serializers.IntegerField(write_only=True) user = serializers.CharField(read_only=True) class Meta: model = Profiles fields = '__all__' def validate_phone_number(self, value): phone_number_pattern = re.compile("^09\d{9}$") if phone_number_pattern.match(value): return value else: raise ValidationError("phone number is not correct.") def create(self, validated_data): if 'post' in validated_data: users = validated_data.pop('user_id') profile_user = get_object_or_404(User, pk=users) post = validated_data.pop('post') profile = Profiles.objects.create(user=profile_user, **validated_data) my_post = Posts.objects.create(**post, author=profile) return profile else: users = validated_data.pop('user_id') profile_user = get_object_or_404(User, pk=users) profile = Profiles.objects.create(user=profile_user, **validated_data) return profile
class CommentSerializer(serializers.ModelSerializer): author = UserSerializer(read_only=True) post_comment = PostSerializer(read_only=True) class Meta: model = Comment fields = ['id', 'text_content', 'author', 'post_comment']
def get(self, request, format=None): """ Return a list of all posts. """ posts = Post.objects.all() serializer = PostSerializer(posts, many=True) return Response(serializer.data)
def get(self, request, pk, format=None): """ Retrieve a post instance """ post = self.get_object(pk) serializer = PostSerializer(post) return Response(serializer.data)