Class-Based Views

from django.db import models


class Author(models.Model):
    name = models.CharField(max_length=200)

    def __str__(self):
        return self.name


class Book(models.Model):
    title = models.CharField(max_length=200)
    isbn = models.CharField(max_length=13, unique=True)
    author = models.ForeignKey(Author, on_delete=models.PROTECT, related_name="books")
    price = models.DecimalField(max_digits=6, decimal_places=2)
    visits = models.PositiveIntegerField(default=0)
    is_published = models.BooleanField(default=True)

    class Meta:
        ordering = ["title"]

    def __str__(self):
        return self.title

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


class GreetingView(View):
    greeting = "Good day"

    def get(self, request, *args, **kwargs):
        name = kwargs.get("name", "reader")
        return HttpResponse(f"{self.greeting}, {name}!")

    def post(self, request, *args, **kwargs):
        return HttpResponse("Message received", status=201)

from django.urls import path

from . import views_basic

urlpatterns = [
    path("greet/", views_basic.GreetingView.as_view(), name="greet"),
    path("greet/<str:name>/", views_basic.GreetingView.as_view(greeting="Welcome"), name="greet-named"),
]

$ curl -i localhost:8723/greet/Ada/
HTTP/1.1 200 OK
Content-Type: text/html; charset=utf-8
Content-Length: 13
X-View: catalog.views_basic.GreetingView

Welcome, Ada!

>>> c = Client()
>>> r = c.delete("/greet/");  r.status_code, r["Allow"]
(405, 'GET, POST, HEAD, OPTIONS')
>>> r = c.options("/greet/"); r.status_code, r["Allow"], r["Content-Length"]
(200, 'GET, POST, HEAD, OPTIONS', '0')
>>> c.head("/greet/").status_code
200

from django.views import View
from django.views.generic import RedirectView, TemplateView

from catalog.views_basic import GreetingView
from catalog.views_mixins import StaffDashboardView

for cls in (View, TemplateView, RedirectView, StaffDashboardView):
    print(cls.__name__, "->", " > ".join(c.__name__ for c in cls.__mro__))

view = GreetingView.as_view(greeting="Hi")
print(type(view).__name__, view.__name__, view.view_class.__name__, view.view_initkwargs)

for bad in ({"get": print}, {"colour": "red"}):
    try:
        GreetingView.as_view(**bad)
    except TypeError as exc:
        print("TypeError:", exc)
print(GreetingView.view_is_async)

View -> View > object
TemplateView -> TemplateView > TemplateResponseMixin > ContextMixin > View > object
RedirectView -> RedirectView > View > object
StaffDashboardView -> StaffDashboardView > AuditMixin > StaffOnlyMixin > CurrentYearMixin > TemplateView > TemplateResponseMixin > ContextMixin > View > object
function view GreetingView {'greeting': 'Hi'}
TypeError: The method name get is not accepted as a keyword argument to GreetingView().
TypeError: GreetingView() received an invalid keyword 'colour'. as_view only accepts arguments that are already attributes of the class.
False

import time

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


class ForgetfulView(View):
    def setup(self, request, *args, **kwargs):
        self.started = time.perf_counter()  # forgot super().setup(...)

    def get(self, request, *args, **kwargs):
        return HttpResponse("never reached")

>>> Client().get("/forgetful/")
AttributeError: ForgetfulView instance has no 'request' attribute. Did you override setup() and forget to call super()?

from django.views.generic import TemplateView

from .models import Book


class HomeView(TemplateView):
    template_name = "catalog/home.html"
    extra_context = {"site_name": "Bookshelf"}

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context["latest_books"] = Book.objects.filter(is_published=True).order_by("-id")[:3]
        return context

from django.views.generic import TemplateView

urlpatterns = [
    path("", views_template.HomeView.as_view(), name="home"),
    path(
        "about/",
        TemplateView.as_view(template_name="catalog/about.html", extra_context={"site_name": "Bookshelf"}),
        name="about",
    ),
]

<h1>{{ site_name }}</h1>
<ul>
{% for book in latest_books %}  <li>{{ book.title }}</li>
{% endfor %}</ul>

$ curl -s localhost:8723/
<h1>Bookshelf</h1>
<ul>
  <li>The Dispossessed</li>
  <li>Lavinia</li>
  <li>Earthsea</li>
</ul>

from django.views.generic import RedirectView

urlpatterns += [
    path("old-catalogue/", RedirectView.as_view(pattern_name="book-list", permanent=True, query_string=True)),
    path("legacy/<int:pk>/", RedirectView.as_view(url="/books/%(pk)s/", permanent=True)),
    path("docs/", RedirectView.as_view(url="https://docs.djangoproject.com/en/6.1/")),
    path("retired/", RedirectView.as_view(url=None), name="retired"),
    path(
        "old-order/",
        RedirectView.as_view(pattern_name="greet", permanent=True, preserve_request=True),
        name="old-order",
    ),
]

$ curl -si "localhost:8723/old-catalogue/?q=x" | grep -i "^HTTP\|^Location"
HTTP/1.1 301 Moved Permanently
Location: /books/?q=x
$ curl -si localhost:8723/legacy/2/ | grep -i "^HTTP\|^Location"
HTTP/1.1 301 Moved Permanently
Location: /books/2/
$ curl -si localhost:8723/retired/ | head -1
HTTP/1.1 410 Gone

>>> c.post("/old-order/").status_code     # permanent + preserve_request
308
>>> c.post("/docs/").status_code          # the default: browsers retry the POST as a GET
302

from django.contrib.auth.decorators import login_required, permission_required
from django.views.generic import TemplateView

urlpatterns = [
    path("about/", login_required(TemplateView.as_view(template_name="secret.html"))),
    path("vote/", permission_required("polls.can_vote")(VoteView.as_view())),
]

from django.contrib.auth.decorators import login_required
from django.http import HttpResponse
from django.utils.decorators import method_decorator
from django.views import View
from django.views.decorators.cache import never_cache
from django.views.generic import TemplateView


@method_decorator([never_cache, login_required], name="dispatch")
class PrivateShelfView(TemplateView):
    template_name = "catalog/pages/default.html"


class AccountView(View):
    @method_decorator(never_cache)
    def dispatch(self, *args, **kwargs):
        return super().dispatch(*args, **kwargs)

    def get(self, request, *args, **kwargs):
        return HttpResponse("account")

>>> r = c.get("/shelf/"); r.status_code, r["Location"]
(302, '/accounts/login/?next=/shelf/')
>>> c.force_login(user)
>>> r = c.get("/shelf/"); r.status_code, r["Cache-Control"]
(200, 'max-age=0, no-cache, no-store, must-revalidate, private')

import hmac
import os

from django.http import HttpResponse, HttpResponseForbidden
from django.utils.decorators import method_decorator
from django.views import View
from django.views.decorators.csrf import csrf_exempt


@method_decorator(csrf_exempt, name="dispatch")
class StockWebhookView(View):
    """Server-to-server callback: no browser, so no CSRF cookie; authenticated by a shared secret instead."""

    def post(self, request, *args, **kwargs):
        secret = os.environ.get("STOCK_WEBHOOK_SECRET", "")
        supplied = request.headers.get("X-Webhook-Secret", "")
        if not secret or not hmac.compare_digest(secret, supplied):
            return HttpResponseForbidden()
        return HttpResponse(status=204)


class FormPostView(View):
    """Same POST handler, but still protected by CsrfViewMiddleware."""

    def post(self, request, *args, **kwargs):
        return HttpResponse(status=204)

$ curl -s -o /dev/null -w "%{http_code}\n" -X POST localhost:8724/hooks/stock/
403
$ curl -s -o /dev/null -w "%{http_code}\n" -X POST -H "X-Webhook-Secret: s3cret" localhost:8724/hooks/stock/
204
$ curl -s -o /dev/null -w "%{http_code}\n" -X POST localhost:8724/form-post/
403

class ViewClassHeaderMiddleware:
    """Shows where as_view() sits in the request cycle: process_view() receives
    the function that as_view() returned and can read its view_class."""

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

    def __call__(self, request):
        response = self.get_response(request)
        label = getattr(request, "view_label", None)
        if label:
            response["X-View"] = label
        return response

    def process_view(self, request, view_func, view_args, view_kwargs):
        view_class = getattr(view_func, "view_class", None)
        if view_class is not None:
            request.view_label = f"{view_class.__module__}.{view_class.__qualname__}"
        else:
            request.view_label = f"{view_func.__module__}.{view_func.__name__}"
        return None  # None means: carry on to the view

import asyncio
import time

from asgiref.sync import sync_to_async
from django.http import JsonResponse
from django.views import View

from .models import Author, Book


class AsyncStatsView(View):
    async def get(self, request, *args, **kwargs):
        books, authors = await asyncio.gather(Book.objects.acount(), Author.objects.acount())
        return JsonResponse({"books": books, "authors": authors})


class AsyncTitlesView(View):
    async def get(self, request, *args, **kwargs):
        titles = [book.title async for book in Book.objects.order_by("title")]
        return JsonResponse({"titles": titles})

    async def post(self, request, *args, **kwargs):
        # A plain sync function (here a stand-in for a blocking library) is bridged explicitly.
        created = await sync_to_async(self._create_sync)(request.POST.get("title", "Untitled"))
        return JsonResponse({"created": created}, status=201)

    def _create_sync(self, title):
        author, _ = Author.objects.get_or_create(name="Anonymous")
        book = Book.objects.create(title=title, isbn=f"x{time.time_ns()}"[:13], author=author, price=0)
        return book.title

$ STOCK_WEBHOOK_SECRET=s3cret python -m uvicorn config.asgi:application --port 8724
$ curl -si localhost:8724/async/stats/ | grep -i "^HTTP\|^server\|^content-type"
HTTP/1.1 200 OK
server: uvicorn
Content-Type: application/json
$ curl -s localhost:8724/async/stats/
{"books": 3, "authors": 1}
$ curl -si -X OPTIONS localhost:8724/async/stats/ | grep -i "^HTTP\|^allow"
HTTP/1.1 200 OK
Allow: GET, HEAD, OPTIONS

import inspect

from django.test import AsyncClient, AsyncRequestFactory, RequestFactory, SimpleTestCase, TestCase
from django.urls import resolve

from .models import Author, Book
from .views_async import AsyncStatsView
from .views_basic import GreetingView, TimedView
from .views_template import HomeView


class UnitTests(SimpleTestCase):
    """No database, no URLconf, no middleware: call the view the way the resolver would."""

    def test_as_view_called_directly(self):
        request = RequestFactory().get("/greet/Bo/")
        response = GreetingView.as_view(greeting="Hi")(request, name="Bo")
        self.assertEqual(response.content, b"Hi, Bo!")

    def test_method_not_allowed(self):
        request = RequestFactory().delete("/greet/")
        response = GreetingView.as_view()(request)
        self.assertEqual(response.status_code, 405)
        self.assertEqual(response["Allow"], "GET, POST, HEAD, OPTIONS")

    def test_setup_without_a_request_cycle(self):
        view = TimedView()
        request = RequestFactory().get("/")
        view.setup(request, 1, key="value")
        self.assertEqual((view.request, view.args, view.kwargs), (request, (1,), {"key": "value"}))
        self.assertTrue(view.request_id)


class IntegrationTests(TestCase):
    @classmethod
    def setUpTestData(cls):
        author = Author.objects.create(name="Octavia E. Butler")
        Book.objects.create(title="Kindred", isbn="9780807083697", author=author, price="12.50")

    def test_template_response_is_lazy_until_rendered(self):
        request = RequestFactory().get("/")
        response = HomeView.as_view()(request)  # a TemplateResponse, not yet rendered
        self.assertFalse(response.is_rendered)
        self.assertEqual(response.context_data["site_name"], "Bookshelf")
        response.render()
        self.assertIn(b"Kindred", response.content)

    def test_resolver_exposes_view_class(self):
        match = resolve("/")
        self.assertIs(match.func.view_class, HomeView)
        self.assertEqual(match.func.view_initkwargs, {})

    def test_client_goes_through_middleware_and_urls(self):
        response = self.client.get("/")
        self.assertTemplateUsed(response, "catalog/home.html")
        self.assertEqual(response["X-View"], "catalog.views_template.HomeView")


class AsyncTests(TestCase):
    async def test_async_view_with_async_factory(self):
        request = AsyncRequestFactory().get("/async/stats/")
        response = await AsyncStatsView.as_view()(request)
        self.assertEqual(response.status_code, 200)

    async def test_async_client(self):
        response = await AsyncClient().get("/async/stats/")
        self.assertEqual(response.json(), {"books": 0, "authors": 0})


class AsyncMarkingTests(SimpleTestCase):
    def test_as_view_marks_async_classes(self):
        self.assertTrue(inspect.iscoroutinefunction(AsyncStatsView.as_view()))
        self.assertFalse(inspect.iscoroutinefunction(GreetingView.as_view()))

$ python manage.py test
Found 43 test(s).
Creating test database for alias 'default'...
System check identified no issues (0 silenced).
...........................................
----------------------------------------------------------------------
Ran 43 tests in 0.5s

OK

from django.urls import path
from django.views.generic import RedirectView, TemplateView

from . import (
    views_async,
    views_basic,
    views_decorated,
    views_mixins,
    views_redirect,
    views_template,
)

urlpatterns = [
    # views_basic
    path("greet/", views_basic.GreetingView.as_view(), name="greet"),
    path("greet/<str:name>/", views_basic.GreetingView.as_view(greeting="Welcome"), name="greet-named"),
    path("book-count/", views_basic.BookCountView.as_view(), name="book-count"),
    path("shared/", views_basic.SharedStateView.as_view(), name="shared"),
    path("per-request/", views_basic.PerRequestStateView.as_view(), name="per-request"),
    path("forgetful/", views_basic.ForgetfulView.as_view(), name="forgetful"),
    # views_template
    path("", views_template.HomeView.as_view(), name="home"),
    path(
        "about/",
        TemplateView.as_view(template_name="catalog/about.html", extra_context={"site_name": "Bookshelf"}),
        name="about",
    ),
    path("pages/<slug:slug>/", views_template.PageView.as_view(), name="page"),
    path("robots.txt", views_template.RobotsView.as_view(), name="robots"),
    # views_redirect
    path("books/", views_basic.BookListView.as_view(), name="book-list"),
    path("books/<int:pk>/", views_mixins.BookDetailView.as_view(), name="book-detail"),
    path("b/<str:isbn>/", views_redirect.BookShortLinkView.as_view(), name="book-short"),
    path("old-catalogue/", RedirectView.as_view(pattern_name="book-list", permanent=True, query_string=True)),
    path("legacy/<int:pk>/", RedirectView.as_view(url="/books/%(pk)s/", permanent=True)),
    path("docs/", RedirectView.as_view(url="https://docs.djangoproject.com/en/6.1/")),
    path("retired/", RedirectView.as_view(url=None), name="retired"),
    path(
        "old-order/",
        RedirectView.as_view(pattern_name="greet", permanent=True, preserve_request=True),
        name="old-order",
    ),
    path("go/", views_redirect.SectionRedirectView.as_view(), name="go"),
    # views_decorated
    path("shelf/", views_decorated.PrivateShelfView.as_view(), name="shelf"),
    path("account/", views_decorated.AccountView.as_view(), name="account"),
    path("hooks/stock/", views_decorated.StockWebhookView.as_view(), name="stock-hook"),
    path("form-post/", views_decorated.FormPostView.as_view(), name="form-post"),
    # views_mixins
    path("hours/", views_mixins.NegotiatedPageView.as_view(), name="hours"),
    path("staff/", views_mixins.StaffDashboardView.as_view(), name="staff"),
    path("broken-staff/", views_mixins.BrokenDashboardView.as_view(), name="broken-staff"),
    path("authors/<int:pk>/books/", views_mixins.AuthorBooksView.as_view(), name="author-books"),
    path("books/<int:pk>/page/", views_mixins.BookPageView.as_view(), name="book-page"),
    # views_async
    path("async/stats/", views_async.AsyncStatsView.as_view(), name="async-stats"),
    path("async/titles/", views_async.AsyncTitlesView.as_view(), name="async-titles"),
    path("async/timed/", views_async.TimedAsyncStatsView.as_view(), name="async-timed"),
    path("async/unawaited/", views_async.UnawaitedDispatchView.as_view(), name="async-unawaited"),
    path("async/sync-mixin/", views_async.SyncMixinOnAsyncView.as_view(), name="async-sync-mixin"),
    path("async/members/", views_async.MembersAsyncView.as_view(), name="async-members"),
    path("async/awaited/", views_async.AwaitedDispatchView.as_view(), name="async-awaited"),
]

$ python manage.py check
System check identified no issues (0 silenced).