So, using an inheritance hierarchy to encode permissions on one of the inherited methods is going to lead to headaches down the line.  What if you find another commonality among the subclasses that you want to abstract out?  For example, at some point you're probably going to find yourself wanting to do

```python
class BaseSomeOtherTypeOfPermissionView(BaseView):
    @method_decorator(require_some_other_permission)
    def dispatch(self, request, *args, **kwargs):
        return super(BaseSomeOtherTypeOfPermissionView, self).dispatch(request, *args, **kwargs)

class SomeView(BaseAdminProjectSettingsView, BaseSomeOtherTypeOfPermissionView):
    pass
```

But wait, that can't work because there can only be one `dispatch()` method.  I think the way to avoid this is something like

```python
def compose(decorator1, decorator2):
    # not sure if this is exactly right
    return lambda fn: decorator1(decorator2(fn))

class BaseView(View):
   domain_admin_required = False
   some_other_permission_required = False

   def dispatch(self, request, *args, **kwargs):
       decorator = method_decorator(lambda fn: fn)
       if self.domain_admin_required:
           decorator = compose(decorator, method_decorator(domain_admin_required))
       if self.some_other_permission_required:
           decorator = compose(decorator, method_decorator(some_other_permission_required))

       dispatch = decorator(super(BaseView, self).dispatch)
       return dispatch(request, *args, **kwargs)
    
class RequireAdminMixin(object):
    domain_admin_required = True

class RequireSomeOtherPermissionMixin(object):
    some_other_permission_required = True

class SomeView(BaseView, RequireAdminMixin, RequireSomeOtherPermissionMixin):
    pass
```

@kennknowles any thoughts on this?