wbcore 2.2.1__py2.py3-none-any.whl

wbcore/contrib/guardian/models/mixins.py

@@ -0,0 +1,138 @@
+from contextlib import suppress
+from datetime import datetime
+
+from celery import shared_task
+from django.contrib.contenttypes.models import ContentType
+from django.db import models, transaction
+from django.db.models.signals import post_save
+from django.dispatch import receiver
+from django.utils.translation import gettext_lazy as _
+from wbcore.contrib.authentication.models.users import User
+from wbcore.contrib.guardian.utils import reload_permissions
+from wbcore.permissions.mixins import PermissionMixin
+from wbcore.utils.itertools import get_inheriting_subclasses
+
+
+class PermissionObjectModelMixin(PermissionMixin):
+    """
+    Permission object Mixin that set the default behavior for permission assignments.
+    Methods can be supercharged in order to customize behavior.
+    """
+
+    id: int
+
+    class PermissionType(models.TextChoices):
+        INTERNAL = "INTERNAL", _("Internal")
+        PUBLIC = "PUBLIC", _("Public")
+        PRIVATE = "PRIVATE", _("Private")
+
+    guardian_shortcut_kwargs = {"accept_global_perms": False}
+
+    permission_type = models.CharField(default=PermissionType.PRIVATE, choices=PermissionType.choices, max_length=8)
+    creator = models.ForeignKey(
+        User,
+        on_delete=models.SET_NULL,
+        blank=True,
+        null=True,
+        related_name="created_%(app_label)s_%(class)s",
+    )
+
+    def save(self, *args, **kwargs):
+        super().save(*args, **kwargs)
+        content_type = ContentType.objects.get_for_model(self)
+        transaction.on_commit(lambda: assign_user_permissions_for_object_as_task.delay(content_type.id, self.id))  # type: ignore
+
+    class Meta:
+        abstract = True
+        default_permissions = ("add", "change", "delete", "view", "administrate")
+
+    def get_permissions_for_user(self, user: User, created: datetime | None = None) -> dict[str, bool]:
+        """
+        Determine the permissions for a given user on this object. This method uses a best guess approach.
+        If this approach is not suitable for your needs, please override this method in your subclass and
+        avoid a call to `super().get_permissions_for_user`.
+
+        This method checks the user's status and permissions to determine what actions
+        they are allowed to perform on the object. The permissions are returned as a
+        dictionary where the keys are permission strings and the values are booleans
+        indicating whether the permission is editable.
+
+        Behavior:
+            - If the user is a superuser, they are granted all permissions (non-editable).
+            - If the user is internal and has admin permissions, they are granted all permissions (non-editable).
+            - For other internal users, permissions are checked individually and added to the
+              result if the user has them (all set as non-editable).
+            - Non-internal users receive no permissions.
+        """
+
+        # Superuser have access regardless, but we do not want to overpolute the permission table
+        if user.is_superuser:
+            return {}
+
+        # If the user is internal and has the admin permission, this user can do anything
+        if user.is_internal and user.has_perm(self.admin_perm_str):
+            return {
+                self.view_perm_str: False,
+                self.change_perm_str: False,
+                self.delete_perm_str: False,
+                self.select_perm_str: False,
+                self.add_perm_str: False,
+            }
+
+        permissions = {}
+        if user.is_internal:
+            if user.has_perm(self.view_perm_str):
+                permissions[self.view_perm_str] = False
+
+            if user.has_perm(self.change_perm_str):
+                permissions[self.change_perm_str] = False
+
+            if user.has_perm(self.delete_perm_str):
+                permissions[self.delete_perm_str] = False
+
+            if user.has_perm(self.select_perm_str):
+                permissions[self.select_perm_str] = False
+
+            if user.has_perm(self.add_perm_str):
+                permissions[self.add_perm_str] = False
+
+        return permissions
+
+    def reload_permissions(self, prune_existing: bool = True, force_pruning: bool = False):
+        reload_permissions(
+            self.__class__.objects, instance=self, prune_existing=prune_existing, force_pruning=force_pruning
+        )
+
+
+@receiver(post_save, sender=User)
+def post_save_user(sender, instance, created, **kwargs):
+    """
+    Triggers the load_permission_objects as a celery task for all connected signals on User save
+    """
+    if created:
+        transaction.on_commit(lambda: assign_object_permissions_for_user_as_task.delay(instance.id))  # type: ignore
+
+
+@shared_task
+def assign_user_permissions_for_object_as_task(
+    content_type_id: int, instance_id: int, prune_existing: bool | None = True
+):
+    """
+    Utility function to create object permission from obj decoupling from the main thread
+    """
+    content_type = ContentType.objects.get(id=content_type_id)
+    if model_class := content_type.model_class():
+        with suppress(model_class.DoesNotExist):
+            instance = model_class.objects.get(id=instance_id)
+            instance.reload_permissions(prune_existing=prune_existing)  # type: ignore
+
+
+@shared_task
+def assign_object_permissions_for_user_as_task(user_id: int):
+    """
+    Utility function to create object permission from user decoupling from the main thread
+    """
+
+    user = User.objects.get(id=user_id)
+    for permission_class in get_inheriting_subclasses(PermissionObjectModelMixin):
+        reload_permissions(permission_class.objects, user=user, prune_existing=True)

wbcore/contrib/guardian/models/models.py

@@ -0,0 +1,29 @@
+from django.db import models
+from guardian.models import GroupObjectPermissionAbstract, UserObjectPermissionAbstract
+
+
+class UserObjectPermission(UserObjectPermissionAbstract):
+    id = models.BigAutoField(editable=False, unique=True, primary_key=True)
+    editable = models.BooleanField(default=True)
+    system = models.BooleanField(default=False)
+
+    class Meta(UserObjectPermissionAbstract.Meta):
+        abstract = False
+        default_related_name = "userobjectpermissions"
+        indexes = [
+            *UserObjectPermissionAbstract.Meta.indexes,
+            models.Index(fields=["content_type", "object_pk", "user"]),
+        ]
+
+
+class GroupObjectPermission(GroupObjectPermissionAbstract):
+    id = models.BigAutoField(editable=False, unique=True, primary_key=True)
+    editable = models.BooleanField(default=True)
+
+    class Meta(GroupObjectPermissionAbstract.Meta):
+        abstract = False
+        default_related_name = "groupobjectpermissions"
+        indexes = [
+            *GroupObjectPermissionAbstract.Meta.indexes,
+            models.Index(fields=["content_type", "object_pk", "group"]),
+        ]

wbcore/contrib/guardian/tests/conftest.py

@@ -0,0 +1 @@
+from wbcore.contrib.authentication.tests.conftest import *  # noqa

wbcore/contrib/guardian/tests/test_model_mixins.py

@@ -0,0 +1,93 @@
+import pytest
+from wbcore.contrib.guardian.models.mixins import PermissionObjectModelMixin
+
+
+@pytest.fixture
+def mocked_permission_object_model_mixin(mocker):
+    def __init__(self):
+        ...
+
+    PermissionObjectModelMixin.__init__ = __init__
+    PermissionObjectModelMixin.objects = mocker.Mock()
+    mocker.patch.object(PermissionObjectModelMixin, "view_perm_str", "view_perm_str")
+    mocker.patch.object(PermissionObjectModelMixin, "change_perm_str", "change_perm_str")
+    mocker.patch.object(PermissionObjectModelMixin, "delete_perm_str", "delete_perm_str")
+    mocker.patch.object(PermissionObjectModelMixin, "select_perm_str", "select_perm_str")
+    mocker.patch.object(PermissionObjectModelMixin, "add_perm_str", "add_perm_str")
+    mocker.patch.object(PermissionObjectModelMixin, "admin_perm_str", "admin_perm_str")
+    return PermissionObjectModelMixin
+
+
+class TestPermissionObjectModelMixin:
+    def test_save_run_assign_permissions(self, mocker, mocked_permission_object_model_mixin):
+        mocker.patch("django.db.models.Model.save")
+        on_commit = mocker.patch("wbcore.contrib.guardian.models.mixins.transaction.on_commit")
+        ContentType = mocker.patch("wbcore.contrib.guardian.models.mixins.ContentType")
+        ContentType.objects.get_for_model.return_value = mocker.Mock()
+
+        mocked_permission_object_model_mixin().save()
+
+        on_commit.assert_called_once()
+
+    def test_reload_permissions(self, mocker, mocked_permission_object_model_mixin):
+        reload_permissions = mocker.patch("wbcore.contrib.guardian.models.mixins.reload_permissions")
+        mocked_permission_object_model_mixin().reload_permissions(prune_existing=True, force_pruning=True)
+        reload_permissions.assert_called_once()
+
+    def test_get_permissions_for_superuser(self, mocker, mocked_permission_object_model_mixin):
+        user = mocker.Mock()
+        user.is_superuser = True
+        permissions = mocked_permission_object_model_mixin().get_permissions_for_user(user)
+        assert permissions == {}
+
+    def test_get_permissions_for_internal_admin_user(self, mocker, mocked_permission_object_model_mixin):
+        user = mocker.Mock()
+        user.is_internal = True
+        user.is_superuser = False
+        mocker.patch.object(user, "has_perm", side_effect=lambda x: x == "admin_perm_str")
+        permissions = mocked_permission_object_model_mixin().get_permissions_for_user(user)
+        assert permissions == {
+            "view_perm_str": False,
+            "change_perm_str": False,
+            "delete_perm_str": False,
+            "select_perm_str": False,
+            "add_perm_str": False,
+        }
+
+    def test_get_permissions_for_external_user(self, mocker, mocked_permission_object_model_mixin):
+        user = mocker.Mock()
+        user.is_internal = False
+        user.is_superuser = False
+        permissions = mocked_permission_object_model_mixin().get_permissions_for_user(user)
+        assert permissions == {}
+
+    @pytest.mark.parametrize(
+        "permission", ["view_perm_str", "change_perm_str", "delete_perm_str", "select_perm_str", "add_perm_str"]
+    )
+    def test_get_permission_for_internal_user_and_single_permission(
+        self, mocker, mocked_permission_object_model_mixin, permission
+    ):
+        user = mocker.Mock()
+        user.is_internal = True
+        user.is_superuser = False
+
+        mocker.patch.object(user, "has_perm", side_effect=lambda x: x == permission)
+
+        permissions = mocked_permission_object_model_mixin().get_permissions_for_user(user)
+        assert permissions == {permission: False}
+
+
+@pytest.mark.django_db
+def test_post_save_user(user_factory, mocker):
+    on_commit = mocker.patch("wbcore.contrib.guardian.models.mixins.transaction.on_commit")
+    user_factory.create()
+
+    on_commit.assert_called_once()
+
+
+@pytest.mark.django_db
+def test_post_save_user_not_called(user_factory, mocker):
+    user_factory.create()
+    on_commit = mocker.patch("wbcore.contrib.guardian.models.mixins.transaction.on_commit")
+
+    on_commit.assert_not_called()

wbcore/contrib/guardian/tests/test_tasks.py

@@ -0,0 +1,77 @@
+import pytest
+from django.contrib.contenttypes.models import ContentType
+from wbcore.contrib.guardian.models.mixins import (
+    assign_object_permissions_for_user_as_task,
+    assign_user_permissions_for_object_as_task,
+)
+
+
+class TestAssignUserPermissionsForObjectAsTask:
+    def test_called(self, mocker):
+        ContentType = mocker.patch("wbcore.contrib.guardian.models.mixins.ContentType")
+        content_type = mocker.Mock()
+        model_class = mocker.Mock()
+        instance = mocker.Mock()
+        model_class.objects.get.return_value = instance
+        content_type.model_class.return_value = model_class
+        ContentType.objects.get.return_value = content_type
+
+        assign_user_permissions_for_object_as_task(1, 1)
+
+        instance.reload_permissions.assert_called_once_with(prune_existing=True)
+
+    def test_called_with_prune_existing(self, mocker):
+        ContentType = mocker.patch("wbcore.contrib.guardian.models.mixins.ContentType")
+        content_type = mocker.Mock()
+        model_class = mocker.Mock()
+        instance = mocker.Mock()
+        model_class.objects.get.return_value = instance
+        content_type.model_class.return_value = model_class
+        ContentType.objects.get.return_value = content_type
+
+        assign_user_permissions_for_object_as_task(1, 1, prune_existing=False)
+
+        instance.reload_permissions.assert_called_once_with(prune_existing=False)
+
+    def test_not_called_without_model_class(self, mocker):
+        ContentType = mocker.patch("wbcore.contrib.guardian.models.mixins.ContentType")
+        content_type = mocker.Mock()
+        model_class = mocker.Mock()
+        instance = mocker.Mock()
+        model_class.objects.get.return_value = instance
+        content_type.model_class.return_value = None
+        ContentType.objects.get.return_value = content_type
+
+        assign_user_permissions_for_object_as_task(1, 1)
+
+        instance.reload_permissions.assert_not_called()
+
+    @pytest.mark.django_db
+    def test_not_called_with_instance(self, user):
+        with pytest.raises(
+            AttributeError
+        ):  # this means it crashed because the method reload_permissions does not exist which is fine
+            assign_user_permissions_for_object_as_task(ContentType.objects.get_for_model(user).id, user.id)
+
+    @pytest.mark.django_db
+    def test_not_called_without_instance(self, user, mocker):
+        user.reload_permissions = mocker.Mock()
+        spy = mocker.spy(user, "reload_permissions")
+        assign_user_permissions_for_object_as_task(ContentType.objects.get_for_model(user).id, user.id + 1)
+        assert spy.call_count == 0
+
+
+class TestAssignObjectPermissionsForUserAsTask:
+    def test_called(self, mocker):
+        User = mocker.patch("wbcore.contrib.guardian.models.mixins.User")
+        user = mocker.Mock()
+
+        User.objects.get.return_value = user
+
+        get_inheriting_subclasses = mocker.patch("wbcore.contrib.guardian.models.mixins.get_inheriting_subclasses")
+        get_inheriting_subclasses.return_value = [User]
+        reload_permissions = mocker.patch("wbcore.contrib.guardian.models.mixins.reload_permissions")
+
+        assign_object_permissions_for_user_as_task(user_id=1)
+
+        reload_permissions.assert_called_once()

wbcore/contrib/guardian/tests/test_utils.py

@@ -0,0 +1,196 @@
+import pytest
+from django.contrib.contenttypes.models import ContentType
+from guardian.shortcuts import UserObjectPermission
+from wbcore.contrib.authentication.models.users import Permission
+from wbcore.contrib.guardian.models.mixins import PermissionObjectModelMixin
+from wbcore.contrib.guardian.utils import (
+    assign_permissions,
+    get_permission_matrix,
+    get_public_user_or_group,
+    prune_permissions,
+    reload_permissions,
+)
+
+
+@pytest.mark.django_db
+class TestAssignPermissionsMap:
+    def test_assign_permissions(self, user):
+        assign_permissions([("view_user", user, user, True)])
+
+        assert user.has_perm("view_user", user)
+        assert not user.has_perm("change_user", user)
+
+    def test_assign_permissions_editable(self, user):
+        assign_permissions([("view_user", user, user, True), ("change_user", user, user, False)])
+
+        assert user.has_perm("view_user", user)
+        assert user.has_perm("change_user", user)
+
+        assert UserObjectPermission.objects.get(
+            user=user,
+            content_type_id=ContentType.objects.get_for_model(user).pk,
+            object_pk=user.pk,
+            permission__codename="view_user",
+        ).editable
+
+        assert not UserObjectPermission.objects.get(
+            user=user,
+            content_type_id=ContentType.objects.get_for_model(user).pk,
+            object_pk=user.pk,
+            permission__codename="change_user",
+        ).editable
+
+    def test_assign_permission_with_non_perm(self, mocker):
+        assign_perm = mocker.patch("wbcore.contrib.guardian.utils.assign_perm")
+        assign_perm.return_value = None
+
+        assign_permissions([("view_user", mocker.Mock(), mocker.Mock(), True)])
+
+        assign_perm.assert_called_once()
+
+
+@pytest.mark.django_db
+class TestGetPublicUserOrGroup:
+    def test_get_public_user_or_group(self, user):
+        public_user = get_public_user_or_group()
+
+        assert public_user.count() == 1
+        public_user = public_user.first()
+        assert public_user
+        assert public_user == user
+        assert public_user.is_active
+
+    def test_get_public_user_or_group_only_internal(self, internal_user):
+        users = get_public_user_or_group(only_internal=True)
+        assert users.count() == 1
+
+    def test_get_public_user_or_group_only_internal_with_external_user(self, user):
+        users = get_public_user_or_group(only_internal=True)
+        assert users.count() == 0
+
+
+@pytest.mark.django_db
+class TestGetPermissionMatrix:
+    def test_get_permission_matrix(self, user, mocker):
+        def get_permission_for_user(self, created=None):
+            return {"view_user": True, "change_user": False}
+
+        queryset = mocker.Mock()
+        instance = mocker.Mock()
+        queryset.__iter__ = lambda _: iter([instance])
+        queryset.all.return_value = iter([instance])
+        instance.get_permissions_for_user = get_permission_for_user
+        instance.permission_type = PermissionObjectModelMixin.PermissionType.PUBLIC
+        instance.PermissionType = PermissionObjectModelMixin.PermissionType
+
+        matrix = get_permission_matrix(queryset, None, None)
+        assert list(matrix) == [("view_user", instance, user, True), ("change_user", instance, user, False)]
+
+    def test_get_permission_matrix_with_instance(self, user, mocker):
+        def get_permission_for_user(self, created=None):
+            return {"view_user": True, "change_user": False}
+
+        queryset = mocker.Mock()
+        queryset.filter.return_value = queryset
+        instance = mocker.Mock()
+        queryset.__iter__ = lambda _: iter([instance])
+        queryset.all.return_value = iter([instance])
+        instance.get_permissions_for_user = get_permission_for_user
+        instance.permission_type = PermissionObjectModelMixin.PermissionType.PUBLIC
+        instance.PermissionType = PermissionObjectModelMixin.PermissionType
+
+        matrix = get_permission_matrix(queryset, None, instance)
+        next(matrix)
+        queryset.filter.assert_called_once_with(id=instance.id)
+
+    def test_get_permission_matrix_private(self, internal_user, mocker):
+        def get_permission_for_user(self, created=None):
+            return {"view_user": True, "change_user": False}
+
+        queryset = mocker.Mock()
+        queryset.filter.return_value = queryset
+        instance = mocker.Mock()
+        queryset.__iter__ = lambda _: iter([instance])
+        queryset.all.return_value = iter([instance])
+        instance.get_permissions_for_user = get_permission_for_user
+        instance.permission_type = PermissionObjectModelMixin.PermissionType.PRIVATE
+        instance.PermissionType = PermissionObjectModelMixin.PermissionType
+
+        matrix = get_permission_matrix(queryset, None, None)
+        assert list(matrix) == [
+            ("view_user", instance, internal_user, True),
+            ("change_user", instance, internal_user, False),
+        ]
+
+
+@pytest.mark.django_db
+class TestPrunePermissions:
+    def test_prune_permissions(self, user):
+        ct = ContentType.objects.get_for_model(user)
+        permission = Permission.objects.filter(content_type=ct).first()
+        UserObjectPermission.objects.create(
+            permission=permission, user=user, content_type=ct, object_pk=user.id, editable=False
+        )
+        assert UserObjectPermission.objects.filter(permission=permission, content_type=ct, object_pk=user.id).exists()
+        prune_permissions(user)
+        assert not UserObjectPermission.objects.filter(
+            permission=permission, content_type=ct, object_pk=user.id
+        ).exists()
+
+    def test_prune_permissions_editable(self, user):
+        ct = ContentType.objects.get_for_model(user)
+        permission = Permission.objects.filter(content_type=ct).first()
+        UserObjectPermission.objects.create(
+            permission=permission, user=user, content_type=ct, object_pk=user.id, editable=True
+        )
+        assert UserObjectPermission.objects.filter(permission=permission, content_type=ct, object_pk=user.id).exists()
+        prune_permissions(user)
+        assert UserObjectPermission.objects.filter(permission=permission, content_type=ct, object_pk=user.id).exists()
+
+    def test_prune_permissions_editable_with_force(self, user):
+        ct = ContentType.objects.get_for_model(user)
+        permission = Permission.objects.filter(content_type=ct).first()
+        UserObjectPermission.objects.create(
+            permission=permission, user=user, content_type=ct, object_pk=user.id, editable=True
+        )
+        assert UserObjectPermission.objects.filter(permission=permission, content_type=ct, object_pk=user.id).exists()
+        prune_permissions(user, True)
+        assert not UserObjectPermission.objects.filter(
+            permission=permission, content_type=ct, object_pk=user.id
+        ).exists()
+
+
+class TestReloadPermissions:
+    def test_reload_permissions(self, mocker):
+        get_permission_matrix = mocker.patch("wbcore.contrib.guardian.utils.get_permission_matrix")
+        assign_permissions = mocker.patch("wbcore.contrib.guardian.utils.assign_permissions")
+
+        queryset = mocker.Mock()
+
+        reload_permissions(queryset)
+
+        get_permission_matrix.assert_called_once()
+        assign_permissions.assert_called_once()
+
+    def test_reload_permissions_with_prune(self, mocker):
+        prune_permissions = mocker.patch("wbcore.contrib.guardian.utils.prune_permissions")
+        mocker.patch("wbcore.contrib.guardian.utils.get_permission_matrix")
+        mocker.patch("wbcore.contrib.guardian.utils.assign_permissions")
+
+        queryset = mocker.Mock()
+
+        reload_permissions(queryset)
+
+        prune_permissions.assert_not_called()
+
+    def test_reload_permissions_with_prune_and_instance(self, mocker):
+        prune_permissions = mocker.patch("wbcore.contrib.guardian.utils.prune_permissions")
+        mocker.patch("wbcore.contrib.guardian.utils.get_permission_matrix")
+        mocker.patch("wbcore.contrib.guardian.utils.assign_permissions")
+
+        queryset = mocker.Mock()
+        instance = mocker.Mock()
+
+        reload_permissions(queryset, instance=instance)
+
+        prune_permissions.assert_called_once()

wbcore/contrib/guardian/tests/test_viewsets.py

@@ -0,0 +1,48 @@
+import pytest
+from django.contrib.contenttypes.models import ContentType
+from django.db.models import Q
+from guardian.shortcuts import assign_perm
+from wbcore.contrib.authentication.models.users import Permission
+from wbcore.contrib.guardian.viewsets import PivotUserObjectPermissionModelViewSet
+
+
+class TestPivotUserObjectPermissionModelViewSet:
+    def test_cached_property_permissions(self, mocker, request):
+        mocked_filter = mocker.patch("wbcore.contrib.guardian.viewsets.viewsets.Permission.objects.filter")
+        view = PivotUserObjectPermissionModelViewSet(request=request, kwargs={"content_type_id": 1})
+        view.permissions
+
+        mocked_filter.assert_called_once_with(
+            Q(content_type=1)
+            & ~Q(codename__icontains="administrate")
+            & ~Q(codename__icontains="import")
+            & ~Q(codename__icontains="export")
+        )
+
+    def test_linked_object(self, mocker, request):
+        mocked_contrib_type = mocker.patch("wbcore.contrib.guardian.viewsets.viewsets.ContentType.objects")
+        mocked_get_object_for_this_type = mocker.Mock()
+        mocked_contrib_type.get.return_value = mocked_get_object_for_this_type
+        view = PivotUserObjectPermissionModelViewSet(request=request, kwargs={"content_type_id": 1, "object_pk": 1})
+        view.linked_object
+
+        mocked_get_object_for_this_type.get_object_for_this_type.assert_called_once()
+
+    @pytest.mark.django_db
+    def test_queryset(self, user, request):
+        assign_perm("view_user", user, user)
+        view = PivotUserObjectPermissionModelViewSet(
+            request=request, kwargs={"content_type_id": ContentType.objects.get_for_model(user), "object_pk": user.id}
+        )
+
+        permissions = view.permissions
+        instance = view.get_queryset().order_by("id").first()
+
+        for permission in permissions:
+            assert permission.codename in instance.keys()
+
+    def test_serializer_class(self, request, mocker):
+        view = PivotUserObjectPermissionModelViewSet(request=request, kwargs={"content_type_id": 1, "object_pk": 1})
+        mocker.patch.object(view, "permissions", [Permission(codename="view_user")])
+        serializer_class = view.get_serializer_class()
+        assert "view_user" in serializer_class.Meta.fields  # type: ignore

wbcore/contrib/guardian/viewsets/__init__.py

@@ -0,0 +1 @@
+from .viewsets import PivotUserObjectPermissionModelViewSet

wbcore/contrib/guardian/viewsets/configs/__init__.py

@@ -0,0 +1,4 @@
+from .buttons import add_object_permission_button
+from .displays import PivotUserObjectPermissionDisplayViewConfig
+from .endpoints import PivotUserObjectPermissionEndpointViewConfig
+from .titles import PivotUserObjectPermissionTitleViewConfig

wbcore/contrib/guardian/viewsets/configs/buttons.py

@@ -0,0 +1,27 @@
+from contextlib import suppress
+
+from django.dispatch import receiver
+from rest_framework.reverse import reverse
+from wbcore.contrib.guardian.models.mixins import PermissionObjectModelMixin
+from wbcore.contrib.icons.icons import WBIcon
+from wbcore.metadata.configs.buttons.buttons import WidgetButton
+from wbcore.signals.instance_buttons import add_extra_button
+
+
+@receiver(add_extra_button)
+def add_object_permission_button(sender, instance, request, view, pk=None, **kwargs):
+    with suppress(AttributeError):
+        if (
+            (
+                request.user.has_perm(f"administrate_{view.queryset.model._meta.model_name}")
+                or request.user.is_superuser
+            )
+            and issubclass(view.queryset.model, PermissionObjectModelMixin)
+            and pk is not None
+        ):
+            endpoint = reverse(
+                "wbcore:guardian:pivoteduserobjectpermission-list",
+                args=[view.get_content_type().id, pk],
+                request=request,
+            )
+            return WidgetButton(endpoint=endpoint, label="Permissions", icon=WBIcon.LOCK.icon)

wbcore/contrib/guardian/viewsets/configs/displays.py

@@ -0,0 +1,43 @@
+from typing import TYPE_CHECKING
+
+from wbcore.metadata.configs import display as dp
+
+if TYPE_CHECKING:
+    from wbcore.contrib.guardian.viewsets import PivotUserObjectPermissionModelViewSet
+
+
+class PivotUserObjectPermissionDisplayViewConfig(dp.DisplayViewConfig):
+    view: "PivotUserObjectPermissionModelViewSet"
+
+    def get_list_display(self) -> dp.ListDisplay:
+        return dp.ListDisplay(
+            fields=[
+                dp.Field(key="userref", label="User", width=250),
+                *[
+                    dp.Field(
+                        key=permission.codename,
+                        label=permission.name,
+                        width=150,
+                        formatting_rules=[
+                            dp.FormattingRule(style={"backgroundColor": "#FF6961"}, condition=("==", False)),
+                            dp.FormattingRule(style={"backgroundColor": "#77DD77"}, condition=("==", True)),
+                        ],
+                    )
+                    for permission in self.view.permissions
+                ],
+            ],
+            formatting=[
+                dp.Formatting(
+                    column="non_editable",
+                    formatting_rules=[dp.FormattingRule(style={"color": "gray"}, condition=("==", True))],
+                )
+            ],
+        )
+
+    def get_instance_display(self) -> dp.Display:
+        gta = [["userref"]]
+
+        for permission in self.view.permissions:
+            gta.append([permission.codename])
+
+        return dp.create_simple_display(grid_template_areas=gta)