Creating a Django REST Framework View to Return Data and Custom Messages
Tags: django, python, beginners, programming
Published: 2023-10-21 20:15:26

## Introduction

Django REST Framework (DRF) is a powerful tool for building web APIs in Django applications. When designing your API views, you may want to return data along with custom messages to provide informative responses to your clients. In this article, we'll guide you through creating a DRF view that returns data and custom messages for different HTTP methods.

### Prerequisites

Before you begin, make sure you have the following:

- A Django project with Django REST Framework installed.
- A model that you want to create a view for (we'll use a `Book` model as an example).

### Creating a View to Return Data and Messages

In this example, we'll create a view for a `Book` model that supports `GET`, `PUT`, and `DELETE` HTTP methods. We want to return the book data and custom messages for each operation.

```python
from rest_framework import status
from rest_framework.response import Response
from rest_framework.decorators import api_view
from .models import Book
from .serializers import BookSerializer

@api_view(['GET', 'PUT', 'DELETE'])
def book(request, pk):
    try:
        book = Book.objects.get(pk=pk)
    except Book.DoesNotExist:
        return Response({'message': 'Book not found'}, status=status.HTTP_404_NOT_FOUND)

    if request.method == 'GET':
        serializer = BookSerializer(book)
        return Response({'message': 'Book retrieved successfully', 'data': serializer.data})

    elif request.method == 'PUT':
        serializer = BookSerializer(book, data=request.data)
        if serializer.is_valid():
            serializer.save()
            return Response({'message': 'Book updated successfully', 'data': serializer.data})
        return Response({'message': 'Invalid data provided'}, status=status.HTTP_400_BAD_REQUEST)

    elif request.method == 'DELETE':
        book.delete()
        return Response({'message': 'Book deleted successfully'})
```

In the code above, we've created a view named `book` that accepts the book's primary key (`pk`) as a parameter.

1. **Handling Book Not Found**: We use a try-except block to handle the case where the requested book does not exist. In this case, we return a 404 Not Found response with a custom message.

2. **GET Method**: For the `GET` method, we retrieve the book, serialize it, and return a response containing the data and a custom success message.

3. **PUT Method**: When a `PUT` request is received, we update the book's data using the provided request data. If the serializer is valid, we save the changes and return the updated data along with a success message. If the data is invalid, we return a 400 Bad Request response with an "Invalid data provided" message.

4. **DELETE Method**: For the `DELETE` method, we delete the book and return a simple success message.

By following this approach, you can create a view that returns both data and custom messages for different HTTP methods, making your API responses more informative and user-friendly. You can adapt this pattern to other views in your DRF-based Django project to improve the quality of your API responses.