- acces/ : conteneur (bibliothèque standard) qui répond à l'outil get_customer_access de LibreDesk. L'e-mail du contact (X-Libredesk-Contact-Email, ajouté par LibreDesk, jamais par le LLM) est traduit en compte auth0|… par l'export d'Auth0 (utilisateurs.json), puis en projets par les UserGroup de la base du dashboard (database.db, lecture seule) : project, serial, role. Jeton Bearer obligatoire ; fichier ou base illisible → 502, jamais une liste vide. - exporter_utilisateurs.py : l'export Auth0, lancé avec le .env du dashboard. - Données et secrets hors de git (acces/.env, database.db, utilisateurs.json), .env interdit à Claude. - Production : en service provisoire sur le PC de Maxime (point 14), vérifié sur un vrai « Generate reply » (1 projet renvoyé). Architecture draw.io : la partie accès. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
95 lines
5.2 KiB
Python
95 lines
5.2 KiB
Python
"""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 <ACCES_JETON>` (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()
|