disabled field is not passed through - workaround needed

I have a form with which I want to update a MyModel object. On the model there is a unique_together constraint, fieldA together with fieldB. In the form in the clean method I check for this unique constraint.

For some reasons I have to show fieldA as readonly in the update. Thus fieldA is not passed through. My issue is that if the form does not validate, the form is re-shown, but I have lost the value in fieldA.

I tried to reset the cleaned_data['fieldA'], but it does not work. Any idea what to change?

Forms.py

class MyModelUpdateForm(forms.ModelForm):
    class Meta:
        model = MyModel

    def __init__(self, *args, **kwargs):
        super(MyModelUpdateForm, self).__init__(*args, **kwargs)
        self.fields['fieldA'].widget.attrs['readonly'] = True
        self.fields['fieldA'].widget.attrs['disabled'] = True

    def clean(self):
        cleaned_data = self.cleaned_data
        fieldA= self.instance.fieldA
        fieldB = cleaned_data.get("fieldB")

        if MyModel.objects.filter(fieldA=fieldA, fieldB=fieldB).co开发者_如何学编程unt() > 0:
            #try to reset fieldA, since it is not passed through, since it is disabled
            cleaned_data['fieldA'] = fieldA.pk #does not work
            raise forms.ValidationError('some unique validation error')
        return cleaned_data

Views.py:

myModelobject = get_object_or_404(MyModel.objects, pk=mymodel_id)

    if request.method == 'POST':
        model_form = MyModelUpdateForm(request.POST, instance=myModelobject )

        if model_form .is_valid():
           ....

I had a little fun looking into how forms works and came up with multiple solutions, just for the heck of it.

Since you are disabling the widget and not the field, as far as the form is concerned it's always receiving nothing for fieldA and that will always fail validation.

Trying something in the clean() method won't help for invalid forms because clean() data is for processing.

It looks like the way forms pull data for HTML display is field.data, which is a call to field.widget.value_from_datadict(POST, FILES, field_name) so it will always be looking at your POST data.

So I think you have a few options. Hack request.POST, hack the internal form POST data, or hack value_from_datadict.

Hacking request.POST: straight forward, makes sense.

    myModelobject = get_object_or_404(MyModel.objects, pk=mymodel_id)

        if request.method == 'POST':
            POST = request.POST.copy()
            POST['fieldA'] = myModelobject.fieldA
            model_form = MyModelUpdateForm(POST, instance=myModelobject )

            if model_form .is_valid():
                # ...

Hacking internal dictionary:

def __init__(self, *args, **kwargs):
    super(MyModelUpdateForm, self).__init__(*args, **kwargs)
    self.data.update({ 'fieldA': self.instance.fieldA })

Hacking value_from_datadict: kinda ridiculous, but illustrates what you can learn from digging into the source

def __init__(self, *args, **kwargs):
    super(MyModelUpdateForm, self).__init__(*args, **kwargs)
    self.fields['fieldA'].widget.value_from_datadict = lambda *args: self.instance.first_name

Learned some cool things here : ) Hope it helps.

I used jQuery to solve the problem by removing disabled from all inputs before submitting.

$('#my_form').submit(function(){
    $("#my_form :disabled").removeAttr('disabled');
});

Used answer from another SO answer

You can put it in the form class like this:

class MyForm(forms.Form):

    MY_VALUE = 'SOMETHING'
    myfield = forms.CharField(
        initial=MY_VALUE,
        widget=forms.TextInput(attrs={'disabled': 'disabled'})

    def __init__(self, *args, **kwargs):

        # If the form has been submitted, populate the disabled field
        if 'data' in kwargs:
            data = kwargs['data'].copy()
            self.prefix = kwargs.get('prefix')
            data[self.add_prefix('myfield')] = MY_VALUE
            kwargs['data'] = data

        super(MyForm, self).__init__(*args, **kwargs) 

The way it works, is it tests to see if any data has been passed in to the form constructor. If it has, it copies it (the uncopied data is immutable) and then puts the initial value in before continuing to instantiate the form.

I faced with similar problem and this is how I solved it.

I set field as hidden:

self.fields['fieldA'].widget.attrs['style'] = 'display:none;'

In template I show field value separately:

{{ form.fieldA.label_tag }}
{{ form.fieldA }}
{{ form.fieldA.value }}
{{ form.fieldA.errors }}

In case of fieldA is a select menu:

{{ form.fieldA.label_tag }}
{{ form.fieldA }}
{% for value, title in form.fields.fieldA.choices %}
    {% if value == form.fieldA.value %}
        {{ title }}
    {% endif %}
{% endfor %}
{{ form.fieldA.errors }}

I solved such problem without touching the backend part, all you need is to add specific class to your fieldA in the forms.py with 'visibility:hidden' property.

self.fields['fieldA'].widget.attrs['class'] = 'visibility_hidden_class'

then, in the template your form.fieldA will be hidden but not lost in post request

{{ form.fieldA.label_tag }}
{{ form.fieldA }}
<input type="text" value="{{ form.fieldA.value }}" disabled />

so you will still have your form.fieldA in request form data. And visually your field will be always populated with the form.fieldA.value.

I know this is an old question, but I recently encountered this problem myself. I think the simplest solution is to use 'initial' in the init definition:

def __init__(self, *args, **kwargs):
    super(MyModelUpdateForm, self).__init__(*args, **kwargs)
    self.fields['fieldA'].disabled = True
    self.fields['fieldA'].initial = self.instance.fieldA

This assumes the instance already exists, of course. You may want to add an 'if' clause if necessary.

When you use disabled attribute the data does not go on POST, you can use readonly that hinder the user from changing the field but sends the value on POST.

I had to solve a similar issue. I was using like dynamic formset to generate new rows, so once you select the product it was shown as disabled, but I needed to get the value on the form in the view. Jquery and JavaScript were easier for me, so I generate a pre - send event removing the disabled on the selector that I use in my formsets. I was using the widget select2 for this setup, so it does work with select2 too.

Of course, the send button id = "postForm" and the id of the form id = "contractForm".

$('#postForm').click(function(e) {
            e.preventDefault();
            $('select[id^="id_p_v"][id$="product"]').each(function(){
                // getIdNumber returns the digit value from id_field-n- in formset value
               // p_v was the prefix of formset 
                var id = getIdNumber($(this).attr('id'));
                // I have an empty form for new forms so skip that one actually on send doesn't matter really. (form POST) but anyway skip
                if(id != null){
                    $(this).prop("disabled", false);
                }
            });
            $('#contractForm').submit();
          });

In models.py add blank=True.

Example:

class myModel(models.Model):
      myField = models.CharField(max_length=30, blank=True)