GET /forum/api/station/<id>.json (lecture seule, sans cookie, cache 60 s vidé à chaque changement, max-age 300) : url du sujet et 3 photos épinglées au plus. Bouton « Épingler sur la fiche » sous les photos du sujet de la station pour le Propriétaire, l'adjoint et le propriétaire de cette station. 61 tests passent. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
540 lignes
28 KiB
Python
540 lignes
28 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 threading
|
|
|
|
import db
|
|
import photos
|
|
import roles
|
|
|
|
TITRE_MAX, CORPS_MAX = 150, 20000
|
|
EPINGLES_MAX = 5 # sujet fixe compris
|
|
FICHE_PHOTOS_MAX = 3 # photos épinglées sur la fiche publique d'une station
|
|
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)
|
|
self.apres_roles = None # fonction(hub_id, roles) : envoie les rôles au Hub (branchée par server.py)
|
|
self.version = 0 # augmente à chaque changement visible sur les fiches de station (cache de server.py)
|
|
|
|
def _pousser_roles(self, hub_id):
|
|
if not self.apres_roles:
|
|
return
|
|
c = self.con.execute("SELECT id FROM users WHERE hub_id=?", (hub_id,)).fetchone()
|
|
if c is None:
|
|
return
|
|
rs = [r[0] for r in self.con.execute("SELECT role FROM user_roles WHERE user_id=?", (c[0],))]
|
|
threading.Thread(target=self.apres_roles, args=(hub_id, rs), daemon=True).start()
|
|
|
|
# --- 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)
|
|
self._pousser_roles(hub_id)
|
|
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()
|
|
self._pousser_roles(hub_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)
|
|
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)
|
|
|
|
# --- 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()
|
|
self.version += 1
|
|
|
|
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()
|
|
self.version += 1
|
|
|
|
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()
|
|
self.version += 1
|
|
|
|
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()
|
|
|
|
# --- fiche publique d'une station (page station de vercors.me) ------
|
|
def _photo_de_station(self, attachment_id):
|
|
r = self.con.execute(
|
|
"SELECT a.id, a.post_id, p.topic_id, p.hidden AS message_masque, t.station, t.status, t.hidden AS sujet_masque"
|
|
" FROM attachments a JOIN posts p ON p.id=a.post_id JOIN topics t ON t.id=p.topic_id WHERE a.id=?",
|
|
(attachment_id,)).fetchone()
|
|
if r is None:
|
|
raise Invalide("photo introuvable")
|
|
if not r["station"]:
|
|
raise Invalide("cette photo n'est pas dans le sujet d'une station")
|
|
return r
|
|
|
|
def peut_epingler_photo(self, user, station):
|
|
"""Propriétaire et adjoint : toutes les stations ; propriétaire de station : la sienne seulement."""
|
|
rs = self.roles_de(user)
|
|
if not station or not roles.peut(rs, "epingler_photo_fiche"):
|
|
return False
|
|
return bool(rs & roles.PROPRIOS) or station in self.stations_de(user)
|
|
|
|
def epingler_photo(self, user, attachment_id, epingle=True):
|
|
"""Épingle (ou retire) une photo du sujet de la station sur sa fiche publique, FICHE_PHOTOS_MAX au plus."""
|
|
ph = self._photo_de_station(attachment_id)
|
|
if not self.peut_epingler_photo(user, ph["station"]):
|
|
raise Refus("épingler une photo de cette station")
|
|
if epingle:
|
|
if ph["status"] != "publie" or ph["sujet_masque"] or ph["message_masque"]:
|
|
raise Invalide("seule une photo publiée peut aller sur la fiche")
|
|
if self.con.execute("SELECT 1 FROM fiche_photos WHERE attachment_id=?", (attachment_id,)).fetchone():
|
|
return ph["topic_id"], ph["post_id"]
|
|
n = self.con.execute("SELECT COUNT(*) FROM fiche_photos WHERE station=?", (ph["station"],)).fetchone()[0]
|
|
if n >= FICHE_PHOTOS_MAX:
|
|
raise Refus("%d photos au plus sur la fiche ; retires-en une d'abord" % FICHE_PHOTOS_MAX)
|
|
self.con.execute("INSERT INTO fiche_photos(attachment_id, station, pinned_by) VALUES (?, ?, ?)",
|
|
(attachment_id, ph["station"], user["id"]))
|
|
else:
|
|
self.con.execute("DELETE FROM fiche_photos WHERE attachment_id=?", (attachment_id,))
|
|
self.con.commit()
|
|
self.version += 1
|
|
return ph["topic_id"], ph["post_id"]
|
|
|
|
def photos_fiche_ids(self, station):
|
|
return {r[0] for r in self.con.execute("SELECT attachment_id FROM fiche_photos WHERE station=?", (station,))}
|
|
|
|
def fiche_station(self, station):
|
|
"""Lecture publique : sujet publié de la station et ses photos épinglées encore visibles."""
|
|
if station not in self.stations:
|
|
raise Invalide("station inconnue")
|
|
t = self.con.execute("SELECT id FROM topics WHERE station=? AND status='publie' AND hidden=0",
|
|
(station,)).fetchone()
|
|
photos_ = []
|
|
if t is not None:
|
|
photos_ = [{"fichier": os.path.basename(r["stored_path"]), "auteur": r["auteur"]} for r in self.con.execute(
|
|
"SELECT a.stored_path, u.display_name AS auteur FROM fiche_photos f"
|
|
" JOIN attachments a ON a.id=f.attachment_id JOIN posts p ON p.id=a.post_id JOIN users u ON u.id=p.author_id"
|
|
" WHERE f.station=? AND p.topic_id=? AND p.hidden=0 ORDER BY f.pinned_at, f.attachment_id LIMIT ?",
|
|
(station, t["id"], FICHE_PHOTOS_MAX))]
|
|
return {"station": station, "sujet": t["id"] if t is not None else None, "photos": photos_}
|
|
|
|
# --- 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
|