Django REST Framework 序列化具有 ForeignKey 和 ManyToManyFields 字段/关系的模型

最后，在获取嵌套在我的 api 生成的 JSON 文档中的响应中的数据的情况下django-rest-framework，我选择了以下解决方案：

我从头开始描述已经完成的工作，所以我将首先展示我最初定义的模型是什么，我如何序列化它们，如何生成视图或端点，最后如何router's建立路由 ()暴露他们类型URLConf

这些是我定义的模型

1.PatientProfile模型，定义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.modelMedicalProfile定义在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定义在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)

序列化

我以这种方式对这些模型进行了序列化：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')

Las vistas que exponen como endpoints los modelos serializados anteriores estan dadas en userprofiles/views.py de esta forma:

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

Presento el modelo RehabilitationSessions localizado en medical_encounter_information/models.py el cual tiene tres llaves foráneas a los anteriores perfiles de usuarios PatientProfile , MedicalProfile y 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

La serialización de los campos de la clase RehabilitationSession esta dada por la clase RehabilitationSessionSerializer localizada en medical_encounter_information/serializers.py

Es aqui en donde tenia mis dudas acerca de como realizar la serializacion y para lo cual estaba consultando un poco acerca de como se manejan las relaciones en Django REST Framework.

Encontré en la documentación como trabajar la serialización de manera anidada sin la necesidad de recurrir a clases extras del tipo Serializer Relationships.

La clave está en adicionar un campo llamado depth el cual permite de manera recursiva n niveles de profundidad (no se realmente hasta que número determinado de niveles) para poder serializar los subdocumentos JSON que tengamos, en este caso los que traía cada ForeignKey de cada perfil de usuario necesitado en una sesión de rehabilitación (PatientProfile,MedicalProfile, TherapistProfile)

Aquí dice lo siguiente:

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.

Entonces mi clase RehabilitationSessionSerializer queda asi:

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

La vista ViewSet que expone esta serialización esta dada de esta forma en 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

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

我还发现了这个字段的嵌套或递归序列化示例，但这次它是相同的模型，有趣且非常必要，对于网络上一个非常常见的示例，即评论和对这些相同评论的响应。

我还要非常感谢您的想法和指导，它们对我找到解决方案很有用：D

使用嵌套关系

例如：

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')

其中来自Album模型的曲目是Track模型的外键。

小心嵌套关系，它们对你的 API 来说是一个性能杀手，我在这篇文章中谈到它：http: //miguelgomez.io/python/optimizador-django-rest-framework/

另一方面，我会使用该类MethodSerializers来使序列化程序尽可能地自定义。

一切顺利。