django admin: separate read-only view and change view

Question

I'd like to use the django admin to produce a read-only view of an object which contains an "Edit" button which switches you to the usual change view of the same object.

I know how to use the readonly attributes to produces a read-only view, but I don't know how to produce two views, one read-only and one that allows changes.

I'd like to reuse as much of the admin interface for this as possible, rather than writing a view from scratch.

Note that this question isn't about permissions: all users will have permission to change the objects. It's just that I would prefer that they not use the change_view unless they do intend to make changes, reducing the risk of accidental changes or simultaneous changes.

Dan Christensen · Accepted Answer · 2011-07-14T16:42:04.583

Here's an answer that literally does what I asked with only a few lines of code and just a couple of template changes:

class MyModelAdmin(admin.ModelAdmin):
    fieldsets = [...]

    def get_readonly_fields(self, request, obj=None):
        if 'edit' not in request.GET:
            return <list all fields here>
        else:
            return self.readonly_fields

Now the usual URL for the change_form will produce a read only change_form, but if you append "?edit=1" to the URL, you will be able to edit.

The change_form template can also be customized depending on whether "?edit=1" is in the URL. To do this, put 'django.core.context_processors.request' in TEMPLATE_CONTEXT_PROCESSORS in settings.py, and then use request.GET.edit in the template.

For example, to add an "Edit" button when not in edit mode, insert

  {% if not request.GET.edit %}                                                 
  <li><a href="?edit=1">Edit</a></li>                                           
  {% endif %}

just after <ul class="object-tools"> in change_form.html.

As another example, changing change_form.html to contain

{% if save_on_top and request.GET.edit %}{% submit_row %}{% endif %}

will mean that the submit row will only be shown in edit mode. One can also hide the Delete buttons on inlines, etc, using this method.

For reference, here is what I put in settings.py:

TEMPLATE_CONTEXT_PROCESSORS = (                                                 
    'django.contrib.auth.context_processors.auth',                              
    'django.core.context_processors.debug',                                     
    'django.core.context_processors.i18n',                                      
    'django.core.context_processors.media',                                     
    'django.contrib.messages.context_processors.messages',                      
    # Above here are the defaults.                                              
    'django.core.context_processors.request',                                   
)

score 1 · Answer 2 · edited May 23 '17 at 11:54

1

I'd suggest to reconsider using custom views. With the help of generic DetailView, you'll need to write literally two lines of code. The template won't require much work either. You just extend standard change_form.html template, overriding field_sets block.

I know how to use the readonly attributes to produces a read-only view, but I don't know how to produce two views, one read-only and one that allows changes.

You actually can register one model in the admin twice[1], using proxy models. (There're some inconsistencies with permissions for proxy models, but it may not be a problem in your case.)

It seems to be possible to register multiple admin sites[2], too.

I'd like to reuse as much of the admin interface for this as possible, rather than writing a view from scratch.

Interface reuse as such has little to do with views, being mostly template- and style-related thing. View, however, should provide the template context necessary for interface reuse, as you correctly pointed out.

If you decide to go with multiple views per one ModelAdmin, then it might be useful for you to check how django-reversion project implements its admin integration: reversion/admin.py.

References

edited May 23 '17 at 11:54

Community

1
1

answered Jul 13 '11 at 15:14

Anton Strogonoff

32,294
8
53
61

Django admin already knows how to render the content quite nicely, with labels, help_text, hide/show, etc. If I write my own template, won't I have to duplicate all of that functionality? And I don't see how I can easily extend change_form.html, since it tries to access variables that won't exist in a generic view. – Dan Christensen Jul 13 '11 at 19:23
You're correct, view also will need to provide all necessary context, which could be a bit of work. Anyway, seems like there's a better method; I've updated the answer. – Anton Strogonoff Jul 14 '11 at 04:13
Thanks, this looks like a good way to accomplish what I wanted. I'll upvote as soon as I have enough rep. I also posted a different method that is easy, and will post a third method soon. – Dan Christensen Jul 14 '11 at 14:22
Your method is interesting, didn't know that read-only fields could be overridden depending on request. However, I'd argue that using two `ModelAdmin`s for the model is more appropriate here. It's more straightforward, and allows to easily implement further customizations that are common in such cases (like displaying a subset of fields or inlines in either view). – Anton Strogonoff Jul 14 '11 at 14:48

score 0 · Answer 3 · answered Feb 23 '14 at 18:19

0

The below code is implementation of read-only admin using proxy models.

Models.py

//real model

class CompetitionEntry(models.Model):
    pass

//Proxy model

class ReviewEntry(CompetitionEntry):
    class Meta:
        proxy = True
    def save(self, *args, **kwargs):
        pass

admin.py

//editable admin

class CompetitionEntryAdmin(admin.ModelAdmin):
     pass
admin.site.register(CompetitionEntry, CompetitionEntryAdmin)

// read-only admin (assign only "change" permission for this)

class ReviewEntryAdmin(admin.ModelAdmin):
    pass
admin.site.register(ReviewEntry, ReviewEntryAdmin)

answered Feb 23 '14 at 18:19

Ryu_hayabusa

3,666
2
29
32

It looks like this will present a view which *looks* like it is editable, but will silently throw away any changes when the user saves the page. – Dan Christensen Feb 26 '14 at 21:56
Yes it does. But you can use modeladmin.save_model() method to throw a warning message. – Ryu_hayabusa Feb 27 '14 at 07:42

score 0 · Answer 4 · answered Jul 13 '11 at 15:11

0

You will need to change template django admin uses for model form. Make it readonly and add a button to original template linked to another url.

Note:

I highly discourage this approach, you will definitely not prevent simultaneous changes. This should be solved with locking.

Also, I recommend using django-reversion for keeping history of objects and eliminating "accidental changes" risk.

answered Jul 13 '11 at 15:11

iElectric

5,633
1
29
31

Can you give a bit more detail about how to do this? (Regarding your other comments: I don't think you can argue that having a read-only view of an object is a bad idea, no matter how else things are designed. My only goal in this question is to get that readonly view by making use of how the admin interface is already able to nicely render things.) – Dan Christensen Jul 13 '11 at 19:40

score 0 · Answer 5 · answered Jul 13 '11 at 15:32

You could create a custom view and display your object there.

To create a custom view in an admin module, override the get_urls() method :

class MyAdmin(admin.ModelAdmin):
    …
    def get_urls(self):
        urls = super(MyAdmin, self).get_urls()
        my_urls = patterns('',
            url(r'^custom_view/(?P<my_id>\d+)/$', self.admin_site.admin_view(self.custom_viem), name='custom_view')
        )
        return my_urls + urls

    def custom_view(self, request, my_id):
        """Define your view function as usual in views.py

        Link to this view using reverse('admin:custom_view')

        """
        from myapp import views
        return views.custom_view(request, my_id, self)

In views.py :

def custom_view(request, object_id, model_admin):
    admin_site = model_admin.admin_site
    opts = model_admin.model._meta
    my_object = get_object_or_404(MyObject, pk=object_id)

    # do stuff

    context = {
        'admin_site': admin_site.name,
        'opts': opts,
        'title': _('My custom view'),
        'root_path': '%s' % admin_site.root_path,
        'app_label': opts.app_label,
        'my_object': my_object,
    }

    return render_to_response('my_template.html', context,
            context_instance=RequestContext(request))

In your template, use {% extends "admin/base_site.html" %} to keep the admin look and feel.

How is this different from just using a generic view, which only requires a couple of lines of code (in addition to the template)? — Dan Christensen, Jul 13 '11 at 19:42
If you can achieve the same result with a generic view, this should be the way to go. — Thibault J, Jul 18 '11 at 11:09

django admin: separate read-only view and change view

5 Answers5

References

Linked