wbcore 2.2.3__py2.py3-none-any.whl → 2.2.5__py2.py3-none-any.whl

wbcore/contrib/example_app/tests/test_viewsets/test_stadium_viewset.py

@@ -0,0 +1,75 @@
+import pytest
+from django.test import Client, TestCase
+from django.urls import reverse
+from wbcore.contrib.authentication.factories import SuperUserFactory
+from wbcore.contrib.example_app.factories import StadiumFactory
+from wbcore.contrib.example_app.models import Stadium
+from wbcore.contrib.example_app.serializers import StadiumModelSerializer
+from wbcore.contrib.example_app.tests.test_viewsets.test_utils_viewsets import (
+    get_create_view,
+    get_delete_view,
+    get_detail_view,
+    get_partial_view,
+    get_update_view,
+)
+from wbcore.contrib.example_app.viewsets import StadiumModelViewSet
+
+
+@pytest.mark.django_db
+class TestStadiumModelViewSet(TestCase):
+    def setUp(self):
+        self.user = SuperUserFactory()
+        self.client = Client()
+        self.client.force_login(user=self.user)
+        self.list_url = reverse("example_app:stadium-list")
+        self.detail_url_str = "example_app:stadium-detail"
+
+    def test_list_view(self):
+        response = self.client.get(self.list_url)
+        self.assertEqual(response.status_code, 200)
+
+    def test_create_view(self):
+        stadium = StadiumFactory()
+        response = get_create_view(self.client, stadium, self.user, self.list_url, StadiumModelViewSet)
+        self.assertEqual(response.status_code, 201)
+        self.assertTrue(Stadium.objects.filter(name=stadium.name).exists())
+
+    def test_detail_view(self):
+        instance = StadiumFactory()
+        response = get_detail_view(self.client, instance.pk, self.detail_url_str)
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.data["instance"]["name"], instance.name)
+
+    def test_update_view(self):
+        instance = StadiumFactory()
+        instance.name = "Updated Instance"
+        response = get_update_view(self.client, instance, StadiumModelSerializer, self.detail_url_str)
+        instance.refresh_from_db()
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.data["instance"]["name"], instance.name)
+
+    def test_partial_update_view(self):
+        instance = StadiumFactory()
+        response = get_partial_view(self.client, instance.id, {"name": "Updated Instance"}, self.detail_url_str)
+        instance.refresh_from_db()
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.data["instance"]["name"], instance.name)
+
+    def test_delete_view(self):
+        instance = StadiumFactory()
+        response = get_delete_view(self.client, self.detail_url_str, instance.pk)
+        self.assertEqual(response.status_code, 204)
+        self.assertFalse(Stadium.objects.filter(pk=instance.pk).exists())
+
+    def test_ordering_fields(self):
+        first_name, second_name, third_name = "Stadium A", "Stadium B", "Stadium C"
+        StadiumFactory(name=second_name)
+        StadiumFactory(name=first_name)
+        StadiumFactory(name=third_name)
+
+        response = self.client.get(self.list_url)
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.data["count"], Stadium.objects.count())
+        self.assertEqual(response.data["results"][0]["name"], first_name)
+        self.assertEqual(response.data["results"][1]["name"], second_name)
+        self.assertEqual(response.data["results"][2]["name"], third_name)

wbcore/contrib/example_app/tests/test_viewsets/test_team_viewset.py

@@ -0,0 +1,92 @@
+import pytest
+from django.test import Client, TestCase
+from django.urls import reverse
+from wbcore.contrib.authentication.factories import SuperUserFactory
+from wbcore.contrib.example_app.factories import TeamFactory
+from wbcore.contrib.example_app.models import Team
+from wbcore.contrib.example_app.serializers import TeamModelSerializer
+from wbcore.contrib.example_app.tests.test_viewsets.test_utils_viewsets import (  # get_update_view,
+    find_instances_in_response,
+    get_create_view,
+    get_delete_view,
+    get_detail_view,
+    get_partial_view,
+    get_update_view,
+)
+from wbcore.contrib.example_app.viewsets import TeamModelViewSet
+
+
+@pytest.mark.django_db
+class TestTeamModelViewSet(TestCase):
+    def setUp(self):
+        self.user = SuperUserFactory()
+        self.client = Client()
+        self.client.force_login(user=self.user)
+        self.list_url = reverse("example_app:team-list")
+        self.detail_url_str = "example_app:team-detail"
+
+    def test_list_view(self):
+        response = self.client.get(self.list_url)
+        self.assertEqual(response.status_code, 200)
+
+    def test_create_view(self):
+        team = TeamFactory()
+        response = get_create_view(self.client, team, self.user, self.list_url, TeamModelViewSet)
+        self.assertEqual(response.status_code, 201)
+        self.assertTrue(Team.objects.filter(name=team.name).exists())
+
+    def test_detail_view(self):
+        team = TeamFactory()
+        response = get_detail_view(self.client, team.pk, self.detail_url_str)
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.data["instance"]["name"], team.name)
+
+    def test_update_view(self):
+        instance = TeamFactory()
+        instance.name = "Updated Instance"
+        response = get_update_view(self.client, instance, TeamModelSerializer, self.detail_url_str)
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.data["instance"]["name"], instance.name)
+
+    def test_partial_update_view(self):
+        instance = TeamFactory()
+        response = get_partial_view(self.client, instance.id, {"name": "Updated Instance"}, self.detail_url_str)
+        instance.refresh_from_db()
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.data["instance"]["name"], instance.name)
+
+    def test_delete_view(self):
+        team = TeamFactory()
+        response = get_delete_view(self.client, self.detail_url_str, team.pk)
+        self.assertEqual(response.status_code, 204)
+        self.assertFalse(Team.objects.filter(pk=team.pk).exists())
+
+    def test_ordering_fields(self):
+        team_a = TeamFactory(name="BBB", order=1)
+        team_b = TeamFactory(name="AAA", order=0)
+        team_c = TeamFactory(name="CCC", order=2)
+
+        response = self.client.get(self.list_url)
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.data["count"], Team.objects.count())
+        self.assertEqual(response.data["results"][0]["id"], team_b.id)
+        self.assertEqual(response.data["results"][1]["id"], team_a.id)
+        self.assertEqual(response.data["results"][2]["id"], team_c.id)
+
+    def test_team_stadium(self):
+        team_a = TeamFactory()
+        team_b = TeamFactory(home_stadium=team_a.home_stadium)
+        team_c = TeamFactory()
+        expected_number_of_teams = Team.objects.filter(home_stadium=team_a.home_stadium).count()
+        team_stadium_url = reverse("example_app:team-stadium-list", args=[team_a.home_stadium.id])
+        response = self.client.get(team_stadium_url)
+        team_a_found, team_b_found, team_c_found = find_instances_in_response([team_a, team_b, team_c], response)
+        self.assertEqual(
+            response.data["count"],
+            expected_number_of_teams,
+            f"The answer should contain {expected_number_of_teams} teams",
+        )
+        self.assertEqual(response.status_code, 200)
+        self.assertTrue(team_a_found, "Team A was not found in Response")
+        self.assertTrue(team_b_found, "Team B was not found in Response")
+        self.assertFalse(team_c_found, "Team C was found in Response, but should not be found")

wbcore/contrib/example_app/tests/test_viewsets/test_teamresult_viewset.py

@@ -0,0 +1,58 @@
+import pytest
+from django.test import Client, TestCase
+from django.urls import reverse
+from wbcore.contrib.authentication.factories import SuperUserFactory
+from wbcore.contrib.example_app.factories import TeamResultsFactory
+from wbcore.contrib.example_app.serializers import TeamResultsModelSerializer
+from wbcore.contrib.example_app.tests.test_viewsets.test_utils_viewsets import (
+    get_create_view,
+    get_delete_view,
+    get_detail_view,
+    get_partial_view,
+    get_update_view,
+)
+from wbcore.contrib.example_app.viewsets import TeamResultsModelViewSet
+
+
+@pytest.mark.django_db
+class TestTeamResultsModelViewSet(TestCase):
+    def setUp(self):
+        self.user = SuperUserFactory()
+        self.client = Client()
+        self.client.force_login(user=self.user)
+        self.list_url = reverse("example_app:teamresults-list")
+        self.detail_url_str = "example_app:teamresults-detail"
+
+    def test_list_view(self):
+        response = self.client.get(self.list_url)
+        self.assertEqual(response.status_code, 200)
+
+    def test_create_view(self):
+        team_result = TeamResultsFactory()
+        response = get_create_view(self.client, team_result, self.user, self.list_url, TeamResultsModelViewSet)
+        # It is not possible to create an team results, since the get_endpoint_url returns None.
+        self.assertEqual(response.status_code, 405)
+
+    def test_detail_view(self):
+        instance = TeamResultsFactory()
+        response = get_detail_view(self.client, instance.pk, self.detail_url_str)
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.data["instance"]["id"], instance.id)
+
+    def test_update_view(self):
+        instance = TeamResultsFactory()
+        instance.points = 5
+        response = get_update_view(self.client, instance, TeamResultsModelSerializer, self.detail_url_str)
+        # It is not possible to update an team results, since the get_endpoint_url returns None.
+        self.assertEqual(response.status_code, 405)
+
+    def test_partial_update_view(self):
+        instance = TeamResultsFactory()
+        response = get_partial_view(self.client, instance.id, {"points": 5}, self.detail_url_str)
+        self.assertEqual(response.status_code, 405)
+
+    def test_delete_view(self):
+        instance = TeamResultsFactory()
+        response = get_delete_view(self.client, self.detail_url_str, instance.pk)
+        # It is not possible to delete an team results, since the get_endpoint_url returns None.
+        self.assertEqual(response.status_code, 405)

wbcore/contrib/example_app/tests/test_viewsets/test_utils_viewsets.py

@@ -0,0 +1,124 @@
+from django.db.models import Model
+from django.http import HttpResponse
+from django.test import Client
+from django.urls import reverse
+from wbcore.contrib.authentication.models import User
+from wbcore.serializers import Serializer
+from wbcore.test.utils import get_data_from_factory
+from wbcore.viewsets import ModelViewSet
+
+
+def get_create_view(
+    client: Client,
+    instance: Model,
+    superuser: User,
+    url: str,
+    viewset: ModelViewSet,
+) -> HttpResponse:
+    """
+    Create a new instance through a view using the Django REST Framework client.
+
+    Parameters:
+        - client (django.test.Client): The Django test client.
+        - instance (django.db.models.Model): The model instance to be created.
+        - superuser (django.contrib.auth.models.User): The superuser for authentication.
+        - url (str): The URL endpoint for the view.
+        - viewset (wbcore.viewsets.ModelViewSet): The viewset for the model.
+
+    Returns:
+        django.http.HttpResponse: The HTTP response from the view.
+    """
+    instance_data = get_data_from_factory(instance, viewset, delete=True, superuser=superuser)
+    return client.post(url, instance_data)
+
+
+def get_detail_view(client: Client, pk: int, url: str) -> HttpResponse:
+    """
+    Retrieve the details of a model instance through a detail view using the Django REST Framework client.
+
+    Parameters:
+        - client (django.test.Client): The Django test client.
+        - pk (int): The primary key of the model instance to retrieve.
+        - url (str): The base URL endpoint for the detail view.
+
+    Returns:
+        django.http.HttpResponse: The HTTP response from the detail view.
+    """
+    detail_url = reverse(url, args=[pk])
+    return client.get(detail_url)
+
+
+def get_update_view(client: Client, instance: Model, serializer: Serializer, url: str) -> HttpResponse:
+    """
+    Update a model instance through an update view using the Django REST Framework client.
+
+    Parameters:
+        - client (django.test.Client): The Django test client.
+        - instance (django.db.models.Model): The model instance to be updated.
+        - serializer (Serializer): The serializer used to serialize the instance.
+        - url (str): The base URL endpoint for the update view.
+
+    Returns:
+        django.http.HttpResponse: The HTTP response from the update view.
+    """
+    update_url = reverse(url, args=[instance.pk])
+    serialized_data = serializer(instance).data
+    return client.put(update_url, data=serialized_data, content_type="application/json")
+
+
+def get_partial_view(client: Client, instance_id: int, data: dict, url: str) -> HttpResponse:
+    """
+    Facilitates partial updates to a specific instance of a model using the Django REST Framework client.
+
+    Parameters:
+        - client (django.test.Client): The Django test client.
+        - instance_id (int): The unique identifier (primary key) of the instance to be partially updated.
+        - data (dict): A dictionary containing the fields and their respective new values that need to be updated in the instance.
+        - url (str): The base URL endpoint for the patch view.
+    Returns:
+        django.http.HttpResponse: The HTTP response from the patch view.
+    """
+    update_url = reverse(url, args=[instance_id])
+    return client.patch(update_url, data=data, content_type="application/json")
+
+
+def get_delete_view(client: Client, url: str, pk: int) -> HttpResponse:
+    """
+    Delete a model instance through a delete view using the Django REST Framework client.
+
+    Parameters:
+        - client (django.test.Client): The Django test client.
+        - url (str): The base URL endpoint for the delete view.
+        - pk (int): The primary key of the model instance to delete.
+
+    Returns:
+        django.http.HttpResponse: The HTTP response from the delete view.
+    """
+    delete_url = reverse(url, args=[pk])
+    return client.delete(delete_url)
+
+
+def find_instances_in_response(instances: list[Model], response: HttpResponse) -> tuple:
+    """
+    Find instances in the data contained in an HTTP response.
+
+    This method takes a list of instances and an HTTP response object, and it checks if each instance
+    is present in the data of the response based on their unique identifier (e.g., 'id').
+
+    Parameters:
+        - instances (list): A list of instances (models) to search for in the response data.
+        - response (HttpResponse): An HTTP response object containing data to search within.
+
+    Returns:
+        tuple: A tuple of Boolean values indicating whether each instance was found in the response.
+            Each element in the tuple corresponds to an instance in the same order as in the 'instances' list.
+            If an instance is found, the corresponding value is True; otherwise, it is False.
+    """
+    found_instances = [False] * len(instances)
+
+    for item in response.data["results"]:
+        for index, instance in enumerate(instances):
+            if item.get("id") == instance.id:
+                found_instances[index] = True
+
+    return tuple(found_instances)

wbcore/contrib/guardian/apps.py

@@ -0,0 +1,6 @@
+from django.apps import AppConfig
+
+
+class GuardianAppConfig(AppConfig):
+    name = "wbcore.contrib.guardian"
+    label = "wbcore_guardian"

wbcore/contrib/guardian/configurations.py

@@ -0,0 +1,3 @@
+class Guardian:
+    GUARDIAN_USER_OBJ_PERMS_MODEL = "wbcore_guardian.UserObjectPermission"
+    GUARDIAN_GROUP_OBJ_PERMS_MODEL = "wbcore_guardian.GroupObjectPermission"

wbcore/contrib/guardian/filters.py

@@ -0,0 +1,21 @@
+from rest_framework.filters import BaseFilterBackend
+
+
+class ObjectPermissionsFilter(BaseFilterBackend):
+    """
+    A filter backend that limits results to those where the requesting user
+    has read object level permissions.
+    """
+
+    def filter_queryset(self, request, queryset, view):
+        from guardian.shortcuts import get_objects_for_user
+        from wbcore.contrib.guardian.models.mixins import PermissionObjectModelMixin
+
+        model_class = queryset.model
+        if issubclass(model_class, PermissionObjectModelMixin):
+            user = request.user
+
+            return get_objects_for_user(
+                user, [model_class.view_perm_str], queryset, **model_class.guardian_shortcut_kwargs
+            )
+        return queryset

wbcore/contrib/guardian/tasks.py

@@ -0,0 +1,10 @@
+from celery import shared_task
+from wbcore.contrib.guardian.models.mixins import PermissionObjectModelMixin
+from wbcore.utils.itertools import get_inheriting_subclasses
+
+
+@shared_task
+def reload_permissions_as_task(prune_existing: bool | None = True, force_pruning: bool | None = False):
+    for subclass in get_inheriting_subclasses(PermissionObjectModelMixin):
+        for instance in subclass.objects.iterator():
+            instance.reload_permissions(prune_existing=prune_existing, force_pruning=force_pruning)

wbcore/contrib/guardian/urls.py

@@ -0,0 +1,12 @@
+from django.urls import include, path
+from wbcore.contrib.guardian.viewsets import PivotUserObjectPermissionModelViewSet
+from wbcore.routers import WBCoreRouter
+
+router = WBCoreRouter()
+router.register(
+    r"pivoteduserobjectpermission", PivotUserObjectPermissionModelViewSet, basename="pivoteduserobjectpermission"
+)
+
+urlpatterns = [
+    path("<int:content_type_id>/<int:object_pk>/", include(router.urls)),
+]

wbcore/contrib/guardian/utils.py

@@ -0,0 +1,124 @@
+from contextlib import suppress
+from datetime import datetime
+from typing import TYPE_CHECKING, Iterable, Iterator
+
+from django.contrib.contenttypes.models import ContentType
+from django.db import ProgrammingError
+from django.db.models import Model, Q, QuerySet
+from django.utils import timezone
+from guardian.shortcuts import assign_perm, get_anonymous_user
+from psycopg.errors import InvalidCursorName
+from wbcore.contrib.authentication.models import User
+from wbcore.contrib.guardian.models.models import UserObjectPermission
+from wbcore.permissions.shortcuts import get_internal_users
+
+if TYPE_CHECKING:
+    from wbcore.contrib.guardian.models.mixins import PermissionObjectModelMixin
+
+
+def assign_permissions(permissions_map: Iterable[tuple[str, Model, User, bool]]):
+    """
+    Assigns object-level permissions to users based on the provided permissions map.
+
+    This method iterates through the permissions_map, assigns the specified permission
+    to the user for the model instance, sets the 'editable' flag for the permission,
+    and saves the object permission.
+    """
+    for permission, instance, user, editable in permissions_map:
+        object_permissions = assign_perm(permission, user, instance)
+
+        if object_permissions is None:
+            continue
+
+        if isinstance(object_permissions, Model):
+            object_permissions = [object_permissions]
+
+        for object_permission in object_permissions:
+            object_permission.editable = editable  # type: ignore -- We have our custom Permission class here
+            object_permission.save()
+
+
+def get_public_user_or_group(only_internal: bool = False) -> QuerySet[User]:
+    """
+    Retrieves a queryset of active users, optionally filtering to internal users only.
+
+    This method fetches users based on the `only_internal` flag.
+    If set, it filters for internal users, otherwise returns all users.
+    The queryset includes active users or the anonymous user and excludes superusers
+    from the main set, while later ensuring their inclusion through a union operation.
+    """
+    users = User.objects.filter(is_active=True)
+    if only_internal:
+        users = users.filter(
+            Q(is_superuser=True) | Q(id=get_anonymous_user().pk) | Q(id__in=get_internal_users().values("id"))
+        )
+    return users
+
+
+def get_permission_matrix(
+    queryset: QuerySet,
+    created: datetime | None = None,
+    instance: Model | None = None,
+    user: User | None = None,
+) -> Iterator[tuple[str, Model, User, bool]]:
+    """
+    Retrieves the permission matrix for all (user, object) pairs
+
+    If an instance is provided, the queryset is filtered to that specific object. The method determines the
+    appropriate set of users based on the permission type of the object (private or public).
+
+    For each user, the function yields a tuple containing the permission string, the object instance,
+    the user, and whether the permission is editable.
+    """
+
+    if instance:
+        queryset = queryset.filter(id=instance.id)  # type: ignore
+
+    for _instance in queryset.all():
+        if _instance.permission_type is _instance.PermissionType.PUBLIC:
+            users = get_public_user_or_group()
+        else:
+            users = get_public_user_or_group(only_internal=True)
+        if user:
+            users = users.filter(id=user.id)
+        for user in users:
+            for permission, editable in _instance.get_permissions_for_user(user, created=created).items():
+                yield permission, _instance, user, editable
+
+
+def prune_permissions(instance: "PermissionObjectModelMixin", force: bool | None = False):
+    queryset = UserObjectPermission.objects.filter(
+        content_type=ContentType.objects.get_for_model(instance), object_pk=instance.id
+    )
+    if not force:
+        queryset = queryset.exclude(editable=True)
+    for permission in queryset:
+        permission.delete()
+
+
+def reload_permissions(
+    queryset: QuerySet,
+    created: datetime | None = None,
+    user: User | None = None,
+    instance: "PermissionObjectModelMixin | None" = None,
+    prune_existing: bool = True,
+    force_pruning: bool = False,
+):
+    """
+    Assigns permissions based on a given queryset, with options to prune existing permissions and
+    specify the creation timestamp. If no creation time is provided, the current time is used.
+
+    The function first checks if existing permissions should be pruned, which happens if both
+    `prune_existing` and `instance` are provided. It then retrieves the permission matrix
+    using `get_permission_matrix()` and assigns the appropriate permissions.
+
+    Error handling is in place to suppress database-related errors, such as `ProgrammingError`
+    and `InvalidCursorName`, which can occur due to unmanaged tables.
+    """
+    if not created:
+        created = timezone.now()
+    with suppress(ProgrammingError, InvalidCursorName):  # We check this to catch error trigger by unmanaged table
+        if prune_existing and instance:
+            prune_permissions(instance, force=force_pruning)
+        permission_matrix = get_permission_matrix(queryset, created=created, instance=instance, user=user)
+        assign_permissions(permission_matrix)

wbcore/contrib/notifications/viewsets/configs/notification_types.py

@@ -0,0 +1,27 @@
+from wbcore.metadata.configs.display import Field, ListDisplay
+from wbcore.metadata.configs.display.instance_display import Display
+from wbcore.metadata.configs.display.instance_display.shortcuts import (
+    create_simple_display,
+)
+from wbcore.metadata.configs.display.view_config import DisplayViewConfig
+
+
+class NotificationTypeSettingDisplayConfig(DisplayViewConfig):
+    def get_list_display(self) -> ListDisplay:
+        return ListDisplay(
+            fields=[
+                Field(key="notification_type", label="Notification"),
+                Field(key="help_text", label="Help Text"),
+                Field(key="enable_web", label="Web"),
+                Field(key="enable_mobile", label="Mobile"),
+                Field(key="enable_email", label="E-Mail"),
+            ],
+        )
+
+    def get_instance_display(self) -> Display:
+        return create_simple_display(
+            [
+                ["notification_type", "notification_type", "notification_type"],
+                ["enable_web", "enable_mobile", "enable_email"],
+            ]
+        )

wbcore/contrib/notifications/viewsets/configs/notifications.py

@@ -0,0 +1,85 @@
+from django.utils.translation import gettext as _
+from rest_framework.reverse import reverse
+from wbcore.contrib.icons.icons import WBIcon
+from wbcore.metadata.configs.buttons.buttons import (
+    ActionButton,
+    HyperlinkButton,
+    RequestType,
+    WidgetButton,
+)
+from wbcore.metadata.configs.buttons.view_config import ButtonViewConfig
+from wbcore.metadata.configs.display import Field, ListDisplay
+from wbcore.metadata.configs.display.instance_display import Display
+from wbcore.metadata.configs.display.instance_display.shortcuts import (
+    create_simple_display,
+)
+from wbcore.metadata.configs.display.view_config import DisplayViewConfig
+
+
+class NotificationButtonConfig(ButtonViewConfig):
+    def get_custom_buttons(self) -> set[ActionButton]:
+        if not self.view.kwargs.get("pk", None):
+            return {
+                ActionButton(
+                    weight=0,
+                    method=RequestType.PATCH,
+                    action_label=_("Reading all notifications"),
+                    endpoint=reverse("wbcore:notifications:notification-read-all", request=self.request),
+                    description_fields=_("Do you want to mark notifications as read?"),
+                    label=_("Mark all read"),
+                    icon=WBIcon.VIEW.icon,
+                    identifiers=["notifications:notification"],
+                ),
+                ActionButton(
+                    weight=1,
+                    method=RequestType.PATCH,
+                    action_label=_("Deleting all read notifications"),
+                    endpoint=reverse("wbcore:notifications:notification-delete-all-read", request=self.request),
+                    description_fields=_("Do you want delete all read notifications?"),
+                    label=_("Delete all read"),
+                    icon=WBIcon.DELETE.icon,
+                    identifiers=["notifications:notification"],
+                ),
+            }
+        return set()
+
+    def get_custom_instance_buttons(self) -> set[WidgetButton]:
+        return {
+            WidgetButton(
+                title=_("Open Resource"),
+                label=_("Open Resource"),
+                icon=WBIcon.LINK.icon,
+                key="open_internal_resource",
+            ),
+            HyperlinkButton(
+                title=_("Open Resource"),
+                label=_("Open Resource"),
+                icon=WBIcon.LINK.icon,
+                key="open_external_resource",
+            ),
+        }
+
+    def get_custom_list_instance_buttons(self) -> set[WidgetButton]:
+        return self.get_custom_instance_buttons()
+
+
+class NotificationDisplayConfig(DisplayViewConfig):
+    def get_list_display(self) -> ListDisplay:
+        return ListDisplay(
+            fields=[
+                Field(key="notification_type", label="Type"),
+                Field(key="title", label="Title"),
+                Field(key="body", label="body"),
+                Field(key="sent", label="Sent"),
+                Field(key="read", label="Read"),
+            ],
+        )
+
+    def get_instance_display(self) -> Display:
+        return create_simple_display(
+            [
+                ["notification_type", ".", "."],
+                ["title", "sent", "read"],
+                ["body", "body", "body"],
+            ]
+        )