Wie kann man den Maximalwert eines numerischen Feldes in einem Django-Modell begrenzen?

Django verfügt über verschiedene numerische Felder zur Verwendung in Modellen, z . B. DecimalField und PositiveIntegerField . Ersteres kann zwar auf die Anzahl der gespeicherten Dezimalstellen und die Gesamtzahl der gespeicherten Zeichen beschränkt werden. Gibt es jedoch eine Möglichkeit, das Speichern nur von Zahlen innerhalb eines bestimmten Bereichs zu beschränken, z. B. 0,0-5,0?

Wenn dies nicht der Fall ist, gibt es eine Möglichkeit, ein PositiveIntegerField so einzuschränken, dass beispielsweise nur Zahlen bis zu 50 gespeichert werden?

Update: Nachdem Bug 6845 geschlossen wurde , ist diese StackOverflow-Frage möglicherweise nicht mehr aktuell. - Sampablokuper

Sie können auch einen benutzerdefinierten Modellfeldtyp erstellen - siehe http://docs.djangoproject.com/de/dev/howto/custom-model-fields/#howto-custom-model-fields

In diesem Fall können Sie vom integrierten IntegerField 'erben' und dessen Validierungslogik überschreiben.

Je mehr ich darüber nachdenke, desto nützlicher wird mir, dass dies für viele Django-Apps nützlich ist. Möglicherweise könnte ein IntegerRangeField-Typ als Patch für die Django-Entwickler eingereicht werden, um das Hinzufügen zum Trunk in Betracht zu ziehen.

Das funktioniert bei mir:

from django.db import models

class IntegerRangeField(models.IntegerField):
    def __init__(self, verbose_name=None, name=None, min_value=None, max_value=None, **kwargs):
        self.min_value, self.max_value = min_value, max_value
        models.IntegerField.__init__(self, verbose_name, name, **kwargs)
    def formfield(self, **kwargs):
        defaults = {'min_value': self.min_value, 'max_value':self.max_value}
        defaults.update(kwargs)
        return super(IntegerRangeField, self).formfield(**defaults)

Dann würden Sie es in Ihrer Modellklasse folgendermaßen verwenden (Feld ist das Modul, in das Sie den obigen Code einfügen):

size = fields.IntegerRangeField(min_value=1, max_value=50)

ODER für einen Bereich von negativ und positiv (wie ein Oszillatorbereich):

size = fields.IntegerRangeField(min_value=-100, max_value=100)

Was wirklich cool wäre, wäre, wenn es mit dem Bereichsoperator wie folgt aufgerufen werden könnte:

size = fields.IntegerRangeField(range(1, 50))

Dies würde jedoch viel mehr Code erfordern, da Sie einen 'Überspringen'-Parameter angeben können - Bereich (1, 50, 2) - Interessante Idee ...

Sie können die in Django integrierten Validatoren verwenden -

from django.db.models import IntegerField, Model
from django.core.validators import MaxValueValidator, MinValueValidator

class CoolModelBro(Model):
    limited_integer_field = IntegerField(
        default=1,
        validators=[
            MaxValueValidator(100),
            MinValueValidator(1)
        ]
     )

Bearbeiten : Wenn Sie direkt mit dem Modell arbeiten, müssen Sie vor dem Speichern des Modells die Methode model full_clean aufrufen , um die Validatoren auszulösen. Dies ist bei der Verwendung nicht erforderlich, ModelFormda die Formulare dies automatisch tun.

from django.db import models
from django.core.validators import MinValueValidator, MaxValueValidator

size = models.IntegerField(validators=[MinValueValidator(0),
                                       MaxValueValidator(5)])

Ich hatte genau das gleiche Problem; Hier war meine Lösung:

SCORE_CHOICES = zip( range(1,n), range(1,n) )
score = models.IntegerField(choices=SCORE_CHOICES, blank=True)

Es gibt zwei Möglichkeiten, dies zu tun. Eine besteht darin, die Formularvalidierung zu verwenden, um niemals zuzulassen, dass ein Benutzer eine Zahl über 50 eingibt. Formularvalidierungsdokumente .

Wenn kein Benutzer an dem Prozess beteiligt ist oder Sie kein Formular zur Dateneingabe verwenden, müssen Sie die saveMethode des Modells überschreiben , um eine Ausnahme auszulösen oder die in das Feld eingehenden Daten einzuschränken .

Hier ist die beste Lösung, wenn Sie zusätzliche Flexibilität wünschen und Ihr Modellfeld nicht ändern möchten. Fügen Sie einfach diesen benutzerdefinierten Validator hinzu:

#Imports
from django.core.exceptions import ValidationError      

class validate_range_or_null(object):
    compare = lambda self, a, b, c: a > c or a < b
    clean = lambda self, x: x
    message = ('Ensure this value is between %(limit_min)s and %(limit_max)s (it is %(show_value)s).')
    code = 'limit_value'

    def __init__(self, limit_min, limit_max):
        self.limit_min = limit_min
        self.limit_max = limit_max

    def __call__(self, value):
        cleaned = self.clean(value)
        params = {'limit_min': self.limit_min, 'limit_max': self.limit_max, 'show_value': cleaned}
        if value:  # make it optional, remove it to make required, or make required on the model
            if self.compare(cleaned, self.limit_min, self.limit_max):
                raise ValidationError(self.message, code=self.code, params=params)

Und es kann als solches verwendet werden:

class YourModel(models.Model):

    ....
    no_dependents = models.PositiveSmallIntegerField("How many dependants?", blank=True, null=True, default=0, validators=[validate_range_or_null(1,100)])

Die beiden Parameter sind max und min und erlauben Nullen. Sie können den Validator anpassen, indem Sie die markierte if-Anweisung entfernen oder Ihr Feld so ändern, dass es leer = False, null = False im Modell ist. Das erfordert natürlich eine Migration.

Hinweis: Ich musste den Validator hinzufügen, da Django den Bereich in PositiveSmallIntegerField nicht validiert, sondern eine kleine Intint (in Postgres) für dieses Feld erstellt und Sie einen DB-Fehler erhalten, wenn die angegebene Zahl außerhalb des Bereichs liegt.

Hoffe das hilft :) Mehr zu Validators in Django .

PS. Ich habe meine Antwort auf BaseValidator in django.core.validators basiert, aber bis auf den Code ist alles anders.