def blog_detail(request, pk): try: blog = Blog.objects.get(pk=pk) except blog.DoesNotExist: return JsonResponse({'message': 'The blog does not exist'}, status=status.HTTP_404_NOT_FOUND) # find blog by pk (id) if request.method == 'GET': blog_serializer = BlogSerializer(blog) return JsonResponse(blog_serializer.data) elif request.method == 'PUT': blog_data = JSONParser().parse(request) blog_serializer = BlogSerializer(blog, data=blog_data) if blog_serializer.is_valid(): blog_serializer.save() return JsonResponse(blog_serializer.data) return JsonResponse(blog_serializer.errors, status=status.HTTP_400_BAD_REQUEST) # GET / PUT / DELETE blog elif request.method == 'DELETE': blog.delete() return JsonResponse({'message': 'blog was deleted successfully!'}, status=status.HTTP_204_NO_CONTENT)
def blog_collection(request): if request.method == 'GET': blogs = Blog.objects.all() serializer = BlogSerializer(blogs, many=True) return Response(serializer.data) elif request.method == 'POST': data = {'title': request.data.get('title'), 'content': request.data.get('content')} serializer = BlogSerializer(data=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 blog_list_api(request): """ List all code snippets, or create a new snippet. """ if request.method == 'GET': blogs = Blog.objects.all() serializer = BlogSerializer(blogs, many=True) return JsonResponse(serializer.data, safe=False) elif request.method == 'POST': data = JSONParser().parse(request) serializer = BlogSerializer(data=data) if serializer.is_valid(): serializer.save() return JsonResponse(serializer.data, status=201) return JsonResponse(serializer.errors, status=400)
def get(self, request): getBlogs = Blog.objects.all() try: blogSerializer = BlogSerializer(getBlogs, many=True) return Response(blogSerializer.data, status=status.HTTP_200_OK) except: return Response(blogSerializer.errors, status.HTTP_403_FORBIDDEN)
def serializer_put(request, requested_blog_id): blog = Blog.objects.get(id=requested_blog_id) serializer = BlogSerializer(blog, data=request.data) if serializer.is_valid(): serializer.save() return Response(serializer.data) return Response(serializer.errors, status=HTTP_400_BAD_REQUEST)
def list(self, request): blogs = Blog.objects.filter(created_by=request.user.id) data = BlogSerializer(blogs, many=True).data return response.Response({ 'data': data, 'user': request.user.username, 'id': request.user.id })
def test_fields(self): serializer = BlogSerializer() self.assert_fields_required(True, serializer, self.required_fields) self.assert_fields_required(False, serializer, self.not_required_fields) self.assertEqual( len(serializer.fields), len(self.required_fields) + len(self.not_required_fields))
class AuthorBlogSerializer(serializers.ModelSerializer): id = serializers.IntegerField(read_only=True) blogs = BlogSerializer(read_only=True, many=True, source='blog_set') user_details = UserSerializer(source='parent_user') class Meta: model = AppUser fields = '__all__'
def blog_list(request): """" List all blogs """ if request.method =="GET": blogs=Blog.objects.all() serializer=BlogSerializer(blogs,many=True) return JsonResponse(serializer.data, safe=False) elif request.method =="POST": data = JSONParser().parse(request) serializer=BlogSerializer(data=data) if serializer.is_valid(): serializer.save() print(data) return JsonResponse(serializer.data, status=201) return JsonResponse (serializer.errors, status=400)
def post(self, request): serializer = BlogSerializer(data=request.data) if serializer.is_valid(): serializer.save() return create_response(data=serializer.data, status=status.HTTP_201_CREATED) return create_response(error=serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def get(self, request, site): try: blog = Blog.objects.get(site=site) except Blog.DoesNotExist: return create_response(error={"message": "Blog does not exist"}, status=status.HTTP_404_NOT_FOUND) serializer = BlogSerializer(blog) return create_response(data=serializer.data, status=status.HTTP_200_OK)
def blog_detail(request, pk): # find blog by id try: blog = Blog.objects.get(pk=pk) # retrive a single blog if request.method == 'GET': blog_serializer = BlogSerializer(blog) return JsonResponse(blog_serializer.data) # Update a Blog by the id in the request elif request.method == 'PUT': blog_data = JSONParser().parse(request) blog_serializer = BlogSerializer(blog, data=blog_data) if blog_serializer.is_valid(): blog_serializer.save() return JsonResponse(blog_serializer.data) return JsonResponse(blog_serializer.errors, status=status.HTTP_400_BAD_REQUEST) # Delete a Blog with the specified id elif request.method == 'DELETE': blog.delete() return JsonResponse({'message':'Blod was deleted successfully!'}, status=status.HTTP_204_NO_CONTENT) except Blog.DoesNotExist: return JsonResponse({'message':'The blog does not exist'}, status=status.HTTP_404_NOT_FOUND)
def list(self, request, format=None): user = request.user queryset = Blog.objects.filter(user_id=user.id).all() serializer = BlogSerializer(queryset, many=True) obj = { "success": True, "data": serializer.data, } return Response(obj, status=status.HTTP_200_OK)
def create(self, request, format=None): payload = request.data payload['user_id'] = request.user.id serializer = BlogSerializer(data=request.data) if (serializer.is_valid()): serializer.save() obj = {"success": True, "message": "Blog created Successfully!"} return Response(obj, status=status.HTTP_201_CREATED) obj = {"success": False, "message": serializer.errors} return Response(obj, status=status.HTTP_400_BAD_REQUEST)
def blog_list_published(request): # Find all Blogs with published = True blogs = Blog.objects.filter(published=True) if request.method == 'GET': blogs_serializer = BlogSerializer(blogs, many=True) return JsonResponse(blogs_serializer.data, safe=False)
def post(self, request, format=None, **kwargs): data = request.data data['author'] = self.request.user.id serializer = BlogSerializer(data=data) if serializer.is_valid(): serializer.save() return Response({"blog": serializer.data})
def blogs_list(request): # GET list of blogs, POST a new blog, DELETE all blogs if request.method == 'POST': blog_data = JSONParser().parse(request) blog_serializer = BlogSerializer(data=blog_data) if blog_serializer.is_valid(): blog_serializer.save() return JsonResponse(blog_serializer.data, status=status.HTTP_201_CREATED) return JsonResponse(blog_serializer.errors, status=status.HTTP_400_BAD_REQUEST) elif request.method == 'GET': blogs = Blog.objects.all() title = request.GET.get('title', None) if title is not None: blogs = blogs.filter(title__icontains=title) blogs_serializer = BlogSerializer(blogs, many=True) return JsonResponse(blogs_serializer.data, safe=False)
def blog_list(request): # retrive all blogs if request.method == 'GET': blogs = Blog.objects.all() title = request.GET.get('title', None) if title is not None: blogs = blogs.filter(title_icontains=title) blogs_serializer = BlogSerializer(blogs, many=True) return JsonResponse(blogs_serializer.data, safe=False) # 'safe=False' for objects serialization # delete all blogs elif request.method == 'DELETE': count = Blog.objects.all().delete() return JsonResponse({'message': '{} Blogs were deleted successfully!'.format(count[0])}, status=status.HTTP_204_NO_CONTENT) # Create and save new blog elif request.method == 'POST': blog_data = JSONParser().parse(request) blog_serializer = BlogSerializer(data=blog_data) if blog_serializer.is_valid(): blog_serializer.save() return JsonResponse(blog_serializer.data, status=status.HTTP_201_CREATED) return JsonResponse(blog_serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def blog_list(request, **kwargs): """ List all code snippets, or create a new snippet. """ qs = request.META['QUERY_STRING'] q, l = qs.split("=") if request.method == 'GET': if (qs): snippets = Blog.objects.all()[:int(l)] else: snippets = Blog.objects.all() serializer = BlogSerializer(snippets, many=True) return JsonResponse(serializer.data, safe=False)
def get(self, request, format=None, **kwargs): """ Return a list of all blogs or questions or both. """ type_ = self.request.query_params.get('type', None) tag_name = self.request.query_params.get('tag_name', None) # Tagged item type specified if type_ != None and tag_name != None: target_type = ContentType.objects.get( app_label=type_, model=type_) items = target_type.model_class().objects.filter( tags__tag_name__contains=tag_name) if type_ == "blog": return Response([BlogSerializer(blog).data for blog in items]) elif type_ == "question": return Response([QuestionSerializer(question).data for question in items]) else: return Response("Unknow tagged item type", status=status.HTTP_400_BAD_REQUEST) # Tagged item type specified, return all elif type_ == None and tag_name != None: blogs = Blog.objects.filter(tags__tag_name__contains=tag_name) data = {"blogs": [BlogSerializer(blog).data for blog in blogs]} questions = Question.objects.filter(tags__tag_name__contains=tag_name) data.update({"questions": [QuestionSerializer(question).data for question in questions]}) return Response(data) # invalid parameters elif type_ != None and tag_name == None: return Response("tag name is not provided", status=status.HTTP_400_BAD_REQUEST) else: return Response("no query parameter is provided", status=status.HTTP_400_BAD_REQUEST)
def retrieve(self, request, pk, format=None): user = request.user queryset = Blog.objects.filter(user_id=user.id).get(pk=pk) if not queryset: obj = {"success": False, "message": "Blog Not Found!"} return Response(obj, status=status.HTTP_401_UNAUTHORIZED) serializer = BlogSerializer(queryset) obj = { "success": True, "data": serializer.data, } return Response(obj, status=status.HTTP_200_OK)
def retrieve(self, request, *args, **kwargs): # get user instance = self.get_object() serializer = self.get_serializer(instance) # get recent blogs queryset_blogs = Blog.objects.filter( user=instance.user).order_by('-pub_date')[:3] serializer_blogs = BlogSerializer(queryset_blogs, context={'request': request}, many=True) return Response({ 'user': serializer.data, 'blogs': serializer_blogs.data })
def blog_detail_api(request, blog_id): """ Retrieve, update or delete a code snippet. """ try: blog = Blog.objects.get(id=blog_id) except Blog.DoesNotExist: return HttpResponse(status=404) if request.method == 'GET': serializer = BlogSerializer(blog) return JsonResponse(serializer.data) elif request.method == 'PUT': data = JSONParser().parse(request) serializer = BlogSerializer(blog, data=data) if serializer.is_valid(): serializer.save() return JsonResponse(serializer.data) return JsonResponse(serializer.errors, status=400) elif request.method == 'DELETE': blog.delete() return HttpResponse(status=204)
def to_representation(self, value): if isinstance(value, Post): serializer = PostSerializer(value) elif isinstance(value, Comment): serializer = CommentSerializer(value) elif isinstance(value, Like): serializer = LikeSerializer(value) elif isinstance(value, Blog): serializer = BlogSerializer(value) elif isinstance(value, Submission): serializer = SubmissionSerializer(value) elif isinstance(value, Message): serializer = MessageSerializer(value) else: return value.__str__() return serializer.data
def post(self, request, *args, **kwargs): blogSerializer = BlogSerializer(data=request.data) if blogSerializer.is_valid(): blog = blogSerializer.save() for image in self.request.FILES.getlist('image'): blogImageSerializer = BlogImageSerializer(data={ 'blog': blog.id, 'image': image }) if blogImageSerializer.is_valid(): blogImageSerializer.save() else: return Response(blogImageSerializer.errors, status.HTTP_403_FORBIDDEN) else: return Response(blogImageSerializer.errors, status.HTTP_403_FORBIDDEN) return Response(blogSerializer.data, status.HTTP_201_CREATED)
def update(self, request, pk=None): user = request.user queryset = Blog.objects.filter(user_id=user.id).get(pk=pk) if not queryset: obj = {"success": False, "message": "Blog Not Found!"} return Response(obj, status=status.HTTP_401_UNAUTHORIZED) payload = request.data payload['user_id'] = user.id serializer = BlogSerializer(queryset, data=payload) if (serializer.is_valid()): serializer.save() obj = {"success": True, "message": "Blog Updated Successfully!"} return Response(obj, status=status.HTTP_201_CREATED) obj = { "success": False, "message": serializer.errors, } return Response(obj, status=status.HTTP_400_BAD_REQUEST)
def type_blog(self, request, pk): blog_type = get_object_or_404(BlogType, pk=pk) blogs_all_list = Blog.objects.filter(blog_type=blog_type).all() paginator = CustomPagination() page = paginator.paginate_queryset(blogs_all_list, request) serializer = BlogSerializer(page, many=True, context={'request': request}) data = serializer.data return Response({ 'links': { 'next': paginator.get_next_link(), 'previous': paginator.get_previous_link() }, 'count': paginator.page.paginator.count, 'results': data, 'page_size': paginator.page_size, 'current_page': paginator.page.number, 'id': pk, 'type_name': blog_type.type_name })
def search(self, request): search_text = request.GET.get('q') raw_sql = f"select * from blog_blog where match(title, content) AGAINST ('{search_text}' IN BOOLEAN MODE)" blogs = Blog.objects.raw(raw_sql) if not search_text: blogs = [] paginator = CustomPagination() page = paginator.paginate_queryset(list(blogs), request) serializer = BlogSerializer(page, many=True, context={'request': request}) data = serializer.data return Response({ 'links': { 'next': paginator.get_next_link(), 'previous': paginator.get_previous_link() }, 'count': paginator.page.paginator.count, 'results': data, 'page_size': paginator.page_size, 'current_page': paginator.page.number, 'search_text': search_text, })
def get(self, request, id): paginator = PageNumberPagination() tag = Tag.objects.get(id=id) tag_serializer = TagSerializer(tag) query = request.GET.get('q', ' ') if query == 'courses': courses = Course.objects.filter(tags=tag) course_result_page = paginator.paginate_queryset(courses, request) course_serializer = CourseSerializer(course_result_page, many=True) return Response( { "tag": tag_serializer.data, "courses": course_serializer.data }, HTTP_200_OK) elif query == 'blogs': blogs = Blog.objects.filter(tags=tag) blog_result_page = paginator.paginate_queryset(blogs, request) blog_serializer = BlogSerializer(blogs, many=True) return Response( { "tag": tag_serializer.data, "blogs": blog_serializer.data }, HTTP_200_OK) elif query == 'clips': clips = Clip.objects.filter(tags=tag) clip_result_page = paginator.paginate_queryset(clips, request) clip_serializer = ClipSerializer(clips, many=True) return Response( { "tag": tag_serializer.data, "clips": clip_serializer.data }, HTTP_200_OK) else: return Response({"tag": tag_serializer.data}, HTTP_200_OK)
def cool_blogs(self, request, pk=None): blogs = BlogModel.objects.filter(pk=pk) sr = BlogSerializer(blogs, many=True) return Response({'data': sr.data})