When to Use One-to-One Relationships

One-to-one relationships are appropriate when certain fields in a table are queried frequantly while others are accessed less often. By separating infrequently used fields into a separate table and establishing a one-to-one relationship, you can optimize database performance.

OneToOneField(to="")

Django's Built-in CSRF Protection Middleware

Django includes a middleware component specifically designed to handle CSRF protection:

django.middleware.csrf.CsrfViewMiddleware

This middleware automatically inserts a hidden input tag into rendered pages. To utilize this protection in forms, include the template tag:

{% csrf_token %}

Decorator Implementation in Django

from django.views.decorators.csrf import csrf_exempt, csrf_protect
from functools import wraps
from django.utils.decorators import method_decorator

def authentication_required(view_func):
    @wraps(view_func)
    def wrapper(request, *args, **kwargs):
        auth_status = request.session.get("authenticated")
        if auth_status == "valid":
            return view_func(request, *args, **kwargs)
        else:
            target_url = request.path_info
            return redirect(f"/auth/login/?redirect={target_url}")
    return wrapper

To disable CSRF verification for specific views:

@csrf_exempt
def login_handler(request):

Applying decorators to class-based views:

class UserProfile(views.View):
    @method_decorator(authentication_required)
    def get(self, request):
        return render(request, "app/user_profile.html")

def logout_handler(request):
    request.session.flush()
    return redirect("/auth/login/")

AJAX Request Handling

$.ajax({
    url: "/api/test/",
    method: "POST",
    dataType: "json",
    traditional: true,
    data: {"username": "john", "items": [1,2,3]},
    success: function(response) {
        if (response.success) {
            alert(response.message);
        } else {
            alert(response.error);
        }
    }
});

Middleware Architecture

Django middleware provides five core methods with specific execution patterns:

• process_request(self, request): Executes sequentially during request processing
• process_response(self, request, response): Executes in reverse order during response generation
• process_view(self, request, view_func, view_args, view_kwargs): Runs after URL routing but before view execution
• process_exception(self, request, exception): Triggers on view exceptions, executing in reverse order
• process_template_response(self, request, response): Executes before template rendering for responses with render methods

Custom Middleware Implementation

class CustomMiddleware(MiddlewareMixin):
    def process_request(self, request):
        print("Custom middleware processing request")
        print(f"Request ID: {id(request)}")

    def process_response(self, request, response):
        print("Custom middleware processing response")
        return response

    def process_view(self, request, view_func, view_args, view_kwargs):
        print("Custom middleware process_view")
        print(f"View function: {view_func}")

    def process_exception(self, request, exception):
        print(f"Exception: {exception}")
        return redirect("https://example.com")

    def process_template_response(self, request, response):
        print("Custom middleware template processing")
        return response

Dynamic Module Import with importlib

The importlib module enables dynamic module imports using string paths, commonly used for loading modules from packages:

module = importlib.import_module("package.module") 
class_name = "UserModel"