Bài 27: Class-Based Views Advanced

FormView

FormView hiển thị form và xử lý submission, không liên quan đến model.

from django.views.generic.edit import FormViewfrom django.urls import reverse_lazyfrom django.contrib import messages # Basic FormViewclass ContactFormView(FormView):    template_name = 'contact.html'    form_class = ContactForm    success_url = reverse_lazy('contact_success')        def form_valid(self, form):        # Process form data        form.send_email()        messages.success(self.request, 'Message sent successfully!')        return super().form_valid(form)        def form_invalid(self, form):        messages.error(self.request, 'Please correct the errors.')        return super().form_invalid(form) # urls.pypath('contact/', ContactFormView.as_view(), name='contact') # FormView vs CreateView:# - FormView: General form processing (contact, search, etc.)# - CreateView: Creating model instances

FormView with Initial Data

class SearchFormView(FormView):    template_name = 'search.html'    form_class = SearchForm        def get_initial(self):        """Set initial form data"""        initial = super().get_initial()        # Pre-fill from GET params        initial['query'] = self.request.GET.get('q', '')        initial['category'] = self.request.GET.get('category', '')        return initial        def get_form_kwargs(self):        """Pass extra kwargs to form"""        kwargs = super().get_form_kwargs()        kwargs['user'] = self.request.user        return kwargs        def form_valid(self, form):        # Process search        results = form.search()                # Add results to context without redirecting        context = self.get_context_data(            form=form,            results=results        )        return self.render_to_response(context)

FormView with File Upload

class FileUploadView(FormView):    template_name = 'upload.html'    form_class = FileUploadForm    success_url = reverse_lazy('upload_success')        def post(self, request, *args, **kwargs):        """Override to handle files"""        form_class = self.get_form_class()        form = self.get_form(form_class)                # Manually pass FILES        if form.is_valid():            return self.form_valid(form)        else:            return self.form_invalid(form)        def form_valid(self, form):        # Process uploaded file        uploaded_file = form.cleaned_data['file']                # Save or process file        Document.objects.create(            title=form.cleaned_data['title'],            file=uploaded_file,            uploaded_by=self.request.user        )                return super().form_valid(form)

get_context_data() Override

Basic Context Data

from django.views.generic import ListView, DetailView class PostListView(ListView):    model = Post    template_name = 'blog/post_list.html'    context_object_name = 'posts'        def get_context_data(self, **kwargs):        # Get parent context        context = super().get_context_data(**kwargs)                # Add custom data        context['title'] = 'All Posts'        context['categories'] = Category.objects.all()        context['popular_posts'] = Post.objects.order_by('-views')[:5]        context['total_posts'] = Post.objects.count()                return context # Template access:# {{ title }}# {% for category in categories %}# {% for post in popular_posts %}

Context Data with Filtering

class PostListView(ListView):    model = Post    paginate_by = 10        def get_context_data(self, **kwargs):        context = super().get_context_data(**kwargs)                # Add current filters        context['current_category'] = self.request.GET.get('category')        context['current_tag'] = self.request.GET.get('tag')        context['search_query'] = self.request.GET.get('q')                # Add filter options        context['categories'] = Category.objects.annotate(            post_count=Count('posts')        )        context['tags'] = Tag.objects.annotate(            post_count=Count('posts')        ).order_by('-post_count')[:20]                # Add statistics        context['stats'] = {            'total_posts': Post.objects.count(),            'published_posts': Post.objects.filter(published=True).count(),            'total_views': Post.objects.aggregate(Sum('views'))['views__sum'] or 0,        }                return context

Context Data in DetailView

class PostDetailView(DetailView):    model = Post        def get_context_data(self, **kwargs):        context = super().get_context_data(**kwargs)                # Related posts        context['related_posts'] = Post.objects.filter(            category=self.object.category        ).exclude(pk=self.object.pk)[:4]                # Comments with replies        context['comments'] = self.object.comments.filter(            parent=None,            approved=True        ).select_related('author').prefetch_related('replies')                # Previous/Next posts        context['previous_post'] = Post.objects.filter(            created__lt=self.object.created,            published=True        ).order_by('-created').first()                context['next_post'] = Post.objects.filter(            created__gt=self.object.created,            published=True        ).order_by('created').first()                # Add comment form        context['comment_form'] = CommentForm()                return context

get_queryset() Override

Basic Queryset Filtering

class PostListView(ListView):    model = Post        def get_queryset(self):        # Get base queryset        queryset = super().get_queryset()                # Only published posts        queryset = queryset.filter(published=True)                # Order by created date        queryset = queryset.order_by('-created')                # Optimize queries        queryset = queryset.select_related('author', 'category')        queryset = queryset.prefetch_related('tags', 'comments')                return queryset

Dynamic Filtering

class PostListView(ListView):    model = Post    paginate_by = 10        def get_queryset(self):        queryset = super().get_queryset()                # Filter by category        category_slug = self.request.GET.get('category')        if category_slug:            queryset = queryset.filter(category__slug=category_slug)                # Filter by tag        tag_slug = self.request.GET.get('tag')        if tag_slug:            queryset = queryset.filter(tags__slug=tag_slug)                # Search        query = self.request.GET.get('q')        if query:            queryset = queryset.filter(                Q(title__icontains=query) |                Q(content__icontains=query)            )                # Sort        sort = self.request.GET.get('sort', '-created')        allowed_sorts = ['created', '-created', 'title', '-title', 'views', '-views']        if sort in allowed_sorts:            queryset = queryset.order_by(sort)                return queryset.distinct()

User-Specific Queryset

class MyPostListView(ListView):    model = Post    template_name = 'blog/my_posts.html'        def get_queryset(self):        # Only current user's posts        return Post.objects.filter(            author=self.request.user        ).order_by('-created') class FollowingPostsView(ListView):    model = Post    template_name = 'blog/following_posts.html'        def get_queryset(self):        # Posts from users that current user follows        following_users = self.request.user.following.all()        return Post.objects.filter(            author__in=following_users,            published=True        ).select_related('author').order_by('-created')

Built-in Mixins

LoginRequiredMixin

from django.contrib.auth.mixins import LoginRequiredMixinfrom django.views.generic import CreateView, UpdateView, DeleteView class PostCreateView(LoginRequiredMixin, CreateView):    model = Post    fields = ['title', 'content', 'category']        # Redirect to login if not authenticated    login_url = '/login/'  # Default: settings.LOGIN_URL    redirect_field_name = 'next'  # Default: 'next'        def form_valid(self, form):        form.instance.author = self.request.user        return super().form_valid(form) # Order matters: LoginRequiredMixin must come first!class PostUpdateView(LoginRequiredMixin, UpdateView):    model = Post    fields = ['title', 'content']

UserPassesTestMixin

from django.contrib.auth.mixins import UserPassesTestMixin class PostUpdateView(LoginRequiredMixin, UserPassesTestMixin, UpdateView):    model = Post    fields = ['title', 'content']        def test_func(self):        """Test if user can access this view"""        post = self.get_object()        # Only author can edit        return self.request.user == post.author # Custom permission denied handling:class PostDeleteView(LoginRequiredMixin, UserPassesTestMixin, DeleteView):    model = Post    success_url = reverse_lazy('post_list')        def test_func(self):        post = self.get_object()        # Author or staff can delete        return self.request.user == post.author or self.request.user.is_staff        def handle_no_permission(self):        messages.error(self.request, "You don't have permission to delete this post.")        return redirect('post_detail', pk=self.get_object().pk)

PermissionRequiredMixin

from django.contrib.auth.mixins import PermissionRequiredMixin class PostCreateView(PermissionRequiredMixin, CreateView):    model = Post    fields = ['title', 'content']    permission_required = 'blog.add_post'    # User must have this permission class PostUpdateView(PermissionRequiredMixin, UpdateView):    model = Post    fields = ['title', 'content']    permission_required = 'blog.change_post' class PostDeleteView(PermissionRequiredMixin, DeleteView):    model = Post    success_url = reverse_lazy('post_list')    permission_required = 'blog.delete_post'        # Multiple permissions (must have all)    permission_required = ['blog.delete_post', 'blog.can_moderate']        # Custom permission denied message    permission_denied_message = "You don't have permission to perform this action."

Custom Mixins

AuthorRequiredMixin

from django.contrib.auth.mixins import LoginRequiredMixinfrom django.core.exceptions import PermissionDenied class AuthorRequiredMixin(LoginRequiredMixin):    """Require user to be the author of the object"""        def dispatch(self, request, *args, **kwargs):        obj = self.get_object()        if obj.author != request.user:            raise PermissionDenied("You are not the author of this post.")        return super().dispatch(request, *args, **kwargs) # Usage:class PostUpdateView(AuthorRequiredMixin, UpdateView):    model = Post    fields = ['title', 'content'] class PostDeleteView(AuthorRequiredMixin, DeleteView):    model = Post    success_url = reverse_lazy('post_list')

FormMessageMixin

from django.contrib import messages class FormMessageMixin:    """Add success/error messages to form views"""        success_message = ''    error_message = 'Please correct the errors below.'        def get_success_message(self):        return self.success_message        def get_error_message(self):        return self.error_message        def form_valid(self, form):        response = super().form_valid(form)        success_message = self.get_success_message()        if success_message:            messages.success(self.request, success_message)        return response        def form_invalid(self, form):        response = super().form_invalid(form)        error_message = self.get_error_message()        if error_message:            messages.error(self.request, error_message)        return response # Usage:class PostCreateView(FormMessageMixin, CreateView):    model = Post    fields = ['title', 'content']    success_message = 'Post created successfully!'        def get_success_message(self):        return f'Post "{self.object.title}" created successfully!'

AjaxResponseMixin

from django.http import JsonResponse class AjaxResponseMixin:    """Handle AJAX requests differently"""        def form_valid(self, form):        response = super().form_valid(form)                if self.request.headers.get('X-Requested-With') == 'XMLHttpRequest':            return JsonResponse({                'success': True,                'message': 'Operation successful',                'redirect_url': self.get_success_url(),            })                return response        def form_invalid(self, form):        response = super().form_invalid(form)                if self.request.headers.get('X-Requested-With') == 'XMLHttpRequest':            return JsonResponse({                'success': False,                'errors': form.errors,            }, status=400)                return response # Usage:class PostCreateView(AjaxResponseMixin, CreateView):    model = Post    fields = ['title', 'content']

PaginationMixin

class CustomPaginationMixin:    """Custom pagination settings"""        def get_paginate_by(self, queryset):        """Allow user to set items per page"""        per_page = self.request.GET.get('per_page')                if per_page:            try:                per_page = int(per_page)                if per_page > 0 and per_page <= 100:                    return per_page            except (ValueError, TypeError):                pass                return self.paginate_by or 10        def get_context_data(self, **kwargs):        context = super().get_context_data(**kwargs)        context['per_page_options'] = [10, 25, 50, 100]        context['current_per_page'] = self.get_paginate_by(None)        return context

Multiple Mixins

Mixin Order

# Order matters! Left to rightclass PostUpdateView(    LoginRequiredMixin,      # 1. Check authentication    UserPassesTestMixin,     # 2. Check permission    FormMessageMixin,        # 3. Add messages    UpdateView               # 4. Base view):    model = Post    fields = ['title', 'content']    success_message = 'Post updated successfully!'        def test_func(self):        return self.request.user == self.get_object().author # Method Resolution Order (MRO):# Python searches methods left to right, then up the hierarchy

Complex Mixin Combination

class PostCreateView(    LoginRequiredMixin,    PermissionRequiredMixin,    FormMessageMixin,    AjaxResponseMixin,    CreateView):    model = Post    form_class = PostForm    permission_required = 'blog.add_post'    success_message = 'Post created successfully!'        def form_valid(self, form):        form.instance.author = self.request.user        return super().form_valid(form)        def get_success_url(self):        return reverse('post_detail', kwargs={'pk': self.object.pk})

Custom Generic Views

Custom Base View

class BasePostView:    """Base view for all post views"""    model = Post        def get_queryset(self):        return Post.objects.select_related('author', 'category').prefetch_related('tags')        def get_context_data(self, **kwargs):        context = super().get_context_data(**kwargs)        context['categories'] = Category.objects.all()        context['popular_tags'] = Tag.objects.annotate(            post_count=Count('posts')        ).order_by('-post_count')[:10]        return context # Usage:class PostListView(BasePostView, ListView):    template_name = 'blog/post_list.html'    paginate_by = 10 class PostDetailView(BasePostView, DetailView):    template_name = 'blog/post_detail.html'

Reusable Filter View

class FilteredListView(ListView):    """Generic filtered list view"""        filter_fields = []  # Override in subclass        def get_queryset(self):        queryset = super().get_queryset()                for field in self.filter_fields:            value = self.request.GET.get(field)            if value:                queryset = queryset.filter(**{field: value})                return queryset        def get_context_data(self, **kwargs):        context = super().get_context_data(**kwargs)        context['active_filters'] = {            field: self.request.GET.get(field)            for field in self.filter_fields            if self.request.GET.get(field)        }        return context # Usage:class PostListView(FilteredListView):    model = Post    filter_fields = ['category__slug', 'tags__slug', 'author__username']    paginate_by = 10

Method Override Patterns

Common Overrides

class PostDetailView(DetailView):    model = Post        def get_object(self, queryset=None):        """Custom object retrieval"""        obj = super().get_object(queryset)                # Increment view count        obj.views = F('views') + 1        obj.save(update_fields=['views'])        obj.refresh_from_db()                return obj        def get_template_names(self):        """Dynamic template selection"""        if self.request.user.is_authenticated:            return ['blog/post_detail_auth.html']        return ['blog/post_detail.html']        def dispatch(self, request, *args, **kwargs):        """Pre-processing before view execution"""        # Log access        logger.info(f'User {request.user} accessed post {kwargs.get("pk")}')                return super().dispatch(request, *args, **kwargs)

Form View Overrides

class PostCreateView(CreateView):    model = Post    form_class = PostForm        def get_form_kwargs(self):        """Pass extra kwargs to form"""        kwargs = super().get_form_kwargs()        kwargs['user'] = self.request.user        return kwargs        def get_initial(self):        """Set initial form data"""        initial = super().get_initial()        initial['author'] = self.request.user        return initial        def form_valid(self, form):        """Process valid form"""        # Set additional fields        form.instance.author = self.request.user        form.instance.ip_address = self.request.META.get('REMOTE_ADDR')                # Save        response = super().form_valid(form)                # Post-save processing        send_notification(self.object)                return response

Bài Tập

Bài 1: Advanced Blog Views

Task: Implement advanced blog views với mixins:

# Requirements:# 1. Base view mixin for common functionality# 2. Post create/update với LoginRequired + AuthorRequired# 3. Success/error messages mixin# 4. AJAX response mixin for async operations# 5. Custom pagination mixin (user-selectable)# 6. Filter mixin for category/tag filtering# 7. Search functionality in ListView# 8. View counter in DetailView# 9. Previous/Next navigation# 10. Related posts in context

Bài 2: Permission-Based Views

Task: Create permission-based view system:

# Requirements:# 1. Role-based access (admin, moderator, author, user)# 2. LoginRequiredMixin on all protected views# 3. PermissionRequiredMixin for admin features# 4. Custom AuthorOrStaffMixin# 5. Handle permission denied gracefully# 6. Redirect with appropriate messages# 7. Log access attempts# 8. Show different templates based on role# 9. Feature flags based on user permissions# 10. Test all permission scenarios

Bài 3: Reusable View Components

Task: Build reusable view components:

# Requirements:# 1. BaseListView with common functionality# 2. FilteredListView for filtering# 3. SearchableListView for search# 4. SortableListView for sorting# 5. ExportMixin (CSV, JSON, PDF)# 6. BreadcrumbMixin for navigation# 7. SEOMixin for meta tags# 8. AnalyticsMixin for tracking# 9. CacheMixin for caching# 10. Use multiple mixins in views

Bài 4: Complete View System

Task: Full-featured view system:

# Requirements:# 1. All CRUD operations with mixins# 2. Soft delete functionality# 3. Bulk operations (multi-select delete)# 4. Version history (track changes)# 5. Approval workflow (draft -> review -> published)# 6. AJAX support for all operations# 7. Form wizards for complex forms# 8. Inline editing support# 9. Activity logging# 10. Performance optimization# 11. Responsive design# 12. Error handling# 13. Unit tests for all views# 14. Integration tests# 15. Documentation

Tài Liệu Tham Khảo

Previous: Bài 26: Email Configuration & Sending | Next: Bài 28: Django Templates Advanced

#class-based-views

Django Generic Views

Django Class-Based Views Advanced