Rewriting our API using class-based views

We'll start by rewriting the root view as a class-based view. All this involves is a little bit of refactoring of views.py.

  1. from snippets.models import Snippet
  2. from snippets.serializers import SnippetSerializer
  3. from django.http import Http404
  4. from rest_framework.views import APIView
  5. from rest_framework.response import Response
  6. from rest_framework import status
  9. class SnippetList(APIView):
  10.     """
  11.     List all snippets, or create a new snippet.
  12.     """
  13.     def get(self, request, format=None):
  14.         snippets = Snippet.objects.all()
  15.         serializer = SnippetSerializer(snippets, many=True)
  16.         return Response(serializer.data)
  18.     def post(self, request, format=None):
  19.         serializer = SnippetSerializer(data=request.data)
  20.         if serializer.is_valid():
  21.             serializer.save()
  22.             return Response(serializer.data, status=status.HTTP_201_CREATED)
  23.         return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

So far, so good. It looks pretty similar to the previous case, but we've got better separation between the different HTTP methods. We'll also need to update the instance view in views.py.

  1. class SnippetDetail(APIView):
  2.     """
  3.     Retrieve, update or delete a snippet instance.
  4.     """
  5.     def get_object(self, pk):
  6.         try:
  7.             return Snippet.objects.get(pk=pk)
  8.         except Snippet.DoesNotExist:
  9.             raise Http404
  11.     def get(self, request, pk, format=None):
  12.         snippet = self.get_object(pk)
  13.         serializer = SnippetSerializer(snippet)
  14.         return Response(serializer.data)
  16.     def put(self, request, pk, format=None):
  17.         snippet = self.get_object(pk)
  18.         serializer = SnippetSerializer(snippet, data=request.data)
  19.         if serializer.is_valid():
  20.             serializer.save()
  21.             return Response(serializer.data)
  22.         return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
  24.     def delete(self, request, pk, format=None):
  25.         snippet = self.get_object(pk)
  26.         snippet.delete()
  27.         return Response(status=status.HTTP_204_NO_CONTENT)

That's looking good. Again, it's still pretty similar to the function based view right now.

We'll also need to refactor our snippets/urls.py slightly now that we're using class-based views.

  1. from django.urls import path
  2. from rest_framework.urlpatterns import format_suffix_patterns
  3. from snippets import views
  5. urlpatterns = [
  6.     path('snippets/', views.SnippetList.as_view()),
  7.     path('snippets/<int:pk>/', views.SnippetDetail.as_view()),
  8. ]
  10. urlpatterns = format_suffix_patterns(urlpatterns)

Okay, we're done. If you run the development server everything should be working just as before.