ethyca-fides 2.69.1rc0__py2.py3-none-any.whl → 2.76.0rc2__py2.py3-none-any.whl

fides/service/dataset/dataset_service.py

@@ -6,6 +6,7 @@ from loguru import logger
 from sqlalchemy import select
 from sqlalchemy.orm import Session
 
+from fides.api.models.datasetconfig import DatasetConfig  # type: ignore[attr-defined]
 from fides.api.schemas.dataset import ValidateDatasetResponse
 from fides.service.dataset.dataset_validator import DatasetValidator
 
@@ -26,6 +27,10 @@ class DatasetNotFoundException(DatasetError):
     """Raised when a dataset is not found"""
 
 
+class LinkedDatasetException(DatasetError):
+    """Raised when attempting to delete a dataset that's associated to a DatasetConfig"""
+
+
 class DatasetService:
     def __init__(self, db: Session):
         self.db = db
@@ -68,6 +73,40 @@ class DatasetService:
     def delete_dataset(self, fides_key: str) -> CtlDataset:
         """Delete a dataset by fides key"""
         dataset = self.get_dataset(fides_key)
+
+        # Check if dataset is associated with any DatasetConfigs
+        associated_configs = (
+            self.db.query(DatasetConfig)
+            .filter(DatasetConfig.ctl_dataset_id == dataset.id)
+            .all()
+        )
+
+        if associated_configs:
+            # Create detailed error message
+            integration_details = []
+            for config in associated_configs:
+                connection_name = (
+                    config.connection_config.name or config.connection_config.key
+                )
+                detail = f"'{connection_name}' ({config.connection_config.connection_type.value})"  # type: ignore[attr-defined]
+
+                # Add system information if available
+                if config.connection_config.system_id:
+                    system = config.connection_config.system
+                    if system:
+                        system_name = system.name or system.fides_key
+                        detail += f" in system '{system_name}'"
+
+                integration_details.append(detail)
+
+            message = (
+                f"Cannot delete dataset '{fides_key}' because it is associated with "
+                f"the following integration(s): {', '.join(integration_details)}. "
+                f"Remove the dataset from these integrations before deleting."
+            )
+
+            raise LinkedDatasetException(message)
+
         dataset.delete(self.db)
         return dataset
 

fides/service/event_audit_service.py

@@ -0,0 +1,109 @@
+"""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()
+        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,
+        }
+        event_audit = EventAudit.create(
+            db=self.db,
+            data=data,
+        )
+
+        msg_payload = {**data}
+        msg_payload.pop("event_type")
+        msg_payload["status"] = status.value
+        msg = f"Created event audit {event_type} for resource: {resource_type}. {msg_payload}"
+
+        logger.info(msg)
+
+        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/messaging/messaging_service.py

@@ -2,12 +2,15 @@ import secrets
 from typing import Optional, Set, Union
 
 from loguru import logger
+from pydantic import BaseModel
 from sqlalchemy.orm import Session
 
 from fides.api.common_exceptions import (
     IdentityNotFoundException,
+    MessageDispatchException,
     PolicyNotFoundException,
 )
+from fides.api.models.messaging import MessagingConfig
 from fides.api.models.policy import Policy
 from fides.api.models.privacy_request import (
     ConsentRequest,
@@ -29,15 +32,22 @@ from fides.api.schemas.policy import ActionType
 from fides.api.schemas.redis_cache import Identity
 from fides.api.service.messaging.message_dispatch_service import (
     EMAIL_JOIN_STRING,
-    dispatch_message,
     dispatch_message_task,
+    get_email_messaging_config_service_type,
     message_send_enabled,
 )
 from fides.api.tasks import MESSAGING_QUEUE_NAME
-from fides.config import FidesConfig, get_config
+from fides.config import FidesConfig
 from fides.config.config_proxy import ConfigProxy
 
 
+class MessageDispatchParams(BaseModel):
+    message_meta: Optional[FidesopsMessage]
+    service_type: Optional[str]
+    to_identity: Optional[Identity]
+    property_id: Optional[str]
+
+
 class MessagingService:
     def __init__(self, db: Session, config: FidesConfig, config_proxy: ConfigProxy):
         self.db = db
@@ -67,15 +77,15 @@ class MessagingService:
 
             dispatch_message_task.apply_async(
                 queue=MESSAGING_QUEUE_NAME,
-                kwargs={
-                    "message_meta": FidesopsMessage(
+                kwargs=MessageDispatchParams(
+                    message_meta=FidesopsMessage(
                         action_type=MessagingActionType.PRIVACY_REQUEST_REVIEW_APPROVE,
                         body_params=None,
-                    ).model_dump(mode="json"),
-                    "service_type": self.config_proxy.notifications.notification_service_type,
-                    "to_identity": to_identity.model_dump(mode="json"),
-                    "property_id": privacy_request.property_id,
-                },
+                    ),
+                    service_type=self.config_proxy.notifications.notification_service_type,
+                    to_identity=to_identity,
+                    property_id=privacy_request.property_id,
+                ).model_dump(mode="json"),
             )
 
     def send_request_denied(
@@ -103,17 +113,17 @@ class MessagingService:
 
             dispatch_message_task.apply_async(
                 queue=MESSAGING_QUEUE_NAME,
-                kwargs={
-                    "message_meta": FidesopsMessage(
+                kwargs=MessageDispatchParams(
+                    message_meta=FidesopsMessage(
                         action_type=MessagingActionType.PRIVACY_REQUEST_REVIEW_DENY,
                         body_params=RequestReviewDenyBodyParams(
                             rejection_reason=deny_reason
                         ),
-                    ).model_dump(mode="json"),
-                    "service_type": self.config_proxy.notifications.notification_service_type,
-                    "to_identity": to_identity.model_dump(mode="json"),
-                    "property_id": privacy_request.property_id,
-                },
+                    ),
+                    service_type=self.config_proxy.notifications.notification_service_type,
+                    to_identity=to_identity,
+                    property_id=privacy_request.property_id,
+                ).model_dump(mode="json"),
             )
 
     def send_verification_code(
@@ -131,19 +141,37 @@ class MessagingService:
             MessagingActionType.SUBJECT_IDENTITY_VERIFICATION,
             self.config_proxy.execution.subject_identity_verification_required,
         ):
+            # Note: Fallback to email messaging config is only used for ConsentRequests
+            service_type = (
+                self.config_proxy.notifications.notification_service_type
+                or get_email_messaging_config_service_type(db=self.db)
+            )
+            if not service_type:
+                raise MessageDispatchException(
+                    "No notification service type configured."
+                )
+
+            # For PrivacyRequest, validate the config exists before dispatching
+            if isinstance(request, PrivacyRequest):
+                MessagingConfig.get_configuration(db=self.db, service_type=service_type)
+
             verification_code = _generate_id_verification_code()
             request.cache_identity_verification_code(verification_code)
 
-            dispatch_message(
-                self.db,
-                action_type=MessagingActionType.SUBJECT_IDENTITY_VERIFICATION,
-                to_identity=to_identity,
-                service_type=self.config_proxy.notifications.notification_service_type,
-                message_body_params=SubjectIdentityVerificationBodyParams(
-                    verification_code=verification_code,
-                    verification_code_ttl_seconds=self.config.redis.identity_verification_code_ttl_seconds,
-                ),
-                property_id=property_id,
+            dispatch_message_task.apply_async(
+                queue=MESSAGING_QUEUE_NAME,
+                kwargs=MessageDispatchParams(
+                    message_meta=FidesopsMessage(
+                        action_type=MessagingActionType.SUBJECT_IDENTITY_VERIFICATION,
+                        body_params=SubjectIdentityVerificationBodyParams(
+                            verification_code=verification_code,
+                            verification_code_ttl_seconds=self.config.redis.identity_verification_code_ttl_seconds,
+                        ),
+                    ),
+                    service_type=service_type,
+                    to_identity=to_identity,
+                    property_id=property_id,
+                ).model_dump(mode="json"),
             )
 
         return verification_code
@@ -185,17 +213,17 @@ class MessagingService:
 
             dispatch_message_task.apply_async(
                 queue=MESSAGING_QUEUE_NAME,
-                kwargs={
-                    "message_meta": FidesopsMessage(
+                kwargs=MessageDispatchParams(
+                    message_meta=FidesopsMessage(
                         action_type=MessagingActionType.PRIVACY_REQUEST_RECEIPT,
                         body_params=RequestReceiptBodyParams(
                             request_types=request_types_list
                         ),
-                    ).model_dump(mode="json"),
-                    "service_type": self.config.notifications.notification_service_type,
-                    "to_identity": identity.labeled_dict(),
-                    "property_id": privacy_request.property_id,
-                },
+                    ),
+                    service_type=self.config.notifications.notification_service_type,
+                    to_identity=identity,
+                    property_id=privacy_request.property_id,
+                ).model_dump(mode="json"),
             )
 
 
@@ -229,17 +257,17 @@ def check_and_dispatch_error_notifications(db: Session) -> None:
         for email in privacy_request_notifications[0].email.split(EMAIL_JOIN_STRING):
             dispatch_message_task.apply_async(
                 queue=MESSAGING_QUEUE_NAME,
-                kwargs={
-                    "message_meta": FidesopsMessage(
+                kwargs=MessageDispatchParams(
+                    message_meta=FidesopsMessage(
                         action_type=MessagingActionType.PRIVACY_REQUEST_ERROR_NOTIFICATION,
                         body_params=ErrorNotificationBodyParams(
                             unsent_errors=len(unsent_errors)
                         ),
-                    ).model_dump(mode="json"),
-                    "service_type": config_proxy.notifications.notification_service_type,
-                    "to_identity": {"email": email},
-                    "property_id": None,
-                },
+                    ),
+                    service_type=config_proxy.notifications.notification_service_type,
+                    to_identity=Identity(email=email),
+                    property_id=None,
+                ).model_dump(mode="json"),
             )
 
         for error in unsent_errors:
@@ -248,33 +276,6 @@ def check_and_dispatch_error_notifications(db: Session) -> None:
     return None
 
 
-def send_verification_code_to_user(
-    db: Session,
-    request: Union[ConsentRequest, PrivacyRequest],
-    to_identity: Optional[Identity],
-    property_id: Optional[str],
-) -> str:
-    """Generate and cache a verification code, and then message the user"""
-    config = get_config()
-    config_proxy = ConfigProxy(db)
-    verification_code = _generate_id_verification_code()
-    request.cache_identity_verification_code(verification_code)
-    messaging_action_type = MessagingActionType.SUBJECT_IDENTITY_VERIFICATION
-    dispatch_message(
-        db,
-        action_type=messaging_action_type,
-        to_identity=to_identity,
-        service_type=config_proxy.notifications.notification_service_type,
-        message_body_params=SubjectIdentityVerificationBodyParams(
-            verification_code=verification_code,
-            verification_code_ttl_seconds=config.redis.identity_verification_code_ttl_seconds,
-        ),
-        property_id=property_id,
-    )
-
-    return verification_code
-
-
 def send_privacy_request_receipt_message_to_user(
     policy: Optional[Policy],
     to_identity: Optional[Identity],
@@ -305,13 +306,13 @@ def send_privacy_request_receipt_message_to_user(
 
     dispatch_message_task.apply_async(
         queue=MESSAGING_QUEUE_NAME,
-        kwargs={
-            "message_meta": FidesopsMessage(
+        kwargs=MessageDispatchParams(
+            message_meta=FidesopsMessage(
                 action_type=MessagingActionType.PRIVACY_REQUEST_RECEIPT,
                 body_params=RequestReceiptBodyParams(request_types=request_types_list),
-            ).model_dump(mode="json"),
-            "service_type": service_type,
-            "to_identity": to_identity.labeled_dict(),
-            "property_id": property_id,
-        },
+            ),
+            service_type=service_type,
+            to_identity=to_identity,
+            property_id=property_id,
+        ).model_dump(mode="json"),
     )