Dans un formulaire Django, comment puis-je rendre un champ en lecture seule (ou désactivé) afin qu'il ne puisse pas être modifié ?

Question

Dans un formulaire Django, comment faire pour qu'un champ soit en lecture seule (ou désactivé) ?

Lorsque le formulaire est utilisé pour créer une nouvelle entrée, tous les champs doivent être activés - mais lorsque l'enregistrement est en mode de mise à jour, certains champs doivent être en lecture seule.

Par exemple, lors de la création d'une nouvelle Item tous les champs doivent être modifiables, mais lors de la mise à jour de l'enregistrement, existe-t-il un moyen de désactiver l'option sku pour qu'il soit visible, mais ne puisse pas être modifié ?

class Item(models.Model):
    sku = models.CharField(max_length=50)
    description = models.CharField(max_length=200)
    added_by = models.ForeignKey(User)

class ItemForm(ModelForm):
    class Meta:
        model = Item
        exclude = ('added_by')

def new_item_view(request):
    if request.method == 'POST':
        form = ItemForm(request.POST)
        # Validate and save
    else:
            form = ItemForm()
    # Render the view

La classe Can ItemForm être réutilisé ? Quels changements seraient nécessaires dans le ItemForm o Item classe modèle ? Devrais-je écrire une autre classe, " ItemUpdateForm ", pour la mise à jour de l'article ?

def update_item_view(request):
    if request.method == 'POST':
        form = ItemUpdateForm(request.POST)
        # Validate and save
    else:
        form = ItemUpdateForm()

Answer 1

Comme indiqué dans cette réponse Django 1.9 a ajouté la fonction Champ.désactivé attribut :

L'argument booléen disabled, lorsqu'il a la valeur True, désactive un champ de formulaire à l'aide de l'attribut HTML disabled afin qu'il ne soit pas modifiable par les utilisateurs. Même si un utilisateur modifie la valeur du champ soumise au serveur, celle-ci sera ignorée au profit de la valeur des données initiales du formulaire.

Avec Django 1.8 et les versions antérieures, pour désactiver l'entrée sur le widget et empêcher les piratages POST malveillants, vous devez scruter l'entrée en plus de définir la propriété readonly sur le champ du formulaire :

class ItemForm(ModelForm):
    def __init__(self, *args, **kwargs):
        super(ItemForm, self).__init__(*args, **kwargs)
        instance = getattr(self, 'instance', None)
        if instance and instance.pk:
            self.fields['sku'].widget.attrs['readonly'] = True

    def clean_sku(self):
        instance = getattr(self, 'instance', None)
        if instance and instance.pk:
            return instance.sku
        else:
            return self.cleaned_data['sku']

Ou bien, remplacez if instance and instance.pk avec une autre condition indiquant que vous êtes en train d'éditer. Vous pouvez également définir l'attribut disabled sur le champ de saisie, au lieu de readonly .

El clean_sku permettra de s'assurer que la readonly ne sera pas remplacée par une valeur de type POST .

Sinon, il n'y a pas de champ de formulaire Django intégré qui rendra une valeur tout en rejetant les données d'entrée liées. Si c'est ce que vous souhaitez, vous devriez plutôt créer un champ de formulaire séparé, le ModelForm qui exclut le(s) champ(s) non éditable(s), et les imprimer simplement dans votre modèle.

Answer 2

Réglage de readonly sur un widget ne fait que rendre l'entrée dans le navigateur en lecture seule. L'ajout d'un clean_sku qui renvoie instance.sku garantit que la valeur du champ ne sera pas modifiée au niveau du formulaire.

def clean_sku(self):
    if self.instance: 
        return self.instance.sku
    else: 
        return self.fields['sku']

De cette façon, vous pouvez utiliser les modèles (sauvegarde non modifiée) et éviter d'obtenir l'erreur de champ obligatoire.

Answer 3

réponse de awalker m'a beaucoup aidé !

J'ai modifié son exemple pour qu'il fonctionne avec Django 1.3, en utilisant les éléments suivants get_readonly_fields .

Habituellement, vous devez déclarer quelque chose comme ceci dans app/admin.py :

class ItemAdmin(admin.ModelAdmin):
    ...
    readonly_fields = ('url',)

Je me suis adapté de cette façon :

# In the admin.py file
class ItemAdmin(admin.ModelAdmin):
    ...
    def get_readonly_fields(self, request, obj=None):
        if obj:
            return ['url']
        else:
            return []

Et cela fonctionne bien. Maintenant, si vous ajoutez un élément, le url est en lecture-écriture, mais lorsqu'il est modifié, il devient en lecture seule.

Answer 4

Pour que cela fonctionne pour un ForeignKey champ, quelques changements doivent être effectués. Tout d'abord, le SELECT HTML ne possède pas l'attribut readonly. Nous devons utiliser disabled="disabled" à la place. Cependant, le navigateur ne renvoie pas de données de formulaire pour ce champ. Nous devons donc faire en sorte que ce champ ne soit pas obligatoire pour qu'il soit validé correctement. Nous devons ensuite réinitialiser la valeur du champ pour qu'elle ne soit pas vide.

Ainsi, pour les clés étrangères, vous devrez faire quelque chose comme :

class ItemForm(ModelForm):

    def __init__(self, *args, **kwargs):
        super(ItemForm, self).__init__(*args, **kwargs)
        instance = getattr(self, 'instance', None)
        if instance and instance.id:
            self.fields['sku'].required = False
            self.fields['sku'].widget.attrs['disabled'] = 'disabled'

    def clean_sku(self):
        # As shown in the above answer.
        instance = getattr(self, 'instance', None)
        if instance:
            return instance.sku
        else:
            return self.cleaned_data.get('sku', None)

De cette façon, le navigateur ne laissera pas l'utilisateur modifier le champ, et toujours POST car il a été laissé en blanc. Nous remplaçons ensuite le clean pour définir la valeur du champ comme étant celle qui se trouvait à l'origine dans l'instance.

Answer 5

Pour Django 1.2+, vous pouvez remplacer le champ comme suit :

sku = forms.CharField(widget = forms.TextInput(attrs={'readonly':'readonly'}))