Update app.py

app.py

@@ -443,12 +443,14 @@ def email_generate_async(token_id: str, variables: dict, items: List[dict]) -> d
 
 
 def wholix_login(email: str, password: str) -> str:
-    res = req(f"{WHOLIX_BASE_URL}/api/v1/auth/login", method="POST",
-              json_body={"email": email, "password": password}, timeout=(5.0, 15.0))
-    token = (res or {}).get("token")
-    if not token:
-        raise RuntimeError("Wholix-Login fehlgeschlagen.")
-    return token
+    """
+    Kompatibel zur alten Signatur (liefert weiterhin ein Token-String),
+    richtet aber zusätzlich den globalen Auto-ReLogin-Manager _WHOLIX_SES ein.
+    """
+    global _WHOLIX_SES
+    _WHOLIX_SES = WholixSession(email, password, base_url=WHOLIX_BASE_URL, session=GLOBAL_SES)
+    return _WHOLIX_SES.get_token()
+
 
 # ===================== Helfer für Platzhalter-E-Mail =======================
 
@@ -473,23 +475,90 @@ def _make_placeholder_email(record: dict) -> str:
 
 # ===================== Wholix Store + Fallbacks ============================
 
-def _store_with_fallbacks(token: str, payload: dict, module: str) -> dict:
+# ============================= Wholix Auth ================================
+
+# ============================= Wholix Auth (NEU) =============================
+
+# Globaler Session-Manager (wird in wholix_login gesetzt)
+_WHOLIX_SES = None  # type: Optional["WholixSession"]
+
+class WholixSession:
     """
-    Versucht 3 Stufen, um 422 zu vermeiden:
-    1) Original-Payload
-    2) Mit reparierten/entfernten URLs
-    3) Minimal-Record (email, firstname, lastname, company_name, exclude_hash, tags)
+    Kapselt Token-Handling:
+    - Login mit email/password
+    - Autorisierte Requests mit Auto-ReLogin bei 401/403/419 (ein Retry)
+    - Thread-sicher
     """
-    url = f"{WHOLIX_BASE_URL}/api/v1/table-object-data/store-objects"
-    headers = {"Authorization": f"Bearer {token}"}
+    def __init__(self, email: str, password: str, base_url: str = WHOLIX_BASE_URL, session: Optional[requests.Session] = None):
+        self.email = email
+        self.password = password
+        self.base_url = base_url.rstrip("/")
+        self._token = None
+        self._lock = threading.RLock()
+        self._ses = session or GLOBAL_SES
+
+    def _login(self) -> str:
+        res = req(f"{self.base_url}/api/v1/auth/login", method="POST",
+                  json_body={"email": self.email, "password": self.password},
+                  timeout=(5.0, 15.0), session=self._ses)
+        token = (res or {}).get("token")
+        if not token:
+            raise RuntimeError("Wholix-Login fehlgeschlagen.")
+        return token
+
+    def get_token(self) -> str:
+        if self._token:
+            return self._token
+        with self._lock:
+            if not self._token:
+                self._token = self._login()
+        return self._token
+
+    def auth_headers(self) -> Dict[str, str]:
+        return {"Authorization": f"Bearer {self.get_token()}"}
+
+    def req_authed(self, path: str, *, method: str = "GET", headers: Optional[Dict[str, str]] = None,
+                   json_body: Any = None, data: Any = None, timeout: Tuple[float, float] = (5.0, 30.0)):
+        url = path if path.startswith("http") else f"{self.base_url}{path}"
+        hdrs = {}
+        hdrs.update(headers or {})
+        hdrs.update(self.auth_headers())
+        try:
+            return req(url, method=method, headers=hdrs, json_body=json_body, data=data, timeout=timeout, session=self._ses)
+        except HTTPError as e:
+            if e.status in (401, 403, 419):
+                with self._lock:
+                    self._token = None
+                    self._token = self._login()
+                hdrs = {}
+                hdrs.update(headers or {})
+                hdrs.update(self.auth_headers())
+                return req(url, method=method, headers=hdrs, json_body=json_body, data=data, timeout=timeout, session=self._ses)
+            raise
+
 
-    def _post(body):
+
+def _store_with_fallbacks(token: str, payload: dict, module: str) -> dict:
+    """
+    Versucht 3 Stufen, um 422 zu vermeiden.
+    NEU: nutzt, wenn vorhanden, den globalen WholixSession-Manager (_WHOLIX_SES)
+         mit Auto-ReLogin. Fällt sonst auf das übergebene Token zurück.
+    """
+    url_path = "/api/v1/table-object-data/store-objects"
+
+    def _post_with_session(body):
+        # bevorzugt Auto-ReLogin-Session
+        if _WHOLIX_SES is not None:
+            return _WHOLIX_SES.req_authed(url_path, method="POST", json_body=body, timeout=(5.0, 30.0))
+        # Fallback: manuelles Token (legacy)
+        url = f"{WHOLIX_BASE_URL}{url_path}"
+        headers = {"Authorization": f"Bearer {token}"}
         return req(url, method="POST", headers=headers, json_body=body, timeout=(5.0, 30.0))
 
     # 1: Original
     body1 = {"module": module, "action": "store", "data": [payload]}
     try:
-        return _post(body1)
+        return _post_with_session(body1)
     except HTTPError as e:
         if e.status != 422:
             raise
@@ -504,7 +573,7 @@ def _store_with_fallbacks(token: str, payload: dict, module: str) -> dict:
             else:
                 p2.pop(k, None)
     try:
-        return _post({"module": module, "action": "store", "data": [p2]})
+        return _post_with_session({"module": module, "action": "store", "data": [p2]})
     except HTTPError as e:
         if e.status != 422:
             raise
@@ -518,25 +587,25 @@ def _store_with_fallbacks(token: str, payload: dict, module: str) -> dict:
         "exclude_hash": p2.get("exclude_hash") or _slug(uuid.uuid4().hex[:8]),
         "tags": p2.get("tags") or {"keys": ["no-email"], "values": ["no-email"]},
     }
-    return _post({"module": module, "action": "store", "data": [minimal]})
+    return _post_with_session({"module": module, "action": "store", "data": [minimal]})
 
 
 def wholix_store_contact(token: str, record: dict, module: str = "Contacts", allow_placeholder: bool = True) -> dict:
     """
     Sendet NUR erlaubte Felder an Wholix und saniert problematische Werte.
     IMMER speicherbar: erzeugt bei Bedarf Placeholder-Mail (example.com) + Tag.
-    Nutzt _store_with_fallbacks gegen 422.
+    Nutzt _store_with_fallbacks (mit Auto-ReLogin via _WHOLIX_SES, falls vorhanden).
     """
     if not isinstance(record, dict):
         raise ValueError("Wholix: record muss ein dict sein.")
 
-    # E-Mail prüfen / ggf. generieren
     def _clean_str(v):
         if v is None:
             return None
         s = str(v).strip()
         return s if s else None
 
+    # E-Mail prüfen / ggf. generieren
     email = _clean_str(record.get("email"))
     if not email or not EMAIL_RE.match(email):
         if allow_placeholder:
@@ -603,7 +672,7 @@ def wholix_store_contact(token: str, record: dict, module: str = "Contacts", all
     # Pflichtfeld sicher (jetzt inkl. Platzhalter möglich)
     out["email"] = _clean_str(email)
 
-    # POST mit Fallback-Logik
+    # POST mit Fallback-Logik (nutzt Auto-ReLogin falls _WHOLIX_SES vorhanden)
     return _store_with_fallbacks(token, out, module)
 
 
@@ -614,8 +683,12 @@ def wholix_fetch_excludes(token: str,
                           per_page: int = 500,
                           max_pages: int = 100,
                           dedupe: bool = True) -> List[Dict[str, str]]:
-    path = f"{WHOLIX_BASE_URL}/api/v1/table-object-data/fetch-paginated-results"
-    headers = {"Authorization": f"Bearer {token}"}
+    """
+    Paginiert Excludes laden.
+    NEU: nutzt, wenn vorhanden, den globalen WholixSession-Manager (_WHOLIX_SES)
+         mit Auto-ReLogin. Fällt sonst auf das übergebene Token zurück.
+    """
+    path = "/api/v1/table-object-data/fetch-paginated-results"
     out: List[Dict[str, str]] = []
     seen: Set[str] = set()
 
@@ -624,8 +697,14 @@ def wholix_fetch_excludes(token: str,
         if page > last_page:
             break
         payload = {"module": module_name, "action": "search", "page": page, "per_page": per_page}
+
         try:
-            res = req(path, method="POST", headers=headers, json_body=payload, timeout=(5.0, 30.0))
+            if _WHOLIX_SES is not None:
+                res = _WHOLIX_SES.req_authed(path, method="POST", json_body=payload, timeout=(5.0, 30.0))
+            else:
+                url = f"{WHOLIX_BASE_URL}{path}"
+                headers = {"Authorization": f"Bearer {token}"}
+                res = req(url, method="POST", headers=headers, json_body=payload, timeout=(5.0, 30.0))
         except Exception as e:
             APP_LOG.warning(f"Wholix-Excludes Page {page} Fehler: {e}")
             break