How can I only display ForeignKey in a ModelForm, not make it editable?

Question

I have the following Models and Forms:

#models.py
class NetworkDevice(models.Model):
    user = models.ForeignKey(User)
    device_name = models.CharField(_('device name'), max_length=100)
    ...

#forms.py
class NetworkDevicesForm(ModelForm):
    class Meta:
        model = NetworkDevice
        fields=('user', 'device_name',...)

'...' are some fields I left out, since they are not important for this. I want to create a formset based on my ModelForm:

#views.py
in some view:
    network_device_formset = modelformset_factory(models.NetworkDevice,  
         extra=0, form=NetworkDevicesForm, fields=(
         'user', 'device_name', ...))

And I display it like this in my template:

<form action="{% url 'some:action'  %}" method="post">
{% csrf_token %}
{{ devices_formset.management_form }}
<table>
{% for form in devices_formset %}
    {% if forloop.first %}
    <thead>
        <tr>
            {% for field in form.visible_fields %}
            <th>{{ field.label }}</th>
            {% endfor %}
        </tr>
    </thead>
    {% endif %}
{% endfor %}

    <tbody>
        {% for form in devices_formset %}
        <tr>
            {% for field in form %}
            <td>{{ field }}</td>
            {% endfor %}
        </tr>
        {% endfor %}
    </tbody>
</table>
<input type="submit" value='{% trans "Save" %}'/>
</form>

Now this will display my ForeignKey with an HTML select tag. I don't even want to show all the choices there however. I just want to display the key for the according instance. I can disable the select tag:

class NetworkDevicesForm(ModelForm):
    class Meta:
        model = NetworkDevice
        fields=('user', 'device_name', ...more fields)
        widgets = {'user': widgets.Select(attrs={'readonly': True,
                                                          'disabled': True})}

But then I get errors on the validation of the user field. Guess I could overwrite the validation for this somehow. But still this would display all the options for the foreign key in the generated html. Is there no way I can just display the value in my template without specifying it in the ModelForm, since I don't want to edit it. Some magic like:

    <tbody>
        {% for form in devices_formset %}
        <tr>
            <td>{{ form.user }}</td>
            {% for field in form %}
            <td>{{ field }}</td>
            {% endfor %}
        </tr>
        {% endfor %}
    </tbody>

Except that {{ form.user }} is not working. Can I access that somehow in the template? Hope I was clear about what I want to do and it's possible.

Answer 1

You could try something like this:

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

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

Answer 2

Alright, I think I got it. I changed my ModelForm to this:

class NetworkDevicesForm(ModelForm):

  readonlyUser = CharField(max_length=100 )

  class Meta:
      model = NetworkDevice
      fields=('readonlyUser', 'device_name')        

  def __init__(self, *args, **kwargs):
      super(NetworkDevicesForm, self).__init__(*args, **kwargs)
      if self.instance.user:
          self.initial['readonlyUser'] = self.instance.user.username
          self.fields['readonlyUser'].widget.attrs['readonly'] = True

Had to use readonly here instead of disabled, otherwise the validation does not work, even though I don't use that field. And in the view I create my modelformset with:

network_device_formset = modelformset_factory(models.NetworkDevice, 
     extra=0, form=NetworkDevicesForm, fields=(
     'readonlyUser', 'device_name'))

This seem to do what I want. Didn't touch the template or the model definition.

Answer 3

If you're going to use this often you can create a new baseclass:

class SpanWidget(forms.Widget):
    '''Renders a value wrapped in a <span> tag.

    Requires use of specific form support. (see ReadonlyForm
    or ReadonlyModelForm)
    '''

    def render(self, name, value, attrs=None):
        final_attrs = self.build_attrs(attrs, name=name)
        return mark_safe(u'<span%s >%s</span>' % (
            forms.util.flatatt(final_attrs), self.display_value))

    def value_from_datadict(self, data, files, name):
        return self.original_value


class SpanField(forms.Field):
    '''A field which renders a value wrapped in a <span> tag.

    Requires use of specific form support. (see ReadonlyForm
    or ReadonlyModelForm)
    '''

    def __init__(self, *args, **kwargs):
        kwargs['widget'] = kwargs.get('widget', SpanWidget)
        super(SpanField, self).__init__(*args, **kwargs)
class Readonly(object):
    '''Base class for ReadonlyForm and ReadonlyModelForm which provides
    the meat of the features described in the docstings for those classes.
    '''

    class NewMeta:
        readonly = tuple()

    def __init__(self, *args, **kwargs):
        super(Readonly, self).__init__(*args, **kwargs)
        readonly = self.NewMeta.readonly
        if not readonly:
            return
        for name, field in self.fields.items():
            if name in readonly:
                field.widget = SpanWidget()
            elif not isinstance(field, SpanField):
                continue
            model_field = self.instance._meta.get_field_by_name(name)[0]
            field.widget.original_value = model_field.value_from_object(self.instance)
            field.widget.display_value = unicode(getattr(self.instance, name))


class ReadonlyForm(Readonly, forms.Form):
    '''A form which provides the ability to specify certain fields as
    readonly, meaning that they will display their value as text wrapped
    with a <span> tag. The user is unable to edit them, and they are
    protected from POST data insertion attacks.

    The recommended usage is to place a NewMeta inner class on the
    form, with a readonly attribute which is a list or tuple of fields,
    similar to the fields and exclude attributes on the Meta inner class.

        class MyForm(ReadonlyForm):
            foo = forms.TextField()
            class NewMeta:
                readonly = ('foo',)
    '''
    pass


class ReadonlyModelForm(Readonly, forms.ModelForm):
    '''A ModelForm which provides the ability to specify certain fields as
    readonly, meaning that they will display their value as text wrapped
    with a <span> tag. The user is unable to edit them, and they are
    protected from POST data insertion attacks.

    The recommended usage is to place a NewMeta inner class on the
    form, with a readonly attribute which is a list or tuple of fields,
    similar to the fields and exclude attributes on the Meta inner class.

        class Foo(models.Model):
            bar = models.CharField(max_length=24)

        class MyForm(ReadonlyModelForm):
            class Meta:
                model = Foo
            class NewMeta:
                readonly = ('bar',)
    '''
    pass

This is code I use in production:

class MembershipForm(ReadonlyModelForm):
    class Meta:
        model = Membership
        fields = ('user','board', 'privileged', 'alumni')

    class NewMeta:
        readonly = ('user')
    def email(self):
        return self.instance.user.email

To answer your question:

#forms.py
class NetworkDevicesForm(ReadOnlyModelForm):
    class Meta:
        model = NetworkDevice
        fields=('user', 'device_name',...)
    class NewMeta:
        readonly=('user',)