wbcore 1.59.9__py2.py3-none-any.whl

wbcore/contrib/workflow/admin/step.py

@@ -0,0 +1,92 @@
+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,9 @@
+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,9 @@
+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,25 @@
+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,11 @@
+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),
+    }

wbcore/contrib/workflow/decorators.py

@@ -0,0 +1,25 @@
+from typing import Callable
+
+
+def register(serializer_class=None):
+    """
+    Register the given model as a "workflowable" model
+    """
+    from wbcore.contrib.workflow.sites import workflow_site
+
+    def _model_wrapper(model_class):
+        workflow_site.registered_model_classes_serializer_map[model_class] = serializer_class
+        return model_class
+
+    return _model_wrapper
+
+
+def register_assignee(name: str) -> Callable:
+    from wbcore.contrib.workflow.sites import workflow_site
+
+    def _wrapper(func: Callable) -> Callable:
+        workflow_site.registered_assignees_methods[func.__name__] = func
+        workflow_site.registered_assignees_names[func.__name__] = name
+        return func
+
+    return _wrapper

wbcore/contrib/workflow/dispatch.py

@@ -0,0 +1,24 @@
+from django.contrib.contenttypes.models import ContentType
+from django.utils.translation import gettext as _
+
+from wbcore.contrib.workflow.models import Process, ProcessStep, Workflow
+
+
+def check_workflow_for_instance(sender, instance, created, *args, **kwargs):
+    # Fail all active process steps with statuses that don't match the instance's status
+    active_process_steps = ProcessStep.objects.filter(
+        state__in=[ProcessStep.StepState.ACTIVE, ProcessStep.StepState.WAITING],
+        process__instance_id=instance.pk,
+        process__content_type=ContentType.objects.get_for_model(instance),
+        process__state=Process.ProcessState.ACTIVE,
+    )
+    for process_step in active_process_steps:
+        if hasattr(instance, process_step.process.workflow.status_field) and not process_step.status == getattr(
+            instance, process_step.process.workflow.status_field
+        ):
+            process_step.step.get_casted_step().set_failed(process_step, _("Invalid status detected!"))
+
+    # Start workflow if instance's status matches the status of a start step
+    start_steps = Workflow.get_start_steps_for_instance(instance)
+    for start_step in start_steps:
+        start_step.workflow.start_workflow(start_step, instance)

wbcore/contrib/workflow/factories/__init__.py

@@ -0,0 +1,18 @@
+from .condition import ConditionFactory
+from .data import DataFactory, DataValueFactory
+from .display import DisplayFactory
+from .process import ProcessFactory, ProcessStepFactory
+from .step import (
+    DecisionStepFactory,
+    EmailStepFactory,
+    FinishStepFactory,
+    JoinStepFactory,
+    RandomChildStepFactory,
+    ScriptStepFactory,
+    SplitStepFactory,
+    StepFactory,
+    UserStepFactory,
+    StartStepFactory,
+)
+from .transition import TransitionFactory
+from .workflow import WorkflowFactory

wbcore/contrib/workflow/factories/condition.py

@@ -0,0 +1,16 @@
+import factory
+from django.db.models import signals
+
+from wbcore.contrib.workflow.models import Condition
+
+
+@factory.django.mute_signals(signals.post_save)
+class ConditionFactory(factory.django.DjangoModelFactory):
+    attribute_name = factory.SelfAttribute("transition.to_step.workflow.status_field")
+    expected_value = factory.Faker("text", max_nb_chars=64)
+    transition = factory.SubFactory("wbcore.contrib.workflow.factories.TransitionFactory")
+    operator = factory.Iterator(Condition.Operator.values)
+    negate_operator = factory.Faker("pybool")
+
+    class Meta:
+        model = Condition

wbcore/contrib/workflow/factories/data.py

@@ -0,0 +1,23 @@
+import factory
+
+from wbcore.contrib.workflow.models import Data, DataValue
+
+
+class DataFactory(factory.django.DjangoModelFactory):
+    label = factory.Faker("text", max_nb_chars=64)
+    help_text = factory.Faker("text", max_nb_chars=128)
+    data_type = factory.Iterator(Data.DataType.values)
+    workflow = factory.SubFactory("wbcore.contrib.workflow.factories.WorkflowFactory")
+    required = factory.Faker("pybool")
+
+    class Meta:
+        model = Data
+
+
+class DataValueFactory(factory.django.DjangoModelFactory):
+    value = factory.Faker("text", max_nb_chars=64)
+    data = factory.SubFactory(DataFactory)
+    process = factory.SubFactory("wbcore.contrib.workflow.factories.ProcessFactory")
+
+    class Meta:
+        model = DataValue

wbcore/contrib/workflow/factories/display.py

@@ -0,0 +1,28 @@
+import random
+
+import factory
+from faker import Faker
+
+from wbcore.contrib.directory.serializers import PersonModelSerializer
+from wbcore.contrib.workflow.models import Display
+
+fake = Faker()
+
+
+def _generate_grid_areas() -> list[list[str]]:
+    outer_list = []
+    inner_list_length = random.randint(1, 5)
+    for _ in range(random.randint(1, 5)):
+        inner_list = []
+        for _ in range(inner_list_length):
+            inner_list.append(random.choice(PersonModelSerializer.Meta.fields))
+        outer_list.append(inner_list)
+    return outer_list
+
+
+class DisplayFactory(factory.django.DjangoModelFactory):
+    name = factory.Faker("text", max_nb_chars=128)
+    grid_template_areas = factory.LazyAttribute(lambda o: _generate_grid_areas())
+
+    class Meta:
+        model = Display

wbcore/contrib/workflow/factories/process.py

@@ -0,0 +1,70 @@
+import factory
+from django.contrib.contenttypes.models import ContentType
+from django.utils import timezone
+
+from wbcore.contrib.directory.factories import PersonFactory
+from wbcore.contrib.directory.models import Person
+from wbcore.contrib.directory.serializers import PersonModelSerializer
+from wbcore.contrib.workflow.models import Process, ProcessStep, Step
+
+
+def _get_person_dict() -> dict:
+    data = PersonModelSerializer(PersonFactory()).data
+    # Serializer throws error when both fields are blank
+    data["primary_email"] = None
+    data["primary_telephone"] = None
+    return data
+
+
+class ProcessFactory(factory.django.DjangoModelFactory):
+    id = factory.Faker("uuid4")
+    workflow = factory.SubFactory("wbcore.contrib.workflow.factories.WorkflowFactory")
+    started = factory.Faker("date_time", tzinfo=timezone.get_current_timezone())
+    finished = factory.Faker("date_time", tzinfo=timezone.get_current_timezone())
+    instance = factory.SubFactory("wbcore.contrib.directory.factories.PersonFactory")
+    instance_id = factory.SelfAttribute("instance.pk")
+    content_type = factory.LazyAttribute(lambda o: ContentType.objects.get_for_model(Person))
+    preserved_instance = factory.Maybe(
+        "preserve_instance_activated",
+        yes_declaration=factory.LazyAttribute(lambda x: _get_person_dict()),
+        no_declaration=None,
+    )
+    state = factory.Iterator(Process.ProcessState.values)
+
+    class Meta:
+        model = Process
+
+    class Params:
+        preserve_instance_activated = factory.SelfAttribute("workflow.preserve_instance")
+
+
+class ProcessStepFactory(factory.django.DjangoModelFactory):
+    id = factory.Faker("uuid4")
+    process = factory.SubFactory(ProcessFactory)
+    step = factory.SubFactory("wbcore.contrib.workflow.factories.RandomChildStepFactory")
+    started = factory.Faker("date_time", tzinfo=timezone.get_current_timezone())
+    finished = factory.Faker("date_time", tzinfo=timezone.get_current_timezone())
+    assignee = factory.Maybe(
+        "is_userstep",
+        yes_declaration=factory.LazyAttribute(lambda x: x.step.get_casted_step().get_assigned_user()),
+        no_declaration=None,
+    )
+    group = factory.Maybe(
+        "is_userstep",
+        yes_declaration=factory.LazyAttribute(lambda x: x.step.get_casted_step().get_assigned_group()),
+        no_declaration=None,
+    )
+    state = factory.Iterator(ProcessStep.StepState.values)
+    status = factory.SelfAttribute("step.status")
+    error_message = factory.Maybe(
+        "step_failed",
+        yes_declaration=factory.Faker("text", max_nb_chars=128),
+        no_declaration=None,
+    )
+
+    class Params:
+        is_userstep = factory.LazyAttribute(lambda x: x.step.step_type == Step.StepType.USERSTEP)
+        step_failed = factory.LazyAttribute(lambda x: x.state == ProcessStep.StepState.FAILED)
+
+    class Meta:
+        model = ProcessStep

wbcore/contrib/workflow/factories/step.py

@@ -0,0 +1,157 @@
+from random import choice
+
+import factory
+from django.db.models import signals
+from faker import Faker
+
+from wbcore.contrib.authentication.factories import GroupFactory
+from wbcore.contrib.workflow.models import (
+    DecisionStep,
+    EmailStep,
+    FinishStep,
+    JoinStep,
+    ScriptStep,
+    SplitStep,
+    StartStep,
+    Step,
+    UserStep,
+)
+from wbcore.contrib.workflow.sites import workflow_site
+
+fake = Faker()
+
+
+def _generate_random_printout() -> str:
+    return f'def run(process_step):\r\n   print("{fake.sentence(nb_words=5)}")'
+
+
+@factory.django.mute_signals(signals.post_save)
+class StepFactory(factory.django.DjangoModelFactory):
+    name = factory.Faker("text", max_nb_chars=128)
+    workflow = factory.SubFactory("wbcore.contrib.workflow.factories.WorkflowFactory")
+    code = factory.Faker("pyint", min_value=0, max_value=9999)
+    status = factory.Faker("text", max_nb_chars=64)
+
+    class Meta:
+        model = Step
+        django_get_or_create = ["code", "workflow"]
+
+
+class RandomChildStepFactory(StepFactory):
+    @classmethod
+    def create(cls, **kwargs):
+        child_factories = [
+            StartStepFactory,
+            UserStepFactory,
+            DecisionStepFactory,
+            SplitStepFactory,
+            JoinStepFactory,
+            ScriptStepFactory,
+            EmailStepFactory,
+            FinishStepFactory,
+        ]
+        if exclude_factories := kwargs.get("exclude_factories"):
+            child_factory = choice(list(set(child_factories) - set(exclude_factories)))
+            kwargs.pop("exclude_factories")
+        else:
+            child_factory = choice(child_factories)
+
+        # Create an instance using the selected child factory
+        return child_factory.create(**kwargs)
+
+    class Meta:
+        model = Step
+        django_get_or_create = ["code"]
+
+
+class UserStepFactory(StepFactory):
+    assignee_method = factory.Iterator([i[0] for i in workflow_site.assignees_choices])
+    notify_user = factory.Faker("pybool")
+    group = factory.SubFactory(GroupFactory)
+    step_type = Step.StepType.USERSTEP
+    display = factory.SubFactory("wbcore.contrib.workflow.factories.DisplayFactory")
+
+    class Meta:
+        model = UserStep
+
+
+class DecisionStepFactory(StepFactory):
+    step_type = Step.StepType.DECISIONSTEP
+
+    class Meta:
+        model = DecisionStep
+
+
+class SplitStepFactory(StepFactory):
+    step_type = Step.StepType.SPLITSTEP
+
+    class Meta:
+        model = SplitStep
+
+
+class StartStepFactory(StepFactory):
+    step_type = Step.StepType.STARTSTEP
+
+    class Meta:
+        model = StartStep
+
+
+class JoinStepFactory(StepFactory):
+    step_type = Step.StepType.JOINSTEP
+    wait_for_all = factory.Faker("pybool")
+
+    class Meta:
+        model = JoinStep
+
+
+class ScriptStepFactory(StepFactory):
+    step_type = Step.StepType.SCRIPTSTEP
+    script = factory.LazyAttribute(lambda o: _generate_random_printout())
+
+    class Meta:
+        model = ScriptStep
+
+
+class EmailStepFactory(StepFactory):
+    step_type = Step.StepType.EMAILSTEP
+    template = factory.django.FileField(filename="testfile.dat", data=b"testdata")
+    subject = factory.Faker("text", max_nb_chars=128)
+
+    @factory.post_generation
+    def to(self, create, extracted, **kwargs):
+        if not create:
+            return
+
+        elif extracted:
+            for recipient in extracted:
+                self.to.add(recipient)
+
+    @factory.post_generation
+    def cc(self, create, extracted, **kwargs):
+        if not create:
+            return
+
+        if extracted:
+            for recipient in extracted:
+                self.cc.add(recipient)
+
+    @factory.post_generation
+    def bcc(self, create, extracted, **kwargs):
+        if not create:
+            return
+
+        elif extracted:
+            for recipient in extracted:
+                self.bcc.add(recipient)
+
+    class Meta:
+        model = EmailStep
+        skip_postgeneration_save = True
+
+
+class FinishStepFactory(StepFactory):
+    step_type = Step.StepType.FINISHSTEP
+    write_preserved_instance = factory.SelfAttribute("workflow.preserve_instance")
+
+    class Meta:
+        model = FinishStep

wbcore/contrib/workflow/factories/transition.py

@@ -0,0 +1,27 @@
+import factory
+from django.db.models import signals
+
+from wbcore.contrib.icons import WBIcon
+from wbcore.contrib.workflow.models import Transition
+
+
+@factory.django.mute_signals(signals.post_save)
+class TransitionFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = Transition
+        exclude = ("_workflow",)
+
+    _workflow = factory.SubFactory("wbcore.contrib.workflow.factories.WorkflowFactory")
+
+    from_step = factory.SubFactory(
+        "wbcore.contrib.workflow.factories.StartStepFactory",
+        workflow=factory.SelfAttribute(".._workflow"),
+    )
+    to_step = factory.SubFactory(
+        "wbcore.contrib.workflow.factories.FinishStepFactory",
+        workflow=factory.SelfAttribute(".._workflow"),
+    )
+
+    icon = factory.Iterator(WBIcon.values)
+
+    name = factory.Sequence(lambda n: f"Transition #{n}")

wbcore/contrib/workflow/factories/workflow.py

@@ -0,0 +1,20 @@
+import factory
+from django.contrib.contenttypes.models import ContentType
+from django.db.models import signals
+
+from wbcore.contrib.directory.models import Person
+from wbcore.contrib.workflow.models import Workflow
+
+
+@factory.django.mute_signals(signals.post_save)
+class WorkflowFactory(factory.django.DjangoModelFactory):
+    name = factory.Faker("word")
+    status_field = "first_name"
+    single_instance_execution = factory.Faker("pybool")
+    preserve_instance = factory.Faker("pybool")
+    model = factory.LazyAttribute(lambda o: ContentType.objects.get_for_model(Person))
+    graph = factory.django.ImageField()
+
+    class Meta:
+        model = Workflow
+        django_get_or_create = ["name"]

wbcore/contrib/workflow/filters/__init__.py

@@ -0,0 +1,24 @@
+from .condition import ConditionFilter
+from .data import DataFilter
+from .process import (
+    ProcessFilter,
+    ProcessStepFilter,
+    ProcessStepProcessFilter,
+    ProcessStepStepFilter,
+    ProcessWorkflowFilter,
+    AssignedProcessStepFilter,
+)
+from .step import (
+    DecisionStepFilter,
+    EmailStepFilter,
+    FinishStepFilter,
+    JoinStepFilter,
+    ScriptStepFilter,
+    SplitStepFilter,
+    StepFilter,
+    StepWorkflowFilter,
+    UserStepFilter,
+    StartStepFilter,
+)
+from .transition import TransitionFilter
+from .workflow import WorkflowFilter

wbcore/contrib/workflow/filters/condition.py

@@ -0,0 +1,24 @@
+from django.utils.translation import gettext_lazy as _
+
+from wbcore import filters as wb_filters
+from wbcore.contrib.workflow.models import Condition, Transition
+
+
+class ConditionFilter(wb_filters.FilterSet):
+    transition = wb_filters.ModelMultipleChoiceFilter(
+        label=_("Transitions"),
+        queryset=Transition.objects.all(),
+        endpoint=Transition.get_representation_endpoint(),
+        value_key=Transition.get_representation_value_key(),
+        label_key=Transition.get_representation_label_key(),
+    )
+
+    operator = wb_filters.MultipleChoiceFilter(choices=Condition.Operator.choices, label=_("Operators"))
+
+    class Meta:
+        model = Condition
+        fields = {
+            "attribute_name": ["exact", "icontains"],
+            "expected_value": ["exact", "icontains"],
+            "negate_operator": ["exact"],
+        }

wbcore/contrib/workflow/filters/data.py

@@ -0,0 +1,25 @@
+from django.utils.translation import gettext_lazy as _
+
+from wbcore import filters as wb_filters
+from wbcore.contrib.workflow.models import Data, Workflow
+
+
+class DataFilter(wb_filters.FilterSet):
+    workflow = wb_filters.ModelMultipleChoiceFilter(
+        label=_("Workflows"),
+        queryset=Workflow.objects.all(),
+        endpoint=Workflow.get_representation_endpoint(),
+        value_key=Workflow.get_representation_value_key(),
+        label_key=Workflow.get_representation_label_key(),
+    )
+
+    data_type = wb_filters.MultipleChoiceFilter(choices=Data.DataType.choices, label=_("Data Types"))
+
+    class Meta:
+        model = Data
+        fields = {
+            "label": ["exact", "icontains"],
+            "help_text": ["exact", "icontains"],
+            "default": ["exact", "icontains"],
+            "required": ["exact"],
+        }