Service d'accès : les projets du client au clic sur « Generate reply »
- 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>
This commit is contained in:
1 parent
2f7ec25731
commit
369f2e0a44
12 files changed
+452
-16
No files matched your search
@@ -0,0 +1,7 @@
|
||||
# Le service d'accès (acces/service.py) : bibliothèque standard seulement, rien à installer.
|
||||
# Version figée (2026-11-18) ; la changer = reconstruire et relancer tests/test_acces.py.
|
||||
FROM python:3.12.8-slim-bookworm
|
||||
COPY service.py /app/service.py
|
||||
USER nobody
|
||||
EXPOSE 8080
|
||||
CMD ["python", "-u", "/app/service.py"]
|
||||
@@ -0,0 +1,13 @@
|
||||
# Surcharge : rattache le service d'accès au réseau Docker de LibreDesk, où il est joignable sous le nom « acces »
|
||||
# (http://acces:8080/customer/access). Localement RESEAU_LIBREDESK=ldtest_libredesk ; sur le serveur, le réseau de LibreDesk.
|
||||
# RESEAU_LIBREDESK=<réseau> docker compose -f acces/compose.yml -f acces/compose.reseau.yml up -d
|
||||
services:
|
||||
acces:
|
||||
networks:
|
||||
libredesk:
|
||||
aliases: [acces]
|
||||
|
||||
networks:
|
||||
libredesk:
|
||||
name: ${RESEAU_LIBREDESK:?donner le réseau Docker de LibreDesk dans RESEAU_LIBREDESK}
|
||||
external: true
|
||||
@@ -0,0 +1,23 @@
|
||||
# Le service d'accès. Son port n'est publié que sur 127.0.0.1, sauf si ACCES_BIND donne une autre adresse (une adresse
|
||||
# INTERNE, jamais publique) ; ACCES_PORT change le port publié (8080 par défaut).
|
||||
# - acces/.env (hors de git, jamais lu par Claude) : ACCES_JETON, le même que l'en-tête « Authorization: Bearer … » de
|
||||
# l'outil get_customer_access de LibreDesk ; ACCES_BIND, ACCES_PORT, BASE_DASHBOARD s'il le faut ;
|
||||
# - BASE_DASHBOARD : le chemin, sur l'hôte, du database.db du dashboard (acces/database.db par défaut) ;
|
||||
# acces/utilisateurs.json : l'export d'Auth0 (acces/exporter_utilisateurs.py). Les deux montés en lecture seule.
|
||||
# docker compose -f acces/compose.yml up -d --build
|
||||
# Sur le réseau Docker de LibreDesk (URL de l'outil : http://acces:8080/customer/access) : ajouter compose.reseau.yml.
|
||||
services:
|
||||
acces:
|
||||
build: .
|
||||
image: exchange.sensima.ch/maxime.pasquier/libredesk-acces:1
|
||||
container_name: libredesk-acces
|
||||
restart: unless-stopped
|
||||
env_file: .env
|
||||
environment:
|
||||
ACCES_BASE: /data/database.db
|
||||
ACCES_UTILISATEURS: /data/utilisateurs.json
|
||||
volumes:
|
||||
- "${BASE_DASHBOARD:-./database.db}:/data/database.db:ro"
|
||||
- "./utilisateurs.json:/data/utilisateurs.json:ro"
|
||||
ports:
|
||||
- "${ACCES_BIND:-127.0.0.1}:${ACCES_PORT:-8080}:8080"
|
||||
@@ -0,0 +1,42 @@
|
||||
"""Les contacts de LibreDesk (lecture seule) : leurs e-mails, pour les comparer aux utilisateurs du dashboard (Auth0).
|
||||
|
||||
Lancé par Maxime (Claude ne lit pas le .env) :
|
||||
set -a && . ./.env && set +a && python3 acces/contacts.py
|
||||
Clé admin (LIBREDESK_ADMIN_KEY / _SECRET) : lister tous les contacts demande `contacts:read_all`, que la clé agent n'a
|
||||
pas. Seulement GET /api/v1/contacts. La liste complète va dans cases/ (hors de git) ; à l'écran, des totaux seulement.
|
||||
"""
|
||||
import collections
|
||||
import json
|
||||
import os
|
||||
import urllib.request
|
||||
from datetime import date
|
||||
from pathlib import Path
|
||||
|
||||
URL = os.environ.get("LIBREDESK_URL", "https://helpdesk.sensima.ch").rstrip("/")
|
||||
SORTIE = Path(__file__).resolve().parents[1] / "cases" / f"contacts-libredesk-{date.today()}.json"
|
||||
|
||||
|
||||
def page(n: int) -> dict:
|
||||
cle = f"token {os.environ['LIBREDESK_ADMIN_KEY']}:{os.environ['LIBREDESK_ADMIN_SECRET']}"
|
||||
requete = urllib.request.Request(f"{URL}/api/v1/contacts?page={n}&page_size=100", headers={"Authorization": cle})
|
||||
with urllib.request.urlopen(requete, timeout=30) as r:
|
||||
return json.load(r)["data"]
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
contacts, n = [], 1
|
||||
while True:
|
||||
d = page(n)
|
||||
contacts += d["results"]
|
||||
if n >= d["total_pages"]:
|
||||
break
|
||||
n += 1
|
||||
SORTIE.parent.mkdir(exist_ok=True)
|
||||
SORTIE.write_text(json.dumps(contacts, ensure_ascii=False, indent=1), encoding="utf-8")
|
||||
emails = [(c.get("email") or "").strip() for c in contacts]
|
||||
domaines = collections.Counter(e.rsplit("@", 1)[-1].lower() for e in emails if "@" in e)
|
||||
print(f"{URL} : {len(contacts)} contacts, {sum(map(bool, emails))} avec e-mail, "
|
||||
f"{sum(e != e.lower() for e in emails)} avec des majuscules, "
|
||||
f"{sum(bool(c.get('external_user_id')) for c in contacts)} avec external_user_id, "
|
||||
f"{len(domaines)} domaines")
|
||||
print(f"liste complète : {SORTIE}")
|
||||
@@ -0,0 +1,64 @@
|
||||
"""Exporte une fois les utilisateurs du dashboard depuis Auth0 (e-mail → auth0|…) dans acces/utilisateurs.json (hors de git).
|
||||
|
||||
Lecture seule (GET /users), avec l'application Auth0 du dashboard, comme sa page Settings (`get_all_users`).
|
||||
Lancé par Maxime avec les variables du dashboard (Claude ne lit pas ce .env) :
|
||||
set -a && . ~/monitoring-dashboard/.env && set +a && python3 acces/exporter_utilisateurs.py
|
||||
Variables : AUTH0_API_AUDIENCE (https://<tenant>/api/v2), AUTH0_API_CLIENTID, AUTH0_API_CLIENT_SECRET.
|
||||
À relancer quand des utilisateurs sont ajoutés au dashboard ; le service relit le fichier à chaque appel.
|
||||
"""
|
||||
import json
|
||||
import os
|
||||
import sys
|
||||
import urllib.parse
|
||||
import urllib.request
|
||||
from pathlib import Path
|
||||
|
||||
SORTIE = Path(__file__).resolve().parent / "utilisateurs.json"
|
||||
PAR_PAGE = 100
|
||||
|
||||
|
||||
def index_par_email(utilisateurs: list[dict]) -> dict[str, list[str]]:
|
||||
"""{e-mail en minuscules: [user_id…]} ; une adresse peut avoir plusieurs comptes, un compte sans e-mail est ignoré."""
|
||||
index: dict[str, list[str]] = {}
|
||||
for u in utilisateurs:
|
||||
email = (u.get("email") or "").strip().lower()
|
||||
if email:
|
||||
index.setdefault(email, []).append(u["user_id"])
|
||||
return {e: sorted(ids) for e, ids in sorted(index.items())}
|
||||
|
||||
|
||||
def jeton(api: str) -> str:
|
||||
u = urllib.parse.urlsplit(api)
|
||||
corps = json.dumps({"client_id": os.environ["AUTH0_API_CLIENTID"],
|
||||
"client_secret": os.environ["AUTH0_API_CLIENT_SECRET"],
|
||||
"audience": api + "/", "grant_type": "client_credentials"}).encode()
|
||||
requete = urllib.request.Request(f"{u.scheme}://{u.netloc}/oauth/token", corps, {"Content-Type": "application/json"})
|
||||
with urllib.request.urlopen(requete, timeout=30) as r:
|
||||
return json.load(r)["access_token"]
|
||||
|
||||
|
||||
def tous_les_utilisateurs(api: str) -> list[dict]:
|
||||
entete = {"Authorization": f"Bearer {jeton(api)}"}
|
||||
utilisateurs, page = [], 0
|
||||
while True:
|
||||
q = urllib.parse.urlencode({"page": page, "per_page": PAR_PAGE, "include_totals": "true",
|
||||
"fields": "user_id,email", "include_fields": "true"})
|
||||
with urllib.request.urlopen(urllib.request.Request(f"{api}/users?{q}", headers=entete), timeout=30) as r:
|
||||
d = json.load(r)
|
||||
utilisateurs += d["users"]
|
||||
if not d["users"] or len(utilisateurs) >= d["total"]:
|
||||
return utilisateurs
|
||||
page += 1
|
||||
# ponytail: Auth0 ne pagine que les 1000 premiers comptes ; au-delà, passer par un job d'export
|
||||
if page * PAR_PAGE >= 1000:
|
||||
sys.exit(f"plus de 1000 comptes ({d['total']}) : la pagination d'Auth0 ne suffit plus")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
api = os.environ["AUTH0_API_AUDIENCE"].rstrip("/")
|
||||
utilisateurs = tous_les_utilisateurs(api)
|
||||
index = index_par_email(utilisateurs)
|
||||
SORTIE.write_text(json.dumps(index, ensure_ascii=False, indent=1), encoding="utf-8")
|
||||
print(f"{len(utilisateurs)} comptes Auth0, {len(index)} adresses, "
|
||||
f"{sum(len(v) > 1 for v in index.values())} adresses avec plusieurs comptes, "
|
||||
f"{sum(not u.get('email') for u in utilisateurs)} comptes sans e-mail → {SORTIE}")
|
||||
@@ -0,0 +1,94 @@
|
||||
"""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()
|
||||
Reference in new issue
Block a user