Validaciones custom en Django Rest Framework

Contenido del curso

Fundamentos de Django Rest Framework

Vistas y Endpoints

Serializadores Avanzados

Testing y Desempeño

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:0010:26

Validaciones custom en Django Rest Framework

Curso de Django Rest Framework

Clase 16 de 21

Clase 16 / 21

Recursos

La confiabilidad de una API inicia con datos limpios. Aquí verás, paso a paso, cómo implementar validaciones personalizadas en Django Rest Framework desde los serializers para controlar correos corporativos y reglas que combinan varios campos, generando mensajes de error claros en JSON y respuestas consistentes en el backend.

¿Cómo validar correos corporativos en Django Rest Framework?

La idea central es restringir el correo a un dominio específico, por ejemplo, @example.com, dentro del serializer del doctor. Aunque el campo email del modelo ya es de tipo EmailField y valida el formato, se necesita una validación custom de dominio. La estrategia es usar un método con nombre especial: validate_<campo>.

Usa el método validate_email para validar solo el campo email.
Retorna el valor si es válido. Lanza excepción si es inválido.
La excepción es serializers.ValidationError y DRF la muestra como JSON con estado 400.

Ejemplo basado en lo explicado:

from rest_framework import serializers

class DoctorSerializer(serializers.ModelSerializer):
    def validate_email(self, value):
        # valida que el dominio corporativo esté presente
        if "example.com" in value:
            return value
        raise serializers.ValidationError("el correo debe incluir @example.com")

Este método se activa automáticamente al correr el sistema de validación.
Si el valor es inválido, la respuesta será un 400 con el detalle del error.
También podrías pasar código o detalles extra en la excepción, pero aquí basta el texto.

¿Qué pasa si el correo no es válido?

Se lanza serializers.ValidationError con un mensaje claro.
El serializer serializa el error a JSON y lo muestra ligado al campo email.
El mensaje visto en pantalla es directo: "el correo debe incluir @example.com".

¿Cuándo usar validate para varias reglas de negocio?

Cuando la regla depende de más de un campo, se emplea el método validate(self, attrs). En el ejemplo, se cruza contact_number con is_on_vacation: si el doctor se marca en vacaciones sin un teléfono válido (mínimo 10 caracteres), se bloquea la actualización.

attrs es un diccionario con todos los valores validados por campo.
Accede con attrs.get("nombre_del_campo").
Lanza serializers.ValidationError para errores que no pertenecen a un único campo.

Ejemplo basado en lo explicado:

from rest_framework import serializers

class DoctorSerializer(serializers.ModelSerializer):
    def validate(self, attrs):
        contact_number = attrs.get("contact_number")
        is_on_vacation = attrs.get("is_on_vacation")

        if is_on_vacation and (not contact_number or len(contact_number) < 10):
            # error general: no asociado a un solo campo
            raise serializers.ValidationError(
                "por favor, ingresa un número válido antes de irte a vacaciones"
            )

        return super().validate(attrs)

¿Cómo se muestran los errores en JSON?

Al subir reglas cruzadas a validate, DRF agrupa el error como non-field error.
El arreglo de mensajes aparece bajo la clave "non_field_errors".
En pruebas con PATCH, si todo es correcto, la respuesta es 200 ok y los cambios se reflejan.

¿Qué habilidades y keywords refuerzas con estas validaciones?

Aplicar estas técnicas mejora la calidad de datos y la experiencia de uso en endpoints sensibles.

Manejo de errores de validación con serializers.ValidationError y estado 400.
Validación custom con validate_<campo> para email corporativo.
Reglas de negocio cruzadas con validate(self, attrs) y errores tipo non-field errors.
Mensajes de error claros y consistentes en JSON.
Uso de booleanos true/false y verificación de longitud mínima para teléfonos.
Buenas prácticas en serializer: retornar el valor si es válido y delegar a super().validate(attrs).
Palabras clave: Django Rest Framework, serializer, serializers, JSON, validate_email, validate, ValidationError, dominio corporativo, contact_number, is_on_vacation, PATCH, 200 ok, endpoints, backend, API.

¿Tienes ideas para validar datos de pacientes? Comparte tus reglas personalizadas y ejemplos en los comentarios.

Damian Rengifo

Hace 10 meses

Las principales validaciones que yo vi necesarias para los modelos de pacientes son validacion del numero de contacto como maximo de caracteres y que solo deben haber numeros y en Insurance validacion del policy number y expiration date

from rest_framework import serializers

from .models import Patient, Insurance, MedicalRecord

from datetime import datetime

class PatientSerializers(serializers.ModelSerializer):

class Meta:

model=Patient

fields = '__all__'

def validate_contact_number(self, value):

if len(value) > 10:

raise serializers.ValidationError("the maximium number of digits in a policy number is 10")

if not value.isdigit():

raise serializers.ValidationError("The contact number only contain numbers")

return value

def validate(self, attrs):

if attrs['first_name'].casefold() == attrs['last_name'].casefold():

raise serializers.ValidationError("The first name and last name can't be iguals")

return super().validate(attrs)

class InsuranceSerializers(serializers.ModelSerializer):

class Meta:

model=Insurance

fields = '__all__'

def validate_policy_number(self, value):

if value.isdigit():

return value

else:

raise serializers.ValidationError("The maximium number of digits in a policy number is 10")

def validate_expiration_date(self, value):

fecha_hoy = datetime.now().date()

if fecha_hoy < value:

return value

else:

raise serializers.ValidationError("The expiration date cant be before than today date")

class MedicalRecordSerializers(serializers.ModelSerializer):

class Meta:

model=MedicalRecord

fields = '__all__'

Luis Martinez

Profesor

Hace 10 meses

Muy buen progreso, una recomendación extra: puedes usar una lista en fields en vez de '__all__' para evitar que se incluyan nuevos campos auotmaticamente.

Comentarios (8)8 comentarios

Antonio Demarco Bonino

Hace 2 años

Dejo este resumen:

Validaciones:
- Se manejan principalmente dentro de los serializers.
- Puedes hacer validaciones a nivel de campo o a nivel de objeto.
- También puedes realizar validaciones basadas en el contexto.
Manejo de Errores:
- DRF gestiona automáticamente muchas excepciones y devuelve respuestas claras.
- Puedes personalizar el manejo de errores utilizando excepciones personalizadas o creando un manejador global de excepciones.
- Utiliza raise_exception=True en los serializers para manejar automáticamente los errores de validación.

Andres Trujillo

thanks for resume

Manuel Galindo

Ventajas de manejar errores:

Mejora la experiencia del usuario: Proporciona mensajes claros y útiles cuando ocurren errores.
Aumenta la seguridad: Previene la exposición de información sensible a través de mensajes de error.
Facilita la depuración: Ayuda a los desarrolladores a identificar y solucionar problemas más rápidamente.

Ventajas de manejar validaciones:

Garantiza la integridad de los datos: Asegura que solo datos correctos y esperados sean procesados.
Previene errores: Reduce la posibilidad de errores en el sistema al validar la entrada de datos.
Mejora la seguridad: Evita la entrada de datos maliciosos que podrían comprometer el sistema.

perfect!

This is my error manage for patients:

class PatientSerializer(serializers.ModelSerializer):
    class Meta:
        model = Patient
        fields = "__all__"

    def validate_email(self, value):
        if "@example.com" in value:
            return value
        raise serializers.ValidationError("Email should contain @example.com")

    def validate(self, attrs):
        if len(attrs["contact_number"]) < 10:
            raise serializers.ValidationError(
                "Contact number must be at least 10 digits"
            )

        if not attrs["medical_history"] or len(attrs["medical_history"]) < 20:
            raise serializers.ValidationError(
                "Medical history must be at least 20 characters"
            )

        if attrs["date_of_birth"] > datetime.now().date():
            raise serializers.ValidationError("Date of birth cannot be in the future")

        return super().validate(attrs)

Mario Alexander Vargas Celis

En Django REST Framework (DRF), el manejo de errores y las validaciones son componentes cruciales para crear APIs robustas. DRF facilita la creación de validaciones personalizadas y el manejo adecuado de errores, ya sea en los serializadores, vistas o directamente en las respuestas de la API.

### Validaciones en Serializers

Los **serializers** son el lugar donde generalmente ocurre la mayoría de las validaciones de datos. DRF proporciona métodos incorporados para validar datos en un ModelSerializer.

#### 1. Validaciones de Campos

DRF realiza validaciones automáticas basadas en los tipos de campo definidos en el modelo, pero también puedes agregar validaciones personalizadas en cada campo.

Ejemplo:


from rest\_framework import serializers

from .models import Patient



class PatientSerializer(serializers.ModelSerializer):

&#x20;   class Meta:

&#x20;       model = Patient

&#x20;       fields = '\_\_all\_\_'



&#x20;   \# Validación personalizada en un campo específico

&#x20;   def validate\_age(self, value):

&#x20;       if value < 0:

&#x20;           raise serializers.ValidationError("La edad no puede ser negativa.")

&#x20;       return value

#### 2. Validaciones Globales

Puedes realizar validaciones que afecten a múltiples campos a la vez usando el método validate en el serializador.


class PatientSerializer(serializers.ModelSerializer):

&#x20;   class Meta:

&#x20;       model = Patient

&#x20;       fields = '\_\_all\_\_'



&#x20;   \# Validación global (en múltiples campos)

&#x20;   def validate(self, data):

&#x20;       if data\['age'] < 18 and not data.get('guardian'):

&#x20;           raise serializers.ValidationError("Pacientes menores de edad deben tener un guardián.")

&#x20;       return data

### Manejo de Errores en Vistas

En Django REST Framework, puedes manejar errores y excepciones en las vistas, ya sea a través de excepciones incorporadas o personalizadas.

#### 1. Excepciones Incorporadas

DRF tiene una serie de excepciones predeterminadas que puedes usar, como:

- ValidationError: Para errores de validación.

- NotFound: Cuando un recurso no existe.

- PermissionDenied: Cuando el usuario no tiene los permisos necesarios.

- NotAuthenticated: Si se requiere autenticación pero no está presente.


from rest\_framework.exceptions import NotFound

from rest\_framework.views import APIView

from .models import Patient

from .serializers import PatientSerializer



class PatientDetailView(APIView):

&#x20;   def get(self, request, pk):

&#x20;       try:

&#x20;           patient = Patient.objects.get(pk=pk)

&#x20;       except Patient.DoesNotExist:

&#x20;           raise NotFound("El paciente con este ID no existe.")



&#x20;       serializer = PatientSerializer(patient)

&#x20;       return Response(serializer.data)

#### 2. Manejo de Excepciones Globales

Si quieres manejar los errores a nivel global, puedes personalizar el comportamiento utilizando un middleware o sobreescribiendo la función de excepción de DRF.


\# En settings.py

REST\_FRAMEWORK = {

&#x20;   'EXCEPTION\_HANDLER': 'my\_project.my\_app.utils.custom\_exception\_handler',

}

Y luego defines tu función personalizada de manejo de errores:


from rest\_framework.views import exception\_handler



def custom\_exception\_handler(exc, context):

&#x20;   response = exception\_handler(exc, context)



&#x20;   if response is not None:

&#x20;       response.data\['status\_code'] = response.status\_code

&#x20;       response.data\['error'] = str(exc)



&#x20;   return response

### Manejo de Validaciones Personalizadas en Formularios

También puedes agregar validaciones personalizadas usando el atributo validators en los serializadores para campos específicos.


from rest\_framework import serializers

from django.core.validators import RegexValidator



class PatientSerializer(serializers.ModelSerializer):

&#x20;   phone\_number = serializers.CharField(

&#x20;       validators=\[RegexValidator(regex='^(\\+)?\[0-9]{10,15}$', message="Número de teléfono inválido")]

&#x20;   )

&#x20;  &#x20;

&#x20;   class Meta:

&#x20;       model = Patient

&#x20;       fields = '\_\_all\_\_'

### Respuestas Personalizadas en Caso de Error

Puedes crear respuestas personalizadas cuando ocurre un error en la validación de los datos en tu API. Por ejemplo, puedes sobrescribir cómo los errores son mostrados en las respuestas.


from rest\_framework.response import Response

from rest\_framework import status

from rest\_framework.views import APIView



class PatientDetailView(APIView):

&#x20;   def post(self, request):

&#x20;       serializer = PatientSerializer(data=request.data)

&#x20;       if serializer.is\_valid():

&#x20;           serializer.save()

&#x20;           return Response(serializer.data, status=status.HTTP\_201\_CREATED)

&#x20;       return Response({

&#x20;           'status': 'error',

&#x20;           'message': 'Datos inválidos',

&#x20;           'errors': serializer.errors

&#x20;       }, status=status.HTTP\_400\_BAD\_REQUEST)

### Resumen

- **Validaciones en Serializers**: Usa validate\_\<field> para validaciones de campo, y el método validate para validaciones que involucran múltiples campos.

- **Manejo de Excepciones**: Puedes usar excepciones predefinidas o personalizadas en tus vistas.

- **Respuestas de Error Personalizadas**: Puedes sobrescribir el formato de los errores de validación para personalizar las respuestas JSON.

- **Excepciones Globales**: Puedes definir un manejador de excepciones global para todo el proyecto a través de la configuración de EXCEPTION\_HANDLER.

Estos mecanismos te permitirán gestionar errores y validaciones de manera eficiente en tu proyecto Django REST Framework.

cool!

Andrés Yasir Romero

Si utilizamos el método set_on_vacation que creamos anteriormente no se realiza la validación. Como podemos solucionar esto?

Puedes validarlo usando el metodo clean_fields https://docs.djangoproject.com/en/5.1/ref/models/instances/#django.db.models.Model.clean_fields

Francisco López Briones

Hace un año

Validación para la Edad del Paciente

class PatientSerializer(serializers.ModelSerializer):
    class Meta:
        model = Patient
        fields = "__all__"

    def validate_date_of_birth(self, value):
        today = datetime.date.today()
        age = today.year - value.year - ((today.month, today.day) < (value.month, value.day))
        if age >= 18:
            return value
        raise serializers.ValidationError('El paciente debe tener al menos 18 años')

Johan Moises Ariza Mahecha

Comparto mi solución al reto:

Validando que no se usen caracteres especiales en el campo de nombre y apellido, además que el número de contacto no sea un número superior a 10.

class PatientSerializer(serializers.ModelSerializer):

    class Meta:
        model = Patient
        fields = "__all__"

    def validate(self, attrs):
        patron = r'^[a-zA-ZáéíóúÁÉÍÓÚñÑüÜ\s\-]+$'

        if not re.match(patron, attrs['first_name']) or not re.match(patron, attrs['last_name']):
            raise serializers.ValidationError("The first name and last name not must be special character")
        
        if len(attrs["contact_number"]) > 10:
            raise serializers.ValidationError("Contact number must be at least 10 digits")
        
        return super().validate(attrs)

Fundamentos de Django Rest Framework

Django REST Framework para APIs escalables

Qué es una API REST y cómo usar JSON

Configuración de Django REST Framework paso a paso

Django Rest: qué reutiliza de Django

Serializers Django: modelos a JSON fácil

Listado de pacientes con serializers en DRF

POST y GET en el mismo endpoint con Django REST

CRUD completo con PUT y DELETE en Django Rest

Cómo probar APIs con Postman y curl

Django Rest Framework: de funciones a vistas genéricas

Vistas genéricas en Django Rest Framework

Documentación automática de APIs con drf-spectacular

Vistas y Endpoints

ViewSets vs APIView: refactor automático de URLs

Acciones personalizadas en ViewSets REST

Autenticación y permisos en Django Rest Framework

Validaciones custom en Django Rest Framework

Serializadores Avanzados

Serializadores anidados en Django REST Framework

Calcular campos dinámicos con SerializerMethodField

Endpoint anidado para citas en Django REST

Testing y Desempeño

Tests de API con APIClient en Django

Throttling en Django Rest para evitar ataques DOS

Validaciones custom en Django Rest Framework

Progreso del curso

Fundamentos de Django Rest Framework

Vistas y Endpoints

Serializadores Avanzados

Testing y Desempeño

Recursos

Recursos