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