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>
163 lines
5.2 KiB
Python
163 lines
5.2 KiB
Python
"""Registered source modules. Unknown kinds are rejected, not guessed."""
|
|
|
|
from __future__ import annotations
|
|
|
|
from dataclasses import dataclass
|
|
from typing import Callable
|
|
|
|
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
|
|
class SourceModule:
|
|
kind: str
|
|
label: str
|
|
representation: str
|
|
capabilities: dict
|
|
probe: Callable
|
|
find: Callable
|
|
open_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
|
|
preview: Callable | None = None
|
|
facets: Callable | None = None
|
|
|
|
|
|
_MODULES: dict[str, SourceModule] = {}
|
|
|
|
|
|
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
|
|
|
|
|
|
def unregister_source(kind: str) -> None:
|
|
_MODULES.pop(kind, None)
|
|
|
|
|
|
def registered_sources() -> list[SourceModule]:
|
|
return list(_MODULES.values())
|
|
|
|
|
|
def get_source(kind: str) -> SourceModule | None:
|
|
return _MODULES.get(kind)
|
|
|
|
|
|
def require_source(kind: str) -> SourceModule:
|
|
module = _MODULES.get(kind)
|
|
if module is None:
|
|
raise unprocessable("Diese Quelle ist nicht registriert.")
|
|
return module
|
|
|
|
|
|
def accepts_reference(source: str) -> bool:
|
|
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
|