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

Finally, in the case of obtaining in a nested way the data in my answer in the JSON 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 which are my originally defined models, how serialized, how the views or endpoints are generated and finally how the routes are established ( router's ) to expose them type URLConf

These are my defined models

1. PatientProfile model, defined userprofiles/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. MedicalProfile model defined in userprofiles/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 in userprofiles/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

The serialization of these models I have it in this way in 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 as endpoints the previous serialized models are given in userprofiles/views.py in this way:

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 RehabilitationSessions located in medical_encounter_information / models.py which has three foreign keys to the previous user profiles PatientProfile , MedicalProfile and TherapistProfile

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 RehabilitationSession is given by the class RehabilitationSessionSerializer located in medical_encounter_information/serializers.py

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

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

The key is to add a field called depth which recursively allows n levels of depth (not really until a certain number of levels) to be able to serialize the JSON subdocuments that we have, in this case the ones that were each ForeignKey of each user profile 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.

Then my class RehabilitationSessionSerializer stays 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 ViewSet view that this serialization exposes is given in this way in medical_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

My routes / routers in urls.py for access to the models exposed via rest framework are:

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.
]

It is then that when I consult this API in my browser, the RehabilitationSession model that has the three foreign keys to the models PatientProfile , MedicalProfile and TherapistProfile ; When it is serialized, it is displayed in the following way with the documents of the respective user profiles mentioned, nested:

This is how I could have a serialization of several models in the same view, so to speak.

Of course there are several classes like Serialization relationships that allow handle the relationships between models in django rest framework according to what we need, if it is a url, if it is a string, if it is a slug type field or if it is a PrimaryKey type field or if it is nested as what was needed

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

I also want to thank you very much for the ideas and guidelines, they were useful for finding 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 of the Album models is a foreign key to the Track model.

Beware of nested relationships, they are a kill performance for your API, I talk about it in this post: link

On the other hand, I would use the class MethodSerializers to create the serializers as personalized as possible.

Greetings.