Ticket #342: readonly-admin.7.diff

django/contrib/admin/helpers.py

@@ -1 @@
-
 from django import forms
 from django.conf import settings
-from django.utils.html import escape
-from django.utils.safestring import mark_safe
-from django.utils.encoding import force_unicode
 from django.contrib.admin.util import flatten_fieldsets
 from django.contrib.contenttypes.models import ContentType
-from django.utils.translation import ugettext_lazy as _
+from django.db import models
+from django.db.models.fields import FieldDoesNotExist
+from django.db.models.fields.related import ManyToManyRel
+from django.forms.util import flatatt
+from django.utils import dateformat
+from django.utils.encoding import force_unicode, smart_unicode
+from django.utils.html import escape
+from django.utils.safestring import mark_safe
+from django.utils.text import capfirst
+from django.utils.translation import get_date_formats, ugettext_lazy as _
+
 
 ACTION_CHECKBOX_NAME = '_selected_action'
 
@@ -16 +22 @@
 checkbox = forms.CheckboxInput({'class': 'action-select'}, lambda value: False)
 
 class AdminForm(object):
-    def __init__(self, form, fieldsets, prepopulated_fields):
+    def __init__(self, form, fieldsets, prepopulated_fields, readonly_fields):
         self.form, self.fieldsets = form, normalize_fieldsets(fieldsets)
         self.prepopulated_fields = [{
             'field': form[field_name],
             'dependencies': [form[f] for f in dependencies]
         } for field_name, dependencies in prepopulated_fields.items()]
+        self.readonly_fields = readonly_fields
 
     def __iter__(self):
         for name, options in self.fieldsets:
-            yield Fieldset(self.form, name, **options)
+            yield Fieldset(self.form, name,
+                readonly_fields=self.readonly_fields, **options)
 
     def first_field(self):
         try:
@@ -49 +57 @@
     media = property(_media)
 
 class Fieldset(object):
-    def __init__(self, form, name=None, fields=(), classes=(), description=None):
+    def __init__(self, form, name=None, readonly_fields=(), fields=(), classes=(),
+        description=None):
         self.form = form
         self.name, self.fields = name, fields
         self.classes = u' '.join(classes)
         self.description = description
+        self.readonly_fields = readonly_fields
 
     def _media(self):
         if 'collapse' in self.classes:
@@ -63 +73 @@
 
     def __iter__(self):
         for field in self.fields:
-            yield Fieldline(self.form, field)
+            yield Fieldline(self.form, field, self.readonly_fields)
 
 class Fieldline(object):
-    def __init__(self, form, field):
+    def __init__(self, form, field, readonly_fields):
         self.form = form # A django.forms.Form instance
         if isinstance(field, basestring):
             self.fields = [field]
         else:
             self.fields = field
+        self.readonly_fields = readonly_fields
 
     def __iter__(self):
         for i, field in enumerate(self.fields):
-            yield AdminField(self.form, field, is_first=(i == 0))
+            if field in self.readonly_fields:
+                yield AdminReadonlyField(self.form, field, is_first=(i == 0))
+            else:
+                yield AdminField(self.form, field, is_first=(i == 0))
 
     def errors(self):
-        return mark_safe(u'\n'.join([self.form[f].errors.as_ul() for f in self.fields]).strip('\n'))
+        return mark_safe(u'\n'.join([self.form[f].errors.as_ul() for f in self.fields if f not in self.readonly_fields]).strip('\n'))
 
 class AdminField(object):
     def __init__(self, form, field, is_first):
@@ -100 +114 @@
         attrs = classes and {'class': u' '.join(classes)} or {}
         return self.field.label_tag(contents=contents, attrs=attrs)
 
+class AdminReadonlyField(object):
+    def __init__(self, form, field, is_first):
+        self.field = field
+        self.form = form
+        self.is_first = is_first
+        self.is_checkbox = False
+        self.is_readonly = True
+    
+    def label_tag(self):
+        attrs = {}
+        if not self.is_first:
+            attrs["class"] = "inline"
+        contents = force_unicode(escape(forms.forms.pretty_name(self.field))) + u":"
+        return mark_safe('<label %(attrs)s>%(contents)s</label>' % {
+            "attrs": flatatt(attrs),
+            "contents": contents,
+        })
+    
+    def contents(self):
+        from django.contrib.admin.templatetags.admin_list import _boolean_icon
+        from django.contrib.admin.views.main import EMPTY_CHANGELIST_VALUE
+        attr = getattr(self.form.instance, self.field)
+        allow_tags = False
+        boolean = False
+        try:
+            f = self.form.instance._meta.get_field_by_name(self.field)[0]
+        except FieldDoesNotExist:
+            value = attr
+            if callable(attr):
+                value = attr()
+            allow_tags = getattr(attr, "allow_tags", False)
+            boolean = getattr(attr, "boolean", False)
+            if boolean:
+                allow_tags = True
+                result_repr = _boolean_icon(value)
+            else:
+                result_repr = smart_unicode(value)
+        else:
+            value = attr
+            if value is None:
+                result_repr = EMPTY_CHANGELIST_VALUE
+            elif isinstance(f.rel, ManyToManyRel):
+                result_repr = ", ".join(map(result_repr, value.all()))
+            elif isinstance(f, models.DateField) or isinstance(f, models.TimeField):
+                date_format, datetime_format, time_format = get_date_formats()
+                if isinstance(f, models.DateTimeField):
+                    result_repr = capfirst(dateformat.format(value, datetime_format))
+                elif isinstance(f, models.TimeField):
+                    result_repr = capfirst(dateformat.time_format(value, time_format))
+                else:
+                    result_repr = capfirst(dateformat.format(value, date_format))
+            elif isinstance(f, models.BooleanField) or isinstance(f, models.NullBooleanField):
+                result_repr = _boolean_icon(value)
+            elif isinstance(f, models.DecimalField):
+                result_repr = ("%%.%sf" % f.decimal_places) % value
+            elif f.flatchoices:
+                result_repr = dict(f.flatchoices).get(value, EMPTY_CHANGELIST_VALUE)
+            else:
+                result_repr = smart_unicode(value)
+        
+        if allow_tags:
+            return mark_safe(result_repr)
+        return escape(result_repr)
+
 class InlineAdminFormSet(object):
     """
     A wrapper around an inline formset for use in the admin system.
     """
-    def __init__(self, inline, formset, fieldsets):
+    def __init__(self, inline, formset, fieldsets, readonly_fields):
         self.opts = inline
         self.formset = formset
         self.fieldsets = fieldsets
+        self.readonly_fields = readonly_fields
 
     def __iter__(self):
         for form, original in zip(self.formset.initial_forms, self.formset.get_queryset()):
-            yield InlineAdminForm(self.formset, form, self.fieldsets, self.opts.prepopulated_fields, original)
+            yield InlineAdminForm(self.formset, form, self.fieldsets, 
+                self.opts.prepopulated_fields, original, self.readonly_fields)
         for form in self.formset.extra_forms:
-            yield InlineAdminForm(self.formset, form, self.fieldsets, self.opts.prepopulated_fields, None)
+            yield InlineAdminForm(self.formset, form, self.fieldsets,
+                self.opts.prepopulated_fields, None, self.readonly_fields)
 
     def fields(self):
         fk = getattr(self.formset, "fk", None)
@@ -133 +214 @@
     """
     A wrapper around an inline form for use in the admin system.
     """
-    def __init__(self, formset, form, fieldsets, prepopulated_fields, original):
+    def __init__(self, formset, form, fieldsets, prepopulated_fields, original,
+        readonly_fields):
         self.formset = formset
         self.original = original
         if original is not None:
             self.original_content_type_id = ContentType.objects.get_for_model(original).pk
         self.show_url = original and hasattr(original, 'get_absolute_url')
-        super(InlineAdminForm, self).__init__(form, fieldsets, prepopulated_fields)
+        super(InlineAdminForm, self).__init__(form, fieldsets, prepopulated_fields,
+            readonly_fields)
 
     def __iter__(self):
         for name, options in self.fieldsets:
-            yield InlineFieldset(self.formset, self.form, name, **options)
+            yield InlineFieldset(self.formset, self.form, name, self.readonly_fields, **options)
 
     def has_auto_field(self):
         if self.form._meta.model._meta.has_auto_field:
@@ -194 +277 @@
         for field in self.fields:
             if fk and fk.name == field:
                 continue
-            yield Fieldline(self.form, field)
+            yield Fieldline(self.form, field, self.readonly_fields)
 
 class AdminErrorList(forms.util.ErrorList):
     """

django/contrib/admin/options.py

@@ -66 +66 @@
     radio_fields = {}
     prepopulated_fields = {}
     formfield_overrides = {}
+    readonly_fields = ()
 
     def __init__(self):
         self.formfield_overrides = dict(FORMFIELD_FOR_DBFIELD_DEFAULTS, **self.formfield_overrides)
@@ -174 +175 @@
             return [(None, {'fields': self.fields})]
         return None
     declared_fieldsets = property(_declared_fieldsets)
+    
+    def get_readonly_fields(self, request, obj=None):
+        return self.readonly_fields
 
 class ModelAdmin(BaseModelAdmin):
     "Encapsulates all admin options and functionality for a given model."
@@ -324 +328 @@
         if self.declared_fieldsets:
             return self.declared_fieldsets
         form = self.get_form(request, obj)
-        return [(None, {'fields': form.base_fields.keys()})]
+        fields = form.base_fields.keys() + list(self.get_readonly_fields(request, obj))
+        return [(None, {'fields': fields})]
 
     def get_form(self, request, obj=None, **kwargs):
         """
@@ -339 +344 @@
             exclude = []
         else:
             exclude = list(self.exclude)
+        exclude.extend(kwargs.get("exclude", []))
+        exclude.extend(self.get_readonly_fields(request, obj))
         # if exclude is an empty list we pass None to be consistant with the
         # default on modelform_factory
+        exclude = exclude or None
         defaults = {
             "form": self.form,
             "fields": fields,
-            "exclude": (exclude + kwargs.get("exclude", [])) or None,
+            "exclude": exclude,
             "formfield_callback": curry(self.formfield_for_dbfield, request=request),
         }
         defaults.update(kwargs)
@@ -764 +772 @@
                 formset = FormSet(instance=self.model(), prefix=prefix)
                 formsets.append(formset)
 
-        adminForm = helpers.AdminForm(form, list(self.get_fieldsets(request)), self.prepopulated_fields)
+        adminForm = helpers.AdminForm(form, list(self.get_fieldsets(request)), 
+            self.prepopulated_fields, self.get_readonly_fields(request)
+        )
         media = self.media + adminForm.media
 
         inline_admin_formsets = []
         for inline, formset in zip(self.inline_instances, formsets):
             fieldsets = list(inline.get_fieldsets(request))
-            inline_admin_formset = helpers.InlineAdminFormSet(inline, formset, fieldsets)
+            readonly = list(inline.get_readonly_fields(request))
+            inline_admin_formset = helpers.InlineAdminFormSet(inline, formset,
+                fieldsets, readonly)
             inline_admin_formsets.append(inline_admin_formset)
             media = media + inline_admin_formset.media
 
@@ -853 +865 @@
                 formset = FormSet(instance=obj, prefix=prefix)
                 formsets.append(formset)
 
-        adminForm = helpers.AdminForm(form, self.get_fieldsets(request, obj), self.prepopulated_fields)
+        adminForm = helpers.AdminForm(form, self.get_fieldsets(request, obj),
+            self.prepopulated_fields, self.get_readonly_fields(request, obj))
         media = self.media + adminForm.media
 
         inline_admin_formsets = []
         for inline, formset in zip(self.inline_instances, formsets):
             fieldsets = list(inline.get_fieldsets(request, obj))
-            inline_admin_formset = helpers.InlineAdminFormSet(inline, formset, fieldsets)
+            readonly = list(inline.get_readonly_fields(request, obj))
+            inline_admin_formset = helpers.InlineAdminFormSet(inline, formset,
+                fieldsets, readonly)
             inline_admin_formsets.append(inline_admin_formset)
             media = media + inline_admin_formset.media
 
@@ -1151 +1166 @@
             exclude = []
         else:
             exclude = list(self.exclude)
+        exclude.extend(kwargs.get("exclude", []))
+        exclude.extend(self.get_readonly_fields(request, obj))
         # if exclude is an empty list we use None, since that's the actual
         # default
+        exclude = exclude or None
         defaults = {
             "form": self.form,
             "formset": self.formset,
             "fk_name": self.fk_name,
             "fields": fields,
-            "exclude": (exclude + kwargs.get("exclude", [])) or None,
+            "exclude": exclude,
             "formfield_callback": curry(self.formfield_for_dbfield, request=request),
             "extra": self.extra,
             "max_num": self.max_num,
@@ -1170 +1188 @@
         if self.declared_fieldsets:
             return self.declared_fieldsets
         form = self.get_formset(request).form
-        return [(None, {'fields': form.base_fields.keys()})]
+        fields = form.base_fields.keys() + list(self.get_readonly_fields(request, obj))
+        return [(None, {'fields': fields})]
 
 class StackedInline(InlineModelAdmin):
     template = 'admin/edit_inline/stacked.html'

django/contrib/admin/templates/admin/includes/fieldset.html

@@ -1 +1 @@
 <fieldset class="module aligned {{ fieldset.classes }}">
-  {% if fieldset.name %}<h2>{{ fieldset.name }}</h2>{% endif %}
-  {% if fieldset.description %}<div class="description">{{ fieldset.description|safe }}</div>{% endif %}
-  {% for line in fieldset %}
-      <div class="form-row{% if line.errors %} errors{% endif %} {% for field in line %}{{ field.field.name }} {% endfor %} ">
-      {{ line.errors }}
-      {% for field in line %}
-      <div{% if not line.fields|length_is:"1" %} class="field-box"{% endif %}>
-          {% if field.is_checkbox %}
-              {{ field.field }}{{ field.label_tag }}
-          {% else %}
-              {{ field.label_tag }}{{ field.field }}
-          {% endif %}
-          {% if field.field.field.help_text %}<p class="help">{{ field.field.field.help_text|safe }}</p>{% endif %}
-      </div>
-      {% endfor %}
-      </div>
-  {% endfor %}
+    {% if fieldset.name %}<h2>{{ fieldset.name }}</h2>{% endif %}
+    {% if fieldset.description %}
+        <div class="description">{{ fieldset.description|safe }}</div>
+    {% endif %}
+    {% for line in fieldset %}
+        <div class="form-row{% if line.errors %} errors{% endif %} {% for field in line %}{{ field.field.name }} {% endfor %} ">
+            {{ line.errors }}
+            {% for field in line %}
+                <div{% if not line.fields|length_is:"1" %} class="field-box"{% endif %}>
+                    {% if field.is_checkbox %}
+                        {{ field.field }}{{ field.label_tag }}
+                    {% else %}
+                        {{ field.label_tag }}
+                        {% if field.is_readonly %}
+                            {{ field.contents }}
+                        {% else %}
+                            {{ field.field }}
+                        {% endif %}
+                    {% endif %}
+                    {% if field.field.field.help_text %}
+                        <p class="help">{{ field.field.field.help_text|safe }}</p>
+                    {% endif %}
+                </div>
+            {% endfor %}
+        </div>
+    {% endfor %}
 </fieldset>

django/contrib/admin/validation.py

@@ -122 +122 @@
             if '__' in field:
                 continue
             get_field(cls, model, opts, 'ordering[%d]' % idx, field)
+    
+    if hasattr(cls, "readonly_fields"):
+        check_isseq(cls, "readonly_fields", cls.readonly_fields)
+        for idx, field in enumerate(cls.readonly_fields):
+            try:
+                field = opts.get_field_by_name(field)[0]
+            except models.FieldDoesNotExist:
+                raise ImproperlyConfigured("'%s.readonly_fields[%d]' refers to a "
+                    "field, '%s', not defined on %s."
+                    % (cls.__name__, idx, field, model.__name__))
+            
 
     # list_select_related = False
     # save_as = False

docs/ref/contrib/admin/index.txt

@@ -540 +540 @@
     class ArticleAdmin(admin.ModelAdmin):
         raw_id_fields = ("newspaper",)
 
+.. attribute:: ModelAdmin.readonly_fields
+
+By default any field Django's admin displays is shown as editable.  Any fields
+in this option (which should be a ``list`` or ``tuple``) will be displayed as
+just showing the data they contain, without the ability to be edited.  Note
+that fields in this option shouldn't be in the ``fields`` or ``exclude``
+options, they can however be in the ``fieldsets`` option to control where they
+appear.
+
 .. attribute:: ModelAdmin.save_as
 
 Set ``save_as`` to enable a "save as" feature on admin change forms.
@@ -744 +753 @@
                 instance.save()
             formset.save_m2m()
 
+.. method:: ModelAdmin.get_readonly_fields(self, request, obj=None)
+
+The ``get_readonly_fields`` method is given the ``HttpRequest`` and the 
+``obj`` being edited (or ``None`` on a add form) and is expected to return a
+``list`` or ``tuple`` of field names that will be displayed as read-only, as 
+described above in the ``ModelAdmin.readonly_fields`` section.  Note that this
+method will be called several times during a given request, therefore if it
+performs and very expensive calculations it may be wise to cache them.
+
 .. method:: ModelAdmin.get_urls(self)
 
 .. versionadded:: 1.1

tests/regressiontests/admin_validation/models.py

@@ -110 +110 @@
 
 >>> validate_inline(TwoAlbumFKAndAnEInline, None, Album)
 
+>>> class SongAdmin(admin.ModelAdmin):
+...     readonly_fields = ("title",)
+
+>>> validate(SongAdmin, Song)
+
+>>> class SongAdmin(admin.ModelAdmin):
+...     readonly_fields = ("title", "nonexistant")
+
+>>> validate(SongAdmin, Song)
+Traceback (most recent call last):
+    ...
+ImproperlyConfigured: 'SongAdmin.readonly_fields[1]' refers to a field, 'nonexistant', not defined on Song.
+
 # Regression test for #12203/#12237 - Fail more gracefully when a M2M field that
 # specifies the 'through' option is included in the 'fields' or the 'fieldsets'
 # ModelAdmin options.

tests/regressiontests/admin_views/models.py

@@ -1 +1 @@
 # -*- coding: utf-8 -*-
+import datetime
 import tempfile
 import os
-from django.core.files.storage import FileSystemStorage
-from django.db import models
+
 from django.contrib import admin
+from django.core.files.storage import FileSystemStorage
 from django.core.mail import EmailMessage
+from django.db import models
+
 
 class Section(models.Model):
     """
@@ -420 +423 @@
 class CollectorAdmin(admin.ModelAdmin):
     inlines = [WidgetInline, DooHickeyInline, GrommetInline, WhatsitInline, FancyDoodadInline, CategoryInline]
 
+class Post(models.Model):
+    title = models.CharField(max_length=100)
+    content = models.TextField()
+    posted = models.DateField(default=datetime.date.today)
+
+class PostAdmin(admin.ModelAdmin):
+    readonly_fields = ('posted',)
+
 admin.site.register(Article, ArticleAdmin)
 admin.site.register(CustomArticle, CustomArticleAdmin)
 admin.site.register(Section, save_as=True, inlines=[ArticleInline])
@@ -443 +454 @@
 admin.site.register(Recommender)
 admin.site.register(Collector, CollectorAdmin)
 admin.site.register(Category, CategoryAdmin)
+admin.site.register(Post, PostAdmin)
 
 # We intentionally register Promo and ChapterXtra1 but not Chapter nor ChapterXtra2.
 # That way we cover all four cases:

tests/regressiontests/admin_views/tests.py

@@ -10 +10 @@
 from django.contrib.admin.sites import LOGIN_FORM_KEY
 from django.contrib.admin.util import quote
 from django.contrib.admin.helpers import ACTION_CHECKBOX_NAME
+from django.utils import dateformat
 from django.utils.cache import get_max_age
 from django.utils.html import escape
+from django.utils.translation import get_date_formats
 
 # local test models
 from models import Article, BarAccount, CustomArticle, EmptyModel, \
     ExternalSubscriber, FooAccount, Gallery, ModelWithStringPrimaryKey, \
     Person, Persona, Picture, Podcast, Section, Subscriber, Vodcast, \
     Language, Collector, Widget, Grommet, DooHickey, FancyDoodad, Whatsit, \
-    Category
+    Category, Post
 
-try:
-    set
-except NameError:
-    from sets import Set as set
 
 class AdminViewBasicTest(TestCase):
     fixtures = ['admin-views-users.xml', 'admin-views-colors.xml', 'admin-views-fabrics.xml']
@@ -1633 +1631 @@
         "Check the never-cache status of the Javascript i18n view"
         response = self.client.get('/test_admin/jsi18n/')
         self.failUnlessEqual(get_max_age(response), None)
+
+
+class ReadonlyTest(TestCase):
+    fixtures = ['admin-views-users.xml']
+
+    def setUp(self):
+        self.client.login(username='super', password='secret')
+
+    def tearDown(self):
+        self.client.logout()
+
+    def test_readonly_get(self):
+        response = self.client.get('/test_admin/admin/admin_views/post/add/')
+        self.assertEqual(response.status_code, 200)
+        self.assertNotContains(response, 'name="posted"')
+        # 3 fields + 2 submit buttons
+        self.assertEqual(response.content.count("input"), 5)
+        self.assertContains(response,
+            dateformat.format(datetime.date.today(), get_date_formats()[0]))
+    
+    def test_readonly_post(self):
+        data = {
+            "title": "Django Got Readonly Fields",
+            "content": "This is an incredible development."
+        }
+        response = self.client.post('/test_admin/admin/admin_views/post/add/', data)
+        self.assertEqual(response.status_code, 302)
+        self.assertEqual(Post.objects.count(), 1)
+        p = Post.objects.get()
+        self.assertEqual(p.posted, datetime.date.today())
+        
+        data["posted"] = "10-8-1990" # some date that's not today
+        response = self.client.post('/test_admin/admin/admin_views/post/add/', data)
+        self.assertEqual(response.status_code, 302)
+        self.assertEqual(Post.objects.count(), 2)
+        p = Post.objects.order_by('-id')[0]
+        self.assertEqual(p.posted, datetime.date.today())