多对多、外键关系模型中的 DRF 更新插入

Question

我有六个模型，它们如下：

class Certificate(DateTimeLog):
    name = models.TextField(max_length=255)


class Vacancy(DateTimeLog):
    name = models.CharField(max_length=255)
    parent_position = models.ForeignKey("self", on_delete=models.CASCADE, null=True, blank=True,
                                        related_name='sub_positions')


class Region(DateTimeLog):
    name = models.CharField(max_length=255)


class MaritalStatus(DateTimeLog):
    name = models.CharField(max_length=255)


class Candidate(DateTimeLog):
    pin = models.CharField(max_length=16, unique=True)
    first_name = models.CharField(max_length=64, blank=True, null=True)
    last_name = models.CharField(max_length=64, blank=True, null=True)
    marital_status = models.ForeignKey(MaritalStatus, on_delete=models.SET_NULL, null=True, blank=True)
    certificate = models.ManyToManyField(Certificate, blank=True)


class Candidacy(DateTimeLog):
    candidate = models.ForeignKey(Candidate, on_delete=models.CASCADE)
    vacancy = models.ForeignKey(Vacancy, on_delete=models.CASCADE)
    work_region = models.ForeignKey(Region, on_delete=models.SET_NULL, null=True, blank=True)

现在我要处理，如果 candidate 记录存在（我正在用 pin 检查它），然后检查并更新 Candidate 相关数据。如果候选人不存在，请创建它。创建或更新候选人后，将其分配给候选人。我的序列化程序如下所示：

class CandidateSerializer(serializers.ModelSerializer):
    marital_status = MaritalStatusSerializer(required=False)
    certificate = CertificateSerializer(many=True, required=False)

    def create(self, validated_data):
        marital_status_data = validated_data.pop("marital_status")
        certificate_data = validated_data.pop("certificate")
        candidate = Candidate.objects.create(**validated_data)

        ms_o = MaritalStatus.objects.get(name=marital_status_data["name"])
        candidate.marital_status = ms_o

        for certificate in certificate_data:
            certificate_o = Certificate.objects.create(**certificate)
            candidate.certificate.add(certificate_o)

        candidate.save()
        return candidate

    class Meta:
        model = Candidate
        fields = '__all__'
        depth = 1


class CandidacySerializer(serializers.ModelSerializer):
    candidate = CandidateSerializer()
    vacancy = VacancySerializer()
    work_region = RegionSerializer()

    def create(self, validated_data):
        candidate_s = CandidateSerializer()
        candidate_data = validated_data.pop('candidate')

        vacancy_data = validated_data.pop('vacancy')
        work_region_data = validated_data.pop('work_region')

        vac_o = Vacancy.objects.get(name=vacancy_data['name'])
        wr_o = Region.objects.get(name=work_region_data['name'])
        candidate_o = candidate_s.create(validated_data=candidate_data)
        validated_data.update({
            'candidate': candidate_o,
            'vacancy': vac_o,
            'work_region': wr_o
        })
        candidacy = Candidacy.objects.create(**validated_data)
        return candidacy

    class Meta:
        model = Candidacy
        fields = '__all__'
        depth = 1

目前，我可以使用 post 请求创建它。我需要明确地检查它还是可以在序列化程序中实现它？

Answer 1

所以你有一个更直接的选择。有一个名为 get 或 create 的函数，它将检查对象是否存在，return 否则它会创建它。 similar question can be found here 顺便说一句，如果这个密码是敏感的，我建议加密它。

Answer 2

因为您已经使用

使 pin 独一无二

pin = models.CharField(max_length=16, unique=True)

不可能有两个相似的别针。现在要根据 pin 检查候选人，您必须在创建方法中手动执行类似的操作。

if Candidate.objects.filter(pin = revievedPinData):
    here candidate is already present so update the information information
    and again check if Canditate is in Candidacy or not
    first get the candidate object
    c = Candidate.objects.get(pin = revievedPinData)
    then
    if Candidacy.objects.filter(candidate = c):
       if true candidate is already assigned and the updated value of candidate will reflect here
    else: create the Candidacy with the current candidate and other values
else:
    if candidate is not there (from the given pin)
    create a new candidate
    aa = candidate.objects.create()
    create a new Candidacy with candidate aa
    Candidacy.objects.create(candidate=aa, **otherdata)

Answer 3

首先，您可以像这样在 CandidateSerializer 中使用 update_or_create：

class CandidateSerializer(serializers.ModelSerializer):
    marital_status = MaritalStatusSerializer(required=False)
    certificate = CertificateSerializer(many=True, required=False)

    def create(self, validated_data):
        marital_status_data = validated_data.pop("marital_status")
        certificate_data = validated_data.pop("certificate")
        candidate, created = Candidate.objects.update_or_create(
            pin=validated_data['pin'],
            **validated_data
        )

        ms_o = MaritalStatus.objects.get(name=marital_status_data["name"])
        candidate.marital_status = ms_o

        for certificate in certificate_data:
            certificate_o = Certificate.objects.create(**certificate)
            candidate.certificate.add(certificate_o)

        candidate.save()
        return candidate

    class Meta:
        model = Candidate
        fields = '__all__'
        depth = 1

其次，你不应该直接调用方法create()。您必须改用 save()。您必须更换：

candidate_s = CandidateSerializer()
candidate_o = candidate_s.create(validated_data=candidate_data)

来自

candidate_s = CandidateSerializer(data=candidate_data)
candidate_o = candidate_s.save()

您可以阅读有关保存实例的更多信息here。

多对多、外键关系模型中的 DRF 更新插入

DRF Update Insert in ManytoMany, ForeignKey Relationship Models

python

django

serialization

django-rest-framework