ethyca-fides 2.63.5rc0__py2.py3-none-any.whl → 2.64.0__py2.py3-none-any.whl

fides/service/manual_tasks/manual_task_service.py

@@ -1,4 +1,4 @@
-from typing import Optional
+from typing import Any, Optional, cast
 
 from loguru import logger
 from sqlalchemy import select
@@ -6,18 +6,22 @@ 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_log import ManualTaskLog
+from fides.api.models.manual_tasks.manual_task_config import ManualTaskConfig
 from fides.api.schemas.manual_tasks.manual_task_schemas import (
-    ManualTaskLogStatus,
     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,
@@ -25,9 +29,12 @@ class ManualTaskService:
         parent_entity_id: Optional[str] = None,
         parent_entity_type: Optional[ManualTaskParentEntityType] = None,
         task_type: Optional[ManualTaskType] = None,
-    ) -> Optional[ManualTask]:
+    ) -> 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
@@ -35,89 +42,203 @@ class ManualTaskService:
             task_type: The task type
 
         Returns:
-            Optional[ManualTask]: The manual task for the connection, if it exists
+            ManualTask: The matching task
         """
         if not any([task_id, parent_entity_id, parent_entity_type, task_type]):
-            logger.warning("No filters provided to get_task. Returning None.")
-            return None
+            logger.debug("No filters provided to get_task")
+            raise ValueError("No filters provided to get_task")
 
-        stmt = select(ManualTask)  # type: ignore[arg-type]
+        # Build filter conditions and a human-readable description
+        filters = []
+        filter_desc = []
         if task_id:
-            stmt = stmt.where(ManualTask.id == task_id)
+            filters.append(ManualTask.id == task_id)
+            filter_desc.append(f"task_id={task_id}")
         if parent_entity_id:
-            stmt = stmt.where(ManualTask.parent_entity_id == 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:
-            stmt = stmt.where(ManualTask.parent_entity_type == 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:
-            stmt = stmt.where(ManualTask.task_type == task_type)
-        return self.db.execute(stmt).scalar_one_or_none()
+            filters.append(ManualTask.task_type == task_type)
+            filter_desc.append(f"task_type={task_type}")
 
-    # User Management
-    def assign_users_to_task(
-        self, db: Session, task: ManualTask, user_ids: list[str]
+        # 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:
-        """Assigns users to this task. We can assign one or more users to a task.
+        """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:
-            db: Database session
-            task: The task to assign users to
-            user_ids: List of user IDs to assign
+            non_existent_user_ids: List of non-existent user IDs
+            task_id: The task ID
+
+        Returns:
+            None
         """
-        user_ids = list(set(user_ids))
-        if not user_ids:
-            raise ValueError("User ID is required for assignment")
-
-        # Create new user assignment
-        for user_id in user_ids:
-            # if user is already assigned, skip
-            if user_id in task.assigned_users:
-                continue
-            # verify user exists
-            user = db.query(FidesUser).filter_by(id=user_id).first()
-            if not user:
-                ManualTaskLog.create_error_log(
-                    db=db,
-                    task_id=task.id,
-                    message=f"Failed to add user {user_id} to task {task.id}: user does not exist",
-                    details={"user_id": user_id},
-                )
-                continue
-
-            ManualTaskReference.create(
-                db=db,
-                data={
-                    "task_id": task.id,
-                    "reference_id": user_id,
-                    "reference_type": ManualTaskReferenceType.assigned_user,
-                },
+        if len(non_existent_user_ids) > 0:
+            raise ValueError(
+                f"User(s) {sorted(list(non_existent_user_ids))} do not exist"
             )
 
-            # Log the user assignment
-            ManualTaskLog.create_log(
-                db=db,
-                task_id=task.id,
-                status=ManualTaskLogStatus.updated,
-                message=f"User {user_id} assigned to task",
-                details={"assigned_user_id": user_id},
-            )
+    def _create_log_data(self, task_id: str, details: dict[str, Any]) -> dict[str, Any]:
+        """Create standard log data structure.
 
-    def unassign_users_from_task(
-        self, db: Session, task: ManualTask, user_ids: list[str]
+        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:
-        """Remove the user assignment from this task.
+        """Handle errors for non-existent users.
 
         Args:
-            db: Database session
-            task: The task to unassign users from
-            user_ids: List of user IDs to unassign
+            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
         """
-        user_ids = list(set(user_ids))
-        if not user_ids:
-            raise ValueError("User ID is required for unassignment")
+        return set(
+            user.id
+            for user in self.db.query(FidesUser)
+            .filter(FidesUser.id.in_(user_ids))
+            .all()
+        )
 
-        # Get references to unassign
-        references_to_unassign = (
-            db.query(ManualTaskReference)
+    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
@@ -127,24 +248,47 @@ class ManualTaskService:
             .all()
         )
 
-        # Delete references and log unassignments
-        for ref in references_to_unassign:
-            ref.delete(db)
-            ManualTaskLog.create_log(
-                db=db,
-                task_id=task.id,
-                status=ManualTaskLogStatus.updated,
-                message=f"User {ref.reference_id} unassigned from task",
-                details={"unassigned_user_id": ref.reference_id},
-            )
+        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)
 
-        # Check if any users weren't unassigned
-        unassigned_user_ids = [ref.reference_id for ref in references_to_unassign]
-        left_over_user_ids = [
-            user_id for user_id in user_ids if user_id not in unassigned_user_ids
-        ]
-        if left_over_user_ids:
-            logger.warning(
-                f"Failed to unassign users {left_over_user_ids} from task {task.id}: "
-                "users were not assigned to the 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)

fides/service/manual_tasks/utils.py

@@ -0,0 +1,185 @@
+from functools import wraps
+from typing import Any, Callable, Optional, TypeVar
+
+from loguru import logger
+from pydantic import ValidationError
+
+from fides.api.models.manual_tasks.manual_task_log import ManualTaskLog
+from fides.api.schemas.manual_tasks.manual_task_config import ManualTaskFieldBase
+from fides.api.schemas.manual_tasks.manual_task_schemas import ManualTaskLogStatus
+from fides.api.schemas.manual_tasks.manual_task_status import StatusType
+
+T = TypeVar("T")
+
+
+def validate_fields(fields: list[dict[str, Any]], is_submission: bool = False) -> None:
+    """Validate field data against the appropriate Pydantic model.
+
+    Args:
+        fields: List of field data to validate
+        is_submission: Whether the fields are for a submission (True) or configuration (False)
+
+    Raises:
+        ValueError: If the field data is invalid
+    """
+    # Check for duplicate field keys
+    if len({str(field.get("field_key")) for field in fields}) != len(fields):
+        raise ValueError(
+            "Duplicate field keys found in field updates, field keys must be unique."
+        )
+
+    for field in fields:
+        if not field.get("field_key"):
+            raise ValueError("Invalid field data: field_key is required")
+        if not field.get("field_type"):
+            raise ValueError("Invalid field data: field_type is required")
+        if is_submission and "value" not in field:
+            raise ValueError("Invalid field data: value is required for submissions")
+        if not is_submission:
+            try:
+                field_model = ManualTaskFieldBase.get_field_model_for_type(
+                    field["field_type"]
+                )
+                field_model.model_validate(field)
+            except ValidationError as e:
+                raise ValueError(f"Invalid field data: {str(e)}")
+
+
+class TaskLogger:
+    """Class-based decorator for logging operation success/failure in service methods.
+    Args:
+        operation_name: The name of the operation to log
+        success_status: The status to log for successful operations
+
+    The decorated function can return either:
+    - A tuple of (return_value, log_details)
+    - Just the return value (in which case log details will be extracted from it)
+    """
+
+    def __init__(
+        self,
+        operation_name: str,
+        success_status: ManualTaskLogStatus = ManualTaskLogStatus.complete,
+    ) -> None:
+        self.operation_name = operation_name
+        self.success_status = success_status
+
+    def __call__(self, func: Callable[..., T]) -> Callable[..., T]:
+        @wraps(func)
+        def wrapped(service_self: Any, *args: Any, **kwargs: Any) -> T:
+            try:
+                result = func(service_self, *args, **kwargs)
+                return_value, log_data = (
+                    result
+                    if isinstance(result, tuple) and len(result) == 2
+                    else (result, {})
+                )
+                if hasattr(service_self, "db") and (
+                    task_id := self._get_task_id(return_value, kwargs)
+                ):
+                    self._log_success(
+                        service_self.db, task_id, return_value, log_data, kwargs
+                    )
+                return return_value
+            except Exception as e:
+                self._log_error(service_self, e, kwargs)
+                raise
+
+        return wrapped
+
+    def _get_task_id(self, result: Any, kwargs: dict) -> Optional[str]:
+        """Extract task_id from result or kwargs."""
+        return getattr(result, "task_id", None) or kwargs.get("task_id")
+
+    def _get_log_data(self, result: Any, kwargs: dict) -> dict:
+        """Create log data from result and kwargs."""
+        log_data = {}
+        for field in ["task_id", "config_id", "instance_id"]:
+            if value := getattr(result, field, None) or kwargs.get(field):
+                log_data[field] = value
+        log_data["details"] = kwargs.get("details", {})
+        return log_data
+
+    def _log_success(
+        self, db: Any, task_id: str, result: Any, log_data: dict, kwargs: dict
+    ) -> None:
+        """Log successful operation."""
+        ManualTaskLog.create_log(
+            db=db,
+            **self._get_log_data(result, kwargs | log_data),
+            status=self.success_status,
+            message=self.operation_name,
+        )
+
+    def _log_error(self, service_self: Any, error: Exception, kwargs: dict) -> None:
+        """Log operation error."""
+        logger.error(f"Error in {self.operation_name}: {str(error)}")
+        if hasattr(service_self, "db") and (task_id := self._get_task_id({}, kwargs)):
+            ManualTaskLog.create_log(
+                db=service_self.db,
+                task_id=task_id,
+                **{
+                    k: v
+                    for k, v in self._get_log_data({}, kwargs).items()
+                    if k != "task_id"
+                },
+                status=ManualTaskLogStatus.error,
+                message=f"Error in {self.operation_name}: {str(error)}",
+            )
+
+    @staticmethod
+    def log_status_change(
+        db: Any,
+        task_id: str,
+        config_id: Optional[str] = None,
+        instance_id: Optional[str] = None,
+        previous_status: Optional[StatusType] = None,
+        new_status: Optional[StatusType] = None,
+        user_id: Optional[str] = None,
+    ) -> None:
+        """Log a status change event."""
+        ManualTaskLog.create_log(
+            db=db,
+            task_id=task_id,
+            config_id=config_id,
+            instance_id=instance_id,
+            status=ManualTaskLogStatus.in_progress,
+            message=f"Task instance status transitioning from {previous_status} to {new_status}",
+            details={
+                "previous_status": previous_status,
+                "new_status": new_status,
+                "user_id": user_id,
+            },
+        )
+
+    @staticmethod
+    def log_create(
+        db: Any,
+        task_id: str,
+        entity_type: str,
+        entity_id: str,
+        details: Optional[dict] = None,
+        user_id: Optional[str] = None,
+        status: ManualTaskLogStatus = ManualTaskLogStatus.created,
+    ) -> None:
+        """Log a creation event."""
+        id_fields = {
+            "task": {"task_id": task_id},
+            "config": {"task_id": task_id, "config_id": entity_id},
+            "instance": {"task_id": task_id, "instance_id": entity_id},
+            "submission": {"task_id": task_id, "instance_id": entity_id},
+        }
+        if entity_type not in id_fields:
+            raise ValueError(f"Invalid entity type: {entity_type}")
+
+        ManualTaskLog.create_log(
+            db=db,
+            **id_fields[entity_type],
+            status=status,
+            message=f"Created new {entity_type}",
+            details=(details or {}) | ({"user_id": user_id} if user_id else {}),
+        )
+
+
+# Alias the class to maintain the original decorator name
+with_task_logging = TaskLogger

fides/ui-build/static/admin/404.html

@@ -1 +1 @@
-<!DOCTYPE html><html lang="en"><head><meta charSet="utf-8"/><meta name="viewport" content="width=device-width"/><meta name="next-head-count" content="2"/><link data-next-font="" rel="preconnect" href="/" crossorigin="anonymous"/><link rel="preload" href="/_next/static/css/1fdf5c593349dbc6.css" as="style"/><link rel="stylesheet" href="/_next/static/css/1fdf5c593349dbc6.css" data-n-g=""/><noscript data-n-css=""></noscript><script defer="" nomodule="" src="/_next/static/chunks/polyfills-42372ed130431b0a.js"></script><script src="/_next/static/chunks/webpack-8457bad7859c44f0.js" defer=""></script><script src="/_next/static/chunks/framework-c92fc3344e6fd165.js" defer=""></script><script src="/_next/static/chunks/main-090643377c8254e6.js" defer=""></script><script src="/_next/static/chunks/pages/_app-f70bffa5a7903c46.js" defer=""></script><script src="/_next/static/chunks/pages/404-ec04f826f3dd79ea.js" defer=""></script><script src="/_next/static/CusFTpvTru1E2j2Mvq9Bl/_buildManifest.js" defer=""></script><script src="/_next/static/CusFTpvTru1E2j2Mvq9Bl/_ssgManifest.js" defer=""></script><style>.data-ant-cssinjs-cache-path{content:"";}</style></head><body><div id="__next"><div style="height:100%;display:flex"></div></div><script id="__NEXT_DATA__" type="application/json">{"props":{"pageProps":{}},"page":"/404","query":{},"buildId":"CusFTpvTru1E2j2Mvq9Bl","nextExport":true,"autoExport":true,"isFallback":false,"scriptLoader":[]}</script></body></html>
+<!DOCTYPE html><html lang="en"><head><meta charSet="utf-8"/><meta name="viewport" content="width=device-width"/><meta name="next-head-count" content="2"/><link data-next-font="" rel="preconnect" href="/" crossorigin="anonymous"/><link rel="preload" href="/_next/static/css/c693338e3bc8dcc6.css" as="style"/><link rel="stylesheet" href="/_next/static/css/c693338e3bc8dcc6.css" data-n-g=""/><noscript data-n-css=""></noscript><script defer="" nomodule="" src="/_next/static/chunks/polyfills-42372ed130431b0a.js"></script><script src="/_next/static/chunks/webpack-0a61b5bd21a41fe6.js" defer=""></script><script src="/_next/static/chunks/framework-c92fc3344e6fd165.js" defer=""></script><script src="/_next/static/chunks/main-090643377c8254e6.js" defer=""></script><script src="/_next/static/chunks/pages/_app-f32f997d9c03a84e.js" defer=""></script><script src="/_next/static/chunks/pages/404-ac2f0844e5c4b4cd.js" defer=""></script><script src="/_next/static/JnAJNZ-6yNjlkUkjzXxai/_buildManifest.js" defer=""></script><script src="/_next/static/JnAJNZ-6yNjlkUkjzXxai/_ssgManifest.js" defer=""></script><style>.data-ant-cssinjs-cache-path{content:"";}</style></head><body><div id="__next"><div style="height:100%;display:flex"></div></div><script id="__NEXT_DATA__" type="application/json">{"props":{"pageProps":{}},"page":"/404","query":{},"buildId":"JnAJNZ-6yNjlkUkjzXxai","nextExport":true,"autoExport":true,"isFallback":false,"scriptLoader":[]}</script></body></html>

fides/ui-build/static/admin/_next/static/JnAJNZ-6yNjlkUkjzXxai/_buildManifest.js

@@ -0,0 +1 @@
+self.__BUILD_MANIFEST=function(s,e,t,a,c,n,i,d,o,r,p,u,g,f,m,b,j,k,h,y,l,v,I,F,x,_,U,w,q,N,A,S,B,C,z,D,E,L,M,T,P,G,H,J,K,O,Q,R,V,W,X){return{__rewrites:{afterFiles:[],beforeFiles:[],fallback:[]},"/":[_,"static/chunks/pages/index-1adb6bcb71701ac2.js"],"/404":["static/chunks/pages/404-ac2f0844e5c4b4cd.js"],"/_error":["static/chunks/pages/_error-bede3a8288930dcf.js"],"/add-systems":[e,_,"static/chunks/pages/add-systems-587e21d14e0a5196.js"],"/add-systems/manual":[s,t,c,n,i,o,b,e,a,d,u,j,l,U,w,"static/chunks/pages/add-systems/manual-0a5f2310ce6b1059.js"],"/add-systems/multiple":[s,t,e,a,u,k,q,"static/chunks/pages/add-systems/multiple-00cb904825aad7e3.js"],"/consent":["static/chunks/pages/consent-4d5ea70a77df1bb8.js"],"/consent/configure":[s,t,e,a,u,k,"static/chunks/pages/consent/configure-f140ec9d8e8a0f7a.js"],"/consent/configure/add-vendors":[s,t,e,a,u,k,q,"static/chunks/pages/consent/configure/add-vendors-fa7305b88c1afd20.js"],"/consent/privacy-experience":[s,t,b,e,a,N,"static/chunks/pages/consent/privacy-experience-d8d926f0735a2546.js"],"/consent/privacy-experience/new":[c,n,g,A,r,h,S,"static/chunks/pages/consent/privacy-experience/new-a0039f216fb3eb93.js"],"/consent/privacy-experience/[id]":[c,n,g,A,r,h,S,"static/chunks/pages/consent/privacy-experience/[id]-0edb7c92518e7d21.js"],"/consent/privacy-notices":[s,t,e,a,N,"static/chunks/pages/consent/privacy-notices-1135ad8924d32c36.js"],"/consent/privacy-notices/new":[c,n,g,B,r,h,C,"static/chunks/pages/consent/privacy-notices/new-130155cfb4a0bcc7.js"],"/consent/privacy-notices/[id]":[c,n,g,B,r,h,C,"static/chunks/pages/consent/privacy-notices/[id]-5c949f2e3cef2398.js"],"/consent/properties":[s,t,e,a,z,"static/chunks/pages/consent/properties-776855e370414beb.js"],"/consent/reporting":[s,t,c,e,a,"static/chunks/pages/consent/reporting-21c23f75ff1135d9.js"],"/data-catalog":[s,t,c,n,i,e,a,d,"static/css/95ac327e5d70148d.css","static/chunks/pages/data-catalog-7b5aec33da578745.js"],"/data-catalog/[systemId]/projects":[s,t,c,n,i,e,a,d,v,p,"static/chunks/pages/data-catalog/[systemId]/projects-cfac259a30641e68.js"],"/data-catalog/[systemId]/projects/[projectUrn]":[s,t,e,a,D,"static/chunks/pages/data-catalog/[systemId]/projects/[projectUrn]-030ee304cbe5e530.js"],"/data-catalog/[systemId]/projects/[projectUrn]/[resourceUrn]":[s,t,c,n,i,e,a,d,v,E,p,"static/chunks/pages/data-catalog/[systemId]/projects/[projectUrn]/[resourceUrn]-c623d6f1a61c8ea9.js"],"/data-catalog/[systemId]/resources":[s,t,e,a,D,"static/chunks/pages/data-catalog/[systemId]/resources-51d99174c8006eb5.js"],"/data-catalog/[systemId]/resources/[resourceUrn]":[s,t,c,n,i,e,a,d,v,E,p,"static/chunks/pages/data-catalog/[systemId]/resources/[resourceUrn]-57bd5cdf784f059f.js"],"/data-discovery/action-center":[s,t,e,a,"static/chunks/pages/data-discovery/action-center-27205f8457a1ecb0.js"],"/data-discovery/action-center/[monitorId]":[s,t,c,n,i,e,a,I,"static/chunks/pages/data-discovery/action-center/[monitorId]-333f53caab751428.js"],"/data-discovery/action-center/[monitorId]/[systemId]":[s,t,c,n,i,e,a,d,u,l,"static/css/81642473e38c67a5.css","static/chunks/pages/data-discovery/action-center/[monitorId]/[systemId]-c948f93c833d4358.js"],"/data-discovery/activity":[s,t,e,a,m,"static/chunks/pages/data-discovery/activity-20a1043f6a06198f.js"],"/data-discovery/detection":[s,t,e,a,m,L,"static/chunks/pages/data-discovery/detection-faf326a6200637d0.js"],"/data-discovery/detection/[resourceUrn]":[s,t,e,a,m,L,"static/chunks/pages/data-discovery/detection/[resourceUrn]-06edce289876dea1.js"],"/data-discovery/discovery":[s,t,c,n,i,e,a,d,m,M,p,"static/chunks/pages/data-discovery/discovery-8c3e4be6d36da66d.js"],"/data-discovery/discovery/[resourceUrn]":[s,t,c,n,i,e,a,d,m,M,p,"static/chunks/pages/data-discovery/discovery/[resourceUrn]-64acf269256ee74f.js"],"/datamap":[s,t,"static/chunks/255-7db55b0e3a0f9dea.js",e,a,j,T,"static/chunks/pages/datamap-fb50de22f83edd4a.js"],"/dataset":[s,t,f,e,a,y,"static/chunks/pages/dataset-8f7d16bc5e9229c8.js"],"/dataset/new":[f,y,"static/chunks/pages/dataset/new-d4e31a1c4a58800e.js"],"/dataset/[datasetId]":[s,t,"static/chunks/9729-fcf6ff4e3534e4a8.js",e,a,F,"static/chunks/pages/dataset/[datasetId]-904d43e31157aa55.js"],"/dataset/[datasetId]/[collectionName]":[s,t,c,n,i,o,e,a,d,F,p,"static/chunks/pages/dataset/[datasetId]/[collectionName]-6e2caba24b3e78c2.js"],"/dataset/[datasetId]/[collectionName]/[...subfieldNames]":[s,t,c,n,i,o,e,a,d,F,p,"static/chunks/pages/dataset/[datasetId]/[collectionName]/[...subfieldNames]-41ab27c4195cfa93.js"],"/datastore-connection":["static/css/5f393dea1c0d031c.css","static/chunks/pages/datastore-connection-8f9b8890018e1ea5.js"],"/datastore-connection/new":[c,o,f,b,P,y,G,"static/chunks/pages/datastore-connection/new-e88509346b2d2851.js"],"/datastore-connection/[id]":[c,o,f,P,y,G,"static/chunks/pages/datastore-connection/[id]-4a33dd0371dbaebc.js"],"/fides-js-docs":["static/chunks/2fbcc6de-a6c61724c327e9fa.js","static/chunks/e3251fe7-5777b5d778e6fffa.js",c,n,i,o,f,H,"static/css/ab65b8cc3144bfc8.css","static/chunks/905-742074a074be1055.js","static/chunks/pages/fides-js-docs-5d8fd1af75f19e2f.js"],"/integrations":[s,t,c,n,i,o,g,J,e,a,K,p,"static/chunks/pages/integrations-adc286ff254e7f41.js"],"/integrations/[id]":[s,t,c,n,i,o,g,J,e,a,K,"static/css/e458b5f1afdbb7fc.css","static/chunks/pages/integrations/[id]-fdc2964fa7d1d8fd.js"],"/login":["static/chunks/pages/login-0cb0eb44bf2dd24c.js"],"/login/[provider]":["static/chunks/pages/login/[provider]-c58beef131c3a82d.js"],"/messaging":[s,t,c,n,i,e,a,"static/chunks/pages/messaging-aa744ae8b61e5ff2.js"],"/messaging/add-template":[r,O,"static/chunks/pages/messaging/add-template-f8fd4795e260887c.js"],"/messaging/[id]":[r,O,"static/chunks/pages/messaging/[id]-9b4d1d61c7c97509.js"],"/poc/ant-components":["static/chunks/pages/poc/ant-components-3407158757fb3627.js"],"/poc/form-experiments/AntForm":["static/chunks/pages/poc/form-experiments/AntForm-47e947c02ae90fd0.js"],"/poc/form-experiments/FormikAntFormItem":["static/chunks/pages/poc/form-experiments/FormikAntFormItem-24f9a44512ce8827.js"],"/poc/form-experiments/FormikControlled":["static/chunks/pages/poc/form-experiments/FormikControlled-e567a69f8c37fb9a.js"],"/poc/form-experiments/FormikField":["static/chunks/pages/poc/form-experiments/FormikField-35a33f9c7def2220.js"],"/poc/form-experiments/FormikSpreadField":[Q,"static/chunks/pages/poc/form-experiments/FormikSpreadField-af097d661f6abcf4.js"],"/poc/forms":[Q,"static/chunks/pages/poc/forms-780e18dde8e38099.js"],"/poc/table-migration":[u,k,"static/chunks/pages/poc/table-migration-7a17dffa515e5560.js"],"/privacy-requests":[s,t,e,a,R,"static/chunks/pages/privacy-requests-c4e1b69fb5bab61a.js"],"/privacy-requests/configure":["static/chunks/pages/privacy-requests/configure-1a1aa83a3f88844c.js"],"/privacy-requests/configure/messaging":["static/chunks/pages/privacy-requests/configure/messaging-b01cbbaac34dadbc.js"],"/privacy-requests/configure/storage":["static/chunks/pages/privacy-requests/configure/storage-a15410de7f1d0f84.js"],"/privacy-requests/[id]":[R,"static/css/5ded47c57dae5baf.css","static/chunks/pages/privacy-requests/[id]-91dd0039cc2b70bc.js"],"/properties":[s,t,e,a,z,"static/chunks/pages/properties-3a1037a2e036212a.js"],"/properties/add-property":[r,V,"static/chunks/pages/properties/add-property-9ccb295110feee20.js"],"/properties/[id]":[r,V,"static/chunks/pages/properties/[id]-19737d4f21aadbee.js"],"/reporting/datamap":[s,t,c,n,i,H,e,a,j,T,"static/chunks/pages/reporting/datamap-4cdbbb8cd1d8698e.js"],"/settings/about":["static/chunks/pages/settings/about-0e1c381d488a7ada.js"],"/settings/about/alpha":["static/chunks/pages/settings/about/alpha-965cc21889b25e44.js"],"/settings/consent":["static/chunks/pages/settings/consent-7796fbf458f8f159.js"],"/settings/consent/[configuration_id]/[purpose_id]":[s,t,e,a,"static/chunks/pages/settings/consent/[configuration_id]/[purpose_id]-d0e350d2a2667883.js"],"/settings/custom-fields":[s,t,e,a,"static/chunks/pages/settings/custom-fields-6f866bc799a5f67f.js"],"/settings/domain-records":[s,t,e,a,"static/chunks/pages/settings/domain-records-0b44b2b224077dcd.js"],"/settings/domains":["static/chunks/pages/settings/domains-5d00e1155bd11178.js"],"/settings/email-templates":["static/chunks/pages/settings/email-templates-d2cdbe770683e9df.js"],"/settings/locations":[s,W,I,"static/chunks/pages/settings/locations-811dadb489f23d7d.js"],"/settings/organization":["static/chunks/pages/settings/organization-24108f615ff5e1e7.js"],"/settings/regulations":[s,W,I,"static/chunks/pages/settings/regulations-54f142bc3e4c95ba.js"],"/systems":[s,t,e,a,"static/chunks/pages/systems-7b71274334c559a4.js"],"/systems/configure/[id]":[s,t,c,n,i,o,b,e,a,d,u,j,l,U,w,"static/chunks/pages/systems/configure/[id]-6eb886e7b7e6785b.js"],"/systems/configure/[id]/test-datasets":[f,"static/chunks/pages/systems/configure/[id]/test-datasets-fef247a87baeb080.js"],"/taxonomy":["static/chunks/678d4732-50255cc09048e643.js",c,n,i,g,"static/chunks/3983-17ae9c232bddc413.js","static/css/34a7eb08b86ddb57.css","static/chunks/pages/taxonomy-18534d2a79a3850b.js"],"/user-management":[x,"static/chunks/pages/user-management-dd43755b687c09a7.js"],"/user-management/new":[x,X,"static/chunks/pages/user-management/new-b124cc24b930c9e1.js"],"/user-management/profile/[id]":[x,X,"static/chunks/pages/user-management/profile/[id]-75d41fde668b9025.js"],sortedPages:["/","/404","/_app","/_error","/add-systems","/add-systems/manual","/add-systems/multiple","/consent","/consent/configure","/consent/configure/add-vendors","/consent/privacy-experience","/consent/privacy-experience/new","/consent/privacy-experience/[id]","/consent/privacy-notices","/consent/privacy-notices/new","/consent/privacy-notices/[id]","/consent/properties","/consent/reporting","/data-catalog","/data-catalog/[systemId]/projects","/data-catalog/[systemId]/projects/[projectUrn]","/data-catalog/[systemId]/projects/[projectUrn]/[resourceUrn]","/data-catalog/[systemId]/resources","/data-catalog/[systemId]/resources/[resourceUrn]","/data-discovery/action-center","/data-discovery/action-center/[monitorId]","/data-discovery/action-center/[monitorId]/[systemId]","/data-discovery/activity","/data-discovery/detection","/data-discovery/detection/[resourceUrn]","/data-discovery/discovery","/data-discovery/discovery/[resourceUrn]","/datamap","/dataset","/dataset/new","/dataset/[datasetId]","/dataset/[datasetId]/[collectionName]","/dataset/[datasetId]/[collectionName]/[...subfieldNames]","/datastore-connection","/datastore-connection/new","/datastore-connection/[id]","/fides-js-docs","/integrations","/integrations/[id]","/login","/login/[provider]","/messaging","/messaging/add-template","/messaging/[id]","/poc/ant-components","/poc/form-experiments/AntForm","/poc/form-experiments/FormikAntFormItem","/poc/form-experiments/FormikControlled","/poc/form-experiments/FormikField","/poc/form-experiments/FormikSpreadField","/poc/forms","/poc/table-migration","/privacy-requests","/privacy-requests/configure","/privacy-requests/configure/messaging","/privacy-requests/configure/storage","/privacy-requests/[id]","/properties","/properties/add-property","/properties/[id]","/reporting/datamap","/settings/about","/settings/about/alpha","/settings/consent","/settings/consent/[configuration_id]/[purpose_id]","/settings/custom-fields","/settings/domain-records","/settings/domains","/settings/email-templates","/settings/locations","/settings/organization","/settings/regulations","/systems","/systems/configure/[id]","/systems/configure/[id]/test-datasets","/taxonomy","/user-management","/user-management/new","/user-management/profile/[id]"]}}("static/chunks/c78d26b1-88a3e1bacb2a03c2.js","static/chunks/7553-a95939c32d54b5b7.js","static/chunks/6060-cb1ab5be7067bf7b.js","static/chunks/4481-f597a7cf03f8c9e1.js","static/chunks/2858-0b44609b6be7850b.js","static/chunks/2866-a73888c17a195cbe.js","static/chunks/9278-9b1b5970f0702668.js","static/chunks/409-037cfc3f096150f0.js","static/chunks/699-8ca44b0de9fa20f0.js","static/chunks/69-6889d6674c95e7b5.js","static/css/d2d4e9a6923e6730.css","static/chunks/401-fceaae662cfca5a5.js","static/chunks/3662-f6a1ddca5ee42076.js","static/chunks/6527-0eed08abe252a918.js","static/chunks/431-f72599f01b98f07d.js","static/chunks/5277-e8a036319456127f.js","static/chunks/9951-f9ab5cac7e2c05ab.js","static/chunks/3923-5d580fbb1dd6ae01.js","static/chunks/6277-3fb4c7fc790a6d20.js","static/chunks/5574-3cd33b3a6c937899.js","static/chunks/1040-630c7f4284dc6f70.js","static/chunks/6882-3cc73d407a088d7d.js","static/css/eb46b504bb5d980d.css","static/chunks/9226-ba6587e46ec7659a.js","static/chunks/3513-8677ee280eaef0da.js","static/css/972dc7eef106ee7c.css","static/chunks/3450-bdaeb35442d810b4.js","static/css/92fc10cc7ed1aba3.css","static/chunks/796-9a6b13c838e25538.js","static/chunks/6853-a4097260e402980e.js","static/chunks/3670-2abd9b2f17770872.js","static/chunks/1817-b4688ba5042ec687.js","static/chunks/6659-b2088f525bf13c17.js","static/chunks/6954-13a25cef3a8fdd76.js","static/chunks/79-5670e31eb65d0a53.js","static/chunks/3872-ffa16c2df7ef0ab6.js","static/chunks/3855-0dec3e7d9e886550.js","static/chunks/5309-4511df9708d5a63c.js","static/chunks/9046-fdf53cc7e926a8c1.js","static/chunks/4230-1cdb7ea1be370ed3.js","static/chunks/2430-b480401d44c55416.js","static/chunks/9767-e49b065d03ce4e80.js","static/chunks/2599-6c4d22e75028d8b6.js","static/chunks/1316-6cc72a45ebf7ff81.js","static/chunks/6662-6a6b90fc8f11558f.js","static/chunks/1100-d43cb04522a6505c.js","static/chunks/2921-aabf41bf3d7573f9.js","static/chunks/8433-adb1fcb29d82f1b7.js","static/chunks/4060-71cd041e5a57ca5a.js","static/chunks/3505-a79256cd851dfab4.js","static/chunks/4121-78a76e980acbd539.js"),self.__BUILD_MANIFEST_CB&&self.__BUILD_MANIFEST_CB();