wbcore 2.2.1__py2.py3-none-any.whl

wbcore/contrib/workflow/migrations/0002_alter_step_step_type.py

@@ -0,0 +1,31 @@
+# Generated by Django 4.1.10 on 2023-08-30 11:20
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("workflow", "0001_initial"),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name="step",
+            name="step_type",
+            field=models.CharField(
+                choices=[
+                    ("StartStep", "Start Step"),
+                    ("UserStep", "User Step"),
+                    ("DecisionStep", "Decision Step"),
+                    ("SplitStep", "Split Step"),
+                    ("JoinStep", "Join Step"),
+                    ("EmailStep", "Email Step"),
+                    ("ScriptStep", "Script Step"),
+                    ("FinishStep", "Finish Step"),
+                ],
+                default="",
+                max_length=64,
+                verbose_name="Step Type",
+            ),
+        ),
+    ]

wbcore/contrib/workflow/migrations/0003_alter_condition_attribute_name_and_more.py

@@ -0,0 +1,75 @@
+# Generated by Django 4.1.10 on 2023-09-12 09:07
+
+import django.db.models.deletion
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("contenttypes", "0002_remove_content_type_name"),
+        ("workflow", "0002_alter_step_step_type"),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name="condition",
+            name="attribute_name",
+            field=models.CharField(
+                help_text="The name of the attribute on the attached instance. Its value will be evaluated against the condition.",
+                max_length=64,
+                verbose_name="Attribute Name",
+            ),
+        ),
+        migrations.AlterField(
+            model_name="condition",
+            name="expected_value",
+            field=models.CharField(
+                help_text="The expected value of the attribute that will satisfy the condition.",
+                max_length=64,
+                verbose_name="Expected Value",
+            ),
+        ),
+        migrations.AlterField(
+            model_name="process",
+            name="content_type",
+            field=models.ForeignKey(
+                blank=True,
+                editable=False,
+                null=True,
+                on_delete=django.db.models.deletion.SET_NULL,
+                to="contenttypes.contenttype",
+                verbose_name="Attached Model",
+            ),
+        ),
+        migrations.AlterField(
+            model_name="step",
+            name="status",
+            field=models.CharField(
+                blank=True,
+                help_text="The status that will be set in the attached instance's status field upon transitioning to this step. Only applicable if attached model is set.",
+                max_length=64,
+                null=True,
+                verbose_name="Status",
+            ),
+        ),
+        migrations.AlterField(
+            model_name="workflow",
+            name="single_instance_execution",
+            field=models.BooleanField(
+                default=False,
+                help_text="Indicates wether the workflow is restricted to only one running workflow at a time. If an instance is attached to the workflow this will restrict the workflow execution per model instance.",
+                verbose_name="Single Instance Execution",
+            ),
+        ),
+        migrations.AlterField(
+            model_name="workflow",
+            name="status_field",
+            field=models.CharField(
+                blank=True,
+                help_text="The status field name in the attached model that needs to be updated by the workflow",
+                max_length=64,
+                null=True,
+                verbose_name="Status Field",
+            ),
+        ),
+    ]

wbcore/contrib/workflow/migrations/0004_alter_userstep_assignee_method.py

@@ -0,0 +1,27 @@
+# Generated by Django 4.2.9 on 2024-01-26 15:31
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("workflow", "0003_alter_condition_attribute_name_and_more"),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name="userstep",
+            name="assignee_method",
+            field=models.CharField(
+                blank=True,
+                choices=[
+                    ("manager_of_instance_assignee", "Instance Assignee's Manager"),
+                    ("weighted_random", "Weighted Random Group Member"),
+                    ("random_group_member", "Random Group Member"),
+                ],
+                max_length=64,
+                null=True,
+                verbose_name="Assignee Method",
+            ),
+        ),
+    ]

wbcore/contrib/workflow/migrations/0005_alter_userstep_assignee_method.py

@@ -0,0 +1,17 @@
+# Generated by Django 4.2.7 on 2024-02-07 10:47
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("workflow", "0004_alter_userstep_assignee_method"),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name="userstep",
+            name="assignee_method",
+            field=models.CharField(blank=True, max_length=64, null=True, verbose_name="Assignee Method"),
+        ),
+    ]

wbcore/contrib/workflow/models/__init__.py

@@ -0,0 +1,19 @@
+from .condition import Condition
+from .data import Data, DataValue
+from .display import Display
+from .process import Process, ProcessStep
+from .step import (
+    DecisionStep,
+    EmailStep,
+    FinishStep,
+    JoinStep,
+    ScriptStep,
+    SplitStep,
+    Step,
+    UserStep,
+    activate_step,
+    StartStep,
+    process_can_finish,
+)
+from .transition import Transition
+from .workflow import Workflow

wbcore/contrib/workflow/models/condition.py

@@ -0,0 +1,123 @@
+from django.db import models
+from django.utils.translation import gettext
+from django.utils.translation import gettext_lazy as _
+from wbcore.contrib.workflow.models.data import Data
+from wbcore.models import WBModel
+
+
+class Condition(WBModel):
+    """A condition that needs to be satisfied in order to make the transition to the next workflow step"""
+
+    class Operator(models.TextChoices):
+        LT = "<", _("Less Than")
+        LTE = "<=", _("Less Than or Equal")
+        EQ = "==", _("Equal")
+        GTE = ">=", _("Greater Than or Equal")
+        GT = ">", _("Greater Than")
+
+    transition = models.ForeignKey(
+        to="workflow.Transition",
+        verbose_name=_("Transition"),
+        on_delete=models.CASCADE,
+        related_name="associated_conditions",
+    )
+    attribute_name = models.CharField(
+        max_length=64,
+        verbose_name=_("Attribute Name"),
+        help_text=_(
+            "The name of the attribute on the attached instance. Its value will be evaluated against the condition."
+        ),
+    )
+    operator = models.CharField(max_length=64, choices=Operator.choices, verbose_name=_("Operator"))
+    expected_value = models.CharField(
+        max_length=64,
+        verbose_name=_("Expected Value"),
+        help_text=_("The expected value of the attribute that will satisfy the condition."),
+    )
+    negate_operator = models.BooleanField(default=False, verbose_name=_("Negate Operator"))
+
+    @property
+    def errors(self):
+        if not hasattr(self, "_errors"):
+            raise ValueError(_('Please call "satisfied" before accessing errors'))
+        return self._errors
+
+    def satisfied(self, instance) -> bool:
+        """Checks if the condition is satisfied for the provided instance
+
+        Args:
+            instance: The instance that should be checked.
+
+        Returns:
+            bool: True if the condition satisfies the provided instance, False otherwise
+        """
+
+        self._errors = []
+        try:
+            attribute_value = getattr(instance, self.attribute_name)
+            try:
+                # We need to cast the expected value to the type of the attached instance's field.
+                # We technically do not need to do this for attached data as the data value is already a string, same as the expected value.
+                casted_expected_value = Data.cast_value_from_target_object(attribute_value, self.expected_value)
+
+                evaluated_condition = False
+                if self.operator == self.Operator.EQ:
+                    evaluated_condition = attribute_value == casted_expected_value
+                elif self.operator == self.Operator.GT:
+                    evaluated_condition = attribute_value > casted_expected_value
+                elif self.operator == self.Operator.GTE:
+                    evaluated_condition = attribute_value >= casted_expected_value
+                elif self.operator == self.Operator.LT:
+                    evaluated_condition = attribute_value < casted_expected_value
+                elif self.operator == self.Operator.LTE:
+                    evaluated_condition = attribute_value <= casted_expected_value
+
+                if self.negate_operator:
+                    return not evaluated_condition
+                return evaluated_condition
+
+            except ValueError:
+                self._errors.append(
+                    gettext(
+                        "Condition error: Type of attribute ({}) and expected value ({}) uncompatible or wrong datetime format!"
+                    ).format(type(attribute_value), self.expected_value)
+                )
+                return False
+        except AttributeError:
+            self._errors.append(
+                gettext("Condition error: No attribute called {} found in attached instance or data!").format(
+                    self.attribute_name
+                )
+            )
+        return False
+
+    def __str__(self) -> str:
+        if self.negate_operator:
+            return _("{} not {} {}").format(self.attribute_name, self.operator, self.expected_value)
+        return f"{self.attribute_name} {self.operator} {self.expected_value}"
+
+    @classmethod
+    def get_endpoint_basename(cls):
+        return "wbcore:workflow:condition"
+
+    @classmethod
+    def get_representation_value_key(cls):
+        return "id"
+
+    @classmethod
+    def get_representation_endpoint(cls):
+        return "wbcore:workflow:conditionrepresentation-list"
+
+    @classmethod
+    def get_representation_label_key(cls):
+        return "{{transition}}: {{attribute_name}} {{negate_operator}} {{operator}} {{expected_value}}"
+
+    class Meta:
+        verbose_name = _("Condition")
+        verbose_name_plural = _("Conditions")
+        constraints = [
+            models.UniqueConstraint(
+                fields=["transition", "attribute_name", "operator", "negate_operator", "expected_value"],
+                name="unique_transition_attribute_name_operator_negate_expected_value",
+            ),
+        ]

wbcore/contrib/workflow/models/data.py

@@ -0,0 +1,238 @@
+from datetime import date, datetime
+
+from django.db import models
+from django.utils.translation import gettext
+from django.utils.translation import gettext_lazy as _
+from rest_framework import serializers as rest_serializers
+from wbcore import serializers
+from wbcore.models import WBModel
+
+
+class Data(WBModel):
+    """A blueprint for what data can be attached to a workflow."""
+
+    class DataType(models.TextChoices):
+        CHAR = "Text", _("Text")
+        INT = "Number", _("Number")
+        DATE = "Date", _("Date")
+        DATETIME = "Date Time", _("Date Time")
+        BOOL = "Boolean", _("Boolean")
+
+        @classmethod
+        def get_serializer_field_mapping(cls) -> dict:
+            serializer_fields = [
+                serializers.CharField(),
+                serializers.IntegerField(),
+                serializers.DateField(),
+                serializers.DateTimeField(),
+                serializers.BooleanField(),
+            ]
+            return {data_type: serializer_field for data_type, serializer_field in zip(cls, serializer_fields)}
+
+        @classmethod
+        def get_cast_mapping(cls) -> dict:
+            cast_callables = [
+                str,
+                int,
+                datetime.strptime,
+                datetime.strptime,
+                bool,
+            ]
+            return {data_type: cast_callable for data_type, cast_callable in zip(cls, cast_callables)}
+
+    workflow = models.ForeignKey(
+        to="workflow.Workflow",
+        on_delete=models.CASCADE,
+        verbose_name=_("Workflow"),
+        related_name="attached_data",
+    )
+    label = models.CharField(max_length=64, verbose_name=_("Label"))
+    help_text = models.CharField(max_length=128, verbose_name=_("Help Text"), null=True, blank=True)
+    data_type = models.CharField(
+        max_length=64, choices=DataType.choices, verbose_name=_("Data Type"), default=DataType.CHAR
+    )
+    required = models.BooleanField(
+        verbose_name=_("Required"),
+    )
+    default = models.CharField(
+        max_length=128,
+        verbose_name=_("Default"),
+        blank=True,
+        null=True,
+    )
+
+    def __str__(self) -> str:
+        return f"{self.label} ({self.workflow})"
+
+    def get_serializer_field(self) -> rest_serializers.Field:
+        """Constructs a serializer field from the instance
+
+        Returns:
+            rest_serializers.Field: A serializer field based on the instance
+
+        Raises:
+            ValueError: If casting the default value fails
+        """
+
+        field = self.DataType.get_serializer_field_mapping()[self.data_type]
+        field.set_attr("label", self.label)
+        field.set_attr("required", self.required)
+        if self.default:
+            casted_value = Data.cast_value_to_datatype(self.data_type, self.default)
+            field.set_attr("default", casted_value)
+        if self.help_text:
+            field.set_attr("help_text", self.help_text)
+        return field
+
+    @classmethod
+    def cast_value_to_datatype(cls, data_type: DataType, value: str) -> datetime | str | int | bool:
+        """Casts a value string into a provided data type
+
+        Args:
+            data_type (DataType): Selected data type
+            value (str): The value string
+
+        Returns:
+            datetime | str | int | bool: Value string casted into selected data type
+
+        Raises:
+            ValueError: If casting fails
+        """
+
+        cast_callable = cls.DataType.get_cast_mapping()[data_type]
+        if data_type == cls.DataType.DATE:
+            # NOTE: Different format? ISO-8601? Create global dateime format preference?
+            casted_value: date = cast_callable.__call__(value, "%d.%m.%Y").date()
+        elif data_type == cls.DataType.DATETIME:
+            casted_value: datetime = cast_callable.__call__(value, "%d.%m.%Y %H:%M:%S")
+        elif data_type == cls.DataType.BOOL:
+            if value.lower() == "true":
+                casted_value: bool = True
+            elif value.lower() == "false":
+                casted_value: bool = False
+            else:
+                raise ValueError(gettext("Casting to bool failed."))
+        else:
+            casted_value: str | int = cast_callable.__call__(value)
+        return casted_value
+
+    @classmethod
+    def cast_value_from_target_object(
+        cls, target_type_object: datetime | date | bool | str | int, input_str: str
+    ) -> datetime | date | bool | str | int | None:
+        """Casts an input string into the type of a provided object. Supported data types: datetime | date | bool | str | int
+
+        Args:
+            target_type_object (datetime | date | bool | str | int): The target type object
+            input_str (str): An input string to be casted
+
+        Raises:
+            ValueError: When an unsupported type is provided or casting failed
+
+        Returns:
+            datetime | date | bool | str | int | None: The casted input string
+        """
+
+        casted_output = None
+
+        if isinstance(target_type_object, datetime):
+            data_type = cls.DataType.DATETIME
+        elif isinstance(target_type_object, date):
+            data_type = cls.DataType.DATE
+        elif isinstance(target_type_object, bool):
+            data_type = cls.DataType.BOOL
+        elif isinstance(target_type_object, int):
+            data_type = cls.DataType.INT
+        elif isinstance(target_type_object, str):
+            data_type = cls.DataType.CHAR
+        else:
+            raise ValueError(gettext("Unsupported target type!"))
+
+        casted_output = cls.cast_value_to_datatype(data_type, input_str)
+
+        return casted_output
+
+    @classmethod
+    def cast_datatype_to_string(cls, data_type: DataType, data_object: datetime | str | int | bool) -> str:
+        """Casts an object of type datatype into a str. Reverse function of 'cast_value_to_datatype'
+
+        Args:
+            data_type (DataType): Selected data type
+            data_object (datetime | str | int | bool): The object to be casted
+
+        Returns:
+            str: A string representation of the object
+
+        Raises:
+            ValueError: If casting fails
+        """
+
+        if data_type in [cls.DataType.DATE, cls.DataType.DATETIME]:
+            if data_type == cls.DataType.DATE:
+                # NOTE: Different format? ISO-8601? Create global dateime format preference?
+                format_str = "%d.%m.%Y"
+            else:
+                format_str = "%d.%m.%Y %H:%M:%S"
+            try:
+                casted_object = data_object.strftime(format_str)
+            except AttributeError:
+                raise ValueError(gettext("Date(time) type selected but no date(time) object provided!"))
+
+        elif data_type == cls.DataType.BOOL:
+            if data_object is True:
+                casted_object = "True"
+            elif data_object is False:
+                casted_object = "False"
+            else:
+                raise ValueError(gettext("Wrong boolean value!"))
+        else:
+            casted_object = str(data_object)
+        return casted_object
+
+    @classmethod
+    def get_endpoint_basename(cls):
+        return "wbcore:workflow:data"
+
+    @classmethod
+    def get_representation_value_key(cls):
+        return "id"
+
+    @classmethod
+    def get_representation_endpoint(cls):
+        return "wbcore:workflow:datarepresentation-list"
+
+    @classmethod
+    def get_representation_label_key(cls):
+        return "{{label}}"
+
+    class Meta:
+        verbose_name = _("Data")
+        verbose_name_plural = _("Data")
+        constraints = [
+            models.UniqueConstraint(fields=["label", "workflow"], name="unique_label_workflow"),
+        ]
+
+
+class DataValue(models.Model):
+    """A model that holds the value for a data object"""
+
+    value = models.CharField(max_length=64, verbose_name=_("Value"), blank=True, null=True)
+    data = models.ForeignKey(to=Data, related_name="values", on_delete=models.CASCADE, verbose_name=_("Data"))
+    process = models.ForeignKey(
+        to="workflow.Process", related_name="data_values", on_delete=models.CASCADE, verbose_name=_("Process")
+    )
+
+    def __str__(self) -> str:
+        return f"{self.data}: {self.value}"
+
+    @classmethod
+    def get_representation_value_key(cls):
+        return "id"
+
+    @classmethod
+    def get_representation_label_key(cls):
+        return "{{value}}"
+
+    class Meta:
+        verbose_name = _("Data Value")
+        verbose_name_plural = _("Data Values")

wbcore/contrib/workflow/models/display.py

@@ -0,0 +1,33 @@
+from django.db import models
+from django.utils.translation import gettext_lazy as _
+from wbcore.models import WBModel
+
+
+class Display(WBModel):
+    """A user modifiable display config that can be used to display process steps."""
+
+    grid_template_areas = models.JSONField(verbose_name=_("Grid Fields"))
+    name = models.CharField(max_length=128, verbose_name=_("Name"), unique=True)
+
+    def __str__(self) -> str:
+        return self.name
+
+    @classmethod
+    def get_endpoint_basename(cls):
+        return "wbcore:workflow:display"
+
+    @classmethod
+    def get_representation_value_key(cls):
+        return "id"
+
+    @classmethod
+    def get_representation_endpoint(cls):
+        return "wbcore:workflow:displayrepresentation-list"
+
+    @classmethod
+    def get_representation_label_key(cls):
+        return "{{name}}"
+
+    class Meta:
+        verbose_name = _("Display")
+        verbose_name_plural = _("Displays")