Django REST Framework: dodanie dodatkowego pola do ModelSerializer

Chcę serializować model, ale chcę dołączyć dodatkowe pole, które wymaga wykonywania niektórych wyszukiwań bazy danych w wystąpieniu modelu do serializacji:

class FooSerializer(serializers.ModelSerializer):
  my_field = ... # result of some database queries on the input Foo object
  class Meta:
        model = Foo
        fields = ('id', 'name', 'myfield')

Jaki jest właściwy sposób, aby to zrobić? Widzę, że można przekazać w dodatkowym „kontekście” do serializatora, czy poprawna odpowiedź jest przekazywana w dodatkowym polu w słowniku kontekstowym? Przy takim podejściu logika uzyskiwania pola, którego potrzebuję, nie byłaby niezależna od definicji serializatora, co jest idealne, ponieważ każda serializowana instancja będzie potrzebować my_field. W innym miejscu dokumentacji serializatorów DRF jest napisane , że „dodatkowe pola mogą odpowiadać dowolnej właściwości lub wywoływać w modelu”. Czy mówię o dodatkowych polach? Czy powinienem zdefiniować funkcję w Foodefinicji modelu, która zwraca my_fieldwartość, aw serializatorze podłączyć my_field do tego wywoływalnego? Jak to wygląda?

Z góry dziękuję, w razie potrzeby chętnie wyjaśnię pytanie.

Myślę, że SerializerMethodField jest tym, czego szukasz:

class FooSerializer(serializers.ModelSerializer):
  my_field = serializers.SerializerMethodField('is_named_bar')

  def is_named_bar(self, foo):
      return foo.name == "bar" 

  class Meta:
    model = Foo
    fields = ('id', 'name', 'my_field')

http://www.django-rest-framework.org/api-guide/fields/#serializermethodfield

Możesz zmienić metodę modelu na właściwość i używać jej w serializatorze za pomocą tego podejścia.

class Foo(models.Model):
    . . .
    @property
    def my_field(self):
        return stuff
    . . .

class FooSerializer(ModelSerializer):
    my_field = serializers.ReadOnlyField(source='my_field')

    class Meta:
        model = Foo
        fields = ('my_field',)

Edycja: Z ostatnimi wersjami frameworka REST (próbowałem 3.3.3), nie musisz zmieniać właściwości. Metoda modelu będzie działać dobrze.

W ostatniej wersji Django Rest Framework musisz stworzyć w swoim modelu metodę z nazwą pola, które chcesz dodać. Nie ma potrzeby @propertyi source='field'zgłosi błąd.

class Foo(models.Model):
    . . .
    def foo(self):
        return 'stuff'
    . . .

class FooSerializer(ModelSerializer):
    foo = serializers.ReadOnlyField()

    class Meta:
        model = Foo
        fields = ('foo',)

Moja odpowiedź na podobne pytanie ( tutaj ) może być przydatna.

Jeśli masz metodę modelu zdefiniowaną w następujący sposób:

class MyModel(models.Model):
    ...

    def model_method(self):
        return "some_calculated_result"

Możesz dodać wynik wywołania tej metody do swojego serializatora w następujący sposób:

class MyModelSerializer(serializers.ModelSerializer):
    model_method_field = serializers.CharField(source='model_method')

ps Ponieważ pole niestandardowe nie jest tak naprawdę polem w Twoim modelu, zazwyczaj chcesz ustawić je jako tylko do odczytu, na przykład:

class Meta:
    model = MyModel
    read_only_fields = (
        'model_method_field',
        )

jeśli chcesz czytać i pisać w swoim dodatkowym polu, możesz użyć nowego niestandardowego serializatora, który rozszerza serializatory.Serializer i używać go w ten sposób

class ExtraFieldSerializer(serializers.Serializer):
    def to_representation(self, instance): 
        # this would have the same as body as in a SerializerMethodField
        return 'my logic here'

    def to_internal_value(self, data):
        # This must return a dictionary that will be used to
        # update the caller's validation data, i.e. if the result
        # produced should just be set back into the field that this
        # serializer is set to, return the following:
        return {
          self.field_name: 'Any python object made with data: %s' % data
        }

class MyModelSerializer(serializers.ModelSerializer):
    my_extra_field = ExtraFieldSerializer(source='*')

    class Meta:
        model = MyModel
        fields = ['id', 'my_extra_field']

używam tego w powiązanych polach zagnieżdżonych z pewną niestandardową logiką

U mnie to zadziałało .Jeśli chcemy po prostu dodać dodatkowe pole w ModelSerializer, możemy to zrobić jak poniżej, a także pole może mieć przypisaną wartość po kilku obliczeniach wyszukiwania. Lub w niektórych przypadkach, jeśli chcemy wysłać parametry w odpowiedzi API.

W model.py

class Foo(models.Model):
    """Model Foo"""
    name = models.CharField(max_length=30, help_text="Customer Name")



   **

W serializer.py

**

class FooSerializer(serializers.ModelSerializer):
    retrieved_time = serializers.SerializerMethodField()

    @classmethod
    def get_retrieved_time(self, object):
        """getter method to add field retrieved_time"""
        return None

  class Meta:
        model = Foo
        fields = ('id', 'name', 'retrieved_time ')

**

Mam nadzieję, że to może komuś pomóc

**

Jak powiedział w tym komentarzu programista chemiczny , w najnowszym DRF można to zrobić w następujący sposób:

class FooSerializer(serializers.ModelSerializer):
    extra_field = serializers.SerializerMethodField()

    def get_extra_field(self, foo_instance):
        return foo_instance.a + foo_instance.b

    class Meta:
        model = Foo
        fields = ('extra_field', ...)

Źródło dokumentacji DRF