wbcore 2.2.1__py2.py3-none-any.whl

wbcore/contrib/workflow/tests/test_workflow_assignees.py

@@ -0,0 +1,225 @@
+from unittest.mock import patch
+
+import pytest
+from wbcore.contrib.authentication.factories import GroupFactory, UserFactory
+from wbcore.contrib.directory.factories import ClientFactory
+from wbcore.contrib.workflow.models import ProcessStep, Step
+from wbcore.contrib.workflow.workflows import (
+    manager_of_instance_assignee,
+    random_group_member,
+    weighted_random,
+)
+
+
+@pytest.mark.django_db
+class TestWorkflowAssignees:
+    def test_manager_of_instance_assignee_person(self, process_step_factory):
+        kwargs = {"assignee_field": "profile", "assignee_type": "entry"}
+        attached_instance = UserFactory()
+        process_step = process_step_factory(process__instance=attached_instance)
+        manager_list = ClientFactory.create_batch(3, clients=[attached_instance.profile])
+        UserFactory(profile=manager_list[1], is_active=False)
+        UserFactory(profile=manager_list[2])
+        assert manager_of_instance_assignee(process_step, **kwargs) == manager_list[2].user_account
+
+    def test_manager_of_instance_assignee_no_kwargs(self, process_step_factory):
+        process_step = process_step_factory()
+        assert not manager_of_instance_assignee(process_step)
+        assert process_step.state == ProcessStep.StepState.FAILED
+
+    def test_manager_of_instance_assignee_no_assignee_field(self, process_step_factory):
+        kwargs = {"test": "profile", "assignee_type": "entry"}
+        process_step = process_step_factory()
+        assert not manager_of_instance_assignee(process_step, **kwargs)
+        assert process_step.state == ProcessStep.StepState.FAILED
+
+    def test_manager_of_instance_assignee_no_assignee_type(self, process_step_factory):
+        kwargs = {"assignee_field": "profile", "test": "entry"}
+        process_step = process_step_factory()
+        assert not manager_of_instance_assignee(process_step, **kwargs)
+        assert process_step.state == ProcessStep.StepState.FAILED
+
+    def test_manager_of_instance_assignee_wrong_assignee_field(self, process_step_factory):
+        kwargs = {"assignee_field": "profile", "assignee_type": "entry"}
+        process_step = process_step_factory()
+        assert not manager_of_instance_assignee(process_step, **kwargs)
+        assert process_step.state == ProcessStep.StepState.FAILED
+
+    def test_manager_of_instance_assignee_wrong_assignee_type(self, process_step_factory):
+        kwargs = {"assignee_field": "profile", "assignee_type": "test"}
+        attached_instance = UserFactory()
+        process_step = process_step_factory(process__instance=attached_instance)
+        assert not manager_of_instance_assignee(process_step, **kwargs)
+        assert process_step.state == ProcessStep.StepState.FAILED
+
+    @pytest.mark.parametrize(
+        "bad_states", [ProcessStep.StepState.FAILED, ProcessStep.StepState.CANCELED, ProcessStep.StepState.WAITING]
+    )
+    @pytest.mark.parametrize(
+        "bad_types",
+        [
+            Step.StepType.DECISIONSTEP,
+            Step.StepType.EMAILSTEP,
+            Step.StepType.FINISHSTEP,
+            Step.StepType.JOINSTEP,
+            Step.StepType.SPLITSTEP,
+            Step.StepType.SCRIPTSTEP,
+        ],
+    )
+    @patch("wbcore.contrib.workflow.workflows.assignees.choices")
+    def test_weighted_random(self, mock_choices, user_step_factory, process_step_factory, bad_states, bad_types):
+        group = GroupFactory()
+        process_step = process_step_factory(group=group)
+        assignee1 = UserFactory(groups=[group])
+        assignee2 = UserFactory(groups=[group])
+        user_step = user_step_factory()
+        process_step_factory(
+            state=ProcessStep.StepState.ACTIVE,
+            process=process_step.process,
+            group=process_step.group,
+            step=user_step,
+            assignee=assignee1,
+        )
+        process_step_factory(
+            state=ProcessStep.StepState.FINISHED,
+            process=process_step.process,
+            group=process_step.group,
+            step=user_step,
+            assignee=assignee2,
+        )
+        process_step_factory(
+            state=ProcessStep.StepState.FINISHED,
+            process=process_step.process,
+            group=process_step.group,
+            step=user_step,
+            assignee=assignee2,
+        )
+        process_step_factory(
+            state=bad_states,
+            process=process_step.process,
+            group=process_step.group,
+            step=user_step,
+            assignee=assignee2,
+        )
+        process_step_factory(
+            state=ProcessStep.StepState.ACTIVE,
+            group=process_step.group,
+            step=user_step,
+            assignee=assignee2,
+        )
+        process_step_factory(
+            state=ProcessStep.StepState.ACTIVE,
+            process=process_step.process,
+            step=user_step,
+            assignee=assignee2,
+        )
+        process_step_factory(
+            state=ProcessStep.StepState.FINISHED,
+            process=process_step.process,
+            group=process_step.group,
+            step__step_type=bad_types,
+            assignee=assignee2,
+        )
+        process_step_factory(
+            state=ProcessStep.StepState.FINISHED,
+            process=process_step.process,
+            group=process_step.group,
+            step=user_step,
+        )
+        assert weighted_random(process_step)
+        assert len(mock_choices.call_args.args) == 1
+        assert len(mock_choices.call_args.kwargs) == 1
+        assignees_with_weights = set(zip(mock_choices.call_args.args[0], mock_choices.call_args.kwargs["weights"]))
+        assert assignees_with_weights == {(assignee1, 2 / 3), (assignee2, 1 / 3)}
+
+    @pytest.mark.parametrize(
+        "bad_states", [ProcessStep.StepState.FAILED, ProcessStep.StepState.CANCELED, ProcessStep.StepState.WAITING]
+    )
+    @pytest.mark.parametrize(
+        "bad_types",
+        [
+            Step.StepType.DECISIONSTEP,
+            Step.StepType.EMAILSTEP,
+            Step.StepType.FINISHSTEP,
+            Step.StepType.JOINSTEP,
+            Step.StepType.SPLITSTEP,
+            Step.StepType.SCRIPTSTEP,
+        ],
+    )
+    @patch("wbcore.contrib.workflow.workflows.assignees.choices")
+    def test_weighted_random_no_past_ocurrences(
+        self, mock_choices, user_step_factory, process_step_factory, bad_states, bad_types
+    ):
+        group = GroupFactory()
+        process_step = process_step_factory(group=group)
+        assignee1 = UserFactory(groups=[group])
+        assignee2 = UserFactory(groups=[group])
+        user_step = user_step_factory()
+
+        process_step_factory(
+            state=bad_states,
+            process=process_step.process,
+            group=process_step.group,
+            step=user_step,
+            assignee=assignee2,
+        )
+        process_step_factory(
+            state=ProcessStep.StepState.ACTIVE,
+            group=process_step.group,
+            step=user_step,
+            assignee=assignee2,
+        )
+        process_step_factory(
+            state=ProcessStep.StepState.ACTIVE,
+            process=process_step.process,
+            step=user_step,
+            assignee=assignee2,
+        )
+        process_step_factory(
+            state=ProcessStep.StepState.FINISHED,
+            process=process_step.process,
+            group=process_step.group,
+            step__step_type=bad_types,
+            assignee=assignee2,
+        )
+        process_step_factory(
+            state=ProcessStep.StepState.FINISHED,
+            process=process_step.process,
+            group=process_step.group,
+            step=user_step,
+        )
+        assert weighted_random(process_step)
+        assert len(mock_choices.call_args.args) == 1
+        assert set(mock_choices.call_args.args[0]) == {assignee1, assignee2}
+        assert not mock_choices.call_args.kwargs
+
+    @patch("wbcore.contrib.workflow.workflows.assignees.choices")
+    def test_weighted_random_no_group(self, mock_choices, process_step_factory):
+        process_step = process_step_factory()
+        assert not weighted_random(process_step)
+        assert not mock_choices.called
+        assert process_step.state == ProcessStep.StepState.FAILED
+
+    @patch("wbcore.contrib.workflow.workflows.assignees.choices")
+    def test_weighted_random_no_group_members(self, mock_choices, process_step_factory):
+        process_step = process_step_factory(group=GroupFactory())
+        assert not weighted_random(process_step)
+        assert not mock_choices.called
+        assert process_step.state == ProcessStep.StepState.FAILED
+
+    def test_random_group_member(self, process_step_factory):
+        group = GroupFactory()
+        process_step = process_step_factory(group=group)
+        UserFactory(groups=[group])
+        UserFactory(groups=[group])
+        assert random_group_member(process_step)
+
+    def test_random_group_member_no_group(self, process_step_factory):
+        process_step = process_step_factory()
+        assert not random_group_member(process_step)
+        assert process_step.state == ProcessStep.StepState.FAILED
+
+    def test_random_group_member_no_group_members(self, process_step_factory):
+        process_step = process_step_factory(group=GroupFactory())
+        assert not random_group_member(process_step)
+        assert process_step.state == ProcessStep.StepState.FAILED

wbcore/contrib/workflow/tests/tests.py

@@ -0,0 +1,24 @@
+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.workflow")
+            and x.__name__
+            not in [
+                "WorkflowModelViewSet",
+                "EmailStepModelViewSet",
+                "ProcessStepModelViewSet",
+                "AssignedProcessStepModelViewSet",
+            ],
+            value,
+        )
+    )
+
+
+@pytest.mark.django_db
+@GenerateTest(config)
+class TestProject:
+    pass

wbcore/contrib/workflow/urls.py

@@ -0,0 +1,66 @@
+from django.urls import include, path
+from wbcore.routers import WBCoreRouter
+
+from . import viewsets
+
+router = WBCoreRouter()
+
+router.register(r"workflow", viewsets.WorkflowModelViewSet, basename="workflow")
+router.register(r"workflowrepresentation", viewsets.WorkflowModelViewSet, basename="workflowrepresentation")
+router.register(r"step", viewsets.StepModelViewSet, basename="step")
+router.register(r"steprepresentation", viewsets.StepModelViewSet, basename="steprepresentation")
+router.register(r"transition", viewsets.TransitionModelViewSet, basename="transition")
+router.register(r"transitionrepresentation", viewsets.TransitionModelViewSet, basename="transitionrepresentation")
+router.register(r"condition", viewsets.ConditionModelViewSet, basename="condition")
+router.register(r"conditionrepresentation", viewsets.ConditionModelViewSet, basename="conditionrepresentation")
+router.register(r"userstep", viewsets.UserStepModelViewSet, basename="userstep")
+router.register(r"usersteprepresentation", viewsets.UserStepModelViewSet, basename="usersteprepresentation")
+router.register(r"process", viewsets.ProcessModelViewSet, basename="process")
+router.register(r"processrepresentation", viewsets.ProcessModelViewSet, basename="processrepresentation")
+router.register(r"processstep", viewsets.ProcessStepModelViewSet, basename="processstep")
+router.register(r"processsteprepresentation", viewsets.ProcessStepModelViewSet, basename="processsteprepresentation")
+router.register(r"processstep-assigned", viewsets.AssignedProcessStepModelViewSet, basename="processstep-assigned")
+router.register(r"display", viewsets.DisplayModelViewSet, basename="display")
+router.register(r"displayrepresentation", viewsets.DisplayModelViewSet, basename="displayrepresentation")
+router.register(r"decisionstep", viewsets.DecisionStepModelViewSet, basename="decisionstep")
+router.register(
+    r"decisionsteprepresentation", viewsets.DecisionStepModelViewSet, basename="decisionsteprepresentation"
+)
+router.register(r"startstep", viewsets.StartStepModelViewSet, basename="startstep")
+router.register(r"startsteprepresentation", viewsets.StartStepModelViewSet, basename="startsteprepresentation")
+router.register(r"splitstep", viewsets.SplitStepModelViewSet, basename="splitstep")
+router.register(r"splitsteprepresentation", viewsets.SplitStepModelViewSet, basename="splitsteprepresentation")
+router.register(r"joinstep", viewsets.JoinStepModelViewSet, basename="joinstep")
+router.register(r"joinsteprepresentation", viewsets.JoinStepModelViewSet, basename="joinsteprepresentation")
+router.register(r"scriptstep", viewsets.ScriptStepModelViewSet, basename="scriptstep")
+router.register(r"scriptsteprepresentation", viewsets.ScriptStepModelViewSet, basename="scriptsteprepresentation")
+router.register(r"emailstep", viewsets.EmailStepModelViewSet, basename="emailstep")
+router.register(r"emailsteprepresentation", viewsets.EmailStepModelViewSet, basename="emailsteprepresentation")
+router.register(r"finishstep", viewsets.FinishStepModelViewSet, basename="finishstep")
+router.register(r"finishsteprepresentation", viewsets.FinishStepModelViewSet, basename="finishsteprepresentation")
+router.register(r"data", viewsets.DataModelViewSet, basename="data")
+router.register(r"datarepresentation", viewsets.DataModelViewSet, basename="datarepresentation")
+
+step_router = WBCoreRouter()
+step_router.register(r"transition-step", viewsets.TransitionModelViewSet, basename="transition-step")
+step_router.register(r"processstep-step", viewsets.ProcessStepModelViewSet, basename="processstep-step")
+
+workflow_router = WBCoreRouter()
+workflow_router.register(r"transition-workflow", viewsets.TransitionModelViewSet, basename="transition-workflow")
+workflow_router.register(r"step-workflow", viewsets.StepModelViewSet, basename="step-workflow")
+workflow_router.register(r"process-workflow", viewsets.ProcessModelViewSet, basename="process-workflow")
+workflow_router.register(r"data-workflow", viewsets.DataModelViewSet, basename="data-workflow")
+
+transition_router = WBCoreRouter()
+transition_router.register(r"condition-transition", viewsets.ConditionModelViewSet, basename="condition-transition")
+
+process_router = WBCoreRouter()
+process_router.register(r"processstep-process", viewsets.ProcessStepModelViewSet, basename="processstep-process")
+
+urlpatterns = [
+    path("", include(router.urls)),
+    path("step/<int:step_id>/", include(step_router.urls)),
+    path("workflow/<int:workflow_id>/", include(workflow_router.urls)),
+    path("transition/<int:transition_id>/", include(transition_router.urls)),
+    path("process/<str:process_id>/", include(process_router.urls)),
+]

wbcore/contrib/workflow/utils.py

@@ -0,0 +1,13 @@
+from wbcore.contrib.workflow.sites import workflow_site
+
+
+def get_model_serializer_class_for_instance(instance):
+    return workflow_site.registered_model_classes_serializer_map[instance.__class__]
+
+
+def get_model_serializer_class_for_class(instance_class):
+    return workflow_site.registered_model_classes_serializer_map[instance_class]
+
+
+def model_is_registered_for_workflow(model) -> bool:
+    return model in workflow_site.registered_model_classes_serializer_map.keys()

wbcore/contrib/workflow/viewsets/__init__.py

@@ -0,0 +1,17 @@
+from .condition import ConditionModelViewSet
+from .data import DataModelViewSet
+from .process import ProcessModelViewSet, ProcessStepModelViewSet, AssignedProcessStepModelViewSet
+from .step import (
+    DecisionStepModelViewSet,
+    DisplayModelViewSet,
+    EmailStepModelViewSet,
+    FinishStepModelViewSet,
+    JoinStepModelViewSet,
+    ScriptStepModelViewSet,
+    SplitStepModelViewSet,
+    StepModelViewSet,
+    UserStepModelViewSet,
+    StartStepModelViewSet,
+)
+from .transition import TransitionModelViewSet
+from .workflow import WorkflowModelViewSet

wbcore/contrib/workflow/viewsets/buttons/__init__.py

@@ -0,0 +1 @@
+from .step import StepButtonConfig

wbcore/contrib/workflow/viewsets/buttons/step.py

@@ -0,0 +1,67 @@
+from django.utils.translation import gettext as _
+from rest_framework.reverse import reverse
+from wbcore.contrib.icons import WBIcon
+from wbcore.metadata.configs import buttons as bt
+from wbcore.metadata.configs.buttons import ButtonViewConfig
+
+
+class StepButtonConfig(ButtonViewConfig):
+    def get_custom_buttons(self) -> set:
+        if workflow_id := self.view.kwargs.get("workflow_id"):
+            return {
+                bt.DropDownButton(
+                    label=_("New Step"),
+                    icon=WBIcon.UNFOLD.icon,
+                    buttons=(
+                        bt.WidgetButton(
+                            endpoint=f"{reverse('wbcore:workflow:startstep-list', args=[], request=self.request)}?workflow={workflow_id}",
+                            label=_("New Start Step"),
+                            icon=WBIcon.START.icon,
+                            new_mode=True,
+                        ),
+                        bt.WidgetButton(
+                            endpoint=f"{reverse('wbcore:workflow:userstep-list', args=[], request=self.request)}?workflow={workflow_id}",
+                            label=_("New User Step"),
+                            icon=WBIcon.PERSON.icon,
+                            new_mode=True,
+                        ),
+                        bt.WidgetButton(
+                            endpoint=f"{reverse('wbcore:workflow:decisionstep-list', args=[], request=self.request)}?workflow={workflow_id}",
+                            label=_("New Decision Step"),
+                            icon=WBIcon.DECISION_STEP.icon,
+                            new_mode=True,
+                        ),
+                        bt.WidgetButton(
+                            endpoint=f"{reverse('wbcore:workflow:splitstep-list', args=[], request=self.request)}?workflow={workflow_id}",
+                            label=_("New Split Step"),
+                            icon=WBIcon.SPLIT.icon,
+                            new_mode=True,
+                        ),
+                        bt.WidgetButton(
+                            endpoint=f"{reverse('wbcore:workflow:joinstep-list', args=[], request=self.request)}?workflow={workflow_id}",
+                            label=_("New Join Step"),
+                            icon=WBIcon.JOIN_STEP.icon,
+                            new_mode=True,
+                        ),
+                        bt.WidgetButton(
+                            endpoint=f"{reverse('wbcore:workflow:scriptstep-list', args=[], request=self.request)}?workflow={workflow_id}",
+                            label=_("New Script Step"),
+                            icon=WBIcon.SCRIPT.icon,
+                            new_mode=True,
+                        ),
+                        bt.WidgetButton(
+                            endpoint=f"{reverse('wbcore:workflow:emailstep-list', args=[], request=self.request)}?workflow={workflow_id}",
+                            label=_("New Email Step"),
+                            icon=WBIcon.MAIL.icon,
+                            new_mode=True,
+                        ),
+                        bt.WidgetButton(
+                            endpoint=f"{reverse('wbcore:workflow:finishstep-list', args=[], request=self.request)}?workflow={workflow_id}",
+                            label=_("New Finish Step"),
+                            icon=WBIcon.END.icon,
+                            new_mode=True,
+                        ),
+                    ),
+                )
+            }
+        return set()

wbcore/contrib/workflow/viewsets/condition.py

@@ -0,0 +1,32 @@
+from wbcore import viewsets
+from wbcore.contrib.workflow.filters import ConditionFilter
+from wbcore.contrib.workflow.models import Condition
+from wbcore.contrib.workflow.serializers import ConditionModelSerializer
+from wbcore.contrib.workflow.viewsets.display import ConditionDisplayConfig
+from wbcore.contrib.workflow.viewsets.endpoints import ConditionEndpointConfig
+from wbcore.contrib.workflow.viewsets.titles import ConditionTitleConfig
+
+
+class ConditionModelViewSet(viewsets.ModelViewSet):
+    LIST_DOCUMENTATION = "workflow/markdown/documentation/condition.md"
+    queryset = Condition.objects.all()
+    serializer_class = ConditionModelSerializer
+    display_config_class = ConditionDisplayConfig
+    title_config_class = ConditionTitleConfig
+    search_fields = ("attribute_name", "expected_value")
+    ordering = ("transition", "attribute_name", "operator", "negate_operator", "expected_value")
+    filterset_class = ConditionFilter
+    endpoint_config_class = ConditionEndpointConfig
+    ordering_fields = (
+        "attribute_name",
+        "transition__name",
+        "operator",
+        "expected_value",
+        "negate_operator",
+    )
+
+    def get_queryset(self):
+        queryset = super().get_queryset().select_related("transition")
+        if transition_id := self.kwargs.get("transition_id"):
+            return queryset.filter(transition=transition_id)
+        return queryset

wbcore/contrib/workflow/viewsets/data.py

@@ -0,0 +1,33 @@
+from wbcore import viewsets
+from wbcore.contrib.workflow.filters import DataFilter
+from wbcore.contrib.workflow.models import Data
+from wbcore.contrib.workflow.serializers import DataModelSerializer
+from wbcore.contrib.workflow.viewsets.display import DataDisplayConfig
+from wbcore.contrib.workflow.viewsets.endpoints import DataEndpointConfig
+from wbcore.contrib.workflow.viewsets.titles import DataTitleConfig
+
+
+class DataModelViewSet(viewsets.ModelViewSet):
+    LIST_DOCUMENTATION = "workflow/markdown/documentation/data.md"
+    queryset = Data.objects.all()
+    serializer_class = DataModelSerializer
+    display_config_class = DataDisplayConfig
+    title_config_class = DataTitleConfig
+    search_fields = ("label",)
+    ordering = ("workflow__name", "data_type", "label")
+    filterset_class = DataFilter
+    endpoint_config_class = DataEndpointConfig
+    ordering_fields = (
+        "workflow__name",
+        "data_type",
+        "label",
+        "help_text",
+        "default",
+        "required",
+    )
+
+    def get_queryset(self):
+        queryset = super().get_queryset().select_related("workflow")
+        if workflow_id := self.kwargs.get("workflow_id"):
+            return queryset.filter(workflow=workflow_id)
+        return queryset

wbcore/contrib/workflow/viewsets/display/__init__.py

@@ -0,0 +1,15 @@
+from .condition import ConditionDisplayConfig
+from .data import DataDisplayConfig
+from .process import ProcessDisplayConfig, ProcessStepDisplayConfig, AssignedProcessStepDisplayConfig
+from .step import (
+    BaseStepDisplayConfig,
+    EmailStepDisplayConfig,
+    FinishDisplayConfig,
+    JoinStepDisplayConfig,
+    ScriptStepDisplayConfig,
+    StepDisplayConfig,
+    UserStepDisplayConfig,
+    StartStepDisplay,
+)
+from .transition import TransitionDisplayConfig
+from .workflow import WorkflowDisplayConfig

wbcore/contrib/workflow/viewsets/display/condition.py

@@ -0,0 +1,50 @@
+from typing import Optional
+
+from django.utils.translation import gettext as _
+from wbcore.metadata.configs import display as dp
+from wbcore.metadata.configs.display import DisplayViewConfig
+from wbcore.metadata.configs.display.instance_display import (
+    Display,
+    Layout,
+    Page,
+    Style,
+)
+from wbcore.metadata.configs.display.instance_display.operators import default
+
+
+class ConditionDisplayConfig(DisplayViewConfig):
+    def get_list_display(self) -> Optional[dp.ListDisplay]:
+        fields = [
+            dp.Field(key="transition", label=_("Transition")),
+            dp.Field(key="attribute_name", label=_("Attribute Name")),
+            dp.Field(key="operator", label=_("Operator")),
+            dp.Field(key="negate_operator", label=_("Negate Operator")),
+            dp.Field(key="expected_value", label=_("Expected Value")),
+        ]
+
+        if "transition_id" in self.view.kwargs:
+            fields.pop(0)
+
+        return dp.ListDisplay(
+            fields=fields,
+        )
+
+    def get_instance_display(self) -> Display:
+        return Display(
+            pages=[
+                Page(
+                    layouts={
+                        default(): Layout(
+                            grid_template_areas=[
+                                ["transition", "attribute_name"],
+                                ["operator", "negate_operator"],
+                                ["expected_value", "."],
+                            ],
+                            grid_auto_columns="minmax(min-content, 1fr)",
+                            grid_auto_rows=Style.MIN_CONTENT,
+                            column_gap=Style.rem(5),
+                        ),
+                    },
+                ),
+            ]
+        )

wbcore/contrib/workflow/viewsets/display/data.py

@@ -0,0 +1,50 @@
+from typing import Optional
+
+from django.utils.translation import gettext as _
+from wbcore.metadata.configs import display as dp
+from wbcore.metadata.configs.display import DisplayViewConfig
+from wbcore.metadata.configs.display.instance_display import (
+    Display,
+    Layout,
+    Page,
+    Style,
+)
+from wbcore.metadata.configs.display.instance_display.operators import default
+
+
+class DataDisplayConfig(DisplayViewConfig):
+    def get_list_display(self) -> Optional[dp.ListDisplay]:
+        fields = [
+            dp.Field(key="label", label=_("Label")),
+            dp.Field(key="workflow", label=_("Workflow")),
+            dp.Field(key="data_type", label=_("Data Type")),
+            dp.Field(key="required", label=_("Required")),
+            dp.Field(key="help_text", label=_("Help Text")),
+            dp.Field(key="default", label=_("Default")),
+        ]
+
+        if "workflow_id" in self.view.kwargs:
+            fields.pop(1)
+
+        return dp.ListDisplay(
+            fields=fields,
+        )
+
+    def get_instance_display(self) -> Display:
+        return Display(
+            pages=[
+                Page(
+                    layouts={
+                        default(): Layout(
+                            grid_template_areas=[
+                                ["label", "workflow", "data_type"],
+                                ["required", "help_text", "default"],
+                            ],
+                            grid_auto_columns="minmax(min-content, 1fr)",
+                            grid_auto_rows=Style.MIN_CONTENT,
+                            column_gap=Style.rem(5),
+                        ),
+                    },
+                ),
+            ]
+        )