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:
maximeandClaude Opus 5.5 committed 2026-11-18 13:50:31 +01:00
1 parent 2f7ec25731
commit 369f2e0a44
12 files changed
+452 -16

No files matched your search

+119
View File
@@ -0,0 +1,119 @@
"""Le service d'accès (acces/service.py) et l'index de l'export Auth0, contre une base SQLite et un utilisateurs.json."""
import json
import sqlite3
import sys
import tempfile
import threading
import unittest
import urllib.error
import urllib.request
from pathlib import Path
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "acces"))
from exporter_utilisateurs import index_par_email # noqa: E402
from service import ROUTE, creer_serveur # noqa: E402
JETON = "j" * 40
UTILISATEURS = {"alice@client.ch": ["auth0|a1", "auth0|a2"], "bob@client.ch": ["auth0|b"]}
def creer_base(chemin: Path):
with sqlite3.connect(chemin) as c:
c.executescript("""
CREATE TABLE Device (id INTEGER PRIMARY KEY, serial_number VARCHAR, name VARCHAR UNIQUE);
CREATE TABLE UserGroup (id INTEGER PRIMARY KEY, device_id INTEGER, role VARCHAR);
CREATE TABLE UserGroupEntry (id INTEGER PRIMARY KEY, group_id INTEGER, user_id VARCHAR);
CREATE TABLE UserAccess (id INTEGER PRIMARY KEY, device_id INTEGER, user_id VARCHAR, access_type TEXT);
INSERT INTO Device VALUES (1, 'PONT', 'Voie Lac'), (2, 'PONT', 'Voie Jura'), (3, 'NORDEND', 'Nordend'),
(4, 'ALASKA', 'Alaska');
INSERT INTO UserGroup VALUES (10, 1, 'user'), (11, 2, 'dev_admin'), (12, 4, 'user'), (13, 99, 'user');
INSERT INTO UserGroupEntry (group_id, user_id) VALUES
(10, 'auth0|a1'), (11, 'auth0|a2'), (10, 'auth0|a2'), (13, 'auth0|a1'), (12, 'auth0|b');
-- l'ancienne table, ignorée comme par le dashboard
INSERT INTO UserAccess (device_id, user_id, access_type) VALUES (3, 'auth0|a1', 'read');
""")
c.close() # « with » valide la transaction mais ne ferme pas
class TestServiceAcces(unittest.TestCase):
def setUp(self):
dossier = tempfile.TemporaryDirectory()
self.addCleanup(dossier.cleanup)
self.base = Path(dossier.name) / "database.db"
self.utilisateurs = Path(dossier.name) / "utilisateurs.json"
creer_base(self.base)
self.utilisateurs.write_text(json.dumps(UTILISATEURS))
self.serveur = creer_serveur(("127.0.0.1", 0), JETON, str(self.base), str(self.utilisateurs))
self.serveur.RequestHandlerClass.log_message = lambda *a: None
threading.Thread(target=self.serveur.serve_forever, daemon=True).start()
self.addCleanup(self.serveur.server_close)
self.addCleanup(self.serveur.shutdown)
def demander(self, entetes: dict, route=ROUTE) -> tuple[int, dict]:
url = f"http://127.0.0.1:{self.serveur.server_address[1]}{route}"
try:
with urllib.request.urlopen(urllib.request.Request(url, headers=entetes), timeout=5) as r:
return r.status, json.load(r)
except urllib.error.HTTPError as e:
with e:
return e.code, json.load(e)
def client(self, email=None) -> tuple[int, dict]:
entetes = {"Authorization": f"Bearer {JETON}"}
if email is not None:
entetes["X-Libredesk-Contact-Email"] = email
return self.demander(entetes)
def test_sans_jeton_ou_mauvais_jeton_401(self):
for entetes in ({}, {"Authorization": "Bearer faux"}, {"Authorization": JETON}):
self.assertEqual(self.demander({**entetes, "X-Libredesk-Contact-Email": "alice@client.ch"})[0], 401)
def test_projets_avec_role_sans_useraccess_ni_device_supprime(self):
# a1 et a2 sont tous deux dans le groupe « user » de Voie Lac : une seule ligne ; a2 administre Voie Jura
self.assertEqual(self.client(" Alice@Client.CH "), (200, {"projects": [
{"project": "Voie Jura", "serial": "PONT", "role": "dev_admin"},
{"project": "Voie Lac", "serial": "PONT", "role": "user"}]}))
def test_dev_admin_l_emporte_sur_user_dans_le_meme_projet(self):
self.utilisateurs.write_text(json.dumps({"dan@client.ch": ["auth0|a2"]}))
with sqlite3.connect(self.base) as c:
c.execute("INSERT INTO UserGroup VALUES (14, 1, 'dev_admin')")
c.execute("INSERT INTO UserGroupEntry (group_id, user_id) VALUES (14, 'auth0|a2')")
c.close()
self.assertIn({"project": "Voie Lac", "serial": "PONT", "role": "dev_admin"}, self.client("dan@client.ch")[1]["projects"])
def test_inconnu_ou_sans_e_mail_liste_vide(self):
self.assertEqual(self.client("inconnu@ailleurs.ch"), (200, {"projects": []}))
self.assertEqual(self.client(), (200, {"projects": []}))
def test_nouvel_export_lu_sans_redemarrer(self):
self.utilisateurs.write_text(json.dumps({"carol@client.ch": ["auth0|b"]}))
self.assertEqual(self.client("carol@client.ch")[1],
{"projects": [{"project": "Alaska", "serial": "ALASKA", "role": "user"}]})
def test_fichier_ou_base_illisible_502_jamais_liste_vide(self):
self.utilisateurs.write_text("pas du json")
self.assertEqual(self.client("alice@client.ch"), (502, {"error": "access lookup unavailable"}))
self.utilisateurs.write_text(json.dumps(UTILISATEURS))
self.base.unlink()
self.assertEqual(self.client("alice@client.ch")[0], 502)
def test_autre_route_404(self):
self.assertEqual(self.demander({"Authorization": f"Bearer {JETON}"}, "/")[0], 404)
def test_base_jamais_modifiee(self):
avant = self.base.read_bytes()
self.client("alice@client.ch")
self.assertEqual(self.base.read_bytes(), avant)
class TestIndexParEmail(unittest.TestCase):
def test_minuscules_plusieurs_comptes_sans_e_mail_ignore(self):
self.assertEqual(index_par_email([
{"user_id": "auth0|2", "email": "Alice@Client.ch "}, {"user_id": "auth0|1", "email": "alice@client.ch"},
{"user_id": "auth0|3"}, {"user_id": "auth0|4", "email": None}]),
{"alice@client.ch": ["auth0|1", "auth0|2"]})
if __name__ == "__main__":
unittest.main()