In una forma Django, come posso rendere un campo di sola lettura (o disabilitato) in modo che non possa essere modificato?

In una forma Django, come posso rendere un campo di sola lettura (o disabilitato)?

Quando il modulo viene utilizzato per creare una nuova voce, è necessario abilitare tutti i campi, ma quando il record è in modalità di aggiornamento alcuni campi devono essere di sola lettura.

Ad esempio, quando si crea un nuovo Itemmodello, tutti i campi devono essere modificabili, ma durante l'aggiornamento del record esiste un modo per disabilitare il skucampo in modo che sia visibile, ma non può essere modificato?

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 lezione può ItemFormessere riutilizzata? Quali modifiche sarebbero necessarie nella classe del modello ItemFormo Item? Dovrei scrivere un'altra classe, " ItemUpdateForm", per aggiornare l'elemento?

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

Come sottolineato in questa risposta , Django 1.9 ha aggiunto l' attributo Field.disabled :

L'argomento booleano disabilitato, se impostato su True, disabilita un campo modulo utilizzando l'attributo HTML disabilitato in modo che non sia modificabile dagli utenti. Anche se un utente manomette il valore del campo inviato al server, verrà ignorato a favore del valore dai dati iniziali del modulo.

Con Django 1.8 e precedenti, per disabilitare l'ingresso sul widget e prevenire gli hack POST dannosi è necessario cancellare l'input oltre a impostare l' readonlyattributo nel campo del modulo:

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

In alternativa, sostituisci if instance and instance.pkcon un'altra condizione che indica che stai modificando. È inoltre possibile impostare l'attributo disabledsul campo di input, anziché readonly.

La clean_skufunzione assicurerà che il readonlyvalore non venga sovrascritto da a POST.

Altrimenti, non esiste un campo modulo Django incorporato che renderà un valore mentre rifiuta i dati di input associati. Se questo è ciò che desideri, dovresti invece crearne uno separato ModelFormche escluda i campi non modificabili e stamparli semplicemente all'interno del tuo modello.

Django 1.9 ha aggiunto l'attributo Field.disabled: https://docs.djangoproject.com/en/stable/ref/forms/fields/#disabled

L'argomento booleano disabilitato, se impostato su True, disabilita un campo modulo utilizzando l'attributo HTML disabilitato in modo che non sia modificabile dagli utenti. Anche se un utente manomette il valore del campo inviato al server, verrà ignorato a favore del valore dai dati iniziali del modulo.

L'impostazione readonlysu un widget rende l'input nel browser di sola lettura. L'aggiunta di un clean_skuche restituisce instance.skugarantisce che il valore del campo non cambierà a livello di modulo.

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

In questo modo è possibile utilizzare il modello (salvataggio non modificato) ed evitare di ottenere l'errore richiesto dal campo.

la risposta di Awalker mi ha aiutato molto!

Ho cambiato il suo esempio per lavorare con Django 1.3, usando get_readonly_fields .

Di solito dovresti dichiarare qualcosa del genere in app/admin.py:

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

Mi sono adattato in questo modo:

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

E funziona benissimo. Ora se aggiungi un elemento, il urlcampo è di lettura-scrittura, ma al momento della modifica diventa di sola lettura.

Affinché funzioni in un ForeignKeycampo, è necessario apportare alcune modifiche. Innanzitutto, il SELECT HTMLtag non ha l'attributo readonly. Dobbiamo usare disabled="disabled"invece. Tuttavia, il browser non restituisce i dati del modulo per quel campo. Pertanto, è necessario impostare quel campo in modo che non sia obbligatorio in modo che il campo venga validato correttamente. Abbiamo quindi bisogno di ripristinare il valore su quello che era in precedenza, quindi non è impostato su vuoto.

Quindi per le chiavi esterne dovrai fare qualcosa del tipo:

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)

In questo modo il browser non consentirà all'utente di modificare il campo e sarà sempre POSTlasciato vuoto. Quindi sovrascriviamo il cleanmetodo per impostare il valore del campo in modo che fosse quello originariamente nell'istanza.

Per Django 1.2+, puoi scavalcare il campo in questo modo:

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

Ho creato una classe MixIn che potresti ereditare per poter aggiungere un campo iterable read_only che disabiliterà e proteggerà i campi nella modifica non prima:

(Basato sulle risposte di Daniel e Muhuk)

from django import forms
from django.db.models.manager import Manager

# I used this instead of lambda expression after scope problems
def _get_cleaner(form, field):
    def clean_field():
         value = getattr(form.instance, field, None)
         if issubclass(type(value), Manager):
             value = value.all()
         return value
    return clean_field

class ROFormMixin(forms.BaseForm):
    def __init__(self, *args, **kwargs):
        super(ROFormMixin, self).__init__(*args, **kwargs)
        if hasattr(self, "read_only"):
            if self.instance and self.instance.pk:
                for field in self.read_only:
                    self.fields[field].widget.attrs['readonly'] = "readonly"
                    setattr(self, "clean_" + field, _get_cleaner(self, field))

# Basic usage
class TestForm(AModelForm, ROFormMixin):
    read_only = ('sku', 'an_other_field')

Ho appena creato il widget più semplice possibile per un campo di sola lettura - non vedo davvero perché i moduli non lo abbiano già:

class ReadOnlyWidget(widgets.Widget):
    """Some of these values are read only - just a bit of text..."""
    def render(self, _, value, attrs=None):
        return value

Nella forma:

my_read_only = CharField(widget=ReadOnlyWidget())

Molto semplice - e mi dà solo output. Comodo in un formset con un sacco di valori di sola lettura. Certo, potresti anche essere un po 'più intelligente e fare un div con gli attr in modo da poter aggiungere lezioni ad esso.

Ho riscontrato un problema simile. Sembra che sono stato in grado di risolverlo definendo un metodo "get_readonly_fields" nella mia classe ModelAdmin.

Qualcosa come questo:

# In the admin.py file

class ItemAdmin(admin.ModelAdmin):

    def get_readonly_display(self, request, obj=None):
        if obj:
            return ['sku']
        else:
            return []

La cosa bella è che objsarà Nessuno quando si aggiunge un nuovo Articolo, o sarà l'oggetto in fase di modifica quando si modifica un Articolo esistente.

get_readonly_display è documentato qui: http://docs.djangoproject.com/en/1.2/ref/contrib/admin/#modeladmin-methods

Un'opzione semplice è semplicemente digitare form.instance.fieldNameil modello anziché form.fieldName.

Come lo faccio con Django 1.11:

class ItemForm(ModelForm):
    disabled_fields = ('added_by',)

    class Meta:
        model = Item
        fields = '__all__'

    def __init__(self, *args, **kwargs):
        super(ItemForm, self).__init__(*args, **kwargs)
        for field in self.disabled_fields:
            self.fields[field].disabled = True

Come utile aggiunta al post di Humphrey , ho avuto alcuni problemi con il django-reversion, perché registrava ancora i campi disabilitati come "modificati". Il codice seguente risolve il problema.

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:
            try:
                self.changed_data.remove('sku')
            except ValueError, e:
                pass
            return instance.sku
        else:
            return self.cleaned_data.get('sku', None)

Dato che non posso ancora commentare ( la soluzione di muhuk ), risponderò come risposta separata. Questo è un esempio di codice completo, che ha funzionato per me:

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

Ancora una volta, sto per offrire un'altra soluzione :) Stavo usando il codice di Humphrey , quindi questo si basa su quello.

Tuttavia, ho riscontrato problemi con il campo essendo a ModelChoiceField. Tutto funzionerebbe alla prima richiesta. Tuttavia, se il formset ha tentato di aggiungere un nuovo elemento e non è riuscito a convalidare, qualcosa andava storto con i moduli "esistenti" in cui l' SELECTEDopzione veniva ripristinata al valore predefinito--------- .

Comunque, non sono riuscito a capire come risolverlo. Quindi invece (e penso che questo sia in realtà più pulito nella forma), ho creato i campiHiddenInputField() . Questo significa solo che devi fare un po 'più di lavoro nel modello.

Quindi la soluzione per me era semplificare il modulo:

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'].widget=HiddenInput()

E poi nel modello, dovrai eseguire un ciclo manuale del formset .

Quindi, in questo caso, faresti qualcosa del genere nel modello:

<div>
    {{ form.instance.sku }} <!-- This prints the value -->
    {{ form }} <!-- Prints form normally, and makes the hidden input -->
</div>

Questo ha funzionato un po 'meglio per me e con meno manipolazione della forma.

Stavo riscontrando lo stesso problema, quindi ho creato un Mixin che sembra funzionare per i miei casi d'uso.

class ReadOnlyFieldsMixin(object):
    readonly_fields =()

    def __init__(self, *args, **kwargs):
        super(ReadOnlyFieldsMixin, self).__init__(*args, **kwargs)
        for field in (field for name, field in self.fields.iteritems() if name in self.readonly_fields):
            field.widget.attrs['disabled'] = 'true'
            field.required = False

    def clean(self):
        cleaned_data = super(ReadOnlyFieldsMixin,self).clean()
        for field in self.readonly_fields:
           cleaned_data[field] = getattr(self.instance, field)

        return cleaned_data

Utilizzo, basta definire quali devono essere letti solo:

class MyFormWithReadOnlyFields(ReadOnlyFieldsMixin, MyForm):
    readonly_fields = ('field1', 'field2', 'fieldx')

se hai bisogno di più campi di sola lettura, puoi utilizzare uno dei metodi indicati di seguito

metodo 1

class ItemForm(ModelForm):
    readonly = ('sku',)

    def __init__(self, *arg, **kwrg):
        super(ItemForm, self).__init__(*arg, **kwrg)
        for x in self.readonly:
            self.fields[x].widget.attrs['disabled'] = 'disabled'

    def clean(self):
        data = super(ItemForm, self).clean()
        for x in self.readonly:
            data[x] = getattr(self.instance, x)
        return data

metodo 2

metodo di eredità

class AdvancedModelForm(ModelForm):


    def __init__(self, *arg, **kwrg):
        super(AdvancedModelForm, self).__init__(*arg, **kwrg)
        if hasattr(self, 'readonly'):
            for x in self.readonly:
                self.fields[x].widget.attrs['disabled'] = 'disabled'

    def clean(self):
        data = super(AdvancedModelForm, self).clean()
        if hasattr(self, 'readonly'):
            for x in self.readonly:
                data[x] = getattr(self.instance, x)
        return data


class ItemForm(AdvancedModelForm):
    readonly = ('sku',)

Altri due approcci (simili) con un esempio generalizzato:

1) primo approccio - rimozione del campo nel metodo save (), ad es. (Non testato;)):

def save(self, *args, **kwargs):
    for fname in self.readonly_fields:
        if fname in self.cleaned_data:
            del self.cleaned_data[fname]
    return super(<form-name>, self).save(*args,**kwargs)

2) secondo approccio: reimpostare il campo sul valore iniziale con metodo pulito:

def clean_<fieldname>(self):
    return self.initial[<fieldname>] # or getattr(self.instance, fieldname)

Sulla base del secondo approccio l'ho generalizzato in questo modo:

from functools                 import partial

class <Form-name>(...):

    def __init__(self, ...):
        ...
        super(<Form-name>, self).__init__(*args, **kwargs)
        ...
        for i, (fname, field) in enumerate(self.fields.iteritems()):
            if fname in self.readonly_fields:
                field.widget.attrs['readonly'] = "readonly"
                field.required = False
                # set clean method to reset value back
                clean_method_name = "clean_%s" % fname
                assert clean_method_name not in dir(self)
                setattr(self, clean_method_name, partial(self._clean_for_readonly_field, fname=fname))

    def _clean_for_readonly_field(self, fname):
        """ will reset value to initial - nothing will be changed 
            needs to be added dynamically - partial, see init_fields
        """
        return self.initial[fname] # or getattr(self.instance, fieldname)

Per la versione Admin, penso che questo sia un modo più compatto se hai più di un campo:

def get_readonly_fields(self, request, obj=None):
    skips = ('sku', 'other_field')
    fields = super(ItemAdmin, self).get_readonly_fields(request, obj)

    if not obj:
        return [field for field in fields if not field in skips]
    return fields

Sulla base della risposta di Yamikep , ho trovato una soluzione migliore e molto semplice che gestisce ancheModelMultipleChoiceField campi.

La rimozione di un campo form.cleaned_dataimpedisce di salvare i campi:

class ReadOnlyFieldsMixin(object):
    readonly_fields = ()

    def __init__(self, *args, **kwargs):
        super(ReadOnlyFieldsMixin, self).__init__(*args, **kwargs)
        for field in (field for name, field in self.fields.iteritems() if
                      name in self.readonly_fields):
            field.widget.attrs['disabled'] = 'true'
            field.required = False

    def clean(self):
        for f in self.readonly_fields:
            self.cleaned_data.pop(f, None)
        return super(ReadOnlyFieldsMixin, self).clean()

Uso:

class MyFormWithReadOnlyFields(ReadOnlyFieldsMixin, MyForm):
    readonly_fields = ('field1', 'field2', 'fieldx')

Ecco una versione leggermente più complessa, basata sulla risposta di christophe31 . Non si basa sull'attributo "sola lettura". Questo fa sì che i suoi problemi, come le caselle di selezione ancora modificabili e i datapicker che spuntano ancora, scompaiano.

Al contrario, avvolge il widget dei campi modulo in un widget di sola lettura, rendendo così il modulo ancora valido. Il contenuto del widget originale viene visualizzato all'interno dei <span class="hidden"></span>tag. Se il widget ha un render_readonly()metodo, lo utilizza come testo visibile, altrimenti analizza l'HTML del widget originale e cerca di indovinare la rappresentazione migliore.

import django.forms.widgets as f
import xml.etree.ElementTree as etree
from django.utils.safestring import mark_safe

def make_readonly(form):
    """
    Makes all fields on the form readonly and prevents it from POST hacks.
    """

    def _get_cleaner(_form, field):
        def clean_field():
            return getattr(_form.instance, field, None)
        return clean_field

    for field_name in form.fields.keys():
        form.fields[field_name].widget = ReadOnlyWidget(
            initial_widget=form.fields[field_name].widget)
        setattr(form, "clean_" + field_name, 
                _get_cleaner(form, field_name))

    form.is_readonly = True

class ReadOnlyWidget(f.Select):
    """
    Renders the content of the initial widget in a hidden <span>. If the
    initial widget has a ``render_readonly()`` method it uses that as display
    text, otherwise it tries to guess by parsing the html of the initial widget.
    """

    def __init__(self, initial_widget, *args, **kwargs):
        self.initial_widget = initial_widget
        super(ReadOnlyWidget, self).__init__(*args, **kwargs)

    def render(self, *args, **kwargs):
        def guess_readonly_text(original_content):
            root = etree.fromstring("<span>%s</span>" % original_content)

            for element in root:
                if element.tag == 'input':
                    return element.get('value')

                if element.tag == 'select':
                    for option in element:
                        if option.get('selected'):
                            return option.text

                if element.tag == 'textarea':
                    return element.text

            return "N/A"

        original_content = self.initial_widget.render(*args, **kwargs)
        try:
            readonly_text = self.initial_widget.render_readonly(*args, **kwargs)
        except AttributeError:
            readonly_text = guess_readonly_text(original_content)

        return mark_safe("""<span class="hidden">%s</span>%s""" % (
            original_content, readonly_text))

# Usage example 1.
self.fields['my_field'].widget = ReadOnlyWidget(self.fields['my_field'].widget)

# Usage example 2.
form = MyForm()
make_readonly(form)

È questo il modo più semplice?

Proprio in una vista codice qualcosa del genere:

def resume_edit(request, r_id):
    .....    
    r = Resume.get.object(pk=r_id)
    resume = ResumeModelForm(instance=r)
    .....
    resume.fields['email'].widget.attrs['readonly'] = True 
    .....
    return render(request, 'resumes/resume.html', context)

Funziona benissimo!

Per django 1.9+
È possibile utilizzare l'argomento Fields disabled per disabilitare il campo. ad es. nel seguente frammento di codice dal file forms.py, ho disabilitato il campo employee_code

class EmployeeForm(forms.ModelForm):
    employee_code = forms.CharField(disabled=True)
    class Meta:
        model = Employee
        fields = ('employee_code', 'designation', 'salary')

Riferimento https://docs.djangoproject.com/en/2.0/ref/forms/fields/#disabled

Se stai lavorando con Django ver < 1.9(l' attributo 1.9ha aggiunto Field.disabled) potresti provare ad aggiungere il seguente decoratore al tuo __init__metodo di modulo :

def bound_data_readonly(_, initial):
    return initial


def to_python_readonly(field):
    native_to_python = field.to_python

    def to_python_filed(_):
        return native_to_python(field.initial)

    return to_python_filed


def disable_read_only_fields(init_method):

    def init_wrapper(*args, **kwargs):
        self = args[0]
        init_method(*args, **kwargs)
        for field in self.fields.values():
            if field.widget.attrs.get('readonly', None):
                field.widget.attrs['disabled'] = True
                setattr(field, 'bound_data', bound_data_readonly)
                setattr(field, 'to_python', to_python_readonly(field))

    return init_wrapper


class YourForm(forms.ModelForm):

    @disable_read_only_fields
    def __init__(self, *args, **kwargs):
        ...

L'idea principale è che se il campo è readonlynon è necessario alcun altro valore tranne initial.

PS: non dimenticare di impostare yuor_form_field.widget.attrs['readonly'] = True

Se stai usando l'amministratore di Django, ecco la soluzione più semplice.

class ReadonlyFieldsMixin(object):
    def get_readonly_fields(self, request, obj=None):
        if obj:
            return super(ReadonlyFieldsMixin, self).get_readonly_fields(request, obj)
        else:
            return tuple()

class MyAdmin(ReadonlyFieldsMixin, ModelAdmin):
    readonly_fields = ('sku',)

Penso che la tua migliore opzione sarebbe solo quella di includere l'attributo readonly nel tuo modello reso in <span>o <p>piuttosto che includerlo nel modulo se è di sola lettura.

I moduli servono per raccogliere dati, non visualizzarli. Detto questo, le opzioni per visualizzare in un readonlywidget e cancellare i dati POST sono ottime soluzioni.