Ropa Tool Integration

import requests

ONETRUST_BASE_URL = "https://helix-biotech.my.onetrust.com/api"
CLIENT_ID = "helix-ropa-integration"
CLIENT_SECRET_ENV = "ONETRUST_CLIENT_SECRET"  # Stored in vault

def get_access_token(client_id: str, client_secret: str) -> str:
    """Obtain OAuth 2.0 access token from OneTrust."""
    response = requests.post(
        f"{ONETRUST_BASE_URL}/auth/oauth/token",
        data={
            "grant_type": "client_credentials",
            "client_id": client_id,
            "client_secret": client_secret,
        },
        headers={"Content-Type": "application/x-www-form-urlencoded"},
    )
    response.raise_for_status()
    return response.json()["access_token"]

def get_processing_activities(token: str, page: int = 0, size: int = 50) -> dict:
    """Retrieve processing activities from OneTrust Data Mapping."""
    response = requests.get(
        f"{ONETRUST_BASE_URL}/datasubject/v3/processingactivities",
        headers={"Authorization": f"Bearer {token}"},
        params={"page": page, "size": size},
    )
    response.raise_for_status()
    return response.json()

def create_processing_activity(token: str, activity: dict) -> dict:
    """Create a new processing activity record in OneTrust."""
    payload = {
        "name": activity["processing_activity"],
        "description": activity.get("description", ""),
        "organizationId": activity["organization_id"],
        "purposes": [
            {"name": p, "legalBasis": activity.get("lawful_basis", "")}
            for p in activity.get("purposes", [])
        ],
        "dataSubjectCategories": [
            {"name": c} for c in activity.get("data_subject_categories", [])
        ],
        "dataElementCategories": [
            {"name": c} for c in activity.get("personal_data_categories", [])
        ],
        "retentionPeriod": activity.get("retention_periods", ""),
        "securityMeasures": activity.get("security_measures", ""),
    }
    response = requests.post(
        f"{ONETRUST_BASE_URL}/datasubject/v3/processingactivities",
        headers={
            "Authorization": f"Bearer {token}",
            "Content-Type": "application/json",
        },
        json=payload,
    )
    response.raise_for_status()
    return response.json()

TRUSTARC_BASE_URL = "https://api.trustarc.com/v1"

def get_processing_records(api_key: str, organization_id: str) -> dict:
    """Retrieve RoPA records from TrustArc PrivacyOps."""
    response = requests.get(
        f"{TRUSTARC_BASE_URL}/organizations/{organization_id}/processing-records",
        headers={
            "Authorization": f"Bearer {api_key}",
            "Accept": "application/json",
        },
    )
    response.raise_for_status()
    return response.json()


def create_assessment(api_key: str, organization_id: str, assessment: dict) -> dict:
    """Create a new processing activity assessment in TrustArc."""
    payload = {
        "name": assessment["name"],
        "type": "PROCESSING_ACTIVITY",
        "templateId": assessment.get("template_id", "art30-controller"),
        "assignee": assessment.get("owner_email"),
        "responses": {
            "purposes": assessment.get("purposes", []),
            "dataSubjects": assessment.get("data_subject_categories", []),
            "dataCategories": assessment.get("personal_data_categories", []),
            "recipients": assessment.get("recipient_categories", []),
            "transfers": assessment.get("international_transfers", []),
            "retention": assessment.get("retention_periods", ""),
            "securityMeasures": assessment.get("security_measures", ""),
        },
    }
    response = requests.post(
        f"{TRUSTARC_BASE_URL}/organizations/{organization_id}/assessments",
        headers={
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json",
        },
        json=payload,
    )
    response.raise_for_status()
    return response.json()

COLLIBRA_BASE_URL = "https://helix-biotech.collibra.com/rest/2.0"

def get_processing_activities(token: str) -> dict:
    """Retrieve processing activity assets from Collibra."""
    response = requests.get(
        f"{COLLIBRA_BASE_URL}/assets",
        headers={"Authorization": f"Bearer {token}"},
        params={
            "typeId": "processing-activity-type-id",
            "limit": 100,
            "offset": 0,
        },
    )
    response.raise_for_status()
    return response.json()


def create_processing_activity_asset(token: str, activity: dict) -> dict:
    """Create a processing activity asset in Collibra."""
    payload = {
        "name": activity["name"],
        "typeId": "processing-activity-type-id",
        "domainId": activity["domain_id"],
        "statusId": "draft-status-id",
    }
    response = requests.post(
        f"{COLLIBRA_BASE_URL}/assets",
        headers={
            "Authorization": f"Bearer {token}",
            "Content-Type": "application/json",
        },
        json=payload,
    )
    response.raise_for_status()
    asset_id = response.json()["id"]

    # Add attributes for each Art. 30(1) field
    attributes = [
        {"typeId": "purpose-attr-id", "value": "; ".join(activity.get("purposes", []))},
        {"typeId": "retention-attr-id", "value": activity.get("retention_periods", "")},
        {"typeId": "security-measures-attr-id", "value": activity.get("security_measures", "")},
    ]
    for attr in attributes:
        attr["assetId"] = asset_id
        requests.post(
            f"{COLLIBRA_BASE_URL}/attributes",
            headers={
                "Authorization": f"Bearer {token}",
                "Content-Type": "application/json",
            },
            json=attr,
        )

    return {"asset_id": asset_id, "name": activity["name"]}