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).
422 lines
18 KiB
Python
Executable file
422 lines
18 KiB
Python
Executable file
"""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})
|