Django Views the Right Way

https://github.com/spookylukey/django-views-the-right-way
Admin
Opinionated guide to writing Django views
Tokens:36,012
Snippets:282
Trust Score:9.8
License:Unlicense
Update:1 year ago
Show doc for...
Tokens:
Raw
### Installing Python Dependencies

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/code/README.rst

This command installs all required Python packages listed in the `requirements.txt` file. It's a standard and necessary step for setting up a Python project's environment before running the application.

```Shell
pip install -r requirements.txt
```

--------------------------------

### Initializing a Basic HTML View in Django

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/source/the-pattern.rst

This snippet demonstrates the fundamental structure for creating an HTML-based view in Django using `TemplateResponse`. It takes a `request` object and an optional URL `arg`, rendering `example.html` with an empty context. This is the recommended starting point for dynamic web pages.

```python
from django.template.response import TemplateResponse

def example_view(request, arg):
    return TemplateResponse(request, 'example.html', {})
```

--------------------------------

### Running Django Development Server

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/code/README.rst

This command starts the Django development server, making the application accessible via a web browser, typically at `http://localhost:8000/`. It is essential for local development, testing, and interacting with the application.

```Shell
./manage.py runserver
```

--------------------------------

### Defining Special Offer Detail URL in Django

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/docs/_sources/delegation.rst.txt

This snippet defines a URL pattern for a special offer detail page in a Django `urls.py` file. It maps the URL `/special-offers/<slug>/` to the `special_offer_detail` view, using a slug to identify the specific offer.

```Python
# urls.py

from . import views

urlpatterns = [
    path('special-offers/<slug:slug>/', views.special_offer_detail, name='special_offer_detail'),
]
```

--------------------------------

### Implementing a Detail View with Django Class-Based View

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/docs/delegation.html

This snippet demonstrates how to create a detail view using a Django Class-Based View. It overrides `get` to fetch a `SpecialOffer` object, `get_context_data` to add the object to the template context, and `get_queryset` to define the queryset for related products. It requires a `SpecialOffer` model and a template named `shop/special_offer_detail.html`.

```Python
    template_name = "shop/special_offer_detail.html"

    def get(self, request, *args, **kwargs):
        self.object = self.get_object(queryset=SpecialOffer.objects.all())
        return super().get(request, *args, **kwargs)

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context['special_offer'] = self.object
        return context

    def get_queryset(self):
        return self.object.products.all()
```

--------------------------------

### Initial Special Offer Detail View in Django

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/docs/_sources/delegation.rst.txt

This snippet presents an initial implementation of the `special_offer_detail` view in Django. It retrieves a `SpecialOffer` object based on the provided slug and renders a template, passing the special offer and its associated products to the context. It assumes `SpecialOffer.get_products()` exists and returns a `QuerySet`.

```Python
# views.py

def special_offer_detail(request, slug):
    special_offer = get_object_or_404(SpecialOffer.objects.all(), slug=slug)
    return TemplateResponse(request, 'shop/special_offer_detail.html', {
        'special_offer': special_offer,
        'products': special_offer.get_products(),
    })
```

--------------------------------

### Handling Pagination and Template Response in Django (Python)

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/docs/_sources/delegation.rst.txt

This Python snippet demonstrates how to retrieve a page number from a Django request, use a paginator to get the corresponding page object, and then render an HTML template using `TemplateResponse`. It passes the `special_offer` and `page_obj` context variables to the template for rendering.

```Python
page_number = request.GET.get('page')
page_obj = paginator.get_page(page_number)
return TemplateResponse(request, 'shop/special_offer_detail.html', {
    'special_offer': special_offer,
    'page_obj': page_obj,
})
```

--------------------------------

### Defining Special Offer Detail URL in Django

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/source/delegation.rst

This snippet defines a URL pattern for the special offer detail page in a Django `urls.py` file. It maps the URL `/special-offers/<slug>/` to the `special_offer_detail` view, using a slug to identify the specific special offer.

```Python
# urls.py

from . import views

urlpatterns = [
    path('special-offers/<slug:slug>/', views.special_offer_detail, name='special_offer_detail'),
]
```

--------------------------------

### Implementing Combined Object Lookup and List View with Django FBVs

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/docs/_sources/delegation.rst.txt

This snippet provides an alternative implementation using Django's Function-Based Views (FBVs) for the same combined object lookup and list display scenario. It manually handles object retrieval using get_object_or_404 and pagination using Paginator, showcasing a simpler and more direct approach compared to the CBV example.

```Python
from django.core.paginator import Paginator
from django.shortcuts import get_object_or_404
from django.template.response import TemplateResponse

from shop.models import SpecialOffer


def special_offer_detail(request, slug):
    special_offer = get_object_or_404(SpecialOffer.objects.all(), slug=slug)
    paginator = Paginator(special_offer.products.all(), 2)
```

--------------------------------

### Combining SingleObjectMixin and ListView in Django CBVs

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/source/delegation.rst

This Django Class-Based View (CBV) demonstrates how to combine SingleObjectMixin and ListView to display details of a single object (SpecialOffer) alongside a paginated list of its related products. It highlights the complexity involved in wrangling multiple mixins for a seemingly straightforward task, requiring careful override of get, get_context_data, and get_queryset methods.

```Python
from django.views.generic import ListView
from django.views.generic.detail import SingleObjectMixin

from shop.models import SpecialOffer


class SpecialOfferDetail(SingleObjectMixin, ListView):
    paginate_by = 2
    template_name = "shop/special_offer_detail.html"

    def get(self, request, *args, **kwargs):
        self.object = self.get_object(queryset=SpecialOffer.objects.all())
        return super().get(request, *args, **kwargs)

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context['special_offer'] = self.object
        return context

    def get_queryset(self):
        return self.object.products.all()
```

--------------------------------

### Initial Special Offer Detail View in Django

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/source/delegation.rst

This Django Function-Based View (FBV) initially handles the display of a single special offer and its associated products. It retrieves the `SpecialOffer` object using the provided slug and renders a template with the special offer and its products.

```Python
# views.py

def special_offer_detail(request, slug):
    special_offer = get_object_or_404(SpecialOffer.objects.all(), slug=slug)
    return TemplateResponse(request, 'shop/special_offer_detail.html', {
        'special_offer': special_offer,
        'products': special_offer.get_products(),
    })
```

--------------------------------

### Displaying Searchbox with jQuery

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/docs/policies.html

This JavaScript snippet utilizes the jQuery library to make the HTML element with the ID 'searchbox' immediately visible. The `show(0)` method ensures the element is displayed without any animation, commonly used for initial UI setup or dynamic visibility changes.

```JavaScript
$('#searchbox').show(0);
```

--------------------------------

### Configuring a Django DetailView for Product Details

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/docs/_sources/detail-view.rst.txt

This snippet demonstrates a basic configuration for a Django DetailView to display product details. It sets the template name, specifies the queryset for retrieving Product objects, and defines the context variable name for the retrieved object. It highlights the minimal setup for a generic display view.

```Python
class ProductDetailView(DetailView):
    template_name = 'shop/product_detail.html'
    queryset = Product.objects.all()
    context_object_name = 'product'
```

--------------------------------

### Defining Special Offer Detail URL and View in Django

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/docs/delegation.html

This snippet defines a URL pattern in `urls.py` and a corresponding basic function-based view in `views.py` for displaying details of a `SpecialOffer` object along with its associated products. It uses `get_object_or_404` to retrieve the offer and `TemplateResponse` to render the page, illustrating a simple view structure before refactoring.

```Python
# urls.py

from . import views

urlpatterns = [
    path('special-offers/<slug:slug>/', views.special_offer_detail, name='special_offer_detail'),
]
```

```Python
# views.py

def special_offer_detail(request, slug):
    special_offer = get_object_or_404(SpecialOffer.objects.all(), slug=slug)
    return TemplateResponse(request, 'shop/special_offer_detail.html', {
        'special_offer': special_offer,
        'products': special_offer.get_products(),
    })
```

--------------------------------

### Accessing User-Specific Bookings with Custom QuerySet Methods

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/docs/thin-views.html

This example demonstrates how to use custom QuerySet methods, such as `in_basket()`, when querying user-specific data. By starting queries with the `user` object (e.g., `user.bookings`), it reinforces the habit of implementing access controls, helping to prevent insecure direct object reference (IDOR) vulnerabilities.

```Python
user = request.user
context = {
    'basket_bookings': user.bookings.in_basket()
}
# etc.
```

--------------------------------

### Implementing Custom Function-Based Redirect with URL Configuration (Python)

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/docs/redirects.html

This example demonstrates creating a custom function-based view (`do_redirect`) that mimics `RedirectView`'s configurable behavior. It accepts parameters like `pattern_name`, `permanent`, and `query_string` directly from the `urls.py` configuration, allowing for flexible redirect logic.

```Python
def do_redirect(request, *args, pattern_name=None, permanent=False, query_string=True, **kwargs):
   url = reverse(pattern_name, args=args, kwargs=kwargs)
   # More of ``RedirectView`` logic here, using ``permanent`` and
   # ``query_string`` etc.
   return HttpResponseRedirect(url)

# urls.py

 urls = [
     path('old-path/<int:pk>/', do_redirect, {
         'pattern_name': 'my_view',
         'permanent': True,
         'query_string': True,
     }),
 ]
```

--------------------------------

### Creating a Custom Redirect Function with URL Parameters (Python)

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/docs/_sources/redirects.rst.txt

This example demonstrates how to create a custom function-based view that mimics RedirectView's configurability by accepting extra keyword arguments from urls.py. The `do_redirect` function uses `reverse` to resolve the target URL based on `pattern_name` and other parameters, then returns an `HttpResponseRedirect`.

```python
def do_redirect(request, *args, pattern_name=None, permanent=False, query_string=True, **kwargs):
   url = reverse(pattern_name, args=args, kwargs=kwargs)
   # More of ``RedirectView`` logic here, using ``permanent`` and
   # ``query_string`` etc.
   return HttpResponseRedirect(url)
```

```python
# urls.py

urls = [
    path('old-path/<int:pk>/', do_redirect, {
        'pattern_name': 'my_view',
        'permanent': True,
        'query_string': True,
    }),
]
```

--------------------------------

### Accessing User Object and Initializing Context in Django

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/docs/_sources/thin-views.rst.txt

This partial snippet shows how to access the current user object from the request (`request.user`) and the beginning of a dictionary initialization for the template context. It provides context for how user-specific operations might start within a Django view.

```Python
user = request.user
context = {
```

--------------------------------

### Retrieving a Single Object with QuerySet.get (Django)

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/docs/detail-view.html

This snippet shows how to retrieve a single `Product` object from the database using its `slug` field. It directly calls the `get()` method on the `Product.objects` manager. This approach can raise a `Product.DoesNotExist` exception if no matching object is found, requiring explicit error handling.

```Python
product = Product.objects.get(slug='some-product-slug')
```

--------------------------------

### Implementing Pagination with Django Paginator

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/docs/_sources/list-view.rst.txt

This code demonstrates how to add pagination to a Django product list view using django.core.paginator.Paginator. It fetches all products, initializes the Paginator to show 5 products per page, retrieves the current page number from the request's GET parameters, and passes the resulting Page object to the template for rendering.

```python
from django.core.paginator import Paginator

def product_list(request):
    products = Product.objects.all()
    paginator = Paginator(products, 5)  # Show 5 products per page.
    page_number = request.GET.get('page')
    page_obj = paginator.get_page(page_number)
    return TemplateResponse(request, 'shop/product_list.html', {
        'page_obj': page_obj,
    })
```

--------------------------------

### Defining Example Python Decorators for Execution Flow (Python)

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/docs/_sources/preconditions.rst.txt

These Python functions define two generic decorators, `decorator_1` and `decorator_2`, which wrap a `view_func`. They include print statements to demonstrate the order of execution during decorator application, pre-processing before the view function call, and post-processing after the view function returns.

```Python
def decorator_1(view_func):
    print("In decorator_1")

    def wrapper(request, *args, **kwargs):
        print("In decorator_1 wrapper, pre-processing")
        response = view_func(request, *args, **kwargs)
        print("In decorator_1 wrapper, post-processing")
        return response

    return wrapper


def decorator_2(view_func):
    print("In decorator_2")

    def wrapper(request, *args, **kwargs):
        print("In decorator_2 wrapper, pre-processing")
        response = view_func(request, *args, **kwargs)
        print("In decorator_2 wrapper, post-processing")
        return response

    return wrapper
```

--------------------------------

### Implementing a Detail View with Pagination using Django Function-Based View

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/docs/delegation.html

This snippet shows how to implement a detail view for a `SpecialOffer` object using a Django Function-Based View, including manual pagination. It uses `get_object_or_404` to retrieve the offer, `Paginator` to paginate its products, and `TemplateResponse` to render the template with the offer and paginated page object. It depends on `django.core.paginator`, `django.shortcuts`, `django.template.response`, and `shop.models.SpecialOffer`.

```Python
from django.core.paginator import Paginator
from django.shortcuts import get_object_or_404
from django.template.response import TemplateResponse

from shop.models import SpecialOffer

def special_offer_detail(request, slug):
    special_offer = get_object_or_404(SpecialOffer.objects.all(), slug=slug)
    paginator = Paginator(special_offer.products.all(), 2)
    page_number = request.GET.get('page')
    page_obj = paginator.get_page(page_number)
    return TemplateResponse(request, 'shop/special_offer_detail.html', {
        'special_offer': special_offer,
        'page_obj': page_obj,
    })
```

--------------------------------

### Configuring Permanent Redirect with RedirectView in Django URLs (Python)

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/docs/redirects.html

This example shows how to configure a permanent redirect (HTTP 301) from an old URL pattern to a new one directly within Django's `urls.py` using `RedirectView.as_view()`. It preserves the query string and uses a named view for the target.

```Python
urls = [
    path('old-path/<int:pk>/', RedirectView.as_view(
        pattern_name='my_view',
        permanent=True,
        query_string=True,
    ),
    path('new-path/<int:pk>/', views.my_view, name='my_view'),
]
```

--------------------------------

### Configuring Permanent Redirect with RedirectView in urls.py (Python)

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/source/redirects.rst

This example shows how to configure a permanent redirect (HTTP 301) for an old URL pattern to a new named view using Django's `RedirectView` directly within `urls.py`. It preserves query string parameters and uses `pattern_name` for target lookup.

```python
urls = [
    path('old-path/<int:pk>/', RedirectView.as_view(
        pattern_name='my_view',
        permanent=True,
        query_string=True,
    ),
    path('new-path/<int:pk>/', views.my_view, name='my_view'),
]
```

--------------------------------

### Defining Sample Python Decorators for Execution Flow Demonstration

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/source/preconditions.rst

This code defines two simple Python decorators, `decorator_1` and `decorator_2`, designed to illustrate the order of execution when multiple decorators are applied. Each decorator prints messages during its initial application, pre-processing phase (before the wrapped function runs), and post-processing phase (after the wrapped function completes). These decorators serve as a practical example for understanding the 'onion metaphor' of decorator execution.

```python
def decorator_1(view_func):
    print("In decorator_1")

    def wrapper(request, *args, **kwargs):
        print("In decorator_1 wrapper, pre-processing")
        response = view_func(request, *args, **kwargs)
        print("In decorator_1 wrapper, post-processing")
        return response

    return wrapper


def decorator_2(view_func):
    print("In decorator_2")

    def wrapper(request, *args, **kwargs):
        print("In decorator_2 wrapper, pre-processing")
        response = view_func(request, *args, **kwargs)
        print("In decorator_2 wrapper, post-processing")
        return response

    return wrapper
```

--------------------------------

### Delegating Product List Display in Django Views

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/source/delegation.rst

This set of Python functions demonstrates the delegation pattern for re-using product list display logic. The `product_list` and `special_offer_detail` views both delegate the actual product rendering to a shared `display_product_list` function, which handles filtering, pagination, and template rendering based on provided queryset, template name, and context. It uses keyword-only arguments and handles mutable default arguments for `context`.

```Python
def product_list(request):
    return display_product_list(
        request,
        queryset=Product.objects.all(),
        template_name='shop/product_list.html',
    )


def special_offer_detail(request, slug):
    special_offer = get_object_or_404(SpecialOffer.objects.all(), slug=slug)
    return display_product_list(
        request,
        context={
            'special_offer': special_offer,
        },
        queryset=special_offer.get_products(),
        template_name='shop/special_offer_detail.html',
    )


def display_product_list(request, *, context=None, queryset, template_name):
    if context is None:
        context = {}
    queryset = apply_product_filtering(request, queryset)
    context |= paged_object_list_context(request, queryset, paginate_by=5)
    return TemplateResponse(request, template_name, context)
```

--------------------------------

### Implementing Combined Object Lookup and List View with Django CBVs

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/docs/_sources/delegation.rst.txt

This snippet demonstrates how to implement a view that combines SingleObjectMixin and ListView in Django's Class-Based Views (CBVs). It fetches a single SpecialOffer object and then paginates its related products. This approach, while functional, is presented as complex and difficult to debug due to the intricate interaction of mixins.

```Python
from django.views.generic import ListView
from django.views.generic.detail import SingleObjectMixin

from shop.models import SpecialOffer


class SpecialOfferDetail(SingleObjectMixin, ListView):
    paginate_by = 2
    template_name = "shop/special_offer_detail.html"

    def get(self, request, *args, **kwargs):
        self.object = self.get_object(queryset=SpecialOffer.objects.all())
        return super().get(request, *args, **kwargs)

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context['special_offer'] = self.object
        return context

    def get_queryset(self):
        return self.object.products.all()
```

--------------------------------

### Implementing Pagination for Product List - Django Python

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/source/list-view.rst

This snippet enhances the product list view by adding pagination using Django's 'Paginator' class. It fetches all products, creates a paginator to show 5 products per page, retrieves the requested page number from GET parameters, and passes a 'Page' object to the template for rendering. This allows for efficient display of large datasets.

```python
from django.core.paginator import Paginator

def product_list(request):
    products = Product.objects.all()
    paginator = Paginator(products, 5)  # Show 5 products per page.
    page_number = request.GET.get('page')
    page_obj = paginator.get_page(page_number)
    return TemplateResponse(request, 'shop/product_list.html', {
        'page_obj': page_obj,
    })
```

--------------------------------

### Example Django Class-Based TemplateView

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/docs/the-pattern.html

This code demonstrates how a simple view might be implemented using Django's Class-Based Views (CBVs), specifically `TemplateView`. It shows that essential view elements like the function, request, and response are implicitly handled by the base class, which can obscure the fundamental nature of a view compared to functional approaches.

```Python
from django.views.generic import TemplateView

class ExampleView(TemplateView):
    template_name = "example.html"
```

--------------------------------

### Refactoring Django Views with Delegation for Product Lists

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/docs/_sources/delegation.rst.txt

This snippet demonstrates the delegation pattern for reusing product list logic across different Django views. It introduces `display_product_list` as a reusable function that handles common filtering, pagination, and template rendering. Both `product_list` and `special_offer_detail` views now delegate the product display logic to this function, passing specific querysets, templates, and context data.

```Python
def product_list(request):
    return display_product_list(
        request,
        queryset=Product.objects.all(),
        template_name='shop/product_list.html',
    )


def special_offer_detail(request, slug):
    special_offer = get_object_or_404(SpecialOffer.objects.all(), slug=slug)
    return display_product_list(
        request,
        context={
            'special_offer': special_offer,
        },
        queryset=special_offer.get_products(),
        template_name='shop/special_offer_detail.html',
    )


def display_product_list(request, *, context=None, queryset, template_name):
    if context is None:
        context = {}
    queryset = apply_product_filtering(request, queryset)
    context |= paged_object_list_context(request, queryset, paginate_by=5)
    return TemplateResponse(request, template_name, context)
```

--------------------------------

### Configuring Permanent Redirect with RedirectView in Django URLs (Python)

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/docs/_sources/redirects.rst.txt

This example illustrates how to configure a permanent redirect directly within Django's urls.py using RedirectView.as_view(). It maps an old URL pattern to a named view, ensuring a permanent redirect (301 status) and preserving any query string parameters from the original request.

```python
urls = [
    path('old-path/<int:pk>/', RedirectView.as_view(
        pattern_name='my_view',
        permanent=True,
        query_string=True,
    ),
    path('new-path/<int:pk>/', views.my_view, name='my_view'),
]
```

--------------------------------

### Implementing Special Offer Product Search View in Django

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/docs/dependency-injection.html

This subclass of `ProductSearchBase` implements the `product_search` method for special offers. It overrides the `get` method to fetch a `SpecialOffer` object and stores it on `self.special_offer`, allowing `product_search` and `get_context_data` to access it. This demonstrates a pattern of inter-method communication via instance variables, which is highlighted as problematic due to hidden dependencies.

```Python
class SpecialOfferDetail(ProductSearchBase):
    template_name = 'shop/special_offer_detail.html'

    def get(self, request, *args, **kwargs):
        special_offer = get_object_or_404(SpecialOffer.objects.all(), slug=kwargs['slug'])
        self.special_offer = special_offer
        return super().get(request, **kwargs)

    def product_search(self, filters, page=1):
        products = special_product_search(filters, self.special_offer, page=page)
        log_special_offer_product_view(self.request.user, self.special_offer, products)
        return products

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context['special_offer'] = self.special_offer
        return context
```

--------------------------------

### Basic Django Class-Based TemplateView Definition

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/source/context-data.rst

This Python snippet defines a basic Django Class-Based View (CBV) using `TemplateView`. It sets the `template_name` attribute to 'home.html', indicating which template this view will render. This example shows the minimal setup for a CBV without custom context handling.

```Python
class HomeView(TemplateView):
    template_name = "home.html"
```

--------------------------------

### Creating a Basic Django View with Manual Template Loading (Python)

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/docs/_sources/the-pattern.rst.txt

This snippet demonstrates a fundamental Django function-based view. It manually loads the 'hello_world.html' template using `loader.get_template()`, renders it with an empty context, and returns the result wrapped in an `HttpResponse`. This illustrates the explicit steps involved in serving an HTML page, requiring `HttpResponse` and `loader` from Django's HTTP and template modules.

```python
from django.http import HttpResponse
from django.template import loader


def hello_world(request, my_arg):
    template = loader.get_template('hello_world.html')
    context = {}
    return HttpResponse(template.render(context, request))
```

--------------------------------

### Mapping URL for Basic 'Hello World' Django View

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/docs/_sources/the-pattern.rst.txt

This `urls.py` snippet configures a URL pattern for the `hello_world` view. It maps the static URL `/hello/` to the `views.hello_world` function and assigns it the name `hello_world` for easy referencing within the Django project.

```Python
from django.urls import path

from . import views

urlpatterns = [
    path('hello/', views.hello_world, name='hello_world'),
]
```

--------------------------------

### Implementing Combined Object and List View with Django FBV

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/source/delegation.rst

This Django Function-Based View (FBV) provides a simpler, more direct approach to displaying details of a single SpecialOffer and its related products. It manually handles object retrieval using get_object_or_404 and pagination using Paginator, contrasting with the complexity of combining mixins in Class-Based Views for the same functionality.

```Python
from django.core.paginator import Paginator
from django.shortcuts import get_object_or_404
from django.template.response import TemplateResponse

from shop.models import SpecialOffer


def special_offer_detail(request, slug):
    special_offer = get_object_or_404(SpecialOffer.objects.all(), slug=slug)
    paginator = Paginator(special_offer.products.all(), 2)
```

--------------------------------

### Implementing a Basic 'Hello World' Django View

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/docs/_sources/the-pattern.rst.txt

This snippet illustrates the simplest form of a Django view function. It imports `HttpResponse` and defines `hello_world` which takes an `HttpRequest` object and returns an `HttpResponse` containing the text 'Hello world!'. This demonstrates the core request-response cycle.

```Python
from django.http import HttpResponse

def hello_world(request):
    return HttpResponse('Hello world!')
```

--------------------------------

### Rendering HTML with Django's render() Shortcut

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/docs/the-pattern.html

This code illustrates the use of Django's `render()` shortcut, which condenses the process of loading a template, rendering it, and returning an `HttpResponse`. It's a common and concise way to serve HTML pages, taking the request, template name, and an optional context dictionary as parameters.

```Python
from django.shortcuts import render

def hello_world(request, my_arg):
    return render(request, 'hello_world.html', {})
```

--------------------------------

### Using Django Render Shortcut for Template Rendering in Python

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/source/the-pattern.rst

This code snippet shows a more concise way to render a Django template using the django.shortcuts.render function. It simplifies the process of loading, rendering, and returning an HttpResponse by combining these steps into a single function call. The request object, template name ('hello_world.html'), and an empty context dictionary are passed as parameters, resulting in an HttpResponse with the rendered template.

```python
from django.shortcuts import render


def hello_world(request, my_arg):
    return render(request, 'hello_world.html', {})
```

--------------------------------

### Delegating Product List Display in Django Views

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/docs/delegation.html

This snippet demonstrates the delegation pattern by refactoring common product list display logic into a reusable `display_product_list` function. Both the general `product_list` view and the `special_offer_detail` view now call this function, passing specific querysets, templates, and context data, enabling consistent features like filtering, sorting, and pagination. The `display_product_list` function handles the common logic, including applying filters and pagination.

```Python
def product_list(request):
    return display_product_list(
        request,
        queryset=Product.objects.all(),
        template_name='shop/product_list.html',
    )

def special_offer_detail(request, slug):
    special_offer = get_object_or_404(SpecialOffer.objects.all(), slug=slug)
    return display_product_list(
        request,
        context={
            'special_offer': special_offer,
        },
        queryset=special_offer.get_products(),
        template_name='shop/special_offer_detail.html',
    )

def display_product_list(request, *, context=None, queryset, template_name):
    if context is None:
        context = {}
    queryset = apply_product_filtering(request, queryset)
    context |= paged_object_list_context(request, queryset, paginate_by=5)
    return TemplateResponse(request, template_name, context)
```

--------------------------------

### Handling Pagination and Rendering Template in Django FBV

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/source/delegation.rst

This Python snippet demonstrates a common pattern in Django Function-Based Views (FBVs) for handling pagination. It retrieves the current page number from the request's GET parameters, uses a `paginator` object to fetch the corresponding `page_obj`, and then renders a `TemplateResponse` with the `special_offer` and `page_obj` context. This approach is presented as a clear and concise way to manage view logic.

```Python
page_number = request.GET.get('page')
page_obj = paginator.get_page(page_number)
return TemplateResponse(request, 'shop/special_offer_detail.html', {
    'special_offer': special_offer,
    'page_obj': page_obj,
})
```

--------------------------------

### Condensing Django Views with `render()` Shortcut (Python)

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/docs/_sources/the-pattern.rst.txt

This snippet shows a more concise way to write a Django view using the `render()` shortcut. It combines template loading, rendering, and `HttpResponse` creation into a single function call, making the view more readable and efficient. The function takes the `request` object, the template name ('hello_world.html'), and an empty dictionary for context data as parameters, returning an `HttpResponse`.

```python
from django.shortcuts import render


def hello_world(request, my_arg):
    return render(request, 'hello_world.html', {})
```

--------------------------------

### Implementing SpecialOfferDetail with Instance Variable Communication in Django Python

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/source/dependency-injection.rst

This Django Class-Based View (CBV) subclass, `SpecialOfferDetail`, demonstrates a pattern where the `special_offer` object, fetched in `get`, is stored on `self` to be accessible by `product_search` and `get_context_data`. This approach couples methods through shared instance state, making the flow less explicit and harder to reason about. It requires `SpecialOffer` and related search/logging functions to be defined.

```Python
class SpecialOfferDetail(ProductSearchBase):
    template_name = 'shop/special_offer_detail.html'

    def get(self, request, *args, **kwargs):
        special_offer = get_object_or_404(SpecialOffer.objects.all(), slug=kwargs['slug'])
        self.special_offer = special_offer
        return super().get(request, **kwargs)

    def product_search(self, filters, page=1):
        products = special_product_search(filters, self.special_offer, page=page)
        log_special_offer_product_view(self.request.user, self.special_offer, products)
        return products

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context['special_offer'] = self.special_offer
        return context
```

--------------------------------

### Basic Django HTML View and URL Pattern

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/docs/the-pattern.html

This snippet illustrates the foundational pattern for creating an HTML-based view in Django using TemplateResponse and its corresponding URL configuration. The example_view renders example.html with context, while the urls.py maps a URL with a string parameter (<str:arg>) to this view, enabling dynamic content.

```Python
from django.template.response import TemplateResponse

def example_view(request, arg):
    return TemplateResponse(request, 'example.html', {})
```

```Python
from django.urls import path

from . import views

urlpatterns = [
    path('example/<str:arg>/', views.example_view, name='example_name'),
]
```

--------------------------------

### Configuring URL Route for 'Hello World' View

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/source/the-pattern.rst

This `urls.py` configuration maps the `/hello/` URL path to the `hello_world` view function. It uses `django.urls.path` to establish the routing, providing a unique name `hello_world` for reverse URL resolution. This makes the 'Hello world!' view accessible via the specified URL.

```python
from django.urls import path

from . import views

urlpatterns = [
    path('hello/', views.hello_world, name='hello_world'),
]
```

--------------------------------

### Creating a Basic 'Hello World' View in Django

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/source/the-pattern.rst

This snippet illustrates the simplest possible Django view function. It imports `HttpResponse` and defines `hello_world` which accepts an `HttpRequest` object and returns an `HttpResponse` containing the text 'Hello world!'. This demonstrates the core request-response cycle.

```python
from django.http import HttpResponse

def hello_world(request):
    return HttpResponse('Hello world!')
```

--------------------------------

### Displaying Searchbox with jQuery

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/docs/delegation.html

This small JavaScript snippet uses jQuery to immediately display an HTML element with the ID 'searchbox'. It's typically used to make an element visible on page load or after some condition is met. It requires the jQuery library to be loaded.

```JavaScript
$('#searchbox').show(0);
```

--------------------------------

### Configuring URL Route for Django HTML View

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/source/the-pattern.rst

This `urls.py` snippet defines a URL pattern for the `example_view`. It uses `django.urls.path` to map the URL `/example/<str:arg>/` to the `example_view` function, allowing for a string parameter `arg` to be captured from the URL. A unique name `example_name` is provided for URL reversing.

```python
from django.urls import path

from . import views

urlpatterns = [
    path('example/<str:arg>/', views.example_view, name='example_name'),
]
```

--------------------------------

### Configuring URL Pattern for Django HTML View

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/docs/_sources/the-pattern.rst.txt

This `urls.py` snippet defines a URL pattern for the `example_view`. It uses `path` to map the URL `/example/<str:arg>/` to the `example_view` function, allowing for a string parameter `arg` to be captured from the URL and passed to the view. A unique name `example_name` is provided for URL reversing.

```Python
from django.urls import path

from . import views

urlpatterns = [
    path('example/<str:arg>/', views.example_view, name='example_name'),
]
```

--------------------------------

### Creating a Basic HTML View in Django

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/docs/_sources/the-pattern.rst.txt

This snippet demonstrates the fundamental structure for an HTML-based view in Django. It uses `TemplateResponse` to render an HTML template (`example.html`) and pass context data. The view function `example_view` takes a `request` object and a URL parameter `arg`.

```Python
from django.template.response import TemplateResponse

def example_view(request, arg):
    return TemplateResponse(request, 'example.html', {})
```

--------------------------------

### Handling Booking Shelving in Django View

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/docs/thin-views.html

This snippet shows an initial implementation of a Django view that directly handles a 'shelve' action for a booking. It modifies the 'shelved' attribute of a booking object and saves it, along with adding a user message. This approach is presented as an example of logic that should be moved out of the view.

```Python
def view_booking(request, pk):
    booking = request.user.bookings.get(id=pk)

    if request.method == 'POST':
        if 'shelve' in request.POST:  # pressed the 'Put on shelf' button
            booking.shelved = True
            booking.save()
            messages.info(request, 'Booking moved to shelf')

   # the rest...
```

--------------------------------

### Displaying Basic Product List - Django Python

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/source/list-view.rst

This snippet demonstrates a basic Django view function to display a list of all products. It retrieves all 'Product' objects from the database and renders them using 'TemplateResponse' with the 'shop/product_list.html' template. It serves as the initial implementation for a product listing page.

```python
def product_list(request):
    return TemplateResponse(request, 'shop/product_list.html', {
        'products': Product.objects.all(),
    })
```

--------------------------------

### Basic Django Class-Based TemplateView Definition

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/docs/_sources/context-data.rst.txt

This snippet defines a fundamental Django Class-Based View (CBV) by inheriting from `TemplateView`. It specifies the `template_name` as 'home.html', indicating the template to be rendered. This example highlights the initial simplicity of a CBV definition, where the context handling mechanism is not immediately apparent.

```python
class HomeView(TemplateView):
    template_name = "home.html"
```

--------------------------------

### Handling Product.DoesNotExist Exception with Http404 in Django

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/source/detail-view.rst

This snippet shows how to robustly retrieve a single `Product` object by catching the `Product.DoesNotExist` exception. If the object is not found, it raises Django's `Http404` exception, which automatically renders a 404 Not Found page to the user, preventing application crashes.

```python
try:
    product = Product.objects.get(slug=slug)
except Product.DoesNotExist:
    raise Http404("Product not found.")
```

--------------------------------

### Rendering Template with Loader in Django Python

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/source/the-pattern.rst

This snippet demonstrates a basic Django view that loads an HTML template using django.template.loader, renders it with an empty context, and returns the result as an HttpResponse. It illustrates the fundamental steps of serving dynamic content by explicitly loading and rendering a template. The request object and my_arg are input parameters, and an HttpResponse containing the rendered template is the output.

```python
from django.http import HttpResponse
from django.template import loader


def hello_world(request, my_arg):
    template = loader.get_template('hello_world.html')
    context = {}
    return HttpResponse(template.render(context, request))
```

--------------------------------

### Combining QuerySets with OR Operator in Django

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/source/thin-views.rst

This example illustrates how to combine two Django QuerySets using the bitwise OR operator (`|`). It creates a new QuerySet, `on_shelf_or_in_basket`, which will efficiently retrieve bookings that are either in the basket or on the shelf with a single database query upon evaluation. This demonstrates the power and efficiency of QuerySet operations.

```Python
on_shelf_or_in_basket = Booking.objects.in_basket() | Booking.objects.on_shelf()
```

--------------------------------

### URL Configuration for Basic Django View

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/docs/the-pattern.html

This snippet shows how to integrate the hello_world view into Django's URL routing system. It uses django.urls.path to map the static URL /hello/ to the views.hello_world function, providing a named route for easy URL reversal.

```Python
from django.urls import path

from . import views

urlpatterns = [
    path('hello/', views.hello_world, name='hello_world'),
]
```

--------------------------------

### Concise Django View for Product Detail Page using get_object_or_404

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/source/detail-view.rst

This snippet presents a complete, concise Django view function (`product_detail`) for displaying a single product. It utilizes `get_object_or_404()` to fetch the `Product` object based on the URL `slug` and then renders it using `TemplateResponse` with the `shop/product_detail.html` template. This view automatically handles cases where the product is not found by raising a 404.

```python
def product_detail(request, slug):
    return TemplateResponse(request, 'shop/product_detail.html', {
        'product': get_object_or_404(Product.objects.all(), slug=slug),
    })
```

--------------------------------

### Applying Multiple Decorators (login_required, premium_required) (Python)

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/docs/preconditions.html

This example demonstrates how to apply multiple decorators to a Django view, specifically `login_required` and the custom `premium_required`. The `login_required` decorator is applied first (outermost) to ensure the user is authenticated before the `premium_required` decorator checks for premium status, preventing errors with `AnonymousUser`.

```Python
from django.contrib.auth.decorators import login_required

@login_required
@premium_required
def my_premium_page(request):
    return TemplateResponse(request, 'premium_page.html', {})
```

--------------------------------

### Defining a Basic Product Search Function (Python)

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/docs/_sources/dependency-injection.rst.txt

This function simulates an external API for searching products. It accepts a dictionary of `filters` and an optional `page` number, returning a list of products. It serves as a dependency for the `display_product_list` function, demonstrating how to integrate non-QuerySet based data sources.

```python
def product_search(filters, page=1):
    ...
    return product_list
```

--------------------------------

### Handling ObjectDoesNotExist Exception with Http404 (Django)

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/docs/detail-view.html

This code demonstrates how to gracefully handle the `Product.DoesNotExist` exception that can occur when using `QuerySet.get()`. It wraps the database query in a `try-except` block, catching the specific exception and raising Django's `Http404` exception to display a 'Not Found' page to the user instead of crashing.

```Python
try:
    product = Product.objects.get(slug=slug)
except Product.DoesNotExist:
    raise Http404("Product not found.")
```

--------------------------------

### Basic Django HTTP Response View

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/docs/the-pattern.html

This snippet demonstrates the simplest Django view, which directly returns an HttpResponse object. The hello_world function takes an HttpRequest and sends a plain text 'Hello world!' back to the client, illustrating the core request-response mechanism.

```Python
from django.http import HttpResponse

def hello_world(request):
    return HttpResponse('Hello world!')
```

--------------------------------

### Handling Object Not Found with Http404 (Python)

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/docs/_sources/detail-view.rst.txt

This code snippet shows how to gracefully handle the `Product.DoesNotExist` exception that can occur when using `QuerySet.get()`. It wraps the retrieval in a `try-except` block, raising Django's `Http404` exception to display a "Page Not Found" error to the user instead of crashing.

```python
try:
    product = Product.objects.get(slug=slug)
except Product.DoesNotExist:
    raise Http404("Product not found.")
```

--------------------------------

### Configuring Product Detail URL in Django (urls.py)

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/source/url-parameters.rst

This snippet defines a URL pattern in Django's `urls.py` to capture a product slug. It maps the URL `/products/<slug>/` to the `product_detail` view function, using a `slug` path converter to extract a URL-friendly string and naming the URL pattern `product_detail` for easy referencing.

```Python
# urls.py

from django.urls import path

from . import views

urlpatterns = [
    path('products/<slug:slug>/', views.product_detail, name='product_detail'),
]
```

--------------------------------

### Conditionally Adding Data to Django Template Context (FBV)

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/docs/context-data.html

This example expands on passing data by first assigning context data to a variable, allowing for conditional additions. It checks if the current day is Monday and adds a 'special_message' to the context if true. This pattern is useful when context data depends on specific conditions.

```Python
def home(request):
    today = date.today()
    context = {
        'today': today,
    }
    if today.weekday() == 0:
        context['special_message'] = 'Happy Monday!'
    return TemplateResponse(request, "home.html", context)
```

--------------------------------

### Adding Today's Date to Django Template Context (FBV)

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/source/context-data.rst

This Python snippet demonstrates how to add the current date to a Django template's context within a function-based view (FBV). It uses `datetime.date.today()` to get the date and passes it as a dictionary entry with the key 'today' to `TemplateResponse`, making it available in 'home.html'.

```Python
from datetime import date

def home(request):
    return TemplateResponse(request, "home.html", {
        'today': date.today(),   # This is the line you add
    })
```

--------------------------------

### Retrieving Object or Raising 404 with Django's get_object_or_404

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/source/detail-view.rst

This snippet demonstrates the use of Django's `get_object_or_404()` shortcut function. It simplifies the common pattern of retrieving an object or raising an `Http404` exception if the object does not exist, reducing boilerplate code. It requires importing `get_object_or_404` from `django.shortcuts`.

```python
# imports
from django.shortcuts import get_object_or_404

# in the view somewhere
product = get_object_or_404(Product.objects.all(), slug=slug)
```

--------------------------------

### Rendering HTML with Django Templates (Verbose)

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/docs/the-pattern.html

This snippet demonstrates the explicit, multi-step process of rendering an HTML template in a Django view. It manually loads the template using `loader.get_template`, renders it with an empty context and the request, and then wraps the result in an `HttpResponse` object. This method provides full control but is more verbose than shortcuts.

```Python
from django.http import HttpResponse
from django.template import loader

def hello_world(request, my_arg):
    template = loader.get_template('hello_world.html')
    context = {}
    return HttpResponse(template.render(context, request))
```

--------------------------------

### Defining a Django DetailView for Product Details

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/source/detail-view.rst

This snippet defines a `ProductDetailView` using Django's generic `DetailView` class. It configures the template to render (`shop/product_detail.html`), specifies the queryset to retrieve `Product` objects, and sets the context variable name for the retrieved object to 'product'. This view is designed to display details of a single product based on a slug or primary key from the URL.

```Python
class ProductDetailView(DetailView):
    template_name = 'shop/product_detail.html'
    queryset = Product.objects.all()
    context_object_name = 'product'
```

--------------------------------

### Direct Booking Filtering in Django View

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/docs/thin-views.html

This snippet illustrates various ways to filter `Booking` objects directly within a Django view using `Booking.objects.filter()`. It shows examples for 'in the basket', 'on the shelf', and 'confirmed for this year' bookings, demonstrating how embedding specific filtering conditions in the view can lead to duplication and reduced readability.

```Python
# In the basket
Booking.objects.filter(shelved=False, confirmed=False)

# On the shelf
Booking.objects.filter(shelved=True, confirmed=False)

# Confirmed for this year
Booking.objects.filter(confirmed=True, start_date__year=date.today().year)
```

--------------------------------

### Direct Query Filtering in Django View (Problematic)

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/docs/_sources/thin-views.rst.txt

This snippet illustrates how filtering of `Booking` objects might be done directly within a Django view using explicit `filter()` calls. It shows examples for different booking states, which the author argues is an anti-pattern due to logic duplication and tight coupling with the database schema.

```Python
# In the basket
Booking.objects.filter(shelved=False, confirmed=False)

# On the shelf
Booking.objects.filter(shelved=True, confirmed=False)

# Confirmed for this year
Booking.objects.filter(confirmed=True, start_date__year=date.today().year)
```

--------------------------------

### Implementing Product Detail View with Django DetailView

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/docs/detail-view.html

This snippet demonstrates how to implement a product detail view using Django's generic `DetailView`. It configures the template name, specifies the queryset for retrieving product objects, and sets the context variable name for the product instance. This approach promotes cleaner separation of concerns compared to overly complex custom views.

```Python
class ProductDetailView(DetailView):
    template_name = 'shop/product_detail.html'
    queryset = Product.objects.all()
    context_object_name = 'product'
```

--------------------------------

### Direct Model Attribute Modification in Django View

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/docs/thin-views.html

This snippet highlights the specific lines of code within a Django view where a booking object's 'shelved' attribute is directly set to True and then saved. This is identified as an example of business logic that tightly couples the view to the model's internal schema, which should ideally be encapsulated within the model itself.

```Python
booking.shelved = True
booking.save()
```

--------------------------------

### Configuring Django URLs for Product Detail View (Python)

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/docs/_sources/url-parameters.rst.txt

This snippet defines a URL pattern in Django's `urls.py` to capture a `slug` parameter for product detail pages. It maps the URL `/products/<slug>/` to the `product_detail` view function, using the `slug` path converter to automatically handle URL-friendly strings.

```python
# urls.py

from django.urls import path

from . import views

urlpatterns = [
    path('products/<slug:slug>/', views.product_detail, name='product_detail'),
]
```

--------------------------------

### Using get_object_or_404 Shortcut (Django)

Source: https://github.com/spookylukey/django-views-the-right-way/blob/master/docs/detail-view.html

This snippet illustrates the use of Django's `get_object_or_404` shortcut function, which combines the logic of retrieving an object and raising an `Http404` exception if it doesn't exist. It requires importing `get_object_or_404` from `django.shortcuts`. The function takes a `QuerySet` (or model manager) and lookup parameters, returning the object or raising `Http404`.

```Python
# imports
from django.shortcuts import get_object_or_404

# in the view somewhere
product = get_object_or_404(Product.objects.all(), slug=slug)
```
Tokens:
Raw