Unikalna wartość BooleanField w Django?

Załóżmy, że mój models.py jest taki:

class Character(models.Model):
    name = models.CharField(max_length=255)
    is_the_chosen_one = models.BooleanField()

Chcę, aby tylko jedna z moich Characterinstancji miała, is_the_chosen_one == Truea wszystkie inne miały is_the_chosen_one == False. Jak najlepiej zapewnić przestrzeganie tego ograniczenia wyjątkowości?

Najwyższe oceny za odpowiedzi, które uwzględniają konieczność przestrzegania ograniczeń na poziomie bazy danych, modelu i formularza (administratora)!

Zawsze, gdy potrzebowałem wykonać to zadanie, nadpisałem metodę zapisu modelu i kazałem mu sprawdzić, czy jakikolwiek inny model ma już ustawioną flagę (i wyłączyć ją).

class Character(models.Model):
    name = models.CharField(max_length=255)
    is_the_chosen_one = models.BooleanField()

    def save(self, *args, **kwargs):
        if self.is_the_chosen_one:
            try:
                temp = Character.objects.get(is_the_chosen_one=True)
                if self != temp:
                    temp.is_the_chosen_one = False
                    temp.save()
            except Character.DoesNotExist:
                pass
        super(Character, self).save(*args, **kwargs)

Zastąpiłbym metodę zapisu modelu i jeśli ustawiłeś wartość logiczną na True, upewnij się, że wszystkie inne są ustawione na False.

from django.db import transaction

class Character(models.Model):
    name = models.CharField(max_length=255)
    is_the_chosen_one = models.BooleanField()

    def save(self, *args, **kwargs):
        if not self.is_the_chosen_one:
            return super(Character, self).save(*args, **kwargs)
        with transaction.atomic():
            Character.objects.filter(
                is_the_chosen_one=True).update(is_the_chosen_one=False)
            return super(Character, self).save(*args, **kwargs)

Próbowałem zredagować podobną odpowiedź Adama, ale została ona odrzucona za zbyt dużą zmianę oryginalnej odpowiedzi. Ten sposób jest bardziej zwięzły i skuteczny, ponieważ sprawdzanie innych wpisów odbywa się w jednym zapytaniu.

Zamiast korzystać z czyszczenia / zapisywania modelu niestandardowego, utworzyłem plik niestandardowe pole nadpisujące pre_savemetodę django.db.models.BooleanField. Zamiast zgłaszać błąd, jeśli było inne pole True, zrobiłem wszystkie inne pola, Falsejeśli było True. Zamiast zgłaszać błąd, jeśli pole było Falsei żadne inne pole nie było True, zapisałem je jako poleTrue

fields.py

from django.db.models import BooleanField


class UniqueBooleanField(BooleanField):
    def pre_save(self, model_instance, add):
        objects = model_instance.__class__.objects
        # If True then set all others as False
        if getattr(model_instance, self.attname):
            objects.update(**{self.attname: False})
        # If no true object exists that isnt saved model, save as True
        elif not objects.exclude(id=model_instance.id)\
                        .filter(**{self.attname: True}):
            return True
        return getattr(model_instance, self.attname)

# To use with South
from south.modelsinspector import add_introspection_rules
add_introspection_rules([], ["^project\.apps\.fields\.UniqueBooleanField"])

models.py

from django.db import models

from project.apps.fields import UniqueBooleanField


class UniqueBooleanModel(models.Model):
    unique_boolean = UniqueBooleanField()

    def __unicode__(self):
        return str(self.unique_boolean)

Poniższe rozwiązanie jest trochę brzydkie, ale może działać:

class MyModel(models.Model):
    is_the_chosen_one = models.NullBooleanField(default=None, unique=True)

    def save(self, *args, **kwargs):
        if self.is_the_chosen_one is False:
            self.is_the_chosen_one = None
        super(MyModel, self).save(*args, **kwargs)

Jeśli ustawisz is_the_chosen_one na False lub None, zawsze będzie NULL. Możesz mieć NULL tyle, ile chcesz, ale możesz mieć tylko jedną True.

Próbując związać koniec z końcem z odpowiedziami tutaj, stwierdzam, że niektóre z nich odnoszą się z powodzeniem do tego samego problemu, a każdy jest odpowiedni w różnych sytuacjach:

Wybrałbym:

• @semente : szanuje ograniczenie na poziomie bazy danych, modelu i formularza administratora, podczas gdy zastępuje Django ORM w najmniejszym możliwym stopniu. Co więcej, możeprawdopodobniebyć używane wewnątrz throughtabeli ManyToManyFieldw unique_togethersytuacji.(Sprawdzę to i zamelduję)

  class MyModel(models.Model):
      is_the_chosen_one = models.NullBooleanField(default=None, unique=True)
  
      def save(self, *args, **kwargs):
          if self.is_the_chosen_one is False:
              self.is_the_chosen_one = None
          super(MyModel, self).save(*args, **kwargs)
  

• @Ellis Percival : Uderza do bazy danych tylko jeden dodatkowy raz i akceptuje bieżący wpis jako wybrany. Czysty i elegancki.

  from django.db import transaction
  
  class Character(models.Model):
      name = models.CharField(max_length=255)
      is_the_chosen_one = models.BooleanField()
  
  def save(self, *args, **kwargs):
      if not self.is_the_chosen_one:
          # The use of return is explained in the comments
          return super(Character, self).save(*args, **kwargs)  
      with transaction.atomic():
          Character.objects.filter(
              is_the_chosen_one=True).update(is_the_chosen_one=False)
          # The use of return is explained in the comments
          return super(Character, self).save(*args, **kwargs)  
  

Inne rozwiązania nieodpowiednie dla mojego przypadku, ale wykonalne:

@nemocorp zastępuje cleanmetodę w celu przeprowadzenia walidacji. Jednak nie informuje, który model jest „tym”, a to nie jest przyjazne dla użytkownika. Mimo to jest to bardzo fajne podejście, zwłaszcza jeśli ktoś nie zamierza być tak agresywny jak @Flyte.

@ saul.shanabrook i @Thierry J. utworzyliby niestandardowe pole, które zmieniłoby dowolny inny wpis „is_the_one” na Falselub podniósł ValidationError. Jestem po prostu niechętny do wprowadzania nowych funkcji do mojej instalacji Django, chyba że jest to absolutnie konieczne.

@daigorocub : używa sygnałów Django. Uważam, że jest to wyjątkowe podejście i podpowiada, jak używać sygnałów Django . Jednak nie jestem pewien, czy jest to - ściśle mówiąc - „właściwe” użycie sygnałów, ponieważ nie mogę traktować tej procedury jako części „aplikacji oddzielonej”.

class Character(models.Model):
    name = models.CharField(max_length=255)
    is_the_chosen_one = models.BooleanField()

    def save(self, *args, **kwargs):
        if self.is_the_chosen_one:
            qs = Character.objects.filter(is_the_chosen_one=True)
            if self.pk:
                qs = qs.exclude(pk=self.pk)
            if qs.count() != 0:
                # choose ONE of the next two lines
                self.is_the_chosen_one = False # keep the existing "chosen one"
                #qs.update(is_the_chosen_one=False) # make this obj "the chosen one"
        super(Character, self).save(*args, **kwargs)

class CharacterForm(forms.ModelForm):
    class Meta:
        model = Character

    # if you want to use the new obj as the chosen one and remove others, then
    # be sure to use the second line in the model save() above and DO NOT USE
    # the following clean method
    def clean_is_the_chosen_one(self):
        chosen = self.cleaned_data.get('is_the_chosen_one')
        if chosen:
            qs = Character.objects.filter(is_the_chosen_one=True)
            if self.instance.pk:
                qs = qs.exclude(pk=self.instance.pk)
            if qs.count() != 0:
                raise forms.ValidationError("A Chosen One already exists! You will pay for your insolence!")
        return chosen

Możesz użyć powyższego formularza również dla administratora, po prostu użyj

class CharacterAdmin(admin.ModelAdmin):
    form = CharacterForm
admin.site.register(Character, CharacterAdmin)

class Character(models.Model):
    name = models.CharField(max_length=255)
    is_the_chosen_one = models.BooleanField()

    def clean(self):
        from django.core.exceptions import ValidationError
        c = Character.objects.filter(is_the_chosen_one__exact=True)  
        if c and self.is_the_chosen:
            raise ValidationError("The chosen one is already here! Too late")

W ten sposób walidacja była dostępna w podstawowym formularzu administratora

Łatwiej jest dodać tego rodzaju ograniczenie do modelu po wersji 2.2 Django. Możesz bezpośrednio użyć UniqueConstraint.condition. Django Docs

Po prostu zastąp swoje modele w class Metaten sposób:

class Meta:
    constraints = [
        UniqueConstraint(fields=['is_the_chosen_one'], condition=Q(is_the_chosen_one=True), name='unique_is_the_chosen_one')
    ]

I to wszystko.

def save(self, *args, **kwargs):
    if self.default_dp:
        DownloadPageOrder.objects.all().update(**{'default_dp': False})
    super(DownloadPageOrder, self).save(*args, **kwargs)

Stosując podobne podejście jak Saul, ale nieco inny cel:

class TrueUniqueBooleanField(BooleanField):

    def __init__(self, unique_for=None, *args, **kwargs):
        self.unique_for = unique_for
        super(BooleanField, self).__init__(*args, **kwargs)

    def pre_save(self, model_instance, add):
        value = super(TrueUniqueBooleanField, self).pre_save(model_instance, add)

        objects = model_instance.__class__.objects

        if self.unique_for:
            objects = objects.filter(**{self.unique_for: getattr(model_instance, self.unique_for)})

        if value and objects.exclude(id=model_instance.id).filter(**{self.attname: True}):
            msg = 'Only one instance of {} can have its field {} set to True'.format(model_instance.__class__, self.attname)
            if self.unique_for:
                msg += ' for each different {}'.format(self.unique_for)
            raise ValidationError(msg)

        return value

Ta implementacja spowoduje podniesienie a ValidationErrorpodczas próby zapisania innego rekordu z wartością True.

Dodałem również unique_forargument, który można ustawić na dowolne inne pole w modelu, aby sprawdzić prawdziwą unikalność tylko dla rekordów o tej samej wartości, takich jak:

class Phone(models.Model):
    user = models.ForeignKey(User)
    main = TrueUniqueBooleanField(unique_for='user', default=False)

Czy dostanę punkty za odpowiedź na moje pytanie?

problem polegał na tym, że znalazł się w pętli, naprawiony przez:

    # is this the testimonial image, if so, unselect other images
    if self.testimonial_image is True:
        others = Photograph.objects.filter(project=self.project).filter(testimonial_image=True)
        pdb.set_trace()
        for o in others:
            if o != self: ### important line
                o.testimonial_image = False
                o.save()

Wypróbowałem niektóre z tych rozwiązań i skończyłem na innym, tylko ze względu na zwięzłość kodu (nie muszę nadpisywać formularzy ani zapisywać metody). Aby to zadziałało, pole nie może być unikalne w swojej definicji, ale sygnał zapewnia, że ​​tak się stanie.

# making default_number True unique
@receiver(post_save, sender=Character)
def unique_is_the_chosen_one(sender, instance, **kwargs):
    if instance.is_the_chosen_one:
        Character.objects.all().exclude(pk=instance.pk).update(is_the_chosen_one=False)

Aktualizacja 2020, aby ułatwić początkującym:

class Character(models.Model):
    name = models.CharField(max_length=255)
    is_the_chosen_one = models.BooleanField(blank=False, null=False, default=False)

    def save(self):
         if self.is_the_chosen_one == True:
              items = Character.objects.filter(is_the_chosen_one = True)
              for x in items:
                   x.is_the_chosen_one = False
                   x.save()
         super().save()

Oczywiście, jeśli chcesz, aby unikalna wartość logiczna miała wartość False, po prostu zamień każdą instancję True na False i odwrotnie.