Readonly modele w interfejsie admina Django?

Administrator służy do edycji, a nie tylko do przeglądania (nie znajdziesz uprawnień "widoku"). Aby osiągnąć to, co chcesz, musisz zabronić dodawania, usuwania i uczynić wszystkie pola readonly:

class MyAdmin(ModelAdmin):

    def has_add_permission(self, request, obj=None):
        return False

    def has_delete_permission(self, request, obj=None):
        return False

(jeśli zabronisz zmiany, nie zobaczysz nawet obiektów)

Dla jakiegoś nieprzetestowanego kodu, który próbuje zautomatyzować ustawianie wszystkich pól tylko do odczytu zobacz moją odpowiedź na cały model jako Tylko do odczytu

EDIT: również niesprawdzony, ale po prostu spojrzałem na mój LogEntryAdmin i to has

readonly_fields = MyModel._meta.get_all_field_names()

EDIT: QuerySet.delete () może nadal masowo usuwać obiekty. Aby to obejść, podaj swój własny menedżer "obiektów" i odpowiadającą mu podklasę QuerySet, która nie jest usuwana - zobacz nadpisywanie QuerySet.delete () in Django

Oto dwie klasy, których używam do tworzenia modelu i / lub jest tylko do odczytu w liniach.

Dla modela admina:

from django.contrib import admin

class ReadOnlyAdmin(admin.ModelAdmin):
    readonly_fields = []

    def get_readonly_fields(self, request, obj=None):
        return list(self.readonly_fields) + \
               [field.name for field in obj._meta.fields] + \
               [field.name for field in obj._meta.many_to_many]


    def has_add_permission(self, request):
        return False

    def has_delete_permission(self, request, obj=None):
        return False

class MyModelAdmin(ReadOnlyAdmin):
    pass

Dla linii:

class ReadOnlyTabularInline(admin.TabularInline):
    extra = 0
    can_delete = False
    editable_fields = []
    readonly_fields = []
    exclude = []

    def get_readonly_fields(self, request, obj=None):
        return list(self.readonly_fields) + \
               [field.name for field in self.model._meta.fields
                if field.name not in self.editable_fields and
                   field.name not in self.exclude]

    def has_add_permission(self, request):
        return False


class MyInline(ReadOnlyTabularInline):
    pass

Jeśli chcesz, aby użytkownik wiedział, że nie może go edytować, brakuje 2 elementów na pierwszym rozwiązaniu. Musisz usunąć akcję Usuń!

class MyAdmin(ModelAdmin)
    def has_add_permission(self, request, obj=None):
        return False
    def has_delete_permission(self, request, obj=None):
        return False

    def get_actions(self, request):
        actions = super(MyAdmin, self).get_actions(request)
        if 'delete_selected' in actions:
            del actions['delete_selected']
        return actions

Po drugie: rozwiązanie readonly działa dobrze na zwykłych modelach. Ale to działa NIE Jeśli masz odziedziczony model z kluczami obcymi. Niestety, nie znam jeszcze rozwiązania. Dobra próba to:

Cały model jako Tylko do odczytu

I finał uwaga, jeśli chcesz myśleć o szerokim rozwiązaniu, musisz wymusić, że każda linia inline musi być również readonly.

W rzeczywistości można spróbować tego prostego rozwiązania:

class ReadOnlyModelAdmin(admin.ModelAdmin):
    actions = None
    list_display_links = None
    # more stuff here

    def has_add_permission(self, request):
        return False

• actions = None: unika wyświetlania rozwijanej listy z "Usuń zaznaczone ..."opcja
• list_display_links = None: unika klikania w kolumny, aby edytować ten obiekt
• has_add_permission() zwracanie False unika tworzenia nowych obiektów dla tego modelu

Jeśli zaakceptowana odpowiedź nie działa dla ciebie, spróbuj tego:

def get_readonly_fields(self, request, obj=None):
    readonly_fields = []
    for field in self.model._meta.fields:
        readonly_fields.append(field.name)

    return readonly_fields

Kompilacja doskonałych odpowiedzi @darklow i @ josir, plus dodanie nieco więcej, aby usunąć przyciski "Zapisz" i "zapisz i kontynuuj" prowadzi do (w składni Pythona 3):

class ReadOnlyAdmin(admin.ModelAdmin):
    """Provides a read-only view of a model in Django admin."""
    readonly_fields = []

    def change_view(self, request, object_id, extra_context=None):
        """ customize add/edit form to remove save / save and continue """
        extra_context = extra_context or {}
        extra_context['show_save_and_continue'] = False
        extra_context['show_save'] = False
        return super().change_view(request, object_id, extra_context=extra_context)

    def get_actions(self, request):
        actions = super().get_actions(request)
        if 'delete_selected' in actions:
            del actions['delete_selected']
        return actions

    def get_readonly_fields(self, request, obj=None):
        return list(self.readonly_fields) + \
           [field.name for field in obj._meta.fields] + \
           [field.name for field in obj._meta.many_to_many]

    def has_add_permission(self, request):
        return False

    def has_delete_permission(self, request, obj=None):
        return False

A potem używasz jak

class MyModelAdmin(ReadOnlyAdmin):
    pass

Próbowałem tego tylko z Django 1.11 / Python 3.

Zaakceptowana odpowiedź powinna działać, ale zachowa to również kolejność wyświetlania pól readonly. Nie musisz również kodować na twardo modelu za pomocą tego rozwiązania.

class ReadonlyAdmin(admin.ModelAdmin):
   def __init__(self, model, admin_site):
      super(ReadonlyAdmin, self).__init__(model, admin_site)
      self.readonly_fields = [field.name for field in filter(lambda f: not f.auto_created, model._meta.fields)]

   def has_delete_permission(self, request, obj=None):
       return False
   def has_add_permission(self, request, obj=None):
       return False

Spotkałem się z tym samym wymogiem, gdy potrzebowałem aby wszystkie pola były tylko odczytywane dla niektórych użytkowników w django admin skończyło się na wykorzystaniu modułu django "django-admin-view-permission" bez włączania własnego kodu. Jeśli potrzebujesz bardziej drobnoziarnistej kontroli, aby jawnie zdefiniować, które pola, musisz rozszerzyć moduł. Możesz sprawdzić wtyczkę w działaniu tutaj

To zostało dodane do Django 2.1, które zostało wydane 8/1/18!

ModelAdmin.has_view_permission() jest podobnie jak istniejące has_delete_permission, has_change_permission i has_add_permission. Możesz o tym przeczytać w dokumentach tutaj

Z informacji o wydaniu:

Pozwala to dać użytkownikom dostęp tylko do odczytu do modeli w panelu administracyjnym. ModelAdmin.has_view_permission() jest nowe. Realizacja jest kompatybilne wstecz, ponieważ nie ma potrzeby przypisywania " widoku" pozwolenie aby umożliwić użytkownikom, którzy mają uprawnienia "Zmień", edytowanie obiektów.

Read-only => views permission

1. pipenv install django-admin-view-permission
2. Dodaj 'admin_view_permission' do INSTALLED_APPS w Ustawieniach. py. w ten sposób: "INSTALLED_APPS = [ "admin_view_permission",
3. python manage.py migrate
4. python manage.py runserver 6666

Ok.baw się dobrze z uprawnieniami "views"

Napisałem klasę generyczną do obsługi ReadOnly view w zależności od uprawnień użytkownika, w tym linii;)

W models.py:

class User(AbstractUser):
    ...
    def is_readonly(self):
        if self.is_superuser:
            return False
        # make readonly all users not in "admins" group
        adminGroup = Group.objects.filter(name="admins")
        if adminGroup in self.groups.all():
            return False
        return True

W admin.py:

# read-only user filter class for ModelAdmin
class ReadOnlyAdmin(admin.ModelAdmin):
    def __init__(self, *args, **kwargs):
        # keep initial readonly_fields defined in subclass
        self._init_readonly_fields = self.readonly_fields
        # keep also inline readonly_fields
        for inline in self.inlines:
            inline._init_readonly_fields = inline.readonly_fields
        super().__init__(*args,**kwargs)
    # customize change_view to disable edition to readonly_users
    def change_view( self, request, object_id, form_url='', extra_context=None ):
        context = extra_context or {}
        # find whether it is readonly or not 
        if request.user.is_readonly():
            # put all fields in readonly_field list
            self.readonly_fields = [ field.name for field in self.model._meta.get_fields() if not field.auto_created ]
            # readonly mode fer all inlines
            for inline in self.inlines:
                inline.readonly_fields = [field.name for field in inline.model._meta.get_fields() if not field.auto_created]
            # remove edition buttons
            self.save_on_top = False
            context['show_save'] = False
            context['show_save_and_continue'] = False
        else:
            # if not readonly user, reset initial readonly_fields
            self.readonly_fields = self._init_readonly_fields
            # same for inlines
            for inline in self.inlines:
                inline.readonly_fields = self._init_readonly_fields
        return super().change_view(
                    request, object_id, form_url, context )
    def save_model(self, request, obj, form, change):
        # disable saving model for readonly users
        # just in case we have a malicious user...
        if request.user.is_readonly():
            # si és usuari readonly no guardem canvis
            return False
        # if not readonly user, save model
        return super().save_model( request, obj, form, change )

Wtedy możemy po prostu dziedziczyć Normalnie nasze klasy w admin.py:

class ContactAdmin(ReadOnlyAdmin):
    list_display = ("name","email","whatever")
    readonly_fields = ("updated","created")
    inlines = ( PhoneInline, ... )