(Django) Ajuster les espaces de charField

Comment puis-je bande espaces (trim) à partir de la fin d'un charField dans Django?

Voici mon Modèle, comme vous pouvez le voir j'ai essayé de les mettre en propre mais ces méthodes ne jamais se faire.

J'ai aussi essayé de faire name.strip()models.charField().strip() mais elles ne fonctionnent pas non plus.

Est-il un moyen pour forcer le charField pour couper automatiquement pour moi?

Grâce.

from django.db import models
from django.forms import ModelForm
from django.core.exceptions import ValidationError
import datetime

class Employee(models.Model):
    """(Workers, Staff, etc)"""
    name                = models.CharField(blank=True, null=True, max_length=100)

    def save(self, *args, **kwargs):
        try:
            # This line doesn't do anything??
            #self.full_clean()
            Employee.clean(self)
        except ValidationError, e:
            print e.message_dict

        super(Employee, self).save(*args, **kwargs) # Real save

    # If I uncomment this, I get an TypeError: unsubscriptable object
    #def clean(self):
    #   return self.clean['name'].strip()

    def __unicode__(self):
        return self.name

    class Meta:
        verbose_name_plural = 'Employees'

    class Admin:pass


class EmployeeForm(ModelForm):
    class Meta:
        model = Employee

    # I have no idea if this method is being called or not  
    def full_clean(self):       
        return super(Employee), self.clean().strip()
        #return self.clean['name'].strip()

Édité: mise à Jour du code pour ma dernière version. Je ne suis pas sûr de ce que je fais de mal qu'il n'est pas encore le décapage de l'espace (coupe) le champ nom.

source d'informationauteur zardon

Modèle de nettoyage doit être appelé (c'est pas automatique) afin de placer quelques self.full_clean() dans votre méthode de sauvegarde.

http://docs.djangoproject.com/en/dev/ref/models/instances/#django.db.models.Model.full_clean

Comme pour votre formulaire, vous devez renvoyer l'dépouillé de données nettoyées.

return self.cleaned_data['name'].strip()

En quelque sorte, je pense que vous avez juste essayé de faire un tas de trucs qui ne fonctionne pas. Rappelez-vous que les formulaires et les modèles sont 2 choses très différentes.

Vérifier sur les formes docs sur la façon de valider des formulaires
http://docs.djangoproject.com/en/dev/ref/forms/validation/

super(Employee), self.clean().strip() makes no sense at all!

Voici ton code corrigé:

class Employee(models.Model):
    """(Workers, Staff, etc)"""
    name = models.CharField(blank=True, null=True, max_length=100)

    def save(self, *args, **kwargs):
        self.full_clean() # performs regular validation then clean()
        super(Employee, self).save(*args, **kwargs)


    def clean(self):
        """
        Custom validation (read docs)
        PS: why do you have null=True on charfield? 
        we could avoid the check for name
        """
        if self.name: 
            self.name = self.name.strip()


class EmployeeForm(ModelForm):
    class Meta:
        model = Employee


    def clean_name(self):
        """
        If somebody enters into this form ' hello ', 
        the extra whitespace will be stripped.
        """
        return self.cleaned_data.get('name', '').strip()

Lorsque vous utilisez un ModelForm exemple pour créer/modifier un modèle, le modèle de la méthode clean() est la garantie d'être appelé. Donc, si vous voulez suppression des espaces à partir d'un champ, il suffit d'ajouter une méthode clean() à votre modèle (pas besoin de modifier le ModelForm classe):

class Employee(models.Model):
    """(Workers, Staff, etc)"""
    name = models.CharField(blank=True, null=True, max_length=100)

    def clean(self):
        if self.name:
            self.name = self.name.strip()

Je trouve l'extrait de code suivant utiles - il réduit l'espace pour tous les modèle de champs qui sous-classe soit CharField ou TextField (c'est aussi les captures URLField champs), sans avoir à indiquer les champs individuellement:

def clean(self):
    for field in self._meta.fields:
        if isinstance(field, (models.CharField, models.TextField)):
            value = getattr(self, field.name)
            if value:
                setattr(self, field.name, value.strip())

Quelqu'un a fait remarquer avec raison que vous ne devriez pas utiliser null=True dans le nom de la déclaration. La meilleure pratique est d'éviter null=True pour les champs de type chaîne, auquel cas ci-dessus se simplifie en:

def clean(self):
    for field in self._meta.fields:
        if isinstance(field, (models.CharField, models.TextField)):
            setattr(self, field.name, getattr(self, field.name).strip())

Si vous avez tant de champs de données à découper, pourquoi ne pas essayer l'extension de CharField?

from django.db import models
from django.utils.translation import ugettext_lazy as _

class TrimCharField(models.CharField):
   description = _(
       "CharField that ignores leading" 
       " and trailing spaces in data")

   def get_prep_value(self, value)
       return trim(super(TrimCharField, self
           ).get_prep_value(value))

   def pre_save(self, model_instance, add):
       return trim(super(TrimCharField, self
           ).pre_save(model_instance, add))

Mise à JOUR:
Pour Django versions <= 1.7 si vous souhaitez étendre domaine, vous êtes à utiliser des modèles.SubfieldBase métaclasse. Donc, ici, il sera comme:

class TrimCharField(six.with_metaclass(
    models.SubfieldBase, models.CharField)):

Je suis de la manipulation de ce dans les vues en tant que décorateur. Je suis également à tronquer les valeurs de champ qui dépasse un CharField max_length valeur.

from django import forms
from django import models
from django.db.models.fields import FieldDoesNotExist
from django.utils.encoding import smart_str

class CleanCharField(forms.CharField):
        """Django's default form handling drives me nuts wrt trailing
        spaces.  http://code.djangoproject.com/attachment/ticket/6362
        """
        def clean(self, value):
            if value is None:
                value = u''
            value = smart_str(value).strip()
            value = super(forms.CharField, self).clean(value)
            return value

def truncate_charfield(model):
    """decorator to truncate CharField data to model field max_length.
    Apply to the clean method in views Form:

    @truncate_charfield(MyModel)
    def clean(self):
        ...
    """
    def wrap(f):
        def wrapped_f(*args):
            f(*args)
            d = args[0].cleaned_data
            for field in model._meta.fields:
                try:
                    mf = model._meta.get_field(field.name)
                    if isinstance(mf, models.CharField) and field.name in d:
                        d[field.name] = d[field.name][:mf.max_length]
                except FieldDoesNotExist:
                    pass
            return d
        return wrapped_f
    return wrap

3

Django 1.9 offre un moyen simple d'y parvenir. À l'aide de la strip argument dont la valeur par défaut est True, vous pouvez assurez-vous que l'attaque et de fuite des espaces est coupé. Vous ne pouvez le faire que dans les champs de formulaire mais afin de s'assurer que la saisie de l'utilisateur est coupé. Mais cela ne protège pas le modèle lui-même. Si vous voulez continuer à le faire, vous pouvez utiliser l'une des méthodes ci-dessus.

Pour plus d'informations, visitez https://docs.djangoproject.com/en/1.9/ref/forms/fields/#charfield

Si vous n'êtes toujours pas sur Django de 1,9+ la honte sur vous (et moi) et déposez le dans votre formulaire. Ceci est similaire à @jeremy-lewis, la réponse mais j'ai eu plusieurs problèmes avec son.

def clean_text_fields(self):
    # TODO: Django 1.9, use on the model strip=True
    # https://docs.djangoproject.com/en/1.9/ref/forms/fields/#charfield
    from django.forms.fields import CharField
    cd = self.cleaned_data
    for field_name, field in self.fields.items():
        if isinstance(field, CharField):
            cd[field_name] = cd[field_name].strip()
            if self.fields[field_name].required and not cd[field_name]:
                self.add_error(field_name, "This is a required field.")

def clean(self):
    self.clean_text_fields()

Vous devez vous connecter pour publier un commentaire.