Merge pull request #210 from pneumaticapp/backend/templates/46269__manager_performer_type

46269 backend [ users ] Hierarchical approval workflow

Author: EBirkenfeld

backend/src/processes/enums.py

@@ -71,12 +71,14 @@ class PerformerType:
     GROUP = 'group'
     WORKFLOW_STARTER = 'workflow_starter'
     FIELD = 'field'
+    MANAGER = 'manager'
 
     choices = (
         (USER, USER),
         (GROUP, GROUP),
         (WORKFLOW_STARTER, WORKFLOW_STARTER),
         (FIELD, FIELD),
+        (MANAGER, MANAGER),
     )
 
     filter_choices = (

backend/src/processes/messages/template.py

@@ -284,3 +284,30 @@
 MSG_PT_0070 = _(
     'Permission denied. You are not a template owner or viewer.',
 )
+MSG_PT_0071 = _(
+    'You should set the source step for performer '
+    'with the type "manager".',
+)
+MSG_PT_0072 = lambda name: format_lazy(
+    _(
+        'Task "{name}": Manager performer '
+        'cannot reference its own step.',
+    ),
+    name=name,
+)
+MSG_PT_0073 = lambda name, step_name: format_lazy(
+    _(
+        'Task "{name}": Manager performer references '
+        'a non-existent step "{step_name}".',
+    ),
+    name=name,
+    step_name=step_name,
+)
+MSG_PT_0074 = lambda name, step_name: format_lazy(
+    _(
+        'Task "{name}": Disable "Required completion by all" '
+        'on step "{step_name}" to use Manager performer.',
+    ),
+    name=name,
+    step_name=step_name,
+)

backend/src/processes/migrations/0252_add_manager_performer_type.py

@@ -0,0 +1,29 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('processes', '0251_add_skip_for_starter'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='rawperformertemplate',
+            name='source_task_api_name',
+            field=models.CharField(
+                blank=True,
+                max_length=200,
+                null=True,
+            ),
+        ),
+        migrations.AddField(
+            model_name='rawperformer',
+            name='source_task_api_name',
+            field=models.CharField(
+                blank=True,
+                max_length=200,
+                null=True,
+            ),
+        ),
+    ]

backend/src/processes/models/mixins.py

@@ -40,6 +40,11 @@ class Meta:
         on_delete=models.CASCADE,
         null=True,
     )
+    source_task_api_name = models.CharField(
+        max_length=200,
+        null=True,
+        blank=True,
+    )
 
 
 class WorkflowMixin(models.Model):
@@ -283,13 +288,17 @@ def delete_raw_performer(
         group: Optional[UserGroup] = None,
         field=None,
         performer_type: PerformerType = PerformerType.USER,
+        source_task_api_name: Optional[str] = None,
     ) -> int:
 
         """ Delete a raw_performer
             and returns the number of objects deleted """
 
         if (
-            performer_type != PerformerType.WORKFLOW_STARTER
+            performer_type not in (
+                PerformerType.WORKFLOW_STARTER,
+                PerformerType.MANAGER,
+            )
             and user is None and group is None and field is None
         ):
             raise Exception(
@@ -301,6 +310,7 @@ def delete_raw_performer(
             user=user,
             group=group,
             field=field,
+            source_task_api_name=source_task_api_name,
         ).delete()[0]
 
     def delete_raw_performers(self):

backend/src/processes/models/workflows/task.py

@@ -1,11 +1,12 @@
 # ruff: noqa: PLC0415
 from collections import defaultdict
-from typing import List, Optional, Set, Tuple
+from typing import TYPE_CHECKING, List, Optional, Set, Tuple
 
 from django.contrib.auth import get_user_model
 from django.db import models
 from django.utils import timezone
 
+from src.accounts.enums import UserStatus
 from src.accounts.models import (
     AccountBaseMixin,
     Notification,
@@ -18,6 +19,7 @@
     FieldType,
     PerformerType,
     TaskStatus,
+    WorkflowEventType,
 )
 from src.processes.models.mixins import (
     ApiNameMixin,
@@ -31,6 +33,9 @@
     TasksQuerySet,
 )
 
+if TYPE_CHECKING:
+    from src.processes.models.workflows.raw_performer import RawPerformer
+
 UserModel = get_user_model()
 
 
@@ -122,6 +127,7 @@ def _get_raw_performer(
         group_id: Optional[int] = None,
         user_id: Optional[int] = None,
         field=None,  # Optional[TaskField]
+        source_task_api_name: Optional[str] = None,
     ):  # -> RawPerformer
 
         """ Returns new a raw performer object with given data """
@@ -134,6 +140,7 @@ def _get_raw_performer(
             field=field,
             api_name=api_name,
             type=performer_type,
+            source_task_api_name=source_task_api_name,
         )
         if user:
             result.user = user
@@ -151,12 +158,18 @@ def add_raw_performer(
         field=None,
         api_name: Optional[str] = None,
         performer_type: PerformerType = PerformerType.USER,
+        source_task_api_name: Optional[str] = None,
     ):  # -> RawPerformer
 
         """ Creates and returns a raw performer for a task with given data
             Optionally updates the performers after create raw performers """
 
-        if (
+        if performer_type == PerformerType.MANAGER:
+            if not source_task_api_name:
+                raise Exception(
+                    'Manager performer requires source_task_api_name',
+                )
+        elif (
             performer_type != PerformerType.WORKFLOW_STARTER
             and not group_id
             and not user
@@ -174,6 +187,7 @@ def add_raw_performer(
             group_id=group_id,
             user_id=user_id,
             field=field,
+            source_task_api_name=source_task_api_name,
         )
         raw_performer.save()
         return raw_performer
@@ -261,6 +275,7 @@ def update_raw_performers_from_task_template(
                 'user_id': e.user_id,
                 'group_id': e.group_id,
                 'api_name': e.api_name,
+                'source_task_api_name': e.source_task_api_name,
                 'field': {
                     'api_name': e.field.api_name,
                 } if e.type == PerformerType.FIELD else None,
@@ -309,6 +324,11 @@ def update_raw_performers_from_task_template(
                         group_id=raw_performer_template.get('group_id'),
                         field=field,
                         api_name=raw_performer_template['api_name'],
+                        source_task_api_name=(
+                            raw_performer_template.get(
+                                'source_task_api_name',
+                            )
+                        ),
                     ),
                 )
         if new_raw_performers:
@@ -318,6 +338,38 @@ def update_raw_performers_from_task_template(
                 api_name__in=deleted_raw_performer_api_names,
             ).delete()
 
+    def _resolve_manager(
+        self,
+        raw_performer: 'RawPerformer',
+    ) -> Optional[UserModel]:
+
+        """ Resolve manager performer: find the user who completed
+            the source step and return their manager.
+            Returns None if source step not completed
+            or completer has no manager. """
+
+        source_api_name = raw_performer.source_task_api_name
+        if not source_api_name:
+            return None
+        from src.processes.models.workflows.event import WorkflowEvent
+        complete_event = (
+            WorkflowEvent.objects
+            .filter(
+                workflow_id=self.workflow_id,
+                task__api_name=source_api_name,
+                task__status=TaskStatus.COMPLETED,
+                type=WorkflowEventType.TASK_COMPLETE,
+            )
+            .select_related('user__manager')
+            .order_by('-created')
+            .first()
+        )
+        if complete_event and complete_event.user:
+            manager = complete_event.user.manager
+            if manager and manager.status == UserStatus.ACTIVE:
+                return manager
+        return None
+
     def update_performers(
         self,
         raw_performer=None,
@@ -354,6 +406,7 @@ def update_performers(
             defaultdict(list),
             defaultdict(list),
         )
+        raw_performers_for_update = []
         for raw_performer_ in raw_performers:
             if raw_performer_.type == PerformerType.USER:
                 user_ids[raw_performer_.user_id].append(raw_performer_)
@@ -364,6 +417,13 @@ def update_performers(
             elif raw_performer_.type == PerformerType.WORKFLOW_STARTER:
                 user = self.get_default_performer()
                 user_ids[user.id].append(raw_performer_)
+            elif raw_performer_.type == PerformerType.MANAGER:
+                manager_user = self._resolve_manager(raw_performer_)
+                if manager_user:
+                    user_ids[manager_user.id].append(raw_performer_)
+                elif raw_performer_.task_performer_id is not None:
+                    raw_performer_.task_performer_id = None
+                    raw_performers_for_update.append(raw_performer_)
 
         if api_names:
             user_fields = self.workflow.get_fields(
@@ -378,7 +438,6 @@ def update_performers(
                 elif field.group_id:
                     group_ids[field.group_id].extend(api_names[field.api_name])
 
-        raw_performers_for_update = []
         created_performers_user_ids = []
         created_performers_group_ids = []
         if user_ids:
@@ -476,7 +535,9 @@ def _delete_orphaned_performers(self) -> Tuple[List[int], List[int]]:
             left pointing to the performer) """
 
         task_performer_ids = list(
-            self.raw_performers.values_list('task_performer_id', flat=True),
+            self.raw_performers
+            .exclude(task_performer_id=None)
+            .values_list('task_performer_id', flat=True),
         )
         performers_to_delete = (
             TaskPerformer.objects
@@ -501,6 +562,7 @@ def delete_raw_performer(
         group: Optional[UserGroup] = None,
         field=None,
         performer_type: PerformerType = PerformerType.USER,
+        source_task_api_name: Optional[str] = None,
     ):
 
         """ Delete a raw_performer
@@ -512,6 +574,7 @@ def delete_raw_performer(
             user=user,
             group=group,
             field=field,
+            source_task_api_name=source_task_api_name,
         )
         if deleted_count:
             self._delete_orphaned_performers()