Web Development with Python and Django: User Authentication, Middleware

Table of Contents

  1. Introduction
  2. Prerequisites
  3. Setup
  4. User Authentication
  5. Middleware
  6. Conclusion

Introduction

In this tutorial, we will explore user authentication and middleware in web development using Python and Django. User authentication is essential for web applications to allow users to register, log in, and protect specific features or pages. Middleware, on the other hand, is a powerful Django concept that allows the processing of requests and responses at various stages of the HTTP cycle. By the end of this tutorial, you will have a solid understanding of user authentication and how to create and use middleware in Django applications.

Prerequisites

Before starting this tutorial, it is recommended to have a basic understanding of Python programming and web development concepts. Familiarity with Django framework will also be helpful.

Setup

To follow along with this tutorial, you will need to have the following software installed:

  • Python (https://www.python.org/downloads/)
  • Django (Install using pip install django)

Create a new Django project using the following command: bash django-admin startproject myproject Navigate to your project directory: bash cd myproject Create a new Django app: bash django-admin startapp myapp Make sure to add myapp to the INSTALLED_APPS list in settings.py.

User Authentication

Creating User Registration

  1. First, let’s create a new Django view for user registration. Open views.py inside the myapp directory and import the necessary modules: 
     from django.shortcuts import render, redirect
 from django.contrib.auth.forms import UserCreationForm
 from django.contrib.auth import login
  2. Define the register view function: 
     def register(request):
     if request.method == 'POST':
         form = UserCreationForm(request.POST)
         if form.is_valid():
             user = form.save()
             login(request, user)
             return redirect('home')
     else:
         form = UserCreationForm()
     return render(request, 'register.html', {'form': form})
  3. Create a new HTML template register.html inside the templates directory: 
    	
 {% extends 'base.html' %}
	
 {% block content %}
   <h2>Register</h2>
	  
   <form method="POST">
     {% csrf_token %}
     {{ form }}
     <button type="submit">Register</button>
   </form>
 {% endblock %}
  4. Update urls.py in the project directory to include the URL pattern for the register view: 
     from django.urls import path
 from myapp.views import register
	
 urlpatterns = [
     # Other URL patterns
     path('register/', register, name='register'),
 ]
  5. Start the development server: 
     python manage.py runserver

    Now, you can access the user registration page at http://127.0.0.1:8000/register/.

Implementing Login Functionality

  1. Let’s create a login view in views.py: 
     from django.contrib.auth.forms import AuthenticationForm
	
 def login_user(request):
     if request.method == 'POST':
         form = AuthenticationForm(request, data=request.POST)
         if form.is_valid():
             user = form.get_user()
             login(request, user)
             return redirect('home')
     else:
         form = AuthenticationForm()
     return render(request, 'login.html', {'form': form})
  2. Create a new HTML template login.html inside the templates directory: 
    	
 {% extends 'base.html' %}
	
 {% block content %}
   <h2>Login</h2>
	  
   <form method="POST">
     {% csrf_token %}
     {{ form }}
     <button type="submit">Login</button>
   </form>
 {% endblock %}
  3. Update urls.py to include the URL pattern for the login_user view: 
     from django.urls import path
 from myapp.views import register, login_user
	
 urlpatterns = [
     # Other URL patterns
     path('login/', login_user, name='login'),
 ]
  4. Run the development server and access the login page at http://127.0.0.1:8000/login/.

Adding Logout Functionality

  1. Implementing logout functionality is pretty straightforward. Add the following view to views.py: 
     from django.contrib.auth import logout
	
 def logout_user(request):
     logout(request)
     return redirect('home')
  2. Update urls.py to include the URL pattern for the logout_user view: 
     from django.urls import path
 from myapp.views import register, login_user, logout_user
	
 urlpatterns = [
     # Other URL patterns
     path('logout/', logout_user, name='logout'),
 ]
  3. Run the development server and access the logout URL at http://127.0.0.1:8000/logout/.

Middleware

Understanding Middleware

Middleware in Django allows you to process requests and responses globally, providing functionality such as authentication, session management, and more. It sits between the server and the view, making it an excellent place to implement cross-cutting concerns.

Creating a Custom Middleware

  1. Let’s create a new custom middleware that will add a custom header to every response. Create a new Python file custom_middleware.py inside the myapp directory.

  2. Open custom_middleware.py and define the CustomMiddleware class: 
     class CustomMiddleware:
     def __init__(self, get_response):
         self.get_response = get_response
	
     def __call__(self, request):
         # Code to be executed before the view is called
	
         response = self.get_response(request)
	
         # Code to be executed after the view is called
         response['X-Custom-Header'] = 'Custom Value'
	
         return response

    Registering the Middleware

  3. Open settings.py inside the project directory. Locate the MIDDLEWARE setting: 
     MIDDLEWARE = [
     # Other middleware classes
	    
     # Add your middleware class here
 ]
  4. Add the path to your CustomMiddleware class in the MIDDLEWARE list: 
     MIDDLEWARE = [
     # Other middleware classes
	    
     'myapp.custom_middleware.CustomMiddleware',
 ]
  5. Save the changes and restart the development server.

Now, every response will have the custom header X-Custom-Header with the value Custom Value.

Conclusion

In this tutorial, you have learned how to implement user authentication in Django, including user registration, login, and logout functionality. Additionally, you have familiarized yourself with middleware and created a custom middleware class in Django to handle global processing of requests and responses. User authentication and middleware are crucial concepts in web development, and mastering them will greatly enhance your Django applications.

Published:

Related Articles