¿Cómo limitar el valor máximo de un campo numérico en un modelo de Django?

Question

Django tiene varios campos numéricos disponibles para su uso en modelos, p. DecimalField y PositiveIntegerField. Aunque el primero se puede restringir al número de decimales almacenados y al número total de caracteres almacenados, ¿hay alguna manera de restringirlo a almacenar solo números dentro de un cierto rango, p. 0.0-5.0?

En su defecto, ¿hay alguna forma de restringir un PositiveIntegerField para almacenar solo, por ejemplo, números de hasta 50?

Actualización: ahora que Bug 6845 has been closed, esta pregunta de StackOverflow puede ser discutible. - sampablokuper

Answer 1

También podría crear un modelo personalizado de tipo de campo - ver http://docs.djangoproject.com/en/dev/howto/custom-model-fields/#howto-custom-model-fields

En este caso, se podría 'hereda' de la validación de su lógica incorporada IntegerField y anular.

Cuanto más pienso en esto, me doy cuenta de lo útil que sería para muchas aplicaciones de Django. Quizás un tipo de IntegerRangeField podría enviarse como un parche para que los desarrolladores de Django consideren agregarlo a trunk.

Esto es trabajo para mí:

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) 

Luego, en la clase del modelo, que podría utilizar de esta manera (siendo campo del módulo donde se coloca el código anterior):

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

O para un rango de negativo y positivo (como un rango de oscilador):

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

Lo que sería genial si c Ould ser llamada con el operador de rango como esto:

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

embargo, eso requeriría un código mucho más desde ya que se puede especificar un parámetro 'saltar' - rango (1, 50, 2) - Una idea interesante sin embargo. ..

Answer 2

Hay dos formas de hacerlo. Una es usar la validación de formularios para que un usuario no ingrese ningún número mayor de 50. Form validation docs.

Si no hay un usuario involucrado en el proceso, o si no está usando un formulario para ingresar datos, entonces deberá anular el método save del modelo para lanzar una excepción o limitar la entrada de datos al campo.

Answer 3

Tuve este mismo problema; aquí fue mi solución:

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

Answer 4

Usted puede utilizar Django's built-in validators -

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

Editar: Aunque estos only work when you're using the model in a ModelForm, no si está usando el modelo "por sí solo", suspiro.

Answer 5

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

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

Answer 6

Aquí está la mejor solución si desea flexibilidad adicional y no desea cambiar el campo de su modelo. Sólo tiene que añadir este validador personalizado:

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

Y puede ser utilizado como tal:

class YourModel(models.Model): 

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

Los dos parámetros son máximos y mínimos, y que permite nulos. Puede personalizar el validador si lo desea, deshágase de la declaración if marcada o cambie su campo para que esté en blanco = False, null = False en el modelo. Eso, por supuesto, requerirá una migración.

Nota: Tuve que agregar el validador porque Django no valida el rango en PositiveSmallIntegerField, sino que crea una smallint (en postgres) para este campo y se obtiene un error de DB si el número especificado está fuera de rango.

Espero que esto ayude :) Más sobre Validators in Django.

PS. Basé mi respuesta en BaseValidator en django.core.validators, pero todo es diferente a excepción del código.