Comparer les révisions
70
Révisions
main
...
f673b752b3
Aucun fichier ne correspond à votre recherche
@@ -6,3 +6,5 @@ __pycache__/
|
||||
site-v2/
|
||||
maquettes/accueil-carte/tuiles/
|
||||
maquettes/accueil-carte/*.png
|
||||
forum/forum-local.sqlite3
|
||||
forum/photos-local/
|
||||
@@ -113,8 +113,17 @@ def courbes(db, maintenant, jours=JOURS):
|
||||
return out
|
||||
|
||||
|
||||
# Stations qu'on n'a pas le droit de publier (04/11/2026 : pas d'autorisation) : gardées en base, jamais écrites.
|
||||
NON_PUBLIEES = {"rochechinard", "marignac", "solaure"}
|
||||
|
||||
|
||||
def ecrire(dossier, maintenant, db):
|
||||
cb = courbes(db, maintenant)
|
||||
cb = {k: v for k, v in courbes(db, maintenant).items() if k not in NON_PUBLIEES}
|
||||
for sid in NON_PUBLIEES:
|
||||
try:
|
||||
os.remove(os.path.join(dossier, sid + ".json"))
|
||||
except OSError:
|
||||
pass
|
||||
index = {}
|
||||
for sid, c in cb.items():
|
||||
ecrire_atomique(os.path.join(dossier, sid + ".json"), c)
|
||||
|
||||
@@ -143,9 +143,12 @@ def meta_station(c):
|
||||
return {"lat": round(c["lat"], 2), "lon": round(c["lon"], 2), "altitude": c["altitude"], "licence": LICENCE_MF}
|
||||
|
||||
|
||||
def collecter(config, cle, heures=24, appel=appeler, pause=1.3):
|
||||
"""Appels réels (une requête par poste). Un poste en erreur ou muet est marqué hors ligne."""
|
||||
def collecter(config, cle, heures=24, appel=appeler, pause=1.3, precedent=None):
|
||||
"""Appels réels (une requête par poste). Une erreur réseau est réessayée une fois ; si elle persiste,
|
||||
on garde les relevés du passage précédent (precedent = ancien JSON) : un raté isolé ne vide plus la station.
|
||||
Un poste muet reste marqué hors ligne."""
|
||||
fin = maintenant()
|
||||
anciens = (precedent or {}).get("stations") or {}
|
||||
stations, meta, journal = {}, {}, []
|
||||
for i, (sid, c) in enumerate(config["stations"].items()):
|
||||
meta[sid] = meta_station(c)
|
||||
@@ -155,13 +158,22 @@ def collecter(config, cle, heures=24, appel=appeler, pause=1.3):
|
||||
else:
|
||||
if i and pause:
|
||||
time.sleep(pause) # quota : 50 requêtes par minute
|
||||
try:
|
||||
rel = construire_releves(appel(c["id"], cle), fin, heures)
|
||||
except ErreurMF as e:
|
||||
etat = "erreur (%s)" % e
|
||||
for essai in (1, 2):
|
||||
try:
|
||||
rel = construire_releves(appel(c["id"], cle), fin, heures)
|
||||
etat = "ok" if essai == 1 else "ok au 2e essai"
|
||||
break
|
||||
except ErreurMF as e:
|
||||
etat = "erreur (%s)" % e
|
||||
if essai == 1 and pause:
|
||||
time.sleep(3)
|
||||
if not rel and etat.startswith("erreur") and sid in anciens:
|
||||
rel = [r for r in anciens[sid].get("releves") or []
|
||||
if fin - lire_date(r["dh_utc"].replace(" ", "T")) <= dt.timedelta(hours=heures)]
|
||||
etat += ", relevés précédents gardés"
|
||||
dernier = lire_date(rel[-1]["dh_utc"].replace(" ", "T")) if rel else None
|
||||
hors_ligne = dernier is None or fin - dernier > dt.timedelta(minutes=HORS_LIGNE_MIN)
|
||||
if rel and hors_ligne and etat == "ok":
|
||||
if rel and hors_ligne and etat.startswith("ok"):
|
||||
etat = "dernier relevé trop ancien"
|
||||
stations[sid] = {"nom": c["nom"], "source": SOURCE_MF, "hors_ligne": hors_ligne, "releves": rel}
|
||||
journal.append("%s: %s (%d relevés)" % (sid, etat, len(rel)))
|
||||
@@ -180,7 +192,12 @@ def main(argv=None):
|
||||
with open(a.config, encoding="utf-8") as f:
|
||||
config = json.load(f)
|
||||
cle = lire_cle(config["var_cle"], a.fichier_env or config.get("fichier_env"))
|
||||
obj, journal = collecter(config, cle, a.heures)
|
||||
try:
|
||||
with open(a.sortie, encoding="utf-8") as f:
|
||||
precedent = json.load(f)
|
||||
except (OSError, ValueError):
|
||||
precedent = None
|
||||
obj, journal = collecter(config, cle, a.heures, precedent=precedent)
|
||||
verifier_public(obj)
|
||||
for st in obj["stations"].values():
|
||||
assert all(set(r) <= set(CHAMPS_PUBLICS) for r in st["releves"])
|
||||
|
||||
@@ -0,0 +1,350 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Collecte ROMMA (api_export.php, type=live) -> JSON public filtré (public/data/romma.json).
|
||||
|
||||
Stations autorisées par ROMMA (accord du 24/10/2026 : « une requête toutes les 10 minutes convient », pas
|
||||
d'historique via l'API, ROMMA cité) : Engins (139), Die (159), Saint-Julien-en-Quint (158), Cirque d'Archiane (212).
|
||||
|
||||
Un SEUL appel par passage (global=1 renvoie toutes les stations de la clé, on ne garde que les 4).
|
||||
Garde-fou : jamais plus d'un appel par 10 minutes (horodatage « pas_avant_utc » écrit AVANT l'appel).
|
||||
Même format que meteofrance.json / infoclimat.json. ROMMA ne donne que le relevé courant : on accumule
|
||||
nos propres passages sur 24 h (pas d'historique demandé à ROMMA). Erreur : relevés précédents gardés.
|
||||
|
||||
Mode SIMULATION par défaut (aucun réseau, données factices, n'écrit que si --sortie est donné).
|
||||
Mode --reel : exige ROMMA_APPEL_RESEAU_VALIDE=oui, ROMMA_CLE, ROMMA_URL_API (avec le marqueur {cle}) ;
|
||||
variables d'environnement, sinon fichier ~/.config/meteo-vercors/romma.env (NOM=valeur). La clé n'est jamais
|
||||
affichée, ni écrite ailleurs.
|
||||
|
||||
Usage :
|
||||
python collecter_romma.py --sortie /tmp/essai.json # simulation
|
||||
python collecter_romma.py --reel # un appel réel (si le délai de 10 min est passé)
|
||||
"""
|
||||
import argparse
|
||||
import datetime as dt
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import sys
|
||||
import urllib.error
|
||||
import urllib.request
|
||||
|
||||
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
|
||||
from collecter_weatherlink import CHAMPS_PUBLICS, charger_json, ecrire_atomique, fmt_utc, maintenant, verifier_public # noqa: E402
|
||||
|
||||
UTC = dt.timezone.utc
|
||||
SOURCE_ROMMA = "ROMMA"
|
||||
MENTION = "Source des données : ROMMA (Réseau d'Observation Météo du Massif Alpin) - www.romma.fr"
|
||||
UA = "vercors.me/0.1 (meteo-vercors)"
|
||||
RACINE = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
|
||||
SORTIE_DEFAUT = os.path.join(RACINE, "public", "data", "romma.json")
|
||||
ENV_DEFAUT = "~/.config/meteo-vercors/romma.env"
|
||||
ETAT_DEFAUT = "~/.config/meteo-vercors/romma_etat.json"
|
||||
INTERVALLE_S = 600 # plancher entre deux appels
|
||||
PAUSE_CLE_REFUSEE_S = 3600
|
||||
HORS_LIGNE_MIN = 40
|
||||
# id du site -> (numéro ROMMA, nom). Les numéros sont ceux de l'autorisation ; rien d'autre n'est conservé.
|
||||
STATIONS = {
|
||||
"engins": (139, "Engins"),
|
||||
"die": (159, "Die"),
|
||||
"st-julien-q": (158, "Saint-Julien-en-Quint"),
|
||||
"archiane": (212, "Cirque d'Archiane"),
|
||||
}
|
||||
# [À VÉRIFIER auprès de ROMMA] unité du vent : on suppose des km/h. Si m/s, mettre 3.6.
|
||||
FACTEUR_VENT = 1.0
|
||||
ROSE = {n: i * 22.5 for i, n in enumerate("N NNE NE ENE E ESE SE SSE S SSO SO OSO O ONO NO NNO".split())}
|
||||
|
||||
|
||||
class ErreurRomma(Exception):
|
||||
pass
|
||||
|
||||
|
||||
class CleRefusee(ErreurRomma):
|
||||
pass
|
||||
|
||||
|
||||
# ------------------------------------------------------------------ heure de Paris (sans tzdata)
|
||||
def _dernier_dimanche(annee, mois):
|
||||
d = dt.date(annee, mois, 31)
|
||||
return d - dt.timedelta(days=(d.weekday() + 1) % 7)
|
||||
|
||||
|
||||
def paris_vers_utc(local):
|
||||
"""datetime naïf (heure de Paris) -> UTC. None si l'heure n'existe pas (saut de mars)."""
|
||||
debut = dt.datetime.combine(_dernier_dimanche(local.year, 3), dt.time(1), UTC)
|
||||
fin = dt.datetime.combine(_dernier_dimanche(local.year, 10), dt.time(1), UTC)
|
||||
ete = (local - dt.timedelta(hours=2)).replace(tzinfo=UTC)
|
||||
if debut <= ete < fin:
|
||||
return ete
|
||||
hiver = (local - dt.timedelta(hours=1)).replace(tzinfo=UTC)
|
||||
return hiver if (hiver < debut or hiver >= fin) else None
|
||||
|
||||
|
||||
# ------------------------------------------------------------------ clé et réglages
|
||||
def lire_env(fichier):
|
||||
"""Lit NOM=valeur du fichier (si présent), puis l'environnement l'emporte. Rien n'est affiché."""
|
||||
out = {}
|
||||
try:
|
||||
with open(os.path.expanduser(fichier), encoding="utf-8") as f:
|
||||
for ligne in f:
|
||||
nom, sep, val = ligne.strip().partition("=")
|
||||
if sep and not nom.startswith("#"):
|
||||
out[nom.strip()] = val.strip().strip('"').strip("'")
|
||||
except OSError:
|
||||
pass
|
||||
for nom in ("ROMMA_CLE", "ROMMA_URL_API", "ROMMA_APPEL_RESEAU_VALIDE"):
|
||||
if os.environ.get(nom):
|
||||
out[nom] = os.environ[nom]
|
||||
return out
|
||||
|
||||
|
||||
def masquer(t, cle):
|
||||
return t.replace(cle, "***") if cle else t
|
||||
|
||||
|
||||
def appeler(url_modele, cle, ouvrir=None):
|
||||
"""UN appel. La clé n'apparaît dans aucun message d'erreur."""
|
||||
req = urllib.request.Request(url_modele.replace("{cle}", cle), headers={"User-Agent": UA, "Accept": "application/json"})
|
||||
try:
|
||||
with (ouvrir or urllib.request.urlopen)(req, timeout=30) as r:
|
||||
return r.read()
|
||||
except urllib.error.HTTPError as e:
|
||||
raise ErreurRomma("HTTP %d" % e.code)
|
||||
except Exception as e:
|
||||
raise ErreurRomma("réseau : %s" % type(e).__name__)
|
||||
|
||||
|
||||
# ------------------------------------------------------------------ lecture de la réponse
|
||||
def nombre(o, cle):
|
||||
v = o.get(cle)
|
||||
if isinstance(v, bool) or v is None:
|
||||
return None
|
||||
if isinstance(v, (int, float)):
|
||||
return float(v)
|
||||
if isinstance(v, str):
|
||||
s = v.strip()
|
||||
if not s or s.upper() == "NULL":
|
||||
return None
|
||||
try:
|
||||
return float(s.replace(",", "."))
|
||||
except ValueError:
|
||||
return None
|
||||
return None
|
||||
|
||||
|
||||
def texte(o, cle):
|
||||
v = o.get(cle)
|
||||
if isinstance(v, (int, float)) and not isinstance(v, bool):
|
||||
return str(int(v)) if float(v).is_integer() else str(v)
|
||||
if isinstance(v, str) and v.strip() and v.strip().upper() != "NULL":
|
||||
return v.strip()
|
||||
return None
|
||||
|
||||
|
||||
def lire_date_heure(date, heure):
|
||||
m = re.fullmatch(r"\s*(\d{1,2})/(\d{1,2})/(\d{2}|\d{4})\s*", date or "")
|
||||
h = re.fullmatch(r"\s*(\d{1,2}):(\d{2})(?::(\d{2}))?\s*", heure or "")
|
||||
if not m or not h:
|
||||
return None
|
||||
a = int(m.group(3))
|
||||
try:
|
||||
return dt.datetime(a + 2000 if a < 100 else a, int(m.group(2)), int(m.group(1)),
|
||||
int(h.group(1)), int(h.group(2)), int(h.group(3) or 0))
|
||||
except ValueError:
|
||||
return None
|
||||
|
||||
|
||||
def parser_reponse(corps, fin, cle=""):
|
||||
"""Réponse brute -> ({id_site: (relevé public, métadonnées)}, avertissements). Lève ErreurRomma / CleRefusee.
|
||||
Ne garde que les 4 stations autorisées ; ignore les mesures invalides, sans température ou dans le futur."""
|
||||
if isinstance(corps, bytes):
|
||||
corps = corps.decode("utf-8", errors="replace")
|
||||
try:
|
||||
valeur = json.loads(corps.strip().lstrip(""))
|
||||
except ValueError:
|
||||
raise ErreurRomma("réponse non JSON")
|
||||
if isinstance(valeur, str):
|
||||
bas = valeur.lower()
|
||||
if "apikey invalid" in bas or "no user associated" in bas:
|
||||
raise CleRefusee("clé refusée")
|
||||
raise ErreurRomma(masquer(valeur, cle)[:120])
|
||||
if not isinstance(valeur, list):
|
||||
raise ErreurRomma("tableau de stations attendu")
|
||||
par_numero = {str(n): sid for sid, (n, _) in STATIONS.items()}
|
||||
out, avert = {}, []
|
||||
for o in valeur:
|
||||
sid = par_numero.get(texte(o, "id_station") or "") if isinstance(o, dict) else None
|
||||
if not sid:
|
||||
continue # station hors autorisation : jamais conservée
|
||||
if not (nombre(o, "is_valide") or 0):
|
||||
avert.append("%s : is_valide=0" % sid)
|
||||
continue
|
||||
loc = lire_date_heure(texte(o, "date"), texte(o, "heure"))
|
||||
d = paris_vers_utc(loc) if loc else None
|
||||
if d is None:
|
||||
avert.append("%s : date/heure inutilisable" % sid)
|
||||
continue
|
||||
if (d - fin).total_seconds() > 900:
|
||||
avert.append("%s : mesure dans le futur" % sid)
|
||||
continue
|
||||
t = nombre(o, "temperature")
|
||||
if t is None:
|
||||
avert.append("%s : pas de température" % sid)
|
||||
continue
|
||||
r = {"dh_utc": fmt_utc(d), "temperature": round(t, 1)}
|
||||
h, p = nombre(o, "humidite"), nombre(o, "pression")
|
||||
v, raf = nombre(o, "vent_moyen_10min"), nombre(o, "vent_rafale_maxi_10min")
|
||||
deg = nombre(o, "vent_direction_degres")
|
||||
if deg is None:
|
||||
deg = ROSE.get((texte(o, "vent_direction") or "").upper())
|
||||
pj = nombre(o, "pluie_jour")
|
||||
if h is not None:
|
||||
r["humidite"] = int(round(h))
|
||||
if p is not None:
|
||||
r["pression"] = round(p, 1)
|
||||
if v is not None:
|
||||
r["vent_moyen"] = round(v * FACTEUR_VENT, 1)
|
||||
if raf is not None:
|
||||
r["vent_rafales"] = round(raf * FACTEUR_VENT, 1)
|
||||
if deg is not None and v:
|
||||
r["vent_direction"] = int(round(deg)) % 360
|
||||
if pj is not None:
|
||||
r["pluie_cumul_0h"] = round(pj, 1)
|
||||
meta = {"licence": SOURCE_ROMMA}
|
||||
lat, lon, alt = nombre(o, "latitude"), nombre(o, "longitude"), nombre(o, "altitude")
|
||||
if lat is not None and lon is not None:
|
||||
meta["lat"], meta["lon"] = round(lat, 2), round(lon, 2)
|
||||
if alt is not None:
|
||||
meta["altitude"] = int(round(alt))
|
||||
out[sid] = (r, meta)
|
||||
return out, avert
|
||||
|
||||
|
||||
# ------------------------------------------------------------------ assemblage
|
||||
def lire_dh(s):
|
||||
return dt.datetime.strptime(s[:19].replace("T", " "), "%Y-%m-%d %H:%M:%S").replace(tzinfo=UTC)
|
||||
|
||||
|
||||
def construire(precedent, nouveaux, fin, heures=24):
|
||||
"""Ancien JSON + relevés du passage -> (nouveau JSON, journal). Sans nouveauté, la station garde ses relevés."""
|
||||
anciens = (precedent or {}).get("stations") or {}
|
||||
metas = dict((precedent or {}).get("metadonnees") or {})
|
||||
debut = fin - dt.timedelta(hours=heures)
|
||||
stations, journal = {}, []
|
||||
for sid, (_, nom) in STATIONS.items():
|
||||
par_date = {}
|
||||
for r in (anciens.get(sid) or {}).get("releves") or []:
|
||||
if isinstance(r, dict) and isinstance(r.get("dh_utc"), str):
|
||||
par_date[r["dh_utc"]] = {k: r[k] for k in CHAMPS_PUBLICS
|
||||
if k in r and k not in ("temperature_min", "temperature_max")}
|
||||
if sid in nouveaux:
|
||||
r, meta = nouveaux[sid]
|
||||
par_date[r["dh_utc"]] = r
|
||||
metas[sid] = {**metas.get(sid, {}), **meta}
|
||||
metas.setdefault(sid, {"licence": SOURCE_ROMMA})
|
||||
rel = [par_date[d] for d in sorted(par_date) if lire_dh(d) > debut]
|
||||
if rel:
|
||||
ts = [r["temperature"] for r in rel]
|
||||
rel[-1]["temperature_min"], rel[-1]["temperature_max"] = min(ts), max(ts)
|
||||
hors = not rel or fin - lire_dh(rel[-1]["dh_utc"]) > dt.timedelta(minutes=HORS_LIGNE_MIN)
|
||||
stations[sid] = {"nom": nom, "source": SOURCE_ROMMA, "hors_ligne": hors, "releves": rel}
|
||||
journal.append("%s: %s (%d relevés)" % (sid, "nouveau" if sid in nouveaux else "pas de nouveau", len(rel)))
|
||||
obj = {"source": MENTION, "mis_a_jour_utc": fin.strftime("%Y-%m-%dT%H:%M:%SZ"),
|
||||
"metadonnees": {sid: metas[sid] for sid in STATIONS}, "stations": stations}
|
||||
return obj, journal
|
||||
|
||||
|
||||
# ------------------------------------------------------------------ garde-fou 10 minutes
|
||||
def reserver_passage(etat_chemin, fin, secondes=INTERVALLE_S):
|
||||
"""(True, None) si un appel est permis ; écrit alors « pas_avant_utc » AVANT l'appel (un plantage ne le rejoue pas)."""
|
||||
etat = charger_json(etat_chemin) if etat_chemin else {}
|
||||
jusque = etat.get("pas_avant_utc")
|
||||
if jusque:
|
||||
try:
|
||||
if fin < lire_dh(jusque):
|
||||
return False, jusque
|
||||
except ValueError:
|
||||
pass
|
||||
if etat_chemin:
|
||||
etat["pas_avant_utc"] = fmt_utc(fin + dt.timedelta(seconds=secondes))
|
||||
ecrire_atomique(etat_chemin, etat)
|
||||
return True, None
|
||||
|
||||
|
||||
def repousser(etat_chemin, fin, secondes, message):
|
||||
if etat_chemin:
|
||||
etat = charger_json(etat_chemin)
|
||||
etat["pas_avant_utc"] = fmt_utc(fin + dt.timedelta(seconds=secondes))
|
||||
etat["derniere_erreur"] = message[:120]
|
||||
ecrire_atomique(etat_chemin, etat)
|
||||
|
||||
|
||||
# ------------------------------------------------------------------ simulation
|
||||
def reponse_factice(fin):
|
||||
loc = (fin + dt.timedelta(hours=1)).replace(tzinfo=None) # simulation seulement : heure d'hiver
|
||||
out = []
|
||||
for i, (sid, (num, nom)) in enumerate(STATIONS.items()):
|
||||
out.append({"id_station": num, "station": nom, "altitude": 500 + 100 * i, "latitude": 44.8 + i / 10,
|
||||
"longitude": 5.4, "is_valide": 1, "date": loc.strftime("%d/%m/%y"), "heure": loc.strftime("%H:%M"),
|
||||
"temperature": 7.5 + i, "pression": 1012.3, "humidite": "NULL", "radiation": "NULL",
|
||||
"vent_moyen_10min": 12 + i, "vent_rafale_maxi_10min": 30, "vent_direction": "SSO",
|
||||
"vent_direction_degres": 202, "pluie_jour": "0.4", "neige": "NULL"})
|
||||
out.append({"id_station": 4, "station": "Hors autorisation", "is_valide": 1, "temperature": 3,
|
||||
"date": loc.strftime("%d/%m/%y"), "heure": loc.strftime("%H:%M")})
|
||||
return json.dumps(out).encode()
|
||||
|
||||
|
||||
# ------------------------------------------------------------------ programme
|
||||
def passage(precedent, fetch, fin, cle="", etat_chemin=None):
|
||||
"""Un passage complet. fetch() -> corps brut. -> (objet à écrire ou None, message, code).
|
||||
Erreur : relevés précédents gardés (objet reconstruit sans nouveauté)."""
|
||||
ok, jusque = reserver_passage(etat_chemin, fin)
|
||||
if not ok:
|
||||
return None, "attente : prochain appel permis après %s UTC" % jusque, 0
|
||||
try:
|
||||
nouveaux, avert = parser_reponse(fetch(), fin, cle)
|
||||
except ErreurRomma as e:
|
||||
msg = masquer(str(e), cle)
|
||||
repousser(etat_chemin, fin, PAUSE_CLE_REFUSEE_S if isinstance(e, CleRefusee) else INTERVALLE_S, msg)
|
||||
if precedent:
|
||||
obj, journal = construire(precedent, {}, fin)
|
||||
return obj, "erreur (%s), relevés précédents gardés ; %s" % (msg, "; ".join(journal)), 0
|
||||
return None, "erreur (%s), rien à garder" % msg, 1
|
||||
obj, journal = construire(precedent, nouveaux, fin)
|
||||
return obj, "ok ; " + "; ".join(journal + avert), 0
|
||||
|
||||
|
||||
def main(argv=None):
|
||||
ap = argparse.ArgumentParser(description=__doc__.split("\n")[0])
|
||||
ap.add_argument("--reel", action="store_true", help="appel réseau réel (garde-fous requis) ; défaut : simulation")
|
||||
ap.add_argument("--sortie", default=None, help="défaut en réel : public/data/romma.json ; en simulation : rien n'est écrit")
|
||||
ap.add_argument("--fichier-env", default=ENV_DEFAUT)
|
||||
ap.add_argument("--etat", default=None, help="fichier d'horodatage du garde-fou (défaut réel : %s)" % ETAT_DEFAUT)
|
||||
a = ap.parse_args(argv)
|
||||
fin = maintenant()
|
||||
cle, etat = "", a.etat
|
||||
if a.reel:
|
||||
env = lire_env(a.fichier_env)
|
||||
cle, url = env.get("ROMMA_CLE", ""), env.get("ROMMA_URL_API", "")
|
||||
if env.get("ROMMA_APPEL_RESEAU_VALIDE") != "oui":
|
||||
print("refusé : ROMMA_APPEL_RESEAU_VALIDE=oui non déclaré (validation de Théo)")
|
||||
return 2
|
||||
if not cle or "{cle}" not in url:
|
||||
print("refusé : ROMMA_CLE et ROMMA_URL_API (avec {cle}) requises dans %s" % a.fichier_env)
|
||||
return 2
|
||||
sortie = a.sortie or SORTIE_DEFAUT
|
||||
etat = etat or os.path.expanduser(ETAT_DEFAUT)
|
||||
fetch = lambda: appeler(url, cle) # noqa: E731
|
||||
else:
|
||||
sortie = a.sortie
|
||||
fetch = lambda: reponse_factice(fin) # noqa: E731
|
||||
precedent = charger_json(sortie) if sortie else {}
|
||||
obj, msg, code = passage(precedent, fetch, fin, cle, etat)
|
||||
if obj is not None:
|
||||
verifier_public(obj)
|
||||
if sortie:
|
||||
ecrire_atomique(sortie, obj)
|
||||
print(("" if a.reel else "[simulation] ") + msg)
|
||||
return code
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
@@ -27,8 +27,8 @@ HORS_LIGNE_MIN = 40 # Infoclimat publie toutes les 10 min, avec du retard
|
||||
STATIONS = {
|
||||
"bruyeres": "000T0", "allieres": "000GS", "engins": "000HT", "meaudre": "000IA", "geve": "000IL",
|
||||
"lans": "VP2", "moucherolle": "STATIC0479", "darbounouse": "STATIC0213", "oscence": "000UF",
|
||||
"die": "000PD", "st-julien-q": "000OS", "marignac": "STATIC0203", "archiane": "000ZK",
|
||||
"rochechinard": "STATIC0238", "solaure": "STATIC0323",
|
||||
"die": "000PD", "st-julien-q": "000OS", "archiane": "000ZK",
|
||||
# retirées le 04/11 (pas d'autorisation) : rochechinard STATIC0238, marignac STATIC0203, solaure STATIC0323
|
||||
}
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,329 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Écrit les données de la page « Climat » de vercors.me : un petit JSON par station (data/climat/<id>.json + index.json).
|
||||
|
||||
Lit l'archive SQLite EN LECTURE SEULE (aucune écriture dans la base) :
|
||||
- table horaire (open data Météo-France) : températures horaires depuis 1993-1995 selon le poste,
|
||||
hauteur de neige au sol (relevé quotidien de 7 h) depuis 1957-1972 pour Gresse, Autrans et Villard ;
|
||||
- table obs (pas de 10 min) : stations ROMMA et de la famille Gastinel (historique relayé par Infoclimat), et le direct.
|
||||
Pour chaque station : température moyenne par année, records, jours de gel par hiver, jours de neige au sol par hiver
|
||||
et la normale saisonnière (1991-2020 si au moins 20 années complètes, sinon la période disponible, annoncée comme telle).
|
||||
Python standard uniquement. Une fois par jour suffit.
|
||||
|
||||
Usage :
|
||||
python generer_climat.py --db archive/vercors.db --sortie public/data/climat
|
||||
"""
|
||||
import argparse
|
||||
import bisect
|
||||
import calendar
|
||||
import datetime as dt
|
||||
import json
|
||||
import math
|
||||
import os
|
||||
import sys
|
||||
import tempfile
|
||||
|
||||
import sqlite3
|
||||
|
||||
# Stations publiées sur la carte (même liste que l'accueil ; rochechinard, marignac, solaure : pas d'autorisation)
|
||||
STATIONS = {
|
||||
"autrans": ("Autrans – L'Escandille", 1069, "Météo-France"),
|
||||
"geve": ("Autrans – Gêve nordique", 1287, "famille Gastinel"),
|
||||
"engins": ("Engins, le Fournel", 905, "ROMMA"),
|
||||
"meaudre": ("Méaudre", 976, "famille Gastinel"),
|
||||
"lans": ("Lans-en-Vercors – village", 1020, "famille Gastinel"),
|
||||
"bruyeres": ("Lans-en-Vercors – Les Bruyères", 990, "famille Gastinel"),
|
||||
"allieres": ("Lans-en-Vercors – Les Allières", 1449, "famille Gastinel"),
|
||||
"villard": ("Villard-de-Lans – Payonère", 1027, "Météo-France"),
|
||||
"moucherolle": ("Crête de la Moucherolle", 1965, "famille Gastinel"),
|
||||
"chapelle": ("La Chapelle-en-Vercors – Les Finets", 879, "Météo-France"),
|
||||
"oscence": ("Combe de l'Oscence", 1000, "famille Gastinel"),
|
||||
"darbounouse": ("Combe de Darbounouse", 1282, "famille Gastinel"),
|
||||
"rousset": ("Col du Rousset – plateau de Beurre", 1400, "Météo-France"),
|
||||
"gresse": ("Gresse-en-Vercors", 1220, "Météo-France"),
|
||||
"st-jean": ("Saint-Jean-en-Royans", 308, "Météo-France"),
|
||||
"die": ("Die", 400, "ROMMA"),
|
||||
"st-julien-q": ("Saint-Julien-en-Quint", 574, "ROMMA"),
|
||||
"archiane": ("Cirque d'Archiane", 747, "ROMMA"),
|
||||
}
|
||||
|
||||
T_MIN, T_MAX = -35.0, 42.0 # bornes physiques plausibles dans le Vercors
|
||||
SAUT = 6.0 # pic isolé : écart de plus de 6 °C avec les deux voisins (10 min) -> point ignoré
|
||||
HEURES_MIN = 20 # une journée compte si au moins 20 heures sur 24 ont une mesure
|
||||
JOURS_MOIS_AN = 24 # une année compte si chaque mois a au moins 24 journées valides
|
||||
JOURS_MOIS_GEL = 28 # un hiver compte si chaque mois d'octobre à avril a au moins 28 journées valides
|
||||
ANS_MIN = 2 # page « climat » : au moins 2 années complètes de température...
|
||||
HIVERS_NEIGE_MIN = 10 # ...ou au moins 10 hivers de neige au sol
|
||||
PAS_NORMALE = 5 # normale saisonnière : une valeur tous les 5 jours (73 valeurs, interpolées par la page)
|
||||
|
||||
|
||||
# ---------- heure de Paris (règle européenne, sans dépendre de tzdata) ----------
|
||||
def _dernier_dimanche(an, mois):
|
||||
j = calendar.monthrange(an, mois)[1]
|
||||
while dt.date(an, mois, j).weekday() != 6:
|
||||
j -= 1
|
||||
return j
|
||||
|
||||
|
||||
_BASCULES = [] # instants UTC des changements d'heure (1976-2040) ; avant 1976 : pas d'heure d'été en France
|
||||
for _a in range(1976, 2041):
|
||||
for _m, _h in ((3, 1), (10, 1)):
|
||||
_BASCULES.append(int(dt.datetime(_a, _m, _dernier_dimanche(_a, _m), _h, tzinfo=dt.timezone.utc).timestamp()))
|
||||
# 1976-1995 : fin de l'heure d'été fin septembre (règle de l'époque)
|
||||
for _a in range(1976, 1996):
|
||||
_BASCULES[(_a - 1976) * 2 + 1] = int(dt.datetime(_a, 9, _dernier_dimanche(_a, 9), 1, tzinfo=dt.timezone.utc).timestamp())
|
||||
|
||||
|
||||
def jour_local(ts):
|
||||
"""Numéro du jour local (Europe/Paris) : jours depuis le 1/1/1970."""
|
||||
ete = bisect.bisect_right(_BASCULES, ts) % 2 == 1
|
||||
return (ts + (7200 if ete else 3600)) // 86400
|
||||
|
||||
|
||||
def date_du_jour(n):
|
||||
return dt.date(1970, 1, 1) + dt.timedelta(days=n)
|
||||
|
||||
|
||||
# ---------- relevés -> journées (Tn, Tx) ----------
|
||||
class Jours:
|
||||
"""Accumule min, max et heures couvertes par jour local."""
|
||||
|
||||
def __init__(self):
|
||||
self.tn, self.tx, self.h = {}, {}, {}
|
||||
|
||||
def ajoute(self, ts, bas, haut):
|
||||
j = jour_local(ts)
|
||||
if j in self.tn:
|
||||
if bas < self.tn[j]:
|
||||
self.tn[j] = bas
|
||||
if haut > self.tx[j]:
|
||||
self.tx[j] = haut
|
||||
self.h[j].add(ts // 3600)
|
||||
else:
|
||||
self.tn[j], self.tx[j], self.h[j] = bas, haut, {ts // 3600}
|
||||
|
||||
def valides(self):
|
||||
"""{jour: (tn, tx)} des journées assez complètes et cohérentes."""
|
||||
out = {}
|
||||
for j, hs in self.h.items():
|
||||
tn, tx = self.tn[j], self.tx[j]
|
||||
if len(hs) >= HEURES_MIN and tx - tn <= 35:
|
||||
out[j] = (tn, tx)
|
||||
return out
|
||||
|
||||
|
||||
def jours_horaire(db, sid):
|
||||
"""Table horaire Météo-France : TN/TX horaires (sinon la température de l'heure). ts = fin de l'heure."""
|
||||
acc = Jours()
|
||||
for ts, t, tn, tx in db.execute("SELECT ts, t, tn, tx FROM horaire WHERE id = ? AND (t IS NOT NULL OR tn IS NOT NULL) ORDER BY ts", (sid,)):
|
||||
bas = tn if tn is not None else t
|
||||
haut = tx if tx is not None else t
|
||||
if bas is None or haut is None or not (T_MIN <= bas <= T_MAX and T_MIN <= haut <= T_MAX):
|
||||
continue
|
||||
acc.ajoute(ts - 1800, bas, haut) # milieu de l'heure écoulée
|
||||
return acc.valides()
|
||||
|
||||
|
||||
def jours_obs(db, sid):
|
||||
"""Table obs (10 min) : min et max des mesures, pics isolés écartés."""
|
||||
acc = Jours()
|
||||
pts = [(ts, t) for ts, t in db.execute("SELECT ts, t FROM obs WHERE id = ? AND t IS NOT NULL ORDER BY ts", (sid,))
|
||||
if T_MIN <= t <= T_MAX]
|
||||
for i, (ts, t) in enumerate(pts):
|
||||
av = pts[i - 1] if i else None
|
||||
ap = pts[i + 1] if i + 1 < len(pts) else None
|
||||
if (av and ap and ts - av[0] <= 1800 and ap[0] - ts <= 1800
|
||||
and abs(t - av[1]) > SAUT and abs(t - ap[1]) > SAUT and (t - av[1]) * (t - ap[1]) > 0):
|
||||
continue
|
||||
acc.ajoute(ts, t, t)
|
||||
return acc.valides()
|
||||
|
||||
|
||||
def neige_hivers(db, sid):
|
||||
"""Jours avec au moins 1 cm de neige au sol (relevé de 7 h, 06 UTC), d'octobre à mai : {hiver: jours}."""
|
||||
par_jour = {}
|
||||
for ts, n in db.execute("SELECT ts, neige FROM horaire WHERE id = ? AND neige IS NOT NULL AND ((ts % 86400) + 86400) % 86400 = 21600", (sid,)):
|
||||
par_jour[ts // 86400] = n
|
||||
hivers = {}
|
||||
for j, n in par_jour.items():
|
||||
d = date_du_jour(j)
|
||||
if d.month in (6, 7, 8, 9):
|
||||
continue
|
||||
h = d.year if d.month >= 10 else d.year - 1
|
||||
hivers.setdefault(h, [0, 0])
|
||||
hivers[h][0] += 1
|
||||
hivers[h][1] += n >= 1
|
||||
out = {}
|
||||
for h, (presents, neige) in hivers.items():
|
||||
total = (dt.date(h + 1, 6, 1) - dt.date(h, 10, 1)).days
|
||||
if presents >= 0.95 * total:
|
||||
out[h] = neige
|
||||
return out
|
||||
|
||||
|
||||
# ---------- statistiques ----------
|
||||
def par_mois(jours):
|
||||
"""{(an, mois): nombre de journées valides}"""
|
||||
c = {}
|
||||
for j in jours:
|
||||
d = date_du_jour(j)
|
||||
c[(d.year, d.month)] = c.get((d.year, d.month), 0) + 1
|
||||
return c
|
||||
|
||||
|
||||
def annees(jours):
|
||||
"""{an: moyenne de (Tn+Tx)/2} pour les années complètes."""
|
||||
cm = par_mois(jours)
|
||||
som = {}
|
||||
for j, (tn, tx) in jours.items():
|
||||
a = date_du_jour(j).year
|
||||
s = som.setdefault(a, [0.0, 0])
|
||||
s[0] += (tn + tx) / 2
|
||||
s[1] += 1
|
||||
return {a: s / n for a, (s, n) in som.items() if all(cm.get((a, m), 0) >= JOURS_MOIS_AN for m in range(1, 13))}
|
||||
|
||||
|
||||
def gel_hivers(jours):
|
||||
"""{hiver (année de juillet): jours avec Tn <= 0 °C de juillet à juin} pour les hivers complets."""
|
||||
cm = par_mois(jours)
|
||||
som = {}
|
||||
for j, (tn, _) in jours.items():
|
||||
d = date_du_jour(j)
|
||||
h = d.year if d.month >= 7 else d.year - 1
|
||||
som[h] = som.get(h, 0) + (tn <= 0)
|
||||
mois = [(0, 10), (0, 11), (0, 12), (1, 1), (1, 2), (1, 3), (1, 4)]
|
||||
return {h: n for h, n in som.items() if all(cm.get((h + da, m), 0) >= JOURS_MOIS_GEL for da, m in mois)}
|
||||
|
||||
|
||||
def doy365(d):
|
||||
"""Rang du jour dans une année de 365 jours (le 29 février compte comme le 28)."""
|
||||
if d.month == 2 and d.day == 29:
|
||||
d = d.replace(day=28)
|
||||
return (d - dt.date(d.year, 1, 1)).days - (1 if calendar.isleap(d.year) and d.month > 2 else 0)
|
||||
|
||||
|
||||
def cycle(valeurs_par_doy, harmoniques=3):
|
||||
"""Cycle annuel lissé (série de Fourier, 3 harmoniques) échantillonné tous les PAS_NORMALE jours."""
|
||||
pts = [(k, sum(v) / len(v)) for k, v in valeurs_par_doy.items() if v]
|
||||
if len(pts) < 300:
|
||||
return None
|
||||
n = 365.0
|
||||
a0 = sum(v for _, v in pts) / len(pts)
|
||||
coef = []
|
||||
for h in range(1, harmoniques + 1):
|
||||
ca = 2 * sum(v * math.cos(2 * math.pi * h * k / n) for k, v in pts) / len(pts)
|
||||
sa = 2 * sum(v * math.sin(2 * math.pi * h * k / n) for k, v in pts) / len(pts)
|
||||
coef.append((ca, sa))
|
||||
out = []
|
||||
for k in range(0, 365, PAS_NORMALE):
|
||||
v = a0 + sum(ca * math.cos(2 * math.pi * h * k / n) + sa * math.sin(2 * math.pi * h * k / n)
|
||||
for h, (ca, sa) in enumerate(coef, 1))
|
||||
out.append(round(v * 10))
|
||||
return out
|
||||
|
||||
|
||||
def normale(jours, ans, gel):
|
||||
"""Normale 1991-2020 si au moins 20 années complètes dans cette période, sinon toutes les années complètes."""
|
||||
dans = [a for a in ans if 1991 <= a <= 2020]
|
||||
if len(dans) >= 20:
|
||||
choix, officielle = dans, True
|
||||
elif len(ans) >= ANS_MIN:
|
||||
choix, officielle = sorted(ans), False
|
||||
else:
|
||||
return None
|
||||
de, a = min(choix), max(choix)
|
||||
tn_d, tx_d = {}, {}
|
||||
for j, (tn, tx) in jours.items():
|
||||
d = date_du_jour(j)
|
||||
if de <= d.year <= a:
|
||||
k = doy365(d)
|
||||
tn_d.setdefault(k, []).append(tn)
|
||||
tx_d.setdefault(k, []).append(tx)
|
||||
ctn, ctx = cycle(tn_d), cycle(tx_d)
|
||||
if not ctn:
|
||||
return None
|
||||
hg = [n for h, n in gel.items() if de <= h <= a] if officielle else list(gel.values())
|
||||
return {
|
||||
"officielle": officielle, "de": de, "a": a, "n": len(choix),
|
||||
"moy": round(sum(ans[x] for x in choix) / len(choix), 1),
|
||||
"gel": round(sum(hg) / len(hg)) if hg else None,
|
||||
"pas": PAS_NORMALE, "tn": ctn, "tx": ctx,
|
||||
}
|
||||
|
||||
|
||||
def serie(d):
|
||||
"""{clé: valeur} -> [première clé, [valeurs ou null]] (trous compris), valeurs en dixièmes si flottantes."""
|
||||
if not d:
|
||||
return None
|
||||
a, b = min(d), max(d)
|
||||
return [a, [(round(d[k] * 10) if isinstance(d[k], float) else d[k]) if k in d else None for k in range(a, b + 1)]]
|
||||
|
||||
|
||||
def station(db, sid):
|
||||
nom, alt, src = STATIONS[sid]
|
||||
jours = jours_horaire(db, sid)
|
||||
for j, v in jours_obs(db, sid).items(): # le direct (et les stations non Météo-France) complètent sans écraser
|
||||
jours.setdefault(j, v)
|
||||
ans = annees(jours)
|
||||
gel = gel_hivers(jours)
|
||||
neige = neige_hivers(db, sid)
|
||||
if len(ans) < ANS_MIN and len(neige) < HIVERS_NEIGE_MIN:
|
||||
return None
|
||||
out = {"id": sid, "nom": nom, "alt": alt, "src": src}
|
||||
if jours:
|
||||
jmin = min(jours, key=lambda j: (jours[j][0], j))
|
||||
jmax = max(jours, key=lambda j: (jours[j][1], -j))
|
||||
out["t"] = {"de": date_du_jour(min(jours)).isoformat(), "jours": len(jours),
|
||||
"min": [jours[jmin][0], date_du_jour(jmin).isoformat()],
|
||||
"max": [jours[jmax][1], date_du_jour(jmax).isoformat()]}
|
||||
if len(ans) >= ANS_MIN:
|
||||
out["ans"] = serie(ans)
|
||||
if gel:
|
||||
out["gel"] = serie(gel)
|
||||
if len(neige) >= HIVERS_NEIGE_MIN:
|
||||
out["neige"] = serie(neige)
|
||||
nm = normale(jours, ans, gel)
|
||||
if nm:
|
||||
out["normale"] = nm
|
||||
return out
|
||||
|
||||
|
||||
def ecrire_atomique(chemin, obj):
|
||||
os.makedirs(os.path.dirname(chemin), exist_ok=True)
|
||||
fd, tmp = tempfile.mkstemp(dir=os.path.dirname(chemin), suffix=".tmp")
|
||||
with os.fdopen(fd, "w", encoding="utf-8") as f:
|
||||
json.dump(obj, f, ensure_ascii=False, separators=(",", ":"))
|
||||
os.chmod(tmp, 0o644)
|
||||
os.replace(tmp, chemin)
|
||||
|
||||
|
||||
def main(argv=None):
|
||||
ap = argparse.ArgumentParser(description=__doc__.split("\n")[0])
|
||||
ap.add_argument("--db", required=True)
|
||||
ap.add_argument("--sortie", required=True)
|
||||
a = ap.parse_args(argv)
|
||||
chemin = os.path.abspath(os.path.expanduser(a.db))
|
||||
if not os.path.exists(chemin):
|
||||
print("base introuvable : %s" % chemin)
|
||||
return 1
|
||||
db = sqlite3.connect("file:%s?mode=ro" % chemin.replace("\\", "/"), uri=True) # lecture seule
|
||||
sortie = os.path.expanduser(a.sortie)
|
||||
index = {}
|
||||
for sid in STATIONS:
|
||||
d = station(db, sid)
|
||||
cible = os.path.join(sortie, sid + ".json")
|
||||
if not d:
|
||||
if os.path.exists(cible):
|
||||
os.remove(cible)
|
||||
continue
|
||||
d["maj"] = dt.date.today().isoformat()
|
||||
ecrire_atomique(cible, d)
|
||||
index[sid] = {"nom": d["nom"], "alt": d["alt"],
|
||||
"t": int(d["t"]["de"][:4]) if "ans" in d else None,
|
||||
"neige": d["neige"][0] if "neige" in d else None}
|
||||
ecrire_atomique(os.path.join(sortie, "index.json"), index)
|
||||
print("climat : %d stations écrites dans %s" % (len(index), sortie))
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
@@ -0,0 +1,79 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Importe l'historique Infoclimat des stations du Vercors depuis la collecte GWS (lecture seule) dans l'archive.
|
||||
|
||||
Source : /mnt/hdd3/gws-meteo/infoclimat/<id Infoclimat>/*.json.gz (clé "hourly" : {id: [relevés]}, valeurs en texte).
|
||||
Cible : base SQLite de l'archive (table obs, pas de 10 min), via archiver_historique.ingerer :
|
||||
une valeur vide n'écrase jamais une valeur connue, ré-import sans doublon.
|
||||
Usage : python3 importer_infoclimat_hdd3.py --db ~/meteo-vercors/archive/vercors.db [--source /mnt/hdd3/gws-meteo/infoclimat]
|
||||
"""
|
||||
import argparse
|
||||
import gzip
|
||||
import json
|
||||
import os
|
||||
import sys
|
||||
import time
|
||||
|
||||
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
|
||||
import archiver_historique as arch # noqa: E402
|
||||
from extraire_infoclimat import STATIONS # noqa: E402
|
||||
|
||||
|
||||
def nombre(v):
|
||||
try:
|
||||
return float(v)
|
||||
except (TypeError, ValueError):
|
||||
return None
|
||||
|
||||
|
||||
def releves(fichier, id_ic):
|
||||
with gzip.open(fichier, "rt", encoding="utf-8") as f:
|
||||
d = json.load(f)
|
||||
lignes = (d.get("hourly") or {}).get(id_ic) or []
|
||||
out = []
|
||||
for r in lignes:
|
||||
if not isinstance(r, dict) or not isinstance(r.get("dh_utc"), str):
|
||||
continue
|
||||
out.append({k: (v if k == "dh_utc" else nombre(v)) for k, v in r.items()})
|
||||
return out
|
||||
|
||||
|
||||
def main(argv=None):
|
||||
ap = argparse.ArgumentParser()
|
||||
ap.add_argument("--db", required=True)
|
||||
ap.add_argument("--source", default="/mnt/hdd3/gws-meteo/infoclimat")
|
||||
a = ap.parse_args(argv)
|
||||
db = arch.ouvrir(a.db)
|
||||
db.execute("PRAGMA busy_timeout = 60000") # le minuteur écrit aussi dans la base toutes les 6 min
|
||||
total = 0
|
||||
for site, id_ic in STATIONS.items():
|
||||
dossier = os.path.join(a.source, id_ic)
|
||||
if not os.path.isdir(dossier):
|
||||
print("%-13s %-11s aucun dossier" % (site, id_ic))
|
||||
continue
|
||||
n_site, premier = 0, None
|
||||
for nom in sorted(os.listdir(dossier)):
|
||||
if not nom.endswith(".json.gz"):
|
||||
continue
|
||||
try:
|
||||
rs = releves(os.path.join(dossier, nom), id_ic)
|
||||
except (OSError, ValueError, EOFError) as e:
|
||||
print(" illisible :", id_ic, nom, type(e).__name__)
|
||||
continue
|
||||
if rs and premier is None:
|
||||
premier = rs[0]["dh_utc"][:10]
|
||||
for essai in range(5):
|
||||
try:
|
||||
n_site += arch.ingerer(db, {"stations": {site: {"releves": rs}}})
|
||||
break
|
||||
except Exception as e: # base occupée par le minuteur : on réessaie
|
||||
if "locked" not in str(e) or essai == 4:
|
||||
raise
|
||||
time.sleep(5)
|
||||
total += n_site
|
||||
print("%-13s %-11s %8d relevés, depuis %s" % (site, id_ic, n_site, premier or "—"), flush=True)
|
||||
print("total :", total)
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
@@ -24,6 +24,10 @@ POSTES = {"38021001": "autrans", "38548001": "villard", "26074001": "chapelle",
|
||||
# colonne de la base <- colonne Météo-France
|
||||
CHAMPS = (("t", "T"), ("tn", "TN"), ("tx", "TX"), ("td", "TD"), ("u", "U"), ("ff", "FF"), ("fxi", "FXI"),
|
||||
("dd", "DD"), ("rr1", "RR1"), ("pmer", "PMER"), ("neige", "NEIGETOT"))
|
||||
# --tout-vercors : tous les postes Météo-France situés dans le Parc (cadre ouest, nord, est, sud), id « mf-<NUM_POSTE> »
|
||||
CADRE_VERCORS = (5.06, 45.305, 5.835, 44.635)
|
||||
SCHEMA_POSTES = """CREATE TABLE IF NOT EXISTS postes_mf (
|
||||
id TEXT PRIMARY KEY, num TEXT, nom TEXT, lat REAL, lon REAL, alti REAL)"""
|
||||
SCHEMA = """CREATE TABLE IF NOT EXISTS horaire (
|
||||
id TEXT NOT NULL, ts INTEGER NOT NULL,
|
||||
t REAL, tn REAL, tx REAL, td REAL, u REAL, ff REAL, fxi REAL, dd REAL, rr1 REAL, pmer REAL, neige REAL,
|
||||
@@ -42,13 +46,21 @@ def epoch(aaaammjjhh):
|
||||
return int(d.timestamp())
|
||||
|
||||
|
||||
def importer_fichier(db, chemin):
|
||||
def importer_fichier(db, chemin, tout_vercors=False):
|
||||
cols = [c for c, _ in CHAMPS]
|
||||
sql = ("INSERT OR REPLACE INTO horaire (id, ts, %s) VALUES (?, ?, %s)" % (", ".join(cols), ", ".join("?" * len(cols))))
|
||||
n = 0
|
||||
with gzip.open(chemin, "rt", encoding="utf-8") as f:
|
||||
for row in csv.DictReader(f, delimiter=";"):
|
||||
site = POSTES.get(row.get("NUM_POSTE"))
|
||||
num = row.get("NUM_POSTE")
|
||||
site = POSTES.get(num)
|
||||
if not site and tout_vercors:
|
||||
lat, lon = nombre(row.get("LAT")), nombre(row.get("LON"))
|
||||
o, nord, e, sud = CADRE_VERCORS
|
||||
if lat is not None and lon is not None and o <= lon <= e and sud <= lat <= nord:
|
||||
site = "mf-" + num
|
||||
db.execute("INSERT OR IGNORE INTO postes_mf VALUES (?, ?, ?, ?, ?, ?)",
|
||||
(site, num, row.get("NOM_USUEL"), lat, lon, nombre(row.get("ALTI"))))
|
||||
if not site or not row.get("AAAAMMJJHH"):
|
||||
continue
|
||||
db.execute(sql, [site, epoch(row["AAAAMMJJHH"])] + [nombre(row.get(src)) for _, src in CHAMPS])
|
||||
@@ -61,12 +73,14 @@ def main(argv=None):
|
||||
ap = argparse.ArgumentParser(description=__doc__.split("\n")[0])
|
||||
ap.add_argument("--db", required=True)
|
||||
ap.add_argument("--dossier", required=True)
|
||||
ap.add_argument("--tout-vercors", action="store_true", help="tous les postes du Parc, pas seulement les 6 de la carte")
|
||||
a = ap.parse_args(argv)
|
||||
db = sqlite3.connect(os.path.expanduser(a.db))
|
||||
db = sqlite3.connect(os.path.expanduser(a.db), timeout=120)
|
||||
db.execute(SCHEMA)
|
||||
db.execute(SCHEMA_POSTES)
|
||||
total = 0
|
||||
for chemin in sorted(glob.glob(os.path.join(os.path.expanduser(a.dossier), "H_*.csv.gz"))):
|
||||
n = importer_fichier(db, chemin)
|
||||
n = importer_fichier(db, chemin, a.tout_vercors)
|
||||
total += n
|
||||
print("%s : %d heures" % (os.path.basename(chemin), n))
|
||||
for site, mini, maxi, nb in db.execute("SELECT id, MIN(ts), MAX(ts), COUNT(*) FROM horaire GROUP BY id"):
|
||||
|
||||
@@ -0,0 +1,26 @@
|
||||
#!/bin/bash
|
||||
# Enregistre la clé ROMMA sans l'afficher, dans ~/.config/meteo-vercors/romma.env (droits 600).
|
||||
# Usage : bash poser_cle_romma.sh
|
||||
# Ne pose PAS ROMMA_APPEL_RESEAU_VALIDE : c'est à Théo de le déclarer, à la main, le jour du premier appel réel.
|
||||
set -eu
|
||||
f=~/.config/meteo-vercors/romma.env
|
||||
mkdir -p "$(dirname "$f")"
|
||||
read -rsp "Colle la clé ROMMA puis Entrée : " K; echo
|
||||
[ -n "$K" ] || { echo "Clé vide : rien n'a changé."; exit 1; }
|
||||
# URL de l'API, avec {cle} à la place de la clé (jamais la clé elle-même). Entrée vide = valeur actuelle,
|
||||
# sinon celle relevée dans le code de GWS (non documentée publiquement, à confirmer auprès de ROMMA).
|
||||
defaut='https://www.romma.fr/api_export.php/?apikey={cle}&type=live&global=1'
|
||||
actuelle="$(grep '^ROMMA_URL_API=' "$f" 2>/dev/null | cut -d= -f2- || true)"
|
||||
echo "URL actuelle : ${actuelle:-(aucune)}"
|
||||
read -rp "URL avec {cle} [Entrée = ${actuelle:-$defaut}] : " U
|
||||
U="${U:-${actuelle:-$defaut}}"
|
||||
case "$U" in *'{cle}'*) ;; *) echo "L'URL doit contenir {cle} : rien n'a changé."; exit 1;; esac
|
||||
umask 077
|
||||
touch "$f"
|
||||
{ grep -v -e '^ROMMA_CLE=' -e '^ROMMA_URL_API=' "$f" || true; } > "$f.tmp"
|
||||
printf 'ROMMA_CLE=%s\nROMMA_URL_API=%s\n' "$K" "$U" >> "$f.tmp"
|
||||
mv "$f.tmp" "$f"
|
||||
chmod 600 "$f"
|
||||
echo "ok : ROMMA_CLE enregistrée (${#K} caractères) et ROMMA_URL_API dans $f"
|
||||
echo "Étape suivante (à toi, après ton feu vert) : ajouter la ligne ROMMA_APPEL_RESEAU_VALIDE=oui dans ce fichier, puis"
|
||||
echo " python3 collecter_romma.py --reel # UN appel ; un 2e lancement avant 10 min est refusé par le garde-fou"
|
||||
@@ -0,0 +1,300 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Statistiques de fréquentation de vercors.me, sans cookie ni identifiant (Python standard uniquement).
|
||||
|
||||
Lit les journaux d'accès Caddy de vercors.me (JSON, une ligne par requête, déjà anonymisés par le bloc `log`
|
||||
de deploy/vercors-me-journal.caddy : ni IP, ni cookie, ni en-tête) et publie data/statistiques.json.
|
||||
|
||||
Ce qui est compté : les pages vues (GET d'une page HTML répondue en 200 ou 304), hors robots, hors /data/,
|
||||
/polices/, /tuiles/ et fichiers techniques. Ce qui n'est PAS fait : aucun visiteur unique (rien ne permet de
|
||||
reconnaître quelqu'un d'une page à l'autre), aucune IP lue ni conservée, aucune valeur individuelle écrite.
|
||||
|
||||
Deux fichiers sont écrits :
|
||||
- l'état privé (--etat) : compteurs agrégés par jour (jamais une ligne de journal), pour garder l'historique
|
||||
quand Caddy supprime les vieux journaux ;
|
||||
- la sortie publique (--sortie) : agrégats sur 30 jours, rien sous 5 occurrences (SEUIL).
|
||||
|
||||
Relancer le script sur les mêmes journaux ne double rien : chaque jour est recalculé depuis les journaux, et
|
||||
un jour dont les journaux ont été en partie supprimés n'est jamais diminué.
|
||||
|
||||
Usage :
|
||||
python statistiques_vercors.py --journaux "/var/log/caddy/vercors.me*.log*" \
|
||||
--etat ~/stats-vercors/etat.json --sortie /srv/vercors.me/data/statistiques.json
|
||||
options : --maintenant 2026-11-05T10:00:00Z (tests) --jours 30 --historique 90
|
||||
"""
|
||||
import argparse
|
||||
import datetime as dt
|
||||
import glob
|
||||
import gzip
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import sys
|
||||
from collections import Counter
|
||||
from urllib.parse import urlsplit
|
||||
|
||||
SEUIL = 5 # rien n'est publié sous 5 occurrences
|
||||
DOMAINES_PROPRES = {"vercors.me", "www.vercors.me"}
|
||||
EXTENSIONS_PAGE = {"", ".html"}
|
||||
PREFIXES_EXCLUS = ("/data/", "/polices/", "/tuiles/")
|
||||
MAX_CLES_PAR_JOUR = 300 # borne contre les valeurs fabriquées (référents bidons)
|
||||
JOURS_ETAT = 400
|
||||
RE_ROBOT = re.compile(r"bot|crawl|spider|slurp|fetch|curl|wget|python|scrapy|headless|monitor|preview|"
|
||||
r"facebookexternalhit|go-http|java/|okhttp|httpclient|lighthouse|uptime", re.I)
|
||||
RE_MOBILE = re.compile(r"mobi|android|iphone|ipad|ipod", re.I)
|
||||
RE_DOMAINE = re.compile(r"^[a-z0-9](?:[a-z0-9.-]{0,98}[a-z0-9])?$")
|
||||
RE_CHEMIN = re.compile(r"^/[A-Za-z0-9/_.\-]{0,80}$")
|
||||
RE_LANGUE = re.compile(r"^[a-z]{2,3}$")
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- heure de Paris, sans fuseau installé
|
||||
def _dernier_dimanche(annee, mois):
|
||||
d = dt.date(annee, mois, 31)
|
||||
return d - dt.timedelta(days=(d.weekday() + 1) % 7)
|
||||
|
||||
|
||||
def jour_paris(ts):
|
||||
"""Date locale (Europe/Paris) d'un horodatage Unix, règle européenne de l'heure d'été."""
|
||||
u = dt.datetime.fromtimestamp(ts, dt.timezone.utc)
|
||||
debut = dt.datetime.combine(_dernier_dimanche(u.year, 3), dt.time(1), dt.timezone.utc)
|
||||
fin = dt.datetime.combine(_dernier_dimanche(u.year, 10), dt.time(1), dt.timezone.utc)
|
||||
decal = 2 if debut <= u < fin else 1
|
||||
return (u + dt.timedelta(hours=decal)).date().isoformat()
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- lecture et réduction des lignes
|
||||
def lignes(chemin):
|
||||
ouvrir = gzip.open if chemin.endswith(".gz") else open
|
||||
with ouvrir(chemin, "rt", encoding="utf-8", errors="replace") as f:
|
||||
for ligne in f:
|
||||
yield ligne
|
||||
|
||||
|
||||
def page_normalisee(uri):
|
||||
"""Chemin d'une page ('/', '/a-propos', ...) ou None si ce n'est pas une page."""
|
||||
chemin = (uri or "").split("?", 1)[0].split("#", 1)[0]
|
||||
if not chemin.startswith("/") or chemin.startswith(PREFIXES_EXCLUS):
|
||||
return None
|
||||
base = chemin.rsplit("/", 1)[-1]
|
||||
ext = os.path.splitext(base)[1].lower()
|
||||
if ext not in EXTENSIONS_PAGE:
|
||||
return None
|
||||
if chemin.endswith("/index.html"):
|
||||
chemin = chemin[:-len("index.html")]
|
||||
elif chemin.endswith(".html"):
|
||||
chemin = chemin[:-len(".html")]
|
||||
if len(chemin) > 1:
|
||||
chemin = chemin.rstrip("/")
|
||||
return chemin if RE_CHEMIN.match(chemin or "/") else None
|
||||
|
||||
|
||||
def classe_appareil(rec, ua):
|
||||
"""'robot' | 'mobile' | 'bureau' | None. Le champ ua_classe (posé par Caddy) prime ; sinon le UA brut,
|
||||
s'il est présent, est classé puis oublié."""
|
||||
c = rec.get("ua_classe")
|
||||
if c in ("robot", "mobile", "bureau"):
|
||||
return c
|
||||
if ua:
|
||||
return "robot" if RE_ROBOT.search(ua) else "mobile" if RE_MOBILE.search(ua) else "bureau"
|
||||
return None
|
||||
|
||||
|
||||
def domaine_referent(valeur):
|
||||
if not isinstance(valeur, str) or not valeur:
|
||||
return None
|
||||
v = valeur.strip().lower()
|
||||
if "://" in v:
|
||||
try:
|
||||
v = urlsplit(v).hostname or ""
|
||||
except ValueError:
|
||||
return None
|
||||
v = v[4:] if v.startswith("www.") else v
|
||||
return v if RE_DOMAINE.match(v) and "." in v else None
|
||||
|
||||
|
||||
def langue(valeur):
|
||||
if not isinstance(valeur, str):
|
||||
return None
|
||||
m = re.match(r"\s*([A-Za-z]{2,3})", valeur)
|
||||
l = m.group(1).lower() if m else None
|
||||
return l if l and RE_LANGUE.match(l) else None
|
||||
|
||||
|
||||
def en_tete(rec, nom):
|
||||
h = (rec.get("request") or {}).get("headers") or {}
|
||||
v = h.get(nom)
|
||||
if isinstance(v, list) and v:
|
||||
return v[0]
|
||||
return v if isinstance(v, str) else None
|
||||
|
||||
|
||||
def reduire(rec):
|
||||
"""Une ligne de journal -> (jour, page, appareil, référent, langue) ou 'robot:jour' ; jamais d'IP.
|
||||
Retourne None si la ligne ne compte pas."""
|
||||
req = rec.get("request") or {}
|
||||
if req.get("method") != "GET" or rec.get("status") not in (200, 304):
|
||||
return None
|
||||
hote = (req.get("host") or "vercors.me").lower().split(":")[0]
|
||||
if hote not in DOMAINES_PROPRES:
|
||||
return None
|
||||
page = page_normalisee(req.get("uri"))
|
||||
ts = rec.get("ts")
|
||||
if page is None or not isinstance(ts, (int, float)):
|
||||
return None
|
||||
appareil = classe_appareil(rec, en_tete(rec, "User-Agent"))
|
||||
jour = jour_paris(ts)
|
||||
if appareil == "robot":
|
||||
return jour, None, "robot", None, None
|
||||
ref = domaine_referent(rec.get("referent") or en_tete(rec, "Referer"))
|
||||
if ref in DOMAINES_PROPRES:
|
||||
ref = "(interne)"
|
||||
lang = langue(rec.get("langue") or en_tete(rec, "Accept-Language"))
|
||||
return jour, page, appareil, ref, lang
|
||||
|
||||
|
||||
def jour_vide():
|
||||
return {"vues": 0, "robots": 0, "pages": {}, "appareils": {}, "referents": {}, "directs": 0, "langues": {}}
|
||||
|
||||
|
||||
def ajouter(d, cle):
|
||||
if cle in d or len(d) < MAX_CLES_PAR_JOUR:
|
||||
d[cle] = d.get(cle, 0) + 1
|
||||
|
||||
|
||||
def compter(fichiers):
|
||||
jours = {}
|
||||
for chemin in fichiers:
|
||||
for ligne in lignes(chemin):
|
||||
try:
|
||||
rec = json.loads(ligne)
|
||||
except ValueError:
|
||||
continue
|
||||
if not isinstance(rec, dict):
|
||||
continue
|
||||
r = reduire(rec)
|
||||
if r is None:
|
||||
continue
|
||||
jour, page, appareil, ref, lang = r
|
||||
j = jours.setdefault(jour, jour_vide())
|
||||
if appareil == "robot":
|
||||
j["robots"] += 1
|
||||
continue
|
||||
j["vues"] += 1
|
||||
ajouter(j["pages"], page)
|
||||
if appareil:
|
||||
j["appareils"][appareil] = j["appareils"].get(appareil, 0) + 1
|
||||
if ref is None:
|
||||
j["directs"] += 1
|
||||
elif ref != "(interne)":
|
||||
ajouter(j["referents"], ref)
|
||||
if lang:
|
||||
ajouter(j["langues"], lang)
|
||||
return jours
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- état privé et sortie publique
|
||||
def charger_etat(chemin):
|
||||
try:
|
||||
with open(chemin, encoding="utf-8") as f:
|
||||
e = json.load(f)
|
||||
return e["jours"] if isinstance(e.get("jours"), dict) else {}
|
||||
except (OSError, ValueError, KeyError, AttributeError):
|
||||
return {}
|
||||
|
||||
|
||||
def ecrire_atomique(chemin, objet, mode=None):
|
||||
os.makedirs(os.path.dirname(os.path.abspath(chemin)), exist_ok=True)
|
||||
tmp = chemin + ".tmp"
|
||||
with open(tmp, "w", encoding="utf-8") as f:
|
||||
json.dump(objet, f, ensure_ascii=False, indent=1, sort_keys=True)
|
||||
f.write("\n")
|
||||
if mode is not None:
|
||||
try:
|
||||
os.chmod(tmp, mode)
|
||||
except OSError:
|
||||
pass
|
||||
os.replace(tmp, chemin)
|
||||
|
||||
|
||||
def fusionner(etat, nouveaux, maintenant_j):
|
||||
"""Un jour recalculé remplace le jour stocké, sauf s'il en ressort moins (journaux partiellement purgés)."""
|
||||
for jour, j in nouveaux.items():
|
||||
ancien = etat.get(jour)
|
||||
if ancien is None or j["vues"] + j["robots"] >= ancien.get("vues", 0) + ancien.get("robots", 0):
|
||||
etat[jour] = j
|
||||
limite = (dt.date.fromisoformat(maintenant_j) - dt.timedelta(days=JOURS_ETAT)).isoformat()
|
||||
for jour in [k for k in etat if k < limite]:
|
||||
del etat[jour]
|
||||
return etat
|
||||
|
||||
|
||||
def somme(jours, champ):
|
||||
c = Counter()
|
||||
for j in jours:
|
||||
c.update(j.get(champ) or {})
|
||||
return c
|
||||
|
||||
|
||||
def publier(etat, maintenant_dt, nb_jours=30, historique=90):
|
||||
auj = dt.date.fromisoformat(jour_paris(maintenant_dt.timestamp()))
|
||||
liste = [(auj - dt.timedelta(days=i)).isoformat() for i in range(historique - 1, -1, -1)]
|
||||
par_jour = []
|
||||
for jr in liste:
|
||||
v = (etat.get(jr) or {}).get("vues", 0)
|
||||
par_jour.append({"jour": jr, "pages_vues": v if v >= SEUIL else None})
|
||||
fenetre = [etat[jr] for jr in liste[-nb_jours:] if jr in etat]
|
||||
total = sum(j["vues"] for j in fenetre)
|
||||
|
||||
def classer(compteur, cle, n=10):
|
||||
return [{cle: k, "vues": v} for k, v in sorted(compteur.items(), key=lambda kv: (-kv[1], kv[0]))
|
||||
if v >= SEUIL][:n]
|
||||
|
||||
app = somme(fenetre, "appareils")
|
||||
app_tot = sum(app.values())
|
||||
appareils = {"telephone": None, "ordinateur": None}
|
||||
if app_tot >= SEUIL:
|
||||
for cle, nom in (("mobile", "telephone"), ("bureau", "ordinateur")):
|
||||
if app.get(cle, 0) >= SEUIL:
|
||||
appareils[nom] = round(100 * app[cle] / app_tot)
|
||||
langues = somme(fenetre, "langues")
|
||||
lang_tot = sum(langues.values())
|
||||
directs = sum(j.get("directs", 0) for j in fenetre)
|
||||
return {
|
||||
"genere": maintenant_dt.strftime("%Y-%m-%dT%H:%MZ"),
|
||||
"periode": {"debut": liste[-nb_jours], "fin": liste[-1], "jours": nb_jours},
|
||||
"seuil": SEUIL,
|
||||
"pages_vues_periode": total if total >= SEUIL else None,
|
||||
"par_jour": par_jour,
|
||||
"pages_les_plus_vues": classer(somme(fenetre, "pages"), "page"),
|
||||
"appareils_pct": appareils,
|
||||
"referents": classer(somme(fenetre, "referents"), "site"),
|
||||
"acces_directs": directs if directs >= SEUIL else None,
|
||||
"langues": [{"langue": e["langue"], "pct": round(100 * e["vues"] / lang_tot)}
|
||||
for e in classer(langues, "langue")] if lang_tot >= SEUIL else [],
|
||||
}
|
||||
|
||||
|
||||
def main(argv=None):
|
||||
if hasattr(sys.stdout, "reconfigure"):
|
||||
sys.stdout.reconfigure(encoding="utf-8")
|
||||
p = argparse.ArgumentParser(description=__doc__.split("\n")[0])
|
||||
p.add_argument("--journaux", required=True, help="motif(s) glob des journaux Caddy (.log, .log.gz)", nargs="+")
|
||||
p.add_argument("--etat", required=True, help="état privé (compteurs agrégés par jour)")
|
||||
p.add_argument("--sortie", required=True, help="data/statistiques.json")
|
||||
p.add_argument("--maintenant", help="horodatage ISO UTC forcé (tests)")
|
||||
p.add_argument("--jours", type=int, default=30)
|
||||
p.add_argument("--historique", type=int, default=90)
|
||||
a = p.parse_args(argv)
|
||||
if a.maintenant:
|
||||
maintenant_dt = dt.datetime.fromisoformat(a.maintenant.replace("Z", "+00:00"))
|
||||
else:
|
||||
maintenant_dt = dt.datetime.now(dt.timezone.utc)
|
||||
fichiers = sorted({f for motif in a.journaux for f in glob.glob(os.path.expanduser(motif))})
|
||||
etat = fusionner(charger_etat(a.etat), compter(fichiers), jour_paris(maintenant_dt.timestamp()))
|
||||
ecrire_atomique(a.etat, {"jours": etat}, 0o600)
|
||||
ecrire_atomique(a.sortie, publier(etat, maintenant_dt, a.jours, a.historique), 0o644)
|
||||
print("journaux lus : %d ; jours en état : %d ; sortie : %s" % (len(fichiers), len(etat), a.sortie))
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
@@ -29,3 +29,5 @@ vercors.me {
|
||||
|
||||
file_server
|
||||
}
|
||||
|
||||
# --- Page 404 : voir deploy/vercors-404.caddy (bloc handle_errors à ajouter dans le site vercors.me, non appliqué) ---
|
||||
@@ -0,0 +1,10 @@
|
||||
# ~/.config/meteo-vercors/forum.env (chmod 600). Aucune valeur secrète ici : le secret client va dans un fichier à part.
|
||||
FORUM_HUB_URL=https://hub.gastinel.me
|
||||
FORUM_CLIENT_ID=forum-vercors
|
||||
FORUM_PREFIXE=/forum
|
||||
FORUM_REDIRECT_URI=https://vercors.me/forum/connexion/retour
|
||||
FORUM_PANNEAU_REDIRECT_URI=http://192.168.1.26:8941/connexion/retour
|
||||
# FORUM_OAUTH_SECRET_FILE=/home/CHANGER/.config/meteo-vercors/forum-oauth-secret
|
||||
# FORUM_PROPRIETAIRE_ID=CHANGER-uuid-gastinel-de-theo
|
||||
FORUM_RELAIS=10.88.88.1
|
||||
# FORUM_MODE_TEST : ne jamais poser en production
|
||||
@@ -0,0 +1,14 @@
|
||||
# À insérer DANS le bloc « hub.gastinel.me { … } » du VPS, avant le « handle { root * /srv/hub … } » final.
|
||||
handle /oauth/* {
|
||||
request_body {
|
||||
max_size 16KB
|
||||
}
|
||||
reverse_proxy 10.88.88.2:8091 {
|
||||
header_up -X-Actor-ID
|
||||
header_up -X-Actor-Username
|
||||
header_up -X-Actor-Privilege
|
||||
header_up -X-Relay-Key
|
||||
header_up X-Forwarded-For {remote_host}
|
||||
header_down Cache-Control "no-store"
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,15 @@
|
||||
# ~/.config/systemd/user/meteo-vercors-forum-panneau.service (cornafserver)
|
||||
# Panneau de gestion du forum, LAN seulement (IP hors LAN : 403), même base que le forum.
|
||||
[Unit]
|
||||
Description=vercors.me : panneau LAN du forum (rôles, adhésions, stations)
|
||||
After=meteo-vercors-forum.service
|
||||
|
||||
[Service]
|
||||
EnvironmentFile=%h/.config/meteo-vercors/forum.env
|
||||
WorkingDirectory=%h/meteo-vercors/forum
|
||||
ExecStart=/usr/bin/python3 %h/meteo-vercors/forum/panneau.py --db %h/meteo-vercors/forum-data/forum.sqlite3 --photos %h/meteo-vercors/forum-data/photos --hote 192.168.1.26 --port 8941
|
||||
Restart=on-failure
|
||||
RestartSec=5
|
||||
|
||||
[Install]
|
||||
WantedBy=default.target
|
||||
@@ -0,0 +1,15 @@
|
||||
# ~/.config/systemd/user/meteo-vercors-forum.service (cornafserver)
|
||||
# Forum public de vercors.me : écoute sur l'adresse wg2 (10.88.88.2), relayé par Caddy du VPS (10.88.88.1).
|
||||
[Unit]
|
||||
Description=vercors.me : forum (relayé par le VPS sous /forum)
|
||||
After=network-online.target
|
||||
|
||||
[Service]
|
||||
EnvironmentFile=%h/.config/meteo-vercors/forum.env
|
||||
WorkingDirectory=%h/meteo-vercors/forum
|
||||
ExecStart=/usr/bin/python3 %h/meteo-vercors/forum/server.py --db %h/meteo-vercors/forum-data/forum.sqlite3 --photos %h/meteo-vercors/forum-data/photos --hote 10.88.88.2 --port 8940
|
||||
Restart=on-failure
|
||||
RestartSec=5
|
||||
|
||||
[Install]
|
||||
WantedBy=default.target
|
||||
@@ -0,0 +1,11 @@
|
||||
# À insérer DANS le bloc « vercors.me { … } » du VPS (/etc/caddy/vercors-me.caddy), juste avant « file_server ».
|
||||
# Le forum garde le préfixe (FORUM_PREFIXE=/forum) : pas de strip. La CSP du site s'applique telle quelle.
|
||||
handle /forum* {
|
||||
request_body {
|
||||
max_size 260MB
|
||||
}
|
||||
reverse_proxy 10.88.88.2:8940 {
|
||||
header_up X-Forwarded-For {remote_host}
|
||||
header_down Cache-Control "no-store"
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,27 @@
|
||||
# NON APPLIQUE. Bloc à ajouter (en sudo, par Théo) dans le site `vercors.me { ... }` de /etc/caddy/Caddyfile
|
||||
# (ou dans le fichier vercors.me importé), juste avant `file_server`. Prérequis : /srv/vercors.me/404.html déployé
|
||||
# (produit par maquettes/accueil-carte/assembler.py dans site-v2/). Valider avec `caddy validate`, puis recharger.
|
||||
#
|
||||
# La page 404 n'utilise que /polices/ et du CSS/SVG en ligne : compatible avec la CSP du site.
|
||||
# Le bloc `header` du site ne s'applique pas aux réponses d'erreur : on répète donc les en-têtes de sécurité.
|
||||
# Les URL /data/* en erreur gardent une réponse courte (pas de page HTML pour les robots de lecture JSON).
|
||||
|
||||
handle_errors {
|
||||
@page404 expression `{err.status_code} == 404 && !{path}.startsWith("/data/")`
|
||||
handle @page404 {
|
||||
header {
|
||||
Content-Security-Policy "default-src 'self'; img-src 'self' data:; style-src 'self' 'unsafe-inline'; script-src 'self' 'unsafe-inline'; font-src 'self'; connect-src 'self'; frame-ancestors 'none'"
|
||||
Referrer-Policy "strict-origin-when-cross-origin"
|
||||
X-Frame-Options "DENY"
|
||||
Cache-Control "no-cache"
|
||||
-Server
|
||||
}
|
||||
rewrite * /404.html
|
||||
file_server {
|
||||
status 404
|
||||
}
|
||||
}
|
||||
handle {
|
||||
respond "{err.status_code} {err.status_text}" {err.status_code}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,53 @@
|
||||
# PROPOSITION, NON APPLIQUEE. Mesure d'audience de vercors.me sans cookie ni identifiant (exemption CNIL : agrégats seuls).
|
||||
# À coller dans le bloc `vercors.me { ... }` de /etc/caddy/vercors-me.caddy (par Théo, avec sudo), puis :
|
||||
# sudo caddy validate --config /etc/caddy/Caddyfile --adapter caddyfile && sudo systemctl reload caddy
|
||||
# Le journal ne contient JAMAIS : IP, port, cookie, en-tête, requête (?...), user-agent complet, URL complète du référent.
|
||||
# Il garde : date, méthode, chemin, code, domaine du référent, 2 lettres de langue, classe d'appareil. Durée : 14 jours.
|
||||
|
||||
# Classe d'appareil (robot / mobile / bureau) : calculée ici, le user-agent lui-même n'est pas écrit.
|
||||
@ua_robot header_regexp User-Agent (?i)bot|crawl|spider|slurp|fetch|curl|wget|python|scrapy|headless|monitor|preview|facebookexternalhit|go-http|java/|okhttp|httpclient|lighthouse|uptime
|
||||
@ua_mobile {
|
||||
header_regexp User-Agent (?i)mobi|android|iphone|ipad|ipod
|
||||
not header_regexp User-Agent (?i)bot|crawl|spider|slurp|fetch|curl|wget|python|scrapy|headless|monitor|preview|facebookexternalhit|go-http|java/|okhttp|httpclient|lighthouse|uptime
|
||||
}
|
||||
@ua_bureau {
|
||||
not header_regexp User-Agent (?i)mobi|android|iphone|ipad|ipod
|
||||
not header_regexp User-Agent (?i)bot|crawl|spider|slurp|fetch|curl|wget|python|scrapy|headless|monitor|preview|facebookexternalhit|go-http|java/|okhttp|httpclient|lighthouse|uptime
|
||||
}
|
||||
log_append @ua_robot ua_classe robot
|
||||
log_append @ua_mobile ua_classe mobile
|
||||
log_append @ua_bureau ua_classe bureau
|
||||
log_append referent {http.request.header.Referer}
|
||||
log_append langue {http.request.header.Accept-Language}
|
||||
|
||||
# Les ressources techniques ne sont pas journalisées du tout.
|
||||
@technique path /data/* /polices/* /tuiles/* /favicon.* /robots.txt /sitemap.xml
|
||||
log_skip @technique
|
||||
|
||||
log {
|
||||
output file /var/log/caddy/vercors.me.log {
|
||||
mode 0644
|
||||
roll_size 10MiB
|
||||
roll_keep 20
|
||||
roll_keep_for 336h
|
||||
}
|
||||
format filter {
|
||||
wrap json
|
||||
fields {
|
||||
request>remote_ip delete
|
||||
request>remote_port delete
|
||||
request>client_ip delete
|
||||
request>headers delete
|
||||
request>tls delete
|
||||
request>proto delete
|
||||
resp_headers delete
|
||||
user_id delete
|
||||
duration delete
|
||||
size delete
|
||||
bytes_read delete
|
||||
request>uri regexp ^([^?#]*).*$ $1
|
||||
referent regexp ^(?:https?://([^/:?#]+))?.*$ $1
|
||||
langue regexp ^([A-Za-z]{2,3})?.*$ $1
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,9 @@
|
||||
# PROPOSITION, NON POSEE. À copier dans /etc/systemd/system/ sur le VPS (par Théo, avec sudo), avec le timer voisin.
|
||||
# Prérequis : mkdir -p /opt/vercors-stats ~/stats-vercors ; copier collecte/statistiques_vercors.py dans /opt/vercors-stats/.
|
||||
[Unit]
|
||||
Description=Statistiques de frequentation de vercors.me (agregation des journaux Caddy, sans IP)
|
||||
|
||||
[Service]
|
||||
Type=oneshot
|
||||
User=debian
|
||||
ExecStart=/usr/bin/python3 -I /opt/vercors-stats/statistiques_vercors.py --journaux "/var/log/caddy/vercors.me*.log*" --etat /home/debian/stats-vercors/etat.json --sortie /srv/vercors.me/data/statistiques.json
|
||||
@@ -0,0 +1,10 @@
|
||||
# PROPOSITION, NON POSEE. Puis : sudo systemctl daemon-reload && sudo systemctl enable --now vercors-statistiques.timer
|
||||
[Unit]
|
||||
Description=Declencheur quotidien (03h40) des statistiques vercors.me
|
||||
|
||||
[Timer]
|
||||
OnCalendar=*-*-* 03:40:00
|
||||
Persistent=true
|
||||
|
||||
[Install]
|
||||
WantedBy=timers.target
|
||||
+35
-3
@@ -1,6 +1,36 @@
|
||||
# Forum de vercors.me (noyau local)
|
||||
|
||||
Forum où le père de Théo et d'autres adhérents météo publient (ex. « Récapitulatif de la semaine »). **État : noyau local, rien de déployé, rien de publié, authentification simulée.**
|
||||
Forum où le père de Théo et d'autres adhérents météo publient (ex. « Récapitulatif de la semaine »). **État : rien de déployé. Connexion « Se connecter avec Gastinel » codée (OAuth 2 code + PKCE), en attente du Hub en ligne.**
|
||||
|
||||
## Connexion Gastinel et mode essai (05/11/2026)
|
||||
- `connexion.py` : client OAuth (state + PKCE S256, `/oauth/autoriser`, `/oauth/jeton`, `/oauth/moi` -> `{id, pseudo}`), sans dépendance.
|
||||
- Session : cookie `forum_session` HttpOnly Secure SameSite=Lax, 30 jours ; seul le SHA-256 de l'identifiant est en base. Déconnexion en POST.
|
||||
- Variables : `FORUM_PREFIXE`, `FORUM_HUB_URL`, `FORUM_CLIENT_ID` (défaut `forum-vercors`), `FORUM_REDIRECT_URI`, `FORUM_OAUTH_SECRET` (ou `_FILE`, facultatif),
|
||||
`FORUM_PROPRIETAIRE_ID` (id Gastinel de Théo -> rôle Propriétaire), `FORUM_RELAIS` (relais de confiance en plus de 127.0.0.1), `FORUM_MODE_TEST=1`.
|
||||
- `/test-login` et `--seed` : seulement avec `FORUM_MODE_TEST=1`, et `/test-login` seulement depuis 127/8, 10/8, 192.168/16 ou ::1.
|
||||
`X-Forwarded-For` n'est cru que d'un relais de confiance (127.0.0.1 par défaut). Ne jamais poser `FORUM_MODE_TEST` en production.
|
||||
- Demandes d'adhésion : `/adhesion` (message + 10 photos / 25 Mo, métadonnées retirées, photos hors du dossier public),
|
||||
`/adhesions` pour le propriétaire et l'adjoint ; méthodes `demander_adhesion`, `demandes_adhesion`, `demande_adhesion`,
|
||||
`decider_adhesion`, `photo_adhesion` dans `forum.py` pour le futur panneau LAN.
|
||||
- Fiche de station (page station de vercors.me) : `GET /forum/api/station/<id>.json`, publique, lecture seule, sans cookie,
|
||||
cache mémoire 60 s vidé à chaque changement + `Cache-Control: public, max-age=300`. Renvoie `{"station", "sujet": "/forum/t/N" ou null,
|
||||
"photos": [{"url": "/forum/photo/<sha>.ext", "auteur"}]}` (3 photos au plus, déjà nettoyées à l'envoi ; pas de vignette réduite, la page les réduit).
|
||||
Épinglage : bouton « Épingler sur la fiche » sous chaque photo du sujet de la station (POST `/fiche-photo`), pour le Propriétaire,
|
||||
l'adjoint et le propriétaire de CETTE station. Une photo masquée (message ou sujet) disparaît de la fiche.
|
||||
Attention : `vercors-forum.caddy` force `Cache-Control: no-store` sur tout `/forum*` ; le cache navigateur de la route ne joue qu'une fois ce point revu.
|
||||
- Tests : `cd forum && python -m unittest` (61 tests, Hub simulé par un faux serveur local).
|
||||
|
||||
## Production : préfixe et écoute
|
||||
- `FORUM_PREFIXE` (ex. `/forum`, défaut vide) est appliqué à tous les liens, formulaires, redirections, chemins de cookie et à la `redirect_uri` par défaut (`https://vercors.me<préfixe>/connexion/retour`, sinon `FORUM_REDIRECT_URI`). Le serveur accepte les requêtes avec ou sans préfixe : Caddy peut le retirer (`handle_path`) ou non.
|
||||
- `--hote` (défaut `127.0.0.1`) : adresse d'écoute ; derrière Caddy, ne pas y toucher. Exemple : `FORUM_PREFIXE=/forum python forum/server.py --port 8940`.
|
||||
|
||||
## Panneau LAN de gestion (`panneau.py`)
|
||||
Second serveur, sur la même base et le même dossier de photos que le forum, réservé au Propriétaire et au Propriétaire adjoint.
|
||||
- Lancer : `FORUM_HUB_URL=... FORUM_PROPRIETAIRE_ID=... FORUM_PANNEAU_REDIRECT_URI=http://<ip-lan>:8790/connexion/retour python forum/panneau.py --db <base du forum> --photos <dossier photos du forum> [--port 8790] [--hote 0.0.0.0]`.
|
||||
- Toute IP hors 127/8, 10/8, 192.168/16, ::1 reçoit 403 ; seule l'adresse de la connexion TCP compte, `X-Forwarded-For` est ignoré (ne pas placer le panneau derrière un relais public).
|
||||
- Connexion avec le compte Gastinel (même client OAuth, mêmes variables `FORUM_HUB_URL`, `FORUM_CLIENT_ID`, `FORUM_OAUTH_SECRET[_FILE]`) ; adresse de retour propre `FORUM_PANNEAU_REDIRECT_URI` (défaut `http://localhost:<port>/connexion/retour`), à déclarer au Hub. Aucune inscription : seuls les comptes déjà connus ayant le droit `gerer_roles` entrent. Cookie `panneau_session` propre (1 jour, sans `Secure` si l'adresse de retour est en http), jetons séparés de ceux du forum.
|
||||
- Pages : utilisateurs avec badges et don/retrait de rôle (`roles.peut_donner` : seul le Propriétaire nomme un adjoint, personne ne donne « Propriétaire »), demandes d'adhésion avec message et photos (accepter/refuser), sujets de station à valider, signalements. Tous les POST portent un jeton CSRF lié à la session, en plus du contrôle d'origine.
|
||||
- Les pages `/roles`, `/adhesions` et `/validation` du forum public restent en attendant ; le panneau les remplace.
|
||||
|
||||
## Choix techniques
|
||||
- Python standard seulement (`http.server`, `sqlite3`, `unittest`) : comme `collecte/` du projet, aucune dépendance, facile à expliquer et à relire. Python 3.10 testé.
|
||||
@@ -15,7 +45,9 @@ Forum où le père de Théo et d'autres adhérents météo publient (ex. « Réc
|
||||
| `roles.py` | rôles, tableau des droits, `peut(role, droit)` |
|
||||
| `db.py` | schéma SQLite, catégories par défaut |
|
||||
| `forum.py` | logique : sujets, messages, signalements, masquage, rôles, purge IP ; tout contrôlé par les droits |
|
||||
| `server.py` | serveur HTTP local + pages + connexion simulée |
|
||||
| `server.py` | serveur HTTP du forum + pages + connexion Gastinel |
|
||||
| `panneau.py` | panneau LAN de gestion (propriétaires) |
|
||||
| `connexion.py` | client OAuth Gastinel, réglages, adresses LAN |
|
||||
| `tests/test_forum.py` | 18 tests (droits de chaque rôle, modération, HTTP, purge IP) |
|
||||
|
||||
Lancer : `python forum/server.py --seed` puis `http://127.0.0.1:8940/test-login?u=adherent1` (aussi `modo1`, `admin1` ; tout autre identifiant crée un « membre »). Tests : `python -I forum/tests/test_forum.py`.
|
||||
@@ -50,7 +82,7 @@ Le visiteur est un navigateur sans compte. Un administrateur ne peut pas se rét
|
||||
|
||||
## RGPD (à faire valider par Théo)
|
||||
- Données minimales : identifiant Hub, nom affiché, rôle, contenus publiés.
|
||||
- Adresse IP : enregistrée avec chaque message pour la personnalisation, **conservée 13 mois**, puis effacée par `Forum.purger_ips(13)` (testé). Il reste à planifier cette purge (tâche périodique) et à l'indiquer dans la politique de confidentialité.
|
||||
- Adresse IP : enregistrée avec chaque message pour la personnalisation, **conservée 12 mois**, puis effacée par `purge.py` (timer systemd quotidien `meteo-vercors-forum-purge.timer`, 03:20 ; efface aussi les brouillons de plus de 30 jours, les signalements traités de plus de 12 mois et les lectures des comptes supprimés). Reste à l'indiquer dans la politique de confidentialité.
|
||||
- Aucun usage des données hors du service lui-même (principe de Théo : pas d'entraînement, pas de publicité).
|
||||
- Suppression du compte Hub : à relier (anonymiser le nom affiché, garder ou retirer les messages : à décider).
|
||||
|
||||
|
||||
@@ -0,0 +1,261 @@
|
||||
// Aperçu avant publication (nouveau sujet, réponse) : texte et photos choisies, sans rien envoyer.
|
||||
// Facultatif : sans JavaScript, les formulaires marchent comme avant.
|
||||
document.querySelectorAll("form[action$='/sujet'], form[action$='/repondre']").forEach(function (form) {
|
||||
var zone = form.querySelector("textarea[name=corps]");
|
||||
var envoi = form.querySelector("button:not([type=button])");
|
||||
if (!zone || !envoi) return;
|
||||
var titre = form.querySelector("input[name=titre]");
|
||||
var fichiers = form.querySelector("input[type=file]");
|
||||
var bouton = document.createElement("button");
|
||||
bouton.type = "button";
|
||||
bouton.className = "bouton-apercu";
|
||||
bouton.textContent = "Aperçu";
|
||||
bouton.setAttribute("aria-expanded", "false");
|
||||
var vue = document.createElement("section");
|
||||
vue.className = "apercu";
|
||||
vue.hidden = true;
|
||||
vue.setAttribute("aria-live", "polite");
|
||||
envoi.parentNode.insertBefore(bouton, envoi);
|
||||
envoi.parentNode.insertBefore(vue, bouton);
|
||||
var urls = [];
|
||||
|
||||
function dessiner() {
|
||||
urls.forEach(URL.revokeObjectURL);
|
||||
urls = [];
|
||||
vue.textContent = "";
|
||||
var tete = document.createElement("p");
|
||||
tete.className = "apercu-tete";
|
||||
tete.textContent = "Aperçu : rien n'est encore publié";
|
||||
vue.appendChild(tete);
|
||||
if (titre && titre.value.trim()) {
|
||||
var h = document.createElement("h3");
|
||||
h.textContent = titre.value.trim();
|
||||
vue.appendChild(h);
|
||||
}
|
||||
var p = document.createElement("p");
|
||||
p.className = "message";
|
||||
p.textContent = zone.value.trim() || "(message vide)";
|
||||
vue.appendChild(p);
|
||||
if (fichiers && fichiers.files.length) {
|
||||
var gal = document.createElement("div");
|
||||
gal.className = "galerie";
|
||||
Array.prototype.slice.call(fichiers.files, 0, 20).forEach(function (f) {
|
||||
if (!/^image\/(jpeg|png|webp)$/.test(f.type)) return;
|
||||
var img = document.createElement("img");
|
||||
var u = URL.createObjectURL(f);
|
||||
urls.push(u);
|
||||
img.src = u;
|
||||
img.alt = f.name;
|
||||
gal.appendChild(img);
|
||||
});
|
||||
vue.appendChild(gal);
|
||||
}
|
||||
}
|
||||
|
||||
bouton.addEventListener("click", function () {
|
||||
var ouvrir = vue.hidden;
|
||||
if (ouvrir) dessiner();
|
||||
vue.hidden = !ouvrir;
|
||||
bouton.textContent = ouvrir ? "Fermer l'aperçu" : "Aperçu";
|
||||
bouton.setAttribute("aria-expanded", String(ouvrir));
|
||||
});
|
||||
[zone, titre, fichiers].forEach(function (champ) {
|
||||
if (champ) champ.addEventListener(champ.type === "file" ? "change" : "input", function () { if (!vue.hidden) dessiner(); });
|
||||
});
|
||||
});
|
||||
|
||||
// « Copier le lien » d'un message : copie l'adresse complète. Sans JavaScript, le lien mène au message.
|
||||
document.querySelectorAll("a.copier-lien").forEach(function (a) {
|
||||
a.addEventListener("click", function (ev) {
|
||||
if (!navigator.clipboard) return;
|
||||
ev.preventDefault();
|
||||
var url = location.origin + location.pathname + location.search + a.getAttribute("href");
|
||||
navigator.clipboard.writeText(url).then(function () {
|
||||
a.textContent = "Lien copié";
|
||||
setTimeout(function () { a.textContent = "Copier le lien"; }, 2000);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
// Photos : un clic ouvre la photo en grand, flèches pour passer à la suivante, Échap pour fermer.
|
||||
// Sans JavaScript, le lien ouvre simplement la photo.
|
||||
(function () {
|
||||
var liens = Array.prototype.slice.call(document.querySelectorAll(".msg .galerie a"));
|
||||
if (!liens.length || typeof HTMLDialogElement !== "function") return;
|
||||
var dlg = document.createElement("dialog");
|
||||
dlg.className = "visionneuse";
|
||||
dlg.setAttribute("aria-label", "Photo en grand");
|
||||
dlg.innerHTML = "<img alt=''><div class='barre'><button type='button' data-pas='-1' aria-label='Photo précédente'>←</button>" +
|
||||
"<span class='compte' aria-live='polite'></span><button type='button' data-pas='1' aria-label='Photo suivante'>→</button>" +
|
||||
"<button type='button' class='fermer'>Fermer</button></div>";
|
||||
document.body.appendChild(dlg);
|
||||
var img = dlg.querySelector("img"), compte = dlg.querySelector(".compte"), i = 0;
|
||||
function montrer(n) {
|
||||
i = (n + liens.length) % liens.length;
|
||||
var vignette = liens[i].querySelector("img");
|
||||
img.src = liens[i].getAttribute("href");
|
||||
img.alt = vignette ? vignette.alt : "";
|
||||
compte.textContent = (i + 1) + " / " + liens.length;
|
||||
dlg.querySelectorAll("[data-pas]").forEach(function (b) { b.hidden = liens.length < 2; });
|
||||
}
|
||||
liens.forEach(function (a, n) {
|
||||
a.addEventListener("click", function (ev) { ev.preventDefault(); montrer(n); dlg.showModal(); });
|
||||
});
|
||||
dlg.addEventListener("click", function (ev) {
|
||||
var pas = ev.target.getAttribute && ev.target.getAttribute("data-pas");
|
||||
if (pas) montrer(i + Number(pas));
|
||||
else if (ev.target === dlg || ev.target.classList.contains("fermer")) dlg.close();
|
||||
});
|
||||
dlg.addEventListener("keydown", function (ev) {
|
||||
if (ev.key === "ArrowRight") montrer(i + 1);
|
||||
if (ev.key === "ArrowLeft") montrer(i - 1);
|
||||
});
|
||||
})();
|
||||
|
||||
// Menus « Trier » et compte : un clic ailleurs (ou Échap) les referme.
|
||||
document.addEventListener("click", function (ev) {
|
||||
document.querySelectorAll("details.tri[open], details.compte[open]").forEach(function (d) {
|
||||
if (!d.contains(ev.target)) d.removeAttribute("open");
|
||||
});
|
||||
});
|
||||
document.addEventListener("keydown", function (ev) {
|
||||
if (ev.key !== "Escape") return;
|
||||
document.querySelectorAll("details.tri[open], details.compte[open]").forEach(function (d) { d.removeAttribute("open"); });
|
||||
});
|
||||
|
||||
// Page « Publier » : barre Markdown, aperçu instantané (rendu par le serveur) et brouillon enregistré
|
||||
// environ 1 s après l'arrêt de la frappe. Sans JavaScript : boutons « Mettre à jour l'aperçu » et « Enregistrer le brouillon ».
|
||||
(function () {
|
||||
var form = document.getElementById("form-publier");
|
||||
if (!form || !window.fetch) return;
|
||||
var base = form.getAttribute("action").replace(/\/publier$/, "");
|
||||
var zone = form.querySelector("textarea[name=corps]");
|
||||
var vue = form.querySelector(".apercu-md");
|
||||
var etat = form.querySelector(".etat-brouillon");
|
||||
var cache = form.querySelector("input[name=brouillon]");
|
||||
var barre = form.querySelector(".barre-md");
|
||||
var sansJs = form.querySelector(".sans-js");
|
||||
if (sansJs) sansJs.hidden = true;
|
||||
|
||||
function corpsFormulaire(champs) {
|
||||
var p = new URLSearchParams();
|
||||
Object.keys(champs).forEach(function (k) { p.append(k, champs[k]); });
|
||||
return p;
|
||||
}
|
||||
|
||||
// Barre de mise en forme : insère la syntaxe autour de la sélection.
|
||||
var outils = [
|
||||
["Gras", "**", "**", "texte en gras"],
|
||||
["Italique", "*", "*", "texte en italique"],
|
||||
["Titre", "\n## ", "\n", "Titre"],
|
||||
["Liste", "\n- ", "\n- \n", "élément"],
|
||||
["Lien", "[", "](https://)", "texte du lien"],
|
||||
["Tableau", "\n| Colonne 1 | Colonne 2 |\n| --- | --- |\n| ", " | |\n", "valeur"]
|
||||
];
|
||||
outils.forEach(function (o) {
|
||||
var b = document.createElement("button");
|
||||
b.type = "button";
|
||||
b.textContent = o[0];
|
||||
b.setAttribute("aria-label", "Insérer : " + o[0].toLowerCase());
|
||||
b.addEventListener("click", function () {
|
||||
var d = zone.selectionStart, f = zone.selectionEnd;
|
||||
var choix = zone.value.slice(d, f) || o[3];
|
||||
zone.setRangeText(o[1] + choix + o[2], d, f, "end");
|
||||
zone.focus();
|
||||
zone.setSelectionRange(d + o[1].length, d + o[1].length + choix.length);
|
||||
zone.dispatchEvent(new Event("input", { bubbles: true }));
|
||||
});
|
||||
barre.appendChild(b);
|
||||
});
|
||||
barre.hidden = false;
|
||||
|
||||
var minuteApercu = null, minuteBrouillon = null;
|
||||
function apercu() {
|
||||
fetch(base + "/apercu-md", { method: "POST", credentials: "same-origin", body: corpsFormulaire({ corps: zone.value }) })
|
||||
.then(function (r) { return r.ok ? r.text() : Promise.reject(); })
|
||||
.then(function (h) { vue.innerHTML = h || "<p class='meta'>L’aperçu de ton message s’affiche ici.</p>"; })
|
||||
.catch(function () {});
|
||||
}
|
||||
function enregistrer() {
|
||||
if (!form.querySelector("input[name=titre]")) return; // réponse : pas de brouillon
|
||||
var titre = form.querySelector("input[name=titre]").value, corps = zone.value;
|
||||
if (!cache.value && !titre.trim() && !corps.trim()) return;
|
||||
var prevenir = form.querySelector("input[name=prevenir]");
|
||||
fetch(base + "/brouillon", {
|
||||
method: "POST", credentials: "same-origin",
|
||||
body: corpsFormulaire({ brouillon: cache.value, titre: titre, corps: corps,
|
||||
station: form.querySelector("select[name=station]").value, prevenir: prevenir.checked ? "1" : "" })
|
||||
}).then(function (r) { return r.ok ? r.json() : Promise.reject(); })
|
||||
.then(function (d) {
|
||||
if (!cache.value) {
|
||||
cache.value = d.id;
|
||||
history.replaceState(null, "", base + "/publier?brouillon=" + d.id);
|
||||
}
|
||||
etat.textContent = "Enregistré à " + d.heure;
|
||||
})
|
||||
.catch(function () { etat.textContent = "Brouillon non enregistré (connexion perdue ?). Utilise « Enregistrer le brouillon »."; });
|
||||
}
|
||||
form.addEventListener("input", function (ev) {
|
||||
if (ev.target === zone) { clearTimeout(minuteApercu); minuteApercu = setTimeout(apercu, 300); }
|
||||
if (ev.target.type === "file") return;
|
||||
clearTimeout(minuteBrouillon);
|
||||
minuteBrouillon = setTimeout(enregistrer, 1000);
|
||||
});
|
||||
form.addEventListener("change", function (ev) {
|
||||
if (ev.target.name === "station" || ev.target.name === "prevenir") { clearTimeout(minuteBrouillon); minuteBrouillon = setTimeout(enregistrer, 1000); }
|
||||
});
|
||||
form.addEventListener("submit", function () { clearTimeout(minuteBrouillon); });
|
||||
})();
|
||||
|
||||
// Fenêtre « Avec un compte, tu peux répondre » (visiteur sans compte, hors Bulletin) : même règle que le bandeau
|
||||
// « pas de cookie » du site : 1re visite, puis après 7 jours sans visite. La date reste dans le navigateur.
|
||||
(function () {
|
||||
var b = document.getElementById("invite-compte");
|
||||
if (!b) return;
|
||||
var montrer = true;
|
||||
try {
|
||||
var dernier = +localStorage.getItem("forum-invite-compte") || 0, maintenant = Date.now();
|
||||
montrer = !dernier || maintenant - dernier >= 7 * 86400000 || /[?&]invite/.test(location.search);
|
||||
localStorage.setItem("forum-invite-compte", String(maintenant));
|
||||
} catch (e) {}
|
||||
if (!montrer) return;
|
||||
b.hidden = false;
|
||||
var minut, fini = false;
|
||||
function partir() { if (fini) return; fini = true; b.classList.add("parti"); setTimeout(function () { b.remove(); }, 600); }
|
||||
function armer() { clearTimeout(minut); minut = setTimeout(partir, 9000); }
|
||||
b.addEventListener("pointerenter", function () { clearTimeout(minut); });
|
||||
b.addEventListener("pointerleave", armer);
|
||||
b.addEventListener("focusin", function () { clearTimeout(minut); });
|
||||
b.querySelector(".fermer").addEventListener("click", partir);
|
||||
armer();
|
||||
})();
|
||||
|
||||
// Écran de bienvenue : le bouton dit « Suivant » (profil public) ou « Terminer » (profil privé).
|
||||
(function () {
|
||||
var b = document.getElementById("bienvenue-suivant");
|
||||
if (!b) return;
|
||||
function maj() {
|
||||
var c = document.querySelector("input[name=profil]:checked");
|
||||
b.textContent = !c ? "Continuer" : (c.value === "public" ? "Suivant" : "Terminer");
|
||||
}
|
||||
Array.prototype.forEach.call(document.querySelectorAll("input[name=profil]"), function (r) {
|
||||
r.addEventListener("change", maj);
|
||||
});
|
||||
maj();
|
||||
})();
|
||||
|
||||
// Fenêtre « profil pas complet » : décompte 3, 2, 1, puis elle part seule et on revient à la page d'avant.
|
||||
(function () {
|
||||
var t = document.getElementById("toast-decompte");
|
||||
if (!t) return;
|
||||
var n = 3, c = t.querySelector(".decompte"), suite = document.querySelector("a.continuer");
|
||||
var iv = setInterval(function () {
|
||||
n -= 1;
|
||||
c.textContent = String(n);
|
||||
if (n <= 0) {
|
||||
clearInterval(iv);
|
||||
t.hidden = true;
|
||||
if (suite) location.href = suite.href;
|
||||
}
|
||||
}, 1000);
|
||||
})();
|
||||
@@ -0,0 +1,261 @@
|
||||
"""« Se connecter avec Gastinel » : client OAuth 2 (code + PKCE S256) vers le Hub. Bibliothèque standard seulement.
|
||||
|
||||
Contrat du Hub (Plan-connexion-Gastinel.md) :
|
||||
GET {hub}/oauth/autoriser?response_type=code&client_id&redirect_uri&state&code_challenge&code_challenge_method=S256
|
||||
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.
|
||||
"""
|
||||
import base64
|
||||
import hashlib
|
||||
import ipaddress
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import secrets
|
||||
import urllib.error
|
||||
import urllib.parse
|
||||
import urllib.request
|
||||
|
||||
REPONSE_MAX = 64 * 1024 # réponse du Hub lue au plus (octets)
|
||||
DELAI = 10 # secondes
|
||||
ID_HUB_OK = re.compile(r"^[A-Za-z0-9_.:@-]{1,64}$")
|
||||
LOCALES = [ipaddress.ip_network(n) for n in ("127.0.0.0/8", "10.0.0.0/8", "192.168.0.0/16", "::1/128")]
|
||||
|
||||
|
||||
class ErreurHub(Exception):
|
||||
"""Le Hub a refusé ou n'a pas répondu correctement."""
|
||||
|
||||
|
||||
def _bool(v):
|
||||
return str(v or "").strip() == "1"
|
||||
|
||||
|
||||
PREFIXE_OK = re.compile(r"^(/[A-Za-z0-9._~-]+)+$")
|
||||
|
||||
|
||||
def normaliser_prefixe(p):
|
||||
"""« forum », « /forum/ » -> « /forum » ; vide -> « ». Refuse tout caractère douteux (injection dans les liens)."""
|
||||
p = (p or "").strip().strip("/")
|
||||
if not p:
|
||||
return ""
|
||||
p = "/" + p
|
||||
if not PREFIXE_OK.match(p):
|
||||
raise ValueError("FORUM_PREFIXE invalide : lettres, chiffres, . _ ~ - et / seulement")
|
||||
return p
|
||||
|
||||
|
||||
class Reglages:
|
||||
"""Configuration de la connexion. En production : depuis les variables d'environnement (depuis_env)."""
|
||||
|
||||
def __init__(self, hub_url="", client_id="forum-vercors",
|
||||
redirect_uri=None, client_secret="",
|
||||
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:
|
||||
u = urllib.parse.urlparse(self.hub_url)
|
||||
local = u.hostname in ("127.0.0.1", "localhost", "::1")
|
||||
if u.scheme != "https" and not (u.scheme == "http" and local):
|
||||
raise ValueError("FORUM_HUB_URL doit être en https (http seulement en local)")
|
||||
self.client_id = client_id
|
||||
self.redirect_uri = redirect_uri or "https://vercors.me%s/connexion/retour" % self.prefixe
|
||||
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):
|
||||
return bool(self.hub_url and self.client_id and self.redirect_uri)
|
||||
|
||||
@classmethod
|
||||
def depuis_env(cls, env=None):
|
||||
env = os.environ if env is None else env
|
||||
secret = ""
|
||||
fichier = env.get("FORUM_OAUTH_SECRET_FILE")
|
||||
if fichier:
|
||||
with open(fichier, encoding="utf-8") as fh:
|
||||
secret = fh.read().strip()
|
||||
else:
|
||||
secret = env.get("FORUM_OAUTH_SECRET", "")
|
||||
relais = ("127.0.0.1", "::1") + tuple(x.strip() for x in env.get("FORUM_RELAIS", "").split(",") if x.strip())
|
||||
return cls(hub_url=env.get("FORUM_HUB_URL", ""),
|
||||
client_id=env.get("FORUM_CLIENT_ID", "forum-vercors"),
|
||||
redirect_uri=env.get("FORUM_REDIRECT_URI") or None,
|
||||
prefixe=env.get("FORUM_PREFIXE", ""),
|
||||
client_secret=secret,
|
||||
mode_test=_bool(env.get("FORUM_MODE_TEST")),
|
||||
relais=relais,
|
||||
roles_depuis_hub=_bool(env.get("FORUM_ROLES_DEPUIS_HUB")))
|
||||
|
||||
|
||||
# --- PKCE et adresse d'autorisation ------------------------------------------
|
||||
def _b64(octets):
|
||||
return base64.urlsafe_b64encode(octets).rstrip(b"=").decode("ascii")
|
||||
|
||||
|
||||
def pkce():
|
||||
"""Retourne (code_verifier, code_challenge S256)."""
|
||||
verifier = secrets.token_urlsafe(48) # 64 caractères (RFC 7636 : 43 à 128)
|
||||
return verifier, _b64(hashlib.sha256(verifier.encode("ascii")).digest())
|
||||
|
||||
|
||||
def nouvel_etat():
|
||||
return secrets.token_urlsafe(32)
|
||||
|
||||
|
||||
def url_autorisation(r, etat, challenge):
|
||||
q = urllib.parse.urlencode({"response_type": "code", "client_id": r.client_id, "redirect_uri": r.redirect_uri,
|
||||
"state": etat, "code_challenge": challenge, "code_challenge_method": "S256"})
|
||||
return "%s/oauth/autoriser?%s" % (r.hub_url, q)
|
||||
|
||||
|
||||
# --- appels serveur à serveur ------------------------------------------------
|
||||
class _SansRedirection(urllib.request.HTTPRedirectHandler):
|
||||
def redirect_request(self, *a, **k): # un code ou un jeton ne suit jamais une redirection
|
||||
return None
|
||||
|
||||
|
||||
_OUVREUR = urllib.request.build_opener(urllib.request.ProxyHandler({}), _SansRedirection())
|
||||
|
||||
|
||||
def _json(req):
|
||||
try:
|
||||
with _OUVREUR.open(req, timeout=DELAI) as rep:
|
||||
brut = rep.read(REPONSE_MAX + 1)
|
||||
except urllib.error.HTTPError as ex:
|
||||
raise ErreurHub("le Hub a répondu %d" % ex.code)
|
||||
except (urllib.error.URLError, OSError) as ex:
|
||||
raise ErreurHub("Hub injoignable (%s)" % ex.__class__.__name__)
|
||||
if len(brut) > REPONSE_MAX:
|
||||
raise ErreurHub("réponse du Hub trop longue")
|
||||
try:
|
||||
d = json.loads(brut.decode("utf-8"))
|
||||
except ValueError:
|
||||
raise ErreurHub("réponse du Hub illisible")
|
||||
if not isinstance(d, dict):
|
||||
raise ErreurHub("réponse du Hub inattendue")
|
||||
return d
|
||||
|
||||
|
||||
def echanger_code(r, code, verifier):
|
||||
"""Échange le code contre un jeton d'accès (POST /oauth/jeton)."""
|
||||
champs = {"grant_type": "authorization_code", "code": code, "redirect_uri": r.redirect_uri,
|
||||
"client_id": r.client_id, "code_verifier": verifier}
|
||||
if r.client_secret:
|
||||
champs["client_secret"] = r.client_secret
|
||||
req = urllib.request.Request(r.hub_url + "/oauth/jeton", data=urllib.parse.urlencode(champs).encode("ascii"),
|
||||
headers={"Content-Type": "application/x-www-form-urlencoded",
|
||||
"Accept": "application/json"}, method="POST")
|
||||
jeton = _json(req).get("access_token")
|
||||
if not isinstance(jeton, str) or not jeton or len(jeton) > 4096:
|
||||
raise ErreurHub("jeton absent")
|
||||
return jeton
|
||||
|
||||
|
||||
def lire_profil(r, jeton):
|
||||
"""GET /oauth/moi -> (id Gastinel, pseudo)."""
|
||||
req = urllib.request.Request(r.hub_url + "/oauth/moi",
|
||||
headers={"Authorization": "Bearer " + jeton, "Accept": "application/json"})
|
||||
d = _json(req)
|
||||
ident = d.get("id", d.get("sub"))
|
||||
if isinstance(ident, bool) or not isinstance(ident, (str, int)):
|
||||
raise ErreurHub("identifiant absent")
|
||||
ident = str(ident)
|
||||
if not ID_HUB_OK.match(ident) or ident == "systeme":
|
||||
raise ErreurHub("identifiant invalide")
|
||||
pseudo = d.get("pseudo")
|
||||
pseudo = "".join(c for c in pseudo if c.isprintable()).strip()[:60] if isinstance(pseudo, str) else ""
|
||||
return ident, pseudo or "Membre"
|
||||
|
||||
|
||||
# --- adresse du client --------------------------------------------------------
|
||||
def ip_client(directe, xff, relais=("127.0.0.1", "::1")):
|
||||
"""Adresse réelle du visiteur. X-Forwarded-For n'est cru que si la requête vient d'un relais de confiance
|
||||
(Caddy en local) ; on prend alors la dernière adresse, celle que le relais a vue."""
|
||||
if directe in relais and xff:
|
||||
derniere = xff.split(",")[-1].strip()
|
||||
try:
|
||||
return str(ipaddress.ip_address(derniere))
|
||||
except ValueError:
|
||||
return directe
|
||||
return directe
|
||||
|
||||
|
||||
def est_locale(ip):
|
||||
try:
|
||||
a = ipaddress.ip_address(ip)
|
||||
except ValueError:
|
||||
return False
|
||||
if getattr(a, "ipv4_mapped", None):
|
||||
a = a.ipv4_mapped
|
||||
return any(a.version == n.version and a in n for n in LOCALES)
|
||||
|
||||
|
||||
def pousser_roles(r, hub_id, roles_forum):
|
||||
"""POST {hub}/oauth/roles : le Hub affiche ces rôles sur la page du compte. Sans secret client, rien n'est envoyé."""
|
||||
if not r.client_secret or not r.hub_url:
|
||||
return
|
||||
valides = ("adherent", "moderateur", "proprietaire_station", "proprietaire_adjoint", "proprietaire")
|
||||
corps = json.dumps({"id": hub_id, "roles": sorted(set(x for x in roles_forum if x in valides))}).encode("utf-8")
|
||||
jeton = base64.b64encode(("%s:%s" % (r.client_id, r.client_secret)).encode("utf-8")).decode("ascii")
|
||||
req = urllib.request.Request(r.hub_url + "/oauth/roles", data=corps, method="POST",
|
||||
headers={"Content-Type": "application/json", "Authorization": "Basic " + jeton})
|
||||
try:
|
||||
with _OUVREUR.open(req, timeout=DELAI):
|
||||
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
|
||||
+204
-24
@@ -1,30 +1,36 @@
|
||||
"""Schéma SQLite et accès aux données."""
|
||||
"""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 (
|
||||
id INTEGER PRIMARY KEY,
|
||||
hub_id TEXT NOT NULL UNIQUE, -- identifiant du compte Gastinel (Hub)
|
||||
display_name TEXT NOT NULL,
|
||||
role TEXT NOT NULL DEFAULT 'membre'
|
||||
CHECK (role IN ('membre','adherent','moderateur','admin')),
|
||||
display_name TEXT NOT NULL, -- pseudo du compte Gastinel
|
||||
created_at TEXT NOT NULL DEFAULT (datetime('now'))
|
||||
);
|
||||
CREATE TABLE IF NOT EXISTS categories (
|
||||
id INTEGER PRIMARY KEY,
|
||||
slug TEXT NOT NULL UNIQUE,
|
||||
name TEXT NOT NULL,
|
||||
min_role_topic TEXT NOT NULL DEFAULT 'adherent',
|
||||
position INTEGER NOT NULL DEFAULT 0
|
||||
-- Rôles cumulables ; « membre » est implicite pour tout compte. station : id de station pour proprietaire_station.
|
||||
CREATE TABLE IF NOT EXISTS user_roles (
|
||||
user_id INTEGER NOT NULL REFERENCES users(id),
|
||||
role TEXT NOT NULL CHECK (role IN ('adherent','moderateur','proprietaire','proprietaire_adjoint','proprietaire_station')),
|
||||
station TEXT NOT NULL DEFAULT '',
|
||||
given_by INTEGER REFERENCES users(id),
|
||||
given_at TEXT NOT NULL DEFAULT (datetime('now')),
|
||||
PRIMARY KEY (user_id, role, station)
|
||||
);
|
||||
CREATE TABLE IF NOT EXISTS topics (
|
||||
id INTEGER PRIMARY KEY,
|
||||
category_id INTEGER NOT NULL REFERENCES categories(id),
|
||||
title TEXT NOT NULL,
|
||||
author_id INTEGER NOT NULL REFERENCES users(id),
|
||||
created_at TEXT NOT NULL DEFAULT (datetime('now')),
|
||||
locked INTEGER NOT NULL DEFAULT 0,
|
||||
hidden INTEGER NOT NULL DEFAULT 0
|
||||
hidden INTEGER NOT NULL DEFAULT 0,
|
||||
fixed INTEGER NOT NULL DEFAULT 0, -- sujet fixe (Bulletin de la semaine) : toujours épinglé en tête
|
||||
pinned INTEGER NOT NULL DEFAULT 0,
|
||||
pin_pos INTEGER NOT NULL DEFAULT 0,
|
||||
replies_open INTEGER NOT NULL DEFAULT 1, -- 0 : seuls les rôles « publier_bulletin » écrivent
|
||||
status TEXT NOT NULL DEFAULT 'publie' CHECK (status IN ('publie','en_attente','refuse')),
|
||||
station TEXT -- sujet d'une station (propriétaire de station)
|
||||
);
|
||||
CREATE TABLE IF NOT EXISTS posts (
|
||||
id INTEGER PRIMARY KEY,
|
||||
@@ -34,7 +40,17 @@ CREATE TABLE IF NOT EXISTS posts (
|
||||
created_at TEXT NOT NULL DEFAULT (datetime('now')),
|
||||
edited_at TEXT,
|
||||
hidden INTEGER NOT NULL DEFAULT 0,
|
||||
ip TEXT -- purgée après 13 mois (purger_ips)
|
||||
ip TEXT -- obligation légale (un an), purgée ensuite (purger_ips)
|
||||
);
|
||||
CREATE TABLE IF NOT EXISTS attachments (
|
||||
id INTEGER PRIMARY KEY,
|
||||
post_id INTEGER NOT NULL REFERENCES posts(id),
|
||||
filename TEXT NOT NULL,
|
||||
mime TEXT NOT NULL,
|
||||
size INTEGER NOT NULL,
|
||||
sha256 TEXT NOT NULL,
|
||||
stored_path TEXT NOT NULL,
|
||||
created_at TEXT NOT NULL DEFAULT (datetime('now'))
|
||||
);
|
||||
CREATE TABLE IF NOT EXISTS reports (
|
||||
id INTEGER PRIMARY KEY,
|
||||
@@ -44,16 +60,126 @@ CREATE TABLE IF NOT EXISTS reports (
|
||||
created_at TEXT NOT NULL DEFAULT (datetime('now')),
|
||||
UNIQUE (post_id, reporter_id)
|
||||
);
|
||||
-- Prévu plus tard : attachments(id, post_id, filename, mime, size, sha256, stored_path)
|
||||
CREATE INDEX IF NOT EXISTS idx_topics_cat ON topics(category_id, id DESC);
|
||||
-- Sessions du forum (connexion Gastinel) : seul le haché SHA-256 de l'identifiant du cookie est gardé.
|
||||
CREATE TABLE IF NOT EXISTS sessions (
|
||||
id_hache TEXT PRIMARY KEY,
|
||||
user_id INTEGER NOT NULL REFERENCES users(id),
|
||||
created_at TEXT NOT NULL DEFAULT (datetime('now')),
|
||||
expires_at TEXT NOT NULL
|
||||
);
|
||||
-- Demandes de connexion en cours (state haché -> code_verifier PKCE), 10 minutes au plus.
|
||||
CREATE TABLE IF NOT EXISTS oauth_etats (
|
||||
etat_hache TEXT PRIMARY KEY,
|
||||
verifier TEXT NOT NULL,
|
||||
created_at TEXT NOT NULL DEFAULT (datetime('now'))
|
||||
);
|
||||
-- Demandes pour devenir adhérent météo (validées par le propriétaire ou l'adjoint).
|
||||
CREATE TABLE IF NOT EXISTS adhesions (
|
||||
id INTEGER PRIMARY KEY,
|
||||
user_id INTEGER NOT NULL REFERENCES users(id),
|
||||
message TEXT NOT NULL,
|
||||
status TEXT NOT NULL DEFAULT 'en_attente' CHECK (status IN ('en_attente','acceptee','refusee')),
|
||||
created_at TEXT NOT NULL DEFAULT (datetime('now')),
|
||||
decided_by INTEGER REFERENCES users(id),
|
||||
decided_at TEXT
|
||||
);
|
||||
CREATE TABLE IF NOT EXISTS adhesion_photos (
|
||||
id INTEGER PRIMARY KEY,
|
||||
adhesion_id INTEGER NOT NULL REFERENCES adhesions(id),
|
||||
filename TEXT NOT NULL,
|
||||
mime TEXT NOT NULL,
|
||||
size INTEGER NOT NULL,
|
||||
sha256 TEXT NOT NULL,
|
||||
stored_path TEXT NOT NULL
|
||||
);
|
||||
-- Photos épinglées sur la fiche publique d'une station (3 au plus), choisies dans le sujet de la station.
|
||||
CREATE TABLE IF NOT EXISTS fiche_photos (
|
||||
attachment_id INTEGER PRIMARY KEY REFERENCES attachments(id),
|
||||
station TEXT NOT NULL,
|
||||
pinned_by INTEGER REFERENCES users(id),
|
||||
pinned_at TEXT NOT NULL DEFAULT (datetime('now'))
|
||||
);
|
||||
CREATE INDEX IF NOT EXISTS idx_fiche_station ON fiche_photos(station, pinned_at);
|
||||
CREATE UNIQUE INDEX IF NOT EXISTS idx_une_demande_en_cours ON adhesions(user_id) WHERE status = 'en_attente';
|
||||
CREATE INDEX IF NOT EXISTS idx_sessions_user ON sessions(user_id);
|
||||
CREATE INDEX IF NOT EXISTS idx_topics_liste ON topics(pinned DESC, pin_pos, id DESC);
|
||||
CREATE INDEX IF NOT EXISTS idx_posts_topic ON posts(topic_id, id);
|
||||
CREATE INDEX IF NOT EXISTS idx_attach_post ON attachments(post_id);
|
||||
-- Dernier message lu par compte et par sujet (pastille « Nouveau », sans cookie de suivi).
|
||||
CREATE TABLE IF NOT EXISTS lectures (
|
||||
user_id INTEGER NOT NULL REFERENCES users(id),
|
||||
topic_id INTEGER NOT NULL REFERENCES topics(id),
|
||||
dernier_post INTEGER NOT NULL DEFAULT 0,
|
||||
PRIMARY KEY (user_id, topic_id)
|
||||
);
|
||||
-- Brouillons de la page « Publier » : privés, un auteur ne voit que les siens ; supprimés à la publication.
|
||||
CREATE TABLE IF NOT EXISTS brouillons (
|
||||
id INTEGER PRIMARY KEY,
|
||||
user_id INTEGER NOT NULL REFERENCES users(id),
|
||||
titre TEXT NOT NULL DEFAULT '',
|
||||
corps TEXT NOT NULL DEFAULT '',
|
||||
station TEXT NOT NULL DEFAULT '',
|
||||
prevenir INTEGER NOT NULL DEFAULT 0,
|
||||
maj TEXT NOT NULL DEFAULT (datetime('now'))
|
||||
);
|
||||
CREATE INDEX IF NOT EXISTS idx_brouillons_user ON brouillons(user_id, maj);
|
||||
CREATE UNIQUE INDEX IF NOT EXISTS idx_un_sujet_par_station ON topics(station) WHERE station IS NOT NULL AND status <> 'refuse';
|
||||
"""
|
||||
|
||||
CATEGORIES_DEFAUT = [
|
||||
("recapitulatif-semaine", "Récapitulatif de la semaine", "adherent", 0),
|
||||
("observations", "Observations", "adherent", 1),
|
||||
("discussion", "Discussion générale", "adherent", 2),
|
||||
]
|
||||
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:"):
|
||||
@@ -61,8 +187,62 @@ def connecter(chemin=":memory:"):
|
||||
con.row_factory = sqlite3.Row
|
||||
con.execute("PRAGMA foreign_keys = ON")
|
||||
con.executescript(SCHEMA)
|
||||
for slug, nom, role, pos in CATEGORIES_DEFAUT:
|
||||
con.execute("INSERT OR IGNORE INTO categories(slug,name,min_role_topic,position)"
|
||||
" VALUES (?,?,?,?)", (slug, nom, role, pos))
|
||||
# migrations douces (colonnes ajoutées après la mise en ligne)
|
||||
if "ancien_body" not in {r[1] for r in con.execute("PRAGMA table_info(posts)")}:
|
||||
con.execute("ALTER TABLE posts ADD COLUMN ancien_body TEXT") # version d'avant l'unique modification
|
||||
if "format" not in {r[1] for r in con.execute("PRAGMA table_info(posts)")}:
|
||||
con.execute("ALTER TABLE posts ADD COLUMN format TEXT NOT NULL DEFAULT 'texte'") # 'texte' ou 'md' (page Publier)
|
||||
cols = {r[1] for r in con.execute("PRAGMA table_info(topics)")}
|
||||
if "station_liee" not in cols:
|
||||
con.execute("ALTER TABLE topics ADD COLUMN station_liee TEXT") # station citée (facultatif), distincte du sujet de station
|
||||
if "prevenir" not in cols:
|
||||
con.execute("ALTER TABLE topics ADD COLUMN prevenir INTEGER NOT NULL DEFAULT 0") # « Me prévenir des réponses » (enregistré, pas encore d'envoi)
|
||||
# Écran de bienvenue et profil public (06/11/2026). Les comptes déjà là reçoivent bienvenue=2 (écran déjà passé)
|
||||
# et profil NULL (« ancien » : nom Gastinel affiché comme avant) ; un nouveau compte part de bienvenue=0.
|
||||
cols = {r[1] for r in con.execute("PRAGMA table_info(users)")}
|
||||
for nom, decl in (("profil", "TEXT"), # NULL (ancien compte), 'attente', 'prive', 'public'
|
||||
("username", "TEXT"), ("username_cle", "TEXT"), ("username_le", "TEXT"),
|
||||
("bio", "TEXT NOT NULL DEFAULT ''"),
|
||||
("photo", "TEXT"), # fichier dans <photos>/profils
|
||||
("avatar_illustre", "TEXT"), # brume, neige, station (NULL : brume par défaut)
|
||||
("notifs", "TEXT"), # réglages des mails (JSON), enregistrés seulement
|
||||
("bienvenue", "INTEGER NOT NULL DEFAULT 2"), # 0 : écran 1 à montrer, 1 : écran 2 en cours, 2 : fini
|
||||
("plus_tard", "INTEGER NOT NULL DEFAULT 0"), ("plus_tard_le", "TEXT"),
|
||||
("supprime", "INTEGER NOT NULL DEFAULT 0")):
|
||||
if nom not in cols:
|
||||
con.execute("ALTER TABLE users ADD COLUMN %s %s" % (nom, decl))
|
||||
con.execute("CREATE UNIQUE INDEX IF NOT EXISTS idx_username ON users(username_cle) WHERE username_cle IS NOT NULL")
|
||||
con.execute("CREATE TABLE IF NOT EXISTS usernames_anciens (id INTEGER PRIMARY KEY,"
|
||||
" user_id INTEGER NOT NULL REFERENCES users(id), username TEXT NOT NULL,"
|
||||
" jusqu_au TEXT NOT NULL DEFAULT (datetime('now')))")
|
||||
con.execute("CREATE INDEX IF NOT EXISTS idx_usernames_anciens ON usernames_anciens(user_id, id)")
|
||||
# Commentaires aux réponses (06/11/2026) : un seul niveau, texte simple ; ils ne comptent pas comme des messages
|
||||
# (limite des visiteurs, tris). Tables à part : rien ne change pour posts et reports.
|
||||
con.execute("CREATE TABLE IF NOT EXISTS comments (id INTEGER PRIMARY KEY,"
|
||||
" post_id INTEGER NOT NULL REFERENCES posts(id), author_id INTEGER NOT NULL REFERENCES users(id),"
|
||||
" body TEXT NOT NULL, created_at TEXT NOT NULL DEFAULT (datetime('now')),"
|
||||
" hidden INTEGER NOT NULL DEFAULT 0, ip TEXT)")
|
||||
con.execute("CREATE INDEX IF NOT EXISTS idx_comments_post ON comments(post_id, id)")
|
||||
con.execute("CREATE TABLE IF NOT EXISTS comment_reports (id INTEGER PRIMARY KEY,"
|
||||
" comment_id INTEGER NOT NULL REFERENCES comments(id), reporter_id INTEGER NOT NULL REFERENCES users(id),"
|
||||
" reason TEXT NOT NULL, created_at TEXT NOT NULL DEFAULT (datetime('now')), UNIQUE (comment_id, reporter_id))")
|
||||
# Réactions aux messages (06/11/2026) : une par membre et par message (la clé primaire l'impose) ; created_at est
|
||||
# remis à l'heure quand la réaction change (servira au mail groupé « N réactions en 7 jours »). Hors limite des
|
||||
# visiteurs et hors tris, comme les commentaires.
|
||||
con.execute("CREATE TABLE IF NOT EXISTS reactions (post_id INTEGER NOT NULL REFERENCES posts(id),"
|
||||
" 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)
|
||||
+1187
-103
Diff désactivé car ce fichier est trop long.
Voir la Diff
@@ -0,0 +1,121 @@
|
||||
"""Convertisseur Markdown maison, volontairement réduit et sûr (aucune bibliothèque externe).
|
||||
|
||||
Tout le texte est d'abord échappé (html.escape) : aucune balise de l'auteur ne passe.
|
||||
On reconnaît ensuite : titres (#, ##, ###), gras (**x**), italique (*x* ou _x_), listes (- * ou 1.),
|
||||
liens [texte](http(s)://…) seulement, code en ligne (`x`), paragraphes et tableaux (syntaxe pipe).
|
||||
"""
|
||||
import html
|
||||
import re
|
||||
|
||||
CODE = re.compile(r"`([^`\n]+)`")
|
||||
LIEN = re.compile(r"\[([^\]\n]+)\]\(([^)\s]+)\)")
|
||||
URL_OK = re.compile(r"^https?://[^\s\x00]+$", re.I)
|
||||
GRAS = re.compile(r"\*\*([^*\n]+)\*\*")
|
||||
ITALIQUE = re.compile(r"(?<![\w*])\*([^*\s](?:[^*\n]*[^*\s])?)\*(?![\w*])|(?<!\w)_([^_\s](?:[^_\n]*[^_\s])?)_(?!\w)")
|
||||
TITRE = re.compile(r"^(#{1,3})[ \t]+(.*)$")
|
||||
LIGNE_MAX = 2000 # au-delà, la ligne est coupée avant les règles en ligne (temps de calcul borné)
|
||||
PUCE = re.compile(r"^\s*[-*+]\s+(.*)$")
|
||||
NUMERO = re.compile(r"^\s*\d{1,3}[.)]\s+(.*)$")
|
||||
CONTROLE = re.compile(r"[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]")
|
||||
SEPARATEUR = re.compile(r"^\s*\|?\s*:?-+:?\s*(\|\s*:?-+:?\s*)*\|?\s*$")
|
||||
|
||||
|
||||
def _en_ligne(t):
|
||||
"""Texte déjà échappé -> HTML en ligne (le code est protégé des autres règles)."""
|
||||
t = t[:LIGNE_MAX * 6] # texte échappé : une ligne de LIGNE_MAX caractères au plus
|
||||
codes = []
|
||||
|
||||
def garder(m):
|
||||
codes.append("<code>%s</code>" % m.group(1))
|
||||
return "\x00%d\x00" % (len(codes) - 1)
|
||||
|
||||
t = CODE.sub(garder, t)
|
||||
|
||||
def lien(m):
|
||||
texte, url = m.group(1), html.unescape(m.group(2))
|
||||
if not URL_OK.match(url):
|
||||
return m.group(0) # javascript:, data:, relatif… : laissé en texte
|
||||
return "<a href='%s' rel='nofollow noopener noreferrer'>%s</a>" % (html.escape(url, quote=True), texte)
|
||||
|
||||
t = LIEN.sub(lien, t)
|
||||
t = GRAS.sub(r"<strong>\1</strong>", t)
|
||||
t = ITALIQUE.sub(lambda m: "<em>%s</em>" % (m.group(1) or m.group(2)), t)
|
||||
def remettre(m):
|
||||
i = int(m.group(1))
|
||||
return codes[i] if i < len(codes) else m.group(0)
|
||||
|
||||
return re.sub("\x00(\\d+)\x00", remettre, t)
|
||||
|
||||
|
||||
def _cellules(ligne):
|
||||
ligne = ligne.strip()
|
||||
if ligne.startswith("|"):
|
||||
ligne = ligne[1:]
|
||||
if ligne.endswith("|"):
|
||||
ligne = ligne[:-1]
|
||||
return [c.strip() for c in ligne.split("|")]
|
||||
|
||||
|
||||
def _alignements(sep):
|
||||
out = []
|
||||
for c in _cellules(sep):
|
||||
g, d = c.startswith(":"), c.endswith(":")
|
||||
out.append(" class='centre'" if g and d else " class='droite'" if d else "")
|
||||
return out
|
||||
|
||||
|
||||
def rendu(texte):
|
||||
"""Markdown -> HTML sûr."""
|
||||
texte = CONTROLE.sub("", texte or "") # \x00 sert de marqueur interne
|
||||
lignes = html.escape((texte or "").replace("\r\n", "\n").replace("\r", "\n"), quote=True).split("\n")
|
||||
lignes = [x[:LIGNE_MAX * 6] for x in lignes] # lignes très longues coupées : temps de calcul borné
|
||||
out, para, i = [], [], 0
|
||||
|
||||
def fermer_para():
|
||||
if para:
|
||||
out.append("<p>%s</p>" % "<br>".join(_en_ligne(x) for x in para))
|
||||
para.clear()
|
||||
|
||||
while i < len(lignes):
|
||||
l = lignes[i]
|
||||
if not l.strip():
|
||||
fermer_para()
|
||||
i += 1
|
||||
continue
|
||||
m = TITRE.match(l)
|
||||
if m and m.group(2).rstrip().rstrip("#").rstrip():
|
||||
fermer_para()
|
||||
n = len(m.group(1)) + 1 # # -> h2 (le h1 est le titre du sujet)
|
||||
out.append("<h%d>%s</h%d>" % (n, _en_ligne(m.group(2).rstrip().rstrip("#").rstrip()), n))
|
||||
i += 1
|
||||
continue
|
||||
if "|" in l and i + 1 < len(lignes) and SEPARATEUR.match(lignes[i + 1]) and "|" in lignes[i + 1]:
|
||||
fermer_para()
|
||||
tete, al = _cellules(l), _alignements(lignes[i + 1])
|
||||
larg = len(tete)
|
||||
al = (al + [""] * larg)[:larg]
|
||||
h = ["<div class='tableau'><table><thead><tr>"]
|
||||
h += ["<th%s>%s</th>" % (al[k], _en_ligne(c)) for k, c in enumerate(tete)]
|
||||
h.append("</tr></thead><tbody>")
|
||||
i += 2
|
||||
while i < len(lignes) and lignes[i].strip() and "|" in lignes[i]:
|
||||
cs = (_cellules(lignes[i]) + [""] * larg)[:larg]
|
||||
h.append("<tr>%s</tr>" % "".join("<td%s>%s</td>" % (al[k], _en_ligne(c)) for k, c in enumerate(cs)))
|
||||
i += 1
|
||||
h.append("</tbody></table></div>")
|
||||
out.append("".join(h))
|
||||
continue
|
||||
for motif, balise in ((PUCE, "ul"), (NUMERO, "ol")):
|
||||
if motif.match(l):
|
||||
fermer_para()
|
||||
items = []
|
||||
while i < len(lignes) and motif.match(lignes[i]):
|
||||
items.append("<li>%s</li>" % _en_ligne(motif.match(lignes[i]).group(1)))
|
||||
i += 1
|
||||
out.append("<%s>%s</%s>" % (balise, "".join(items), balise))
|
||||
break
|
||||
else:
|
||||
para.append(l.strip())
|
||||
i += 1
|
||||
fermer_para()
|
||||
return "\n".join(out)
|
||||
@@ -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())
|
||||
@@ -0,0 +1,106 @@
|
||||
# Noms bloqués pour les usernames du forum (comparés en minuscules, sans accents ni ponctuation, aussi à l'envers).
|
||||
# Partie 1 : noms réservés (décision de Théo, 06/11/2026).
|
||||
admin
|
||||
administrateur
|
||||
moderateur
|
||||
moderation
|
||||
meteovercors
|
||||
meteovercorsforum
|
||||
direction
|
||||
equipe
|
||||
gastinel
|
||||
theogastinel
|
||||
richardgastinel
|
||||
# Partie 2 : mots grossiers en français, liste « List of Dirty, Naughty, Obscene, and Otherwise Bad Words » (fichier fr),
|
||||
# https://github.com/LDNOOBW/List-of-Dirty-Naughty-Obscene-and-Otherwise-Bad-Words, licence CC BY 4.0, téléchargée le 06/11/2026.
|
||||
baiser
|
||||
bander
|
||||
bigornette
|
||||
bite
|
||||
bitte
|
||||
bloblos
|
||||
bordel
|
||||
bourré
|
||||
bourrée
|
||||
brackmard
|
||||
branlage
|
||||
branler
|
||||
branlette
|
||||
branleur
|
||||
branleuse
|
||||
brouter le cresson
|
||||
caca
|
||||
chatte
|
||||
chiasse
|
||||
chier
|
||||
chiottes
|
||||
clito
|
||||
clitoris
|
||||
con
|
||||
connard
|
||||
connasse
|
||||
conne
|
||||
couilles
|
||||
cramouille
|
||||
cul
|
||||
déconne
|
||||
déconner
|
||||
emmerdant
|
||||
emmerder
|
||||
emmerdeur
|
||||
emmerdeuse
|
||||
enculé
|
||||
enculée
|
||||
enculeur
|
||||
enculeurs
|
||||
enfoiré
|
||||
enfoirée
|
||||
étron
|
||||
fille de pute
|
||||
fils de pute
|
||||
folle
|
||||
foutre
|
||||
gerbe
|
||||
gerber
|
||||
gouine
|
||||
grande folle
|
||||
grogniasse
|
||||
gueule
|
||||
jouir
|
||||
la putain de ta mère
|
||||
MALPT
|
||||
ménage à trois
|
||||
merde
|
||||
merdeuse
|
||||
merdeux
|
||||
meuf
|
||||
nègre
|
||||
negro
|
||||
nique ta mère
|
||||
nique ta race
|
||||
palucher
|
||||
pédale
|
||||
pédé
|
||||
péter
|
||||
pipi
|
||||
pisser
|
||||
pouffiasse
|
||||
pousse-crotte
|
||||
putain
|
||||
pute
|
||||
ramoner
|
||||
sac à foutre
|
||||
sac à merde
|
||||
salaud
|
||||
salope
|
||||
suce
|
||||
tapette
|
||||
tanche
|
||||
teuch
|
||||
tringler
|
||||
trique
|
||||
troncher
|
||||
trou du cul
|
||||
turlute
|
||||
zigounette
|
||||
zizi
|
||||
@@ -0,0 +1,343 @@
|
||||
"""Panneau de gestion du forum, réservé au réseau local et au Propriétaire / Propriétaire adjoint.
|
||||
|
||||
Second serveur, sur la même base que le forum (python forum/panneau.py --port 8790).
|
||||
- Toute requête dont l'adresse n'est pas en 127/8, 10/8, 192.168/16 ou ::1 reçoit 403 : on regarde seulement
|
||||
l'adresse de la connexion TCP, JAMAIS X-Forwarded-For (le panneau ne se place pas derrière un relais).
|
||||
- Connexion avec le compte Gastinel (même client OAuth que le forum, connexion.py), mais adresse de retour propre
|
||||
(FORUM_PANNEAU_REDIRECT_URI) et session propre (cookie panneau_session, jetons séparés de ceux du forum).
|
||||
- Aucune inscription ici : seul un compte déjà connu du forum et ayant le droit « gerer_roles » entre.
|
||||
- Tous les POST exigent un jeton CSRF lié à la session, en plus du contrôle d'origine.
|
||||
|
||||
Variables d'environnement : celles du forum (FORUM_HUB_URL, FORUM_CLIENT_ID, FORUM_OAUTH_SECRET[_FILE],
|
||||
FORUM_PROPRIETAIRE_ID) + FORUM_PANNEAU_REDIRECT_URI (défaut : http://localhost:<port>/connexion/retour).
|
||||
"""
|
||||
import argparse
|
||||
import hashlib
|
||||
import hmac
|
||||
import os
|
||||
import re
|
||||
import secrets
|
||||
import sys
|
||||
from http import cookies
|
||||
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
|
||||
from urllib.parse import parse_qs, urlparse
|
||||
|
||||
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
|
||||
import connexion # noqa: E402
|
||||
import roles # noqa: E402
|
||||
import server # noqa: E402
|
||||
from forum import ETAT_MINUTES, Forum, Invalide, Refus # noqa: E402
|
||||
from server import CSS, JETON_OK, PHOTO_OK, TYPES_IMG, e # noqa: E402
|
||||
|
||||
PORTEE = "panneau" # sépare les sessions du panneau de celles du forum
|
||||
SESSION = "panneau_session"
|
||||
ETAT = "panneau_etat"
|
||||
SESSION_JOURS = 1
|
||||
FORMULAIRE_MAX = 64 * 1024
|
||||
|
||||
SUJET_PUBLIC = "https://vercors.me/forum/t/"
|
||||
|
||||
|
||||
class App:
|
||||
def __init__(self, forum, reglages):
|
||||
self.forum = forum
|
||||
self.reglages = reglages
|
||||
self.cle = secrets.token_bytes(32) # clé des jetons CSRF (propre à ce processus)
|
||||
|
||||
|
||||
class Handler(BaseHTTPRequestHandler):
|
||||
server_version = "PanneauForum"
|
||||
app = None # défini dans creer_serveur
|
||||
|
||||
def log_message(self, *a):
|
||||
pass
|
||||
|
||||
# --- outils ---------------------------------------------------------
|
||||
def ip(self):
|
||||
return self.client_address[0] # volontairement sans X-Forwarded-For
|
||||
|
||||
def cookie(self, nom):
|
||||
try:
|
||||
c = cookies.SimpleCookie(self.headers.get("Cookie", ""))
|
||||
except cookies.CookieError:
|
||||
return None
|
||||
return c[nom].value if nom in c else None
|
||||
|
||||
def jeton_session(self):
|
||||
j = self.cookie(SESSION)
|
||||
return j if j and JETON_OK.match(j) else None
|
||||
|
||||
def utilisateur(self):
|
||||
j = self.jeton_session()
|
||||
return self.app.forum.utilisateur_de_session(j, PORTEE) if j else None
|
||||
|
||||
def csrf(self):
|
||||
j = self.jeton_session() or ""
|
||||
return hmac.new(self.app.cle, j.encode("ascii"), hashlib.sha256).hexdigest()
|
||||
|
||||
def champ_csrf(self):
|
||||
return "<input type='hidden' name='csrf' value='%s'>" % self.csrf()
|
||||
|
||||
def ck(self, nom, valeur, age):
|
||||
secure = self.app.reglages.redirect_uri.startswith("https://")
|
||||
return server._cookie(nom, valeur, age, "/", secure)
|
||||
|
||||
def envoyer(self, code, corps, type_="text/html; charset=utf-8", extra=()):
|
||||
data = corps if isinstance(corps, bytes) else corps.replace("__POLICES__", "/polices").encode("utf-8")
|
||||
self.send_response(code)
|
||||
self.send_header("Content-Type", type_)
|
||||
self.send_header("Content-Length", str(len(data)))
|
||||
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", "same-origin")
|
||||
self.send_header("Cache-Control", "private, no-store")
|
||||
for k, v in extra:
|
||||
self.send_header(k, v)
|
||||
self.end_headers()
|
||||
self.wfile.write(data)
|
||||
|
||||
def rediriger(self, url, extra=()):
|
||||
self.send_response(303)
|
||||
self.send_header("Location", url)
|
||||
self.send_header("Referrer-Policy", "same-origin")
|
||||
for k, v in extra:
|
||||
self.send_header(k, v)
|
||||
self.send_header("Content-Length", "0")
|
||||
self.end_headers()
|
||||
|
||||
def page(self, titre, contenu, user, code=200, extra=()):
|
||||
qui = ""
|
||||
nav = ""
|
||||
if user is not None:
|
||||
qui = ("<div class='moi'><span>%s</span><form method='post' action='/deconnexion'>"
|
||||
"%s<button>Se déconnecter</button></form></div>"
|
||||
% (e(user["display_name"]), self.champ_csrf()))
|
||||
if roles.peut(self.app.forum.roles_de(user), "gerer_roles"):
|
||||
liens = [("/", "Vue d’ensemble"), ("/utilisateurs", "Comptes et rôles"), ("/adhesions", "Adhésions"),
|
||||
("/stations", "Stations à valider"), ("/signalements", "Signalements")]
|
||||
nav = server.navigation(liens, urlparse(self.path).path, "Panneau du forum")
|
||||
corps = ("<!doctype html><html lang='fr'><head><meta charset='utf-8'>"
|
||||
"<meta name='viewport' content='width=device-width,initial-scale=1'><meta name='robots' content='noindex'>"
|
||||
"<title>%s · Panneau du forum</title><style>%s</style></head><body>"
|
||||
"<a class='saut' href='#contenu'>Aller au contenu</a>"
|
||||
"<header class='haut'><a class='nom' href='/'>Météo Vercors · Gestion</a>%s</header>"
|
||||
"<main id='contenu'>%s%s</main>"
|
||||
"<footer class='pied'>Panneau de gestion · réseau local uniquement</footer></body></html>"
|
||||
% (e(titre), CSS, qui, nav, contenu))
|
||||
self.envoyer(code, corps, extra=extra)
|
||||
|
||||
def erreur(self, user, code, msg, extra=()):
|
||||
titre = {400: "Demande à corriger", 403: "Accès refusé", 404: "Page introuvable"}.get(code, "Action indisponible")
|
||||
self.page(titre, "<h1>%s</h1><p class='info'>%s</p><p><a class='bouton' href='/'>Retour au panneau</a></p>"
|
||||
% (titre, e(msg)), user, code, extra)
|
||||
|
||||
def refuser_hors_lan(self):
|
||||
if connexion.est_locale(self.ip()):
|
||||
return False
|
||||
self.envoyer(403, "Accès refusé", "text/plain; charset=utf-8")
|
||||
return True
|
||||
|
||||
def origine_ok(self):
|
||||
o = self.headers.get("Origin") or self.headers.get("Referer") or ""
|
||||
return urlparse(o).netloc == self.headers.get("Host", "x")
|
||||
|
||||
def gestionnaire(self, user):
|
||||
"""L'utilisateur s'il a le droit d'utiliser le panneau, sinon Refus (rôles revérifiés à chaque requête)."""
|
||||
if user is None:
|
||||
raise Refus("connexion requise")
|
||||
if not roles.peut(self.app.forum.roles_de(user), "gerer_roles"):
|
||||
raise Refus("réservé au Propriétaire et au Propriétaire adjoint")
|
||||
return user
|
||||
|
||||
# --- connexion Gastinel ----------------------------------------------
|
||||
def connexion_depart(self, user):
|
||||
r = self.app.reglages
|
||||
if not r.configuree:
|
||||
return self.erreur(user, 503, "La connexion avec Gastinel n'est pas configurée")
|
||||
verifier, challenge = connexion.pkce()
|
||||
etat = connexion.nouvel_etat()
|
||||
self.app.forum.noter_etat(etat, verifier)
|
||||
self.rediriger(connexion.url_autorisation(r, etat, challenge), [self.ck(ETAT, etat, ETAT_MINUTES * 60)])
|
||||
|
||||
def connexion_retour(self, q):
|
||||
f, r = self.app.forum, self.app.reglages
|
||||
efface = self.ck(ETAT, "", 0)
|
||||
if not r.configuree:
|
||||
return self.erreur(None, 503, "La connexion avec Gastinel n'est pas configurée")
|
||||
if "error" in q:
|
||||
return self.erreur(None, 400, "Connexion annulée", [efface])
|
||||
etat, code = q.get("state", [""])[0], q.get("code", [""])[0]
|
||||
du_navigateur = self.cookie(ETAT) or ""
|
||||
if (not etat or not du_navigateur or len(etat) > 200
|
||||
or not hmac.compare_digest(etat.encode("utf-8"), du_navigateur.encode("utf-8"))):
|
||||
return self.erreur(None, 400, "Demande de connexion invalide ou expirée, recommence", [efface])
|
||||
verifier = f.prendre_etat(etat)
|
||||
if not verifier or not code or len(code) > 512:
|
||||
return self.erreur(None, 400, "Demande de connexion invalide ou expirée, recommence", [efface])
|
||||
try:
|
||||
jeton = connexion.echanger_code(r, code, verifier)
|
||||
ident, pseudo = connexion.lire_profil(r, jeton)
|
||||
except connexion.ErreurHub:
|
||||
return self.erreur(None, 502, "Le compte Gastinel n'a pas pu être vérifié, réessaie plus tard", [efface])
|
||||
if f.proprietaire_id and ident == f.proprietaire_id:
|
||||
user = f.connexion_gastinel(ident, pseudo)
|
||||
else:
|
||||
user = f.utilisateur_existant(ident) # pas d'inscription par le panneau
|
||||
if user is None or not roles.peut(f.roles_de(user), "gerer_roles"):
|
||||
return self.erreur(None, 403, "Ce compte n'a pas accès au panneau", [efface])
|
||||
ancien = self.jeton_session()
|
||||
if ancien:
|
||||
f.fermer_session(ancien, PORTEE)
|
||||
self.rediriger("/", [efface, self.ck(SESSION, f.ouvrir_session(user, SESSION_JOURS, PORTEE), SESSION_JOURS * 86400)])
|
||||
|
||||
# --- pages ------------------------------------------------------------
|
||||
def accueil(self, user):
|
||||
if user is None:
|
||||
action = (server.BOUTON_GASTINEL if self.app.reglages.configuree
|
||||
else "<p class='info'>La connexion Gastinel doit être configurée avant d’utiliser le panneau.</p>")
|
||||
return self.page("Connexion", "<h1>Panneau du forum</h1><section class='boite'><h2>Accès de gestion</h2>"
|
||||
"<p>Connecte-toi avec le compte Gastinel du Propriétaire ou du Propriétaire adjoint.</p>"
|
||||
"%s</section>" % action, None)
|
||||
f = self.app.forum
|
||||
self.gestionnaire(user)
|
||||
cartes = (
|
||||
("/adhesions", "Demandes d’adhésion", len(f.demandes_adhesion(user)), "à examiner"),
|
||||
("/stations", "Sujets de station", len(f.en_attente(user)), "à valider"),
|
||||
("/signalements", "Signalements", len(f.signalements(user)), "reçus"),
|
||||
("/utilisateurs", "Comptes et rôles", len(f.tous_les_utilisateurs(user)), "comptes"),
|
||||
)
|
||||
grille = "".join("<a class='fiche' href='%s'><h2>%s</h2><p class='meta'>%d %s</p></a>"
|
||||
% (url, nom, nombre, libelle) for url, nom, nombre, libelle in cartes)
|
||||
self.page("Vue d’ensemble", "<h1>Panneau du forum</h1><p class='chapeau'>Retrouve les demandes, les signalements "
|
||||
"et les rôles des comptes Gastinel inscrits au forum.</p><div class='grille'>%s</div>" % grille, user)
|
||||
|
||||
def utilisateurs(self, user):
|
||||
self.gestionnaire(user)
|
||||
filtre = parse_qs(urlparse(self.path).query).get("q", [""])[0].strip()[:80]
|
||||
self.page("Comptes et rôles", "<h1>Comptes et rôles</h1><p class='chapeau'>Retrouve un compte puis ouvre sa fiche. "
|
||||
"Le rôle Propriétaire est défini dans la configuration. Seul le Propriétaire peut nommer son adjoint.</p>%s"
|
||||
% server.gestion_roles(self.app.forum, user, filtre, self.champ_csrf()), user)
|
||||
|
||||
def adhesions(self, user):
|
||||
self.gestionnaire(user)
|
||||
self.page("Adhésions", "<h1>Demandes d’adhésion</h1><p class='chapeau'>Relis les présentations et leurs photos avant de décider.</p>%s"
|
||||
% server.demandes_html(self.app.forum, user, self.champ_csrf()), user)
|
||||
|
||||
def stations(self, user):
|
||||
self.gestionnaire(user)
|
||||
self.page("Stations à valider", "<h1>Sujets de station à valider</h1>"
|
||||
"<p class='chapeau'>Vérifie la présentation avant publication sur le forum.</p>%s"
|
||||
% server.stations_html(self.app.forum, user, csrf=self.champ_csrf()), user)
|
||||
|
||||
def signalements(self, user):
|
||||
self.gestionnaire(user)
|
||||
self.page("Signalements", "<h1>Signalements</h1><p class='chapeau'>Retrouve le contexte du message sur le forum. "
|
||||
"Les actions de modération s’effectuent depuis la discussion.</p>%s"
|
||||
% server.signalements_html(self.app.forum, user, SUJET_PUBLIC), user)
|
||||
|
||||
def photo_adhesion(self, user, nom):
|
||||
self.gestionnaire(user)
|
||||
if not PHOTO_OK.match(nom):
|
||||
return self.envoyer(404, "introuvable", "text/plain; charset=utf-8")
|
||||
with open(self.app.forum.photo_adhesion(user, nom), "rb") as fh:
|
||||
self.envoyer(200, fh.read(), TYPES_IMG[nom.rsplit(".", 1)[1]])
|
||||
|
||||
# --- GET / POST ---------------------------------------------------------
|
||||
def do_GET(self):
|
||||
if self.refuser_hors_lan():
|
||||
return
|
||||
u = urlparse(self.path)
|
||||
user = self.utilisateur()
|
||||
if u.path.startswith("/polices/"):
|
||||
return server.servir_police(self, u.path)
|
||||
try:
|
||||
if u.path == "/connexion/gastinel":
|
||||
return self.connexion_depart(user)
|
||||
if u.path == "/connexion/retour":
|
||||
return self.connexion_retour(parse_qs(u.query))
|
||||
routes = {"/": self.accueil, "/utilisateurs": self.utilisateurs, "/adhesions": self.adhesions,
|
||||
"/stations": self.stations, "/signalements": self.signalements}
|
||||
if u.path in routes:
|
||||
return routes[u.path](user)
|
||||
m = re.fullmatch(r"/adhesion-photo/([^/]+)", u.path)
|
||||
if m:
|
||||
return self.photo_adhesion(user, m.group(1))
|
||||
self.erreur(user, 404, "Page introuvable")
|
||||
except Refus as ex:
|
||||
self.erreur(user, 403, "Accès réservé : %s" % ex)
|
||||
except Invalide as ex:
|
||||
self.erreur(user, 404, str(ex))
|
||||
|
||||
def lire_formulaire(self):
|
||||
try:
|
||||
n = int(self.headers.get("Content-Length") or 0)
|
||||
except ValueError:
|
||||
raise Invalide("longueur de requête invalide")
|
||||
if n < 0 or n > FORMULAIRE_MAX:
|
||||
raise Invalide("requête invalide")
|
||||
return {k: v[0] for k, v in parse_qs(self.rfile.read(n).decode("utf-8", "replace")).items()}
|
||||
|
||||
def do_POST(self):
|
||||
if self.refuser_hors_lan():
|
||||
return
|
||||
user = self.utilisateur()
|
||||
f = self.app.forum
|
||||
if not self.origine_ok():
|
||||
return self.erreur(user, 403, "Origine refusée")
|
||||
try:
|
||||
d = self.lire_formulaire()
|
||||
if user is None:
|
||||
raise Refus("connexion requise")
|
||||
if not hmac.compare_digest(d.get("csrf", "").encode("utf-8"), self.csrf().encode("ascii")):
|
||||
raise Refus("jeton CSRF invalide, recharge la page")
|
||||
if self.path == "/deconnexion":
|
||||
f.fermer_session(self.jeton_session(), PORTEE)
|
||||
return self.rediriger("/", [self.ck(SESSION, "", 0)])
|
||||
self.gestionnaire(user)
|
||||
if self.path == "/role":
|
||||
action = {"donner": f.donner_role, "retirer": f.retirer_role}.get(d.get("action"))
|
||||
if action is None:
|
||||
raise Invalide("Choisis une action pour le rôle.")
|
||||
action(user, d.get("hub_id", ""), d.get("role", ""), d.get("station", ""))
|
||||
return self.rediriger("/utilisateurs")
|
||||
if self.path == "/adhesion/decider":
|
||||
f.decider_adhesion(user, int(d.get("demande", "0")), d.get("ok") == "1")
|
||||
return self.rediriger("/adhesions")
|
||||
if self.path == "/valider":
|
||||
f.valider_sujet(user, int(d.get("sujet", "0")), d.get("ok") == "1")
|
||||
return self.rediriger("/stations")
|
||||
self.erreur(user, 404, "Page introuvable")
|
||||
except Refus as ex:
|
||||
self.erreur(user, 403, "Non autorisé : %s" % ex)
|
||||
except (Invalide, ValueError) as ex:
|
||||
self.erreur(user, 400, str(ex))
|
||||
|
||||
|
||||
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)
|
||||
|
||||
|
||||
def main():
|
||||
ici = os.path.dirname(os.path.abspath(__file__))
|
||||
ap = argparse.ArgumentParser(description="Panneau de gestion du forum (réseau local, Propriétaire et adjoint)")
|
||||
ap.add_argument("--db", default=os.path.join(ici, "forum-local.sqlite3"), help="la même base que le forum")
|
||||
ap.add_argument("--photos", default=os.path.join(ici, "photos-local"), help="le même dossier de photos que le forum")
|
||||
ap.add_argument("--port", type=int, default=8790)
|
||||
ap.add_argument("--hote", default="0.0.0.0", help="adresse d'écoute (défaut 0.0.0.0 ; les IP hors LAN reçoivent 403)")
|
||||
a = ap.parse_args()
|
||||
reglages = connexion.Reglages.depuis_env()
|
||||
reglages.redirect_uri = os.environ.get("FORUM_PANNEAU_REDIRECT_URI") or "http://localhost:%d/connexion/retour" % a.port
|
||||
f = Forum(a.db, stations=server.charger_stations() or {"geve": "Gêve"}, dossier_photos=a.photos,
|
||||
proprietaire_id=os.environ.get("FORUM_PROPRIETAIRE_ID"))
|
||||
f.apres_roles = lambda h, rs: connexion.pousser_roles(reglages, h, rs) # rôles affichés sur la page du compte Gastinel
|
||||
s = creer_serveur(f, a.port, a.hote, reglages)
|
||||
print("Panneau : http://%s:%d (réseau local seulement ; connexion Gastinel %s, retour %s)" % (
|
||||
a.hote, a.port, "configurée" if reglages.configuree else "NON configurée : FORUM_HUB_URL manquant", reglages.redirect_uri))
|
||||
s.serve_forever()
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,86 @@
|
||||
"""Photos jointes aux messages : type vérifié par le contenu, métadonnées retirées (position GPS, appareil, date).
|
||||
|
||||
Bibliothèque standard seulement. JPEG, PNG et WebP. Tout autre contenu est refusé.
|
||||
"""
|
||||
import struct
|
||||
|
||||
TYPES = {"image/jpeg": ".jpg", "image/png": ".png", "image/webp": ".webp"}
|
||||
|
||||
|
||||
class PhotoInvalide(ValueError):
|
||||
pass
|
||||
|
||||
|
||||
def type_reel(data):
|
||||
if data[:3] == b"\xff\xd8\xff":
|
||||
return "image/jpeg"
|
||||
if data[:8] == b"\x89PNG\r\n\x1a\n":
|
||||
return "image/png"
|
||||
if data[:4] == b"RIFF" and data[8:12] == b"WEBP":
|
||||
return "image/webp"
|
||||
raise PhotoInvalide("format non accepté (JPEG, PNG ou WebP)")
|
||||
|
||||
|
||||
def _jpeg(data):
|
||||
"""Retire les segments APP1 (EXIF, XMP, dont la position GPS), APP13 (IPTC) et les commentaires."""
|
||||
out, i = bytearray(b"\xff\xd8"), 2
|
||||
while i < len(data):
|
||||
if data[i] != 0xFF:
|
||||
raise PhotoInvalide("JPEG abîmé")
|
||||
marqueur = data[i + 1]
|
||||
if marqueur == 0xD9: # fin d'image
|
||||
out += data[i:i + 2]
|
||||
return bytes(out)
|
||||
if 0xD0 <= marqueur <= 0xD7 or marqueur == 0x01:
|
||||
out += data[i:i + 2]
|
||||
i += 2
|
||||
continue
|
||||
if i + 4 > len(data):
|
||||
raise PhotoInvalide("JPEG abîmé")
|
||||
longueur = struct.unpack(">H", data[i + 2:i + 4])[0]
|
||||
segment = data[i:i + 2 + longueur]
|
||||
if marqueur == 0xDA: # début des données d'image : tout le reste est gardé tel quel
|
||||
out += data[i:]
|
||||
return bytes(out)
|
||||
if marqueur not in (0xE1, 0xED, 0xFE): # APP1, APP13, COM retirés
|
||||
out += segment
|
||||
i += 2 + longueur
|
||||
raise PhotoInvalide("JPEG incomplet")
|
||||
|
||||
|
||||
def _png(data):
|
||||
"""Retire les blocs eXIf, tEXt, iTXt, zTXt et tIME."""
|
||||
out, i = bytearray(data[:8]), 8
|
||||
while i + 12 <= len(data):
|
||||
longueur = struct.unpack(">I", data[i:i + 4])[0]
|
||||
nom = data[i + 4:i + 8]
|
||||
bloc = data[i:i + 12 + longueur]
|
||||
if nom not in (b"eXIf", b"tEXt", b"iTXt", b"zTXt", b"tIME"):
|
||||
out += bloc
|
||||
i += 12 + longueur
|
||||
if nom == b"IEND":
|
||||
return bytes(out)
|
||||
raise PhotoInvalide("PNG incomplet")
|
||||
|
||||
|
||||
def _webp(data):
|
||||
"""Retire les blocs EXIF et XMP et remet à jour l'en-tête."""
|
||||
out, i = bytearray(), 12
|
||||
while i + 8 <= len(data):
|
||||
nom = data[i:i + 4]
|
||||
longueur = struct.unpack("<I", data[i + 4:i + 8])[0]
|
||||
bloc = data[i:i + 8 + longueur + (longueur & 1)]
|
||||
if nom == b"VP8X":
|
||||
bloc = bytearray(bloc)
|
||||
bloc[8] &= ~0x0C & 0xFF # drapeaux EXIF (0x08) et XMP (0x04) retirés
|
||||
bloc = bytes(bloc)
|
||||
if nom not in (b"EXIF", b"XMP "):
|
||||
out += bloc
|
||||
i += 8 + longueur + (longueur & 1)
|
||||
return b"RIFF" + struct.pack("<I", 4 + len(out)) + b"WEBP" + bytes(out)
|
||||
|
||||
|
||||
def nettoyer(data):
|
||||
"""Retourne (type, octets sans métadonnées)."""
|
||||
mime = type_reel(data)
|
||||
return mime, {"image/jpeg": _jpeg, "image/png": _png, "image/webp": _webp}[mime](data)
|
||||
Fichier binaire non affiché.
Fichier binaire non affiché.
@@ -0,0 +1,209 @@
|
||||
"""Profil public du forum : username, noms bloqués, biographie, avatars illustrés, réglages des mails.
|
||||
|
||||
Décisions de Théo du 06/11/2026 (09-Forum/Bienvenue-et-profil.md). Bibliothèque standard seulement.
|
||||
"""
|
||||
import html
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import unicodedata
|
||||
|
||||
USERNAME_MIN, USERNAME_MAX = 5, 20
|
||||
SPECIAUX = ".@-_!?¿"
|
||||
BIO_MAX = 1000
|
||||
CHANGEMENT_JOURS = 30 # un changement de username tous les 30 jours
|
||||
PHOTO_MAX = 5 * 1024 * 1024 # photo de profil : 5 Mo au plus
|
||||
|
||||
AVATARS = {"brume": "Dans la brume", "neige": "Sous la neige", "station": "La station au soleil"}
|
||||
AVATAR_DEFAUT = "brume"
|
||||
|
||||
# Réglages des mails (enregistrés seulement : l'envoi n'est pas encore codé).
|
||||
# (clé, libellé, actif par défaut, [(clé, libellé, actif par défaut)])
|
||||
NOTIFS = (
|
||||
("posts", "Posts", True, (("reponse_sujet", "Réponse à ton sujet", True), ("reponse_post", "Réponse à ton post", True),
|
||||
("reponse_reponse", "Réponse à ta réponse", False), ("reactions", "Réactions", False))),
|
||||
("autre", "Autre", True, (("bulletin", "Bulletin de la semaine", True), ("nouveautes", "Nouveautés du forum", False),
|
||||
("station", "Nouvelle station", False))),
|
||||
)
|
||||
|
||||
|
||||
class UsernameInvalide(ValueError):
|
||||
pass
|
||||
|
||||
|
||||
# --- noms bloqués -------------------------------------------------------------
|
||||
_LEET = str.maketrans({"0": "o", "1": "i", "3": "e", "4": "a", "5": "s", "7": "t", "@": "a", "$": "s", "!": "i"})
|
||||
|
||||
|
||||
def _latin_ou_chiffre(c):
|
||||
"""Chiffre 0-9 ou lettre de l'alphabet latin (accents compris) : bloque les sosies cyrilliques ou grecs."""
|
||||
if "0" <= c <= "9":
|
||||
return True
|
||||
return c.isalpha() and unicodedata.name(c, "").startswith("LATIN ")
|
||||
|
||||
|
||||
def cle(texte):
|
||||
"""Minuscules, sans accents, lettres et chiffres seulement (séparateurs retirés)."""
|
||||
s = unicodedata.normalize("NFKD", (texte or "").casefold())
|
||||
return "".join(c for c in s if c.isalnum() and not unicodedata.combining(c))
|
||||
|
||||
|
||||
def charger_bloques(chemin=None):
|
||||
"""noms_bloques.txt -> (réservés : refusés même au milieu d'un mot, mots grossiers)."""
|
||||
chemin = chemin or os.path.join(os.path.dirname(os.path.abspath(__file__)), "noms_bloques.txt")
|
||||
reserves, mots, partie = set(), set(), 1
|
||||
try:
|
||||
with open(chemin, encoding="utf-8") as fh:
|
||||
for ligne in fh:
|
||||
ligne = ligne.strip()
|
||||
if ligne.startswith("#"):
|
||||
if "Partie 2" in ligne:
|
||||
partie = 2
|
||||
continue
|
||||
k = cle(ligne)
|
||||
if k:
|
||||
(reserves if partie == 1 else mots).add(k)
|
||||
except OSError:
|
||||
pass
|
||||
reserves |= {"admin", "moderateur", "meteovercors", "direction", "gastinel"} # même sans le fichier
|
||||
return frozenset(reserves), frozenset(mots)
|
||||
|
||||
|
||||
RESERVES, MOTS = charger_bloques()
|
||||
|
||||
|
||||
def est_bloque(username, reserves=None, mots=None):
|
||||
"""Vrai si le username contient un nom réservé ou un mot grossier, à l'endroit, à l'envers,
|
||||
sans séparateurs ni accents, et en remplaçant les chiffres par des lettres (adm1n, 4dmin)."""
|
||||
reserves = RESERVES if reserves is None else reserves
|
||||
mots = MOTS if mots is None else mots
|
||||
for base in {cle(username), cle(username.casefold().translate(_LEET))}:
|
||||
for s in (base, base[::-1]):
|
||||
if not s:
|
||||
continue
|
||||
if any(r in s for r in reserves):
|
||||
return True
|
||||
# mots courts (con, cul) : seulement le mot entier, pour ne pas bloquer « contamines » ou « habite »
|
||||
if any(m == s or (len(m) >= 6 and m in s) for m in mots):
|
||||
return True
|
||||
return False
|
||||
|
||||
|
||||
def verifier_username(brut):
|
||||
"""Retourne le username (NFC) ou lève UsernameInvalide avec ce qui ne va pas."""
|
||||
u = unicodedata.normalize("NFC", brut or "")
|
||||
if any(c.isspace() for c in u):
|
||||
raise UsernameInvalide("Pas d'espace dans le username.")
|
||||
if len(u) < USERNAME_MIN:
|
||||
raise UsernameInvalide("Trop court : %d caractères minimum." % USERNAME_MIN)
|
||||
if len(u) > USERNAME_MAX:
|
||||
raise UsernameInvalide("Trop long : %d caractères maximum." % USERNAME_MAX)
|
||||
mauvais = []
|
||||
for c in u:
|
||||
if not (_latin_ou_chiffre(c) or c in SPECIAUX) and c not in mauvais:
|
||||
mauvais.append(c)
|
||||
if mauvais:
|
||||
raise UsernameInvalide("Caractère non accepté : « %s ». Lettres, chiffres et . @ - _ ! ? ¿ seulement."
|
||||
% " ".join(c if c.isprintable() else "?" for c in mauvais))
|
||||
if not any(c.isalnum() for c in u):
|
||||
raise UsernameInvalide("Le username doit contenir au moins une lettre ou un chiffre.")
|
||||
if est_bloque(u):
|
||||
raise UsernameInvalide("Ce username est réservé. Choisis-en un autre.")
|
||||
return u
|
||||
|
||||
|
||||
def cle_unicite(username):
|
||||
"""Deux usernames qui ne diffèrent que par les majuscules sont le même."""
|
||||
return unicodedata.normalize("NFKC", username).casefold()
|
||||
|
||||
|
||||
# --- biographie ----------------------------------------------------------------
|
||||
_URL = re.compile(r"https?://[^\s<>\"'«»]+", re.I)
|
||||
|
||||
|
||||
def verifier_bio(texte):
|
||||
t = (texte or "").replace("\r\n", "\n").strip()
|
||||
if len(t) > BIO_MAX:
|
||||
raise ValueError("Biographie trop longue : %d caractères au plus." % BIO_MAX)
|
||||
if re.search(r"[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]", t):
|
||||
raise ValueError("Biographie : caractères de contrôle refusés.")
|
||||
return t
|
||||
|
||||
|
||||
def bio_html(texte):
|
||||
"""Texte simple échappé ; les adresses http(s) deviennent des liens (nofollow)."""
|
||||
out, i = [], 0
|
||||
for m in _URL.finditer(texte or ""):
|
||||
url = m.group(0).rstrip(".,;:!?)]")
|
||||
out.append(html.escape(texte[i:m.start()]))
|
||||
out.append("<a href='%s' rel='nofollow ugc noopener noreferrer'>%s</a>" % (html.escape(url, True), html.escape(url)))
|
||||
i = m.start() + len(url)
|
||||
out.append(html.escape((texte or "")[i:]))
|
||||
return "".join(out)
|
||||
|
||||
|
||||
# --- réglages des mails ----------------------------------------------------------
|
||||
def notifs_defaut():
|
||||
d = {}
|
||||
for cat, _, actif, subs in NOTIFS:
|
||||
d[cat] = actif
|
||||
for k, _, a in subs:
|
||||
d[cat + "." + k] = a
|
||||
return d
|
||||
|
||||
|
||||
def notifs_lire(texte):
|
||||
d = notifs_defaut()
|
||||
try:
|
||||
enreg = json.loads(texte) if texte else {}
|
||||
except ValueError:
|
||||
enreg = {}
|
||||
if isinstance(enreg, dict):
|
||||
d.update({k: bool(v) for k, v in enreg.items() if k in d})
|
||||
return d
|
||||
|
||||
|
||||
def notifs_du_formulaire(champs):
|
||||
"""Cases cochées du formulaire (notif_posts, notif_posts_reponse_sujet...) -> JSON."""
|
||||
d = {}
|
||||
for cat, _, _, subs in NOTIFS:
|
||||
d[cat] = champs.get("notif_" + cat) == "1"
|
||||
for k, _, _ in subs:
|
||||
d[cat + "." + k] = champs.get("notif_%s_%s" % (cat, k)) == "1"
|
||||
return json.dumps(d, sort_keys=True)
|
||||
|
||||
|
||||
# --- avatars illustrés (maquette validée par Théo) -------------------------------------
|
||||
_TETE = "M60 30c-11 0-19 9-19 21s8 21 19 21 19-9 19-21-8-21-19-21Z"
|
||||
_CORPS = "M22 120c2-26 17-41 38-41s36 15 38 41Z"
|
||||
|
||||
|
||||
def _silhouette(couleur, transform=""):
|
||||
t = " transform='%s'" % transform if transform else ""
|
||||
return "<g fill='%s'%s><path d='%s'/><path d='%s'/></g>" % (couleur, t, _TETE, _CORPS)
|
||||
|
||||
|
||||
_DESSINS = {
|
||||
"brume": ("<rect width='120' height='120' fill='#ece9e1'/>"
|
||||
"<g stroke='#cfcabd' stroke-width='5'><path d='M0 34h70M30 48h90M0 62h50'/></g>" + _silhouette("#8c938a")),
|
||||
"neige": ("<rect width='120' height='120' fill='#dcecef'/>"
|
||||
"<path d='M0 92 30 56l18 20 22-30 50 46v28H0Z' fill='#fff' stroke='#6eb5bd' stroke-width='2'/>"
|
||||
"<g fill='#6eb5bd'><circle cx='18' cy='20' r='2.5'/><circle cx='44' cy='12' r='2'/><circle cx='96' cy='22' r='2.5'/>"
|
||||
"<circle cx='104' cy='44' r='2'/><circle cx='14' cy='46' r='2'/></g>" + _silhouette("#1f4d3a")
|
||||
+ "<g fill='#6f8f5c'><path d='M40 47c1-14 9-22 20-22s19 8 20 22Z'/><rect x='38' y='44' width='44' height='7'/>"
|
||||
"<circle cx='60' cy='22' r='5'/></g>"),
|
||||
"station": ("<rect width='120' height='120' fill='#f1e3d6'/>"
|
||||
"<circle cx='94' cy='26' r='12' fill='none' stroke='#b5643c' stroke-width='3'/>"
|
||||
"<g stroke='#b5643c' stroke-width='3'><path d='M94 6v6M94 40v6M74 26h6M108 26h6'/></g>"
|
||||
"<g stroke='#1f4d3a' stroke-width='3' fill='none'><path d='M18 120V48M10 52h16M10 52l-3 6M26 52l3 6'/>"
|
||||
"<rect x='11' y='72' width='14' height='12' fill='#fff'/></g>" + _silhouette("#1f4d3a", "translate(12 0)")),
|
||||
}
|
||||
|
||||
|
||||
def svg_avatar(nom):
|
||||
"""Fichier SVG autonome d'un avatar illustré (servi en image/svg+xml)."""
|
||||
dessin = _DESSINS.get(nom)
|
||||
if dessin is None:
|
||||
return None
|
||||
return ("<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 120 120' width='120' height='120'>"
|
||||
"<title>%s</title>%s</svg>" % (html.escape(AVATARS[nom]), dessin))
|
||||
@@ -0,0 +1,34 @@
|
||||
"""Purge de conservation du forum (RGPD) : à lancer chaque jour (timer systemd), sans danger si relancée.
|
||||
|
||||
python purge.py --db chemin/forum.sqlite3 (ou : cd forum && python -m purge --db ...)
|
||||
|
||||
Efface : les IP de plus de 12 mois (posts, comments et toute table avec une colonne ip), les lectures des comptes
|
||||
supprimés, les brouillons non modifiés depuis 30 jours, les signalements traités (message ou commentaire masqué)
|
||||
vieux de 12 mois, les sessions expirées. Journal : une ligne sur la sortie standard.
|
||||
"""
|
||||
import argparse
|
||||
import os
|
||||
import sys
|
||||
|
||||
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
|
||||
from forum import Forum # noqa: E402
|
||||
|
||||
|
||||
def main(argv=None):
|
||||
ici = os.path.dirname(os.path.abspath(__file__))
|
||||
ap = argparse.ArgumentParser(description="Purge de conservation du forum")
|
||||
ap.add_argument("--db", default=os.path.join(ici, "forum-local.sqlite3"))
|
||||
ap.add_argument("--mois-ip", type=int, default=12)
|
||||
ap.add_argument("--jours-brouillons", type=int, default=30)
|
||||
ap.add_argument("--mois-signalements", type=int, default=12)
|
||||
a = ap.parse_args(argv)
|
||||
if a.db != ":memory:" and not os.path.exists(a.db):
|
||||
print("purge : base introuvable (%s)" % a.db, file=sys.stderr)
|
||||
return 1
|
||||
r = Forum(a.db).purger(a.mois_ip, a.jours_brouillons, a.mois_signalements)
|
||||
print("purge forum : " + ", ".join("%s=%d" % kv for kv in r.items()))
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
@@ -0,0 +1,89 @@
|
||||
// Réactions sous les messages : envoi en fetch sans recharger la page, avec les animations de la maquette.
|
||||
// Facultatif : sans JavaScript, le formulaire POST /reagir marche seul (retour à l'ancre du message).
|
||||
document.querySelectorAll("form.reactions").forEach(function (form) {
|
||||
var menu = form.querySelector("details.reac-menu");
|
||||
var occupe = false;
|
||||
|
||||
function rejouer(el, classe) {
|
||||
el.classList.remove(classe);
|
||||
void el.offsetWidth;
|
||||
el.classList.add(classe);
|
||||
}
|
||||
|
||||
function bouton(k) {
|
||||
var b = form.querySelector(":scope > .reac[data-k='" + k + "']");
|
||||
if (b) return b;
|
||||
var modele = form.querySelector(".reac-choix .reac[data-k='" + k + "']");
|
||||
b = document.createElement("button");
|
||||
b.className = "reac";
|
||||
b.name = "reaction";
|
||||
b.value = k;
|
||||
b.dataset.k = k;
|
||||
b.appendChild(modele.querySelector("svg").cloneNode(true));
|
||||
var s = document.createElement("span");
|
||||
s.textContent = "0";
|
||||
b.appendChild(s);
|
||||
form.insertBefore(b, menu);
|
||||
return b;
|
||||
}
|
||||
|
||||
// Applique l'état renvoyé par le serveur : compteurs, noms au survol, réaction choisie.
|
||||
function appliquer(etat) {
|
||||
var vus = {};
|
||||
etat.liste.forEach(function (r) {
|
||||
vus[r.k] = true;
|
||||
var b = bouton(r.k), s = b.lastChild;
|
||||
var on = r.k === etat.mien, avant = b.getAttribute("aria-pressed") === "true";
|
||||
b.classList.remove("sort");
|
||||
b.title = r.titre;
|
||||
b.setAttribute("aria-label", r.label);
|
||||
b.setAttribute("aria-pressed", on ? "true" : "false");
|
||||
if (s.textContent !== String(r.n)) {
|
||||
s.textContent = r.n;
|
||||
rejouer(s, "bump");
|
||||
}
|
||||
if (on && !avant) rejouer(b, "pop");
|
||||
});
|
||||
form.querySelectorAll(":scope > .reac").forEach(function (b) {
|
||||
if (vus[b.dataset.k]) return;
|
||||
b.setAttribute("aria-pressed", "false");
|
||||
b.lastChild.textContent = "0";
|
||||
rejouer(b.lastChild, "bump");
|
||||
b.classList.add("sort");
|
||||
setTimeout(function () { if (b.classList.contains("sort")) b.remove(); }, 250);
|
||||
});
|
||||
// garde l'ordre des six réactions
|
||||
form.querySelectorAll(".reac-choix .reac").forEach(function (c) {
|
||||
var b = form.querySelector(":scope > .reac[data-k='" + c.dataset.k + "']");
|
||||
if (b) form.insertBefore(b, menu);
|
||||
});
|
||||
}
|
||||
|
||||
form.addEventListener("submit", function (ev) {
|
||||
var b = ev.submitter;
|
||||
if (!b || !b.value || !window.fetch) return;
|
||||
ev.preventDefault();
|
||||
if (occupe) return;
|
||||
occupe = true;
|
||||
var corps = new URLSearchParams();
|
||||
corps.set("post", form.dataset.post);
|
||||
corps.set("reaction", b.value);
|
||||
if (menu) menu.open = false;
|
||||
fetch(form.action, {method: "POST", body: corps, credentials: "same-origin",
|
||||
headers: {"Accept": "application/json"}})
|
||||
.then(function (r) {
|
||||
if (!r.ok) throw new Error(r.status);
|
||||
return r.json();
|
||||
})
|
||||
.then(appliquer)
|
||||
.catch(function () { // session échue, erreur : on repasse par le formulaire classique
|
||||
var champ = document.createElement("input");
|
||||
champ.type = "hidden";
|
||||
champ.name = "reaction";
|
||||
champ.value = b.value;
|
||||
form.appendChild(champ);
|
||||
form.submit();
|
||||
})
|
||||
.then(function () { occupe = false; });
|
||||
});
|
||||
});
|
||||
+71
-25
@@ -1,33 +1,79 @@
|
||||
"""Rôles et droits du forum. Aucune dépendance."""
|
||||
"""Rôles et droits du forum (décision de Théo du 04/11/2026). Aucune dépendance.
|
||||
|
||||
VISITEUR, MEMBRE, ADHERENT, MODERATEUR, ADMIN = (
|
||||
"visiteur", "membre", "adherent", "moderateur", "admin")
|
||||
ORDRE = [VISITEUR, MEMBRE, ADHERENT, MODERATEUR, ADMIN]
|
||||
Les rôles se cumulent. Tout compte connecté est « membre » ; les autres rôles s'ajoutent :
|
||||
adhérent météo, modérateur, propriétaire, propriétaire adjoint, propriétaire de station (lié à une station).
|
||||
Exemple : le père de Théo est propriétaire adjoint + modérateur, sans être adhérent.
|
||||
Un visiteur (non connecté) n'a aucun rôle : il lit seulement.
|
||||
"""
|
||||
|
||||
# Droit -> rôle minimal
|
||||
MEMBRE = "membre"
|
||||
ADHERENT = "adherent"
|
||||
MODERATEUR = "moderateur"
|
||||
PROPRIETAIRE = "proprietaire"
|
||||
ADJOINT = "proprietaire_adjoint"
|
||||
STATION = "proprietaire_station"
|
||||
|
||||
LIBELLES = {
|
||||
PROPRIETAIRE: "Propriétaire",
|
||||
ADJOINT: "Propriétaire adjoint",
|
||||
MODERATEUR: "Modérateur",
|
||||
ADHERENT: "Adhérent météo",
|
||||
STATION: "Propriétaire de station",
|
||||
MEMBRE: "Membre",
|
||||
}
|
||||
# ordre d'affichage des badges
|
||||
ORDRE_BADGES = [PROPRIETAIRE, ADJOINT, MODERATEUR, ADHERENT, STATION, MEMBRE]
|
||||
|
||||
# Rôles qu'on peut donner depuis le panneau (« propriétaire » est fixé par la configuration, jamais par l'interface)
|
||||
ATTRIBUABLES = (ADHERENT, MODERATEUR, ADJOINT, STATION)
|
||||
|
||||
# Décision de Théo : un modérateur non adhérent ne crée PAS de sujet ; il modère et répond.
|
||||
MODERATEUR_CREE_SUJETS = False
|
||||
|
||||
PROPRIOS = {PROPRIETAIRE, ADJOINT}
|
||||
_CREATEURS = {ADHERENT} | PROPRIOS | ({MODERATEUR} if MODERATEUR_CREE_SUJETS else set())
|
||||
|
||||
# Droit -> ensemble des rôles qui l'ont. None = tout le monde, même un visiteur.
|
||||
DROITS = {
|
||||
"lire": VISITEUR,
|
||||
"repondre": MEMBRE,
|
||||
"signaler": MEMBRE,
|
||||
"modifier_son_message": MEMBRE,
|
||||
"creer_sujet": ADHERENT, # peut être relevé par catégorie (voir db)
|
||||
"masquer": MODERATEUR,
|
||||
"verrouiller": MODERATEUR,
|
||||
"voir_masques": MODERATEUR,
|
||||
"voir_signalements": MODERATEUR,
|
||||
"changer_role": ADMIN,
|
||||
"gerer_categories": ADMIN,
|
||||
"lire": None,
|
||||
"repondre": {MEMBRE},
|
||||
"signaler": {MEMBRE},
|
||||
"commenter": {MEMBRE}, # commentaires courts sous une réponse (profils privés compris)
|
||||
"reagir": {MEMBRE}, # réactions sous un message (une par membre et par message)
|
||||
"modifier_son_message": {MEMBRE},
|
||||
"creer_sujet": _CREATEURS,
|
||||
"publier_bulletin": _CREATEURS, # écrire dans un sujet fermé aux réponses (Bulletin de la semaine)
|
||||
"creer_sujet_station": {STATION},
|
||||
"valider_sujet": PROPRIOS,
|
||||
"epingler": PROPRIOS, # décision de Théo : pas les modérateurs
|
||||
"epingler_photo_fiche": PROPRIOS | {STATION}, # propriétaire de station : seulement pour SA station
|
||||
"demander_adhesion": {MEMBRE},
|
||||
"valider_adhesion": PROPRIOS,
|
||||
"masquer": {MODERATEUR} | PROPRIOS,
|
||||
"verrouiller": {MODERATEUR} | PROPRIOS,
|
||||
"voir_masques": {MODERATEUR} | PROPRIOS,
|
||||
"voir_signalements": {MODERATEUR} | PROPRIOS,
|
||||
"gerer_roles": PROPRIOS,
|
||||
"photos_illimitees": PROPRIOS,
|
||||
"supprimer": PROPRIOS, # suppression définitive (message, commentaire, sujet) : Théo et son père
|
||||
}
|
||||
|
||||
|
||||
def niveau(role):
|
||||
if role not in ORDRE:
|
||||
raise ValueError("rôle inconnu : %r" % (role,))
|
||||
return ORDRE.index(role)
|
||||
|
||||
|
||||
def peut(role, droit, role_min=None):
|
||||
"""Vrai si `role` a `droit`. `role_min` remplace le minimum par défaut."""
|
||||
def peut(roles_utilisateur, droit):
|
||||
"""Vrai si l'ensemble de rôles donné a ce droit. `roles_utilisateur` vaut None pour un visiteur."""
|
||||
if droit not in DROITS:
|
||||
raise ValueError("droit inconnu : %r" % (droit,))
|
||||
return niveau(role) >= niveau(role_min or DROITS[droit])
|
||||
autorises = DROITS[droit]
|
||||
if autorises is None:
|
||||
return True
|
||||
return bool(roles_utilisateur) and bool(set(roles_utilisateur) & autorises)
|
||||
|
||||
|
||||
def peut_donner(roles_acteur, role):
|
||||
"""Qui peut attribuer quoi : seul le propriétaire nomme un propriétaire adjoint ;
|
||||
propriétaire et adjoint donnent les autres rôles. Personne ne donne « propriétaire »."""
|
||||
if role not in ATTRIBUABLES:
|
||||
return False
|
||||
if role == ADJOINT:
|
||||
return PROPRIETAIRE in (roles_acteur or ())
|
||||
return peut(roles_acteur, "gerer_roles")
|
||||
+2008
-175
Diff désactivé car ce fichier est trop long.
Voir la Diff
@@ -0,0 +1,20 @@
|
||||
{
|
||||
"autrans": "Autrans – L'Escandille",
|
||||
"geve": "Autrans – Gêve nordique",
|
||||
"engins": "Engins",
|
||||
"meaudre": "Méaudre",
|
||||
"lans": "Lans-en-Vercors – village",
|
||||
"bruyeres": "Lans-en-Vercors – Les Bruyères",
|
||||
"allieres": "Lans-en-Vercors – Les Allières",
|
||||
"villard": "Villard-de-Lans – Payonère",
|
||||
"moucherolle": "Crête de la Moucherolle",
|
||||
"chapelle": "La Chapelle-en-Vercors – Les Finets",
|
||||
"oscence": "Combe de l'Oscence",
|
||||
"darbounouse": "Combe de Darbounouse",
|
||||
"rousset": "Col du Rousset – plateau de Beurre",
|
||||
"gresse": "Gresse-en-Vercors",
|
||||
"st-jean": "Saint-Jean-en-Royans",
|
||||
"die": "Die",
|
||||
"st-julien-q": "Saint-Julien-en-Quint",
|
||||
"archiane": "Cirque d'Archiane"
|
||||
}
|
||||
Seulement les espaces.
@@ -0,0 +1,148 @@
|
||||
"""Sujets de station d'office, pastille « Nouveau », tri, encadré station (demandes de Théo du 06/11/2026)."""
|
||||
import json
|
||||
import os
|
||||
import time
|
||||
|
||||
import test_forum as base
|
||||
import server
|
||||
from forum import Invalide, Refus
|
||||
|
||||
|
||||
class TestAmeliorations(base.BaseHTTP):
|
||||
def test_sujets_de_station_crees_puis_repris(self):
|
||||
self.assertEqual(self.f.creer_sujets_stations(), 2)
|
||||
self.assertEqual(self.f.creer_sujets_stations(), 0) # une seule fois
|
||||
stations = {t["station"]: t for t in self.f.sujets(None) if t["station"]}
|
||||
self.assertEqual(set(stations), {"geve", "oscence"})
|
||||
tid = stations["geve"]["id"]
|
||||
self.assertEqual(self.f.fiche_station("geve")["sujet"], tid) # lien de la carte
|
||||
page = self.req("/t/%d" % tid)[2].decode()
|
||||
self.assertIn("Aucun message n'a encore été publié ici.", page)
|
||||
self.assertIn("https://vercors.me/#station=geve", page)
|
||||
liste = self.req("/")[2].decode()
|
||||
self.assertIn("Météo Vercors", liste)
|
||||
self.assertNotIn("Par vercors.me", liste)
|
||||
# le propriétaire reprend le sujet avec sa présentation, sans nouvelle validation
|
||||
self.assertEqual(self.f.creer_sujet_station(self.prop, "geve", "Ma station"), tid)
|
||||
t, msgs = self.f.sujet(None, tid)
|
||||
self.assertEqual((t["author_id"], msgs[0]["body"]), (self.prop["id"], "Ma station"))
|
||||
with self.assertRaises(Invalide):
|
||||
self.f.creer_sujet_station(self.prop, "geve", "Encore")
|
||||
oscence = stations["oscence"]["id"]
|
||||
self.f.donner_role(self.pere, "s1", "proprietaire_station", "oscence")
|
||||
self.f.verrouiller(self.theo, oscence)
|
||||
with self.assertRaises(Refus):
|
||||
self.f.creer_sujet_station(self.prop, "oscence", "Pas permis")
|
||||
self.assertEqual(self.f.sujet(None, oscence)[1], [])
|
||||
|
||||
def test_pastille_nouveau_par_compte(self):
|
||||
tid = self.f.creer_sujet(self.adh, "Neige", "Il neige")
|
||||
self.assertIn("etat nouveau", self.req("/", "m1")[2].decode())
|
||||
self.assertNotIn("etat nouveau", self.req("/", "a1")[2].decode()) # son propre message
|
||||
self.assertNotIn("etat nouveau", self.req("/")[2].decode()) # visiteur : aucun suivi
|
||||
self.req("/t/%d" % tid, "m1")
|
||||
self.assertNotIn("etat nouveau", self.req("/", "m1")[2].decode())
|
||||
self.f.repondre(self.theo, tid, "Ici aussi")
|
||||
self.assertIn("etat nouveau", self.req("/", "m1")[2].decode())
|
||||
|
||||
def test_tri_et_photos(self):
|
||||
court = self.f.creer_sujet(self.adh, "Court", "x")
|
||||
long_ = self.f.creer_sujet(self.adh, "Long", "x" * 500)
|
||||
p = self.f.repondre(self.membre, court, "photo")
|
||||
self.f.ajouter_photos(self.membre, p, [("a.png", base.png())])
|
||||
ids = lambda tri, media="": [t["id"] for t in self.f.sujets(None, tri, media) if not t["fixed"]]
|
||||
self.assertEqual(ids("anciens"), [court, long_])
|
||||
self.assertEqual(ids("recents"), [long_, court])
|
||||
self.assertEqual(ids("longs"), [long_, court])
|
||||
self.assertEqual(ids("courts"), [court, long_])
|
||||
self.assertEqual(ids("activite", "avec"), [court])
|
||||
self.assertEqual(ids("activite", "sans"), [long_])
|
||||
page = self.req("/?tri=longs&media=sans")[2].decode()
|
||||
self.assertIn("<details class='tri'>", page)
|
||||
self.assertIn("value='longs' checked", page)
|
||||
self.assertNotIn(">Court<", page)
|
||||
self.assertEqual(self.req("/?tri=%3Cscript%3E")[0], 200) # valeur inconnue : tri par défaut
|
||||
|
||||
def test_derniere_temperature(self):
|
||||
dossier = os.path.join(self.tmp, "data", "semaine")
|
||||
os.makedirs(dossier)
|
||||
maintenant = time.time()
|
||||
with open(os.path.join(dossier, "geve.json"), "w", encoding="utf-8") as fh:
|
||||
json.dump({"debut": int(maintenant) - 3600, "pas": 1800, "t": [1.0, -2.4, None]}, fh)
|
||||
ancien, server.DONNEES = server.DONNEES, os.path.join(self.tmp, "data")
|
||||
try:
|
||||
self.assertEqual(server.derniere_temperature("geve", maintenant)[0], -2.4)
|
||||
self.assertIsNone(server.derniere_temperature("geve", maintenant + 4 * 3600)) # trop vieux
|
||||
self.assertIsNone(server.derniere_temperature("../geve"))
|
||||
self.assertIsNone(server.derniere_temperature("oscence")) # pas de fichier
|
||||
self.f.creer_sujets_stations()
|
||||
tid = [t for t in self.f.sujets(None) if t["station"] == "geve"][0]["id"]
|
||||
self.assertIn("−2,4 °C", self.req("/t/%d" % tid)[2].decode())
|
||||
finally:
|
||||
server.DONNEES = ancien
|
||||
|
||||
|
||||
class TestPages(base.BaseHTTP):
|
||||
def test_dix_sujets_par_page_et_filtres(self):
|
||||
ids = [self.f.creer_sujet(self.adh, "Sujet %02d" % i, "texte") for i in range(23)]
|
||||
p1 = self.req("/")[2].decode()
|
||||
self.assertIn("Page 1 sur 3", p1)
|
||||
self.assertIn(">Sujet 22<", p1)
|
||||
self.assertNotIn(">Sujet 12<", p1)
|
||||
p3 = self.req("/?page=3")[2].decode()
|
||||
self.assertIn(">Sujet 00<", p3)
|
||||
self.assertIn("rel='prev'", p3)
|
||||
self.assertNotIn("rel='next'", p3)
|
||||
self.assertIn("Page 3 sur 3", self.req("/?page=99")[2].decode())
|
||||
self.assertEqual(self.req("/?page=abc")[0], 200)
|
||||
self.assertIn("tri=anciens&page=2", self.req("/?tri=anciens")[2].decode())
|
||||
# plus de messages, plus de photos, photos récentes
|
||||
self.f.repondre(self.membre, ids[3], "a")
|
||||
self.f.repondre(self.membre, ids[3], "b")
|
||||
p = self.f.repondre(self.membre, ids[5], "photos")
|
||||
self.f.ajouter_photos(self.membre, p, [("a.png", base.png()), ("b.png", base.png())])
|
||||
p = self.f.repondre(self.membre, ids[7], "photo")
|
||||
self.f.ajouter_photos(self.membre, p, [("c.png", base.png())])
|
||||
premier = lambda tri: [t["id"] for t in self.f.sujets(None, tri) if not t["fixed"]][0]
|
||||
self.assertEqual(premier("messages"), ids[3])
|
||||
self.assertEqual(premier("photos"), ids[5])
|
||||
self.assertEqual(premier("medias"), ids[7])
|
||||
|
||||
|
||||
class TestModification(base.BaseHTTP):
|
||||
def test_une_seule_modification_en_7_jours(self):
|
||||
tid = self.f.creer_sujet(self.adh, "Givre", "Version 1 <b>")
|
||||
pid = self.f.sujet(None, tid)[1][0]["id"]
|
||||
page = self.req("/t/%d" % tid, "a1")[2].decode()
|
||||
self.assertIn("action='/modifier'", page)
|
||||
self.assertNotIn("action='/modifier'", self.req("/t/%d" % tid, "m1")[2].decode()) # pas son message
|
||||
corps = "post=%d&corps=Version+2" % pid
|
||||
st, h, _ = self.req("/modifier", "m1", corps=corps)
|
||||
self.assertEqual(self.f.sujet(None, tid)[1][0]["body"], "Version 1 <b>") # refusé
|
||||
st, h, _ = self.req("/modifier", "a1", corps=corps)
|
||||
self.assertEqual(st, 303)
|
||||
page = self.req("/t/%d" % tid, "a1")[2].decode()
|
||||
self.assertIn("Version 2", page)
|
||||
self.assertIn("voir l’ancienne version", page)
|
||||
self.assertIn("Version 1 <b>", page)
|
||||
self.assertNotIn("action='/modifier'", page) # une seule fois
|
||||
with self.assertRaises(Refus):
|
||||
self.f.modifier_message(self.adh, pid, "Version 3")
|
||||
# plus de 7 jours : plus modifiable
|
||||
tid2 = self.f.creer_sujet(self.adh, "Vieux", "ancien")
|
||||
pid2 = self.f.sujet(None, tid2)[1][0]["id"]
|
||||
self.f.con.execute("UPDATE posts SET created_at=datetime('now','-8 days') WHERE id=?", (pid2,))
|
||||
with self.assertRaises(Refus):
|
||||
self.f.modifier_message(self.adh, pid2, "nouveau")
|
||||
|
||||
|
||||
class TestApercu(base.BaseHTTP):
|
||||
def test_script_apercu_servi_et_autorise(self):
|
||||
st, h, corps = self.req("/apercu.js")
|
||||
self.assertEqual(st, 200)
|
||||
self.assertIn("javascript", h["Content-Type"])
|
||||
self.assertIn(b"Aper", corps)
|
||||
st, h, page = self.req("/publier", "a1")
|
||||
self.assertIn("<script src='/apercu.js' defer></script>", page.decode())
|
||||
self.assertIn("script-src 'self'", h["Content-Security-Policy"])
|
||||
self.assertIn("script-src 'self';", h["Content-Security-Policy"])
|
||||
+1857
-202
Diff désactivé car ce fichier est trop long.
Voir la Diff
@@ -0,0 +1,202 @@
|
||||
"""Page « Publier » : Markdown sûr, tableaux, brouillons privés, publication (vrai HTTP local, SQLite jetable)."""
|
||||
import json
|
||||
import re
|
||||
import unittest
|
||||
from urllib.parse import urlencode
|
||||
|
||||
import test_forum as base
|
||||
import markdown_sur
|
||||
from forum import Invalide
|
||||
|
||||
|
||||
class TestMarkdown(unittest.TestCase):
|
||||
def test_html_echappe_et_liens_surs(self):
|
||||
h = markdown_sur.rendu("<script>alert(1)</script>\n<img src=x onerror=alert(1)>")
|
||||
self.assertNotIn("<script", h)
|
||||
self.assertNotIn("<img", h)
|
||||
self.assertIn("<script>", h)
|
||||
for piege in ("[clic](javascript:alert(1))", "[clic](JaVaScRiPt:alert(1))", "[x](data:text/html,a)",
|
||||
"[x](/relatif)", "[x](https://a.fr\"onclick=alert(1))", "[x](https://a.fr'onmouseover='alert(1))"):
|
||||
h = markdown_sur.rendu(piege)
|
||||
self.assertNotIn("href='javascript", h.lower())
|
||||
self.assertNotRegex(h, r"<a [^>]*\s(onclick|onmouseover)=")
|
||||
self.assertNotIn("href='data", h)
|
||||
self.assertNotIn("href='/", h)
|
||||
h = markdown_sur.rendu("[Météo](https://vercors.me/?a=1&b=2)")
|
||||
self.assertIn("<a href='https://vercors.me/?a=1&b=2' rel='nofollow noopener noreferrer'>Météo</a>", h)
|
||||
|
||||
def test_mise_en_forme(self):
|
||||
h = markdown_sur.rendu("# Titre\n\n**gras** et *ita* et _ita2_ et `<b>code</b>`\nligne 2\n\n- un\n- deux\n\n1. a\n2. b")
|
||||
self.assertIn("<h2>Titre</h2>", h)
|
||||
self.assertIn("<strong>gras</strong>", h)
|
||||
self.assertIn("<em>ita</em>", h)
|
||||
self.assertIn("<em>ita2</em>", h)
|
||||
self.assertIn("<code><b>code</b></code>", h)
|
||||
self.assertIn("<br>ligne 2</p>", h)
|
||||
self.assertIn("<ul><li>un</li><li>deux</li></ul>", h)
|
||||
self.assertIn("<ol><li>a</li><li>b</li></ol>", h)
|
||||
self.assertIn("<code>**pas gras**</code>", markdown_sur.rendu("`**pas gras**`"))
|
||||
|
||||
def test_caracteres_de_controle(self):
|
||||
h = markdown_sur.rendu("a \x005\x00 `c` \x000\x00 b\x07")
|
||||
self.assertNotIn("\x00", h)
|
||||
self.assertIn("<code>c</code>", h)
|
||||
self.assertEqual(markdown_sur._en_ligne("\x009\x00"), "\x009\x00") # marqueur inconnu : pas d'IndexError
|
||||
f = base.Forum()
|
||||
u = f.fixer_proprietaire("theo", "Théo")
|
||||
for titre, corps in (("t\x00", "c"), ("t", "a\x005\x00")):
|
||||
with self.assertRaises(Invalide):
|
||||
f.creer_sujet(u, titre, corps)
|
||||
f.creer_sujet(u, "t", "ligne\r\nsuite\ttab") # retours à la ligne et tabulations restent permis
|
||||
|
||||
def test_entrees_pieges_rapides(self):
|
||||
import time
|
||||
for piege in ("# " + " " * 20000 + "x", "#" * 3 + " " + "#" * 20000 + " x", "**" + "a " * 20000,
|
||||
"*a" * 20000, "_a " * 20000, "| " * 20000 + "\n|" + "-|" * 20000, "[" * 20000 + "](" * 20000):
|
||||
debut = time.perf_counter()
|
||||
markdown_sur.rendu(piege)
|
||||
self.assertLess(time.perf_counter() - debut, 1.0, piege[:20])
|
||||
self.assertIn("<h2>Titre</h2>", markdown_sur.rendu("# Titre ## "))
|
||||
self.assertNotIn("<h2>", markdown_sur.rendu("# ###"))
|
||||
|
||||
def test_tableaux(self):
|
||||
h = markdown_sur.rendu("| Station | Tmin | Note |\n| --- | ---: | :-: |\n| Gêve | -4,2 | **gel** |\n| <i>x</i> | 1 |")
|
||||
self.assertIn("<table>", h)
|
||||
self.assertIn("<th>Station</th><th class='droite'>Tmin</th><th class='centre'>Note</th>", h)
|
||||
self.assertIn("<td>Gêve</td><td class='droite'>-4,2</td><td class='centre'><strong>gel</strong></td>", h)
|
||||
self.assertIn("<td><i>x</i></td><td class='droite'>1</td><td class='centre'></td>", h) # cellule manquante complétée
|
||||
self.assertNotIn("<table>", markdown_sur.rendu("a | b\nc | d")) # sans ligne de séparation : texte
|
||||
|
||||
|
||||
class TestPublier(base.BaseHTTP):
|
||||
def post(self, chemin, qui, champs, **kw):
|
||||
return self.req(chemin, qui, urlencode(champs).encode(), **kw)
|
||||
|
||||
def test_page_et_bouton_entete(self):
|
||||
page = self.req("/publier", "a1")[2].decode()
|
||||
self.assertNotIn("class='bouton principal publier'", page) # plus de bouton Publier dans l'en-tête (Théo, 06/11)
|
||||
self.assertIn("href='/brouillons'>Mes brouillons</a>", page)
|
||||
for libelle in ("for='titre'", "for='station'", "for='corps'", "for='photos'", "Me prévenir des réponses",
|
||||
"Catégorie <span class='etat'>bientôt</span>", "Enregistrer le brouillon", "formnovalidate"):
|
||||
self.assertIn(libelle, page)
|
||||
self.assertNotRegex(page, r"name='prevenir' value='1' checked") # décochée par défaut
|
||||
self.assertIn("Gêve", page) # liste des stations
|
||||
self.assertEqual(self.req("/publier", "m1")[0], 403)
|
||||
self.assertNotIn("href='/publier'", self.req("/", "m1")[2].decode())
|
||||
self.assertNotIn("Mes brouillons", self.req("/", "m1")[2].decode())
|
||||
|
||||
def test_publication_markdown_et_brouillon_supprime(self):
|
||||
st, _, b = self.post("/brouillon", "a1", {"titre": "Gel", "corps": "brouillon", "station": "geve"})
|
||||
bid = json.loads(b)["id"]
|
||||
self.assertRegex(json.loads(b)["heure"], r"^\d{1,2} h \d{2}$")
|
||||
corps = "## Relevés\n\n| Station | Tmin |\n| --- | --- |\n| Gêve | -4 |\n\n<script>alert(1)</script> [x](javascript:alert(1))"
|
||||
st, h, _ = self.post("/publier", "a1", {"brouillon": bid, "titre": "Gel <b>matinal</b>", "corps": corps,
|
||||
"station": "geve", "prevenir": "1", "action": "publier"})
|
||||
self.assertEqual(st, 303)
|
||||
tid = int(re.search(r"/t/(\d+)", h["Location"]).group(1))
|
||||
page = self.req(h["Location"])[2].decode()
|
||||
self.assertIn("<div class='message md'><h3>Relevés</h3>", page)
|
||||
self.assertIn("<td>Gêve</td><td>-4</td>", page)
|
||||
self.assertNotIn("<script>alert", page)
|
||||
self.assertNotIn("href='javascript", page)
|
||||
self.assertIn("Gel <b>matinal</b>", page)
|
||||
self.assertIn("Station liée : <b>", page)
|
||||
t = self.f.con.execute("SELECT prevenir, station_liee FROM topics WHERE id=?", (tid,)).fetchone()
|
||||
self.assertEqual((t[0], t[1]), (1, "geve"))
|
||||
self.assertEqual(self.f.con.execute("SELECT format FROM posts WHERE topic_id=?", (tid,)).fetchone()[0], "md")
|
||||
self.assertEqual(self.f.brouillons(self.adh), [])
|
||||
# Les anciens messages (format texte) restent affichés tels quels
|
||||
ancien = self.f.creer_sujet(self.adh, "Ancien", "**pas gras**\n<i>x</i>")
|
||||
page = self.req("/t/%d" % ancien)[2].decode()
|
||||
self.assertIn("<p class='message'>**pas gras**\n<i>x</i></p>", page)
|
||||
|
||||
def test_brouillons_prives(self):
|
||||
bid, _ = self.f.enregistrer_brouillon(self.adh, 0, "SECRET_TITRE", "SECRET_CORPS")
|
||||
self.assertIn("SECRET_TITRE", self.req("/brouillons", "a1")[2].decode())
|
||||
self.assertIn("SECRET_CORPS", self.req("/publier?brouillon=%d" % bid, "a1")[2].decode())
|
||||
for qui in ("theo", "pere"): # même le propriétaire ne voit pas le brouillon d'un autre
|
||||
self.assertNotIn("SECRET_TITRE", self.req("/brouillons", qui)[2].decode())
|
||||
st, _, b = self.req("/publier?brouillon=%d" % bid, qui)
|
||||
self.assertEqual(st, 404)
|
||||
self.assertNotIn("SECRET", b.decode())
|
||||
self.assertEqual(self.post("/brouillon", qui, {"brouillon": bid, "titre": "pirate", "corps": "x"})[0], 400)
|
||||
self.assertEqual(self.post("/brouillon/supprimer", qui, {"brouillon": bid})[0], 400)
|
||||
self.assertEqual(self.post("/publier", qui, {"brouillon": bid, "titre": "t", "corps": "c", "action": "publier"})[0], 400)
|
||||
self.assertEqual(self.req("/brouillons")[0], 403)
|
||||
self.assertEqual(self.post("/brouillon", None, {"titre": "x"})[0], 403)
|
||||
self.assertEqual(self.post("/brouillon", "m1", {"titre": "x"})[0], 403) # membre sans droit creer_sujet
|
||||
self.assertEqual(self.f.brouillon(self.adh, bid)["titre"], "SECRET_TITRE")
|
||||
with self.assertRaises(Invalide):
|
||||
self.f.brouillon(self.theo, bid)
|
||||
# contrôle d'origine, comme les autres POST
|
||||
self.assertEqual(self.post("/brouillon", "a1", {"brouillon": bid, "titre": "x"}, origine=False)[0], 403)
|
||||
self.assertEqual(self.f.brouillon(self.adh, bid)["titre"], "SECRET_TITRE")
|
||||
|
||||
def test_brouillon_sans_js_reprise_et_suppression(self):
|
||||
st, h, _ = self.post("/publier", "a1", {"titre": "Neige", "corps": "début", "station": "geve", "action": "brouillon"})
|
||||
self.assertEqual(st, 303)
|
||||
self.assertRegex(h["Location"], r"^/publier\?brouillon=\d+&suite=enregistre$")
|
||||
page = self.req(h["Location"], "a1")[2].decode()
|
||||
self.assertRegex(page, r"Enregistré à \d{1,2} h \d{2}\.")
|
||||
self.assertIn("value='Neige'", page)
|
||||
self.assertIn("<option value='geve' selected>", page)
|
||||
bid = int(h["Location"].split("=")[1].split("&")[0])
|
||||
# mise à jour du même brouillon, puis aperçu sans JS
|
||||
self.post("/publier", "a1", {"brouillon": bid, "titre": "Neige fraîche", "corps": "**10 cm**", "action": "brouillon"})
|
||||
self.assertEqual(len(self.f.brouillons(self.adh)), 1)
|
||||
st, _, b = self.post("/publier", "a1", {"brouillon": bid, "titre": "Neige fraîche", "corps": "**10 cm**", "action": "apercu"})
|
||||
self.assertEqual(st, 200)
|
||||
self.assertIn("<strong>10 cm</strong>", b.decode())
|
||||
page = self.req("/brouillons", "a1")[2].decode()
|
||||
self.assertIn("href='/publier?brouillon=%d'>Reprendre</a>" % bid, page)
|
||||
self.assertEqual(self.post("/brouillon/supprimer", "a1", {"brouillon": bid})[0], 303)
|
||||
self.assertIn("Aucun brouillon", self.req("/brouillons", "a1")[2].decode())
|
||||
|
||||
def test_apercu_instantane_et_validation(self):
|
||||
st, _, b = self.post("/apercu-md", "a1", {"corps": "<script>x</script>| a | b |\n|---|---|\n| 1 | 2 |"})
|
||||
self.assertEqual(st, 200)
|
||||
self.assertNotIn("<script>", b.decode())
|
||||
self.assertIn("<td>1</td><td>2</td>", b.decode())
|
||||
self.assertEqual(self.post("/apercu-md", "a1", {"corps": "x"}, origine=False)[0], 403)
|
||||
self.assertEqual(self.post("/apercu-md", "m1", {"corps": "x"})[0], 200) # un membre peut répondre, donc prévisualiser
|
||||
self.assertEqual(self.post("/apercu-md", None, {"corps": "x"})[0], 403)
|
||||
st, _, b = self.post("/publier", "a1", {"titre": "Sans corps", "corps": " ", "action": "publier"})
|
||||
self.assertEqual(st, 400)
|
||||
self.assertIn("value='Sans corps'", b.decode()) # rien n'est perdu
|
||||
self.assertEqual(self.post("/publier", "a1", {"titre": "t", "corps": "c", "station": "inconnue", "action": "publier"})[0], 400)
|
||||
# photos : même validation que creer_sujet
|
||||
corps = (b'--P\r\nContent-Disposition: form-data; name="titre"\r\n\r\nPhoto\r\n'
|
||||
b'--P\r\nContent-Disposition: form-data; name="corps"\r\n\r\nTexte\r\n'
|
||||
b'--P\r\nContent-Disposition: form-data; name="photos"; filename="x.png"\r\nContent-Type: image/png\r\n\r\ninvalide\r\n--P--\r\n')
|
||||
self.assertEqual(self.req("/publier", "a1", corps, "multipart/form-data; boundary=P")[0], 400)
|
||||
corps = corps.replace(b"invalide", base.png())
|
||||
st, h, _ = self.req("/publier", "a1", corps, "multipart/form-data; boundary=P")
|
||||
self.assertEqual(st, 303)
|
||||
self.assertIn("/photo/", self.req(h["Location"])[2].decode())
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
|
||||
|
||||
class TestRepondrePleinePage(base.BaseHTTP):
|
||||
def post(self, chemin, qui, champs, **kw):
|
||||
return self.req(chemin, qui, urlencode(champs).encode(), **kw)
|
||||
|
||||
def test_barre_puis_page_de_reponse_en_markdown(self):
|
||||
st, h, _ = self.post("/publier", "a1", {"titre": "Sujet ouvert", "corps": "Premier", "action": "publier"})
|
||||
self.assertEqual(st, 303)
|
||||
tid = int(re.search(r"/t/(\d+)", h["Location"]).group(1))
|
||||
page = self.req("/t/%d" % tid, "m1")[2].decode()
|
||||
self.assertIn("class='barre-repondre' href='/publier?sujet=%d'" % tid, page)
|
||||
self.assertNotIn("id='reponse'", page) # plus de grand champ dans le sujet
|
||||
st, _, b = self.req("/publier?sujet=%d" % tid, "m1")
|
||||
self.assertEqual(st, 200)
|
||||
self.assertIn("name='sujet' value='%d'" % tid, b.decode())
|
||||
st, _, _ = self.post("/publier", "m1", {"sujet": str(tid), "corps": "| a | b |\n|---|---|\n| 1 | 2 |", "action": "publier"})
|
||||
self.assertEqual(st, 303)
|
||||
self.assertIn("<td>1</td><td>2</td>", self.req("/t/%d" % tid, "m1")[2].decode())
|
||||
# Bulletin (sujet 1) : un membre n'a pas la barre ni le droit d'y publier
|
||||
self.assertNotIn("class='barre-repondre'", self.req("/t/1", "m1")[2].decode())
|
||||
self.assertEqual(self.post("/publier", "m1", {"sujet": "1", "corps": "x", "action": "publier"})[0], 403)
|
||||
|
||||
@@ -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()
|
||||
@@ -0,0 +1,102 @@
|
||||
"""Regressions UX sur vrai HTTP local, SQLite jetable et faux Hub."""
|
||||
from unittest.mock import patch
|
||||
import test_forum as base
|
||||
import roles
|
||||
from forum import Invalide, Refus
|
||||
|
||||
|
||||
class TestUX(base.BaseHTTP):
|
||||
def test_navigation_et_creation_selon_role(self):
|
||||
for qui, autorise in ((None,False),('m1',False),('a1',True),('mo1',False),('theo',True),('pere',True),('s1',False)):
|
||||
with self.subTest(qui=qui):
|
||||
st,_,b=self.req('/',qui)
|
||||
self.assertEqual(st,200)
|
||||
# Plus de menu Sujets / Stations / Se connecter (demande de Théo, 05/11) ;
|
||||
# connecté : le pseudo mène au compte.
|
||||
self.assertNotIn(">Stations</a>",b.decode())
|
||||
self.assertEqual("href='/profil'" in b.decode(), qui is not None)
|
||||
# Bouton « Publier » de l'en-tête (remplace /nouveau, gardé en redirection)
|
||||
self.assertEqual("href='/publier'" in b.decode(),autorise)
|
||||
self.assertEqual(self.req('/publier',qui)[0],200 if autorise else 403)
|
||||
st,h,_=self.req('/nouveau',qui)
|
||||
self.assertEqual((st,h['Location']),(303,'/publier'))
|
||||
if not autorise:
|
||||
self.assertIn('Demander à devenir adhérent',b.decode())
|
||||
for route in ('/profil','/stations','/adhesion'):
|
||||
self.assertEqual(self.req(route,qui)[0],200)
|
||||
|
||||
def test_bouton_retour_du_sujet(self):
|
||||
tid=self.f.creer_sujet(self.adh,'Neige','Échanges')
|
||||
page=self.req('/t/%d'%tid)[2].decode()
|
||||
self.assertIn("class='bouton retour' href='/'",page)
|
||||
hote=self.srv.server_address
|
||||
import http.client
|
||||
for ref,attendu in (('http://%s:%d/stations'%hote,'/stations'),('http://ailleurs.example/stations','/'),
|
||||
('http://%s:%d/t/%d'%(hote+(tid,)),'/'),("http://%s:%d/?q=a'b"%hote,'/?q=a'b')):
|
||||
c=http.client.HTTPConnection(*hote); c.request('GET','/t/%d'%tid,headers={'Referer':ref})
|
||||
self.assertIn("class='bouton retour' href='%s'"%attendu,c.getresponse().read().decode())
|
||||
|
||||
def test_apercus_echappes_et_masques_non_divulgues(self):
|
||||
tid=self.f.creer_sujet(self.adh,'<img src=x>','<script>alert(1)</script> Observation visible')
|
||||
secret=self.f.repondre(self.adh,tid,'TEXTE_MASQUE_UNIQUE')
|
||||
self.f.masquer_message(self.theo,secret)
|
||||
for qui in (None,'m1','a1','mo1','theo'):
|
||||
page=self.req('/',qui)[2].decode()
|
||||
self.assertNotIn('TEXTE_MASQUE_UNIQUE',page)
|
||||
self.assertNotIn('<script>alert',page)
|
||||
self.assertIn('<script>',page)
|
||||
self.assertIn('Aucune réponse',page)
|
||||
self.assertIn('Dernier message',page)
|
||||
self.f.masquer_sujet(self.theo,tid)
|
||||
self.assertNotIn('Observation visible',self.req('/')[2].decode())
|
||||
|
||||
def test_station_en_attente_privee_et_filtre(self):
|
||||
tid=self.f.creer_sujet_station(self.prop,'geve','PRESENTATION_PRIVEE')
|
||||
self.assertNotIn('PRESENTATION_PRIVEE',self.req('/stations')[2].decode())
|
||||
self.f.valider_sujet(self.theo,tid)
|
||||
page=self.req('/stations')[2].decode()
|
||||
self.assertIn('PRESENTATION_PRIVEE',page)
|
||||
self.assertIn("href='https://vercors.me/'",page)
|
||||
self.assertIn('Aucun sujet ne correspond',self.req('/stations?q=inexistant')[2].decode())
|
||||
|
||||
def test_photos_creation_atomique_limites_et_nettoyage(self):
|
||||
avant=len(self.f.sujets(None))
|
||||
with self.assertRaises(Invalide):
|
||||
self.f.creer_sujet(self.adh,'Photo','Texte',fichiers=[('x.png',b'invalide')])
|
||||
with self.assertRaises(Refus):
|
||||
self.f.creer_sujet(self.adh,'Photo','Texte',fichiers=[('x.png',base.png())]*11)
|
||||
with self.assertRaises(Refus):
|
||||
self.f.creer_sujet(self.adh,'Photo','Texte',fichiers=[('x.png',b'x'*(25*1024*1024+1))])
|
||||
with patch.object(self.f,'_stocker',side_effect=OSError('disque indisponible')):
|
||||
with self.assertRaises(OSError):
|
||||
self.f.creer_sujet(self.adh,'Photo','Texte',fichiers=[('x.png',base.png())])
|
||||
self.assertEqual(len(self.f.sujets(None)),avant)
|
||||
tid=self.f.creer_sujet(self.adh,'Photo','Texte',fichiers=[('x.png',base.png())])
|
||||
pid=self.f.sujet(None,tid)[1][0]['id']
|
||||
photo=self.f.photos_de(pid)[0]
|
||||
with open(photo['stored_path'],'rb') as fichier:
|
||||
self.assertNotIn(b'GPS',fichier.read())
|
||||
|
||||
def test_creation_multipart_http_et_prefixe(self):
|
||||
self.reglages.prefixe='/forum'
|
||||
body=(b'--UX\r\nContent-Disposition: form-data; name="titre"\r\n\r\nGivre\r\n'
|
||||
b'--UX\r\nContent-Disposition: form-data; name="corps"\r\n\r\nObservation\r\n'
|
||||
b'--UX\r\nContent-Disposition: form-data; name="photos"; filename="givre.png"\r\nContent-Type: image/png\r\n\r\n'+base.png()+b'\r\n--UX--\r\n')
|
||||
st,h,_=self.req('/forum/sujet','a1',body,'multipart/form-data; boundary=UX')
|
||||
self.assertEqual(st,303)
|
||||
self.assertTrue(h['Location'].startswith('/forum/t/'))
|
||||
page=self.req(h['Location'])[2].decode()
|
||||
self.assertIn('/forum/photo/',page)
|
||||
self.assertIn('/forum/polices/',page)
|
||||
self.assertEqual(self.req('/forum/sujet','mo1',body,'multipart/form-data; boundary=UX')[0],403)
|
||||
|
||||
def test_polices_locales_et_profil_prive(self):
|
||||
for nom in ('bitter-normal.woff2','outfit-normal.woff2'):
|
||||
st,h,b=self.req('/polices/'+nom)
|
||||
self.assertEqual(st,200)
|
||||
self.assertEqual(h['Content-Type'],'font/woff2')
|
||||
self.assertTrue(b.startswith(b'wOF2'))
|
||||
self.assertEqual(self.req('/polices/../connexion.py')[0],404)
|
||||
self.assertNotIn('Marie',self.req('/profil')[2].decode())
|
||||
self.assertIn('Marie',self.req('/profil','m1')[2].decode())
|
||||
self.assertNotIn('par vercors.me',self.req('/')[2].decode())
|
||||
@@ -0,0 +1,59 @@
|
||||
<!doctype html>
|
||||
<html lang="fr">
|
||||
<head>
|
||||
<meta charset="utf-8">
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1">
|
||||
<meta name="theme-color" content="#f5f3ee">
|
||||
<meta name="robots" content="noindex">
|
||||
<title>Hors sentier · Météo Vercors</title>
|
||||
<link rel="icon" href="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 32 32'%3E%3Crect width='32' height='32' fill='%231f4d3a'/%3E%3Cpath d='M3 24 12 9l5 8 3-4 9 11z' fill='%23f5f3ee'/%3E%3C/svg%3E">
|
||||
<style>
|
||||
@font-face{font-family:'Bitter';font-style:italic;font-weight:500;font-display:swap;src:url(/polices/bitter-italic.woff2) format('woff2');unicode-range:U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD}
|
||||
@font-face{font-family:'Bitter';font-style:normal;font-weight:500 700;font-display:swap;src:url(/polices/bitter-normal.woff2) format('woff2');unicode-range:U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD}
|
||||
@font-face{font-family:'Outfit';font-style:normal;font-weight:400 600;font-display:swap;src:url(/polices/outfit-normal.woff2) format('woff2');unicode-range:U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD}
|
||||
:root{--titre:'Bitter',Georgia,serif;--texte:'Outfit',system-ui,sans-serif;--sapin:#1f4d3a;--calcaire:#f5f3ee;--pierre:#e4e0d6;--roche:#2b2f2c;--gris:#5d635e;--rouge:#b3402f}
|
||||
*{box-sizing:border-box}
|
||||
html,body{margin:0;min-height:100%;background:var(--calcaire);color:var(--roche);font-family:var(--texte);line-height:1.55}
|
||||
a{color:var(--sapin)}
|
||||
a:focus-visible{outline:2px solid var(--sapin);outline-offset:2px}
|
||||
main{max-width:760px;margin:0 auto;padding:48px 20px 40px}
|
||||
.coord{font-size:12px;font-weight:600;letter-spacing:.14em;text-transform:uppercase;color:var(--gris)}
|
||||
.balise{display:inline-block;width:22px;height:7px;background:#fff;box-shadow:0 7px 0 var(--rouge);margin:0 8px 7px 0;vertical-align:middle;outline:1px solid var(--pierre)}
|
||||
h1{font-family:var(--titre);font-weight:700;font-size:56px;line-height:1;margin:18px 0 12px;color:var(--sapin)}
|
||||
.accroche{margin:0 0 22px;font-family:var(--titre);font-style:italic;font-size:18px;color:var(--gris)}
|
||||
p{font-size:16px;max-width:52ch}
|
||||
.crete{display:block;width:100%;max-width:560px;margin:28px 0}
|
||||
.crete .ligne{fill:none;stroke:var(--roche);stroke-width:2.4;stroke-linejoin:round}
|
||||
.crete .sentier{fill:none;stroke:var(--rouge);stroke-width:2;stroke-dasharray:2 7;stroke-linecap:round}
|
||||
.crete .point{fill:var(--rouge)}
|
||||
.crete text{font-family:var(--texte);font-size:11px;letter-spacing:.08em;fill:var(--gris)}
|
||||
.crete .ici{fill:var(--rouge);font-weight:600}
|
||||
.actions{display:flex;flex-wrap:wrap;gap:10px;margin-top:22px}
|
||||
.bouton{display:inline-block;font-size:12px;font-weight:600;letter-spacing:.12em;text-transform:uppercase;text-decoration:none;color:#fff;background:var(--sapin);padding:10px 14px}
|
||||
.bouton.clair{color:var(--sapin);background:var(--calcaire);border:1px solid var(--sapin)}
|
||||
.pied{margin-top:44px;padding-top:14px;border-top:1px solid var(--pierre);font-size:13px;color:var(--gris)}
|
||||
@media (max-width:560px){h1{font-size:42px}}
|
||||
</style>
|
||||
</head>
|
||||
<body>
|
||||
<main>
|
||||
<div class="coord"><span class="balise" aria-hidden="true"></span>Erreur 404 · Météo Vercors</div>
|
||||
<h1>Hors sentier.</h1>
|
||||
<p class="accroche">Ici, aucune station ne mesure rien.</p>
|
||||
<p>La page demandée n'existe pas (ou plus). Le balisage s'arrête net : mieux vaut faire demi-tour jusqu'à la carte, où les stations du Vercors donnent leurs relevés en direct.</p>
|
||||
<svg class="crete" viewBox="0 0 560 150" role="img" aria-label="Une ligne de crête et un sentier qui s'arrête">
|
||||
<path class="ligne" d="M0 120 L50 100 L90 108 L150 36 L190 84 L230 70 L290 22 L340 78 L380 62 L440 96 L500 88 L560 112"/>
|
||||
<text x="140" y="26">Pic 404</text>
|
||||
<text x="280" y="14">Col du Néant</text>
|
||||
<path class="sentier" d="M8 138 C70 132 120 142 180 128 S250 126 274 132"/>
|
||||
<circle class="point" cx="274" cy="132" r="5"/>
|
||||
<text class="ici" x="284" y="137">VOUS ÊTES ICI</text>
|
||||
</svg>
|
||||
<div class="actions">
|
||||
<a class="bouton" href="/">← Retour à la carte</a>
|
||||
<a class="bouton clair" href="/a-propos">À propos</a>
|
||||
</div>
|
||||
<p class="pied">Lien cassé chez nous ? Écrivez à <a href="mailto:studio@gastinel.me">studio@gastinel.me</a></p>
|
||||
</main>
|
||||
</body>
|
||||
</html>
|
||||
@@ -6,6 +6,19 @@
|
||||
<meta name="theme-color" content="#f5f3ee">
|
||||
<meta name="description" content="Le projet, les sources, les licences et les mentions légales de Météo Vercors.">
|
||||
<title>À propos · Météo Vercors</title>
|
||||
<link rel="canonical" href="https://vercors.me/a-propos">
|
||||
<meta name="robots" content="index, follow">
|
||||
<meta name="color-scheme" content="light">
|
||||
<meta property="og:type" content="website">
|
||||
<meta property="og:site_name" content="Météo Vercors">
|
||||
<meta property="og:locale" content="fr_FR">
|
||||
<meta property="og:url" content="https://vercors.me/a-propos">
|
||||
<meta property="og:title" content="À propos · Météo Vercors">
|
||||
<meta property="og:description" content="Le projet, les sources, les licences et les mentions légales de Météo Vercors.">
|
||||
<meta name="twitter:card" content="summary">
|
||||
<meta name="twitter:title" content="À propos · Météo Vercors">
|
||||
<meta name="twitter:description" content="Le projet, les sources, les licences et les mentions légales de Météo Vercors.">
|
||||
<script type="application/ld+json">{"@context":"https://schema.org","@type":"AboutPage","url":"https://vercors.me/a-propos","name":"À propos · Météo Vercors","inLanguage":"fr","isPartOf":{"@type":"WebSite","name":"Météo Vercors","url":"https://vercors.me/"}}</script>
|
||||
<link rel="icon" href="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 32 32'%3E%3Crect width='32' height='32' fill='%231f4d3a'/%3E%3Cpath d='M3 24 12 9l5 8 3-4 9 11z' fill='%23f5f3ee'/%3E%3C/svg%3E">
|
||||
<style>
|
||||
@font-face{font-family:'Bitter';font-style:italic;font-weight:500;font-display:swap;src:url(polices/bitter-italic.woff2) format('woff2');unicode-range:U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD}
|
||||
@@ -25,6 +38,11 @@ h2{font-family:var(--titre);font-weight:600;font-size:22px;margin:34px 0 8px;pad
|
||||
p,li{font-size:16px}
|
||||
ul{padding-left:20px}
|
||||
li{margin:4px 0}
|
||||
h3{font-family:var(--titre);font-weight:600;font-size:17px;margin:22px 0 4px;color:var(--roche)}
|
||||
.essentiel{border:2px solid var(--sapin);background:#faf9f5;padding:6px 18px 12px;margin:12px 0 18px}
|
||||
.essentiel h3{margin:10px 0 6px;color:var(--sapin);font-size:19px}
|
||||
.essentiel ul{margin:0;padding-left:20px}
|
||||
.carte-maison{border-left:4px solid var(--sapin);background:#faf9f5;padding:2px 16px 8px;margin:12px 0}
|
||||
table{border-collapse:collapse;width:100%;font-size:14.5px;margin:10px 0}
|
||||
th,td{border:1px solid var(--roche);padding:7px 10px;text-align:left;vertical-align:top}
|
||||
th{background:#faf9f5;font-weight:600}
|
||||
@@ -38,7 +56,7 @@ th{background:#faf9f5;font-weight:600}
|
||||
<h1>À propos</h1>
|
||||
<p class="accroche">Des stations de chez nous, des chiffres d'ici.</p>
|
||||
|
||||
<p>Météo Vercors affiche en direct les mesures de stations météo situées dans le Vercors, et uniquement dans le Vercors. C'est un projet personnel et indépendant, sans publicité ni suivi des visiteurs. Il est né d'un constat simple : dans les combes du plateau, il peut faire dix degrés de moins qu'à deux kilomètres de là, et aucune application météo générique ne le montre.</p>
|
||||
<p>Météo Vercors affiche en direct les mesures de stations météo situées dans le Vercors, et uniquement dans le Vercors. C'est un projet personnel et indépendant, sans publicité et sans pistage des visiteurs (seulement un comptage anonyme des pages vues, voir plus bas). Il est né d'un constat simple : dans les combes du plateau, il peut faire dix degrés de moins qu'à deux kilomètres de là, et aucune application météo générique ne le montre.</p>
|
||||
|
||||
<h2>Lire la carte</h2>
|
||||
<ul>
|
||||
@@ -51,23 +69,53 @@ th{background:#faf9f5;font-weight:600}
|
||||
<table>
|
||||
<tr><th>Source</th><th>Stations</th><th>Mise à jour</th><th>Licence</th></tr>
|
||||
<tr><td>Météo-France, API Observations (paquet 6 minutes)</td><td>Autrans, Villard-de-Lans, La Chapelle-en-Vercors, Col du Rousset, Gresse-en-Vercors, Saint-Jean-en-Royans</td><td>6 minutes</td><td>Licence Ouverte Etalab 2.0</td></tr>
|
||||
<tr><td>Infoclimat (réseau StatIC et stations partenaires)</td><td>Engins, Méaudre, Combe de l'Oscence, Combe de Darbounouse, crête de la Moucherolle, Die, Saint-Julien-en-Quint, Marignac, Cirque d'Archiane, Solaure, Rochechinard, Les Allières, Les Bruyères, Gêve</td><td>10 minutes</td><td>CC BY ou CC BY-NC selon la station (indiquée dans la fiche)</td></tr>
|
||||
<tr><td>WeatherLink (Davis Instruments)</td><td>Les Bruyères, Méaudre, Gêve (stations de Théo Gastinel et de proches)</td><td>15 minutes</td><td>Données des exploitants</td></tr>
|
||||
<tr><td>Station Gastinel (Davis Vantage Pro2)</td><td>Lans-en-Vercors, village</td><td>10 minutes</td><td>Données de l'éditeur</td></tr>
|
||||
<tr><td>Stations de la famille Gastinel (WeatherLink en premier, aussi publiées sur ROMMA et Infoclimat)</td><td>Lans-en-Vercors village, Les Bruyères, Les Allières, Méaudre, Gêve, Combe de l'Oscence, Combe de Darbounouse, crête de la Moucherolle</td><td>10 à 15 minutes</td><td>Données de l'éditeur</td></tr>
|
||||
<tr><td>ROMMA (Réseau d'Observation Météo du Massif Alpin), avec l'accord de l'association</td><td>Engins, Die, Saint-Julien-en-Quint, Cirque d'Archiane</td><td>10 minutes</td><td>Données ROMMA, reproduites avec son autorisation</td></tr>
|
||||
</table>
|
||||
<ul>
|
||||
<li>Fond de carte : relief RGE ALTI, cours d'eau, sommets et limite du Parc : © IGN, licence ouverte. Communes : geo.api.gouv.fr. La carte est dessinée une fois pour toutes et servie par ce site : aucun serveur tiers n'est contacté par la page.</li>
|
||||
<li>Polices Bitter et Outfit (licence SIL OFL), hébergées sur ce site.</li>
|
||||
<li>Les stations Infoclimat sous licence CC BY-NC ne servent qu'à un usage non commercial : ce site n'a ni publicité ni offre payante.</li>
|
||||
<li>Infoclimat : notre demande d'autorisation est en cours, sans réponse pour l'instant. Aucune station n'est donc publiée sur la seule base d'Infoclimat ; il sert uniquement de relais technique pour des stations autorisées par leur propriétaire ou par ROMMA.</li>
|
||||
</ul>
|
||||
<p>Site indépendant, sans lien avec le Parc naturel régional du Vercors ni avec une commune. Les relevés ne remplacent pas un bulletin officiel (Météo-France, Vigilance) pour la sécurité en montagne.</p>
|
||||
|
||||
<h2 id="mentions">Mentions légales</h2>
|
||||
<div class="essentiel">
|
||||
<h3>L'essentiel</h3>
|
||||
<ul>
|
||||
<li><b>Qui édite ce site</b> : Richard Gastinel, entrepreneur individuel à Lans-en-Vercors. Théo Gastinel en dirige la publication.</li>
|
||||
<li><b>Qui l'héberge</b> : Infomaniak, une société suisse (Genève).</li>
|
||||
<li><b>Publicité et cookies</b> : aucune publicité, aucun cookie, aucun serveur tiers contacté par la page.</li>
|
||||
<li><b>Données personnelles</b> : presque aucune. Pas de compte. Le serveur garde des journaux techniques pour la sécurité, et un comptage anonyme des pages vues (sans cookie, sans adresse IP conservée) nous dit combien de personnes viennent.</li>
|
||||
<li><b>Nous contacter</b> : <a href="mailto:studio@gastinel.me">studio@gastinel.me</a>, ou le 06 36 27 64 19.</li>
|
||||
<li><b>Vos droits</b> : vous pouvez demander à voir, corriger ou effacer les données qui vous concernent, par simple message à la même adresse.</li>
|
||||
</ul>
|
||||
</div>
|
||||
<h3>Le détail</h3>
|
||||
<p><b>Éditeur</b> : Richard GASTINEL, entrepreneur individuel (EI), micro-entreprise dont Théo et Richard Gastinel sont tous deux responsables (SIRET 10481674900014 ; 621, avenue Léopold Fabre, 38250 Lans-en-Vercors, France ; 06 36 27 64 19). Directeur de la publication : Théo Gastinel.<br>
|
||||
Contact : <a href="mailto:studio@gastinel.me">studio@gastinel.me</a></p>
|
||||
<p><b>Hébergement</b> : Infomaniak Network SA, Rue Eugène-Marziano 25, 1227 Les Acacias (Genève), Suisse, +41 22 820 35 44, www.infomaniak.com. Les relevés sont collectés et archivés sur un serveur de l'éditeur à Lans-en-Vercors.</p>
|
||||
<p><b>Données personnelles</b> : la page ne dépose aucun cookie et n'a pas de compte. Les journaux techniques du serveur (adresse IP, page demandée) servent à la sécurité ; durée de conservation : voir la politique de confidentialité à venir. Pour toute demande : studio@gastinel.me.</p>
|
||||
<p><b>Mesure d'audience</b> : le site compte les pages vues de façon agrégée, sans cookie et sans identifiant. Aucune adresse IP n'est conservée pour ce comptage, aucun visiteur n'est reconnu d'une page à l'autre, et rien n'est publié sous cinq occurrences. Cette mesure strictement statistique entre dans l'exemption de consentement prévue par la CNIL. Les chiffres agrégés sont consultables sur la <a href="statistiques.html">page des statistiques</a>.</p>
|
||||
<p><b>Propriété</b> : le code et la mise en page sont de Théo Gastinel. Les mesures appartiennent à leurs exploitants (voir sources).</p>
|
||||
|
||||
<h2 id="performance">Performance</h2>
|
||||
<p>La page ne dépend d'aucun service extérieur : ni police chargée ailleurs, ni bibliothèque, ni fond de carte, ni script de suivi. Tout (code, polices, carte) vient de ce site, ce qui évite des connexions inutiles et protège votre vie privée.</p>
|
||||
<ul>
|
||||
<li><b>Poids d'une visite</b> : environ 440 ko à la première ouverture, dont 200 ko de tuiles de carte. Une visite de cinq minutes avec une fiche station consultée pèse environ 600 ko, car la page se rafraîchit chaque minute (environ 34 ko). Polices et tuiles sont ensuite gardées par votre navigateur.</li>
|
||||
<li><b>Fraîcheur des données</b> : les relevés sont mis à jour toutes les 6 à 15 minutes selon la source (6 minutes pour Météo-France).</li>
|
||||
</ul>
|
||||
|
||||
<h2 id="carte">D'où vient la carte</h2>
|
||||
<div class="carte-maison">
|
||||
<p>La carte n'est pas un fond tiers : c'est un travail maison, dessiné pour ce site à partir de données ouvertes, puis servi par le site lui-même.</p>
|
||||
<ul>
|
||||
<li><b>Relief</b> : RGE ALTI de l'IGN, le modèle d'altitude de référence de l'IGN.</li>
|
||||
<li><b>Cours d'eau, sommets et limite du Parc naturel régional du Vercors</b> : IGN, licence ouverte.</li>
|
||||
<li><b>Communes</b> : geo.api.gouv.fr.</li>
|
||||
<li><b>Dessin</b> : la carte a été composée une seule fois et découpée en tuiles ; aucune requête vers un serveur de cartes n'est faite quand vous la parcourez.</li>
|
||||
</ul>
|
||||
</div>
|
||||
</main>
|
||||
<footer class="pied">© Théo Gastinel · <a href="./">Retour à la carte</a></footer>
|
||||
</body>
|
||||
|
||||
@@ -6,6 +6,19 @@
|
||||
<meta name="theme-color" content="#f5f3ee">
|
||||
<meta name="description" content="Le projet, les sources, les licences et les mentions légales de Météo Vercors.">
|
||||
<title>À propos · Météo Vercors</title>
|
||||
<link rel="canonical" href="https://vercors.me/a-propos">
|
||||
<meta name="robots" content="index, follow">
|
||||
<meta name="color-scheme" content="light">
|
||||
<meta property="og:type" content="website">
|
||||
<meta property="og:site_name" content="Météo Vercors">
|
||||
<meta property="og:locale" content="fr_FR">
|
||||
<meta property="og:url" content="https://vercors.me/a-propos">
|
||||
<meta property="og:title" content="À propos · Météo Vercors">
|
||||
<meta property="og:description" content="Le projet, les sources, les licences et les mentions légales de Météo Vercors.">
|
||||
<meta name="twitter:card" content="summary">
|
||||
<meta name="twitter:title" content="À propos · Météo Vercors">
|
||||
<meta name="twitter:description" content="Le projet, les sources, les licences et les mentions légales de Météo Vercors.">
|
||||
<script type="application/ld+json">{"@context":"https://schema.org","@type":"AboutPage","url":"https://vercors.me/a-propos","name":"À propos · Météo Vercors","inLanguage":"fr","isPartOf":{"@type":"WebSite","name":"Météo Vercors","url":"https://vercors.me/"}}</script>
|
||||
<link rel="icon" href="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 32 32'%3E%3Crect width='32' height='32' fill='%231f4d3a'/%3E%3Cpath d='M3 24 12 9l5 8 3-4 9 11z' fill='%23f5f3ee'/%3E%3C/svg%3E">
|
||||
<style>
|
||||
/*POLICES*/
|
||||
@@ -23,6 +36,11 @@ h2{font-family:var(--titre);font-weight:600;font-size:22px;margin:34px 0 8px;pad
|
||||
p,li{font-size:16px}
|
||||
ul{padding-left:20px}
|
||||
li{margin:4px 0}
|
||||
h3{font-family:var(--titre);font-weight:600;font-size:17px;margin:22px 0 4px;color:var(--roche)}
|
||||
.essentiel{border:2px solid var(--sapin);background:#faf9f5;padding:6px 18px 12px;margin:12px 0 18px}
|
||||
.essentiel h3{margin:10px 0 6px;color:var(--sapin);font-size:19px}
|
||||
.essentiel ul{margin:0;padding-left:20px}
|
||||
.carte-maison{border-left:4px solid var(--sapin);background:#faf9f5;padding:2px 16px 8px;margin:12px 0}
|
||||
table{border-collapse:collapse;width:100%;font-size:14.5px;margin:10px 0}
|
||||
th,td{border:1px solid var(--roche);padding:7px 10px;text-align:left;vertical-align:top}
|
||||
th{background:#faf9f5;font-weight:600}
|
||||
@@ -36,7 +54,7 @@ th{background:#faf9f5;font-weight:600}
|
||||
<h1>À propos</h1>
|
||||
<p class="accroche">/*ACCROCHE*/</p>
|
||||
|
||||
<p>Météo Vercors affiche en direct les mesures de stations météo situées dans le Vercors, et uniquement dans le Vercors. C'est un projet personnel et indépendant, sans publicité ni suivi des visiteurs. Il est né d'un constat simple : dans les combes du plateau, il peut faire dix degrés de moins qu'à deux kilomètres de là, et aucune application météo générique ne le montre.</p>
|
||||
<p>Météo Vercors affiche en direct les mesures de stations météo situées dans le Vercors, et uniquement dans le Vercors. C'est un projet personnel et indépendant, sans publicité et sans pistage des visiteurs (seulement un comptage anonyme des pages vues, voir plus bas). Il est né d'un constat simple : dans les combes du plateau, il peut faire dix degrés de moins qu'à deux kilomètres de là, et aucune application météo générique ne le montre.</p>
|
||||
|
||||
<h2>Lire la carte</h2>
|
||||
<ul>
|
||||
@@ -49,23 +67,53 @@ th{background:#faf9f5;font-weight:600}
|
||||
<table>
|
||||
<tr><th>Source</th><th>Stations</th><th>Mise à jour</th><th>Licence</th></tr>
|
||||
<tr><td>Météo-France, API Observations (paquet 6 minutes)</td><td>Autrans, Villard-de-Lans, La Chapelle-en-Vercors, Col du Rousset, Gresse-en-Vercors, Saint-Jean-en-Royans</td><td>6 minutes</td><td>Licence Ouverte Etalab 2.0</td></tr>
|
||||
<tr><td>Infoclimat (réseau StatIC et stations partenaires)</td><td>Engins, Méaudre, Combe de l'Oscence, Combe de Darbounouse, crête de la Moucherolle, Die, Saint-Julien-en-Quint, Marignac, Cirque d'Archiane, Solaure, Rochechinard, Les Allières, Les Bruyères, Gêve</td><td>10 minutes</td><td>CC BY ou CC BY-NC selon la station (indiquée dans la fiche)</td></tr>
|
||||
<tr><td>WeatherLink (Davis Instruments)</td><td>Les Bruyères, Méaudre, Gêve (stations de Théo Gastinel et de proches)</td><td>15 minutes</td><td>Données des exploitants</td></tr>
|
||||
<tr><td>Station Gastinel (Davis Vantage Pro2)</td><td>Lans-en-Vercors, village</td><td>10 minutes</td><td>Données de l'éditeur</td></tr>
|
||||
<tr><td>Stations de la famille Gastinel (WeatherLink en premier, aussi publiées sur ROMMA et Infoclimat)</td><td>Lans-en-Vercors village, Les Bruyères, Les Allières, Méaudre, Gêve, Combe de l'Oscence, Combe de Darbounouse, crête de la Moucherolle</td><td>10 à 15 minutes</td><td>Données de l'éditeur</td></tr>
|
||||
<tr><td>ROMMA (Réseau d'Observation Météo du Massif Alpin), avec l'accord de l'association</td><td>Engins, Die, Saint-Julien-en-Quint, Cirque d'Archiane</td><td>10 minutes</td><td>Données ROMMA, reproduites avec son autorisation</td></tr>
|
||||
</table>
|
||||
<ul>
|
||||
<li>Fond de carte : relief RGE ALTI, cours d'eau, sommets et limite du Parc : © IGN, licence ouverte. Communes : geo.api.gouv.fr. La carte est dessinée une fois pour toutes et servie par ce site : aucun serveur tiers n'est contacté par la page.</li>
|
||||
<li>Polices Bitter et Outfit (licence SIL OFL), hébergées sur ce site.</li>
|
||||
<li>Les stations Infoclimat sous licence CC BY-NC ne servent qu'à un usage non commercial : ce site n'a ni publicité ni offre payante.</li>
|
||||
<li>Infoclimat : notre demande d'autorisation est en cours, sans réponse pour l'instant. Aucune station n'est donc publiée sur la seule base d'Infoclimat ; il sert uniquement de relais technique pour des stations autorisées par leur propriétaire ou par ROMMA.</li>
|
||||
</ul>
|
||||
<p>Site indépendant, sans lien avec le Parc naturel régional du Vercors ni avec une commune. Les relevés ne remplacent pas un bulletin officiel (Météo-France, Vigilance) pour la sécurité en montagne.</p>
|
||||
|
||||
<h2 id="mentions">Mentions légales</h2>
|
||||
<div class="essentiel">
|
||||
<h3>L'essentiel</h3>
|
||||
<ul>
|
||||
<li><b>Qui édite ce site</b> : Richard Gastinel, entrepreneur individuel à Lans-en-Vercors. Théo Gastinel en dirige la publication.</li>
|
||||
<li><b>Qui l'héberge</b> : Infomaniak, une société suisse (Genève).</li>
|
||||
<li><b>Publicité et cookies</b> : aucune publicité, aucun cookie, aucun serveur tiers contacté par la page.</li>
|
||||
<li><b>Données personnelles</b> : presque aucune. Pas de compte. Le serveur garde des journaux techniques pour la sécurité, et un comptage anonyme des pages vues (sans cookie, sans adresse IP conservée) nous dit combien de personnes viennent.</li>
|
||||
<li><b>Nous contacter</b> : <a href="mailto:studio@gastinel.me">studio@gastinel.me</a>, ou le 06 36 27 64 19.</li>
|
||||
<li><b>Vos droits</b> : vous pouvez demander à voir, corriger ou effacer les données qui vous concernent, par simple message à la même adresse.</li>
|
||||
</ul>
|
||||
</div>
|
||||
<h3>Le détail</h3>
|
||||
<p><b>Éditeur</b> : Richard GASTINEL, entrepreneur individuel (EI), micro-entreprise dont Théo et Richard Gastinel sont tous deux responsables (SIRET 10481674900014 ; 621, avenue Léopold Fabre, 38250 Lans-en-Vercors, France ; 06 36 27 64 19). Directeur de la publication : Théo Gastinel.<br>
|
||||
Contact : <a href="mailto:studio@gastinel.me">studio@gastinel.me</a></p>
|
||||
<p><b>Hébergement</b> : Infomaniak Network SA, Rue Eugène-Marziano 25, 1227 Les Acacias (Genève), Suisse, +41 22 820 35 44, www.infomaniak.com. Les relevés sont collectés et archivés sur un serveur de l'éditeur à Lans-en-Vercors.</p>
|
||||
<p><b>Données personnelles</b> : la page ne dépose aucun cookie et n'a pas de compte. Les journaux techniques du serveur (adresse IP, page demandée) servent à la sécurité ; durée de conservation : voir la politique de confidentialité à venir. Pour toute demande : studio@gastinel.me.</p>
|
||||
<p><b>Mesure d'audience</b> : le site compte les pages vues de façon agrégée, sans cookie et sans identifiant. Aucune adresse IP n'est conservée pour ce comptage, aucun visiteur n'est reconnu d'une page à l'autre, et rien n'est publié sous cinq occurrences. Cette mesure strictement statistique entre dans l'exemption de consentement prévue par la CNIL. Les chiffres agrégés sont consultables sur la <a href="statistiques.html">page des statistiques</a>.</p>
|
||||
<p><b>Propriété</b> : le code et la mise en page sont de Théo Gastinel. Les mesures appartiennent à leurs exploitants (voir sources).</p>
|
||||
|
||||
<h2 id="performance">Performance</h2>
|
||||
<p>La page ne dépend d'aucun service extérieur : ni police chargée ailleurs, ni bibliothèque, ni fond de carte, ni script de suivi. Tout (code, polices, carte) vient de ce site, ce qui évite des connexions inutiles et protège votre vie privée.</p>
|
||||
<ul>
|
||||
<li><b>Poids d'une visite</b> : environ 440 ko à la première ouverture, dont 200 ko de tuiles de carte. Une visite de cinq minutes avec une fiche station consultée pèse environ 600 ko, car la page se rafraîchit chaque minute (environ 34 ko). Polices et tuiles sont ensuite gardées par votre navigateur.</li>
|
||||
<li><b>Fraîcheur des données</b> : les relevés sont mis à jour toutes les 6 à 15 minutes selon la source (6 minutes pour Météo-France).</li>
|
||||
</ul>
|
||||
|
||||
<h2 id="carte">D'où vient la carte</h2>
|
||||
<div class="carte-maison">
|
||||
<p>La carte n'est pas un fond tiers : c'est un travail maison, dessiné pour ce site à partir de données ouvertes, puis servi par le site lui-même.</p>
|
||||
<ul>
|
||||
<li><b>Relief</b> : RGE ALTI de l'IGN, le modèle d'altitude de référence de l'IGN.</li>
|
||||
<li><b>Cours d'eau, sommets et limite du Parc naturel régional du Vercors</b> : IGN, licence ouverte.</li>
|
||||
<li><b>Communes</b> : geo.api.gouv.fr.</li>
|
||||
<li><b>Dessin</b> : la carte a été composée une seule fois et découpée en tuiles ; aucune requête vers un serveur de cartes n'est faite quand vous la parcourez.</li>
|
||||
</ul>
|
||||
</div>
|
||||
</main>
|
||||
<footer class="pied">© Théo Gastinel · <a href="./">Retour à la carte</a></footer>
|
||||
</body>
|
||||
|
||||
@@ -1,18 +1,19 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Assemble le site publiable de vercors.me dans <projet>/site-v2/ à partir de la maquette.
|
||||
|
||||
site-v2/index.html, a-propos.html, (cgu.html, confidentialite.html si présents), polices/, tuiles/, data/ (vide)
|
||||
site-v2/index.html, a-propos.html, statistiques.html, 404.html, llms.txt, llms-full.txt, (cgu.html, confidentialite.html si présents), polices/, tuiles/, data/ (vide)
|
||||
Les JSON de données (data/*.json, data/semaine/) sont produits sur cornafserver et copiés sur le serveur public à part.
|
||||
Usage : python assembler.py
|
||||
"""
|
||||
import os
|
||||
import re
|
||||
import shutil
|
||||
import sys
|
||||
|
||||
ICI = os.path.dirname(os.path.abspath(__file__))
|
||||
DEST = os.path.join(os.path.dirname(os.path.dirname(ICI)), "site-v2")
|
||||
# CGU et confidentialité : retirées de la version publique jusqu'à la relecture juridique (textes dans maquettes/ et Documents/Meteo-Vercors/08-Juridique)
|
||||
PAGES = ("index.html", "a-propos.html")
|
||||
PAGES = ("index.html", "a-propos.html", "statistiques.html", "climat.html")
|
||||
|
||||
|
||||
def main():
|
||||
@@ -25,16 +26,26 @@ def main():
|
||||
# forum non ouvert : pas de lien vers des pages qui n'existent pas encore en ligne
|
||||
ip = os.path.join(DEST, "index.html")
|
||||
t = open(ip, encoding="utf-8").read()
|
||||
t = t.replace('<li><a href="cgu.html">CGU</a></li>', '').replace('<li><a href="confidentialite.html">Confidentialité</a></li>', '')
|
||||
t = t.replace('href="forum/index.html"', 'aria-disabled="true"').replace('href="forum/connexion.html"', 'aria-disabled="true"')
|
||||
t = re.sub(r'<li><a href="(?:cgu|confidentialite)\.html"[^>]*>[^<]*</a></li>', '', t) # pages en attente de l'avocate
|
||||
# forum ouvert le 05/11/2026 : les liens /forum/ restent tels quels
|
||||
open(ip, "w", encoding="utf-8").write(t)
|
||||
# statistiques : CGU et confidentialité non publiées, on retire leurs liens de la page copiée
|
||||
sp = os.path.join(DEST, "statistiques.html")
|
||||
if os.path.exists(sp):
|
||||
t = open(sp, encoding="utf-8").read()
|
||||
t = t.replace(' Voir la <a href="confidentialite.html">politique de confidentialité</a>.', '')
|
||||
t = t.replace('<a href="cgu.html">Conditions d\'utilisation</a> · <a href="confidentialite.html">Confidentialité</a> · ', '')
|
||||
open(sp, "w", encoding="utf-8").write(t)
|
||||
for fixe in ("404.html", "llms.txt", "llms-full.txt", "charte.html", "charte-vercors.pdf"):
|
||||
if os.path.exists(os.path.join(ICI, fixe)):
|
||||
shutil.copy(os.path.join(ICI, fixe), os.path.join(DEST, fixe))
|
||||
open(os.path.join(DEST, "robots.txt"), "w", encoding="utf-8").write("User-agent: *\nAllow: /\nSitemap: https://vercors.me/sitemap.xml\n")
|
||||
urls = "".join("<url><loc>https://vercors.me/%s</loc></url>" % u for u in ("", "a-propos"))
|
||||
urls = "".join("<url><loc>https://vercors.me/%s</loc></url>" % u for u in ("", "climat", "a-propos", "statistiques", "charte"))
|
||||
open(os.path.join(DEST, "sitemap.xml"), "w", encoding="utf-8").write('<?xml version="1.0" encoding="UTF-8"?><urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">%s</urlset>\n' % urls)
|
||||
for dossier in ("polices", "tuiles"):
|
||||
src = os.path.join(ICI, dossier)
|
||||
if os.path.isdir(src):
|
||||
shutil.copytree(src, os.path.join(DEST, dossier), ignore=shutil.ignore_patterns("*.css"))
|
||||
shutil.copytree(src, os.path.join(DEST, dossier), ignore=shutil.ignore_patterns("*.css"), dirs_exist_ok=True)
|
||||
# contrôle : aucune ressource distante dans les pages
|
||||
for nom in os.listdir(DEST):
|
||||
if nom.endswith(".html"):
|
||||
|
||||
@@ -108,7 +108,7 @@ th{background:#faf9f5;font-weight:600}
|
||||
<p>10.7. <b>Propriété des contributions</b> : l'auteur reste propriétaire de ses contributions. En publiant, il concède à l'éditeur, à titre gratuit et non exclusif, le droit de les reproduire et de les afficher sur le Site, pour la durée de leur mise en ligne et aux seules fins du forum. Aucune contribution n'est utilisée à une autre fin : ni publicité, ni revente, ni entraînement d'intelligence artificielle. <mark class="a-trancher">[À COMPLÉTER : si les relevés publiés par un adhérent rejoignent l'archive météo sans limite de durée, le prévoir ici explicitement.]</mark></p>
|
||||
<p>10.8. <b>Suppression</b> : l'auteur peut supprimer ses contributions et son compte à tout moment. Ses données personnelles sont alors effacées selon la politique de confidentialité, sous réserve des données d'identification des auteurs que la loi impose de conserver.</p>
|
||||
<h2>Article 11 : Données personnelles et cookies</h2>
|
||||
<p>Le traitement des données personnelles est décrit dans la <b>politique de confidentialité</b> de vercors.me. Le Site ne dépose aucun cookie tiers et ne contacte aucun serveur tiers : la carte et les polices sont servies par le Site lui-même.</p>
|
||||
<p>Le traitement des données personnelles est décrit dans la <b>politique de confidentialité</b> de vercors.me. Le Site ne dépose aucun cookie tiers et ne contacte aucun serveur tiers : la carte et les polices sont servies par le Site lui-même. Le Site réalise une mesure d'audience agrégée (comptage des pages vues), sans cookie, sans identifiant et sans conservation d'adresse IP, qui relève de l'exemption de consentement prévue par la CNIL ; elle est décrite dans la politique de confidentialité.</p>
|
||||
<h2>Article 12 : Modification des CGU</h2>
|
||||
<p>L'éditeur peut modifier les présentes CGU. La version applicable est celle en ligne au moment de la consultation ; sa date figure en tête. Une fois les comptes ouverts, toute modification substantielle sera signalée aux membres avant son entrée en vigueur.</p>
|
||||
<h2>Article 13 : Droit applicable et litiges</h2>
|
||||
|
||||
Fichier binaire non affiché.
@@ -0,0 +1,121 @@
|
||||
<!doctype html>
|
||||
<html lang="fr">
|
||||
<head>
|
||||
<meta charset="utf-8">
|
||||
<meta name="viewport" content="width=device-width,initial-scale=1">
|
||||
<meta name="color-scheme" content="light">
|
||||
<meta name="description" content="Charte graphique de Météo Vercors : couleurs, polices et règles d’accessibilité.">
|
||||
<title>Charte graphique · Météo Vercors</title>
|
||||
<style>
|
||||
@font-face{font-family:Bitter;font-weight:500 700;font-display:swap;src:url('polices/bitter-normal.woff2') format('woff2')}
|
||||
@font-face{font-family:Outfit;font-weight:400 600;font-display:swap;src:url('polices/outfit-normal.woff2') format('woff2')}
|
||||
:root{color-scheme:light;--sapin:#1f4d3a;--mousse:#6f8f5c;--calcaire:#f5f3ee;--pierre:#e4e0d6;--roche:#2b2f2c;--glacier:#6eb5bd;--gris:#5d635e;--chaud:#b5643c}
|
||||
*{box-sizing:border-box}
|
||||
body{margin:0;background:var(--calcaire);color:var(--roche);font:18px/1.6 Outfit,system-ui,sans-serif}
|
||||
a{color:var(--sapin)}
|
||||
header,main,footer{max-width:1100px;margin:0 auto;padding:0 24px}
|
||||
header{padding-top:40px;padding-bottom:28px;border-bottom:1px solid #b9b4a6}
|
||||
.kicker{color:var(--sapin);font-weight:600;margin:0 0 8px}
|
||||
h1,h2,h3{font-family:Bitter,Georgia,serif;color:var(--sapin);line-height:1.15}
|
||||
h1{font-size:clamp(40px,7vw,68px);margin:0 0 12px}
|
||||
h2{font-size:34px;margin:56px 0 8px}
|
||||
h3{font-size:22px;margin:0 0 6px}
|
||||
.chapeau{font-size:20px;max-width:62ch;color:var(--gris);margin:0}
|
||||
.intro{color:var(--gris);max-width:70ch;margin:0 0 24px}
|
||||
.palette{display:grid;grid-template-columns:repeat(auto-fill,minmax(min(100%,240px),1fr));gap:16px}
|
||||
.couleur{background:#fff;border:1px solid #a5afa1}
|
||||
.couleur .pastille{height:150px;border-bottom:1px solid #a5afa1}
|
||||
.couleur div{padding:16px 18px}
|
||||
.couleur b{display:block;font-family:Bitter,Georgia,serif;font-size:22px;color:var(--roche)}
|
||||
.couleur code{display:block;font:600 26px/1.3 ui-monospace,Consolas,monospace;margin:4px 0 6px;color:var(--roche)}
|
||||
.couleur span{color:var(--gris);font-size:16px}
|
||||
.polices{display:grid;grid-template-columns:repeat(auto-fit,minmax(min(100%,420px),1fr));gap:16px}
|
||||
.carte{background:#fff;border:1px solid #a5afa1;padding:28px}
|
||||
.geant{font-size:clamp(64px,12vw,120px);line-height:1;margin:8px 0 16px;color:var(--sapin)}
|
||||
.bitter{font-family:Bitter,Georgia,serif;font-weight:700}
|
||||
.outfit{font-family:Outfit,system-ui,sans-serif;font-weight:600}
|
||||
.alphabet{font-size:22px;overflow-wrap:anywhere;margin:0 0 10px}
|
||||
.role{color:var(--gris);margin:0}
|
||||
.regles{display:grid;grid-template-columns:repeat(auto-fit,minmax(min(100%,300px),1fr));gap:16px}
|
||||
.regle{background:#fff;border:1px solid #a5afa1;border-left:5px solid var(--sapin);padding:20px 22px}
|
||||
.regle.non{border-left-color:var(--chaud)}
|
||||
.regle p{margin:0}
|
||||
.etiquette{display:inline-block;font-size:14px;font-weight:600;border:1px solid currentColor;padding:0 8px;margin-bottom:8px}
|
||||
.oui .etiquette{color:var(--sapin)}.non .etiquette{color:var(--chaud)}
|
||||
.donnees{display:grid;grid-template-columns:repeat(auto-fill,minmax(min(100%,200px),1fr));gap:12px}
|
||||
.donnee{display:flex;align-items:center;gap:12px;background:#fff;border:1px solid #a5afa1;padding:12px 14px}
|
||||
.donnee i{width:36px;height:36px;flex:none;border:1px solid #a5afa1}
|
||||
.ton{background:#fff;border:1px solid #a5afa1;padding:24px 28px}
|
||||
.ton ul{margin:0;padding-left:22px}
|
||||
.actions{margin:24px 0 0;display:flex;gap:16px;align-items:center;flex-wrap:wrap}
|
||||
.bouton{display:inline-block;background:var(--sapin);color:#fff;text-decoration:none;font-weight:600;padding:12px 18px;border:1px solid var(--sapin)}
|
||||
.bouton:hover{background:#163a2b}
|
||||
@media print{.actions{display:none}body{font-size:14px}h2{margin-top:28px;break-after:avoid}.couleur,.carte,.regle{break-inside:avoid}}
|
||||
.brouillon{border:1px dashed var(--gris);padding:10px 14px;color:var(--gris);font-size:15px;margin:24px 0 0}
|
||||
footer{margin-top:64px;padding-top:24px;padding-bottom:40px;border-top:1px solid #b9b4a6;color:var(--gris);font-size:16px}
|
||||
:focus-visible{outline:3px solid var(--sapin);outline-offset:3px}
|
||||
</style>
|
||||
</head>
|
||||
<body>
|
||||
<header>
|
||||
<p class="kicker">Météo Vercors</p>
|
||||
<h1>Charte graphique</h1>
|
||||
<p class="chapeau">Les couleurs, les polices et les règles qui donnent au site son allure. Simple, clair, lisible par tout le monde.</p>
|
||||
<p class="actions"><a class="bouton" href="charte-vercors.pdf" download>Télécharger la charte (PDF)</a> <a href="./">Retour à la carte</a></p>
|
||||
</header>
|
||||
<main>
|
||||
|
||||
<h2>Couleurs</h2>
|
||||
<p class="intro">Une palette figée, tirée des paysages du massif : la forêt, la prairie, le calcaire, la roche et la glace.</p>
|
||||
<div class="palette">
|
||||
<div class="couleur"><div class="pastille" style="background:#1f4d3a"></div><div><b>Sapin</b><code>#1F4D3A</code><span>Couleur principale : titres, liens, boutons.</span></div></div>
|
||||
<div class="couleur"><div class="pastille" style="background:#6f8f5c"></div><div><b>Mousse</b><code>#6F8F5C</code><span>Accent doux : adhérents, détails.</span></div></div>
|
||||
<div class="couleur"><div class="pastille" style="background:#f5f3ee"></div><div><b>Calcaire</b><code>#F5F3EE</code><span>Fond des pages.</span></div></div>
|
||||
<div class="couleur"><div class="pastille" style="background:#e4e0d6"></div><div><b>Pierre</b><code>#E4E0D6</code><span>Séparations, cadres légers.</span></div></div>
|
||||
<div class="couleur"><div class="pastille" style="background:#2b2f2c"></div><div><b>Roche</b><code>#2B2F2C</code><span>Texte principal.</span></div></div>
|
||||
<div class="couleur"><div class="pastille" style="background:#5d635e"></div><div><b>Gris</b><code>#5D635E</code><span>Texte secondaire, dates.</span></div></div>
|
||||
<div class="couleur"><div class="pastille" style="background:#6eb5bd"></div><div><b>Glacier</b><code>#6EB5BD</code><span>Froid, neige, stations.</span></div></div>
|
||||
<div class="couleur"><div class="pastille" style="background:#b5643c"></div><div><b>Chaud</b><code>#B5643C</code><span>Chaleur, mises en garde.</span></div></div>
|
||||
</div>
|
||||
|
||||
<h2>Polices</h2>
|
||||
<p class="intro">Deux polices seulement, hébergées sur le site (aucun appel à un service extérieur).</p>
|
||||
<div class="polices">
|
||||
<div class="carte"><h3>Titres</h3><p class="geant bitter">Bitter</p><p class="alphabet bitter">Aa Bb Cc Éé Gg 0123456789</p><p class="role">Serif solide, pour les titres et les noms de stations.</p></div>
|
||||
<div class="carte"><h3>Textes</h3><p class="geant outfit">Outfit</p><p class="alphabet outfit">Aa Bb Cc Éé Gg 0123456789</p><p class="role">Sans serif lisible, pour tout le reste : textes, boutons, chiffres.</p></div>
|
||||
</div>
|
||||
|
||||
|
||||
<h2>Couleurs des données</h2>
|
||||
<p class="intro">Toujours les mêmes couleurs pour les mêmes mesures, sur la carte comme dans les graphiques.</p>
|
||||
<div class="donnees">
|
||||
<div class="donnee"><i style="background:#b5643c"></i>Température</div>
|
||||
<div class="donnee"><i style="background:#6eb5bd"></i>Neige, froid</div>
|
||||
<div class="donnee"><i style="background:#1f4d3a"></i>Pluie</div>
|
||||
<div class="donnee"><i style="background:#6f8f5c"></i>Humidité</div>
|
||||
<div class="donnee"><i style="background:#5d635e"></i>Vent</div>
|
||||
</div>
|
||||
<p class="brouillon">Correspondance des couleurs de données à confirmer avec les graphiques actuels du site.</p>
|
||||
|
||||
<h2>Règles</h2>
|
||||
<div class="regles">
|
||||
<div class="regle oui"><span class="etiquette">Oui</span><p><b>Accessible à tous.</b> Texte d’au moins 16 px, contrastes forts, focus clavier toujours visible.</p></div>
|
||||
<div class="regle oui"><span class="etiquette">Oui</span><p><b>Thème clair uniquement.</b> Fond calcaire, texte roche.</p></div>
|
||||
<div class="regle oui"><span class="etiquette">Oui</span><p><b>Angles droits.</b> Cadres fins, sans ombres fortes.</p></div>
|
||||
<div class="regle non"><span class="etiquette">Non</span><p><b>Pas de mode sombre.</b></p></div>
|
||||
<div class="regle non"><span class="etiquette">Non</span><p><b>Pas d’emoji dans l’interface.</b> Des pictogrammes dessinés, avec un texte à côté.</p></div>
|
||||
<div class="regle non"><span class="etiquette">Non</span><p><b>Pas de couleur hors palette.</b></p></div>
|
||||
</div>
|
||||
|
||||
<h2>Ton des textes</h2>
|
||||
<div class="ton"><ul>
|
||||
<li>On tutoie, avec des phrases courtes.</li>
|
||||
<li>On dit ce qu’on mesure, sans exagérer.</li>
|
||||
<li>Les unités sont toujours écrites : °C, mm, km/h.</li>
|
||||
<li>En français d’abord ; anglais et allemand dans les paramètres.</li>
|
||||
</ul></div>
|
||||
|
||||
</main>
|
||||
<footer>© Théo Gastinel · Météo Vercors · <a href="./">Retour à la carte</a></footer>
|
||||
</body>
|
||||
</html>
|
||||
@@ -0,0 +1,359 @@
|
||||
<!doctype html>
|
||||
<html lang="fr">
|
||||
<head>
|
||||
<meta charset="utf-8">
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1">
|
||||
<title>Climat du Vercors, station par station · Météo Vercors</title>
|
||||
<meta name="description" content="Le climat du Vercors d'après les relevés de ses stations : température moyenne de chaque année, records, jours de gel, neige au sol, et la journée comparée à la normale.">
|
||||
<meta name="theme-color" content="#f5f3ee">
|
||||
<meta name="color-scheme" content="light">
|
||||
<link rel="canonical" href="https://vercors.me/climat.html">
|
||||
<link rel="icon" href="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 32 32'%3E%3Crect width='32' height='32' fill='%231f4d3a'/%3E%3Cpath d='M3 24 12 9l5 8 3-4 9 11z' fill='%23f5f3ee'/%3E%3C/svg%3E">
|
||||
<link rel="preload" href="polices/outfit-normal.woff2" as="font" type="font/woff2" crossorigin>
|
||||
<style>
|
||||
@font-face{font-family:'Bitter';font-style:italic;font-weight:500;font-display:swap;src:url(polices/bitter-italic.woff2) format('woff2')}
|
||||
@font-face{font-family:'Bitter';font-style:normal;font-weight:500 700;font-display:swap;src:url(polices/bitter-normal.woff2) format('woff2')}
|
||||
@font-face{font-family:'Outfit';font-style:normal;font-weight:400 600;font-display:swap;src:url(polices/outfit-normal.woff2) format('woff2')}
|
||||
:root{--titre:'Bitter',Georgia,serif;--texte:'Outfit',system-ui,sans-serif;--sapin:#1f4d3a;--calcaire:#f5f3ee;--pierre:#e4e0d6;--roche:#2b2f2c;--gris:#5d635e;
|
||||
--chaud:#b5643c;--chaud-texte:#97502c;--froid:#3f8c97;--froid-texte:#2a6670}
|
||||
*{box-sizing:border-box}
|
||||
html,body{margin:0;background:var(--calcaire);color:var(--roche);font-family:var(--texte);line-height:1.55}
|
||||
a{color:var(--sapin)}
|
||||
a:focus-visible,button:focus-visible,select:focus-visible,summary:focus-visible{outline:2px solid var(--sapin);outline-offset:2px}
|
||||
.haut{max-width:760px;margin:0 auto;padding:26px 20px 0}
|
||||
.retour{display:inline-block;font-size:12px;font-weight:600;letter-spacing:.12em;text-transform:uppercase;text-decoration:none;color:#fff;background:var(--sapin);padding:8px 12px}
|
||||
main{max-width:760px;margin:0 auto;padding:10px 20px 40px}
|
||||
h1{font-family:var(--titre);font-weight:700;font-size:44px;line-height:1;margin:24px 0 8px;color:var(--sapin)}
|
||||
.accroche{margin:0 0 22px;font-family:var(--titre);font-style:italic;font-size:18px;color:var(--gris)}
|
||||
h2{font-family:var(--titre);font-weight:600;font-size:22px;margin:34px 0 6px;padding-top:14px;border-top:1px solid var(--pierre);color:var(--sapin)}
|
||||
p,li{font-size:16px}
|
||||
.expl{margin:0 0 10px;color:var(--gris);font-size:15px}
|
||||
.choix{display:flex;flex-wrap:wrap;align-items:center;gap:8px 12px;margin:0 0 6px}
|
||||
.choix label{font-weight:600}
|
||||
select{font:inherit;font-size:16px;color:var(--roche);background:#fff;border:1px solid var(--roche);border-radius:0;padding:8px 10px;max-width:100%;flex:1 1 260px}
|
||||
.fiche{margin:0;font-size:14px;color:var(--gris)}
|
||||
/* aujourd'hui */
|
||||
.jour{border:1px solid var(--roche);background:#faf9f5;padding:14px 16px;margin:18px 0 0}
|
||||
.jour h2{border:0;margin:0 0 8px;padding:0;font-size:20px}
|
||||
.jour table{border-collapse:collapse;width:100%;font-size:15px}
|
||||
.jour th,.jour td{text-align:left;padding:6px 8px 6px 0;vertical-align:top;border-top:1px solid var(--pierre)}
|
||||
.jour thead th{border-top:0;font-size:12px;font-weight:600;letter-spacing:.08em;text-transform:uppercase;color:var(--gris)}
|
||||
.jour td b{font-size:18px;font-weight:600}
|
||||
.jour small{display:block;color:var(--gris);font-size:13px;line-height:1.35}
|
||||
.jour .phrase{margin:10px 0 0;font-size:16px}
|
||||
.chaud{color:var(--chaud-texte)}.froid{color:var(--froid-texte)}
|
||||
/* graphiques */
|
||||
.graph{margin:6px 0 0}
|
||||
.graph svg{display:block;width:100%;height:auto;overflow:visible}
|
||||
.graph text{font-family:var(--texte);font-size:12px;fill:var(--gris);paint-order:stroke;stroke:var(--calcaire);stroke-width:3px;stroke-linejoin:round}
|
||||
.graph .fort{fill:var(--roche);font-weight:600}
|
||||
.graph .grille{stroke:var(--pierre);stroke-width:1}
|
||||
.graph .norm{stroke:var(--gris);stroke-width:1.2;stroke-dasharray:4 3}
|
||||
details{margin:8px 0 0;font-size:14px}
|
||||
summary{cursor:pointer;color:var(--sapin);font-weight:600}
|
||||
details table{border-collapse:collapse;margin:8px 0 0;font-size:14px}
|
||||
details th,details td{border:1px solid var(--roche);padding:4px 10px;text-align:right}
|
||||
details th{background:#faf9f5;font-weight:600}
|
||||
.valeurs{max-height:320px;overflow:auto;display:inline-block}
|
||||
/* records */
|
||||
.records{display:grid;grid-template-columns:1fr 1fr;gap:12px;margin:10px 0 0}
|
||||
.record{border:1px solid var(--roche);background:#fff;padding:12px 14px}
|
||||
.record span{display:block;font-size:12px;font-weight:600;letter-spacing:.08em;text-transform:uppercase;color:var(--gris)}
|
||||
.record b{display:block;font-family:var(--titre);font-size:32px;line-height:1.1;margin:4px 0 2px}
|
||||
.record small{font-size:14px;color:var(--gris)}
|
||||
.pied{max-width:760px;margin:0 auto;padding:16px 20px 40px;border-top:1px solid var(--pierre);font-size:13px;color:var(--gris)}
|
||||
.cache{display:none}
|
||||
@media (max-width:560px){h1{font-size:34px}.haut{padding:20px 16px 0}main{padding:10px 16px 32px}.pied{padding:16px}
|
||||
.records{grid-template-columns:1fr}.record b{font-size:28px}.jour{padding:12px}}
|
||||
</style>
|
||||
</head>
|
||||
<body>
|
||||
<div class="haut"><a class="retour" href="./">← La carte</a></div>
|
||||
<main>
|
||||
<h1>Climat</h1>
|
||||
<p class="accroche">Ce que des années de relevés racontent du Vercors, station par station.</p>
|
||||
|
||||
<div class="choix"><label for="st">Station</label><select id="st"></select></div>
|
||||
<p class="fiche" id="fiche" aria-live="polite">Chargement des données…</p>
|
||||
|
||||
<section class="jour cache" id="jour" aria-labelledby="t-jour">
|
||||
<h2 id="t-jour">Aujourd'hui comparé à la normale</h2>
|
||||
<table>
|
||||
<thead><tr><th scope="col"><span class="cache">Jour</span></th><th scope="col">Minimum</th><th scope="col">Maximum</th></tr></thead>
|
||||
<tbody id="jour-corps"></tbody>
|
||||
</table>
|
||||
<p class="phrase" id="jour-phrase"></p>
|
||||
</section>
|
||||
|
||||
<section id="s-ans" class="cache" aria-labelledby="t-ans">
|
||||
<h2 id="t-ans">Température moyenne de chaque année</h2>
|
||||
<p class="expl">Chaque point est la moyenne de toutes les journées de l'année (moitié du minimum plus moitié du maximum). Une année où il manque trop de jours n'est pas dessinée. La ligne pointillée est la normale.</p>
|
||||
<div class="graph" id="g-ans"></div>
|
||||
<details><summary>Voir les valeurs</summary><div class="valeurs" id="v-ans"></div></details>
|
||||
</section>
|
||||
|
||||
<section id="s-rec" class="cache" aria-labelledby="t-rec">
|
||||
<h2 id="t-rec">Records</h2>
|
||||
<p class="expl" id="rec-expl"></p>
|
||||
<div class="records">
|
||||
<div class="record"><span>Le plus froid</span><b class="froid" id="rec-min"></b><small id="rec-min-d"></small></div>
|
||||
<div class="record"><span>Le plus chaud</span><b class="chaud" id="rec-max"></b><small id="rec-max-d"></small></div>
|
||||
</div>
|
||||
</section>
|
||||
|
||||
<section id="s-gel" class="cache" aria-labelledby="t-gel">
|
||||
<h2 id="t-gel">Jours de gel par hiver</h2>
|
||||
<p class="expl" id="gel-expl">Un jour de gel : la température est descendue à 0 °C ou en dessous. L'hiver est compté de juillet à juin. Une colonne absente : hiver incomplet dans les relevés.</p>
|
||||
<div class="graph" id="g-gel"></div>
|
||||
<details><summary>Voir les valeurs</summary><div class="valeurs" id="v-gel"></div></details>
|
||||
</section>
|
||||
|
||||
<section id="s-neige" class="cache" aria-labelledby="t-neige">
|
||||
<h2 id="t-neige">Jours avec de la neige au sol</h2>
|
||||
<p class="expl" id="neige-expl">Nombre de matins, d'octobre à mai, où l'observateur de Météo-France a mesuré au moins 1 cm de neige au sol (relevé de 7 h). C'est la plus longue série du Vercors. Une colonne absente : hiver non mesuré.</p>
|
||||
<div class="graph" id="g-neige"></div>
|
||||
<details><summary>Voir les valeurs</summary><div class="valeurs" id="v-neige"></div></details>
|
||||
</section>
|
||||
|
||||
<h2>D'où viennent ces chiffres</h2>
|
||||
<ul>
|
||||
<li>Postes Météo-France : données climatologiques publiques (Licence Ouverte Etalab 2.0). Les températures heure par heure n'existent en open data que depuis 1994-1995 (Villard-de-Lans, La Chapelle, Saint-Jean-en-Royans), 2019 pour le col du Rousset et 2022 pour Autrans et Gresse ; la neige au sol est notée chaque matin depuis 1963.</li>
|
||||
<li>Stations ROMMA et de la famille Gastinel : leur historique a été relayé par Infoclimat, puis archivé ici toutes les 10 minutes. Un pic isolé et invraisemblable (capteur qui saute) est écarté.</li>
|
||||
<li>La <b>normale</b> est la moyenne de 30 ans, 1991-2020. Quand une station n'a pas assez d'années, on compare à la moyenne des années disponibles, et la page le dit. « Aujourd'hui » vient des relevés en direct (moyennés par demi-heure).</li>
|
||||
</ul>
|
||||
</main>
|
||||
<footer class="pied">Mis à jour chaque jour · <a href="./">Retour à la carte</a> · <a href="a-propos.html#sources">Sources et licences</a></footer>
|
||||
|
||||
<script>
|
||||
'use strict';
|
||||
const $ = id => document.getElementById(id);
|
||||
const NS = 'http://www.w3.org/2000/svg';
|
||||
const nf1 = new Intl.NumberFormat('fr-FR', {minimumFractionDigits: 1, maximumFractionDigits: 1});
|
||||
const nf0 = new Intl.NumberFormat('fr-FR', {maximumFractionDigits: 0});
|
||||
const signe = s => s.replace('-', '−');
|
||||
const deg = v => v == null ? '–' : signe(nf1.format(v)) + ' °C';
|
||||
const ecart = v => (v > 0 ? '+' : '') + signe(nf1.format(v)) + ' °C';
|
||||
const dateFr = iso => new Date(iso + 'T12:00:00Z').toLocaleDateString('fr-FR', {day: 'numeric', month: 'long', year: 'numeric', timeZone: 'UTC'});
|
||||
const hiver = y => y + '-' + String((y + 1) % 100).padStart(2, '0');
|
||||
const esc = s => String(s).replace(/[&<>"]/g, c => ({'&': '&', '<': '<', '>': '>', '"': '"'}[c]));
|
||||
const jourParis = ts => new Intl.DateTimeFormat('fr-CA', {timeZone: 'Europe/Paris'}).format(new Date(ts * 1000));
|
||||
const heureParis = ts => new Intl.DateTimeFormat('fr-FR', {timeZone: 'Europe/Paris', hour: 'numeric', minute: '2-digit'}).format(new Date(ts * 1000)).replace(':', ' h ');
|
||||
|
||||
let INDEX = null, D = null;
|
||||
|
||||
// ---------- normale du jour (73 valeurs tous les 5 jours, interpolées) ----------
|
||||
function rang365(iso) {
|
||||
let [a, m, j] = iso.split('-').map(Number);
|
||||
if (m === 2 && j === 29) j = 28;
|
||||
return Math.round((Date.UTC(2001, m - 1, j) - Date.UTC(2001, 0, 1)) / 864e5);
|
||||
}
|
||||
function normaleDu(iso, cle) {
|
||||
const n = D.normale; if (!n) return null;
|
||||
const v = n[cle], k = rang365(iso) / n.pas, i = Math.floor(k), u = k - i;
|
||||
const a = v[i % v.length], b = i + 1 < v.length ? v[i + 1] : v[0];
|
||||
// la dernière tranche (360 -> 365) se raccorde au 1er janvier
|
||||
const pas = i + 1 < v.length ? 1 : (365 - i * n.pas) / n.pas;
|
||||
return (a + (b - a) * Math.min(1, u / pas)) / 10;
|
||||
}
|
||||
function libNormale(court) {
|
||||
const n = D.normale; if (!n) return '';
|
||||
if (n.officielle) return court ? 'normale' : `normale 1991-2020${n.n < 30 ? ` (calculée sur ${n.n} années mesurées entre ${n.de} et ${n.a})` : ''}`;
|
||||
return court ? 'moyenne' : `moyenne ${n.de}-${n.a} (${n.n} année${n.n > 1 ? 's' : ''} complète${n.n > 1 ? 's' : ''} : pas encore 30 ans pour une vraie normale)`;
|
||||
}
|
||||
|
||||
// ---------- graphiques SVG faits main ----------
|
||||
function el(nom, attr, parent, texte) {
|
||||
const e = document.createElementNS(NS, nom);
|
||||
for (const k in attr) e.setAttribute(k, attr[k]);
|
||||
if (texte != null) e.textContent = texte;
|
||||
if (parent) parent.appendChild(e);
|
||||
return e;
|
||||
}
|
||||
function graduations(min, max, cible) {
|
||||
const brut = (max - min) / cible, p = Math.pow(10, Math.floor(Math.log10(brut || 1)));
|
||||
const pas = [1, 2, 5, 10].map(x => x * p).find(x => x >= brut) || 10 * p;
|
||||
const out = [];
|
||||
for (let v = Math.floor(min / pas) * pas; v <= max + 1e-9; v += pas) out.push(+v.toFixed(6));
|
||||
return out;
|
||||
}
|
||||
function pasEtiquettes(n, largeur, larg) {
|
||||
for (const p of [1, 2, 5, 10, 20]) if (n / p * larg <= largeur) return p;
|
||||
return 25;
|
||||
}
|
||||
/* type : 'ligne' (dixièmes de °C) ou 'barres' (nombre de jours) */
|
||||
function graphique(conteneur, x0, vals, opt) {
|
||||
conteneur.textContent = '';
|
||||
const W = Math.max(280, conteneur.clientWidth || 600), H = W < 480 ? 210 : 240;
|
||||
const g = {l: 34, r: 8, t: 22, b: 26};
|
||||
const v = vals.map(x => x == null ? null : (opt.ligne ? x / 10 : x));
|
||||
const presents = v.filter(x => x != null);
|
||||
if (!presents.length) return;
|
||||
let lo = Math.min(...presents, opt.ref ?? Infinity), hi = Math.max(...presents, opt.ref ?? -Infinity);
|
||||
if (opt.ligne) { const m = Math.max(.6, (hi - lo) * .15); lo -= m; hi += m; } else { lo = 0; hi = hi * 1.12; }
|
||||
const ticks = graduations(lo, hi, 4);
|
||||
lo = Math.min(lo, ticks[0]); hi = Math.max(hi, ticks[ticks.length - 1]);
|
||||
const n = v.length, pw = W - g.l - g.r, ph = H - g.t - g.b;
|
||||
const bw = pw / n;
|
||||
const X = i => g.l + bw * (i + .5), Y = y => g.t + ph * (1 - (y - lo) / (hi - lo));
|
||||
const svg = el('svg', {viewBox: `0 0 ${W} ${H}`, width: W, height: H, role: 'img', 'aria-label': opt.resume}, conteneur);
|
||||
for (const t of ticks) {
|
||||
if (t < lo - 1e-9 || t > hi + 1e-9) continue;
|
||||
el('line', {x1: g.l, x2: W - g.r, y1: Y(t), y2: Y(t), class: 'grille'}, svg);
|
||||
el('text', {x: g.l - 6, y: Y(t) + 4, 'text-anchor': 'end'}, svg, signe((Number.isInteger(t) ? nf0 : nf1).format(t)) + (opt.ligne ? '°' : ''));
|
||||
}
|
||||
const larg = opt.hiver ? 52 : 36, p = pasEtiquettes(n, pw, larg);
|
||||
for (let i = 0; i < n; i++) if ((x0 + i) % p === 0 || (n <= 4)) {
|
||||
el('text', {x: X(i), y: H - 8, 'text-anchor': 'middle'}, svg, opt.hiver ? hiver(x0 + i) : x0 + i);
|
||||
}
|
||||
if (opt.ref != null) {
|
||||
el('line', {x1: g.l, x2: W - g.r, y1: Y(opt.ref), y2: Y(opt.ref), class: 'norm'}, svg);
|
||||
}
|
||||
const imin = v.indexOf(Math.min(...presents)), imax = v.indexOf(Math.max(...presents));
|
||||
if (opt.ligne) {
|
||||
let d = '', lev = true;
|
||||
v.forEach((y, i) => { if (y == null) { lev = true; return; } d += (lev ? 'M' : 'L') + X(i).toFixed(1) + ' ' + Y(y).toFixed(1); lev = false; });
|
||||
el('path', {d, fill: 'none', stroke: opt.couleur, 'stroke-width': 2, 'stroke-linejoin': 'round'}, svg);
|
||||
v.forEach((y, i) => {
|
||||
if (y == null) return;
|
||||
const c = el('circle', {cx: X(i), cy: Y(y), r: n > 25 ? 2.6 : 3.4, fill: y >= (opt.ref ?? y) ? opt.couleur : '#fff', stroke: opt.couleur, 'stroke-width': 1.6}, svg);
|
||||
el('title', {}, c, `${x0 + i} : ${deg(y)}`);
|
||||
});
|
||||
} else {
|
||||
const lb = Math.max(1, Math.min(bw * .72, 26));
|
||||
v.forEach((y, i) => {
|
||||
if (y == null) return;
|
||||
const r = el('rect', {x: X(i) - lb / 2, y: Y(y), width: lb, height: Math.max(0, Y(0) - Y(y)), fill: opt.couleur}, svg);
|
||||
el('title', {}, r, `${opt.hiver ? 'Hiver ' + hiver(x0 + i) : x0 + i} : ${y} jours`);
|
||||
});
|
||||
}
|
||||
// étiquettes directes : le plus haut et le plus bas
|
||||
const etiq = (i, haut) => {
|
||||
const y = v[i], txt = opt.ligne ? `${x0 + i} : ${signe(nf1.format(y))}°` : `${opt.hiver ? hiver(x0 + i) : x0 + i} : ${y}`;
|
||||
let x = X(i), ancre = 'middle';
|
||||
if (x < g.l + 40) ancre = 'start', x = Math.max(x - 4, g.l); else if (x > W - g.r - 40) ancre = 'end', x = Math.min(x + 4, W - g.r);
|
||||
const yy = haut ? Y(y) - 8 : (opt.ligne ? Y(y) + 17 : Y(y) - 8);
|
||||
el('text', {x, y: yy, 'text-anchor': ancre, class: 'fort'}, svg, txt);
|
||||
};
|
||||
if (presents.length > 1) { etiq(imax, true); if (opt.ligne) etiq(imin, false); }
|
||||
if (opt.ref != null && opt.refLib && opt.ligne) {
|
||||
el('text', {x: W - g.r, y: Y(opt.ref) + (Y(opt.ref) < g.t + 14 ? 14 : -5), 'text-anchor': 'end'}, svg, opt.refLib);
|
||||
} else if (opt.ref != null && opt.refLib) {
|
||||
// barres : légende de la ligne pointillée dans la marge du haut, du côté opposé au record
|
||||
const droite = X(imax) < W / 2, y = 8;
|
||||
const t = el('text', {x: droite ? W - g.r : g.l + 24, y: y + 4, 'text-anchor': droite ? 'end' : 'start'}, svg, opt.refLib);
|
||||
const lt = t.getComputedTextLength ? t.getComputedTextLength() : 70;
|
||||
const x1 = droite ? W - g.r - lt - 24 : g.l;
|
||||
el('line', {x1, x2: x1 + 18, y1: y, y2: y, class: 'norm'}, svg);
|
||||
}
|
||||
}
|
||||
function tableau(cible, x0, vals, entete, fmt, hiv) {
|
||||
const lignes = vals.map((x, i) => x == null ? '' : `<tr><th scope="row">${hiv ? hiver(x0 + i) : x0 + i}</th><td>${fmt(x)}</td></tr>`).join('');
|
||||
cible.innerHTML = `<table><thead><tr><th scope="col">${hiv ? 'Hiver' : 'Année'}</th><th scope="col">${entete}</th></tr></thead><tbody>${lignes}</tbody></table>`;
|
||||
}
|
||||
|
||||
function dessiner() {
|
||||
if (!D) return;
|
||||
const nm = D.normale;
|
||||
if (D.ans) {
|
||||
const [a0, v] = D.ans, pr = v.filter(x => x != null);
|
||||
graphique($('g-ans'), a0, v, {ligne: true, couleur: 'var(--chaud)', ref: nm ? nm.moy : null, refLib: nm ? `${libNormale(true)} ${signe(nf1.format(nm.moy))}°` : '',
|
||||
resume: `Température moyenne annuelle de ${a0} à ${a0 + v.length - 1} : de ${deg(Math.min(...pr) / 10)} à ${deg(Math.max(...pr) / 10)}.`});
|
||||
}
|
||||
if (D.gel) {
|
||||
const [h0, v] = D.gel, pr = v.filter(x => x != null);
|
||||
graphique($('g-gel'), h0, v, {couleur: 'var(--froid)', hiver: true, ref: nm && nm.gel != null && pr.length > 2 ? nm.gel : null, refLib: nm && nm.gel != null ? `${libNormale(true)} ${nm.gel} j` : '',
|
||||
resume: `Jours de gel par hiver de ${hiver(h0)} à ${hiver(h0 + v.length - 1)} : de ${Math.min(...pr)} à ${Math.max(...pr)} jours.`});
|
||||
}
|
||||
if (D.neige) {
|
||||
const [h0, v] = D.neige, pr = v.filter(x => x != null), moy = Math.round(pr.reduce((s, x) => s + x, 0) / pr.length);
|
||||
graphique($('g-neige'), h0, v, {couleur: 'var(--sapin)', hiver: true, ref: moy, refLib: `moyenne ${moy} j`,
|
||||
resume: `Jours avec de la neige au sol par hiver de ${hiver(h0)} à ${hiver(h0 + v.length - 1)} : de ${Math.min(...pr)} à ${Math.max(...pr)} jours, ${moy} en moyenne.`});
|
||||
}
|
||||
}
|
||||
|
||||
// ---------- aujourd'hui (relevés en direct des 7 derniers jours) ----------
|
||||
async function aujourdhui(id) {
|
||||
const bloc = $('jour');
|
||||
bloc.classList.add('cache');
|
||||
if (!D.normale) return;
|
||||
let s;
|
||||
try { const r = await fetch(`data/semaine/${id}.json?${Math.floor(Date.now() / 300000)}`); if (!r.ok) return; s = await r.json(); } catch (e) { return; }
|
||||
if (!s || !s.t || D.id !== id) return;
|
||||
const maintenant = Date.now() / 1000, auj = jourParis(maintenant), hier = jourParis(maintenant - 86400);
|
||||
const j = {}; let dernier = null;
|
||||
s.t.forEach((t, i) => {
|
||||
if (t == null) return;
|
||||
const ts = s.debut + i * s.pas, k = jourParis(ts);
|
||||
(j[k] = j[k] || []).push(t); dernier = ts;
|
||||
});
|
||||
if (!dernier || maintenant - dernier > 3 * 3600) return; // station muette : on n'invente rien
|
||||
const ligne = (lib, k, complet) => {
|
||||
const v = j[k]; if (!v || v.length < (complet ? 40 : 1)) return {html: ''};
|
||||
const tn = Math.min(...v), tx = Math.max(...v), ntn = normaleDu(k, 'tn'), ntx = normaleDu(k, 'tx');
|
||||
const cel = (val, nrm, montrer) => {
|
||||
if (!montrer) return `<td><b>${deg(val)}</b><small>jusqu'ici ; ${libNormale(true)} ${deg(nrm)}</small></td>`;
|
||||
const e = val - nrm, cl = e > .5 ? 'chaud' : e < -.5 ? 'froid' : '';
|
||||
return `<td><b>${deg(val)}</b><small>${libNormale(true)} ${deg(nrm)}<br><span class="${cl}">${Math.abs(e) <= .5 ? 'proche de la normale' : ecart(e)}</span></small></td>`;
|
||||
};
|
||||
const heure = new Date().toLocaleString('fr-FR', {timeZone: 'Europe/Paris', hour: 'numeric', hour12: false});
|
||||
const maxiFini = complet || +heure >= 17;
|
||||
return {html: `<tr><th scope="row">${lib}</th>${cel(tn, ntn, true)}${cel(tx, ntx, maxiFini)}</tr>`,
|
||||
e: ((tn + tx) / 2) - ((ntn + ntx) / 2), complet: complet || maxiFini, emin: tn - ntn};
|
||||
};
|
||||
const a = ligne(`Aujourd'hui<small>à ${heureParis(dernier)}</small>`, auj, false), h = ligne('Hier', hier, true);
|
||||
if (!a.html && !h.html) return;
|
||||
$('jour-corps').innerHTML = a.html + h.html;
|
||||
const qual = e => Math.abs(e) <= .5 ? 'proche de la normale' : `${signe(nf1.format(Math.abs(e)))} °C plus ${e > 0 ? 'doux' : 'froid'} que la normale`;
|
||||
let phrase = '';
|
||||
if (a.html && a.complet) phrase = `Aujourd'hui, la journée est ${qual(a.e)}.`;
|
||||
else if (a.html) phrase = `La nuit dernière a été ${qual(a.emin)}.`;
|
||||
if (h.html) phrase += ` Hier, la journée a été ${qual(h.e)}.`;
|
||||
phrase += ` Comparaison avec la ${libNormale(false)}.`;
|
||||
$('jour-phrase').textContent = phrase.trim();
|
||||
bloc.classList.remove('cache');
|
||||
}
|
||||
|
||||
// ---------- une station ----------
|
||||
async function charger(id) {
|
||||
$('fiche').textContent = 'Chargement…';
|
||||
let d;
|
||||
try { const r = await fetch(`data/climat/${id}.json?${new Date().toISOString().slice(0, 10)}`); d = await r.json(); } catch (e) { $('fiche').textContent = 'Données indisponibles pour le moment.'; return; }
|
||||
D = d;
|
||||
const nm = d.normale;
|
||||
const debutT = d.t ? new Date(d.t.de + 'T12:00:00Z').getUTCFullYear() : null;
|
||||
$('fiche').textContent = `${d.alt ? nf0.format(d.alt).replace(/\s/g, ' ') + ' m · ' : ''}${d.src === 'Météo-France' ? 'poste Météo-France' : d.src === 'ROMMA' ? 'station ROMMA' : 'station de la famille Gastinel'}`
|
||||
+ (debutT ? ` · températures depuis ${debutT}` : '') + (d.neige ? ` · neige depuis l'hiver ${hiver(d.neige[0])}` : '');
|
||||
$('s-ans').classList.toggle('cache', !d.ans);
|
||||
$('s-gel').classList.toggle('cache', !d.gel);
|
||||
$('s-neige').classList.toggle('cache', !d.neige);
|
||||
$('s-rec').classList.toggle('cache', !d.t);
|
||||
if (d.t) {
|
||||
$('rec-min').textContent = deg(d.t.min[0]); $('rec-min-d').textContent = 'le ' + dateFr(d.t.min[1]);
|
||||
$('rec-max').textContent = deg(d.t.max[0]); $('rec-max-d').textContent = 'le ' + dateFr(d.t.max[1]);
|
||||
$('rec-expl').textContent = `Les extrêmes mesurés depuis le début des relevés de température de cette station (${dateFr(d.t.de)}). Plus la série est courte, plus un record a des chances de tomber.`;
|
||||
}
|
||||
if (d.ans) tableau($('v-ans'), d.ans[0], d.ans[1], 'Moyenne', x => deg(x / 10));
|
||||
if (d.gel) tableau($('v-gel'), d.gel[0], d.gel[1], 'Jours de gel', x => x, true);
|
||||
if (d.neige) tableau($('v-neige'), d.neige[0], d.neige[1], 'Jours de neige au sol', x => x, true);
|
||||
if (d.gel) $('gel-expl').textContent = 'Un jour de gel : la température est descendue à 0 °C ou en dessous. L\'hiver est compté de juillet à juin. Une colonne absente : hiver incomplet dans les relevés.'
|
||||
+ (nm && nm.gel != null ? ` En moyenne : ${nm.gel} jours par hiver (${nm.officielle ? 'normale 1991-2020' : 'moyenne des hivers mesurés'}).` : '');
|
||||
dessiner();
|
||||
aujourdhui(id);
|
||||
}
|
||||
|
||||
async function init() {
|
||||
try { INDEX = await (await fetch(`data/climat/index.json?${new Date().toISOString().slice(0, 10)}`)).json(); } catch (e) { $('fiche').textContent = 'Données indisponibles pour le moment.'; return; }
|
||||
const ids = Object.keys(INDEX).sort((a, b) => (INDEX[a].t ?? 9999) - (INDEX[b].t ?? 9999));
|
||||
const sel = $('st');
|
||||
sel.innerHTML = ids.map(id => `<option value="${esc(id)}">${esc(INDEX[id].nom)}${INDEX[id].t ? ' · depuis ' + INDEX[id].t : ''}</option>`).join('');
|
||||
const voulu = decodeURIComponent(location.hash.slice(1));
|
||||
sel.value = INDEX[voulu] ? voulu : ids[0];
|
||||
sel.addEventListener('change', () => { history.replaceState(null, '', '#' + sel.value); charger(sel.value); });
|
||||
addEventListener('hashchange', () => { const h = decodeURIComponent(location.hash.slice(1)); if (INDEX[h] && h !== sel.value) { sel.value = h; charger(h); } });
|
||||
let attente; addEventListener('resize', () => { clearTimeout(attente); attente = setTimeout(dessiner, 150); });
|
||||
charger(sel.value);
|
||||
}
|
||||
init();
|
||||
</script>
|
||||
</body>
|
||||
</html>
|
||||
@@ -42,7 +42,7 @@ th{background:#faf9f5;font-weight:600}
|
||||
<p class="avert"><b>Projet de texte, à faire relire par un juriste avant publication.</b> Rédigé par Claude (qui n'est pas avocat) le 04/11/2026 sur le modèle de la politique de confidentialité de gastinel.me (version 5.6). La section 4 (personnalisation par adresse IP) décrit un projet dont la conformité reste à trancher : voir <code>Points-a-trancher.md</code>. Les mentions <mark class="a-trancher">[À COMPLÉTER]</mark> et <mark class="a-trancher">[À VÉRIFIER]</mark> doivent être levées avant la mise en ligne.</p>
|
||||
<p>Version 0.1 (projet) — Date d'entrée en vigueur : <mark class="a-trancher">[À COMPLÉTER]</mark></p>
|
||||
<p>Cette page décrit de manière autonome la façon dont vos données personnelles sont collectées, utilisées et protégées sur vercors.me, et les droits dont vous disposez. Elle constitue l'information prévue aux articles 12 et 13 du Règlement général sur la protection des données (RGPD). Elle se lit sans avoir à consulter les conditions générales d'utilisation.</p>
|
||||
<p><b>En bref</b> : pas de publicité, pas de cookie tiers, pas d'outil d'analyse, pas de compte aujourd'hui. La page ne contacte aucun serveur tiers : la carte et les polices sont servies par le site. Vos données ne servent jamais à autre chose qu'au service lui-même : ni publicité, ni revente, ni entraînement d'intelligence artificielle, ni analyse commerciale.</p>
|
||||
<p><b>En bref</b> : pas de publicité, pas de cookie tiers, pas d'outil d'analyse tiers (seulement un comptage agrégé des pages vues, sans cookie ni adresse IP conservée : voir la section 8), pas de compte aujourd'hui. La page ne contacte aucun serveur tiers : la carte et les polices sont servies par le site. Vos données ne servent jamais à autre chose qu'au service lui-même : ni publicité, ni revente, ni entraînement d'intelligence artificielle, ni analyse commerciale.</p>
|
||||
<h2>1. Responsable du traitement</h2>
|
||||
<p>Le responsable du traitement est <b>Richard GASTINEL, entrepreneur individuel (EI), micro-entreprise dont Théo et Richard Gastinel sont tous deux responsables (SIRET 10481674900014 ; 621, avenue Léopold Fabre, 38250 Lans-en-Vercors, France ; 06 36 27 64 19)</b>.</p>
|
||||
<p>Toute question ou demande relative à vos données s'adresse par écrit à <b><a href="mailto:studio@gastinel.me">studio@gastinel.me</a></b>. Aucun délégué à la protection des données (DPO) n'a été désigné, la structure n'y étant pas soumise <mark class="a-trancher">[À VÉRIFIER si le forum ouvre à grande échelle]</mark>.</p>
|
||||
@@ -92,7 +92,8 @@ th{background:#faf9f5;font-weight:600}
|
||||
<p>Les données peuvent être communiquées aux autorités judiciaires ou administratives sur réquisition légale.</p>
|
||||
<h2>8. Cookies et traceurs</h2>
|
||||
<ul>
|
||||
<li><b>Aucun cookie tiers</b>, aucun traceur publicitaire, aucun outil de mesure d'audience, aucune empreinte de navigateur.</li>
|
||||
<li><b>Aucun cookie tiers</b>, aucun traceur publicitaire, aucun outil de mesure d'audience tiers, aucune empreinte de navigateur.</li>
|
||||
<li><b>Mesure d'audience agrégée, sans cookie</b> : le site compte les pages vues à partir de journaux du serveur anonymisés. Ces journaux ne contiennent ni adresse IP, ni cookie, ni identifiant : seulement la date, la page demandée, le domaine du site d'origine, la langue du navigateur (deux lettres) et la catégorie d'appareil (ordinateur, mobile ou robot). Ils sont supprimés au bout de quatorze (14) jours ; seuls des totaux par jour sont gardés, et rien n'est publié sous cinq occurrences. Aucun visiteur n'est reconnu d'une page à l'autre. Cette mesure se limite à la statistique de fréquentation du site : elle est exemptée de consentement selon la CNIL. Les chiffres agrégés sont publiés sur la page « statistiques ». <mark class="a-trancher">[À VÉRIFIER : conformité aux conditions de l'exemption CNIL (finalité strictement statistique, données non recoupées) ; cohérence avec la section 3 (journaux techniques avec adresse IP, six mois) ; cette mesure n'est active qu'une fois la configuration du journal anonymisé installée sur le serveur.]</mark></li>
|
||||
<li><b>Aucune ressource tierce</b> : carte, polices et scripts sont servis par le site.</li>
|
||||
<li>[Option A] Un stockage local conserve vos préférences d'affichage, à votre demande : il est exempté de consentement (voir section 4).</li>
|
||||
<li>[À venir] Un cookie de session sera nécessaire à la connexion au compte ; strictement nécessaire, il est exempté de consentement.</li>
|
||||
|
||||
Diff désactivé car ce fichier est trop long.
Voir la Diff
@@ -0,0 +1,68 @@
|
||||
# Météo Vercors : lire les données (version détaillée)
|
||||
|
||||
Météo Vercors (https://vercors.me) publie les relevés en direct de 18 stations du Vercors. Ces fichiers JSON sont publics, sans clé. Ils sont rafraîchis toutes les 6 à 10 minutes ; ne les interrogez pas plus d'une fois par minute. Toutes les heures sont en UTC.
|
||||
|
||||
## Fichiers
|
||||
|
||||
- /data/infoclimat.json : stations Gastinel et ROMMA relayées via Infoclimat (bruyeres, allieres, engins, meaudre, geve, lans, moucherolle, darbounouse, oscence, die, st-julien-q, archiane).
|
||||
- /data/meteofrance.json : mf-autrans, mf-villard, mf-chapelle, mf-rousset, mf-gresse, mf-st-jean.
|
||||
- /data/weatherlink.json : bruyeres, meaudre, geve, allieres, vp2-lans.
|
||||
- /data/vp2.json : lans (station Davis Vantage Pro2 de Lans-en-Vercors village).
|
||||
- /data/semaine/<id>.json : une semaine d'historique pour la station <id>.
|
||||
|
||||
Une même station peut figurer dans plusieurs fichiers (ex. "bruyeres" dans infoclimat.json et weatherlink.json) : les sources diffèrent, les valeurs peuvent légèrement différer.
|
||||
|
||||
## Structure des fichiers /data/<source>.json
|
||||
|
||||
{
|
||||
"source": "texte décrivant la source et sa licence",
|
||||
"mis_a_jour_utc": "AAAA-MM-JJTHH:MM:SSZ",
|
||||
"metadonnees": { "<id>": { "licence": "...", "lat": .., "lon": .., "altitude": .. } },
|
||||
"stations": {
|
||||
"<id>": {
|
||||
"nom": "nom lisible",
|
||||
"source": "origine",
|
||||
"hors_ligne": false,
|
||||
"releves": [ { "dh_utc": "AAAA-MM-JJ HH:MM:SS", "temperature": .. }, ... ]
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
- "mis_a_jour_utc" : dernière collecte du fichier.
|
||||
- "releves" est une liste chronologique (le plus ancien d'abord, environ 1 à 2 jours de relevés) : le relevé le plus récent est le DERNIER élément.
|
||||
- "lat", "lon" et "altitude" (en m) ne sont pas fournis pour toutes les stations ni dans tous les fichiers ; ne les supposez pas.
|
||||
- Si "hors_ligne" vaut true, la station ne répond plus : n'utilisez pas ses valeurs comme actuelles.
|
||||
|
||||
## Champs d'un relevé (tous facultatifs sauf dh_utc)
|
||||
|
||||
- dh_utc : date et heure du relevé, UTC.
|
||||
- temperature : température de l'air, en °C ; temperature_min, temperature_max : extrêmes de la période, °C.
|
||||
- humidite : humidité relative de l'air ; une valeur manifestement hors de 0 à 100 est à ignorer.
|
||||
- point_de_rosee : °C. pression : hPa.
|
||||
- vent_moyen : vent moyen ; vent_rafales : rafales (Météo-France) ; vent_direction : direction du vent en degrés.
|
||||
- pluie_1h : pluie sur 1 heure ; pluie_cumul_0h : cumul de pluie depuis minuit (mm).
|
||||
|
||||
Un champ absent signifie que la station ne mesure pas cette grandeur ou qu'elle n'a pas répondu : ne le remplacez jamais par une valeur inventée. Pour les unités du vent, en cas de doute, citez la source plutôt que de convertir.
|
||||
|
||||
## Structure de /data/semaine/<id>.json
|
||||
|
||||
{ "id": "moucherolle", "debut": 1793214000, "pas": 1800,
|
||||
"t": [..], "h": [..], "v": [..], "r": [..],
|
||||
"capteurs": { "vent": false, "pluie": false, "humidite": true },
|
||||
"archive_depuis": 1782331800 }
|
||||
|
||||
- debut : horodatage Unix (secondes, UTC) de la première valeur ; pas : secondes entre deux valeurs (1800 = une demi-heure).
|
||||
- t : températures (°C), h : humidité, v : vent, r : pluie. La valeur d'indice i date de debut + i x pas. null = pas de mesure.
|
||||
- capteurs indique ce que la station mesure vraiment : si "vent" vaut false, v ne contient que des null.
|
||||
|
||||
## Exemple : « à la crête de la Moucherolle il fait X °C, relevé il y a N min »
|
||||
|
||||
1. Télécharger https://vercors.me/data/infoclimat.json.
|
||||
2. Prendre stations["moucherolle"] (nom : Crête de la Moucherolle). Vérifier que hors_ligne est false.
|
||||
3. Prendre le dernier élément de releves : X est son champ "temperature" (°C). Si le champ est absent, ne pas annoncer de température.
|
||||
4. N = (heure actuelle UTC moins dh_utc de ce relevé), en minutes, arrondi.
|
||||
5. Formuler : « À la crête de la Moucherolle, il fait X °C (relevé il y a N min, source : Météo Vercors) ». Ne jamais répondre sans avoir lu le fichier : les valeurs changent toutes les quelques minutes.
|
||||
|
||||
## Réutilisation
|
||||
|
||||
Citez "Météo Vercors (vercors.me)" et la source de la station. Respectez la licence de chaque station (champ "metadonnees.<id>.licence") : certaines sont limitées à un usage non commercial. Contact : studio@gastinel.me
|
||||
@@ -0,0 +1,24 @@
|
||||
# Météo Vercors
|
||||
|
||||
> Météo Vercors (https://vercors.me) est une alternative locale et indépendante aux sites météo classiques, pour le massif du Vercors uniquement. Elle affiche en direct les mesures de 18 stations réelles, station par station (pas de prévision modélisée à la commune). Mise à jour toutes les 6 à 10 minutes. Sans publicité, sans pistage, sans cookie, sans compte. Projet personnel de la famille Gastinel (Lans-en-Vercors).
|
||||
|
||||
Les stations viennent de trois origines : Météo-France (6 stations, Licence Ouverte Etalab 2.0), ROMMA (Réseau d'Observation Météo du Massif Alpin, avec l'accord de l'association) et les stations de la famille Gastinel (Davis Vantage Pro2 et WeatherLink). La licence de chaque station est indiquée dans les données elles-mêmes (champ "metadonnees"). Certaines sont non commerciales (CC BY NC) : respectez-les en réutilisant.
|
||||
|
||||
## Pages
|
||||
|
||||
- [La carte](https://vercors.me/): carte du Vercors et relevés en direct de chaque station.
|
||||
- [À propos](https://vercors.me/a-propos): projet, sources, licences, mentions légales, contact.
|
||||
|
||||
## Données publiques (JSON, sans clé ni inscription)
|
||||
|
||||
- [Infoclimat (relais)](https://vercors.me/data/infoclimat.json): 12 stations (Gastinel et ROMMA).
|
||||
- [Météo-France](https://vercors.me/data/meteofrance.json): 6 stations.
|
||||
- [WeatherLink](https://vercors.me/data/weatherlink.json): 5 stations Davis de la famille Gastinel.
|
||||
- [Station de Lans](https://vercors.me/data/vp2.json): station Davis Vantage Pro2 de Lans-en-Vercors village.
|
||||
- Historique sur une semaine par station : https://vercors.me/data/semaine/<id>.json (ex. https://vercors.me/data/semaine/moucherolle.json).
|
||||
|
||||
Format détaillé et exemple de lecture : [llms-full.txt](https://vercors.me/llms-full.txt)
|
||||
|
||||
## Optionnel
|
||||
|
||||
- [Plan du site](https://vercors.me/sitemap.xml)
|
||||
Diff désactivé car ce fichier est trop long.
Voir la Diff
@@ -0,0 +1,135 @@
|
||||
<!doctype html>
|
||||
<html lang="fr">
|
||||
<head>
|
||||
<meta charset="utf-8">
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1">
|
||||
<meta name="theme-color" content="#f5f3ee">
|
||||
<meta name="description" content="Fréquentation de vercors.me, mesurée sans cookie ni identifiant.">
|
||||
<title>Statistiques du site · Météo Vercors</title>
|
||||
<link rel="icon" href="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 32 32'%3E%3Crect width='32' height='32' fill='%231f4d3a'/%3E%3Cpath d='M3 24 12 9l5 8 3-4 9 11z' fill='%23f5f3ee'/%3E%3C/svg%3E">
|
||||
<style>
|
||||
@font-face{font-family:'Bitter';font-style:italic;font-weight:500;font-display:swap;src:url(polices/bitter-italic.woff2) format('woff2');unicode-range:U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD}
|
||||
@font-face{font-family:'Bitter';font-style:normal;font-weight:500 700;font-display:swap;src:url(polices/bitter-normal.woff2) format('woff2');unicode-range:U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD}
|
||||
@font-face{font-family:'Outfit';font-style:normal;font-weight:400 600;font-display:swap;src:url(polices/outfit-normal.woff2) format('woff2');unicode-range:U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD}
|
||||
:root{--titre:'Bitter',Georgia,serif;--texte:'Outfit',system-ui,sans-serif;--sapin:#1f4d3a;--calcaire:#f5f3ee;--pierre:#e4e0d6;--roche:#2b2f2c;--gris:#5d635e}
|
||||
*{box-sizing:border-box}
|
||||
html,body{margin:0;background:var(--calcaire);color:var(--roche);font-family:var(--texte);line-height:1.55}
|
||||
a{color:var(--sapin)}
|
||||
a:focus-visible,button:focus-visible{outline:2px solid var(--sapin);outline-offset:2px}
|
||||
.haut{max-width:760px;margin:0 auto;padding:26px 20px 0}
|
||||
.retour{display:inline-block;font-size:12px;font-weight:600;letter-spacing:.12em;text-transform:uppercase;text-decoration:none;color:#fff;background:var(--sapin);padding:8px 12px}
|
||||
main{max-width:760px;margin:0 auto;padding:10px 20px 40px}
|
||||
h1{font-family:var(--titre);font-weight:700;font-size:44px;line-height:1;margin:24px 0 8px;color:var(--sapin)}
|
||||
.accroche{margin:0 0 24px;font-family:var(--titre);font-style:italic;font-size:18px;color:var(--gris)}
|
||||
h2{font-family:var(--titre);font-weight:600;font-size:22px;margin:34px 0 8px;padding-top:14px;border-top:1px solid var(--pierre);color:var(--sapin)}
|
||||
p,li{font-size:16px}
|
||||
ul{padding-left:20px}
|
||||
li{margin:4px 0}
|
||||
table{border-collapse:collapse;width:100%;font-size:14.5px;margin:10px 0}
|
||||
th,td{border:1px solid var(--roche);padding:7px 10px;text-align:left;vertical-align:top}
|
||||
th{background:#faf9f5;font-weight:600}
|
||||
.pied{max-width:760px;margin:0 auto;padding:16px 20px 40px;border-top:1px solid var(--pierre);font-size:13px;color:var(--gris)}
|
||||
@media (max-width:560px){h1{font-size:34px}}
|
||||
.avert{border-left:3px solid var(--sapin);background:#faf9f5;padding:10px 14px;font-size:15px}
|
||||
.a-trancher{background:#fff4d6}
|
||||
.mesure{border-left:3px solid var(--sapin);background:#faf9f5;padding:10px 14px;font-size:15px;margin:0 0 8px}
|
||||
figure{margin:12px 0 0}
|
||||
figcaption{font-size:13px;color:var(--gris);margin-top:4px}
|
||||
svg{display:block;width:100%;height:auto}
|
||||
svg text{font-family:var(--texte);fill:var(--gris);font-size:12px}
|
||||
svg .lib{fill:var(--roche);font-size:12.5px}
|
||||
svg .val{fill:var(--roche);font-size:12.5px;font-weight:600}
|
||||
.vide{font-size:15px;color:var(--gris);font-style:italic}
|
||||
.maj{font-size:13px;color:var(--gris)}
|
||||
</style>
|
||||
</head>
|
||||
<body>
|
||||
<div class="haut"><a class="retour" href="./">← La carte</a></div>
|
||||
<main>
|
||||
<h1>Statistiques du site</h1>
|
||||
<p class="accroche">Combien de personnes viennent sur vercors.me, sans que personne ne soit suivi.</p>
|
||||
<p class="mesure"><b>Ce qui est mesuré</b> : le nombre de pages affichées chaque jour, les pages les plus consultées, la part de téléphones et d'ordinateurs, le site d'où l'on arrive et la langue du navigateur, en totaux seulement. <b>Ce qui ne l'est pas</b> : aucun cookie, aucun identifiant, aucune adresse IP conservée, aucun visiteur reconnu d'une page ou d'un jour à l'autre, aucun service tiers ; les robots sont écartés. Aucun chiffre inférieur à 5 n'est publié. Voir la <a href="confidentialite.html">politique de confidentialité</a>.</p>
|
||||
<p class="maj" id="maj" aria-live="polite">Chargement des chiffres…</p>
|
||||
<div id="contenu" hidden>
|
||||
<h2>Pages vues par jour</h2>
|
||||
<p id="total"></p>
|
||||
<figure><svg id="g-jours" role="img" aria-labelledby="t-jours" viewBox="0 0 720 200"><title id="t-jours">Pages vues par jour sur les 90 derniers jours</title></svg>
|
||||
<figcaption>Les jours en pointillé ont eu moins de 5 pages vues : le chiffre exact n'est pas publié.</figcaption></figure>
|
||||
<h2>Pages les plus vues (30 jours)</h2>
|
||||
<div id="pages"></div>
|
||||
<h2>Téléphone ou ordinateur</h2>
|
||||
<div id="appareils"></div>
|
||||
<h2>D'où viennent les visites</h2>
|
||||
<div id="referents"></div>
|
||||
<p id="directs" class="maj"></p>
|
||||
<h2>Langue du navigateur</h2>
|
||||
<div id="langues"></div>
|
||||
</div>
|
||||
</main>
|
||||
<footer class="pied">© Théo Gastinel · <a href="cgu.html">Conditions d'utilisation</a> · <a href="confidentialite.html">Confidentialité</a> · <a href="./">Retour à la carte</a></footer>
|
||||
<script>
|
||||
(function(){
|
||||
var NS='http://www.w3.org/2000/svg',SAPIN='#1f4d3a',PIERRE='#e4e0d6',GRIS='#5d635e',MOUSSE='#6f8f5c';
|
||||
var NOMS_PAGES={'/':'Accueil (la carte)','/a-propos':'À propos','/cgu':"Conditions d'utilisation",'/confidentialite':'Confidentialité','/statistiques':'Statistiques du site'};
|
||||
var NOMS_LANGUES={fr:'français',en:'anglais',de:'allemand',es:'espagnol',it:'italien',nl:'néerlandais',pt:'portugais'};
|
||||
function el(n,a,t){var e=document.createElementNS(NS,n),k;for(k in a)e.setAttribute(k,a[k]);if(t!=null)e.textContent=t;return e}
|
||||
function fmt(n){return String(n).replace(/\B(?=(\d{3})+(?!\d))/g,' ')}
|
||||
function jourFr(s){var p=s.split('-');return parseInt(p[2],10)+'/'+parseInt(p[1],10)}
|
||||
function vide(id,txt){var d=document.getElementById(id);d.innerHTML='';var p=document.createElement('p');p.className='vide';p.textContent=txt;d.appendChild(p)}
|
||||
function barres(id,lignes,suffixe,aria){
|
||||
var d=document.getElementById(id);d.innerHTML='';
|
||||
var H=30,W=Math.max(280,d.clientWidth||720),L=Math.round(Math.min(250,W*.45)),nmax=Math.floor(L/7),max=Math.max.apply(null,lignes.map(function(x){return x.v}));
|
||||
var s=el('svg',{role:'img','aria-label':aria,viewBox:'0 0 '+W+' '+(lignes.length*H+4)});
|
||||
lignes.forEach(function(x,i){
|
||||
var y=i*H+2,w=Math.max(2,(W-L-64)*x.v/max);
|
||||
s.appendChild(el('text',{x:0,y:y+19,'class':'lib'},x.nom.length>nmax?x.nom.slice(0,nmax-1)+'…':x.nom));
|
||||
s.appendChild(el('rect',{x:L,y:y+5,width:w,height:18,fill:SAPIN}));
|
||||
s.appendChild(el('text',{x:L+w+8,y:y+19,'class':'val'},fmt(x.v)+(suffixe||'')));
|
||||
});
|
||||
d.appendChild(s);
|
||||
}
|
||||
function jours(par){
|
||||
var s=document.getElementById('g-jours'),n=par.length,L=34,B=24,T=10,W=Math.max(280,s.parentNode.clientWidth||720),H=200,aire=H-B-T;
|
||||
s.innerHTML='';s.setAttribute('viewBox','0 0 '+W+' '+H);s.appendChild(el('title',{id:'t-jours'},'Pages vues par jour sur les 90 derniers jours'));
|
||||
var max=Math.max.apply(null,par.map(function(x){return x.pages_vues||0}).concat([5]));
|
||||
var pas=(W-L)/n,bw=Math.max(2,pas-1.5);
|
||||
[0,max].forEach(function(v){var y=T+aire-aire*v/max;s.appendChild(el('line',{x1:L,x2:W,y1:y,y2:y,stroke:PIERRE}));s.appendChild(el('text',{x:L-6,y:y+4,'text-anchor':'end'},fmt(v)))});
|
||||
par.forEach(function(x,i){
|
||||
var xx=L+i*pas+(pas-bw)/2,r;
|
||||
if(x.pages_vues==null){r=el('rect',{x:xx,y:T+aire-4,width:bw,height:4,fill:'none',stroke:GRIS,'stroke-dasharray':'2 1.5','stroke-width':1});r.appendChild(el('title',{},jourFr(x.jour)+' : moins de 5'))}
|
||||
else{var h=Math.max(1,aire*x.pages_vues/max);r=el('rect',{x:xx,y:T+aire-h,width:bw,height:h,fill:SAPIN});r.appendChild(el('title',{},jourFr(x.jour)+' : '+x.pages_vues))}
|
||||
s.appendChild(r);
|
||||
});
|
||||
[0,Math.floor(n/2),n-1].forEach(function(i){s.appendChild(el('text',{x:L+i*pas+pas/2,y:H-6,'text-anchor':i==0?'start':(i==n-1?'end':'middle')},jourFr(par[i].jour)))});
|
||||
}
|
||||
function appareils(a){
|
||||
var t=a.telephone,o=a.ordinateur;
|
||||
if(t==null&&o==null){vide('appareils','Pas assez de visites pour publier une répartition.');return}
|
||||
var d=document.getElementById('appareils');d.innerHTML='';
|
||||
var W=Math.max(280,d.clientWidth||720),s=el('svg',{role:'img','aria-label':'Répartition des appareils',viewBox:'0 0 '+W+' 64'});
|
||||
var tt=t==null?0:t,oo=o==null?0:o,tot=tt+oo||1,wt=W*tt/tot;
|
||||
if(tt)s.appendChild(el('rect',{x:0,y:4,width:wt,height:26,fill:SAPIN}));
|
||||
if(oo)s.appendChild(el('rect',{x:wt,y:4,width:W-wt,height:26,fill:MOUSSE}));
|
||||
s.appendChild(el('text',{x:0,y:52,'class':'val'},t!=null?'Téléphone '+t+' %':'Téléphone : moins de 5 visites'));
|
||||
s.appendChild(el('text',{x:W,y:52,'class':'val','text-anchor':'end'},o!=null?'Ordinateur '+o+' %':'Ordinateur : moins de 5 visites'));
|
||||
d.appendChild(s);
|
||||
}
|
||||
var derniere=null;
|
||||
function rendre(s){
|
||||
derniere=s;
|
||||
document.getElementById('maj').textContent='Période : du '+jourFr(s.periode.debut)+' au '+jourFr(s.periode.fin)+' (30 jours). Mise à jour automatique, une fois par jour.';
|
||||
document.getElementById('contenu').hidden=false;
|
||||
document.getElementById('total').textContent=s.pages_vues_periode==null?'Moins de 5 pages vues sur la période : trop peu pour publier un total.':fmt(s.pages_vues_periode)+' pages vues sur les 30 derniers jours (robots exclus).';
|
||||
jours(s.par_jour);
|
||||
if(s.pages_les_plus_vues.length)barres('pages',s.pages_les_plus_vues.map(function(p){return{nom:NOMS_PAGES[p.page]||p.page,v:p.vues}}),'','Pages les plus vues');else vide('pages','Pas encore assez de visites pour classer les pages.');
|
||||
appareils(s.appareils_pct);
|
||||
if(s.referents.length)barres('referents',s.referents.map(function(r){return{nom:r.site,v:r.vues}}),'','Sites d’origine des visites');else vide('referents','Aucun site d’origine n’atteint 5 visites.');
|
||||
document.getElementById('directs').textContent=s.acces_directs==null?'':fmt(s.acces_directs)+' visites sont arrivées directement (adresse saisie, favori, application) : l’origine n’est pas connue.';
|
||||
if(s.langues.length)barres('langues',s.langues.map(function(l){return{nom:NOMS_LANGUES[l.langue]||l.langue,v:l.pct}}),' %','Langue du navigateur');else vide('langues','Pas assez de visites pour publier les langues.');
|
||||
}
|
||||
var tempo;window.addEventListener('resize',function(){clearTimeout(tempo);tempo=setTimeout(function(){if(derniere)rendre(derniere)},200)});
|
||||
fetch('data/statistiques.json',{cache:'no-cache'}).then(function(r){if(!r.ok)throw 0;return r.json()}).then(rendre).catch(function(){document.getElementById('maj').textContent='Les statistiques ne sont pas encore disponibles.'});
|
||||
})();
|
||||
</script>
|
||||
</body>
|
||||
</html>
|
||||
@@ -0,0 +1,116 @@
|
||||
<!doctype html>
|
||||
<html lang="fr">
|
||||
<head>
|
||||
<meta charset="utf-8">
|
||||
<meta name="viewport" content="width=device-width,initial-scale=1">
|
||||
<meta name="color-scheme" content="light">
|
||||
<title>Charte graphique · Météo Vercors</title>
|
||||
<style>
|
||||
@font-face{font-family:Bitter;font-weight:500 700;font-display:swap;src:url('polices/bitter-normal.woff2') format('woff2')}
|
||||
@font-face{font-family:Outfit;font-weight:400 600;font-display:swap;src:url('polices/outfit-normal.woff2') format('woff2')}
|
||||
:root{color-scheme:light;--sapin:#1f4d3a;--mousse:#6f8f5c;--calcaire:#f5f3ee;--pierre:#e4e0d6;--roche:#2b2f2c;--glacier:#6eb5bd;--gris:#5d635e;--chaud:#b5643c}
|
||||
*{box-sizing:border-box}
|
||||
body{margin:0;background:var(--calcaire);color:var(--roche);font:18px/1.6 Outfit,system-ui,sans-serif}
|
||||
a{color:var(--sapin)}
|
||||
header,main,footer{max-width:1100px;margin:0 auto;padding:0 24px}
|
||||
header{padding-top:40px;padding-bottom:28px;border-bottom:1px solid #b9b4a6}
|
||||
.kicker{color:var(--sapin);font-weight:600;margin:0 0 8px}
|
||||
h1,h2,h3{font-family:Bitter,Georgia,serif;color:var(--sapin);line-height:1.15}
|
||||
h1{font-size:clamp(40px,7vw,68px);margin:0 0 12px}
|
||||
h2{font-size:34px;margin:56px 0 8px}
|
||||
h3{font-size:22px;margin:0 0 6px}
|
||||
.chapeau{font-size:20px;max-width:62ch;color:var(--gris);margin:0}
|
||||
.intro{color:var(--gris);max-width:70ch;margin:0 0 24px}
|
||||
.palette{display:grid;grid-template-columns:repeat(auto-fill,minmax(min(100%,240px),1fr));gap:16px}
|
||||
.couleur{background:#fff;border:1px solid #a5afa1}
|
||||
.couleur .pastille{height:150px;border-bottom:1px solid #a5afa1}
|
||||
.couleur div{padding:16px 18px}
|
||||
.couleur b{display:block;font-family:Bitter,Georgia,serif;font-size:22px;color:var(--roche)}
|
||||
.couleur code{display:block;font:600 26px/1.3 ui-monospace,Consolas,monospace;margin:4px 0 6px;color:var(--roche)}
|
||||
.couleur span{color:var(--gris);font-size:16px}
|
||||
.polices{display:grid;grid-template-columns:repeat(auto-fit,minmax(min(100%,420px),1fr));gap:16px}
|
||||
.carte{background:#fff;border:1px solid #a5afa1;padding:28px}
|
||||
.geant{font-size:clamp(64px,12vw,120px);line-height:1;margin:8px 0 16px;color:var(--sapin)}
|
||||
.bitter{font-family:Bitter,Georgia,serif;font-weight:700}
|
||||
.outfit{font-family:Outfit,system-ui,sans-serif;font-weight:600}
|
||||
.alphabet{font-size:22px;overflow-wrap:anywhere;margin:0 0 10px}
|
||||
.role{color:var(--gris);margin:0}
|
||||
.regles{display:grid;grid-template-columns:repeat(auto-fit,minmax(min(100%,300px),1fr));gap:16px}
|
||||
.regle{background:#fff;border:1px solid #a5afa1;border-left:5px solid var(--sapin);padding:20px 22px}
|
||||
.regle.non{border-left-color:var(--chaud)}
|
||||
.regle p{margin:0}
|
||||
.etiquette{display:inline-block;font-size:14px;font-weight:600;border:1px solid currentColor;padding:0 8px;margin-bottom:8px}
|
||||
.oui .etiquette{color:var(--sapin)}.non .etiquette{color:var(--chaud)}
|
||||
.donnees{display:grid;grid-template-columns:repeat(auto-fill,minmax(min(100%,200px),1fr));gap:12px}
|
||||
.donnee{display:flex;align-items:center;gap:12px;background:#fff;border:1px solid #a5afa1;padding:12px 14px}
|
||||
.donnee i{width:36px;height:36px;flex:none;border:1px solid #a5afa1}
|
||||
.ton{background:#fff;border:1px solid #a5afa1;padding:24px 28px}
|
||||
.ton ul{margin:0;padding-left:22px}
|
||||
.brouillon{border:1px dashed var(--gris);padding:10px 14px;color:var(--gris);font-size:15px;margin:24px 0 0}
|
||||
footer{margin-top:64px;padding-top:24px;padding-bottom:40px;border-top:1px solid #b9b4a6;color:var(--gris);font-size:16px}
|
||||
:focus-visible{outline:3px solid var(--sapin);outline-offset:3px}
|
||||
</style>
|
||||
</head>
|
||||
<body>
|
||||
<header>
|
||||
<p class="kicker">Météo Vercors</p>
|
||||
<h1>Charte graphique</h1>
|
||||
<p class="chapeau">Les couleurs, les polices et les règles qui donnent au site son allure. Simple, clair, lisible par tout le monde.</p>
|
||||
<p class="brouillon">Aperçu temporaire, pas encore en ligne. Le PDF à télécharger viendra ensuite.</p>
|
||||
</header>
|
||||
<main>
|
||||
|
||||
<h2>Couleurs</h2>
|
||||
<p class="intro">Une palette figée, tirée des paysages du massif : la forêt, la prairie, le calcaire, la roche et la glace.</p>
|
||||
<div class="palette">
|
||||
<div class="couleur"><div class="pastille" style="background:#1f4d3a"></div><div><b>Sapin</b><code>#1F4D3A</code><span>Couleur principale : titres, liens, boutons.</span></div></div>
|
||||
<div class="couleur"><div class="pastille" style="background:#6f8f5c"></div><div><b>Mousse</b><code>#6F8F5C</code><span>Accent doux : adhérents, détails.</span></div></div>
|
||||
<div class="couleur"><div class="pastille" style="background:#f5f3ee"></div><div><b>Calcaire</b><code>#F5F3EE</code><span>Fond des pages.</span></div></div>
|
||||
<div class="couleur"><div class="pastille" style="background:#e4e0d6"></div><div><b>Pierre</b><code>#E4E0D6</code><span>Séparations, cadres légers.</span></div></div>
|
||||
<div class="couleur"><div class="pastille" style="background:#2b2f2c"></div><div><b>Roche</b><code>#2B2F2C</code><span>Texte principal.</span></div></div>
|
||||
<div class="couleur"><div class="pastille" style="background:#5d635e"></div><div><b>Gris</b><code>#5D635E</code><span>Texte secondaire, dates.</span></div></div>
|
||||
<div class="couleur"><div class="pastille" style="background:#6eb5bd"></div><div><b>Glacier</b><code>#6EB5BD</code><span>Froid, neige, stations.</span></div></div>
|
||||
<div class="couleur"><div class="pastille" style="background:#b5643c"></div><div><b>Chaud</b><code>#B5643C</code><span>Chaleur, mises en garde.</span></div></div>
|
||||
</div>
|
||||
|
||||
<h2>Polices</h2>
|
||||
<p class="intro">Deux polices seulement, hébergées sur le site (aucun appel à un service extérieur).</p>
|
||||
<div class="polices">
|
||||
<div class="carte"><h3>Titres</h3><p class="geant bitter">Bitter</p><p class="alphabet bitter">Aa Bb Cc Éé Gg 0123456789</p><p class="role">Serif solide, pour les titres et les noms de stations.</p></div>
|
||||
<div class="carte"><h3>Textes</h3><p class="geant outfit">Outfit</p><p class="alphabet outfit">Aa Bb Cc Éé Gg 0123456789</p><p class="role">Sans serif lisible, pour tout le reste : textes, boutons, chiffres.</p></div>
|
||||
</div>
|
||||
|
||||
|
||||
<h2>Couleurs des données</h2>
|
||||
<p class="intro">Toujours les mêmes couleurs pour les mêmes mesures, sur la carte comme dans les graphiques.</p>
|
||||
<div class="donnees">
|
||||
<div class="donnee"><i style="background:#b5643c"></i>Température</div>
|
||||
<div class="donnee"><i style="background:#6eb5bd"></i>Neige, froid</div>
|
||||
<div class="donnee"><i style="background:#1f4d3a"></i>Pluie</div>
|
||||
<div class="donnee"><i style="background:#6f8f5c"></i>Humidité</div>
|
||||
<div class="donnee"><i style="background:#5d635e"></i>Vent</div>
|
||||
</div>
|
||||
<p class="brouillon">Correspondance des couleurs de données à confirmer avec les graphiques actuels du site.</p>
|
||||
|
||||
<h2>Règles</h2>
|
||||
<div class="regles">
|
||||
<div class="regle oui"><span class="etiquette">Oui</span><p><b>Accessible à tous.</b> Texte d’au moins 16 px, contrastes forts, focus clavier toujours visible.</p></div>
|
||||
<div class="regle oui"><span class="etiquette">Oui</span><p><b>Thème clair uniquement.</b> Fond calcaire, texte roche.</p></div>
|
||||
<div class="regle oui"><span class="etiquette">Oui</span><p><b>Angles droits.</b> Cadres fins, sans ombres fortes.</p></div>
|
||||
<div class="regle non"><span class="etiquette">Non</span><p><b>Pas de mode sombre.</b></p></div>
|
||||
<div class="regle non"><span class="etiquette">Non</span><p><b>Pas d’emoji dans l’interface.</b> Des pictogrammes dessinés, avec un texte à côté.</p></div>
|
||||
<div class="regle non"><span class="etiquette">Non</span><p><b>Pas de couleur hors palette.</b></p></div>
|
||||
</div>
|
||||
|
||||
<h2>Ton des textes</h2>
|
||||
<div class="ton"><ul>
|
||||
<li>On tutoie, avec des phrases courtes.</li>
|
||||
<li>On dit ce qu’on mesure, sans exagérer.</li>
|
||||
<li>Les unités sont toujours écrites : °C, mm, km/h.</li>
|
||||
<li>En français d’abord ; anglais et allemand dans les paramètres.</li>
|
||||
</ul></div>
|
||||
|
||||
</main>
|
||||
<footer>Météo Vercors · Théo Gastinel · Charte graphique, aperçu du 06/11/2026</footer>
|
||||
</body>
|
||||
</html>
|
||||
@@ -0,0 +1,171 @@
|
||||
"""Tests du collecteur ROMMA, sans réseau : python -m unittest discover -s tests"""
|
||||
import contextlib
|
||||
import datetime as dt
|
||||
import io
|
||||
import json
|
||||
import os
|
||||
import sys
|
||||
import tempfile
|
||||
import unittest
|
||||
|
||||
sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "collecte"))
|
||||
import collecter_romma as cr # noqa: E402
|
||||
from collecter_weatherlink import verifier_public # noqa: E402
|
||||
|
||||
FIN = dt.datetime(2026, 11, 5, 10, 0, tzinfo=dt.timezone.utc) # 11:00 à Paris (hiver)
|
||||
CLE = "CLE-SECRETE-XYZ"
|
||||
|
||||
|
||||
def ligne(num, heure="10:55", **kw):
|
||||
o = {"id_station": num, "station": "S%s" % num, "altitude": 1000, "latitude": 44.91, "longitude": 5.43,
|
||||
"is_valide": 1, "date": "05/11/26", "heure": heure, "temperature": "5,5", "pression": 1010,
|
||||
"humidite": "NULL", "vent_moyen_10min": 10, "vent_rafale_maxi_10min": 25, "vent_direction": "SSO",
|
||||
"vent_direction_degres": 200, "pluie_jour": "1.2"}
|
||||
o.update(kw)
|
||||
return o
|
||||
|
||||
|
||||
def corps(*lignes):
|
||||
return json.dumps(list(lignes)).encode()
|
||||
|
||||
|
||||
class TestRomma(unittest.TestCase):
|
||||
def test_parse_filtre_et_unites(self):
|
||||
r, _ = cr.parser_reponse(corps(ligne(139), ligne(4), ligne(159, humidite="80")), FIN)
|
||||
self.assertEqual(set(r), {"engins", "die"}) # station 4 hors autorisation
|
||||
rel = r["engins"][0]
|
||||
self.assertEqual(rel["dh_utc"], "2026-11-05 09:55:00")
|
||||
self.assertEqual((rel["temperature"], rel["vent_moyen"], rel["vent_direction"], rel["pluie_cumul_0h"]),
|
||||
(5.5, 10.0, 200, 1.2))
|
||||
self.assertNotIn("humidite", rel)
|
||||
self.assertEqual(r["die"][0]["humidite"], 80)
|
||||
self.assertEqual(r["engins"][1]["lat"], 44.91)
|
||||
|
||||
def test_ignores(self):
|
||||
r, av = cr.parser_reponse(corps(ligne(139, is_valide=0), ligne(159, temperature="NULL"),
|
||||
ligne(158, heure="12:30"), ligne(212, date="xx")), FIN)
|
||||
self.assertEqual(r, {})
|
||||
self.assertEqual(len(av), 4)
|
||||
|
||||
def test_cle_refusee_et_reponse_invalide(self):
|
||||
with self.assertRaises(cr.CleRefusee):
|
||||
cr.parser_reponse(json.dumps("Erreur : no user associated or apikey invalid"), FIN)
|
||||
with self.assertRaises(cr.ErreurRomma):
|
||||
cr.parser_reponse("<html>", FIN)
|
||||
|
||||
def test_sortie_publique(self):
|
||||
r, _ = cr.parser_reponse(cr.reponse_factice(FIN), FIN)
|
||||
obj, _ = cr.construire({}, r, FIN)
|
||||
verifier_public(obj)
|
||||
self.assertEqual(set(obj["stations"]), set(cr.STATIONS))
|
||||
self.assertEqual(obj["stations"]["die"]["source"], "ROMMA")
|
||||
self.assertFalse(obj["stations"]["die"]["hors_ligne"])
|
||||
self.assertNotIn("Hors autorisation", json.dumps(obj))
|
||||
|
||||
def test_accumulation_et_fenetre(self):
|
||||
prec, _ = cr.construire({}, cr.parser_reponse(corps(ligne(139, heure="10:50", temperature=2)), FIN)[0], FIN)
|
||||
r2, _ = cr.parser_reponse(corps(ligne(139, heure="10:55", temperature=8)), FIN)
|
||||
obj, _ = cr.construire(prec, r2, FIN)
|
||||
rel = obj["stations"]["engins"]["releves"]
|
||||
self.assertEqual(len(rel), 2)
|
||||
self.assertEqual((rel[-1]["temperature_min"], rel[-1]["temperature_max"]), (2.0, 8.0))
|
||||
obj2, _ = cr.construire(obj, {}, FIN + dt.timedelta(hours=25)) # hors fenêtre de 24 h
|
||||
self.assertEqual(obj2["stations"]["engins"]["releves"], [])
|
||||
self.assertTrue(obj2["stations"]["engins"]["hors_ligne"])
|
||||
|
||||
def test_erreur_garde_precedent(self):
|
||||
prec, _ = cr.construire({}, cr.parser_reponse(cr.reponse_factice(FIN), FIN)[0], FIN)
|
||||
|
||||
def casse():
|
||||
raise cr.ErreurRomma("HTTP 500")
|
||||
obj, msg, code = cr.passage(prec, casse, FIN + dt.timedelta(minutes=5), CLE, None)
|
||||
self.assertEqual(code, 0)
|
||||
self.assertEqual(len(obj["stations"]["die"]["releves"]), 1)
|
||||
self.assertIn("précédents gardés", msg)
|
||||
obj, msg, code = cr.passage({}, casse, FIN, CLE, None)
|
||||
self.assertEqual((obj, code), (None, 1))
|
||||
|
||||
def test_garde_fou_10_minutes(self):
|
||||
with tempfile.TemporaryDirectory() as d:
|
||||
etat = os.path.join(d, "etat.json")
|
||||
appels = []
|
||||
|
||||
def f():
|
||||
appels.append(1)
|
||||
return cr.reponse_factice(FIN)
|
||||
self.assertIsNotNone(cr.passage({}, f, FIN, CLE, etat)[0])
|
||||
obj, msg, _ = cr.passage({}, f, FIN + dt.timedelta(minutes=9), CLE, etat)
|
||||
self.assertIsNone(obj)
|
||||
self.assertIn("attente", msg)
|
||||
self.assertEqual(len(appels), 1) # un seul appel pour les 4 stations
|
||||
cr.passage({}, f, FIN + dt.timedelta(minutes=10, seconds=1), CLE, etat)
|
||||
self.assertEqual(len(appels), 2)
|
||||
|
||||
def test_garde_fou_apres_erreur_et_cle_refusee(self):
|
||||
with tempfile.TemporaryDirectory() as d:
|
||||
etat = os.path.join(d, "etat.json")
|
||||
|
||||
def refuse():
|
||||
raise cr.CleRefusee("clé refusée")
|
||||
cr.passage({}, refuse, FIN, CLE, etat)
|
||||
obj, msg, _ = cr.passage({}, refuse, FIN + dt.timedelta(minutes=30), CLE, etat)
|
||||
self.assertIsNone(obj)
|
||||
self.assertIn("attente", msg) # clé refusée : pause d'une heure
|
||||
|
||||
def test_main_refuse_sans_validation_et_n_affiche_pas_la_cle(self):
|
||||
with tempfile.TemporaryDirectory() as d:
|
||||
env = os.path.join(d, "romma.env")
|
||||
with open(env, "w") as f:
|
||||
f.write("ROMMA_CLE=%s\nROMMA_URL_API=https://exemple.invalide/?k={cle}\n" % CLE)
|
||||
for k in ("ROMMA_CLE", "ROMMA_URL_API", "ROMMA_APPEL_RESEAU_VALIDE"):
|
||||
os.environ.pop(k, None)
|
||||
sortie = io.StringIO()
|
||||
with contextlib.redirect_stdout(sortie):
|
||||
code = cr.main(["--reel", "--fichier-env", env, "--sortie", os.path.join(d, "r.json"),
|
||||
"--etat", os.path.join(d, "e.json")])
|
||||
self.assertEqual(code, 2) # validation absente : aucun appel
|
||||
self.assertNotIn(CLE, sortie.getvalue())
|
||||
self.assertFalse(os.path.exists(os.path.join(d, "r.json")))
|
||||
|
||||
def test_main_reel_erreur_reseau_masque_la_cle(self):
|
||||
with tempfile.TemporaryDirectory() as d:
|
||||
env = os.path.join(d, "romma.env")
|
||||
with open(env, "w") as f:
|
||||
f.write("ROMMA_CLE=%s\nROMMA_URL_API=https://exemple.invalide/?k={cle}\n"
|
||||
"ROMMA_APPEL_RESEAU_VALIDE=oui\n" % CLE)
|
||||
appels = []
|
||||
|
||||
def ouvrir(req, timeout=0):
|
||||
appels.append(req.full_url)
|
||||
raise OSError("échec " + req.full_url)
|
||||
vrai = cr.urllib.request.urlopen
|
||||
cr.urllib.request.urlopen = ouvrir
|
||||
try:
|
||||
sortie = io.StringIO()
|
||||
with contextlib.redirect_stdout(sortie):
|
||||
code = cr.main(["--reel", "--fichier-env", env, "--sortie", os.path.join(d, "r.json"),
|
||||
"--etat", os.path.join(d, "e.json")])
|
||||
code2 = cr.main(["--reel", "--fichier-env", env, "--sortie", os.path.join(d, "r.json"),
|
||||
"--etat", os.path.join(d, "e.json")])
|
||||
finally:
|
||||
cr.urllib.request.urlopen = vrai
|
||||
self.assertEqual((code, code2), (1, 0))
|
||||
self.assertEqual(len(appels), 1) # le 2e passage est bloqué par le garde-fou
|
||||
self.assertNotIn(CLE, sortie.getvalue())
|
||||
|
||||
def test_simulation_par_defaut(self):
|
||||
with contextlib.redirect_stdout(io.StringIO()) as s:
|
||||
self.assertEqual(cr.main([]), 0) # sans --sortie : rien n'est écrit
|
||||
self.assertIn("[simulation]", s.getvalue())
|
||||
|
||||
def test_lire_env(self):
|
||||
with tempfile.TemporaryDirectory() as d:
|
||||
env = os.path.join(d, "e")
|
||||
with open(env, "w") as f:
|
||||
f.write("# c\nROMMA_CLE=\"abc\"\n")
|
||||
os.environ.pop("ROMMA_CLE", None)
|
||||
self.assertEqual(cr.lire_env(env)["ROMMA_CLE"], "abc")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,101 @@
|
||||
"""Tests des statistiques de fréquentation, avec un faux journal Caddy : python -I tests/test_statistiques_vercors.py"""
|
||||
import datetime as dt
|
||||
import gzip
|
||||
import json
|
||||
import os
|
||||
import sys
|
||||
import tempfile
|
||||
|
||||
sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "collecte"))
|
||||
import statistiques_vercors as st # noqa: E402
|
||||
|
||||
MAINT = dt.datetime(2026, 11, 5, 10, 0, tzinfo=dt.timezone.utc)
|
||||
IP_SECRETE = "203.0.113.77"
|
||||
|
||||
|
||||
def ts(jour, h=12):
|
||||
return dt.datetime.fromisoformat(jour + "T%02d:00:00+00:00" % h).timestamp()
|
||||
|
||||
|
||||
def ligne(jour, uri="/", classe="bureau", ref="", langue="fr", status=200, methode="GET", hote="vercors.me", h=12, brut=False):
|
||||
r = {"level": "info", "ts": ts(jour, h), "status": status, "ua_classe": classe, "referent": ref, "langue": langue,
|
||||
"request": {"method": methode, "host": hote, "uri": uri}}
|
||||
if brut: # journal mal filtré : l'IP et les cookies ne doivent de toute façon jamais ressortir
|
||||
r["request"].update(remote_ip=IP_SECRETE, headers={"Cookie": ["secret=1"], "User-Agent": ["Mozilla/5.0 (iPhone)"]})
|
||||
del r["ua_classe"]
|
||||
return json.dumps(r)
|
||||
|
||||
|
||||
def faux_journal():
|
||||
L = []
|
||||
for _ in range(12):
|
||||
L.append(ligne("2026-11-04", "/", "bureau", ref="duckduckgo.com"))
|
||||
for _ in range(7):
|
||||
L.append(ligne("2026-11-04", "/a-propos.html", "mobile", ref="https://www.google.com/search?q=secret", langue="en"))
|
||||
L.append(ligne("2026-11-04", "/cgu", "mobile", ref="petit-site.fr")) # 1 occurrence : jamais publié
|
||||
for _ in range(3):
|
||||
L.append(ligne("2026-11-03", "/", "bureau")) # jour < 5 : null
|
||||
for _ in range(30):
|
||||
L.append(ligne("2026-11-04", "/", "robot")) # robots : hors vues
|
||||
L += [ligne("2026-11-04", "/data/meteo.json"), ligne("2026-11-04", "/polices/x.woff2"),
|
||||
ligne("2026-11-04", "/app.js"), ligne("2026-11-04", "/inexistant", status=404),
|
||||
ligne("2026-11-04", "/", methode="POST"), ligne("2026-11-04", "/", hote="autre.org"),
|
||||
ligne("2026-11-04", "/", ref="https://vercors.me/a-propos"), "pas du json", "[1,2]", ""]
|
||||
L.append(ligne("2026-11-04", "/?utm=jeton123", brut=True)) # requête avec IP brute
|
||||
return "\n".join(L) + "\n"
|
||||
|
||||
|
||||
def lancer(dossier, sortie="s.json"):
|
||||
args = ["--journaux", os.path.join(dossier, "vercors.me*.log*"), "--etat", os.path.join(dossier, "etat.json"),
|
||||
"--sortie", os.path.join(dossier, sortie), "--maintenant", "2026-11-05T10:00:00Z"]
|
||||
assert st.main(args) == 0
|
||||
with open(os.path.join(dossier, sortie), encoding="utf-8") as f:
|
||||
return f.read()
|
||||
|
||||
|
||||
def main():
|
||||
with tempfile.TemporaryDirectory() as d:
|
||||
with open(os.path.join(d, "vercors.me.log"), "w", encoding="utf-8") as f:
|
||||
f.write(faux_journal())
|
||||
with gzip.open(os.path.join(d, "vercors.me-2026.log.gz"), "wt", encoding="utf-8") as f:
|
||||
f.write(ligne("2026-11-02", "/", "bureau") + "\n")
|
||||
brut = lancer(d)
|
||||
s = json.loads(brut)
|
||||
|
||||
# rien d'individuel
|
||||
for interdit in (IP_SECRETE, "secret", "jeton123", "remote_ip", "Cookie", "petit-site.fr", "q="):
|
||||
assert interdit not in brut, interdit
|
||||
assert "secret" not in open(os.path.join(d, "etat.json"), encoding="utf-8").read()
|
||||
assert IP_SECRETE not in open(os.path.join(d, "etat.json"), encoding="utf-8").read()
|
||||
|
||||
jours = {j["jour"]: j["pages_vues"] for j in s["par_jour"]}
|
||||
assert jours["2026-11-04"] == 12 + 7 + 1 + 1 + 1 + 0, jours["2026-11-04"] # /, a-propos, cgu, ref interne, brut
|
||||
assert jours["2026-11-03"] is None and jours["2026-11-02"] is None and jours["2026-11-05"] is None
|
||||
pages = {p["page"]: p["vues"] for p in s["pages_les_plus_vues"]}
|
||||
assert pages == {"/": 12 + 1 + 1 + 3 + 1, "/a-propos": 7}, pages
|
||||
assert "/cgu" not in pages and "/data/meteo.json" not in pages and "/app.js" not in pages
|
||||
assert all(v >= st.SEUIL for v in pages.values())
|
||||
assert s["appareils_pct"]["telephone"] is not None and s["appareils_pct"]["ordinateur"] is not None
|
||||
assert 0 <= s["appareils_pct"]["telephone"] <= 100
|
||||
sites = {r["site"] for r in s["referents"]}
|
||||
assert sites == {"duckduckgo.com", "google.com"}, sites
|
||||
assert [l["langue"] for l in s["langues"]] == ["fr", "en"] or {l["langue"] for l in s["langues"]} == {"fr", "en"}
|
||||
assert s["seuil"] == 5 and s["periode"]["fin"] == "2026-11-05" and len(s["par_jour"]) == 90
|
||||
|
||||
# idempotence : relancer ne double rien
|
||||
assert json.loads(lancer(d, "s2.json")) == s
|
||||
# journaux purgés : l'historique de l'état est conservé
|
||||
os.remove(os.path.join(d, "vercors.me.log"))
|
||||
s3 = json.loads(lancer(d, "s3.json"))
|
||||
assert {j["jour"]: j["pages_vues"] for j in s3["par_jour"]}["2026-11-04"] == 22
|
||||
|
||||
# heure d'été : 31 octobre 2026 22:30 UTC = 23:30 à Paris, 1er novembre 00:30 en heure d'hiver
|
||||
assert st.jour_paris(dt.datetime(2026, 10, 31, 22, 30, tzinfo=dt.timezone.utc).timestamp()) == "2026-10-31"
|
||||
assert st.jour_paris(dt.datetime(2026, 11, 1, 23, 30, tzinfo=dt.timezone.utc).timestamp()) == "2026-11-02"
|
||||
assert st.page_normalisee("/index.html") == "/" and st.page_normalisee("/a-propos/") == "/a-propos"
|
||||
assert st.page_normalisee("/x.php") is None and st.page_normalisee("/a b") is None
|
||||
print("OK")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
Référencer dans un nouveau ticket
Bloquer un utilisateur