ethyca-fides 2.71.1b1__py2.py3-none-any.whl → 2.71.2b0__py2.py3-none-any.whl

fides/api/service/privacy_request/request_runner_service.py

@@ -2,9 +2,8 @@
 import time
 from copy import deepcopy
 from datetime import datetime, timedelta
-from typing import Any, Optional, Tuple
+from typing import Any, Optional
 
-import requests
 from loguru import logger
 from pydantic import ValidationError as PydanticValidationError
 from sqlalchemy.orm import Query, Session
@@ -22,7 +21,6 @@ from fides.api.common_exceptions import (
     ValidationError,
 )
 from fides.api.db.session import get_db_session
-from fides.api.graph.config import CollectionAddress
 from fides.api.graph.graph import DatasetGraph
 from fides.api.models.attachment import Attachment, AttachmentReferenceType
 from fides.api.models.audit_log import AuditLog, AuditLogAction
@@ -53,7 +51,7 @@ from fides.api.schemas.policy import ActionType, CurrentStep
 from fides.api.schemas.privacy_request import PrivacyRequestStatus
 from fides.api.schemas.redis_cache import Identity
 from fides.api.schemas.storage.storage import StorageType
-from fides.api.service.connectors import FidesConnector, get_connector
+from fides.api.service.connectors import get_connector
 from fides.api.service.connectors.consent_email_connector import (
     CONSENT_EMAIL_CONNECTOR_TYPES,
 )
@@ -85,11 +83,7 @@ from fides.api.util.collection_util import Row
 from fides.api.util.logger import Pii, _log_exception, _log_warning
 from fides.api.util.logger_context_utils import LoggerContextKeys, log_context
 from fides.api.util.memory_watchdog import memory_limiter
-from fides.common.api.v1.urn_registry import (
-    PRIVACY_CENTER_DSR_PACKAGE,
-    PRIVACY_REQUEST_TRANSFER_TO_PARENT,
-    V1_URL_PREFIX,
-)
+from fides.common.api.v1.urn_registry import PRIVACY_CENTER_DSR_PACKAGE
 from fides.config import CONFIG
 from fides.config.config_proxy import ConfigProxy
 
@@ -307,8 +301,11 @@ def upload_and_save_access_results(  # pylint: disable=R0912
 ) -> list[str]:
     """Process the data uploads after the access portion of the privacy request has completed"""
     download_urls: list[str] = []
-    # Remove manual webhook attachments from the list of attachments
-    # This is done because the manual webhook attachments are already included in the manual_data
+    # Remove manual webhook attachments and request task attachments from the list of attachments
+    # This is done because:
+    # - manual webhook attachments are already included in the manual_data
+    # - manual task submission attachments are already included in the manual_data
+    # - request task attachments (from async polling) are already embedded in the dataset results
     loaded_attachments = [
         attachment
         for attachment in privacy_request.attachments
@@ -317,6 +314,7 @@ def upload_and_save_access_results(  # pylint: disable=R0912
             in [
                 AttachmentReferenceType.access_manual_webhook,
                 AttachmentReferenceType.manual_task_submission,
+                AttachmentReferenceType.request_task,
             ]
             for ref in attachment.references
         )
@@ -922,78 +920,6 @@ def mark_paused_privacy_request_as_expired(privacy_request_id: str) -> None:
     db.close()
 
 
-def _retrieve_child_results(  # pylint: disable=R0911
-    fides_connector: Tuple[str, ConnectionConfig],
-    rule_key: str,
-    access_result: dict[str, list[Row]],
-) -> Optional[list[dict[str, Optional[list[Row]]]]]:
-    """Get child access request results to add to upload."""
-    try:
-        connector = FidesConnector(fides_connector[1])
-    except Exception as e:
-        logger.error(
-            "Error create client for child server {}: {}", fides_connector[0], e
-        )
-        return None
-
-    results = []
-
-    for key, rows in access_result.items():
-        address = CollectionAddress.from_string(key)
-        privacy_request_id = None
-        if address.dataset == fides_connector[0]:
-            if not rows:
-                logger.info("No rows found for result entry {}", key)
-                continue
-            privacy_request_id = rows[0]["id"]
-
-        if not privacy_request_id:
-            logger.error(
-                "No privacy request found for connector key {}", fides_connector[0]
-            )
-            continue
-
-        try:
-            client = connector.create_client()
-        except requests.exceptions.HTTPError as e:
-            logger.error(
-                "Error logger into to child server for privacy request {}: {}",
-                privacy_request_id,
-                e,
-            )
-            continue
-
-        try:
-            request = client.authenticated_request(
-                method="get",
-                path=f"{V1_URL_PREFIX}{PRIVACY_REQUEST_TRANSFER_TO_PARENT.format(privacy_request_id=privacy_request_id, rule_key=rule_key)}",
-                headers={"Authorization": f"Bearer {client.token}"},
-            )
-            response = client.session.send(request)
-        except requests.exceptions.HTTPError as e:
-            logger.error(
-                "Error retrieving data from child server for privacy request {}: {}",
-                privacy_request_id,
-                e,
-            )
-            continue
-
-        if response.status_code != 200:
-            logger.error(
-                "Error retrieving data from child server for privacy request {}: {}",
-                privacy_request_id,
-                response.json(),
-            )
-            continue
-
-        results.append(response.json())
-
-    if not results:
-        return None
-
-    return results
-
-
 def get_consent_email_connection_configs(db: Session) -> Query:
     """Return enabled consent email connection configs."""
     return db.query(ConnectionConfig).filter(

fides/api/service/privacy_request/request_service.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import json
-from asyncio import sleep
 from datetime import datetime, timedelta
 from typing import Any, Dict, List, Optional, Set
 
@@ -11,7 +10,7 @@ from sqlalchemy import text
 from sqlalchemy.orm import Session
 from sqlalchemy.sql.elements import TextClause
 
-from fides.api.common_exceptions import PrivacyRequestError, PrivacyRequestNotFound
+from fides.api.common_exceptions import PrivacyRequestError
 from fides.api.models.privacy_request import (
     EXITED_EXECUTION_LOG_STATUSES,
     PrivacyRequest,
@@ -21,10 +20,7 @@ from fides.api.models.privacy_request.request_task import AsyncTaskType
 from fides.api.models.worker_task import ExecutionLogStatus
 from fides.api.schemas.drp_privacy_request import DrpPrivacyRequestCreate
 from fides.api.schemas.policy import ActionType
-from fides.api.schemas.privacy_request import (
-    PrivacyRequestResponse,
-    PrivacyRequestStatus,
-)
+from fides.api.schemas.privacy_request import PrivacyRequestStatus
 from fides.api.schemas.redis_cache import Identity
 from fides.api.tasks import DSR_QUEUE_NAME, DatabaseTask, celery_app
 from fides.api.tasks.scheduled.scheduler import scheduler
@@ -38,7 +34,6 @@ from fides.api.util.cache import (
     reset_privacy_request_retry_count,
 )
 from fides.api.util.lock import redis_lock
-from fides.common.api.v1.urn_registry import PRIVACY_REQUESTS, V1_URL_PREFIX
 from fides.config import CONFIG
 
 PRIVACY_REQUEST_STATUS_CHANGE_POLL = "privacy_request_status_change_poll"
@@ -98,62 +93,6 @@ def get_async_client() -> AsyncClient:
     return AsyncClient()
 
 
-async def poll_server_for_completion(
-    privacy_request_id: str,
-    server_url: str,
-    token: str,
-    *,
-    poll_interval_seconds: int = 30,
-    timeout_seconds: int = 1800,  # 30 minutes
-    client: AsyncClient | None = None,
-) -> PrivacyRequestResponse:
-    """Poll a server for privacy request completion.
-
-    Requests will report complete with if they have a status of canceled, complete,
-    denied, or error. By default the polling will time out if not completed in 30
-    minutes, time can be overridden by setting the timeout_seconds.
-    """
-    url = (
-        f"{server_url}{V1_URL_PREFIX}{PRIVACY_REQUESTS}?request_id={privacy_request_id}"
-    )
-    start_time = datetime.now()
-    elapsed_time = 0.0
-    while elapsed_time < timeout_seconds:
-        if client:
-            response = await client.get(
-                url, headers={"Authorization": f"Bearer {token}"}
-            )
-        else:
-            async_client = get_async_client()
-            response = await async_client.get(
-                url, headers={"Authorization": f"Bearer {token}"}
-            )
-        response.raise_for_status()
-
-        # Privacy requests are returned paginated. Since this is searching for a specific
-        # privacy request there should only be one value present in items.
-        items = response.json()["items"]
-        if not items:
-            raise PrivacyRequestNotFound(
-                f"No privacy request found with id '{privacy_request_id}'"
-            )
-        status = PrivacyRequestResponse(**items[0])
-        if status.status and status.status in (
-            PrivacyRequestStatus.complete,
-            PrivacyRequestStatus.canceled,
-            PrivacyRequestStatus.error,
-            PrivacyRequestStatus.denied,
-        ):
-            return status
-
-        await sleep(poll_interval_seconds)
-        time_delta = datetime.now() - start_time
-        elapsed_time = time_delta.seconds
-    raise TimeoutError(
-        f"Timeout of {timeout_seconds} seconds has been exceeded while waiting for privacy request {privacy_request_id}"
-    )
-
-
 def initiate_poll_for_exited_privacy_request_tasks() -> None:
     """Initiates scheduler to check if a Privacy Request's status needs to be flipped when all
     Request Tasks have had a chance to run"""
@@ -364,7 +303,7 @@ def initiate_interrupted_task_requeue_poll() -> None:
     )
 
 
-def initiate_async_tasks_status_polling() -> None:
+def initiate_polling_task_requeue() -> None:
     """Initiates scheduler to check for and requeue pending polling async tasks"""
     if CONFIG.test_mode:
         return
@@ -375,13 +314,13 @@ def initiate_async_tasks_status_polling() -> None:
 
     logger.info("Initiating scheduler for async tasks status polling")
     scheduler.add_job(
-        func=poll_async_tasks_status,
+        func=requeue_polling_tasks,
         trigger="interval",
         kwargs={},
         id=ASYNC_TASKS_STATUS_POLLING,
         coalesce=True,
         replace_existing=True,
-        seconds=CONFIG.execution.async_tasks_status_polling_interval_seconds,
+        seconds=20,
     )
 
 
@@ -541,6 +480,27 @@ def _get_request_task_ids_in_progress(
     return [task[0] for task in request_tasks_in_progress]
 
 
+def _has_polling_tasks(db: Session, privacy_request_id: str) -> bool:
+    """
+    Check if a privacy request has any polling async tasks.
+
+    Args:
+        db: Database session
+        privacy_request_id: The ID of the privacy request to check
+
+    Returns:
+        bool: True if the privacy request has polling tasks, False otherwise
+    """
+    return db.query(
+        db.query(RequestTask)
+        .filter(
+            RequestTask.privacy_request_id == privacy_request_id,
+            RequestTask.async_type == AsyncTaskType.polling,
+        )
+        .exists()
+    ).scalar()
+
+
 # pylint: disable=too-many-branches
 # pylint: disable=too-many-statements
 @celery_app.task(base=DatabaseTask, bind=True)
@@ -680,6 +640,17 @@ def requeue_interrupted_tasks(self: DatabaseTask) -> None:
                                 should_requeue = False
                                 break
 
+                            # Check if the Privacy request has polling tasks
+                            if _has_polling_tasks(db, privacy_request.id):
+                                # If the polling request task has no cached task ID, it's stuck
+                                logger.warning(
+                                    f"No task ID found for request task {request_task_id} "
+                                    f"(privacy request {privacy_request.id}) Contains polling tasks - "
+                                    f"keeping request in current status as it may be waiting for polling task to complete"
+                                )
+                                should_requeue = False
+                                break
+
                             # For other statuses, cancel the entire privacy request
                             _cancel_interrupted_tasks_and_error_privacy_request(
                                 db,
@@ -706,7 +677,7 @@ def requeue_interrupted_tasks(self: DatabaseTask) -> None:
 
 
 @celery_app.task(base=DatabaseTask, bind=True)
-def poll_async_tasks_status(self: DatabaseTask) -> None:
+def requeue_polling_tasks(self: DatabaseTask) -> None:
     """
     Poll the status of async tasks that are awaiting processing.
     """
@@ -720,19 +691,21 @@ def poll_async_tasks_status(self: DatabaseTask) -> None:
         with self.get_new_session() as db:
             logger.debug("Polling for async tasks status")
 
-            # Get all tasks that are awaiting processing and are from polling async tasks
+            # Get all tasks that are polling and are from polling async tasks
             async_tasks = (
                 db.query(RequestTask)
-                .filter(RequestTask.status == ExecutionLogStatus.awaiting_processing)
+                .filter(RequestTask.status == ExecutionLogStatus.polling)
                 .filter(RequestTask.async_type == AsyncTaskType.polling)
                 .all()
             )
-            logger.info(f"Found {len(async_tasks)} async tasks awaiting processing")
+            logger.info(f"Found {len(async_tasks)} async polling tasks")
 
             if async_tasks:
-                from fides.api.service.async_dsr.async_dsr_service import (  # pylint: disable=cyclic-import
-                    requeue_polling_request,
-                )
+                # Avoiding cyclic imports
+                from fides.api.task.execute_request_tasks import queue_request_task
 
                 for async_task in async_tasks:
-                    requeue_polling_request(db, async_task)
+                    logger.info(
+                        f"Requeuing polling task {async_task.id} for processing"
+                    )
+                    queue_request_task(async_task, privacy_request_proceed=True)

fides/api/service/saas_request/saas_request_override_factory.py

@@ -1,6 +1,6 @@
 from enum import Enum
 from inspect import Signature, signature
-from typing import Callable, Dict, List, Union
+from typing import TYPE_CHECKING, Callable, Dict, List, Union
 
 from loguru import logger
 
@@ -12,6 +12,9 @@ from fides.api.schemas.consentable_item import ConsentableItem, ConsentWebhookRe
 from fides.api.schemas.saas.shared_schemas import ConsentPropagationStatus
 from fides.api.util.collection_util import Row
 
+if TYPE_CHECKING:
+    from fides.api.schemas.saas.async_polling_configuration import PollingResult
+
 
 # at some point this should likely be formalized more centrally...
 class SaaSRequestType(Enum):
@@ -30,6 +33,10 @@ class SaaSRequestType(Enum):
     UPDATE_CONSENT = "update_consent"
     PROCESS_CONSENT_WEBHOOK = "process_consent_webhook"
 
+    # Async polling request types
+    POLLING_STATUS = "polling_status"
+    POLLING_RESULT = "polling_result"
+
 
 RequestOverrideFunction = Callable[
     ...,
@@ -39,6 +46,8 @@ RequestOverrideFunction = Callable[
         List[Row],
         ConsentPropagationStatus,
         int,
+        bool,  # For polling status overrides
+        "PollingResult",  # For polling result overrides - string literal to avoid circular import
         None,
     ],
 ]
@@ -105,6 +114,10 @@ class SaaSRequestOverrideFactory:
                     validate_update_consent_function(override_function)
                 elif request_type == SaaSRequestType.PROCESS_CONSENT_WEBHOOK:
                     validate_process_consent_webhook_function(override_function)
+                elif request_type == SaaSRequestType.POLLING_STATUS:
+                    validate_polling_status_override_function(override_function)
+                elif request_type == SaaSRequestType.POLLING_RESULT:
+                    validate_polling_result_override_function(override_function)
                 else:
                     raise ValueError(
                         f"Invalid SaaSRequestType '{request_type}' provided for SaaS request override function"
@@ -264,5 +277,57 @@ def validate_process_consent_webhook_function(f: Callable) -> None:
         )
 
 
+def validate_polling_status_override_function(f: Callable) -> None:
+    """
+    Perform some basic checks on the user-provided SaaS request override function
+    that will be used for polling status checks.
+
+    The validation is not overly strict to allow for some flexibility in
+    the functions that are used for overrides, but we check to ensure that
+    the function meets the framework's basic expectations.
+
+    Specifically, the validation checks that function's return type is `bool`
+    and that it declares at least 4 parameters.
+    """
+    sig: Signature = signature(f)
+    if sig.return_annotation is not bool:
+        raise InvalidSaaSRequestOverrideException(
+            "Polling status override function must return a bool"
+        )
+    if len(sig.parameters) < 4:
+        raise InvalidSaaSRequestOverrideException(
+            "Polling status override function must declare at least 4 parameters"
+        )
+
+
+def validate_polling_result_override_function(f: Callable) -> None:
+    """
+    Perform some basic checks on the user-provided SaaS request override function
+    that will be used for polling result retrieval.
+
+    The validation is not overly strict to allow for some flexibility in
+    the functions that are used for overrides, but we check to ensure that
+    the function meets the framework's basic expectations.
+
+    Specifically, the validation checks that function's return type is `PollingResult`
+    and that it declares at least 4 parameters.
+    """
+    sig: Signature = signature(f)
+
+    # Import PollingResult here to avoid circular imports at module level
+    from fides.api.schemas.saas.async_polling_configuration import PollingResult
+
+    # Check return type annotation - handle both direct class and string literals
+    return_annotation = sig.return_annotation
+    if return_annotation not in (PollingResult, "PollingResult"):
+        raise InvalidSaaSRequestOverrideException(
+            "Polling result override function must return a PollingResult"
+        )
+    if len(sig.parameters) < 4:
+        raise InvalidSaaSRequestOverrideException(
+            "Polling result override function must declare at least 4 parameters"
+        )
+
+
 # TODO: Avoid running this on import?
 register = SaaSRequestOverrideFactory.register

fides/api/task/execute_request_tasks.py

@@ -22,7 +22,10 @@ from fides.api.common_exceptions import (
 from fides.api.graph.config import TERMINATOR_ADDRESS, CollectionAddress
 from fides.api.models.connectionconfig import ConnectionConfig
 from fides.api.models.privacy_request import ExecutionLog, PrivacyRequest, RequestTask
-from fides.api.models.worker_task import ExecutionLogStatus
+from fides.api.models.worker_task import (
+    RESUMABLE_EXECUTION_LOG_STATUSES,
+    ExecutionLogStatus,
+)
 from fides.api.schemas.policy import ActionType, CurrentStep
 from fides.api.schemas.privacy_request import PrivacyRequestStatus
 from fides.api.task.graph_task import (
@@ -162,7 +165,7 @@ def can_run_task_body(
     if request_task.is_root_task:
         # Shouldn't be possible but adding as a catch-all
         return False
-    if request_task.status != ExecutionLogStatus.pending:
+    if request_task.status not in RESUMABLE_EXECUTION_LOG_STATUSES:
         logger_method(request_task)(
             "Skipping {} task {} with status {}.",
             request_task.action_type,

fides/api/task/filter_results.py

@@ -6,10 +6,43 @@ from loguru import logger
 
 from fides.api.graph.config import CollectionAddress, FieldPath
 from fides.api.graph.graph import DatasetGraph
+from fides.api.service.storage.util import is_attachment_field
 from fides.api.task.manual.manual_task_address import ManualTaskAddress
 from fides.api.util.collection_util import Row
 
 
+def should_skip_data_category_filtering(
+    node_address: str, results: List[Dict[str, Optional[Any]]]
+) -> bool:
+    """
+    Determine if results should skip data category filtering.
+
+    This includes:
+    1. Manual task data - controlled by field definitions, not data categories
+    2. Attachment data - should be preserved regardless of data categories (from polling or manual tasks)
+
+    :param node_address: The collection address being processed
+    :param results: The results data to check
+    :return: True if filtering should be skipped, False otherwise
+    """
+    # Check if this is a manual task address
+    if ManualTaskAddress.is_manual_task_address(node_address):
+        return True
+
+    # Check if results contain attachment data
+    if not results:
+        return False
+
+    # Verify it looks like actual attachment data
+    for result in results:
+        if isinstance(result, dict) and any(
+            is_attachment_field(value) for value in result.values()
+        ):
+            return True
+
+    return False
+
+
 def filter_data_categories(
     access_request_results: Dict[str, List[Dict[str, Optional[Any]]]],
     target_categories: Set[str],
@@ -38,8 +71,8 @@ def filter_data_categories(
         if not results:
             continue
 
-        # Skip manual task data - it doesn't need filtering since it's controlled by field definitions
-        if ManualTaskAddress.is_manual_task_address(node_address):
+        # Skip data that doesn't need filtering (manual tasks and attachment data)
+        if should_skip_data_category_filtering(node_address, results):
             filtered_access_results[node_address].extend(results)
             continue
 

fides/api/task/graph_task.py

@@ -13,6 +13,7 @@ from sqlalchemy.orm import Session
 from fides.api.api.deps import get_autoclose_db_session as get_db
 from fides.api.common_exceptions import (
     ActionDisabled,
+    AwaitingAsyncProcessing,
     AwaitingAsyncTask,
     CollectionDisabled,
     NotSupportedForCollection,
@@ -96,6 +97,7 @@ def retry(
     If we exceed the number of TASK_RETRY_COUNT retries, we re-raise the exception to stop execution of the privacy request.
     """
 
+    # pylint: disable=too-many-return-statements
     def decorator(func: Callable) -> Callable:
         @wraps(func)
         def result(*args: Any, **kwargs: Any) -> Any:
@@ -115,6 +117,17 @@ def retry(
                         self.log_start(action_type)
                     # Run access or erasure request
                     return func(*args, **kwargs)
+                except AwaitingAsyncProcessing as ex:
+                    logger.warning(
+                        "Request Task {} {} {} async processing in progress",
+                        self.request_task.id if self.request_task.id else None,
+                        method_name,
+                        self.execution_node.address,
+                    )
+                    # Log the async processing status and exit without retrying.
+                    self.log_async_processing(action_type, ex)
+                    # Request Task put in "polling" status and exited, external system is processing
+                    return None
                 except AwaitingAsyncTask as ex:
                     logger.warning(
                         "Request Task {} {} {} awaiting async continuation",
@@ -416,9 +429,13 @@ class GraphTask(ABC):  # pylint: disable=too-many-instance-attributes
             # created to keep these in sync.
             # TODO remove conditional above alongside deprecating DSR 2.0
             if self.request_task.id:
-                # Merge the request task to ensure we keep the changes made
-                # to self.request_task that haven't yet been committed to the database
+                # Merge the request_task into the current session to make it persistent,
+                # then refresh its `async_type` to load the latest state from the
+                # database. This is crucial for async tasks where `async_type` might be
+                # updated by another process, and avoids overwriting local data like
+                # `access_data`.
                 request_task = db.merge(self.request_task)
+                db.refresh(request_task, attribute_names=["async_type"])
                 request_task.update_status(db, status)
                 self.request_task = request_task
 
@@ -453,6 +470,21 @@ class GraphTask(ABC):  # pylint: disable=too-many-instance-attributes
             message, [], action_type, ExecutionLogStatus.awaiting_processing
         )
 
+    def log_async_processing(
+        self,
+        action_type: ActionType,
+        ex: Optional[BaseException],
+        extra_message: Optional[str] = None,
+    ) -> None:
+        """On async processing activities - external system is actively processing, Fides is polling"""
+        logger.info("Polling for async results on node {}", self.key)
+
+        message = str(ex)
+        if extra_message:
+            message = f"{message}. {extra_message}"
+
+        self.update_status(message, [], action_type, ExecutionLogStatus.polling)
+
     def log_skipped(self, action_type: ActionType, ex: str) -> None:
         """Log that a collection was skipped.  For now, this is because a collection has been disabled."""
         logger.info("Skipping node {}", self.key)

fides/api/util/saas_util.py

@@ -26,6 +26,7 @@ PRIVACY_REQUEST_ID = "privacy_request_id"
 MASKED_OBJECT_FIELDS = "masked_object_fields"
 ALL_OBJECT_FIELDS = "all_object_fields"
 CUSTOM_PRIVACY_REQUEST_FIELDS = "custom_privacy_request_fields"
+PRIVACY_REQUEST_OBJECT = "privacy_request"
 UUID = "uuid"
 ISO_8601_DATETIME = "iso_8601_datetime"
 FIELD_LIST = "field_list"

fides/config/execution_settings.py

@@ -61,9 +61,13 @@ class ExecutionSettings(FidesSettings):
         default=3,
         description="The number of times a privacy request will be requeued when its tasks are interrupted before being marked as error",
     )
-    async_tasks_status_polling_interval_seconds: int = Field(
-        default=3600,
-        description="Seconds between polling for async tasks to requeue",
+    async_polling_interval_hours: int = Field(
+        default=24,
+        description="Hours between status checks for async tasks",
+    )
+    async_polling_request_timeout_days: int = Field(
+        default=30,
+        description="Maximum time in days to wait for an async polling request to complete before timing out",
     )
     erasure_request_finalization_required: bool = Field(
         default=False,

fides/data/language/languages.yml

@@ -9,6 +9,8 @@ languages:
   name: Catalan
 - id: cs
   name: Czech
+- id: cy
+  name: Welsh
 - id: da
   name: Danish
 - id: de

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/295d729ea1b11885.css" as="style"/><link rel="stylesheet" href="/_next/static/css/295d729ea1b11885.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-2766492c5dbceb0a.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-c1c2f757b1f3da12.js" defer=""></script><script src="/_next/static/chunks/pages/404-2eb8aed4939f1142.js" defer=""></script><script src="/_next/static/_IxwgneyQjdSaZFEF3Tqu/_buildManifest.js" defer=""></script><script src="/_next/static/_IxwgneyQjdSaZFEF3Tqu/_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":"_IxwgneyQjdSaZFEF3Tqu","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/372d6a236c84613f.css" as="style"/><link rel="stylesheet" href="/_next/static/css/372d6a236c84613f.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-118fb4723d13c14f.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-9e869a44215709ed.js" defer=""></script><script src="/_next/static/chunks/pages/404-2014144a1a0fa64f.js" defer=""></script><script src="/_next/static/zmEQMSpOBih8kmA1t-EWO/_buildManifest.js" defer=""></script><script src="/_next/static/zmEQMSpOBih8kmA1t-EWO/_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":"zmEQMSpOBih8kmA1t-EWO","nextExport":true,"autoExport":true,"isFallback":false,"scriptLoader":[]}</script></body></html>

fides/ui-build/static/admin/_next/static/chunks/1099-27b2d4e59a569b38.js

@@ -0,0 +1 @@
+(self.webpackChunk_N_E=self.webpackChunk_N_E||[]).push([[1099],{56632:function(e,t,n){var i=n(89278),a=n(80068),o=n(50098);e.exports=function(e){return function(t,n,r){var s=Object(t);if(!a(t)){var l=i(n,3);t=o(t),n=function(e){return l(s[e],e,s)}}var c=e(t,n,r);return c>-1?s[l?t[c]:c]:void 0}}},64925:function(e,t,n){var i=n(56632)(n(66259));e.exports=i},66259:function(e,t,n){var i=n(95372),a=n(89278),o=n(47991),r=Math.max;e.exports=function(e,t,n){var s=null==e?0:e.length;if(!s)return -1;var l=null==n?0:o(n);return l<0&&(l=r(s+l,0)),i(e,a(t,3),l)}},94919:function(e,t,n){var i=n(91936),a=1/0;e.exports=function(e){return e?(e=i(e))===a||e===-a?(e<0?-1:1)*17976931348623157e292:e==e?e:0:0===e?e:0}},47991:function(e,t,n){var i=n(94919);e.exports=function(e){var t=i(e),n=t%1;return t==t?n?t-n:t:0}},12627:function(e,t,n){"use strict";var i=n(24246),a=n(79283),o=n(34929);t.Z=e=>{let{selectedTaxonomies:t,showDisabled:n=!1,...r}=e,{getDataCategoryDisplayNameProps:s,getDataCategories:l}=(0,o.Z)(),c=(n?l():l().filter(e=>e.active)).filter(e=>!(null==t?void 0:t.includes(e.fides_key))).map(e=>{let{name:t,primaryName:n}=s(e.fides_key);return{value:e.fides_key,name:t,primaryName:n,description:e.description||""}});return(0,i.jsx)(a.l,{options:c,...r})}},79283:function(e,t,n){"use strict";n.d(t,{l:function(){return d}});var i=n(24246),a=n(20595),o=n(72707),r=n.n(o);let s=e=>{let{data:{formattedTitle:t,description:n,name:o,primaryName:r}}=e;return(0,i.jsxs)(a.jqI,{gap:12,title:"".concat(t," - ").concat(n),children:[(0,i.jsxs)("div",{children:[(0,i.jsx)("strong",{children:r||o}),r&&": ".concat(o)]}),(0,i.jsx)("em",{children:n})]})},l=e=>"options"in e&&Array.isArray(e.options),c=e=>({...e,className:r().option,formattedTitle:e.formattedTitle||[e.primaryName,e.name].filter(e=>e).join(": ")}),d=e=>{let{options:t,...n}=e,o=null==t?void 0:t.map(e=>l(e)?{...e,options:e.options.map(c)}:c(e));return(0,i.jsx)(a.WPr,{options:o,filterOption:(e,t)=>{var n,i;return(null==t?void 0:null===(n=t.formattedTitle)||void 0===n?void 0:n.toLowerCase().includes(e.toLowerCase()))||(null==t?void 0:null===(i=t.value)||void 0===i?void 0:i.toLowerCase().includes(e.toLowerCase()))||!1},optionFilterProp:"label",autoFocus:!0,variant:"borderless",optionRender:s,styles:{popup:{root:{minWidth:"500px"}}},className:"w-full p-0","data-testid":"taxonomy-select",...n})}},34929:function(e,t,n){"use strict";var i=n(24246),a=n(64925),o=n.n(a),r=n(27378),s=n(16134),l=n(30002),c=n(28079),d=n(57072);let u=()=>{let{isLoading:e}=(0,c.fd)(),t=(0,s.C)(c.U3),{isLoading:n}=(0,d.MO)(),i=(0,s.C)(d.qb),{isLoading:a}=(0,l.te)();return{dataUses:t,dataSubjects:(0,s.C)(l.ZL),dataCategories:i,isLoading:e||n||a}};t.Z=()=>{let{dataUses:e,dataCategories:t,dataSubjects:n,isLoading:a}=u(),s=function(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:1;return e.split(".").slice(0,t).join(".")},l=function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:1,i=t(e);if(!i)return{};let a=t(s(e,n)),o=!!i.parent_key;return{name:i.name||void 0,primaryName:o&&(null==a?void 0:a.name)!==i.name&&(null==a?void 0:a.name)||void 0}},c=function(e,t){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:1,{name:a,primaryName:o}=l(e,t,n);return a?o?(0,i.jsxs)(r.Fragment,{children:[(0,i.jsxs)("strong",{children:[o,":"]})," ",a]},e):(0,i.jsx)("strong",{children:a},e):e},d=t=>o()(e,{fides_key:t}),f=e=>o()(t,{fides_key:e}),v=e=>o()(n,{fides_key:e});return{getDataUses:()=>e,getDataUseByKey:d,getDataUseDisplayName:e=>c(e,d,1),getDataUseDisplayNameProps:e=>l(e,d,1),getDataCategories:()=>t,getDataCategoryByKey:f,getDataCategoryDisplayName:e=>c(e,f,2),getDataCategoryDisplayNameProps:e=>l(e,f,2),getDataSubjects:()=>n,getDataSubjectByKey:v,getDataSubjectDisplayName:e=>{let t=v(e);return t?t.name:e},getPrimaryKey:s,isLoading:a}}},61099:function(e,t,n){"use strict";var i=n(24246),a=n(20595),o=n(27378),r=n(12627),s=n(34929),l=n(26183),c=n(70675);t.Z=e=>{var t,n,d;let{resource:u}=e,[f,v]=(0,o.useState)(!1),{getDataCategoryDisplayName:p}=(0,s.Z)(),[g]=(0,c.NA)(),m=(null===(t=u.classifications)||void 0===t?void 0:t.length)?u.classifications[0].label:null,x=null!==(d=u.user_assigned_data_categories)&&void 0!==d?d:[],h=!m&&!(null==x?void 0:x.length),_=null===(n=u.sub_field_urns)||void 0===n?void 0:n.length,j=e=>{g({staged_resource_urn:u.urn,monitor_config_id:u.monitor_config_id,user_assigned_data_categories:[...x,e]})},y=e=>{var t;g({staged_resource_urn:u.urn,monitor_config_id:u.monitor_config_id,user_assigned_data_categories:null!==(t=null==x?void 0:x.filter(t=>t!==e))&&void 0!==t?t:[]})},b=!f&&!!x.length,w=!f&&!!m&&!x.length;return(0,i.jsxs)(l.Z,{"data-testid":"edit-category-cell",children:[h&&(0,i.jsxs)(i.Fragment,{children:[(0,i.jsx)(a.j8w,{"data-testid":"no-classifications",color:"white",children:"None"}),!_&&(0,i.jsx)(a.j8w,{onClick:()=>v(!0),addable:!0,"data-testid":"taxonomy-add-btn","aria-label":"Add category"})]}),b&&(0,i.jsxs)(i.Fragment,{children:[x.map(e=>(0,i.jsx)(a.j8w,{"data-testid":"user-classification-".concat(e),color:"white",closable:!0,onClose:()=>y(e),closeButtonLabel:"Remove category",children:p(e)},e)),(0,i.jsx)(a.j8w,{onClick:()=>v(!0),addable:!0,"data-testid":"taxonomy-add-btn","aria-label":"Add category"})]}),w&&(0,i.jsxs)(a.j8w,{onClick:()=>v(!0),color:"white","data-testid":"classification-".concat(m),hasSparkle:!0,children:[p(m),(0,i.jsx)(a.PJP.I8b,{size:10})]}),f&&(0,i.jsx)(a.xuv,{className:"select-wrapper",position:"absolute",zIndex:10,top:"0",left:"0",width:"100%",height:"max",bgColor:"#fff",children:(0,i.jsx)(r.Z,{selectedTaxonomies:x,onChange:e=>{v(!1),j(e)},onBlur:()=>v(!1),open:!0})})]})}},26183:function(e,t,n){"use strict";var i=n(24246);n(27378),t.Z=e=>{let{children:t,className:n,...a}=e;return(0,i.jsx)("div",{className:"relative flex w-full flex-wrap items-center gap-2 overflow-x-auto py-2 ".concat(n||""),...a,children:t})}},57072:function(e,t,n){"use strict";n.d(t,{Bd:function(){return i.Bd},L5:function(){return i.L5},MO:function(){return i.MO},qb:function(){return i.qb}});var i=n(5785)},72707:function(e){e.exports={option:"TaxonomySelect_option__vY6v2"}}}]);