В форме Django, как сделать поле только для чтения (или отключено), чтобы его нельзя было редактировать?

Django 1.9 добавил поле.атрибут disabled: https://docs.djangoproject.com/en/1.9/ref/forms/fields/#disabled

отключенный логический аргумент, если установлено значение True, отключает поле формы с помощью отключенного атрибута HTML, чтобы оно не редактировалось пользователями. Даже если пользователь изменяет значение поля, отправленное на сервер, оно будет проигнорировано в пользу значения из исходных данных формы.

настройка только для чтения на виджете делает вход в браузере только для чтения. Добавление clean_sku, который возвращает экземпляр.sku гарантирует, что значение поля не изменится на уровне формы.

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

таким образом, вы можете использовать модель (немодифицированное сохранение) и aviod, получая поле требуемой ошибки.

ответ awalker мне очень помогли!

Я изменил его пример для работы с Django 1.3, используя get_readonly_fields.

обычно вы должны объявить что-то подобное в app/admin.py:

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

я адаптировался таким образом:

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

и он отлично работает. Теперь, если вы добавляете элемент,url поле read-write, но при изменении оно становится доступным только для чтения.

чтобы сделать эту работу для поля ForeignKey, необходимо внести несколько изменений. Во-первых, тег SELECT HTML не имеет атрибута readonly. Вместо этого нам нужно использовать disabled="disabled". Однако, браузер не отправляет данные обратно на поле. Поэтому нам нужно установить, что это поле не требуется, чтобы поле правильно проверялось. Затем нам нужно сбросить значение обратно к тому, что было раньше, чтобы оно не было пустым.

поэтому для внешних ключей вам понадобится сделать что-то вроде:

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)

таким образом, браузер не позволит пользователю изменить поле и всегда будет публиковать, как оно было оставлено пустым. Затем мы переопределяем метод clean, чтобы установить значение поля таким, каким оно было изначально в экземпляре.

для Django 1.2+, вы можете переопределить поле вот так:

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

Я сделал класс MixIn, который вы можете наследовать, чтобы добавить поле read_only iterable, которое отключит и защитит поля на не-Первом редактировании:

(основан на Дэниела и ответы по 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')

Я только что создал самый простой виджет для поля readonly - я действительно не понимаю, почему у форм этого еще нет:

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

в виде:

my_read_only = CharField(widget=ReadOnlyWidget())

очень просто - и получает меня только выход. Удобно в formset с кучей значений только для чтения. Конечно - вы также можете быть немного умнее и дать ему div с attrs, чтобы вы могли добавлять к нему классы.

я столкнулся с аналогичной проблемой. Похоже, я смог решить его, определив метод "get_readonly_fields" в моем классе ModelAdmin.

что-то вроде этого:

# In the admin.py file

class ItemAdmin(admin.ModelAdmin):

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

хорошая вещь, что obj будет None при добавлении нового элемента, или это будет объект, редактируемый при изменении существующего элемента.

get_readonly_display документирован здесь: http://docs.djangoproject.com/en/1.2/ref/contrib/admin/#modeladmin-methods

как полезное дополнение к сообщение Хамфри, у меня были некоторые проблемы с django-reversion, потому что он все еще регистрировал отключенные поля как "измененные". Следующий код устраняет проблему.

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)

As I can't yet comment (muhuk это), Я отвечу как отдельный ответ. Это полный пример кода, который работал для меня:

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

Я собирался в ту же проблему, поэтому я создал миксин, который, кажется, работает для моего случая использования.

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

использовании, просто определите, какие из них должны быть прочитаны только:

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

еще раз, я собираюсь предложить еще одно решение :) я использовал Хамфри код, так что это зависит от этого.

однако у меня возникли проблемы с полем, являющимся ModelChoiceField. Все будет работать по первому требованию. Однако, если formset попытался добавить новый элемент и не удалось проверить, что-то пошло не так с "существующими" формами, где выбранный параметр сбрасывается по умолчанию "---------".

в любом случае, я не мог выяснить, как это исправить. Поэтому вместо этого (и я думаю, что это на самом деле чище в форме), я сделал поля HiddenInputField (). Это просто означает, что вам нужно сделать немного больше работы в шаблоне.

поэтому исправление для меня было упростить форме:

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

и затем в шаблоне вам нужно будет сделать некоторые ручной цикл набора форм.

Итак, в этом случае вы бы сделали что-то подобное в шаблоне:

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

этот сработало немного лучше для меня и с меньшим количеством манипуляций с формой.

еще два (похожих) подхода с одним обобщенным примером:

1) первый подход-удаление Поля в методе save (), например (не проверено ;)):

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) второй подход-сбросить поле до исходного значения в чистом методе:

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

на основе второго подхода я обобщил это так:

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)

один простой вариант-просто ввести form.instance.fieldName в шаблоне вместо form.fieldName.

если нужно несколько полей только для чтения.вы можете использовать любой из методов, приведенных ниже

Способ 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

Способ 2

способ наследования

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',)

Как я это делаю с 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

для версии администратора, я думаю, что это более компактный способ, если у вас есть более одного поля:

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

на основе Yamikep это, Я нашел лучшее и очень простое решение, которое также обрабатывает ModelMultipleChoiceField поля.

удаление Поля из form.cleaned_data предотвращает сохранение полей:

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

использование:

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

вот немного более сложная версия, основанная на christophe31 это!--5-->. Он не полагается на атрибут "readonly". Это делает его проблемы, как выбрать коробки по-прежнему изменчивы и datapickers по-прежнему появляются, уходят.

вместо этого он обертывает виджет полей формы в виджет только для чтения, тем самым делая форму все еще проверяемой. Содержимое исходного виджета отображается внутри <span class="hidden"></span> теги. Если виджет имеет render_readonly() метод он использует это как видимый текст, в противном случае он анализирует HTML исходного виджета и пытается угадать лучшее представление.

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)

Это самый простой способ?

прямо в код что-то вроде этого:

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)

Он работает отлично!

Я решил эту проблему так:

    class UploadFileForm(forms.ModelForm):
     class Meta:
      model = FileStorage
      fields = '__all__'
      widgets = {'patient': forms.HiddenInput()}

in views:

form = UploadFileForm(request.POST, request.FILES, instance=patient, initial={'patient': patient})

Это все.

для django 1.9+
Аргумент Fields disabled можно использовать для отключения поля. например, в следующем фрагменте кода из forms.py файл, я сделал employee_code поле отключено

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

ссылка https://docs.djangoproject.com/en/2.0/ref/forms/fields/#disabled

Если вы используете Django admin, вот самое простое решение.

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',)

Я думаю, что лучшим вариантом было бы просто включить атрибут readonly в ваш шаблон, отображаемый в <span> или <p> вместо того, чтобы включать его в форму, если это только для чтения.

формы предназначены для сбора данных, а не для их отображения. Тем не менее, параметры для отображения в readonly виджет и скраб POST данные являются прекрасными решениями.

если вы работаете с Django ver < 1.9 (между 1.9 добавил Field.disabled атрибут) вы можете попробовать добавить следующий декоратор в свою форму __init__ способ:

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):
        ...

основная идея заключается в том, что если поле readonly вам не нужно никакое другое значение кроме initial.

P. S: Не забудьте установить yuor_form_field.widget.attrs['readonly'] = True