Come limitare il valore massimo di un campo numerico in un modello Django?

Django ha vari campi numerici disponibili per l'uso nei modelli, ad esempio DecimalField e PositiveIntegerField . Sebbene il primo possa essere limitato al numero di cifre decimali memorizzate e al numero complessivo di caratteri memorizzati, esiste un modo per limitarlo a memorizzare solo numeri entro un certo intervallo, ad esempio 0,0-5,0?

In caso contrario, c'è un modo per limitare un PositiveIntegerField per memorizzare solo, ad esempio, numeri fino a 50?

Aggiornamento: ora che Bug 6845 è stato chiuso , questa domanda StackOverflow potrebbe essere discutibile. - sampablokuper

È inoltre possibile creare un tipo di campo del modello personalizzato: consultare http://docs.djangoproject.com/en/dev/howto/custom-model-fields/#howto-custom-model-fields

In questo caso, è possibile "ereditare" da IntegerField integrato e sovrascriverne la logica di convalida.

Più ci penso, mi rendo conto di quanto sarebbe utile per molte app Django. Forse un tipo IntegerRangeField potrebbe essere inviato come patch per gli sviluppatori di Django per prendere in considerazione l'aggiunta al trunk.

Questo funziona per me:

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)

Quindi nella tua classe di modello, lo useresti in questo modo (campo essendo il modulo in cui hai inserito il codice sopra):

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

OPPURE per un intervallo di negativo e positivo (come un intervallo di oscillatori):

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

Ciò che sarebbe davvero bello sarebbe se potesse essere chiamato con l'operatore di gamma in questo modo:

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

Ma ciò richiederebbe molto più codice dato che è possibile specificare un parametro 'skip' - range (1, 50, 2) - Idea interessante però ...

Puoi usare i validatori integrati di Django -

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

Modifica : quando si lavora direttamente con il modello, assicurarsi di chiamare il metodo full_clean del modello prima di salvare il modello per attivare i validatori. Questo non è necessario quando si utilizza ModelFormpoiché i moduli lo faranno automaticamente.

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

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

Ho avuto questo stesso problema; ecco la mia soluzione:

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

Ci sono due modi per farlo. Uno è utilizzare la validazione del modulo per non consentire a nessun utente di inserire un numero superiore a 50. Documenti di convalida del modulo .

Se non vi è alcun utente coinvolto nel processo o non si utilizza un modulo per immettere dati, è necessario sostituire il savemetodo del modello per generare un'eccezione o limitare i dati che entrano nel campo.

Ecco la soluzione migliore se vuoi maggiore flessibilità e non vuoi cambiare il campo del tuo modello. Aggiungi questo validatore personalizzato:

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

E può essere usato come tale:

class YourModel(models.Model):

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

I due parametri sono max e min e consente valori null. Se lo desideri, puoi personalizzare il validatore eliminando l'istruzione if contrassegnata o modificare il campo in modo che sia vuoto = Falso, null = Falso nel modello. Ciò richiederà ovviamente una migrazione.

Nota: ho dovuto aggiungere il validatore perché Django non convalida l'intervallo su PositiveSmallIntegerField, invece crea un smallint (in postgres) per questo campo e si ottiene un errore DB se il valore numerico specificato non è compreso nell'intervallo.

Spero che questo aiuti :) Altre informazioni sui validatori in Django .

PS. Ho basato la mia risposta su BaseValidator in django.core.validators, ma tutto è diverso tranne il codice.