Valore BooleanField unico in Django?

Supponiamo che il mio models.py sia così:

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

Voglio che solo una delle mie Characteristanze abbia is_the_chosen_one == Truee tutte le altre is_the_chosen_one == False. Come posso garantire al meglio il rispetto di questo vincolo di unicità?

Il massimo dei voti alle risposte che tengono conto dell'importanza di rispettare il vincolo a livello di database, modello e modulo (admin)!

Ogni volta che ho bisogno di eseguire questa operazione, ciò che ho fatto è sovrascrivere il metodo di salvataggio per il modello e fargli controllare se qualsiasi altro modello ha il flag già impostato (e disattivarlo).

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)

Sostituirei il metodo di salvataggio del modello e se hai impostato il valore booleano su True, assicurati che tutti gli altri siano impostati su 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)

Ho provato a modificare la risposta simile di Adam, ma è stata rifiutata per aver modificato troppo la risposta originale. In questo modo è più succinto ed efficiente in quanto il controllo di altre voci viene eseguito in una singola query.

Invece di utilizzare la pulizia / salvataggio del modello personalizzato, ho creato un campo personalizzato che sovrascrive il pre_savemetodo django.db.models.BooleanField. Invece di generare un errore se c'era un altro campo True, ho creato tutti gli altri campi Falsese lo era True. Inoltre, invece di generare un errore se il campo era Falsee nessun altro campo lo era True, l'ho salvato comeTrue

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)

La seguente soluzione è un po 'brutta ma potrebbe funzionare:

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)

Se imposti is_the_chosen_one su False o None, sarà sempre NULL. Puoi avere NULL quanto vuoi, ma puoi averne solo uno True.

Cercando di sbarcare il lunario con le risposte qui, trovo che alcune di esse affrontino lo stesso problema con successo e ognuna sia adatta a situazioni diverse:

Sceglierei:

• @semente : rispetta il vincolo a livello di database, modello e modulo di amministrazione mentre sovrascrive il meno possibile Django ORM. Inoltre puòprobabilmenteessere utilizzato all'interno di una throughtabella di ManyToManyFielduna unique_togethersituazione.(Lo controllerò e riferirò)

  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 : colpisce il database solo una volta in più e accetta la voce corrente come quella prescelta. Pulito ed elegante.

  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)  
  

Altre soluzioni non adatte al mio caso ma praticabili:

@nemocorp sta sovrascrivendo il cleanmetodo per eseguire una convalida. Tuttavia, non riporta quale modello è "quello" e questo non è facile da usare. Nonostante ciò, è un approccio molto carino, specialmente se qualcuno non intende essere aggressivo come @Flyte.

@ saul.shanabrook e @Thierry J. creerebbero un campo personalizzato che cambierebbe qualsiasi altra voce "is_the_one" Falseo solleverebbe un ValidationError. Sono solo riluttante a migliorare nuove funzionalità per la mia installazione Django a meno che non sia assolutamente necessario.

@daigorocub : utilizza i segnali Django. Lo trovo un approccio unico e dà un suggerimento su come utilizzare i segnali Django . Tuttavia non sono sicuro che si tratti di un uso "corretto" dei segnali poiché non posso considerare questa procedura come parte di una "applicazione disaccoppiata".

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

Puoi utilizzare il modulo sopra anche per l'amministratore, basta usare

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")

In questo modo la convalida è disponibile nel modulo di amministrazione di base

È più semplice aggiungere questo tipo di vincolo al tuo modello dopo la versione 2.2 di Django. Puoi usare direttamente UniqueConstraint.condition. Django Docs

Sovrascrivi i tuoi modelli in class Metaquesto modo:

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

E questo è tutto.

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

Utilizzando un approccio simile a Saul, ma con uno scopo leggermente diverso:

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

Questa implementazione genererà un ValidationErrorquando si tenta di salvare un altro record con un valore di True.

Inoltre, ho aggiunto l' unique_forargomento che può essere impostato su qualsiasi altro campo nel modello, per verificare la vera unicità solo per i record con lo stesso valore, come ad esempio:

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

Ottengo punti rispondendo alla mia domanda?

il problema era che si trovava nel ciclo, risolto da:

    # 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()

Ho provato alcune di queste soluzioni e ne ho trovata un'altra, solo per motivi di brevità del codice (non è necessario sovrascrivere i moduli o salvare il metodo). Perché funzioni, il campo non può essere unico nella sua definizione, ma il segnale fa in modo che ciò accada.

# 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)

Aggiornamento 2020 per rendere le cose meno complicate per i principianti:

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()

Ovviamente, se vuoi che il valore booleano univoco sia False, devi semplicemente scambiare ogni istanza di True con False e viceversa.