Django Request Objects

When a user interacts with your Django application by accessing a URL, Django creates a HttpRequest object containing metadata about that request. Understanding how to work with request objects is fundamental to building interactive web applications with Django.

What is a Django Request Object?

The request object is an instance of Django's HttpRequest class that contains information about the current HTTP request. This object is automatically created by Django when a user makes a request to your application and is passed as the first parameter to your view functions.

The request object contains valuable information such as:

• The HTTP method used (GET, POST, etc.)
• User session data
• Request headers
• Form data or JSON payload
• Query parameters
• File uploads
• Authentication details

Accessing the Request Object in Views

Every view function in Django receives the request object as its first parameter:

python

from django.http import HttpResponse

def sample_view(request):
    # 'request' is the HttpRequest object
    return HttpResponse("This is a sample view")

Common Request Object Properties and Methods

HTTP Method

You can check what HTTP method was used with request.method:

python

def my_view(request):
    if request.method == 'POST':
        # Process form data
        return HttpResponse("This was a POST request")
    elif request.method == 'GET':
        # Handle GET request
        return HttpResponse("This was a GET request")

Query Parameters

Access URL query parameters (e.g., ?name=John&age=25) using request.GET:

python

def search_view(request):
    query = request.GET.get('q', '')  # Default to empty string if 'q' not present
    category = request.GET.get('category', 'all')
    
    # Use query and category to filter results
    return HttpResponse(f"Searched for: {query} in category: {category}")

Form Data

For POST requests, access form data using request.POST:

python

def contact_form(request):
    if request.method == 'POST':
        name = request.POST.get('name', '')
        email = request.POST.get('email', '')
        message = request.POST.get('message', '')
        
        # Process the form data (e.g., send email, save to database)
        
        return HttpResponse("Form submitted successfully!")
    else:
        # Display the form
        return render(request, 'contact_form.html')

File Uploads

Access uploaded files using request.FILES:

python

def upload_file(request):
    if request.method == 'POST' and request.FILES.get('document'):
        uploaded_file = request.FILES['document']
        
        # Process the file (e.g., save to disk, analyze)
        file_name = uploaded_file.name
        file_size = uploaded_file.size
        
        return HttpResponse(f"Uploaded {file_name} ({file_size} bytes)")
    else:
        return render(request, 'upload_form.html')

JSON Data

For API endpoints receiving JSON data:

python

import json
from django.http import JsonResponse

def api_endpoint(request):
    if request.method == 'POST':
        try:
            data = json.loads(request.body)
            # Process the JSON data
            return JsonResponse({'status': 'success', 'data': data})
        except json.JSONDecodeError:
            return JsonResponse({'status': 'error', 'message': 'Invalid JSON'}, status=400)
    return JsonResponse({'status': 'error', 'message': 'Only POST requests allowed'}, status=405)

Cookies

Access cookies set by the client:

python

def cookie_view(request):
    username = request.COOKIES.get('username', 'Guest')
    return HttpResponse(f"Hello, {username}!")

Set a cookie in the response:

python

from django.http import HttpResponse

def set_cookie(request):
    response = HttpResponse("Cookie has been set!")
    response.set_cookie('username', 'django_user', max_age=3600)  # expires in 1 hour
    return response

Sessions

Access and modify session data:

python

def session_view(request):
    # Get visit count from session, default to 0 if not present
    visit_count = request.session.get('visit_count', 0)
    
    # Increment the count
    visit_count += 1
    
    # Save the new count back to the session
    request.session['visit_count'] = visit_count
    
    return HttpResponse(f"You've visited this page {visit_count} times")

User Authentication

Access the current user (if authenticated):

python

def profile_view(request):
    if request.user.is_authenticated:
        return HttpResponse(f"Hello, {request.user.username}!")
    else:
        return HttpResponse("Please log in to view your profile.")

Request Headers

Access HTTP headers:

python

def header_info(request):
    user_agent = request.headers.get('User-Agent', '')
    content_type = request.headers.get('Content-Type', '')
    
    return HttpResponse(
        f"Your browser: {user_agent}<br>"
        f"Content type: {content_type}"
    )

Real-World Example: Processing a Comment Form

Here's a complete example showing how to handle a comment form submission:

python

from django.shortcuts import render, redirect
from django.contrib import messages
from .models import BlogPost, Comment

def blog_post_detail(request, post_id):
    try:
        post = BlogPost.objects.get(id=post_id)
        
        if request.method == 'POST':
            # Check if user is authenticated
            if not request.user.is_authenticated:
                messages.error(request, "You must be logged in to comment.")
                return redirect('login')
            
            # Get the comment text from the form
            comment_text = request.POST.get('comment', '').strip()
            
            if not comment_text:
                messages.error(request, "Comment cannot be empty.")
            else:
                # Create a new comment
                Comment.objects.create(
                    post=post,
                    author=request.user,
                    content=comment_text
                )
                messages.success(request, "Comment added successfully!")
            
            # Redirect to the same page to prevent form resubmission
            return redirect('blog_post_detail', post_id=post_id)
        
        # For GET requests or after processing POST
        comments = Comment.objects.filter(post=post).order_by('-created_at')
        return render(request, 'blog/post_detail.html', {
            'post': post,
            'comments': comments,
        })
        
    except BlogPost.DoesNotExist:
        return render(request, '404.html', status=404)

Request Objects in Class-Based Views

Django's class-based views also work with request objects:

python

from django.views import View
from django.http import HttpResponse

class GreetingView(View):
    def get(self, request):
        # Handle GET request
        name = request.GET.get('name', 'Guest')
        return HttpResponse(f"Hello, {name}!")
        
    def post(self, request):
        # Handle POST request
        name = request.POST.get('name', 'Guest')
        return HttpResponse(f"Welcome, {name}!")

Request and Response Lifecycle

Understanding where the request object fits in Django's request/response cycle:

1. The user makes a request to a URL
2. Django's URL dispatcher matches the URL to a view
3. Django creates an HttpRequest object containing request data
4. The matched view function receives the request object
5. The view processes the request and returns an HttpResponse object
6. Django sends the response back to the user's browser

Custom Middleware and Request Objects

Middleware can process and modify request objects before they reach your views:

python

class SimpleMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        # Code to be executed for each request before the view is called
        request.custom_attribute = 'Added by middleware'
        
        response = self.get_response(request)
        
        # Code to be executed for each request/response after the view is called
        return response

After adding this middleware to your settings, you can access request.custom_attribute in your views.

Summary

Django request objects are the gateway to understanding user interactions with your web application. They provide:

• Access to user input data (GET, POST, cookies, files)
• Information about the current request (headers, method)
• User authentication details
• Session data

By effectively working with request objects, you can build dynamic, interactive web applications that respond appropriately to different types of user input.

Exercises

1. Create a view that displays all headers from the current request
2. Build a form that accepts file uploads and displays information about the uploaded file
3. Create a view that checks if a user is on a mobile device by inspecting the User-Agent header
4. Implement a simple API endpoint that accepts JSON data and returns it transformed in some way

Additional Resources

• Django Official Documentation on Request and Response objects
• Django Forms Documentation
• Django File Uploads Guide