Wie mache ich eine PATCH-Anfrage mit Django? REST Rahmen

class DetailView(APIView):
    def get_object(self, pk):
        return TestModel.objects.get(pk=pk)

    def patch(self, request, pk):
        testmodel = self.get_object(pk)
        serializer = TestModelSerializer(testmodel, data=request.data, partial=True) # set partial=True to update a data partially
        if serializer.is_valid():
            serializer.save()
            return JsonReponse(code=201, data=serializer.data)
        return JsonResponse(code=400, data="wrong parameters")

Dokumentation
Sie müssen den partial_update nicht schreiben oder die update-Methode überschreiben. Verwenden Sie einfach die patch-Methode.

Stellen Sie sicher, dass Sie "PATCH" in http_method_names haben. Alternativ kannst du es so schreiben:

@property
def allowed_methods(self):
    """
    Return the list of allowed HTTP methods, uppercased.
    """
    self.http_method_names.append("patch")
    return [method.upper() for method in self.http_method_names
            if hasattr(self, method)]

Wie in Dokumentation angegeben :

Standardmäßig müssen Serialisierer Werte für alle erforderlichen Felder übergeben, da sonst Validierungsfehler auftreten. Sie können das Teilargument verwenden, um Teilaktualisierungen zuzulassen.

Überschreiben Sie die update-Methode in Ihrer Ansicht:

def update(self, request, *args, **kwargs):
    instance = self.get_object()
    serializer = TimeSerializer(instance, data=request.data, partial=True)
    serializer.is_valid(raise_exception=True)
    serializer.save(customer_id=customer, **serializer.validated_data)
    return Response(serializer.validated_data)

Oder überschreiben Sie einfach die Methode partial_update in Ihrer Ansicht:

def partial_update(self, request, *args, **kwargs):
    kwargs['partial'] = True
    return self.update(request, *args, **kwargs)

Der Serializer ruft update Methode von ModelSerializer auf (siehe sources ):

def update(self, instance, validated_data):
    raise_errors_on_nested_writes('update', self, validated_data)

    # Simply set each attribute on the instance, and then save it.
    # Note that unlike `.create()` we don't need to treat many-to-many
    # relationships as being a special case. During updates we already
    # have an instance pk for the relationships to be associated with.
    for attr, value in validated_data.items():
        setattr(instance, attr, value)
    instance.save()

    return instance

Update gibt die Werte von validated_data an die angegebene Instanz weiter. Beachten Sie, dass beim Update nicht davon ausgegangen werden soll, dass alle Felder verfügbar sind. Dies hilft bei Teilaktualisierungen (PATCHrequest).

Die patch-Methode wird für mich mithilfe von viewset in DRF bearbeitet. Ich ändere deinen Code:

class UserViewSet(viewsets.ModelViewSet):
    queryset = TimeEntry.objects.all()
    serializer_class = TimeSerializer

    def perform_update(self, serializer):
        user_instance = serializer.instance
        request = self.request
        serializer.save(**modified_attrs)
        return Response(status=status.HTTP_200_OK)

Ich bin auch auf dieses Problem gestoßen. Ich habe es gelöst, indem ich die Methode get_serializer_method neu definiert und benutzerdefinierte Logik hinzugefügt habe, um das teilweise Update zu handhaben. Python 3

 class ViewSet(viewsets.ModelViewSet):
     def get_serializer_class(self):
         if self.action == "partial_update":
             return PartialUpdateSerializer

Hinweis: Möglicherweise müssen Sie die Funktion partial_update im Serializer überschreiben. Wie so:

class PartialUpdateSerializer(serializers.Serializer):
    def partial_update(self, instance, validated_data):
       *custom logic*
       return super().update(instance, validated_data)

Verwenden Sie stattdessen ModelViewSet und überschreiben Sie die perform_update-Methode von UpdateModelMixin.

class UserViewSet(viewsets.ModelViewSet):
    queryset = TimeEntry.objects.all()
    serializer_class = TimeSerializer

    def perform_update(self, serializer):
        serializer.save()
        # you may also do additional things here
        # e.g.: signal other components about this update

Das ist es. Gib bei dieser Methode nichts zurück. UpdateModelMixin hat die update-Methode implementiert, um aktualisierte Daten als Antwort für Sie zurückzugeben, und löscht auch _prefetched_objects_cache. Siehe den Quellcode hier .

Eine andere Möglichkeit besteht darin, die Anfrage per URL zu stellen. Zum Beispiel habe ich ein Modell wie dieses

      class Author(models.Model):
        FirstName = models.CharField(max_length=70)
        MiddleName = models.CharField(max_length=70)
        LastName = models.CharField(max_length=70)
        Gender = models.CharField(max_length=1, choices = GENDERS)
        user = models.ForeignKey(User, default = 1, on_delete = models.CASCADE, related_name='author_user')
        IsActive = models.BooleanField(default=True)
        class Meta:
          ordering = ['LastName']

Und eine Ansicht wie diese

      class Author(viewsets.ModelViewSet):
        queryset = Author.objects.all()
        serializer_class = AuthorSerializer

Geben Sie also http://127.0.0.1:8000/author/ ein, um Autoren abzurufen oder zu veröffentlichen. Wenn ich eine PATCH-Anfrage stellen möchte, können Sie von Ihrem Client auf http://127.0.0.1:8000/author/ID_AUTHOR verweisen. In angle2 können Sie beispielsweise so etwas haben

       patchRequest(item: any): Observable<Author> {
        return this.http.patch('http://127.0.0.1:8000/author/1', item);
       }

Angenommen, Sie haben Ihr CORS konfiguriert und haben das gleiche Modell auf der Vorder- und Rückseite. Hoffe, es kann nützlich sein.