Files
tsumugu/backend/app/sourcebind.py
T
LarsandCursor d6b70d8f92
Deploy Development / deploy (push) Successful in 28s
Test Suite / pytest-backend (push) Failing after 2m18s
Test Suite / smoke-dev (push) Successful in 0s
Test Suite / frontend-build (push) Successful in 10s
Schließe die Connector-Kapselung ab, damit Paperless, IMAP und weitere Quellen über dieselbe Anbindung laufen.
Co-authored-by: Cursor <cursoragent@cursor.com>
2026-10-19 15:00:50 +02:00

212 lines
7.3 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. 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)