Django Rest Framework: come aggiungere un campo personalizzato in ModelSerializer

Ho creato ModelSerializere desidero aggiungere un campo personalizzato che non fa parte del mio modello.

Ho trovato una descrizione per aggiungere campi extra qui e ho provato quanto segue:

customField = CharField(source='my_field')

Quando aggiungo questo campo e chiamo la mia validate()funzione, questo campo non fa parte del attrdict. attrcontiene tutti i campi del modello specificati tranne i campi aggiuntivi. Quindi non posso accedere a questo campo nella mia convalida sovrascritta, posso?

Quando aggiungo questo campo all'elenco dei campi in questo modo:

class Meta:
    model = Account
    fields = ('myfield1', 'myfield2', 'customField')

allora ricevo un errore perché customField non fa parte del mio modello - ciò che è corretto perché voglio aggiungerlo solo per questo serializzatore.

C'è un modo per aggiungere un campo personalizzato?

Stai facendo la cosa giusta, tranne quella CharField (e gli altri campi digitati) sono per i campi scrivibili.

In questo caso vuoi solo un semplice campo di sola lettura, quindi usa semplicemente:

customField = Field(source='get_absolute_url')

In effetti c'è una soluzione senza toccare affatto il modello. Puoi usare SerializerMethodFieldche ti permettono di collegare qualsiasi metodo al tuo serializzatore.

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

    def get_foo(self, obj):
        return "Foo id: %i" % obj.pk

... per chiarezza, se hai un Model Method definito nel modo seguente:

class MyModel(models.Model):
    ...

    def model_method(self):
        return "some_calculated_result"

Puoi aggiungere il risultato della chiamata di detto metodo al tuo serializzatore in questo modo:

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

ps Poiché il campo personalizzato non è realmente un campo nel tuo modello, di solito vorrai renderlo di sola lettura, in questo modo:

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

qui rispondi alla tua domanda. dovresti aggiungere al tuo account modello:

@property
def my_field(self):
    return None

ora puoi usare:

customField = CharField(source='my_field')

fonte: https://stackoverflow.com/a/18396622/3220916

Per mostrare self.author.full_name, ho ricevuto un errore con Field. Ha funzionato con ReadOnlyField:

class CommentSerializer(serializers.HyperlinkedModelSerializer):
    author_name = ReadOnlyField(source="author.full_name")
    class Meta:
        model = Comment
        fields = ('url', 'content', 'author_name', 'author')

Con l'ultima versione di Django Rest Framework, è necessario creare un metodo nel modello con il nome del campo che si desidera aggiungere.

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

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

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

Stavo cercando una soluzione per aggiungere un campo personalizzato scrivibile a un serializzatore di modelli. Ho trovato questo, che non è stato trattato nelle risposte a questa domanda.

Sembra che tu abbia davvero bisogno di scrivere il tuo semplice serializzatore.

class PassThroughSerializer(serializers.Field):
    def to_representation(self, instance):
        # This function is for the direction: Instance -> Dict
        # If you only need this, use a ReadOnlyField, or SerializerField
        return None

    def to_internal_value(self, data):
        # This function is for the direction: Dict -> Instance
        # Here you can manipulate the data if you need to.
        return data

Ora puoi usare questo serializzatore per aggiungere campi personalizzati a un ModelSerializer

class MyModelSerializer(serializers.ModelSerializer)
    my_custom_field = PassThroughSerializer()

    def create(self, validated_data):
        # now the key 'my_custom_field' is available in validated_data
        ...
        return instance

Funziona anche se il Modello MyModelha effettivamente una proprietà chiamata my_custom_fieldma vuoi ignorare i suoi validatori.

Dopo aver letto tutte le risposte qui, la mia conclusione è che è impossibile farlo in modo pulito. Devi giocare sporco e fare qualcosa di strano come creare un campo write_only e poi sovrascrivere i metodi validatee to_representation. Questo è ciò che ha funzionato per me:

class FooSerializer(ModelSerializer):

    foo = CharField(write_only=True)

    class Meta:
        model = Foo
        fields = ["foo", ...]

    def validate(self, data):
        foo = data.pop("foo", None)
        # Do what you want with your value
        return super().validate(data)

    def to_representation(self, instance):
        data = super().to_representation(instance)
        data["foo"] = whatever_you_want
        return data