ethyca-fides 2.69.3b1__py2.py3-none-any.whl → 2.70.0__py2.py3-none-any.whl

fides/api/schemas/messaging/shared_schemas.py

@@ -0,0 +1,102 @@
+from typing import Any, Dict, Optional, Union
+
+from pydantic import BaseModel, ConfigDict, model_validator
+
+from fides.api.custom_types import PhoneNumber
+from fides.api.schemas.base_class import NoValidationSchema
+from fides.api.schemas.connection_configuration.connection_secrets_base_aws import (
+    BaseAWSSchema,
+)
+
+
+class MessagingServiceSecretsMailgun(BaseModel):
+    """The secrets required to connect to Mailgun."""
+
+    mailgun_api_key: str
+    model_config = ConfigDict(extra="forbid")
+
+
+class MessagingServiceSecretsTwilioSMS(BaseModel):
+    """The secrets required to connect to Twilio SMS."""
+
+    twilio_account_sid: str
+    twilio_auth_token: str
+    twilio_messaging_service_sid: Optional[str] = None
+    twilio_sender_phone_number: Optional[PhoneNumber] = None
+    model_config = ConfigDict(extra="forbid")
+
+    @model_validator(mode="before")
+    @classmethod
+    def validate_fields(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        sender_phone = values.get("twilio_sender_phone_number")
+        if not values.get("twilio_messaging_service_sid") and not sender_phone:
+            raise ValueError(
+                "Either the twilio_messaging_service_sid or the twilio_sender_phone_number should be supplied."
+            )
+        return values
+
+
+class MessagingServiceSecretsTwilioEmail(BaseModel):
+    """The secrets required to connect to twilio email."""
+
+    twilio_api_key: str
+    model_config = ConfigDict(extra="forbid")
+
+
+class MessagingServiceSecretsMailchimpTransactional(BaseModel):
+    """The secrets required to connect to Mailchimp Transactional."""
+
+    mailchimp_transactional_api_key: str
+    model_config = ConfigDict(extra="forbid")
+
+
+class MessagingServiceSecretsMailchimpTransactionalDocs(
+    MessagingServiceSecretsMailchimpTransactional,
+    NoValidationSchema,
+):
+    """The secrets required to connect Mailchimp Transactional, for documentation"""
+
+
+class MessagingSecretsMailgunDocs(MessagingServiceSecretsMailgun, NoValidationSchema):
+    """The secrets required to connect to Mailgun, for documentation"""
+
+
+class MessagingSecretsTwilioSMSDocs(
+    MessagingServiceSecretsTwilioSMS, NoValidationSchema
+):
+    """The secrets required to connect to Twilio sms, for documentation"""
+
+
+class MessagingSecretsTwilioEmailDocs(
+    MessagingServiceSecretsTwilioEmail, NoValidationSchema
+):
+    """The secrets required to connect to Twilio email, for documentation"""
+
+
+class MessagingServiceSecretsAWS_SES(BaseAWSSchema):
+    """The secrets required to connect to AWS SES."""
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class MessagingServiceSecretsAWS_SESDocs(
+    MessagingServiceSecretsAWS_SES, NoValidationSchema
+):
+    """The secrets required to connect to AWS SES, for documentation"""
+
+
+SUPPORTED_MESSAGING_SERVICE_SECRETS = Union[
+    MessagingServiceSecretsMailgun,
+    MessagingServiceSecretsTwilioSMS,
+    MessagingServiceSecretsTwilioEmail,
+    MessagingServiceSecretsMailchimpTransactional,
+    MessagingServiceSecretsAWS_SES,
+]
+
+PossibleMessagingSecrets = Union[
+    MessagingSecretsMailgunDocs,
+    MessagingSecretsTwilioSMSDocs,
+    MessagingSecretsTwilioEmailDocs,
+    MessagingServiceSecretsMailchimpTransactionalDocs,
+    MessagingServiceSecretsAWS_SESDocs,
+]

fides/api/schemas/privacy_center_config.py

@@ -1,7 +1,14 @@
 from abc import ABC
-from typing import Any, Dict, List, Literal, Optional, Union
+from typing import Annotated, Any, Dict, List, Literal, Optional, Union
 
-from pydantic import ConfigDict, Field, field_validator, model_validator
+from pydantic import (
+    ConfigDict,
+    Discriminator,
+    Field,
+    Tag,
+    field_validator,
+    model_validator,
+)
 
 from fides.api.models.location_regulation_selections import PrivacyNoticeRegion
 from fides.api.schemas.base_class import FidesSchema
@@ -86,9 +93,26 @@ class LocationCustomPrivacyRequestField(BaseCustomPrivacyRequestField):
         return values
 
 
-# Create a simple union type - Pydantic will use the field_type to determine which model to use
-CustomPrivacyRequestFieldUnion = Union[
-    LocationCustomPrivacyRequestField, CustomPrivacyRequestField
+# Create a discriminated union type using the field_type to properly distinguish between types
+def get_field_type_discriminator(v: Any) -> str:
+    """Discriminator function for CustomPrivacyRequestFieldUnion"""
+    if isinstance(v, dict):
+        field_type = v.get("field_type")
+    else:
+        # For model instances, get field_type attribute
+        field_type = getattr(v, "field_type", None)
+
+    if field_type == "location":
+        return "location"
+    return "custom"
+
+
+CustomPrivacyRequestFieldUnion = Annotated[
+    Union[
+        Annotated[LocationCustomPrivacyRequestField, Tag("location")],
+        Annotated[CustomPrivacyRequestField, Tag("custom")],
+    ],
+    Discriminator(get_field_type_discriminator),
 ]
 
 

fides/api/service/deps.py

@@ -8,6 +8,7 @@ from fides.config import FidesConfig
 from fides.config.config_proxy import ConfigProxy
 from fides.service.dataset.dataset_config_service import DatasetConfigService
 from fides.service.dataset.dataset_service import DatasetService
+from fides.service.event_audit_service import EventAuditService
 from fides.service.messaging.messaging_service import MessagingService
 from fides.service.privacy_request.privacy_request_service import PrivacyRequestService
 from fides.service.system.system_service import SystemService
@@ -47,8 +48,15 @@ def get_user_service(
     return UserService(db, config, config_proxy)
 
 
-def get_taxonomy_service(db: Session = Depends(get_db)) -> TaxonomyService:
-    return TaxonomyService(db)
+def get_event_audit_service(db: Session = Depends(get_db)) -> EventAuditService:
+    return EventAuditService(db)
+
+
+def get_taxonomy_service(
+    db: Session = Depends(get_db),
+    event_audit_service: EventAuditService = Depends(get_event_audit_service),
+) -> TaxonomyService:
+    return TaxonomyService(db, event_audit_service)
 
 
 def get_system_service(db: AsyncSession = Depends(get_async_db)) -> SystemService:

fides/api/service/messaging/message_dispatch_service.py

@@ -44,7 +44,6 @@ from fides.api.service.messaging.messaging_crud_service import (
     get_enabled_messaging_template_by_type_and_property,
 )
 from fides.api.tasks import DatabaseTask, celery_app
-from fides.api.util.logger import Pii
 from fides.config import CONFIG
 from fides.config.config_proxy import ConfigProxy
 from fides.service.messaging.aws_ses_service import AWS_SES_Service
@@ -663,9 +662,9 @@ def _mailgun_dispatcher(
                 raise MessageDispatchException(
                     f"Email failed to send with status code {response.status_code}"
                 )
-    except Exception as e:
-        logger.error("Email failed to send: {}", Pii(str(e)))
-        raise MessageDispatchException(f"Email failed to send due to: {Pii(e)}")
+    except Exception as exc:
+        logger.error("Email failed to send: {}", str(exc))
+        raise MessageDispatchException(f"Email failed to send due to: {str(exc)}")
 
 
 def _twilio_email_dispatcher(
@@ -707,14 +706,14 @@ def _twilio_email_dispatcher(
             logger.error(
                 "Email failed to send: %s: %s",
                 response.status_code,
-                Pii(str(response.body)),
+                str(response.body),
             )
             raise MessageDispatchException(
-                f"Email failed to send: {response.status_code}, {Pii(str(response.body))}"
+                f"Email failed to send: {response.status_code}, {str(response.body)}"
             )
-    except Exception as e:
-        logger.error("Email failed to send: {}", Pii(str(e)))
-        raise MessageDispatchException(f"Email failed to send due to: {Pii(e)}")
+    except Exception as exc:
+        logger.error("Email failed to send: {}", str(exc))
+        raise MessageDispatchException(f"Email failed to send due to: {str(exc)}")
 
 
 def _twilio_sms_dispatcher(
@@ -753,9 +752,9 @@ def _twilio_sms_dispatcher(
             raise MessageDispatchException(
                 "Message failed to send. Either sender phone number or messaging service sid must be provided."
             )
-    except TwilioRestException as e:
-        logger.error("Twilio SMS failed to send: {}", Pii(str(e)))
-        raise MessageDispatchException(f"Twilio SMS failed to send due to: {Pii(e)}")
+    except TwilioRestException as exc:
+        logger.error("Twilio SMS failed to send: {}", str(exc))
+        raise MessageDispatchException(f"Twilio SMS failed to send due to: {str(exc)}")
 
 
 def _aws_ses_dispatcher(
@@ -769,9 +768,11 @@ def _aws_ses_dispatcher(
 
     try:
         aws_ses_serivce.send_email(to, message.subject, message.body)
-    except Exception as e:
-        logger.error("Email failed to send: {}", Pii(str(e)))
-        raise MessageDispatchException(f"AWS SES email failed to send due to: {Pii(e)}")
+    except Exception as exc:
+        logger.error("Email failed to send: {}", str(exc))
+        raise MessageDispatchException(
+            f"AWS SES email failed to send due to: {str(exc)}"
+        )
 
 
 def _get_template_id_if_exists(

fides/api/service/messaging/messaging_crud_service.py

@@ -25,7 +25,7 @@ from fides.api.schemas.messaging.messaging import (
 
 def update_messaging_config(
     db: Session, key: FidesKey, config: MessagingConfigRequest
-) -> MessagingConfigResponse:
+) -> MessagingConfig:
     existing_config_with_key: Optional[MessagingConfig] = MessagingConfig.get_by(
         db=db, field="key", value=key
     )
@@ -38,7 +38,7 @@ def update_messaging_config(
 
 def create_or_update_messaging_config(
     db: Session, config: MessagingConfigRequest
-) -> MessagingConfigResponse:
+) -> MessagingConfig:
     data = {
         "key": config.key,
         "name": config.name,
@@ -46,16 +46,10 @@ def create_or_update_messaging_config(
     }
     if config.details:
         data["details"] = config.details.__dict__  # type: ignore
-    messaging_config: MessagingConfig = MessagingConfig.create_or_update(
+    return MessagingConfig.create_or_update(
         db=db,
         data=data,
     )
-    return MessagingConfigResponse(
-        name=messaging_config.name,
-        key=messaging_config.key,
-        service_type=messaging_config.service_type.value,  # type: ignore
-        details=messaging_config.details,
-    )
 
 
 def delete_messaging_config(db: Session, key: FidesKey) -> None:
@@ -84,6 +78,8 @@ def get_messaging_config_by_key(db: Session, key: FidesKey) -> MessagingConfigRe
         key=config.key,
         service_type=config.service_type.value,  # type: ignore[attr-defined]
         details=config.details,
+        last_test_timestamp=config.last_test_timestamp,
+        last_test_succeeded=config.last_test_succeeded,
     )
 
 

fides/api/service/privacy_request/request_runner_service.py

@@ -782,10 +782,28 @@ def run_privacy_request(
                                     privacy_request.property_id,
                                     privacy_request.id,
                                 )
+                                # Add success log for completion email
+                                privacy_request.add_success_execution_log(
+                                    session,
+                                    connection_key=None,
+                                    dataset_name="Privacy request completion email",
+                                    collection_name=None,
+                                    message="Privacy request completion email sent successfully.",
+                                    action_type=privacy_request.policy.get_action_type(),  # type: ignore
+                                )
                             except (
                                 IdentityNotFoundException,
                                 MessageDispatchException,
                             ) as e:
+                                # Add error log for completion email failure
+                                privacy_request.add_error_execution_log(
+                                    session,
+                                    connection_key=None,
+                                    dataset_name="Privacy request completion email",
+                                    collection_name=None,
+                                    message=f"Privacy request completion email failed: {str(e)}",
+                                    action_type=privacy_request.policy.get_action_type(),  # type: ignore
+                                )
                                 privacy_request.error_processing(db=session)
                                 # If dev mode, log traceback
                                 _log_exception(e, CONFIG.dev_mode)

fides/api/tasks/__init__.py

@@ -19,6 +19,7 @@ from fides.config import CONFIG, FidesConfig
 MESSAGING_QUEUE_NAME = "fidesops.messaging"
 PRIVACY_PREFERENCES_QUEUE_NAME = "fides.privacy_preferences"  # This queue is used in Fidesplus for saving privacy preferences and notices served
 DSR_QUEUE_NAME = "fides.dsr"  # This queue is used for running data subject requests
+CONSENT_WEBHOOK_QUEUE_NAME = "fidesplus.consent_webhooks"  # This queue is used for processing consent webhooks from 3rd-party APIs
 DISCOVERY_MONITORS_DETECTION_QUEUE_NAME = "fidesplus.discovery_monitors_detection"  # This queue is used for running discovery monitors detection tasks
 DISCOVERY_MONITORS_CLASSIFICATION_QUEUE_NAME = "fidesplus.discovery_monitors_classification"  # This queue is used for running discovery monitors classification tasks
 DISCOVERY_MONITORS_PROMOTION_QUEUE_NAME = "fidesplus.discovery_monitors_promotion"  # This queue is used for running discovery monitors promotion tasks

fides/api/util/cache.py

@@ -220,7 +220,7 @@ def get_cache() -> FidesopsRedis:
 
     if not connected:
         raise common_exceptions.RedisConnectionError(
-            "Unable to establish Redis connection. Fidesops is unable to accept PrivacyRequsts."
+            "Unable to establish Redis connection. Fides is unable to accept PrivacyRequests."
         )
 
     return _connection

fides/api/worker/__init__.py

@@ -8,6 +8,7 @@ from loguru import logger
 from fides.api.db.base import Base  # type: ignore
 from fides.api.service.saas_request.override_implementations import *
 from fides.api.tasks import (
+    CONSENT_WEBHOOK_QUEUE_NAME,
     DISCOVERY_MONITORS_CLASSIFICATION_QUEUE_NAME,
     DISCOVERY_MONITORS_DETECTION_QUEUE_NAME,
     DISCOVERY_MONITORS_PROMOTION_QUEUE_NAME,
@@ -39,6 +40,7 @@ def start_worker(
         MESSAGING_QUEUE_NAME,
         PRIVACY_PREFERENCES_QUEUE_NAME,
         DSR_QUEUE_NAME,
+        CONSENT_WEBHOOK_QUEUE_NAME,
         DISCOVERY_MONITORS_DETECTION_QUEUE_NAME,
         DISCOVERY_MONITORS_CLASSIFICATION_QUEUE_NAME,
         DISCOVERY_MONITORS_PROMOTION_QUEUE_NAME,

fides/common/api/v1/urn_registry.py

@@ -66,7 +66,8 @@ MESSAGING_ACTIVE_DEFAULT = "/messaging/default/active"
 MESSAGING_STATUS = "/messaging/default/status"
 MESSAGING_DEFAULT_SECRETS = "/messaging/default/{service_type}/secret"
 MESSAGING_DEFAULT_BY_TYPE = "/messaging/default/{service_type}"
-MESSAGING_TEST = "/messaging/config/test"
+MESSAGING_TEST_DEPRECATED = "/messaging/config/test"  # DEPRECATED
+MESSAGING_TEST = "/messaging/test/{service_type}"
 MESSAGING_EMAIL_INVITE_STATUS = "/messaging/email-invite/status"
 
 # Policy URLs

fides/service/event_audit_service.py

@@ -0,0 +1,115 @@
+"""Service for creating and managing event audit records."""
+
+from typing import Any, Dict, List, Optional
+
+from loguru import logger
+from sqlalchemy.orm import Session
+
+from fides.api.models.event_audit import EventAudit, EventAuditStatus, EventAuditType
+from fides.api.request_context import get_user_id
+
+
+class EventAuditService:
+    """Service for creating and managing event audit records."""
+
+    def __init__(self, db: Session):
+        self.db = db
+
+    def create_event_audit(
+        self,
+        event_type: EventAuditType,
+        status: EventAuditStatus,
+        *,
+        user_id: Optional[str] = None,
+        resource_type: Optional[str] = None,
+        resource_identifier: Optional[str] = None,
+        description: Optional[str] = None,
+        event_details: Optional[Dict[str, Any]] = None,
+    ) -> EventAudit:
+        """Create a new audit event record."""
+
+        # Uses the passed in user_id or falls back to the authenticated user via get_user_id()
+        event_audit = EventAudit.create(
+            db=self.db,
+            data={
+                "event_type": event_type,
+                "status": status,
+                "user_id": user_id or get_user_id(),
+                "resource_type": resource_type,
+                "resource_identifier": resource_identifier,
+                "description": description,
+                "event_details": event_details,
+            },
+        )
+
+        if resource_identifier:
+            logger.debug(
+                "Created event audit: {} for resource: {} ({})",
+                event_type,
+                resource_type,
+                resource_identifier,
+            )
+        else:
+            logger.debug(
+                "Created event audit: {} for resource: {}",
+                event_type,
+                resource_type,
+            )
+
+        return event_audit
+
+    def get_events_for_resource(
+        self,
+        resource_type: str,
+        resource_identifier: Optional[str] = None,
+        limit: int = 100,
+    ) -> List[EventAudit]:
+        """Get audit events for a specific resource."""
+
+        query = self.db.query(EventAudit).filter(
+            EventAudit.resource_type == resource_type
+        )
+
+        if resource_identifier:
+            query = query.filter(EventAudit.resource_identifier == resource_identifier)
+
+        return query.order_by(EventAudit.created_at.desc()).limit(limit).all()
+
+    def get_events_by_user(self, user_id: str, limit: int = 100) -> List[EventAudit]:
+        """Get audit events by a specific user."""
+
+        return (
+            self.db.query(EventAudit)
+            .filter(EventAudit.user_id == user_id)
+            .order_by(EventAudit.created_at.desc())
+            .limit(limit)
+            .all()
+        )
+
+    def get_events_by_type(
+        self, event_type: EventAuditType, limit: int = 100
+    ) -> List[EventAudit]:
+        """Get audit events of a specific type."""
+
+        return (
+            self.db.query(EventAudit)
+            .filter(EventAudit.event_type == event_type)
+            .order_by(EventAudit.created_at.desc())
+            .limit(limit)
+            .all()
+        )
+
+    def get_events_by_category(
+        self, category_prefix: str, limit: int = 100
+    ) -> List[EventAudit]:
+        """Get all events matching a category prefix (e.g., 'consent', 'system', 'taxonomy')."""
+
+        prefix_with_dot = category_prefix + "."
+
+        return (
+            self.db.query(EventAudit)
+            .filter(EventAudit.event_type.startswith(prefix_with_dot))
+            .order_by(EventAudit.created_at.desc())
+            .limit(limit)
+            .all()
+        )

fides/service/messaging/aws_ses_service.py

@@ -4,10 +4,8 @@ from loguru import logger
 
 from fides.api.models.messaging import MessagingConfig
 from fides.api.models.property import CONFIG
-from fides.api.schemas.messaging.messaging import (
-    MessagingServiceDetailsAWS_SES,
-    MessagingServiceSecretsAWS_SES,
-)
+from fides.api.schemas.messaging.messaging import MessagingServiceDetailsAWS_SES
+from fides.api.schemas.messaging.shared_schemas import MessagingServiceSecretsAWS_SES
 from fides.api.schemas.storage.storage import StorageSecrets
 from fides.api.util.aws_util import get_aws_session
 

fides/service/taxonomy/taxonomy_service.py

@@ -7,12 +7,14 @@ from typing import Any, Dict, List, Literal, Optional, Union, overload
 from sqlalchemy import or_
 from sqlalchemy.orm import Session
 
+from fides.api.models.event_audit import EventAuditStatus, EventAuditType
 from fides.api.models.sql_models import (  # type:ignore[attr-defined]
     DataCategory,
     DataSubject,
     DataUse,
 )
 from fides.api.models.taxonomy import TaxonomyUsage
+from fides.service.event_audit_service import EventAuditService
 
 from .handlers import LegacyTaxonomyHandler, TaxonomyHandler
 from .utils import (
@@ -34,8 +36,9 @@ class TaxonomyService:
 
     # Most of the main methods in this service have a type-specific overload to help with type hints
 
-    def __init__(self, db: Session):
+    def __init__(self, db: Session, event_audit_service: EventAuditService):
         self.db = db
+        self.event_audit_service = event_audit_service
 
     @overload
     def get_elements(
@@ -121,7 +124,22 @@ class TaxonomyService:
 
         # Centralized validation before delegation
         self._validate_element_data(processed_data, taxonomy_type, action="create")
-        return self._get_handler(taxonomy_type).create_element(processed_data)
+
+        element = self._get_handler(taxonomy_type).create_element(processed_data)
+
+        self.event_audit_service.create_event_audit(
+            EventAuditType.taxonomy_element_created,
+            EventAuditStatus.succeeded,
+            resource_type="taxonomy_element",
+            resource_identifier=processed_data.get("fides_key"),
+            description=f"Created {taxonomy_type} element: {processed_data.get('fides_key')} ({processed_data.get('name')})",
+            event_details={
+                "taxonomy_type": taxonomy_type,
+                **processed_data,
+            },
+        )
+
+        return element
 
     @overload
     def update_element(
@@ -162,8 +180,12 @@ class TaxonomyService:
         # Update the element via handler
         updated_element = handler.update_element(fides_key, element_data)
 
+        # Return early if element was not found
+        if updated_element is None:
+            return None
+
         # Handle hierarchical activation/deactivation logic at service level
-        if updated_element and "active" in element_data:
+        if "active" in element_data:
             if element_data["active"]:
                 activate_taxonomy_parents(updated_element, self.db)
             else:
@@ -178,6 +200,18 @@ class TaxonomyService:
             # Refresh the updated element to return the latest state
             self.db.refresh(updated_element)
 
+        self.event_audit_service.create_event_audit(
+            EventAuditType.taxonomy_element_updated,
+            EventAuditStatus.succeeded,
+            resource_type="taxonomy_element",
+            resource_identifier=fides_key,
+            description=f"Updated {taxonomy_type} element: {fides_key} ({updated_element.name})",  # type: ignore
+            event_details={
+                "taxonomy_type": taxonomy_type,
+                **element_data,
+            },
+        )
+
         return updated_element
 
     def delete_element(self, taxonomy_type: str, fides_key: str) -> None:
@@ -196,6 +230,18 @@ class TaxonomyService:
         self._get_handler(taxonomy_type).delete_element(fides_key)
         self.db.commit()
 
+        self.event_audit_service.create_event_audit(
+            EventAuditType.taxonomy_element_deleted,
+            EventAuditStatus.succeeded,
+            resource_type="taxonomy_element",
+            resource_identifier=fides_key,
+            description=f"Deleted {taxonomy_type} element: {fides_key}",
+            event_details={
+                "taxonomy_type": taxonomy_type,
+                "fides_key": fides_key,
+            },
+        )
+
     @overload
     def create_or_update_element(
         self, taxonomy_type: Literal["data_categories"], element_data: Dict

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/018c12b58ee7f861.css" as="style"/><link rel="stylesheet" href="/_next/static/css/018c12b58ee7f861.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-606818148553db7b.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-a653cee14ce2366b.js" defer=""></script><script src="/_next/static/chunks/pages/404-8d9c703c96662265.js" defer=""></script><script src="/_next/static/_b75ACzlGNz3tZqGUPTE5/_buildManifest.js" defer=""></script><script src="/_next/static/_b75ACzlGNz3tZqGUPTE5/_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":"_b75ACzlGNz3tZqGUPTE5","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/018c12b58ee7f861.css" as="style"/><link rel="stylesheet" href="/_next/static/css/018c12b58ee7f861.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-302177edeb0dc4f5.js" defer=""></script><script src="/_next/static/chunks/pages/404-2eb8aed4939f1142.js" defer=""></script><script src="/_next/static/v72X5v2wmNmYdDpd8p1YY/_buildManifest.js" defer=""></script><script src="/_next/static/v72X5v2wmNmYdDpd8p1YY/_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":"v72X5v2wmNmYdDpd8p1YY","nextExport":true,"autoExport":true,"isFallback":false,"scriptLoader":[]}</script></body></html>

fides/ui-build/static/admin/_next/static/chunks/1115-7888473b3dc28cda.js

@@ -0,0 +1 @@
+"use strict";(self.webpackChunk_N_E=self.webpackChunk_N_E||[]).push([[1115],{77213:function(e,n,i){i.d(n,{Z:function(){return f}});var t=i(24246),s=i(96306),r=i(88038),a=i.n(r),o=i(86677);i(27378);var l=i(25980),c=i(90867),g=i(42478),d=i(77830),u=()=>{let e=(0,o.useRouter)();return(0,t.jsx)(s.xuv,{bg:"gray.50",border:"1px solid",borderColor:"blue.400",borderRadius:"md",justifyContent:"space-between",p:5,mb:5,mt:5,children:(0,t.jsxs)(s.xuv,{children:[(0,t.jsxs)(s.Kqy,{direction:{base:"column",sm:"row"},justifyContent:"space-between",children:[(0,t.jsx)(s.xvT,{fontWeight:"semibold",children:"Configure your storage and messaging provider"}),(0,t.jsx)(s.wpx,{onClick:()=>{e.push(d.AD)},children:"Configure"})]}),(0,t.jsxs)(s.xvT,{children:["Before Fides can process your privacy requests we need two simple steps to configure your storage and email client."," "]})]})})},f=e=>{let{children:n,title:i,padded:r=!0,mainProps:d}=e,f=(0,l.hz)(),m=(0,o.useRouter)(),h="/privacy-requests"===m.pathname||"/datastore-connection"===m.pathname,x=!(f.flags.messagingConfiguration&&h),{data:p}=(0,g.JE)(void 0,{skip:x}),{data:y}=(0,c.PW)(void 0,{skip:x}),j=f.flags.messagingConfiguration&&(!p||!y)&&h;return(0,t.jsxs)(s.kCb,{"data-testid":i,direction:"column",h:"100vh",children:[(0,t.jsxs)(a(),{children:[(0,t.jsxs)("title",{children:["Fides Admin UI - ",i]}),(0,t.jsx)("meta",{name:"description",content:"Privacy Engineering Platform"}),(0,t.jsx)("link",{rel:"icon",href:"/favicon.ico"})]}),(0,t.jsxs)(s.kCb,{as:"main",direction:"column",py:r?6:0,px:r?10:0,h:r?"calc(100% - 48px)":"full",flex:1,minWidth:0,overflow:"auto",...d,children:[j?(0,t.jsx)(u,{}):null,n]})]})}},58754:function(e,n,i){var t=i(24246),s=i(96306),r=i(70788);n.Z=e=>{let{heading:n,breadcrumbItems:i,isSticky:a=!0,children:o,rightContent:l,style:c,...g}=e;return(0,t.jsxs)("div",{...g,style:a?{position:"sticky",top:"-24px",paddingTop:"24px",paddingBottom:"24px",paddingLeft:"40px",marginLeft:"-40px",paddingRight:"40px",marginRight:"-40px",marginTop:"-24px",left:0,zIndex:20,backgroundColor:"white",...c}:{paddingBottom:"24px",...c},children:[(0,t.jsxs)(s.jqI,{justify:"space-between",children:["string"==typeof n?(0,t.jsx)(s.lQT,{className:i||o?"pb-4":void 0,level:1,"data-testid":"page-heading",children:n}):n,l&&(0,t.jsx)("div",{"data-testid":"page-header-right-content",children:l})]}),!!i&&(0,t.jsx)(r.m,{className:o?"pb-4":void 0,items:i,"data-testid":"page-breadcrumb"}),o]})}},70788:function(e,n,i){i.d(n,{m:function(){return c}});var t=i(24246),s=i(96306),r=i(79894),a=i.n(r),o=i(27378);let{Text:l}=s.AntTypography,c=e=>{let{items:n,...i}=e,r=(0,o.useMemo)(()=>null==n?void 0:n.map((e,i)=>{let r=i===n.length-1,o={...e},c=o.onClick&&!o.href;return("string"==typeof o.title&&(o.title=(0,t.jsx)(l,{style:{color:"inherit",maxWidth:r?void 0:400},ellipsis:!r,id:r?"breadcrumb-current-page":void 0,children:o.title})),c)?o.title=(0,t.jsx)(s.wpx,{type:"text",size:"small",icon:o.icon,onClick:o.onClick,className:"ant-breadcrumb-link -mt-px px-1 text-inherit",children:o.title}):(o.icon&&(o.title=(0,t.jsxs)(t.Fragment,{children:[(0,t.jsx)("span",{className:"anticon align-text-bottom",children:o.icon}),o.title]})),o.href&&o.title&&(o.title=(0,t.jsx)(a(),{href:o.href,className:"ant-breadcrumb-link",children:o.title}),delete o.href)),o}),[n]);return(0,t.jsx)(s.zrq,{items:r,...i})}},42478:function(e,n,i){i.d(n,{FU:function(){return c},JE:function(){return s},Ki:function(){return d},SU:function(){return u},W:function(){return f},h9:function(){return r},jc:function(){return t},qt:function(){return l},sn:function(){return g}});let{useGetEmailInviteStatusQuery:t,useGetActiveMessagingProviderQuery:s,useCreateMessagingConfigurationMutation:r,useCreateMessagingConfigurationSecretsMutation:a,useGetMessagingConfigurationDetailsQuery:o,useGetMessagingConfigurationsQuery:l,useGetMessagingConfigurationByKeyQuery:c,useUpdateMessagingConfigurationByKeyMutation:g,useUpdateMessagingConfigurationSecretsByKeyMutation:d,useCreateTestConnectionMessageMutation:u,useDeleteMessagingConfigurationByKeyMutation:f}=i(78780).u.injectEndpoints({endpoints:e=>({getEmailInviteStatus:e.query({query:()=>({url:"/messaging/email-invite/status"}),providesTags:()=>["Email Invite Status"]}),createMessagingConfiguration:e.mutation({query:e=>({url:"messaging/config",method:"POST",body:e}),invalidatesTags:["Messaging Config","Configuration Settings"]}),getActiveMessagingProvider:e.query({queryFn:async(e,n,i,t)=>{let s=await t({url:"messaging/default/active"});return s.error&&404===s.error.status?{data:null}:s},providesTags:["Messaging Config"]}),createMessagingConfigurationSecrets:e.mutation({query:e=>({url:"messaging/default/".concat(e.service_type,"/secret"),method:"PUT",body:e.details}),invalidatesTags:["Messaging Config","Configuration Settings"]}),getMessagingConfigurationDetails:e.query({query:e=>({url:"messaging/default/".concat(e.type)}),providesTags:["Messaging Config"]}),getMessagingConfigurations:e.query({query:()=>({url:"messaging/config"}),providesTags:["Messaging Config"]}),getMessagingConfigurationByKey:e.query({query:e=>({url:"messaging/config/".concat(e.key)}),providesTags:["Messaging Config"]}),createTestConnectionMessage:e.mutation({query:e=>({url:"messaging/test/".concat(e.service_type),method:"POST",body:e.details}),invalidatesTags:["Messaging Config"]}),updateMessagingConfigurationByKey:e.mutation({query:e=>({url:"messaging/config/".concat(e.key),method:"PATCH",body:e.config}),invalidatesTags:["Messaging Config","Configuration Settings"]}),updateMessagingConfigurationSecretsByKey:e.mutation({query:e=>({url:"messaging/config/".concat(e.key,"/secret"),method:"PUT",body:e.secrets}),invalidatesTags:["Messaging Config","Configuration Settings"]}),deleteMessagingConfigurationByKey:e.mutation({query:e=>({url:"messaging/config/".concat(e.key),method:"DELETE"}),invalidatesTags:["Messaging Config","Configuration Settings"]})})})},71115:function(e,n,i){i.r(n),i.d(n,{default:function(){return d}});var t=i(24246),s=i(96306),r=i(25980),a=i(62165),o=i(16394);let l=e=>{let{flag:n,value:i,override:r}=e;return"boolean"!=typeof i?(0,t.jsxs)(t.Fragment,{children:[(0,t.jsx)(s.xvT,{fontSize:"sm",children:n}),(0,t.jsx)(s.xvT,{fontSize:"sm",children:i})]}):a.Ky[n].userCannotModify?null:(0,t.jsxs)(s.NIc,{display:"contents",children:[(0,t.jsx)(s.xuv,{justifySelf:"center",children:(0,t.jsx)(s.rAg,{id:"flag-".concat(n),checked:i,onChange:()=>r({flag:n,value:!i})})}),(0,t.jsx)(s.xuv,{children:(0,t.jsx)(s.lXp,{margin:0,fontSize:"sm",htmlFor:"flag-".concat(n),title:n,children:(0,o.Py)(n)})}),(0,t.jsx)(s.xuv,{children:(0,t.jsx)(s.xvT,{fontSize:"sm",children:a.Ky[n].description})})]})};var c=i(77213),g=i(58754),d=e=>{let{showAlphaFeatures:n=!1}=e,i=(0,r.hz)(),{flags:o,override:d,reset:u}=(0,a.Vb)(),f=a.R$.filter(e=>e.startsWith("alpha")),m=a.R$.filter(e=>!e.startsWith("alpha"));return(0,t.jsxs)(c.Z,{title:"About Fides",children:[(0,t.jsx)(g.Z,{heading:"About Fides",children:(0,t.jsxs)(s.kCb,{direction:"column",gap:4,children:[(0,t.jsxs)(s.xuv,{children:[(0,t.jsxs)(s.xvT,{as:"span",fontWeight:"bold",children:["Fides Core Version:"," "]}),(0,t.jsx)(s.xvT,{as:"pre",display:"inline",children:i.version})]}),i.plusVersion?(0,t.jsxs)(s.xuv,{children:[(0,t.jsxs)(s.xvT,{as:"span",fontWeight:"bold",children:["Fides Plus Version:"," "]}),(0,t.jsx)(s.xvT,{as:"pre",display:"inline",children:i.plusVersion})]}):null,(0,t.jsx)(s.izJ,{})]})}),(0,t.jsxs)(s.kCb,{alignItems:"center",gap:4,children:[(0,t.jsx)(s.X6q,{as:"h2",fontSize:"xl",children:"Beta Features"}),(0,t.jsx)(s.wpx,{onClick:u,children:"Reset"})]}),(0,t.jsx)(s.rjZ,{gridTemplateColumns:"1fr 2fr 6fr",gridColumnGap:4,gridRowGap:2,alignItems:"center",className:"py-6",children:m.map(e=>(0,t.jsx)(l,{flag:e,value:o[e],override:d},e))}),n&&(0,t.jsxs)(t.Fragment,{children:[(0,t.jsxs)(s.kCb,{alignItems:"center",gap:4,children:[(0,t.jsx)(s.X6q,{as:"h2",fontSize:"xl",children:"Alpha Features"}),(0,t.jsx)(s.wpx,{onClick:u,children:"Reset"})]}),(0,t.jsx)(s.rjZ,{gridTemplateColumns:"1fr 2fr 6fr",gridColumnGap:4,gridRowGap:2,alignItems:"center",className:"py-6",children:f.map(e=>(0,t.jsx)(l,{flag:e,value:o[e],override:d},e))})]}),(0,t.jsxs)(s.xuv,{children:[(0,t.jsxs)(s.xvT,{fontSize:"sm",children:["Please visit"," ",(0,t.jsx)(s.rUS,{color:"complimentary.500",href:"https://docs.ethyca.com",isExternal:!0,children:"docs.ethyca.com"})," ","for more information on these features."]}),(0,t.jsxs)(s.xvT,{fontSize:"sm",children:["For questions and feedback, please join us at"," ",(0,t.jsx)(s.rUS,{color:"complimentary.500",href:"https://fidescommunity.slack.com",isExternal:!0,children:"fidescommunity.slack.com"}),"."]})]})]})}}}]);