检查保存方法中的唯一约束

Question

I have a model on which the unique_together parameter is not working. The reason is that most of the times the "client_repr" variable is set on the save() method. If someone creates a task with the same ('client_repr', 'task_type'... ) combination the model won't detect it because the "client_repr" value is null until the end of the save() method.

How can i call for a unique constraint verification inside the save() method?

class Task(models.Model):
    client = models.ForeignKey(Client, related_name = 'tasks', on_delete = models.CASCADE)
    b_client = models.ForeignKey(BClient, related_name = 'tasks', on_delete = models.CASCADE, null = True, blank = True)
    client_repr = models.CharField(max_length = 100, null = True, blank = True)
    task_type = models.CharField(max_length = 100)
    task_description = models.CharField(max_length = 100)
    department = models.ForeignKey(Department, related_name = 'tasks', on_delete = models.CASCADE)
    extra_fields = models.ManyToManyField(ExtraField, blank = True)
    spot = models.BooleanField(default = False)

    class Meta:
        unique_together = (('client_repr', 'task_type', 'task_description', 'department'), )

    def __str__(self):
        return ' | '.join([f'{self.client_repr}', f'{self.task_description}', f'{self.task_type}'])

    def save(self, *args, **kwargs):
        if not self.b_client:
            self.client_repr = str(self.client)
        else:
            self.client_repr = str(self.b_client)

        super().save(*args, **kwargs)

I know i could just make a search (ex: if Task.objects.get(...): ) but is it the most django-pythonic way?

Answer 1

Option 1: Using clean()

It's not directly what you asked, but it's generally more django-friendly and does not require weird things like overriding save()

class Task(Model):

    def clean():
        # your code starts here
        if not self.b_client:
            self.client_repr = str(self.client)
        else:
            self.client_repr = str(self.b_client)
        # your code ends here

Since this custom clean() is called before django calls validate_unique() , it should fulfill your requirements.

See the details in the official documentation.

Option 2: Continue doing everything in save()

To check unique constraints, you can do the following:

from django.core.exceptions import ValidationError

def save(self, *args, **kwargs):
    ...  # your code that automatically sets some fields
    try:
        self.validate_unique()
        # self.full_clean()  # <- alternatively, can use this to validate **everything**, see my comments below
    except ValidationError:
        # failed
        # that's up to you what to do in this case
        # you cannot just re-raise the ValidationError because Django doesn't expect ValidationError happening inside of save()
    super().save(*args, **kwargs)

Note:

• doing only self.validate_unique() does not guarantee, that the updated earlier in save() values are good and don't violate something else
• self.full_clean() is safer, but will be slightly slower (how slow - depends on the validators you have)

Documentation

Django documentation says :

There are three steps involved in validating a model:

• Validate the model fields - Model.clean_fields()
• Validate the model as a whole - Model.clean()
• Validate the field uniqueness - Model.validate_unique()

All three steps are performed when you call a model's full_clean() method.