Django Rest Framework ModelSerializer自定义序列化器字段to_internal_value不会保存到对象

Question

我有模型和序列化器，该模型中有ArrayField（postgres）。

现在，我想创建一个序列化器字段，该字段将接收列表[1,2]并将其保存到对象，但是要在序列化器中获取列表和详细信息以显示JSON对象列表。

模型：

class User(models.Model):
    email = models.EmailField('Email', unique=True, blank=False)
    full_name = models.CharField(
        'Full name', max_length=150, blank=True, null=True)
    roles = ArrayField(
        models.PositiveSmallIntegerField(),
        default=list,
        blank=True
    )

串行：

class ArraySerializerField(ListField):

    def __init__(self, queryset, serializer_class):
        super(ArraySerializerField, self).__init__()
        self.queryset = queryset
        self.serializer_class = serializer_class

    def to_representation(self, value):
        if value:
            qs = self.queryset.filter(pk__in=value)
            return self.serializer_class(qs, many=True).data

        return []

    def to_internal_value(self, value):
        super(ArraySerializerField, self).to_internal_value(value)
        print(value)  # [1, 2]
        return value


class UserSerializer(SerializerExtensionsMixin, serializers.ModelSerializer):
    roles = ArraySerializerField(queryset=Role.objects.all(), serializer_class=RoleSerializer)

    class Meta:
        model = User
        fields = ('id', 'email', 'full_name', 'roles')

    def create(self, validated_data):
        print(validated_data) 
        # {'email': 'test@test.com', 'full_name': 'Test', 'roles': []}
        user = super(UserSerializer, self).create(validated_data)

        return user

现在，当我执行列表或详细信息请求时，一切正常，我得到了一个角色列表，如JSON。

但是当我尝试发布数据并发送此数据时：

{
  "email": "test@test.com",
  "full_name": "Test",
  "roles": [1, 2]
}

create方法中的validated_data始终将角色显示为[]并且对象保存时没有角色，但是从to_internal_value打印显示[1, 2] 。

我究竟做错了什么？ 它应该保存发送的数据，因为to_internal_value可以正常工作。

编辑：

GET和LIST响应给了我正确的格式：

{
  "id": 1,
  "email": "test@test.com",
  "full_name": "Test",
  "roles": [
    {
      "id": 1,
      "name": "Role 1"
    },
    {
      "id": 2,
      "name": "Role 2"
    }
  ]
}

Answer 1

你有尝试过吗？

class UserSerializer(SerializerExtensionsMixin, serializers.ModelSerializer):
    roles = serializers.ListField(child=serializers.IntegerField(), allow_empty=True, required=False)

    class Meta:
        model = User
        fields = ('id', 'email', 'full_name', 'roles')

    def create(self, validated_data):
        # check validated_data here
        ...

注意

我不确定SerializerExtensionsMixin类的性质。 另外我不确定您的自定义ListField的queryset和serializer_class参数背后的意图

---

Django Shell输出

In [7]: from rest_framework import serializers                                                                                                                                                                     

In [8]: class UserSerializer(serializers.Serializer):  # Created a simple serializer without model
   ...:     roles = serializers.ListField(child=serializers.IntegerField(), allow_empty=True, required=False) 
   ...:     email = serializers.EmailField() 
   ...:     full_name = serializers.CharField() 
   ...:                                                                                                                                                                                                            

In [9]: data = { # your data
   ...:   "email": "test@test.com", 
   ...:   "full_name": "Test", 
   ...:   "roles": [1, 2] 
   ...: }                                                                                                                                                                                                          

In [10]: u = UserSerializer(data=data)                                                                                                                                                                             

In [11]: u.is_valid()                                                                                                                                                                                              
Out[11]: True

In [12]: u.data  # got valid data                                                                                                                                                                                                  
Out[12]: {'roles': [1, 2], 'email': 'test@test.com', 'full_name': 'Test'}

In [13]: data["roles"] = [] # change data to accept empty list                                                                                                                                                                                       

In [14]: u = UserSerializer(data=data)                                                                                                                                                                             

In [15]: u.is_valid()                                                                                                                                                                                              
Out[15]: True

In [16]: u.data  # got validated data with empty list                                                                                                                                                                                                  
Out[16]: {'roles': [], 'email': 'test@test.com', 'full_name': 'Test'} 

In [17]: data["roles"] = ["foo","bar"]   #added string to the list                                                                                                                                                                          

In [18]: u = UserSerializer(data=data)                                                                                                                                                                             

In [19]: u.is_valid()  # validation failed                                                                                                                                                                                          
Out[19]: False

In [20]: u.errors                                                                                                                                                                                                  
Out[20]: {'roles': {0: [ErrorDetail(string='A valid integer is required.', code='invalid')], 1: [ErrorDetail(string='A valid integer is required.', code='invalid')]}}

---

UPDATE-1

创建一个RoleSerializer并在UserSerializer

class RoleSerializer(serializers.ModelSerializer): class Meta: model = Role fields = ('id', 'name')


class UserSerializer(SerializerExtensionsMixin, serializers.ModelSerializer):
    roles = serializers.ListField(child=serializers.IntegerField(), allow_empty=True, required=False)

    class Meta:
        model = User
        fields = ('id', 'email', 'full_name', 'roles')

    def create(self, validated_data):
        # check validated_data here
        ...

    def to_representation(self, instance): rep = super().to_representation(instance) rep['roles'] = RoleSerializer(Role.objects.filter(id__in=rep['roles']), many=True).data return rep

---

UPDATE-2

使用自定义数组字段

class ArrayField(serializers.ListField): def __init__(self, *args, **kwargs): self.queryset = kwargs.pop('queryset', None) self.serializer_class = kwargs.pop('serializer_class', None) super().__init__(*args, **kwargs) def to_representation(self, data): qs = self.queryset.filter(id__in=data) serializer = self.serializer_class(qs,many=True) return serializer.data

class UserSerializer(SerializerExtensionsMixin, serializers.ModelSerializer):
    roles = ArrayField(queryset=Role.objects.all(), serializer_class=RoleSerializer)

    class Meta:
        model = User
        fields = ('id', 'email', 'full_name', 'roles')

    def create(self, validated_data):
        # check validated_data here
        ...

Answer 2

尝试切换到PrimaryKeyRelatedField 。 虽然您需要更改用户模型以使用实际关系。 通常这是一个好主意，因为它将帮助您的项目加强数据完整性。

class User(models.Model):
    email = models.EmailField('Email', unique=True, blank=False)
    full_name = models.CharField(
        'Full name', max_length=150, blank=True, null=True)
    roles = models.ManyToManyField(Role, blank=True)

class UserSerializer(SerializerExtensionsMixin, serializers.ModelSerializer):
    roles = serializers.PrimaryKeyRelatedField(
        many=True,
        queryset=Role.objects.all(),
    )

    class Meta:
        model = User
        fields = ('id', 'email', 'full_name', 'roles')

    def create(self, validated_data):
        print(validated_data) 
        # {'email': 'test@test.com', 'full_name': 'Test', 'roles': []}
        user = super(UserSerializer, self).create(validated_data)

        return user