从django rest框架中的ManytoMany字段获取None类型值

我无法在序列化程序列表中的许多字段中检索答案选择id或检索 相反，我得到了

quick.Choice.None

我理解这是为什么，但如果我从序列化程序中删除

answer=serializers.CharField（）

这一行。创建问题时出现错误：

{
    "answer": [
        "Incorrect type. Expected pk value, received str."
    ]
}

我无法从前端传递答案，我希望检索

“答案”：[2,3]

而不是“无”，我还知道如果我从序列化程序中删除

answer=serializers.CharField（）

这一行。它解决了这个问题，但它提出了另一个问题，我无法传递一个甚至还没有创建的答案选择id。这类问题的最佳解决方案是什么？我还尝试对空数组进行应答验证。但这根本不起作用

{
        "id": 5,
        "label": "Question 1",
        "answer": "quiz.Choice.None",
        "explanation": "New Added fhfd",
        "mode": 1,
        "subtopic": 2,
        "choice": [
            {
                "id": 5,
                "option": "option 6 Edited New One",
                "question": 5
            },
            {
                "id": 6,
                "option": "option 5 Hllloo Sakib",
                "question": 5
            }
        ]
    }

我的模型： 在Serializers.py中： 在api.py中： 在axios柱体中：

---

答案

由其

主键

引用，而非

选项

下面这样的调用应该可以工作，您可以提交选项的主键，而不是选项文本：

{
“标签”：“标签q”，
“解释”：“解释”，
“答复”：[7,8]，
“模式”：1，
“副标题”：2，
“选择”：[
{
“id”：3324242，
“选项”：“选项7”
},
{
“id”：3324245，
“选项”：“选项8”
},
{
“id”：3324248，
“选项”：“选项9”
}
]
}

更新 我将Modelviewset类更新为：

class CreateQuestionView(viewsets.ModelViewSet):
    serializer_class = CreateQuestionSerializer
    queryset = Question.objects.all()

    def retrieve(self, request, *args, **kwargs):
        instance = self.get_object()
        serializer = self.get_serializer(instance)
        answer = []
        for ans in instance.answer.all():
            answer.append(ans.id)
        newDict = {}
        newDict.update(serializer.data)
        newDict.update({"answer": answer})

        return Response(newDict)

    def list(self, request, *args, **kwargs):
        queryset = self.filter_queryset(self.get_queryset())

        page = self.paginate_queryset(queryset)
        if page is not None:
            serializer = self.get_serializer(page, many=True)
            return self.get_paginated_response(serializer.data)

        serializer = self.get_serializer(queryset, many=True)
        newList = []
        for question in serializer.data:
            q = Question.objects.get(pk=question["id"])

            answer = []
            for ans in q.answer.all():
                answer.append(ans.id)
            newDict = {}
            newDict.update(question)
            newDict.update({"answer": answer})
            newList.append(newDict)

        return Response(newList)

---

现在一切都很顺利。谢谢我自己v

我知道这一点，但我怎么知道这个选项的id甚至没有创建。选择ID是在我发布请求后创建的。而id是自动创建的，在创建之前不可能知道。或者我如何从前端传递答案？

class ChoiceSerializer(serializers.ModelSerializer):
    """Serializers for Question Choice"""

    id = serializers.IntegerField()

    class Meta:
        model = Choice
        fields = ("id", "option", "question")


class CreateQuestionSerializer(serializers.ModelSerializer):

    choice = ChoiceSerializer(many=True, partial=True)
    answer = serializers.CharField()

    class Meta:
        model = Question
        fields = ("id", "label", "answer", "explanation", "mode", "subtopic", "choice")
        extra_kwargs = {"answer": {"validators": []}}

    def create(self, validated_data):
        """Create Model With nested Serializer"""

        choices_data = validated_data.pop("choice")
        answerString = validated_data.pop("answer", [])
        answer = literal_eval(answerString)

        print(answer)
        print(type(answer))
        question = Question.objects.create(**validated_data)
        for choice_data in choices_data:
            choice_created = Choice.objects.create(
                option=choice_data["option"], question=question
            )
            for choice_option in answer:
                if choice_option == choice_created.option:
                    question.answer.add(choice_created)
                    question.save()
        return question

    def update(self, instance, validated_data):
        """Update Instance including nested serializer"""
        choices_data = validated_data.pop("choice", None)

        if choices_data is not None:
            for choice_data in choices_data:
                choice = Choice.objects.get(pk=choice_data["id"])
                choice.option = choice_data["option"]
                choice.save()
        return super().update(instance, validated_data)

class CreateQuestionView(viewsets.ModelViewSet):
    serializer_class = CreateQuestionSerializer
    queryset = Question.objects.all()

    {
        "label": "Label q",
        "explanation": "",
        "answer": ["option 7","option 8"],
        "mode": 1,
        "subtopic": 2,
        "choice": [
            {
                "id":3324242,
                "option": "option 7"
            },
            {
                "id":3324245,
                "option": "option 8"
            },
            {
                "id":3324248,
                "option": "option 9"
            }
            ]
    }

class CreateQuestionView(viewsets.ModelViewSet):
    serializer_class = CreateQuestionSerializer
    queryset = Question.objects.all()

    def retrieve(self, request, *args, **kwargs):
        instance = self.get_object()
        serializer = self.get_serializer(instance)
        answer = []
        for ans in instance.answer.all():
            answer.append(ans.id)
        newDict = {}
        newDict.update(serializer.data)
        newDict.update({"answer": answer})

        return Response(newDict)

    def list(self, request, *args, **kwargs):
        queryset = self.filter_queryset(self.get_queryset())

        page = self.paginate_queryset(queryset)
        if page is not None:
            serializer = self.get_serializer(page, many=True)
            return self.get_paginated_response(serializer.data)

        serializer = self.get_serializer(queryset, many=True)
        newList = []
        for question in serializer.data:
            q = Question.objects.get(pk=question["id"])

            answer = []
            for ans in q.answer.all():
                answer.append(ans.id)
            newDict = {}
            newDict.update(question)
            newDict.update({"answer": answer})
            newList.append(newDict)

        return Response(newList)