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

fides/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2025-09-08T12:08:59-0300",
+ "date": "2025-09-10T16:14:21-0400",
  "dirty": false,
  "error": null,
- "full-revisionid": "4e4ef38fde9cbb24f1b053bb67af1945cf409477",
- "version": "2.69.3b1"
+ "full-revisionid": "cb174101f57cbd0c9f18c818631b1fcab77b8d6b",
+ "version": "2.70.0rc0"
 }
 '''  # END VERSION_JSON
 

fides/api/alembic/migrations/versions/4d8c0fcc5771_adding_default_system_groups.py

@@ -0,0 +1,78 @@
+"""adding default system groups
+
+Revision ID: 4d8c0fcc5771
+Revises: 5fa78b1f324d
+Create Date: 2025-09-10 05:40:19.064377
+
+"""
+
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision = "4d8c0fcc5771"
+down_revision = "5fa78b1f324d"
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # Insert default system groups into taxonomy_element table
+    op.execute(
+        """
+        INSERT INTO taxonomy_element (id, created_at, updated_at, taxonomy_type, fides_key, name, description, parent_key, active, tags, organization_fides_key)
+        VALUES
+          ('tax_' || gen_random_uuid(), now(), now(), 'system_group', 'analytics_business_intelligence', 'Analytics & Business intelligence', 'System group for analytics and business intelligence systems', NULL, true, NULL, 'default_organization'),
+          ('tax_' || gen_random_uuid(), now(), now(), 'system_group', 'customer_management', 'Customer management', 'System group for customer management systems', NULL, true, NULL, 'default_organization'),
+          ('tax_' || gen_random_uuid(), now(), now(), 'system_group', 'internal_operations', 'Internal operations', 'System group for internal operations systems', NULL, true, NULL, 'default_organization'),
+          ('tax_' || gen_random_uuid(), now(), now(), 'system_group', 'legal_compliance', 'Legal & Compliance', 'System group for legal and compliance systems', NULL, true, NULL, 'default_organization'),
+          ('tax_' || gen_random_uuid(), now(), now(), 'system_group', 'marketing', 'Marketing', 'System group for marketing systems', NULL, true, NULL, 'default_organization'),
+          ('tax_' || gen_random_uuid(), now(), now(), 'system_group', 'payments_billing', 'Payments & Billing', 'System group for payments and billing systems', NULL, true, NULL, 'default_organization'),
+          ('tax_' || gen_random_uuid(), now(), now(), 'system_group', 'product_service_delivery', 'Product & Service delivery', 'System group for product and service delivery systems', NULL, true, NULL, 'default_organization'),
+          ('tax_' || gen_random_uuid(), now(), now(), 'system_group', 'research_development', 'Research & Development', 'System group for research and development systems', NULL, true, NULL, 'default_organization'),
+          ('tax_' || gen_random_uuid(), now(), now(), 'system_group', 'sales_revenue_operations', 'Sales & Revenue operations', 'System group for sales and revenue operations systems', NULL, true, NULL, 'default_organization'),
+          ('tax_' || gen_random_uuid(), now(), now(), 'system_group', 'security_fraud', 'Security & Fraud', 'System group for security and fraud systems', NULL, true, NULL, 'default_organization')
+        """
+    )
+
+    # Insert default system groups into system_group table with white labels
+    op.execute(
+        """
+        INSERT INTO system_group (id, created_at, updated_at, fides_key, label_color, data_steward_username, data_uses)
+        VALUES
+          ('sys_' || gen_random_uuid(), now(), now(), 'analytics_business_intelligence', 'taxonomy_white', NULL, '{}'),
+          ('sys_' || gen_random_uuid(), now(), now(), 'customer_management', 'taxonomy_white', NULL, '{}'),
+          ('sys_' || gen_random_uuid(), now(), now(), 'internal_operations', 'taxonomy_white', NULL, '{}'),
+          ('sys_' || gen_random_uuid(), now(), now(), 'legal_compliance', 'taxonomy_white', NULL, '{}'),
+          ('sys_' || gen_random_uuid(), now(), now(), 'marketing', 'taxonomy_white', NULL, '{}'),
+          ('sys_' || gen_random_uuid(), now(), now(), 'payments_billing', 'taxonomy_white', NULL, '{}'),
+          ('sys_' || gen_random_uuid(), now(), now(), 'product_service_delivery', 'taxonomy_white', NULL, '{}'),
+          ('sys_' || gen_random_uuid(), now(), now(), 'research_development', 'taxonomy_white', NULL, '{}'),
+          ('sys_' || gen_random_uuid(), now(), now(), 'sales_revenue_operations', 'taxonomy_white', NULL, '{}'),
+          ('sys_' || gen_random_uuid(), now(), now(), 'security_fraud', 'taxonomy_white', NULL, '{}')
+        """
+    )
+
+
+def downgrade():
+    # Remove default system groups from both tables
+    op.execute(
+        """
+        DELETE FROM system_group
+        WHERE fides_key IN (
+          'analytics_business_intelligence', 'customer_management', 'internal_operations',
+          'legal_compliance', 'marketing', 'payments_billing', 'product_service_delivery',
+          'research_development', 'sales_revenue_operations', 'security_fraud'
+        )
+        """
+    )
+
+    op.execute(
+        """
+        DELETE FROM taxonomy_element
+        WHERE fides_key IN (
+          'analytics_business_intelligence', 'customer_management', 'internal_operations',
+          'legal_compliance', 'marketing', 'payments_billing', 'product_service_delivery',
+          'research_development', 'sales_revenue_operations', 'security_fraud'
+        ) AND taxonomy_type = 'system_group'
+        """
+    )

fides/api/alembic/migrations/versions/5fa78b1f324d_add_event_audit_table.py

@@ -0,0 +1,82 @@
+"""add event audit table
+
+Revision ID: 5fa78b1f324d
+Revises: fd7571bef683
+Create Date: 2025-09-09 17:51:15.715976
+
+"""
+
+import sqlalchemy as sa
+from alembic import op
+from sqlalchemy.dialects import postgresql
+
+# revision identifiers, used by Alembic.
+revision = "5fa78b1f324d"
+down_revision = "fd7571bef683"
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    op.create_table(
+        "event_audit",
+        sa.Column("id", sa.String(length=255), nullable=False),
+        sa.Column(
+            "created_at",
+            sa.DateTime(timezone=True),
+            server_default=sa.text("now()"),
+            nullable=True,
+        ),
+        sa.Column(
+            "updated_at",
+            sa.DateTime(timezone=True),
+            server_default=sa.text("now()"),
+            nullable=True,
+        ),
+        sa.Column("event_type", sa.String(), nullable=False),
+        sa.Column("user_id", sa.String(), nullable=True),
+        sa.Column("resource_type", sa.String(), nullable=True),
+        sa.Column("resource_identifier", sa.String(), nullable=True),
+        sa.Column("description", sa.Text(), nullable=True),
+        sa.Column(
+            "event_details", postgresql.JSONB(astext_type=sa.Text()), nullable=True
+        ),
+        sa.Column(
+            "status",
+            sa.Enum("succeeded", "failed", name="eventauditstatus"),
+            nullable=False,
+        ),
+        sa.PrimaryKeyConstraint("id"),
+    )
+    op.create_index(
+        op.f("ix_event_audit_event_type"), "event_audit", ["event_type"], unique=False
+    )
+    op.create_index(op.f("ix_event_audit_id"), "event_audit", ["id"], unique=False)
+    op.create_index(
+        op.f("ix_event_audit_resource_identifier"),
+        "event_audit",
+        ["resource_identifier"],
+        unique=False,
+    )
+    op.create_index(
+        op.f("ix_event_audit_resource_type"),
+        "event_audit",
+        ["resource_type"],
+        unique=False,
+    )
+    op.create_index(
+        op.f("ix_event_audit_user_id"), "event_audit", ["user_id"], unique=False
+    )
+    op.create_index(
+        op.f("ix_event_audit_status"), "event_audit", ["status"], unique=False
+    )
+
+
+def downgrade():
+    op.drop_index(op.f("ix_event_audit_status"), table_name="event_audit")
+    op.drop_index(op.f("ix_event_audit_user_id"), table_name="event_audit")
+    op.drop_index(op.f("ix_event_audit_resource_type"), table_name="event_audit")
+    op.drop_index(op.f("ix_event_audit_resource_identifier"), table_name="event_audit")
+    op.drop_index(op.f("ix_event_audit_id"), table_name="event_audit")
+    op.drop_index(op.f("ix_event_audit_event_type"), table_name="event_audit")
+    op.drop_table("event_audit")

fides/api/alembic/migrations/versions/b9bfa12c167b_add_not_applicable_to_asset_consentstatus.py

@@ -0,0 +1,46 @@
+"""Add not_applicable to asset ConsentStatus
+
+Revision ID: b9bfa12c167b
+Revises: 30369bb8ae01
+Create Date: 2025-09-09 16:44:23.146325
+
+"""
+
+import sqlalchemy as sa
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision = "b9bfa12c167b"
+down_revision = "30369bb8ae01"
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.execute("ALTER TYPE consentstatus ADD VALUE 'not_applicable'")
+    # ### end Alembic commands ###
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    # Remove any records that have the new enum value before dropping it
+    op.execute(
+        "UPDATE asset SET consent_status = 'unknown' WHERE consent_status = 'not_applicable'"
+    )
+
+    # Recreate the enum without the new value
+    op.execute("ALTER TYPE consentstatus RENAME TO consentstatus_old")
+    op.execute(
+        "CREATE TYPE consentstatus AS ENUM ('cmp_error', 'pre_consent', 'with_consent', 'without_consent', 'exempt', 'unknown')"
+    )
+
+    # Drop default, change type, and set default back
+    op.execute("ALTER TABLE asset ALTER COLUMN consent_status DROP DEFAULT")
+    op.execute(
+        "ALTER TABLE asset ALTER COLUMN consent_status TYPE consentstatus USING "
+        "consent_status::text::consentstatus"
+    )
+    op.execute("ALTER TABLE asset ALTER COLUMN consent_status SET DEFAULT 'unknown'")
+    op.execute("DROP TYPE consentstatus_old")
+    # ### end Alembic commands ###

fides/api/alembic/migrations/versions/fd7571bef683_adds_new_fields_to_messagingconfig_for_.py

@@ -0,0 +1,31 @@
+"""Adds new fields to MessagingConfig for test info
+
+Revision ID: fd7571bef683
+Revises: b9bfa12c167b
+Create Date: 2024-10-09 23:08:01.901592
+
+"""
+
+import sqlalchemy as sa
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision = "fd7571bef683"
+down_revision = "b9bfa12c167b"
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    op.add_column(
+        "messagingconfig",
+        sa.Column("last_test_timestamp", sa.DateTime(timezone=True), nullable=True),
+    )
+    op.add_column(
+        "messagingconfig", sa.Column("last_test_succeeded", sa.Boolean(), nullable=True)
+    )
+
+
+def downgrade():
+    op.drop_column("messagingconfig", "last_test_succeeded")
+    op.drop_column("messagingconfig", "last_test_timestamp")

fides/api/api/v1/endpoints/messaging_endpoints.py

@@ -1,4 +1,4 @@
-from typing import Dict, List, Optional
+from typing import Any, Dict, List, Optional
 
 from fastapi import Depends, Security
 from fastapi.encoders import jsonable_encoder
@@ -26,6 +26,7 @@ from fides.api.common_exceptions import (
     MessagingConfigNotFoundException,
     MessagingTemplateValidationException,
 )
+from fides.api.models.application_config import ApplicationConfig
 from fides.api.models.messaging import (
     MessagingConfig,
     default_messaging_config_key,
@@ -46,16 +47,16 @@ from fides.api.schemas.messaging.messaging import (
     MessagingConfigResponse,
     MessagingConfigStatus,
     MessagingConfigStatusMessage,
+    MessagingConnectionTestStatus,
     MessagingMethod,
     MessagingServiceType,
     MessagingTemplateDefault,
     MessagingTemplateWithPropertiesDetail,
+    MessagingTestBodyParams,
     TestMessagingStatusMessage,
     UserEmailInviteStatus,
 )
-from fides.api.schemas.messaging.messaging_secrets_docs_only import (
-    possible_messaging_secrets,
-)
+from fides.api.schemas.messaging.shared_schemas import PossibleMessagingSecrets
 from fides.api.schemas.redis_cache import Identity
 from fides.api.service.messaging.message_dispatch_service import dispatch_message
 from fides.api.service.messaging.messaging_crud_service import (
@@ -91,10 +92,14 @@ from fides.common.api.v1.urn_registry import (
     MESSAGING_TEMPLATE_BY_ID,
     MESSAGING_TEMPLATE_DEFAULT_BY_TEMPLATE_TYPE,
     MESSAGING_TEST,
+    MESSAGING_TEST_DEPRECATED,
     V1_URL_PREFIX,
 )
+from fides.config import get_config
 from fides.config.config_proxy import ConfigProxy
 
+CONFIG = get_config()
+
 router = APIRouter(tags=["Messaging"], prefix=V1_URL_PREFIX)
 
 
@@ -107,33 +112,73 @@ router = APIRouter(tags=["Messaging"], prefix=V1_URL_PREFIX)
 def post_config(
     *,
     db: Session = Depends(deps.get_db),
-    messaging_config: MessagingConfigRequest,
+    messaging_config_request: MessagingConfigRequest,
 ) -> MessagingConfigResponse:
     """
     Given a messaging config, create corresponding MessagingConfig object, provided no config already exists
     """
 
     try:
-        return create_or_update_messaging_config(db=db, config=messaging_config)
-    except ValueError as e:
+        # set default values for the name and type if they're not provided
+        if not messaging_config_request.name:
+            messaging_config_request.name = default_messaging_config_name(
+                messaging_config_request.service_type.value
+            )
+        if not messaging_config_request.key:
+            messaging_config_request.key = default_messaging_config_key(
+                messaging_config_request.service_type.value
+            )
+        messaging_config = create_or_update_messaging_config(
+            db=db, config=messaging_config_request
+        )
+        if messaging_config_request.secrets:
+            update_config_secrets(
+                db,
+                messaging_config,
+                unvalidated_messaging_secrets=messaging_config_request.secrets,
+            )
+
+        # if there is only one messaging config, make it the default
+        messaging_config_count = db.query(MessagingConfig).count()
+        if messaging_config_count == 1:
+            ApplicationConfig.update_api_set(
+                db,
+                {
+                    "notifications": {
+                        "notification_service_type": messaging_config.service_type
+                    }
+                },
+            )
+
+        return MessagingConfigResponse(
+            name=messaging_config.name,
+            key=messaging_config.key,
+            service_type=messaging_config.service_type.value,  # type: ignore
+            details=messaging_config.details,
+            last_test_timestamp=messaging_config.last_test_timestamp,
+            last_test_succeeded=messaging_config.last_test_succeeded,
+        )
+    except ValueError as exc:
+        failed_key = messaging_config_request.key
         logger.warning(
             "Create failed for messaging config {}: {}",
-            messaging_config.key,
-            Pii(str(e)),
+            failed_key,
+            str(exc),
         )
         raise HTTPException(
             status_code=HTTP_400_BAD_REQUEST,
-            detail=f"Config with key {messaging_config.key} failed to be added: {e}",
+            detail=f"Config with key {failed_key} failed to be added: {exc}",
         )
     except Exception as exc:
+        failed_key = messaging_config_request.key
         logger.warning(
             "Create failed for messaging config {}: {}",
-            messaging_config.key,
-            Pii(str(exc)),
+            failed_key,
+            str(exc),
         )
         raise HTTPException(
             status_code=HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"Config with key {messaging_config.key} failed to be added: {exc}",
+            detail=f"Config with key {failed_key} failed to be added: {exc}",
         )
 
 
@@ -146,13 +191,23 @@ def patch_config_by_key(
     config_key: FidesKey,
     *,
     db: Session = Depends(deps.get_db),
-    messaging_config: MessagingConfigRequest,
+    messaging_config_request: MessagingConfigRequest,
 ) -> Optional[MessagingConfigResponse]:
     """
     Updates config for messaging by key, provided config with key can be found.
     """
     try:
-        return update_messaging_config(db=db, key=config_key, config=messaging_config)
+        messaging_config = update_messaging_config(
+            db=db, key=config_key, config=messaging_config_request
+        )
+        return MessagingConfigResponse(
+            name=messaging_config.name,
+            key=messaging_config.key,
+            service_type=messaging_config.service_type.value,  # type: ignore
+            details=messaging_config.details,
+            last_test_timestamp=messaging_config.last_test_timestamp,
+            last_test_succeeded=messaging_config.last_test_succeeded,
+        )
     except MessagingConfigNotFoundException:
         logger.warning("No messaging config found with key {}", config_key)
         raise HTTPException(
@@ -162,12 +217,12 @@ def patch_config_by_key(
     except Exception as exc:
         logger.warning(
             "Patch failed for messaging config {}: {}",
-            messaging_config.key,
-            Pii(str(exc)),
+            config_key,
+            str(exc),
         )
         raise HTTPException(
             status_code=HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"Config with key {messaging_config.key} failed to be added",
+            detail=f"Config with key {config_key} failed to be added",
         )
 
 
@@ -294,17 +349,19 @@ def get_messaging_status(
 def put_default_config(
     *,
     db: Session = Depends(deps.get_db),
-    messaging_config: MessagingConfigRequestBase,
+    messaging_config_request: MessagingConfigRequestBase,
 ) -> Optional[MessagingConfigResponse]:
     """
     Updates default messaging config for given service type.
     """
     logger.info(
         "Starting upsert for default messaging config of type '{}'",
-        messaging_config.service_type,
+        messaging_config_request.service_type,
+    )
+    incoming_data = messaging_config_request.model_dump(mode="json")
+    existing_default = MessagingConfig.get_by_type(
+        db, messaging_config_request.service_type
     )
-    incoming_data = messaging_config.model_dump(mode="json")
-    existing_default = MessagingConfig.get_by_type(db, messaging_config.service_type)
     if existing_default:
         # take the key of the existing default and add that to the incoming data, to ensure we overwrite the same record
         incoming_data["key"] = existing_default.key
@@ -312,14 +369,22 @@ def put_default_config(
     else:
         # set a key and name for our config if we're creating a new default
         incoming_data["name"] = default_messaging_config_name(
-            messaging_config.service_type.value
+            messaging_config_request.service_type.value
         )
         incoming_data["key"] = default_messaging_config_key(
-            messaging_config.service_type.value
+            messaging_config_request.service_type.value
         )
-    return create_or_update_messaging_config(
+    messaging_config = create_or_update_messaging_config(
         db, MessagingConfigRequest(**incoming_data)
     )
+    return MessagingConfigResponse(
+        name=messaging_config.name,
+        key=messaging_config.key,
+        service_type=messaging_config.service_type.value,  # type: ignore
+        details=messaging_config.details,
+        last_test_timestamp=messaging_config.last_test_timestamp,
+        last_test_succeeded=messaging_config.last_test_succeeded,
+    )
 
 
 @router.put(
@@ -332,7 +397,7 @@ def put_default_config_secrets(
     service_type: MessagingServiceType,
     *,
     db: Session = Depends(deps.get_db),
-    unvalidated_messaging_secrets: possible_messaging_secrets,
+    unvalidated_messaging_secrets: PossibleMessagingSecrets,
 ) -> TestMessagingStatusMessage:
     messaging_config = MessagingConfig.get_by_type(db, service_type=service_type)
     if not messaging_config:
@@ -353,7 +418,7 @@ def put_config_secrets(
     config_key: FidesKey,
     *,
     db: Session = Depends(deps.get_db),
-    unvalidated_messaging_secrets: possible_messaging_secrets,
+    unvalidated_messaging_secrets: PossibleMessagingSecrets,
 ) -> TestMessagingStatusMessage:
     """
     Add or update secrets for messaging config.
@@ -371,7 +436,7 @@ def put_config_secrets(
 def update_config_secrets(
     db: Session,
     messaging_config: MessagingConfig,
-    unvalidated_messaging_secrets: possible_messaging_secrets,
+    unvalidated_messaging_secrets: PossibleMessagingSecrets,
 ) -> TestMessagingStatusMessage:
     try:
         secrets_schema = get_schema_for_secrets(
@@ -512,11 +577,70 @@ def delete_config_by_key(
     },
 )
 def send_test_message(
+    service_type: MessagingServiceType,
+    *,
+    db: Session = Depends(deps.get_db),
+    params: MessagingTestBodyParams,
+) -> Dict[str, str]:
+    """
+    Sends a test message to the provided email or phone number.
+    """
+    config = MessagingConfig.get_by_type(db, service_type)
+    if not config:
+        raise HTTPException(
+            status_code=404,
+            detail=f"No messaging config found with service type: {service_type}",
+        )
+    try:
+        dispatch_message(
+            db,
+            action_type=MessagingActionType.TEST_MESSAGE,
+            to_identity=Identity(
+                email=params.to_identity.email,
+                phone_number=params.to_identity.phone_number,
+            ),
+            service_type=service_type.value,
+        )
+    except MessageDispatchException as exc:
+        config.update_test_status(
+            test_status=MessagingConnectionTestStatus.failed, db=db
+        )
+        raise HTTPException(
+            status_code=400,
+            detail=f"There was an error sending the test message: {exc}",
+        )
+    config.update_test_status(
+        test_status=MessagingConnectionTestStatus.succeeded, db=db
+    )
+    return {"details": "Test message successfully sent"}
+
+
+@router.post(
+    MESSAGING_TEST_DEPRECATED,
+    deprecated=True,
+    status_code=HTTP_200_OK,
+    dependencies=[Security(verify_oauth_client, scopes=[MESSAGING_CREATE_OR_UPDATE])],
+    response_model=Dict[str, Any],
+    responses={
+        HTTP_200_OK: {
+            "content": {
+                "application/json": {
+                    "example": {
+                        "details": "Test message successfully sent",
+                    }
+                }
+            }
+        }
+    },
+)
+def send_test_message_deprecated(
     message_info: Identity,
     db: Session = Depends(deps.get_db),
     config_proxy: ConfigProxy = Depends(deps.get_config_proxy),
-) -> Dict[str, str]:
-    """Sends a test message."""
+) -> Dict[str, Any]:
+    """
+    This endpoint is deprecated. Please use the `POST /messaging/test/{service_type}`
+    """
     try:
         dispatch_message(
             db,
@@ -524,11 +648,17 @@ def send_test_message(
             to_identity=message_info,
             service_type=config_proxy.notifications.notification_service_type,
         )
-    except MessageDispatchException as e:
+    except MessageDispatchException as exc:
         raise HTTPException(
-            status_code=400, detail=f"There was an error sending the test message: {e}"
-        )
-    return {"details": "Test message successfully sent"}
+            status_code=400,
+            detail=f"There was an error sending the test message: {exc}",
+        )
+    return {
+        "details": "Test message successfully sent",
+        "warnings": [
+            "This endpoint is deprecated. Please use the `POST /messaging/test/{service_type}`"
+        ],
+    }
 
 
 @router.get(

fides/api/db/base.py

@@ -22,6 +22,7 @@ from fides.api.models.detection_discovery.monitor_task import (
     MonitorTaskExecutionLog,
 )
 from fides.api.models.detection_discovery.web_monitor import WebMonitorGroupJob
+from fides.api.models.event_audit import EventAudit
 from fides.api.models.experience_notices import ExperienceNotices
 from fides.api.models.fides_cloud import FidesCloud
 from fides.api.models.fides_user import FidesUser

fides/api/db/seed.py

@@ -2,6 +2,7 @@
 Provides functions that seed the application with data.
 """
 
+import os
 from typing import Dict, List, Optional
 
 from fideslang.default_taxonomy import DEFAULT_TAXONOMY
@@ -17,6 +18,7 @@ from fides.api.common_exceptions import KeyOrNameAlreadyExists
 from fides.api.db.base_class import FidesBase
 from fides.api.db.ctl_session import sync_session
 from fides.api.db.system import upsert_system
+from fides.api.models.application_config import ApplicationConfig
 from fides.api.models.client import ClientDetail
 from fides.api.models.connectionconfig import ConnectionConfig
 from fides.api.models.datasetconfig import DatasetConfig
@@ -37,7 +39,16 @@ from fides.api.schemas.connection_configuration.saas_config_template_values impo
     SaasConnectionTemplateValues,
 )
 from fides.api.schemas.dataset import DatasetConfigCtlDataset
+from fides.api.schemas.messaging.messaging import (
+    MessagingConfigRequest,
+    MessagingServiceDetailsMailgun,
+    MessagingServiceType,
+)
+from fides.api.schemas.messaging.shared_schemas import MessagingSecretsMailgunDocs
 from fides.api.schemas.policy import ActionType, DrpAction
+from fides.api.service.messaging.messaging_crud_service import (
+    create_or_update_messaging_config,
+)
 from fides.api.util.connection_util import patch_connection_configs
 from fides.api.util.data_category import get_user_data_categories
 from fides.api.util.errors import AlreadyExistsError, QueryError
@@ -486,6 +497,29 @@ async def load_samples(async_session: AsyncSession) -> None:
     except QueryError:  # pragma: no cover
         pass  # The upsert_resources function will log any error
 
+    if os.getenv("MAILGUN_DOMAIN") and os.getenv("MAILGUN_API_KEY"):
+        log.info("Loading Mailgun messaging config")
+        with sync_session() as db:
+            messaging_config = create_or_update_messaging_config(
+                db=db,
+                config=MessagingConfigRequest(
+                    key="my_mailgun_config",
+                    name="Mailgun",
+                    service_type=MessagingServiceType.mailgun,
+                    details=MessagingServiceDetailsMailgun(
+                        domain=os.getenv("MAILGUN_DOMAIN")
+                    ),
+                ),
+            )
+            messaging_config.set_secrets(
+                db=db,
+                messaging_secrets=MessagingSecretsMailgunDocs(
+                    mailgun_api_key=os.getenv("MAILGUN_API_KEY")
+                ),
+            )
+            CONFIG.notifications.notification_service_type = "mailgun"
+            ApplicationConfig.update_config_set(db, CONFIG)
+
 
 def load_default_organization(db: Session) -> None:
     """

fides/api/models/asset.py

@@ -34,6 +34,7 @@ class ConsentStatus(str, Enum):
     with_consent = "with_consent"
     without_consent = "without_consent"
     exempt = "exempt"
+    not_applicable = "not_applicable"
     unknown = "unknown"