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

fides/api/api/v1/endpoints/privacy_request_endpoints.py

@@ -4,7 +4,7 @@ import csv
 import io
 import json
 from collections import defaultdict
-from datetime import datetime, timezone
+from datetime import datetime, timedelta, timezone
 from typing import (
     Annotated,
     Any,
@@ -29,7 +29,7 @@ from loguru import logger
 from pydantic import Field
 from pydantic import ValidationError as PydanticValidationError
 from sqlalchemy import cast, column, null, or_, select
-from sqlalchemy.orm import Query, Session
+from sqlalchemy.orm import Query, Session, selectinload
 from sqlalchemy.sql.expression import nullslast
 from starlette.responses import StreamingResponse
 from starlette.status import (
@@ -88,9 +88,11 @@ from fides.api.schemas.dataset import CollectionAddressResponse, DryRunDatasetRe
 from fides.api.schemas.external_https import PrivacyRequestResumeFormat
 from fides.api.schemas.policy import ActionType, CurrentStep
 from fides.api.schemas.privacy_request import (
+    BULK_PRIVACY_REQUEST_BATCH_SIZE,
     BulkPostPrivacyRequests,
     BulkReviewResponse,
     BulkSoftDeletePrivacyRequests,
+    CancelPrivacyRequests,
     CheckpointActionRequired,
     DenyPrivacyRequests,
     ExecutionLogDetailResponse,
@@ -144,8 +146,10 @@ from fides.common.api.v1.urn_registry import (
     PRIVACY_REQUEST_APPROVE,
     PRIVACY_REQUEST_AUTHENTICATED,
     PRIVACY_REQUEST_BATCH_EMAIL_SEND,
+    PRIVACY_REQUEST_BULK_FINALIZE,
     PRIVACY_REQUEST_BULK_RETRY,
     PRIVACY_REQUEST_BULK_SOFT_DELETE,
+    PRIVACY_REQUEST_CANCEL,
     PRIVACY_REQUEST_DENY,
     PRIVACY_REQUEST_FILTERED_RESULTS,
     PRIVACY_REQUEST_FINALIZE,
@@ -222,7 +226,9 @@ def create_privacy_request(
     privacy_request_service: PrivacyRequestService = Depends(
         get_privacy_request_service
     ),
-    data: Annotated[List[PrivacyRequestCreate], Field(max_length=50)],  # type: ignore
+    data: Annotated[
+        List[PrivacyRequestCreate], Field(max_length=BULK_PRIVACY_REQUEST_BATCH_SIZE)
+    ],  # type: ignore
 ) -> BulkPostPrivacyRequests:
     """
     Given a list of privacy request data elements, create corresponding PrivacyRequest objects
@@ -248,7 +254,9 @@ def create_privacy_request_authenticated(
         verify_oauth_client,
         scopes=[PRIVACY_REQUEST_CREATE],
     ),
-    data: Annotated[List[PrivacyRequestCreate], Field(max_length=50)],  # type: ignore
+    data: Annotated[
+        List[PrivacyRequestCreate], Field(max_length=BULK_PRIVACY_REQUEST_BATCH_SIZE)
+    ],  # type: ignore
 ) -> BulkPostPrivacyRequests:
     """
     Given a list of privacy request data elements, create corresponding PrivacyRequest objects
@@ -269,48 +277,73 @@ def privacy_request_csv_download(
     f = io.StringIO()
     csv_file = csv.writer(f)
 
+    # Execute query once and convert to list to avoid multiple iterations
+    privacy_requests: List[PrivacyRequest] = privacy_request_query.all()
+    privacy_request_ids: List[str] = [r.id for r in privacy_requests]
+
+    denial_audit_log_query: Query = db.query(AuditLog).filter(
+        AuditLog.action == AuditLogAction.denied,
+        AuditLog.privacy_request_id.in_(privacy_request_ids),
+    )
+    denial_audit_logs: Dict[str, str] = {
+        r.privacy_request_id: r.message for r in denial_audit_log_query
+    }
+
+    identity_columns, custom_field_columns = get_variable_columns(privacy_requests)
+
     csv_file.writerow(
         [
             "Status",
             "Request Type",
-            "Subject Identity",
-            "Custom Privacy Request Fields",
             "Time Received",
+            "Deadline",
             "Reviewed By",
             "Request ID",
             "Time Approved/Denied",
             "Denial Reason",
+            "Last Updated",
+            "Completed On",
         ]
+        + identity_columns
+        + with_prefix("Custom Field", list(custom_field_columns.values()))
     )
-    privacy_request_ids: List[str] = [r.id for r in privacy_request_query]
-    denial_audit_log_query: Query = db.query(AuditLog).filter(
-        AuditLog.action == AuditLogAction.denied,
-        AuditLog.privacy_request_id.in_(privacy_request_ids),
-    )
-    denial_audit_logs: Dict[str, str] = {
-        r.privacy_request_id: r.message for r in denial_audit_log_query
-    }
 
-    for pr in privacy_request_query:
+    pr: PrivacyRequest
+    for pr in privacy_requests:
         denial_reason = (
             denial_audit_logs[pr.id]
             if pr.status == PrivacyRequestStatus.denied and pr.id in denial_audit_logs
             else None
         )
 
-        csv_file.writerow(
-            [
-                pr.status.value if pr.status else None,
-                pr.policy.rules[0].action_type if len(pr.policy.rules) > 0 else None,
-                pr.get_persisted_identity().model_dump(mode="json"),
-                pr.get_persisted_custom_privacy_request_fields(),
-                pr.created_at,
-                pr.reviewed_by,
-                pr.id,
-                pr.reviewed_at,
-                denial_reason,
-            ]
-        )
+        action_types: List[str] = []
+        if pr and pr.policy:
+            for rule in pr.policy.rules or []:  # type: ignore
+                action_types.append(rule.action_type)
+
+        deadline: Optional[datetime] = None
+        if pr.days_left and pr.created_at:
+            deadline = pr.created_at + timedelta(days=pr.days_left)
+
+        static_cells = [
+            pr.status.value if pr.status else None,
+            ("+".join(action_types)),
+            pr.created_at,
+            deadline,
+            pr.reviewed_by,
+            pr.id,
+            pr.reviewed_at,
+            denial_reason,
+            pr.updated_at,
+            pr.finalized_at,
+        ]
+
+        identity_cells = extract_identity_cells(identity_columns, pr)
+        custom_field_cells = extract_custom_field_cells(custom_field_columns, pr)
+
+        row = static_cells + identity_cells + custom_field_cells
+
+        csv_file.writerow(row)
 
     f.seek(0)
     response = StreamingResponse(f, media_type="text/csv")
@@ -320,6 +353,64 @@ def privacy_request_csv_download(
     return response
 
 
+def get_variable_columns(
+    privacy_requests: List[PrivacyRequest],
+) -> tuple[List[str], Dict[str, str]]:
+    identity_columns: Set[str] = set()
+    custom_field_columns: Dict[str, str] = {}
+
+    for pr in privacy_requests:
+        identity_columns.update(
+            extract_identity_column_names(pr.get_persisted_identity().model_dump())
+        )
+        custom_field_columns.update(
+            extract_custom_field_column_names(
+                pr.get_persisted_custom_privacy_request_fields()
+            )
+        )
+
+    return list(identity_columns), custom_field_columns
+
+
+def extract_identity_column_names(identities: dict[str, Any]) -> Set[str]:
+    """Extract column names from identity data that have non-empty values."""
+    return {key for key, value in identities.items() if value}
+
+
+def extract_custom_field_column_names(custom_fields: dict[str, Any]) -> Dict[str, str]:
+    """Extract column names and labels from custom field data that have non-empty values."""
+    return {
+        key: value["label"]
+        for key, value in custom_fields.items()
+        if value.get("value")
+    }
+
+
+def with_prefix(prefix: str, items: List[str]) -> List[str]:
+    return [f"{prefix} {item}" for item in items]
+
+
+def extract_custom_field_cells(
+    custom_field_columns: Dict[str, str], pr: PrivacyRequest
+) -> List[str]:
+    custom_fields = pr.get_persisted_custom_privacy_request_fields()
+    return [
+        custom_fields.get(custom_field_column, {}).get("value")
+        for custom_field_column in custom_field_columns
+    ]
+
+
+def extract_identity_cells(
+    identity_columns: List[str], pr: PrivacyRequest
+) -> List[str]:
+    identity = pr.get_persisted_identity()
+    identity_dict = identity.model_dump()
+    return [
+        identity_dict.get(identity_column)  # type: ignore
+        for identity_column in identity_columns
+    ]
+
+
 def execution_and_audit_logs_by_dataset_name(
     self: PrivacyRequest,
 ) -> DefaultDict[str, List[Union["AuditLog", "ExecutionLog"]]]:
@@ -405,7 +496,7 @@ def _filter_privacy_request_queryset(
     errored_gt: Optional[datetime] = None,
     external_id: Optional[str] = None,
     location: Optional[str] = None,
-    action_type: Optional[ActionType] = None,
+    action_type: Optional[Union[ActionType, List[ActionType]]] = None,
     include_consent_webhook_requests: Optional[bool] = False,
     include_deleted_requests: Optional[bool] = False,
 ) -> Query:
@@ -595,9 +686,11 @@ def _filter_privacy_request_queryset(
             PrivacyRequest.finished_processing_at > errored_gt,
         )
     if action_type:
+        if isinstance(action_type, ActionType):
+            action_type = [action_type]
         policy_ids_for_action_type = (
             db.query(Rule)
-            .filter(Rule.action_type == action_type)
+            .filter(Rule.action_type.in_(action_type))
             .with_entities(Rule.policy_id)
             .distinct()
         )
@@ -711,7 +804,7 @@ def _shared_privacy_request_search(
     errored_gt: Optional[datetime] = None,
     external_id: Optional[str] = None,
     location: Optional[str] = None,
-    action_type: Optional[ActionType] = None,
+    action_type: Optional[Union[ActionType, List[ActionType]]] = None,
     verbose: Optional[bool] = False,
     include_identities: Optional[bool] = False,
     include_custom_privacy_request_fields: Optional[bool] = False,
@@ -730,7 +823,8 @@ def _shared_privacy_request_search(
 
     logger.debug("Finding all request statuses with pagination params {}", params)
 
-    query = db.query(PrivacyRequest)
+    # Use query_without_large_columns to prevent OOM errors when loading many privacy requests
+    query = PrivacyRequest.query_without_large_columns(db)
     query = _filter_privacy_request_queryset(
         db,
         query,
@@ -762,10 +856,29 @@ def _shared_privacy_request_search(
 
     if download_csv:
         _validate_result_size(query)
+        # Eager load relationships needed for CSV export to avoid N+1 queries
+        query = query.options(
+            selectinload(PrivacyRequest.provided_identities),  # type: ignore[attr-defined]
+            selectinload(PrivacyRequest.custom_fields),  # type: ignore[attr-defined]
+            selectinload(PrivacyRequest.policy).selectinload(Policy.rules),  # type: ignore[attr-defined]
+        )
         # Returning here if download_csv param was specified
         logger.info("Downloading privacy requests as csv")
         return privacy_request_csv_download(db, query)
 
+    # Eager load relationships for regular list view to avoid N+1 queries
+    if include_identities or include_custom_privacy_request_fields:
+        eager_load_options = []
+        if include_identities:
+            eager_load_options.append(
+                selectinload(PrivacyRequest.provided_identities)  # type: ignore[attr-defined]
+            )
+        if include_custom_privacy_request_fields:
+            eager_load_options.append(
+                selectinload(PrivacyRequest.custom_fields)  # type: ignore[attr-defined]
+            )
+        query = query.options(*eager_load_options)
+
     # Conditionally embed execution log details in the response.
     if verbose:
         logger.info("Finding execution and audit log details")
@@ -1202,15 +1315,26 @@ def validate_manual_input(
     ],
 )
 def bulk_restart_privacy_request_from_failure(
-    privacy_request_ids: List[str],
+    privacy_request_ids: Annotated[
+        List[str], Field(max_length=BULK_PRIVACY_REQUEST_BATCH_SIZE)
+    ],
     *,
     db: Session = Depends(deps.get_db),
 ) -> BulkPostPrivacyRequests:
-    """Bulk restart a of privacy request from failure."""
+    """Bulk restart privacy requests from failure."""
     succeeded: List[PrivacyRequestResponse] = []
     failed: List[Dict[str, Any]] = []
+
+    # Fetch all privacy requests in one query to avoid N+1
+    privacy_requests_dict = {
+        pr.id: pr
+        for pr in PrivacyRequest.query_without_large_columns(db)
+        .filter(PrivacyRequest.id.in_(privacy_request_ids))
+        .all()
+    }
+
     for privacy_request_id in privacy_request_ids:
-        privacy_request = PrivacyRequest.get(db, object_id=privacy_request_id)
+        privacy_request = privacy_requests_dict.get(privacy_request_id)
 
         if not privacy_request:
             failed.append(
@@ -1276,10 +1400,10 @@ def restart_privacy_request_from_failure(
     )
 
     # Automatically resubmit the request if the cache has expired
+
     if (
-        not privacy_request.get_cached_identity_data()
-        and privacy_request.status
-        not in [PrivacyRequestStatus.complete, PrivacyRequestStatus.pending]
+        not privacy_request.verify_cache_for_identity_data()
+        and privacy_request.status != PrivacyRequestStatus.complete
     ):
         logger.info(
             f"Cached data for privacy request {privacy_request.id} has expired, automatically resubmitting request"
@@ -1396,10 +1520,37 @@ def deny_privacy_request(
     )
 
 
+@router.patch(
+    PRIVACY_REQUEST_CANCEL,
+    status_code=HTTP_200_OK,
+    response_model=BulkReviewResponse,
+)
+def cancel_privacy_request(
+    *,
+    client: ClientDetail = Security(
+        verify_oauth_client,
+        scopes=[PRIVACY_REQUEST_REVIEW],
+    ),
+    privacy_request_service: PrivacyRequestService = Depends(
+        get_privacy_request_service
+    ),
+    privacy_requests: CancelPrivacyRequests,
+) -> BulkReviewResponse:
+    """Cancel a list of privacy requests and/or report failure"""
+
+    return privacy_request_service.cancel_privacy_requests(
+        privacy_requests.request_ids, privacy_requests.reason, user_id=client.user_id
+    )
+
+
 def _validate_privacy_request_pending_or_error(
     db: Session, privacy_request_id: str
 ) -> None:
-    privacy_request = PrivacyRequest.get(db, object_id=privacy_request_id)
+    privacy_request = (
+        PrivacyRequest.query_without_large_columns(db)
+        .filter(PrivacyRequest.id == privacy_request_id)
+        .first()
+    )
     if not privacy_request:
         raise HTTPException(
             status_code=HTTP_404_NOT_FOUND,
@@ -1667,17 +1818,15 @@ def privacy_request_data_transfer(
             detail=f"Rule key {rule_key} not found",
         )
 
-    value_dict: Dict[str, Optional[List[Row]]] = cache.get_encoded_objects_by_prefix(
-        f"{privacy_request_id}__access_request"
+    access_result: Dict[str, Optional[List[Row]]] = (
+        privacy_request.get_raw_access_results()
     )
 
-    if not value_dict:
+    if not access_result:
         raise HTTPException(
             status_code=HTTP_404_NOT_FOUND,
             detail=f"No access request information found for privacy request id {privacy_request_id}",
         )
-
-    access_result = {k.split("__")[-1]: v for k, v in value_dict.items()}
     datasets = DatasetConfig.all(db=db)
     if not datasets:
         raise HTTPException(
@@ -1893,6 +2042,32 @@ def resume_privacy_request_from_requires_input(
     return privacy_request  # type: ignore[return-value]
 
 
+@router.post(
+    PRIVACY_REQUEST_BULK_FINALIZE,
+    status_code=HTTP_200_OK,
+    response_model=BulkReviewResponse,
+)
+def bulk_finalize_privacy_requests(
+    *,
+    client: ClientDetail = Security(
+        verify_oauth_client,
+        scopes=[PRIVACY_REQUEST_REVIEW],
+    ),
+    privacy_request_service: PrivacyRequestService = Depends(
+        get_privacy_request_service
+    ),
+    privacy_requests: ReviewPrivacyRequestIds,
+) -> BulkReviewResponse:
+    """
+    Bulk finalize privacy requests that are in requires_manual_finalization status.
+    Each request will be moved from the 'requires_finalization' state to 'complete'.
+    Returns an object with the list of successfully finalized privacy requests and the list of failed finalizations.
+    """
+    return privacy_request_service.finalize_privacy_requests(
+        privacy_requests.request_ids, user_id=client.user_id
+    )
+
+
 @router.post(
     PRIVACY_REQUEST_FINALIZE,
     status_code=HTTP_200_OK,
@@ -2079,8 +2254,18 @@ def bulk_soft_delete_privacy_requests(
     if client.id == CONFIG.security.oauth_root_client_id:
         user_id = "root"
 
-    for privacy_request_id in privacy_requests.request_ids:
-        privacy_request = PrivacyRequest.get(db, object_id=privacy_request_id)
+    request_ids = privacy_requests.request_ids
+
+    # Fetch all privacy requests in one query to avoid N+1
+    privacy_requests_dict = {
+        pr.id: pr
+        for pr in PrivacyRequest.query_without_large_columns(db)
+        .filter(PrivacyRequest.id.in_(request_ids))
+        .all()
+    }
+
+    for privacy_request_id in request_ids:
+        privacy_request = privacy_requests_dict.get(privacy_request_id)
 
         if not privacy_request:
             failed.append(

fides/api/api/v1/endpoints/saas_config_endpoints.py

@@ -1,12 +1,11 @@
-from io import BytesIO
 from typing import Optional
-from zipfile import BadZipFile, ZipFile
 
-from fastapi import Body, Depends, HTTPException, Request
+from fastapi import Depends, HTTPException, Request
+from fastapi.encoders import jsonable_encoder
 from fastapi.params import Security
-from fastapi.responses import JSONResponse
 from fideslang.validation import FidesKey
 from loguru import logger
+from pydantic import ValidationError
 from sqlalchemy.orm import Session
 from starlette.status import (
     HTTP_200_OK,
@@ -18,9 +17,15 @@ from starlette.status import (
 )
 
 from fides.api.api import deps
-from fides.api.common_exceptions import FidesopsException, KeyOrNameAlreadyExists
+from fides.api.common_exceptions import (
+    FidesopsException,
+    KeyOrNameAlreadyExists,
+    SaaSConfigNotFoundException,
+)
+from fides.api.common_exceptions import ValidationError as FidesValidationError
 from fides.api.models.connectionconfig import ConnectionConfig, ConnectionType
 from fides.api.models.datasetconfig import DatasetConfig
+from fides.api.models.event_audit import EventAuditStatus, EventAuditType
 from fides.api.models.sql_models import System  # type: ignore
 from fides.api.oauth.utils import verify_oauth_client
 from fides.api.schemas.connection_configuration.connection_config import (
@@ -29,7 +34,6 @@ from fides.api.schemas.connection_configuration.connection_config import (
 from fides.api.schemas.connection_configuration.saas_config_template_values import (
     SaasConnectionTemplateValues,
 )
-from fides.api.schemas.saas.connector_template import ConnectorTemplate
 from fides.api.schemas.saas.saas_config import (
     SaaSConfig,
     SaaSConfigValidationDetails,
@@ -41,17 +45,11 @@ from fides.api.service.authentication.authentication_strategy import (
 from fides.api.service.authentication.authentication_strategy_oauth2_authorization_code import (
     OAuth2AuthorizationCodeAuthenticationStrategy,
 )
-from fides.api.service.connectors.saas.connector_registry_service import (
-    ConnectorRegistry,
-    CustomConnectorTemplateLoader,
-    create_connection_config_from_template_no_save,
-    upsert_dataset_config_from_template,
-)
 from fides.api.util.api_router import APIRouter
-from fides.api.util.connection_util import validate_secrets
+from fides.api.util.connection_util import validate_secrets_error_message
+from fides.api.util.event_audit_util import generate_connection_audit_event_details
 from fides.common.api.scope_registry import (
     CONNECTION_AUTHORIZE,
-    CONNECTOR_TEMPLATE_REGISTER,
     SAAS_CONFIG_CREATE_OR_UPDATE,
     SAAS_CONFIG_DELETE,
     SAAS_CONFIG_READ,
@@ -59,13 +57,16 @@ from fides.common.api.scope_registry import (
 )
 from fides.common.api.v1.urn_registry import (
     AUTHORIZE,
-    CONNECTION_TYPES,
-    REGISTER_CONNECTOR_TEMPLATE,
     SAAS_CONFIG,
     SAAS_CONFIG_VALIDATE,
     SAAS_CONNECTOR_FROM_TEMPLATE,
     V1_URL_PREFIX,
 )
+from fides.service.connection.connection_service import (
+    ConnectionService,
+    ConnectorTemplateNotFound,
+)
+from fides.service.event_audit_service import EventAuditService
 
 router = APIRouter(tags=["SaaS Configs"], prefix=V1_URL_PREFIX)
 
@@ -168,12 +169,29 @@ def patch_saas_config(
     Given a SaaS config element, update the corresponding ConnectionConfig object
     or report failure
     """
+
     logger.info(
         "Updating SaaS config '{}' on connection config '{}'",
         saas_config.fides_key,
         connection_config.key,
     )
     connection_config.update_saas_config(db, saas_config=saas_config)
+
+    # Create audit event for SaaS config update
+    event_audit_service = EventAuditService(db)
+    event_details, description = generate_connection_audit_event_details(
+        EventAuditType.connection_updated,
+        connection_config=connection_config,
+    )
+    event_audit_service.create_event_audit(
+        event_type=EventAuditType.connection_updated,
+        status=EventAuditStatus.succeeded,
+        resource_type="connection_config",
+        resource_identifier=connection_config.key,
+        description=description,
+        event_details=event_details,
+    )
+
     return connection_config.saas_config  # type: ignore
 
 
@@ -286,11 +304,11 @@ def authorize_connection(
     response_model=SaasConnectionTemplateResponse,
 )
 def instantiate_connection_from_template(
-    saas_connector_type: str,
+    connector_template_type: str,
     template_values: SaasConnectionTemplateValues,
     db: Session = Depends(deps.get_db),
 ) -> SaasConnectionTemplateResponse:
-    return instantiate_connection(db, saas_connector_type, template_values)
+    return instantiate_connection(db, connector_template_type, template_values)
 
 
 def instantiate_connection(
@@ -305,92 +323,45 @@ def instantiate_connection(
     Looks up the connector type in the SaaS connector registry and, if all required
     fields are provided, persists the associated connection config and dataset to the database.
     """
-    connector_template: Optional[ConnectorTemplate] = (
-        ConnectorRegistry.get_connector_template(saas_connector_type)
-    )
-    if not connector_template:
-        raise HTTPException(
-            status_code=HTTP_404_NOT_FOUND,
-            detail=f"SaaS connector type '{saas_connector_type}' is not yet available in Fidesops. For a list of available SaaS connectors, refer to {CONNECTION_TYPES}.",
+    event_audit_service = EventAuditService(db)
+    connection_service = ConnectionService(db, event_audit_service)
+    try:
+        connection_config, dataset_config = connection_service.instantiate_connection(
+            saas_connector_type, template_values, system
         )
-
-    if DatasetConfig.filter(
-        db=db,
-        conditions=(DatasetConfig.fides_key == template_values.instance_key),  # type: ignore[arg-type]
-    ).count():
+    except ConnectorTemplateNotFound as exc:
         raise HTTPException(
-            status_code=HTTP_400_BAD_REQUEST,
-            detail=f"SaaS connector instance key '{template_values.instance_key}' already exists.",
-        )
-
-    try:
-        connection_config: ConnectionConfig = (
-            create_connection_config_from_template_no_save(
-                db, connector_template, template_values
-            )
+            status_code=HTTP_404_NOT_FOUND,
+            detail=f"{exc.args[0]}",
         )
     except KeyOrNameAlreadyExists as exc:
         raise HTTPException(
             status_code=HTTP_400_BAD_REQUEST,
             detail=exc.args[0],
         )
-
-    connection_config.secrets = validate_secrets(
-        db, template_values.secrets, connection_config
-    ).model_dump(mode="json")
-    if system:
-        connection_config.system_id = system.id
-    connection_config.save(db=db)  # Not persisted to db until secrets are validated
-
-    try:
-        dataset_config: DatasetConfig = upsert_dataset_config_from_template(
-            db, connection_config, connector_template, template_values
+    except SaaSConfigNotFoundException:
+        raise HTTPException(
+            status_code=HTTP_422_UNPROCESSABLE_ENTITY,
+            detail=validate_secrets_error_message(),
+        )
+    except FidesValidationError as e:
+        # Check if the exception has the original pydantic errors attached
+        raise HTTPException(status_code=HTTP_422_UNPROCESSABLE_ENTITY, detail=e.message)
+    except ValidationError as e:
+        errors = e.errors(include_url=False, include_input=False)
+        for err in errors:
+            # Additionally, manually remove the context from the error message -
+            # this may contain sensitive information
+            err.pop("ctx", None)
+        raise HTTPException(
+            status_code=HTTP_422_UNPROCESSABLE_ENTITY,
+            detail=jsonable_encoder(errors),
         )
-    except Exception:
-        connection_config.delete(db)
+    except Exception as exc:
         raise HTTPException(
             status_code=HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"SaaS Connector could not be created from the '{saas_connector_type}' template at this time.",
+            detail=f"{exc.args[0]}",
         )
-    logger.info(
-        "SaaS Connector and Dataset {} successfully created from '{}' template.",
-        template_values.instance_key,
-        saas_connector_type,
-    )
-
     return SaasConnectionTemplateResponse(
         connection=connection_config, dataset=dataset_config.ctl_dataset
     )
-
-
-@router.post(
-    REGISTER_CONNECTOR_TEMPLATE,
-    dependencies=[Security(verify_oauth_client, scopes=[CONNECTOR_TEMPLATE_REGISTER])],
-)
-def register_custom_connector_template(
-    file: bytes = Body(..., media_type="application/zip"),
-    db: Session = Depends(deps.get_db),
-) -> JSONResponse:
-    """
-    Registers a custom connector template from a zip file uploaded by the user.
-    The endpoint performs the following steps:
-
-    1. Validates the uploaded file is a proper zip file.
-    2. Uses the CustomConnectorTemplateLoader to validate, register, and save the template to the database.
-
-    If the uploaded file is not a valid zip file or there are any validation errors
-    when creating the ConnectorTemplates an HTTP 400 status code with error details is returned.
-    """
-
-    try:
-        with ZipFile(BytesIO(file), "r") as zip_file:
-            CustomConnectorTemplateLoader.save_template(db=db, zip_file=zip_file)
-    except BadZipFile:
-        raise HTTPException(status_code=400, detail="Invalid zip file")
-    except Exception as exc:
-        logger.exception("Error loading connector template from zip file.")
-        raise HTTPException(status_code=400, detail=str(exc))
-
-    return JSONResponse(
-        content={"message": "Connector template successfully registered."}
-    )