fix conflicts for like the thousandth time

conftest.py

@@ -9,7 +9,7 @@ from flask_bpmn.models.db import db
 from flask_bpmn.models.db import SpiffworkflowBaseDBModel
 from tests.spiffworkflow_backend.helpers.base_test import BaseTest
 
-from spiffworkflow_backend.models.active_task_user import ActiveTaskUserModel
+from spiffworkflow_backend.models.human_task_user import HumanTaskUserModel
 from spiffworkflow_backend.models.process_instance import ProcessInstanceModel
 from spiffworkflow_backend.models.user import UserModel
 from spiffworkflow_backend.services.process_instance_processor import (
@@ -47,7 +47,7 @@ def app() -> Flask:
 @pytest.fixture()
 def with_db_and_bpmn_file_cleanup() -> None:
     """Process_group_resource."""
-    db.session.query(ActiveTaskUserModel).delete()
+    db.session.query(HumanTaskUserModel).delete()
 
     for model in SpiffworkflowBaseDBModel._all_subclasses():
         db.session.query(model).delete()

migrations/versions/b86f7cc3a74b_.py

@@ -1,8 +1,8 @@
 """empty message
 
-Revision ID: e284612a9778
+Revision ID: b86f7cc3a74b
 Revises: 
-Create Date: 2022-12-19 11:23:10.567440
+Create Date: 2022-12-19 16:20:27.715487
 
 """
 from alembic import op
@@ -10,7 +10,7 @@ import sqlalchemy as sa
 
 
 # revision identifiers, used by Alembic.
-revision = 'e284612a9778'
+revision = 'b86f7cc3a74b'
 down_revision = None
 branch_labels = None
 depends_on = None
@@ -176,7 +176,7 @@ def upgrade():
     sa.PrimaryKeyConstraint('id'),
     sa.UniqueConstraint('user_id', 'group_id', name='user_group_assignment_unique')
     )
-    op.create_table('active_task',
+    op.create_table('human_task',
     sa.Column('id', sa.Integer(), nullable=False),
     sa.Column('process_instance_id', sa.Integer(), nullable=False),
     sa.Column('actual_owner_id', sa.Integer(), nullable=True),
@@ -191,12 +191,14 @@ def upgrade():
     sa.Column('task_type', sa.String(length=50), nullable=True),
     sa.Column('task_status', sa.String(length=50), nullable=True),
     sa.Column('process_model_display_name', sa.String(length=255), nullable=True),
+    sa.Column('completed', sa.Boolean(), nullable=False),
     sa.ForeignKeyConstraint(['actual_owner_id'], ['user.id'], ),
     sa.ForeignKeyConstraint(['lane_assignment_id'], ['group.id'], ),
     sa.ForeignKeyConstraint(['process_instance_id'], ['process_instance.id'], ),
     sa.PrimaryKeyConstraint('id'),
-    sa.UniqueConstraint('task_id', 'process_instance_id', name='active_task_unique')
+    sa.UniqueConstraint('task_id', 'process_instance_id', name='human_task_unique')
     )
+    op.create_index(op.f('ix_human_task_completed'), 'human_task', ['completed'], unique=False)
     op.create_table('message_correlation',
     sa.Column('id', sa.Integer(), nullable=False),
     sa.Column('process_instance_id', sa.Integer(), nullable=False),
@@ -263,17 +265,17 @@ def upgrade():
     sa.ForeignKeyConstraint(['process_instance_id'], ['process_instance.id'], ),
     sa.PrimaryKeyConstraint('id')
     )
-    op.create_table('active_task_user',
+    op.create_table('human_task_user',
     sa.Column('id', sa.Integer(), nullable=False),
-    sa.Column('active_task_id', sa.Integer(), nullable=False),
+    sa.Column('human_task_id', sa.Integer(), nullable=False),
     sa.Column('user_id', sa.Integer(), nullable=False),
-    sa.ForeignKeyConstraint(['active_task_id'], ['active_task.id'], ),
+    sa.ForeignKeyConstraint(['human_task_id'], ['human_task.id'], ),
     sa.ForeignKeyConstraint(['user_id'], ['user.id'], ),
     sa.PrimaryKeyConstraint('id'),
-    sa.UniqueConstraint('active_task_id', 'user_id', name='active_task_user_unique')
+    sa.UniqueConstraint('human_task_id', 'user_id', name='human_task_user_unique')
     )
-    op.create_index(op.f('ix_active_task_user_active_task_id'), 'active_task_user', ['active_task_id'], unique=False)
+    op.create_index(op.f('ix_human_task_user_human_task_id'), 'human_task_user', ['human_task_id'], unique=False)
-    op.create_index(op.f('ix_active_task_user_user_id'), 'active_task_user', ['user_id'], unique=False)
+    op.create_index(op.f('ix_human_task_user_user_id'), 'human_task_user', ['user_id'], unique=False)
     op.create_table('message_correlation_message_instance',
     sa.Column('id', sa.Integer(), nullable=False),
     sa.Column('message_instance_id', sa.Integer(), nullable=False),
@@ -293,9 +295,9 @@ def downgrade():
     op.drop_index(op.f('ix_message_correlation_message_instance_message_instance_id'), table_name='message_correlation_message_instance')
     op.drop_index(op.f('ix_message_correlation_message_instance_message_correlation_id'), table_name='message_correlation_message_instance')
     op.drop_table('message_correlation_message_instance')
-    op.drop_index(op.f('ix_active_task_user_user_id'), table_name='active_task_user')
+    op.drop_index(op.f('ix_human_task_user_user_id'), table_name='human_task_user')
-    op.drop_index(op.f('ix_active_task_user_active_task_id'), table_name='active_task_user')
+    op.drop_index(op.f('ix_human_task_user_human_task_id'), table_name='human_task_user')
-    op.drop_table('active_task_user')
+    op.drop_table('human_task_user')
     op.drop_table('spiff_step_details')
     op.drop_index(op.f('ix_process_instance_metadata_key'), table_name='process_instance_metadata')
     op.drop_table('process_instance_metadata')
@@ -306,7 +308,8 @@ def downgrade():
     op.drop_index(op.f('ix_message_correlation_name'), table_name='message_correlation')
     op.drop_index(op.f('ix_message_correlation_message_correlation_property_id'), table_name='message_correlation')
     op.drop_table('message_correlation')
-    op.drop_table('active_task')
+    op.drop_index(op.f('ix_human_task_completed'), table_name='human_task')
+    op.drop_table('human_task')
     op.drop_table('user_group_assignment')
     op.drop_table('secret')
     op.drop_table('refresh_token')

src/spiffworkflow_backend/api.yml

@@ -509,6 +509,119 @@ paths:
               schema:
                 $ref: "#/components/schemas/OkTrue"
 
+  /process-instances/for-me:
+    parameters:
+      - name: process_model_identifier
+        in: query
+        required: false
+        description: The unique id of an existing process model.
+        schema:
+          type: string
+      - name: page
+        in: query
+        required: false
+        description: The page number to return. Defaults to page 1.
+        schema:
+          type: integer
+      - name: per_page
+        in: query
+        required: false
+        description: The page number to return. Defaults to page 1.
+        schema:
+          type: integer
+      - name: start_from
+        in: query
+        required: false
+        description: For filtering - beginning of start window - in seconds since epoch
+        schema:
+          type: integer
+      - name: start_to
+        in: query
+        required: false
+        description: For filtering - end of start window - in seconds since epoch
+        schema:
+          type: integer
+      - name: end_from
+        in: query
+        required: false
+        description: For filtering - beginning of end window - in seconds since epoch
+        schema:
+          type: integer
+      - name: end_to
+        in: query
+        required: false
+        description: For filtering - end of end window - in seconds since epoch
+        schema:
+          type: integer
+      - name: process_status
+        in: query
+        required: false
+        description: For filtering - not_started, user_input_required, waiting, complete, error, or suspended
+        schema:
+          type: string
+      - name: initiated_by_me
+        in: query
+        required: false
+        description: For filtering - show instances initiated by me
+        schema:
+          type: boolean
+      - name: with_tasks_completed_by_me
+        in: query
+        required: false
+        description: For filtering - show instances with tasks completed by me
+        schema:
+          type: boolean
+      - name: with_tasks_completed_by_my_group
+        in: query
+        required: false
+        description: For filtering - show instances with tasks completed by my group
+        schema:
+          type: boolean
+      - name: with_relation_to_me
+        in: query
+        required: false
+        description: For filtering - show instances that have something to do with me
+        schema:
+          type: boolean
+      - name: user_filter
+        in: query
+        required: false
+        description: For filtering - indicates the user has manually entered a query
+        schema:
+          type: boolean
+      - name: report_identifier
+        in: query
+        required: false
+        description: Specifies the identifier of a report to use, if any
+        schema:
+          type: string
+      - name: report_id
+        in: query
+        required: false
+        description: Specifies the identifier of a report to use, if any
+        schema:
+          type: integer
+      - name: group_identifier
+        in: query
+        required: false
+        description: The identifier of the group to get the process instances for
+        schema:
+          type: string
+    get:
+      operationId: spiffworkflow_backend.routes.process_api_blueprint.process_instance_list_for_me
+      summary: Returns a list of process instances that are associated with me.
+      tags:
+        - Process Instances
+      responses:
+        "200":
+          description: Workflow.
+          content:
+            application/json:
+              schema:
+                type: array
+                items:
+                  $ref: "#/components/schemas/Workflow"
+
   /process-instances:
     parameters:
       - name: process_model_identifier
@@ -577,6 +690,12 @@ paths:
         description: For filtering - show instances with tasks completed by my group
         schema:
           type: boolean
+      - name: with_relation_to_me
+        in: query
+        required: false
+        description: For filtering - show instances that have something to do with me
+        schema:
+          type: boolean
       - name: user_filter
         in: query
         required: false
@@ -603,7 +722,7 @@ paths:
           type: string
     get:
       operationId: spiffworkflow_backend.routes.process_api_blueprint.process_instance_list
-      summary: Returns a list of process instances for a given process model
+      summary: Returns a list of process instances.
       tags:
         - Process Instances
       responses:
@@ -679,6 +798,53 @@ paths:
               schema:
                 $ref: "#/components/schemas/Workflow"
 
+  /process-instances/for-me/{modified_process_model_identifier}/{process_instance_id}/task-info:
+    parameters:
+      - name: modified_process_model_identifier
+        in: path
+        required: true
+        description: The unique id of an existing process model
+        schema:
+          type: string
+      - name: process_instance_id
+        in: path
+        required: true
+        description: The unique id of an existing process instance.
+        schema:
+          type: integer
+      - name: process_identifier
+        in: query
+        required: false
+        description: The identifier of the process to use for the diagram. Useful for displaying the diagram for a call activity.
+        schema:
+          type: string
+      - name: all_tasks
+        in: query
+        required: false
+        description: If true, this wil return all tasks associated with the process instance and not just user tasks.
+        schema:
+          type: boolean
+      - name: spiff_step
+        in: query
+        required: false
+        description: If set will return the tasks as they were during a specific step of execution.
+        schema:
+          type: integer
+    get:
+      tags:
+        - Process Instances
+      operationId: spiffworkflow_backend.routes.process_api_blueprint.process_instance_task_list_without_task_data_for_me
+      summary: returns the list of all user tasks associated with process instance without the task data
+      responses:
+        "200":
+          description: list of tasks
+          content:
+            application/json:
+              schema:
+                type: array
+                items:
+                  $ref: "#/components/schemas/Task"
+
   /process-instances/{modified_process_model_identifier}/{process_instance_id}/task-info:
     parameters:
       - name: modified_process_model_identifier
@@ -726,6 +892,39 @@ paths:
                 items:
                   $ref: "#/components/schemas/Task"
 
+  /process-instances/for-me/{modified_process_model_identifier}/{process_instance_id}:
+    parameters:
+      - name: modified_process_model_identifier
+        in: path
+        required: true
+        description: The unique id of an existing process model
+        schema:
+          type: string
+      - name: process_instance_id
+        in: path
+        required: true
+        description: The unique id of an existing process instance.
+        schema:
+          type: integer
+      - name: process_identifier
+        in: query
+        required: false
+        description: The identifier of the process to use for the diagram. Useful for displaying the diagram for a call activity.
+        schema:
+          type: string
+    get:
+      tags:
+        - Process Instances
+      operationId: spiffworkflow_backend.routes.process_api_blueprint.process_instance_show_for_me
+      summary: Show information about a process instance that is associated with me
+      responses:
+        "200":
+          description: One Process Instance
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/Workflow"
+
   /process-instances/{modified_process_model_identifier}/{process_instance_id}:
     parameters:
       - name: modified_process_model_identifier

src/spiffworkflow_backend/config/permissions/development.yml

@@ -115,15 +115,15 @@ permissions:
     users: []
     allowed_permissions: [read]
     uri: /v1.0/process-models/*
-  read-all-process-instance:
+  read-all-process-instances-for-me:
     groups: [everybody]
     users: []
     allowed_permissions: [read]
-    uri: /v1.0/process-instances/*
+    uri: /v1.0/process-instances/for-me/*
   read-process-instance-reports:
     groups: [everybody]
     users: []
-    allowed_permissions: [read]
+    allowed_permissions: [create, read, update, delete]
     uri: /v1.0/process-instances/reports/*
   processes-read:
     groups: [everybody]

src/spiffworkflow_backend/config/permissions/staging.yml

@@ -98,15 +98,15 @@ permissions:
     users: []
     allowed_permissions: [read]
     uri: /v1.0/process-models/*
-  read-all-process-instance:
+  read-all-process-instances-for-me:
     groups: [everybody]
     users: []
     allowed_permissions: [read]
-    uri: /v1.0/process-instances/*
+    uri: /v1.0/process-instances/for-me/*
-  read-process-instance-reports:
+  manage-process-instance-reports:
     groups: [everybody]
     users: []
-    allowed_permissions: [read]
+    allowed_permissions: [create, read, update, delete]
     uri: /v1.0/process-instances/reports/*
   processes-read:
     groups: [everybody]

src/spiffworkflow_backend/config/permissions/terraform_deployed_environment.yml

@@ -93,15 +93,15 @@ permissions:
     users: []
     allowed_permissions: [read]
     uri: /v1.0/process-models/*
-  read-all-process-instance:
+  read-all-process-instances-for-me:
     groups: [everybody]
     users: []
     allowed_permissions: [read]
-    uri: /v1.0/process-instances/*
+    uri: /v1.0/process-instances/for-me/*
   read-process-instance-reports:
     groups: [everybody]
     users: []
-    allowed_permissions: [read]
+    allowed_permissions: [create, read, update, delete]
     uri: /v1.0/process-instances/reports/*
   processes-read:
     groups: [everybody]

src/spiffworkflow_backend/load_database_models.py

@@ -17,7 +17,7 @@ from spiffworkflow_backend.models.user_group_assignment import (
 from spiffworkflow_backend.models.principal import PrincipalModel  # noqa: F401
 
 
-from spiffworkflow_backend.models.active_task import ActiveTaskModel  # noqa: F401
+from spiffworkflow_backend.models.human_task import HumanTaskModel  # noqa: F401
 from spiffworkflow_backend.models.spec_reference import (
     SpecReferenceCache,
 )  # noqa: F401

src/spiffworkflow_backend/models/human_task.py

@@ -1,4 +1,4 @@
-"""Active_task."""
+"""Human_task."""
 from __future__ import annotations
 
 from dataclasses import dataclass
@@ -17,20 +17,18 @@ from spiffworkflow_backend.models.user import UserModel
 
 
 if TYPE_CHECKING:
-    from spiffworkflow_backend.models.active_task_user import (  # noqa: F401
+    from spiffworkflow_backend.models.human_task_user import (  # noqa: F401
-        ActiveTaskUserModel,
+        HumanTaskUserModel,
     )
 
 
 @dataclass
-class ActiveTaskModel(SpiffworkflowBaseDBModel):
+class HumanTaskModel(SpiffworkflowBaseDBModel):
-    """ActiveTaskModel."""
+    """HumanTaskModel."""
 
-    __tablename__ = "active_task"
+    __tablename__ = "human_task"
     __table_args__ = (
-        db.UniqueConstraint(
+        db.UniqueConstraint("task_id", "process_instance_id", name="human_task_unique"),
-            "task_id", "process_instance_id", name="active_task_unique"
-        ),
     )
 
     actual_owner: RelationshipProperty[UserModel] = relationship(UserModel)
@@ -52,17 +50,18 @@ class ActiveTaskModel(SpiffworkflowBaseDBModel):
     task_type: str = db.Column(db.String(50))
     task_status: str = db.Column(db.String(50))
     process_model_display_name: str = db.Column(db.String(255))
+    completed: bool = db.Column(db.Boolean, default=False, nullable=False, index=True)
 
-    active_task_users = relationship("ActiveTaskUserModel", cascade="delete")
+    human_task_users = relationship("HumanTaskUserModel", cascade="delete")
     potential_owners = relationship(  # type: ignore
         "UserModel",
         viewonly=True,
-        secondary="active_task_user",
+        secondary="human_task_user",
-        overlaps="active_task_user,users",
+        overlaps="human_task_user,users",
     )
 
     @classmethod
-    def to_task(cls, task: ActiveTaskModel) -> Task:
+    def to_task(cls, task: HumanTaskModel) -> Task:
         """To_task."""
         new_task = Task(
             task.task_id,
@@ -79,7 +78,7 @@ class ActiveTaskModel(SpiffworkflowBaseDBModel):
         if hasattr(task, "process_model_identifier"):
             new_task.process_model_identifier = task.process_model_identifier
 
-        # active tasks only have status when getting the list on the home page
+        # human tasks only have status when getting the list on the home page
         # and it comes from the process_instance. it should not be confused with task_status.
         if hasattr(task, "status"):
             new_task.process_instance_status = task.status

src/spiffworkflow_backend/models/human_task_user.py

@@ -1,4 +1,4 @@
-"""Active_task_user."""
+"""Human_task_user."""
 from __future__ import annotations
 
 from dataclasses import dataclass
@@ -7,26 +7,26 @@ from flask_bpmn.models.db import db
 from flask_bpmn.models.db import SpiffworkflowBaseDBModel
 from sqlalchemy import ForeignKey
 
-from spiffworkflow_backend.models.active_task import ActiveTaskModel
+from spiffworkflow_backend.models.human_task import HumanTaskModel
 from spiffworkflow_backend.models.user import UserModel
 
 
 @dataclass
-class ActiveTaskUserModel(SpiffworkflowBaseDBModel):
+class HumanTaskUserModel(SpiffworkflowBaseDBModel):
-    """ActiveTaskUserModel."""
+    """HumanTaskUserModel."""
 
-    __tablename__ = "active_task_user"
+    __tablename__ = "human_task_user"
 
     __table_args__ = (
         db.UniqueConstraint(
-            "active_task_id",
+            "human_task_id",
             "user_id",
-            name="active_task_user_unique",
+            name="human_task_user_unique",
         ),
     )
 
     id = db.Column(db.Integer, primary_key=True)
-    active_task_id = db.Column(
+    human_task_id = db.Column(
-        ForeignKey(ActiveTaskModel.id), nullable=False, index=True  # type: ignore
+        ForeignKey(HumanTaskModel.id), nullable=False, index=True  # type: ignore
     )
     user_id = db.Column(ForeignKey(UserModel.id), nullable=False, index=True)

src/spiffworkflow_backend/models/process_instance.py

@@ -34,36 +34,6 @@ class ProcessInstanceCannotBeDeletedError(Exception):
     """ProcessInstanceCannotBeDeletedError."""
 
 
-class NavigationItemSchema(Schema):
-    """NavigationItemSchema."""
-
-    class Meta:
-        """Meta."""
-
-        fields = [
-            "spec_id",
-            "name",
-            "spec_type",
-            "task_id",
-            "description",
-            "backtracks",
-            "indent",
-            "lane",
-            "state",
-            "children",
-        ]
-        unknown = INCLUDE
-
-    state = marshmallow.fields.String(required=False, allow_none=True)
-    description = marshmallow.fields.String(required=False, allow_none=True)
-    backtracks = marshmallow.fields.String(required=False, allow_none=True)
-    lane = marshmallow.fields.String(required=False, allow_none=True)
-    task_id = marshmallow.fields.String(required=False, allow_none=True)
-    children = marshmallow.fields.List(
-        marshmallow.fields.Nested(lambda: NavigationItemSchema())
-    )
-
-
 class ProcessInstanceStatus(SpiffEnum):
     """ProcessInstanceStatus."""
 
@@ -90,7 +60,11 @@ class ProcessInstanceModel(SpiffworkflowBaseDBModel):
     process_initiator_id: int = db.Column(ForeignKey(UserModel.id), nullable=False)
     process_initiator = relationship("UserModel")
 
-    active_tasks = relationship("ActiveTaskModel", cascade="delete")  # type: ignore
+    human_tasks = relationship(
+        "HumanTaskModel",
+        cascade="delete",
+        primaryjoin="and_(HumanTaskModel.process_instance_id==ProcessInstanceModel.id, HumanTaskModel.completed == False)",
+    )  # type: ignore
     message_instances = relationship("MessageInstanceModel", cascade="delete")  # type: ignore
     message_correlations = relationship("MessageCorrelationModel", cascade="delete")  # type: ignore
 
@@ -139,6 +113,10 @@ class ProcessInstanceModel(SpiffworkflowBaseDBModel):
         """Validate_status."""
         return self.validate_enum_field(key, value, ProcessInstanceStatus)
 
+    def can_submit_task(self) -> bool:
+        """Can_submit_task."""
+        return not self.has_terminal_status() and self.status != "suspended"
+
     def has_terminal_status(self) -> bool:
         """Has_terminal_status."""
         return self.status in self.terminal_statuses()

src/spiffworkflow_backend/routes/process_api_blueprint.py

@@ -33,16 +33,17 @@ from sqlalchemy import and_
 from sqlalchemy import asc
 from sqlalchemy import desc
 from sqlalchemy import func
+from sqlalchemy import or_
 from sqlalchemy.orm import aliased
 from sqlalchemy.orm import selectinload
 
 from spiffworkflow_backend.exceptions.process_entity_not_found_error import (
     ProcessEntityNotFoundError,
 )
-from spiffworkflow_backend.models.active_task import ActiveTaskModel
-from spiffworkflow_backend.models.active_task_user import ActiveTaskUserModel
 from spiffworkflow_backend.models.file import FileSchema
 from spiffworkflow_backend.models.group import GroupModel
+from spiffworkflow_backend.models.human_task import HumanTaskModel
+from spiffworkflow_backend.models.human_task_user import HumanTaskUserModel
 from spiffworkflow_backend.models.message_correlation import MessageCorrelationModel
 from spiffworkflow_backend.models.message_instance import MessageInstanceModel
 from spiffworkflow_backend.models.message_model import MessageModel
@@ -847,6 +848,38 @@ def message_start(
     )
 
 
+def process_instance_list_for_me(
+    process_model_identifier: Optional[str] = None,
+    page: int = 1,
+    per_page: int = 100,
+    start_from: Optional[int] = None,
+    start_to: Optional[int] = None,
+    end_from: Optional[int] = None,
+    end_to: Optional[int] = None,
+    process_status: Optional[str] = None,
+    user_filter: Optional[bool] = False,
+    report_identifier: Optional[str] = None,
+    report_id: Optional[int] = None,
+    group_identifier: Optional[str] = None,
+) -> flask.wrappers.Response:
+    """Process_instance_list_for_me."""
+    return process_instance_list(
+        process_model_identifier=process_model_identifier,
+        page=page,
+        per_page=per_page,
+        start_from=start_from,
+        start_to=start_to,
+        end_from=end_from,
+        end_to=end_to,
+        process_status=process_status,
+        user_filter=user_filter,
+        report_identifier=report_identifier,
+        report_id=report_id,
+        group_identifier=group_identifier,
+        with_relation_to_me=True,
+    )
+
+
 def process_instance_list(
     process_model_identifier: Optional[str] = None,
     page: int = 1,
@@ -859,6 +892,7 @@ def process_instance_list(
     initiated_by_me: Optional[bool] = None,
     with_tasks_completed_by_me: Optional[bool] = None,
     with_tasks_completed_by_my_group: Optional[bool] = None,
+    with_relation_to_me: Optional[bool] = None,
     user_filter: Optional[bool] = False,
     report_identifier: Optional[str] = None,
     report_id: Optional[int] = None,
@@ -868,6 +902,7 @@ def process_instance_list(
     process_instance_report = ProcessInstanceReportService.report_with_identifier(
         g.user, report_id, report_identifier
     )
+    print(f"with_relation_to_me: {with_relation_to_me}")
 
     if user_filter:
         report_filter = ProcessInstanceReportFilter(
@@ -880,6 +915,7 @@ def process_instance_list(
             initiated_by_me,
             with_tasks_completed_by_me,
             with_tasks_completed_by_my_group,
+            with_relation_to_me,
         )
     else:
         report_filter = (
@@ -894,6 +930,7 @@ def process_instance_list(
                 initiated_by_me,
                 with_tasks_completed_by_me,
                 with_tasks_completed_by_my_group,
+                with_relation_to_me,
             )
         )
 
@@ -954,6 +991,23 @@ def process_instance_list(
             process_initiator=g.user
         )
 
+    if report_filter.with_relation_to_me is True:
+        process_instance_query = process_instance_query.outerjoin(
+            HumanTaskModel
+        ).outerjoin(
+            HumanTaskUserModel,
+            and_(
+                HumanTaskModel.id == HumanTaskUserModel.human_task_id,
+                HumanTaskUserModel.user_id == g.user.id,
+            ),
+        )
+        process_instance_query = process_instance_query.filter(
+            or_(
+                HumanTaskUserModel.id.is_not(None),
+                ProcessInstanceModel.process_initiator_id == g.user.id,
+            )
+        )
+
     # TODO: not sure if this is exactly what is wanted
     if report_filter.with_tasks_completed_by_me is True:
         process_instance_query = process_instance_query.filter(
@@ -1120,14 +1174,41 @@ def process_instance_report_column_list() -> flask.wrappers.Response:
     return make_response(jsonify(table_columns + columns_for_metadata_strings), 200)
 
 
+def process_instance_show_for_me(
+    modified_process_model_identifier: str,
+    process_instance_id: int,
+    process_identifier: Optional[str] = None,
+) -> flask.wrappers.Response:
+    """Process_instance_show_for_me."""
+    process_instance = _find_process_instance_for_me_or_raise(process_instance_id)
+    return _get_process_instance(
+        process_instance=process_instance,
+        modified_process_model_identifier=modified_process_model_identifier,
+        process_identifier=process_identifier,
+    )
+
+
 def process_instance_show(
     modified_process_model_identifier: str,
     process_instance_id: int,
     process_identifier: Optional[str] = None,
 ) -> flask.wrappers.Response:
     """Create_process_instance."""
-    process_model_identifier = modified_process_model_identifier.replace(":", "/")
     process_instance = find_process_instance_by_id_or_raise(process_instance_id)
+    return _get_process_instance(
+        process_instance=process_instance,
+        modified_process_model_identifier=modified_process_model_identifier,
+        process_identifier=process_identifier,
+    )
+
+
+def _get_process_instance(
+    modified_process_model_identifier: str,
+    process_instance: ProcessInstanceModel,
+    process_identifier: Optional[str] = None,
+) -> flask.wrappers.Response:
+    """_get_process_instance."""
+    process_model_identifier = modified_process_model_identifier.replace(":", "/")
     current_version_control_revision = GitService.get_current_revision()
 
     process_model_with_diagram = None
@@ -1335,35 +1416,36 @@ def process_instance_report_show(
 def task_list_my_tasks(page: int = 1, per_page: int = 100) -> flask.wrappers.Response:
     """Task_list_my_tasks."""
     principal = find_principal_or_raise()
-    active_tasks = (
+    human_tasks = (
-        ActiveTaskModel.query.order_by(desc(ActiveTaskModel.id))  # type: ignore
+        HumanTaskModel.query.order_by(desc(HumanTaskModel.id))  # type: ignore
         .join(ProcessInstanceModel)
-        .join(ActiveTaskUserModel)
+        .join(HumanTaskUserModel)
         .filter_by(user_id=principal.user_id)
+        .filter(HumanTaskModel.completed == False)  # noqa: E712
         # just need this add_columns to add the process_model_identifier. Then add everything back that was removed.
         .add_columns(
             ProcessInstanceModel.process_model_identifier,
             ProcessInstanceModel.process_model_display_name,
             ProcessInstanceModel.status,
-            ActiveTaskModel.task_name,
+            HumanTaskModel.task_name,
-            ActiveTaskModel.task_title,
+            HumanTaskModel.task_title,
-            ActiveTaskModel.task_type,
+            HumanTaskModel.task_type,
-            ActiveTaskModel.task_status,
+            HumanTaskModel.task_status,
-            ActiveTaskModel.task_id,
+            HumanTaskModel.task_id,
-            ActiveTaskModel.id,
+            HumanTaskModel.id,
-            ActiveTaskModel.process_model_display_name,
+            HumanTaskModel.process_model_display_name,
-            ActiveTaskModel.process_instance_id,
+            HumanTaskModel.process_instance_id,
         )
         .paginate(page=page, per_page=per_page, error_out=False)
     )
-    tasks = [ActiveTaskModel.to_task(active_task) for active_task in active_tasks.items]
+    tasks = [HumanTaskModel.to_task(human_task) for human_task in human_tasks.items]
 
     response_json = {
         "results": tasks,
         "pagination": {
-            "count": len(active_tasks.items),
+            "count": len(human_tasks.items),
-            "total": active_tasks.total,
+            "total": human_tasks.total,
-            "pages": active_tasks.pages,
+            "pages": human_tasks.pages,
         },
     }
 
@@ -1417,74 +1499,97 @@ def get_tasks(
     """Get_tasks."""
     user_id = g.user.id
 
-    # use distinct to ensure we only get one row per active task otherwise
+    # use distinct to ensure we only get one row per human task otherwise
-    # we can get back multiple for the same active task row which throws off
+    # we can get back multiple for the same human task row which throws off
     # pagination later on
     # https://stackoverflow.com/q/34582014/6090676
-    active_tasks_query = (
+    human_tasks_query = (
-        ActiveTaskModel.query.distinct()
+        HumanTaskModel.query.distinct()
-        .outerjoin(GroupModel, GroupModel.id == ActiveTaskModel.lane_assignment_id)
+        .outerjoin(GroupModel, GroupModel.id == HumanTaskModel.lane_assignment_id)
         .join(ProcessInstanceModel)
         .join(UserModel, UserModel.id == ProcessInstanceModel.process_initiator_id)
+        .filter(HumanTaskModel.completed == False)  # noqa: E712
     )
 
     if processes_started_by_user:
-        active_tasks_query = active_tasks_query.filter(
+        human_tasks_query = human_tasks_query.filter(
             ProcessInstanceModel.process_initiator_id == user_id
         ).outerjoin(
-            ActiveTaskUserModel,
+            HumanTaskUserModel,
             and_(
-                ActiveTaskUserModel.user_id == user_id,
+                HumanTaskUserModel.user_id == user_id,
-                ActiveTaskModel.id == ActiveTaskUserModel.active_task_id,
+                HumanTaskModel.id == HumanTaskUserModel.human_task_id,
             ),
         )
     else:
-        active_tasks_query = active_tasks_query.filter(
+        human_tasks_query = human_tasks_query.filter(
             ProcessInstanceModel.process_initiator_id != user_id
         ).join(
-            ActiveTaskUserModel,
+            HumanTaskUserModel,
             and_(
-                ActiveTaskUserModel.user_id == user_id,
+                HumanTaskUserModel.user_id == user_id,
-                ActiveTaskModel.id == ActiveTaskUserModel.active_task_id,
+                HumanTaskModel.id == HumanTaskUserModel.human_task_id,
             ),
         )
         if has_lane_assignment_id:
             if group_identifier:
-                active_tasks_query = active_tasks_query.filter(
+                human_tasks_query = human_tasks_query.filter(
                     GroupModel.identifier == group_identifier
                 )
             else:
-                active_tasks_query = active_tasks_query.filter(
+                human_tasks_query = human_tasks_query.filter(
-                    ActiveTaskModel.lane_assignment_id.is_not(None)  # type: ignore
+                    HumanTaskModel.lane_assignment_id.is_not(None)  # type: ignore
                 )
         else:
-            active_tasks_query = active_tasks_query.filter(ActiveTaskModel.lane_assignment_id.is_(None))  # type: ignore
+            human_tasks_query = human_tasks_query.filter(HumanTaskModel.lane_assignment_id.is_(None))  # type: ignore
 
-    active_tasks = active_tasks_query.add_columns(
+    human_tasks = (
-        ProcessInstanceModel.process_model_identifier,
+        human_tasks_query.add_columns(
-        ProcessInstanceModel.status.label("process_instance_status"),  # type: ignore
+            ProcessInstanceModel.process_model_identifier,
-        ProcessInstanceModel.updated_at_in_seconds,
+            ProcessInstanceModel.status.label("process_instance_status"),  # type: ignore
-        ProcessInstanceModel.created_at_in_seconds,
+            ProcessInstanceModel.updated_at_in_seconds,
-        UserModel.username,
+            ProcessInstanceModel.created_at_in_seconds,
-        GroupModel.identifier.label("group_identifier"),
+            UserModel.username,
-        ActiveTaskModel.task_name,
+            GroupModel.identifier.label("group_identifier"),
-        ActiveTaskModel.task_title,
+            HumanTaskModel.task_name,
-        ActiveTaskModel.process_model_display_name,
+            HumanTaskModel.task_title,
-        ActiveTaskModel.process_instance_id,
+            HumanTaskModel.process_model_display_name,
-        ActiveTaskUserModel.user_id.label("current_user_is_potential_owner"),
+            HumanTaskModel.process_instance_id,
-    ).paginate(page=page, per_page=per_page, error_out=False)
+            HumanTaskUserModel.user_id.label("current_user_is_potential_owner"),
+        )
+        .order_by(desc(HumanTaskModel.id))  # type: ignore
+        .paginate(page=page, per_page=per_page, error_out=False)
+    )
 
     response_json = {
-        "results": active_tasks.items,
+        "results": human_tasks.items,
         "pagination": {
-            "count": len(active_tasks.items),
+            "count": len(human_tasks.items),
-            "total": active_tasks.total,
+            "total": human_tasks.total,
-            "pages": active_tasks.pages,
+            "pages": human_tasks.pages,
         },
     }
     return make_response(jsonify(response_json), 200)
 
 
+def process_instance_task_list_without_task_data_for_me(
+    modified_process_model_identifier: str,
+    process_instance_id: int,
+    all_tasks: bool = False,
+    spiff_step: int = 0,
+) -> flask.wrappers.Response:
+    """Process_instance_task_list_without_task_data_for_me."""
+    process_instance = _find_process_instance_for_me_or_raise(process_instance_id)
+    print(f"process_instance: {process_instance}")
+    return process_instance_task_list(
+        modified_process_model_identifier,
+        process_instance,
+        all_tasks,
+        spiff_step,
+        get_task_data=False,
+    )
+
+
 def process_instance_task_list_without_task_data(
     modified_process_model_identifier: str,
     process_instance_id: int,
@@ -1492,9 +1597,10 @@ def process_instance_task_list_without_task_data(
     spiff_step: int = 0,
 ) -> flask.wrappers.Response:
     """Process_instance_task_list_without_task_data."""
+    process_instance = find_process_instance_by_id_or_raise(process_instance_id)
     return process_instance_task_list(
         modified_process_model_identifier,
-        process_instance_id,
+        process_instance,
         all_tasks,
         spiff_step,
         get_task_data=False,
@@ -1508,9 +1614,10 @@ def process_instance_task_list_with_task_data(
     spiff_step: int = 0,
 ) -> flask.wrappers.Response:
     """Process_instance_task_list_with_task_data."""
+    process_instance = find_process_instance_by_id_or_raise(process_instance_id)
     return process_instance_task_list(
         modified_process_model_identifier,
-        process_instance_id,
+        process_instance,
         all_tasks,
         spiff_step,
         get_task_data=True,
@@ -1519,19 +1626,17 @@ def process_instance_task_list_with_task_data(
 
 def process_instance_task_list(
     _modified_process_model_identifier: str,
-    process_instance_id: int,
+    process_instance: ProcessInstanceModel,
     all_tasks: bool = False,
     spiff_step: int = 0,
     get_task_data: bool = False,
 ) -> flask.wrappers.Response:
     """Process_instance_task_list."""
-    process_instance = find_process_instance_by_id_or_raise(process_instance_id)
-
     if spiff_step > 0:
         step_detail = (
             db.session.query(SpiffStepDetailsModel)
             .filter(
-                SpiffStepDetailsModel.process_instance_id == process_instance.id,
+                SpiffStepDetailsModel.process_instance.id == process_instance.id,
                 SpiffStepDetailsModel.spiff_step == spiff_step,
             )
             .first()
@@ -1672,6 +1777,13 @@ def task_submit(
     """Task_submit_user_data."""
     principal = find_principal_or_raise()
     process_instance = find_process_instance_by_id_or_raise(process_instance_id)
+    if not process_instance.can_submit_task():
+        raise ApiError(
+            error_code="process_instance_not_runnable",
+            message=f"Process Instance ({process_instance.id}) has status "
+            f"{process_instance.status} which does not allow tasks to be submitted.",
+            status_code=400,
+        )
 
     processor = ProcessInstanceProcessor(process_instance)
     spiff_task = get_spiff_task_from_process_instance(
@@ -1693,14 +1805,14 @@ def task_submit(
     if terminate_loop and spiff_task.is_looping():
         spiff_task.terminate_loop()
 
-    active_task = ActiveTaskModel.query.filter_by(
+    human_task = HumanTaskModel.query.filter_by(
-        process_instance_id=process_instance_id, task_id=task_id
+        process_instance_id=process_instance_id, task_id=task_id, completed=False
     ).first()
-    if active_task is None:
+    if human_task is None:
         raise (
             ApiError(
-                error_code="no_active_task",
+                error_code="no_human_task",
-                message="Cannot find an active task with task id '{task_id}' for process instance {process_instance_id}.",
+                message="Cannot find an human task with task id '{task_id}' for process instance {process_instance_id}.",
                 status_code=500,
             )
         )
@@ -1710,7 +1822,7 @@ def task_submit(
         spiff_task=spiff_task,
         data=body,
         user=g.user,
-        active_task=active_task,
+        human_task=human_task,
     )
 
     # If we need to update all tasks, then get the next ready task and if it a multi-instance with the same
@@ -1723,16 +1835,18 @@ def task_submit(
     #         last_index = next_task.task_info()["mi_index"]
     #         next_task = processor.next_task()
 
-    next_active_task_assigned_to_me = (
+    next_human_task_assigned_to_me = (
-        ActiveTaskModel.query.filter_by(process_instance_id=process_instance_id)
+        HumanTaskModel.query.filter_by(
-        .order_by(asc(ActiveTaskModel.id))  # type: ignore
+            process_instance_id=process_instance_id, completed=False
-        .join(ActiveTaskUserModel)
+        )
+        .order_by(asc(HumanTaskModel.id))  # type: ignore
+        .join(HumanTaskUserModel)
         .filter_by(user_id=principal.user_id)
         .first()
     )
-    if next_active_task_assigned_to_me:
+    if next_human_task_assigned_to_me:
         return make_response(
-            jsonify(ActiveTaskModel.to_task(next_active_task_assigned_to_me)), 200
+            jsonify(HumanTaskModel.to_task(next_human_task_assigned_to_me)), 200
         )
 
     return Response(json.dumps({"ok": True}), status=202, mimetype="application/json")
@@ -2225,3 +2339,38 @@ def commit_and_push_to_git(message: str) -> None:
         current_app.logger.info(f"git output: {git_output}")
     else:
         current_app.logger.info("Git commit on save is disabled")
+
+
+def _find_process_instance_for_me_or_raise(
+    process_instance_id: int,
+) -> ProcessInstanceModel:
+    """_find_process_instance_for_me_or_raise."""
+    process_instance: ProcessInstanceModel = (
+        ProcessInstanceModel.query.filter_by(id=process_instance_id)
+        .outerjoin(HumanTaskModel)
+        .outerjoin(
+            HumanTaskUserModel,
+            and_(
+                HumanTaskModel.id == HumanTaskUserModel.human_task_id,
+                HumanTaskUserModel.user_id == g.user.id,
+            ),
+        )
+        .filter(
+            or_(
+                HumanTaskUserModel.id.is_not(None),
+                ProcessInstanceModel.process_initiator_id == g.user.id,
+            )
+        )
+        .first()
+    )
+
+    if process_instance is None:
+        raise (
+            ApiError(
+                error_code="process_instance_cannot_be_found",
+                message=f"Process instance with id {process_instance_id} cannot be found that is associated with you.",
+                status_code=400,
+            )
+        )
+
+    return process_instance

src/spiffworkflow_backend/services/authorization_service.py

@@ -19,8 +19,8 @@ from SpiffWorkflow.task import Task as SpiffTask  # type: ignore
 from sqlalchemy import or_
 from sqlalchemy import text
 
-from spiffworkflow_backend.models.active_task import ActiveTaskModel
 from spiffworkflow_backend.models.group import GroupModel
+from spiffworkflow_backend.models.human_task import HumanTaskModel
 from spiffworkflow_backend.models.permission_assignment import PermissionAssignmentModel
 from spiffworkflow_backend.models.permission_target import PermissionTargetModel
 from spiffworkflow_backend.models.principal import MissingPrincipalError
@@ -37,8 +37,8 @@ class PermissionsFileNotSetError(Exception):
     """PermissionsFileNotSetError."""
 
 
-class ActiveTaskNotFoundError(Exception):
+class HumanTaskNotFoundError(Exception):
-    """ActiveTaskNotFoundError."""
+    """HumanTaskNotFoundError."""
 
 
 class UserDoesNotHaveAccessToTaskError(Exception):
@@ -429,17 +429,17 @@ class AuthorizationService:
         user: UserModel,
     ) -> bool:
         """Assert_user_can_complete_spiff_task."""
-        active_task = ActiveTaskModel.query.filter_by(
+        human_task = HumanTaskModel.query.filter_by(
             task_name=spiff_task.task_spec.name,
             process_instance_id=process_instance_id,
         ).first()
-        if active_task is None:
+        if human_task is None:
-            raise ActiveTaskNotFoundError(
+            raise HumanTaskNotFoundError(
-                f"Could find an active task with task name '{spiff_task.task_spec.name}'"
+                f"Could find an human task with task name '{spiff_task.task_spec.name}'"
                 f" for process instance '{process_instance_id}'"
             )
 
-        if user not in active_task.potential_owners:
+        if user not in human_task.potential_owners:
             raise UserDoesNotHaveAccessToTaskError(
                 f"User {user.username} does not have access to update task'{spiff_task.task_spec.name}'"
                 f" for process instance '{process_instance_id}'"
@@ -485,7 +485,7 @@ class AuthorizationService:
         cls.import_permissions_from_yaml_file()
 
         if is_new_user:
-            UserService.add_user_to_active_tasks_if_appropriate(user_model)
+            UserService.add_user_to_human_tasks_if_appropriate(user_model)
 
         # this cannot be None so ignore mypy
         return user_model  # type: ignore

src/spiffworkflow_backend/services/process_instance_processor.py

@@ -65,11 +65,11 @@ from SpiffWorkflow.task import Task as SpiffTask  # type: ignore
 from SpiffWorkflow.task import TaskState
 from SpiffWorkflow.util.deep_merge import DeepMerge  # type: ignore
 
-from spiffworkflow_backend.models.active_task import ActiveTaskModel
-from spiffworkflow_backend.models.active_task_user import ActiveTaskUserModel
 from spiffworkflow_backend.models.file import File
 from spiffworkflow_backend.models.file import FileType
 from spiffworkflow_backend.models.group import GroupModel
+from spiffworkflow_backend.models.human_task import HumanTaskModel
+from spiffworkflow_backend.models.human_task_user import HumanTaskUserModel
 from spiffworkflow_backend.models.message_correlation import MessageCorrelationModel
 from spiffworkflow_backend.models.message_correlation_message_instance import (
     MessageCorrelationMessageInstanceModel,
@@ -575,10 +575,10 @@ class ProcessInstanceProcessor:
         )
         return details_model
 
-    def save_spiff_step_details(self, active_task: ActiveTaskModel) -> None:
+    def save_spiff_step_details(self, human_task: HumanTaskModel) -> None:
         """SaveSpiffStepDetails."""
         details_model = self.spiff_step_details()
-        details_model.lane_assignment_id = active_task.lane_assignment_id
+        details_model.lane_assignment_id = human_task.lane_assignment_id
         db.session.add(details_model)
         db.session.commit()
 
@@ -639,7 +639,7 @@ class ProcessInstanceProcessor:
         db.session.add(self.process_instance_model)
         db.session.commit()
 
-        active_tasks = ActiveTaskModel.query.filter_by(
+        human_tasks = HumanTaskModel.query.filter_by(
             process_instance_id=self.process_instance_model.id
         ).all()
         ready_or_waiting_tasks = self.get_all_ready_or_waiting_tasks()
@@ -670,14 +670,14 @@ class ProcessInstanceProcessor:
                     if "formUiSchemaFilename" in properties:
                         ui_form_file_name = properties["formUiSchemaFilename"]
 
-                active_task = None
+                human_task = None
-                for at in active_tasks:
+                for at in human_tasks:
                     if at.task_id == str(ready_or_waiting_task.id):
-                        active_task = at
+                        human_task = at
-                        active_tasks.remove(at)
+                        human_tasks.remove(at)
 
-                if active_task is None:
+                if human_task is None:
-                    active_task = ActiveTaskModel(
+                    human_task = HumanTaskModel(
                         process_instance_id=self.process_instance_model.id,
                         process_model_display_name=process_model_display_name,
                         form_file_name=form_file_name,
@@ -689,21 +689,22 @@ class ProcessInstanceProcessor:
                         task_status=ready_or_waiting_task.get_state_name(),
                         lane_assignment_id=potential_owner_hash["lane_assignment_id"],
                     )
-                    db.session.add(active_task)
+                    db.session.add(human_task)
                     db.session.commit()
 
                     for potential_owner_id in potential_owner_hash[
                         "potential_owner_ids"
                     ]:
-                        active_task_user = ActiveTaskUserModel(
+                        human_task_user = HumanTaskUserModel(
-                            user_id=potential_owner_id, active_task_id=active_task.id
+                            user_id=potential_owner_id, human_task_id=human_task.id
                         )
-                        db.session.add(active_task_user)
+                        db.session.add(human_task_user)
                     db.session.commit()
 
-        if len(active_tasks) > 0:
+        if len(human_tasks) > 0:
-            for at in active_tasks:
+            for at in human_tasks:
-                db.session.delete(at)
+                at.completed = True
+                db.session.add(at)
             db.session.commit()
 
     def serialize_task_spec(self, task_spec: SpiffTask) -> Any:
@@ -1208,11 +1209,11 @@ class ProcessInstanceProcessor:
         )
         return user_tasks  # type: ignore
 
-    def complete_task(self, task: SpiffTask, active_task: ActiveTaskModel) -> None:
+    def complete_task(self, task: SpiffTask, human_task: HumanTaskModel) -> None:
         """Complete_task."""
         self.increment_spiff_step()
         self.bpmn_process_instance.complete_task_from_id(task.id)
-        self.save_spiff_step_details(active_task)
+        self.save_spiff_step_details(human_task)
 
     def get_data(self) -> dict[str, Any]:
         """Get_data."""

src/spiffworkflow_backend/services/process_instance_report_service.py

@@ -24,6 +24,7 @@ class ProcessInstanceReportFilter:
     initiated_by_me: Optional[bool] = None
     with_tasks_completed_by_me: Optional[bool] = None
     with_tasks_completed_by_my_group: Optional[bool] = None
+    with_relation_to_me: Optional[bool] = None
 
     def to_dict(self) -> dict[str, str]:
         """To_dict."""
@@ -51,6 +52,8 @@ class ProcessInstanceReportFilter:
             d["with_tasks_completed_by_my_group"] = str(
                 self.with_tasks_completed_by_my_group
             ).lower()
+        if self.with_relation_to_me is not None:
+            d["with_relation_to_me"] = str(self.with_relation_to_me).lower()
 
         return d
 
@@ -174,6 +177,7 @@ class ProcessInstanceReportService:
         with_tasks_completed_by_my_group = bool_value(
             "with_tasks_completed_by_my_group"
         )
+        with_relation_to_me = bool_value("with_relation_to_me")
 
         report_filter = ProcessInstanceReportFilter(
             process_model_identifier,
@@ -185,6 +189,7 @@ class ProcessInstanceReportService:
             initiated_by_me,
             with_tasks_completed_by_me,
             with_tasks_completed_by_my_group,
+            with_relation_to_me,
         )
 
         return report_filter
@@ -202,6 +207,7 @@ class ProcessInstanceReportService:
         initiated_by_me: Optional[bool] = None,
         with_tasks_completed_by_me: Optional[bool] = None,
         with_tasks_completed_by_my_group: Optional[bool] = None,
+        with_relation_to_me: Optional[bool] = None,
     ) -> ProcessInstanceReportFilter:
         """Filter_from_metadata_with_overrides."""
         report_filter = cls.filter_from_metadata(process_instance_report)
@@ -226,6 +232,8 @@ class ProcessInstanceReportService:
             report_filter.with_tasks_completed_by_my_group = (
                 with_tasks_completed_by_my_group
             )
+        if with_relation_to_me is not None:
+            report_filter.with_relation_to_me = with_relation_to_me
 
         return report_filter
 

src/spiffworkflow_backend/services/process_instance_service.py

@@ -8,7 +8,7 @@ from flask_bpmn.api.api_error import ApiError
 from flask_bpmn.models.db import db
 from SpiffWorkflow.task import Task as SpiffTask  # type: ignore
 
-from spiffworkflow_backend.models.active_task import ActiveTaskModel
+from spiffworkflow_backend.models.human_task import HumanTaskModel
 from spiffworkflow_backend.models.process_instance import ProcessInstanceApi
 from spiffworkflow_backend.models.process_instance import ProcessInstanceModel
 from spiffworkflow_backend.models.process_instance import ProcessInstanceStatus
@@ -196,7 +196,7 @@ class ProcessInstanceService:
         spiff_task: SpiffTask,
         data: dict[str, Any],
         user: UserModel,
-        active_task: ActiveTaskModel,
+        human_task: HumanTaskModel,
     ) -> None:
         """All the things that need to happen when we complete a form.
 
@@ -210,7 +210,7 @@ class ProcessInstanceService:
         dot_dct = ProcessInstanceService.create_dot_dict(data)
         spiff_task.update_data(dot_dct)
         # ProcessInstanceService.post_process_form(spiff_task)  # some properties may update the data store.
-        processor.complete_task(spiff_task, active_task)
+        processor.complete_task(spiff_task, human_task)
         processor.do_engine_steps(save=True)
 
     @staticmethod

src/spiffworkflow_backend/services/user_service.py

@@ -7,9 +7,9 @@ from flask import g
 from flask_bpmn.api.api_error import ApiError
 from flask_bpmn.models.db import db
 
-from spiffworkflow_backend.models.active_task import ActiveTaskModel
-from spiffworkflow_backend.models.active_task_user import ActiveTaskUserModel
 from spiffworkflow_backend.models.group import GroupModel
+from spiffworkflow_backend.models.human_task import HumanTaskModel
+from spiffworkflow_backend.models.human_task_user import HumanTaskUserModel
 from spiffworkflow_backend.models.principal import PrincipalModel
 from spiffworkflow_backend.models.user import UserModel
 from spiffworkflow_backend.models.user_group_assignment import UserGroupAssignmentModel
@@ -192,15 +192,15 @@ class UserService:
         return None
 
     @classmethod
-    def add_user_to_active_tasks_if_appropriate(cls, user: UserModel) -> None:
+    def add_user_to_human_tasks_if_appropriate(cls, user: UserModel) -> None:
-        """Add_user_to_active_tasks_if_appropriate."""
+        """Add_user_to_human_tasks_if_appropriate."""
         group_ids = [g.id for g in user.groups]
-        active_tasks = ActiveTaskModel.query.filter(
+        human_tasks = HumanTaskModel.query.filter(
-            ActiveTaskModel.lane_assignment_id.in_(group_ids)  # type: ignore
+            HumanTaskModel.lane_assignment_id.in_(group_ids)  # type: ignore
         ).all()
-        for active_task in active_tasks:
+        for human_task in human_tasks:
-            active_task_user = ActiveTaskUserModel(
+            human_task_user = HumanTaskUserModel(
-                user_id=user.id, active_task_id=active_task.id
+                user_id=user.id, human_task_id=human_task.id
             )
-            db.session.add(active_task_user)
+            db.session.add(human_task_user)
             db.session.commit()

tests/spiffworkflow_backend/integration/test_process_api.py

@@ -16,8 +16,8 @@ from tests.spiffworkflow_backend.helpers.test_data import load_test_spec
 from spiffworkflow_backend.exceptions.process_entity_not_found_error import (
     ProcessEntityNotFoundError,
 )
-from spiffworkflow_backend.models.active_task import ActiveTaskModel
 from spiffworkflow_backend.models.group import GroupModel
+from spiffworkflow_backend.models.human_task import HumanTaskModel
 from spiffworkflow_backend.models.process_group import ProcessGroup
 from spiffworkflow_backend.models.process_instance import ProcessInstanceModel
 from spiffworkflow_backend.models.process_instance import ProcessInstanceStatus
@@ -1463,15 +1463,15 @@ class TestProcessApi(BaseTest):
         assert response.json is not None
         assert response.json["next_task"] is not None
 
-        active_tasks = (
+        human_tasks = (
-            db.session.query(ActiveTaskModel)
+            db.session.query(HumanTaskModel)
-            .filter(ActiveTaskModel.process_instance_id == process_instance_id)
+            .filter(HumanTaskModel.process_instance_id == process_instance_id)
             .all()
         )
-        assert len(active_tasks) == 1
+        assert len(human_tasks) == 1
-        active_task = active_tasks[0]
+        human_task = human_tasks[0]
         response = client.get(
-            f"/v1.0/tasks/{process_instance_id}/{active_task.task_id}",
+            f"/v1.0/tasks/{process_instance_id}/{human_task.task_id}",
             headers=self.logged_in_headers(with_super_admin_user),
         )
         assert response.json is not None

tests/spiffworkflow_backend/scripts/test_get_localtime.py

@@ -68,9 +68,9 @@ class TestGetLocaltime(BaseTest):
         processor = ProcessInstanceProcessor(process_instance)
 
         processor.do_engine_steps(save=True)
-        active_task = process_instance.active_tasks[0]
+        human_task = process_instance.human_tasks[0]
         spiff_task = processor.__class__.get_task_by_bpmn_identifier(
-            active_task.task_name, processor.bpmn_process_instance
+            human_task.task_name, processor.bpmn_process_instance
         )
 
         ProcessInstanceService.complete_form_task(
@@ -78,12 +78,12 @@ class TestGetLocaltime(BaseTest):
             spiff_task,
             {"timezone": "US/Pacific"},
             initiator_user,
-            active_task,
+            human_task,
         )
 
-        active_task = process_instance.active_tasks[0]
+        human_task = process_instance.human_tasks[0]
         spiff_task = processor.__class__.get_task_by_bpmn_identifier(
-            active_task.task_name, processor.bpmn_process_instance
+            human_task.task_name, processor.bpmn_process_instance
         )
 
         assert spiff_task

tests/spiffworkflow_backend/unit/test_authorization_service.py

@@ -90,14 +90,14 @@ class TestAuthorizationService(BaseTest):
             users["testuser2"], "read", "/v1.0/process-groups/"
         )
 
-    def test_user_can_be_added_to_active_task_on_first_login(
+    def test_user_can_be_added_to_human_task_on_first_login(
         self,
         app: Flask,
         client: FlaskClient,
         with_db_and_bpmn_file_cleanup: None,
         with_super_admin_user: UserModel,
     ) -> None:
-        """Test_user_can_be_added_to_active_task_on_first_login."""
+        """Test_user_can_be_added_to_human_task_on_first_login."""
         initiator_user = self.find_or_create_user("initiator_user")
         assert initiator_user.principal is not None
         # to ensure there is a user that can be assigned to the task
@@ -121,21 +121,21 @@ class TestAuthorizationService(BaseTest):
         )
         processor = ProcessInstanceProcessor(process_instance)
         processor.do_engine_steps(save=True)
-        active_task = process_instance.active_tasks[0]
+        human_task = process_instance.human_tasks[0]
         spiff_task = processor.__class__.get_task_by_bpmn_identifier(
-            active_task.task_name, processor.bpmn_process_instance
+            human_task.task_name, processor.bpmn_process_instance
         )
         ProcessInstanceService.complete_form_task(
-            processor, spiff_task, {}, initiator_user, active_task
+            processor, spiff_task, {}, initiator_user, human_task
         )
 
-        active_task = process_instance.active_tasks[0]
+        human_task = process_instance.human_tasks[0]
         spiff_task = processor.__class__.get_task_by_bpmn_identifier(
-            active_task.task_name, processor.bpmn_process_instance
+            human_task.task_name, processor.bpmn_process_instance
         )
         finance_user = AuthorizationService.create_user_from_sign_in(
             {"username": "testuser2", "sub": "open_id"}
         )
         ProcessInstanceService.complete_form_task(
-            processor, spiff_task, {}, finance_user, active_task
+            processor, spiff_task, {}, finance_user, human_task
         )

tests/spiffworkflow_backend/unit/test_dot_notation.py

@@ -47,7 +47,7 @@ class TestDotNotation(BaseTest):
 
         processor = ProcessInstanceProcessor(process_instance)
         processor.do_engine_steps(save=True)
-        active_task = process_instance.active_tasks[0]
+        human_task = process_instance.human_tasks[0]
 
         user_task = processor.get_ready_user_tasks()[0]
         form_data = {
@@ -58,7 +58,7 @@ class TestDotNotation(BaseTest):
             "invoice.dueDate": "09/30/2022",
         }
         ProcessInstanceService.complete_form_task(
-            processor, user_task, form_data, with_super_admin_user, active_task
+            processor, user_task, form_data, with_super_admin_user, human_task
         )
 
         expected = {

tests/spiffworkflow_backend/unit/test_process_instance_processor.py

@@ -49,14 +49,14 @@ class TestProcessInstanceProcessor(BaseTest):
             == "Chuck Norris doesn’t read books. He stares them down until he gets the information he wants."
         )
 
-    def test_sets_permission_correctly_on_active_task(
+    def test_sets_permission_correctly_on_human_task(
         self,
         app: Flask,
         client: FlaskClient,
         with_db_and_bpmn_file_cleanup: None,
         with_super_admin_user: UserModel,
     ) -> None:
-        """Test_sets_permission_correctly_on_active_task."""
+        """Test_sets_permission_correctly_on_human_task."""
         self.create_process_group(
             client, with_super_admin_user, "test_group", "test_group"
         )
@@ -80,63 +80,63 @@ class TestProcessInstanceProcessor(BaseTest):
         processor = ProcessInstanceProcessor(process_instance)
         processor.do_engine_steps(save=True)
 
-        assert len(process_instance.active_tasks) == 1
+        assert len(process_instance.human_tasks) == 1
-        active_task = process_instance.active_tasks[0]
+        human_task = process_instance.human_tasks[0]
-        assert active_task.lane_assignment_id is None
+        assert human_task.lane_assignment_id is None
-        assert len(active_task.potential_owners) == 1
+        assert len(human_task.potential_owners) == 1
-        assert active_task.potential_owners[0] == initiator_user
+        assert human_task.potential_owners[0] == initiator_user
 
         spiff_task = processor.__class__.get_task_by_bpmn_identifier(
-            active_task.task_name, processor.bpmn_process_instance
+            human_task.task_name, processor.bpmn_process_instance
         )
         with pytest.raises(UserDoesNotHaveAccessToTaskError):
             ProcessInstanceService.complete_form_task(
-                processor, spiff_task, {}, finance_user, active_task
+                processor, spiff_task, {}, finance_user, human_task
             )
         ProcessInstanceService.complete_form_task(
-            processor, spiff_task, {}, initiator_user, active_task
+            processor, spiff_task, {}, initiator_user, human_task
         )
 
-        assert len(process_instance.active_tasks) == 1
+        assert len(process_instance.human_tasks) == 1
-        active_task = process_instance.active_tasks[0]
+        human_task = process_instance.human_tasks[0]
-        assert active_task.lane_assignment_id == finance_group.id
+        assert human_task.lane_assignment_id == finance_group.id
-        assert len(active_task.potential_owners) == 1
+        assert len(human_task.potential_owners) == 1
-        assert active_task.potential_owners[0] == finance_user
+        assert human_task.potential_owners[0] == finance_user
 
         spiff_task = processor.__class__.get_task_by_bpmn_identifier(
-            active_task.task_name, processor.bpmn_process_instance
+            human_task.task_name, processor.bpmn_process_instance
         )
         with pytest.raises(UserDoesNotHaveAccessToTaskError):
             ProcessInstanceService.complete_form_task(
-                processor, spiff_task, {}, initiator_user, active_task
+                processor, spiff_task, {}, initiator_user, human_task
             )
 
         ProcessInstanceService.complete_form_task(
-            processor, spiff_task, {}, finance_user, active_task
+            processor, spiff_task, {}, finance_user, human_task
         )
-        assert len(process_instance.active_tasks) == 1
+        assert len(process_instance.human_tasks) == 1
-        active_task = process_instance.active_tasks[0]
+        human_task = process_instance.human_tasks[0]
-        assert active_task.lane_assignment_id is None
+        assert human_task.lane_assignment_id is None
-        assert len(active_task.potential_owners) == 1
+        assert len(human_task.potential_owners) == 1
-        assert active_task.potential_owners[0] == initiator_user
+        assert human_task.potential_owners[0] == initiator_user
 
         spiff_task = processor.__class__.get_task_by_bpmn_identifier(
-            active_task.task_name, processor.bpmn_process_instance
+            human_task.task_name, processor.bpmn_process_instance
         )
         ProcessInstanceService.complete_form_task(
-            processor, spiff_task, {}, initiator_user, active_task
+            processor, spiff_task, {}, initiator_user, human_task
         )
 
         assert process_instance.status == ProcessInstanceStatus.complete.value
 
-    def test_sets_permission_correctly_on_active_task_when_using_dict(
+    def test_sets_permission_correctly_on_human_task_when_using_dict(
         self,
         app: Flask,
         client: FlaskClient,
         with_db_and_bpmn_file_cleanup: None,
         with_super_admin_user: UserModel,
     ) -> None:
-        """Test_sets_permission_correctly_on_active_task_when_using_dict."""
+        """Test_sets_permission_correctly_on_human_task_when_using_dict."""
         self.create_process_group(
             client, with_super_admin_user, "test_group", "test_group"
         )
@@ -163,94 +163,94 @@ class TestProcessInstanceProcessor(BaseTest):
         processor.do_engine_steps(save=True)
         processor.save()
 
-        assert len(process_instance.active_tasks) == 1
+        assert len(process_instance.human_tasks) == 1
-        active_task = process_instance.active_tasks[0]
+        human_task = process_instance.human_tasks[0]
-        assert active_task.lane_assignment_id is None
+        assert human_task.lane_assignment_id is None
-        assert len(active_task.potential_owners) == 1
+        assert len(human_task.potential_owners) == 1
-        assert active_task.potential_owners[0] == initiator_user
+        assert human_task.potential_owners[0] == initiator_user
 
         spiff_task = processor.__class__.get_task_by_bpmn_identifier(
-            active_task.task_name, processor.bpmn_process_instance
+            human_task.task_name, processor.bpmn_process_instance
         )
         with pytest.raises(UserDoesNotHaveAccessToTaskError):
             ProcessInstanceService.complete_form_task(
-                processor, spiff_task, {}, finance_user_three, active_task
+                processor, spiff_task, {}, finance_user_three, human_task
             )
         ProcessInstanceService.complete_form_task(
-            processor, spiff_task, {}, initiator_user, active_task
+            processor, spiff_task, {}, initiator_user, human_task
         )
 
-        assert len(process_instance.active_tasks) == 1
+        assert len(process_instance.human_tasks) == 1
-        active_task = process_instance.active_tasks[0]
+        human_task = process_instance.human_tasks[0]
-        assert active_task.lane_assignment_id is None
+        assert human_task.lane_assignment_id is None
-        assert len(active_task.potential_owners) == 2
+        assert len(human_task.potential_owners) == 2
-        assert active_task.potential_owners == [finance_user_three, finance_user_four]
+        assert human_task.potential_owners == [finance_user_three, finance_user_four]
 
         spiff_task = processor.__class__.get_task_by_bpmn_identifier(
-            active_task.task_name, processor.bpmn_process_instance
+            human_task.task_name, processor.bpmn_process_instance
         )
         with pytest.raises(UserDoesNotHaveAccessToTaskError):
             ProcessInstanceService.complete_form_task(
-                processor, spiff_task, {}, initiator_user, active_task
+                processor, spiff_task, {}, initiator_user, human_task
             )
 
         g.user = finance_user_three
         ProcessInstanceService.complete_form_task(
-            processor, spiff_task, {}, finance_user_three, active_task
+            processor, spiff_task, {}, finance_user_three, human_task
         )
-        assert len(process_instance.active_tasks) == 1
+        assert len(process_instance.human_tasks) == 1
-        active_task = process_instance.active_tasks[0]
+        human_task = process_instance.human_tasks[0]
-        assert active_task.lane_assignment_id is None
+        assert human_task.lane_assignment_id is None
-        assert len(active_task.potential_owners) == 1
+        assert len(human_task.potential_owners) == 1
-        assert active_task.potential_owners[0] == finance_user_four
+        assert human_task.potential_owners[0] == finance_user_four
 
         spiff_task = processor.__class__.get_task_by_bpmn_identifier(
-            active_task.task_name, processor.bpmn_process_instance
+            human_task.task_name, processor.bpmn_process_instance
         )
         with pytest.raises(UserDoesNotHaveAccessToTaskError):
             ProcessInstanceService.complete_form_task(
-                processor, spiff_task, {}, initiator_user, active_task
+                processor, spiff_task, {}, initiator_user, human_task
             )
 
         ProcessInstanceService.complete_form_task(
-            processor, spiff_task, {}, finance_user_four, active_task
+            processor, spiff_task, {}, finance_user_four, human_task
         )
-        assert len(process_instance.active_tasks) == 1
+        assert len(process_instance.human_tasks) == 1
-        active_task = process_instance.active_tasks[0]
+        human_task = process_instance.human_tasks[0]
-        assert active_task.lane_assignment_id is None
+        assert human_task.lane_assignment_id is None
-        assert len(active_task.potential_owners) == 1
+        assert len(human_task.potential_owners) == 1
-        assert active_task.potential_owners[0] == initiator_user
+        assert human_task.potential_owners[0] == initiator_user
 
         spiff_task = processor.__class__.get_task_by_bpmn_identifier(
-            active_task.task_name, processor.bpmn_process_instance
+            human_task.task_name, processor.bpmn_process_instance
         )
         ProcessInstanceService.complete_form_task(
-            processor, spiff_task, {}, initiator_user, active_task
+            processor, spiff_task, {}, initiator_user, human_task
         )
 
-        assert len(process_instance.active_tasks) == 1
+        assert len(process_instance.human_tasks) == 1
-        active_task = process_instance.active_tasks[0]
+        human_task = process_instance.human_tasks[0]
         spiff_task = processor.__class__.get_task_by_bpmn_identifier(
-            active_task.task_name, processor.bpmn_process_instance
+            human_task.task_name, processor.bpmn_process_instance
         )
         with pytest.raises(UserDoesNotHaveAccessToTaskError):
             ProcessInstanceService.complete_form_task(
-                processor, spiff_task, {}, initiator_user, active_task
+                processor, spiff_task, {}, initiator_user, human_task
             )
         ProcessInstanceService.complete_form_task(
-            processor, spiff_task, {}, testadmin1, active_task
+            processor, spiff_task, {}, testadmin1, human_task
         )
 
         assert process_instance.status == ProcessInstanceStatus.complete.value
 
-    def test_does_not_recreate_active_tasks_on_multiple_saves(
+    def test_does_not_recreate_human_tasks_on_multiple_saves(
         self,
         app: Flask,
         client: FlaskClient,
         with_db_and_bpmn_file_cleanup: None,
         with_super_admin_user: UserModel,
     ) -> None:
-        """Test_sets_permission_correctly_on_active_task_when_using_dict."""
+        """Test_sets_permission_correctly_on_human_task_when_using_dict."""
         self.create_process_group(
             client, with_super_admin_user, "test_group", "test_group"
         )
@@ -273,11 +273,11 @@ class TestProcessInstanceProcessor(BaseTest):
         )
         processor = ProcessInstanceProcessor(process_instance)
         processor.do_engine_steps(save=True)
-        assert len(process_instance.active_tasks) == 1
+        assert len(process_instance.human_tasks) == 1
-        initial_active_task_id = process_instance.active_tasks[0].id
+        initial_human_task_id = process_instance.human_tasks[0].id
 
-        # save again to ensure we go attempt to process the active tasks again
+        # save again to ensure we go attempt to process the human tasks again
         processor.save()
 
-        assert len(process_instance.active_tasks) == 1
+        assert len(process_instance.human_tasks) == 1
-        assert initial_active_task_id == process_instance.active_tasks[0].id
+        assert initial_human_task_id == process_instance.human_tasks[0].id