django-cbv-patterns

name	django-cbv-patterns
user-invocable	false
description	Use when Django Class-Based Views for building modular, reusable views. Use when creating CRUD operations and complex view logic.
allowed-tools	["Bash","Read"]

Django Class-Based Views

Master Django Class-Based Views for building modular, reusable view logic with proper separation of concerns.

Generic Views

Use Django's built-in generic views for common patterns.

from django.views.generic import ListView, DetailView, CreateView, UpdateView, DeleteView
from django.urls import reverse_lazy

class PostListView(ListView):
    model = Post
    template_name = 'posts/list.html'
    context_object_name = 'posts'
    paginate_by = 10
    ordering = ['-created_at']

    def get_queryset(self):
        queryset = super().get_queryset()
        # Only show published posts
        return queryset.filter(published=True).select_related('author')

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context['total_posts'] = self.get_queryset().count()
        return context

class PostDetailView(DetailView):
    model = Post
    template_name = 'posts/detail.html'
    context_object_name = 'post'

    def get_queryset(self):
        return super().get_queryset().select_related('author').prefetch_related('comments')

class PostCreateView(CreateView):
    model = Post
    fields = ['title', 'content', 'published']
    template_name = 'posts/create.html'
    success_url = reverse_lazy('post-list')

    def form_valid(self, form):
        form.instance.author = self.request.user
        return super().form_valid(form)

class PostUpdateView(UpdateView):
    model = Post
    fields = ['title', 'content', 'published']
    template_name = 'posts/update.html'

    def get_success_url(self):
        return reverse_lazy('post-detail', kwargs={'pk': self.object.pk})

class PostDeleteView(DeleteView):
    model = Post
    template_name = 'posts/confirm_delete.html'
    success_url = reverse_lazy('post-list')

Built-in Mixins

Leverage Django's built-in mixins for common functionality.

from django.contrib.auth.mixins import LoginRequiredMixin, UserPassesTestMixin, PermissionRequiredMixin
from django.views.generic import CreateView, UpdateView

class PostCreateView(LoginRequiredMixin, CreateView):
    model = Post
    fields = ['title', 'content']
    login_url = '/login/'
    redirect_field_name = 'next'

class PostUpdateView(LoginRequiredMixin, UserPassesTestMixin, UpdateView):
    model = Post
    fields = ['title', 'content']

    def test_func(self):
        post = self.get_object()
        return self.request.user == post.author

    def handle_no_permission(self):
        # Custom handling when test fails
        messages.error(self.request, 'You can only edit your own posts')
        return redirect('post-list')

class AdminPostListView(PermissionRequiredMixin, ListView):
    model = Post
    permission_required = 'posts.view_post'
    raise_exception = True  # Return 403 instead of redirect

Custom Mixins

Create reusable mixins for common patterns.

from django.views.generic import View
from django.shortcuts import redirect
from django.contrib import messages

class AuthorRequiredMixin:
    """Ensure the current user is the object's author."""

    def dispatch(self, request, *args, **kwargs):
        obj = self.get_object()
        if obj.author != request.user:
            messages.error(request, 'You do not have permission')
            return redirect('post-list')
        return super().dispatch(request, *args, **kwargs)

class FormMessageMixin:
    """Add success messages to form views."""
    success_message = ''

    def form_valid(self, form):
        response = super().form_valid(form)
        if self.success_message:
            messages.success(self.request, self.success_message)
        return response

class AjaxableResponseMixin:
    """Handle AJAX requests differently."""

    def form_valid(self, form):
        if self.request.is_ajax():
            data = {
                'pk': form.instance.pk,
                'success': True
            }
             JsonResponse(data)
         ().form_valid(form)

     ():
         .request.is_ajax():
             JsonResponse(form.errors, status=)
         ().form_invalid(form)


 (LoginRequiredMixin, AuthorRequiredMixin, FormMessageMixin, UpdateView):
    model = Post
    fields = [, ]
    success_message = 

Method Resolution Order (MRO)

Understand how Django resolves methods in CBVs.

# MRO matters! Order from left to right
class PostUpdateView(
    LoginRequiredMixin,      # Check login first
    AuthorRequiredMixin,     # Then check authorship
    FormMessageMixin,        # Add messages
    UpdateView               # Base view last
):
    model = Post
    fields = ['title', 'content']

# View the MRO
print(PostUpdateView.__mro__)

# Bad example - wrong order
class BadPostUpdateView(
    UpdateView,              # Base view first - wrong!
    LoginRequiredMixin,
    AuthorRequiredMixin
):
    pass  # Mixins won't work correctly

# Override dispatch to control flow
class CustomView(LoginRequiredMixin, UpdateView):
    def dispatch(self, request, *args, **kwargs):
        # Custom logic before any other processing
        if not request.user.is_verified:
            return redirect('verify-email')
        return super().dispatch(request, *args, **kwargs)

Form Handling in CBVs

Advanced form handling patterns.

from django.views.generic.edit import FormView
from django.contrib import messages

class ContactFormView(FormView):
    template_name = 'contact.html'
    form_class = ContactForm
    success_url = '/thanks/'

    def get_form_kwargs(self):
        """Pass request to form."""
        kwargs = super().get_form_kwargs()
        kwargs['request'] = self.request
        return kwargs

    def get_initial(self):
        """Pre-populate form."""
        initial = super().get_initial()
        if self.request.user.is_authenticated:
            initial['email'] = self.request.user.email
            initial['name'] = self.request.user.name
        return initial

    def form_valid(self, form):
        form.send_email()
        messages.success(self.request, 'Message sent!')
        return super().form_valid(form)

    def form_invalid(self, form):
        messages.error(self.request, 'Please correct the errors')
        return super().form_invalid(form)

# Multiple forms in one view
 (LoginRequiredMixin, TemplateView):
    template_name = 

     ():
        context = ().get_context_data(**kwargs)
            context:
            context[] = UserForm(instance=.request.user)
            context:
            context[] = ProfileForm(instance=.request.user.profile)
         context

     ():
        user_form = UserForm(request.POST, instance=request.user)
        profile_form = ProfileForm(request.POST, instance=request.user.profile)

         user_form.is_valid()  profile_form.is_valid():
            user_form.save()
            profile_form.save()
            messages.success(request, )
             redirect()

         .render_to_response(
            .get_context_data(user_form=user_form, profile_form=profile_form)
        )

When to Use CBVs vs FBVs

Guidelines for choosing between class-based and function-based views.

# Use CBVs for:
# 1. Standard CRUD operations
class PostListView(ListView):
    model = Post

# 2. Reusable view logic
class OwnerRequiredMixin:
    def get_queryset(self):
        return super().get_queryset().filter(owner=self.request.user)

# 3. Multiple similar views
class UserPostListView(OwnerRequiredMixin, ListView):
    model = Post

class UserDraftListView(OwnerRequiredMixin, ListView):
    model = Post
    queryset = Post.objects.filter(published=False)

# Use FBVs for:
# 1. Simple one-off views
def simple_view(request):
    return render(request, 'simple.html')

# 2. Complex custom logic that doesn't fit CBV patterns
def complex_workflow(request):
    if request.method == 'POST':
        # Complex multi-step logic
        step = request.POST.get('step')
        if step == '1':
            # Process step 1
            pass
        elif step == '2':
            # Process step 2
            pass
     render(request, )


 ():
    posts = Post.objects.(author=request.user)
    comments = Comment.objects.(post__author=request.user)
    analytics = calculate_analytics(request.user)
     render(request, , {
        : posts,
        : comments,
        : analytics
    })

Testing CBVs

Comprehensive testing strategies for class-based views.

from django.test import TestCase, RequestFactory
from django.contrib.auth.models import User, AnonymousUser

class PostListViewTest(TestCase):
    def setUp(self):
        self.factory = RequestFactory()
        self.user = User.objects.create_user(
            username='testuser',
            password='testpass'
        )

    def test_list_view(self):
        request = self.factory.get('/posts/')
        request.user = self.user
        response = PostListView.as_view()(request)
        self.assertEqual(response.status_code, 200)

    def test_queryset_only_published(self):
        Post.objects.create(title='Published', author=self.user, published=True)
        Post.objects.create(title='Draft', author=self.user, published=False)

        request = self.factory.get('/posts/')
        request.user = self.user
        response = PostListView.as_view()(request)
        self.assertEqual(len(response.context_data['posts']), 1)

    def test_login_required(self):
        request = self.factory.get()
        request.user = AnonymousUser()
        response = PostCreateView.as_view()(request)
        .assertEqual(response.status_code, )  

     ():
        other_user = User.objects.create_user(, password=)
        post = Post.objects.create(title=, author=other_user)

        request = .factory.get()
        request.user = .user
        response = PostUpdateView.as_view()(request, pk=post.pk)
        .assertEqual(response.status_code, )  

Advanced Patterns

Complex CBV patterns for production applications.

# Filtering with GET parameters
class PostFilterView(ListView):
    model = Post
    paginate_by = 20

    def get_queryset(self):
        queryset = super().get_queryset()
        author = self.request.GET.get('author')
        published = self.request.GET.get('published')

        if author:
            queryset = queryset.filter(author__name__icontains=author)
        if published is not None:
            queryset = queryset.filter(published=published == 'true')

        return queryset

# Dynamic template selection
class PostDetailView(DetailView):
    model = Post

    def get_template_names(self):
        if self.request.user == self.object.author:
            return ['posts/detail_owner.html']
        return ['posts/detail.html']

# JSON response view
from django.http import JsonResponse

class PostJSONView(DetailView):
    model = Post

    def render_to_response():
         JsonResponse({
            : ..,
            : ..title,
            : ..content,
            : ..author.name
        })


 ():
    model = Post
    template_name = 

     ():
         .request.user.is_staff:
             AdminPostForm
         UserPostForm


 django.views.generic  TemplateView

 ():
    template_name = 

     ():
        context = ().get_context_data(**kwargs)
        query = .request.GET.get(, )

         query:
            context[] = Post.objects.(title__icontains=query)
            context[] = User.objects.(name__icontains=query)
            context[] = query

         context

Pagination in CBVs

Implement sophisticated pagination patterns.

from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger
from django.views.generic import ListView

class PostListView(ListView):
    model = Post
    paginate_by = 20
    paginate_orphans = 5  # Avoid last page with few items

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)

        # Add custom pagination data
        paginator = context['paginator']
        page_obj = context['page_object']

        # Calculate page range for display
        index = page_obj.number - 1
        max_index = len(paginator.page_range)
        start_index = index - 3 if index >= 3 else 0
        end_index = index + 4 if index <= max_index - 4 else max_index

        context['page_range'] = list(paginator.page_range)[start_index:end_index]
        context['total_pages'] = paginator.num_pages

        return context

# AJAX pagination
class AjaxPostListView(ListView):
    model = Post
    paginate_by = 10
    template_name = 'posts/list.html'

    def get_template_names(self):
        if .request.is_ajax():
             []
         [.template_name]

     ():
         .request.is_ajax():
             django.http  JsonResponse
            posts = [
                {
                    : post.,
                    : post.title,
                    : post.author.name
                }
                 post  context[]
            ]
             JsonResponse({
                : posts,
                : context[].has_next(),
                : context[].number
            })
         ().render_to_response(context, **response_kwargs)


 ():
    model = Post
    paginate_by = 

     ():
        context = ().get_context_data(**kwargs)
        context[] = 
         context

Context Data Manipulation

Master advanced context manipulation techniques.

class PostDetailView(DetailView):
    model = Post

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)

        # Add related data
        post = self.object
        context['related_posts'] = Post.objects.filter(
            category=post.category
        ).exclude(id=post.id)[:5]

        # Add user-specific data
        if self.request.user.is_authenticated:
            context['has_liked'] = post.likes.filter(
                user=self.request.user
            ).exists()
            context['is_bookmarked'] = post.bookmarks.filter(
                user=self.request.user
            ).exists()

        # Add computed data
        context['reading_time'] = post.calculate_reading_time()
        context['share_url'] = self.request.build_absolute_uri()

        return context

# Multiple context mixins
class AnalyticsMixin:
    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context['analytics_enabled'] = True
        context['tracking_id'] = settings.ANALYTICS_ID
        return context

class :
    breadcrumbs = []

     ():
        context = ().get_context_data(**kwargs)
        context[] = .get_breadcrumbs()
         context

     ():
         .breadcrumbs

 (AnalyticsMixin, BreadcrumbMixin, DetailView):
    model = Post
    breadcrumbs = [
        (, ),
        (, ),
    ]

     ():
        breadcrumbs = ().get_breadcrumbs()
        breadcrumbs.append((..title, ))
         breadcrumbs

Method Override Patterns

Override specific methods for fine-grained control.

class PostCreateView(CreateView):
    model = Post
    fields = ['title', 'content', 'category']

    # Control initial form data
    def get_initial(self):
        initial = super().get_initial()
        if self.request.user.is_authenticated:
            initial['author'] = self.request.user
        return initial

    # Control form kwargs
    def get_form_kwargs(self):
        kwargs = super().get_form_kwargs()
        kwargs['user'] = self.request.user
        kwargs['categories'] = Category.objects.filter(active=True)
        return kwargs

    # Control form class selection
    def get_form_class(self):
        if self.request.user.is_staff:
            return AdminPostForm
        return PostForm

    # Control success URL dynamically
    def get_success_url(self):
        if 'save_and_add' in self.request.POST:
            return reverse('post-create')
        return reverse(, kwargs={: ..pk})

    
     ():
        form.instance.author = .request.user
        form.instance.ip_address = .request.META.get()

        
         form.instance.published   form.instance.content:
            form.add_error(, )
             .form_invalid(form)

        response = ().form_valid(form)

        
        messages.success(.request, )

         response

    
     ():
        messages.error(.request, )
         ().form_invalid(form)


 ():
    model = Post

     ():
        obj = ().get_object(queryset)

        
        obj.views += 
        obj.save(update_fields=[])

        
         obj.author != .request.user   .request.user.is_staff:
             PermissionDenied()

         obj

     ():
        queryset = ().get_queryset()

        
          .request.user.is_staff:
            queryset = queryset.(author=.request.user)

        
        queryset = queryset.select_related(, )

         queryset

Advanced Mixin Composition

Build complex functionality through mixin composition.

from django.contrib import messages
from django.shortcuts import redirect
from django.core.exceptions import PermissionDenied

class SetHeadlineMixin:
    """Add a headline to the context."""
    headline = None

    def get_headline(self):
        return self.headline

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

class SetButtonTextMixin:
    """Add button text to the context."""
    button_text = 'Submit'

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

class FormValidMessageMixin:
    """Display success message after form submission."""
    success_message = 'Form submitted successfully'

    def form_valid(self, form):
        response = super().form_valid(form)
        messages.success(self.request, self.get_success_message(form))
         response

     ():
         .success_message

 :
    
     ():
          request.POST.get():
            messages.warning(request, )
             redirect(.get_success_url())

        messages.success(request, )
         ().delete(request, *args, **kwargs)

 :
    
     ():
          request.user.is_staff:
             PermissionDenied
         ().dispatch(request, *args, **kwargs)

 :
    
     ():
          form.instance.pk:
            form.instance.created_by = .request.user
        form.instance.updated_by = .request.user
         ().form_valid(form)


 (
    LoginRequiredMixin,
    SetHeadlineMixin,
    SetButtonTextMixin,
    FormValidMessageMixin,
    AuditMixin,
    CreateView
):
    model = Post
    fields = [, ]
    headline = 
    button_text = 
    success_message = 

Search and Filter Views

Implement advanced search and filtering.

from django.db.models import Q
from django.views.generic import ListView

class PostSearchView(ListView):
    model = Post
    template_name = 'posts/search.html'
    paginate_by = 20

    def get_queryset(self):
        queryset = super().get_queryset()
        query = self.request.GET.get('q')

        if query:
            queryset = queryset.filter(
                Q(title__icontains=query) |
                Q(content__icontains=query) |
                Q(author__name__icontains=query)
            )

        return queryset

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context['query'] = self.request.GET.get('q', '')
        context['result_count'] = context['paginator'].count
        return context

class PostFilterView(ListView):
    model = Post
    template_name = 'posts/filter.html'
    paginate_by = 20

    def get_queryset(self):
        queryset = super().get_queryset()

        # Category filter
        category = self.request.GET.get('category')
        if category:
            queryset = queryset.(category_id=category)

        
        author = .request.GET.get()
         author:
            queryset = queryset.(author_id=author)

        
        date_from = .request.GET.get()
        date_to = .request.GET.get()
         date_from:
            queryset = queryset.(created_at__gte=date_from)
         date_to:
            queryset = queryset.(created_at__lte=date_to)

        
        published = .request.GET.get()
         published   :
            queryset = queryset.(published=published == )

        
        sort = .request.GET.get(, )
        allowed_sorts = [, , , , , ]
         sort  allowed_sorts:
            queryset = queryset.order_by(sort)

         queryset.select_related(, )

     ():
        context = ().get_context_data(**kwargs)
        context[] = Category.objects.()
        context[] = User.objects.(posts__isnull=).distinct()
        context[] = .request.GET
         context

File Upload Views

Handle file uploads with CBVs.

from django.views.generic.edit import FormView
from django.core.files.storage import default_storage

class FileUploadView(FormView):
    template_name = 'upload.html'
    form_class = FileUploadForm
    success_url = '/success/'

    def form_valid(self, form):
        file = form.cleaned_data['file']

        # Save file
        filename = default_storage.save(f'uploads/{file.name}', file)

        # Process file
        self.process_file(filename)

        messages.success(self.request, f'File {file.name} uploaded successfully')
        return super().form_valid(form)

    def process_file(self, filename):
        # Custom file processing logic
        pass

class MultipleFileUploadView(FormView):
    template_name = 'upload_multiple.html'
    form_class = MultipleFileUploadForm
    success_url = '/success/'

    def form_valid(self, form):
        files = self.request.FILES.getlist('files')

        for file in files:
            # Validate file
            if file.size > 10 * 1024 * :  
                form.add_error(, )
                 .form_invalid(form)

            
            filename = default_storage.save(, file)

            
            FileUpload.objects.create(
                filename=filename,
                original_name=file.name,
                size=file.size,
                uploaded_by=.request.user
            )

        messages.success(.request, )
         ().form_valid(form)

 ():
    model = Image
    fields = [, , ]
    template_name = 

     ():
        form.instance.uploaded_by = .request.user

        
        image = form.cleaned_data[]
         image.size >  *  * :  
            form.add_error(, )
             .form_invalid(form)

        
        form.instance.thumbnail = .create_thumbnail(image)

         ().form_valid(form)

     ():
        
        

Performance Optimization

Optimize CBVs for better performance.

class OptimizedPostListView(ListView):
    model = Post
    paginate_by = 20

    def get_queryset(self):
        return Post.objects.select_related(
            'author'
        ).prefetch_related(
            'comments'
        ).only(
            'id', 'title', 'created_at', 'author__name'
        ).filter(
            published=True
        )

# Caching
from django.views.decorators.cache import cache_page
from django.utils.decorators import method_decorator

@method_decorator(cache_page(60 * 15), name='dispatch')
class CachedPostListView(ListView):
    model = Post

# Conditional caching based on user
class SmartCachedView(ListView):
    model = Post

    @method_decorator(cache_page(60 * 15))
    def dispatch(self, request, *args, **kwargs):
        if request.user.is_authenticated:
            # Don't cache for authenticated users
            return super().dispatch(request, *args, **kwargs)
         ().dispatch(request, *args, **kwargs)


 django.views.decorators.http  condition

 ():
     Post.objects.latest().updated_at

 ():
     (Post.objects.latest().updated_at.timestamp())

 ():
    model = Post


     ():
         ().dispatch(*args, **kwargs)

When to Use This Skill

Use django-cbv-patterns when building modern, production-ready applications that require advanced patterns, best practices, and optimal performance.

API Views with CBVs

Build API endpoints using CBVs without DRF.

from django.http import JsonResponse
from django.views.generic import View
from django.views.decorators.csrf import csrf_exempt
from django.utils.decorators import method_decorator
import json

@method_decorator(csrf_exempt, name='dispatch')
class PostAPIView(View):
    def get(self, request, *args, **kwargs):
        posts = Post.objects.filter(published=True).values(
            'id', 'title', 'content', 'author__name'
        )
        return JsonResponse(list(posts), safe=False)

    def post(self, request, *args, **kwargs):
        try:
            data = json.loads(request.body)
            post = Post.objects.create(
                title=data['title'],
                content=data['content'],
                author=request.user
            )
            return JsonResponse({
                'id': post.id,
                'title': post.title,
                'message': 'Post created successfully'
            }, status=201)
        except Exception as e:
            return JsonResponse({'error': str(e)}, status=)

 ():
     ():
        :
            post = Post.objects.select_related().get(pk=pk)
             JsonResponse({
                : post.,
                : post.title,
                : post.content,
                : post.author.name,
                : post.created_at.isoformat()
            })
         Post.DoesNotExist:
             JsonResponse({: }, status=)

     ():
        :
            post = Post.objects.get(pk=pk)
            data = json.loads(request.body)

            post.title = data.get(, post.title)
            post.content = data.get(, post.content)
            post.save()

             JsonResponse({: })
         Post.DoesNotExist:
             JsonResponse({: }, status=)

     ():
        :
            post = Post.objects.get(pk=pk)
            post.delete()
             JsonResponse({: })
         Post.DoesNotExist:
             JsonResponse({: }, status=)

Wizard and Multi-Step Forms

Implement multi-step form wizards with CBVs.

from django.views.generic import TemplateView
from django.shortcuts import redirect
from django.urls import reverse

class MultiStepFormMixin:
    """Mixin for multi-step form handling."""

    def get_step(self):
        return int(self.request.GET.get('step', 1))

    def get_session_key(self, step):
        return f'form_data_step_{step}'

    def save_step_data(self, step, data):
        self.request.session[self.get_session_key(step)] = data

    def get_step_data(self, step):
        return self.request.session.get(self.get_session_key(step), {})

    def clear_wizard_data(self):
        for key in list(self.request.session.keys()):
            if key.startswith('form_data_step_'):
                del self.request.session[key]

class UserRegistrationWizard(MultiStepFormMixin, TemplateView):
    template_name = 

     ():
        context = ().get_context_data(**kwargs)
        step = .get_step()

         step == :
            context[] = UserBasicInfoForm(initial=.get_step_data())
         step == :
            context[] = UserProfileForm(initial=.get_step_data())
         step == :
            context[] = UserPreferencesForm(initial=.get_step_data())

        context[] = step
        context[] = 
         context

     ():
        step = .get_step()

         step == :
            form = UserBasicInfoForm(request.POST)
             form.is_valid():
                .save_step_data(, form.cleaned_data)
                 redirect()

         step == :
            form = UserProfileForm(request.POST)
             form.is_valid():
                .save_step_data(, form.cleaned_data)
                 redirect()

         step == :
            form = UserPreferencesForm(request.POST)
             form.is_valid():
                .save_step_data(, form.cleaned_data)

                
                .create_user()
                .clear_wizard_data()

                 redirect()

         .render_to_response(.get_context_data(form=form))

     ():
        data1 = .get_step_data()
        data2 = .get_step_data()
        data3 = .get_step_data()

        user = User.objects.create_user(
            username=data1[],
            email=data1[],
            password=data1[]
        )

        Profile.objects.create(
            user=user,
            bio=data2[],
            avatar=data2[]
        )

        Preferences.objects.create(
            user=user,
            notifications=data3[],
            privacy=data3[]
        )

Redirect and Success URL Patterns

Master URL redirection strategies.

from django.urls import reverse, reverse_lazy
from django.views.generic import CreateView, UpdateView

class PostCreateView(CreateView):
    model = Post
    fields = ['title', 'content']

    # Static success URL
    success_url = reverse_lazy('post-list')

    # Dynamic success URL based on object
    def get_success_url(self):
        return reverse('post-detail', kwargs={'pk': self.object.pk})

class PostUpdateView(UpdateView):
    model = Post
    fields = ['title', 'content']

    # Success URL based on form submission button
    def get_success_url(self):
        if 'save_and_continue' in self.request.POST:
            return reverse('post-update', kwargs={'pk': self.object.pk})
        elif 'save_and_add' in self.request.POST:
            return reverse('post-create')
        else:
            return reverse('post-detail', kwargs={: ..pk})

 :
    

     ():
        next_url = .request.GET.get()  .request.POST.get()
         next_url:
             next_url
         ().get_success_url()

 (FlexibleRedirectMixin, DeleteView):
    model = Post
    success_url = reverse_lazy()

Template and Response Customization

Customize template selection and response rendering.

from django.views.generic import DetailView
from django.http import HttpResponse
from django.template.loader import render_to_string

class PostDetailView(DetailView):
    model = Post

    # Dynamic template selection
    def get_template_names(self):
        # Mobile template
        if self.request.user_agent.is_mobile:
            return ['posts/detail_mobile.html']

        # Owner template
        if self.request.user == self.object.author:
            return ['posts/detail_owner.html']

        # Default template
        return ['posts/detail.html']

class ExportMixin:
    """Add export functionality to views."""

    def render_to_response(self, context, **response_kwargs):
        export_format = self.request.GET.get('format')

        if export_format == 'pdf':
            return self.render_to_pdf(context)
        elif export_format == 'csv':
            return self.render_to_csv(context)
        elif export_format == :
             .render_to_json(context)

         ().render_to_response(context, **response_kwargs)

     ():
        
        html = render_to_string(.template_name, context)
        
         HttpResponse(pdf_content, content_type=)

     ():
         csv
         io  StringIO

        output = StringIO()
        writer = csv.writer(output)

        
         obj  context[]:
            writer.writerow([obj., obj.title, obj.author.name])

        response = HttpResponse(output.getvalue(), content_type=)
        response[] = 
         response

     ():
         django.http  JsonResponse
        data = [
            {
                : obj.,
                : obj.title,
                : obj.author.name
            }
             obj  context[]
        ]
         JsonResponse(data, safe=)

 (ExportMixin, ListView):
    model = Post

Advanced Testing Patterns

Write comprehensive tests for CBVs.

from django.test import TestCase, RequestFactory, Client
from django.contrib.auth.models import User, AnonymousUser
from django.urls import reverse

class PostViewTestCase(TestCase):
    def setUp(self):
        self.factory = RequestFactory()
        self.user = User.objects.create_user(
            username='testuser',
            password='testpass'
        )
        self.post = Post.objects.create(
            title='Test Post',
            author=self.user
        )

    def test_list_view_with_factory(self):
        """Test using RequestFactory."""
        request = self.factory.get('/posts/')
        request.user = self.user

        response = PostListView.as_view()(request)
        self.assertEqual(response.status_code, 200)

    def test_detail_view_with_client(self):
        """Test using Client."""
        client = Client()
        response = client.get(reverse('post-detail', kwargs={'pk': self.post.pk}))
        self.assertEqual(response.status_code, 200)
        self.assertContains(response, 'Test Post')

    def test_create_view_requires_login():
        
        request = .factory.get()
        request.user = AnonymousUser()

        response = PostCreateView.as_view()(request)
        .assertEqual(response.status_code, )  

     ():
        
        other_user = User.objects.create_user(, password=)
        request = .factory.get()
        request.user = other_user

         .assertRaises(PermissionDenied):
            PostUpdateView.as_view()(request, pk=.post.pk)

     ():
        
        request = .factory.get()
        request.user = .user

        view = PostListView()
        view.request = request
        view.object_list = Post.objects.()

        context = view.get_context_data()
        .assertIn(, context)
        .assertIn(, context)

     ():
        
        data = {
            : ,
            : 
        }
        request = .factory.post(, data)
        request.user = .user

        response = PostCreateView.as_view()(request)
        .assertEqual(response.status_code, )  
        .assertTrue(Post.objects.(title=).exists())

     ():
        
         .assertNumQueries():
            request = .factory.get()
            request.user = .user
            response = OptimizedPostListView.as_view()(request)
            (response.context_data[])

Django CBV Best Practices

1. Follow MRO carefully - Order mixins correctly: permission mixins first, then functionality mixins, base view last
2. Use built-in mixins - Leverage LoginRequiredMixin, UserPassesTestMixin instead of writing custom permission logic
3. Override get_queryset() - Customize querysets in get_queryset(), not in the class attribute
4. Use get_context_data() - Add extra context properly by calling super() first
5. Keep views focused - Each view should have a single responsibility
6. Leverage generic views - Use built-in generic views for CRUD operations
7. Create custom mixins - Extract reusable functionality into mixins
8. Use get_form_kwargs() - Pass additional data to forms through get_form_kwargs()
9. Optimize queries - Use select_related and prefetch_related in get_queryset()
10. Test thoroughly - Use RequestFactory for unit testing views
11. Use success_url wisely - Prefer get_success_url() for dynamic URLs
12. Handle AJAX requests - Check request.is_ajax() and return appropriate responses
13. Implement proper pagination - Always paginate large querysets
14. Cache where appropriate - Use method decorators for caching expensive views
15. Document mixin order - Comment why mixins are ordered a certain way

Django CBV Common Pitfalls

1. Wrong mixin order - Incorrect MRO causes mixins to not work or override each other incorrectly
2. Not calling super() - Forgetting super() breaks the inheritance chain
3. Hardcoded querysets - Defining queryset as class attribute instead of using get_queryset()
4. Overusing CBVs - Using CBVs for simple views that would be clearer as functions
5. Not understanding dispatch() - Misusing dispatch() method leads to unexpected behavior
6. Ignoring context_object_name - Templates are less readable without proper context names
7. Mixing concerns - Putting too much logic in views instead of models or forms
8. Not optimizing queries - N+1 problems from not using select_related/prefetch_related
9. Testing with client only - Not unit testing with RequestFactory
10. Complex inheritance chains - Too many mixins make code hard to understand and debug
11. Forgetting CSRF protection - Disabling CSRF without understanding security implications
12. Not handling exceptions - Not catching DoesNotExist or PermissionDenied in custom methods
13. Incorrect success_url usage - Using reverse() instead of reverse_lazy() in class attributes
14. Template name conflicts - Not setting explicit template_name when needed
15. Missing get_object() customization - Not customizing get_object() for permission checks

Resources

• Django Class-Based Views Documentation
• Classy Class-Based Views
• Django CBV Inspector
• Django Mixins Documentation
• Django Forms in CBVs