Django Patterns

1---2name: django-patterns3description: Django architecture patterns, REST API design with DRF, ORM best practices, caching, signals, middleware, and production-grade Django apps.4origin: ECC5---6 7# Django Development Patterns8 9Production-grade Django architecture patterns for scalable, maintainable applications.10 11## When to Activate12 13- Building Django web applications14- Designing Django REST Framework APIs15- Working with Django ORM and models16- Setting up Django project structure17- Implementing caching, signals, middleware18 19## Project Structure20 21### Recommended Layout22 23```24myproject/25├── config/26│   ├── __init__.py27│   ├── settings/28│   │   ├── __init__.py29│   │   ├── base.py          # Base settings30│   │   ├── development.py   # Dev settings31│   │   ├── production.py    # Production settings32│   │   └── test.py          # Test settings33│   ├── urls.py34│   ├── wsgi.py35│   └── asgi.py36├── manage.py37└── apps/38    ├── __init__.py39    ├── users/40    │   ├── __init__.py41    │   ├── models.py42    │   ├── views.py43    │   ├── serializers.py44    │   ├── urls.py45    │   ├── permissions.py46    │   ├── filters.py47    │   ├── services.py48    │   └── tests/49    └── products/50        └── ...51```52 53### Split Settings Pattern54 55```python56# config/settings/base.py57from pathlib import Path58 59BASE_DIR = Path(__file__).resolve().parent.parent.parent60 61SECRET_KEY = env('DJANGO_SECRET_KEY')62DEBUG = False63ALLOWED_HOSTS = []64 65INSTALLED_APPS = [66    'django.contrib.admin',67    'django.contrib.auth',68    'django.contrib.contenttypes',69    'django.contrib.sessions',70    'django.contrib.messages',71    'django.contrib.staticfiles',72    'rest_framework',73    'rest_framework.authtoken',74    'corsheaders',75    # Local apps76    'apps.users',77    'apps.products',78]79 80MIDDLEWARE = [81    'django.middleware.security.SecurityMiddleware',82    'whitenoise.middleware.WhiteNoiseMiddleware',83    'django.contrib.sessions.middleware.SessionMiddleware',84    'corsheaders.middleware.CorsMiddleware',85    'django.middleware.common.CommonMiddleware',86    'django.middleware.csrf.CsrfViewMiddleware',87    'django.contrib.auth.middleware.AuthenticationMiddleware',88    'django.contrib.messages.middleware.MessageMiddleware',89    'django.middleware.clickjacking.XFrameOptionsMiddleware',90]91 92ROOT_URLCONF = 'config.urls'93WSGI_APPLICATION = 'config.wsgi.application'94 95DATABASES = {96    'default': {97        'ENGINE': 'django.db.backends.postgresql',98        'NAME': env('DB_NAME'),99        'USER': env('DB_USER'),100        'PASSWORD': env('DB_PASSWORD'),101        'HOST': env('DB_HOST'),102        'PORT': env('DB_PORT', default='5432'),103    }104}105 106# config/settings/development.py107from .base import *108 109DEBUG = True110ALLOWED_HOSTS = ['localhost', '127.0.0.1']111 112DATABASES['default']['NAME'] = 'myproject_dev'113 114INSTALLED_APPS += ['debug_toolbar']115 116MIDDLEWARE += ['debug_toolbar.middleware.DebugToolbarMiddleware']117 118EMAIL_BACKEND = 'django.core.mail.backends.console.EmailBackend'119 120# config/settings/production.py121from .base import *122 123DEBUG = False124ALLOWED_HOSTS = env.list('ALLOWED_HOSTS')125SECURE_SSL_REDIRECT = True126SESSION_COOKIE_SECURE = True127CSRF_COOKIE_SECURE = True128SECURE_HSTS_SECONDS = 31536000129SECURE_HSTS_INCLUDE_SUBDOMAINS = True130SECURE_HSTS_PRELOAD = True131 132# Logging133LOGGING = {134    'version': 1,135    'disable_existing_loggers': False,136    'handlers': {137        'file': {138            'level': 'WARNING',139            'class': 'logging.FileHandler',140            'filename': '/var/log/django/django.log',141        },142    },143    'loggers': {144        'django': {145            'handlers': ['file'],146            'level': 'WARNING',147            'propagate': True,148        },149    },150}151```152 153## Model Design Patterns154 155### Model Best Practices156 157```python158from django.db import models159from django.contrib.auth.models import AbstractUser160from django.core.validators import MinValueValidator, MaxValueValidator161 162class User(AbstractUser):163    """Custom user model extending AbstractUser."""164    email = models.EmailField(unique=True)165    phone = models.CharField(max_length=20, blank=True)166    birth_date = models.DateField(null=True, blank=True)167 168    USERNAME_FIELD = 'email'169    REQUIRED_FIELDS = ['username']170 171    class Meta:172        db_table = 'users'173        verbose_name = 'user'174        verbose_name_plural = 'users'175        ordering = ['-date_joined']176 177    def __str__(self):178        return self.email179 180    def get_full_name(self):181        return f"{self.first_name} {self.last_name}".strip()182 183class Product(models.Model):184    """Product model with proper field configuration."""185    name = models.CharField(max_length=200)186    slug = models.SlugField(unique=True, max_length=250)187    description = models.TextField(blank=True)188    price = models.DecimalField(189        max_digits=10,190        decimal_places=2,191        validators=[MinValueValidator(0)]192    )193    stock = models.PositiveIntegerField(default=0)194    is_active = models.BooleanField(default=True)195    category = models.ForeignKey(196        'Category',197        on_delete=models.CASCADE,198        related_name='products'199    )200    tags = models.ManyToManyField('Tag', blank=True, related_name='products')201    created_at = models.DateTimeField(auto_now_add=True)202    updated_at = models.DateTimeField(auto_now=True)203 204    class Meta:205        db_table = 'products'206        ordering = ['-created_at']207        indexes = [208            models.Index(fields=['slug']),209            models.Index(fields=['-created_at']),210            models.Index(fields=['category', 'is_active']),211        ]212        constraints = [213            models.CheckConstraint(214                check=models.Q(price__gte=0),215                name='price_non_negative'216            )217        ]218 219    def __str__(self):220        return self.name221 222    def save(self, *args, **kwargs):223        if not self.slug:224            self.slug = slugify(self.name)225        super().save(*args, **kwargs)226```227 228### QuerySet Best Practices229 230```python231from django.db import models232 233class ProductQuerySet(models.QuerySet):234    """Custom QuerySet for Product model."""235 236    def active(self):237        """Return only active products."""238        return self.filter(is_active=True)239 240    def with_category(self):241        """Select related category to avoid N+1 queries."""242        return self.select_related('category')243 244    def with_tags(self):245        """Prefetch tags for many-to-many relationship."""246        return self.prefetch_related('tags')247 248    def in_stock(self):249        """Return products with stock > 0."""250        return self.filter(stock__gt=0)251 252    def search(self, query):253        """Search products by name or description."""254        return self.filter(255            models.Q(name__icontains=query) |256            models.Q(description__icontains=query)257        )258 259class Product(models.Model):260    # ... fields ...261 262    objects = ProductQuerySet.as_manager()  # Use custom QuerySet263 264# Usage265Product.objects.active().with_category().in_stock()266```267 268### Manager Methods269 270```python271class ProductManager(models.Manager):272    """Custom manager for complex queries."""273 274    def get_or_none(self, **kwargs):275        """Return object or None instead of DoesNotExist."""276        try:277            return self.get(**kwargs)278        except self.model.DoesNotExist:279            return None280 281    def create_with_tags(self, name, price, tag_names):282        """Create product with associated tags."""283        product = self.create(name=name, price=price)284        tags = [Tag.objects.get_or_create(name=name)[0] for name in tag_names]285        product.tags.set(tags)286        return product287 288    def bulk_update_stock(self, product_ids, quantity):289        """Bulk update stock for multiple products."""290        return self.filter(id__in=product_ids).update(stock=quantity)291 292# In model293class Product(models.Model):294    # ... fields ...295    custom = ProductManager()296```297 298## Django REST Framework Patterns299 300### Serializer Patterns301 302```python303from rest_framework import serializers304from django.contrib.auth.password_validation import validate_password305from .models import Product, User306 307class ProductSerializer(serializers.ModelSerializer):308    """Serializer for Product model."""309 310    category_name = serializers.CharField(source='category.name', read_only=True)311    average_rating = serializers.FloatField(read_only=True)312    discount_price = serializers.SerializerMethodField()313 314    class Meta:315        model = Product316        fields = [317            'id', 'name', 'slug', 'description', 'price',318            'discount_price', 'stock', 'category_name',319            'average_rating', 'created_at'320        ]321        read_only_fields = ['id', 'slug', 'created_at']322 323    def get_discount_price(self, obj):324        """Calculate discount price if applicable."""325        if hasattr(obj, 'discount') and obj.discount:326            return obj.price * (1 - obj.discount.percent / 100)327        return obj.price328 329    def validate_price(self, value):330        """Ensure price is non-negative."""331        if value < 0:332            raise serializers.ValidationError("Price cannot be negative.")333        return value334 335class ProductCreateSerializer(serializers.ModelSerializer):336    """Serializer for creating products."""337 338    class Meta:339        model = Product340        fields = ['name', 'description', 'price', 'stock', 'category']341 342    def validate(self, data):343        """Custom validation for multiple fields."""344        if data['price'] > 10000 and data['stock'] > 100:345            raise serializers.ValidationError(346                "Cannot have high-value products with large stock."347            )348        return data349 350class UserRegistrationSerializer(serializers.ModelSerializer):351    """Serializer for user registration."""352 353    password = serializers.CharField(354        write_only=True,355        required=True,356        validators=[validate_password],357        style={'input_type': 'password'}358    )359    password_confirm = serializers.CharField(write_only=True, style={'input_type': 'password'})360 361    class Meta:362        model = User363        fields = ['email', 'username', 'password', 'password_confirm']364 365    def validate(self, data):366        """Validate passwords match."""367        if data['password'] != data['password_confirm']:368            raise serializers.ValidationError({369                "password_confirm": "Password fields didn't match."370            })371        return data372 373    def create(self, validated_data):374        """Create user with hashed password."""375        validated_data.pop('password_confirm')376        password = validated_data.pop('password')377        user = User.objects.create(**validated_data)378        user.set_password(password)379        user.save()380        return user381```382 383### ViewSet Patterns384 385```python386from rest_framework import viewsets, status, filters387from rest_framework.decorators import action388from rest_framework.response import Response389from rest_framework.permissions import IsAuthenticated, IsAdminUser390from django_filters.rest_framework import DjangoFilterBackend391from .models import Product392from .serializers import ProductSerializer, ProductCreateSerializer393from .permissions import IsOwnerOrReadOnly394from .filters import ProductFilter395from .services import ProductService396 397class ProductViewSet(viewsets.ModelViewSet):398    """ViewSet for Product model."""399 400    queryset = Product.objects.select_related('category').prefetch_related('tags')401    permission_classes = [IsAuthenticated, IsOwnerOrReadOnly]402    filter_backends = [DjangoFilterBackend, filters.SearchFilter, filters.OrderingFilter]403    filterset_class = ProductFilter404    search_fields = ['name', 'description']405    ordering_fields = ['price', 'created_at', 'name']406    ordering = ['-created_at']407 408    def get_serializer_class(self):409        """Return appropriate serializer based on action."""410        if self.action == 'create':411            return ProductCreateSerializer412        return ProductSerializer413 414    def perform_create(self, serializer):415        """Save with user context."""416        serializer.save(created_by=self.request.user)417 418    @action(detail=False, methods=['get'])419    def featured(self, request):420        """Return featured products."""421        featured = self.queryset.filter(is_featured=True)[:10]422        serializer = self.get_serializer(featured, many=True)423        return Response(serializer.data)424 425    @action(detail=True, methods=['post'])426    def purchase(self, request, pk=None):427        """Purchase a product."""428        product = self.get_object()429        service = ProductService()430        result = service.purchase(product, request.user)431        return Response(result, status=status.HTTP_201_CREATED)432 433    @action(detail=False, methods=['get'], permission_classes=[IsAuthenticated])434    def my_products(self, request):435        """Return products created by current user."""436        products = self.queryset.filter(created_by=request.user)437        page = self.paginate_queryset(products)438        serializer = self.get_serializer(page, many=True)439        return self.get_paginated_response(serializer.data)440```441 442### Custom Actions443 444```python445from rest_framework.decorators import api_view, permission_classes446from rest_framework.permissions import IsAuthenticated447from rest_framework.response import Response448 449@api_view(['POST'])450@permission_classes([IsAuthenticated])451def add_to_cart(request):452    """Add product to user cart."""453    product_id = request.data.get('product_id')454    quantity = request.data.get('quantity', 1)455 456    try:457        product = Product.objects.get(id=product_id)458    except Product.DoesNotExist:459        return Response(460            {'error': 'Product not found'},461            status=status.HTTP_404_NOT_FOUND462        )463 464    cart, _ = Cart.objects.get_or_create(user=request.user)465    CartItem.objects.create(466        cart=cart,467        product=product,468        quantity=quantity469    )470 471    return Response({'message': 'Added to cart'}, status=status.HTTP_201_CREATED)472```473 474## Service Layer Pattern475 476```python477# apps/orders/services.py478from typing import Optional479from django.db import transaction480from .models import Order, OrderItem481 482class OrderService:483    """Service layer for order-related business logic."""484 485    @staticmethod486    @transaction.atomic487    def create_order(user, cart: Cart) -> Order:488        """Create order from cart."""489        order = Order.objects.create(490            user=user,491            total_price=cart.total_price492        )493 494        for item in cart.items.all():495            OrderItem.objects.create(496                order=order,497                product=item.product,498                quantity=item.quantity,499                price=item.product.price500            )501 502        # Clear cart503        cart.items.all().delete()504 505        return order506 507    @staticmethod508    def process_payment(order: Order, payment_data: dict) -> bool:509        """Process payment for order."""510        # Integration with payment gateway511        payment = PaymentGateway.charge(512            amount=order.total_price,513            token=payment_data['token']514        )515 516        if payment.success:517            order.status = Order.Status.PAID518            order.save()519            # Send confirmation email520            OrderService.send_confirmation_email(order)521            return True522 523        return False524 525    @staticmethod526    def send_confirmation_email(order: Order):527        """Send order confirmation email."""528        # Email sending logic529        pass530```531 532## Caching Strategies533 534### View-Level Caching535 536```python537from django.views.decorators.cache import cache_page538from django.utils.decorators import method_decorator539 540@method_decorator(cache_page(60 * 15), name='dispatch')  # 15 minutes541class ProductListView(generic.ListView):542    model = Product543    template_name = 'products/list.html'544    context_object_name = 'products'545```546 547### Template Fragment Caching548 549```django550{% load cache %}551{% cache 500 sidebar %}552    ... expensive sidebar content ...553{% endcache %}554```555 556### Low-Level Caching557 558```python559from django.core.cache import cache560 561def get_featured_products():562    """Get featured products with caching."""563    cache_key = 'featured_products'564    products = cache.get(cache_key)565 566    if products is None:567        products = list(Product.objects.filter(is_featured=True))568        cache.set(cache_key, products, timeout=60 * 15)  # 15 minutes569 570    return products571```572 573### QuerySet Caching574 575```python576from django.core.cache import cache577 578def get_popular_categories():579    cache_key = 'popular_categories'580    categories = cache.get(cache_key)581 582    if categories is None:583        categories = list(Category.objects.annotate(584            product_count=Count('products')585        ).filter(product_count__gt=10).order_by('-product_count')[:20])586        cache.set(cache_key, categories, timeout=60 * 60)  # 1 hour587 588    return categories589```590 591## Signals592 593### Signal Patterns594 595```python596# apps/users/signals.py597from django.db.models.signals import post_save598from django.dispatch import receiver599from django.contrib.auth import get_user_model600from .models import Profile601 602User = get_user_model()603 604@receiver(post_save, sender=User)605def create_user_profile(sender, instance, created, **kwargs):606    """Create profile when user is created."""607    if created:608        Profile.objects.create(user=instance)609 610@receiver(post_save, sender=User)611def save_user_profile(sender, instance, **kwargs):612    """Save profile when user is saved."""613    instance.profile.save()614 615# apps/users/apps.py616from django.apps import AppConfig617 618class UsersConfig(AppConfig):619    default_auto_field = 'django.db.models.BigAutoField'620    name = 'apps.users'621 622    def ready(self):623        """Import signals when app is ready."""624        import apps.users.signals625```626 627## Middleware628 629### Custom Middleware630 631```python632# middleware/active_user_middleware.py633import time634from django.utils.deprecation import MiddlewareMixin635 636class ActiveUserMiddleware(MiddlewareMixin):637    """Middleware to track active users."""638 639    def process_request(self, request):640        """Process incoming request."""641        if request.user.is_authenticated:642            # Update last active time643            request.user.last_active = timezone.now()644            request.user.save(update_fields=['last_active'])645 646class RequestLoggingMiddleware(MiddlewareMixin):647    """Middleware for logging requests."""648 649    def process_request(self, request):650        """Log request start time."""651        request.start_time = time.time()652 653    def process_response(self, request, response):654        """Log request duration."""655        if hasattr(request, 'start_time'):656            duration = time.time() - request.start_time657            logger.info(f'{request.method} {request.path} - {response.status_code} - {duration:.3f}s')658        return response659```660 661## Performance Optimization662 663### N+1 Query Prevention664 665```python666# Bad - N+1 queries667products = Product.objects.all()668for product in products:669    print(product.category.name)  # Separate query for each product670 671# Good - Single query with select_related672products = Product.objects.select_related('category').all()673for product in products:674    print(product.category.name)675 676# Good - Prefetch for many-to-many677products = Product.objects.prefetch_related('tags').all()678for product in products:679    for tag in product.tags.all():680        print(tag.name)681```682 683### Database Indexing684 685```python686class Product(models.Model):687    name = models.CharField(max_length=200, db_index=True)688    slug = models.SlugField(unique=True)689    category = models.ForeignKey('Category', on_delete=models.CASCADE)690    created_at = models.DateTimeField(auto_now_add=True)691 692    class Meta:693        indexes = [694            models.Index(fields=['name']),695            models.Index(fields=['-created_at']),696            models.Index(fields=['category', 'created_at']),697        ]698```699 700### Bulk Operations701 702```python703# Bulk create704Product.objects.bulk_create([705    Product(name=f'Product {i}', price=10.00)706    for i in range(1000)707])708 709# Bulk update710products = Product.objects.all()[:100]711for product in products:712    product.is_active = True713Product.objects.bulk_update(products, ['is_active'])714 715# Bulk delete716Product.objects.filter(stock=0).delete()717```718 719## Quick Reference720 721| Pattern | Description |722|---------|-------------|723| Split settings | Separate dev/prod/test settings |724| Custom QuerySet | Reusable query methods |725| Service Layer | Business logic separation |726| ViewSet | REST API endpoints |727| Serializer validation | Request/response transformation |728| select_related | Foreign key optimization |729| prefetch_related | Many-to-many optimization |730| Cache first | Cache expensive operations |731| Signals | Event-driven actions |732| Middleware | Request/response processing |733 734Remember: Django provides many shortcuts, but for production applications, structure and organization matter more than concise code. Build for maintainability.