wbcore 2.2.1__py2.py3-none-any.whl

wbcore/contrib/workflow/serializers/workflow.py

@@ -0,0 +1,124 @@
+from django.db.models import Model
+from django.utils.translation import gettext as _
+from rest_framework.exceptions import ValidationError
+from rest_framework.reverse import reverse
+from wbcore import serializers as wb_serializers
+from wbcore.content_type.serializers import ContentTypeRepresentationSerializer
+from wbcore.contrib.icons import WBIcon
+from wbcore.contrib.workflow.models import Workflow
+from wbcore.contrib.workflow.sites import workflow_site
+from wbcore.enums import RequestType
+from wbcore.metadata.configs import buttons as bt
+
+
+class WorkflowModelSerializer(wb_serializers.ModelSerializer):
+    _model = ContentTypeRepresentationSerializer(source="model", allowed_types=workflow_site.model_content_types)
+    graph = wb_serializers.ImageField(required=False, read_only=True, label=_("Graph"))
+
+    @wb_serializers.register_resource()
+    def steps_inline(self, instance: Workflow, request, user) -> dict[str, str]:
+        if not self.context.get("request"):
+            return {}
+        return {
+            "steps": reverse("wbcore:workflow:step-workflow-list", args=[instance.pk], request=self.context["request"])
+        }
+
+    @wb_serializers.register_resource()
+    def transitions_inline(self, instance: Workflow, request, user) -> dict[str, str]:
+        if not self.context.get("request"):
+            return {}
+        return {
+            "transitions": reverse(
+                "wbcore:workflow:transition-workflow-list", args=[instance.pk], request=self.context["request"]
+            )
+        }
+
+    @wb_serializers.register_resource()
+    def processes_inline(self, instance: Workflow, request, user) -> dict[str, str]:
+        if not self.context.get("request"):
+            return {}
+        return {
+            "processes": reverse(
+                "wbcore:workflow:process-workflow-list", args=[instance.pk], request=self.context["request"]
+            )
+        }
+
+    @wb_serializers.register_resource()
+    def data_inline(self, instance: Workflow, request, user) -> dict[str, str]:
+        if not self.context.get("request"):
+            return {}
+        return {
+            "data": reverse("wbcore:workflow:data-workflow-list", args=[instance.pk], request=self.context["request"])
+        }
+
+    @wb_serializers.register_dynamic_button()
+    def start_workflow_buttons(self, instance: Workflow, request, user):
+        buttons = []
+        for step in instance.get_start_steps_for_workflow():
+            buttons.append(
+                bt.ActionButton(
+                    method=RequestType.PATCH,
+                    identifiers=("workflow:process",),
+                    endpoint=f"{reverse('wbcore:workflow:workflow-start', args=[instance.pk], request=request)}?step_id={step.pk}",
+                    label=_("Start {}").format(step.workflow.name),
+                    icon=WBIcon.START.icon,
+                    description_fields=_("Are you sure you want to start workflow {}?").format(step.workflow.name),
+                    title=_("Start {}").format(step.workflow.name),
+                    action_label=_("Starting {}").format(step.workflow.name),
+                )
+            )
+        return buttons
+
+    def validate(self, data: dict) -> dict:
+        if "status_field" in data:
+            status_field: str | None = data["status_field"]
+        else:
+            status_field: str | None = self.instance.status_field if self.instance else None
+        if "model" in data:
+            model: Model | None = data["model"]
+        else:
+            model: Model | None = self.instance.model if self.instance else None
+        preserve_instance: bool | None = data.get(
+            "preserve_instance", self.instance.preserve_instance if self.instance else None
+        )
+
+        if preserve_instance and not bool(model):
+            raise ValidationError({"preserve_instance": _("Can only preserve the instance when a model is attached.")})
+
+        if model and status_field:
+            if not (model_class := model.model_class()):
+                raise ValidationError({"model": _("Model not found.")})
+            if not hasattr(model_class, status_field):
+                raise ValidationError({"status_field": _("This model does not implement the specified status field.")})
+        return data
+
+    class Meta:
+        dependency_map = {
+            "status_field": ["model"],
+            "preserve_instance": ["model"],
+        }
+        model = Workflow
+        fields = (
+            "id",
+            "name",
+            "single_instance_execution",
+            "model",
+            "_model",
+            "status_field",
+            "_additional_resources",
+            "_buttons",
+            "preserve_instance",
+            "graph",
+        )
+
+
+class WorkflowRepresentationSerializer(wb_serializers.RepresentationSerializer):
+    _detail = wb_serializers.HyperlinkField(reverse_name="wbcore:workflow:workflow-detail")
+
+    class Meta:
+        model = Workflow
+        fields = (
+            "id",
+            "name",
+            "_detail",
+        )

wbcore/contrib/workflow/sites.py

@@ -0,0 +1,43 @@
+from dataclasses import dataclass, field
+from typing import Callable
+
+from django.utils.functional import cached_property
+from django.utils.module_loading import autodiscover_modules, import_string
+
+
+class CachedDict(dict):
+    def __init__(self):
+        super().__init__()
+        self._cache = {}
+
+    def __getitem__(self, key):
+        if key in self._cache:
+            return self._cache[key]
+        value = super().get(key)
+        self._cache[key] = import_string(value)
+        return self._cache[key]
+
+
+@dataclass
+class WorkflowSite:
+    registered_assignees_methods: dict[str, Callable] = field(default_factory=dict)
+    registered_assignees_names: dict[str, str] = field(default_factory=dict)
+    registered_model_classes_serializer_map: CachedDict = field(default_factory=CachedDict)
+
+    @cached_property
+    def assignees_choices(self) -> tuple[str, str]:
+        autodiscover_modules("workflows")  # we have to do that because the filter choices loads at runtime
+        return tuple(self.registered_assignees_names.items())
+
+    @cached_property
+    def assignees_methods(self) -> tuple[str, Callable]:
+        return tuple(self.registered_assignees_methods.items())
+
+    @cached_property
+    def model_content_types(self):
+        return [
+            (model._meta.app_label, model.__name__) for model in self.registered_model_classes_serializer_map.keys()
+        ]
+
+
+workflow_site = WorkflowSite()

wbcore/contrib/workflow/tests/conftest.py

@@ -0,0 +1,57 @@
+import pytest
+from django.apps import apps
+from django.db.backends.base.base import BaseDatabaseWrapper
+from django.db.models.signals import pre_migrate
+from pytest_factoryboy import register
+from wbcore.contrib.geography.tests.signals import app_pre_migration
+from wbcore.contrib.workflow.factories import (
+    ConditionFactory,
+    DataFactory,
+    DataValueFactory,
+    DecisionStepFactory,
+    EmailStepFactory,
+    FinishStepFactory,
+    JoinStepFactory,
+    ProcessFactory,
+    ProcessStepFactory,
+    RandomChildStepFactory,
+    ScriptStepFactory,
+    SplitStepFactory,
+    StartStepFactory,
+    StepFactory,
+    TransitionFactory,
+    UserStepFactory,
+    WorkflowFactory,
+)
+from wbcore.tests.conftest import *
+
+register(WorkflowFactory)
+register(EmailStepFactory)
+register(TransitionFactory)
+register(DataFactory)
+register(ProcessStepFactory)
+register(UserStepFactory)
+register(ConditionFactory)
+register(RandomChildStepFactory)
+register(FinishStepFactory)
+register(ProcessFactory)
+register(DecisionStepFactory)
+register(SplitStepFactory)
+register(JoinStepFactory)
+register(ScriptStepFactory)
+register(StepFactory)
+register(DataValueFactory)
+register(StartStepFactory)
+
+
+@pytest.fixture(autouse=True, scope="session")
+def django_test_environment(django_test_environment):
+    from django.apps import apps
+
+    get_models = apps.get_models
+
+    for m in [m for m in get_models() if not m._meta.managed]:
+        m._meta.managed = True
+
+
+pre_migrate.connect(app_pre_migration, sender=apps.get_app_config("geography"))

wbcore/contrib/workflow/tests/test_configs.py

@@ -0,0 +1,6 @@
+from wbcore.configs.registry import ConfigRegistry
+
+
+def test_workflow_config(config_registry: ConfigRegistry):
+    workflow = config_registry.get_config_dict()["workflow"]
+    assert workflow["endpoint"]

wbcore/contrib/workflow/tests/test_dispatch.py

@@ -0,0 +1,88 @@
+from unittest.mock import patch
+
+import pytest
+from wbcore.contrib.directory.factories import PersonFactory
+from wbcore.contrib.workflow.dispatch import check_workflow_for_instance
+from wbcore.contrib.workflow.factories import UserStepFactory
+from wbcore.contrib.workflow.models import Process, ProcessStep
+
+
+@pytest.mark.django_db
+class TestDispatch:
+    @patch("wbcore.contrib.workflow.models.step.Step.set_failed")
+    def test_check_workflow_for_instance_fail_process_steps(
+        self, mock_failed, process_step_factory, random_child_step_factory
+    ):
+        instance = PersonFactory()
+        step = random_child_step_factory(exclude_factories=[UserStepFactory])
+        process_step1 = process_step_factory(
+            step=step,
+            state=ProcessStep.StepState.WAITING,
+            process__state=Process.ProcessState.ACTIVE,
+            process__instance=instance,
+        )
+        process_step2 = process_step_factory(
+            step=step,
+            state=ProcessStep.StepState.ACTIVE,
+            process__state=Process.ProcessState.ACTIVE,
+            process__instance=instance,
+        )
+        process_step_factory(
+            step=step,
+            state=ProcessStep.StepState.ACTIVE,
+            process__state=Process.ProcessState.ACTIVE,
+            process__instance=instance,
+            status=instance.first_name,
+        )
+        process_step_factory(
+            step=step,
+            state=ProcessStep.StepState.CANCELED,
+            process__state=Process.ProcessState.ACTIVE,
+            process__instance=instance,
+        )
+        process_step_factory(
+            step=step,
+            state=ProcessStep.StepState.FAILED,
+            process__state=Process.ProcessState.ACTIVE,
+            process__instance=instance,
+        )
+        process_step_factory(
+            step=step,
+            state=ProcessStep.StepState.FINISHED,
+            process__state=Process.ProcessState.ACTIVE,
+            process__instance=instance,
+        )
+        process_step_factory(
+            step=step,
+            state=ProcessStep.StepState.ACTIVE,
+            process__state=Process.ProcessState.FAILED,
+            process__instance=instance,
+        )
+        process_step_factory(
+            step=step,
+            state=ProcessStep.StepState.ACTIVE,
+            process__state=Process.ProcessState.FINISHED,
+            process__instance=instance,
+        )
+        process_step_factory(
+            step=step,
+            state=ProcessStep.StepState.ACTIVE,
+            process__state=Process.ProcessState.ACTIVE,
+            process__instance=PersonFactory(),
+        )
+        check_workflow_for_instance(instance.__class__, instance, False)
+        assert len(mock_failed.call_args_list) == 2
+        assert str(mock_failed.call_args_list[0][0][0].pk) == process_step1.pk
+        assert str(mock_failed.call_args_list[1][0][0].pk) == process_step2.pk
+
+    @patch("wbcore.contrib.workflow.models.workflow.Workflow.start_workflow")
+    @patch("wbcore.contrib.workflow.models.workflow.Workflow.get_start_steps_for_instance")
+    def test_check_workflow_for_instance_start_workflow(self, mock_start_steps, mock_start, start_step_factory):
+        instance = PersonFactory()
+        start_step1 = start_step_factory()
+        start_step2 = start_step_factory()
+        start_step_factory()
+        mock_start_steps.return_value = [start_step1, start_step2]
+        check_workflow_for_instance(instance.__class__, instance, False)
+        assert mock_start_steps.call_args.args == (instance,)
+        assert mock_start.call_args_list == [((start_step1, instance),), ((start_step2, instance),)]

wbcore/contrib/workflow/tests/test_displays.py

@@ -0,0 +1,119 @@
+import pytest
+from rest_framework.test import APIRequestFactory
+from wbcore.contrib.color.enums import WBColor
+from wbcore.contrib.workflow.models import ProcessStep
+from wbcore.contrib.workflow.viewsets.display.process import (
+    get_state_formatting,
+    get_state_legend,
+)
+
+
+@pytest.mark.django_db
+class TestProcessStep:
+    api_factory = APIRequestFactory()
+
+    def test_get_state_legend(self):
+        color_map = [
+            (ProcessStep.StepState.FAILED, WBColor.GREEN_LIGHT.value),
+            (ProcessStep.StepState.CANCELED, WBColor.BLUE_LIGHT.value),
+        ]
+        assert set((y.icon, y.label, y.value) for y in get_state_legend(color_map)[0].items) == {
+            (WBColor.GREEN_LIGHT.value, ProcessStep.StepState.FAILED.label, ProcessStep.StepState.FAILED.value),
+            (WBColor.BLUE_LIGHT.value, ProcessStep.StepState.CANCELED.label, ProcessStep.StepState.CANCELED.value),
+        }
+
+    def test_get_state_formatting(self):
+        color_map = [
+            (ProcessStep.StepState.WAITING, WBColor.GREY.value),
+            (ProcessStep.StepState.ACTIVE, WBColor.YELLOW_DARK.value),
+        ]
+        assert set(
+            (y.style["backgroundColor"], y.condition[1]) for y in get_state_formatting(color_map)[0].formatting_rules
+        ) == {
+            (WBColor.GREY.value, ProcessStep.StepState.WAITING.value),
+            (WBColor.YELLOW_DARK.value, ProcessStep.StepState.ACTIVE.value),
+        }
+
+    # @patch("wbcore.contrib.workflow.viewsets.display.process.split_list_into_grid_template_area_sublists")
+    # def test_process_step_display_instance_injection(
+    #     self, mock_split, data_factory, user_step_factory, process_step_factory
+    # ):
+    #     request = self.api_factory.get("")
+    #     request.user = get_or_create_superuser()
+    #     request.query_params = {}
+    #     step = user_step_factory()
+    #     process_step = process_step_factory(step=step)
+    #     data_factory(workflow=process_step.step.workflow)
+    #     mvs = ProcessStepModelViewSet(request=request, kwargs={"pk": process_step.pk})
+    #     display = mvs.display_config_class(mvs, request).get_instance_display()
+    #     assert display.pages[0].layouts["default"].grid_template_areas == step.display.grid_template_areas
+    #     assert not mock_split.called
+
+    # @patch("wbcore.contrib.workflow.viewsets.display.process.split_list_into_grid_template_area_sublists")
+    # def test_process_step_display_no_userstep(self, mock_split, random_child_step_factory, process_step_factory):
+    #     request = self.api_factory.get("")
+    #     request.user = get_or_create_superuser()
+    #     request.query_params = {}
+    #     step = random_child_step_factory(exclude_factories=[UserStepFactory])
+    #     process_step = process_step_factory(step=step)
+    #     mvs = ProcessStepModelViewSet(request=request, kwargs={"pk": process_step.pk})
+    #     display = mvs.display_config_class(mvs, request).get_instance_display()
+    #     display_fields = set(itertools.chain.from_iterable(display.pages[0].layouts["default"].grid_template_areas))
+    #     person_fields = set(PersonModelSerializer.Meta.fields)
+    #     assert not mock_split.called
+    #     assert display_fields.intersection(person_fields) == {"id"}
+
+    # @patch("wbcore.contrib.workflow.viewsets.display.process.split_list_into_grid_template_area_sublists")
+    # def test_process_step_display_no_display(self, mock_split, user_step_factory, process_step_factory):
+    #     request = self.api_factory.get("")
+    #     request.user = get_or_create_superuser()
+    #     request.query_params = {}
+    #     step = user_step_factory(display=None)
+    #     process_step = process_step_factory(step=step)
+    #     mvs = ProcessStepModelViewSet(request=request, kwargs={"pk": process_step.pk})
+    #     display = mvs.display_config_class(mvs, request).get_instance_display()
+    #     display_fields = set(itertools.chain.from_iterable(display.pages[0].layouts["default"].grid_template_areas))
+    #     person_fields = set(PersonModelSerializer.Meta.fields)
+    #     assert not mock_split.called
+    #     assert display_fields.intersection(person_fields) == {"id"}
+
+    # @patch("wbcore.contrib.workflow.viewsets.display.process.split_list_into_grid_template_area_sublists")
+    # def test_process_step_display_data_injection(
+    #     self, mock_split, data_factory, user_step_factory, process_step_factory
+    # ):
+    #     request = self.api_factory.get("")
+    #     request.user = get_or_create_superuser()
+    #     request.query_params = {}
+    #     step = user_step_factory(display=None)
+    #     process_step = process_step_factory(step=step)
+    #     data1 = data_factory(workflow=process_step.process.workflow)
+    #     data2 = data_factory(workflow=process_step.process.workflow)
+    #     data_factory()
+    #     data_sublist = ["a", "b", "c"]
+    #     mock_split.return_value = data_sublist
+    #     mvs = ProcessStepModelViewSet(request=request, kwargs={"pk": process_step.pk})
+    #     display = mvs.display_config_class(mvs, request).get_instance_display()
+    #     display_fields = set(itertools.chain.from_iterable(display.pages[0].layouts["default"].grid_template_areas))
+    #     person_fields = set(PersonModelSerializer.Meta.fields)
+    #     assert display_fields.intersection(person_fields) == {"id"}
+    #     assert mock_split.call_args.args[0] == [f"data__{str(data1.pk)}", f"data__{str(data2.pk)}"]
+    #     for key in data_sublist:
+    #         assert key in display_fields
+
+    # @patch("wbcore.contrib.workflow.viewsets.display.process.split_list_into_grid_template_area_sublists")
+    # def test_process_step_display_no_display_no_data(
+    #     self, mock_split, data_factory, user_step_factory, process_step_factory
+    # ):
+    #     request = self.api_factory.get("")
+    #     request.user = get_or_create_superuser()
+    #     request.query_params = {}
+    #     step = user_step_factory(display=None)
+    #     process_step = process_step_factory(step=step)
+    #     data_factory()
+    #     data_factory()
+    #     mvs = ProcessStepModelViewSet(request=request, kwargs={"pk": process_step.pk})
+    #     display = mvs.display_config_class(mvs, request).get_instance_display()
+    #     display_fields = set(itertools.chain.from_iterable(display.pages[0].layouts["default"].grid_template_areas))
+    #     person_fields = set(PersonModelSerializer.Meta.fields)
+    #     assert display_fields.intersection(person_fields) == {"id"}
+    #     assert not mock_split.called

wbcore/contrib/workflow/tests/test_filters.py

@@ -0,0 +1,86 @@
+import pytest
+from django.contrib.contenttypes.models import ContentType
+from rest_framework.test import APIRequestFactory
+from wbcore.contrib.workflow.models import Step
+from wbcore.contrib.workflow.viewsets import (
+    EmailStepModelViewSet,
+    StepModelViewSet,
+    TransitionModelViewSet,
+    WorkflowModelViewSet,
+)
+from wbcore.test.utils import get_or_create_superuser
+
+
+@pytest.mark.django_db
+class TestWorkflow:
+    api_factory = APIRequestFactory()
+
+    def test_filter_attached_model(self, workflow_factory):
+        workflow_factory()
+        workflow_factory(model=ContentType.objects.first())
+        mvs = WorkflowModelViewSet()
+        request = self.api_factory.get("")
+        request.user = get_or_create_superuser()
+        qs = mvs.get_queryset()
+        assert mvs.filterset_class(request=request).filter_attached_model(qs, "", None) == qs
+        assert mvs.filterset_class(request=request).filter_attached_model(qs, "", "person").count() == 1
+        assert not mvs.filterset_class(request=request).filter_attached_model(qs, "", "company").exists()
+
+    def test_filter_by_data(self, workflow_factory, data_factory):
+        workflow_factory()
+        data = data_factory()
+        mvs = WorkflowModelViewSet()
+        request = self.api_factory.get("")
+        request.user = get_or_create_superuser()
+        qs = mvs.get_queryset()
+        assert mvs.filterset_class(request=request).filter_by_data(qs, "", None) == qs
+        assert mvs.filterset_class(request=request).filter_by_data(qs, "", data).count() == 1
+        assert mvs.filterset_class(request=request).filter_by_data(qs, "", data).first() == data.workflow
+
+
+@pytest.mark.django_db
+class TestStep:
+    api_factory = APIRequestFactory()
+
+    def test_filter_by_transition(self, transition_factory, random_child_step_factory):
+        transition = transition_factory()
+        random_child_step_factory()
+        mvs = StepModelViewSet(kwargs={})
+        request = self.api_factory.get("")
+        request.user = get_or_create_superuser()
+        qs = mvs.get_queryset()
+        assert mvs.get_filterset_class(request=request)().filter_by_transition(qs, "", None) == qs
+        assert set(mvs.get_filterset_class(request=request)().filter_by_transition(qs, "", transition)) == set(
+            Step.objects.filter(id__in=[transition.from_step.pk, transition.to_step.pk])
+        )
+
+    def test_email_filter_template_name(self, email_step_factory):
+        step = email_step_factory()
+        email_step_factory()
+        mvs = EmailStepModelViewSet(kwargs={})
+        request = self.api_factory.get("")
+        request.user = get_or_create_superuser()
+        qs = mvs.get_queryset()
+        assert mvs.get_filterset_class(request=request)().filter_template_name(qs, "", None) == qs
+        assert mvs.get_filterset_class(request=request)().filter_template_name(qs, "", step.template.name).count() == 1
+        assert (
+            mvs.get_filterset_class(request=request)().filter_template_name(qs, "", step.template.name).first() == step
+        )
+
+
+@pytest.mark.django_db
+class TestTransition:
+    api_factory = APIRequestFactory()
+
+    def test_filter_by_condition(self, condition_factory, transition_factory):
+        transition_factory()
+        condition = condition_factory()
+        mvs = TransitionModelViewSet(kwargs={})
+        request = self.api_factory.get("")
+        request.user = get_or_create_superuser()
+        qs = mvs.get_queryset()
+        assert mvs.filterset_class(request=request).filter_by_condition(qs, "", None) == qs
+        assert mvs.filterset_class(request=request).filter_by_condition(qs, "", condition).count() == 1
+        assert (
+            mvs.filterset_class(request=request).filter_by_condition(qs, "", condition).first() == condition.transition
+        )