ethyca-fides 2.69.3b0__py2.py3-none-any.whl → 2.69.3b2__py2.py3-none-any.whl

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/api/v1/endpoints/system.py

@@ -1,29 +1,27 @@
-import datetime
 from typing import Annotated, Dict, List, Optional, Union
 
 from fastapi import Depends, HTTPException, Query, Response, Security
 from fastapi_pagination import Page, Params
 from fastapi_pagination.bases import AbstractPage
-from fastapi_pagination.ext.async_sqlalchemy import paginate as async_paginate
 from fastapi_pagination.ext.sqlalchemy import paginate
 from fideslang.models import System as SystemSchema
 from fideslang.validation import FidesKey
 from loguru import logger
 from pydantic import Field
-from sqlalchemy import or_
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.future import select
 from sqlalchemy.orm import Session
 from starlette import status
-from starlette.status import HTTP_200_OK, HTTP_204_NO_CONTENT, HTTP_404_NOT_FOUND
+from starlette.status import (
+    HTTP_200_OK,
+    HTTP_204_NO_CONTENT,
+    HTTP_400_BAD_REQUEST,
+    HTTP_404_NOT_FOUND,
+)
 
 from fides.api.api import deps
 from fides.api.api.v1.endpoints.saas_config_endpoints import instantiate_connection
-from fides.api.db.crud import (
-    get_resource,
-    get_resource_with_custom_fields,
-    list_resource,
-)
+from fides.api.db.crud import get_resource, get_resource_with_custom_fields
 from fides.api.db.ctl_session import get_async_db
 from fides.api.db.system import (
     create_system,
@@ -34,10 +32,8 @@ from fides.api.db.system import (
 )
 from fides.api.models.connectionconfig import ConnectionConfig, ConnectionType
 from fides.api.models.fides_user import FidesUser
-from fides.api.models.sql_models import (  # type:ignore[attr-defined]
-    PrivacyDeclaration,
-    System,
-)
+from fides.api.models.sql_models import System  # type:ignore[attr-defined]
+from fides.api.oauth.roles import APPROVER
 from fides.api.oauth.system_manager_oauth_util import (
     verify_oauth_client_for_system_from_fides_key,
     verify_oauth_client_for_system_from_request_body_cli,
@@ -56,8 +52,12 @@ from fides.api.schemas.connection_configuration.connection_secrets import (
 from fides.api.schemas.connection_configuration.saas_config_template_values import (
     SaasConnectionTemplateValues,
 )
-from fides.api.schemas.filter_params import FilterParams
-from fides.api.schemas.system import BasicSystemResponse, SystemResponse
+from fides.api.schemas.system import (
+    AssignStewardRequest,
+    BasicSystemResponse,
+    SystemResponse,
+)
+from fides.api.service.deps import get_system_service
 from fides.api.util.api_router import APIRouter
 from fides.api.util.connection_util import (
     connection_status,
@@ -66,7 +66,6 @@ from fides.api.util.connection_util import (
     patch_connection_configs,
     validate_secrets,
 )
-from fides.api.util.filter_utils import apply_filters_to_query
 from fides.common.api.scope_registry import (
     CONNECTION_CREATE_OR_UPDATE,
     CONNECTION_DELETE,
@@ -82,6 +81,7 @@ from fides.common.api.v1.urn_registry import (
     SYSTEM_CONNECTIONS,
     V1_URL_PREFIX,
 )
+from fides.service.system.system_service import SystemService
 
 SYSTEM_ROUTER = APIRouter(tags=["System"], prefix=f"{V1_URL_PREFIX}/system")
 SYSTEM_CONNECTIONS_ROUTER = APIRouter(
@@ -349,6 +349,123 @@ async def delete(
     }
 
 
+@SYSTEM_ROUTER.post(
+    "/bulk-delete",
+    dependencies=[
+        Security(
+            verify_oauth_client_prod,
+            scopes=[SYSTEM_DELETE],
+        )
+    ],
+    status_code=status.HTTP_200_OK,
+)
+async def system_bulk_delete(
+    fides_keys: List[str],
+    db: AsyncSession = Depends(get_async_db),
+) -> Dict:
+    """Delete multiple systems by their fides_keys."""
+
+    deleted: List[Dict] = []
+
+    async with db.begin():
+        # Retrieve all systems within the same transactional context
+        stmt = select(System).filter(System.fides_key.in_(fides_keys))
+        result = await db.execute(stmt)
+        systems_to_delete = result.scalars().all()
+
+        for system in systems_to_delete:
+            await db.delete(system)
+            deleted.append(SystemSchema.model_validate(system).model_dump(mode="json"))
+
+    return {
+        "message": f"Deleted {len(deleted)} system(s)",
+        "deleted": deleted,
+    }
+
+
+@SYSTEM_ROUTER.post(
+    "/assign-steward",
+    dependencies=[
+        Security(
+            verify_oauth_client_prod,
+            scopes=[SYSTEM_UPDATE],
+        )
+    ],
+)
+async def bulk_assign_steward(
+    data: AssignStewardRequest,
+    db: Session = Depends(deps.get_db),
+) -> Dict:
+    """Assign the given `data_steward` (username) as a system manager for the list of `system_keys`.
+
+    This mirrors the behavior of the user permissions endpoint that assigns systems to a given user but
+    from the perspective of the System API. It validates that:
+
+    1. The provided user exists.
+    2. The user already has permissions (cannot be None).
+    3. The user is not an approver (approvers are explicitly disallowed from being system managers).
+    4. All provided `system_keys` resolve to existing System records.
+    5. There are no duplicate keys in the payload.
+    """
+
+    data_steward = data.data_steward
+    system_keys = data.system_keys
+
+    user: Optional[FidesUser] = FidesUser.get_by(
+        db, field="username", value=data_steward
+    )
+    if not user:
+        raise HTTPException(
+            status_code=HTTP_404_NOT_FOUND,
+            detail=f"No user found with username {data_steward}.",
+        )
+
+    # Validate user has permissions assigned
+    if not (user.permissions and user.permissions.roles):  # type: ignore[attr-defined]
+        raise HTTPException(
+            status_code=HTTP_400_BAD_REQUEST,
+            detail=f"User {data_steward} needs permissions before they can be assigned as system manager.",
+        )
+
+    # Approvers are not allowed to be system managers
+    if APPROVER in user.permissions.roles:  # type: ignore[attr-defined]
+        raise HTTPException(
+            status_code=HTTP_400_BAD_REQUEST,
+            detail=f"User {data_steward} is an {APPROVER} and cannot be assigned as a system manager.",
+        )
+
+    # Check for duplicate system keys
+    if len(set(system_keys)) != len(system_keys):
+        raise HTTPException(
+            status_code=HTTP_400_BAD_REQUEST,
+            detail=f"Cannot add user {data_steward} as system manager. Duplicate systems in request body.",
+        )
+
+    # Retrieve systems and validate existence
+    systems_query = db.query(System).filter(System.fides_key.in_(system_keys))
+    if systems_query.count() != len(system_keys):
+        raise HTTPException(
+            status_code=HTTP_404_NOT_FOUND,
+            detail=f"Cannot add user {data_steward} as system manager. System(s) not found.",
+        )
+
+    systems = systems_query.all()
+
+    logger.info(
+        "Assigning user {} as data steward for {} systems", data_steward, len(systems)
+    )
+
+    updated_count = 0
+    for system in systems:
+        if user not in system.data_stewards:
+            user.set_as_system_manager(db, system)
+            updated_count += 1
+
+    return {
+        "message": f"User {data_steward} assigned as data steward to {updated_count} system(s)",
+    }
+
+
 @SYSTEM_ROUTER.post(
     "/",
     response_model=SystemResponse,
@@ -384,62 +501,30 @@ async def create(
     name="List systems (optionally paginated)",
 )
 async def ls(  # pylint: disable=invalid-name
-    db: AsyncSession = Depends(get_async_db),
+    system_service: SystemService = Depends(get_system_service),
     size: Optional[int] = Query(None, ge=1, le=100),
     page: Optional[int] = Query(None, ge=1),
     search: Optional[str] = None,
     data_uses: Optional[List[FidesKey]] = Query(None),
     data_categories: Optional[List[FidesKey]] = Query(None),
     data_subjects: Optional[List[FidesKey]] = Query(None),
-    show_deleted: Optional[bool] = Query(False),
-) -> List:
+    show_deleted: bool = Query(False),
+) -> Union[List[System], Page[System]]:
     """Get a list of all of the Systems.
     If any parameters or filters are provided the response will be paginated and/or filtered.
     Otherwise all Systems will be returned (this may be a slow operation if there are many systems,
     so using the pagination parameters is recommended).
     """
-    if not (size or page or search or data_uses or data_categories or data_subjects):
-        # if no advanced parameters are passed, we return a very basic list of all System resources
-        # to maintain backward compatibility of the original API, which backs some important client usages, e.g. the fides CLI
 
-        return await list_resource(System, db)
-
-    query = select(System)
-
-    pagination_params = Params(page=page or 1, size=size or 50)
-    # Need to join with PrivacyDeclaration in order to be able to filter
-    # by data use, data category, and data subject
-    if any([data_uses, data_categories, data_subjects]):
-        query = query.outerjoin(
-            PrivacyDeclaration, System.id == PrivacyDeclaration.system_id
-        )
-
-    # Filter out any vendor deleted systems, unless explicitly asked for
-    if not show_deleted:
-        query = query.filter(
-            or_(
-                System.vendor_deleted_date.is_(None),
-                System.vendor_deleted_date >= datetime.datetime.now(),
-            )
-        )
-
-    filter_params = FilterParams(
+    return await system_service.get_systems(
         search=search,
         data_uses=data_uses,
         data_categories=data_categories,
         data_subjects=data_subjects,
+        size=size,
+        page=page,
+        show_deleted=show_deleted,
     )
-    filtered_query = apply_filters_to_query(
-        query=query,
-        filter_params=filter_params,
-        search_model=System,
-        taxonomy_model=PrivacyDeclaration,
-    )
-
-    # Add a distinct so we only get one row per system
-    duplicates_removed = filtered_query.distinct(System.id)
-
-    return await async_paginate(db, duplicates_removed, pagination_params)
 
 
 @SYSTEM_ROUTER.patch(

fides/api/db/base.py

@@ -21,6 +21,8 @@ from fides.api.models.detection_discovery.monitor_task import (
     MonitorTask,
     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
@@ -77,6 +79,7 @@ from fides.api.models.property import (
 from fides.api.models.registration import UserRegistration
 from fides.api.models.storage import StorageConfig
 from fides.api.models.system_compass_sync import SystemCompassSync
+from fides.api.models.system_group import SystemGroup, SystemGroupMember
 from fides.api.models.system_history import SystemHistory
 from fides.api.models.system_manager import SystemManager
 from fides.api.models.taxonomy import (

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:
     """