Führe die Konfigurationsansicht der Connectoren ein, damit Paperless und IMAP ihre Felder selbst deklarieren.
Deploy Development / deploy (push) Successful in 40s
Test Suite / pytest-backend (push) Successful in 3m12s
Test Suite / smoke-dev (push) Successful in 0s
Test Suite / frontend-build (push) Successful in 21s

Das Modul liefert ein Feldmanifest und validiert es; ein leeres Geheimnisfeld behält das gespeicherte. Die Oberfläche rendert die Felder generisch in einer Detailansicht je Zugang mit Prüfstand, Fähigkeiten und Verwendung. Die providerspezifischen Formulare in Sources.jsx entfallen, die flachen API-Felder bleiben als Kompatibilität. Das Standardfach eines IMAP-Kontos öffnet der Picker zuerst.

Die Backend-Tests wurden in der Entwicklungsumgebung nicht ausgeführt; der Lauf auf develop steht aus.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
LarsandClaude Sonnet 5.5 committed 2026-10-20 09:34:37 +02:00
1 parent c29bd29f34
commit eb58dce4cd
20 files changed
+1071 -244

No files matched your search

+1 -1
View File
@@ -304,7 +304,7 @@ class ConnectorIn(APIModel):
password: str | None = None password: str | None = None
mailbox: str | None = Field(default=None, max_length=200) mailbox: str | None = Field(default=None, max_length=200)
security: Literal["ssl", "starttls"] | None = None security: Literal["ssl", "starttls"] | None = None
config: dict[str, str] | None = None config: dict[str, str | int | None] | None = None
class SourceAssignmentIn(APIModel): class SourceAssignmentIn(APIModel):
+15 -7
View File
@@ -21,10 +21,13 @@ from app.sourcebind import assign_reference
from app.sourceport import capability_payload, with_capabilities from app.sourceport import capability_payload, with_capabilities
from app.sourceregistry import get_source, require_source from app.sourceregistry import get_source, require_source
from app.sources import ( from app.sources import (
connector_detail,
delete_connector, delete_connector,
imap_preview, imap_preview,
list_connectors, list_connectors,
owned_connector,
paperless_content, paperless_content,
parse_connector,
probe, probe,
save_connector, save_connector,
update_connector, update_connector,
@@ -52,11 +55,16 @@ def source_capabilities(principal: Principal = Depends(get_principal)):
@router.post("/api/v1/connectors", status_code=201) @router.post("/api/v1/connectors", status_code=201)
def post_connector(body: ConnectorIn, principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)): def post_connector(body: ConnectorIn, principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)):
name, settings, secret = _connector_parts(body) name, settings, secret = _connector_parts(body, None)
row = save_connector(conn, principal.account_id, body.kind, name, settings, secret) row = save_connector(conn, principal.account_id, body.kind, name, settings, secret)
return row return row
@router.get("/api/v1/connectors/{connector_id}")
def get_connector(connector_id: UUID, principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)):
return connector_detail(conn, principal.account_id, connector_id)
@router.patch("/api/v1/connectors/{connector_id}") @router.patch("/api/v1/connectors/{connector_id}")
def patch_connector( def patch_connector(
connector_id: UUID, connector_id: UUID,
@@ -64,12 +72,10 @@ def patch_connector(
principal: Principal = Depends(get_principal), principal: Principal = Depends(get_principal),
conn: Connection = Depends(get_conn), conn: Connection = Depends(get_conn),
): ):
name, settings, secret = _connector_parts(body) current = owned_connector(conn, principal.account_id, connector_id)
current = next((item for item in list_connectors(conn, principal.account_id) if item["id"] == str(connector_id)), None)
if current is None:
raise not_found()
if current["kind"] != body.kind: if current["kind"] != body.kind:
raise unprocessable("Der Zugang bleibt bei seiner Quellenart.") raise unprocessable("Der Zugang bleibt bei seiner Quellenart.")
name, settings, secret = _connector_parts(body, current)
return update_connector(conn, principal.account_id, connector_id, name, settings, secret) return update_connector(conn, principal.account_id, connector_id, name, settings, secret)
@@ -382,8 +388,10 @@ def assign_source(
return {"id": str(element_id), "connector_id": str(body.connector_id), "resolution": "bound"} return {"id": str(element_id), "connector_id": str(body.connector_id), "resolution": "bound"}
def _connector_parts(body: ConnectorIn) -> tuple[str, dict, str]: def _connector_parts(body: ConnectorIn, current: dict | None) -> tuple[str, dict, str]:
return require_source(body.kind).parse_config(body.model_dump()) """The registered module validates. Flat fields of the first release are folded into ``config``."""
flat = body.model_dump(exclude={"kind", "name", "config"})
return parse_connector(body.kind, body.name, flat, body.config, current)
_SEARCH_FLAGS = { _SEARCH_FLAGS = {
+9
View File
@@ -73,6 +73,15 @@ def capability_payload() -> dict:
return { return {
"sources": [module.capabilities for module in registered_sources()], "sources": [module.capabilities for module in registered_sources()],
"modules": [
{
"kind": module.kind,
"label": module.label,
"representation": module.representation,
"config_fields": [item.public() for item in module.config_fields],
}
for module in registered_sources()
],
"editors": EDITORS, "editors": EDITORS,
"protection_profiles": { "protection_profiles": {
"legacy-plaintext": "cleartext", "legacy-plaintext": "cleartext",
+109 -1
View File
@@ -7,6 +7,46 @@ from typing import Callable
from app.core.errors import unprocessable from app.core.errors import unprocessable
FIELD_TYPES = ("text", "url", "number", "password", "select")
@dataclass(frozen=True)
class ConfigField:
"""One configuration field a module declares for its connector instances.
At most one field per module is a secret. Its value is stored apart from
the settings and is never handed out again.
"""
key: str
label: str
type: str = "text"
required: bool = False
secret: bool = False
default: str | int | None = None
options: tuple[tuple[str, str], ...] = ()
help: str = ""
placeholder: str = ""
minimum: int | None = None
maximum: int | None = None
max_length: int = 200
def public(self) -> dict:
return {
"key": self.key,
"label": self.label,
"type": self.type,
"required": self.required,
"secret": self.secret,
"default": self.default,
"options": [{"value": value, "label": label} for value, label in self.options],
"help": self.help,
"placeholder": self.placeholder,
"minimum": self.minimum,
"maximum": self.maximum,
"max_length": self.max_length,
}
@dataclass @dataclass
class SourceModule: class SourceModule:
@@ -14,11 +54,14 @@ class SourceModule:
label: str label: str
representation: str representation: str
capabilities: dict capabilities: dict
parse_config: Callable[[dict], tuple[str, dict, str]]
probe: Callable probe: Callable
find: Callable find: Callable
open_original: Callable open_original: Callable
export_original: Callable export_original: Callable
# A module either declares fields (generic validation) or parses the payload itself.
parse_config: Callable[[dict], tuple[str, dict, str]] | None = None
config_fields: tuple[ConfigField, ...] = ()
normalize_config: Callable[[dict, str], dict] | None = None
navigate: Callable | None = None navigate: Callable | None = None
preview: Callable | None = None preview: Callable | None = None
facets: Callable | None = None facets: Callable | None = None
@@ -28,6 +71,13 @@ _MODULES: dict[str, SourceModule] = {}
def register_source(module: SourceModule) -> None: def register_source(module: SourceModule) -> None:
if module.parse_config is None and not module.config_fields:
raise ValueError(f"Quelle {module.kind} braucht Konfigurationsfelder oder parse_config.")
if sum(1 for item in module.config_fields if item.secret) > 1:
raise ValueError(f"Quelle {module.kind} darf höchstens ein Geheimnisfeld haben.")
for item in module.config_fields:
if item.type not in FIELD_TYPES:
raise ValueError(f"Feldtyp {item.type} ist unbekannt.")
_MODULES[module.kind] = module _MODULES[module.kind] = module
@@ -52,3 +102,61 @@ def require_source(kind: str) -> SourceModule:
def accepts_reference(source: str) -> bool: def accepts_reference(source: str) -> bool:
return source == "url" or source in _MODULES return source == "url" or source in _MODULES
def _blank(value) -> bool:
return value is None or (isinstance(value, str) and not value.strip())
def _coerce(field: ConfigField, value):
if field.type == "number":
try:
number = int(str(value).strip())
except (TypeError, ValueError):
raise unprocessable(f"{field.label} muss eine ganze Zahl sein.") from None
if field.minimum is not None and number < field.minimum:
raise unprocessable(f"{field.label} ist zu klein.")
if field.maximum is not None and number > field.maximum:
raise unprocessable(f"{field.label} ist zu groß.")
return number
text = str(value) if field.secret else str(value).strip()
if len(text) > field.max_length:
raise unprocessable(f"{field.label} ist zu lang.")
if field.type == "select" and text not in {option for option, _label in field.options}:
raise unprocessable(f"{field.label} ist keine zulässige Auswahl.")
return text
def parse_fields(
fields: tuple[ConfigField, ...],
values: dict,
current_settings: dict | None = None,
current_secret: str = "",
) -> tuple[dict, str]:
"""Validate declared fields. Unknown keys are refused, a blank secret keeps the stored one."""
known = {item.key for item in fields}
extra = sorted(key for key, value in values.items() if key not in known and not _blank(value))
if extra:
raise unprocessable("Unbekanntes Konfigurationsfeld: " + ", ".join(extra[:3]) + ".")
current_settings = current_settings or {}
settings: dict = {}
secret = current_secret
for item in fields:
raw = values.get(item.key)
if item.secret:
if _blank(raw):
if not current_secret and item.required:
raise unprocessable(f"{item.label} fehlt.")
continue
secret = _coerce(item, raw)
continue
if _blank(raw):
raw = current_settings.get(item.key)
if _blank(raw):
raw = item.default
if _blank(raw):
if item.required:
raise unprocessable(f"{item.label} fehlt.")
continue
settings[item.key] = _coerce(item, raw)
return settings, secret
+155 -34
View File
@@ -44,15 +44,47 @@ from app.sourceaccess import (
release_for_external, release_for_external,
) )
from app.sourceport import CAPABILITIES from app.sourceport import CAPABILITIES
from app.sourceregistry import SourceModule, get_source, register_source from app.sourceregistry import ConfigField, SourceModule, get_source, parse_fields, register_source, require_source
_PUBLIC_COLUMNS = """
id, kind, name, settings, created_at,
secret <> '' AS has_secret,
last_probe_at, last_probe_ok, last_probe_detail
"""
def parse_connector(
kind: str,
name: str,
flat: dict,
config: dict | None,
current: dict | None = None,
) -> tuple[str, dict, str]:
"""Validate a connector body with the registered module. ``current`` is the stored row on change."""
module = require_source(kind)
name = " ".join(str(name or "").split())
values = {key: value for key, value in flat.items() if value is not None}
values.update(config or {})
if module.config_fields:
settings, secret = parse_fields(
module.config_fields,
values,
current["settings"] if current else None,
current["secret"] if current else "",
)
if module.normalize_config is not None:
settings = module.normalize_config(settings, secret)
return name, settings, secret
return module.parse_config({**values, "kind": kind, "name": name, "config": config or {}})
def save_connector(conn, owner_id: UUID, kind: str, name: str, settings: dict, secret: str) -> dict: def save_connector(conn, owner_id: UUID, kind: str, name: str, settings: dict, secret: str) -> dict:
row = conn.execute( row = conn.execute(
""" f"""
INSERT INTO connectors (owner_id, kind, name, settings, secret) INSERT INTO connectors (owner_id, kind, name, settings, secret)
VALUES (%s, %s, %s, %s, %s) VALUES (%s, %s, %s, %s, %s)
RETURNING id, kind, name, settings, created_at RETURNING {_PUBLIC_COLUMNS}
""", """,
(owner_id, kind, name, Json(settings), secret), (owner_id, kind, name, Json(settings), secret),
).fetchone() ).fetchone()
@@ -63,11 +95,12 @@ def update_connector(conn, owner_id: UUID, connector_id: UUID, name: str, settin
"""Credential or name change on the same instance. The id does not move.""" """Credential or name change on the same instance. The id does not move."""
current = _owned(conn, owner_id, connector_id) current = _owned(conn, owner_id, connector_id)
row = conn.execute( row = conn.execute(
""" f"""
UPDATE connectors UPDATE connectors
SET name = %s, settings = %s, secret = %s SET name = %s, settings = %s, secret = %s,
last_probe_at = NULL, last_probe_ok = NULL, last_probe_detail = NULL
WHERE id = %s AND owner_id = %s WHERE id = %s AND owner_id = %s
RETURNING id, kind, name, settings, created_at RETURNING {_PUBLIC_COLUMNS}
""", """,
(name, Json(settings), secret, current["id"], owner_id), (name, Json(settings), secret, current["id"], owner_id),
).fetchone() ).fetchone()
@@ -76,8 +109,8 @@ def update_connector(conn, owner_id: UUID, connector_id: UUID, name: str, settin
def list_connectors(conn, owner_id: UUID) -> list[dict]: def list_connectors(conn, owner_id: UUID) -> list[dict]:
rows = conn.execute( rows = conn.execute(
""" f"""
SELECT id, kind, name, settings, created_at SELECT {_PUBLIC_COLUMNS}
FROM connectors WHERE owner_id = %s FROM connectors WHERE owner_id = %s
ORDER BY kind, name ORDER BY kind, name
""", """,
@@ -86,6 +119,30 @@ def list_connectors(conn, owner_id: UUID) -> list[dict]:
return [_public(row) for row in rows] return [_public(row) for row in rows]
def connector_detail(conn, owner_id: UUID, connector_id: UUID) -> dict:
"""One own instance with its use. The secret itself is never part of it."""
row = conn.execute(
f"SELECT {_PUBLIC_COLUMNS} FROM connectors WHERE id = %s AND owner_id = %s",
(connector_id, owner_id),
).fetchone()
if row is None:
raise not_found()
used = conn.execute(
"""
SELECT count(*) AS total
FROM external_references er
JOIN elements e ON e.id = er.element_id
WHERE (er.connector_id = %s OR er.detail ->> 'connector_id' = %s)
AND e.deleted_at IS NULL AND e.owner_subject_id = %s
""",
(connector_id, str(connector_id), owner_id),
).fetchone()
body = _public(row)
body["references"] = int(used["total"])
body["protection_profile"] = "legacy-plaintext"
return body
def delete_connector(conn, owner_id: UUID, connector_id: UUID) -> None: def delete_connector(conn, owner_id: UUID, connector_id: UUID) -> None:
row = conn.execute( row = conn.execute(
"DELETE FROM connectors WHERE id = %s AND owner_id = %s RETURNING id", "DELETE FROM connectors WHERE id = %s AND owner_id = %s RETURNING id",
@@ -101,11 +158,30 @@ def probe(conn, owner_id: UUID, connector_id: UUID) -> dict:
if module is None: if module is None:
raise unprocessable("Diese Quelle ist nicht registriert.") raise unprocessable("Diese Quelle ist nicht registriert.")
release_for_external(conn) release_for_external(conn)
result = module.probe(row) try:
result = module.probe(row)
except Problem as exc:
assert_still_owned(conn, row["id"], owner_id)
_record_probe(conn, row["id"], False, exc.detail)
conn.commit()
raise
assert_still_owned(conn, row["id"], owner_id) assert_still_owned(conn, row["id"], owner_id)
_record_probe(conn, row["id"], bool(result.get("ok", True)), str(result.get("detail") or ""))
return result return result
def _record_probe(conn, connector_id: UUID, ok: bool, detail: str) -> None:
"""Display only. The detail comes from the module and must not carry a secret."""
conn.execute(
"""
UPDATE connectors
SET last_probe_at = now(), last_probe_ok = %s, last_probe_detail = %s
WHERE id = %s
""",
(ok, detail[:300] or None, connector_id),
)
def _paperless_choice(value, label: str) -> str | None: def _paperless_choice(value, label: str) -> str | None:
text = str(value or "").strip() text = str(value or "").strip()
if not text: if not text:
@@ -325,6 +401,11 @@ def _owned(conn, owner_id: UUID, connector_id: UUID) -> dict:
return row return row
def owned_connector(conn, owner_id: UUID, connector_id: UUID) -> dict:
"""The stored row of an own instance, secret included. For server-side use only."""
return _owned(conn, owner_id, connector_id)
def _public(row) -> dict: def _public(row) -> dict:
return { return {
"id": str(row["id"]), "id": str(row["id"]),
@@ -333,6 +414,14 @@ def _public(row) -> dict:
"settings": row["settings"], "settings": row["settings"],
"created_at": row["created_at"].strftime("%Y-%m-%dT%H:%M:%SZ"), "created_at": row["created_at"].strftime("%Y-%m-%dT%H:%M:%SZ"),
"capabilities": (get_source(row["kind"]).capabilities if get_source(row["kind"]) else None), "capabilities": (get_source(row["kind"]).capabilities if get_source(row["kind"]) else None),
"has_secret": bool(row["has_secret"]),
"probe": {
"at": row["last_probe_at"].strftime("%Y-%m-%dT%H:%M:%SZ"),
"ok": bool(row["last_probe_ok"]),
"detail": row["last_probe_detail"] or "",
}
if row["last_probe_at"]
else None,
} }
@@ -1456,32 +1545,62 @@ def _search_rfc822(client: imaplib.IMAP4, expected_id: str, max_bytes: int) -> l
return found return found
def _paperless_config(payload: dict) -> tuple[str, dict, str]: PAPERLESS_FIELDS = (
base_url = str(payload.get("base_url") or "").strip() ConfigField(
token = str(payload.get("token") or "").strip() "base_url",
name = str(payload.get("name") or "").strip() "Adresse",
if not base_url or len(token) < 8: type="url",
raise unprocessable("Paperless braucht eine Adresse und einen API-Schlüssel.") required=True,
return name, {"base_url": clean_base_url(base_url)}, token placeholder="https://paperless.example",
help="Adresse deiner Paperless-Instanz ohne Pfad.",
max_length=300,
),
ConfigField(
"token",
"API-Schlüssel",
type="password",
required=True,
secret=True,
help="Den Schlüssel erzeugst du in Paperless unter deinem Profil.",
max_length=200,
),
)
IMAP_FIELDS = (
ConfigField("host", "Server", required=True, placeholder="imap.example", max_length=200),
ConfigField("port", "Port", type="number", required=True, default=993, minimum=1, maximum=65535),
ConfigField(
"security",
"Verbindung",
type="select",
required=True,
default="ssl",
options=(("ssl", "SSL"), ("starttls", "STARTTLS")),
),
ConfigField("username", "Benutzername", required=True, max_length=200),
ConfigField("password", "Passwort", type="password", required=True, secret=True, max_length=500),
ConfigField(
"mailbox",
"Standardfach",
default="INBOX",
help="Dieses Fach öffnet die Auswahl zuerst.",
max_length=200,
),
)
def _imap_config(payload: dict) -> tuple[str, dict, str]: def _paperless_normalize(settings: dict, secret: str) -> dict:
host = str(payload.get("host") or "").strip() if len(secret.strip()) < 8:
username = str(payload.get("username") or "").strip() raise unprocessable("Der API-Schlüssel ist zu kurz.")
password = str(payload.get("password") or "") return {**settings, "base_url": clean_base_url(settings["base_url"])}
name = str(payload.get("name") or "").strip()
if not host or not username or not password:
raise unprocessable("Ein E-Mail-Konto braucht Server, Benutzername und Passwort.") def _imap_normalize(settings: dict, secret: str) -> dict:
if " " in host or len(host) > 200: del secret
if " " in settings["host"]:
raise unprocessable("Der Mailserver ist ungültig.") raise unprocessable("Der Mailserver ist ungültig.")
port = payload.get("port") or 993 _check_mailbox(settings.get("mailbox") or "INBOX")
return name, { return settings
"host": host,
"port": int(port),
"username": username,
"mailbox": str(payload.get("mailbox") or "INBOX").strip() or "INBOX",
"security": payload.get("security") or "ssl",
}, password
def _paperless_find(conn, owner_id: UUID, connector_id: UUID | None, query: str, options: dict) -> dict: def _paperless_find(conn, owner_id: UUID, connector_id: UUID | None, query: str, options: dict) -> dict:
@@ -1624,7 +1743,8 @@ def _install_sources() -> None:
label="Paperless", label="Paperless",
representation="pdf", representation="pdf",
capabilities=CAPABILITIES["paperless"], capabilities=CAPABILITIES["paperless"],
parse_config=_paperless_config, config_fields=PAPERLESS_FIELDS,
normalize_config=_paperless_normalize,
probe=paperless.probe, probe=paperless.probe,
find=paperless.find, find=paperless.find,
open_original=read_linked_paperless, open_original=read_linked_paperless,
@@ -1638,7 +1758,8 @@ def _install_sources() -> None:
label="E-Mail", label="E-Mail",
representation="email", representation="email",
capabilities=CAPABILITIES["imap"], capabilities=CAPABILITIES["imap"],
parse_config=_imap_config, config_fields=IMAP_FIELDS,
normalize_config=_imap_normalize,
probe=imap.probe, probe=imap.probe,
find=imap.find, find=imap.find,
open_original=_imap_bytes, open_original=_imap_bytes,
@@ -0,0 +1,8 @@
-- Last connection check per connector instance. Display only: it grants nothing
-- and carries no secret.
ALTER TABLE connectors
ADD COLUMN last_probe_at timestamptz,
ADD COLUMN last_probe_ok boolean,
ADD COLUMN last_probe_detail text,
ADD CONSTRAINT connectors_probe_detail_len CHECK (last_probe_detail IS NULL OR char_length(last_probe_detail) <= 300);
+12 -8
View File
@@ -10,7 +10,7 @@ from uuid import UUID
from app.core.errors import not_found, unprocessable from app.core.errors import not_found, unprocessable
from app.retrieval import FilePayload, RetrievalFailure from app.retrieval import FilePayload, RetrievalFailure
from app.sourcebind import resolve_for_read from app.sourcebind import resolve_for_read
from app.sourceregistry import SourceModule, register_source, unregister_source from app.sourceregistry import ConfigField, SourceModule, register_source, unregister_source
from app.sourceaccess import borrow_original, complete_borrow from app.sourceaccess import borrow_original, complete_borrow
KIND = "sample" KIND = "sample"
@@ -51,13 +51,16 @@ CAPABILITIES = {
} }
def parse_config(payload: dict) -> tuple[str, dict, str]: CONFIG_FIELDS = (
config = payload.get("config") or {} ConfigField("catalog", "Katalog", required=True, default="alpha", help="Name des Beispielkatalogs."),
catalog = str(config.get("catalog") or "").strip() )
name = str(payload.get("name") or "").strip() or catalog
if catalog not in CATALOG:
def normalize_config(settings: dict, secret: str) -> dict:
del secret
if settings["catalog"] not in CATALOG:
raise unprocessable("Der Katalog dieser Beispielquelle ist unbekannt.") raise unprocessable("Der Katalog dieser Beispielquelle ist unbekannt.")
return name, {"catalog": catalog}, "" return settings
def probe(row) -> dict: def probe(row) -> dict:
@@ -109,7 +112,8 @@ def install_sample_source() -> None:
label="Beispielquelle", label="Beispielquelle",
representation="text", representation="text",
capabilities=CAPABILITIES, capabilities=CAPABILITIES,
parse_config=parse_config, config_fields=CONFIG_FIELDS,
normalize_config=normalize_config,
probe=probe, probe=probe,
find=find, find=find,
open_original=open_original, open_original=open_original,
+215
View File
@@ -0,0 +1,215 @@
"""Connector configuration: fields come from the module, secrets never leave the server."""
from __future__ import annotations
import pytest
from app.core.errors import Problem
from app.sourceregistry import ConfigField, parse_fields
from tests.sample_source import install_sample_source, remove_sample_source
from tests.support import Actor, register
SECRET_WORDS = ("secret", "token-geheim-1234", "passwort-geheim")
PAPERLESS = {"kind": "paperless", "name": "Archiv", "base_url": "https://paper.example.test", "token": "token-geheim-1234"}
IMAP = {
"kind": "imap",
"name": "Postfach",
"host": "imap.example.test",
"port": 993,
"username": "ada",
"password": "passwort-geheim",
"security": "ssl",
}
@pytest.fixture
def sample_source():
install_sample_source()
try:
yield
finally:
remove_sample_source()
def _ada(client, db) -> Actor:
ada = Actor(client, "ada-config@example.test", "Ada Konfig")
register(db, ada.email, ada.name)
ada.login()
return ada
def _stored(db, connector_id: str) -> dict:
return db.execute("SELECT settings, secret FROM connectors WHERE id = %s", (connector_id,)).fetchone()
def test_parse_fields_checks_types_and_refuses_unknown_keys():
fields = (
ConfigField("host", "Server", required=True),
ConfigField("port", "Port", type="number", default=993, minimum=1, maximum=65535),
ConfigField("mode", "Modus", type="select", default="a", options=(("a", "A"), ("b", "B"))),
ConfigField("key", "Schlüssel", type="password", required=True, secret=True),
)
settings, secret = parse_fields(fields, {"host": " h ", "key": "k"})
assert settings == {"host": "h", "port": 993, "mode": "a"}
assert secret == "k"
for bad in (
{"host": "h", "key": "k", "port": "abc"},
{"host": "h", "key": "k", "port": 0},
{"host": "h", "key": "k", "mode": "c"},
{"host": "h", "key": "k", "fremd": "x"},
{"key": "k"},
{"host": "h"},
):
with pytest.raises(Problem) as caught:
parse_fields(fields, bad)
assert caught.value.status == 422
kept_settings, kept_secret = parse_fields(fields, {"host": "neu", "key": ""}, {"host": "alt", "port": 143}, "bleibt")
assert kept_settings["host"] == "neu" and kept_settings["port"] == 143
assert kept_secret == "bleibt"
def test_capabilities_list_the_fields_of_each_module(client, db):
ada = _ada(client, db)
modules = {item["kind"]: item for item in ada.request("GET", "/api/v1/sources/capabilities")["modules"]}
assert {"paperless", "imap"} <= set(modules)
paperless = {item["key"]: item for item in modules["paperless"]["config_fields"]}
assert paperless["token"]["secret"] is True and paperless["base_url"]["required"] is True
imap = {item["key"]: item for item in modules["imap"]["config_fields"]}
assert imap["password"]["secret"] is True
assert imap["port"]["type"] == "number" and imap["port"]["default"] == 993
assert [option["value"] for option in imap["security"]["options"]] == ["ssl", "starttls"]
assert imap["mailbox"]["default"] == "INBOX"
def test_create_with_config_and_flat_fields_gives_the_same_stored_result(client, db):
ada = _ada(client, db)
flat = ada.request("POST", "/api/v1/connectors", json=PAPERLESS, status=201)
config = ada.request(
"POST",
"/api/v1/connectors",
json={
"kind": "paperless",
"name": "Zweites Archiv",
"config": {"base_url": "https://paper.example.test/", "token": "token-geheim-1234"},
},
status=201,
)
assert _stored(db, flat["id"]) == _stored(db, config["id"])
assert _stored(db, flat["id"])["settings"] == {"base_url": "https://paper.example.test"}
def test_secrets_never_leave_the_server(client, db):
ada = _ada(client, db)
created = ada.request("POST", "/api/v1/connectors", json=IMAP, status=201)
detail = ada.request("GET", f"/api/v1/connectors/{created['id']}")
listed = ada.request("GET", "/api/v1/connectors")
for body in (created, detail, listed):
text = str(body)
assert not any(word in text for word in SECRET_WORDS if word != "secret"), text
assert "'secret'" not in text and "'password'" not in text and "'token'" not in text
assert detail["has_secret"] is True
assert detail["settings"]["mailbox"] == "INBOX"
assert detail["settings"]["port"] == 993
assert detail["protection_profile"] == "legacy-plaintext"
assert detail["references"] == 0
assert detail["probe"] is None
def test_change_without_secret_keeps_the_stored_one_and_the_instance(client, db):
ada = _ada(client, db)
created = ada.request("POST", "/api/v1/connectors", json=IMAP, status=201)
changed = ada.request(
"PATCH",
f"/api/v1/connectors/{created['id']}",
json={"kind": "imap", "name": "Umbenannt", "config": {"host": "mail.example.test", "port": "143", "security": "starttls"}},
)
assert changed["id"] == created["id"]
assert changed["name"] == "Umbenannt"
stored = _stored(db, created["id"])
assert stored["secret"] == "passwort-geheim"
assert stored["settings"]["host"] == "mail.example.test"
assert stored["settings"]["port"] == 143
assert stored["settings"]["security"] == "starttls"
assert stored["settings"]["username"] == "ada"
renewed = ada.request(
"PATCH",
f"/api/v1/connectors/{created['id']}",
json={"kind": "imap", "name": "Umbenannt", "config": {"password": "neues-passwort"}},
)
assert renewed["id"] == created["id"]
assert _stored(db, created["id"])["secret"] == "neues-passwort"
def test_module_validation_refuses_bad_input(client, db):
ada = _ada(client, db)
ada.request("POST", "/api/v1/connectors", json={**PAPERLESS, "base_url": "ftp://paper.example.test"}, status=422)
ada.request("POST", "/api/v1/connectors", json={**PAPERLESS, "token": "kurz"}, status=422)
ada.request("POST", "/api/v1/connectors", json={**IMAP, "host": "mail server"}, status=422)
ada.request("POST", "/api/v1/connectors", json={**IMAP, "port": 70000}, status=422)
ada.request("POST", "/api/v1/connectors", json={**IMAP, "password": None}, status=422)
ada.request(
"POST",
"/api/v1/connectors",
json={"kind": "paperless", "name": "Fremdfeld", "config": {"base_url": "https://paper.example.test", "token": "token-geheim-1234", "host": "x"}},
status=422,
)
created = ada.request("POST", "/api/v1/connectors", json=PAPERLESS, status=201)
ada.request(
"PATCH",
f"/api/v1/connectors/{created['id']}",
json={**PAPERLESS, "kind": "imap"},
status=422,
)
assert _stored(db, created["id"])["settings"] == {"base_url": "https://paper.example.test"}
def test_a_foreign_instance_is_not_found(client, db):
ada = _ada(client, db)
ben = Actor(client, "ben-config@example.test", "Ben Konfig")
register(db, ben.email, ben.name)
created = ada.request("POST", "/api/v1/connectors", json=PAPERLESS, status=201)
ben.login()
ben.request("GET", f"/api/v1/connectors/{created['id']}", status=404)
ben.request("PATCH", f"/api/v1/connectors/{created['id']}", json=PAPERLESS, status=404)
ben.request("DELETE", f"/api/v1/connectors/{created['id']}", status=404)
def test_probe_result_is_kept_for_display(client, db, sample_source):
del sample_source
ada = _ada(client, db)
created = ada.request(
"POST",
"/api/v1/connectors",
json={"kind": "sample", "name": "Katalog", "config": {"catalog": "alpha"}},
status=201,
)
probed = ada.request("POST", f"/api/v1/connectors/{created['id']}/probe")
detail = ada.request("GET", f"/api/v1/connectors/{created['id']}")
assert detail["probe"]["ok"] is True
assert detail["probe"]["detail"] == probed["detail"]
ada.request(
"PATCH",
f"/api/v1/connectors/{created['id']}",
json={"kind": "sample", "name": "Katalog", "config": {"catalog": "alpha"}},
)
assert ada.request("GET", f"/api/v1/connectors/{created['id']}")["probe"] is None
def test_a_module_with_fields_needs_no_central_schema(client, db, sample_source):
del sample_source
ada = _ada(client, db)
modules = {item["kind"]: item for item in ada.request("GET", "/api/v1/sources/capabilities")["modules"]}
assert [item["key"] for item in modules["sample"]["config_fields"]] == ["catalog"]
ada.request(
"POST",
"/api/v1/connectors",
json={"kind": "sample", "name": "Ohne Wert", "config": {}},
status=201,
)
ada.request(
"POST",
"/api/v1/connectors",
json={"kind": "sample", "name": "Falsch", "config": {"catalog": "kein-katalog"}},
status=422,
)
+5 -4
View File
@@ -153,11 +153,12 @@ Legende Spalte „Auth“: **–** öffentlich, **S** gültige Session, **S+R**
| Methode | Pfad | Zweck | | Methode | Pfad | Zweck |
|---|---|---| |---|---|---|
| GET | `/api/v1/connectors` | eigene Zugänge ohne Secret, mit Fähigkeiten der registrierten Quelle | | GET | `/api/v1/connectors` | eigene Zugänge ohne Secret, mit Fähigkeiten der registrierten Quelle, `has_secret` und letztem Prüfstand (`probe`) |
| POST | `/api/v1/connectors` | neue Instanz einer registrierten Quelle; unbekannte Art wird abgewiesen; ersetzt keinen vorhandenen Zugang | | GET | `/api/v1/connectors/{id}` | Detail eines eigenen Zugangs: nicht geheime Einstellungen, `has_secret`, Fähigkeiten, Schutzprofil, Prüfstand und Zahl der eigenen Verknüpfungen. Nie das Secret. Fremde Instanz: 404 |
| PATCH | `/api/v1/connectors/{id}` | Name, Einstellungen und Zugangsdaten derselben Instanz | | POST | `/api/v1/connectors` | neue Instanz einer registrierten Quelle; Body `{kind, name, config}`. `config` wird gegen das Feldmanifest des Moduls geprüft (`modules[].config_fields` aus `/api/v1/sources/capabilities`); unbekannte Art oder unbekanntes Feld wird abgewiesen; ersetzt keinen vorhandenen Zugang. Die flachen Felder der ersten Lieferung (`base_url`, `token`, `host`, …) gelten nur als Kompatibilität und werden in `config` übersetzt |
| PATCH | `/api/v1/connectors/{id}` | Name, Einstellungen und Zugangsdaten derselben Instanz. Ein leeres Geheimnisfeld behält das gespeicherte Geheimnis; der letzte Prüfstand wird zurückgesetzt |
| DELETE | `/api/v1/connectors/{id}` | Zugang löschen; bestehende Referenzen bleiben und werden nicht umgehängt | | DELETE | `/api/v1/connectors/{id}` | Zugang löschen; bestehende Referenzen bleiben und werden nicht umgehängt |
| POST | `/api/v1/connectors/{id}/probe` | Zugang prüfen | | POST | `/api/v1/connectors/{id}/probe` | gespeicherten Zugang prüfen; Ergebnis (auch ein Fehler) wird als Prüfstand festgehalten. Es gibt keine Prüfung mit ungespeicherten Entwürfen |
| GET | `/api/v1/sources/capabilities` | erklärte Such-, Lese- und Editorfähigkeiten; nicht Vorhandenes bleibt falsch | | GET | `/api/v1/sources/capabilities` | erklärte Such-, Lese- und Editorfähigkeiten; nicht Vorhandenes bleibt falsch |
| GET | `/api/v1/sources/{kind}/search` | Suche der registrierten Quelle im erklärten Umfang; unbekannte Art und nicht erklärte Filter antworten `422` | | GET | `/api/v1/sources/{kind}/search` | Suche der registrierten Quelle im erklärten Umfang; unbekannte Art und nicht erklärte Filter antworten `422` |
| GET | `/api/v1/sources/{kind}/navigate?connector_id=` | Fachnavigation, wenn die Quelle sie erklärt | | GET | `/api/v1/sources/{kind}/navigate?connector_id=` | Fachnavigation, wenn die Quelle sie erklärt |
+2 -2
View File
@@ -1,6 +1,6 @@
# Tsumugu – Datenmodell (Ist-Stand) # Tsumugu – Datenmodell (Ist-Stand)
**Stand:** 19.10.2026, nach den Migrationen in `backend/migrations/` (letzte: `20261019T150000Z_source_registry.sql`). Entstanden im Code-Review vom 18.10.2026 und für die Connector-Grundlage nachgezogen. Die Arten `connectors.kind` und `external_references.source` prüft die Registrierung. Die früheren Prüflisten in der Datenbank sind entfernt. `url` bleibt eine Referenz ohne Connector. **Stand:** 19.10.2026, nach den Migrationen in `backend/migrations/` (letzte: `20261020T120000Z_connector_probe_status.sql`). Entstanden im Code-Review vom 18.10.2026 und für die Connector-Grundlage nachgezogen. Die Arten `connectors.kind` und `external_references.source` prüft die Registrierung. Die früheren Prüflisten in der Datenbank sind entfernt. `url` bleibt eine Referenz ohne Connector.
Die Sollfassung steht in der [technischen Spezifikation, Abschnitt 4](TSUMUGU_TECHNICAL_SPEC.md). Diese Datei beschreibt, was tatsächlich angelegt ist. Bei jeder neuen Migration nachziehen. Die Sollfassung steht in der [technischen Spezifikation, Abschnitt 4](TSUMUGU_TECHNICAL_SPEC.md). Diese Datei beschreibt, was tatsächlich angelegt ist. Bei jeder neuen Migration nachziehen.
@@ -75,7 +75,7 @@ Die Sollfassung steht in der [technischen Spezifikation, Abschnitt 4](TSUMUGU_TE
| Tabelle | Wesentliche Spalten | Regeln | | Tabelle | Wesentliche Spalten | Regeln |
|---|---|---| |---|---|---|
| `connectors` | `owner_id`, `kind` (`paperless`/`imap`), `name`, `settings` (JSON), `secret` (Klartext, Review R-05) | Mehrere Instanzen je Art sind möglich. Ein POST legt eine neue Instanz an. Ein PATCH ändert Zugangsdaten derselben Id. Das Secret bleibt im Adapter und ist keine SaaS-Schlüsselhaltung | | `connectors` | `owner_id`, `kind` (`paperless`/`imap`), `name`, `settings` (JSON), `secret` (Klartext, Review R-05), `last_probe_at`/`last_probe_ok`/`last_probe_detail` (nur Anzeige des letzten Prüfstands) | Mehrere Instanzen je Art sind möglich. Ein POST legt eine neue Instanz an. Ein PATCH ändert Zugangsdaten derselben Id. Das Secret bleibt im Adapter und ist keine SaaS-Schlüsselhaltung |
| `storage_instances` | `kind` (`local`), `generation` (eindeutig), `root_path` | Die Bestandsgeneration `legacy-local-1` wird einmal an die Wurzel gebunden. Ein späterer Wurzelwechsel erzeugt eine neue Generation und hängt alte Referenzen nicht um | | `storage_instances` | `kind` (`local`), `generation` (eindeutig), `root_path` | Die Bestandsgeneration `legacy-local-1` wird einmal an die Wurzel gebunden. Ein späterer Wurzelwechsel erzeugt eine neue Generation und hängt alte Referenzen nicht um |
| `domain_events` | `actor_subject_id`, `scope_id`, `action`, `resource_kind`, `resource_id`, `context_kind/id`, `occurred_on`, `occurred_at`, `result` | append-only; Grundlage von Chronologie und fachlichem Verlauf | | `domain_events` | `actor_subject_id`, `scope_id`, `action`, `resource_kind`, `resource_id`, `context_kind/id`, `occurred_on`, `occurred_at`, `result` | append-only; Grundlage von Chronologie und fachlichem Verlauf |
@@ -91,3 +91,11 @@ Die Bedienprüfung lief gegen eine lokale API mit nachgebildetem IMAP und einem
| K5 Registrierung | Die Leserhülle ruft die registrierte Darstellung auf. Die Beispielquelle bringt Formular und Registrierung in ihrem eigenen Modul mit und erscheint in der Produktauslieferung nicht. | Die Leserhülle rendert die Testdarstellung und speichert über den registrierten Testeditor. Bedienung mit `?probe=1`: Beispielquelle verbinden, nach „Proben“ suchen, übernehmen, öffnen, erneut öffnen, Übergabepaket prüfen und herunterladen. Der Download antwortete mit 200; der Prüfstand nannte `Probenbrief/Probenbrief.txt`. | Bestanden in der Testoberfläche. | Die Beispielquelle ist kein Produktzugang. | | K5 Registrierung | Die Leserhülle ruft die registrierte Darstellung auf. Die Beispielquelle bringt Formular und Registrierung in ihrem eigenen Modul mit und erscheint in der Produktauslieferung nicht. | Die Leserhülle rendert die Testdarstellung und speichert über den registrierten Testeditor. Bedienung mit `?probe=1`: Beispielquelle verbinden, nach „Proben“ suchen, übernehmen, öffnen, erneut öffnen, Übergabepaket prüfen und herunterladen. Der Download antwortete mit 200; der Prüfstand nannte `Probenbrief/Probenbrief.txt`. | Bestanden in der Testoberfläche. | Die Beispielquelle ist kein Produktzugang. |
| K6 Paperless-Antworten | Eine verspätete Suche oder Facette schreibt nicht in die inzwischen gewählte Instanz. Der Instanzwechsel leert Filter und Trefferliste. | Bedienung am Stellvertreter: Suche auf „Alt“ starten, zu „Neu“ wechseln, die späte Antwort abwarten. Zugang, leere Suche und Facette blieben bei Neu. Die anschließende Suche zeigte „Treffer Neu“. Schließen während einer laufenden Suche ließ die Vorgangsliste unverändert. | In der Bedienung bestanden. | Keine echte Paperless-Instanz. | | K6 Paperless-Antworten | Eine verspätete Suche oder Facette schreibt nicht in die inzwischen gewählte Instanz. Der Instanzwechsel leert Filter und Trefferliste. | Bedienung am Stellvertreter: Suche auf „Alt“ starten, zu „Neu“ wechseln, die späte Antwort abwarten. Zugang, leere Suche und Facette blieben bei Neu. Die anschließende Suche zeigte „Treffer Neu“. Schließen während einer laufenden Suche ließ die Vorgangsliste unverändert. | In der Bedienung bestanden. | Keine echte Paperless-Instanz. |
| K7 Filter und reale Quellen | Der synthetische Paperless-Abruf filtert den Katalog nach Inhalt, Titel, Metadaten, Datum und Seite. | `test_paperless_filters_change_the_hits`: nur der Inhaltstreffer, nur Titel „Vertrag“, die kombinierte Teilmenge und die zweite Seite unterscheiden sich. | Synthetisch bestanden. | Weder die bestehende Paperless-Dokumentabfrage noch das bestehende Postfach wurden ausgeführt. Schema-Lesen vom 19.10. ersetzt das nicht. | | K7 Filter und reale Quellen | Der synthetische Paperless-Abruf filtert den Katalog nach Inhalt, Titel, Metadaten, Datum und Seite. | `test_paperless_filters_change_the_hits`: nur der Inhaltstreffer, nur Titel „Vertrag“, die kombinierte Teilmenge und die zweite Seite unterscheiden sich. | Synthetisch bestanden. | Weder die bestehende Paperless-Dokumentabfrage noch das bestehende Postfach wurden ausgeführt. Schema-Lesen vom 19.10. ersetzt das nicht. |
## Konfigurationsansicht am 20.10.2026
Die Konfiguration einer Instanz gehört dem Modul. Ein Modul deklariert `config_fields` (`ConfigField` in `backend/app/sourceregistry.py`) und optional `normalize_config` für Protokollprüfungen. `parse_fields` validiert Pflicht, Typ, Grenzen und unbekannte Schlüssel; ein leeres Geheimnisfeld behält das gespeicherte. `/api/v1/sources/capabilities` liefert die Felder unter `modules`. Die Oberfläche (`frontend/src/sources/config-form.jsx`, `connector-config.jsx`, Route `sources/:connectorId`) rendert sie generisch; ein Modul kann mit `Form` im UI-Registereintrag eine eigene Maske mitbringen. Paperless (Adresse, API-Schlüssel) und IMAP (Server, Port, Verbindung, Benutzer, Passwort, Standardfach) sind darauf umgestellt; die flachen Felder der ersten Lieferung bleiben nur als Kompatibilität in `ConnectorIn`.
Neuer Connector: Modul mit `config_fields` in `register_source` eintragen, UI-Modul mit `registerSourceModule` registrieren. Kein Eingriff in `ConnectorIn`, `Sources.jsx` oder die Fachseiten.
Nachweis und Grenzen: `backend/tests/test_connector_config.py` (Manifest, Geheimnis, Instanzerhalt, Fremdzugriff, Prüfstand) und `frontend/src/sources/config-core.test.mjs` (6 Node-Tests bestanden), Frontend-Build erfolgreich. Die Backend-Tests wurden in dieser Umgebung **nicht ausgeführt** (kein Python, keine PostgreSQL-Instanz). Keine Bedienprüfung im Browser. Zugangsdaten bleiben im Klartext (R-05); Archivmodus und DataPolicy sind nicht Teil dieses Schnitts.
+92
View File
@@ -0,0 +1,92 @@
# 10 – Nachprüfung gegen Richtlinien und Blueprints
**Stand:** 20.10.2026 · **Geprüfter Code:** Branch `develop`, Commit `c29bd29` · **Vorgänger:** Review vom 18.10.2026 auf Commit `f21c64a` ([README](README.md)) · **Art:** statische Nachprüfung, keine Codeänderung
## Umfang und Grenzen
Seit `f21c64a` kamen 33 Commits hinzu (rund 17 900 Zeilen). Geprüft wurde:
1. Ob die 31 Befunde R-01 bis R-31 aus [06_BEFUNDE.md](06_BEFUNDE.md) im aktuellen Code noch bestehen.
2. Ob die neuen Connector-Module (`sourceaccess.py`, `sourcebind.py`, `sourceport.py`, `sourceregistry.py`, `media/port.py`, Frontend `sources/`) den Connector-/Storage-Vertrag v0.1 und die Blueprints in `docs/reference` einhalten.
Ausgeführt wurde: `npm ci` und `vite build` (erfolgreich). **Nicht** ausgeführt wurden die Backend-Tests und `py_compile`: Auf diesem Rechner ist kein Python installiert, und es gibt keine PostgreSQL-Instanz. Die Aussagen zu Backend-Verhalten beruhen auf Codelektüre. Die Node-Tests lieferten keine auswertbare Ausgabe und sind nicht bewertet. Die Nachprüfung deckt die Stellen ab, die in den Befunden genannt sind, und die neuen Module. Sie ist keine zweite Vollprüfung aller 17 900 Zeilen.
## 1. Stand der früheren Befunde
| ID | Früher | Jetzt | Beleg im aktuellen Code |
|---|---|---|---|
| R-01 Bearbeiter löschen Akte/Vorgang | Hoch | **offen** | [ops.py:519-545](../../backend/app/ops.py#L519-L545): `delete_case` und `delete_matter` verlangen weiter nur `edit` |
| R-02 Detach/Anmerkung ohne Kontextbindung | Hoch | **offen** | [ops.py:956-989](../../backend/app/ops.py#L956-L989): `detach_binding` vergleicht nur die Kontext**art**; `_binding_in_page` (Zeile 371) wird nicht verwendet |
| R-03 Aktive Inhalte `inline` | Hoch | **offen** | [api/sources.py:105](../../backend/app/api/sources.py#L105) und [:207](../../backend/app/api/sources.py#L207): Paperless-Original und Mail-Anlage `inline` mit Absender-MIME; keine Sandbox-CSP |
| R-04 Web-Bootstrap, keine MFA | Hoch | **offen** | [routes.py:292-300](../../backend/app/api/routes.py#L292-L300) |
| R-05 Secrets im Klartext | Mittel | **offen, jetzt dokumentiert** | `connectors.secret` unverändert; [sourceport.py:77](../../backend/app/sourceport.py#L77) führt das Profil `legacy-plaintext` ausdrücklich (Vertrag v0.1, Abschnitt 7 erlaubt das als Legacy-Zustand) |
| R-06 SSRF / Redirect mit Token | Mittel | **teilweise** | Dateiabruf prüft den Zielhost nach Redirect ([sources.py:467-471](../../backend/app/sources.py#L467-L471)); `_paperless_get` und `_paperless_metadata` ([:501](../../backend/app/sources.py#L501), [:577](../../backend/app/sources.py#L577)) folgen Redirects weiter mit `Authorization`-Header. Keine Host-Allowlist |
| R-07 Vorgangsausnahmen wirken nicht auf Inhalte | Mittel | nicht neu geprüft | `policy.py` geändert (64 Zeilen), Befund nicht gezielt nachverfolgt |
| R-08 Session-/Login-Härtung | Hoch | **offen** | [settings.py:27](../../backend/app/core/settings.py#L27) 336 h; [routes.py:163](../../backend/app/api/routes.py#L163) Login-Zähler im Prozessspeicher; [security.py:23-27](../../backend/app/auth/security.py#L23-L27) kein Dummy-Vergleich |
| R-09 Gemeinsame DB-Zugangsdaten, Migrator ohne Lock | Mittel | **offen** | [docker-compose.yml:30-34](../../docker-compose.yml#L30-L34), [migrate.py](../../backend/app/db/migrate.py): kein Advisory-Lock, keine Fehlend-Prüfung |
| R-10 Quelle über Zugang des Betrachters | Mittel | **behoben** | [sourceaccess.py](../../backend/app/sourceaccess.py), [sourcebind.py](../../backend/app/sourcebind.py): Referenz ist an `connector_id` gebunden, Abruf über den Owner-Zugang (`mediated_source_owner`), kein Fallback auf den zuletzt angelegten Zugang, Audit `source_read_mediated` |
| R-11 `LIMIT` vor Rechteprüfung | Hoch | **offen** | [routes.py:1358-1389](../../backend/app/api/routes.py#L1358-L1389) (`LIMIT 200`), Suche `LIMIT 100` ([:1450](../../backend/app/api/routes.py#L1450)) |
| R-12 Zweite Teilvorgangsebene durch Verschieben | Mittel | **offen** | [ops.py:558-596](../../backend/app/ops.py#L558-L596): nur Zyklusprüfung, keine Ebenenprüfung |
| R-13 Bezugsziele blockieren Export | Mittel | nicht neu geprüft | `exporting.py` stark verändert (787 Zeilen) |
| R-14 bis R-19 | – | nicht neu geprüft | – |
| R-20 Unbekannter Zeichensatz | Niedrig | **teilweise** | [mailpack.py:330](../../backend/app/mailpack.py#L330) fängt `LookupError`; [sources.py:960](../../backend/app/sources.py#L960) ruft `decode_transfer` ohne Schutz auf, und `decode_transfer` selbst ([mailpack.py:178](../../backend/app/mailpack.py#L178)) wirft bei unbekanntem Zeichensatz |
| R-21 P7 fehlt | Hoch | **offen** | [deploy-prod.yml](../../.gitea/workflows/deploy-prod.yml): Push auf `main` baut und startet ohne Gate; kein Backup/Restore |
| R-22 Externe Aufrufe in offener Transaktion | Mittel | **teilweise behoben** | `release_for_external` in [sourceaccess.py:29](../../backend/app/sourceaccess.py#L29) und `complete_borrow` mit erneuter Rechteprüfung sind der richtige Schnitt; die Restpunkte stehen unter 2.1 |
| R-23 Commit-Zeitpunkt | Mittel | **offen** | [deps.py:30-43](../../backend/app/api/deps.py#L30-L43) unverändert, FastAPI 0.115.6 gepinnt |
| R-24 Request-ID, Problem-Typen | Niedrig | **offen** | keine `X-Request-ID` im Code |
| R-25 Frontend-Transport ohne Timeout/Abbruch | Niedrig | **offen** | [api.js](../../frontend/src/api.js) enthält weder `AbortController` noch Timeout |
| R-26 Abhängigkeiten | Niedrig | **offen** | `requirements.txt` ohne Hashes; Vite/`pdfjs-dist` wie zuvor |
| R-27 CI | Mittel | **offen** | [test.yml](../../.gitea/workflows/test.yml): zwei Auslöser, feste `tsumugu_test`, `pip install` im Laufzeitimage, Tests nicht Gate für Prod |
| R-31 Uploads ohne Normalisierung | Hoch | **offen** | keine Bildbibliothek in `requirements.txt` |
**Fazit:** Alle acht hohen Befunde aus dem Review vom 18.10. sind unverändert offen (R-01, R-02, R-03, R-04, R-08, R-11, R-21, R-31). Die Arbeit der letzten drei Tage ging fast vollständig in den Connector-Umbau. Dort wurde R-10 geschlossen und R-22 zur Hälfte.
## 2. Neue Befunde aus der Nachprüfung
### 2.1 N-01 – Externe Abrufe laufen teils weiter in der Fachtransaktion (Mittel)
Der Nacharbeitsbericht [TSUMUGU_CONNECTOR_NACHARBEIT_REVIEW_2026-10-20.md](../product/TSUMUGU_CONNECTOR_NACHARBEIT_REVIEW_2026-10-20.md) nennt vier Restpunkte, davon betrifft Punkt 1 genau Medien-Blueprint und Vertrag Abschnitt 7 („externe Aufrufe außerhalb offener Fachtransaktionen“). In dieser Nachprüfung nicht erneut gegen den Code belegt, aber Commit `c29bd29` („verspätete Quellenantworten“) behandelt nur Punkt 4 erkennbar. Vor der Abnahme prüfen, ob Punkt 1 (IMAP-Lesepfad, Export, Versandfassung) und Punkt 2 (Markdown-Renderer) geschlossen sind.
### 2.2 N-02 – `complete_borrow` committet bei Fehlern nur im Audit-Fall (Niedrig)
[sourceaccess.py:67-68](../../backend/app/sourceaccess.py#L67-L68): `audit_mediated` committet bei `outcome != "ok"` mitten im Request. Das ist gewollt, damit das Audit eines abgelehnten Abrufs den folgenden Rollback übersteht, bricht aber die Regel „ein Transaktionskontext je Anwendungsfall“ (A3) und verlässt sich darauf, dass der Aufrufer danach nichts Unfertiges in der Transaktion hält. Bitte im Code kommentieren und mit einem Test absichern.
### 2.3 N-03 – Download der Mail-Anlage liefert `inline` für jede Anlage (Hoch, Teil von R-03)
[api/sources.py:207](../../backend/app/api/sources.py#L207) übergibt `inline=True` für jede Anlage, ohne Allowlist. Der neue `media_type` stammt weiter aus der E-Mail. Eine `text/html`- oder `image/svg+xml`-Anlage wird damit im App-Origin angezeigt. Das ist nach dem Datei-Blueprint 9.3 ein Vertragsverstoß und sollte vor der Anbindung echter Postfächer geschlossen werden.
## 3. Abgleich mit den Blueprints
Die Vertragstabellen in [05_REFERENZARCHITEKTUR_BLUEPRINTS.md](05_REFERENZARCHITEKTUR_BLUEPRINTS.md) gelten weiter. Änderungen durch die neuen Module:
| Blueprint | Vorgabe | Status | Bemerkung |
|---|---|---|---|
| Datei-Blueprint 7 | Storage hinter Port, opake Referenzen | ✅ verbessert | `media/port.py` (Adapter, `adapter_for`), Migration `source_storage` |
| Datei-Blueprint 7.2 | Keine behauptete Atomarität, Reconciliation | 🟡 | `discard_stored` räumt nach Commit/Rollback auf; weiter kein dauerhafter Intent und kein Reconciler |
| Datei-Blueprint 9.3 | Dokumente als `attachment`, restriktive CSP | ❌ | siehe R-03, N-03 |
| A2 | Router → Service → Repository | 🟡 | neue Schnitte (Source-Port, Registry, Bind) sind sauber; `sources.py` hat 1 653 Zeilen, `ops.py` 1 594, `routes.py` 1 886, `correspondence.py` 1 636, `exporting.py` 1 416 |
| A3 | Externe Kommunikation außerhalb der Transaktion | 🟡 | `release_for_external` neu, nicht überall angewendet (siehe 2.1) |
| A5 | Migrationen mit Ledger, Lock, Fehlend-Prüfung | 🟡 | unverändert |
| A8 | Fail-closed Zugriff | ✅ | `borrow_original` verweigert ohne `mediated_source_owner`, prüft nach dem Abruf erneut (`_recheck`) |
| Connector-Vertrag 4 | Fähigkeiten je Quelle, nicht unterstützte Filter melden | ✅ | `sourceport.py`: `CAPABILITIES`, `unsupported_filters` |
| Connector-Vertrag 4 | Kein Fallback auf die zuletzt angelegte Verbindung | ✅ | `sourcebind.resolve_for_read`, `ambiguous` verlangt bewusste Zuordnung |
| Connector-Vertrag 7 | Schutzprofil, Legacy-Klartext ausdrücklich | ✅ | `protection_profiles` in `capability_payload` |
| Connector-Vertrag 5 | Registrierte Komponenten statt Quellverzweigungen in Fachseiten | 🟡 | `sources/registry.jsx` ordnet Medien Lesernamen zu; `ReadingPane.jsx` und `NoteEditor` bleiben fest verdrahtet (Nacharbeitsbericht Punkt 3) |
| KI-/Prompt-/Entitlement-Blueprints | nur als Grenze | ✅ | keine KI-Bibliothek, keine Provider-Anbindung im Code |
## 4. Empfohlene Reihenfolge
Die Reihenfolge folgt dem Risiko für echte Daten, nicht der ID.
1. **Vor jedem Echtbetrieb:** R-21 (Prod-Gate, Backup), R-03/N-03 (Auslieferung), R-01/R-02 (Rechte), R-11 (Übersicht verliert Einträge). Alle vier sind klein bis mittel im Aufwand und haben im Review vom 18.10. bereits konkrete Empfehlungen.
2. **Auth:** R-04 und R-08 gemeinsam als eigenes Paket (Bootstrap, Sessionlaufzeit, Dummy-Vergleich, persistente Begrenzung).
3. **Connector-Abschluss:** Restpunkte 1 bis 3 des Nacharbeitsberichts, R-06 (Redirects), R-20 (`sources.py:960`).
4. **Struktur:** die fünf großen Module aufteilen, bevor weitere Funktionen dazukommen.
5. **Betrieb/CI:** R-27, R-23, R-09, R-24, R-25, R-26.
## 5. Nicht geprüft
- Backend-Tests (82 laut Abschlussmatrix) wurden nicht ausgeführt, kein Python, keine PostgreSQL-Instanz.
- Befunde R-07, R-13 bis R-19, R-28 bis R-30 sind nicht gegen den aktuellen Code abgeglichen.
- Das Frontend wurde nur gebaut, nicht in einem Browser bedient.
- Keine echte Paperless- oder IMAP-Quelle angesprochen.
+2
View File
@@ -10,6 +10,7 @@ import { MatterList, MatterDetail } from "./pages/Matters.jsx";
import { Rooms } from "./pages/Rooms.jsx"; import { Rooms } from "./pages/Rooms.jsx";
import { Search } from "./pages/Search.jsx"; import { Search } from "./pages/Search.jsx";
import { Sources } from "./pages/Sources.jsx"; import { Sources } from "./pages/Sources.jsx";
import { ConnectorConfig } from "./sources/connector-config.jsx";
import { Users } from "./pages/Users.jsx"; import { Users } from "./pages/Users.jsx";
import { Work } from "./pages/Work.jsx"; import { Work } from "./pages/Work.jsx";
import { Settings } from "./pages/Settings.jsx"; import { Settings } from "./pages/Settings.jsx";
@@ -106,6 +107,7 @@ export function App() {
<Route path="settings" element={<Settings />} /> <Route path="settings" element={<Settings />} />
<Route path="rooms" element={<Rooms />} /> <Route path="rooms" element={<Rooms />} />
<Route path="sources" element={<Sources />} /> <Route path="sources" element={<Sources />} />
<Route path="sources/:connectorId" element={<ConnectorConfig />} />
<Route path="users" element={<Users />} /> <Route path="users" element={<Users />} />
<Route path="search" element={<Search />} /> <Route path="search" element={<Search />} />
</Route> </Route>
+27 -158
View File
@@ -1,8 +1,9 @@
import { useEffect, useRef, useState } from "react"; import { useEffect, useRef, useState } from "react";
import { Link } from "react-router-dom"; import { Link, useNavigate } from "react-router-dom";
import { api, fetchBlob } from "../api.js"; import { api, fetchBlob } from "../api.js";
import { MailBody } from "../mail-view.jsx"; import { MailBody } from "../mail-view.jsx";
import { SourceFrame, moduleFor, registerSourceModule, sourceModules } from "../sources/registry.jsx"; import { NewConnector, useSourceModules } from "../sources/connector-config.jsx";
import { SourceFrame, registerSourceModule } from "../sources/registry.jsx";
const SEARCH_LIMITS = { const SEARCH_LIMITS = {
paperless: "Suchtext gilt für Titel und Dokumentinhalt. Zusätzlich gibt es Titel, Korrespondent, Dokumenttyp, Tags, Dokumentdatum und Sortierung.", paperless: "Suchtext gilt für Titel und Dokumentinhalt. Zusätzlich gibt es Titel, Korrespondent, Dokumenttyp, Tags, Dokumentdatum und Sortierung.",
@@ -15,10 +16,9 @@ import { ErrorNote } from "./widgets.jsx";
export function Sources() { export function Sources() {
const [items, setItems] = useState([]); const [items, setItems] = useState([]);
const [error, setError] = useState(""); const [error, setError] = useState("");
const [notice, setNotice] = useState(""); const [adding, setAdding] = useState(false);
const [renew, setRenew] = useState(null); const { modules, error: moduleError } = useSourceModules();
const modules = sourceModules(); const navigate = useNavigate();
const RenewForm = renew ? moduleFor(renew.kind)?.Form : null;
async function load() { async function load() {
const data = await api("/api/v1/connectors"); const data = await api("/api/v1/connectors");
@@ -29,6 +29,8 @@ export function Sources() {
load().catch((err) => setError(err.message)); load().catch((err) => setError(err.message));
}, []); }, []);
const labels = new Map(modules.map((item) => [item.kind, item.label]));
return ( return (
<main className="page"> <main className="page">
<header className="page-head"> <header className="page-head">
@@ -36,145 +38,31 @@ export function Sources() {
<h1>Quellen</h1> <h1>Quellen</h1>
<p className="muted">Paperless und E-Mail-Konten bleiben bei dir. Eine Verknüpfung zeigt in der Akte nur Titel und Herkunft.</p> <p className="muted">Paperless und E-Mail-Konten bleiben bei dir. Eine Verknüpfung zeigt in der Akte nur Titel und Herkunft.</p>
</div> </div>
{modules.length ? <button type="button" onClick={() => setAdding(true)} disabled={adding}>Quelle hinzufügen</button> : null}
</header> </header>
<ErrorNote error={error} /> <ErrorNote error={error || moduleError} />
{notice ? <p className="notice">{notice}</p> : null} {adding ? (
<NewConnector
modules={modules}
onCancel={() => setAdding(false)}
onSaved={(saved) => navigate(`/sources/${saved.id}`)}
/>
) : null}
{!items.length && !adding ? <p className="muted">Noch keine Quelle verbunden.</p> : null}
<div className="tiles"> <div className="tiles">
{items.map((item) => ( {items.map((item) => (
<article key={item.id} className="tile"> <Link key={item.id} to={`/sources/${item.id}`} className="tile">
<span className="tile__kind">{moduleFor(item.kind)?.title || item.kind}</span> <span className="tile__kind">{labels.get(item.kind) || item.kind}</span>
<strong>{item.name}</strong> <strong>{item.name}</strong>
<span>{item.settings.base_url || item.settings.username || item.settings.catalog || ""}</span> <span>{item.settings.base_url || item.settings.username || item.settings.catalog || ""}</span>
<div className="row"> <span>{item.probe ? (item.probe.ok ? "Zuletzt erreichbar" : "Letzte Prüfung fehlgeschlagen") : "Noch nicht geprüft"}</span>
<button type="button" className="quiet" onClick={() => probe(item.id, setNotice, setError)}>Prüfen</button> </Link>
<button type="button" className="quiet" onClick={() => setRenew(item)}>Zugang erneuern</button>
<button type="button" className="danger" onClick={() => remove(item.id, load, setError)}>Entfernen</button>
</div>
</article>
))} ))}
</div> </div>
{renew ? (
<section className="card">
<h2>Zugang erneuern: {renew.name}</h2>
<p className="muted">Dasselbe Konto behält seine Instanz. Eine weitere Instanz legst du darunter neu an.</p>
{RenewForm ? (
<RenewForm
connectorId={renew.id}
initialName={renew.name}
settings={renew.settings}
onSaved={async () => { setRenew(null); await load(); }}
onError={setError}
/>
) : (
<p className="muted">Dieser Zugang wird über sein Modul erneuert.</p>
)}
</section>
) : null}
{modules.filter((module) => module.Form).map((module) => (
<section key={module.kind} className="card">
<h2>{module.title}</h2>
<module.Form onSaved={load} onError={setError} />
</section>
))}
</main> </main>
); );
} }
function PaperlessForm({ onSaved, onError, connectorId = "", initialName = "Paperless", initialUrl = "", settings = null }) {
const [name, setName] = useState(initialName);
const [baseUrl, setBaseUrl] = useState(settings?.base_url || initialUrl);
const [token, setToken] = useState("");
async function submit(event) {
event.preventDefault();
onError("");
try {
const body = { kind: "paperless", name, base_url: baseUrl, token };
if (connectorId) {
await api(`/api/v1/connectors/${connectorId}`, { method: "PATCH", body });
} else {
await api("/api/v1/connectors", { method: "POST", body });
}
setToken("");
await onSaved();
} catch (err) {
onError(err.message);
}
}
return (
<form onSubmit={submit} className="stack">
<label>Name <input value={name} onChange={(event) => setName(event.target.value)} required /></label>
<label>Adresse <input value={baseUrl} onChange={(event) => setBaseUrl(event.target.value)} placeholder="https://paperless.example" required /></label>
<label>API-Schlüssel <input type="password" value={token} onChange={(event) => setToken(event.target.value)} autoComplete="off" required /></label>
<button type="submit">{connectorId ? "Zugang dieser Instanz erneuern" : "Paperless-Instanz verbinden"}</button>
</form>
);
}
function MailForm({
onSaved,
onError,
connectorId = "",
initialName = "",
initialHost = "",
initialPort = "993",
initialUsername = "",
initialSecurity = "ssl",
settings = null,
}) {
const [name, setName] = useState(initialName);
const [host, setHost] = useState(settings?.host || initialHost);
const [port, setPort] = useState(String(settings?.port || initialPort));
const [username, setUsername] = useState(settings?.username || initialUsername);
const [password, setPassword] = useState("");
const [security, setSecurity] = useState(settings?.security || initialSecurity);
async function submit(event) {
event.preventDefault();
onError("");
try {
const body = {
kind: "imap",
name: name || username,
host,
port: Number(port),
username,
password,
security,
mailbox: "INBOX",
};
if (connectorId) {
await api(`/api/v1/connectors/${connectorId}`, { method: "PATCH", body });
} else {
await api("/api/v1/connectors", { method: "POST", body });
}
setPassword("");
await onSaved();
} catch (err) {
onError(err.message);
}
}
return (
<form onSubmit={submit} className="stack">
<label>Name <input value={name} onChange={(event) => setName(event.target.value)} placeholder="Postfach" /></label>
<label>Server <input value={host} onChange={(event) => setHost(event.target.value)} placeholder="imap.example" required /></label>
<label>Port <input value={port} onChange={(event) => setPort(event.target.value)} required /></label>
<label>
Verbindung
<select value={security} onChange={(event) => setSecurity(event.target.value)}>
<option value="ssl">SSL</option>
<option value="starttls">STARTTLS</option>
</select>
</label>
<label>Benutzername <input value={username} onChange={(event) => setUsername(event.target.value)} required /></label>
<label>Passwort <input type="password" value={password} onChange={(event) => setPassword(event.target.value)} autoComplete="off" required /></label>
<button type="submit">{connectorId ? "Zugang dieses Kontos erneuern" : "Konto hinzufügen"}</button>
</form>
);
}
function paperlessLabel(item) { function paperlessLabel(item) {
const dated = formatDate(item.document_on); const dated = formatDate(item.document_on);
return dated !== "Ohne Datum" ? `${dated} · ${item.title}` : item.title; return dated !== "Ohne Datum" ? `${dated} · ${item.title}` : item.title;
@@ -653,7 +541,9 @@ export function MailPicker({ context, placement, chapterId = "", chapterTitle =
if (!alive) return; if (!alive) return;
const list = data.items || []; const list = data.items || [];
setFolders(list); setFolders(list);
const preferred = list.find((item) => item.selectable && item.name.toUpperCase() === "INBOX") const standard = accounts.find((item) => item.id === accountId)?.settings?.mailbox;
const preferred = (standard && list.find((item) => item.selectable && item.name === standard))
|| list.find((item) => item.selectable && item.name.toUpperCase() === "INBOX")
|| list.find((item) => item.selectable); || list.find((item) => item.selectable);
setMailbox(preferred ? preferred.name : ""); setMailbox(preferred ? preferred.name : "");
if (!preferred) setLoading(""); if (!preferred) setLoading("");
@@ -893,26 +783,5 @@ export function MailPicker({ context, placement, chapterId = "", chapterTitle =
); );
} }
async function probe(id, setNotice, setError) { registerSourceModule({ kind: "paperless", title: "Paperless", addLabel: "Paperless", manual: true, searchHint: SEARCH_LIMITS.paperless, Picker: PaperlessPicker });
setError(""); registerSourceModule({ kind: "imap", title: "E-Mail-Konto", addLabel: "E-Mail", wide: true, searchHint: SEARCH_LIMITS.imap, Picker: MailPicker });
setNotice("");
try {
const data = await api(`/api/v1/connectors/${id}/probe`, { method: "POST" });
setNotice(data.detail);
} catch (err) {
setError(err.message);
}
}
async function remove(id, load, setError) {
setError("");
try {
await api(`/api/v1/connectors/${id}`, { method: "DELETE" });
await load();
} catch (err) {
setError(err.message);
}
}
registerSourceModule({ kind: "paperless", title: "Paperless", addLabel: "Paperless", manual: true, searchHint: SEARCH_LIMITS.paperless, Form: PaperlessForm, Picker: PaperlessPicker });
registerSourceModule({ kind: "imap", title: "E-Mail-Konto", addLabel: "E-Mail", wide: true, searchHint: SEARCH_LIMITS.imap, Form: MailForm, Picker: MailPicker });
+48
View File
@@ -0,0 +1,48 @@
// Pure helpers for module-declared configuration fields. No React, so Node can test them.
export function initialValues(fields, settings = null) {
const values = {};
for (const field of fields || []) {
if (field.secret) {
values[field.key] = "";
continue;
}
const stored = settings?.[field.key];
const value = stored ?? field.default ?? "";
values[field.key] = String(value);
}
return values;
}
// A blank secret is left out when an existing instance is edited: the server keeps the stored one.
export function fieldsToPayload(fields, values, { editing = false } = {}) {
const config = {};
const missing = [];
for (const field of fields || []) {
const raw = values?.[field.key] ?? "";
const blank = String(raw).trim() === "";
if (blank) {
if (field.secret && editing) continue;
if (field.required) missing.push(field.label);
continue;
}
if (field.type === "number") {
const number = Number(String(raw).trim());
config[field.key] = Number.isInteger(number) ? number : String(raw).trim();
} else {
config[field.key] = field.secret ? String(raw) : String(raw).trim();
}
}
return { config, missing };
}
export function missingMessage(missing) {
if (!missing.length) return "";
return missing.length === 1 ? `${missing[0]} fehlt.` : `Es fehlen: ${missing.join(", ")}.`;
}
export function probeSummary(probe) {
if (!probe) return "Noch nicht geprüft.";
const state = probe.ok ? "Erreichbar" : "Fehlgeschlagen";
return probe.detail ? `${state}: ${probe.detail}` : state;
}
+51
View File
@@ -0,0 +1,51 @@
import assert from "node:assert/strict";
import test from "node:test";
import { fieldsToPayload, initialValues, missingMessage, probeSummary } from "./config-core.js";
const fields = [
{ key: "host", label: "Server", type: "text", required: true },
{ key: "port", label: "Port", type: "number", required: true, default: 993 },
{ key: "mailbox", label: "Standardfach", type: "text", default: "INBOX" },
{ key: "password", label: "Passwort", type: "password", required: true, secret: true },
];
test("new instances start with the declared defaults and an empty secret", () => {
assert.deepEqual(initialValues(fields), { host: "", port: "993", mailbox: "INBOX", password: "" });
});
test("stored settings win over defaults and a secret is never prefilled", () => {
const values = initialValues(fields, { host: "mail.example.test", port: 143, password: "geheim" });
assert.equal(values.host, "mail.example.test");
assert.equal(values.port, "143");
assert.equal(values.password, "");
});
test("a new instance needs every required field including the secret", () => {
const { config, missing } = fieldsToPayload(fields, { host: "h", port: "993", mailbox: "", password: "" });
assert.deepEqual(missing, ["Passwort"]);
assert.deepEqual(config, { host: "h", port: 993 });
assert.equal(missingMessage(missing), "Passwort fehlt.");
});
test("editing leaves a blank secret out so the server keeps the stored one", () => {
const { config, missing } = fieldsToPayload(
fields,
{ host: " mail.example.test ", port: "143", mailbox: "Archiv", password: "" },
{ editing: true },
);
assert.deepEqual(missing, []);
assert.deepEqual(config, { host: "mail.example.test", port: 143, mailbox: "Archiv" });
assert.equal("password" in config, false);
});
test("a new secret is sent unchanged, a non-number stays a string for the server to refuse", () => {
const { config } = fieldsToPayload(fields, { host: "h", port: "abc", mailbox: "", password: " pw " }, { editing: true });
assert.equal(config.password, " pw ");
assert.equal(config.port, "abc");
});
test("the last check is summarised without inventing a state", () => {
assert.equal(probeSummary(null), "Noch nicht geprüft.");
assert.equal(probeSummary({ ok: true, detail: "Das Postfach ist erreichbar." }), "Erreichbar: Das Postfach ist erreichbar.");
assert.equal(probeSummary({ ok: false, detail: "" }), "Fehlgeschlagen");
});
+108
View File
@@ -0,0 +1,108 @@
import { useState } from "react";
import { api } from "../api.js";
import { ErrorNote } from "../pages/widgets.jsx";
import { fieldsToPayload, initialValues, missingMessage } from "./config-core.js";
import { moduleFor } from "./registry-core.js";
const INPUT_TYPES = { text: "text", url: "url", number: "number", password: "password" };
export function ConfigFields({ fields, values, onChange, editing = false, hasSecret = false, disabled = false }) {
return (
<>
{fields.map((field) => {
const id = `config-${field.key}`;
const hint = field.secret && editing && hasSecret ? "Unverändert lassen, wenn der Schlüssel gleich bleibt." : field.help;
return (
<label key={field.key} htmlFor={id}>
{field.label}
{field.type === "select" ? (
<select id={id} value={values[field.key] ?? ""} disabled={disabled} onChange={(event) => onChange(field.key, event.target.value)}>
{field.options.map((option) => <option key={option.value} value={option.value}>{option.label}</option>)}
</select>
) : (
<input
id={id}
type={INPUT_TYPES[field.type] || "text"}
value={values[field.key] ?? ""}
disabled={disabled}
required={field.required && !(field.secret && editing && hasSecret)}
autoComplete={field.secret ? "new-password" : "off"}
placeholder={field.secret && editing && hasSecret ? "••••••••" : field.placeholder || ""}
min={field.minimum ?? undefined}
max={field.maximum ?? undefined}
maxLength={field.type === "number" ? undefined : field.max_length}
onChange={(event) => onChange(field.key, event.target.value)}
/>
)}
{hint ? <span className="muted">{hint}</span> : null}
</label>
);
})}
</>
);
}
// One form for a new or an existing instance. A module may bring its own `Form` instead.
export function ConnectorForm({ module, connector = null, onSaved, onError }) {
const fields = module.config_fields || [];
const [name, setName] = useState(connector?.name || module.label || "");
const [values, setValues] = useState(() => initialValues(fields, connector?.settings));
const [pending, setPending] = useState(false);
const [error, setError] = useState("");
const editing = Boolean(connector);
const Custom = moduleFor(module.kind)?.Form;
if (Custom) {
return <Custom connectorId={connector?.id || ""} initialName={connector?.name || module.label} settings={connector?.settings || null} onSaved={onSaved} onError={onError} />;
}
async function submit(event) {
event.preventDefault();
setError("");
onError?.("");
const { config, missing } = fieldsToPayload(fields, values, { editing });
if (!name.trim()) missing.unshift("Name");
if (missing.length) {
setError(missingMessage(missing));
return;
}
setPending(true);
try {
const body = { kind: module.kind, name: name.trim(), config };
const saved = editing
? await api(`/api/v1/connectors/${connector.id}`, { method: "PATCH", body })
: await api("/api/v1/connectors", { method: "POST", body });
setValues((current) => {
const next = { ...current };
for (const field of fields) if (field.secret) next[field.key] = "";
return next;
});
await onSaved?.(saved);
} catch (err) {
setError(err.message);
} finally {
setPending(false);
}
}
return (
<form onSubmit={submit} className="stack">
<label htmlFor="config-name">
Name
<input id="config-name" value={name} maxLength={120} required disabled={pending} onChange={(event) => setName(event.target.value)} />
</label>
<ConfigFields
fields={fields}
values={values}
editing={editing}
hasSecret={Boolean(connector?.has_secret)}
disabled={pending}
onChange={(key, value) => setValues((current) => ({ ...current, [key]: value }))}
/>
<ErrorNote error={error} />
<div className="row">
<button type="submit" disabled={pending}>{editing ? "Änderungen speichern" : `${module.label} verbinden`}</button>
</div>
</form>
);
}
+202
View File
@@ -0,0 +1,202 @@
import { useEffect, useState } from "react";
import { Link, useNavigate, useParams } from "react-router-dom";
import { api } from "../api.js";
import { ErrorNote } from "../pages/widgets.jsx";
import { probeSummary } from "./config-core.js";
import { ConnectorForm } from "./config-form.jsx";
export function useSourceModules() {
const [modules, setModules] = useState([]);
const [error, setError] = useState("");
useEffect(() => {
let alive = true;
api("/api/v1/sources/capabilities")
.then((data) => {
if (alive) setModules(data.modules || []);
})
.catch((err) => {
if (alive) setError(err.message);
});
return () => {
alive = false;
};
}, []);
return { modules, error };
}
const OPERATIONS = [
["navigate", "Ordner und Struktur durchsuchen"],
["read_preview", "Vorschau vor dem Übernehmen"],
["read_original", "Original abrufen"],
["read_attachment", "Anlagen abrufen"],
["edit_content", "Inhalt in der Quelle bearbeiten"],
["edit_metadata", "Metadaten in der Quelle bearbeiten"],
];
const SEARCH_FILTERS = [
["query", "Suchtext"],
["title", "Titel"],
["correspondent", "Korrespondent"],
["document_type", "Dokumenttyp"],
["tags", "Tags"],
["document_range", "Dokumentdatum"],
["sort", "Sortierung"],
["continuation", "Weitere Seiten"],
];
function Availability({ items, source }) {
return (
<ul className="plain-list">
{items.map(([key, label]) => (
<li key={key}>
{label}: <strong>{source[key] ? "ja" : "nicht verfügbar"}</strong>
</li>
))}
</ul>
);
}
export function NewConnector({ modules, onSaved, onCancel }) {
const [kind, setKind] = useState(modules[0]?.kind || "");
const module = modules.find((item) => item.kind === kind) || modules[0];
const [error, setError] = useState("");
if (!module) return <p className="muted">Es ist keine Quelle registriert.</p>;
return (
<section className="card stack" aria-label="Quelle hinzufügen">
<h2>Quelle hinzufügen</h2>
{modules.length > 1 ? (
<label htmlFor="new-source-kind">
Art der Quelle
<select id="new-source-kind" value={module.kind} onChange={(event) => { setKind(event.target.value); setError(""); }}>
{modules.map((item) => <option key={item.kind} value={item.kind}>{item.label}</option>)}
</select>
</label>
) : null}
<ErrorNote error={error} />
<ConnectorForm key={module.kind} module={module} onSaved={onSaved} onError={setError} />
{onCancel ? <button type="button" className="quiet" onClick={onCancel}>Abbrechen</button> : null}
</section>
);
}
export function ConnectorConfig() {
const { connectorId } = useParams();
const navigate = useNavigate();
const { modules, error: moduleError } = useSourceModules();
const [connector, setConnector] = useState(null);
const [error, setError] = useState("");
const [notice, setNotice] = useState("");
const [checking, setChecking] = useState(false);
const [confirming, setConfirming] = useState(false);
async function load() {
setConnector(await api(`/api/v1/connectors/${connectorId}`));
}
useEffect(() => {
setConnector(null);
setError("");
load().catch((err) => setError(err.message));
}, [connectorId]);
async function check() {
setChecking(true);
setError("");
setNotice("");
try {
const result = await api(`/api/v1/connectors/${connectorId}/probe`, { method: "POST" });
setNotice(result.detail || "Die Verbindung wurde geprüft.");
} catch (err) {
setError(err.message);
} finally {
setChecking(false);
await load().catch(() => {});
}
}
async function remove() {
setError("");
try {
await api(`/api/v1/connectors/${connectorId}`, { method: "DELETE" });
navigate("/sources");
} catch (err) {
setError(err.message);
}
}
const module = modules.find((item) => item.kind === connector?.kind);
const capabilities = connector?.capabilities;
return (
<main className="page">
<header className="page-head">
<div>
<p className="muted"><Link to="/sources">Quellen</Link></p>
<h1>{connector?.name || "Zugang"}</h1>
{module ? <p className="muted">{module.label}</p> : null}
</div>
</header>
<ErrorNote error={error || moduleError} />
{notice ? <p className="notice" role="status">{notice}</p> : null}
{connector && module ? (
<div className="stack">
<section className="card stack" aria-label="Zugang">
<h2>Zugang</h2>
<ConnectorForm
key={`${connector.id}-${connector.name}-${connector.probe?.at || ""}`}
module={module}
connector={connector}
onSaved={async () => { setNotice("Gespeichert. Die Instanz und ihre Verknüpfungen bleiben dieselben."); await load(); }}
onError={setError}
/>
</section>
<section className="card stack" aria-label="Verbindung">
<h2>Verbindung</h2>
<p>{probeSummary(connector.probe)}</p>
{connector.probe?.at ? <p className="muted">Zuletzt geprüft: {new Date(connector.probe.at).toLocaleString("de-DE")}</p> : null}
<div className="row">
<button type="button" className="quiet" disabled={checking} onClick={check}>{checking ? "Prüft …" : "Verbindung prüfen"}</button>
</div>
</section>
{capabilities ? (
<section className="card stack" aria-label="Fähigkeiten">
<h2>Fähigkeiten</h2>
<Availability items={OPERATIONS} source={capabilities} />
<h3>Suche</h3>
<Availability items={SEARCH_FILTERS} source={capabilities.search || {}} />
</section>
) : null}
<section className="card stack" aria-label="Verwendung und Schutz">
<h2>Verwendung und Schutz</h2>
<p>{connector.references === 1 ? "Eine eigene Verknüpfung nutzt diesen Zugang." : `${connector.references} eigene Verknüpfungen nutzen diesen Zugang.`}</p>
<p className="muted">
Zugangsdaten sind derzeit unverschlüsselt in der Datenbank abgelegt (Schutzprofil „{connector.protection_profile}“) und werden nie wieder angezeigt.
</p>
</section>
<section className="card stack" aria-label="Entfernen">
<h2>Entfernen</h2>
{confirming ? (
<>
<p>
{connector.references
? `${connector.references} Verknüpfung(en) bleiben in den Akten stehen, lassen sich aber nicht mehr öffnen, bis ein anderer Zugang zugeordnet ist.`
: "Dieser Zugang wird entfernt."}
</p>
<div className="row">
<button type="button" className="danger" onClick={remove}>Endgültig entfernen</button>
<button type="button" className="quiet" onClick={() => setConfirming(false)}>Abbrechen</button>
</div>
</>
) : (
<div className="row">
<button type="button" className="danger" onClick={() => setConfirming(true)}>Zugang entfernen</button>
</div>
)}
</section>
</div>
) : !error ? (
<p className="muted">Wird geladen …</p>
) : null}
</main>
);
}
-29
View File
@@ -1,33 +1,5 @@
import { createElement, useState } from "react";
import { api } from "../api.js";
import { registerSourceModule, unregisterSourceModule } from "./registry-core.js"; import { registerSourceModule, unregisterSourceModule } from "./registry-core.js";
function SampleForm({ onSaved, onError, connectorId = "", initialName = "Beispielquelle", settings = null }) {
const [name, setName] = useState(initialName);
const [catalog, setCatalog] = useState(settings?.catalog || "alpha");
async function submit(event) {
event.preventDefault();
onError("");
try {
const body = { kind: "sample", name, config: { catalog } };
if (connectorId) await api(`/api/v1/connectors/${connectorId}`, { method: "PATCH", body });
else await api("/api/v1/connectors", { method: "POST", body });
await onSaved();
} catch (err) {
onError(err.message);
}
}
return createElement(
"form",
{ onSubmit: submit, className: "stack" },
createElement("label", null, "Name ", createElement("input", { value: name, onChange: (event) => setName(event.target.value), required: true })),
createElement("label", null, "Katalog ", createElement("input", { value: catalog, onChange: (event) => setCatalog(event.target.value), required: true })),
createElement("button", { type: "submit" }, connectorId ? "Zugang erneuern" : "Beispielquelle verbinden"),
);
}
export function installSampleSource() { export function installSampleSource() {
return registerSourceModule({ return registerSourceModule({
kind: "sample", kind: "sample",
@@ -35,7 +7,6 @@ export function installSampleSource() {
addLabel: "Beispielquelle", addLabel: "Beispielquelle",
representation: "text", representation: "text",
manual: true, manual: true,
Form: SampleForm,
}); });
} }
+2
View File
@@ -1714,3 +1714,5 @@ button.pick-tree__twist {
@media (max-width: 390px) { @media (max-width: 390px) {
.source-filters label, .note-source__bar button, .note-editor button, .note-editor [role="radio"] { min-height: 44px; } .source-filters label, .note-source__bar button, .note-editor button, .note-editor [role="radio"] { min-height: 44px; }
} }
.plain-list { list-style: none; padding: 0; margin: 0; display: grid; gap: 4px; font-size: 14px; }