"""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 —
→ + window.MOTS (les mots, depuis la
base) + window.ETAT (progression du compte + CSRF) + le menu
+ le gabarit caché du chargeur d'image (variante avatar),
→ + 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 : 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 ('' + 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,
) + "")
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 = ('')
icone_compas = ('')
icone_horloge = ('')
utilisateur = render_to_string("_menu_utilisateur.html", request=request)
return f"""
{nom_site}
"""
# --------------------------------------------------------------------- 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(
"",
'\n'
f'\n'
+ _menu_html(request)
+ _fragment_avatar(request, profil),
1,
)
page = page.replace("", "\n", 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})