Comment limiter la valeur maximale d'un champ numérique dans un modèle Django?

Django a divers champs numériques disponibles pour une utilisation dans les modèles, par exemple DecimalField et PositiveIntegerField . Bien que le premier puisse être limité au nombre de décimales stockées et au nombre total de caractères stockés, y a-t-il un moyen de le restreindre à stocker uniquement des nombres dans une certaine plage, par exemple 0,0-5,0?

À défaut, existe-t-il un moyen de restreindre un PositiveIntegerField pour ne stocker, par exemple, que des nombres jusqu'à 50?

Mise à jour: maintenant que le bogue 6845 a été fermé , cette question StackOverflow peut être sans objet. - sampablokuper

Vous pouvez également créer un type de champ de modèle personnalisé - voir http://docs.djangoproject.com/en/dev/howto/custom-model-fields/#howto-custom-model-fields

Dans ce cas, vous pouvez «hériter» du champ IntegerField intégré et remplacer sa logique de validation.

Plus j'y pense, plus je réalise à quel point cela serait utile pour de nombreuses applications Django. Peut-être qu'un type IntegerRangeField pourrait être soumis en tant que patch pour que les développeurs Django envisagent l'ajout au tronc.

Cela fonctionne pour moi:

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)

Ensuite, dans votre classe de modèle, vous l'utiliseriez comme ceci (le champ étant le module où vous mettez le code ci-dessus):

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

OU pour une plage de négatif et de positif (comme une plage d'oscillateur):

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

Ce qui serait vraiment cool, c'est s'il pouvait être appelé avec l'opérateur de plage comme ceci:

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

Mais cela nécessiterait beaucoup plus de code car puisque vous pouvez spécifier un paramètre `` skip '' - range (1, 50, 2) - Idée intéressante cependant ...

Vous pouvez utiliser les validateurs intégrés de 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)
        ]
     )

Edit : Lorsque vous travaillez directement avec le modèle, assurez-vous d'appeler la méthode model full_clean avant d'enregistrer le modèle afin de déclencher les validateurs. Cela n'est pas nécessaire lors de l'utilisation ModelFormcar les formulaires le feront automatiquement.

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

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

J'ai eu ce même problème; voici ma solution:

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

Il y a deux façons de faire ça. La première consiste à utiliser la validation de formulaire pour ne jamais laisser entrer un nombre supérieur à 50 par un utilisateur. Documents de validation de formulaire .

Si aucun utilisateur n'est impliqué dans le processus, ou si vous n'utilisez pas de formulaire pour saisir des données, vous devrez remplacer la saveméthode du modèle pour lever une exception ou limiter les données entrant dans le champ.

Voici la meilleure solution si vous souhaitez une flexibilité supplémentaire et ne souhaitez pas modifier votre champ de modèle. Ajoutez simplement ce validateur personnalisé:

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

Et il peut être utilisé comme tel:

class YourModel(models.Model):

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

Les deux paramètres sont max et min et autorise les valeurs nulles. Vous pouvez personnaliser le validateur si vous le souhaitez en vous débarrassant de l'instruction if marquée ou en modifiant votre champ pour qu'il soit vide = False, null = False dans le modèle. Cela nécessitera bien sûr une migration.

Remarque: j'ai dû ajouter le validateur car Django ne valide pas la plage sur PositiveSmallIntegerField, au lieu de cela, il crée un smallint (dans postgres) pour ce champ et vous obtenez une erreur de base de données si le numérique spécifié est hors plage.

J'espère que cela aidera :) Plus d'informations sur les validateurs dans Django .

PS. J'ai basé ma réponse sur BaseValidator dans django.core.validators, mais tout est différent sauf pour le code.