220 lines
7.6 KiB
Python
220 lines
7.6 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)
|