Acciones en Django Rest con decorador @action

Clase 14 de 21 • Curso de Django Rest Framework

Resumen

Crear acciones en Django Rest Framework con seguridad y claridad mejora la experiencia de desarrollo y la de quienes consumen la API. Aquí verás cómo implementar acciones en un view set para gestionar estados como vacaciones, cómo asegurar endpoints idempotentes y cómo optimizar la URL con url_path para legibilidad y SEO.

¿Cómo crear acciones en Django Rest Framework con view sets?

Agregar acciones a recursos permite ejecutar comportamientos específicos sobre un ítem, como activar o desactivar un estado. En DRF se logra con el decorador @action dentro de un view set, definiendo los métodos permitidos y si actúa sobre detalle con detail=True.

Acciones: comportamientos sobre recursos como pagos o estados.
Decorador @action: añade rutas personalizadas al view set.
detail=True: la acción usa el ID del recurso en la URL.
methods=['post']: restringe la acción a POST.
get_object: recuperación segura del objeto actual en el view set.

¿Qué pasos aplicar en el modelo y migraciones?

Primero, añade el campo booleano en el modelo del doctor. Por defecto inicia en False.

# models.py
class Doctor(models.Model):
    # otros campos...
    is_on_vacation = models.BooleanField(default=False)

Crea y aplica migraciones.

python manage.py makemigrations
python manage.py migrate

¿Cómo definir una acción POST con detail true?

Usa @action para crear dos rutas: una para encender el estado y otra para apagarlo. Importa el decorador y la respuesta de DRF.

# views.py
from rest_framework.decorators import action
from rest_framework.response import Response
from rest_framework.viewsets import ModelViewSet

class DoctorViewSet(ModelViewSet):
    queryset = Doctor.objects.all()

    @action(detail=True, methods=['post'], url_path='set-on-vacation')
    def set_on_vacation(self, request, pk=None):
        doctor = self.get_object()
        doctor.is_on_vacation = True
        doctor.save()
        return Response({'status': 'el doctor está en vacaciones'})

    @action(detail=True, methods=['post'], url_path='set-off-vacation')
    def set_off_vacation(self, request, pk=None):
        doctor = self.get_object()
        doctor.is_on_vacation = False
        doctor.save()
        return Response({'status': 'el doctor no está en vacaciones'})

Claves de esta implementación:

Self, request y pk: la acción recibe el contexto del view set y el ID del recurso.
get_object: reutiliza lógica de filtros y permisos del view set.
Response: siempre retorna contenido útil para el cliente.

¿Qué rol cumple get_object en la acción?

En lugar de consultar manualmente el queryset, self.get_object() obtiene el recurso actual aplicando filtros y validaciones del view set. Esto evita duplicar lógica y reduce errores al modificar código que ya funciona.

¿Por qué la idempotencia importa en endpoints REST?

Un endpoint debe permitir reintentos sin cambiar el resultado final si el mismo comando se repite. Por eso, en vez de un "toggle" que alterna valores con cada request, conviene implementar acciones explícitas: “encender” y “apagar”.

Idempotencia: repetir requests no altera el estado final.
Evita confusiones: un “toggle” puede dejar el estado inesperado si hay reintentos tras fallos.
Diseño claro: acciones como set-on y set-off comunican intención.

Ejemplo no recomendado por no ser idempotente:

@action(detail=True, methods=['post'])
def toggle_vacation(self, request, pk=None):
    doctor = self.get_object()
    doctor.is_on_vacation = not doctor.is_on_vacation
    doctor.save()
    return Response({'status': 'actualizado'})

¿Cómo optimizar las URLs de acciones para SEO y legibilidad?

DRF genera la ruta de la acción a partir del nombre del método, lo que suele crear rutas con guiones bajos. Para mejorar legibilidad y SEO, define la ruta con url_path usando guiones.

url_path: establece la ruta pública de la acción.
kebab-case: preferible a snake_case en URLs.
Consistencia: facilita el consumo y la documentación.

Ejemplo con guiones:

@action(detail=True, methods=['post'], url_path='set-on-vacation')
def set_on_vacation(self, request, pk=None):
    # implementación...
    pass

¿Listo para practicar? Implementa en el view set de pacientes una acción que devuelva el reporte de la historia clínica en JSON vía POST. ¿Cómo mostrarías el texto en formato JSON y qué clave usarías en la respuesta? Comparte tu enfoque en los comentarios.

Comentarios

Antonio Demarco Bonino

student•

Dejo el reto por aquí:

from rest_framework import viewsets
from rest_framework.decorators import action
from rest_framework.response import Response
from .models import Patient, MedicalHistory
from .serializers import MedicalHistorySerializer

class PatientViewSet(viewsets.ModelViewSet):
    queryset = Patient.objects.all()
    serializer_class = MedicalHistorySerializer  # Se utiliza en las acciones personalizadas

    # Acción personalizada para agregar un nuevo historial clínico
    @action(['POST'], detail=True, url_path='add-medical-history')
    def add_medical_history(self, request, pk=None):
        patient = self.get_object()  # Obtener el paciente por su pk
        data = request.data  # Obtener los datos del historial clínico desde la solicitud
        data['patient'] = patient.id  # Asignar el paciente al historial clínico
        serializer = MedicalHistorySerializer(data=data)
        
        if serializer.is_valid():
            serializer.save()  # Guardar el historial clínico
            return Response({"status": "Medical history added"}, status=201)
        return Response(serializer.errors, status=400)  # Retornar errores si los datos no son válidos

    # Acción personalizada para listar el historial clínico de un paciente
    @action(['GET'], detail=True, url_path='medical-history')
    def list_medical_history(self, request, pk=None):
        patient = self.get_object()  # Obtener el paciente por su pk
        medical_history = MedicalHistory.objects.filter(patient=patient)  # Filtrar el historial clínico por paciente
        serializer = MedicalHistorySerializer(medical_history, many=True)
        return Response(serializer.data)  # Retornar el historial clínico en formato JSON

Juan Camilo Jaramillo Tascón

student•

Para este caso sería bueno si nos puedes compartir el modelo MedicalHistory :), igual gracias por tu aporte.

Andres Trujillo

student•

cool!

Alvaro Emilio Dangond Rojas

student•

from rest_framework import viewsets
from rest_framework.decorators import action
from rest_framework.response import Response
from .models import Patient, Insurance, MedicalRecord
from .serializers import PatientSerializer

# 🧑‍⚕️ ViewSet para gestionar pacientes y consultar su historia clínica
class PatientViewSet(viewsets.ModelViewSet):
    """
    API endpoint que permite ver, crear, actualizar y eliminar pacientes.
    También incluye una acción personalizada para consultar la historia clínica completa.
    """
    queryset = Patient.objects.all()
    serializer_class = PatientSerializer

    @action(detail=True, methods=['get'], url_path='clinical-history')
    def clinical_history(self, request, pk=None):
        """
        Devuelve el reporte de historia clínica del paciente en formato JSON.
        Incluye datos personales, historial médico, seguros y registros clínicos.
        """
        patient = self.get_object()

        # Seguros
        insurances = patient.insurances.all().values(
            'provider', 'policy_number', 'expiration_date'
        )

        # Registros médicos
        records = patient.medical_records.all().values(
            'date', 'diagnosis', 'treatment', 'follow_up_date'
        )

        report = {
            "patient": {
                "id": patient.id,
                "full_name": f"{patient.first_name} {patient.last_name}",
                "date_of_birth": patient.date_of_birth,
                "contact_number": patient.contact_number,
                "email": patient.email,
                "address": patient.address,
                "medical_history": patient.medical_history,
            },
            "insurances": list(insurances),
            "medical_records": list(records),
        }

        return Response(report)
```from rest\_framework import viewsetsfrom rest\_framework.decorators import actionfrom rest\_framework.response import Responsefrom .models import Patient, Insurance, MedicalRecordfrom .serializers import PatientSerializer
\# 🧑‍⚕️ ViewSet para gestionar pacientes y consultar su historia clínicaclass PatientViewSet(viewsets.ModelViewSet):    """    API endpoint que permite ver, crear, actualizar y eliminar pacientes.    También incluye una acción personalizada para consultar la historia clínica completa.    """    queryset = Patient.objects.all()    serializer\_class = PatientSerializer
    @action(detail=True, methods=\['get'], url\_path='clinical-history')    def clinical\_history(self, request, pk=None):        """        Devuelve el reporte de historia clínica del paciente en formato JSON.        Incluye datos personales, historial médico, seguros y registros clínicos.        """        patient = self.get\_object()
        # Seguros        insurances = patient.insurances.all().values(            'provider', 'policy\_number', 'expiration\_date'        )
        # Registros médicos        records = patient.medical\_records.all().values(            'date', 'diagnosis', 'treatment', 'follow\_up\_date'        )
        report = {            "patient": {                "id": patient.id,                "full\_name": f"{patient.first\_name} {patient.last\_name}",                "date\_of\_birth": patient.date\_of\_birth,                "contact\_number": patient.contact\_number,                "email": patient.email,                "address": patient.address,                "medical\_history": patient.medical\_history,            },            "insurances": list(insurances),            "medical\_records": list(records),        }
        return Response(report)

Andres Trujillo

student•

My solutiosn 🫨:

class ListPatientView(viewsets.ModelViewSet):
    serializer_class = PatientSerializer
    queryset = Patient.objects.all()

    @action(["GET"], detail=True, url_path="get-medical-history")
    def get_medical_history(self, request, pk):
        patient = self.get_object()
        return Response({"medical_history": patient.medical_history})

Damian Rengifo

student••

Esta fue mi solucion al reto, fue un poco complicado por que tuve que investigar como cambiar correctamente el serializer segun la accion

from rest_framework import viewsets, status

from rest_framework.response import Response

from rest_framework.decorators import action

from .serializers import PatientSerializers, InsuranceSerializers, MedicalRecordSerializers

from .models import Patient, Insurance, MedicalRecord

class PatientViewSet(viewsets.ModelViewSet):

"""

Endpoints GET, PUT, PATCH, POST AND DELETE for the manage of the patients

"""

serializer_class = PatientSerializers

queryset = Patient.objects.all()

def get_serializer_class(self):

if self.action == 'generate_medical_history':

return MedicalRecordSerializers

return super().get_serializer_class()

@action(['POST'], detail=True, url_path='generate-medical-history')

def generate_medical_history(self, request, pk) -> Response:

'''

Action for create a medical history for a patient created recently with the method POST in this endpoint.

Args: pk(id_patient) pk of the patient created recently

'''

patient = self.get_object()

data = request.data.copy()

data['patient'] = patient.id

serializador = MedicalRecordSerializers(data=data)

serializador.is_valid(raise_exception=status.HTTP_422_UNPROCESSABLE_ENTITY)

serializador.save()

return Response(serializador.data, status=status.HTTP_201_CREATED)

@action(['GET'], detail=True, url_path='consult-medic-history')

def consult_medic_history(self, request, pk) -> Response:

'''

Action for consult the medic history of a pacient

args = pk(patient_id), with this argument you can obtain the medical records of the patient with that pk

'''

patient = self.get_object()

medical_records = MedicalRecord.objects.filter(patient=patient)

serializador = MedicalRecordSerializers(medical_records, many=True)

code = status.HTTP_200_OK if medical_records.count() > 0 else status.HTTP_204_NO_CONTENT

return Response(serializador.data, status=code)

Ernesto Jose Gomez Flores

student•

Solucion al reto:

from rest_framework import viewsets
from rest_framework.decorators import action
from rest_framework.response import Response
from rest_framework import status

from .serializers import PatientSerializer, MedicalRecordSerializer
from .models import Patient

# Create your views here.


class PatientViewSet(viewsets.ModelViewSet):
    '''
    Vista basada en conjunto de vistas para el modelo Patient.
    Proporciona operaciones CRUD completas para el modelo Patient.
    * Atributos:
        - serializer_class: Serializador para el modelo Patient.
        - queryset: Conjunto de todos los objetos Patient.
    '''
    serializer_class = PatientSerializer
    queryset = Patient.objects.all()

    def get_serializer_class(self):
        '''
        Retorna el serializador apropiado según la acción.
        - Para `add_medical_record`, usa `MedicalRecordSerializer`.
        - Para el resto, usa el `PatientSerializer` por defecto.
        '''
        if self.action == 'add_medical_record':
            return MedicalRecordSerializer
        return super().get_serializer_class()

    #Actions personalizado para agregar un nuevo historial medico
    @action(detail=True, methods=["post"], url_path="add-medical-record")
    def add_medical_record(self, request, pk) -> Response:
        '''
        Agrega un nuevo historial médico a un paciente existente.

        Parámetros:
        - request: Objeto de solicitud HTTP que contiene los datos del historial médico.
        - pk: ID del paciente al que se le agregará el historial médico.

        Retorna:
        - Response: Objeto de respuesta HTTP con el historial médico creado o errores de validación.
        '''
        patient = self.get_object()
        # Obtenemos el serializador a través del método que ya hemos definido
        serializer = self.get_serializer(data=request.data)
        serializer.is_valid(raise_exception=True)
        serializer.save(patient=patient)
        return Response(serializer.data, status=status.HTTP_201_CREATED)

    #Action personalizado para mostrar el historial medico del paciente en formato JSON
    @action(["GET"], detail=True, url_path="medical-record")
    def medical_record(self, request, pk) -> Response:
        '''
        Recupera el historial médico de un paciente específico.
        Parámetros:
        - request: Objeto de solicitud HTTP.
        - pk: ID del paciente cuyo historial médico se va a recuperar.
        Retorna:
        - Response: Objeto de respuesta HTTP con los datos del historial médico del paciente.
        '''
        patient = self.get_object()
        medical_records = patient.medical_records.all()
        serializer = MedicalRecordSerializer(medical_records, many=True)
        return Response(serializer.data)

Manuel Galindo

student•

Ventajas de utilizar acciones personalizadas en viewsets con Django Rest Framework:

Flexibilidad: Permiten agregar funcionalidades específicas que no están cubiertas por las acciones predeterminadas.
Reutilización de lógica: Facilitan la reutilización de lógica común en diferentes partes de la API.
URLs claras y específicas: Generan rutas URL intuitivas y específicas para las acciones personalizadas.
Mejor organización: Mantienen la lógica relacionada en un solo lugar, mejorando la estructura del código.
Facilitan la extensión: Hacen más sencillo extender la API con nuevas funcionalidades sin modificar las acciones básicas.

Zareth Alvarez

student•

Comparto viewsets de doctors:

from rest_framework import viewsets from .serializers import DoctorSerializer, DepartmentSerializer, DoctorAvailabilitySerializer, MedicalNoteSerializerfrom .models import Doctor, Department, DoctorAvailability, MedicalNote class DoctorViewSet(viewsets.ModelViewSet): serializer_class=DoctorSerializer queryset = Doctor.objects.all()

class DepartmentViewSet(viewsets.ModelViewSet): serializer_class = DepartmentSerializer queryset = Department.objects.all() class DoctorAvailabilityViewSet(viewsets.ModelViewSet): serializer_class = DoctorAvailabilitySerializer queryset = DoctorAvailability.objects.all() class MedicalNoteViewSet(viewsets.ModelViewSet): serializer_class = MedicalNoteSerializer queryset = MedicalNote.objects.all()

Zareth Alvarez

student•

urls. py de doctors de el reto de la clase:

Johan Moises Ariza Mahecha

student•

Comparto mi solución al reto:

from rest_framework import viewsets
from rest_framework.decorators import action 
from rest_framework.response import Response

from .serializers import PatientSerializer, InsuranceSerializer, MedicalRecordSerializer
from .models import Patient, Insurance, MedicalRecord

class PatientViewSets(viewsets.ModelViewSet):
    serializer_class = PatientSerializer
    queryset = Patient.objects.all()

    @action(["GET"], detail=True)
    def show_medical_record(self, requests, pk):
        patient = self.get_object() #Obtenemos el objeto de paciente especifico de esta vista
        medical_record = MedicalRecord.objects.filter(patient = patient)# Traemos todos los medical records relacionados con el paciente
        serializer = MedicalRecordSerializer(medical_record, many=True)#Lo serializamos y lo devolvemos como JSON para ser usado por la API.
        return Response(serializer.data)#Devolvemos los datos de ese JSON
```También el JSON para que se pueda usar en el modelo de Medical Record.

```js
{
        "id": 1,
        "date": "2025-04-10",
        "diagnosis": "Gripe común con síntomas leves como congestión nasal, dolor de garganta y fiebre moderada.",
        "treatment": "Reposo en casa, hidratación abundante, paracetamol cada 8 horas durante 3 días.",
        "follow_up_date": "2025-04-17",
        "patient": 1
    }

Andres Trujillo

student•

Nueva clase, nuevos conocimientos, super genial todo :')

Ederson Felipe Lopez Bolivar

student•

Un ViewSet en Django REST Framework genera automáticamente varias acciones y URLs para manejar operaciones CRUD sobre los recursos. Aquí están las acciones básicas que crea:

Listar: GET /<modelo>/
Crear: POST /<modelo>/
Leer (detalle): GET /<modelo>/<id>/
Actualizar: PUT /<modelo>/<id>/
Parcialmente actualizar: PATCH /<modelo>/<id>/
Eliminar: DELETE /<modelo>/<id>/

Además, si defines acciones personalizadas usando el decorador @action, puedes crear URLs adicionales según la lógica de negocio que necesites, como POST /<modelo>/set_on_vacation/ o similar, dependiendo de cómo lo implementes en tu código. Estas URLs se generan automáticamente siguiendo la convención de nombres y los métodos HTTP permitidos.

from rest_framework import viewsets
from rest_framework.decorators import action
from rest_framework.response import Response
from .models import Patient, MedicalHistory
from .serializers import MedicalHistorySerializer

class PatientViewSet(viewsets.ModelViewSet):
    queryset = Patient.objects.all()
    serializer_class = MedicalHistorySerializer  # Se utiliza en las acciones personalizadas

    # Acción personalizada para agregar un nuevo historial clínico
    @action(['POST'], detail=True, url_path='add-medical-history')
    def add_medical_history(self, request, pk=None):
        patient = self.get_object()  # Obtener el paciente por su pk
        data = request.data  # Obtener los datos del historial clínico desde la solicitud
        data['patient'] = patient.id  # Asignar el paciente al historial clínico
        serializer = MedicalHistorySerializer(data=data)
        
        if serializer.is_valid():
            serializer.save()  # Guardar el historial clínico
            return Response({"status": "Medical history added"}, status=201)
        return Response(serializer.errors, status=400)  # Retornar errores si los datos no son válidos

    # Acción personalizada para listar el historial clínico de un paciente
    @action(['GET'], detail=True, url_path='medical-history')
    def list_medical_history(self, request, pk=None):
        patient = self.get_object()  # Obtener el paciente por su pk
        medical_history = MedicalHistory.objects.filter(patient=patient)  # Filtrar el historial clínico por paciente
        serializer = MedicalHistorySerializer(medical_history, many=True)
        return Response(serializer.data)  # Retornar el historial clínico en formato JSON

from rest_framework import viewsets
from rest_framework.decorators import action
from rest_framework.response import Response
from .models import Patient, Insurance, MedicalRecord
from .serializers import PatientSerializer

# 🧑‍⚕️ ViewSet para gestionar pacientes y consultar su historia clínica
class PatientViewSet(viewsets.ModelViewSet):
    """
    API endpoint que permite ver, crear, actualizar y eliminar pacientes.
    También incluye una acción personalizada para consultar la historia clínica completa.
    """
    queryset = Patient.objects.all()
    serializer_class = PatientSerializer

    @action(detail=True, methods=['get'], url_path='clinical-history')
    def clinical_history(self, request, pk=None):
        """
        Devuelve el reporte de historia clínica del paciente en formato JSON.
        Incluye datos personales, historial médico, seguros y registros clínicos.
        """
        patient = self.get_object()

        # Seguros
        insurances = patient.insurances.all().values(
            'provider', 'policy_number', 'expiration_date'
        )

        # Registros médicos
        records = patient.medical_records.all().values(
            'date', 'diagnosis', 'treatment', 'follow_up_date'
        )

        report = {
            "patient": {
                "id": patient.id,
                "full_name": f"{patient.first_name} {patient.last_name}",
                "date_of_birth": patient.date_of_birth,
                "contact_number": patient.contact_number,
                "email": patient.email,
                "address": patient.address,
                "medical_history": patient.medical_history,
            },
            "insurances": list(insurances),
            "medical_records": list(records),
        }

        return Response(report)
```from rest\_framework import viewsetsfrom rest\_framework.decorators import actionfrom rest\_framework.response import Responsefrom .models import Patient, Insurance, MedicalRecordfrom .serializers import PatientSerializer
\# 🧑‍⚕️ ViewSet para gestionar pacientes y consultar su historia clínicaclass PatientViewSet(viewsets.ModelViewSet):    """    API endpoint que permite ver, crear, actualizar y eliminar pacientes.    También incluye una acción personalizada para consultar la historia clínica completa.    """    queryset = Patient.objects.all()    serializer\_class = PatientSerializer
    @action(detail=True, methods=\['get'], url\_path='clinical-history')    def clinical\_history(self, request, pk=None):        """        Devuelve el reporte de historia clínica del paciente en formato JSON.        Incluye datos personales, historial médico, seguros y registros clínicos.        """        patient = self.get\_object()
        # Seguros        insurances = patient.insurances.all().values(            'provider', 'policy\_number', 'expiration\_date'        )
        # Registros médicos        records = patient.medical\_records.all().values(            'date', 'diagnosis', 'treatment', 'follow\_up\_date'        )
        report = {            "patient": {                "id": patient.id,                "full\_name": f"{patient.first\_name} {patient.last\_name}",                "date\_of\_birth": patient.date\_of\_birth,                "contact\_number": patient.contact\_number,                "email": patient.email,                "address": patient.address,                "medical\_history": patient.medical\_history,            },            "insurances": list(insurances),            "medical\_records": list(records),        }
        return Response(report)

class ListPatientView(viewsets.ModelViewSet):
    serializer_class = PatientSerializer
    queryset = Patient.objects.all()

    @action(["GET"], detail=True, url_path="get-medical-history")
    def get_medical_history(self, request, pk):
        patient = self.get_object()
        return Response({"medical_history": patient.medical_history})

from rest_framework import viewsets
from rest_framework.decorators import action
from rest_framework.response import Response
from rest_framework import status

from .serializers import PatientSerializer, MedicalRecordSerializer
from .models import Patient

# Create your views here.


class PatientViewSet(viewsets.ModelViewSet):
    '''
    Vista basada en conjunto de vistas para el modelo Patient.
    Proporciona operaciones CRUD completas para el modelo Patient.
    * Atributos:
        - serializer_class: Serializador para el modelo Patient.
        - queryset: Conjunto de todos los objetos Patient.
    '''
    serializer_class = PatientSerializer
    queryset = Patient.objects.all()

    def get_serializer_class(self):
        '''
        Retorna el serializador apropiado según la acción.
        - Para `add_medical_record`, usa `MedicalRecordSerializer`.
        - Para el resto, usa el `PatientSerializer` por defecto.
        '''
        if self.action == 'add_medical_record':
            return MedicalRecordSerializer
        return super().get_serializer_class()

    #Actions personalizado para agregar un nuevo historial medico
    @action(detail=True, methods=["post"], url_path="add-medical-record")
    def add_medical_record(self, request, pk) -> Response:
        '''
        Agrega un nuevo historial médico a un paciente existente.

        Parámetros:
        - request: Objeto de solicitud HTTP que contiene los datos del historial médico.
        - pk: ID del paciente al que se le agregará el historial médico.

        Retorna:
        - Response: Objeto de respuesta HTTP con el historial médico creado o errores de validación.
        '''
        patient = self.get_object()
        # Obtenemos el serializador a través del método que ya hemos definido
        serializer = self.get_serializer(data=request.data)
        serializer.is_valid(raise_exception=True)
        serializer.save(patient=patient)
        return Response(serializer.data, status=status.HTTP_201_CREATED)

    #Action personalizado para mostrar el historial medico del paciente en formato JSON
    @action(["GET"], detail=True, url_path="medical-record")
    def medical_record(self, request, pk) -> Response:
        '''
        Recupera el historial médico de un paciente específico.
        Parámetros:
        - request: Objeto de solicitud HTTP.
        - pk: ID del paciente cuyo historial médico se va a recuperar.
        Retorna:
        - Response: Objeto de respuesta HTTP con los datos del historial médico del paciente.
        '''
        patient = self.get_object()
        medical_records = patient.medical_records.all()
        serializer = MedicalRecordSerializer(medical_records, many=True)
        return Response(serializer.data)

from rest_framework import viewsets
from rest_framework.decorators import action 
from rest_framework.response import Response

from .serializers import PatientSerializer, InsuranceSerializer, MedicalRecordSerializer
from .models import Patient, Insurance, MedicalRecord

class PatientViewSets(viewsets.ModelViewSet):
    serializer_class = PatientSerializer
    queryset = Patient.objects.all()

    @action(["GET"], detail=True)
    def show_medical_record(self, requests, pk):
        patient = self.get_object() #Obtenemos el objeto de paciente especifico de esta vista
        medical_record = MedicalRecord.objects.filter(patient = patient)# Traemos todos los medical records relacionados con el paciente
        serializer = MedicalRecordSerializer(medical_record, many=True)#Lo serializamos y lo devolvemos como JSON para ser usado por la API.
        return Response(serializer.data)#Devolvemos los datos de ese JSON
```También el JSON para que se pueda usar en el modelo de Medical Record.

```js
{
        "id": 1,
        "date": "2025-04-10",
        "diagnosis": "Gripe común con síntomas leves como congestión nasal, dolor de garganta y fiebre moderada.",
        "treatment": "Reposo en casa, hidratación abundante, paracetamol cada 8 horas durante 3 días.",
        "follow_up_date": "2025-04-17",
        "patient": 1
    }

Acciones en Django Rest con decorador @action

Fundamentos de Django Rest Framework

Django REST Framework para APIs escalables

Qué son las APIs y cómo funcionan

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 en Django Rest con decorador @action

Autenticación y permisos en Django Rest Framework

Validaciones custom en Django Rest Framework

Serializadores Avanzados

Serializadores anidados en Django REST Framework

Serializer_method_field para cálculos en Django REST

Endpoint anidado para agendar citas médicas

Testing y Desempeño

Unit tests con ApiClient en Django REST

Throttling en Django Rest para evitar ataques DOS