patrones-django

Patrones de Desarrollo Django

Patrones de arquitectura Django de nivel de producción para aplicaciones escalables y mantenibles.

Cuándo Activar

• Construir aplicaciones web Django
• Diseñar APIs Django REST Framework
• Trabajar con ORM y modelos de Django
• Configurar la estructura de proyectos Django
• Implementar caching, señales, middleware

Estructura del Proyecto

Diseño Recomendado

myproject/
├── config/
│   ├── __init__.py
│   ├── settings/
│   │   ├── __init__.py
│   │   ├── base.py          # Configuración base
│   │   ├── development.py   # Configuración de desarrollo
│   │   ├── production.py    # Configuración de producción
│   │   └── test.py          # Configuración de pruebas
│   ├── urls.py
│   ├── wsgi.py
│   └── asgi.py
├── manage.py
└── apps/
    ├── __init__.py
    ├── users/
    │   ├── __init__.py
    │   ├── models.py
    │   ├── views.py
    │   ├── serializers.py
    │   ├── urls.py
    │   ├── permissions.py
    │   ├── filters.py
    │   ├── services.py
    │   └── tests/
    └── products/
        └── ...

Patrón de Configuraciones Divididas

# config/settings/base.py
from pathlib import Path

BASE_DIR = Path(__file__).resolve().parent.parent.parent

SECRET_KEY = env('DJANGO_SECRET_KEY')
DEBUG = False
ALLOWED_HOSTS = []

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'rest_framework',
    'rest_framework.authtoken',
    'corsheaders',
    # Apps locales
    'apps.users',
    'apps.products',
]

MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'whitenoise.middleware.WhiteNoiseMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'corsheaders.middleware.CorsMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
]

ROOT_URLCONF = 'config.urls'
WSGI_APPLICATION = 'config.wsgi.application'

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': env('DB_NAME'),
        'USER': env('DB_USER'),
        'PASSWORD': env('DB_PASSWORD'),
        'HOST': env('DB_HOST'),
        'PORT': env('DB_PORT', default='5432'),
    }
}

# config/settings/development.py
from .base import *

DEBUG = True
ALLOWED_HOSTS = ['localhost', '127.0.0.1']

DATABASES['default']['NAME'] = 'myproject_dev'

INSTALLED_APPS += ['debug_toolbar']

MIDDLEWARE += ['debug_toolbar.middleware.DebugToolbarMiddleware']

EMAIL_BACKEND = 'django.core.mail.backends.console.EmailBackend'

# config/settings/production.py
from .base import *

DEBUG = False
ALLOWED_HOSTS = env.list('ALLOWED_HOSTS')
SECURE_SSL_REDIRECT = True
SESSION_COOKIE_SECURE = True
CSRF_COOKIE_SECURE = True
SECURE_HSTS_SECONDS = 31536000
SECURE_HSTS_INCLUDE_SUBDOMAINS = True
SECURE_HSTS_PRELOAD = True

# Logging
LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'handlers': {
        'file': {
            'level': 'WARNING',
            'class': 'logging.FileHandler',
            'filename': '/var/log/django/django.log',
        },
    },
    'loggers': {
        'django': {
            'handlers': ['file'],
            'level': 'WARNING',
            'propagate': True,
        },
    },
}

Patrones de Diseño de Modelos

Mejores Prácticas para Modelos

from django.db import models
from django.contrib.auth.models import AbstractUser
from django.core.validators import MinValueValidator, MaxValueValidator

class User(AbstractUser):
    """Modelo de usuario personalizado que extiende AbstractUser."""
    email = models.EmailField(unique=True)
    phone = models.CharField(max_length=20, blank=True)
    birth_date = models.DateField(null=True, blank=True)

    USERNAME_FIELD = 'email'
    REQUIRED_FIELDS = ['username']

    class Meta:
        db_table = 'users'
        verbose_name = 'usuario'
        verbose_name_plural = 'usuarios'
        ordering = ['-date_joined']

    def __str__(self):
        return self.email

    def get_full_name(self):
        return f"{self.first_name} {self.last_name}".strip()

class Product(models.Model):
    """Modelo de producto con configuración de campos adecuada."""
    name = models.CharField(max_length=200)
    slug = models.SlugField(unique=True, max_length=250)
    description = models.TextField(blank=True)
    price = models.DecimalField(
        max_digits=10,
        decimal_places=2,
        validators=[MinValueValidator(0)]
    )
    stock = models.PositiveIntegerField(default=0)
    is_active = models.BooleanField(default=True)
    category = models.ForeignKey(
        'Category',
        on_delete=models.CASCADE,
        related_name='products'
    )
    tags = models.ManyToManyField('Tag', blank=True, related_name='products')
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)

    class Meta:
        db_table = 'products'
        ordering = ['-created_at']
        indexes = [
            models.Index(fields=['slug']),
            models.Index(fields=['-created_at']),
            models.Index(fields=['category', 'is_active']),
        ]
        constraints = [
            models.CheckConstraint(
                check=models.Q(price__gte=0),
                name='price_non_negative'
            )
        ]

    def __str__(self):
        return self.name

    def save(self, *args, **kwargs):
        if not self.slug:
            self.slug = slugify(self.name)
        super().save(*args, **kwargs)

Mejores Prácticas para QuerySets

from django.db import models

class ProductQuerySet(models.QuerySet):
    """QuerySet personalizado para el modelo Product."""

    def active(self):
        """Devuelve solo los productos activos."""
        return self.filter(is_active=True)

    def with_category(self):
        """Selecciona la categoría relacionada para evitar consultas N+1."""
        return self.select_related('category')

    def with_tags(self):
        """Precarga las etiquetas para relaciones muchos a muchos."""
        return self.prefetch_related('tags')

    def in_stock(self):
        """Devuelve productos con stock > 0."""
        return self.filter(stock__gt=0)

    def search(self, query):
        """Busca productos por nombre o descripción."""
        return self.filter(
            models.Q(name__icontains=query) |
            models.Q(description__icontains=query)
        )

class Product(models.Model):
    # ... campos ...

    objects = ProductQuerySet.as_manager()  # Usa QuerySet personalizado

# Uso
Product.objects.active().with_category().in_stock()

Métodos del Manager

class ProductManager(models.Manager):
    """Manager personalizado para consultas complejas."""

    def get_or_none(self, **kwargs):
        """Devuelve el objeto o None en lugar de DoesNotExist."""
        try:
            return self.get(**kwargs)
        except self.model.DoesNotExist:
            return None

    def create_with_tags(self, name, price, tag_names):
        """Crea un producto con etiquetas asociadas."""
        product = self.create(name=name, price=price)
        tags = [Tag.objects.get_or_create(name=name)[0] for name in tag_names]
        product.tags.set(tags)
        return product

    def bulk_update_stock(self, product_ids, quantity):
        """Actualiza el stock de múltiples productos en lote."""
        return self.filter(id__in=product_ids).update(stock=quantity)

# En el modelo
class Product(models.Model):
    # ... campos ...
    custom = ProductManager()

Patrones de Django REST Framework

Patrones de Serializadores

from rest_framework import serializers
from django.contrib.auth.password_validation import validate_password
from .models import Product, User

class ProductSerializer(serializers.ModelSerializer):
    """Serializador para el modelo Product."""

    category_name = serializers.CharField(source='category.name', read_only=True)
    average_rating = serializers.FloatField(read_only=True)
    discount_price = serializers.SerializerMethodField()

    class Meta:
        model = Product
        fields = [
            'id', 'name', 'slug', 'description', 'price',
            'discount_price', 'stock', 'category_name',
            'average_rating', 'created_at'
        ]
        read_only_fields = ['id', 'slug', 'created_at']

    def get_discount_price(self, obj):
        """Calcula el precio con descuento si aplica."""
        if hasattr(obj, 'discount') and obj.discount:
            return obj.price * (1 - obj.discount.percent / 100)
        return obj.price

    def validate_price(self, value):
        """Asegura que el precio no sea negativo."""
        if value < 0:
            raise serializers.ValidationError("El precio no puede ser negativo.")
        return value

class ProductCreateSerializer(serializers.ModelSerializer):
    """Serializador para crear productos."""

    class Meta:
        model = Product
        fields = ['name', 'description', 'price', 'stock', 'category']

    def validate(self, data):
        """Validación personalizada para múltiples campos."""
        if data['price'] > 10000 and data['stock'] > 100:
            raise serializers.ValidationError(
                "No se pueden tener productos de alto valor con gran stock."
            )
        return data

class UserRegistrationSerializer(serializers.ModelSerializer):
    """Serializador para registro de usuarios."""

    password = serializers.CharField(
        write_only=True,
        required=True,
        validators=[validate_password],
        style={'input_type': 'password'}
    )
    password_confirm = serializers.CharField(write_only=True, style={'input_type': 'password'})

    class Meta:
        model = User
        fields = ['email', 'username', 'password', 'password_confirm']

    def validate(self, data):
        """Valida que las contraseñas coincidan."""
        if data['password'] != data['password_confirm']:
            raise serializers.ValidationError({
                "password_confirm": "Los campos de contraseña no coinciden."
            })
        return data

    def create(self, validated_data):
        """Crea un usuario con contraseña hasheada."""
        validated_data.pop('password_confirm')
        password = validated_data.pop('password')
        user = User.objects.create(**validated_data)
        user.set_password(password)
        user.save()
        return user

Patrones de ViewSets

from rest_framework import viewsets, status, filters
from rest_framework.decorators import action
from rest_framework.response import Response
from rest_framework.permissions import IsAuthenticated, IsAdminUser
from django_filters.rest_framework import DjangoFilterBackend
from .models import Product
from .serializers import ProductSerializer, ProductCreateSerializer
from .permissions import IsOwnerOrReadOnly
from .filters import ProductFilter
from .services import ProductService

class ProductViewSet(viewsets.ModelViewSet):
    """ViewSet para el modelo Product."""

    queryset = Product.objects.select_related('category').prefetch_related('tags')
    permission_classes = [IsAuthenticated, IsOwnerOrReadOnly]
    filter_backends = [DjangoFilterBackend, filters.SearchFilter, filters.OrderingFilter]
    filterset_class = ProductFilter
    search_fields = ['name', 'description']
    ordering_fields = ['price', 'created_at', 'name']
    ordering = ['-created_at']

    def get_serializer_class(self):
        """Devuelve el serializador adecuado según la acción."""
        if self.action == 'create':
            return ProductCreateSerializer
        return ProductSerializer

    def perform_create(self, serializer):
        """Guarda con el contexto del usuario."""
        serializer.save(created_by=self.request.user)

    @action(detail=False, methods=['get'])
    def featured(self, request):
        """Devuelve productos destacados."""
        featured = self.queryset.filter(is_featured=True)[:10]
        serializer = self.get_serializer(featured, many=True)
        return Response(serializer.data)

    @action(detail=True, methods=['post'])
    def purchase(self, request, pk=None):
        """Compra un producto."""
        product = self.get_object()
        service = ProductService()
        result = service.purchase(product, request.user)
        return Response(result, status=status.HTTP_201_CREATED)

    @action(detail=False, methods=['get'], permission_classes=[IsAuthenticated])
    def my_products(self, request):
        """Devuelve los productos creados por el usuario actual."""
        products = self.queryset.filter(created_by=request.user)
        page = self.paginate_queryset(products)
        serializer = self.get_serializer(page, many=True)
        return self.get_paginated_response(serializer.data)

Acciones Personalizadas

from rest_framework.decorators import api_view, permission_classes
from rest_framework.permissions import IsAuthenticated
from rest_framework.response import Response

@api_view(['POST'])
@permission_classes([IsAuthenticated])
def add_to_cart(request):
    """Añade un producto al carrito del usuario."""
    product_id = request.data.get('product_id')
    quantity = request.data.get('quantity', 1)

    try:
        product = Product.objects.get(id=product_id)
    except Product.DoesNotExist:
        return Response(
            {'error': 'Producto no encontrado'},
            status=status.HTTP_404_NOT_FOUND
        )

    cart, _ = Cart.objects.get_or_create(user=request.user)
    CartItem.objects.create(
        cart=cart,
        product=product,
        quantity=quantity
    )

    return Response({'message': 'Añadido al carrito'}, status=status.HTTP_201_CREATED)

Patrón de Capa de Servicios

# apps/orders/services.py
from typing import Optional
from django.db import transaction
from .models import Order, OrderItem

class OrderService:
    """Capa de servicios para la lógica de negocio relacionada con pedidos."""

    @staticmethod
    @transaction.atomic
    def create_order(user, items):
        """Crea un pedido con sus elementos de manera atómica."""
        order = Order.objects.create(user=user)
        for item in items:
            OrderItem.objects.create(
                order=order,
                product=item['product'],
                quantity=item['quantity'],
                price=item['product'].price
            )
        return order

    @staticmethod
    def get_order_history(user):
        """Obtiene el historial de pedidos de un usuario."""
        return Order.objects.filter(user=user).select_related('items__product').order_by('-created_at')

Caching

Caching de Consultas

from django.core.cache import cache
from .models import Product

def get_active_products():
    """Cachea la lista de productos activos."""
    cache_key = 'active_products'
    products = cache.get(cache_key)
    if not products:
        products = Product.objects.active().with_category()
        cache.set(cache_key, products, 3600)  # Cachea por 1 hora
    return products

def invalidate_product_cache(product_id):
    """Invalida el caché cuando un producto se actualiza."""
    cache.delete('active_products')
    cache.delete(f'product_{product_id}')

class Product(models.Model):
    # ... campos ...

    def save(self, *args, **kwargs):
        super().save(*args, **kwargs)
        invalidate_product_cache(self.id)

Caching de Vistas

from django.views.decorators.cache import cache_page
from django.utils.decorators import method_decorator
from rest_framework.response import Response

class CachedProductViewSet(viewsets.ReadOnlyModelViewSet):
    """ViewSet de solo lectura con caching de respuestas."""

    @method_decorator(cache_page(60 * 15))  # Cachea por 15 minutos
    def dispatch(self, request, *args, **kwargs):
        return super().dispatch(request, *args, **kwargs)

    def list(self, request):
        # La respuesta se cachea automáticamente
        return super().list(request)

Señales

Señales de Modelo

from django.db.models.signals import post_save, pre_save
from django.dispatch import receiver

@receiver(post_save, sender=Product)
def update_product_search_index(sender, instance, created, **kwargs):
    """Actualiza el índice de búsqueda cuando se guarda un producto."""
    if created:
        # Agrega al índice de búsqueda
        update_search_index.delay(instance.id)
    else:
        # Actualiza el índice de búsqueda
        update_search_index.delay(instance.id)

@receiver(pre_save, sender=User)
def lowercase_email(sender, instance, **kwargs):
    """Convierte el email a minúsculas antes de guardar."""
    if instance.email:
        instance.email = instance.email.lower()

Middleware

Middleware Personalizado

# apps/core/middleware.py
from django.utils import timezone
from django.shortcuts import redirect

class UserActivityMiddleware:
    """Registra la actividad del usuario en cada solicitud."""

    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        if request.user.is_authenticated:
            request.user.last_activity = timezone.now()
            request.user.save(update_fields=['last_activity'])
        response = self.get_response(request)
        return response

class MaintenanceModeMiddleware:
    """Redirige a una página de mantenimiento si está activo."""

    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        if settings.MAINTENANCE_MODE and not request.user.is_staff:
            return redirect('maintenance')
        return self.get_response(request)

Pruebas

Pruebas de Modelos

from django.test import TestCase
from .models import Product, Category

class ProductModelTest(TestCase):
    """Pruebas para el modelo Product."""

    def setUp(self):
        self.category = Category.objects.create(name='Electrónica', slug='electronics')
        self.product = Product.objects.create(
            name='Laptop Gamer',
            price=1200.00,
            stock=10,
            category=self.category
        )

    def test_product_creation(self):
        """Prueba que un producto se crea correctamente."""
        self.assertEqual(self.product.name, 'Laptop Gamer')
        self.assertEqual(self.product.price, 1200.00)
        self.assertTrue(self.product.is_active)

    def test_string_representation(self):
        """Prueba la representación en cadena del producto."""
        self.assertEqual(str(self.product), 'Laptop Gamer')

Pruebas de API

from rest_framework.test import APITestCase
from django.contrib.auth import get_user_model
from .models import Product

class ProductAPITest(APITestCase):
    """Pruebas para la API de productos."""

    def setUp(self):
        self.user = get_user_model().objects.create_user(
            email='[email protected]',
            password='testpass123'
        )
        self.client.force_authenticate(user=self.user)

    def test_list_products(self):
        """Prueba que se pueden listar productos."""
        response = self.client.get('/api/products/')
        self.assertEqual(response.status_code, 200)

    def test_create_product(self):
        """Prueba que se puede crear un producto."""
        data = {
            'name': 'Nuevo Producto',
            'price': 50.00,
            'stock': 100,
            'category': self.category.id
        }
        response = self.client.post('/api/products/', data)
        self.assertEqual(response.status_code, 201)
        self.assertEqual(Product.objects.count(), 1)

Recursos Adicionales

• Documentación Oficial de Django
• Documentación de Django REST Framework
• Patrones de Diseño de Django

Nota: Estos patrones están diseñados para proyectos Django medianos a grandes con Django REST Framework. Adáptalos según las necesidades específicas de tu proyecto.