"""Le service d'accès : les stations qu'un contact LibreDesk a le droit de voir (docs/architecture.drawio). GET /customer/access, appelé par l'outil `get_customer_access` de LibreDesk au clic sur « Generate reply » : - `Authorization: Bearer ` (l'en-tête secret déclaré dans l'outil), sinon 401 ; - `X-Libredesk-Contact-Email`, ajouté par LibreDesk lui-même, jamais par le LLM ; - e-mail → comptes du dashboard (utilisateurs.json, exporté d'Auth0 par exporter_utilisateurs.py) → leurs UserGroup → les projets (Device) : {"projects": [{"project": nom, "serial": station, "role": "dev_admin" | "user"}]}. Les deux rôles voient le projet sur le dashboard ; c'est la règle du dashboard (`Device.user_access`, `can_access_system`). La table UserAccess, ancienne, n'est plus lue par le dashboard : ignorée. ponytail: les admins globaux du dashboard (`is_admin()`, un rôle Auth0, absent de la base) voient tout là-bas mais reçoivent ici une liste vide ; laissé de côté (équipe interne, pas des clients) : exporter les rôles si ça change. Contact sans e-mail, inconnu ou sans droit : liste vide. Fichier ou base illisible : 502, jamais une liste vide (« aucun droit » serait faux). Variables : ACCES_JETON (32 caractères au moins), ACCES_BASE (database.db du dashboard, ouverte en lecture seule), ACCES_UTILISATEURS (utilisateurs.json, relu à chaque appel : un nouvel export sert sans redémarrer). Écoute toujours sur 8080 dans le conteneur ; le port publié se choisit dans le compose (ACCES_PORT). """ import hmac import json import os import sqlite3 import sys import urllib.parse from contextlib import closing from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer from pathlib import Path ROUTE = "/customer/access" VARIABLES = ("ACCES_JETON", "ACCES_BASE", "ACCES_UTILISATEURS") def comptes(utilisateurs: str, email: str) -> list[str]: """Les comptes du dashboard (auth0|…) de cette adresse.""" return json.loads(Path(utilisateurs).read_text(encoding="utf-8")).get(email, []) def projets(base: str, user_ids: list[str]) -> list[dict]: """Les projets (Device) dont l'un de ces comptes est membre d'un groupe : nom, station (serial) et rôle (`dev_admin` l'emporte sur `user` si le compte est dans les deux groupes du projet).""" if not user_ids: return [] with closing(sqlite3.connect(Path(base).resolve().as_uri() + "?mode=ro", uri=True)) as c: lignes = c.execute( "SELECT d.name, d.serial_number, MIN(CASE g.role WHEN 'dev_admin' THEN 0 ELSE 1 END) " "FROM UserGroupEntry e JOIN UserGroup g ON g.id = e.group_id JOIN Device d ON d.id = g.device_id " f"WHERE d.serial_number IS NOT NULL AND e.user_id IN ({','.join('?' * len(user_ids))}) " "GROUP BY d.id ORDER BY 2, 1", user_ids).fetchall() return [{"project": nom, "serial": serial, "role": "dev_admin" if r == 0 else "user"} for nom, serial, r in lignes] def creer_serveur(adresse: tuple[str, int], jeton: str, base: str, utilisateurs: str) -> ThreadingHTTPServer: attendu = f"Bearer {jeton}".encode() class Gestion(BaseHTTPRequestHandler): def _repondre(self, code: int, corps: dict): texte = json.dumps(corps, ensure_ascii=False).encode() self.send_response(code) self.send_header("Content-Type", "application/json") self.send_header("Content-Length", str(len(texte))) self.end_headers() self.wfile.write(texte) def do_GET(self): if urllib.parse.urlsplit(self.path).path != ROUTE: return self._repondre(404, {"error": "not found"}) if not hmac.compare_digest(self.headers.get("Authorization", "").encode(), attendu): return self._repondre(401, {"error": "unauthorized"}) email = self.headers.get("X-Libredesk-Contact-Email", "").strip().lower() try: liste = projets(base, comptes(utilisateurs, email)) if email else [] except Exception as e: # fichier ou base : on refuse plutôt que de répondre « aucun droit » self.log_error("recherche des droits impossible : %r", e) return self._repondre(502, {"error": "access lookup unavailable"}) # sans l'adresse : seulement si le contact a un e-mail et combien de projets il voit self.log_message("e-mail %s, %d projet(s)", "présent" if email else "absent", len(liste)) self._repondre(200, {"projects": liste}) return ThreadingHTTPServer(adresse, Gestion) if __name__ == "__main__": manquantes = [n for n in VARIABLES if not os.environ.get(n)] if manquantes: sys.exit("variables manquantes : " + ", ".join(manquantes)) if len(os.environ["ACCES_JETON"]) < 32: sys.exit("ACCES_JETON trop court (32 caractères au moins)") base, utilisateurs = os.environ["ACCES_BASE"], os.environ["ACCES_UTILISATEURS"] projets(base, comptes(utilisateurs, "")) # base et fichier lisibles, sinon on s'arrête au démarrage projets(base, ["-"]) serveur = creer_serveur(("0.0.0.0", 8080), os.environ["ACCES_JETON"], base, utilisateurs) print(f"service d'accès sur le port {serveur.server_address[1]}", flush=True) serveur.serve_forever()