Generic views in DRF in Django - Mini Project: Build & Apply

Building a Simple API with Generic Views in DRF

📖 Scenario: You are creating a small API for a bookstore. You want to list books and add new books easily using Django Rest Framework's generic views.

🎯 Goal: Build a simple API with a list and create endpoint for books using DRF generic views.

📋 What You'll Learn

Create a Book model with fields title and author

Create a serializer called BookSerializer for the Book model

Use DRF's generic views to create a view that lists all books and allows adding new books

Configure URL routing to connect the view to the path /books/

💡 Why This Matters

🌍 Real World

APIs like this let apps and websites get and add data easily, such as showing a list of books or adding new ones.

💼 Career

Knowing DRF generic views is important for backend developers building REST APIs quickly and cleanly.

1

Create the Book model

Create a Django model called Book with two fields: title as a CharField with max length 100, and author as a CharField with max length 100.

Django

# Your code here

Hint

Think of a book as having a name and who wrote it. Use CharField for both.

2

Create the BookSerializer

Create a serializer class called BookSerializer that inherits from serializers.ModelSerializer. Inside, add a Meta class with model = Book and fields = ['id', 'title', 'author'].

Django

from django.db import models

class Book(models.Model):
    title = models.CharField(max_length=100)
    author = models.CharField(max_length=100)

from rest_framework import serializers

# Your code here

Hint

Serializers help convert model data to JSON. Use ModelSerializer for easy setup.

3

Create the generic view for listing and creating books

Create a view class called BookListCreateView that inherits from generics.ListCreateAPIView. Set its queryset to Book.objects.all() and serializer_class to BookSerializer.

Django

from django.db import models

class Book(models.Model):
    title = models.CharField(max_length=100)
    author = models.CharField(max_length=100)

from rest_framework import serializers

class BookSerializer(serializers.ModelSerializer):
    class Meta:
        model = Book
        fields = ['id', 'title', 'author']

from rest_framework import generics

# Your code here

Hint

Generic views save time. Use ListCreateAPIView to list and add books.

4

Add URL routing for the book API

In your urls.py, import BookListCreateView and add a path 'books/' that points to BookListCreateView.as_view().

Django

from django.db import models

class Book(models.Model):
    title = models.CharField(max_length=100)
    author = models.CharField(max_length=100)

from rest_framework import serializers

class BookSerializer(serializers.ModelSerializer):
    class Meta:
        model = Book
        fields = ['id', 'title', 'author']

from rest_framework import generics

class BookListCreateView(generics.ListCreateAPIView):
    queryset = Book.objects.all()
    serializer_class = BookSerializer

from django.urls import path

# Your code here

Hint

URLs connect your views to web addresses. Use path and as_view() for class-based views.

Practice

1. What is the main purpose of using generic views in Django REST Framework (DRF)?

easy

A. To provide ready-made classes that simplify common API tasks like CRUD operations

B. To write raw SQL queries directly in views

C. To handle user authentication manually

D. To create HTML templates for the frontend

Solution

1. Step 1: Understand generic views role

   Generic views in DRF offer pre-built classes to handle common API tasks such as listing, creating, updating, and deleting data.

2. Step 2: Compare options

   Options B, C, and D describe unrelated tasks: raw SQL, manual auth, and frontend templates, which are not the main purpose of generic views.

3. Final Answer:

   To provide ready-made classes that simplify common API tasks like CRUD operations -> Option A

4. Quick Check:

   Generic views simplify CRUD = A [OK]

Hint: Generic views = ready-made CRUD classes in DRF [OK]

Common Mistakes:

• Confusing generic views with authentication classes
• Thinking generic views handle frontend rendering
• Assuming generic views require manual SQL

2. Which of the following is the correct way to use a generic view to list all objects of a model named Book in DRF?

easy

A. class BookList(generics.ListAPIView):\n queryset = Book.objects.all()\n serializer_class = BookSerializer

B. class BookList(generics.CreateAPIView):\n queryset = Book.objects.all()\n serializer_class = BookSerializer

C. class BookList(generics.UpdateAPIView):\n queryset = Book.objects.all()\n serializer_class = BookSerializer

D. class BookList(generics.DestroyAPIView):\n queryset = Book.objects.all()\n serializer_class = BookSerializer

Solution

1. Step 1: Identify the generic view for listing objects

   The ListAPIView is designed to list all objects of a model.

2. Step 2: Match the class with the task

   Options B, C, and D correspond to creating, updating, and deleting respectively, which do not list objects.

3. Final Answer:

   class BookList(generics.ListAPIView):\n queryset = Book.objects.all()\n serializer_class = BookSerializer -> Option A

4. Quick Check:

   List all objects = ListAPIView = A [OK]

Hint: List objects use ListAPIView class [OK]

Common Mistakes:

• Using CreateAPIView for listing data
• Confusing UpdateAPIView with ListAPIView
• Forgetting to set queryset or serializer_class

3. Given this DRF generic view code, what will be the HTTP method supported and the main action performed?

class ArticleDetail(generics.RetrieveUpdateDestroyAPIView):
    queryset = Article.objects.all()
    serializer_class = ArticleSerializer

medium

A. Supports only POST method to create a new article

B. Supports GET, PUT, PATCH, DELETE methods to retrieve, update, or delete an article

C. Supports GET method to list all articles

D. Supports DELETE method only to remove all articles

Solution

1. Step 1: Understand RetrieveUpdateDestroyAPIView

   This generic view supports retrieving a single object (GET), updating it (PUT/PATCH), and deleting it (DELETE).

2. Step 2: Match HTTP methods to actions

   Supports GET, PUT, PATCH, DELETE methods to retrieve, update, or delete an article correctly describes the supported methods (GET for retrieve, PUT/PATCH for update, DELETE for destroy) for a single article. Options A, C, and D describe incorrect methods or actions.

3. Final Answer:

   Supports GET, PUT, PATCH, DELETE methods to retrieve, update, or delete an article -> Option B

4. Quick Check:

   RetrieveUpdateDestroyAPIView = GET, PUT/PATCH, DELETE [OK]

Hint: RetrieveUpdateDestroyAPIView handles GET, PUT/PATCH, DELETE [OK]

Common Mistakes:

• Thinking it supports POST for creation
• Confusing list view with detail view
• Assuming it deletes all objects instead of one

4. Identify the error in this DRF generic view code snippet:

class UserCreate(generics.CreateAPIView):
    serializer_class = UserSerializer

medium

A. CreateAPIView does not exist in DRF

B. serializer_class should be named serializer

C. Class name should be lowercase

D. Missing queryset attribute causes runtime error

Solution

1. Step 1: Check required attributes for CreateAPIView

   While CreateAPIView requires serializer_class, it also typically needs a queryset attribute to function properly without errors, especially in standard setups with permissions.

2. Step 2: Identify the error

   The missing queryset attribute causes runtime errors in many scenarios. Options A, B, and D are incorrect: CreateAPIView does exist (A), serializer_class is the correct name (B), and class names should use PascalCase (D).

3. Final Answer:

   Missing queryset attribute causes runtime error -> Option D

4. Quick Check:

   Missing queryset = runtime error [OK]

Hint: Always set queryset with generic views unless serializer handles all [OK]

Common Mistakes:

• Omitting queryset attribute
• Renaming serializer_class incorrectly
• Thinking CreateAPIView is invalid
• Using lowercase class names

5. You want to create a DRF API endpoint that allows listing all Product items and creating new ones in the same view. Which generic view class should you use and why?

hard

A. Use generics.ListAPIView only because creation should be separate

B. Use generics.RetrieveUpdateDestroyAPIView because it handles all CRUD operations

C. Use generics.ListCreateAPIView because it supports both listing and creating in one view

D. Use generics.CreateAPIView only because listing is not needed

Solution

1. Step 1: Identify the requirement

   The endpoint must list all products and allow creating new ones in the same view.

2. Step 2: Match generic view to requirement

   ListCreateAPIView is the correct choice as it supports GET (listing) and POST (creating). Use generics.RetrieveUpdateDestroyAPIView because it handles all CRUD operations (RetrieveUpdateDestroyAPIView) is for single-object detail operations. Options A and C support only a single action each.

3. Final Answer:

   Use generics.ListCreateAPIView because it supports both listing and creating in one view -> Option C

4. Quick Check:

   List + Create = ListCreateAPIView [OK]

Hint: ListCreateAPIView combines list and create in one view [OK]

Common Mistakes:

• Using RetrieveUpdateDestroyAPIView for list/create
• Choosing only CreateAPIView or ListAPIView alone
• Not combining actions in one view