Cuando trabajas con APIs en Django REST Framework, a veces necesitas mostrar un valor que no existe directamente en tu modelo, sino que se calcula a partir de otros campos. Aquí entra en juego SerializerMethodField, una herramienta que te permite agregar campos calculados sin modificar tu base de datos.
Qué es SerializerMethodField y para qué sirve
Imagina que tienes un modelo Patient con la fecha de nacimiento, pero en tu endpoint quieres mostrar la edad. No tiene sentido guardar la edad en la base de datos porque cambia cada año. La solución es calcularla al momento de serializar.
SerializerMethodField es un campo de solo lectura que ejecuta un método de tu clase serializer y retorna el valor calculado. Recibe la instancia del modelo y desde ahí puedes acceder a cualquier atributo para hacer la lógica que necesites [1:00].
¿Qué es SerializerMethodField en DRF? Es un campo de serializer que permite calcular y retornar valores dinámicos a partir de la instancia del modelo, sin necesidad de almacenarlos en la base de datos.
Cómo calcular la edad de un paciente desde la fecha de nacimiento
El objetivo es transformar un campo date_of_birth en un valor numérico que represente la edad del paciente. Para lograrlo, necesitas dos piezas: el módulo date de Python y un método dentro del serializer.
Cómo importar el módulo correcto en Python
La importación que necesitas es específica. Como el campo en el modelo es de tipo Date y no Datetime, importas solo date:
python
from datetime import date
Con esto puedes usar date.today() para obtener la fecha actual y restar la fecha de nacimiento [2:30].
Cómo definir el campo age en el serializer
Dentro de tu clase serializer, declara el nuevo campo y crea el método correspondiente. Si dejas vacío el parámetro method_name, Django REST Framework genera el nombre automáticamente con el prefijo get_ seguido del nombre del campo.
python
from rest_framework import serializers
from datetime import date
class PatientSerializer(serializers.ModelSerializer):
age = serializers.SerializerMethodField()
El detalle clave está en age_timedelta.days. Cuando restas dos fechas obtienes un objeto timedelta, no un número. Para convertirlo en un valor numérico debes acceder al atributo days y dividirlo entre 365 [3:45].
Por qué no debes retornar texto desde una API REST
Es tentador devolver algo como "45 años" directamente desde el serializer usando un f-string. Técnicamente funciona, pero es mala práctica.
Las APIs deben retornar valores puros y consistentes.
El formato y los textos pertenecen al front-end.
Muchas aplicaciones manejan varios idiomas y necesitan adaptar el texto.
Mezclar lógica de presentación en el backend complica el mantenimiento.
Lo ideal es retornar el número y documentar la unidad: la edad va en años, la duración en minutos, el precio en centavos. El cliente decide cómo mostrarlo.
¿Por qué no devolver strings con formato desde el backend? Porque rompe la separación de responsabilidades. El backend entrega datos, el frontend decide cómo presentarlos según el idioma o el contexto del usuario.
Cuándo conviene usar SerializerMethodField en lugar de modificar el modelo
No todo cálculo merece una columna nueva en la base de datos. SerializerMethodField brilla cuando el valor depende del momento de la consulta o se deriva de datos ya existentes.
Úsalo cuando:
El valor cambia con el tiempo, como la edad o la antigüedad.
Es una combinación simple de campos que ya tienes.
Solo se necesita en la respuesta del endpoint, no para filtrar ni ordenar.
Quieres evitar migraciones innecesarias.
Si en cambio el valor se va a consultar con frecuencia, se usa para filtros o se calcula con lógica pesada, probablemente convenga guardarlo en el modelo o usar una property combinada con caché.
Reto: calcula la experiencia de un doctor
Ahora aplica lo aprendido. Crea un método dentro del serializer del modelo Doctor que calcule los años de experiencia basándose en la fecha en la que empezó a trabajar. La lógica es la misma que usaste con la edad del paciente: resta de fechas, acceso a days y división entre 365.
¿Cómo resolviste el reto? Comparte tu implementación en los comentarios y cuéntame si encontraste alguna variación interesante para manejar años bisiestos.
Calcular campos dinámicos con SerializerMethodField
Cuando trabajas con APIs en Django REST Framework, a veces necesitas mostrar un valor que no existe directamente en tu modelo, sino que se calcula a partir de otros campos. Aquí entra en juego SerializerMethodField, una herramienta que te permite agregar campos calculados sin modificar tu base de datos.
Qué es SerializerMethodField y para qué sirve
Imagina que tienes un modelo Patient con la fecha de nacimiento, pero en tu endpoint quieres mostrar la edad. No tiene sentido guardar la edad en la base de datos porque cambia cada año. La solución es calcularla al momento de serializar.
SerializerMethodField es un campo de solo lectura que ejecuta un método de tu clase serializer y retorna el valor calculado. Recibe la instancia del modelo y desde ahí puedes acceder a cualquier atributo para hacer la lógica que necesites [1:00].
¿Qué es SerializerMethodField en DRF? Es un campo de serializer que permite calcular y retornar valores dinámicos a partir de la instancia del modelo, sin necesidad de almacenarlos en la base de datos.
Cómo calcular la edad de un paciente desde la fecha de nacimiento
El objetivo es transformar un campo date_of_birth en un valor numérico que represente la edad del paciente. Para lograrlo, necesitas dos piezas: el módulo date de Python y un método dentro del serializer.
Cómo importar el módulo correcto en Python
La importación que necesitas es específica. Como el campo en el modelo es de tipo Date y no Datetime, importas solo date:
python
from datetime import date
Con esto puedes usar date.today() para obtener la fecha actual y restar la fecha de nacimiento [2:30].
Cómo definir el campo age en el serializer
Dentro de tu clase serializer, declara el nuevo campo y crea el método correspondiente. Si dejas vacío el parámetro method_name, Django REST Framework genera el nombre automáticamente con el prefijo get_ seguido del nombre del campo.
python
from rest_framework import serializers
from datetime import date
class PatientSerializer(serializers.ModelSerializer):
age = serializers.SerializerMethodField()
El detalle clave está en age_timedelta.days. Cuando restas dos fechas obtienes un objeto timedelta, no un número. Para convertirlo en un valor numérico debes acceder al atributo days y dividirlo entre 365 [3:45].
Por qué no debes retornar texto desde una API REST
Es tentador devolver algo como "45 años" directamente desde el serializer usando un f-string. Técnicamente funciona, pero es mala práctica.
Las APIs deben retornar valores puros y consistentes.
El formato y los textos pertenecen al front-end.
Muchas aplicaciones manejan varios idiomas y necesitan adaptar el texto.
Mezclar lógica de presentación en el backend complica el mantenimiento.
Lo ideal es retornar el número y documentar la unidad: la edad va en años, la duración en minutos, el precio en centavos. El cliente decide cómo mostrarlo.
¿Por qué no devolver strings con formato desde el backend? Porque rompe la separación de responsabilidades. El backend entrega datos, el frontend decide cómo presentarlos según el idioma o el contexto del usuario.
Cuándo conviene usar SerializerMethodField en lugar de modificar el modelo
No todo cálculo merece una columna nueva en la base de datos. SerializerMethodField brilla cuando el valor depende del momento de la consulta o se deriva de datos ya existentes.
Úsalo cuando:
El valor cambia con el tiempo, como la edad o la antigüedad.
Es una combinación simple de campos que ya tienes.
Solo se necesita en la respuesta del endpoint, no para filtrar ni ordenar.
Quieres evitar migraciones innecesarias.
Si en cambio el valor se va a consultar con frecuencia, se usa para filtros o se calcula con lógica pesada, probablemente convenga guardarlo en el modelo o usar una property combinada con caché.
Reto: calcula la experiencia de un doctor
Ahora aplica lo aprendido. Crea un método dentro del serializer del modelo Doctor que calcule los años de experiencia basándose en la fecha en la que empezó a trabajar. La lógica es la misma que usaste con la edad del paciente: resta de fechas, acceso a days y división entre 365.
¿Cómo resolviste el reto? Comparte tu implementación en los comentarios y cuéntame si encontraste alguna variación interesante para manejar años bisiestos.
from datetime import date
from rest_framework import serializers
from .models import Doctor
class DoctorSerializer(serializers.ModelSerializer):
experience_years = serializers.SerializerMethodField() # Campo personalizado para años de experiencia
class Meta:
model = Doctor
fields = [
'first_name',
'last_name',
'qualification',
'email',
'start_date',
'experience_years' # Incluir el campo calculado en la salida
]
def get_experience_years(self, obj):
experience_td = date.today() - obj.start_date # Calcula la diferencia entre hoy y la fecha de inicio
years = experience_td.days // 365 # Convierte los días en años
return f"{years} años" # Retorna los años de experiencia con el texto "años"
def get_age(self, obj):
# Muestar los años que tiene el paciente
# age_td = date.today() - obj.date_of_birth
# years = age_td.days // 365
# return f"{years} años"
# Muestar los años, meses y dias que tiene el paciente
age_td = date.today() - obj.date_of_birth
years = age_td.days // 365
remaining_days = age_td.days % 365
months = remaining_days // 30
days = remaining_days % 30
return f"{years} años, {months} meses y {days} días"
```def get\_age(self, obj): # Muestar los años que tiene el paciente # age\_td = date.today() - obj.date\_of\_birth # years = age\_td.days // 365 # return f"{years} años"
# Muestar los años, meses y dias que tiene el paciente age\_td = date.today() - obj.date\_of\_birth years = age\_td.days // 365 remaining\_days = age\_td.days % 365 months = remaining\_days // 30 days = remaining\_days % 30 return f"{years} años, {months} meses y {days} días"
from rest_framework import serializers
from .models import Physician, Department, PhyisicanAvailability, MedicalNote
from datetime import date
from patients.models import Patient
from physicians.models import Physician
from bookings.serializers import AppointmentSerializer
class DepartmentSerializer(serializers.ModelSerializer):
class Meta:
model = Department
fields = [
'id',
'name',
'description'
]
class PhyisicanAvailabilitySerializer(serializers.ModelSerializer):
class Meta:
model = PhyisicanAvailability
fields = [
'id',
'phyisican',
'start_date',
'end_date',
'start_time',
'end_time'
]
class MedicalNoteSerializer(serializers.ModelSerializer):
class Meta:
model = MedicalNote
fields = [
'id',
'phyisican',
'note',
'date'
]
class PhysicianSerializer(serializers.ModelSerializer):
department = DepartmentSerializer(read_only=True)
doctor_availability = PhyisicanAvailabilitySerializer(many=True, read_only=True, source='availabilities') #
medical_notes = MedicalNoteSerializer(many=True, read_only=True)
appointments = AppointmentSerializer(many=True, read_only=True)
work_time_exp = serializers.SerializerMethodField()
class Meta:
model = Physician
fields = [
'id',
'first_name',
'last_name',
'qualification',
'contact_number',
'email',
'address',
'biography',
'department',
'doctor_availability',
'medical_notes',
'appointments',
'work_time_exp'
]
def validate_email(self, value):
if "@example.com" in value:
return value
raise serializers.ValidationError("Invalid email address")
def validate(self, attrs):
# Check if keys exist in attrs , object.
if 'contact_number' in attrs and 'is_on_vacation' in attrs:
if len(attrs['contact_number']) < 10 and attrs['is_on_vacation']:
raise serializers.ValidationError("Contact number is required before vacations")
return super().validate(attrs)
def get_work_time_exp(self, obj):
# USE Create _at date because it is the date the doctor was created on db system.
if obj.created_at:
experience_td = date.today() - obj.created_at.date()
years = experience_td.days // 365
return years
return 0
class Doctor(models.Model):
'''
Modelo que representa a un doctor en el sistema.
Contiene información personal y profesional relevante.
* Atributos:
- first_name: Nombre del doctor.
- last_name: Apellido del doctor.
- qualification: Título profesional del doctor.
- graduation_date: Fecha de graduación del doctor.
- contact_number: Número de contacto del doctor.
- email: Dirección de correo electrónico del doctor.
- address: Dirección del consultorio del doctor.
- biography: Breve biografía del doctor.
- specialty: Especialidad médica del doctor.
- is_on_vacation: Indica si el doctor está de vacaciones.
* Métodos:
- __str__: Retorna una representación legible del doctor.
'''
first_name = models.CharField(max_length=30)
last_name = models.CharField(max_length=30)
qualification = models.CharField(max_length=100)
contact_number = models.CharField(max_length=15)
email = models.EmailField(unique=True)
address = models.TextField()
biography = models.TextField(blank=True)
specialty = models.CharField(max_length=100)
graduation_date = models.DateField(blank=True, null=True)
is_on_vacation = models.BooleanField(default=False)
def __str__(self):
return f"Dr. {self.first_name} {self.last_name} - {self.specialty}"
-----
# Campo calculado para los años de experiencia del doctor.
experience = serializers.SerializerMethodField()
class Meta:
model = Doctor
fields = '__all__'
def get_experience(self, obj) -> int:
'''
Calcula los años de experiencia del doctor basado en su fecha de graduación.
* Parámetros:
- obj: Instancia del modelo Doctor.
* Retorna:
- int: Años de experiencia del doctor.
'''
if obj.graduation_date:
experience_td = date.today() - obj.graduation_date
return int(experience_td.days // 365.25) # Aproximación considerando años bisiestos
return 0 # Si no hay fecha de graduación, retorna 0 años de experiencia
Relacioné los modelos de DoctorAvailability y Doctor para obtener la fecha de inicio del doctor y modifique el resultado de tiempo de experiencia para hacerlo más específico implementando la librería de python-dateutil
from datetime import date, datetime
from dateutil.relativedelta import relativedelta
class DoctorSerializer(serializers.ModelSerializer):
# Relacionar con el serializador de DoctorAvailability
availabilities = DoctorAvailabilitySerializer(many=True, read_only=True)
experience_years = serializers.SerializerMethodField()
class Meta:
model = Doctor
fields = [
'id',
'first_name',
'last_name',
'qualification',
'contact_number',
'email',
'address',
'biography',
'is_on_vacation',
'availabilities',
'experience_years',
]
def get_experience_years(self, obj):
first_availability = obj.availabilities.order_by('start_date').first()
if first_availability:
# Calcular la diferencia entre la fecha actual y la primera disponibilidad
now = datetime.now()
dob = datetime.combine(first_availability.start_date, datetime.min.time())
experience_time_delta = relativedelta(now, dob)
# Obtener los años, meses y días
years = experience_time_delta.years
months = experience_time_delta.months
days = experience_time_delta.days
return f'{years} años, {months} meses, {days} días'
else:
# En caso de que no tenga disponibilidad, retornar 'Sin experiencia'
return 'Sin experiencia'
```Y así ajuste el serializador de PatientSerializer
```js
def get_age(self, obj):
# Combinar con tiempo para obtener datetime completo
dob = datetime.combine(obj.date_of_birth, datetime.min.time())
# Calcular la diferencia entre la fecha de nacimiento y el momento actual
age_time_delta = relativedelta(date.today(), dob)
# Obtener los años, meses, días y horas
years = age_time_delta.years
months = age_time_delta.months
days = age_time_delta.days
return f'{years} años, {months} meses, {days} días'
Asi quedo el SerializerMetodField para calcular la experiencia de los doctores. Esta hecha basada en el modelo DoctorAvailability pero seguramente se puede hacer mucho mejor desde el modelo Doctor.
class DoctorAvailabilitySerializer(serializers.ModelSerializer): experience = serializers.SerializerMethodField() class Meta: model = DoctorAvailability fields = [ 'doctor', 'experience', 'start_date', 'end_date', 'start_time', 'end_time', ] def get_experience(self, obj): """ Return the doctor experience in years """ # get age in days (timedelta) experience_timedelta = date.today() - obj.start_date years = experience_timedelta.days // 365 return f"{years}"