wbcore 2.2.1__py2.py3-none-any.whl

wbcore/contrib/notifications/tests/test_viewsets/test_notification_types.py

@@ -0,0 +1,121 @@
+import pytest
+from rest_framework.reverse import reverse
+from wbcore.contrib.authentication.factories import UserFactory
+from wbcore.contrib.notifications.factories.notification_types import (
+    NotificationTypeModelFactory,
+)
+
+
+@pytest.mark.django_db
+class TestNotificationTypeRepresentationViewSet:
+    @pytest.mark.parametrize(
+        "user__user_permissions,status_code", [(None, 403), (["notifications.select_notificationtype"], 200)]
+    )
+    def test_instance(self, notification_type, client, user, status_code):
+        client.force_authenticate(user)
+        response = client.get(
+            reverse("wbcore:notifications:notification_type_representation-detail", args=[notification_type.pk])
+        )
+        assert response.status_code == status_code  # type: ignore
+
+    @pytest.mark.parametrize(
+        "user__user_permissions,status_code", [(None, 403), (["notifications.select_notificationtype"], 200)]
+    )
+    def test_list(self, client, user, status_code):
+        client.force_authenticate(user)
+        response = client.get(reverse("wbcore:notifications:notification_type_representation-list"))
+        assert response.status_code == status_code  # type: ignore
+
+
+@pytest.mark.django_db
+class TestNotificationTypeSettingModelViewSet:
+    @pytest.mark.parametrize(
+        "user__user_permissions,status_code", [(None, 403), (["notifications.view_notificationtypesetting"], 200)]
+    )
+    def test_instance(self, notification_type_setting, client, user, status_code):
+        client.force_authenticate(user)
+        response = client.get(
+            reverse("wbcore:notifications:notification_type_setting-detail", args=[notification_type_setting.pk])
+        )
+        assert response.status_code == status_code  # type: ignore
+
+    @pytest.mark.parametrize(
+        "user__user_permissions,status_code", [(None, 403), (["notifications.view_notificationtypesetting"], 200)]
+    )
+    def test_list(self, client, user, status_code):
+        client.force_authenticate(user)
+        response = client.get(reverse("wbcore:notifications:notification_type_setting-list"))
+        assert response.status_code == status_code  # type: ignore
+
+    @pytest.mark.parametrize(
+        "user__user_permissions,status_code", [(None, 403), (["notifications.add_notificationtypesetting"], 403)]
+    )
+    def test_create(self, notification_type, client, user, status_code):
+        """Regardless of permission, no user should ever be able to create notification type setting"""
+        client.force_authenticate(user)
+        response = client.post(
+            reverse("wbcore:notifications:notification_type_setting-list"),
+            {"user": user.id, "notification_type": notification_type.id},
+        )
+        assert response.status_code == status_code  # type: ignore
+
+    @pytest.mark.parametrize(
+        "user__user_permissions,status_code", [(None, 403), (["notifications.delete_notificationtypesetting"], 403)]
+    )
+    def test_delete(self, notification_type_setting, client, user, status_code):
+        """Regardless of permission, no user should ever be able to delete notification type setting"""
+        client.force_authenticate(user)
+        response = client.delete(
+            reverse("wbcore:notifications:notification_type_setting-detail", args=[notification_type_setting.id])
+        )
+        assert response.status_code == status_code  # type: ignore
+
+    @pytest.mark.parametrize(
+        "user__user_permissions,status_code", [(None, 403), (["notifications.change_notificationtypesetting"], 200)]
+    )
+    def test_change(self, notification_type_setting, client, user, status_code):
+        notification_type_setting.user = user
+        notification_type_setting.save()
+
+        client.force_authenticate(user)
+        response = client.patch(
+            reverse("wbcore:notifications:notification_type_setting-detail", args=[notification_type_setting.id]),
+            {"enable_web": True},
+        )
+        assert response.status_code == status_code  # type: ignore
+
+    @pytest.mark.parametrize(
+        "user__user_permissions,status_code", [(["notifications.change_notificationtypesetting"], 200)]
+    )
+    def test_change_notification_type_and_user(self, notification_type_setting, client, user, status_code):
+        """Regardless of the permission, you should never be able to change the user or notification type"""
+        user2 = UserFactory()
+        notification_type2 = NotificationTypeModelFactory()
+
+        assert user != user2
+        assert notification_type_setting.notification_type != notification_type2
+
+        client.force_authenticate(user)
+        response = client.patch(
+            reverse("wbcore:notifications:notification_type_setting-detail", args=[notification_type_setting.id]),
+            {"notification_type": notification_type2.pk, "user": user2.pk},  # type: ignore
+        )
+        assert response.status_code == status_code  # type: ignore
+        assert response.data["instance"]["user"] == user.pk
+        assert response.data["instance"]["notification_type"] == notification_type_setting.notification_type.pk
+
+    @pytest.mark.parametrize(
+        "user__user_permissions,status_code", [(["notifications.change_notificationtypesetting"], 404)]
+    )
+    def test_change_setting_from_other_user(self, notification_type_setting, client, user, status_code):
+        """Regardless of permission, no user should ever be able to change a setting from a different user"""
+        user2 = UserFactory()
+        notification_type_setting.user = user2
+        notification_type_setting.save()
+
+        client.force_authenticate(user)
+        response = client.patch(
+            reverse("wbcore:notifications:notification_type_setting-detail", args=[notification_type_setting.id]),
+            {"enable_web": True},
+        )
+        assert response.status_code == status_code  # type: ignore

wbcore/contrib/notifications/tests/test_viewsets/test_notifications.py

@@ -0,0 +1,120 @@
+import pytest
+from django.utils import timezone
+from rest_framework.reverse import reverse
+from wbcore.contrib.authentication.factories import UserFactory
+from wbcore.contrib.notifications.factories.notifications import (
+    NotificationModelFactory,
+)
+from wbcore.contrib.notifications.models.notifications import Notification
+
+
+@pytest.mark.django_db
+class TestNotificationModelViewSet:
+    @pytest.mark.parametrize(
+        "user__user_permissions,status_code", [(None, 403), (["notifications.view_notification"], 200)]
+    )
+    def test_instance(self, notification, client, user, status_code):
+        client.force_authenticate(user)
+        response = client.get(reverse("wbcore:notifications:notification-detail", args=[notification.pk]))
+        assert response.status_code == status_code  # type: ignore
+
+    @pytest.mark.parametrize("user__user_permissions,status_code", [(["notifications.view_notification"], 200)])
+    def test_instance_read(self, notification, client, user, status_code):
+        assert notification.read is None
+        client.force_authenticate(user)
+        response = client.get(reverse("wbcore:notifications:notification-detail", args=[notification.pk]))
+        assert response.status_code == status_code  # type: ignore
+        notification.refresh_from_db()
+        assert notification.read is not None
+
+    @pytest.mark.parametrize(
+        "user__user_permissions,status_code", [(None, 403), (["notifications.view_notification"], 200)]
+    )
+    def test_list(self, client, user, status_code):
+        client.force_authenticate(user)
+        response = client.get(reverse("wbcore:notifications:notification-list"))
+        assert response.status_code == status_code  # type: ignore
+
+    @pytest.mark.parametrize("user__user_permissions,status_code", [(["notifications.add_notification"], 403)])
+    def test_create(self, notification, client, user, status_code):
+        """Regardless of permission, no user should ever be able to create notification"""
+        client.force_authenticate(user)
+        response = client.post(
+            reverse("wbcore:notifications:notification-list"),
+            {"user": user.id, "notification": notification.id, "title": "abc", "body": "abc"},
+        )
+        assert response.status_code == status_code  # type: ignore
+
+    @pytest.mark.parametrize("user__user_permissions,status_code", [(["notifications.change_notification"], 403)])
+    def test_change(self, notification, client, user, status_code):
+        """Regardless of permission, no user should ever be able to change notification"""
+        client.force_authenticate(user)
+        response = client.patch(
+            reverse("wbcore:notifications:notification-detail", args=[notification.pk]), {"title": "abc"}
+        )
+        assert response.status_code == status_code  # type: ignore
+        response = client.put(
+            reverse("wbcore:notifications:notification-detail", args=[notification.pk]), {"title": "abc"}
+        )
+        assert response.status_code == status_code  # type: ignore
+
+    @pytest.mark.parametrize(
+        "user__user_permissions,status_code", [(None, 403), (["notifications.delete_notification"], 204)]
+    )
+    def test_delete(self, notification, client, user, status_code):
+        client.force_authenticate(user)
+        response = client.delete(reverse("wbcore:notifications:notification-detail", args=[notification.pk]))
+        assert response.status_code == status_code  # type: ignore
+
+    @pytest.mark.parametrize("user__user_permissions,status_code", [(["notifications.delete_notification"], 404)])
+    def test_delete_other_notification(self, notification, client, user, status_code):
+        """Regardless of the permission, a user should never be able to delete another users notifications"""
+        user2 = UserFactory()
+        notification.user = user2
+        notification.save()
+        client.force_authenticate(user)
+        response = client.delete(reverse("wbcore:notifications:notification-detail", args=[notification.pk]))
+        assert response.status_code == status_code  # type: ignore
+
+    @pytest.mark.parametrize("user__user_permissions", [(["notifications.change_notification"])])
+    def test_read_all_action(self, notification, client, user):
+        assert notification.read is None
+        client.force_authenticate(user)
+        client.patch(reverse("wbcore:notifications:notification-read-all"))
+        notification.refresh_from_db()
+        assert notification.read is not None
+
+    @pytest.mark.parametrize("user__user_permissions", [(["notifications.change_notification"])])
+    def test_read_all_action_other_notification(self, notification, client, user):
+        notification2 = NotificationModelFactory()
+        assert notification.read is None
+        assert notification2.read is None  # type: ignore
+        client.force_authenticate(user)
+        client.patch(reverse("wbcore:notifications:notification-read-all"))
+        notification.refresh_from_db()
+        notification2.refresh_from_db()  # type: ignore
+        assert notification.read is not None
+        assert notification2.read is None  # type: ignore
+
+    @pytest.mark.parametrize("user__user_permissions", [(["notifications.change_notification"])])
+    def test_delete_all_action(self, notification, client, user):
+        NotificationModelFactory(user=user, read=timezone.now())
+        assert Notification.objects.filter(user=user).count() == 2
+
+        client.force_authenticate(user)
+        client.patch(reverse("wbcore:notifications:notification-delete-all-read"))
+
+        assert Notification.objects.filter(user=user).count() == 1
+
+    @pytest.mark.parametrize("user__user_permissions", [(["notifications.change_notification"])])
+    def test_delete_all_action_other_notification(self, notification, client, user):
+        user2 = UserFactory()
+        NotificationModelFactory(user=user2, read=timezone.now())
+        notification.read = timezone.now()
+        notification.save()
+        assert Notification.objects.all().count() == 2
+
+        client.force_authenticate(user)
+        client.patch(reverse("wbcore:notifications:notification-delete-all-read"))
+
+        assert Notification.objects.all().count() == 1

wbcore/contrib/notifications/urls.py

@@ -0,0 +1,26 @@
+from django.urls import include, path
+from wbcore.contrib.notifications import viewsets
+from wbcore.contrib.notifications.views import (
+    NotificationTokenAPIView,
+    service_worker_view,
+)
+from wbcore.routers import WBCoreRouter
+
+router = WBCoreRouter()
+
+router.register("notification", viewsets.NotificationModelViewSet, basename="notification")
+router.register(
+    "notification_type_representation",
+    viewsets.NotificationTypeRepresentationViewSet,
+    basename="notification_type_representation",
+)
+router.register(
+    "notification_type_setting", viewsets.NotificationTypeSettingModelViewSet, basename="notification_type_setting"
+)
+
+
+urlpatterns = [
+    path("service-worker/<str:service_worker_name>", service_worker_view, name="service-worker"),
+    path("token/", NotificationTokenAPIView.as_view(), name="token"),
+    path("", include(router.urls)),
+]

wbcore/contrib/notifications/utils.py

@@ -0,0 +1,20 @@
+from django.conf import settings
+from django.contrib.sites.models import Site
+
+
+def base_domain() -> str:
+    """A utility method that assembles the current domain. Utilizes the site app from django
+
+    Returns:
+        A string containing the current domain as noted in the curret `Site` prefixed with the http scheme
+
+    """
+    scheme = "https" if settings.SECURE_SSL_REDIRECT else "http"
+    base_domain = Site.objects.get_current().domain
+    return f"{scheme}://{base_domain}"
+
+
+def create_notification_type(
+    code: str, title: str, help_text: str, web: bool = True, mobile: bool = True, email: bool = False
+) -> tuple[str, str, str, bool, bool, bool]:
+    return (code, title, help_text, web, mobile, email)

wbcore/contrib/notifications/views.py

@@ -0,0 +1,62 @@
+from django.conf import settings
+from django.contrib.staticfiles import finders
+from django.db.utils import IntegrityError
+from django.http.response import HttpResponse
+from django.utils.module_loading import import_string
+from rest_framework import status
+from rest_framework.permissions import IsAuthenticated
+from rest_framework.request import Request
+from rest_framework.response import Response
+from rest_framework.views import APIView
+from wbcore.contrib.notifications.models.tokens import NotificationUserToken
+
+
+class NotificationTokenAPIView(APIView):
+    """An APIView that returns the configuration needed for a frontend to generate a token and to upload said token"""
+
+    permission_classes = [IsAuthenticated]
+
+    def get(self, request: Request) -> Response:
+        return Response(import_string(settings.NOTIFICATION_BACKEND).get_configuration())
+
+    def post(self, request: Request) -> Response:
+        try:
+            token: str = request.data["token"]  # type: ignore
+
+            existing_instance = NotificationUserToken.objects.filter(
+                user=request.user,
+                token__startswith=token.split(":")[0],
+            )
+
+            if existing_instance.exists():
+                existing_instance.update(token=token)
+            else:
+                NotificationUserToken.objects.create(
+                    user=request.user,
+                    token=token,
+                    device_type=request.data["device_type"],  # type: ignore
+                )
+            return Response({}, status=status.HTTP_201_CREATED)
+        except IntegrityError:
+            return Response({}, status=status.HTTP_200_OK)
+        except KeyError:
+            return Response({}, status=status.HTTP_400_BAD_REQUEST)
+
+    def delete(self, request: Request) -> Response:
+        queryset = NotificationUserToken.objects.filter(user=request.user)
+
+        if device_type := request.GET.get("device_type", None):  # type: ignore
+            queryset = queryset.filter(device_type=device_type)
+
+        queryset.delete()
+        return Response({}, status=status.HTTP_204_NO_CONTENT)
+
+
+def service_worker_view(request, service_worker_name: str | None = None):
+    file_path = finders.find(f"notifications/{service_worker_name}")
+    if file_path:
+        with open(file_path) as f:
+            response = HttpResponse(content=f.read(), content_type="application/javascript")
+            response.headers["Service-Worker-Allowed"] = "../" * ((request.get_full_path()).count("/") - 1)
+            return response
+    return HttpResponse(status=status.HTTP_400_BAD_REQUEST)

wbcore/contrib/notifications/viewsets/__init__.py

@@ -0,0 +1,5 @@
+from .notification_types import (
+    NotificationTypeRepresentationViewSet,
+    NotificationTypeSettingModelViewSet,
+)
+from .notifications import NotificationModelViewSet

wbcore/contrib/notifications/viewsets/menus.py

@@ -0,0 +1,14 @@
+from django.utils.translation import gettext as _
+from wbcore.menus import ItemPermission, MenuItem
+
+NotificationTypeMenuItem = MenuItem(
+    label=_("Notification Types"),
+    endpoint="wbcore:notifications:notification_type_setting-list",
+    permission=ItemPermission(permissions=["notifications.view_notificationtype"]),
+)
+
+NotificationMenuItem = MenuItem(
+    label=_("Notifications"),
+    endpoint="wbcore:notifications:notification-list",
+    permission=ItemPermission(permissions=["notifications.view_notification"]),
+)

wbcore/contrib/notifications/viewsets/notification_types.py

@@ -0,0 +1,40 @@
+from django.db.models.query import F, QuerySet
+from rest_framework import status
+from rest_framework.request import Request
+from rest_framework.response import Response
+from wbcore import viewsets
+from wbcore.contrib.notifications.models import (
+    NotificationType,
+    NotificationTypeSetting,
+)
+from wbcore.contrib.notifications.serializers import (
+    NotificationTypeRepresentationSerializer,
+    NotificationTypeSettingModelSerializer,
+)
+
+from .configs.notification_types import NotificationTypeSettingDisplayConfig
+
+
+class NotificationTypeRepresentationViewSet(viewsets.RepresentationViewSet):
+    queryset = NotificationType.objects.all()
+    serializer_class = NotificationTypeRepresentationSerializer
+
+
+class NotificationTypeSettingModelViewSet(viewsets.ModelViewSet):
+    queryset = NotificationTypeSetting.objects.all()
+    serializer_class = NotificationTypeSettingModelSerializer
+
+    display_config_class = NotificationTypeSettingDisplayConfig
+
+    search_fields = ["notification_type__title", "notification_type__help_text"]
+
+    def create(self, request: Request) -> Response:
+        return Response(status=status.HTTP_403_FORBIDDEN)
+
+    def destroy(self, request: Request, pk=None) -> Response:
+        return Response(status=status.HTTP_403_FORBIDDEN)
+
+    def get_queryset(self) -> QuerySet[NotificationTypeSetting]:
+        return (
+            super().get_queryset().filter(user=self.request.user).annotate(help_text=F("notification_type__help_text"))
+        )

wbcore/contrib/notifications/viewsets/notifications.py

@@ -0,0 +1,57 @@
+from django.db.models.query import QuerySet
+from django.utils import timezone
+from rest_framework import status
+from rest_framework.decorators import action
+from rest_framework.request import Request
+from rest_framework.response import Response
+from wbcore import viewsets
+from wbcore.contrib.notifications.models import Notification
+from wbcore.contrib.notifications.serializers import NotificationModelSerializer
+from wbcore.contrib.notifications.viewsets.configs.notifications import (
+    NotificationButtonConfig,
+    NotificationDisplayConfig,
+)
+
+
+class NotificationModelViewSet(viewsets.ModelViewSet):
+    ordering = ("-created",)
+    search_fields = ("title", "notification_type__title")
+
+    queryset = Notification.objects.all()
+
+    serializer_class = NotificationModelSerializer
+    display_config_class = NotificationDisplayConfig
+    button_config_class = NotificationButtonConfig
+
+    def retrieve(self, request: Request, *args, **kwargs) -> Response:
+        obj = self.get_object()
+        if not obj.read:
+            obj.read = timezone.now()
+            obj.save()
+        return super().retrieve(request, *args, **kwargs)
+
+    def create(self, request: Request) -> Response:
+        return Response(status=status.HTTP_403_FORBIDDEN)
+
+    def update(self, request: Request, pk=None) -> Response:
+        return Response(status=status.HTTP_403_FORBIDDEN)
+
+    def partial_update(self, request: Request, pk=None) -> Response:
+        return Response(status=status.HTTP_403_FORBIDDEN)
+
+    def get_queryset(self) -> QuerySet[Notification]:
+        return super().get_queryset().filter(user=self.request.user)
+
+    @action(methods=["GET"], detail=False)
+    def unread_count(self, request, pk=None):
+        return Response({"count": Notification.objects.filter(user=request.user, read__isnull=True).count()})
+
+    @action(methods=["PATCH"], detail=False)
+    def read_all(self, request: Request, pk=None) -> Response:
+        self.get_queryset().filter(read__isnull=True).update(read=timezone.now())
+        return Response({})
+
+    @action(methods=["PATCH"], detail=False)
+    def delete_all_read(self, request: Request, pk=None) -> Response:
+        self.get_queryset().filter(read__isnull=False).delete()
+        return Response({})

wbcore/contrib/tags/admin.py

@@ -0,0 +1,17 @@
+from django.contrib import admin
+
+from .models import Tag, TagGroup
+
+
+@admin.register(Tag)
+class TagModelAdmin(admin.ModelAdmin):
+    list_display = ("title", "slug", "color", "content_type")
+    search_fields = ("title", "slug")
+    readonly_fields = ("managed",)
+
+
+@admin.register(TagGroup)
+class TagGroupModelAdmin(admin.ModelAdmin):
+    list_display = ("title",)
+    search_fields = ("title",)
+    readonly_fields = ("managed",)

wbcore/contrib/tags/apps.py

@@ -0,0 +1,9 @@
+from django.apps import AppConfig
+
+
+class TagsConfig(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "wbcore.contrib.tags"
+
+    def ready(self):
+        import wbcore.contrib.tags.signals  # noqa: F401

wbcore/contrib/tags/factories.py

@@ -0,0 +1,27 @@
+import factory
+
+from .models import Tag, TagGroup
+
+
+class TagFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = Tag
+
+    title = factory.Faker("name")
+    description = factory.Faker("paragraph")
+
+    @factory.post_generation
+    def groups(self, create, extracted, **kwargs):
+        if not create:
+            return
+
+        if extracted:
+            for group in extracted:
+                self.groups.add(group)
+
+
+class TagGroupFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = TagGroup
+
+    title = factory.Faker("name")

wbcore/contrib/tags/filters.py

@@ -0,0 +1,42 @@
+from itertools import chain
+
+from django.contrib.contenttypes.models import ContentType
+from django.db.models import Q
+from wbcore import filters
+from wbcore.content_type.utils import (
+    get_ancestors_content_type,
+    get_view_content_type_id,
+)
+
+from .models import Tag
+
+
+class TagFilterMixin(filters.FilterSet):
+    tags = filters.ModelMultipleChoiceFilter(
+        endpoint=Tag.get_representation_endpoint(),
+        value_key=Tag.get_representation_value_key(),
+        label_key=Tag.get_representation_label_key(),
+        label="Tags",
+        filter_params=lambda request, view: {"content_type": get_view_content_type_id(view)},
+        queryset=Tag.objects.all(),
+    )
+
+
+class TagFilterSet(filters.FilterSet):
+    content_type = filters.ModelMultipleChoiceFilter(
+        endpoint="wbcore:contenttyperepresentation-list",
+        value_key="id",
+        label_key="{{app_label}} | {{model}}",
+        queryset=ContentType.objects.all(),
+        method="filter_content_type",
+    )
+
+    def filter_content_type(self, queryset, label, value):
+        if value:
+            content_types = list(chain(*[get_ancestors_content_type(content_type) for content_type in value]))
+            return queryset.filter(Q(content_type__isnull=True) | Q(content_type__in=content_types))
+        return queryset
+
+    class Meta:
+        model = Tag
+        fields = {"title": ["icontains", "exact"], "description": ["icontains"], "groups": ["exact"]}

wbcore/contrib/tags/migrations/0001_initial.py

@@ -0,0 +1,62 @@
+# Generated by Django 4.1.8 on 2023-04-06 14:14
+
+import django.db.models.deletion
+import wbcore.models.fields
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    initial = True
+
+    dependencies = [
+        ("contenttypes", "0002_remove_content_type_name"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="TagGroup",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name="ID"),
+                ),
+                ("managed", models.BooleanField(default=False)),
+                ("title", models.CharField(max_length=255, unique=True)),
+            ],
+            options={
+                "verbose_name": "Tag Group",
+                "verbose_name_plural": "Tag Groups",
+            },
+        ),
+        migrations.CreateModel(
+            name="Tag",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name="ID"),
+                ),
+                ("computed_str", models.CharField(blank=True, max_length=512, null=True, verbose_name="Name")),
+                ("managed", models.BooleanField(default=False)),
+                ("title", models.CharField(max_length=255)),
+                ("slug", models.CharField(blank=True, max_length=255, null=True)),
+                ("color", wbcore.contrib.color.fields.ColorField(default="#D3D3D3")),
+                ("description", models.TextField(blank=True, default="")),
+                (
+                    "content_type",
+                    models.ForeignKey(
+                        blank=True,
+                        null=True,
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="associated_tags",
+                        to="contenttypes.contenttype",
+                    ),
+                ),
+                ("groups", models.ManyToManyField(blank=True, to="tags.taggroup")),
+            ],
+            options={
+                "verbose_name": "Tag",
+                "verbose_name_plural": "Tags",
+                "unique_together": {("slug", "content_type")},
+            },
+        ),
+    ]

wbcore/contrib/tags/models/__init__.py

@@ -0,0 +1,2 @@
+from .mixins import TagModelMixin
+from .tags import Tag, TagGroup