wbcore 2.2.1__py2.py3-none-any.whl

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,23 @@
+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,15 @@
+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,22 @@
+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,27 @@
+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 k in range(random.randint(1, 5)):
+        inner_list = []
+        for i 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,69 @@
+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,155 @@
+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
+
+
+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,25 @@
+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):
+    name = factory.Faker("text", max_nb_chars=128)
+    to_step = factory.SubFactory("wbcore.contrib.workflow.factories.RandomChildStepFactory")
+    from_step = factory.SubFactory("wbcore.contrib.workflow.factories.RandomChildStepFactory")
+    icon = factory.Iterator(WBIcon.values)
+
+    @classmethod
+    def _create(cls, model_class, *args, **kwargs):
+        # Both steps need to belong to the same workflow
+        if (from_step := kwargs.get("from_step")) and (to_step := kwargs.get("to_step")):
+            if kwargs["from_step"].workflow != kwargs["to_step"].workflow:
+                from_step.workflow = to_step.workflow
+                from_step.save()
+                kwargs["from_step"] = from_step
+        return super()._create(model_class, *args, **kwargs)
+
+    class Meta:
+        model = Transition

wbcore/contrib/workflow/factories/workflow.py

@@ -0,0 +1,19 @@
+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,23 @@
+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,24 @@
+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"],
+        }

wbcore/contrib/workflow/filters/process.py

@@ -0,0 +1,164 @@
+from django.utils.translation import gettext_lazy as _
+from wbcore import filters as wb_filters
+from wbcore.contrib.authentication.models import Group, Permission, User
+from wbcore.contrib.workflow.models import Process, ProcessStep, Step, Workflow
+
+
+class ProcessWorkflowFilter(wb_filters.FilterSet):
+    started__lte = wb_filters.DateTimeFilter(
+        label=_("Started Before/On"),
+        lookup_expr="lte",
+        field_name="started",
+    )
+    started__gte = wb_filters.DateTimeFilter(
+        label=_("Started After/On"),
+        lookup_expr="gte",
+        field_name="started",
+    )
+    finished__lte = wb_filters.DateTimeFilter(
+        label=_("Finished Before/On"),
+        lookup_expr="lte",
+        field_name="finished",
+    )
+    finished__gte = wb_filters.DateTimeFilter(
+        label=_("Finished After/On"),
+        lookup_expr="gte",
+        field_name="finished",
+    )
+    id = wb_filters.CharFilter(label=_("UUID"))
+    state = wb_filters.MultipleChoiceFilter(choices=Process.ProcessState.choices, label=_("States"))
+
+    class Meta:
+        model = Process
+        fields = {}
+
+
+class ProcessFilter(ProcessWorkflowFilter):
+    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(),
+    )
+
+    class Meta(ProcessWorkflowFilter.Meta):
+        model = Process
+        fields = ProcessWorkflowFilter.Meta.fields
+
+
+class ProcessStepBaseFilter(ProcessWorkflowFilter):
+    assignee = wb_filters.ModelMultipleChoiceFilter(
+        label=_("Assignees"),
+        queryset=User.objects.all(),
+        endpoint=User.get_representation_endpoint(),
+        value_key=User.get_representation_value_key(),
+        label_key=User.get_representation_label_key(),
+    )
+    group = wb_filters.ModelMultipleChoiceFilter(
+        label=_("Groups"),
+        queryset=Group.objects.all(),
+        endpoint=Group.get_representation_endpoint(),
+        value_key=Group.get_representation_value_key(),
+        label_key=Group.get_representation_label_key(),
+    )
+    permission = wb_filters.ModelMultipleChoiceFilter(
+        label=_("Permissions"),
+        queryset=Permission.objects.all(),
+        endpoint=Permission.get_representation_endpoint(),
+        value_key=Permission.get_representation_value_key(),
+        label_key=Permission.get_representation_label_key(),
+    )
+
+    class Meta:
+        model = ProcessStep
+        fields = {
+            "status": ["exact", "icontains"],
+            "error_message": ["exact", "icontains"],
+        }
+
+
+class ProcessStepProcessFilter(ProcessStepBaseFilter):
+    step = wb_filters.ModelMultipleChoiceFilter(
+        label=_("Steps"),
+        queryset=Step.objects.all(),
+        endpoint=Step.get_representation_endpoint(),
+        value_key=Step.get_representation_value_key(),
+        label_key=Step.get_representation_label_key(),
+    )
+
+    class Meta(ProcessStepBaseFilter.Meta):
+        model = ProcessStep
+        fields = ProcessStepBaseFilter.Meta.fields
+
+
+class ProcessStepStepFilter(ProcessStepBaseFilter):
+    process = wb_filters.ModelMultipleChoiceFilter(
+        label=_("Processes"),
+        queryset=Process.objects.all(),
+        endpoint=Process.get_representation_endpoint(),
+        value_key=Process.get_representation_value_key(),
+        label_key=Process.get_representation_label_key(),
+    )
+
+    class Meta(ProcessStepBaseFilter.Meta):
+        model = ProcessStep
+        fields = ProcessStepBaseFilter.Meta.fields
+
+
+class ProcessStepFilter(ProcessStepProcessFilter, ProcessStepStepFilter):
+    class Meta(ProcessStepBaseFilter.Meta):
+        model = ProcessStep
+        fields = ProcessStepBaseFilter.Meta.fields
+
+
+class AssignedProcessStepFilter(wb_filters.FilterSet):
+    step = wb_filters.ModelMultipleChoiceFilter(
+        label=_("Steps"),
+        queryset=Step.objects.all(),
+        endpoint=Step.get_representation_endpoint(),
+        value_key=Step.get_representation_value_key(),
+        label_key=Step.get_representation_label_key(),
+    )
+    started__lte = wb_filters.DateTimeFilter(
+        label=_("Started Before/On"),
+        lookup_expr="lte",
+        field_name="started",
+    )
+    started__gte = wb_filters.DateTimeFilter(
+        label=_("Started After/On"),
+        lookup_expr="gte",
+        field_name="started",
+    )
+    finished__lte = wb_filters.DateTimeFilter(
+        label=_("Finished Before/On"),
+        lookup_expr="lte",
+        field_name="finished",
+    )
+    finished__gte = wb_filters.DateTimeFilter(
+        label=_("Finished After/On"),
+        lookup_expr="gte",
+        field_name="finished",
+    )
+    group = wb_filters.ModelMultipleChoiceFilter(
+        label=_("Groups"),
+        queryset=Group.objects.all(),
+        endpoint=Group.get_representation_endpoint(),
+        value_key=Group.get_representation_value_key(),
+        label_key=Group.get_representation_label_key(),
+    )
+    permission = wb_filters.ModelMultipleChoiceFilter(
+        label=_("Permissions"),
+        queryset=Permission.objects.all(),
+        endpoint=Permission.get_representation_endpoint(),
+        value_key=Permission.get_representation_value_key(),
+        label_key=Permission.get_representation_label_key(),
+    )
+    workflow_name = wb_filters.CharFilter(label=_("Workflow"), lookup_expr="icontains")
+    attached_model = wb_filters.CharFilter(label=_("Attached Model"), lookup_expr="icontains")
+
+    class Meta:
+        model = ProcessStep
+        fields = {
+            "status": ["exact", "icontains"],
+        }