example - Django Rest Framework con ChoiceField

django rest framework serializer

Question

Tengo algunos campos en mi modelo de usuario que son campos de elección y estoy tratando de descubrir cómo implementarlo mejor en Django Rest Framework.

A continuación hay un código simplificado para mostrar lo que estoy haciendo.

# models.py
class User(AbstractUser):
    GENDER_CHOICES = (
        (''M'', ''Male''),
        (''F'', ''Female''),
    )

    gender = models.CharField(max_length=1, choices=GENDER_CHOICES)


# serializers.py 
class UserSerializer(serializers.ModelSerializer):
    gender = serializers.CharField(source=''get_gender_display'')

    class Meta:
        model = User


# viewsets.py
class UserViewSet(viewsets.ModelViewSet):
    queryset = User.objects.all()
    serializer_class = UserSerializer

Esencialmente, lo que intento hacer es hacer que los métodos get / post / put utilicen el valor de visualización del campo de elección en lugar del código, con un aspecto similar al JSON a continuación.

{
  ''username'': ''newtestuser'',
  ''email'': ''[email protected]'',
  ''first_name'': ''first'',
  ''last_name'': ''last'',
  ''gender'': ''Male''
  // instead of ''gender'': ''M''
}

¿Cómo voy a hacer eso? El código anterior no funciona. Antes tenía algo como esto trabajando para GET, pero para POST / PUT me daba errores. Estoy buscando consejos generales sobre cómo hacer esto, parece que sería algo común, pero no puedo encontrar ejemplos. O eso o estoy haciendo algo terriblemente mal.

Answer 1

Desde DRF 3.1 hay una nueva API llamada personalización de mapeo de campo . Lo usé para cambiar la asignación predeterminada de ChoiceField a ChoiceDisplayField:

class UserSerializer(DefaultModelSerializer):    
    class Meta:
        model = User
        fields = (''id'', ''gender'')

Si usa DefaultModelSerializer :

...

"id": 1,
"gender": {
    "display": "Male",
    "value": "M"
},
...

Obtendrás algo como:

from django.contrib.auth import get_user_model
from rest_framework import serializers

User = get_user_model()

class ChoiceField(serializers.ChoiceField):

    def to_representation(self, obj):
        return self._choices[obj]

class UserSerializer(serializers.ModelSerializer):
    gender = ChoiceField(choices=User.GENDER_CHOICES)

    class Meta:
        model = User

Answer 2

Django proporciona el método Model.get_FOO_display para obtener el valor "legible para humanos" de un campo:

class UserSerializer(serializers.ModelSerializer):
    gender = serializers.SerializerMethodField()

    class Meta:
        model = User

    def get_gender(self,obj):
        return obj.get_gender_display()

para el último DRF (3.6.3) - el método más sencillo es:

gender = serializers.CharField(source=''get_gender_display'')

Answer 3

Encontré soup boy el enfoque del soup boy es el mejor. Aunque sugeriría heredar de serializers.ChoiceField lugar de serializers.Field . De esta manera, solo necesita anular el método to_representation y el resto funciona como un ChoiceField normal.

class DisplayChoiceField(serializers.ChoiceField):

    def __init__(self, *args, **kwargs):
        choices = kwargs.get(''choices'')
        self._choices = OrderedDict(choices)
        super(DisplayChoiceField, self).__init__(*args, **kwargs)

    def to_representation(self, obj):
        """Used while retrieving value for the field."""
        return self._choices[obj]

Answer 4

La siguiente solución funciona con cualquier campo con opciones, sin necesidad de especificar en el serializador un método personalizado para cada uno:

from rest_framework import serializers

class ChoicesSerializerField(serializers.SerializerMethodField):
    """
    A read-only field that return the representation of a model field with choices.
    """

    def to_representation(self, value):
        # sample: ''get_XXXX_display''
        method_name = ''get_{field_name}_display''.format(field_name=self.field_name)
        # retrieve instance method
        method = getattr(value, method_name)
        # finally use instance method to return result of get_XXXX_display()
        return method()

Ejemplo:

dado:

class Person(models.Model):
    ...
    GENDER_CHOICES = (
        (''M'', ''Male''),
        (''F'', ''Female''),
    )
    gender = models.CharField(max_length=1, choices=GENDER_CHOICES)

utilizar:

class PersonSerializer(serializers.ModelSerializer):
    ...
    gender = ChoicesSerializerField()

para recibir:

{
    ...
    ''gender'': ''Male''
}

en lugar de:

{
    ...
    ''gender'': ''M''
}

Answer 5

Prefiero la respuesta de @nicolaspanel para mantener el campo de escritura. Si usa esta definición en lugar de su ChoiceField , aprovechará toda / toda la infraestructura en el ChoiceField mientras ChoiceField las opciones de str => int :

class MappedChoiceField(serializers.ChoiceField):

    @serializers.ChoiceField.choices.setter
    def choices(self, choices):
        self.grouped_choices = fields.to_choices_dict(choices)
        self._choices = fields.flatten_choices_dict(self.grouped_choices)
        # in py2 use `iteritems` or `six.iteritems`
        self.choice_strings_to_values = {v: k for k, v in self._choices.items()}

La anulación @property es "fea", pero mi objetivo siempre es cambiar la menor cantidad posible del núcleo (para maximizar la compatibilidad hacia adelante).

PD: si quieres allow_blank , hay un bug en DRF. La solución más simple es agregar lo siguiente a MappedChoiceField :

def validate_empty_values(self, data):
    if data == '''':
        if self.allow_blank:
            return (True, None)
    # for py2 make the super() explicit
    return super().validate_empty_values(data)

PPS Si tiene un montón de campos de elección que todos necesitan ser mapeados, aproveche la característica anotada por @lechup y agregue lo siguiente a su ModelSerializer ( no su Meta ):

serializer_choice_field = MappedChoiceField

Answer 6

Probablemente necesite algo como esto en algún lugar de su util.py e importar en cualquier serializador que ChoiceFields .

class ChoicesField(serializers.Field):
    """Custom ChoiceField serializer field."""

    def __init__(self, choices, **kwargs):
        """init."""
        self._choices = OrderedDict(choices)
        super(ChoicesField, self).__init__(**kwargs)

    def to_representation(self, obj):
        """Used while retrieving value for the field."""
        return self._choices[obj]

    def to_internal_value(self, data):
        """Used while storing value for the field."""
        for i in self._choices:
            if self._choices[i] == data:
                return i
        raise serializers.ValidationError("Acceptable values are {0}.".format(list(self._choices.values())))

Answer 7

Sugiero usar django-models-utils con un campo de serializador DRF personalizado

El código se convierte en:

# models.py
from model_utils import Choices

class User(AbstractUser):
    GENDER = Choices(
       (''M'', ''Male''),
       (''F'', ''Female''),
    )

    gender = models.CharField(max_length=1, choices=GENDER, default=GENDER.M)


# serializers.py 
from rest_framework import serializers

class ChoicesField(serializers.Field):
    def __init__(self, choices, **kwargs):
        self._choices = choices
        super(ChoicesField, self).__init__(**kwargs)

    def to_representation(self, obj):
        return self._choices[obj]

    def to_internal_value(self, data):
        return getattr(self._choices, data)

class UserSerializer(serializers.ModelSerializer):
    gender = ChoicesField(choices=User.GENDER)

    class Meta:
        model = User

# viewsets.py
class UserViewSet(viewsets.ModelViewSet):
    queryset = User.objects.all()
    serializer_class = UserSerializer

Answer 8

Una actualización para este hilo, en las últimas versiones de DRF, en realidad hay un ChoiceField .

Por lo tanto, todo lo que debe hacer si desea devolver el display_name es subclasificar ChoiceField to_representation método de presentación como este:

import six
from rest_framework.fields import ChoiceField


class ChoiceDisplayField(ChoiceField):
    def __init__(self, *args, **kwargs):
        super(ChoiceDisplayField, self).__init__(*args, **kwargs)
        self.choice_strings_to_display = {
            six.text_type(key): value for key, value in self.choices.items()
        }

    def to_representation(self, value):
        if value is None:
            return value
        return {
            ''value'': self.choice_strings_to_values.get(six.text_type(value), value),
            ''display'': self.choice_strings_to_display.get(six.text_type(value), value),
        }

class DefaultModelSerializer(serializers.ModelSerializer):
    serializer_choice_field = ChoiceDisplayField

Por lo tanto, no es necesario cambiar el método __init__ ni agregar ningún paquete adicional.