"""Bind a reference to one connector instance. The newest connection is never a fallback. A stored id that no longer exists stays missing. Ambiguous stock waits for an explicit assignment. """ from __future__ import annotations from dataclasses import dataclass from uuid import UUID from psycopg.types.json import Json from app.access.policy import get_element from app.core.errors import not_found, unprocessable from app.sourceregistry import get_source @dataclass(frozen=True) class ResolveResult: row: dict | None code: str message: str choices: tuple[dict, ...] = () def _uuid(value) -> UUID | None: if isinstance(value, UUID): return value if not value: return None try: return UUID(str(value)) except (TypeError, ValueError): return None def stored_id(ref) -> UUID | None: if not ref: return None detail = ref["detail"] if "detail" in ref.keys() else None detail = detail or {} return _uuid(detail.get("connector_id")) or _uuid(ref["connector_id"] if "connector_id" in ref.keys() else None) def _connectors(conn, owner_id: UUID, kind: str) -> list[dict]: return conn.execute( """ SELECT id, owner_id, kind, name, settings, secret FROM connectors WHERE owner_id = %s AND kind = %s ORDER BY name, id """, (owner_id, kind), ).fetchall() def resolve_for_read(conn, owner_id: UUID, kind: str, ref, assigned: UUID | None) -> ResolveResult: """Resolve one access. Assignment applies only when the reference has no stored id.""" stored = stored_id(ref) resolution = (ref["resolution"] if ref and "resolution" in ref.keys() and ref["resolution"] else None) or "unresolved" rows = _connectors(conn, owner_id, kind) if stored is not None: match = next((row for row in rows if row["id"] == stored), None) if match is None: return ResolveResult(None, "missing", "Der gespeicherte Zugang für diese Quelle ist nicht mehr vorhanden.") return ResolveResult(match, "ok", "") if assigned is not None: match = next((row for row in rows if row["id"] == assigned), None) if match is None: return ResolveResult( None, "assignment", "Der gewählte Zugang gehört nicht zu diesem Konto oder passt nicht zur Quelle.", ) return ResolveResult(match, "ok", "") if resolution == "ambiguous" or len(rows) != 1: if not rows: return ResolveResult(None, "missing", "Für diese Quelle ist kein Zugang vorhanden.") return ResolveResult( None, "ambiguous", "Für diese Quelle ist kein eindeutiger Zugang zugeordnet. Die Zuordnung muss bewusst gewählt werden.", tuple({"id": str(row["id"]), "name": row["name"]} for row in rows), ) return ResolveResult(rows[0], "ok", "") def _set_binding(conn, element_id: UUID, connector_id: UUID | None, resolution: str, detail: dict | None = None) -> None: if detail is None: conn.execute( """ UPDATE external_references SET connector_id = %s, resolution = %s WHERE element_id = %s """, (connector_id, resolution, element_id), ) return conn.execute( """ UPDATE external_references SET connector_id = %s, resolution = %s, detail = %s WHERE element_id = %s """, (connector_id, resolution, Json(detail), element_id), ) def attach_new_reference(conn, element_id: UUID) -> None: row = conn.execute( """ SELECT er.source, er.detail, e.owner_subject_id FROM external_references er JOIN elements e ON e.id = er.element_id WHERE er.element_id = %s """, (element_id,), ).fetchone() if row is None: return if get_source(row["source"]) is None: _set_binding(conn, element_id, None, "none") return detail = dict(row["detail"] or {}) stored = _uuid(detail.get("connector_id")) if stored is not None: match = conn.execute( """ SELECT id FROM connectors WHERE id = %s AND owner_id = %s AND kind = %s """, (stored, row["owner_subject_id"], row["source"]), ).fetchone() _set_binding(conn, element_id, stored, "bound" if match else "unresolved") return rows = _connectors(conn, row["owner_subject_id"], row["source"]) if len(rows) == 1: detail["connector_id"] = str(rows[0]["id"]) _set_binding(conn, element_id, rows[0]["id"], "bound", detail) return if len(rows) > 1: _set_binding(conn, element_id, None, "ambiguous") return _set_binding(conn, element_id, None, "unresolved") def backfill_source_bindings(conn) -> None: """Idempotent. Bound and ambiguous rows stay. Unique unresolved stock is bound once.""" conn.execute( """ UPDATE external_references SET resolution = 'none' WHERE source = 'url' AND resolution = 'unresolved' """ ) rows = conn.execute( """ SELECT er.element_id, er.source, er.detail, e.owner_subject_id FROM external_references er JOIN elements e ON e.id = er.element_id WHERE er.source <> 'url' AND er.resolution = 'unresolved' AND er.connector_id IS NULL """ ).fetchall() for row in rows: if get_source(row["source"]) is None: continue detail = dict(row["detail"] or {}) stored = _uuid(detail.get("connector_id")) if stored is not None: match = conn.execute( """ SELECT id FROM connectors WHERE id = %s AND owner_id = %s AND kind = %s """, (stored, row["owner_subject_id"], row["source"]), ).fetchone() _set_binding(conn, row["element_id"], stored, "bound" if match else "unresolved") continue found = _connectors(conn, row["owner_subject_id"], row["source"]) if len(found) == 1: detail["connector_id"] = str(found[0]["id"]) _set_binding(conn, row["element_id"], found[0]["id"], "bound", detail) elif len(found) > 1: _set_binding(conn, row["element_id"], None, "ambiguous") def assign_reference(conn, actor_id: UUID, element_id: UUID, connector_id: UUID) -> None: element = get_element(conn, element_id) if element is None or element["kind"] != "external_ref" or element["owner_subject_id"] != actor_id: raise not_found() ref = conn.execute( "SELECT source, detail FROM external_references WHERE element_id = %s", (element_id,), ).fetchone() if ref is None or get_source(ref["source"]) is None: raise unprocessable("Diese Referenz hat keinen Quellzugang.") connector = conn.execute( """ SELECT id, kind FROM connectors WHERE id = %s AND owner_id = %s """, (connector_id, actor_id), ).fetchone() if connector is None or connector["kind"] != ref["source"]: raise unprocessable("Der Zugang gehört nicht zu diesem Konto oder passt nicht zur Quelle.") detail = dict(ref["detail"] or {}) detail["connector_id"] = str(connector_id) _set_binding(conn, element_id, connector_id, "bound", detail)