Django REST Framework Serializing models that have ForeignKey and ManyToManyFields fields/relationships

Finally, in the case of obtaining the data in my response nested in the JSON's document(s) that my api generates with django-rest-framework, I have opted for the following solution:

I return from the beginning to give a description of what has been done, so I will start by showing what my originally defined models are, how I serialized them, how the views or endpoints are generated and finally how the routes ( router's) are established to expose them typeURLConf

These are my defined models

1.PatientProfile model, defineduserprofiles/models.py

class PatientProfile(models.Model):
    user = models.OneToOneField(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
    full_name = models.CharField(max_length=64)
    time_of_evolution = models.CharField(max_length=64, blank=False)
    diagnostic = models.TextField(blank=True)
    
    class Meta:
        verbose_name='Usuarios con perfil de pacientes'

    def __str__(self):
        return '%s %s' % (self.user.first_name, self.user.last_name)

2.modelMedicalProfile defined inuserprofiles/models.py

class MedicalProfile(models.Model):
    user = models.OneToOneField(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
    full_name = models.CharField(max_length=64)
    specialty = models.CharField(max_length=64)

    class Meta:
        verbose_name='Usuarios con perfil de médicos'

    def __str__(self):
        return '%s %s' % (self.user.first_name, self.user.last_name)

3.TherapistProfile defined inuserprofiles/models.py

class TherapistProfile(models.Model):
    user = models.OneToOneField(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
    full_name = models.CharField(max_length=64)
    specialty = models.CharField(max_length=64)

    class Meta:
        verbose_name='Usuarios con perfil de terapeutas'

    def __str__(self):
        return '%s %s' % (self.user.first_name, self.user.last_name)

serializing

I have the serialization of these models in this way:userprofiles/serializers.py

from .models import PatientProfile, MedicalProfile, TherapistProfile
from rest_framework import serializers

class PatientProfileSerializer(serializers.HyperlinkedModelSerializer):
        class Meta:
            model = PatientProfile
            fields = ('url','id','user','full_name','time_of_evolution','diagnostic','marital_status','educational_level','partner_full_name','partner_relationship','partner_phone','partner_gender',
                      'care_provider',)

class MedicalProfileSerializer(serializers.HyperlinkedModelSerializer):
        class Meta:
            model = MedicalProfile
            fields = ('url','id','user','full_name','specialty')
    
class TherapistProfileSerializer(serializers.HyperlinkedModelSerializer):
        class Meta:
            model = TherapistProfile
            fields = ('url','id','user','full_name','specialty')

The views that expose like endpointsthe serialized models above are given in userprofiles/views.pythis form:

from .models import PatientProfile, MedicalProfile, TherapistProfile
from rest_framework import viewsets
from .serializers import (PatientProfileSerializer, MedicalProfileSerializer, TherapistProfileSerializer,)

class PatientProfileViewSet(viewsets.ModelViewSet):
    queryset = PatientProfile.objects.all()
    serializer_class = PatientProfileSerializer

class MedicalProfileViewSet(viewsets.ModelViewSet):
    queryset = MedicalProfile.objects.all()
    serializer_class = MedicalProfileSerializer

class TherapistProfileViewSet(viewsets.ModelViewSet):
    queryset = TherapistProfile.objects.all()
    serializer_class = TherapistProfileSerializer

I present the model RehabilitationSessionslocated in medical_encounter_information/models.py which has three foreign keys to the previous user profiles PatientProfile, MedicalProfileandTherapistProfile

from django.db import models
from smart_selects.db_fields import ChainedManyToManyField
from django.utils import timezone

from multiselectfield import MultiSelectField

class RehabilitationSession(models.Model):

    EXTREMITY_CHOICES = (
        ('Extremidad superior derecha', 'Superior Derecha'),
        ('Extremidad superior izquierda', 'Superior Izquierda'),
    )

    # Primer campo con ForeignKey relationship 
    patient = models.ForeignKey('userprofiles.PatientProfile',      null=True, blank=True,                                verbose_name='Paciente', related_name='patientprofile')
    
    # Segundo campo con ForeignKey relationship 
    medical = models.ForeignKey('userprofiles.MedicalProfile', null=True, blank=True,
                                verbose_name='Médico tratante', related_name='medicalprofile')

    # Tercer campo con ForeignKey relationship
    therapist = models.ForeignKey('userprofiles.TherapistProfile', null=True, blank=True,
                               verbose_name='Terapeuta')


    date_session_begin = models.DateTimeField(default=timezone.now(), verbose_name = 'Fecha de inicio')
  
    upper_extremity = MultiSelectField(
        max_length=255,
        choices=EXTREMITY_CHOICES,
        blank=False,
        verbose_name='Extremidad Superior'
    )

    affected_segment = models.ManyToManyField(AffectedSegment,verbose_name='Segmento afectado', related_name='affectedsegment')
    movement = ChainedManyToManyField(
        Movement, #Modelo encadenado
        chained_field = 'affected_segment',
        chained_model_field = 'corporal_segment_associated',
        verbose_name='Movimiento'
    )

    metrics = models.ManyToManyField(Metric, blank=True, verbose_name='Métrica')
    date_session_end = models.DateTimeField(default=timezone.now(), verbose_name = 'Fecha de finalización')
    period = models.CharField(max_length=25,blank=True, verbose_name='Tiempo de duración de la sesión')

    observations = models.TextField(blank=False, verbose_name='Observaciones')

    class Meta:
        verbose_name = 'Sesiones de Rehabilitación'

    def __str__(self):
        return "%s" % self.patient

The serialization of the fields of the class RehabilitationSessionis given by the class RehabilitationSessionSerializerlocated inmedical_encounter_information/serializers.py

This is where I had my doubts about how to perform serialization and for which I was asking a bit about how relationships are handled in the Django REST Framework .

I found in the documentation how to work serialization in a nested way without the need to resort to extra classes of the Serializer Relationships type .

The key is to add a field called depthwhich recursively allows n levels of depth (I don't really know up to what number of levels) to be able to serialize the JSON subdocuments that we have, in this case the ones that each ForeignKeyof each user profile brought needed in a rehabilitation session ( PatientProfile, MedicalProfile, TherapistProfile)

Here it says the following:

The depth option should be set to an integer value that indicates the depth of relationships that should be traversed before reverting to a flat representation.

If you want to customize the way the serialization is done you'll need to define the field yourself.

So my class RehabilitationSessionSerializerlooks like this:

from .models import (RehabilitationSession,) 
from rest_framework import serializers
class RehabilitationSessionSerializer(serializers.ModelSerializer):

    class Meta:
        model = RehabilitationSession
        fields = ('url','id','patient','medical','therapist','affected_segment','movement','metrics','date_session_begin',
                  'status','slug', 'date_session_end','period','games','game_levels',
                  'iterations','observations',)
        #read_only_fields = ('patient','medical','therapist',)
        depth=1

The view ViewSetthat exposes this serialization is given in this waymedical_encounter_information/views.py

from .models import RehabilitationSession
from rest_framework import viewsets
from .serializers import (RehabilitationSessionSerializer,)

class RehabilitationSessionViewSet(viewsets.ModelViewSet):
    queryset = RehabilitationSession.objects.all()
    serializer_class = RehabilitationSessionSerializer

Mis rutas/routers en urls.py para el acceso a los modelos expuestos via rest framework son:

from rest_framework import routers
from userprofiles.views import PatientProfileViewSet,                 MedicalProfileViewSet, TherapistProfileViewSet

from medical_encounter_information.views import (RehabilitationSessionViewSet, AffectedSegmentViewSet, MovementViewSet,
                                                 MetricViewSet,)

# Routers provide an easy way of automatically determining the URL conf.
# Because we're using viewsets instead of views, we can automatically
# generate the URL conf for our API, by simply registering the viewsets with a router class.
router = routers.DefaultRouter()
router.register(r'rehabilitationsession', RehabilitationSessionViewSet)
router.register(r'patientprofile', PatientProfileViewSet)
router.register(r'medicalprofile', MedicalProfileViewSet)
router.register(r'therapistprofile', TherapistProfileViewSet)
router.register(r'affectedsegment', AffectedSegmentViewSet)
router.register(r'movement', MovementViewSet)
router.register(r'metrics', MetricViewSet)



urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^chaining/', include('smart_selects.urls')),
    url(r'^$', home, name='home'),
    
    url(r'^', include('userprofiles.urls')),
    #Call the userprofiles/urls.py

    url(r'^', include('medical_encounter_information.urls' )),
    #Call the medical_encounter_information/urls.py

    #REST Frameworks url's
    # Wire up our API using automatic URL routing.
    # Additionally, we include login URLs for the browsable API.

    url(r'^api/', include(router.urls)),
    url(r'^api-auth/', include('rest_framework.urls', namespace='rest_framework')),
    # Including default login and logout views for use with the browsable API.
    # That's optional, but useful if your API requires authentication and you want to use the browsable API.
    # Note that the URL path can be whatever you want, but you must include 'rest_framework.urls' with the 'rest_framework' namespace.
    # You may leave out the namespace in Django 1.9+, and REST framework will set it for you.
]

Es entonces que cuando consulto este API en mi navegador, el modelo RehabilitationSession que posee las tres claves foráneas a los modelos PatientProfile, MedicalProfile y TherapistProfile; al ser serializado me queda desplegado de la siguiente manera con los documentos de los respectivos perfiles de usuario mencionados, anidados:

Es así como pude tener una serialización de varios modelos en una misma vista por asi decirlo.

POr supuesto existen varias clases como las de Serialization relationships que permiten manejar las relaciones entre modelos en django rest framework acorde a lo que necesitemos, si es una url, si es un string, si es un campo de tipo slug o si es un campo tipo PrimaryKey o si es anidado como lo que necesitaba

I also found this example of nested or recursive serialization for fields, but this time it is the same model, interesting and very necessary, for a very common example on the web, which is comments and responses to those same comments.

I also want to thank you very much for the ideas and guidance, they were useful for me to find my solution :D

Use Nested Relations

For example:

class TrackSerializer(serializers.ModelSerializer):
    class Meta:
        model = Track
        fields = ('order', 'title', 'duration')

class AlbumSerializer(serializers.ModelSerializer):
    tracks = TrackSerializer(many=True, read_only=True)

    class Meta:
        model = Album
        fields = ('album_name', 'artist', 'tracks')

where tracks from the Album model is a foreign key to the Track model .

Be careful with nested relationships, they are a performance kill for your API, I talk about it in this post: http://miguelgomez.io/python/optimizador-django-rest-framework/

On the other hand, I would use the class MethodSerializersto make the serializers as custom as possible.

All the best.