Eindeutiger BooleanField-Wert in Django?

Angenommen, meine models.py ist wie folgt:

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

Ich möchte nur eine meiner CharacterInstanzen is_the_chosen_one == Trueund alle anderen haben is_the_chosen_one == False. Wie kann ich am besten sicherstellen, dass diese Eindeutigkeitsbeschränkung eingehalten wird?

Bestnoten für Antworten, die die Wichtigkeit der Einhaltung der Einschränkungen auf Datenbank-, Modell- und (Administrator-) Formularebene berücksichtigen!

Wann immer ich diese Aufgabe ausführen musste, habe ich die Speichermethode für das Modell überschrieben und prüfen lassen, ob für ein anderes Modell das Flag bereits gesetzt ist (und es deaktivieren).

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)

Ich würde die Speichermethode des Modells überschreiben. Wenn Sie den Booleschen Wert auf True gesetzt haben, stellen Sie sicher, dass alle anderen auf False gesetzt sind.

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)

Ich habe versucht, die ähnliche Antwort von Adam zu bearbeiten, aber sie wurde abgelehnt, weil zu viel von der ursprünglichen Antwort geändert wurde. Diese Methode ist prägnanter und effizienter, da die Überprüfung anderer Einträge in einer einzigen Abfrage erfolgt.

Anstatt das Bereinigen / Speichern von benutzerdefinierten Modellen zu verwenden, habe ich ein benutzerdefiniertes Feld erstellt, das die pre_saveMethode überschreibt django.db.models.BooleanField. Anstatt einen Fehler auszulösen, wenn ein anderes Feld vorhanden war True, habe ich alle anderen Felder erstellt, Falsewenn dies der Fall war True. Anstatt einen Fehler auszulösen, wenn das Feld war Falseund kein anderes Feld war True, habe ich das Feld als gespeichertTrue

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)

Die folgende Lösung ist etwas hässlich, könnte aber funktionieren:

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)

Wenn Sie is_the_chosen_one auf False oder None setzen, ist es immer NULL. Sie können so viel NULL haben, wie Sie möchten, aber Sie können nur ein True haben.

Beim Versuch, mit den Antworten hier über die Runden zu kommen, stelle ich fest, dass einige von ihnen dasselbe Problem erfolgreich angehen und jedes für unterschiedliche Situationen geeignet ist:

Ich würde wählen:

• @semente : Respektiert die Einschränkung auf Datenbank-, Modell- und Administratorformularebene, während Django ORM so wenig wie möglich überschrieben wird. Darüber hinaus kann eswahrscheinlichin einer throughTabelle ManyToManyFieldin einer unique_togetherSituation verwendet werden.(Ich werde es überprüfen und berichten)

  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 : Trifft die Datenbank nur ein zusätzliches Mal und akzeptiert den aktuellen Eintrag als den ausgewählten. Sauber und elegant.

  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)  

Andere Lösungen, die für meinen Fall nicht geeignet, aber realisierbar sind:

@nemocorp überschreibt die cleanMethode zur Durchführung einer Validierung. Es wird jedoch nicht zurückgemeldet, welches Modell "das" ist, und dies ist nicht benutzerfreundlich. Trotzdem ist es ein sehr netter Ansatz, besonders wenn jemand nicht so aggressiv sein will wie @Flyte.

@ saul.shanabrook und @Thierry J. würden ein benutzerdefiniertes Feld erstellen, das entweder einen anderen "is_the_one" -Eintrag in a ändert Falseoder a auslöst ValidationError. Ich zögere nur, neue Funktionen für meine Django-Installation zu implementieren, es sei denn, dies ist unbedingt erforderlich.

@daigorocub : Verwendet Django-Signale. Ich finde es ein einzigartiger Ansatz und gebe einen Hinweis auf die Verwendung von Django-Signalen . Ich bin mir jedoch nicht sicher, ob dies streng genommen eine "ordnungsgemäße" Verwendung von Signalen ist, da ich dieses Verfahren nicht als Teil einer "entkoppelten Anwendung" betrachten kann.

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

Sie können das obige Formular auch für Administratoren verwenden. Verwenden Sie einfach

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

Dadurch wurde die Validierung im Basisverwaltungsformular verfügbar

Es ist einfacher, diese Art von Einschränkung nach Django Version 2.2 zu Ihrem Modell hinzuzufügen. Sie können direkt verwenden UniqueConstraint.condition. Django Docs

Überschreiben Sie einfach Ihre Modelle class Metawie folgt:

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

Und das ist alles.

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

Mit einem ähnlichen Ansatz wie Saul, aber etwas anderem Zweck:

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

Diese Implementierung löst ein aus, ValidationErrorwenn versucht wird, einen anderen Datensatz mit dem Wert True zu speichern.

Außerdem habe ich das unique_forArgument hinzugefügt, das für jedes andere Feld im Modell festgelegt werden kann, um die Eindeutigkeit nur für Datensätze mit demselben Wert zu überprüfen, z.

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

Bekomme ich Punkte für die Beantwortung meiner Frage?

Das Problem war, dass es sich in der Schleife befand, behoben durch:

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

Ich habe einige dieser Lösungen ausprobiert und bin aus Gründen der Codekürzung zu einer anderen gekommen (ich muss keine Formulare überschreiben oder Methoden speichern). Damit dies funktioniert, kann das Feld in seiner Definition nicht eindeutig sein, aber das Signal stellt sicher, dass dies geschieht.

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

Update 2020, um Anfängern die Arbeit zu erleichtern:

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

Wenn Sie möchten, dass der eindeutige Boolesche Wert False ist, tauschen Sie natürlich einfach jede Instanz von True gegen False aus und umgekehrt.