Die gemeinsame Suchroute kennt keine Filternamen mehr; das Modul deklariert sie und unbekannte Parameter werden abgewiesen. Unvollständige Zusatzfeld-Zeilen werden gemeldet statt weggelassen. Vorschaubilder nur als Rastergrafik. Abschlussmatrix und API-Referenz nachgeführt. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
168 lines
5.6 KiB
Python
168 lines
5.6 KiB
Python
"""Registered source modules. Unknown kinds are rejected, not guessed."""
|
|
|
|
from __future__ import annotations
|
|
|
|
from dataclasses import dataclass, field
|
|
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
|
|
# Query parameter of a search, mapped to the capability flag that must be true for it.
|
|
# The module owns its filter names. Anything not declared here is refused.
|
|
search_params: dict[str, str] = field(default_factory=dict)
|
|
# thumbnail(conn, owner_id, connector_id, item) -> (bytes, media type), when the module declares it.
|
|
thumbnail: 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
|