"""Le client LibreDesk restreint : le seul code du dépôt qui parle à LibreDesk. Lire des conversations et des messages ; écrire seulement une note privée et des étiquettes (spec §7.2, §7.3). Pas de requête générique : une écriture qui n'est pas ici n'existe pas. `ecrire=False` (simulation) : rien n'est envoyé. """ import json import urllib.error import urllib.parse import urllib.request class Garde(Exception): """Anomalie du garde-fou d'envoi : l'appelant arrête toute l'exécution (spec §7.3).""" class LibreDesk: def __init__(self, url: str, cle: str, secret: str, ecrire: bool): self.url, self.ecrire = url.rstrip("/"), ecrire self._auth = f"token {cle}:{secret}" def _requete(self, methode: str, chemin: str, corps: dict | None = None) -> bytes: r = urllib.request.Request(urllib.parse.urljoin(self.url + "/", chemin.lstrip("/")), method=methode, data=json.dumps(corps).encode() if corps is not None else None, headers={"Content-Type": "application/json"}) r.add_unredirected_header("Authorization", self._auth) # pas vers S3 si une pièce redirige with urllib.request.urlopen(r, timeout=30) as rep: return rep.read() def _data(self, methode: str, chemin: str, corps: dict | None = None): return json.loads(self._requete(methode, chemin, corps) or b"{}").get("data") # --- lectures def moi(self) -> int: return self._data("GET", "/api/v1/agents/me")["id"] def ids_etiquettes(self) -> dict[str, int]: return {t["name"]: t["id"] for t in self._data("GET", "/api/v1/tags") or []} def conversations(self, avec: int) -> list[dict]: """Toutes les conversations qui portent l'étiquette d'id `avec`.""" filtre = json.dumps([{"model": "conversations", "field": "tags", "operator": "contains", "value": f"[{avec}]"}]) tout, page = [], 1 while True: d = self._data("GET", f"/api/v1/conversations/all?page_size=50&page={page}" f"&order_by=conversations.last_message_at&order=asc&filters={urllib.parse.quote(filtre)}") tout += d.get("results") or [] if page >= (d.get("total_pages") or 1): return tout page += 1 def etiquettes(self, uuid: str) -> list[str]: return self._data("GET", f"/api/v1/conversations/{uuid}").get("tags") or [] def messages(self, uuid: str) -> list[dict]: return self._data("GET", f"/api/v1/conversations/{uuid}/messages?page_size=500").get("results") or [] def piece(self, url: str) -> bytes: return self._requete("GET", url) # --- écritures def etiqueter(self, uuid: str, ajouter: list[str] = (), retirer: list[str] = ()) -> None: """Toujours add_tags / remove_tags : sans action, LibreDesk remplacerait toutes les étiquettes.""" if not self.ecrire: print(f"[simulation] {uuid} : + {list(ajouter)} − {list(retirer)}") return for action, noms in (("add_tags", ajouter), ("remove_tags", retirer)): if noms: self._data("POST", f"/api/v1/conversations/{uuid}/tags", {"tags": list(noms), "action": action}) if ajouter and (manque := set(ajouter) - set(self.etiquettes(uuid))): raise RuntimeError(f"étiquettes absentes de LibreDesk (ignorées en silence) : {sorted(manque)}") def note_privee(self, uuid: str, html: str) -> dict | None: """La seule écriture de message : private en dur, ni to, ni cc, ni bcc. Toute réponse qui n'est pas une note privée lève Garde.""" if not self.ecrire: print(f"[simulation] note pour {uuid} :\n{html}") return None try: m = self._data("POST", f"/api/v1/conversations/{uuid}/messages", {"message": html, "private": True, "sender_type": "agent"}) except urllib.error.HTTPError as e: raise Garde(f"note privée refusée ({e.code}) sur {uuid}") from e if not isinstance(m, dict) or m.get("private") is not True: raise Garde(f"la réponse de LibreDesk n'est pas une note privée ({uuid}) : {str(m)[:200]}") return m