Comparer les révisions
6
Révisions
f0d8e041d8
...
f673b752b3
| Auteur | SHA1 | Date | ||
|---|---|---|---|---|
| ||||
|
|
f673b752b3 | |||
|
|
6462b41b30 | |||
|
|
0cf0b78822 | |||
|
|
94cf4187e0 | |||
|
|
c8dc543226 | |||
|
|
acdb96f616 | |||
Aucun fichier ne correspond à votre recherche
@@ -5,6 +5,10 @@ Contrat du Hub (Plan-connexion-Gastinel.md) :
|
||||
POST {hub}/oauth/jeton (formulaire) grant_type=authorization_code, code, redirect_uri, client_id, code_verifier[, client_secret]
|
||||
-> {"access_token", "token_type": "Bearer", "expires_in": 3600} ; erreurs {"error"} en 400/401/429
|
||||
GET {hub}/oauth/moi (Authorization: Bearer <jeton>) -> {"id": "<uuid>", "pseudo": "..."} ; sinon 401 {"error": "invalid_token"}
|
||||
GET {hub}/oauth/roles?id=<uuid> (Basic client_id:secret) -> {"id", "roles": [...]} ; 404 si le compte n'a jamais
|
||||
utilisé le forum. Mode FORUM_ROLES_DEPUIS_HUB=1 : le Hub est la source de vérité des rôles
|
||||
(gérés depuis le panneau admin) ; le forum les relit à chaque connexion / renouvellement.
|
||||
POST {hub}/oauth/roles (Basic) {"id", "roles"} : remplace les rôles (gestes faits dans le forum, reprise).
|
||||
|
||||
Le forum ne voit jamais le mot de passe ni l'e-mail : seulement l'identifiant et le pseudo.
|
||||
"""
|
||||
@@ -52,7 +56,7 @@ class Reglages:
|
||||
|
||||
def __init__(self, hub_url="", client_id="forum-vercors",
|
||||
redirect_uri=None, client_secret="",
|
||||
mode_test=False, relais=("127.0.0.1", "::1"), prefixe=""):
|
||||
mode_test=False, relais=("127.0.0.1", "::1"), prefixe="", roles_depuis_hub=False):
|
||||
self.prefixe = normaliser_prefixe(prefixe)
|
||||
self.hub_url = (hub_url or "").rstrip("/")
|
||||
if self.hub_url:
|
||||
@@ -65,6 +69,8 @@ class Reglages:
|
||||
self.client_secret = client_secret
|
||||
self.mode_test = bool(mode_test)
|
||||
self.relais = frozenset(relais)
|
||||
# Hub = source de vérité des rôles (exige le secret client pour lire /oauth/roles).
|
||||
self.roles_depuis_hub = bool(roles_depuis_hub)
|
||||
|
||||
@property
|
||||
def configuree(self):
|
||||
@@ -87,7 +93,8 @@ class Reglages:
|
||||
prefixe=env.get("FORUM_PREFIXE", ""),
|
||||
client_secret=secret,
|
||||
mode_test=_bool(env.get("FORUM_MODE_TEST")),
|
||||
relais=relais)
|
||||
relais=relais,
|
||||
roles_depuis_hub=_bool(env.get("FORUM_ROLES_DEPUIS_HUB")))
|
||||
|
||||
|
||||
# --- PKCE et adresse d'autorisation ------------------------------------------
|
||||
@@ -207,3 +214,48 @@ def pousser_roles(r, hub_id, roles_forum):
|
||||
pass
|
||||
except (urllib.error.URLError, OSError):
|
||||
pass # le Hub rattrapera à la prochaine connexion ou au prochain changement de rôle
|
||||
|
||||
|
||||
ROLES_HUB = ("adherent", "moderateur", "proprietaire_station", "proprietaire_adjoint", "proprietaire")
|
||||
|
||||
|
||||
def _basic(r):
|
||||
return "Basic " + base64.b64encode(("%s:%s" % (r.client_id, r.client_secret)).encode("utf-8")).decode("ascii")
|
||||
|
||||
|
||||
def lire_roles(r, hub_id):
|
||||
"""GET {hub}/oauth/roles?id= : rôles du compte selon le Hub (liste triée, rôles connus seulement).
|
||||
[] si le Hub ne connaît pas ce compte pour le forum (404) ; None si le Hub ne répond pas ou si rien n'est
|
||||
configuré : l'appelant garde alors les rôles qu'il a déjà."""
|
||||
if not r.client_secret or not r.hub_url or not ID_HUB_OK.match(hub_id or ""):
|
||||
return None
|
||||
req = urllib.request.Request(r.hub_url + "/oauth/roles?" + urllib.parse.urlencode({"id": hub_id}),
|
||||
headers={"Authorization": _basic(r), "Accept": "application/json"})
|
||||
try:
|
||||
with _OUVREUR.open(req, timeout=DELAI) as rep:
|
||||
brut = rep.read(REPONSE_MAX + 1)
|
||||
except urllib.error.HTTPError as ex:
|
||||
return [] if ex.code == 404 else None
|
||||
except (urllib.error.URLError, OSError):
|
||||
return None
|
||||
try:
|
||||
d = json.loads(brut[:REPONSE_MAX].decode("utf-8"))
|
||||
except ValueError:
|
||||
return None
|
||||
rs = d.get("roles") if isinstance(d, dict) else None
|
||||
if not isinstance(rs, list) or str(d.get("id", "")) != hub_id:
|
||||
return None
|
||||
return sorted(set(x for x in rs if isinstance(x, str) and x in ROLES_HUB))
|
||||
|
||||
|
||||
def modifier_roles(r, hub_id, ajouts, retraits):
|
||||
"""Écrit dans le Hub un changement fait dans le forum (adhésion validée, rôle donné au panneau du forum) :
|
||||
relit les rôles du Hub et n'applique que le changement, sans écraser ce que le panneau admin a changé
|
||||
entre-temps. Hub injoignable : rien n'est envoyé (False)."""
|
||||
actuels = lire_roles(r, hub_id)
|
||||
if actuels is None:
|
||||
return False
|
||||
nouveaux = (set(actuels) | set(ajouts)) - set(retraits)
|
||||
if nouveaux != set(actuels):
|
||||
pousser_roles(r, hub_id, nouveaux)
|
||||
return True
|
||||
+60
-1
@@ -1,5 +1,6 @@
|
||||
"""Schéma SQLite et accès aux données (version 4 : + sessions Gastinel, demandes d'adhésion, photos de la fiche station)."""
|
||||
import sqlite3
|
||||
import threading
|
||||
|
||||
SCHEMA = """
|
||||
CREATE TABLE IF NOT EXISTS users (
|
||||
@@ -129,6 +130,58 @@ SYSTEME = "systeme" # compte technique, auteur du sujet fixe
|
||||
BULLETIN = "Bulletin de la semaine du Vercors"
|
||||
|
||||
|
||||
class _Resultat:
|
||||
"""Résultat déjà lu sous le verrou (les lignes ne dépendent plus de la connexion partagée)."""
|
||||
def __init__(self, lignes, rowcount, lastrowid):
|
||||
self._l, self.rowcount, self.lastrowid = lignes, rowcount, lastrowid
|
||||
def fetchone(self):
|
||||
return self._l.pop(0) if self._l else None
|
||||
def fetchall(self):
|
||||
l, self._l = self._l, []
|
||||
return l
|
||||
def __iter__(self):
|
||||
return iter(self.fetchall())
|
||||
|
||||
|
||||
class ConnexionVerrouillee:
|
||||
"""Connexion SQLite partagée entre les fils du serveur : chaque appel passe sous un verrou et lit
|
||||
ses lignes tout de suite. Le verrou ne couvre que la base, jamais la lecture du réseau."""
|
||||
def __init__(self, con):
|
||||
self._con, self.verrou = con, threading.RLock()
|
||||
def execute(self, sql, params=()):
|
||||
with self.verrou:
|
||||
c = self._con.execute(sql, params)
|
||||
return _Resultat(c.fetchall(), c.rowcount, c.lastrowid)
|
||||
def executemany(self, sql, seq):
|
||||
with self.verrou:
|
||||
c = self._con.executemany(sql, seq)
|
||||
return _Resultat([], c.rowcount, c.lastrowid)
|
||||
def executescript(self, sql):
|
||||
with self.verrou:
|
||||
return self._con.executescript(sql)
|
||||
def commit(self):
|
||||
with self.verrou:
|
||||
self._con.commit()
|
||||
def rollback(self):
|
||||
with self.verrou:
|
||||
self._con.rollback()
|
||||
def __enter__(self): # « with con: » = une transaction entière sous le verrou
|
||||
self.verrou.acquire()
|
||||
try:
|
||||
self._con.__enter__()
|
||||
except BaseException:
|
||||
self.verrou.release()
|
||||
raise
|
||||
return self
|
||||
def __exit__(self, *exc):
|
||||
try:
|
||||
return self._con.__exit__(*exc)
|
||||
finally:
|
||||
self.verrou.release()
|
||||
def __getattr__(self, nom):
|
||||
return getattr(self._con, nom)
|
||||
|
||||
|
||||
def connecter(chemin=":memory:"):
|
||||
con = sqlite3.connect(chemin, check_same_thread=False)
|
||||
con.row_factory = sqlite3.Row
|
||||
@@ -180,10 +233,16 @@ def connecter(chemin=":memory:"):
|
||||
" user_id INTEGER NOT NULL REFERENCES users(id), kind TEXT NOT NULL,"
|
||||
" created_at TEXT NOT NULL DEFAULT (datetime('now')), PRIMARY KEY (post_id, user_id))")
|
||||
con.execute("CREATE INDEX IF NOT EXISTS idx_reactions_date ON reactions(created_at)")
|
||||
# Journal des suppressions définitives (06/11/2026) : qui, quoi, quand ; l'extrait garde une trace lisible.
|
||||
con.execute("CREATE TABLE IF NOT EXISTS journal_suppressions (id INTEGER PRIMARY KEY,"
|
||||
" acteur_id INTEGER NOT NULL REFERENCES users(id), acteur_nom TEXT NOT NULL,"
|
||||
" quoi TEXT NOT NULL CHECK (quoi IN ('sujet','message','commentaire')), cible_id INTEGER NOT NULL,"
|
||||
" sujet_id INTEGER, extrait TEXT NOT NULL DEFAULT '', details TEXT NOT NULL DEFAULT '',"
|
||||
" quand TEXT NOT NULL DEFAULT (datetime('now')))")
|
||||
con.execute("INSERT OR IGNORE INTO users(hub_id, display_name) VALUES (?, ?)", (SYSTEME, "vercors.me"))
|
||||
if con.execute("SELECT 1 FROM topics WHERE fixed=1").fetchone() is None:
|
||||
sid = con.execute("SELECT id FROM users WHERE hub_id=?", (SYSTEME,)).fetchone()[0]
|
||||
con.execute("INSERT INTO topics(title, author_id, fixed, pinned, pin_pos, replies_open)"
|
||||
" VALUES (?, ?, 1, 1, 0, 0)", (BULLETIN, sid))
|
||||
con.commit()
|
||||
return con
|
||||
return ConnexionVerrouillee(con)
|
||||
+148
-5
@@ -70,8 +70,49 @@ class Forum:
|
||||
self.dossier_photos = dossier_photos
|
||||
self.proprietaire_id = proprietaire_id or None # id Gastinel de Théo (FORUM_PROPRIETAIRE_ID)
|
||||
self.apres_roles = None # fonction(hub_id, roles) : envoie les rôles au Hub (branchée par server.py)
|
||||
# Mode « Hub = source de vérité » (FORUM_ROLES_DEPUIS_HUB=1, branché par server.py) :
|
||||
# lire_roles_hub(hub_id) -> liste | None : relu à chaque connexion / renouvellement de session ;
|
||||
# maj_roles_hub(hub_id, ajouts, retraits) : écrit dans le Hub un changement fait dans le forum.
|
||||
self.lire_roles_hub = None
|
||||
self.maj_roles_hub = None
|
||||
self.version = 0 # augmente à chaque changement visible sur les fiches de station (cache de server.py)
|
||||
|
||||
def _noms_roles(self, user_id):
|
||||
return {r[0] for r in self.con.execute("SELECT role FROM user_roles WHERE user_id=?", (user_id,))}
|
||||
|
||||
def _signaler(self, hub_id, avant, apres):
|
||||
"""Après un changement de rôles fait dans le forum. Mode Hub : seul le changement part vers le Hub
|
||||
(relu puis modifié). Sinon : l'ancienne poussée de tous les rôles."""
|
||||
if self.maj_roles_hub:
|
||||
ajouts, retraits = sorted(apres - avant), sorted(avant - apres)
|
||||
if ajouts or retraits:
|
||||
threading.Thread(target=self.maj_roles_hub, args=(hub_id, ajouts, retraits), daemon=True).start()
|
||||
return
|
||||
self._pousser_roles(hub_id)
|
||||
|
||||
# Rôles que le Hub fixe en mode Hub. « proprietaire » reste fixé par la configuration (FORUM_PROPRIETAIRE_ID).
|
||||
SYNCHRONISES = (roles.ADHERENT, roles.MODERATEUR, roles.ADJOINT, roles.STATION)
|
||||
|
||||
def synchroniser_roles(self, hub_id, roles_hub):
|
||||
"""Aligne les rôles locaux sur ceux du Hub. Le lien d'un propriétaire de station avec SA station reste
|
||||
local (le Hub ne connaît que le rôle) : gardé tant que le Hub donne le rôle, retiré sinon."""
|
||||
u = self._cible(hub_id)
|
||||
voulu = set(roles_hub or ()) & set(self.SYNCHRONISES)
|
||||
locaux = self._noms_roles(u["id"])
|
||||
for role in self.SYNCHRONISES:
|
||||
if role in voulu and role not in locaux:
|
||||
self.con.execute("INSERT OR IGNORE INTO user_roles(user_id, role, station) VALUES (?, ?, '')", (u["id"], role))
|
||||
elif role not in voulu and role in locaux:
|
||||
self.con.execute("DELETE FROM user_roles WHERE user_id=? AND role=?", (u["id"], role))
|
||||
self._nettoyer_station(u["id"])
|
||||
self.con.commit()
|
||||
|
||||
def _nettoyer_station(self, user_id):
|
||||
# Ligne « propriétaire de station » sans station : inutile dès qu'une vraie station est liée.
|
||||
self.con.execute("DELETE FROM user_roles WHERE user_id=? AND role=? AND station=''"
|
||||
" AND EXISTS (SELECT 1 FROM user_roles WHERE user_id=? AND role=? AND station<>'')",
|
||||
(user_id, roles.STATION, user_id, roles.STATION))
|
||||
|
||||
def _pousser_roles(self, hub_id):
|
||||
if not self.apres_roles:
|
||||
return
|
||||
@@ -98,7 +139,14 @@ class Forum:
|
||||
u = self.con.execute("SELECT * FROM users WHERE id=?", (u["id"],)).fetchone()
|
||||
if self.proprietaire_id and hub_id == self.proprietaire_id:
|
||||
u = self.fixer_proprietaire(hub_id, pseudo)
|
||||
self._pousser_roles(hub_id)
|
||||
if self.lire_roles_hub:
|
||||
# Hub = source de vérité : relu ici, avant d'ouvrir la session. Hub injoignable (None) : on garde
|
||||
# les rôles locaux, relus au prochain renouvellement.
|
||||
rs = self.lire_roles_hub(hub_id)
|
||||
if rs is not None:
|
||||
self.synchroniser_roles(hub_id, rs)
|
||||
else:
|
||||
self._pousser_roles(hub_id)
|
||||
return u
|
||||
|
||||
def ouvrir_session(self, user, jours=None, portee=""):
|
||||
@@ -222,19 +270,22 @@ class Forum:
|
||||
else:
|
||||
station = ""
|
||||
cible = self._cible(hub_id)
|
||||
avant = self._noms_roles(cible["id"])
|
||||
self.con.execute("INSERT OR IGNORE INTO user_roles(user_id, role, station, given_by) VALUES (?, ?, ?, ?)",
|
||||
(cible["id"], role, station, acteur["id"]))
|
||||
self._nettoyer_station(cible["id"])
|
||||
self.con.commit()
|
||||
self._pousser_roles(hub_id)
|
||||
self._signaler(hub_id, avant, self._noms_roles(cible["id"]))
|
||||
|
||||
def retirer_role(self, acteur, hub_id, role, station=""):
|
||||
if not roles.peut_donner(self.roles_de(acteur), role):
|
||||
raise Refus("retirer le rôle %s" % role)
|
||||
cible = self._cible(hub_id)
|
||||
avant = self._noms_roles(cible["id"])
|
||||
self.con.execute("DELETE FROM user_roles WHERE user_id=? AND role=? AND station=?",
|
||||
(cible["id"], role, station if role == roles.STATION else ""))
|
||||
self.con.commit()
|
||||
self._pousser_roles(hub_id)
|
||||
self._signaler(hub_id, avant, self._noms_roles(cible["id"]))
|
||||
|
||||
# --- lecture -------------------------------------------------------
|
||||
def _visible(self, user, t):
|
||||
@@ -592,10 +643,15 @@ class Forum:
|
||||
raise Invalide("demande déjà traitée")
|
||||
self.con.execute("UPDATE adhesions SET status=?, decided_by=?, decided_at=datetime('now') WHERE id=?",
|
||||
("acceptee" if accepte else "refusee", acteur["id"], demande_id))
|
||||
avant = self._noms_roles(d["user_id"])
|
||||
if accepte:
|
||||
self.con.execute("INSERT OR IGNORE INTO user_roles(user_id, role, given_by) VALUES (?, ?, ?)",
|
||||
(d["user_id"], roles.ADHERENT, acteur["id"]))
|
||||
self.con.commit()
|
||||
if self.maj_roles_hub and accepte:
|
||||
h = self.con.execute("SELECT hub_id FROM users WHERE id=?", (d["user_id"],)).fetchone()
|
||||
if h is not None:
|
||||
self._signaler(h[0], avant, self._noms_roles(d["user_id"]))
|
||||
|
||||
def photo_adhesion(self, acteur, nom):
|
||||
"""Chemin d'une photo de demande, si l'acteur a le droit de la voir et qu'elle appartient à une demande."""
|
||||
@@ -718,16 +774,103 @@ class Forum:
|
||||
return p["topic_id"], p["id"]
|
||||
|
||||
def supprimer_commentaire(self, user, comment_id):
|
||||
"""L'auteur supprime son commentaire (effacé de la base, signalements compris)."""
|
||||
"""L'auteur supprime son commentaire (effacé de la base, signalements compris) ;
|
||||
le propriétaire et l'adjoint aussi (droit « supprimer »), et c'est alors journalisé."""
|
||||
c = self._commentaire(comment_id)
|
||||
if user is None or c["author_id"] != user["id"]:
|
||||
if user is None:
|
||||
raise Refus("connexion requise")
|
||||
auteur = c["author_id"] == user["id"]
|
||||
if not auteur and not self._peut(user, "supprimer"):
|
||||
raise Refus("pas ton commentaire")
|
||||
lieu = self._sujet_du_commentaire(user, c)
|
||||
with self.con:
|
||||
self.con.execute("DELETE FROM comment_reports WHERE comment_id=?", (comment_id,))
|
||||
self.con.execute("DELETE FROM comments WHERE id=?", (comment_id,))
|
||||
if not auteur:
|
||||
self._journaliser(user, "commentaire", comment_id, lieu[0], c["body"], "message %d" % lieu[1])
|
||||
return lieu
|
||||
|
||||
# --- suppression définitive (propriétaire et adjoint seulement) ------
|
||||
def sujet_supprimable(self, t):
|
||||
"""Le Bulletin (sujet fixe) et les sujets de station ne se suppriment jamais : seulement leurs messages."""
|
||||
return not (t["fixed"] or t["station"])
|
||||
|
||||
def _journaliser(self, acteur, quoi, cible_id, sujet_id, extrait, details=""):
|
||||
nom = self.con.execute("SELECT " + nom_sql() + " FROM users u WHERE u.id=?", (acteur["id"],)).fetchone()[0]
|
||||
self.con.execute("INSERT INTO journal_suppressions(acteur_id, acteur_nom, quoi, cible_id, sujet_id, extrait, details)"
|
||||
" VALUES (?, ?, ?, ?, ?, ?, ?)",
|
||||
(acteur["id"], nom or "", quoi, cible_id, sujet_id, (extrait or "")[:200], details))
|
||||
|
||||
def journal_suppressions(self, acteur):
|
||||
self._exiger(acteur, "supprimer")
|
||||
return self.con.execute("SELECT * FROM journal_suppressions ORDER BY id DESC").fetchall()
|
||||
|
||||
def _effacer_messages(self, post_ids):
|
||||
"""Efface les messages et tout ce qui en dépend ; retourne les chemins de photos devenus orphelins.
|
||||
À appeler dans une transaction."""
|
||||
ids = [int(i) for i in post_ids]
|
||||
if not ids:
|
||||
return []
|
||||
q = ",".join("?" * len(ids))
|
||||
chemins = {r[0] for r in self.con.execute("SELECT stored_path FROM attachments WHERE post_id IN (%s)" % q, ids)}
|
||||
self.con.execute("DELETE FROM fiche_photos WHERE attachment_id IN (SELECT id FROM attachments WHERE post_id IN (%s))" % q, ids)
|
||||
self.con.execute("DELETE FROM attachments WHERE post_id IN (%s)" % q, ids)
|
||||
self.con.execute("DELETE FROM reactions WHERE post_id IN (%s)" % q, ids)
|
||||
self.con.execute("DELETE FROM reports WHERE post_id IN (%s)" % q, ids)
|
||||
self.con.execute("DELETE FROM comment_reports WHERE comment_id IN (SELECT id FROM comments WHERE post_id IN (%s))" % q, ids)
|
||||
self.con.execute("DELETE FROM comments WHERE post_id IN (%s)" % q, ids)
|
||||
self.con.execute("DELETE FROM posts WHERE id IN (%s)" % q, ids)
|
||||
# une même photo (même empreinte) peut servir ailleurs : on ne retire que les fichiers plus référencés
|
||||
return [c for c in chemins
|
||||
if not self.con.execute("SELECT 1 FROM attachments WHERE stored_path=? UNION ALL"
|
||||
" SELECT 1 FROM adhesion_photos WHERE stored_path=? LIMIT 1", (c, c)).fetchone()]
|
||||
|
||||
def _retirer_fichiers(self, chemins):
|
||||
racine = os.path.realpath(self.dossier_photos) if self.dossier_photos else None
|
||||
for c in chemins:
|
||||
reel = os.path.realpath(c)
|
||||
if racine is None or os.path.dirname(reel) != racine:
|
||||
continue # jamais hors du dossier des photos
|
||||
try:
|
||||
os.remove(reel)
|
||||
except OSError:
|
||||
pass
|
||||
|
||||
def _premier_message(self, topic_id):
|
||||
return self.con.execute("SELECT MIN(id) FROM posts WHERE topic_id=?", (topic_id,)).fetchone()[0]
|
||||
|
||||
def supprimer_message(self, user, post_id):
|
||||
"""Supprime un message (commentaires, réactions, signalements, photos). Le premier message d'un sujet
|
||||
supprimable ne s'efface pas seul : c'est le sujet entier qu'on supprime. Retourne le topic_id."""
|
||||
self._exiger(user, "supprimer")
|
||||
p = self._post(post_id)
|
||||
t = self.con.execute("SELECT * FROM topics WHERE id=?", (p["topic_id"],)).fetchone()
|
||||
if self.sujet_supprimable(t) and self._premier_message(t["id"]) == p["id"]:
|
||||
raise Invalide("c'est le premier message : supprime plutôt le sujet entier")
|
||||
with self.con:
|
||||
orphelins = self._effacer_messages([post_id])
|
||||
self._journaliser(user, "message", post_id, t["id"], p["body"], "sujet « %s »" % t["title"][:100])
|
||||
self._retirer_fichiers(orphelins)
|
||||
self.version += 1
|
||||
return t["id"]
|
||||
|
||||
def supprimer_sujet(self, user, topic_id):
|
||||
"""Supprime le sujet, ses messages, commentaires, réactions, signalements, lectures et photos."""
|
||||
self._exiger(user, "supprimer")
|
||||
t = self.con.execute("SELECT * FROM topics WHERE id=?", (topic_id,)).fetchone()
|
||||
if t is None:
|
||||
raise Invalide("sujet introuvable")
|
||||
if not self.sujet_supprimable(t):
|
||||
raise Refus("ce sujet ne se supprime pas (seulement ses messages)")
|
||||
ids = [r[0] for r in self.con.execute("SELECT id FROM posts WHERE topic_id=?", (topic_id,))]
|
||||
with self.con:
|
||||
orphelins = self._effacer_messages(ids)
|
||||
self.con.execute("DELETE FROM lectures WHERE topic_id=?", (topic_id,))
|
||||
self.con.execute("DELETE FROM topics WHERE id=?", (topic_id,))
|
||||
self._journaliser(user, "sujet", topic_id, topic_id, t["title"], "%d message(s)" % len(ids))
|
||||
self._retirer_fichiers(orphelins)
|
||||
self.version += 1
|
||||
|
||||
def signaler_commentaire(self, user, comment_id, motif):
|
||||
self._exiger(user, "signaler")
|
||||
c = self._commentaire(comment_id)
|
||||
|
||||
@@ -0,0 +1,109 @@
|
||||
"""Reprise des rôles du forum dans le Hub (06/11/2026), avant de passer en mode FORUM_ROLES_DEPUIS_HUB=1.
|
||||
|
||||
Le Hub devient la source de vérité des statuts météo (panneau admin, onglet « Statuts météo »). Ce script copie
|
||||
dans le Hub les rôles que la base du forum connaît et que le Hub n'a pas encore. Il n'en retire jamais aucun :
|
||||
cible = rôles du Hub ∪ rôles du forum. Idempotent : un second passage n'envoie plus rien.
|
||||
|
||||
Par défaut : simulation (rien n'est écrit, rien ne part). --appliquer : envoie POST /oauth/roles.
|
||||
Configuration : mêmes variables que le forum (FORUM_HUB_URL, FORUM_CLIENT_ID, FORUM_OAUTH_SECRET_FILE).
|
||||
Aucun secret n'est affiché.
|
||||
|
||||
python migrer_roles_hub.py --db /chemin/forum.sqlite3 # simulation
|
||||
python migrer_roles_hub.py --db /chemin/forum.sqlite3 --appliquer
|
||||
"""
|
||||
import argparse
|
||||
import json
|
||||
import sqlite3
|
||||
import sys
|
||||
import urllib.error
|
||||
import urllib.request
|
||||
|
||||
import connexion
|
||||
import db
|
||||
|
||||
|
||||
def roles_locaux(con, proprietaire_id=None):
|
||||
"""{hub_id: {rôles}} depuis la base du forum (compte système et comptes supprimés exclus)."""
|
||||
out = {}
|
||||
for hub_id, role in con.execute(
|
||||
"SELECT u.hub_id, r.role FROM user_roles r JOIN users u ON u.id = r.user_id"
|
||||
" WHERE u.hub_id <> ? AND COALESCE(u.supprime, 0) = 0", (db.SYSTEME,)):
|
||||
if role in connexion.ROLES_HUB:
|
||||
out.setdefault(hub_id, set()).add(role)
|
||||
if proprietaire_id and proprietaire_id in out:
|
||||
out[proprietaire_id].add("proprietaire")
|
||||
return out
|
||||
|
||||
|
||||
def planifier(locaux, lire):
|
||||
"""Liste de (hub_id, état, rôles du Hub, rôles cibles). lire(hub_id) -> liste | [] (absent) | None (erreur).
|
||||
état : « envoyer », « a_jour », « erreur »."""
|
||||
plan = []
|
||||
for hub_id in sorted(locaux):
|
||||
actuels = lire(hub_id)
|
||||
if actuels is None:
|
||||
plan.append((hub_id, "erreur", None, None))
|
||||
continue
|
||||
cible = sorted(set(actuels) | locaux[hub_id])
|
||||
plan.append((hub_id, "a_jour" if set(cible) == set(actuels) else "envoyer", sorted(actuels), cible))
|
||||
return plan
|
||||
|
||||
|
||||
def envoyer(r, hub_id, roles):
|
||||
"""POST /oauth/roles ; renvoie le code HTTP (0 si le Hub est injoignable)."""
|
||||
corps = json.dumps({"id": hub_id, "roles": sorted(roles)}).encode("utf-8")
|
||||
req = urllib.request.Request(r.hub_url + "/oauth/roles", data=corps, method="POST",
|
||||
headers={"Content-Type": "application/json", "Authorization": connexion._basic(r)})
|
||||
try:
|
||||
with connexion._OUVREUR.open(req, timeout=connexion.DELAI) as rep:
|
||||
return rep.status
|
||||
except urllib.error.HTTPError as ex:
|
||||
return ex.code
|
||||
except (urllib.error.URLError, OSError):
|
||||
return 0
|
||||
|
||||
|
||||
def executer(con, reglages, appliquer, proprietaire_id=None, lire=None, envoi=None, sortie=print):
|
||||
lire = lire or (lambda h: connexion.lire_roles(reglages, h))
|
||||
envoi = envoi or (lambda h, rs: envoyer(reglages, h, rs))
|
||||
plan = planifier(roles_locaux(con, proprietaire_id), lire)
|
||||
compte = {"envoyer": 0, "a_jour": 0, "erreur": 0, "envoye": 0, "refuse": 0}
|
||||
for hub_id, etat, actuels, cible in plan:
|
||||
compte[etat] += 1
|
||||
if etat == "erreur":
|
||||
sortie("%s : Hub illisible, ignoré" % hub_id)
|
||||
elif etat == "a_jour":
|
||||
sortie("%s : déjà à jour (%s)" % (hub_id, ",".join(actuels) or "aucun"))
|
||||
else:
|
||||
sortie("%s : %s -> %s%s" % (hub_id, ",".join(actuels) or "aucun", ",".join(cible),
|
||||
"" if appliquer else " (simulation)"))
|
||||
if appliquer:
|
||||
code = envoi(hub_id, cible)
|
||||
if code == 204:
|
||||
compte["envoye"] += 1
|
||||
else:
|
||||
compte["refuse"] += 1
|
||||
sortie("%s : refusé par le Hub (%s)%s" % (hub_id, code,
|
||||
" : compte jamais connecté au forum" if code == 404 else ""))
|
||||
sortie("Bilan : %(envoyer)d à envoyer, %(a_jour)d déjà à jour, %(erreur)d illisibles, "
|
||||
"%(envoye)d envoyés, %(refuse)d refusés" % compte)
|
||||
return compte
|
||||
|
||||
|
||||
def main(argv=None):
|
||||
ap = argparse.ArgumentParser(description=__doc__.splitlines()[0])
|
||||
ap.add_argument("--db", required=True, help="base SQLite du forum (ouverte en lecture seule)")
|
||||
ap.add_argument("--proprietaire", default=None, help="id Gastinel du propriétaire (défaut : FORUM_PROPRIETAIRE_ID)")
|
||||
ap.add_argument("--appliquer", action="store_true", help="envoyer au Hub (sans : simulation)")
|
||||
a = ap.parse_args(argv)
|
||||
import os
|
||||
reglages = connexion.Reglages.depuis_env()
|
||||
if not reglages.hub_url or not reglages.client_secret:
|
||||
sys.exit("FORUM_HUB_URL et le secret client (FORUM_OAUTH_SECRET_FILE) sont nécessaires")
|
||||
con = sqlite3.connect("file:%s?mode=ro" % a.db, uri=True)
|
||||
compte = executer(con, reglages, a.appliquer, a.proprietaire or os.environ.get("FORUM_PROPRIETAIRE_ID"))
|
||||
return 1 if compte["erreur"] or compte["refuse"] else 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
@@ -90,7 +90,7 @@ class Handler(BaseHTTPRequestHandler):
|
||||
self.send_header("Content-Security-Policy",
|
||||
"default-src 'none'; style-src 'unsafe-inline'; img-src 'self'; font-src 'self'; form-action 'self'; frame-ancestors 'none'")
|
||||
self.send_header("X-Content-Type-Options", "nosniff")
|
||||
self.send_header("Referrer-Policy", "no-referrer")
|
||||
self.send_header("Referrer-Policy", "same-origin")
|
||||
self.send_header("Cache-Control", "private, no-store")
|
||||
for k, v in extra:
|
||||
self.send_header(k, v)
|
||||
@@ -100,7 +100,7 @@ class Handler(BaseHTTPRequestHandler):
|
||||
def rediriger(self, url, extra=()):
|
||||
self.send_response(303)
|
||||
self.send_header("Location", url)
|
||||
self.send_header("Referrer-Policy", "no-referrer")
|
||||
self.send_header("Referrer-Policy", "same-origin")
|
||||
for k, v in extra:
|
||||
self.send_header(k, v)
|
||||
self.send_header("Content-Length", "0")
|
||||
@@ -316,6 +316,7 @@ class Handler(BaseHTTPRequestHandler):
|
||||
|
||||
def creer_serveur(forum, port=0, hote="127.0.0.1", reglages=None):
|
||||
h = type("H", (Handler,), {"app": App(forum, reglages or connexion.Reglages())})
|
||||
h.timeout = 30 # socket muette plus de 30 s : connexion fermée
|
||||
return ThreadingHTTPServer((hote, port), h)
|
||||
|
||||
|
||||
|
||||
@@ -55,6 +55,7 @@ DROITS = {
|
||||
"voir_signalements": {MODERATEUR} | PROPRIOS,
|
||||
"gerer_roles": PROPRIOS,
|
||||
"photos_illimitees": PROPRIOS,
|
||||
"supprimer": PROPRIOS, # suppression définitive (message, commentaire, sujet) : Théo et son père
|
||||
}
|
||||
|
||||
|
||||
|
||||
+48
-1
@@ -172,6 +172,8 @@ form.inline{display:inline;margin:0 6px 0 0}form.inline button{font-size:12px;pa
|
||||
.barre-repondre:hover .faux-champ,.barre-repondre:focus-visible .faux-champ{border-color:var(--sapin);color:var(--sapin)}
|
||||
.creer-sujet{margin:0 0 4px}
|
||||
.actions .signaler{margin-left:auto}.actions .signaler[open]{margin-left:0}
|
||||
.actions details.suppr>summary,.sujet-suppr>summary{color:var(--gris);font-weight:400}
|
||||
.sujet-suppr{margin:0 0 12px}.sujet-suppr>summary{cursor:pointer;padding:7px 0}.suppr form,.sujet-suppr form{margin:6px 0}
|
||||
.actions summary,.fiche summary{cursor:pointer;color:var(--sapin);font-weight:600;padding:7px 0}
|
||||
.ligne{display:flex;flex-wrap:wrap;gap:8px;align-items:flex-end}.ligne>div{flex:1 1 180px;min-width:0}
|
||||
.ligne select,.ligne input{width:100%}
|
||||
@@ -848,7 +850,18 @@ class Handler(BaseHTTPRequestHandler):
|
||||
self.end_headers()
|
||||
|
||||
def badges(self, user_id):
|
||||
return "".join(badge(r, lib) for r, lib in self.app.forum.badges(user_id))
|
||||
tous = list(self.app.forum.badges(user_id))
|
||||
stations = [lib for r, lib in tous if r == roles.STATION]
|
||||
out = []
|
||||
for r, lib in tous:
|
||||
if r == roles.STATION and len(stations) > 1:
|
||||
if lib == stations[0]: # un seul badge groupé, la liste complète au survol
|
||||
noms = [s.split("·", 1)[-1].strip() for s in stations]
|
||||
out.append(badge(r, "Propriétaire de %d stations" % len(stations)).replace(
|
||||
"<span class='badge", "<span title='%s' class='badge" % e(" · ".join(noms)), 1))
|
||||
continue
|
||||
out.append(badge(r, lib))
|
||||
return "".join(out)
|
||||
|
||||
def page(self, titre, contenu, user, code=200, extra=(), tete=""):
|
||||
f = self.app.forum
|
||||
@@ -1562,6 +1575,8 @@ class Handler(BaseHTTPRequestHandler):
|
||||
|
||||
def commentaire_html(self, user, rs, c):
|
||||
outils = []
|
||||
if user is not None and c["author_id"] != user["id"] and roles.peut(rs, "supprimer"):
|
||||
outils.append(form_supprimer("/commentaire/supprimer", "commentaire", c["id"]))
|
||||
if user is not None and c["author_id"] == user["id"]:
|
||||
outils.append("<details class='supprimer'><summary>Supprimer</summary><form method='post' action='/commentaire/supprimer'>"
|
||||
"<input type='hidden' name='commentaire' value='%d'><p class='meta'>Le commentaire sera effacé.</p>"
|
||||
@@ -1604,6 +1619,10 @@ class Handler(BaseHTTPRequestHandler):
|
||||
+ "<h1>%s</h1><p class='chapeau'>Les observations et les échanges de la communauté, message après message.</p>" % e(t["title"])]
|
||||
if t["pinned"] or t["fixed"]:
|
||||
out.append("<p><span class='etat'>Épinglé</span></p>")
|
||||
sujet_suppr = roles.peut(rs, "supprimer") and f.sujet_supprimable(t)
|
||||
if sujet_suppr:
|
||||
out.append(form_supprimer("/sujet/supprimer", "sujet", tid, "sujet-suppr", "Supprimer le sujet",
|
||||
"Le sujet, tous ses messages, réponses, réactions et photos seront effacés."))
|
||||
if t["status"] != "publie":
|
||||
out.append("<p class='info'>Ce sujet est %s.</p>" % ("en attente de validation" if t["status"] == "en_attente" else "refusé"))
|
||||
if t["locked"]:
|
||||
@@ -1611,6 +1630,8 @@ class Handler(BaseHTTPRequestHandler):
|
||||
suite = parse_qs(urlparse(self.path).query).get("suite", [""])[0]
|
||||
if suite == "signalement" and user is not None:
|
||||
out.append("<p class='info' role='status'>Signalement pris en compte.</p>")
|
||||
if suite == "supprime" and user is not None:
|
||||
out.append("<p class='info' role='status'>Suppression effectuée.</p>")
|
||||
caches = 0
|
||||
if user is None and not t["fixed"] and len(msgs) > VISITEUR_MAX:
|
||||
caches = len(msgs) - VISITEUR_MAX
|
||||
@@ -1655,6 +1676,12 @@ class Handler(BaseHTTPRequestHandler):
|
||||
"<input type='hidden' name='post' value='%d'><label>Motif du signalement"
|
||||
"<textarea name='motif' maxlength='500' required></textarea></label>"
|
||||
"<button>Envoyer le signalement</button></form></details>" % m["id"])
|
||||
if roles.peut(rs, "supprimer"):
|
||||
if sujet_suppr and i == 0 and m["id"] == f._premier_message(tid):
|
||||
outils += form_supprimer("/sujet/supprimer", "sujet", tid, aide="C’est le premier message : "
|
||||
"tout le sujet sera supprimé, avec ses réponses et ses photos.")
|
||||
else:
|
||||
outils += form_supprimer("/supprimer", "post", m["id"])
|
||||
if f.peut_modifier(user, m):
|
||||
lien += ("<span class='sep' aria-hidden='true'>|</span>"
|
||||
"<details class='modifier'><summary>Modifier</summary><form method='post' action='/modifier'>"
|
||||
@@ -1986,6 +2013,12 @@ class Handler(BaseHTTPRequestHandler):
|
||||
cid = int(d.get("commentaire", "0"))
|
||||
tid, _ = f.masquer_commentaire(user, cid, d.get("etat") == "1")
|
||||
return self.rediriger("/t/%d#commentaire-%d" % (tid, cid))
|
||||
if chemin == "/supprimer":
|
||||
tid = f.supprimer_message(user, int(d.get("post", "0")))
|
||||
return self.rediriger("/t/%d?suite=supprime" % tid)
|
||||
if chemin == "/sujet/supprimer":
|
||||
f.supprimer_sujet(user, int(d.get("sujet", "0")))
|
||||
return self.rediriger("/?suite=sujet-supprime")
|
||||
if chemin == "/masquer":
|
||||
f.masquer_message(user, int(d.get("post", "0")), d.get("etat") == "1")
|
||||
return self.rediriger(self.headers.get("Referer") or "/")
|
||||
@@ -2006,8 +2039,17 @@ class Handler(BaseHTTPRequestHandler):
|
||||
self.erreur(user, 400, str(ex))
|
||||
|
||||
|
||||
def form_supprimer(action, champ, ident, classe="suppr", resume="Supprimer", aide=""):
|
||||
"""Bouton discret « Supprimer » (propriétaire et adjoint) : confirmation dans un <details>, POST sans JavaScript."""
|
||||
return ("<details class='%s'><summary>%s</summary><form method='post' action='%s'>"
|
||||
"<input type='hidden' name='%s' value='%d'><p class='meta'>Supprimer définitivement ?%s</p>"
|
||||
"<button class='danger'>Supprimer</button></form></details>"
|
||||
% (classe, e(resume), action, champ, int(ident), (" " + e(aide)) if aide else ""))
|
||||
|
||||
|
||||
def creer_serveur(forum, port=0, hote="127.0.0.1", reglages=None):
|
||||
h = type("H", (Handler,), {"app": App(forum, reglages or connexion.Reglages())})
|
||||
h.timeout = 30 # socket muette plus de 30 s : connexion fermée
|
||||
return ThreadingHTTPServer((hote, port), h)
|
||||
|
||||
|
||||
@@ -2054,6 +2096,11 @@ def main():
|
||||
proprietaire_id=os.environ.get("FORUM_PROPRIETAIRE_ID"))
|
||||
f.creer_sujets_stations()
|
||||
f.apres_roles = lambda h, rs: connexion.pousser_roles(reglages, h, rs)
|
||||
if reglages.roles_depuis_hub:
|
||||
if not reglages.client_secret:
|
||||
sys.exit("FORUM_ROLES_DEPUIS_HUB=1 exige le secret client (FORUM_OAUTH_SECRET_FILE)")
|
||||
f.lire_roles_hub = lambda h: connexion.lire_roles(reglages, h)
|
||||
f.maj_roles_hub = lambda h, plus, moins: connexion.modifier_roles(reglages, h, plus, moins)
|
||||
if a.seed:
|
||||
semer(f)
|
||||
s = creer_serveur(f, a.port, a.hote, reglages=reglages)
|
||||
|
||||
@@ -1790,5 +1790,114 @@ class TestReactionsHTTP(BaseHTTP):
|
||||
self.assertIn(b"form.reactions", corps)
|
||||
|
||||
|
||||
class TestSuppression(Base):
|
||||
def _sujet_complet(self):
|
||||
t = self.f.creer_sujet(self.adh, "Orage", "Premier message")
|
||||
p = self.f.repondre(self.membre, t, "Une réponse")
|
||||
self.f.ajouter_photos(self.membre, p, [("o.png", png())])
|
||||
c = self.f.commenter(self.adh, p, "Un commentaire")
|
||||
self.f.reagir(self.adh, p, sorted(forum_mod.REACTIONS)[0])
|
||||
self.f.signaler(self.adh, p, "test")
|
||||
self.f.signaler_commentaire(self.membre, c, "test")
|
||||
self.f.noter_lecture(self.membre, t, p)
|
||||
return t, p, c
|
||||
|
||||
def _n(self, sql, *a):
|
||||
return self.f.con.execute(sql, a).fetchone()[0]
|
||||
|
||||
def test_droit_reserve_aux_proprietaires(self):
|
||||
self.assertEqual(roles.DROITS["supprimer"], {roles.PROPRIETAIRE, roles.ADJOINT})
|
||||
t, p, c = self._sujet_complet()
|
||||
for qui in (self.membre, self.adh, self.modo, self.prop):
|
||||
with self.assertRaises(Refus):
|
||||
self.f.supprimer_message(qui, p)
|
||||
with self.assertRaises(Refus):
|
||||
self.f.supprimer_sujet(qui, t)
|
||||
with self.assertRaises(Refus):
|
||||
self.f.supprimer_commentaire(self.modo, c) # le modérateur masque, il ne supprime pas
|
||||
self.assertEqual(self._n("SELECT COUNT(*) FROM posts WHERE topic_id=?", t), 2)
|
||||
self.f.supprimer_commentaire(self.pere, c) # adjoint
|
||||
self.assertEqual(self._n("SELECT COUNT(*) FROM comments"), 0)
|
||||
self.assertEqual(self._n("SELECT COUNT(*) FROM comment_reports"), 0)
|
||||
self.assertEqual(self.f.supprimer_message(self.theo, p), t)
|
||||
self.assertEqual(self._n("SELECT COUNT(*) FROM posts WHERE id=?", p), 0)
|
||||
j = self.f.journal_suppressions(self.theo)
|
||||
self.assertEqual([r["quoi"] for r in j], ["message", "commentaire"])
|
||||
self.assertEqual(j[0]["acteur_id"], self.theo["id"])
|
||||
self.assertTrue(j[0]["quand"])
|
||||
with self.assertRaises(Refus):
|
||||
self.f.journal_suppressions(self.modo)
|
||||
|
||||
def test_premier_message_renvoie_au_sujet(self):
|
||||
t, _, _ = self._sujet_complet()
|
||||
premier = self.f._premier_message(t)
|
||||
with self.assertRaises(Invalide):
|
||||
self.f.supprimer_message(self.theo, premier)
|
||||
|
||||
def test_suppression_en_cascade(self):
|
||||
t, p, _ = self._sujet_complet()
|
||||
fichier = self.f.photos_de(p)[0]["stored_path"]
|
||||
self.assertTrue(os.path.isfile(fichier))
|
||||
autre = self.f.creer_sujet(self.adh, "Autre", "Reste")
|
||||
self.f.supprimer_sujet(self.pere, t)
|
||||
for table in ("posts", "comments", "reactions", "reports", "comment_reports", "attachments", "lectures"):
|
||||
col = "topic_id" if table in ("posts", "lectures") else None
|
||||
if col:
|
||||
self.assertEqual(self._n("SELECT COUNT(*) FROM %s WHERE topic_id=?" % table, t), 0, table)
|
||||
else:
|
||||
self.assertEqual(self._n("SELECT COUNT(*) FROM %s" % table), 0, table)
|
||||
self.assertEqual(self._n("SELECT COUNT(*) FROM topics WHERE id=?", t), 0)
|
||||
self.assertFalse(os.path.exists(fichier))
|
||||
self.assertEqual(self._n("SELECT COUNT(*) FROM topics WHERE id=?", autre), 1)
|
||||
self.assertEqual(self.f.journal_suppressions(self.theo)[0]["quoi"], "sujet")
|
||||
|
||||
def test_photo_partagee_gardee(self):
|
||||
t1 = self.f.creer_sujet(self.adh, "Un", "x")
|
||||
t2 = self.f.creer_sujet(self.adh, "Deux", "y")
|
||||
p1 = self.f.repondre(self.membre, t1, "a")
|
||||
p2 = self.f.repondre(self.membre, t2, "b")
|
||||
self.f.ajouter_photos(self.membre, p1, [("a.png", png())])
|
||||
self.f.ajouter_photos(self.membre, p2, [("a.png", png())])
|
||||
fichier = self.f.photos_de(p2)[0]["stored_path"]
|
||||
self.f.supprimer_sujet(self.theo, t1)
|
||||
self.assertTrue(os.path.isfile(fichier))
|
||||
|
||||
def test_sujets_fixes_proteges(self):
|
||||
b = self.bulletin()
|
||||
with self.assertRaises(Refus):
|
||||
self.f.supprimer_sujet(self.theo, b["id"])
|
||||
self.f.creer_sujets_stations()
|
||||
st = self.f.con.execute("SELECT id FROM topics WHERE station='geve'").fetchone()[0]
|
||||
with self.assertRaises(Refus):
|
||||
self.f.supprimer_sujet(self.theo, st)
|
||||
pid = self.f.repondre(self.theo, b["id"], "Bulletin du lundi") # leurs messages, oui (même le premier)
|
||||
self.f.supprimer_message(self.theo, pid)
|
||||
self.assertEqual(self._n("SELECT COUNT(*) FROM topics WHERE id=?", b["id"]), 1)
|
||||
|
||||
|
||||
class TestSuppressionHTTP(BaseHTTP):
|
||||
def test_boutons_et_post(self):
|
||||
t = self.f.creer_sujet(self.adh, "Neige", "Premier")
|
||||
p = self.f.repondre(self.adh, t, "Deuxième")
|
||||
page = self.req("/t/%d" % t, "theo")[2].decode()
|
||||
self.assertIn("action='/sujet/supprimer'", page)
|
||||
self.assertIn("action='/supprimer'", page)
|
||||
self.assertIn("Supprimer définitivement ?", page)
|
||||
for qui in ("mo1", "m1"):
|
||||
pg = self.req("/t/%d" % t, qui)[2].decode()
|
||||
self.assertNotIn("action='/supprimer'", pg)
|
||||
self.assertNotIn("action='/sujet/supprimer'", pg)
|
||||
self.assertEqual(self.req("/supprimer", qui, "post=%d" % p)[0], 403)
|
||||
self.assertEqual(self.req("/supprimer", "theo", "post=%d" % p, origine=False)[0], 403) # contrôle Origin
|
||||
st, h, _ = self.req("/supprimer", "theo", "post=%d" % p)
|
||||
self.assertEqual((st, h["Location"]), (303, "/t/%d?suite=supprime" % t))
|
||||
st, h, _ = self.req("/sujet/supprimer", "pere", "sujet=%d" % t)
|
||||
self.assertEqual(st, 303)
|
||||
self.assertEqual(self.req("/t/%d" % t, "theo")[0], 404)
|
||||
b = self.bulletin()["id"]
|
||||
self.assertNotIn("action='/sujet/supprimer'", self.req("/t/%d" % b, "theo")[2].decode())
|
||||
self.assertEqual(self.req("/sujet/supprimer", "theo", "sujet=%d" % b)[0], 403)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,223 @@
|
||||
"""Hub = source de vérité des statuts météo (06/11/2026) : synchronisation à la connexion, écriture des changements
|
||||
faits dans le forum, lecture GET /oauth/roles, script de reprise idempotent.
|
||||
|
||||
python -m unittest discover -s tests
|
||||
"""
|
||||
import json
|
||||
import os
|
||||
import sys
|
||||
import threading
|
||||
import unittest
|
||||
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
|
||||
from urllib.parse import parse_qs, urlparse
|
||||
|
||||
ICI = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..")
|
||||
sys.path.insert(0, ICI)
|
||||
import connexion # noqa: E402
|
||||
import migrer_roles_hub as migr # noqa: E402
|
||||
import roles # noqa: E402
|
||||
from forum import Forum # noqa: E402
|
||||
|
||||
STATIONS = {"geve": "Gêve", "oscence": "Combe de l'Oscence"}
|
||||
THEO, ALICE, BOB = "id-theo", "id-alice", "id-bob"
|
||||
|
||||
|
||||
class _Synchrone(threading.Thread):
|
||||
"""Remplace threading.Thread dans forum : exécute tout de suite (tests déterministes)."""
|
||||
def __init__(self, target, args=(), daemon=None):
|
||||
self._t, self._a = target, args
|
||||
|
||||
def start(self):
|
||||
self._t(*self._a)
|
||||
|
||||
|
||||
class ModeHub(unittest.TestCase):
|
||||
def setUp(self):
|
||||
import forum as forum_mod
|
||||
self._thread = forum_mod.threading.Thread
|
||||
forum_mod.threading.Thread = _Synchrone
|
||||
self.addCleanup(setattr, forum_mod.threading, "Thread", self._thread)
|
||||
self.hub = {} # hub_id -> liste de rôles (faux Hub)
|
||||
self.ecrits = []
|
||||
self.f = Forum(stations=STATIONS, proprietaire_id=THEO)
|
||||
self.f.lire_roles_hub = lambda h: self.hub.get(h, [])
|
||||
self.f.maj_roles_hub = self._maj
|
||||
self.poussees = []
|
||||
self.f.apres_roles = lambda h, rs: self.poussees.append((h, rs))
|
||||
|
||||
def _maj(self, h, plus, moins):
|
||||
self.ecrits.append((h, plus, moins))
|
||||
self.hub[h] = sorted((set(self.hub.get(h, [])) | set(plus)) - set(moins))
|
||||
|
||||
def noms(self, hub_id):
|
||||
return self.f.roles_de(self.f.utilisateur_existant(hub_id)) - {roles.MEMBRE}
|
||||
|
||||
def test_connexion_aligne_sur_le_hub(self):
|
||||
self.f.connexion_gastinel(ALICE, "Alice")
|
||||
self.assertEqual(self.noms(ALICE), set())
|
||||
self.hub[ALICE] = ["adherent", "moderateur"]
|
||||
self.f.connexion_gastinel(ALICE, "Alice") # renouvellement de session
|
||||
self.assertEqual(self.noms(ALICE), {roles.ADHERENT, roles.MODERATEUR})
|
||||
self.hub[ALICE] = ["adherent"]
|
||||
self.f.connexion_gastinel(ALICE, "Alice")
|
||||
self.assertEqual(self.noms(ALICE), {roles.ADHERENT})
|
||||
self.assertEqual(self.poussees, [], "mode Hub : plus de poussée complète à la connexion")
|
||||
|
||||
def test_proprietaire_reste_fixe_par_la_configuration(self):
|
||||
self.hub[ALICE] = ["proprietaire"]
|
||||
self.f.connexion_gastinel(ALICE, "Alice")
|
||||
self.assertNotIn(roles.PROPRIETAIRE, self.noms(ALICE))
|
||||
self.f.connexion_gastinel(THEO, "Théo") # Hub vide pour Théo
|
||||
self.assertIn(roles.PROPRIETAIRE, self.noms(THEO))
|
||||
|
||||
def test_hub_injoignable_garde_les_roles_locaux(self):
|
||||
self.hub[ALICE] = ["moderateur"]
|
||||
self.f.connexion_gastinel(ALICE, "Alice")
|
||||
self.f.lire_roles_hub = lambda h: None
|
||||
self.f.connexion_gastinel(ALICE, "Alice")
|
||||
self.assertEqual(self.noms(ALICE), {roles.MODERATEUR})
|
||||
|
||||
def test_station_liee_dans_le_forum_gardee_tant_que_le_hub_donne_le_role(self):
|
||||
theo = self.f.connexion_gastinel(THEO, "Théo")
|
||||
self.hub[ALICE] = ["proprietaire_station"]
|
||||
self.f.connexion_gastinel(ALICE, "Alice")
|
||||
self.f.donner_role(theo, ALICE, roles.STATION, "geve")
|
||||
u = self.f.utilisateur_existant(ALICE)
|
||||
self.assertEqual(self.f.stations_de(u), {"geve"}) # la ligne sans station a disparu
|
||||
self.f.connexion_gastinel(ALICE, "Alice")
|
||||
self.assertEqual(self.f.stations_de(u), {"geve"})
|
||||
self.hub[ALICE] = []
|
||||
self.f.connexion_gastinel(ALICE, "Alice")
|
||||
self.assertEqual(self.f.stations_de(u), set())
|
||||
|
||||
def test_changement_dans_le_forum_ecrit_seulement_le_delta(self):
|
||||
theo = self.f.connexion_gastinel(THEO, "Théo")
|
||||
self.f.connexion_gastinel(ALICE, "Alice")
|
||||
self.hub[ALICE] = ["moderateur"] # donné au panneau admin, Alice pas encore reconnectée
|
||||
self.f.donner_role(theo, ALICE, roles.ADHERENT)
|
||||
self.assertEqual(self.ecrits[-1], (ALICE, ["adherent"], []))
|
||||
self.assertEqual(self.hub[ALICE], ["adherent", "moderateur"], "le modérateur du panneau admin est gardé")
|
||||
self.f.retirer_role(theo, ALICE, roles.ADHERENT)
|
||||
self.assertEqual(self.hub[ALICE], ["moderateur"])
|
||||
n = len(self.ecrits)
|
||||
self.f.retirer_role(theo, ALICE, roles.ADHERENT) # rien ne change : rien n'est écrit
|
||||
self.assertEqual(len(self.ecrits), n)
|
||||
|
||||
def test_adhesion_acceptee_ecrite_dans_le_hub(self):
|
||||
theo = self.f.connexion_gastinel(THEO, "Théo")
|
||||
alice = self.f.connexion_gastinel(ALICE, "Alice")
|
||||
demande = self.f.demander_adhesion(alice, "Je relève la station de mon village depuis 2019.")
|
||||
self.f.decider_adhesion(theo, demande, True)
|
||||
self.assertIn("adherent", self.hub[ALICE])
|
||||
|
||||
|
||||
class _FauxHub(BaseHTTPRequestHandler):
|
||||
roles = {}
|
||||
secret = "s3cret"
|
||||
|
||||
def log_message(self, *a):
|
||||
pass
|
||||
|
||||
def _auth(self):
|
||||
attendu = connexion._basic(connexion.Reglages(hub_url="http://127.0.0.1", client_secret=self.secret))
|
||||
return self.headers.get("Authorization") == attendu
|
||||
|
||||
def do_GET(self):
|
||||
q = parse_qs(urlparse(self.path).query)
|
||||
h = q.get("id", [""])[0]
|
||||
if not self._auth():
|
||||
self.send_response(401); self.end_headers(); return
|
||||
if h == "id-bizarre":
|
||||
corps = json.dumps({"id": "autre", "roles": ["adherent"]}).encode()
|
||||
elif h not in self.roles:
|
||||
self.send_response(404); self.end_headers(); return
|
||||
else:
|
||||
corps = json.dumps({"id": h, "roles": self.roles[h] + ["inconnu"]}).encode()
|
||||
self.send_response(200)
|
||||
self.send_header("Content-Type", "application/json")
|
||||
self.end_headers()
|
||||
self.wfile.write(corps)
|
||||
|
||||
def do_POST(self):
|
||||
d = json.loads(self.rfile.read(int(self.headers["Content-Length"])))
|
||||
if not self._auth() or d["id"] not in self.roles:
|
||||
self.send_response(404 if self._auth() else 401); self.end_headers(); return
|
||||
self.roles[d["id"]] = d["roles"]
|
||||
self.send_response(204); self.end_headers()
|
||||
|
||||
|
||||
class LectureHub(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.srv = ThreadingHTTPServer(("127.0.0.1", 0), _FauxHub)
|
||||
threading.Thread(target=cls.srv.serve_forever, daemon=True).start()
|
||||
cls.url = "http://127.0.0.1:%d" % cls.srv.server_address[1]
|
||||
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
cls.srv.shutdown()
|
||||
|
||||
def setUp(self):
|
||||
_FauxHub.roles = {ALICE: ["moderateur"], BOB: []}
|
||||
self.r = connexion.Reglages(hub_url=self.url, client_secret=_FauxHub.secret)
|
||||
|
||||
def test_lire_roles(self):
|
||||
self.assertEqual(connexion.lire_roles(self.r, ALICE), ["moderateur"]) # « inconnu » filtré
|
||||
self.assertEqual(connexion.lire_roles(self.r, "id-absent"), [])
|
||||
self.assertIsNone(connexion.lire_roles(self.r, "id-bizarre"), "id différent : réponse ignorée")
|
||||
self.assertIsNone(connexion.lire_roles(connexion.Reglages(hub_url=self.url, client_secret="faux"), ALICE))
|
||||
self.assertIsNone(connexion.lire_roles(connexion.Reglages(hub_url=self.url), ALICE), "sans secret : rien")
|
||||
self.assertIsNone(connexion.lire_roles(connexion.Reglages(hub_url="http://127.0.0.1:1", client_secret="x"), ALICE))
|
||||
|
||||
def test_modifier_roles_applique_le_delta(self):
|
||||
self.assertTrue(connexion.modifier_roles(self.r, ALICE, ["adherent"], []))
|
||||
self.assertEqual(sorted(_FauxHub.roles[ALICE]), ["adherent", "moderateur"])
|
||||
self.assertTrue(connexion.modifier_roles(self.r, ALICE, [], ["moderateur"]))
|
||||
self.assertEqual(_FauxHub.roles[ALICE], ["adherent"])
|
||||
|
||||
def test_reglages_depuis_env(self):
|
||||
self.assertFalse(connexion.Reglages.depuis_env({}).roles_depuis_hub)
|
||||
self.assertTrue(connexion.Reglages.depuis_env({"FORUM_ROLES_DEPUIS_HUB": "1"}).roles_depuis_hub)
|
||||
|
||||
def test_reprise_idempotente(self):
|
||||
f = Forum(stations=STATIONS, proprietaire_id=THEO)
|
||||
theo = f.connexion_gastinel(THEO, "Théo")
|
||||
for h in (ALICE, BOB, "id-absent"):
|
||||
f.connexion_gastinel(h, h)
|
||||
f.donner_role(theo, ALICE, roles.ADHERENT)
|
||||
f.donner_role(theo, BOB, roles.STATION, "geve")
|
||||
f.donner_role(theo, "id-absent", roles.MODERATEUR)
|
||||
_FauxHub.roles[THEO] = []
|
||||
lignes = []
|
||||
# Simulation : rien n'est envoyé.
|
||||
c = migr.executer(f.con, self.r, False, THEO, sortie=lignes.append)
|
||||
self.assertEqual(_FauxHub.roles[ALICE], ["moderateur"])
|
||||
self.assertEqual(c["envoyer"], 4)
|
||||
self.assertTrue(any("simulation" in l for l in lignes))
|
||||
# Application : union, aucun rôle du Hub retiré ; compte inconnu du Hub signalé.
|
||||
c = migr.executer(f.con, self.r, True, THEO, sortie=lignes.append)
|
||||
self.assertEqual(sorted(_FauxHub.roles[ALICE]), ["adherent", "moderateur"])
|
||||
self.assertEqual(_FauxHub.roles[BOB], ["proprietaire_station"])
|
||||
self.assertEqual(_FauxHub.roles[THEO], ["proprietaire"])
|
||||
self.assertEqual((c["envoye"], c["refuse"]), (3, 1)) # id-absent : jamais connecté (404)
|
||||
self.assertEqual(c["a_jour"], 0)
|
||||
# Second passage : plus rien à envoyer (seul le compte inconnu du Hub est encore signalé).
|
||||
c = migr.executer(f.con, self.r, True, THEO, sortie=lignes.append)
|
||||
self.assertEqual((c["envoye"], c["a_jour"], c["refuse"]), (0, 3, 1))
|
||||
self.assertFalse(any("s3cret" in l for l in lignes), "aucun secret affiché")
|
||||
|
||||
def test_reprise_compte_jamais_connecte_au_hub(self):
|
||||
f = Forum(stations=STATIONS, proprietaire_id=THEO)
|
||||
theo = f.connexion_gastinel(THEO, "Théo")
|
||||
f.connexion_gastinel("id-nouveau", "N")
|
||||
f.donner_role(theo, "id-nouveau", roles.ADHERENT)
|
||||
_FauxHub.roles[THEO] = ["proprietaire"]
|
||||
envois = []
|
||||
c = migr.executer(f.con, self.r, True, THEO, lire=lambda h: [] if h == "id-nouveau" else ["proprietaire"],
|
||||
envoi=lambda h, rs: envois.append(h) or 404, sortie=lambda l: None)
|
||||
self.assertEqual(envois, ["id-nouveau"])
|
||||
self.assertEqual(c["refuse"], 1)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
Référencer dans un nouveau ticket
Bloquer un utilisateur