ethyca-fides 2.64.1rc0__py2.py3-none-any.whl → 2.64.2b0__py2.py3-none-any.whl

fides/api/models/manual_tasks/__init__.py

@@ -3,12 +3,18 @@ from fides.api.models.manual_tasks.manual_task_config import (
     ManualTaskConfig,
     ManualTaskConfigField,
 )
+from fides.api.models.manual_tasks.manual_task_instance import (
+    ManualTaskInstance,
+    ManualTaskSubmission,
+)
 from fides.api.models.manual_tasks.manual_task_log import ManualTaskLog
 
 __all__ = [
     "ManualTask",
     "ManualTaskConfig",
     "ManualTaskConfigField",
-    "ManualTaskReference",
+    "ManualTaskInstance",
     "ManualTaskLog",
+    "ManualTaskReference",
+    "ManualTaskSubmission",
 ]

fides/api/models/manual_tasks/manual_task.py

@@ -1,10 +1,11 @@
 from typing import TYPE_CHECKING, Any
 
-from sqlalchemy import Column, DateTime, ForeignKey, String
+from sqlalchemy import Column, DateTime, ForeignKey, Index, String, UniqueConstraint
 from sqlalchemy.ext.declarative import declared_attr
 from sqlalchemy.orm import Session, relationship
+from sqlalchemy.sql import func
 
-from fides.api.db.base_class import Base
+from fides.api.db.base_class import Base, FidesBase
 from fides.api.db.util import EnumColumn
 from fides.api.models.manual_tasks.manual_task_log import ManualTaskLog
 from fides.api.schemas.manual_tasks.manual_task_schemas import (
@@ -18,6 +19,10 @@ if TYPE_CHECKING:  # pragma: no cover
     from fides.api.models.manual_tasks.manual_task_config import (  # pragma: no cover
         ManualTaskConfig,
     )
+    from fides.api.models.manual_tasks.manual_task_instance import (
+        ManualTaskInstance,
+        ManualTaskSubmission,
+    )
 
 
 class ManualTask(Base):
@@ -36,6 +41,22 @@ class ManualTask(Base):
         """Overriding base class method to set the table name."""
         return "manual_task"
 
+    # redefined here because there's a minor, unintended discrepancy between
+    # this `id` field and that of the `Base` class, which explicitly sets `index=True`.
+    # TODO: we likely should _not_ be setting `index=True` on the `id`
+    # attribute of the `Base` class, as `primary_key=True` already specifies a
+    # primary key constraint, which will implicitly create an index for the field.
+    id = Column(String(255), primary_key=True, default=FidesBase.generate_uuid)
+    created_at = Column(
+        DateTime(timezone=True), server_default=func.now(), nullable=False
+    )
+    updated_at = Column(
+        DateTime(timezone=True),
+        server_default=func.now(),
+        onupdate=func.now(),
+        nullable=False,
+    )
+
     # Database columns
     task_type = Column(
         EnumColumn(ManualTaskType),
@@ -48,7 +69,16 @@ class ManualTask(Base):
         nullable=False,
         default=ManualTaskParentEntityType.connection_config,
     )
-    due_date = Column(DateTime, nullable=True)
+
+    __table_args__ = (
+        UniqueConstraint(
+            "parent_entity_id",
+            "parent_entity_type",
+            name="uq_manual_task_parent_entity",
+        ),
+        Index("ix_manual_task_parent_entity", "parent_entity_type", "parent_entity_id"),
+        Index("ix_manual_task_task_type", "task_type"),
+    )
 
     # Relationships
     references = relationship(
@@ -68,6 +98,19 @@ class ManualTask(Base):
         "ManualTaskConfig",
         back_populates="task",
         cascade="all, delete-orphan",
+        uselist=True,
+    )
+    instances = relationship(
+        "ManualTaskInstance",
+        back_populates="task",
+        viewonly=True,
+        uselist=True,
+    )
+    submissions = relationship(
+        "ManualTaskSubmission",
+        back_populates="task",
+        uselist=True,
+        viewonly=True,
     )
 
     # Properties
@@ -109,6 +152,22 @@ class ManualTaskReference(Base):
         """Overriding base class method to set the table name."""
         return "manual_task_reference"
 
+    # redefined here because there's a minor, unintended discrepancy between
+    # this `id` field and that of the `Base` class, which explicitly sets `index=True`.
+    # TODO: we likely should _not_ be setting `index=True` on the `id`
+    # attribute of the `Base` class, as `primary_key=True` already specifies a
+    # primary key constraint, which will implicitly create an index for the field.
+    id = Column(String(255), primary_key=True, default=FidesBase.generate_uuid)
+    created_at = Column(
+        DateTime(timezone=True), server_default=func.now(), nullable=False
+    )
+    updated_at = Column(
+        DateTime(timezone=True),
+        server_default=func.now(),
+        onupdate=func.now(),
+        nullable=False,
+    )
+
     # Database columns
     task_id = Column(
         String, ForeignKey("manual_task.id", ondelete="CASCADE"), nullable=False
@@ -116,5 +175,10 @@ class ManualTaskReference(Base):
     reference_id = Column(String, nullable=False)
     reference_type = Column(EnumColumn(ManualTaskReferenceType), nullable=False)
 
+    __table_args__ = (
+        Index("ix_manual_task_reference_reference", "reference_id", "reference_type"),
+        Index("ix_manual_task_reference_task_id", "task_id"),
+    )
+
     # Relationships
-    task = relationship("ManualTask", back_populates="references")
+    task = relationship("ManualTask", back_populates="references", viewonly=True)

fides/api/models/manual_tasks/manual_task_config.py

@@ -1,11 +1,21 @@
-from typing import TYPE_CHECKING, Any, Optional
-
-from sqlalchemy import Boolean, Column, ForeignKey, Integer, String
+from typing import TYPE_CHECKING, Any, Optional, cast
+
+from sqlalchemy import (
+    Boolean,
+    Column,
+    DateTime,
+    ForeignKey,
+    Index,
+    Integer,
+    String,
+    UniqueConstraint,
+)
 from sqlalchemy.dialects.postgresql import JSONB
 from sqlalchemy.ext.declarative import declared_attr
 from sqlalchemy.orm import Session, relationship
+from sqlalchemy.sql import func
 
-from fides.api.db.base_class import Base
+from fides.api.db.base_class import Base, FidesBase
 from fides.api.db.util import EnumColumn
 from fides.api.models.manual_tasks.manual_task_log import ManualTaskLog
 from fides.api.schemas.manual_tasks.manual_task_config import (
@@ -13,10 +23,19 @@ from fides.api.schemas.manual_tasks.manual_task_config import (
     ManualTaskFieldMetadata,
     ManualTaskFieldType,
 )
-from fides.api.schemas.manual_tasks.manual_task_schemas import ManualTaskLogStatus
+from fides.api.schemas.manual_tasks.manual_task_schemas import (
+    ManualTaskExecutionTiming,
+    ManualTaskLogStatus,
+)
 
 if TYPE_CHECKING:  # pragma: no cover
     from fides.api.models.manual_tasks.manual_task import ManualTask  # pragma: no cover
+    from fides.api.models.manual_tasks.manual_task_instance import (
+        ManualTaskInstance,  # pragma: no cover
+    )
+    from fides.api.models.manual_tasks.manual_task_instance import (
+        ManualTaskSubmission,  # pragma: no cover
+    )
 
 
 class ManualTaskConfig(Base):
@@ -28,13 +47,53 @@ class ManualTaskConfig(Base):
     def __tablename__(cls) -> str:
         return "manual_task_config"
 
-    task_id = Column(String, ForeignKey("manual_task.id"), nullable=False)
+    # redefined here because there's a minor, unintended discrepancy between
+    # this `id` field and that of the `Base` class, which explicitly sets `index=True`.
+    # TODO: we likely should _not_ be setting `index=True` on the `id`
+    # attribute of the `Base` class, as `primary_key=True` already specifies a
+    # primary key constraint, which will implicitly create an index for the field.
+    id = Column(String(255), primary_key=True, default=FidesBase.generate_uuid)
+    created_at = Column(
+        DateTime(timezone=True), server_default=func.now(), nullable=False
+    )
+    updated_at = Column(
+        DateTime(timezone=True),
+        server_default=func.now(),
+        onupdate=func.now(),
+        nullable=False,
+    )
+
+    task_id = Column(
+        String,
+        ForeignKey(
+            "manual_task.id",
+            name="manual_task_config_task_id_fkey",
+            ondelete="CASCADE",
+        ),
+        nullable=False,
+    )
     config_type = Column(EnumColumn(ManualTaskConfigurationType), nullable=False)
     version = Column(Integer, nullable=False, default=1)
     is_current = Column(Boolean, nullable=False, default=True)
+    execution_timing = Column(
+        EnumColumn(ManualTaskExecutionTiming),
+        nullable=False,
+        default=ManualTaskExecutionTiming.pre_execution,
+    )
+
+    __table_args__ = (
+        Index("ix_manual_task_config_config_type", "config_type"),
+        Index("ix_manual_task_config_task_id", "task_id"),
+    )
 
     # Relationships
-    task = relationship("ManualTask", back_populates="configs")
+    task = relationship("ManualTask", back_populates="configs", viewonly=True)
+    instances = relationship(
+        "ManualTaskInstance", back_populates="config", uselist=True, viewonly=True
+    )
+    submissions = relationship(
+        "ManualTaskSubmission", back_populates="config", uselist=True, viewonly=True
+    )
     field_definitions = relationship(
         "ManualTaskConfigField",
         back_populates="config",
@@ -45,7 +104,7 @@ class ManualTaskConfig(Base):
         "ManualTaskLog",
         back_populates="config",
         primaryjoin="ManualTaskConfig.id == ManualTaskLog.config_id",
-        viewonly=True,
+        cascade="all, delete-orphan",
     )
 
     @classmethod
@@ -89,20 +148,72 @@ class ManualTaskConfigField(Base):
     def __tablename__(cls) -> str:
         return "manual_task_config_field"
 
-    task_id = Column(String, ForeignKey("manual_task.id"), nullable=False)
-    config_id = Column(String, ForeignKey("manual_task_config.id"), nullable=False)
+    # redefined here because there's a minor, unintended discrepancy between
+    # this `id` field and that of the `Base` class, which explicitly sets `index=True`.
+    # TODO: we likely should _not_ be setting `index=True` on the `id`
+    # attribute of the `Base` class, as `primary_key=True` already specifies a
+    # primary key constraint, which will implicitly create an index for the field.
+    id = Column(String(255), primary_key=True, default=FidesBase.generate_uuid)
+    created_at = Column(
+        DateTime(timezone=True), server_default=func.now(), nullable=False
+    )
+    updated_at = Column(
+        DateTime(timezone=True),
+        server_default=func.now(),
+        onupdate=func.now(),
+        nullable=False,
+    )
+
+    task_id = Column(
+        String,
+        ForeignKey(
+            "manual_task.id",
+            name="manual_task_config_field_task_id_fkey",
+            ondelete="CASCADE",
+        ),
+        nullable=False,
+    )
+    config_id = Column(
+        String,
+        ForeignKey(
+            "manual_task_config.id",
+            name="manual_task_config_field_config_id_fkey",
+            ondelete="CASCADE",
+        ),
+        nullable=False,
+    )
     field_key = Column(String, nullable=False)
     field_type = Column(
         EnumColumn(ManualTaskFieldType), nullable=False
     )  # Using ManualTaskFieldType
-    field_metadata = Column(JSONB, nullable=False, default={})
+    field_metadata: dict[str, Any] = cast(
+        dict[str, Any], Column(JSONB, nullable=False, default={})
+    )
+
+    __table_args__ = (
+        UniqueConstraint("config_id", "field_key", name="unique_field_key_per_config"),
+        Index("ix_manual_task_config_field_config_id", "config_id"),
+        Index("ix_manual_task_config_field_field_key", "field_key"),
+        Index("ix_manual_task_config_field_task_id", "task_id"),
+    )
 
     # Relationships
-    config = relationship("ManualTaskConfig", back_populates="field_definitions")
+    config = relationship(
+        "ManualTaskConfig", back_populates="field_definitions", viewonly=True
+    )
+    submissions = relationship(
+        "ManualTaskSubmission",
+        back_populates="field",
+        uselist=True,
+        cascade="all, delete-orphan",
+    )
 
     @property
     def field_metadata_model(self) -> ManualTaskFieldMetadata:
         """Get the field metadata as a Pydantic model."""
+        assert isinstance(
+            self.field_metadata, dict
+        ), "field_metadata must be a dictionary"
         return ManualTaskFieldMetadata.model_validate(self.field_metadata)
 
     @classmethod

fides/api/models/manual_tasks/manual_task_instance.py

@@ -0,0 +1,294 @@
+from datetime import datetime, timezone
+from typing import TYPE_CHECKING, Optional
+
+from sqlalchemy import Column, DateTime, ForeignKey, Index, String
+from sqlalchemy.dialects.postgresql import JSONB
+from sqlalchemy.ext.declarative import declared_attr
+from sqlalchemy.orm import relationship
+from sqlalchemy.sql import func
+
+from fides.api.db.base_class import Base, FidesBase
+from fides.api.db.util import EnumColumn
+from fides.api.models.manual_tasks.manual_task_config import ManualTaskConfigField
+from fides.api.schemas.manual_tasks.manual_task_schemas import ManualTaskEntityType
+from fides.api.schemas.manual_tasks.manual_task_status import (
+    StatusTransitionMixin,
+    StatusType,
+)
+
+if TYPE_CHECKING:  # pragma: no cover
+    from fides.api.models.attachment import Attachment  # pragma: no cover
+    from fides.api.models.fides_user import FidesUser  # pragma: no cover
+    from fides.api.models.manual_tasks.manual_task import ManualTask  # pragma: no cover
+    from fides.api.models.manual_tasks.manual_task_config import (
+        ManualTaskConfig,  # pragma: no cover
+    )
+    from fides.api.models.manual_tasks.manual_task_log import (
+        ManualTaskLog,  # pragma: no cover; pragma: no cover
+    )
+
+
+class ManualTaskInstance(Base, StatusTransitionMixin):
+    """Model for tracking task status per entity instance.
+
+    This model implements StatusTransitionProtocol through the StatusTransitionMixin.
+    """
+
+    @declared_attr
+    def __tablename__(cls) -> str:
+        """Overriding base class method to set the table name."""
+        return "manual_task_instance"
+
+    # redefined here because there's a minor, unintended discrepancy between
+    # this `id` field and that of the `Base` class, which explicitly sets `index=True`.
+    # TODO: we likely should _not_ be setting `index=True` on the `id`
+    # attribute of the `Base` class, as `primary_key=True` already specifies a
+    # primary key constraint, which will implicitly create an index for the field.
+    id = Column(String(255), primary_key=True, default=FidesBase.generate_uuid)
+    created_at = Column(
+        DateTime(timezone=True), server_default=func.now(), nullable=False
+    )
+    updated_at = Column(
+        DateTime(timezone=True),
+        server_default=func.now(),
+        onupdate=func.now(),
+        nullable=False,
+    )
+
+    # Database columns
+    task_id: Column[str] = Column(
+        String,
+        ForeignKey(
+            "manual_task.id",
+            name="manual_task_instance_task_id_fkey",
+            ondelete="CASCADE",
+        ),
+        nullable=False,
+    )
+    config_id: Column[str] = Column(
+        String,
+        ForeignKey(
+            "manual_task_config.id",
+            name="manual_task_instance_config_id_fkey",
+            ondelete="CASCADE",
+        ),
+        nullable=False,
+    )
+    # entity id is the entity that the instance relates to
+    # (e.g. a privacy request is an entity that has its own manual task instance)
+    entity_id: Column[str] = Column(String, nullable=False)
+    entity_type: Column[ManualTaskEntityType] = Column(
+        EnumColumn(ManualTaskEntityType), nullable=False
+    )
+    # ingnore[assignment] because the mypy and sqlalchemy types mismatch
+    # upgrading to 2.0 allows mapping which provides better type safety visibility.
+    status: Column[StatusType] = Column(EnumColumn(StatusType), nullable=False, default=StatusType.pending)  # type: ignore[assignment]
+    completed_at: Column[Optional[datetime]] = Column(DateTime, nullable=True)  # type: ignore[assignment]
+    completed_by_id: Column[Optional[str]] = Column(String, nullable=True)  # type: ignore[assignment]
+    due_date: Column[Optional[datetime]] = Column(DateTime, nullable=True)
+
+    __table_args__ = (
+        Index("ix_manual_task_instance_completed_at", "completed_at"),
+        Index("ix_manual_task_instance_config_id", "config_id"),
+        Index("ix_manual_task_instance_entity", "entity_type", "entity_id"),
+        Index("ix_manual_task_instance_entity_id", "entity_id"),
+        Index("ix_manual_task_instance_entity_type", "entity_type"),
+        Index("ix_manual_task_instance_status", "status"),
+        Index("ix_manual_task_instance_task_id", "task_id"),
+    )
+
+    # Relationships
+    task = relationship("ManualTask", back_populates="instances")
+    config = relationship("ManualTaskConfig", back_populates="instances")
+    submissions = relationship(
+        "ManualTaskSubmission",
+        back_populates="instance",
+        cascade="all, delete-orphan",
+        uselist=True,
+    )
+    logs = relationship(
+        "ManualTaskLog",
+        back_populates="instance",
+        primaryjoin="ManualTaskInstance.id == ManualTaskLog.instance_id",
+        cascade="all, delete-orphan",
+        order_by="ManualTaskLog.created_at",
+        uselist=True,
+    )
+    attachments = relationship(
+        "Attachment",
+        secondary="attachment_reference",
+        primaryjoin="and_(ManualTaskInstance.id == ManualTaskSubmission.instance_id, "
+        "ManualTaskSubmission.id == AttachmentReference.reference_id, "
+        "AttachmentReference.reference_type == 'manual_task_submission')",
+        secondaryjoin="Attachment.id == AttachmentReference.attachment_id",
+        order_by="Attachment.created_at",
+        viewonly=True,
+        uselist=True,
+    )
+
+    @property
+    def required_fields(self) -> list["ManualTaskConfigField"]:
+        """Get all required fields."""
+        return [
+            field
+            for field in self.config.field_definitions
+            if field.field_metadata.get("required", False)
+        ]
+
+    @property
+    def incomplete_fields(self) -> list["ManualTaskConfigField"]:
+        """Get all fields that haven't been completed yet.
+        A field is considered incomplete if:
+        1. It's required and has no submission
+        Returns:
+            list[ManualTaskConfigField]: List of incomplete fields
+        """
+        return [
+            field
+            for field in self.required_fields
+            if not self.get_submission_for_field(field.id)
+        ]
+
+    @property
+    def completed_fields(self) -> list["ManualTaskConfigField"]:
+        """Get all fields that have been completed."""
+        return [
+            field
+            for field in self.config.field_definitions
+            if field.field_metadata.get("required", False)
+            and self.get_submission_for_field(field.id)
+        ]
+
+    def get_submission_for_field(
+        self, field_id: str
+    ) -> Optional["ManualTaskSubmission"]:
+        """Get the submission for a specific field.
+
+        Args:
+            field_id: The ID of the field to get the submission for
+
+        Returns:
+            Optional[ManualTaskSubmission]: The submission for the field, or None if no submission exists
+        """
+        return next(
+            (
+                submission
+                for submission in self.submissions
+                if submission.field_id == field_id
+            ),
+            None,
+        )
+
+
+class ManualTaskSubmission(Base):
+    """Model for storing user submissions.
+    Each submission represents data for a single field.
+    """
+
+    @declared_attr
+    def __tablename__(cls) -> str:
+        """Overriding base class method to set the table name."""
+        return "manual_task_submission"
+
+    # redefined here because there's a minor, unintended discrepancy between
+    # this `id` field and that of the `Base` class, which explicitly sets `index=True`.
+    # TODO: we likely should _not_ be setting `index=True` on the `id`
+    # attribute of the `Base` class, as `primary_key=True` already specifies a
+    # primary key constraint, which will implicitly create an index for the field.
+    id = Column(String(255), primary_key=True, default=FidesBase.generate_uuid)
+    created_at = Column(
+        DateTime(timezone=True), server_default=func.now(), nullable=False
+    )
+    updated_at = Column(
+        DateTime(timezone=True),
+        server_default=func.now(),
+        onupdate=func.now(),
+        nullable=False,
+    )
+
+    # Database columns
+    task_id = Column(
+        String,
+        ForeignKey(
+            "manual_task.id",
+            name="manual_task_submission_task_id_fkey",
+            ondelete="CASCADE",
+        ),
+        nullable=False,
+    )
+    config_id = Column(
+        String,
+        ForeignKey(
+            "manual_task_config.id",
+            name="manual_task_submission_config_id_fkey",
+            ondelete="CASCADE",
+        ),
+        nullable=False,
+    )
+    field_id = Column(
+        String,
+        ForeignKey(
+            "manual_task_config_field.id",
+            name="manual_task_submission_field_id_fkey",
+            ondelete="CASCADE",
+        ),
+        nullable=False,
+    )
+    instance_id = Column(
+        String,
+        ForeignKey(
+            "manual_task_instance.id",
+            name="manual_task_submission_instance_id_fkey",
+            ondelete="CASCADE",
+        ),
+        nullable=False,
+    )
+    submitted_by = Column(
+        String,
+        ForeignKey(
+            "fidesuser.id",
+            name="manual_task_submission_submitted_by_fkey",
+            ondelete="SET NULL",
+        ),
+        nullable=True,
+    )
+    submitted_at = Column(DateTime, default=datetime.now(timezone.utc), nullable=False)
+    data = Column(JSONB, nullable=False)
+
+    __table_args__ = (
+        Index("ix_manual_task_submission_config_id", "config_id"),
+        Index("ix_manual_task_submission_field_id", "field_id"),
+        Index("ix_manual_task_submission_instance_field", "instance_id", "field_id"),
+        Index("ix_manual_task_submission_instance_id", "instance_id"),
+        Index("ix_manual_task_submission_submitted_at", "submitted_at"),
+        Index("ix_manual_task_submission_submitted_by", "submitted_by"),
+        Index("ix_manual_task_submission_task_id", "task_id"),
+    )
+
+    # Relationships
+    task = relationship("ManualTask", back_populates="submissions", viewonly=True)
+    config = relationship(
+        "ManualTaskConfig", back_populates="submissions", viewonly=True
+    )
+    field = relationship(
+        "ManualTaskConfigField", back_populates="submissions", viewonly=True
+    )
+    instance = relationship(
+        "ManualTaskInstance", back_populates="submissions", viewonly=True
+    )
+    attachments = relationship(
+        "Attachment",
+        secondary="attachment_reference",
+        primaryjoin="and_(ManualTaskSubmission.id == AttachmentReference.reference_id, "
+        "AttachmentReference.reference_type == 'manual_task_submission')",
+        secondaryjoin="Attachment.id == AttachmentReference.attachment_id",
+        order_by="Attachment.created_at",
+        viewonly=True,
+        uselist=True,
+    )
+
+    user = relationship(
+        "FidesUser",
+        primaryjoin="FidesUser.id == ManualTaskSubmission.submitted_by",
+        viewonly=True,
+    )