Files
tsumugu/backend/app/sourcebind.py
T
LarsandCursor 7a1206b18c
Test Suite / pytest-backend (push) Canceled after 0s
Test Suite / smoke-dev (push) Canceled after 0s
Test Suite / frontend-build (push) Canceled after 0s
Deploy Development / deploy (push) Successful in 43s
Speichere die neue Position einer verschobenen IMAP-Nachricht, damit der nächste Aufruf sie direkt öffnet.
Co-authored-by: Cursor <cursoragent@cursor.com>
2026-10-23 13:00:25 +02:00

259 lines
8.7 KiB
Python

"""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)),
)