I'm building a DRF API, and I would like to allow staff members (is_staff == True) to access all of the REST endpoints, while still providing custom permission checking per ViewSet. Ideally, this would be a global setting, but I'm not against setting it up per ViewSet.

Here are the things I've tried:

Option 1: Check on every custom permission

from rest_framework import permissions

class SomeModelPermission(permissions.BasePermission):
 def has_permission(self, request, view):
 if request.user.is_staff:
 return True

 # other logic

 def has_object_permission(self, request, view, obj):
 if request.user.is_staff:
 return True

 # other logic

This works, but I'd rather not repeat so much code.

Option 2: Bitwise operators

I tried removing the is_staff logic from the custom permission above, and adding this to the ViewSet:

from rest_framework import permissions, viewsets

class SomeModelViewSet(viewsets.ModelViewSet):
 permission_classes = (permissions.IsAdminUser|SomeModelPermission,)

However, this actually does not enforce permissions as I'd like, because IsAdminUser inherits from BasePermission, which is defined as:

class BasePermission(object):
 def has_permission(self, request, view):
 return True

 def has_object_permission(self, request, view, obj):
 return True

IsAdminUser doesn't define its own has_object_permission, so it will always return True when checking object permissions, resulting in unintended object access.

Any ideas? I was hoping there would be some way I could set a global permissions check that would return True when the user is a staff member, and defer to the custom permissions otherwise. But reading through how permissions are determined, I'm not sure that this is possible.

Bitwise solution:

How about creating your own IsAdminUser which also defines has_object_permission ? You could just inherit from the existing one:

from rest_framework.permissions import IsAdminUser as BaseIsAdminUser

class IsAdminUser(BaseIsAdminUser):
 def has_object_permission(self, request, view, obj):
 # Just reuse the same logic as `has_permission`...
 return self.has_permission(request, view)

Then you can do what you attempted above, with the bitwise operator:

from rest_framework import permissions, viewsets
from your_own_project.permissions import IsAdminUser

class SomeModelViewSet(viewsets.ModelViewSet):
 permission_classes = (IsAdminUser|SomeModelPermission,)

Another solution:

A bit "hacky" in some ways, but you could try to create your own permission types on the fly.

So the end result would look something like:

class SomeModelViewSet(viewsets.ModelViewSet):
 permission_classes = skip_for_staff((SomeModelPermission, SomeOtherPermission, ...))

With the implementation something similar to:

class StaffAllowedMixin:
 def has_permission(self, request, view):
 if request.user.is_staff:
 return True
 return super().has_permission(request, view)

 def has_object_permission(self, request, view, obj):
 if request.user.is_staff:
 return True
 return super().has_object_permission(request, view, obj)


def skip_for_staff(permission_classes):
 # You can probably also use a comprehension here, but for clarity:
 staff_allowed_classes = []
 for permission_class in permissions(
 staff_allowed_classes.append(
 # Create a new type (class) with name StaffAllowed<...>
 type(f"StaffAllowedpermission_class",
 # Inherit from the mixin above, and from the original class
 (StaffAllowedMixin, permission_class),
 # empty dictionary means you don't want to override any attributes
 )
 )
 return tuple(staff_allowed_classes)

Essentially, for each permission class, you create a new class with the extra mixin that takes precedence and checks if the user is staff.
But you do that on the fly, where your permissions are used, instead of having to predefine it for every permission.