VocabulAyr/jeu/views.py
VocabulAyr 29f9afbd8a VocabulAyr 0.04
Séparation du moteur dans la partie métier (instance 03, spec M1-M6, option B) :
- jeu/static/jeu/moteur.js : le moteur du jeu — règles (pistes, registres,
  grades), progression, persistance (fusion anti-recul, sauvegarde
  /api/etat/) et verdicts purs des mini-jeux (verdictChoix, verdictChaine,
  partagés par les pistes et la résolution) — décide sans jamais toucher
  au DOM, testable hors navigateur ;
- index.html garde le dessin : écrans, style, polices incrustées, câblage
  des clics ; les handlers lisent les verdicts puis rendent ;
- mode « fichier unique hors ligne » retiré (jamais un objectif) : le jeu
  n'existe que sur le site, branché sur l'injection Django (window.MOTS,
  window.ETAT) et sur ui.js ;
- cache-busteur aligné ?v=0.04 sur ui.css, ui.js et moteur.js ;
- 33e test : la page sert le moteur séparé, sans accès au DOM ;
- README ajusté (rôles moteur/page, « Ce que le site apporte au jeu »,
  33 tests) ; docstring de la vue mise au ton.
Comportement de jeu inchangé : 33 tests OK, moteur exécuté hors navigateur
(harnais node), parcours complet vérifié dans un navigateur réel (pistes,
résolution, thème, remise à zéro).
2026-11-09 15:52:40 +00:00

422 lines
18 KiB
Python
Executable file
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

"""Pages et API de VocabulAyr.
Le savoir du jeu (les mots, leurs pistes, leurs mini-jeux) vit en base
(modèle Mot) ; le moteur est moteur.js — règles, progression, verdicts,
sans accès au DOM — chargé par la page index.html, que la vue sert en
y injectant trois marqueurs —
<body> → <body class="site-mode"> + window.MOTS (les mots, depuis la
base) + window.ETAT (progression du compte + CSRF) + le menu
+ le gabarit caché du chargeur d'image (variante avatar),
</style> → + le style du menu (rail PC façon BibliothequAyr, entête
mobile façon CulinAyr).
"""
import io
import json
import logging
from pathlib import Path
from django.conf import settings
from django.contrib import messages
from django.contrib.auth import login as auth_login
from django.contrib.auth import views as auth_views
from django.contrib.auth.decorators import login_required
from django.contrib.auth.models import User
from django.core.files.base import ContentFile
from django.http import HttpResponse, JsonResponse
from django.middleware.csrf import get_token
from django.shortcuts import redirect, render
from django.template.loader import render_to_string
from django.utils.html import escape
from django.views.decorators.cache import never_cache
from django.views.decorators.http import require_POST
from jeu.models import Mot, Profil, Progression, SiteConfig
APP_DIR = Path(__file__).resolve().parent
PAGE_JEU = APP_DIR / "static" / "jeu" / "index.html"
MENU_CSS = APP_DIR / "static" / "jeu" / "menu.css"
POSTE_MAX_OCTETS = 512 * 1024
FOND_MAX_OCTETS = 5 * 1024 * 1024 # plafond des images de fond, comme BibliothequAyr
AVATAR_MAX_OCTETS = 2 * 1024 * 1024
AVATAR_TAILLE = 256
logger = logging.getLogger("jeu")
_cache = {}
def _lu_frais(chemin, cle):
"""Contenu d'un fichier mis en cache par mtime (fraîcheur en mode dev)."""
mtime = chemin.stat().st_mtime
if _cache.get(cle + "_mtime") != mtime:
_cache[cle] = chemin.read_text(encoding="utf-8")
_cache[cle + "_mtime"] = mtime
return _cache[cle]
# ----------------------------------------------------------------- menu site
def _fragment_avatar(request, profil):
"""Le gabarit de chargement d'image (variante avatar), rendu une fois
et posé caché dans la page dans un <template> : la boîte « Mon avatar »
le clone au moment d'ouvrir. Un seul template (_image_upload.html)
sert ainsi l'avatar et le fond, comme chez BibliothequAyr."""
return ('<template class="tpl-zi">' + render_to_string(
"_image_upload.html",
{
"variant": "avatar",
"input_id": "id-zi-avatar",
"champ": "avatar",
"envoyer": "/api/avatar/",
"effacer": "effacer",
"mode": "avatar",
"msg_max": "2 Mo",
"initiale": (request.user.username[:1].upper() if request.user.username else "?"),
"current": profil.avatar.url if (profil and profil.avatar) else None,
"empty_label": "Aucune image pour l'instant.",
"preview_id": "zi-avatar-apercu",
"placeholder_id": "zi-avatar-vide",
},
request=request,
) + "</template>")
def _menu_html(request):
"""Menu du site injecté dans la page du jeu — même structure que
base.html : rail latéral (PC, modèle BibliothequAyr) et entête
(mobile/tablette, modèle CulinAyr). Le bloc utilisateur (pastille +
sous-menu) est rendu par le template _menu_utilisateur.html, partagé
avec base.html : strictement le même HTML des deux côtés."""
nom_site = escape(SiteConfig.load().site_name or "VocabulAyr")
icone_fil = ('<svg class="ic" viewBox="0 0 24 24" aria-hidden="true">'
'<path d="M3 21C9 19 7 13 12 11s7-5 6-9"/><circle cx="19" cy="4" r="1.6"/></svg>')
icone_compas = ('<svg class="ic" viewBox="0 0 24 24" aria-hidden="true">'
'<circle cx="12" cy="12" r="9"/><path d="M12 5l1.8 7-1.8 7-1.8-7z"/>'
'<path d="M5 12l7-1.8 7 1.8-7 1.8z"/></svg>')
icone_horloge = ('<svg class="ic" viewBox="0 0 24 24" aria-hidden="true">'
'<circle cx="12" cy="12" r="9"/><path d="M12 7v5l3 2"/></svg>')
utilisateur = render_to_string("_menu_utilisateur.html", request=request)
return f"""
<nav class="sidebar" aria-label="Navigation du site">
<div class="brand">{icone_fil}<span class="brand-name">{nom_site}</span></div>
<a class="nav-item" href="/">{icone_compas}<span>Le jeu</span></a>
<a class="nav-item" href="/historique/">{icone_horloge}<span>Historique</span></a>
<div class="spacer"></div>
<ul class="menu-liste menu-rail">
{utilisateur}
</ul>
</nav>
<header class="entete">
<nav class="menu-gauche" aria-label="Navigation principale">
<a class="lien-entete" href="/">Le jeu</a>
</nav>
<a class="logo" href="/">{nom_site}</a>
<div class="zone-droite">
<a class="lien-entete" href="/historique/">Historique</a>
<ul class="menu-liste">
{utilisateur}
</ul>
</div>
</header>"""
# --------------------------------------------------------------------- pages
@login_required
@never_cache
def jeu(request):
"""Le jeu, avec les mots (window.MOTS), l'état du compte (window.ETAT)
et le menu du site injectés : le savoir vient de la base."""
page = _lu_frais(PAGE_JEU, "page_jeu")
progression = Progression.load(request.user)
profil = Profil.objects.filter(user=request.user).first()
etat = {
"site": True,
"user": request.user.username,
"csrf": get_token(request),
"avatar": profil.avatar.url if profil and profil.avatar else None,
"data": progression.data or {},
}
etat_json = json.dumps(etat, ensure_ascii=False).replace("</", "<\\/")
mots_json = json.dumps(
[m.vers_donnees(True) for m in Mot.objects.order_by("ordre")],
ensure_ascii=False,
).replace("</", "<\\/")
page = page.replace(
"<body>",
'<body class="site-mode">\n'
f'<script>window.MOTS={mots_json};window.ETAT={etat_json};</script>\n'
+ _menu_html(request)
+ _fragment_avatar(request, profil),
1,
)
page = page.replace("</style>", "</style>\n<style>" + _lu_frais(MENU_CSS, "menu_css") + "</style>", 1)
return HttpResponse(page, content_type="text/html; charset=utf-8")
def _choix_theme(progression):
"""Le choix de thème du joueur ('auto', 'light', 'dark'), mémorisé dans
sa progression par le moteur du jeu (boutons Auto / Clair / Sombre)."""
g = (progression.data or {}).get("_g")
t = g.get("theme") if isinstance(g, dict) else None
return t if t in ("auto", "light", "dark") else "auto"
@login_required
@never_cache
def historique(request):
"""Les mots en poche du compte : fiches complètes, en lecture seule."""
progression = Progression.load(request.user)
donnees = [m.vers_donnees(False) for m in Mot.objects.order_by("ordre")]
return render(request, "historique.html", {
"donnees": donnees,
"progression": progression.data or {},
"theme": _choix_theme(progression),
})
@login_required
def parametres(request):
"""Réglages du site (style BibliothequAyr) : titre du site et image de
fond de la page de connexion. Réservée à l'administrateur.
L'image de fond se gère par le fragment _image_upload.html et sa
route /api/fond/ (choix = envoi immédiat, retrait confirmé) ; la
vue ne traite plus en POST que le titre du site."""
if not request.user.is_superuser:
return redirect("jeu")
cfg = SiteConfig.load()
if request.method == "POST":
nom = (request.POST.get("site_name") or "").strip()
if not nom:
messages.error(request, "Le titre ne peut pas être vide.")
else:
cfg.site_name = nom[:80]
cfg.save(update_fields=["site_name"])
messages.success(request, "Titre du site mis à jour.")
return redirect("parametres")
return render(request, "parametres.html", {
"cfg": cfg,
# l'URL calculée ici : le template ne peut pas demander .url à une
# image absente (Django lèverait une erreur de rendu)
"fond_url": cfg.background_image.url if cfg.background_image else None,
"theme": _choix_theme(Progression.load(request.user)),
})
def _compte_progression(data):
"""La marche du fil en trois nombres : (mots résolus, pistes finies,
mot courant). C'est le minimum vital pour savoir si un état reçu va
plus loin que celui déjà en base — sans jamais interpréter le JSON."""
if not isinstance(data, dict):
return (0, 0, 0)
resolus = pistes = 0
for cle, valeur in data.items():
if cle == "_g" or not isinstance(valeur, dict):
continue # marqueurs internes du moteur (_mig2...) : ni mots ni nombres
if valeur.get("solved"):
resolus += 1
pp = valeur.get("p")
if isinstance(pp, dict):
pistes += len(pp)
g = data.get("_g")
idx = g.get("idx", 0) if isinstance(g, dict) else 0
return (resolus, pistes, int(idx or 0))
# ---------------------------------------------------------------------- api
@login_required
def api_etat(request):
"""L'état de jeu du compte.
GET : le relire — un onglet qui réapparaît se resynchronise pour ne
jamais repartir d'un instantané plus vieux que le serveur.
POST : l'enregistrer (envoi immédiat du moteur aux événements forts,
débouncé ailleurs).
Garde anti-recul : une sauvegarde ne remplace l'état en base que si
elle va au moins aussi loin que lui (règle du moteur côté client :
« adopte ce qui va plus loin — jamais l'inverse »). Un onglet chargé
à froid qui rephotocopierait un carnet vide ne peut donc plus effacer
la progression posée par un autre appareil. Le reset passe par sa
propre vue (api_reinitialiser) et n'est pas concerné."""
p = Progression.load(request.user)
if request.method == "GET":
return JsonResponse({"status": "ok", "data": p.data})
if len(request.body) > POSTE_MAX_OCTETS:
return JsonResponse({"status": "too_big"}, status=413)
try:
payload = json.loads(request.body.decode("utf-8"))
except (ValueError, UnicodeDecodeError):
return JsonResponse({"status": "invalid"}, status=400)
data = payload.get("data")
if not isinstance(data, dict):
return JsonResponse({"status": "invalid"}, status=400)
ancien = _compte_progression(p.data)
nouveau = _compte_progression(data)
recule = any(n < a for n, a in zip(nouveau, ancien)) \
and not any(n > a for n, a in zip(nouveau, ancien))
if recule:
logger.warning("etat : refus d'un état en recul pour %s — serveur %s, reçu %s",
request.user.username, ancien, nouveau)
return JsonResponse({"status": "recul"}, status=409)
p.data = data
p.save(update_fields=["data", "maj"])
if getattr(settings, "JOURNAL_ETAT", False):
logger.info("etat : %s → résolus=%s pistes=%s idx=%s (%s octets)",
request.user.username, nouveau[0], nouveau[1], nouveau[2],
len(request.body))
return JsonResponse({"status": "ok"})
@login_required
@require_POST
def api_reinitialiser(request):
"""Remet la progression du compte à zéro (choix du joueur, confirmé deux fois)."""
p = Progression.load(request.user)
p.data = {}
p.save(update_fields=["data", "maj"])
return JsonResponse({"status": "ok"})
@login_required
@require_POST
def api_avatar(request):
"""Charge ou efface l'avatar du compte — le changement est validé tout
de suite (modèle BibliothequAyr : pas de bouton intermédiaire).
POST multipart : fichier « avatar » (image lisible, 2 Mo maximum) —
recadrée en carré, réduite à 256×256, posée en PNG dans data/media/
(donc couverte par la sauvegarde). POST action=effacer : suppression.
Réponse : {"status": "ok", "avatar": url_ou_null}."""
profil, _ = Profil.objects.get_or_create(user=request.user)
if request.POST.get("action") == "effacer":
if profil.avatar:
profil.avatar.delete(save=False)
profil.avatar = None
profil.save(update_fields=["avatar"])
if getattr(settings, "JOURNAL_ETAT", False):
logger.info("avatar : %s a effacé son avatar", request.user.username)
return JsonResponse({"status": "ok", "avatar": None})
image = request.FILES.get("avatar")
if image is None:
return JsonResponse({"status": "aucune_image"}, status=400)
if image.size > AVATAR_MAX_OCTETS:
return JsonResponse({"status": "trop_grosse"}, status=413)
if not (image.content_type or "").startswith("image/"):
return JsonResponse({"status": "pas_image"}, status=400)
try:
from PIL import Image as PILImage, ImageOps
ouverte = PILImage.open(image)
ouverte.load()
except Exception:
return JsonResponse({"status": "pas_image"}, status=400)
# Droit des photos de téléphone (EXIF) : on redresse avant le cadrage.
ouverte = ImageOps.exif_transpose(ouverte)
largeur, hauteur = ouverte.size
cote = min(largeur, hauteur)
ouverte = ouverte.crop(((largeur - cote) // 2, (hauteur - cote) // 2,
(largeur + cote) // 2, (hauteur + cote) // 2))
ouverte = ouverte.resize((AVATAR_TAILLE, AVATAR_TAILLE))
if ouverte.mode in ("RGBA", "LA", "P"):
ouverte = ouverte.convert("RGBA")
fond = PILImage.new("RGB", ouverte.size, (242, 234, 215)) # papier du jeu
fond.paste(ouverte, mask=ouverte.split()[-1])
ouverte = fond
else:
ouverte = ouverte.convert("RGB")
tampon = io.BytesIO()
ouverte.save(tampon, "PNG")
if profil.avatar:
profil.avatar.delete(save=False) # écrase l'ancien fichier
profil.avatar.save(f"avatar-{request.user.pk}.png", ContentFile(tampon.getvalue()),
save=True)
if getattr(settings, "JOURNAL_ETAT", False):
logger.info("avatar : %s a posé un avatar (%s octets reçus → PNG %dx%d)",
request.user.username, image.size, AVATAR_TAILLE, AVATAR_TAILLE)
return JsonResponse({"status": "ok", "avatar": profil.avatar.url})
@login_required
@require_POST
def api_fond(request):
"""Installe ou retire l'image de fond de la page de connexion —
réservée à l'administrateur (la page Paramètres ne concerne que lui).
Modèle BibliothequAyr : le choix d'une image est envoyé aussitôt
(chargement = remplacement), validé ici (Pillow, 5 Mo maximum) et
répondu {"status": "ok", "url": ...} ; le client recharge alors la
page. Le retrait passe par action=retirer, confirmé côté client par
BoiteDialog. Journalisé comme l'avatar quand JOURNAL_ETAT=1."""
if not request.user.is_superuser:
return JsonResponse({"status": "forbidden"}, status=403)
cfg = SiteConfig.load()
if request.POST.get("action") == "retirer":
if cfg.background_image:
cfg.background_image.delete(save=False)
cfg.background_image = None
cfg.save(update_fields=["background_image"])
if getattr(settings, "JOURNAL_ETAT", False):
logger.info("fond : %s a retiré l'image de la connexion",
request.user.username)
return JsonResponse({"status": "ok", "url": None})
image = request.FILES.get("image")
if image is None:
return JsonResponse({"status": "aucune_image"}, status=400)
if image.size > FOND_MAX_OCTETS:
return JsonResponse({"status": "trop_grosse"}, status=413)
if not (image.content_type or "").startswith("image/"):
return JsonResponse({"status": "pas_image"}, status=400)
try:
from PIL import Image as PILImage
ouverte = PILImage.open(image)
ouverte.verify()
image.seek(0)
except Exception:
return JsonResponse({"status": "pas_image"}, status=400)
if cfg.background_image:
cfg.background_image.delete(save=False) # remplace l'ancienne image
cfg.background_image = image
cfg.save()
if getattr(settings, "JOURNAL_ETAT", False):
logger.info("fond : %s a posé une image de connexion (%s octets reçus)",
request.user.username, image.size)
return JsonResponse({"status": "ok", "url": cfg.background_image.url})
# ------------------------------------------------------------------ connexion
def connexion(request):
"""Page de connexion ; à la toute première visite du site, elle devient
l'écran de création du compte administrateur (Ayr)."""
if not User.objects.exists():
return _premiere_installation(request)
# Filet de sécurité : le tout premier compte est celui de l'administrateur
# (c'est lui qui ouvre les comptes de la famille). Si la base vient d'une
# version ancienne du site qui l'avait créé sans droits, on le promeut —
# sinon la page Paramètres resterait inatteignable, sans explication.
premier = User.objects.order_by("pk").first()
if premier and not premier.is_superuser and User.objects.count() == 1:
premier.is_staff = True
premier.is_superuser = True
premier.save(update_fields=["is_staff", "is_superuser"])
return auth_views.LoginView.as_view(template_name="registration/login.html")(request)
def _premiere_installation(request):
erreur = ""
if request.method == "POST":
username = (request.POST.get("username") or "").strip()
pw1 = request.POST.get("password1") or ""
pw2 = request.POST.get("password2") or ""
if not username or " " in username:
erreur = "Choisissez un identifiant sans espace."
elif len(pw1) < 6:
erreur = "Le mot de passe doit faire au moins 6 caractères."
elif pw1 != pw2:
erreur = "Les deux mots de passe ne concordent pas."
elif User.objects.filter(username__iexact=username).exists():
erreur = "Cet identifiant existe déjà."
else:
User.objects.create_superuser(username=username, email="", password=pw1)
SiteConfig.load() # crée la ligne de configuration
auth_login(request, User.objects.get(username=username))
return redirect("jeu")
return render(request, "registration/login.html", {"installation": True, "erreur": erreur})