[feature]: using request.data.get("key") while fetching request body instead of unnecessary using json.dumps.

[shikharpa]

Is there an existing issue for this?

• I have searched the existing issues

Summary

Issue: Inefficient Data Parsing in Django REST Framework

Description:

In the current implementation, data from the request body is being manually parsed using json.loads(request.body) in several places. This manual parsing can be inefficient and error-prone, especially since Django REST Framework (DRF) provides a more optimized solution with request.data.

Using json.loads(request.body):

• Requires manual parsing of the request body.
• Can lead to errors if the content type is not correctly handled or if the body is malformed.
• Increases complexity by requiring additional error handling and content-type checks.

Solution:

Replace json.loads(request.body) with request.data wherever request data is being processed. DRF's request.data automatically handles the parsing of the request body, ensuring:

• Correct Content-Type Handling: request.data automatically handles different content types (JSON, form data, etc.).
• Error Handling: Built-in error handling for invalid or malformed data.
• Code Simplicity: No need to manually parse or check the content type, making the code more readable and maintainable.
• Optimized Performance: DRF uses optimized methods for parsing request data, improving performance over manual parsing.

Example:

# Before:
import json
def post(self, request):
    payload = json.loads(request.body)  # Manual parsing of JSON

# After:
def post(self, request):
    data = request.data  # Automatically parsed by DRF


### Why should this be worked on?

## Why should this be worked on?

### 1. **Improved Performance:**
Manual parsing with `json.loads(request.body)` adds an unnecessary step that could be avoided. DRF’s `request.data` is optimized for parsing and can handle different content types more efficiently, leading to better performance.

### 2. **Error Handling and Robustness:**
By using `request.data`, DRF provides automatic validation and error handling for invalid or malformed data. This reduces the risk of errors related to improper content types, ensuring a more stable and reliable application.

### 3. **Code Maintainability:**
Using `request.data` simplifies the code by eliminating the need to manually check the content type and parse the body. This leads to cleaner, more readable code that is easier to maintain and extend in the future.

### 4. **Consistency and Best Practices:**
DRF’s `request.data` is the standard approach for handling request bodies, and aligning with this convention ensures that the project adheres to best practices, improving the overall consistency of the codebase.

### 5. **Scalability:**
As the project grows, relying on DRF’s abstraction will make it easier to manage and scale, especially when dealing with different types of data and increasing complexity in requests. It reduces the overhead of manually parsing various types of data.

### 6. **Reduced Technical Debt:**
By switching to DRF’s native handling of request data, the technical debt of managing manual parsing is minimized, making the project easier to work with in the long term.