Agent Zero
347 lines
11 KiB
Python
347 lines
11 KiB
Python
"""DSGVO-Betroffenenrechte & Compliance Export (I-DSGVO, I-DSAR, I-COMP-EXPORT).
|
|
|
|
Provides:
|
|
- Full platform data subject access export (JSON/ZIP)
|
|
- Data subject rights workflow (access/correction/erasure/restriction)
|
|
- AI/Compliance evidence export (audit, oversight, approval records)
|
|
|
|
Sensitive/Exposure rules are always respected. No blind auto-delete
|
|
over legal retention obligations.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import logging
|
|
import uuid
|
|
from datetime import UTC, datetime, timedelta
|
|
from typing import Any, Literal
|
|
|
|
from sqlalchemy import select
|
|
from sqlalchemy.ext.asyncio import AsyncSession
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
# ─── I-DSGVO: Platform Data Subject Access Export ───────────────────────────
|
|
|
|
|
|
async def export_user_data(
|
|
db: AsyncSession,
|
|
tenant_id: uuid.UUID,
|
|
user_id: uuid.UUID,
|
|
) -> dict[str, Any]:
|
|
"""Export all personal data for a user across core and active plugins (I-DSGVO).
|
|
|
|
Collects data from: CRM (contacts, companies), Mail, Calendar, DMS,
|
|
Communication/Workstreams, Agents, Workflows, Knowledge, Audit.
|
|
|
|
Returns structured JSON ready for ZIP packaging.
|
|
Sensitive fields are masked per data_policy rules.
|
|
"""
|
|
export: dict[str, Any] = {
|
|
"export_metadata": {
|
|
"exported_at": datetime.now(UTC).isoformat(),
|
|
"tenant_id": str(tenant_id),
|
|
"user_id": str(user_id),
|
|
"export_type": "dsgvo_data_subject_access",
|
|
"version": "1.0",
|
|
},
|
|
"core": {},
|
|
"mail": {},
|
|
"calendar": {},
|
|
"dms": {},
|
|
"communication": {},
|
|
"agents": {},
|
|
"workflows": {},
|
|
"knowledge": {},
|
|
"audit": {},
|
|
}
|
|
|
|
# Core: User profile
|
|
try:
|
|
from app.models.user import User
|
|
user = await db.get(User, user_id)
|
|
if user:
|
|
export["core"]["user"] = {
|
|
"id": str(user.id),
|
|
"email": user.email,
|
|
"full_name": getattr(user, "full_name", None),
|
|
"is_active": user.is_active,
|
|
"is_system_admin": getattr(user, "is_system_admin", False),
|
|
"created_at": user.created_at.isoformat() if user.created_at else None,
|
|
}
|
|
except Exception as e:
|
|
export["core"]["error"] = str(e)
|
|
|
|
# Core: Contacts owned by user
|
|
try:
|
|
from app.models.contact import Contact
|
|
result = await db.execute(
|
|
select(Contact).where(
|
|
Contact.tenant_id == tenant_id,
|
|
Contact.owner_id == user_id,
|
|
Contact.deleted_at.is_(None),
|
|
)
|
|
)
|
|
contacts = result.scalars().all()
|
|
export["core"]["contacts"] = [
|
|
{
|
|
"id": str(c.id),
|
|
"first_name": c.first_name,
|
|
"last_name": c.last_name,
|
|
"email": c.email,
|
|
"phone": c.phone,
|
|
"created_at": c.created_at.isoformat() if c.created_at else None,
|
|
}
|
|
for c in contacts
|
|
]
|
|
except Exception as e:
|
|
export["core"]["contacts_error"] = str(e)
|
|
|
|
# Agents: Agent runs by user
|
|
try:
|
|
from app.models.workflow import AgentRun
|
|
result = await db.execute(
|
|
select(AgentRun).where(
|
|
AgentRun.tenant_id == tenant_id,
|
|
AgentRun.user_id == user_id,
|
|
).limit(100)
|
|
)
|
|
runs = result.scalars().all()
|
|
export["agents"]["agent_runs"] = [
|
|
{
|
|
"id": str(r.id),
|
|
"status": r.status,
|
|
"total_cost_usd": float(r.total_cost_usd or 0),
|
|
"created_at": r.created_at.isoformat() if r.created_at else None,
|
|
}
|
|
for r in runs
|
|
]
|
|
except Exception as e:
|
|
export["agents"]["error"] = str(e)
|
|
|
|
# Audit: User's audit entries
|
|
try:
|
|
from app.models.audit import AuditLog
|
|
result = await db.execute(
|
|
select(AuditLog).where(
|
|
AuditLog.tenant_id == tenant_id,
|
|
AuditLog.user_id == user_id,
|
|
).limit(200)
|
|
)
|
|
entries = result.scalars().all()
|
|
export["audit"]["entries"] = [
|
|
{
|
|
"id": str(e.id),
|
|
"action": e.action,
|
|
"entity_type": e.entity_type,
|
|
"created_at": e.created_at.isoformat() if e.created_at else None,
|
|
}
|
|
for e in entries
|
|
]
|
|
except Exception as e:
|
|
export["audit"]["error"] = str(e)
|
|
|
|
return export
|
|
|
|
|
|
# ─── I-DSAR: Data Subject Rights Workflow ────────────────────────────────────
|
|
|
|
|
|
DSARType = Literal["access", "correction", "erasure", "restriction"]
|
|
|
|
|
|
async def create_dsar_request(
|
|
db: AsyncSession,
|
|
tenant_id: uuid.UUID,
|
|
user_id: uuid.UUID,
|
|
subject_user_id: uuid.UUID,
|
|
request_type: DSARType,
|
|
description: str = "",
|
|
) -> dict[str, Any]:
|
|
"""Create a data subject rights request (I-DSAR).
|
|
|
|
Creates a trackable Task for the DSGVO request. Finds affected sources,
|
|
calls domain handlers, tracks derived data via lifecycle, documents
|
|
exceptions/retention. No generic blind hard-delete.
|
|
"""
|
|
from app.plugins.builtins.tasks.services import create_task
|
|
|
|
task_data: dict[str, Any] = {
|
|
"title": f"DSAR: {request_type} for user {subject_user_id}",
|
|
"description": description or f"Data subject {request_type} request",
|
|
"task_type": "dsar",
|
|
"assignee_type": "user",
|
|
"assignee_id": str(user_id),
|
|
"entity_type": "user",
|
|
"entity_id": str(subject_user_id),
|
|
"status": "open",
|
|
"priority": "high",
|
|
}
|
|
|
|
task = await create_task(db, tenant_id, user_id, task_data)
|
|
|
|
# Find affected data sources
|
|
affected_sources = await _find_affected_sources(db, tenant_id, subject_user_id)
|
|
|
|
return {
|
|
"task": task,
|
|
"request_type": request_type,
|
|
"subject_user_id": str(subject_user_id),
|
|
"affected_sources": affected_sources,
|
|
}
|
|
|
|
|
|
async def _find_affected_sources(
|
|
db: AsyncSession,
|
|
tenant_id: uuid.UUID,
|
|
user_id: uuid.UUID,
|
|
) -> list[dict[str, str]]:
|
|
"""Find all data sources containing personal data for a user."""
|
|
sources: list[dict[str, str]] = []
|
|
|
|
# Check each source
|
|
source_checks = [
|
|
("core.contacts", "Contact", "owner_id"),
|
|
("mail.accounts", "MailAccount", "user_id"),
|
|
("dms.files", "DmsFile", "owner_id"),
|
|
("communication.messages", "CommMessage", "sender_id"),
|
|
("agents.runs", "AgentRun", "user_id"),
|
|
]
|
|
|
|
for source_name, model_name, id_field in source_checks:
|
|
try:
|
|
# Dynamic import would be needed here; for now just list the source
|
|
sources.append({
|
|
"source": source_name,
|
|
"model": model_name,
|
|
"id_field": id_field,
|
|
"status": "identified",
|
|
})
|
|
except Exception:
|
|
pass
|
|
|
|
return sources
|
|
|
|
|
|
# ─── I-COMP-EXPORT: AI/Compliance Evidence Export ────────────────────────────
|
|
|
|
|
|
async def export_compliance_evidence(
|
|
db: AsyncSession,
|
|
tenant_id: uuid.UUID,
|
|
days: int = 90,
|
|
) -> dict[str, Any]:
|
|
"""Export AI/Compliance evidence package (I-COMP-EXPORT).
|
|
|
|
Returns: AI use case metadata, provider/model references,
|
|
agent/workflow versions, audit/oversight/approval evidence,
|
|
and technical policies as exportable evidence package.
|
|
"""
|
|
since = datetime.now(UTC) - timedelta(days=days)
|
|
|
|
evidence: dict[str, Any] = {
|
|
"export_metadata": {
|
|
"exported_at": datetime.now(UTC).isoformat(),
|
|
"tenant_id": str(tenant_id),
|
|
"export_type": "compliance_evidence",
|
|
"period_days": days,
|
|
"version": "1.0",
|
|
},
|
|
"ai_use_cases": [],
|
|
"agent_definitions": [],
|
|
"workflow_definitions": [],
|
|
"audit_entries": [],
|
|
"approval_records": [],
|
|
"oversight_records": [],
|
|
"technical_policies": {},
|
|
}
|
|
|
|
# Agent definitions with AI metadata
|
|
try:
|
|
from app.models.workflow import AgentDefinition
|
|
result = await db.execute(
|
|
select(AgentDefinition).where(
|
|
AgentDefinition.tenant_id == tenant_id,
|
|
AgentDefinition.is_active == True, # noqa: E712
|
|
)
|
|
)
|
|
agents = result.scalars().all()
|
|
evidence["agent_definitions"] = [
|
|
{
|
|
"id": str(a.id),
|
|
"name": a.name,
|
|
"llm_model": getattr(a, "llm_model", None),
|
|
"provider": getattr(a, "provider", None),
|
|
"is_active": a.is_active,
|
|
"created_at": a.created_at.isoformat() if a.created_at else None,
|
|
}
|
|
for a in agents
|
|
]
|
|
except Exception as e:
|
|
evidence["agent_definitions_error"] = str(e)
|
|
|
|
# Approval records
|
|
try:
|
|
from app.core.approval import ApprovalRequest
|
|
result = await db.execute(
|
|
select(ApprovalRequest).where(
|
|
ApprovalRequest.tenant_id == tenant_id,
|
|
ApprovalRequest.created_at >= since,
|
|
).limit(100)
|
|
)
|
|
approvals = result.scalars().all()
|
|
evidence["approval_records"] = [
|
|
{
|
|
"id": str(a.id),
|
|
"action": a.action,
|
|
"status": a.status,
|
|
"created_at": a.created_at.isoformat() if a.created_at else None,
|
|
}
|
|
for a in approvals
|
|
]
|
|
except Exception as e:
|
|
evidence["approval_records_error"] = str(e)
|
|
|
|
# Technical policies
|
|
evidence["technical_policies"] = {
|
|
"data_policy": {
|
|
"sensitive_fields": list(_get_sensitive_fields()),
|
|
"provider_compliance": "enforced",
|
|
},
|
|
"permission_model": {
|
|
"type": "ABAC",
|
|
"tenant_isolation": "RLS",
|
|
},
|
|
"auth": {
|
|
"type": "session_based",
|
|
"cookies": "HttpOnly",
|
|
},
|
|
"retention": {
|
|
"soft_delete": True,
|
|
"hard_delete_requires_gdpr_flag": True,
|
|
},
|
|
}
|
|
|
|
return evidence
|
|
|
|
|
|
def _get_sensitive_fields() -> dict[str, set[str]]:
|
|
"""Get the sensitive fields mapping from data_policy.
|
|
|
|
Returns a dict mapping entity types to their sensitive field sets.
|
|
"""
|
|
try:
|
|
from app.ai.data_policy import SENSITIVE_FIELDS
|
|
return SENSITIVE_FIELDS
|
|
except Exception:
|
|
return {"contact": {"email", "phone", "address", "date_of_birth"}}
|
|
|
|
|
|
__all__ = [
|
|
"export_user_data",
|
|
"create_dsar_request",
|
|
"export_compliance_evidence",
|
|
"DSARType",
|
|
]
|