"""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. Unique stock is bound once. A stored id is never retargeted. Startup calls this before the application has imported the connector modules. Register them first, otherwise every existing reference stays unresolved and the case or matter can no longer open its originals. """ from app.sources import _install_sources _install_sources() 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 IN ('unresolved', 'ambiguous') 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) def remember_imap_location( conn, element_id: UUID, external_id: str, previous_mailbox: str, previous_uid: int, mailbox: str, uid: int, ) -> None: """Store the folder and UID of a message found at a new place. Only the previous place is replaced. The message identity, the connector and an adopted direction stay as they were. """ if ( not mailbox or any(char in mailbox for char in "\r\n\x00") or uid < 1 or (mailbox == previous_mailbox and uid == previous_uid) ): return conn.execute( """ UPDATE external_references SET detail = jsonb_set( jsonb_set(detail, '{mailbox}', to_jsonb(%s::text)), '{uid}', to_jsonb(%s::bigint) ) WHERE element_id = %s AND source = 'imap' AND external_id = %s AND detail->>'mailbox' = %s AND detail->>'uid' = %s """, (mailbox, uid, element_id, external_id, previous_mailbox, str(previous_uid)), )