Fichiers
meteo-vercors/forum/forum.py
T

463 lignes
24 KiB
Python

"""Logique du forum : toutes les actions passent par un contrôle de droits.
Vocabulaire (Théo, 04/11/2026) : le Forum est la partie du site ; il contient des sujets.
Le sujet fixe « Bulletin de la semaine du Vercors » est toujours épinglé en tête et fermé aux réponses.
"""
import hashlib
import os
import secrets
import db
import photos
import roles
TITRE_MAX, CORPS_MAX = 150, 20000
EPINGLES_MAX = 5 # sujet fixe compris
PHOTOS_MAX, OCTETS_MAX = 10, 25 * 1024 * 1024 # par message, sauf propriétaires (et par demande d'adhésion)
ADHESION_MAX = 4000 # longueur du message d'une demande d'adhésion
SESSION_JOURS, ETAT_MINUTES = 30, 10
class Refus(Exception):
"""Action interdite (rôle insuffisant, sujet verrouillé...)."""
class Invalide(Exception):
"""Données incorrectes ou objet introuvable."""
class Forum:
def __init__(self, chemin=":memory:", stations=None, dossier_photos=None, proprietaire_id=None):
self.con = db.connecter(chemin)
self.stations = stations or {} # id -> nom affiché (pour le titre des sujets de station)
self.dossier_photos = dossier_photos
self.proprietaire_id = proprietaire_id or None # id Gastinel de Théo (FORUM_PROPRIETAIRE_ID)
# --- connexion Gastinel et sessions ----------------------------------
@staticmethod
def _hache(s):
return hashlib.sha256(s.encode("utf-8")).hexdigest()
def connexion_gastinel(self, hub_id, pseudo):
"""Après « Se connecter avec Gastinel » : crée ou met à jour le compte ; le propriétaire configuré reçoit son rôle."""
u = self.utilisateur(hub_id, pseudo)
if self.proprietaire_id and hub_id == self.proprietaire_id:
u = self.fixer_proprietaire(hub_id, pseudo)
return u
def ouvrir_session(self, user, jours=SESSION_JOURS, portee=""):
"""Retourne l'identifiant aléatoire à mettre dans le cookie ; seul son haché est stocké.
`portee` (ex. « panneau ») sépare les sessions : un jeton du forum ne vaut rien dans le panneau, et inversement."""
jeton = secrets.token_urlsafe(32)
self.con.execute("DELETE FROM sessions WHERE expires_at < datetime('now')")
self.con.execute("INSERT INTO sessions(id_hache, user_id, expires_at) VALUES (?, ?, datetime('now', ?))",
(self._hache(portee + ":" + jeton), user["id"], "+%d days" % jours))
self.con.commit()
return jeton
def utilisateur_de_session(self, jeton, portee=""):
if not jeton:
return None
return self.con.execute("SELECT u.* FROM sessions s JOIN users u ON u.id=s.user_id"
" WHERE s.id_hache=? AND s.expires_at > datetime('now')", (self._hache(portee + ":" + jeton),)).fetchone()
def fermer_session(self, jeton, portee=""):
self.con.execute("DELETE FROM sessions WHERE id_hache=?", (self._hache(portee + ":" + (jeton or "")),))
self.con.commit()
def noter_etat(self, etat, verifier):
"""Mémorise une demande de connexion (state -> code_verifier PKCE)."""
self.con.execute("DELETE FROM oauth_etats WHERE created_at < datetime('now', ?)", ("-%d minutes" % ETAT_MINUTES,))
self.con.execute("INSERT INTO oauth_etats(etat_hache, verifier) VALUES (?, ?)", (self._hache(etat), verifier))
self.con.commit()
def prendre_etat(self, etat):
"""Usage unique : retourne le code_verifier si le state est connu et récent, sinon None."""
h = self._hache(etat or "")
r = self.con.execute("SELECT verifier FROM oauth_etats WHERE etat_hache=? AND created_at >= datetime('now', ?)",
(h, "-%d minutes" % ETAT_MINUTES)).fetchone()
self.con.execute("DELETE FROM oauth_etats WHERE etat_hache=?", (h,))
self.con.commit()
return r["verifier"] if r else None
# --- utilisateurs et rôles -----------------------------------------
def utilisateur_existant(self, hub_id):
"""Le compte lié à cet identifiant s'il existe déjà, sans le créer (panneau : aucune inscription)."""
return self.con.execute("SELECT * FROM users WHERE hub_id=? AND hub_id<>?", (hub_id, db.SYSTEME)).fetchone()
def tous_les_utilisateurs(self, acteur):
self._exiger(acteur, "gerer_roles")
return self.con.execute("SELECT * FROM users WHERE hub_id<>? ORDER BY display_name COLLATE NOCASE", (db.SYSTEME,)).fetchall()
def utilisateur(self, hub_id, nom=None):
"""Retourne l'utilisateur lié à ce compte Gastinel (créé au besoin : il est d'office membre)."""
if hub_id == db.SYSTEME:
raise Invalide("identifiant réservé")
r = self.con.execute("SELECT * FROM users WHERE hub_id=?", (hub_id,)).fetchone()
if r is None:
self.con.execute("INSERT INTO users(hub_id, display_name) VALUES (?, ?)", (hub_id, (nom or hub_id)[:60]))
self.con.commit()
r = self.con.execute("SELECT * FROM users WHERE hub_id=?", (hub_id,)).fetchone()
elif nom and nom[:60] != r["display_name"]: # le pseudo suit celui du compte Gastinel
self.con.execute("UPDATE users SET display_name=? WHERE id=?", (nom[:60], r["id"]))
self.con.commit()
r = self.con.execute("SELECT * FROM users WHERE id=?", (r["id"],)).fetchone()
return r
def roles_de(self, user):
"""Ensemble des rôles d'un utilisateur (None pour un visiteur)."""
if user is None:
return None
rs = {roles.MEMBRE}
rs |= {r["role"] for r in self.con.execute("SELECT role FROM user_roles WHERE user_id=?", (user["id"],))}
return rs
def stations_de(self, user):
if user is None:
return set()
return {r["station"] for r in self.con.execute(
"SELECT station FROM user_roles WHERE user_id=? AND role=?", (user["id"], roles.STATION))}
def badges(self, user_id):
"""Badges affichés à côté du pseudo, dans l'ordre : [(rôle, libellé), ...]."""
lignes = self.con.execute("SELECT role, station FROM user_roles WHERE user_id=?", (user_id,)).fetchall()
out = []
for role in roles.ORDRE_BADGES:
if role == roles.MEMBRE:
if not out:
out.append((role, roles.LIBELLES[role]))
continue
for l in lignes:
if l["role"] == role:
lib = roles.LIBELLES[role]
if role == roles.STATION and l["station"]:
lib += " · " + self.stations.get(l["station"], l["station"])
out.append((role, lib))
return out
def _peut(self, user, droit):
return roles.peut(self.roles_de(user), droit)
def _exiger(self, user, droit):
if not self._peut(user, droit):
raise Refus(droit)
def fixer_proprietaire(self, hub_id, nom=None):
"""Configuration (ligne de commande), jamais depuis l'interface : nomme le propriétaire du forum."""
u = self.utilisateur(hub_id, nom)
self.con.execute("INSERT OR IGNORE INTO user_roles(user_id, role) VALUES (?, ?)", (u["id"], roles.PROPRIETAIRE))
self.con.commit()
return u
def _cible(self, hub_id):
c = self.con.execute("SELECT * FROM users WHERE hub_id=?", (hub_id,)).fetchone()
if c is None or hub_id == db.SYSTEME:
raise Invalide("utilisateur inconnu")
return c
def donner_role(self, acteur, hub_id, role, station=""):
if not roles.peut_donner(self.roles_de(acteur), role):
raise Refus("donner le rôle %s" % role)
if role == roles.STATION:
if station not in self.stations:
raise Invalide("station inconnue")
else:
station = ""
cible = self._cible(hub_id)
self.con.execute("INSERT OR IGNORE INTO user_roles(user_id, role, station, given_by) VALUES (?, ?, ?, ?)",
(cible["id"], role, station, acteur["id"]))
self.con.commit()
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)
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()
# --- lecture -------------------------------------------------------
def _visible(self, user, t):
"""Un sujet masqué ou en attente n'est visible que des modérateurs, propriétaires et de son auteur (attente)."""
if t is None:
return False
if t["hidden"] and not self._peut(user, "voir_masques"):
return False
if t["status"] != "publie":
return self._peut(user, "valider_sujet") or (user is not None and t["author_id"] == user["id"])
return True
def sujets(self, user):
"""Sujets : épinglés d'abord (le Bulletin en tête), puis les plus récents."""
voit = self._peut(user, "voir_masques")
rows = self.con.execute(
"SELECT t.*, u.display_name AS auteur,"
" (SELECT COUNT(*) FROM posts p WHERE p.topic_id=t.id AND (p.hidden=0 OR ?)) AS n,"
" (SELECT MAX(p.id) FROM posts p WHERE p.topic_id=t.id AND p.hidden=0) AS dernier"
" FROM topics t JOIN users u ON u.id=t.author_id"
" ORDER BY t.fixed DESC, t.pinned DESC, t.pin_pos, COALESCE(dernier, 0) DESC, t.id DESC", (int(voit),)).fetchall()
return [r for r in rows if self._visible(user, r)]
def sujet(self, user, topic_id):
"""Retourne (sujet, messages). Invisible = introuvable."""
t = self.con.execute("SELECT * FROM topics WHERE id=?", (topic_id,)).fetchone()
if not self._visible(user, t):
raise Invalide("sujet introuvable")
voit = self._peut(user, "voir_masques")
msgs = self.con.execute(
"SELECT p.id, p.topic_id, p.author_id, p.body, p.created_at, p.edited_at, p.hidden,"
" u.display_name AS auteur FROM posts p JOIN users u ON u.id=p.author_id"
" WHERE p.topic_id=? AND (p.hidden=0 OR ?) ORDER BY p.id", (topic_id, int(voit))).fetchall()
return t, msgs
def en_attente(self, user):
self._exiger(user, "valider_sujet")
return self.con.execute("SELECT t.*, u.display_name AS auteur FROM topics t JOIN users u ON u.id=t.author_id"
" WHERE t.status='en_attente' ORDER BY t.id").fetchall()
def photos_de(self, post_id):
return self.con.execute("SELECT * FROM attachments WHERE post_id=? ORDER BY id", (post_id,)).fetchall()
# --- écriture -------------------------------------------------------
@staticmethod
def _texte(s, maxi, nom):
s = (s or "").strip()
if not s or len(s) > maxi:
raise Invalide("%s vide ou trop long" % nom)
return s
def _nouveau_sujet(self, user, titre, corps, ip, status="publie", station=None):
cur = self.con.execute("INSERT INTO topics(title, author_id, status, station) VALUES (?, ?, ?, ?)",
(titre, user["id"], status, station))
post = self.con.execute("INSERT INTO posts(topic_id, author_id, body, ip) VALUES (?, ?, ?, ?)",
(cur.lastrowid, user["id"], corps, ip))
self.con.commit()
return cur.lastrowid, post.lastrowid
def creer_sujet(self, user, titre, corps, ip=None):
"""Adhérents et propriétaires (un membre écrit seulement dans les sujets existants)."""
self._exiger(user, "creer_sujet")
return self._nouveau_sujet(user, self._texte(titre, TITRE_MAX, "titre"), self._texte(corps, CORPS_MAX, "message"), ip)[0]
def creer_sujet_station(self, user, station, corps, ip=None):
"""Propriétaire de station : un seul sujet pour sa station, titre préconfiguré, à valider."""
self._exiger(user, "creer_sujet_station")
if station not in self.stations_de(user):
raise Refus("ce n'est pas votre station")
if self.con.execute("SELECT 1 FROM topics WHERE station=? AND status<>'refuse'", (station,)).fetchone():
raise Invalide("cette station a déjà son sujet")
titre = "Station · " + self.stations.get(station, station)
return self._nouveau_sujet(user, titre, self._texte(corps, CORPS_MAX, "message"), ip, "en_attente", station)[0]
def valider_sujet(self, user, topic_id, accepte=True):
self._exiger(user, "valider_sujet")
t = self.con.execute("SELECT * FROM topics WHERE id=?", (topic_id,)).fetchone()
if t is None or t["status"] != "en_attente":
raise Invalide("rien à valider")
self.con.execute("UPDATE topics SET status=? WHERE id=?", ("publie" if accepte else "refuse", topic_id))
self.con.commit()
def repondre(self, user, topic_id, corps, ip=None):
self._exiger(user, "repondre")
t, _ = self.sujet(user, topic_id)
if t["locked"]:
raise Refus("sujet verrouillé")
if t["status"] != "publie":
raise Refus("sujet en attente de validation")
if not t["replies_open"] and not self._peut(user, "publier_bulletin"):
raise Refus("sujet fermé aux réponses")
cur = self.con.execute("INSERT INTO posts(topic_id, author_id, body, ip) VALUES (?, ?, ?, ?)",
(topic_id, user["id"], self._texte(corps, CORPS_MAX, "message"), ip))
self.con.commit()
return cur.lastrowid
def epingler(self, user, topic_id, epingle=True, position=None):
"""Jusqu'à EPINGLES_MAX sujets épinglés, Bulletin compris ; le Bulletin ne se désépingle pas."""
self._exiger(user, "epingler")
t, _ = self.sujet(user, topic_id)
if t["fixed"]:
raise Refus("le Bulletin de la semaine reste épinglé")
if epingle and not t["pinned"]:
n = self.con.execute("SELECT COUNT(*) FROM topics WHERE pinned=1").fetchone()[0]
if n >= EPINGLES_MAX:
raise Refus("%d sujets épinglés au maximum" % EPINGLES_MAX)
if position is None:
position = (self.con.execute("SELECT COALESCE(MAX(pin_pos), 0) FROM topics WHERE pinned=1").fetchone()[0] + 1)
self.con.execute("UPDATE topics SET pinned=?, pin_pos=? WHERE id=?",
(int(epingle), max(1, int(position)) if epingle else 0, topic_id))
self.con.commit()
def ajouter_photos(self, user, post_id, fichiers):
"""fichiers : [(nom, octets)]. 10 photos et 25 Mo par message, sauf propriétaires. Métadonnées retirées."""
p = self._post(post_id)
if p["author_id"] != user["id"]:
raise Refus("pas votre message")
deja = self.photos_de(post_id)
prets = self._preparer_photos(fichiers, deja, self._peut(user, "photos_illimitees"))
ids = []
for nom, mime, propre in prets:
empreinte, chemin = self._stocker(self.dossier_photos, mime, propre)
cur = self.con.execute("INSERT INTO attachments(post_id, filename, mime, size, sha256, stored_path)"
" VALUES (?, ?, ?, ?, ?, ?)", (post_id, nom, mime, len(propre), empreinte, chemin))
ids.append(cur.lastrowid)
self.con.commit()
return ids
def _preparer_photos(self, fichiers, deja=(), illimite=False):
"""Vérifie limites et formats, retire les métadonnées ; rien n'est écrit. -> [(nom, mime, octets)]"""
if not self.dossier_photos:
raise Invalide("photos non configurées")
if not illimite:
if len(deja) + len(fichiers) > PHOTOS_MAX:
raise Refus("%d photos par message au maximum" % PHOTOS_MAX)
if sum(a["size"] for a in deja) + sum(len(d) for _, d in fichiers) > OCTETS_MAX:
raise Refus("25 Mo par message au maximum")
prets = []
for nom, data in fichiers: # tout est vérifié avant d'écrire quoi que ce soit
try:
mime, propre = photos.nettoyer(data)
except photos.PhotoInvalide as e:
raise Invalide(str(e))
prets.append((os.path.basename(nom or "photo")[:80], mime, propre))
return prets
@staticmethod
def _stocker(dossier, mime, propre):
os.makedirs(dossier, exist_ok=True)
empreinte = hashlib.sha256(propre).hexdigest()
chemin = os.path.join(dossier, empreinte + photos.TYPES[mime])
if not os.path.exists(chemin):
with open(chemin + ".tmp", "wb") as f:
f.write(propre)
os.replace(chemin + ".tmp", chemin)
return empreinte, chemin
# --- demandes d'adhésion ---------------------------------------------
# Méthodes prévues pour être reprises telles quelles par le panneau LAN.
@property
def dossier_demandes(self):
"""Photos des demandes : hors du dossier public, servies seulement au propriétaire et à l'adjoint."""
return os.path.join(self.dossier_photos, "demandes") if self.dossier_photos else None
def demander_adhesion(self, user, message, fichiers=()):
"""Un membre demande à devenir adhérent météo : message + jusqu'à 10 photos (25 Mo). Une demande en cours à la fois."""
self._exiger(user, "demander_adhesion")
if roles.ADHERENT in self.roles_de(user):
raise Invalide("tu es déjà adhérent")
if self.con.execute("SELECT 1 FROM adhesions WHERE user_id=? AND status='en_attente'", (user["id"],)).fetchone():
raise Invalide("une demande est déjà en cours")
message = self._texte(message, ADHESION_MAX, "message")
prets = self._preparer_photos(list(fichiers)) if fichiers else []
cur = self.con.execute("INSERT INTO adhesions(user_id, message) VALUES (?, ?)", (user["id"], message))
try:
for nom, mime, propre in prets:
empreinte, chemin = self._stocker(self.dossier_demandes, mime, propre)
self.con.execute("INSERT INTO adhesion_photos(adhesion_id, filename, mime, size, sha256, stored_path)"
" VALUES (?, ?, ?, ?, ?, ?)", (cur.lastrowid, nom, mime, len(propre), empreinte, chemin))
except OSError:
self.con.rollback()
raise
self.con.commit()
return cur.lastrowid
def ma_demande_adhesion(self, user):
"""Dernière demande de cet utilisateur (ou None), pour lui afficher où elle en est."""
if user is None:
return None
return self.con.execute("SELECT * FROM adhesions WHERE user_id=? ORDER BY id DESC LIMIT 1", (user["id"],)).fetchone()
def demandes_adhesion(self, acteur, statut="en_attente"):
"""Liste des demandes (propriétaire et adjoint). statut : en_attente, acceptee, refusee ou None (toutes)."""
self._exiger(acteur, "valider_adhesion")
return self.con.execute(
"SELECT a.*, u.display_name AS pseudo, u.hub_id,"
" (SELECT COUNT(*) FROM adhesion_photos p WHERE p.adhesion_id=a.id) AS n_photos"
" FROM adhesions a JOIN users u ON u.id=a.user_id WHERE (? IS NULL OR a.status=?) ORDER BY a.id",
(statut, statut)).fetchall()
def demande_adhesion(self, acteur, demande_id):
"""Retourne (demande, photos)."""
self._exiger(acteur, "valider_adhesion")
d = self.con.execute("SELECT a.*, u.display_name AS pseudo, u.hub_id FROM adhesions a"
" JOIN users u ON u.id=a.user_id WHERE a.id=?", (demande_id,)).fetchone()
if d is None:
raise Invalide("demande introuvable")
return d, self.con.execute("SELECT * FROM adhesion_photos WHERE adhesion_id=? ORDER BY id", (demande_id,)).fetchall()
def decider_adhesion(self, acteur, demande_id, accepte):
"""Accepter donne le rôle adhérent météo ; refuser clôt la demande (une nouvelle reste possible)."""
self._exiger(acteur, "valider_adhesion")
d, _ = self.demande_adhesion(acteur, demande_id)
if d["status"] != "en_attente":
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))
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()
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."""
self._exiger(acteur, "valider_adhesion")
for r in self.con.execute("SELECT stored_path FROM adhesion_photos WHERE sha256=?", (nom.split(".")[0],)):
if os.path.basename(r["stored_path"]) == nom and os.path.isfile(r["stored_path"]):
return r["stored_path"]
raise Invalide("photo introuvable")
def _post(self, post_id):
p = self.con.execute("SELECT * FROM posts WHERE id=?", (post_id,)).fetchone()
if p is None:
raise Invalide("message introuvable")
return p
def modifier_message(self, user, post_id, corps):
self._exiger(user, "modifier_son_message")
p = self._post(post_id)
if p["author_id"] != user["id"] or p["hidden"]:
raise Refus("pas votre message")
self.con.execute("UPDATE posts SET body=?, edited_at=datetime('now') WHERE id=?",
(self._texte(corps, CORPS_MAX, "message"), post_id))
self.con.commit()
def signaler(self, user, post_id, motif):
self._exiger(user, "signaler")
if self._post(post_id)["hidden"]:
raise Invalide("message introuvable")
self.con.execute("INSERT OR IGNORE INTO reports(post_id, reporter_id, reason) VALUES (?, ?, ?)",
(post_id, user["id"], self._texte(motif, 500, "motif")))
self.con.commit()
def signalements(self, user):
self._exiger(user, "voir_signalements")
return self.con.execute("SELECT r.*, p.body, p.topic_id FROM reports r JOIN posts p ON p.id=r.post_id"
" ORDER BY r.id DESC").fetchall()
def masquer_message(self, user, post_id, masque=True):
self._exiger(user, "masquer")
self._post(post_id)
self.con.execute("UPDATE posts SET hidden=? WHERE id=?", (int(masque), post_id))
self.con.commit()
def masquer_sujet(self, user, topic_id, masque=True):
self._exiger(user, "masquer")
t, _ = self.sujet(user, topic_id)
if t["fixed"]:
raise Refus("le Bulletin de la semaine ne se masque pas")
self.con.execute("UPDATE topics SET hidden=? WHERE id=?", (int(masque), topic_id))
self.con.commit()
def verrouiller(self, user, topic_id, verrou=True):
self._exiger(user, "verrouiller")
self.sujet(user, topic_id)
self.con.execute("UPDATE topics SET locked=? WHERE id=?", (int(verrou), topic_id))
self.con.commit()
# --- RGPD ----------------------------------------------------------
def purger_ips(self, mois=12):
"""Efface les adresses IP de plus de `mois` mois (obligation légale : un an). Retourne le nombre de lignes."""
cur = self.con.execute("UPDATE posts SET ip=NULL WHERE ip IS NOT NULL AND created_at < datetime('now', ?)",
("-%d months" % mois,))
self.con.commit()
return cur.rowcount