wbcore 2.2.1__py2.py3-none-any.whl

wbcore/contrib/tags/models/mixins.py

@@ -0,0 +1,27 @@
+from django.db import models
+
+
+class TagModelMixin(models.Model):
+    tag_detail_endpoint = models.CharField(max_length=255, null=True, blank=True)
+    tag_representation = models.CharField(max_length=512, null=True, blank=True)
+    tags = models.ManyToManyField(
+        to="tags.Tag",
+        related_name="%(app_label)s_%(class)s_items",
+        blank=True,
+    )
+
+    def save(self, *args, **kwargs):
+        super().save(*args, **kwargs)
+        self.__class__.objects.filter(id=self.id).update(
+            tag_detail_endpoint=self.get_tag_detail_endpoint(),
+            tag_representation=self.get_tag_representation(),
+        )
+
+    def get_tag_detail_endpoint(self):
+        raise NotImplementedError("When using Tags, you must implement get_tag_detail_endpoint")
+
+    def get_tag_representation(self):
+        raise NotImplementedError("When using Tags, you must implement get_tag_representation")
+
+    class Meta:
+        abstract = True

wbcore/contrib/tags/models/tags.py

@@ -0,0 +1,103 @@
+from django.contrib.contenttypes.models import ContentType
+from django.db import models
+from django.db.models.fields.reverse_related import ManyToManyRel
+from django.db.models.signals import m2m_changed
+from django.dispatch import receiver
+from slugify import slugify
+from wbcore.contrib.color.fields import ColorField
+from wbcore.models import WBModel
+from wbcore.utils.models import ComplexToStringMixin
+
+
+class ManagedMixin(models.Model):
+    managed = models.BooleanField(default=False)
+
+    class Meta:
+        abstract = True
+
+
+class Tag(ManagedMixin, ComplexToStringMixin, WBModel):
+    title = models.CharField(max_length=255)
+
+    slug = models.CharField(max_length=255, null=True, blank=True)
+    color = ColorField(default="#D3D3D3")
+
+    groups = models.ManyToManyField(to="tags.TagGroup", blank=True)
+    description = models.TextField(default="", blank=True)
+
+    content_type = models.ForeignKey(
+        ContentType, on_delete=models.CASCADE, blank=True, null=True, related_name="associated_tags"
+    )
+
+    class Meta:
+        unique_together = [("slug", "content_type")]
+        verbose_name = "Tag"
+        verbose_name_plural = "Tags"
+
+    @classmethod
+    def get_endpoint_basename(cls):
+        return "wbcore:tags:tag"
+
+    @classmethod
+    def get_representation_endpoint(cls):
+        return "wbcore:tags:tagrepresentation-list"
+
+    @classmethod
+    def get_representation_value_key(cls):
+        return "id"
+
+    @classmethod
+    def get_representation_label_key(cls):
+        return "{{computed_str}}"
+
+    def compute_str(self) -> str:
+        # We need to check here if the instance already is in the database, otherwise groups cannot be linked yet
+        if self.id and self.groups.exists():
+            groups = ",".join(self.groups.all().values_list("title", flat=True))
+            return f"{groups}::{self.title}"
+        return self.title
+
+    def save(self, *args, **kwargs):
+        if not self.slug:
+            self.slug = slugify(self.title)
+        self.computed_str = self.compute_str()
+        super().save(*args, **kwargs)
+
+    def get_tagged_queryset(self):
+        qs = self.__class__.objects.none()
+        for field in filter(lambda x: isinstance(x, ManyToManyRel), self.__class__._meta.get_fields()):
+            _qs = getattr(self, field.related_name).all()
+            qs = qs.union(_qs.values("tag_detail_endpoint", "tag_representation"))
+        return qs
+
+
+class TagGroup(ManagedMixin, WBModel):
+    title = models.CharField(max_length=255, unique=True)
+
+    @classmethod
+    def get_endpoint_basename(cls):
+        return "wbcore:tags:taggroup"
+
+    @classmethod
+    def get_representation_endpoint(cls):
+        return "wbcore:tags:taggrouprepresentation-list"
+
+    @classmethod
+    def get_representation_value_key(cls):
+        return "id"
+
+    @classmethod
+    def get_representation_label_key(cls):
+        return "{{title}}"
+
+    def __str__(self) -> str:
+        return f"{self.title}"
+
+    class Meta:
+        verbose_name = "Tag Group"
+        verbose_name_plural = "Tag Groups"
+
+
+@receiver(m2m_changed, sender=Tag.groups.through)
+def tag_groups_m2m_changed(sender, instance, action, **kwargs):
+    instance.save()

wbcore/contrib/tags/release_notes/1_0_0.md

@@ -0,0 +1,13 @@
+Date: 2023-04-26
+Module: Tags
+Summary: Initial Release Note
+Version: 1.0.0
+
+## New Features
+- Bootstrap module versioning
+
+## Enhancements
+./.
+
+## Bugfixes
+./.

wbcore/contrib/tags/serializers.py

@@ -0,0 +1,87 @@
+from django.contrib.contenttypes.models import ContentType
+from rest_framework.reverse import reverse
+from wbcore import serializers
+from wbcore.content_type.serializers import ContentTypeRepresentationSerializer
+from wbcore.content_type.utils import get_view_content_type_id
+
+from .models import Tag, TagGroup
+
+
+class TagGroupRepresentationSerializer(serializers.RepresentationSerializer):
+    _detail = serializers.HyperlinkField(reverse_name="wbcore:tags:taggroup-detail")
+
+    class Meta:
+        model = TagGroup
+        fields = ("id", "title", "_detail")
+
+
+class TagGroupModelSerializer(serializers.ModelSerializer):
+    @serializers.register_resource()
+    def additional_resources(self, instance, request, user):
+        return {
+            "tags": reverse(
+                "wbcore:tags:group-tag-list",
+                args=[instance.id],
+                request=request,
+            )
+        }
+
+    class Meta:
+        model = TagGroup
+        read_only_fields = ("slug",)
+        fields = ("id", "title", "_additional_resources")
+
+
+class TagRepresentationSerializer(serializers.RepresentationSerializer):
+    _detail = serializers.HyperlinkField(reverse_name="wbcore:tags:tag-detail")
+    _detail_preview = serializers.HyperlinkField(reverse_name="wbcore:tags:tag-detail")
+
+    def get_filter_params(self, request):
+        content_type_id = get_view_content_type_id(request.parser_context["view"])
+        return {"content_type": content_type_id}
+
+    class Meta:
+        model = Tag
+        read_only_fields = ("slug",)
+        fields = (
+            "id",
+            "title",
+            "computed_str",
+            "color",
+            "slug",
+            "description",
+            "_detail",
+            "_detail_preview",
+        )
+
+
+class TagModelSerializer(serializers.ModelSerializer):
+    _groups = TagGroupRepresentationSerializer(source="groups", many=True)
+    _content_type = ContentTypeRepresentationSerializer(source="content_type")
+    content_type = serializers.PrimaryKeyRelatedField(queryset=ContentType.objects.all(), required=False)
+    groups = serializers.PrimaryKeyRelatedField(
+        queryset=TagGroup.objects.all(),
+        many=True,
+        default=serializers.DefaultFromKwargs("group_id"),
+    )
+
+    class Meta:
+        model = Tag
+        read_only_fields = ("slug",)
+        fields = (
+            "id",
+            "title",
+            "computed_str",
+            "color",
+            "content_type",
+            "_content_type",
+            "slug",
+            "description",
+            "groups",
+            "_groups",
+        )
+
+
+class TagSerializerMixin(serializers.Serializer):
+    tags = serializers.PrimaryKeyRelatedField(queryset=Tag.objects.all(), label="Tags", many=True)
+    _tags = TagRepresentationSerializer(source="tags", many=True)

wbcore/contrib/tags/signals.py

@@ -0,0 +1,17 @@
+from django.db.models.signals import m2m_changed
+from wbcore.dispatch import receiver_inherited_through_models
+
+from .models.mixins import TagModelMixin
+
+
+@receiver_inherited_through_models(m2m_changed, sender=TagModelMixin, through_field_name="tags")
+def pre_add_tags(sender, instance, action, pk_set, **kwargs):
+    from django.contrib.contenttypes.models import ContentType
+    from wbcore.contrib.tags.models.tags import Tag
+
+    if action == "post_add" and pk_set:
+        content_type = ContentType.objects.get_for_model(instance)
+        for tag_id in pk_set:
+            tag = Tag.objects.get(id=tag_id)
+            if tag.content_type and tag.content_type != content_type:
+                instance.tags.remove(tag)

wbcore/contrib/tags/tests/conftest.py

@@ -0,0 +1,7 @@
+from pytest_factoryboy import register
+from wbcore.tests.conftest import *
+
+from ..factories import TagFactory, TagGroupFactory
+
+register(TagFactory)
+register(TagGroupFactory)

wbcore/contrib/tags/tests/tests.py

@@ -0,0 +1,17 @@
+import pytest
+from wbcore.test import GenerateTest, default_config
+
+config = {}
+for key, value in default_config.items():
+    config[key] = list(
+        filter(
+            lambda x: x.__module__.startswith("wbcore.contrib.tags") and x.__name__ not in ["TagTagGroupModelViewSet"],
+            value,
+        )
+    )
+
+
+@pytest.mark.django_db
+@GenerateTest(config)
+class TestProject:
+    pass

wbcore/contrib/tags/urls.py

@@ -0,0 +1,14 @@
+from django.urls import include, path
+from wbcore.routers import WBCoreRouter
+
+from .viewsets import viewsets
+
+router = WBCoreRouter()
+router.register(r"tagrepresentation", viewsets.TagRepresentationViewSet, basename="tagrepresentation")
+router.register(r"tag", viewsets.TagModelViewSet, basename="tag")
+router.register(r"taggrouprepresentation", viewsets.TagGroupRepresentationViewSet, basename="taggrouprepresentation")
+router.register(r"taggroup", viewsets.TagGroupModelViewSet, basename="taggroup")
+
+group_router = WBCoreRouter()
+group_router.register(r"tag", viewsets.TagTagGroupModelViewSet, basename="group-tag")
+urlpatterns = [path("", include(router.urls)), path("group/<int:group_id>/", include(group_router.urls))]

wbcore/contrib/tags/viewsets/__init__.py

@@ -0,0 +1,8 @@
+from .menu import TAG_MENUITEM
+from .viewsets import (
+    TagGroupModelSerializer,
+    TagGroupRepresentationSerializer,
+    TagModelViewSet,
+    TagRepresentationViewSet,
+    TagTagGroupModelViewSet,
+)

wbcore/contrib/tags/viewsets/display.py

@@ -0,0 +1,50 @@
+from typing import Optional
+
+from wbcore.metadata.configs import display as dp
+from wbcore.metadata.configs.display.instance_display.shortcuts import (
+    Display,
+    create_simple_display,
+    create_simple_section,
+)
+from wbcore.metadata.configs.display.instance_display.utils import repeat_field
+from wbcore.metadata.configs.display.view_config import DisplayViewConfig
+from wbcore.metadata.configs.preview import PreviewViewConfig
+
+
+class TagGroupDisplayConfig(DisplayViewConfig):
+    def get_list_display(self) -> Optional[dp.ListDisplay]:
+        return dp.ListDisplay(fields=[dp.Field(key="title", label="Title")])
+
+    def get_instance_display(self) -> Display:
+        return create_simple_display(
+            [["title"], ["tags_sections"]],
+            [create_simple_section("tags_sections", "Tags", [["tags"]], "tags", collapsed=True)],
+        )
+
+
+class TagDisplayConfig(DisplayViewConfig):
+    def get_list_display(self) -> Optional[dp.ListDisplay]:
+        return dp.ListDisplay(
+            fields=[
+                dp.Field(key="title", label="Title"),
+                dp.Field(key="color", label="Color"),
+                dp.Field(key="slug", label="Slug"),
+                dp.Field(key="groups", label="Groups"),
+                dp.Field(key="content_type", label="Content Type"),
+                dp.Field(key="description", label="Description"),
+            ]
+        )
+
+    def get_instance_display(self) -> Display:
+        return create_simple_display(
+            [
+                [repeat_field(2, "title"), "slug"],
+                ["groups", "color", "content_type"],
+                [repeat_field(3, "description")],
+            ]
+        )
+
+
+class TagPreviewConfig(PreviewViewConfig):
+    def get_display(self):
+        return create_simple_display([["title", "groups", "description"]])

wbcore/contrib/tags/viewsets/menu.py

@@ -0,0 +1,15 @@
+from wbcore.menus import ItemPermission, MenuItem
+
+TAG_MENUITEM = MenuItem(
+    label="Tag",
+    endpoint="wbcore:tags:tag-list",
+    add=MenuItem(label="New Tag", endpoint="wbcore:tags:tag-list"),
+    permission=ItemPermission(permissions=["tags.change_tag"]),
+)
+
+TAGGROUP_MENUITEM = MenuItem(
+    label="Tag Group",
+    endpoint="wbcore:tags:taggroup-list",
+    add=MenuItem(label="New Tag Group", endpoint="wbcore:tags:taggroup-list"),
+    permission=ItemPermission(permissions=["tags.change_taggroup"]),
+)

wbcore/contrib/tags/viewsets/viewsets.py

@@ -0,0 +1,58 @@
+from wbcore import viewsets
+
+from ..filters import TagFilterSet
+from ..models import Tag, TagGroup
+from ..serializers import (
+    TagGroupModelSerializer,
+    TagGroupRepresentationSerializer,
+    TagModelSerializer,
+    TagRepresentationSerializer,
+)
+from .display import TagDisplayConfig, TagGroupDisplayConfig, TagPreviewConfig
+
+
+class TagGroupRepresentationViewSet(viewsets.RepresentationViewSet):
+    queryset = TagGroup.objects.all()
+    serializer_class = TagGroupRepresentationSerializer
+
+    search_fields = ["title"]
+
+
+class TagGroupModelViewSet(viewsets.ModelViewSet):
+    queryset = TagGroup.objects.all()
+    serializer_class = TagGroupModelSerializer
+
+    filterset_fields = {"title": ["icontains", "exact"]}
+    search_fields = ["title"]
+
+    display_config_class = TagGroupDisplayConfig
+
+
+class TagRepresentationViewSet(viewsets.RepresentationViewSet):
+    queryset = Tag.objects.all()
+    serializer_class = TagRepresentationSerializer
+    filterset_class = TagFilterSet
+
+    search_fields = ["title", "slug", "groups__title"]
+
+
+class TagModelViewSet(viewsets.ModelViewSet):
+    queryset = Tag.objects.all()
+    serializer_class = TagModelSerializer
+
+    filterset_class = TagFilterSet
+    search_fields = ("title", "description")
+    ordering_fields = [
+        "title",
+        "color",
+        "slug",
+        "content_type",
+    ]
+    ordering = ["title"]
+    display_config_class = TagDisplayConfig
+    preview_config_class = TagPreviewConfig
+
+
+class TagTagGroupModelViewSet(TagModelViewSet):
+    def get_queryset(self):
+        return super().get_queryset().filter(groups=self.kwargs["group_id"])

wbcore/contrib/workflow/__init__.py

@@ -0,0 +1 @@
+from .decorators import register, register_assignee

wbcore/contrib/workflow/admin/__init__.py

@@ -0,0 +1,15 @@
+from .condition import ConditionAdmin
+from .data import DataAdmin, DataValueAdmin
+from .display import DisplayAdmin
+from .process import ProcessAdmin
+from .step import (
+    DecisionStepAdmin,
+    EmailStepAdmin,
+    FinishStepAdmin,
+    JoinStepAdmin,
+    SplitStepAdmin,
+    UserStepAdmin,
+    StartStepAdmin,
+)
+from .transition import TransitionAdmin
+from .workflow import WorkflowAdmin

wbcore/contrib/workflow/admin/condition.py

@@ -0,0 +1,8 @@
+from django.contrib import admin
+from wbcore.contrib.workflow.models import Condition
+
+
+@admin.register(Condition)
+class ConditionAdmin(admin.ModelAdmin):
+    search_fields = ("name",)
+    list_display = ("id", "transition", "attribute_name", "operator", "negate_operator", "expected_value")

wbcore/contrib/workflow/admin/data.py

@@ -0,0 +1,14 @@
+from django.contrib import admin
+from wbcore.contrib.workflow.models import Data, DataValue
+
+
+@admin.register(Data)
+class DataAdmin(admin.ModelAdmin):
+    search_fields = ("label",)
+    list_display = ("id", "label", "data_type", "workflow", "help_text", "required", "default")
+
+
+@admin.register(DataValue)
+class DataValueAdmin(admin.ModelAdmin):
+    search_fields = ("value",)
+    list_display = ("id", "value", "data")

wbcore/contrib/workflow/admin/display.py

@@ -0,0 +1,8 @@
+from django.contrib import admin
+from wbcore.contrib.workflow.models import Display
+
+
+@admin.register(Display)
+class DisplayAdmin(admin.ModelAdmin):
+    search_fields = ("name",)
+    list_display = ("id", "name", "grid_template_areas")

wbcore/contrib/workflow/admin/process.py

@@ -0,0 +1,36 @@
+from django.contrib import admin
+from wbcore.contrib.workflow.models import Process, ProcessStep
+
+
+@admin.register(Process)
+class ProcessAdmin(admin.ModelAdmin):
+    search_fields = ("id", "workflow")
+    list_display = (
+        "id",
+        "workflow",
+        "state",
+        "started",
+        "finished",
+        "instance_id",
+        "content_type",
+        "instance",
+        "preserved_instance",
+    )
+
+
+@admin.register(ProcessStep)
+class ProcessStepAdmin(admin.ModelAdmin):
+    search_fields = ("id", "process", "step")
+    list_display = (
+        "id",
+        "process",
+        "step",
+        "state",
+        "error_message",
+        "started",
+        "finished",
+        "assignee",
+        "group",
+        "permission",
+        "status",
+    )

wbcore/contrib/workflow/admin/step.py

@@ -0,0 +1,91 @@
+from django.contrib import admin
+from wbcore.contrib.workflow.models import (
+    DecisionStep,
+    EmailStep,
+    FinishStep,
+    JoinStep,
+    ScriptStep,
+    SplitStep,
+    StartStep,
+    UserStep,
+)
+
+STEP_BASE_FIELDS = (
+    "id",
+    "name",
+    "workflow",
+    "status",
+    "code",
+    "permission",
+)
+
+
+@admin.register(StartStep)
+class StartStepAdmin(admin.ModelAdmin):
+    search_fields = ("name",)
+    list_display = STEP_BASE_FIELDS
+
+
+@admin.register(SplitStep)
+class SplitStepAdmin(admin.ModelAdmin):
+    search_fields = ("name",)
+    list_display = STEP_BASE_FIELDS
+
+
+@admin.register(UserStep)
+class UserStepAdmin(admin.ModelAdmin):
+    search_fields = ("name", "assignee", "group")
+    list_display = (
+        "assignee",
+        "group",
+        "assignee_method",
+        "notify_user",
+        "display",
+        "kwargs",
+    ) + STEP_BASE_FIELDS
+
+
+@admin.register(DecisionStep)
+class DecisionStepAdmin(admin.ModelAdmin):
+    search_fields = ("name",)
+    list_display = STEP_BASE_FIELDS
+
+
+@admin.register(JoinStep)
+class JoinStepAdmin(admin.ModelAdmin):
+    search_fields = ("name", "wait_for_all")
+    list_display = ("wait_for_all",) + STEP_BASE_FIELDS
+
+
+@admin.register(ScriptStep)
+class ScriptStepAdmin(admin.ModelAdmin):
+    search_fields = ("name",)
+    list_display = ("script",) + STEP_BASE_FIELDS
+
+
+@admin.register(EmailStep)
+class EmailStepAdmin(admin.ModelAdmin):
+    search_fields = (
+        "to",
+        "subject",
+        "name",
+    )
+    list_display = ("subject", "template") + STEP_BASE_FIELDS
+    fields = (
+        "to",
+        "subject",
+        "name",
+        "template",
+        "cc",
+        "bcc",
+        "workflow",
+        "status",
+        "code",
+        "permission",
+    )
+
+
+@admin.register(FinishStep)
+class FinishStepAdmin(admin.ModelAdmin):
+    search_fields = ("name",)
+    list_display = ("write_preserved_instance",) + STEP_BASE_FIELDS

wbcore/contrib/workflow/admin/transition.py

@@ -0,0 +1,8 @@
+from django.contrib import admin
+from wbcore.contrib.workflow.models import Transition
+
+
+@admin.register(Transition)
+class TransitionAdmin(admin.ModelAdmin):
+    search_fields = ("name",)
+    list_display = ("id", "name", "from_step", "to_step", "icon")

wbcore/contrib/workflow/admin/workflow.py

@@ -0,0 +1,8 @@
+from django.contrib import admin
+from wbcore.contrib.workflow.models import Workflow
+
+
+@admin.register(Workflow)
+class WorkflowAdmin(admin.ModelAdmin):
+    search_fields = ("name",)
+    list_display = ("id", "name", "single_instance_execution", "model", "status_field", "preserve_instance")

wbcore/contrib/workflow/apps.py

@@ -0,0 +1,26 @@
+from django.apps import AppConfig
+from django.db.models.signals import post_save
+from django.utils.module_loading import autodiscover_modules
+from wbcore.signals import add_dynamic_button
+
+
+class WorkflowConfig(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "wbcore.contrib.workflow"
+
+    def ready(self):
+        autodiscover_modules("workflows")
+        from wbcore.contrib.workflow.dispatch import check_workflow_for_instance
+        from wbcore.contrib.workflow.serializers.signals import (
+            add_workflow_next_buttons_to_instance,
+        )
+        from wbcore.contrib.workflow.sites import workflow_site
+
+        for (
+            model_class
+        ) in (
+            workflow_site.registered_model_classes_serializer_map.keys()
+        ):  # we don't use items because the map is a custom cachedictionary where
+            serializer_class = workflow_site.registered_model_classes_serializer_map[model_class]
+            post_save.connect(check_workflow_for_instance, sender=model_class, weak=False)
+            add_dynamic_button.connect(add_workflow_next_buttons_to_instance, sender=serializer_class)

wbcore/contrib/workflow/configs.py

@@ -0,0 +1,10 @@
+from rest_framework.request import Request
+from rest_framework.reverse import reverse
+from wbcore.configs.decorators import register_config
+
+
+@register_config
+def assigned_workflow_steps(request: Request) -> tuple[str, dict[str, str]]:
+    return "workflow", {
+        "endpoint": reverse("wbcore:workflow:processstep-assigned-list", request=request),
+    }