Como evito a escalada de permissão no Django Admin ao conceder permissão de "mudança do usuário"?

Question

Eu tenho um site django com uma grande base de clientes. Gostaria de dar ao nosso departamento de atendimento ao cliente a capacidade de alterar contas de usuário normais, fazendo coisas como alterar senhas, endereços de e-mail etc. No entanto, se eu conceder a alguém o embutido auth | user | Can change user permissão, eles ganham a capacidade de definir o is_superuser Bandeira em qualquer conta, incluindo a sua. (!!!)

Qual é a melhor maneira de remover essa opção para a equipe que não é superusor? Tenho certeza que envolve subclasse django.contrib.auth.forms.UserChangeForm e conectá-lo ao meu Já UserAdmin objeto ... de alguma forma. Mas não consigo encontrar nenhuma documentação sobre como fazer isso, e ainda não entendo bem os internos.

Answer 1

Eles ganham a capacidade de definir a bandeira IS_SUPERUSER em qualquer conta, incluindo a sua. (!!!)

Não apenas isso, eles também ganham a capacidade de dar a si mesmos alguma permissões uma a um, o mesmo efeito ...

Tenho certeza de que envolve a subclassificação django.contrib.auth.forms.userChangeForm

Bem, não necessariamente. O formulário que você vê na página de mudança do administrador de Django é criado dinamicamente pelo aplicativo de administrador e com base em UserChangeForm, mas esta classe mal adiciona validação de regex ao username campo.

e conectá-lo ao meu objeto de usuário já personalizado ...

Um costume UserAdmin é o caminho a seguir aqui. Basicamente, você quer mudar o fieldsets propriedade para algo assim:

class MyUserAdmin(UserAdmin):
    fieldsets = (
        (None, {'fields': ('username', 'password')}),
        (_('Personal info'), {'fields': ('first_name', 'last_name', 'email')}),
        # Removing the permission part
        # (_('Permissions'), {'fields': ('is_staff', 'is_active', 'is_superuser', 'user_permissions')}),
        (_('Important dates'), {'fields': ('last_login', 'date_joined')}),
        # Keeping the group parts? Ok, but they shouldn't be able to define
        # their own groups, up to you...
        (_('Groups'), {'fields': ('groups',)}),
    )

Mas o problema aqui é que essa restrição se aplicará a todos os usuários. Se não é isso que você deseja, você pode, por exemplo, substituir change_view Para se comportar de maneira diferente, dependendo da permissão dos usuários. Fragmento de código :

class MyUserAdmin(UserAdmin):
    staff_fieldsets = (
        (None, {'fields': ('username', 'password')}),
        (_('Personal info'), {'fields': ('first_name', 'last_name', 'email')}),
        # No permissions
        (_('Important dates'), {'fields': ('last_login', 'date_joined')}),
        (_('Groups'), {'fields': ('groups',)}),
    )

    def change_view(self, request, *args, **kwargs):
        # for non-superuser
        if not request.user.is_superuser:
            try:
                self.fieldsets = self.staff_fieldsets
                response = super(MyUserAdmin, self).change_view(request, *args, **kwargs)
            finally:
                # Reset fieldsets to its original value
                self.fieldsets = UserAdmin.fieldsets
            return response
        else:
            return super(MyUserAdmin, self).change_view(request, *args, **kwargs)

Answer 2

A parte abaixo da resposta aceita tem uma condição de corrida em que, se dois usuários da equipe tentarem acessar o formulário de administração ao mesmo tempo, um deles poderá obter o formulário do superusuário.

try:
    self.readonly_fields = self.staff_self_readonly_fields
    response = super(MyUserAdmin, self).change_view(request, object_id, form_url, extra_context, *args, **kwargs)
finally:
    # Reset fieldsets to its original value
    self.fieldsets = UserAdmin.fieldsets

Para evitar essa condição de corrida (e na minha opinião, melhore a qualidade geral da solução), podemos substituir o get_fieldsets() e get_readonly_fields() Métodos diretamente:

class UserAdmin(BaseUserAdmin):
    staff_fieldsets = (
        (None, {'fields': ('username')}),
        ('Personal info', {'fields': ('first_name', 'last_name', 'email')}),
        # No permissions
        ('Important dates', {'fields': ('last_login', 'date_joined')}),
    )
    staff_readonly_fields = ('username', 'first_name', 'last_name', 'email', 'last_login', 'date_joined')

    def get_fieldsets(self, request, obj=None):
        if not request.user.is_superuser:
            return self.staff_fieldsets
        else:
            return super(UserAdmin, self).get_fieldsets(request, obj)

    def get_readonly_fields(self, request, obj=None):
        if not request.user.is_superuser:
            return self.staff_readonly_fields
        else:
            return super(UserAdmin, self).get_readonly_fields(request, obj)

Answer 3

Ótimo obrigado a Clément. O que eu criei ao fazer o mesmo para o meu site é que eu precisava adicionar a todos os campos readnalmente para os usuários que você além de si mesmo. Então, baseando -se na resposta de Clément I Addeed Readenly Fields e senha se escondendo ao visualizar não

class MyUserAdmin(UserAdmin):
    model = User
    staff_self_fieldsets = (
        (None, {'fields': ('username', 'password')}),
        (_('Personal info'), {'fields': ('first_name', 'last_name', 'email')}),
        # No permissions
        (_('Important dates'), {'fields': ('last_login', 'date_joined')}),
    )

    staff_other_fieldsets = (
        (None, {'fields': ('username', )}),
        (_('Personal info'), {'fields': ('first_name', 'last_name', 'email')}),
        # No permissions
        (_('Important dates'), {'fields': ('last_login', 'date_joined')}),
    )

    staff_self_readonly_fields = ('last_login', 'date_joined')

    def change_view(self, request, object_id, form_url='', extra_context=None, *args, **kwargs):
        # for non-superuser
        if not request.user.is_superuser:
            try:
                if int(object_id) != request.user.id:
                    self.readonly_fields = User._meta.get_all_field_names()
                    self.fieldsets = self.staff_other_fieldsets
                else:
                    self.readonly_fields = self.staff_self_readonly_fields
                    self.fieldsets = self.staff_self_fieldsets

                response = super(MyUserAdmin, self).change_view(request, object_id, form_url, extra_context, *args, **kwargs)
            except:
                logger.error('Admin change view error. Returned all readonly fields')

                self.fieldsets = self.staff_other_fieldsets
                self.readonly_fields = ('first_name', 'last_name', 'email', 'username', 'password', 'last_login', 'date_joined')
                response = super(MyUserAdmin, self).change_view(request, object_id, form_url, extra_context, *args, **kwargs)
            finally:
                # Reset fieldsets to its original value
                self.fieldsets = UserAdmin.fieldsets
                self.readonly_fields = UserAdmin.readonly_fields
            return response
        else:
            return super(MyUserAdmin, self).change_view(request, object_id, form_url, extra_context, *args, **kwargs)

Answer 4

Código completo para Django 1.1 (limitado às informações básicas do usuário para a equipe (não superusores))

from django.contrib.auth.models import User
from django.utils.translation import ugettext_lazy as _


class MyUserAdmin(UserAdmin):
   my_fieldsets = (
       (None, {'fields': ('username', 'password')}),
       (_('Personal info'), {'fields': ('first_name', 'last_name', 'email')}),
   )

   def change_view(self, request, object_id, extra_context=None):
       # for non-superuser
       print 'test'
       if not request.user.is_superuser:
           self.fieldsets = self.my_fieldsets
           response = UserAdmin.change_view(self, request, object_id,
extra_context=None)
           return response
       else:
           return UserAdmin.change_view(self, request, object_id,
extra_context=None)


admin.site.unregister(User)
admin.site.register(User, MyUserAdmin)

Answer 5

Essa abordagem foi montada em várias dicas úteis na web. Nesse caso, estamos modificando o usuário do UserAdmin para que, para a equipe que não é superuser com a permissão de adição/alteração do usuário, as únicas permissões e grupos que eles possam conceder a outro usuário são os que o membro da equipe já possui.

(Para Django 1.11)

from django.contrib.auth.admin import UserAdmin, User
from django.contrib import admin

class RestrictedUserAdmin(UserAdmin):
    model = User

    def formfield_for_dbfield(self, db_field, **kwargs):
        field = super(RestrictedUserAdmin, self).formfield_for_dbfield(db_field, **kwargs)
        user = kwargs['request'].user
        if not user.is_superuser:
            if db_field.name == 'groups':
                field.queryset = field.queryset.filter(id__in=[i.id for i in user.groups.all()])
            if db_field.name == 'user_permissions':
                field.queryset = field.queryset.filter(id__in=[i.id for i in user.user_permissions.all()])
            if db_field.name == 'is_superuser':
                field.widget.attrs['disabled'] = True
        return field

admin.site.unregister(User)
admin.site.register(User, RestrictedUserAdmin)

Da mesma forma, isso deve ser feito para o GroupAdmin se um usuário tiver permissão para alterar grupos.