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

fides/service/manual_tasks/manual_task_config_service.py

@@ -1,370 +0,0 @@
-from typing import Any, Optional
-
-from loguru import logger
-from sqlalchemy.orm import Query, Session, selectinload
-
-from fides.api.models.manual_tasks.manual_task import ManualTask
-from fides.api.models.manual_tasks.manual_task_config import (
-    ManualTaskConfig,
-    ManualTaskConfigField,
-)
-from fides.api.schemas.manual_tasks.manual_task_config import (
-    ManualTaskConfigResponse,
-    ManualTaskConfigurationType,
-)
-from fides.service.manual_tasks.utils import validate_fields, with_task_logging
-
-
-class ManualTaskConfigService:
-    def __init__(self, db: Session):
-        self.db = db
-
-    def _create_log_data(
-        self, task_id: str, config_id: Optional[str], details: dict[str, Any]
-    ) -> dict[str, Any]:
-        """Create standard log data structure."""
-        return {"task_id": task_id, "config_id": config_id, "details": details}
-
-    def _get_base_config_query(self) -> Query:
-        """Get base config query with field definitions loaded."""
-        return self.db.query(ManualTaskConfig).options(
-            selectinload(ManualTaskConfig.field_definitions)
-        )
-
-    def _create_config_version(
-        self,
-        task: ManualTask,
-        config_type: str,
-        version: int,
-        is_current: bool = True,
-    ) -> ManualTaskConfig:
-        """Create a new config version. This is a helper method that creates a new config
-        version and sets it as the current version.
-
-        Args:
-            task: The task to create the config for
-            config_type: The type of config to create
-            version: The version number of the config
-            is_current: Whether the config is the current version
-        Returns:
-            The new config
-        """
-        try:
-            ManualTaskConfigurationType(config_type)
-        except ValueError:
-            raise ValueError(f"Invalid config type: {config_type}")
-
-        # Set all existing versions to non-current
-        if is_current:
-            self.db.query(ManualTaskConfig).filter(
-                ManualTaskConfig.task_id == task.id,
-                ManualTaskConfig.config_type == config_type,
-            ).update({"is_current": False})
-            self.db.flush()
-
-        return ManualTaskConfig.create(
-            db=self.db,
-            data={
-                "task_id": task.id,
-                "config_type": config_type,
-                "version": version,
-                "is_current": is_current,
-            },
-        )
-
-    def _handle_field_updates(
-        self,
-        config: ManualTaskConfig,
-        field_updates: Optional[list[dict[str, Any]]] = None,
-        fields_to_remove: Optional[list[str]] = None,
-        previous_config: Optional[ManualTaskConfig] = None,
-    ) -> set[str]:
-        """Handle field updates, removals, and recreation from previous version. This is a helper
-        function that:
-        - Creates new fields from field_updates
-        - Recreates unmodified fields from previous version so they will remain in the config
-        - Removes fields that are no longer in the config
-
-        Args:
-            config: The config to update
-            field_updates: The fields to update
-            fields_to_remove: The fields to remove
-            previous_config: The previous config
-        Returns:
-            The modified keys
-        """
-        modified_keys = set(fields_to_remove or [])
-
-        if field_updates:
-            validate_fields(field_updates, is_submission=False)
-            fields_to_create = [
-                {
-                    "task_id": config.task_id,
-                    "config_id": config.id,
-                    "field_key": f["field_key"],
-                    "field_type": f.get("field_type"),
-                    "field_metadata": f.get("field_metadata", {}),
-                }
-                for f in field_updates
-            ]
-            if fields_to_create:
-                self.db.bulk_insert_mappings(ManualTaskConfigField, fields_to_create)
-                modified_keys.update(f["field_key"] for f in field_updates)
-
-        if previous_config:
-            # Recreate unmodified fields from previous version
-            unmodified = [
-                {
-                    "task_id": config.task_id,
-                    "config_id": config.id,
-                    "field_key": f.field_key,
-                    "field_type": f.field_type,
-                    "field_metadata": f.field_metadata,
-                }
-                for f in previous_config.field_definitions
-                if f.field_key not in modified_keys
-            ]
-            if unmodified:
-                self.db.bulk_insert_mappings(ManualTaskConfigField, unmodified)
-
-        self.db.flush()
-        return modified_keys
-
-    def to_response(self, config: ManualTaskConfig) -> ManualTaskConfigResponse:
-        """Convert config model to response object."""
-        return ManualTaskConfigResponse.model_validate(
-            {
-                "id": config.id,
-                "task_id": config.task_id,
-                "config_type": config.config_type,
-                "version": config.version,
-                "is_current": config.is_current,
-                "fields": [
-                    {
-                        "field_key": f.field_key,
-                        "field_type": f.field_type,
-                        "field_metadata": f.field_metadata,
-                    }
-                    for f in config.field_definitions
-                ],
-                "created_at": config.created_at,
-                "updated_at": config.updated_at,
-            }
-        )
-
-    def get_current_config(
-        self, task: ManualTask, config_type: str
-    ) -> ManualTaskConfig:
-        """Get current config for task by type."""
-        config = (
-            self._get_base_config_query()
-            .filter(
-                ManualTaskConfig.task_id == task.id,
-                ManualTaskConfig.config_type == config_type,
-                ManualTaskConfig.is_current.is_(True),
-            )
-            .first()
-        )
-
-        if not config:
-            raise ValueError(
-                f"No current config found for task {task.id} and type {config_type}"
-            )
-        return config
-
-    def list_config_type_versions(
-        self, task: ManualTask, config_type: str
-    ) -> list[ManualTaskConfig]:
-        """List all versions of a config type for a task."""
-        return (
-            self._get_base_config_query()
-            .filter(
-                ManualTaskConfig.task_id == task.id,
-                ManualTaskConfig.config_type == config_type,
-            )
-            .order_by(ManualTaskConfig.version.desc())
-            .all()
-        )
-
-    def get_config(
-        self,
-        task: ManualTask,
-        config_type: str,
-        field_id: str,
-        config_id: str,
-        field_key: str,
-        version: int,
-    ) -> Optional[ManualTaskConfig]:
-        """Get config by various filters. This is a flexible lookup method that can find configs based on various filters.
-
-        Args:
-            task: The task to get the config for
-            config_type: The type of config to get
-            field_id: The ID of a field in the config
-            config_id: The ID of the config
-            field_key: The key of a field in the config
-            version: The version number of the config
-        Returns:
-            The matching config if found, None otherwise
-        """
-        if not any([task, config_id, field_id, config_type]):
-            logger.debug("No filters provided to get_config")
-            return None
-
-        query = self._get_base_config_query()
-        if field_id or field_key:
-            query = query.join(ManualTaskConfig.field_definitions)
-
-        filters = [
-            f
-            for f in [
-                task and ManualTaskConfig.task_id == task.id,
-                config_id and ManualTaskConfig.id == config_id,
-                field_id and ManualTaskConfigField.id == field_id,
-                field_key and ManualTaskConfigField.field_key == field_key,
-                version and ManualTaskConfig.version == version,
-                config_type and ManualTaskConfig.config_type == config_type,
-            ]
-            if f
-        ]
-
-        return query.filter(*filters).first()
-
-    @with_task_logging("Creating new configuration version")
-    def create_new_version(
-        self,
-        task: ManualTask,
-        config_type: str,
-        field_updates: Optional[list[dict[str, Any]]] = None,
-        fields_to_remove: Optional[list[str]] = None,
-        previous_config: Optional[ManualTaskConfig] = None,
-    ) -> tuple[ManualTaskConfig, dict[str, Any]]:
-        """Create new version of configuration.
-
-        Args:
-            task: The task to create the config for
-            config_type: The type of config to create
-            field_updates: The fields to update
-            fields_to_remove: The fields to remove
-            previous_config: The previous config
-
-        Returns:
-            Tuple containing the new config and log data, the log data is
-            captured by the with_task_logging decorator. and the new config is
-            returned to the caller.
-        """
-        new_config = self._create_config_version(
-            task, config_type, (previous_config.version + 1 if previous_config else 1)
-        )
-
-        self._handle_field_updates(
-            new_config, field_updates, fields_to_remove, previous_config
-        )
-
-        return new_config, self._create_log_data(
-            task.id,
-            new_config.id,
-            {
-                "config_type": config_type,
-                "version": new_config.version,
-                "added_field_keys": [f.get("field_key") for f in (field_updates or [])],
-                "removed_field_keys": fields_to_remove or [],
-            },
-        )
-
-    @with_task_logging("Adding fields to configuration")
-    def add_fields(
-        self, task: ManualTask, config_type: str, fields: list[dict[str, Any]]
-    ) -> tuple[ManualTaskConfig, dict[str, Any]]:
-        """Add fields to configuration.
-
-        Args:
-            task: The task to add the fields to
-            config_type: The type of config to add the fields to
-            fields: The fields to add
-
-        Returns:
-            Tuple containing the new config and log data, the log data is
-            captured by the with_task_logging decorator. and the new config is
-            returned to the caller.
-        """
-        current = self.get_current_config(task, config_type)
-        self.create_new_version(task, config_type, fields, previous_config=current)
-        new_config = self.get_current_config(task, config_type)
-
-        return new_config, self._create_log_data(
-            task.id,
-            current.id,
-            {
-                "config_type": config_type,
-                "previous_version": current.version,
-                "added_field_keys": [f.get("field_key") for f in fields],
-                "new_config_id": new_config.id,
-                "new_config_version": new_config.version,
-            },
-        )
-
-    @with_task_logging("Removing fields from configuration")
-    def remove_fields(
-        self, task: ManualTask, config_type: str, field_keys: list[str]
-    ) -> tuple[ManualTaskConfig, dict[str, Any]]:
-        """Remove fields from configuration.
-
-        Args:
-            task: The task to remove the fields from
-            config_type: The type of config to remove the fields from
-            field_keys: The keys of the fields to remove
-
-        Returns:
-            Tuple containing the new config and log data, the log data is
-            captured by the with_task_logging decorator. and the new config is
-            returned to the caller.
-        """
-        current = self.get_current_config(task, config_type)
-        self.create_new_version(
-            task, config_type, fields_to_remove=field_keys, previous_config=current
-        )
-        new_config = self.get_current_config(task, config_type)
-
-        return new_config, self._create_log_data(
-            task.id,
-            current.id,
-            {
-                "config_type": config_type,
-                "version": current.version,
-                "deleted_field_keys": field_keys,
-                "new_config_id": new_config.id,
-                "new_config_version": new_config.version,
-            },
-        )
-
-    @with_task_logging("Deleting Manual Task configuration")
-    def delete_config(
-        self, task: ManualTask, config_id: str
-    ) -> tuple[ManualTaskConfig, dict[str, Any]]:
-        """Delete config for task.
-
-        Args:
-            task: The task to delete the config for
-            config_id: The ID of the config to delete
-
-        Returns:
-            Tuple containing the deleted config and log data, the log data is
-            captured by the with_task_logging decorator. and the deleted config is
-            returned to the caller.
-        """
-        config = self.db.query(ManualTaskConfig).filter_by(id=config_id).first()
-        if not config:
-            raise ValueError(f"Config with ID {config_id} not found")
-
-        log_data = self._create_log_data(
-            task.id,
-            None,
-            {
-                "config_type": config.config_type,
-                "version": config.version,
-                "deleted_config_id": config_id,
-            },
-        )
-        config.delete(self.db)
-        return config, log_data

fides/service/manual_tasks/manual_task_service.py

@@ -1,294 +0,0 @@
-from typing import Any, Optional, cast
-
-from loguru import logger
-from sqlalchemy import select
-from sqlalchemy.orm import Session
-
-from fides.api.models.fides_user import FidesUser
-from fides.api.models.manual_tasks.manual_task import ManualTask, ManualTaskReference
-from fides.api.models.manual_tasks.manual_task_config import ManualTaskConfig
-from fides.api.schemas.manual_tasks.manual_task_schemas import (
-    ManualTaskParentEntityType,
-    ManualTaskReferenceType,
-    ManualTaskType,
-)
-from fides.service.manual_tasks.manual_task_config_service import (
-    ManualTaskConfigService,
-)
-from fides.service.manual_tasks.utils import with_task_logging
-
-
-class ManualTaskService:
-    def __init__(self, db: Session):
-        self.db = db
-        self.config_service = ManualTaskConfigService(db)
-
-    def get_task(
-        self,
-        task_id: Optional[str] = None,
-        parent_entity_id: Optional[str] = None,
-        parent_entity_type: Optional[ManualTaskParentEntityType] = None,
-        task_type: Optional[ManualTaskType] = None,
-    ) -> ManualTask:
-        """Get the manual task using provided filters.
-
-        This is a flexible lookup method that can find tasks based on various filters.
-        It's normal for this method to return None if no task matches the given filters.
-
-        Args:
-            task_id: The task ID
-            parent_entity_id: The parent entity ID
-            parent_entity_type: The parent entity type
-            task_type: The task type
-
-        Returns:
-            ManualTask: The matching task
-        """
-        if not any([task_id, parent_entity_id, parent_entity_type, task_type]):
-            logger.debug("No filters provided to get_task")
-            raise ValueError("No filters provided to get_task")
-
-        # Build filter conditions and a human-readable description
-        filters = []
-        filter_desc = []
-        if task_id:
-            filters.append(ManualTask.id == task_id)
-            filter_desc.append(f"task_id={task_id}")
-        if parent_entity_id:
-            filters.append(ManualTask.parent_entity_id == parent_entity_id)
-            filter_desc.append(f"parent_entity_id={parent_entity_id}")
-        if parent_entity_type:
-            filters.append(ManualTask.parent_entity_type == parent_entity_type)
-            filter_desc.append(f"parent_entity_type={parent_entity_type}")
-        if task_type:
-            filters.append(ManualTask.task_type == task_type)
-            filter_desc.append(f"task_type={task_type}")
-
-        # Apply all filters at once
-        stmt = select(ManualTask)  # type: ignore[arg-type]
-        if filters:
-            stmt = stmt.where(*filters)
-
-        task = self.db.execute(stmt).scalar_one_or_none()
-        if task is None:
-            logger.debug(f"No task found with filters: {filter_desc}")
-            raise ValueError(f"No task found with filters: {filter_desc}")
-        return task
-
-    @with_task_logging("Provided user IDs verified")
-    def _non_existent_users(
-        self, non_existent_user_ids: list[str], *, task_id: str
-    ) -> None:
-        """This is a helper function to raise an error if users do not exist.
-        If non_existent_user_ids is empty, this function will instead create
-        a success log entry.
-
-        Args:
-            non_existent_user_ids: List of non-existent user IDs
-            task_id: The task ID
-
-        Returns:
-            None
-        """
-        if len(non_existent_user_ids) > 0:
-            raise ValueError(
-                f"User(s) {sorted(list(non_existent_user_ids))} do not exist"
-            )
-
-    def _create_log_data(self, task_id: str, details: dict[str, Any]) -> dict[str, Any]:
-        """Create standard log data structure.
-
-        Args:
-            task_id: The task ID
-            details: The log details
-
-        Returns:
-            dict: The log data structure
-        """
-        return {
-            "task_id": task_id,
-            "details": details,
-        }
-
-    def _handle_user_errors(
-        self,
-        non_existent_users: list[str],
-        task_id: str,
-        details: dict[str, Any],
-        success_count: int,
-        error_key: str,
-    ) -> None:
-        """Handle errors for non-existent users.
-
-        Args:
-            non_existent_users: List of non-existent user IDs
-            task_id: The task ID
-            details: The log details to update
-            success_count: Number of successful operations
-            error_key: Key to use for error details
-
-        Raises:
-            ValueError: If no successful operations and users don't exist
-        """
-        try:
-            self._non_existent_users(non_existent_users, task_id=task_id)
-        except ValueError as e:
-            details[error_key] = sorted(non_existent_users)
-            if success_count == 0:
-                raise e
-
-    def _get_existing_users(self, user_ids: list[str]) -> set[str]:
-        """Get set of existing user IDs from the provided list.
-
-        Args:
-            user_ids: List of user IDs to check
-
-        Returns:
-            set: Set of existing user IDs
-        """
-        return set(
-            user.id
-            for user in self.db.query(FidesUser)
-            .filter(FidesUser.id.in_(user_ids))
-            .all()
-        )
-
-    def _handle_user_operation(
-        self,
-        task_id: str,
-        user_ids: list[str],
-        operation_type: str,
-        current_users: Optional[set[str]] = None,
-    ) -> tuple[set[str], dict[str, Any]]:
-        """Handle user assignment/unassignment operations.
-
-        Args:
-            task_id: The task ID
-            user_ids: List of user IDs to process
-            operation_type: Type of operation ('assign' or 'unassign')
-            current_users: Optional set of current users
-
-        Returns:
-            tuple: (processed_users, log_data)
-        """
-        if not (user_ids := list(set(user_ids))):
-            raise ValueError(f"User ID is required for {operation_type}ment")
-
-        existing_users = set(
-            u.id
-            for u in self.db.query(FidesUser).filter(FidesUser.id.in_(user_ids)).all()
-        )
-        processed_users = (
-            existing_users - (current_users or set())
-            if operation_type == "assign"
-            else existing_users
-        )
-        details = {f"{operation_type}ed_users": sorted(list(processed_users))}
-
-        if non_existing := list(set(user_ids) - existing_users):
-            try:
-                self._non_existent_users(non_existing, task_id=task_id)
-            except ValueError as e:
-                details[f"user_ids_not_{operation_type}ed"] = sorted(non_existing)
-                if not processed_users:
-                    raise e
-
-        return processed_users, {"task_id": task_id, "details": details}
-
-    @with_task_logging("Assign users to task")
-    def assign_users_to_task(
-        self, task_id: str, user_ids: list[str]
-    ) -> tuple[ManualTask, dict[str, Any]]:
-        """Assign users to a task.
-
-        Args:
-            task_id: The task ID
-            user_ids: List of user IDs to assign
-
-        Returns:
-            Tuple containing the task and log data, the log data is
-            captured by the with_task_logging decorator. and the task is
-            returned to the caller.
-        """
-        task = self.get_task(task_id=task_id)
-        users_to_assign, log_data = self._handle_user_operation(
-            task_id, user_ids, "assign", set(task.assigned_users)
-        )
-
-        if users_to_assign:
-            self.db.bulk_insert_mappings(
-                ManualTaskReference,
-                [
-                    {
-                        "task_id": task.id,
-                        "reference_id": user_id,
-                        "reference_type": ManualTaskReferenceType.assigned_user,
-                    }
-                    for user_id in users_to_assign
-                ],
-            )
-            self.db.flush()
-            self.db.refresh(task)
-
-        return task, log_data
-
-    @with_task_logging("Unassign users from task")
-    def unassign_users_from_task(
-        self, task_id: str, user_ids: list[str]
-    ) -> tuple[ManualTask, dict[str, Any]]:
-        task = self.get_task(task_id=task_id)
-        refs_to_unassign = (
-            self.db.query(ManualTaskReference)
-            .filter(
-                ManualTaskReference.task_id == task.id,
-                ManualTaskReference.reference_type
-                == ManualTaskReferenceType.assigned_user,
-                ManualTaskReference.reference_id.in_(user_ids),
-            )
-            .all()
-        )
-
-        if refs_to_unassign:
-            self.db.query(ManualTaskReference).filter(
-                ManualTaskReference.id.in_([ref.id for ref in refs_to_unassign])
-            ).delete(synchronize_session=False)
-            self.db.flush()
-            self.db.refresh(task)
-
-        _, log_data = self._handle_user_operation(task_id, user_ids, "unassign")
-        return task, log_data
-
-    def create_config(
-        self, config_type: str, fields: list[dict], task_id: str
-    ) -> ManualTaskConfig:
-        """Create a new config for a task.
-
-        Args:
-            config_type: The config type
-            fields: The fields for the config
-            task_id: The task ID
-
-        Returns:
-            ManualTaskConfig: The new config
-        """
-        task = self.get_task(task_id=task_id)
-        config = self.config_service.create_new_version(task, config_type, fields)
-        return cast(ManualTaskConfig, config)
-
-    def delete_config(self, config: ManualTaskConfig, task_id: str) -> None:
-        """Delete this configuration.
-        Args:
-            config: The config to delete
-            task_id: The task ID
-        Raises:
-            ValueError: If there are active instances using this configuration
-            ValueError: If the task does not exist
-
-        Returns:
-            dict[str, Any]: The log details - intercepted by the `with_task_logging` decorator.
-        """
-        task = self.get_task(task_id=task_id)
-
-        # Delete the configuration
-        config_id = config.id
-        self.config_service.delete_config(task, config_id)