Bài 6.3: Generic Views & ViewSets - Phần 3 - Advanced Patterns

**Series Navigation:** - [Bài 6.1: Generic Views](/django-advance/generic-views-viewsets-phan-1) - [Bài 6.2: ViewSets & Routers](/django-advance/generic-views-viewsets-phan-3) - **Bài 6.3 (bài này): Advanced Patterns** 👈

Mục Tiêu Bài 6.3

Sau khi hoàn thành Bài 6.3 này, bạn sẽ:

✅ Implement nested routes và nested ViewSets
✅ Master pagination strategies
✅ Configure filtering, searching, ordering
✅ Optimize queryset performance
✅ Handle multiple serializers dynamically
✅ Apply per-action permissions
✅ Test ViewSets effectively
✅ Implement advanced patterns

Nested Routes

What are Nested Routes?

Nested routes = URLs representing resource relationships.

Examples:

/articles/                        → All articles/articles/1/                      → Article #1/articles/1/comments/             → Comments for article #1/articles/1/comments/5/           → Comment #5 of article #1 /users/                           → All users/users/1/                         → User #1/users/1/articles/                → Articles by user #1/users/1/articles/5/              → Article #5 by user #1

Manual Nested Routes

Without nested routers:

# views.pyclass ArticleCommentViewSet(viewsets.ModelViewSet):    serializer_class = CommentSerializer    permission_classes = [IsAuthenticatedOrReadOnly]        def get_queryset(self):        """Filter comments by article"""        article_id = self.kwargs['article_pk']        return Comment.objects.filter(article_id=article_id)        def perform_create(self, serializer):        """Associate comment with article"""        article_id = self.kwargs['article_pk']        article = get_object_or_404(Article, pk=article_id)        serializer.save(article=article, author=self.request.user) # urls.pyfrom django.urls import pathfrom .views import ArticleCommentViewSet urlpatterns = [    path('articles/<int:article_pk>/comments/',          ArticleCommentViewSet.as_view({'get': 'list', 'post': 'create'}),         name='article-comment-list'),    path('articles/<int:article_pk>/comments/<int:pk>/',          ArticleCommentViewSet.as_view({             'get': 'retrieve',             'put': 'update',             'patch': 'partial_update',             'delete': 'destroy'         }),         name='article-comment-detail'),]

Using drf-nested-routers

Install:

pip install drf-nested-routers

Setup:

# urls.pyfrom rest_framework.routers import DefaultRouterfrom rest_framework_nested import routersfrom .views import ArticleViewSet, CommentViewSet # Main routerrouter = DefaultRouter()router.register(r'articles', ArticleViewSet, basename='article') # Nested routerarticles_router = routers.NestedDefaultRouter(router, r'articles', lookup='article')articles_router.register(r'comments', CommentViewSet, basename='article-comments') urlpatterns = [    path('', include(router.urls)),    path('', include(articles_router.urls)),]

Generated URLs:

# Main resourceGET    /articles/POST   /articles/GET    /articles/{id}/PUT    /articles/{id}/PATCH  /articles/{id}/DELETE /articles/{id}/ # Nested resourceGET    /articles/{article_pk}/comments/POST   /articles/{article_pk}/comments/GET    /articles/{article_pk}/comments/{id}/PUT    /articles/{article_pk}/comments/{id}/PATCH  /articles/{article_pk}/comments/{id}/DELETE /articles/{article_pk}/comments/{id}/

ViewSet:

class CommentViewSet(viewsets.ModelViewSet):    serializer_class = CommentSerializer    permission_classes = [IsAuthenticatedOrReadOnly]        def get_queryset(self):        # article_pk automatically available from URL        return Comment.objects.filter(article_pk=self.kwargs['article_pk'])        def perform_create(self, serializer):        article = get_object_or_404(Article, pk=self.kwargs['article_pk'])        serializer.save(article=article, author=self.request.user)

Multi-Level Nesting

3-level nesting:

# URLs: /articles/{article_pk}/comments/{comment_pk}/replies/ from rest_framework_nested import routers # Level 1: Articlesrouter = DefaultRouter()router.register(r'articles', ArticleViewSet) # Level 2: Commentscomments_router = routers.NestedDefaultRouter(router, r'articles', lookup='article')comments_router.register(r'comments', CommentViewSet, basename='article-comments') # Level 3: Repliesreplies_router = routers.NestedDefaultRouter(comments_router, r'comments', lookup='comment')replies_router.register(r'replies', ReplyViewSet, basename='comment-replies') urlpatterns = [    path('', include(router.urls)),    path('', include(comments_router.urls)),    path('', include(replies_router.urls)),]

ViewSet:

class ReplyViewSet(viewsets.ModelViewSet):    serializer_class = ReplySerializer        def get_queryset(self):        return Reply.objects.filter(            comment__article_pk=self.kwargs['article_pk'],            comment_pk=self.kwargs['comment_pk']        )        def perform_create(self, serializer):        comment = get_object_or_404(            Comment,            pk=self.kwargs['comment_pk'],            article_pk=self.kwargs['article_pk']        )        serializer.save(comment=comment, author=self.request.user)

Pagination

Why Pagination?

Benefits:

✅ Reduce response size
✅ Improve performance
✅ Better user experience
✅ Prevent memory issues

PageNumberPagination

Most common pagination style:

# settings.pyREST_FRAMEWORK = {    'DEFAULT_PAGINATION_CLASS': 'rest_framework.pagination.PageNumberPagination',    'PAGE_SIZE': 10}

Usage:

GET /articles/              → Page 1 (items 1-10)GET /articles/?page=2       → Page 2 (items 11-20)GET /articles/?page=3       → Page 3 (items 21-30)

Response:

{    "count": 100,    "next": "http://api.example.com/articles/?page=2",    "previous": null,    "results": [        {...},        {...}    ]}

Custom PageNumberPagination:

# pagination.pyfrom rest_framework.pagination import PageNumberPagination class CustomPageNumberPagination(PageNumberPagination):    page_size = 20    page_size_query_param = 'page_size'    max_page_size = 100    page_query_param = 'page' # views.pyclass ArticleViewSet(viewsets.ModelViewSet):    queryset = Article.objects.all()    serializer_class = ArticleSerializer    pagination_class = CustomPageNumberPagination # Usage:# GET /articles/?page=2&page_size=50

LimitOffsetPagination

SQL-style pagination:

# pagination.pyfrom rest_framework.pagination import LimitOffsetPagination class CustomLimitOffsetPagination(LimitOffsetPagination):    default_limit = 10    limit_query_param = 'limit'    offset_query_param = 'offset'    max_limit = 100 # views.pyclass ArticleViewSet(viewsets.ModelViewSet):    queryset = Article.objects.all()    serializer_class = ArticleSerializer    pagination_class = CustomLimitOffsetPagination # Usage:# GET /articles/?limit=20&offset=40  → Items 41-60

Response:

{    "count": 100,    "next": "http://api.example.com/articles/?limit=20&offset=60",    "previous": "http://api.example.com/articles/?limit=20&offset=20",    "results": [...]}

CursorPagination

Best for large datasets:

# pagination.pyfrom rest_framework.pagination import CursorPagination class ArticleCursorPagination(CursorPagination):    page_size = 20    ordering = '-created_at'  # Must have ordering    cursor_query_param = 'cursor' # views.pyclass ArticleViewSet(viewsets.ModelViewSet):    queryset = Article.objects.all()    serializer_class = ArticleSerializer    pagination_class = ArticleCursorPagination # Usage:# GET /articles/?cursor=cD0yMDIxLTA5LTAxKzAzJTNBMjQlM0E1NC4zMzY1NjY=

Benefits:

✅ Consistent pagination (no skipped/duplicated items)
✅ Better performance for large datasets
✅ No page numbers (prevents deep pagination issues)

Limitations:

❌ Can't jump to specific page
❌ Requires ordering field
❌ Can't get total count

Custom Pagination

Custom pagination class:

# pagination.pyfrom rest_framework.pagination import PageNumberPaginationfrom rest_framework.response import Response class CustomPagination(PageNumberPagination):    page_size = 10    page_size_query_param = 'page_size'    max_page_size = 100        def get_paginated_response(self, data):        return Response({            'pagination': {                'count': self.page.paginator.count,                'page': self.page.number,                'page_size': self.page.paginator.per_page,                'total_pages': self.page.paginator.num_pages,                'next': self.get_next_link(),                'previous': self.get_previous_link(),            },            'data': data        }) # Response:{    "pagination": {        "count": 100,        "page": 1,        "page_size": 10,        "total_pages": 10,        "next": "...",        "previous": null    },    "data": [...]}

Per-Action Pagination

Different pagination per action:

class ArticleViewSet(viewsets.ModelViewSet):    queryset = Article.objects.all()    serializer_class = ArticleSerializer        def get_pagination_class(self):        """Dynamic pagination"""        if self.action == 'list':            return PageNumberPagination        elif self.action == 'recent':            return None  # No pagination        return super().get_pagination_class()        @action(detail=False, pagination_class=None)    def featured(self, request):        """No pagination for featured"""        articles = self.get_queryset().filter(is_featured=True)[:5]        serializer = self.get_serializer(articles, many=True)        return Response(serializer.data)

Filtering

Basic Filtering

Query parameters:

class ArticleViewSet(viewsets.ModelViewSet):    queryset = Article.objects.all()    serializer_class = ArticleSerializer        def get_queryset(self):        queryset = super().get_queryset()                # Filter by status        status = self.request.query_params.get('status')        if status:            queryset = queryset.filter(status=status)                # Filter by author        author_id = self.request.query_params.get('author')        if author_id:            queryset = queryset.filter(author_id=author_id)                # Filter by date range        start_date = self.request.query_params.get('start_date')        end_date = self.request.query_params.get('end_date')        if start_date:            queryset = queryset.filter(created_at__gte=start_date)        if end_date:            queryset = queryset.filter(created_at__lte=end_date)                return queryset # Usage:# GET /articles/?status=published# GET /articles/?author=5# GET /articles/?start_date=2024-01-01&end_date=2024-12-31

DjangoFilterBackend

Install:

pip install django-filter

Setup:

# settings.pyINSTALLED_APPS = [    ...    'django_filters',] REST_FRAMEWORK = {    'DEFAULT_FILTER_BACKENDS': [        'django_filters.rest_framework.DjangoFilterBackend',    ]}

Simple filtering:

# views.pyfrom django_filters.rest_framework import DjangoFilterBackend class ArticleViewSet(viewsets.ModelViewSet):    queryset = Article.objects.all()    serializer_class = ArticleSerializer    filter_backends = [DjangoFilterBackend]    filterset_fields = ['status', 'author', 'is_featured'] # Usage:# GET /articles/?status=published# GET /articles/?author=5# GET /articles/?is_featured=true# GET /articles/?status=published&author=5

Custom FilterSet:

# filters.pyfrom django_filters import rest_framework as filtersfrom .models import Article class ArticleFilter(filters.FilterSet):    title = filters.CharFilter(lookup_expr='icontains')    status = filters.ChoiceFilter(choices=Article.STATUS_CHOICES)    author = filters.NumberFilter(field_name='author__id')    author_name = filters.CharFilter(field_name='author__username', lookup_expr='icontains')    created_after = filters.DateTimeFilter(field_name='created_at', lookup_expr='gte')    created_before = filters.DateTimeFilter(field_name='created_at', lookup_expr='lte')    min_views = filters.NumberFilter(field_name='views', lookup_expr='gte')        class Meta:        model = Article        fields = ['title', 'status', 'author', 'author_name',                   'created_after', 'created_before', 'min_views'] # views.pyclass ArticleViewSet(viewsets.ModelViewSet):    queryset = Article.objects.all()    serializer_class = ArticleSerializer    filter_backends = [DjangoFilterBackend]    filterset_class = ArticleFilter # Usage:# GET /articles/?title=django# GET /articles/?author_name=john# GET /articles/?created_after=2024-01-01&created_before=2024-12-31# GET /articles/?min_views=100

Searching

Setup:

# settings.pyREST_FRAMEWORK = {    'DEFAULT_FILTER_BACKENDS': [        'rest_framework.filters.SearchFilter',    ]}

Usage:

from rest_framework import filters class ArticleViewSet(viewsets.ModelViewSet):    queryset = Article.objects.all()    serializer_class = ArticleSerializer    filter_backends = [filters.SearchFilter]    search_fields = ['title', 'content', 'author__username'] # Usage:# GET /articles/?search=django# Searches in title, content, and author username

Search operators:

class ArticleViewSet(viewsets.ModelViewSet):    queryset = Article.objects.all()    serializer_class = ArticleSerializer    filter_backends = [filters.SearchFilter]    search_fields = [        '^title',            # Starts-with search        '=author__username', # Exact match        '@content',          # Full-text search (PostgreSQL)        'excerpt',           # Default: icontains    ] # Examples:# ^title: title__istartswith# =author__username: author__username__iexact# @content: Full-text search# excerpt: excerpt__icontains

Combined Filtering and Searching

class ArticleViewSet(viewsets.ModelViewSet):    queryset = Article.objects.all()    serializer_class = ArticleSerializer    filter_backends = [DjangoFilterBackend, filters.SearchFilter]    filterset_fields = ['status', 'author']    search_fields = ['title', 'content'] # Usage:# GET /articles/?status=published&search=django# Filters by status AND searches in title/content

Ordering

OrderingFilter

Setup:

from rest_framework import filters class ArticleViewSet(viewsets.ModelViewSet):    queryset = Article.objects.all()    serializer_class = ArticleSerializer    filter_backends = [filters.OrderingFilter]    ordering_fields = ['created_at', 'updated_at', 'title', 'views']    ordering = ['-created_at']  # Default ordering # Usage:# GET /articles/?ordering=title           → Ascending by title# GET /articles/?ordering=-title          → Descending by title# GET /articles/?ordering=-views          → Most viewed first# GET /articles/?ordering=created_at      → Oldest first# GET /articles/?ordering=-created_at     → Newest first# GET /articles/?ordering=author,-views   → By author, then views desc

Restrict ordering fields:

class ArticleViewSet(viewsets.ModelViewSet):    queryset = Article.objects.all()    serializer_class = ArticleSerializer    filter_backends = [filters.OrderingFilter]    ordering_fields = ['created_at', 'title']  # Only allow these    ordering = ['-created_at']

Custom ordering:

class ArticleViewSet(viewsets.ModelViewSet):    queryset = Article.objects.all()    serializer_class = ArticleSerializer    filter_backends = [filters.OrderingFilter]    ordering_fields = '__all__'  # Allow all fields    ordering = ['-created_at']        def get_queryset(self):        queryset = super().get_queryset()                # Custom ordering logic        ordering = self.request.query_params.get('ordering')        if ordering == 'popular':            # Custom: order by views in last 30 days            from django.utils import timezone            from datetime import timedelta            thirty_days_ago = timezone.now() - timedelta(days=30)            queryset = queryset.filter(                created_at__gte=thirty_days_ago            ).order_by('-views')                return queryset # Usage:# GET /articles/?ordering=popular

Combined Filtering, Searching, Ordering

from django_filters.rest_framework import DjangoFilterBackendfrom rest_framework import filters class ArticleViewSet(viewsets.ModelViewSet):    queryset = Article.objects.all()    serializer_class = ArticleSerializer    filter_backends = [DjangoFilterBackend, filters.SearchFilter, filters.OrderingFilter]        # Filtering    filterset_fields = ['status', 'author', 'is_featured']        # Searching    search_fields = ['title', 'content', 'author__username']        # Ordering    ordering_fields = ['created_at', 'title', 'views']    ordering = ['-created_at'] # Usage:# GET /articles/?status=published&search=django&ordering=-views# → Published articles containing "django", ordered by views descending

QuerySet Optimization

Optimize ForeignKey lookups:

class ArticleViewSet(viewsets.ModelViewSet):    # Bad: N+1 queries    queryset = Article.objects.all()        # Good: 1 query with JOIN    queryset = Article.objects.select_related('author').all()        serializer_class = ArticleSerializer # Serializer accesses author without additional queryclass ArticleSerializer(serializers.ModelSerializer):    author_name = serializers.CharField(source='author.username')        class Meta:        model = Article        fields = ['id', 'title', 'author_name']

Optimize ManyToMany and reverse ForeignKey:

class ArticleViewSet(viewsets.ModelViewSet):    # Bad: N+1 queries for tags and comments    queryset = Article.objects.all()        # Good: Prefetch related objects    queryset = Article.objects.prefetch_related('tags', 'comments').all()        serializer_class = ArticleSerializer # Serializerclass ArticleSerializer(serializers.ModelSerializer):    tags = TagSerializer(many=True, read_only=True)    comments_count = serializers.IntegerField(source='comments.count', read_only=True)        class Meta:        model = Article        fields = ['id', 'title', 'tags', 'comments_count']

Combined Optimization

class ArticleViewSet(viewsets.ModelViewSet):    queryset = Article.objects.select_related(        'author',          # ForeignKey        'category'         # ForeignKey    ).prefetch_related(        'tags',            # ManyToMany        'comments',        # Reverse ForeignKey        'comments__author' # Nested prefetch    ).all()        serializer_class = ArticleDetailSerializer

Defer and Only

Select specific fields:

class ArticleViewSet(viewsets.ModelViewSet):    serializer_class = ArticleSerializer        def get_queryset(self):        queryset = Article.objects.all()                if self.action == 'list':            # Only load necessary fields for list            queryset = queryset.only('id', 'title', 'excerpt', 'created_at')        elif self.action == 'retrieve':            # Load all fields except heavy ones            queryset = queryset.defer('content')  # Skip heavy content field                return queryset

Annotate for Computed Fields

Add computed fields at database level:

from django.db.models import Count, Avg, Q class ArticleViewSet(viewsets.ModelViewSet):    serializer_class = ArticleSerializer        def get_queryset(self):        return Article.objects.annotate(            comments_count=Count('comments'),            avg_rating=Avg('ratings__value'),            published_comments=Count('comments', filter=Q(comments__is_approved=True))        ).select_related('author') # Serializerclass ArticleSerializer(serializers.ModelSerializer):    comments_count = serializers.IntegerField(read_only=True)    avg_rating = serializers.FloatField(read_only=True)    published_comments = serializers.IntegerField(read_only=True)        class Meta:        model = Article        fields = ['id', 'title', 'comments_count', 'avg_rating', 'published_comments']

Dynamic Serializers

Per-Action Serializers

class ArticleViewSet(viewsets.ModelViewSet):    queryset = Article.objects.all()        # Map actions to serializers    serializer_classes = {        'list': ArticleListSerializer,        'retrieve': ArticleDetailSerializer,        'create': ArticleCreateSerializer,        'update': ArticleUpdateSerializer,    }        def get_serializer_class(self):        return self.serializer_classes.get(self.action, ArticleSerializer)

Request-Based Serializers

class ArticleViewSet(viewsets.ModelViewSet):    queryset = Article.objects.all()        def get_serializer_class(self):        # Different serializer based on user role        if self.request.user.is_staff:            return ArticleAdminSerializer        elif self.request.user.is_authenticated:            return ArticleAuthenticatedSerializer        return ArticlePublicSerializer

Query Parameter Serializers

class ArticleViewSet(viewsets.ModelViewSet):    queryset = Article.objects.all()        def get_serializer_class(self):        # ?detail=full → Full serializer        # ?detail=minimal → Minimal serializer        detail = self.request.query_params.get('detail', 'normal')                if detail == 'full':            return ArticleFullSerializer        elif detail == 'minimal':            return ArticleMinimalSerializer        return ArticleSerializer

Per-Action Permissions

from rest_framework.permissions import IsAuthenticated, IsAdminUser, AllowAny class ArticleViewSet(viewsets.ModelViewSet):    queryset = Article.objects.all()    serializer_class = ArticleSerializer        # Map actions to permission classes    permission_classes_by_action = {        'list': [AllowAny],        'retrieve': [AllowAny],        'create': [IsAuthenticated],        'update': [IsAuthenticated, IsOwnerOrAdmin],        'partial_update': [IsAuthenticated, IsOwnerOrAdmin],        'destroy': [IsAdminUser],    }        def get_permissions(self):        try:            return [permission() for permission in self.permission_classes_by_action[self.action]]        except KeyError:            return [permission() for permission in self.permission_classes]

Testing ViewSets

Basic Tests

# tests.pyfrom rest_framework.test import APITestCasefrom rest_framework import statusfrom django.contrib.auth.models import Userfrom .models import Article class ArticleViewSetTest(APITestCase):    def setUp(self):        self.user = User.objects.create_user('testuser', 'test@test.com', 'password')        self.article = Article.objects.create(            title='Test Article',            content='Test content',            author=self.user        )        def test_list_articles(self):        """Test GET /articles/"""        response = self.client.get('/api/articles/')        self.assertEqual(response.status_code, status.HTTP_200_OK)        self.assertEqual(len(response.data['results']), 1)        def test_create_article(self):        """Test POST /articles/"""        self.client.force_authenticate(user=self.user)        data = {            'title': 'New Article',            'content': 'New content',            'status': 'draft'        }        response = self.client.post('/api/articles/', data)        self.assertEqual(response.status_code, status.HTTP_201_CREATED)        self.assertEqual(Article.objects.count(), 2)        def test_retrieve_article(self):        """Test GET /articles/{id}/"""        response = self.client.get(f'/api/articles/{self.article.id}/')        self.assertEqual(response.status_code, status.HTTP_200_OK)        self.assertEqual(response.data['title'], 'Test Article')        def test_update_article(self):        """Test PUT /articles/{id}/"""        self.client.force_authenticate(user=self.user)        data = {'title': 'Updated Title', 'content': 'Updated content'}        response = self.client.put(f'/api/articles/{self.article.id}/', data)        self.assertEqual(response.status_code, status.HTTP_200_OK)        self.article.refresh_from_db()        self.assertEqual(self.article.title, 'Updated Title')        def test_delete_article(self):        """Test DELETE /articles/{id}/"""        self.client.force_authenticate(user=self.user)        response = self.client.delete(f'/api/articles/{self.article.id}/')        self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)        self.assertEqual(Article.objects.count(), 0)        def test_custom_action(self):        """Test POST /articles/{id}/publish/"""        self.client.force_authenticate(user=self.user)        response = self.client.post(f'/api/articles/{self.article.id}/publish/')        self.assertEqual(response.status_code, status.HTTP_200_OK)        self.article.refresh_from_db()        self.assertEqual(self.article.status, 'published')

Complete Advanced Example

# models.pyfrom django.db import modelsfrom django.contrib.auth.models import User class Article(models.Model):    STATUS_CHOICES = [        ('draft', 'Draft'),        ('published', 'Published'),        ('archived', 'Archived'),    ]        title = models.CharField(max_length=200)    slug = models.SlugField(unique=True)    content = models.TextField()    excerpt = models.TextField(blank=True)    status = models.CharField(max_length=20, choices=STATUS_CHOICES, default='draft')    author = models.ForeignKey(User, on_delete=models.CASCADE, related_name='articles')    tags = models.ManyToManyField('Tag', related_name='articles')    created_at = models.DateTimeField(auto_now_add=True)    updated_at = models.DateTimeField(auto_now=True)    views = models.IntegerField(default=0)        class Meta:        ordering = ['-created_at']        indexes = [            models.Index(fields=['status', '-created_at']),            models.Index(fields=['author', '-created_at']),        ] # serializers.pyclass ArticleListSerializer(serializers.ModelSerializer):    author_name = serializers.CharField(source='author.username', read_only=True)    tags_count = serializers.IntegerField(read_only=True)    comments_count = serializers.IntegerField(read_only=True)        class Meta:        model = Article        fields = ['id', 'title', 'slug', 'excerpt', 'author_name',                   'status', 'created_at', 'views', 'tags_count', 'comments_count'] # views.pyfrom django.db.models import Count, Qfrom django_filters.rest_framework import DjangoFilterBackendfrom rest_framework import viewsets, filters class ArticleViewSet(viewsets.ModelViewSet):    permission_classes = [IsAuthenticatedOrReadOnly]    filter_backends = [DjangoFilterBackend, filters.SearchFilter, filters.OrderingFilter]    filterset_class = ArticleFilter    search_fields = ['title', 'content', 'author__username']    ordering_fields = ['created_at', 'views', 'title']    ordering = ['-created_at']    pagination_class = CustomPageNumberPagination    lookup_field = 'slug'        def get_queryset(self):        queryset = Article.objects.select_related('author').prefetch_related('tags').annotate(            tags_count=Count('tags'),            comments_count=Count('comments', filter=Q(comments__is_approved=True))        )                if self.action == 'list':            if not self.request.user.is_authenticated:                queryset = queryset.filter(status='published')                return queryset        def get_serializer_class(self):        if self.action == 'list':            return ArticleListSerializer        elif self.action == 'retrieve':            return ArticleDetailSerializer        return ArticleCreateUpdateSerializer        def get_permissions(self):        if self.action in ['create', 'update', 'partial_update', 'destroy']:            permission_classes = [IsAuthenticated, IsOwnerOrAdmin]        else:            permission_classes = [AllowAny]        return [permission() for permission in permission_classes]        @action(detail=False, methods=['get'])    def trending(self, request):        from django.utils import timezone        from datetime import timedelta                week_ago = timezone.now() - timedelta(days=7)        articles = self.get_queryset().filter(            created_at__gte=week_ago,            status='published'        ).order_by('-views')[:10]                serializer = self.get_serializer(articles, many=True)        return Response(serializer.data)

Tóm Tắt Bài 6.3

Trong Bài 6.3 này, bạn đã học:

✅ Nested Routes:

Manual nested routes
drf-nested-routers package
Multi-level nesting

✅ Pagination:

PageNumberPagination, LimitOffsetPagination, CursorPagination
Custom pagination classes
Per-action pagination

✅ Filtering:

Basic filtering with query params
DjangoFilterBackend
Custom FilterSet classes

✅ Searching & Ordering:

SearchFilter with operators
OrderingFilter
Combined filtering, searching, ordering

✅ QuerySet Optimization:

select_related, prefetch_related
defer, only
Annotate for computed fields

✅ Dynamic Configuration:

Per-action serializers
Request-based serializers
Per-action permissions

✅ Testing:

APITestCase for ViewSet testing
Testing CRUD operations
Testing custom actions

Bài Tập Thực Hành

Bài 1: Blog API với Advanced Features

Xây dựng complete blog API với:

Articles với nested Comments
Pagination (page size 20)
Filtering (status, author, tags)
Searching (title, content)
Ordering (created_at, views, title)
Custom actions (publish, archive, feature)
Optimized querysets

Bài 2: E-commerce API

Xây dựng API cho:

Products với nested Reviews
Categories với nested Products
Filtering (price range, category, brand)
Searching (name, description)
Ordering (price, popularity, newest)
Custom actions (discount, out_of_stock, trending)

Bài 3: Testing Suite

Viết comprehensive tests cho Article ViewSet:

Test all CRUD operations
Test custom actions
Test permissions
Test filtering, searching, ordering
Test nested routes

Navigation:

← Bài 6.2: ViewSets & Routers
Bài 6.3: Advanced Patterns (current)
Bài 7: Permissions & Authentication →

#nested-routes

Generic Views & ViewSets - Phần 3 - Advanced Patterns