ethyca-fides 2.64.3b0__py2.py3-none-any.whl → 2.64.5rc1__py2.py3-none-any.whl

fides/api/models/manual_tasks/manual_task_config.py

@@ -0,0 +1,136 @@
+from typing import TYPE_CHECKING, Any, Optional
+
+from sqlalchemy import Boolean, Column, ForeignKey, Integer, String
+from sqlalchemy.dialects.postgresql import JSONB
+from sqlalchemy.ext.declarative import declared_attr
+from sqlalchemy.orm import Session, relationship
+
+from fides.api.db.base_class import Base
+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 (
+    ManualTaskConfigurationType,
+    ManualTaskFieldMetadata,
+    ManualTaskFieldType,
+)
+from fides.api.schemas.manual_tasks.manual_task_schemas import ManualTaskLogStatus
+
+if TYPE_CHECKING:  # pragma: no cover
+    from fides.api.models.manual_tasks.manual_task import ManualTask  # pragma: no cover
+
+
+class ManualTaskConfig(Base):
+    """Model for storing manual task configurations.
+    A single configuration may have many fields of different types.
+    """
+
+    @declared_attr
+    def __tablename__(cls) -> str:
+        return "manual_task_config"
+
+    task_id = Column(String, ForeignKey("manual_task.id"), nullable=False)
+    config_type = Column(EnumColumn(ManualTaskConfigurationType), nullable=False)
+    version = Column(Integer, nullable=False, default=1)
+    is_current = Column(Boolean, nullable=False, default=True)
+
+    # Relationships
+    task = relationship("ManualTask", back_populates="configs")
+    field_definitions = relationship(
+        "ManualTaskConfigField",
+        back_populates="config",
+        cascade="all, delete-orphan",
+        uselist=True,
+    )
+    logs = relationship(
+        "ManualTaskLog",
+        back_populates="config",
+        primaryjoin="ManualTaskConfig.id == ManualTaskLog.config_id",
+        viewonly=True,
+    )
+
+    @classmethod
+    def create(
+        cls, db: Session, *, data: dict[str, Any], check_name: bool = True
+    ) -> "ManualTaskConfig":
+        """Create a new manual task configuration."""
+        # Validate config_type
+        try:
+            ManualTaskConfigurationType(data["config_type"])
+        except ValueError:
+            raise ValueError(f"Invalid config type: {data['config_type']}")
+
+        config = super().create(db=db, data=data, check_name=check_name)
+
+        # Log the config creation as a task-level log
+        ManualTaskLog.create_log(
+            db=db,
+            task_id=data["task_id"],
+            config_id=config.id,
+            status=ManualTaskLogStatus.created,
+            message=f"Created manual task configuration for {data['config_type']}",
+            details={
+                "config_type": data["config_type"],
+            },
+        )
+        return config
+
+    def get_field(self, field_key: str) -> Optional["ManualTaskConfigField"]:
+        """Get a field by its key."""
+        for field in self.field_definitions:
+            if field.field_key == field_key:
+                return field
+        return None
+
+
+class ManualTaskConfigField(Base):
+    """Model for storing fields associated with each config."""
+
+    @declared_attr
+    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)
+    field_key = Column(String, nullable=False)
+    field_type = Column(
+        EnumColumn(ManualTaskFieldType), nullable=False
+    )  # Using ManualTaskFieldType
+    field_metadata = Column(JSONB, nullable=False, default={})
+
+    # Relationships
+    config = relationship("ManualTaskConfig", back_populates="field_definitions")
+
+    @property
+    def field_metadata_model(self) -> ManualTaskFieldMetadata:
+        """Get the field metadata as a Pydantic model."""
+        return ManualTaskFieldMetadata.model_validate(self.field_metadata)
+
+    @classmethod
+    def create(
+        cls, db: Session, *, data: dict[str, Any], check_name: bool = True
+    ) -> "ManualTaskConfigField":
+        """Create a new manual task config field."""
+        # Get the config to access its task_id and check if it exists
+        try:
+            config = (
+                db.query(ManualTaskConfig)
+                .filter(ManualTaskConfig.id == data["config_id"])
+                .first()
+            )
+            if not config:
+                raise ValueError(f"Config with id {data['config_id']} not found")
+        except Exception as e:
+            raise ValueError(f"Config with id {data['config_id']} not found: {e}")
+
+        # Create the field and let SQLAlchemy complex type validation handled in service.
+        field = super().create(db=db, data=data, check_name=check_name)
+
+        # Create a log entry
+        ManualTaskLog.create_log(
+            db=db,
+            task_id=config.task_id,
+            config_id=data["config_id"],
+            status=ManualTaskLogStatus.created,
+            message=f"Created manual task config field for {data['field_key']}",
+        )
+        return field

fides/api/models/manual_tasks/manual_task_log.py

@@ -0,0 +1,104 @@
+from typing import TYPE_CHECKING, Any, Optional
+
+from sqlalchemy import Column, ForeignKey, String
+from sqlalchemy.dialects.postgresql import JSONB
+from sqlalchemy.ext.declarative import declared_attr
+from sqlalchemy.orm import Session, relationship
+
+from fides.api.db.base_class import Base
+from fides.api.schemas.manual_tasks.manual_task_schemas import 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_config import (
+        ManualTaskConfig,  # pragma: no cover
+    )
+
+
+class ManualTaskLog(Base):
+    """Model for storing manual task execution logs."""
+
+    @declared_attr
+    def __tablename__(cls) -> str:
+        """Overriding base class method to set the table name."""
+        return "manual_task_log"
+
+    task_id = Column(
+        String, ForeignKey("manual_task.id", ondelete="CASCADE"), nullable=False
+    )
+    config_id = Column(String, ForeignKey("manual_task_config.id"), nullable=True)
+    instance_id = Column(String, nullable=True)
+    status = Column(String, nullable=False)
+    message = Column(String, nullable=False)
+    details = Column(JSONB, nullable=True)
+
+    # Relationships - using string references to avoid circular imports
+    task = relationship("ManualTask", back_populates="logs", foreign_keys=[task_id])
+    config = relationship(
+        "ManualTaskConfig", back_populates="logs", foreign_keys=[config_id]
+    )
+    # TODO: Add instance relationship when it is implemented
+    # instance = relationship("ManualTaskInstance", back_populates="logs")
+
+    @classmethod
+    def create_log(
+        cls,
+        db: Session,
+        task_id: str,
+        status: ManualTaskLogStatus,
+        message: str,
+        config_id: Optional[str] = None,
+        instance_id: Optional[str] = None,
+        details: Optional[dict[str, Any]] = None,
+    ) -> "ManualTaskLog":
+        """Create a new task log entry.
+
+        Args:
+            db: Database session
+            task_id: ID of the task
+            status: Status of the log entry
+            message: Optional message describing the event
+            details: Optional additional details about the event
+        """
+        data = {
+            "task_id": task_id,
+            "config_id": config_id,
+            "instance_id": instance_id,
+            "status": status,
+            "message": message,
+            "details": details,
+        }
+        return cls.create(db=db, data=data)
+
+    @classmethod
+    def create_error_log(
+        cls,
+        db: Session,
+        task_id: str,
+        message: str,
+        config_id: Optional[str] = None,
+        instance_id: Optional[str] = None,
+        details: Optional[dict[str, Any]] = None,
+    ) -> "ManualTaskLog":
+        """Create a new error log entry.
+
+        Args:
+            db: Database session
+            task_id: ID of the task
+            message: Error message describing what went wrong
+            config_id: Optional ID of the configuration
+            instance_id: Optional ID of the instance
+            details: Optional additional details about the error
+
+        Returns:
+            The created error log entry
+        """
+        return cls.create_log(
+            db=db,
+            status=ManualTaskLogStatus.error,
+            task_id=task_id,
+            config_id=config_id,
+            instance_id=instance_id,
+            message=message,
+            details=details,
+        )

fides/api/models/tcf_publisher_restrictions.py

@@ -10,7 +10,7 @@ from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.ext.declarative import declared_attr
 from sqlalchemy.orm import Session, relationship
 
-from fides.api.db.base_class import Base, FidesBase
+from fides.api.db.base_class import Base
 
 if TYPE_CHECKING:
     from fides.api.models.privacy_experience import PrivacyExperienceConfig
@@ -83,13 +83,7 @@ class TCFConfiguration(Base):
     def __tablename__(self) -> str:
         return "tcf_configuration"
 
-    # 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)
-    name = Column(String, nullable=False, unique=True)
+    name = Column(String, nullable=False, index=True, unique=True)
 
     privacy_experience_configs = relationship(
         "PrivacyExperienceConfig",
@@ -109,17 +103,11 @@ class TCFPublisherRestriction(Base):
     def __tablename__(self) -> str:
         return "tcf_publisher_restriction"
 
-    # 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)
-
     tcf_configuration_id = Column(
         String(255),
         ForeignKey("tcf_configuration.id", ondelete="CASCADE"),
         nullable=False,
+        index=True,
     )
     purpose_id = Column(Integer, nullable=False)
     restriction_type = Column(EnumColumn(TCFRestrictionType), nullable=False)
@@ -133,7 +121,7 @@ class TCFPublisherRestriction(Base):
     # can be inferred from the presence of the end_vendor_id.
     range_entries = Column(
         ARRAY(JSONB),
-        nullable=False,
+        nullable=True,
         server_default="{}",
         default=list,
     )

fides/api/schemas/manual_tasks/manual_task_config.py

@@ -0,0 +1,311 @@
+from datetime import datetime
+from enum import Enum
+from typing import TYPE_CHECKING, Annotated, Literal, Optional, Union
+
+from pydantic import ConfigDict, Field, ValidationInfo, field_validator, model_validator
+
+from fides.api.schemas.base_class import FidesSchema
+
+if TYPE_CHECKING:  # pragma: no cover
+    from fides.api.models.manual_tasks.manual_task import ManualTask  # pragma: no cover
+
+
+class ManualTaskConfigurationType(str, Enum):
+    """Enum for manual task configuration types."""
+
+    access_privacy_request = "access_privacy_request"
+    erasure_privacy_request = "erasure_privacy_request"
+    # Add more configuration types as needed
+
+
+class ManualTaskFieldType(str, Enum):
+    """Enum for manual task field types."""
+
+    text = "text"  # Key-value pairs
+    checkbox = "checkbox"  # Boolean value
+    attachment = "attachment"  # File upload
+    # Add more field types as needed
+
+
+class ManualTaskFieldMetadata(FidesSchema):
+    """Base schema for manual task field metadata."""
+
+    model_config = ConfigDict(extra="allow")
+
+    label: Annotated[str, Field(description="Display label for the field")]
+    required: Annotated[
+        bool, Field(default=False, description="Whether the field is required")
+    ]
+    help_text: Annotated[
+        Optional[str],
+        Field(default=None, description="Help text to display with the field"),
+    ]
+    data_uses: Annotated[
+        Optional[list[str]],
+        Field(
+            default=None,
+            description="List of data uses associated with this field",
+        ),
+    ]
+
+
+class ManualTaskTextFieldMetadata(ManualTaskFieldMetadata):
+    """Schema text field metadata."""
+
+    placeholder: Annotated[
+        Optional[str], Field(default=None, description="Placeholder text for the field")
+    ]
+    default_value: Annotated[
+        Optional[str], Field(default=None, description="Default value for the field")
+    ]
+    max_length: Annotated[
+        Optional[int], Field(default=None, description="Maximum length for text fields")
+    ]
+    min_length: Annotated[
+        Optional[int], Field(default=None, description="Minimum length for text fields")
+    ]
+    pattern: Annotated[
+        Optional[str],
+        Field(
+            default=None,
+            description=(
+                "Regex pattern for validation, for example if the field is an email address, "
+                r"you could use: ^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$"
+            ),
+        ),
+    ]
+
+    @field_validator("min_length", "max_length")
+    @classmethod
+    def validate_lengths(cls, v: Optional[int], info: ValidationInfo) -> Optional[int]:
+        """Validate that min_length is not greater than max_length."""
+        if v is None:
+            return v
+
+        if info.field_name == "min_length":
+            max_length = info.data.get("max_length")
+            if max_length is not None and v > max_length:
+                raise ValueError("min_length cannot be greater than max_length")
+        elif info.field_name == "max_length":
+            min_length = info.data.get("min_length")
+            if min_length is not None and v < min_length:
+                raise ValueError("min_length cannot be greater than max_length")
+
+        return v
+
+
+class ManualTaskCheckboxFieldMetadata(ManualTaskFieldMetadata):
+    """Schema for checkbox field metadata."""
+
+    default_value: Annotated[
+        Optional[bool],
+        Field(default=False, description="Default value for the checkbox"),
+    ]
+    label_true: Annotated[
+        Optional[str], Field(default=None, description="Label for checked state")
+    ]
+    label_false: Annotated[
+        Optional[str], Field(default=None, description="Label for unchecked state")
+    ]
+
+
+class ManualTaskAttachmentFieldMetadata(ManualTaskFieldMetadata):
+    """Schema for attachment field metadata."""
+
+    file_types: Annotated[
+        list[str], Field(description="Allowed file types for upload fields")
+    ]
+    max_file_size: Annotated[
+        int, Field(description="Maximum file size in bytes for upload fields")
+    ]
+    multiple: Annotated[
+        bool, Field(default=False, description="Whether multiple files can be uploaded")
+    ]
+    max_files: Annotated[
+        Optional[int],
+        Field(
+            default=None,
+            description="Maximum number of files allowed when multiple is true",
+        ),
+    ]
+    require_attachment_id: Annotated[
+        bool,
+        Field(
+            default=True,
+            description="Whether an attachment ID is required for this field",
+        ),
+    ]
+    attachment_ids: Annotated[
+        Optional[list[str]],
+        Field(
+            default=None,
+            description="List of attachment IDs associated with this field",
+        ),
+    ]
+
+    @model_validator(mode="after")
+    def validate_multiple_max_files(self) -> "ManualTaskAttachmentFieldMetadata":
+        """Validate that max_files is set when multiple is True."""
+        if self.multiple and self.max_files is None:
+            raise ValueError("max_files must be set when multiple is True")
+        return self
+
+
+class ManualTaskFieldBase(FidesSchema):
+    """Base schema for all field definitions."""
+
+    model_config = ConfigDict(extra="allow")
+
+    field_key: Annotated[
+        str, Field(description="Unique key for the field", min_length=1)
+    ]
+    field_type: Annotated[ManualTaskFieldType, Field(description="Type of the field")]
+    field_metadata: Annotated[
+        ManualTaskFieldMetadata, Field(description="Field metadata and configuration")
+    ]
+
+    @classmethod
+    def get_field_model_for_type(
+        cls, field_type: Union[str, ManualTaskFieldType]
+    ) -> type["ManualTaskFieldBase"]:
+        """Get the appropriate field model class for a given field type.
+
+        Args:
+            field_type: The field type as a string or ManualTaskFieldType enum value
+
+        Returns:
+            The appropriate field model class
+
+        Raises:
+            ValueError: If the field type is not recognized
+        """
+        # Handle non-string/non-enum types
+        if not isinstance(field_type, (str, ManualTaskFieldType)):
+            raise ValueError(
+                f"Invalid field type: expected string or ManualTaskFieldType, got {type(field_type).__name__}"
+            )
+
+        # Convert string to enum if needed
+        if isinstance(field_type, str):
+            try:
+                field_type = ManualTaskFieldType(field_type)
+            except ValueError:
+                raise ValueError(
+                    f"Invalid field type: '{field_type}' is not a valid ManualTaskFieldType"
+                )
+
+        # Map field types to their model classes
+        field_type_to_model = {
+            ManualTaskFieldType.text: ManualTaskTextField,
+            ManualTaskFieldType.checkbox: ManualTaskCheckboxField,
+            ManualTaskFieldType.attachment: ManualTaskAttachmentField,
+        }
+
+        model_class = field_type_to_model.get(field_type)
+        if not model_class:
+            raise ValueError(f"No model class found for field type: {field_type}")
+
+        return model_class
+
+
+class ManualTaskTextField(ManualTaskFieldBase):
+    """Schema for text field definition."""
+
+    field_type: Annotated[
+        Literal[ManualTaskFieldType.text], Field(description="Type of the field")
+    ]
+    field_metadata: Annotated[
+        ManualTaskTextFieldMetadata,
+        Field(description="Field metadata and configuration"),
+    ]
+
+
+class ManualTaskCheckboxField(ManualTaskFieldBase):
+    """Schema for checkbox field definition."""
+
+    field_type: Annotated[
+        Literal[ManualTaskFieldType.checkbox], Field(description="Type of the field")
+    ]
+    field_metadata: Annotated[
+        ManualTaskCheckboxFieldMetadata,
+        Field(description="Field metadata and configuration"),
+    ]
+
+
+class ManualTaskAttachmentField(ManualTaskFieldBase):
+    """Schema for attachment field definition."""
+
+    field_type: Annotated[
+        Literal[ManualTaskFieldType.attachment], Field(description="Type of the field")
+    ]
+    field_metadata: Annotated[
+        ManualTaskAttachmentFieldMetadata,
+        Field(description="Field metadata and configuration"),
+    ]
+
+
+# Type alias for all field types
+ManualTaskField = ManualTaskFieldBase
+
+
+class ManualTaskConfigCreate(FidesSchema):
+    """Schema for creating a manual task configuration."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    task_id: Annotated[
+        str, Field(description="ID of the task this configuration belongs to")
+    ]
+    config_type: Annotated[
+        ManualTaskConfigurationType, Field(description="Type of configuration")
+    ]
+    fields: Annotated[
+        list[ManualTaskFieldBase], Field(description="List of field definitions")
+    ]
+
+
+class ManualTaskConfigResponse(FidesSchema):
+    """Schema for manual task configuration response."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    id: Annotated[str, Field(description="Configuration ID")]
+    task_id: Annotated[str, Field(description="Task ID")]
+    config_type: Annotated[
+        ManualTaskConfigurationType, Field(description="Type of configuration")
+    ]
+    version: Annotated[int, Field(description="Version of the configuration")]
+    is_current: Annotated[
+        bool, Field(description="Whether this is the current version")
+    ]
+    fields: Annotated[
+        list[ManualTaskFieldBase], Field(description="List of field definitions")
+    ]
+    created_at: Annotated[datetime, Field(description="Creation timestamp")]
+    updated_at: Annotated[datetime, Field(description="Last update timestamp")]
+
+
+class ManualTaskConfigUpdate(FidesSchema):
+    """Schema for updating a manual task configuration."""
+
+    model_config = ConfigDict(extra="forbid", arbitrary_types_allowed=True)
+
+    task_id: Annotated[str, Field(description="ID of the task")]
+    config_type: Annotated[
+        ManualTaskConfigurationType, Field(description="Type of configuration")
+    ]
+    fields: Annotated[
+        list[ManualTaskFieldBase], Field(description="List of field definitions")
+    ]
+
+
+class ManualTaskConfigFieldResponse(FidesSchema):
+    """Schema for manual task configuration field response."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    field_key: Annotated[str, Field(description="Unique key for the field")]
+    field_type: Annotated[ManualTaskFieldType, Field(description="Type of the field")]
+    field_metadata: Annotated[
+        ManualTaskFieldMetadata, Field(description="Field metadata and configuration")
+    ]

fides/api/schemas/manual_tasks/manual_task_schemas.py

@@ -0,0 +1,79 @@
+from datetime import datetime
+from enum import Enum
+from typing import Annotated, Any, Optional
+
+from pydantic import ConfigDict, Field
+
+from fides.api.schemas.base_class import FidesSchema
+
+
+class ManualTaskType(str, Enum):
+    """Enum for manual task types."""
+
+    privacy_request = "privacy_request"
+    # Add more task types as needed
+
+
+class ManualTaskParentEntityType(str, Enum):
+    """Enum for manual task parent entity types."""
+
+    connection_config = (
+        "connection_config"  # used for access and erasure privacy requests
+    )
+    # Add more parent entity types as needed
+
+
+class ManualTaskReferenceType(str, Enum):
+    """Enum for manual task reference types."""
+
+    privacy_request = "privacy_request"
+    connection_config = "connection_config"
+    manual_task_config = "manual_task_config"
+    assigned_user = "assigned_user"  # Reference to the user assigned to the task
+    # Add more reference types as needed
+
+
+class ManualTaskLogStatus(str, Enum):
+    """Enum for manual task log status."""
+
+    created = "created"
+    updated = "updated"
+    in_progress = "in_progress"
+    complete = "complete"
+    error = "error"
+    retrying = "retrying"
+    paused = "paused"
+    awaiting_input = "awaiting_input"
+
+
+class ManualTaskLogCreate(FidesSchema):
+    """Schema for creating a manual task log entry."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    task_id: Annotated[str, Field(..., description="ID of the task")]
+    status: Annotated[ManualTaskLogStatus, Field(..., description="Log status")]
+    message: Annotated[Optional[str], Field(None, description="Log message")]
+    details: Annotated[
+        Optional[dict[str, Any]], Field(None, description="Additional details")
+    ]
+    config_id: Annotated[Optional[str], Field(None, description="Configuration ID")]
+    instance_id: Annotated[Optional[str], Field(None, description="Instance ID")]
+
+
+class ManualTaskLogResponse(FidesSchema):
+    """Schema for manual task log response."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    id: Annotated[str, Field(..., description="Log ID")]
+    task_id: Annotated[str, Field(..., description="Task ID")]
+    status: Annotated[ManualTaskLogStatus, Field(..., description="Log status")]
+    message: Annotated[Optional[str], Field(None, description="Log message")]
+    details: Annotated[
+        Optional[dict[str, Any]], Field(None, description="Additional details")
+    ]
+    config_id: Annotated[Optional[str], Field(None, description="Configuration ID")]
+    instance_id: Annotated[Optional[str], Field(None, description="Instance ID")]
+    created_at: Annotated[datetime, Field(..., description="Creation timestamp")]
+    updated_at: Annotated[datetime, Field(..., description="Last update timestamp")]