Django Rest Framework POST verschachtelte Objekte

Sie haben es mit dem Problem von verschachtelte Serialisierung zu tun. Bitte lesen Sie die verknüpfte Dokumentation, bevor Sie fortfahren.

Ihre Frage bezieht sich auf einen komplexen Bereich von Problemen in DRF und erfordert daher einige Erklärungen und Diskussionen, um zu verstehen, wie Serializer und Viewsets funktionieren.

Ich werde das Problem der Darstellung Ihrer Subject- und Class -Daten über denselben Endpunkt diskutieren, indem eine unterschiedliche Darstellung von Daten für verschiedene HTTP-Methoden verwendet wird, da dies häufig das Problem ist, wenn Benutzer ihre Daten darstellen möchten Daten in verschachtelten Formaten; Sie möchten ihren Benutzerschnittstellen genügend Informationen für eine saubere Verwendung bereitstellen, z. durch die Dropdown-Selektoren.

Standardmäßig beziehen sich Django und Django REST Framework (DRF)) auf verwandte Objekte (Ihre Subject und Class) durch ihre Primärschlüssel Dies sind standardmäßig automatisch inkrementierende Ganzzahlschlüssel mit Django.Wenn Sie auf andere Weise auf sie verweisen möchten, müssen Sie Überschreibungen schreiben Hierfür gibt es verschiedene Möglichkeiten.

1. Die erste Möglichkeit besteht darin, Ihre Erstellungs- und Aktualisierungslogik zu spezialisieren: Wenden Sie sich über andere Attribute an Ihre Klasse, und schreiben Sie die Lookups für die Erstellung manuell, oder legen Sie den Schlüssel fest, auf den Sie sich beziehen durch als Primärschlüssel Ihrer Klasse. Sie können den Namen Ihrer Klasse, die UUID oder ein anderes Attribut als Primärdatenbankschlüssel festlegen, sofern es sich um ein eindeutiges einzelnes Feld (das Ich erwähne dies, weil Sie im Moment Ihre Class Modelle mit einer zusammengesetzten Suche durchsuchen, die aus einem zusammengesetzten Suchbegriff (Zahl, Buchstabe) besteht. Sie können verwandte Objekt-Lookups beispielsweise in Ihrer View-Methode create (für POST) überschreiben, müssen dann aber ähnliche Lookups auch in Ihrer View-Methode update (für PUT und PATCH) behandeln ).
2. Zweitens ist meiner Meinung nach die bevorzugte Option, Ihre Objektdarstellungen zu spezialisieren: Beziehen Sie sich auf Ihre Klassen normalerweise über den Primärschlüssel und erstellen Sie einen Serialisierer zum Lesen = das Objekt und eines zum Erstellen und Aktualisieren es. Dies kann auf einfache Weise durch Vererbung von Serializer-Klassen und Überschreiben Ihrer Darstellungen erreicht werden. Verwenden Sie den Primärschlüssel in Ihren POST-, PUT-, PATCH- usw. Anforderungen, um Ihre Klassenreferenzen und Fremdschlüssel zu aktualisieren.

Option 1: Klasse und Betreff mit einem beliebigen Attribut in create and update nachschlagen:

Legen Sie die verschachtelten Klassenserialisierer als schreibgeschützt fest:

class ExamSerializer(serializers.ModelSerializer):
    subject = SubjectSerializer(read_only=True)
    clazz = ClassSerializer(read_only=True)

Überschreiben Sie die Erstellung Ihrer Ansicht, um die zugehörigen Klassen in Freiformattributen nachzuschlagen. Lesen Sie auch wie DRF dies mit Mixins implementiert. Sie müssen auch Ihre update -Methode überschreiben, um diese korrekt zu behandeln, und die PATCH -Unterstützung (Teilaktualisierung) zusätzlich zu PUT (Aktualisierung) berücksichtigen, wenn Sie dies annehmen Route:

def create(self, request):
    # Look up objects by arbitrary attributes.
    # You can check here if your students are participating
    # the classes and have taken the subjects they sign up for.
    subject = get_object_or_404(Subject, title=request.data.get('subject'))
    clazz = get_object_or_404(
        Class, 
        number=request.data.get('clazz_number')
        letter=request.data.get('clazz_letter')
    )

    serializer = self.get_serializer(data=request.data)
    serializer.is_valid(raise_exception=True)
    serializer.save(clazz=clazz, subject=subject)
    headers = self.get_success_headers(serializer.data)

    return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers)

Option 2: Spezialisieren Sie Ihre Serializer auf Lesen und Schreiben und verwenden Sie Primärschlüssel. Dies ist der idiomatische Ansatz:

Definieren Sie zunächst einen Standard-ModelSerializer, den Sie für den normalen Betrieb verwenden möchten (POST, PUT, PATCH):

class ExamSerializer(serializers.ModelSerializer)
    class Meta:
        model = Exam
        fields = ('id', 'subject', 'clazz', 'topic', 'date', 'details')

Überschreiben Sie dann die erforderlichen Felder mit der Art der Darstellung, die Sie ihnen zum Lesen der Daten (GET) geben möchten:

class ExamReadSerializer(ExamSerializer):
     subject = SubjectSerializer(read_only=True)
     clazz = ClassSerializer(read_only=True)

Dann geben Sie den Serializer an, den Sie für verschiedene Operationen verwenden möchten für Ihr ViewSet. Hier geben wir die verschachtelten Betreff- und Klassendaten für Leseoperationen zurück, verwenden jedoch nur deren Primärschlüssel für Aktualisierungsoperationen (viel einfacher):

class ExamViewSet(viewsets.ModelViewSet):
     queryset = Exam.objects.all()

     def get_serializer_class(self):
         # Define your HTTP method-to-serializer mapping freely.
         # This also works with CoreAPI and Swagger documentation,
         # which produces clean and readable API documentation,
         # so I have chosen to believe this is the way the
         # Django REST Framework author intended things to work:
         if self.request.method in ['GET']:
             # Since the ReadSerializer does nested lookups
             # in multiple tables, only use it when necessary
             return ExamReadSerializer
         return ExamSerializer

Wie Sie sehen, scheint Option 2 weniger komplex und fehleranfällig zu sein und enthält nur 3 Zeilen handgeschriebenen Code über DRF (die Implementierung von get_serializer_class). Lassen Sie sich einfach von der Logik des Frameworks die Darstellungen sowie die Erstellung und Aktualisierung von Objekten erklären.

Ich habe viele andere Ansätze gesehen, aber bisher waren dies diejenigen, die den für mich am wenigsten zu wartenden Code hervorgebracht haben und die Vorteile des DRF-Designs auf saubere Weise nutzen.