VocabulAyr 0.03

Menu utilisateur du rail identique au mobile (Mon avatar, Paramètres, Admin, Déconnexion) ; titre du site masqué sur téléphone/tablette.
Fragment réutilisable _image_upload.html pour le fond (Paramètres) et l'avatar, à la façon BibliothequAyr ; nouvelle route POST /api/fond/ (admin, Pillow, plafond 5 Mo) ; retrait du fond via BoiteDialog.
Icônes SVG du site à la place des Bootstrap Icons jamais chargées ; les 9 favicons voyagent dans le projet.
Aucune migration ; moteur, anti-régression et journal intacts.
This commit is contained in:
VocabulAyr 2026-11-08 15:32:06 +00:00
commit 05335d39a6
64 changed files with 28946 additions and 0 deletions

9
.dockerignore Executable file
View file

@ -0,0 +1,9 @@
# Rien de secret ni de volatil dans l'image : data/ et staticfiles/
# sont des volumes, .env est injecté par docker compose (env_file).
.env
data/
staticfiles/
__pycache__/
*.pyc
.ruff_cache/
.git/

8
.gitignore vendored Executable file
View file

@ -0,0 +1,8 @@
# VocabulAyr
/data/
/staticfiles/
.env
__pycache__/
*.pyc
.ruff_cache/
.DS_Store

26
Dockerfile Executable file
View file

@ -0,0 +1,26 @@
# Image de production VocabulAyr (calque BibliothequAyr / CulinAyr)
FROM python:3.14-slim
ENV PYTHONDONTWRITEBYTECODE=1 \
PYTHONUNBUFFERED=1 \
PYTHONPATH=/app
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt \
&& pip install --no-cache-dir gunicorn==23.0.0
# Code + script d'entrée (data/ et .env restent hors image : volumes/montés)
COPY . .
# Utilisateur dédié, uid:gid fixes — mêmes numéros de la maison que les autres projets
RUN groupadd --gid 1005 vocabulayr \
&& useradd --uid 1001 --gid 1005 --create-home vocabulayr \
&& mkdir -p /app/data /app/staticfiles \
&& chown -R 1001:1005 /app \
&& chmod +x /app/docker-entrypoint.sh
USER 1001:1005
EXPOSE 8000
ENTRYPOINT ["/app/docker-entrypoint.sh"]

201
README.md Executable file
View file

@ -0,0 +1,201 @@
# VocabulAyr — Le Fil des Mots
Jeu d'étymologie française pour toute la famille, auto-hébergé :
un chemin de 105 mots et expressions, cinq pistes par mot (sens,
origines, registre, emplois, voisins), des mini-jeux, une fiche
d'étymologie par mot, des grades d'écriture (du Griffonneur au
Calligraphe d'or) et un thème clair/sombre. Le chemin n'ouvre qu'un
mot à la fois : sa fiche assemblée à 100 % ouvre le suivant, et
toutes les fiches acquises restent relire dans l'**Historique**.
Adresse de la maison : **https://vocabulaire.servayr.duckdns.org**
(port local 8020, même série que bibliothequayr=8000 et culinayr=8010).
Techniquement : le projet sépare les **rouages du savoir**. Le savoir —
les mots, leurs pistes, leurs mini-jeux — vit **en base de données**
(table `jeu_mot` du dossier `data/`, avec un catalogue embarqué dans
`jeu/catalogue/mots-complet.json` pour les installations neuves). Les
rouages — le moteur du jeu — sont le fichier `jeu/static/jeu/index.html`
(polices incrustées, zéro dépendance extérieure) que Django 6 habille :
il y injecte les mots (`window.MOTS`), l'état du compte (`window.ETAT`)
et le menu du site. Le moteur ne contient plus aucun mot.
## Ce que le site ajoute au fichier
- **Des comptes de joueurs.** Ayr ouvre les comptes dans l'admin
(`/admin/` → Utilisateurs) ; chaque membre se connecte ensuite sur
n'importe quel appareil (tablette, téléphone, PC) et retrouve sa
progression.
- **La progression ET le savoir en base de données** (SQLite, dossier
`data/`). Le jeu sauvegarde la progression au fil du jeu ; les mots
sont importés depuis le catalogue au premier démarrage. **La
sauvegarde nocturne couvre donc tout le site** : progressions,
comptes, mots, mini-jeux.
- **Un site fermé.** Sans connexion, une seule page : la connexion.
- **Une page Paramètres** (menu du site, réservée à l'administrateur,
même esprit que BibliothequAyr) : le **titre du site** — affiché dans
le menu, sur les téléphones et sur la page de connexion — et
**l'image de fond de la connexion**, avec aperçu immédiat et bouton
pour la retirer. L'icône d'onglet (favicon) se dépose à part, dans
`jeu/static/jeu/favicons/` du serveur.
- **Une page Historique** : les fiches de tous les mots en poche,
en lecture seule, avec leur badge (Fiche parfaite / improvisée).
- **« Recommencer à zéro »**, en bas du jeu : chaque joueur remet sa
propre progression à vide (double confirmation).
## La première connexion (une seule fois)
Le site commence vide : la page de connexion devient alors l'écran de
**première installation** — on y crée le compte de l'administrateur
(« Ayr »). À partir de là, cet écran redevient la page de connexion
classique et l'admin s'ouvre avec ce compte.
## Déployer sa propre instance
### Le conseil principal
Si vous n'êtes pas à l'aise avec Docker et Linux : **faites-vous
accompagner par une IA**. Donnez-lui ce README, le Dockerfile et le
docker-compose.yml du dépôt, décrivez votre machine (distribution,
Docker installé ?), et faites chaque étape avec elle, une à la fois.
### Les pièces du puzzle (pour comprendre avant de taper)
- **Le code** : ce dépôt git. Il contient tout sauf vos données et
vos secrets.
- **L'image Docker** : construite par `docker compose up --build`.
Le code y est figé ; vos données, jamais.
- **Le dossier data/** : la base SQLite (comptes, progressions) et
les médias (image de fond de la connexion). **C'est ici que vit
maintenant la progression de toute la famille** — les sauvegardes
sont indispensables (voir étape 7).
- **Le fichier .env** : deux lignes de secrets. `DEBUG=0` (mode
production). `SECRET_KEY` : la clé avec laquelle le site signe ses
sessions et ses cookies — **ce n'est pas une clé d'API**. Elle se
génère une fois, se garde précieusement, ne se partage jamais.
Une variable optionnelle, `JOURNAL_ETAT=1`, active le journal de
diagnostic (chaque sauvegarde de progression et d'avatar notée dans
`docker logs vocabulayr`) : à retirer une fois le problème résolu,
en production normale rien ne s'écrit.
- **docker-compose.yml** : fourni — le conteneur, son port (8020, en
local seulement) et les dossiers montés. Il voyage avec le code.
- **VERSION** : le numéro de la version installée, incrémenté de 0.01
à chaque livraison. `cat VERSION` le rappelle, et l'image Docker
porte la même étiquette (`docker images | grep vocabulayr`).
- **install/** : les deux fichiers du timer de sauvegarde systemd,
prêts à copier dans `/etc/systemd/system/` (étape 7).
### Les étapes
1. **Récupérer le code**
git clone <URL-du-dépôt> vocabulayr && cd vocabulayr
2. **Créer le .env**
echo "DEBUG=0" > .env
echo "SECRET_KEY=$(python3 -c 'import secrets; print(secrets.token_urlsafe(64))')" >> .env
chmod 600 .env
3. **Préparer les dossiers de données**
mkdir -p data staticfiles
sudo chown -R 1001:1005 data staticfiles
(1001:1005 = l'utilisateur interne du conteneur, mêmes numéros
que bibliothequayr et culinayr.)
4. **Lancer**
docker compose up -d --build
Au premier démarrage : migration, fichiers statiques collectés,
gunicorn à l'écoute sur le port **8020 de la machine, en local
uniquement**. Ensuite : nom de domaine + reverse proxy HTTPS
devant (Caddy, nginx…) qui transmet au 8020 — un extrait de
Caddyfile prêt à adapter est dans `docs/caddy-extrait.txt`.
5. **Ouvrir https://vocabulaire.servayr.duckdns.org** → l'écran de
première installation crée le compte administrateur.
6. **Ouvrir les comptes de la famille** : `/admin/` (compte Ayr) →
Utilisateurs → Ajouter. Un identifiant, un mot de passe, c'est
tout — le jeu crée la progression de chacun à la première partie.
7. **Sauvegarde nocturne** (indispensable : la base porte désormais
tout — progressions, comptes, mots, mini-jeux)
scripts/sauvegarde-vocabulayr.sh # premier essai, à la main
Le script fait : copie cohérente de la base (« à chaud », mécanisme
officiel SQLite), contrôle d'intégrité, empreintes sha256, copie
des médias, garde 7 jeux. Destination :
`/mnt/share/sauvegardes/vocabulayr/<date>/` (le même disque protégé
que BibliothequAyr). Puis le timer systemd — tous les jours à 4h00,
décalé de BibliothequAyr qui tourne à 3h30 :
sudo cp install/vocabulayr-sauvegarde.* /etc/systemd/system/
sudo systemctl daemon-reload
sudo systemctl enable --now vocabulayr-sauvegarde.timer
systemctl list-timers --no-pager | grep vocabulayr
## Ajouter des mots / mettre le jeu à jour
Les mots vivent **en base** : on ne touche plus jamais au fichier du
moteur pour du contenu.
### Ajouter ou modifier un mot
1. Préparez un fichier `mot.json` au format catalogue (même forme que
les entrées de `jeu/catalogue/mots-complet.json` : identifiant,
titre, fiche `card`, les cinq `pistes` avec leurs mini-jeux, les
perles de résolution) ;
2. Dans le dossier du site, sur le serveur :
docker exec -it vocabulayr python manage.py ajouter_mot mot.json
Ajouté à la suite du chemin, ou inséré avec `--ordre 7`. L'identifiant
existe déjà ? Le mot est mis à jour, la place conservée.
La structure est vérifiée avant écriture ; rien ne rentre si elle
cloche, et la base entière est recontrôlée après.
### Mettre le code à jour
1. Remplacez le code par la nouvelle version (l'archive du
coordonnateur, en gardant `data/` et `.env`) ;
2. `docker compose up -d --build`. ~10 secondes d'interruption.
Au démarrage, une base vide reçoit automatiquement le catalogue
(`importer_mots --si-vide`) : une base existante n'est jamais touchée.
La progression de chacun est conservée : elle ne dépend que des
identifiants de mots, jamais de la version du code.
## Développer / faire évoluer
- Dossier séparé pour le dev (ex. vocabulayr-dev), même dépôt,
DEBUG=1 dans son .env, port **8021** (jamais le 8020). Avant le
premier `compose.dev.yml up` : `docker volume create vocabulayr-pip`.
- Commandes de gestion du savoir :
python manage.py importer_mots # (ré)importe le catalogue
python manage.py ajouter_mot mot.json # ajoute/met à jour un mot
python manage.py verifier_mots # filet de sécurité structurel
python manage.py exporter_mots --fichier sauv.json # sortie catalogue
- Tests du projet : `python manage.py test` (26 tests : site fermé,
première installation, progression, catalogue, registre ternaire,
commandes d'ajout/export).
- Pistes d'évolution : statistiques de famille,
mode « rejouer » dans l'Historique, éditeur de mots dans l'admin.
## Restaurer après un sinistre (le mode d'emploi du moi-de-dans-5-ans)
1. Réinstallez Docker, clonez ce dépôt (étapes 1 et 2 ci-dessus —
un .env neuf avec une NOUVELLE SECRET_KEY convient) ;
2. Récupérez `data/` depuis votre disque de sauvegarde (db.sqlite3
+ media/), placez-le dans `data/` — il porte les comptes, les
progressions **et les 105 mots avec leurs mini-jeux** ;
3. `docker compose up -d --build` ;
4. Le site revient tel quel : comptes, progressions, mots, image de
fond. (Sans `data/`, le site repart du catalogue : les mots y sont,
seuls comptes et progressions sont perdus.)

1
VERSION Executable file
View file

@ -0,0 +1 @@
0.03

21
compose.dev.yml Executable file
View file

@ -0,0 +1,21 @@
# Environnement de développement — ne JAMAIS pointer Caddy prod dessus.
# Le cache pip est partagé : avant le premier `up`, créer le volume :
# docker volume create vocabulayr-pip
services:
vocabulayr-dev:
image: python:3.14.7-slim
container_name: vocabulayr-dev
user: "1001:1005"
working_dir: /app
command: >
sh -c "pip install --no-cache-dir -r requirements.txt
&& python manage.py migrate --noinput
&& python manage.py runserver 0.0.0.0:8000"
ports:
- "127.0.0.1:8021:8000"
volumes:
- .:/app
- vocabulayr-pip:/root/.cache/pip
volumes:
vocabulayr-pip:
external: true

0
config/__init__.py Executable file
View file

127
config/settings.py Executable file
View file

@ -0,0 +1,127 @@
"""Django settings pour VocabulAyr (calque BibliothequAyr)."""
from pathlib import Path
import os
BASE_DIR = Path(__file__).resolve().parent.parent
def _load_env(path):
"""Charge un .env (clé=valeur) : # ignorés, guillemets retirés."""
if not path.exists():
return
for line in path.read_text().splitlines():
line = line.strip()
if not line or line.startswith("#") or "=" not in line:
continue
key, _, value = line.partition("=")
os.environ.setdefault(key.strip(), value.strip().strip('"').strip("'"))
_load_env(BASE_DIR / ".env")
SECRET_KEY = os.environ.get("SECRET_KEY")
if not SECRET_KEY:
raise RuntimeError(
"SECRET_KEY absente : créez le fichier .env à la racine du projet "
"(voir README, étape 2)."
)
DEBUG = os.environ.get("DEBUG", "1") == "1"
# Journal de diagnostic : JOURNAL_ETAT=1 dans .env note chaque arrivée
# (qui, quoi, combien) dans les logs du conteneur (docker logs). Absent
# ou à 0 : rien ne s'écrit — en production normale, aucun tracé.
JOURNAL_ETAT = os.environ.get("JOURNAL_ETAT", "0") == "1"
ALLOWED_HOSTS = [
"vocabulaire.servayr.duckdns.org",
"localhost",
"127.0.0.1",
]
INSTALLED_APPS = [
"django.contrib.admin",
"django.contrib.auth",
"django.contrib.contenttypes",
"django.contrib.sessions",
"django.contrib.messages",
"django.contrib.staticfiles",
"jeu.apps.JeuConfig",
]
MIDDLEWARE = [
"django.middleware.security.SecurityMiddleware",
"django.contrib.sessions.middleware.SessionMiddleware",
"django.middleware.common.CommonMiddleware",
"django.middleware.csrf.CsrfViewMiddleware",
"django.contrib.auth.middleware.AuthenticationMiddleware",
"jeu.middleware.LoginRequiredMiddleware",
"django.contrib.messages.middleware.MessageMiddleware",
"django.middleware.clickjacking.XFrameOptionsMiddleware",
]
ROOT_URLCONF = "config.urls"
TEMPLATES = [
{
"BACKEND": "django.template.backends.django.DjangoTemplates",
"DIRS": [],
"APP_DIRS": True,
"OPTIONS": {
"context_processors": [
"django.template.context_processors.request",
"django.template.context_processors.csrf",
"django.contrib.auth.context_processors.auth",
"django.contrib.messages.context_processors.messages",
"jeu.context_processors.site_config",
"jeu.context_processors.avatar",
],
},
},
]
WSGI_APPLICATION = "config.wsgi.application"
os.makedirs(BASE_DIR / "data", exist_ok=True) # installation fraîche viable
DATABASES = {
"default": {
"ENGINE": "django.db.backends.sqlite3",
"NAME": BASE_DIR / "data" / "db.sqlite3",
}
}
AUTH_PASSWORD_VALIDATORS = [] # volontairement vide : la famille choisit ses mots de passe
LANGUAGE_CODE = "fr-fr"
TIME_ZONE = "Europe/Paris"
USE_I18N = True
USE_TZ = True
STATIC_URL = "static/"
MEDIA_URL = "/media/"
MEDIA_ROOT = BASE_DIR / "data" / "media"
# L'image de fond de la connexion peut être lourde (5 Mo autorisés dans
# la vue) : on laisse passer le corps de la requête correspondant.
DATA_UPLOAD_MAX_MEMORY_SIZE = 12 * 1024 * 1024
CSRF_TRUSTED_ORIGINS = ["https://vocabulaire.servayr.duckdns.org"]
SECURE_PROXY_SSL_HEADER = ("HTTP_X_FORWARDED_PROTO", "https")
LOGIN_URL = "/login/"
LOGIN_REDIRECT_URL = "/"
LOGOUT_REDIRECT_URL = "/login/"
STATIC_ROOT = BASE_DIR / "staticfiles"
DEFAULT_AUTO_FIELD = "django.db.models.BigAutoField"
# La famille se reconnecte rarement : session mémorisée un an sur chaque appareil.
SESSION_COOKIE_AGE = 365 * 24 * 3600
if not DEBUG:
SESSION_COOKIE_SECURE = True
CSRF_COOKIE_SECURE = True
SECURE_SSL_REDIRECT = True
SECURE_HSTS_SECONDS = 3600
SECURE_HSTS_INCLUDE_SUBDOMAINS = True
LOGGING = {
"version": 1,
"disable_existing_loggers": False,
"handlers": {"console": {"class": "logging.StreamHandler"}},
"loggers": {"jeu": {"handlers": ["console"], "level": "INFO", "propagate": False}},
}

35
config/urls.py Executable file
View file

@ -0,0 +1,35 @@
from django.conf import settings
from django.conf.urls.static import static
from django.contrib import admin
from django.contrib.auth import views as auth_views
from django.urls import path
from jeu import views
urlpatterns = [
path("admin/", admin.site.urls),
path("login/", views.connexion, name="login"),
path("logout/", auth_views.LogoutView.as_view(), name="logout"),
path("", views.jeu, name="jeu"),
path("historique/", views.historique, name="historique"),
path("parametres/", views.parametres, name="parametres"),
path("api/etat/", views.api_etat, name="api_etat"),
path("api/avatar/", views.api_avatar, name="api_avatar"),
path("api/fond/", views.api_fond, name="api_fond"),
path("api/reinitialiser/", views.api_reinitialiser, name="api_reinitialiser"),
]
# Fichiers servis par Django dans les deux modes (décision production de
# BibliothequAyr : site fermé — les médias restent derrière la connexion,
# Caddy ne fait que le proxy vers Django).
if settings.DEBUG:
urlpatterns += static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)
else:
from django.views.static import serve as static_serve
urlpatterns += [
path("static/<path:path>", static_serve,
{"document_root": settings.STATIC_ROOT}),
path("media/<path:path>", static_serve,
{"document_root": settings.MEDIA_ROOT}),
]

7
config/wsgi.py Executable file
View file

@ -0,0 +1,7 @@
import os
from django.core.wsgi import get_wsgi_application
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "config.settings")
application = get_wsgi_application()

14
docker-compose.yml Executable file
View file

@ -0,0 +1,14 @@
services:
vocabulayr:
build: .
image: vocabulayr:0.03
container_name: vocabulayr
user: "1001:1005"
restart: unless-stopped
ports:
- "127.0.0.1:8020:8000"
env_file:
- .env
volumes:
- ./data:/app/data
- ./staticfiles:/app/staticfiles

9
docker-entrypoint.sh Executable file
View file

@ -0,0 +1,9 @@
#!/usr/bin/env bash
set -euo pipefail
cd /app
python manage.py migrate --noinput
# Les mots vivent en base : une base neuve (ou migrée d'avant la base)
# reçoit automatiquement le catalogue embarqué. Base déjà peuplée : rien.
python manage.py importer_mots --si-vide
python manage.py collectstatic --noinput
exec gunicorn --bind 0.0.0.0:8000 --workers 2 config.wsgi:application

6
docs/caddy-extrait.txt Executable file
View file

@ -0,0 +1,6 @@
# Extrait à adapter dans le Caddyfile du serveur (ArC Linux).
# Le site est fermé : Caddy ne fait que le proxy HTTPS vers Django,
# qui sert lui-même /static/ et /media/ (tout reste derrière la connexion).
vocabulaire.servayr.duckdns.org {
reverse_proxy 127.0.0.1:8020
}

View file

@ -0,0 +1,8 @@
# /etc/systemd/system/vocabulayr-sauvegarde.service
[Unit]
Description=Sauvegarde nocturne VocabulAyr (SQLite a chaud + medias)
[Service]
Type=oneshot
User=pasroot
ExecStart=/srv/vocabulayr/scripts/sauvegarde-vocabulayr.sh

View file

@ -0,0 +1,10 @@
# /etc/systemd/system/vocabulayr-sauvegarde.timer
[Unit]
Description=Declenche la sauvegarde VocabulAyr a 4h00
[Timer]
OnCalendar=*-*-* 04:00:00
Persistent=true
[Install]
WantedBy=timers.target

0
jeu/__init__.py Executable file
View file

47
jeu/admin.py Executable file
View file

@ -0,0 +1,47 @@
import json
from django.contrib import admin
from django.contrib.auth.admin import UserAdmin as BaseUserAdmin
from django.contrib.auth.models import User
from jeu.models import Progression, SiteConfig
class ProgressionInline(admin.TabularInline):
model = Progression
can_delete = False
verbose_name_plural = "Progression"
fields = ("data_pretty", "maj")
readonly_fields = ("data_pretty", "maj")
@admin.display(description="état du jeu")
def data_pretty(self, obj):
try:
return json.dumps(obj.data, ensure_ascii=False, indent=2) or "{}"
except (TypeError, ValueError):
return str(obj.data)
def has_add_permission(self, request, obj=None):
return False
admin.site.unregister(User)
@admin.register(User)
class CompteAdmin(BaseUserAdmin):
"""Ayr ouvre et gère ici les comptes de la famille."""
inlines = [ProgressionInline]
list_display = ("username", "last_login", "is_staff", "date_joined")
@admin.register(SiteConfig)
class SiteConfigAdmin(admin.ModelAdmin):
"""Configuration du site : une seule ligne, créée une fois, jamais supprimée."""
fields = ("site_name", "background_image")
def has_add_permission(self, request):
return not SiteConfig.objects.exists()
def has_delete_permission(self, request, obj=None):
return False

7
jeu/apps.py Executable file
View file

@ -0,0 +1,7 @@
from django.apps import AppConfig
class JeuConfig(AppConfig):
default_auto_field = "django.db.models.BigAutoField"
name = "jeu"
verbose_name = "VocabulAyr"

24956
jeu/catalogue/mots-complet.json Executable file

File diff suppressed because it is too large Load diff

32
jeu/context_processors.py Executable file
View file

@ -0,0 +1,32 @@
from pathlib import Path
from django.conf import settings
from jeu.models import Profil, SiteConfig
def _asset_version():
"""Version = mtime le plus récent des assets maison (cache-busting ?v=)."""
version = 0
base = Path(settings.BASE_DIR) / "jeu" / "static" / "jeu"
for motif in ("*.css", "*.js"):
for f in base.glob(motif):
try:
version = max(version, int(f.stat().st_mtime))
except OSError:
pass
return version
def site_config(request):
"""Configuration globale + version des assets, pour tous les templates."""
return {"site_config": SiteConfig.load(), "asset_version": _asset_version()}
def avatar(request):
"""L'URL de l'avatar du compte (ou None) : base.html affiche l'image
dans la pastille du menu au lieu de l'initiale."""
if not request.user.is_authenticated:
return {"avatar_url": None}
profil = Profil.objects.filter(user=request.user).first()
return {"avatar_url": profil.avatar.url if (profil and profil.avatar) else None}

19
jeu/controle.py Executable file
View file

@ -0,0 +1,19 @@
# -*- coding: utf-8 -*-
"""Vérifie tous les mots en base, dans l'ordre du chemin."""
from jeu.models import Mot
from jeu.validation import verifier_entree
def verifier_base():
"""Renvoie (nombre de mots, liste d'erreurs)."""
erreurs = []
n = 0
ordre_vus = set()
for mot in Mot.objects.order_by("ordre"):
n += 1
erreurs += verifier_entree(mot.vers_donnees(True), ou=mot.slug)
ordre_vus.add(mot.ordre)
# contiguïté du chemin : 1, 2, 3… sans trou (simple avertissement intégré)
if n and ordre_vus != set(range(1, n + 1)):
erreurs.append("chemin : les positions ne se suivent pas (trou ou doublon dans l'ordre).")
return n, erreurs

0
jeu/management/__init__.py Executable file
View file

View file

View file

@ -0,0 +1,89 @@
# -*- coding: utf-8 -*-
"""Ajoute (ou met à jour) un mot dans la base, depuis un fichier JSON.
C'est le script d'ajout de mots, pour faire grandir le chemin :
python manage.py ajouter_mot mot.json # à la suite
python manage.py ajouter_mot mot.json --ordre 7 # inséré en 7e position
Le fichier contient UN mot, ou une liste de mots, au format catalogue
(la même forme que les entrées de mots-complet.json, pistes comprises).
- identifiant déjà en base → le mot est mis à jour (sa place est gardée,
sauf si --ordre est fourni) ;
- identifiant nouveau → le mot est créé, les suivants glissent d'un cran
si une position précise est demandée.
La structure est vérifiée avant toute écriture, et la base entière est
recontrôlée après : rien ne rentre sans passer le filet.
"""
import json
from pathlib import Path
from django.core.management.base import BaseCommand
from jeu.controle import verifier_base
from jeu.models import Mot
from jeu.validation import verifier_entree
CHAMPS = ("titre", "nature", "tampon", "accroche", "note_carte", "defi",
"definition", "etymologie", "date_apparition", "registre",
"anecdote", "voisins", "pistes", "resolve")
class Command(BaseCommand):
help = "Ajoute ou met à jour un (ou plusieurs) mot(s) depuis un fichier JSON au format catalogue."
def add_arguments(self, parser):
parser.add_argument("fichier", help="Fichier JSON du mot (ou liste de mots).")
parser.add_argument("--ordre", type=int, default=None,
help="Position sur le chemin (1 = premier). Défaut : à la suite.")
def handle(self, *args, **options):
donnees = json.loads(Path(options["fichier"]).read_text(encoding="utf-8"))
if isinstance(donnees, dict):
donnees = [donnees]
erreurs = []
for i, d in enumerate(donnees):
erreurs += verifier_entree(d, ou=f"« {d.get('id', '?')} »")
if erreurs:
for msg in erreurs[:20]:
self.stderr.write(msg)
self.stderr.write(f"Aucune écriture : {len(erreurs)} erreur(s) détectée(s).")
raise SystemExit(1)
position = options["ordre"]
for d in donnees:
mot = Mot.objects.filter(slug=d["id"]).first()
if mot is not None:
neuf = Mot.depuis_donnees(d)
for champ in CHAMPS:
setattr(mot, champ, getattr(neuf, champ))
if position is not None:
mot.ordre = position
mot.save()
self.stdout.write(self.style.SUCCESS(
f"« {mot.titre} » ({mot.slug}) mis à jour — place {mot.ordre}."))
continue
if position is not None:
# list() : on matérialise avant de déplacer, sinon la
# requête voit ses propres lignes bouger pendant le parcours
for m in list(Mot.objects.filter(ordre__gte=position).order_by("-ordre")):
m.ordre += 1 # du plus grand au plus petit : aucune collision
m.save()
mot = Mot.depuis_donnees(d, ordre=position)
else:
dernier = Mot.objects.order_by("-ordre").first()
mot = Mot.depuis_donnees(d, ordre=(dernier.ordre + 1) if dernier else 1)
mot.save()
self.stdout.write(self.style.SUCCESS(
f"« {mot.titre} » ({mot.slug}) enregistré — place {mot.ordre}."))
position = None # les suivants d'une liste se placent après, à la suite
nb, erreurs = verifier_base()
if erreurs:
for msg in erreurs[:10]:
self.stderr.write(msg)
raise SystemExit(1)
self.stdout.write(self.style.SUCCESS(
f"Base recontrôlée : {nb} mot(s), structure impeccable."))

View file

@ -0,0 +1,32 @@
# -*- coding: utf-8 -*-
"""Exporte les mots de la base au format catalogue.
Le retour arrière facile : `python manage.py exporter_mots --fichier
sauvegarde-mots.json` produit un fichier réimportable tel quel par
`importer_mots --fichier`. Pratique pour sauvegarder le savoir seul ou
le transporter vers une autre instance.
"""
import json
from pathlib import Path
from django.core.management.base import BaseCommand
from jeu.models import Mot
class Command(BaseCommand):
help = "Exporte tous les mots (format catalogue, pistes comprises) vers un fichier ou la sortie."
def add_arguments(self, parser):
parser.add_argument("--fichier", default=None,
help="Fichier de sortie (défaut : sortie standard).")
def handle(self, *args, **options):
data = [m.vers_donnees(True) for m in Mot.objects.order_by("ordre")]
texte = json.dumps(data, ensure_ascii=False, indent=1) + "\n"
if options["fichier"]:
Path(options["fichier"]).write_text(texte, encoding="utf-8")
self.stdout.write(self.style.SUCCESS(
f"{len(data)} mot(s) exporté(s) vers {options['fichier']}."))
else:
self.stdout.write(texte)

View file

@ -0,0 +1,69 @@
# -*- coding: utf-8 -*-
"""Importe le catalogue de mots dans la base (création ou mise à jour).
C'est la commande du démarrage : le conteneur la lance avec --si-vide à
chaque boot, si bien qu'une base neuve (ou une base migrée qui ne
connaissait pas encore la table) reçoit les 105 mots automatiquement.
"""
import json
from pathlib import Path
from django.core.management.base import BaseCommand
from jeu.models import Mot
from jeu.validation import verifier_entree
CATALOGUE = Path(__file__).resolve().parents[2] / "catalogue" / "mots-complet.json"
CHAMPS = ("titre", "nature", "tampon", "accroche", "note_carte", "defi",
"definition", "etymologie", "date_apparition", "registre",
"anecdote", "voisins", "pistes", "resolve")
class Command(BaseCommand):
help = "Importe le catalogue des mots : crée ou met à jour par identifiant, dans l'ordre du fichier."
def add_arguments(self, parser):
parser.add_argument("--fichier", default=str(CATALOGUE),
help="Catalogue JSON à importer (défaut : catalogue embarqué).")
parser.add_argument("--si-vide", action="store_true",
help="N'importe que si la base ne contient encore aucun mot.")
parser.add_argument("--vider", action="store_true",
help="Supprime tous les mots avant l'import.")
def handle(self, *args, **options):
if options["si_vide"] and Mot.objects.exists():
self.stdout.write("La base contient déjà des mots : import ignoré (--si-vide).")
return
donnees = json.loads(Path(options["fichier"]).read_text(encoding="utf-8"))
if not isinstance(donnees, list) or not donnees:
self.stderr.write("Le fichier doit contenir une liste non vide de mots.")
raise SystemExit(1)
erreurs = []
for i, d in enumerate(donnees):
erreurs += verifier_entree(d, ou=f"n°{i + 1}")
if erreurs:
for msg in erreurs[:20]:
self.stderr.write(msg)
self.stderr.write(f"Import annulé : {len(erreurs)} erreur(s) détectée(s).")
raise SystemExit(1)
if options["vider"]:
Mot.objects.all().delete()
crees = mis = 0
for i, d in enumerate(donnees):
mot = Mot.objects.filter(slug=d["id"]).first()
if mot is None:
Mot.depuis_donnees(d, ordre=i + 1).save()
crees += 1
else:
neuf = Mot.depuis_donnees(d)
for champ in CHAMPS:
setattr(mot, champ, getattr(neuf, champ))
mot.ordre = i + 1
mot.save()
mis += 1
self.stdout.write(self.style.SUCCESS(
f"Import terminé : {crees} créé(s), {mis} mis à jour, {Mot.objects.count()} mot(s) en base."))

View file

@ -0,0 +1,25 @@
# -*- coding: utf-8 -*-
"""Vérifie la structure de tous les mots en base.
Le filet de sécurité : chaque mot est passé au crible (identité, fiche,
5 pistes, chaque mini-jeu conforme à son type, perles de résolution,
ordre du chemin). Code de sortie 1 au premier pépin : la commande peut
servir de garde-fou après un import ou une édition manuelle.
"""
from django.core.management.base import BaseCommand
from jeu.controle import verifier_base
class Command(BaseCommand):
help = "Vérifie la structure de tous les mots en base (identité, pistes, mini-jeux, chemin)."
def handle(self, *args, **options):
nb, erreurs = verifier_base()
if erreurs:
for msg in erreurs[:30]:
self.stderr.write(msg)
self.stderr.write(self.style.ERROR(
f"{len(erreurs)} erreur(s) détectée(s) sur {nb} mot(s)."))
raise SystemExit(1)
self.stdout.write(self.style.SUCCESS(f"{nb} mot(s) vérifié(s) : structure impeccable."))

33
jeu/middleware.py Executable file
View file

@ -0,0 +1,33 @@
"""Fermeture du site : toute requête d'un utilisateur non connecté est
redirigée vers la page de connexion, sauf exceptions explicites."""
from django.conf import settings
from django.http import JsonResponse
from django.shortcuts import redirect
class LoginRequiredMiddleware:
# /static/ est servi par Django : il doit rester accessible pour que la
# page de connexion puisse charger ses ressources ; /media/theme/ porte
# l'image de fond de la connexion, publique par nécessité ; /admin/ a
# sa propre page de connexion et sa propre protection.
EXEMPT_PREFIXES = ('/static/', '/media/theme/', '/admin/')
def __init__(self, get_response):
self.get_response = get_response
def __call__(self, request):
if not request.user.is_authenticated:
path = request.path
if not path.startswith(settings.LOGIN_URL) \
and not path.startswith(self.EXEMPT_PREFIXES):
if path.startswith('/api/'):
return JsonResponse({"status": "unauthorized"}, status=401)
return redirect(
f'{settings.LOGIN_URL}?next={request.get_full_path()}')
response = self.get_response(request)
# Pages toujours fraîches : la page du jeu porte l'état du compte
# injecté par le serveur, elle ne doit jamais sortir du cache HTTP.
# /static/ et /media/ restent cachables (le ?v= les versionne).
if not request.path.startswith('/static/') and not request.path.startswith('/media/'):
response['Cache-Control'] = 'no-store, must-revalidate'
return response

42
jeu/migrations/0001_initial.py Executable file
View file

@ -0,0 +1,42 @@
# Generated by Django 6.1.1 on 2026-11-05 14:44
import django.db.models.deletion
from django.conf import settings
from django.db import migrations, models
class Migration(migrations.Migration):
initial = True
dependencies = [
migrations.swappable_dependency(settings.AUTH_USER_MODEL),
]
operations = [
migrations.CreateModel(
name='SiteConfig',
fields=[
('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('site_name', models.CharField(blank=True, default='VocabulAyr', max_length=80, verbose_name='nom du site')),
('background_image', models.ImageField(blank=True, null=True, upload_to='theme/', verbose_name='image de fond (page de connexion)')),
],
options={
'verbose_name': 'configuration du site',
'verbose_name_plural': 'configuration du site',
},
),
migrations.CreateModel(
name='Progression',
fields=[
('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('data', models.JSONField(blank=True, default=dict)),
('maj', models.DateTimeField(auto_now=True, verbose_name='mise à jour')),
('user', models.OneToOneField(on_delete=django.db.models.deletion.CASCADE, related_name='progression', to=settings.AUTH_USER_MODEL)),
],
options={
'verbose_name': 'progression',
'verbose_name_plural': 'progressions',
},
),
]

43
jeu/migrations/0002_mot.py Executable file
View file

@ -0,0 +1,43 @@
# Generated by Django 6.1.1 on 2026-11-06 08:51
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('jeu', '0001_initial'),
]
operations = [
migrations.CreateModel(
name='Mot',
fields=[
('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('slug', models.SlugField(help_text="Jamais modifié après création : la progression des comptes s'y attache.", max_length=60, unique=True, verbose_name='identifiant')),
('ordre', models.PositiveIntegerField(unique=True, verbose_name='place sur le chemin')),
('chapitre', models.PositiveIntegerField(default=1, verbose_name='chapitre')),
('titre', models.CharField(max_length=80)),
('nature', models.CharField(max_length=40, verbose_name='nature grammaticale')),
('tampon', models.CharField(choices=[('JUNIOR', 'Junior'), ('ADOS', 'Ados'), ('SÉNIOR', 'Sénior')], max_length=10)),
('accroche', models.TextField()),
('note_carte', models.TextField(verbose_name='note de la carte')),
('defi', models.BooleanField(default=False, verbose_name='défi')),
('definition', models.TextField()),
('etymologie', models.JSONField(default=list, verbose_name='chaîne étymologique')),
('date_apparition', models.CharField(max_length=60, verbose_name='première trace')),
('registre', models.CharField(max_length=30)),
('anecdote', models.TextField()),
('voisins', models.JSONField(default=list, verbose_name='mots voisins')),
('pistes', models.JSONField(default=dict, verbose_name='pistes de mini-jeux')),
('resolve', models.JSONField(blank=True, default=dict, verbose_name='perles de résolution')),
('cree', models.DateTimeField(auto_now_add=True, verbose_name='créé le')),
('maj', models.DateTimeField(auto_now=True, verbose_name='modifié le')),
],
options={
'verbose_name': 'mot',
'verbose_name_plural': 'mots',
'ordering': ['ordre'],
},
),
]

View file

@ -0,0 +1,17 @@
# Generated by Django 6.1.1 on 2026-11-06 10:25
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [
('jeu', '0002_mot'),
]
operations = [
migrations.RemoveField(
model_name='mot',
name='chapitre',
),
]

28
jeu/migrations/0004_profil.py Executable file
View file

@ -0,0 +1,28 @@
# Generated by Django 6.1.1 on 2026-11-07 17:44
import django.db.models.deletion
from django.conf import settings
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('jeu', '0003_remove_mot_chapitre'),
migrations.swappable_dependency(settings.AUTH_USER_MODEL),
]
operations = [
migrations.CreateModel(
name='Profil',
fields=[
('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('avatar', models.ImageField(blank=True, null=True, upload_to='avatars/', verbose_name='avatar')),
('user', models.OneToOneField(on_delete=django.db.models.deletion.CASCADE, related_name='profil', to=settings.AUTH_USER_MODEL)),
],
options={
'verbose_name': 'profil',
'verbose_name_plural': 'profils',
},
),
]

0
jeu/migrations/__init__.py Executable file
View file

175
jeu/models.py Executable file
View file

@ -0,0 +1,175 @@
from django.db import models
class SiteConfig(models.Model):
"""Réglages globaux du site, édités dans /admin (une seule ligne).
Le nom affiché et l'image de fond de la page de connexion (même
mécanique que BibliothequAyr)."""
site_name = models.CharField("nom du site", max_length=80, blank=True, default="VocabulAyr")
background_image = models.ImageField(
"image de fond (page de connexion)", upload_to="theme/", null=True, blank=True,
)
class Meta:
verbose_name = "configuration du site"
verbose_name_plural = "configuration du site"
def save(self, *args, **kwargs):
self.pk = 1 # une seule ligne, toujours
super().save(*args, **kwargs)
@classmethod
def load(cls):
obj, _ = cls.objects.get_or_create(pk=1)
return obj
def __str__(self):
return "Configuration"
class Progression(models.Model):
"""L'état de jeu d'un compte : le fil JSON tel que le moteur le lit.
Structure (tenue par le client, validée légèrement côté serveur) :
{"_g": {"idx": 12, "theme": "auto"},
"<id-du-mot>": {"p": {"sens": 1, ...}, "solved": 1, "badge": "parfaite"}}
"""
user = models.OneToOneField(
"auth.User", on_delete=models.CASCADE, related_name="progression",
)
data = models.JSONField(default=dict, blank=True)
maj = models.DateTimeField("mise à jour", auto_now=True)
class Meta:
verbose_name = "progression"
verbose_name_plural = "progressions"
@classmethod
def load(cls, user):
obj, _ = cls.objects.get_or_create(user=user)
return obj
def __str__(self):
return f"Progression de {self.user.username}"
class Profil(models.Model):
"""Le côté personnel d'un compte, en dehors de la progression : pour
l'instant l'avatar, posé par le gabarit commun de chargement d'image
(_image_upload.html) via /api/avatar/. Recadré en carré et réduit
côté serveur, donc léger."""
user = models.OneToOneField(
"auth.User", on_delete=models.CASCADE, related_name="profil",
)
avatar = models.ImageField("avatar", upload_to="avatars/", blank=True, null=True)
class Meta:
verbose_name = "profil"
verbose_name_plural = "profils"
def __str__(self):
return f"Profil de {self.user.username}"
TAMPONS = [("JUNIOR", "Junior"), ("ADOS", "Ados"), ("SÉNIOR", "Sénior")]
class Mot(models.Model):
"""Un mot ou une expression du « Fil des Mots » : le savoir du jeu.
Ce qui se liste, se trie ou se filtre est en colonnes ; les pistes de
mini-jeux et les perles de résolution — structures emboîtées que le
moteur du jeu consomme telles quelles — restent dans des champs JSON.
`vers_donnees()` recrache la forme historique attendue par le moteur
(clés anglaises) : c'est elle qui alimente `window.MOTS` dans la page
du jeu, et l'Historique. Les identifiants (`slug`) ne changent jamais
après création : la progression des comptes s'y attache.
"""
slug = models.SlugField(
"identifiant", max_length=60, unique=True,
help_text="Jamais modifié après création : la progression des comptes s'y attache.",
)
ordre = models.PositiveIntegerField("place sur le chemin", unique=True)
titre = models.CharField(max_length=80)
nature = models.CharField("nature grammaticale", max_length=40)
tampon = models.CharField(max_length=10, choices=TAMPONS)
accroche = models.TextField()
note_carte = models.TextField("note de la carte")
defi = models.BooleanField("défi", default=False)
definition = models.TextField()
etymologie = models.JSONField("chaîne étymologique", default=list)
date_apparition = models.CharField("première trace", max_length=60)
registre = models.CharField(max_length=30)
anecdote = models.TextField()
voisins = models.JSONField("mots voisins", default=list)
pistes = models.JSONField("pistes de mini-jeux", default=dict)
resolve = models.JSONField("perles de résolution", default=dict, blank=True)
cree = models.DateTimeField("créé le", auto_now_add=True)
maj = models.DateTimeField("modifié le", auto_now=True)
class Meta:
verbose_name = "mot"
verbose_name_plural = "mots"
ordering = ["ordre"]
def __str__(self):
return f"{self.ordre}. {self.titre}"
def vers_donnees(self, complet=True):
"""La forme historique « donnees » du mot.
complet=True → le moteur du jeu (avec pistes et resolve),
complet=False → l'Historique (l'ancien donnees.json, fiche seule).
"""
carte = {
"def": self.definition,
"etym": self.etymologie,
"date": self.date_apparition,
"registre": self.registre,
"anecdote": self.anecdote,
"vois": self.voisins,
}
d = {
"id": self.slug,
"title": self.titre,
"kind": self.nature,
"stamp": self.tampon,
"teaser": self.accroche,
"mapNote": self.note_carte,
"card": carte,
}
if complet:
# le moteur historique omettait « defi » quand il était faux ;
# on lui rend exactement la même forme
if self.defi:
d["defi"] = True
d["pistes"] = self.pistes
d["resolve"] = self.resolve
else:
d["defi"] = self.defi
return d
@classmethod
def depuis_donnees(cls, d, ordre=None):
"""Construit une instance (non enregistrée) depuis une entrée de
catalogue, la forme historique complet=True."""
carte = d.get("card", {})
return cls(
slug=d["id"],
ordre=ordre,
titre=d["title"],
nature=d["kind"],
tampon=d["stamp"],
accroche=d.get("teaser", ""),
note_carte=d.get("mapNote", ""),
defi=bool(d.get("defi")),
definition=carte.get("def", ""),
etymologie=carte.get("etym", []),
date_apparition=carte.get("date", ""),
registre=carte.get("registre", ""),
anecdote=carte.get("anecdote", ""),
voisins=carte.get("vois", []),
pistes=d.get("pistes", {}),
resolve=d.get("resolve", {}),
)

Binary file not shown.

After

Width:  |  Height:  |  Size: 13 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 36 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 12 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 8.1 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 656 B

Binary file not shown.

After

Width:  |  Height:  |  Size: 17 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 1.6 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 2.5 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 3.6 KiB

62
jeu/static/jeu/historique.css Executable file
View file

@ -0,0 +1,62 @@
/* Page Historique : fiches des mots en poche, en lecture seule.
Les styles de fiche reprennent ceux du jeu (papier, encre, vermillon).
La palette vient de menu.css (--pg-*) : la page suit le thème choisi
dans le jeu — Auto suit le système, Clair et Sombre s'imposent. */
:root {
--paper: var(--pg-carte); --paper2: var(--pg-carte); --paper3: var(--pg-carte2);
--ink: var(--pg-encre); --ink2: var(--pg-encre2);
--line: var(--pg-ligne); --line2: var(--pg-ligne2);
--red: var(--pg-rouge); --green: var(--pg-vert); --gold: var(--pg-or);
--greenbg: var(--pg-vert); --badgefg: var(--pg-badge);
}
* { box-sizing: border-box; margin: 0; padding: 0; }
body.site-mode { background: radial-gradient(var(--pg-point) 1px, transparent 1.3px) 0 0/22px 22px,
linear-gradient(180deg, var(--pg-fond1), var(--pg-fond2));
color: var(--ink); min-height: 100vh;
font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif; }
.serif { font-family: Georgia, "Iowan Old Style", "Palatino Linotype", "Book Antiqua", Times, serif; }
.histo { max-width: 760px; margin: 0 auto; }
.histo h1 { font-size: clamp(1.9rem, 6vw, 2.6rem); }
.histo .sous { color: var(--ink2); margin-top: .35rem; font-size: .95rem; }
.resume { display: flex; gap: 10px; flex-wrap: wrap; margin: 16px 0 6px; }
.resume span { background: var(--paper2); border: 1px solid var(--line2); border-radius: 999px;
padding: 6px 14px; font-size: .82rem; color: var(--gold); font-weight: 700; }
.vide { margin: 26px 0; color: var(--ink2); font-style: italic; }
.fiche { max-width: 640px; margin: 18px auto; position: relative;
background: var(--paper2); border: 2px solid var(--ink); border-radius: 6px;
box-shadow: var(--pg-ombre), 0 0 0 5px var(--paper2), 0 0 0 6px var(--line2);
padding: 28px 22px; }
.fiche .numb { position: absolute; top: -14px; left: 14px; width: 28px; height: 28px;
border-radius: 50%; background: var(--red); color: var(--badgefg);
display: grid; place-items: center; font-size: .74rem; font-weight: 800; }
.fiche .fw { font-size: clamp(1.8rem, 6vw, 2.6rem); line-height: 1.05; }
.fiche .fk { color: var(--ink2); font-style: italic; margin-top: 4px; }
.fiche .cal { color: var(--gold); }
.fiche hr { border: 0; border-top: 1px solid var(--line2); margin: 15px 0; }
.fiche .lbl { font-size: .68rem; letter-spacing: 2.2px; font-weight: 800; color: var(--red);
text-transform: uppercase; margin-bottom: 6px; }
.fiche p.d { font-size: .98rem; line-height: 1.6; }
.etym-list { list-style: none; display: flex; flex-direction: column; gap: 6px; }
.etym-list li { display: flex; gap: 8px; font-size: .92rem; line-height: 1.5; }
.etym-list li::before { content: "→"; color: var(--red); font-weight: 700; flex: 0 0 auto; }
.meta { display: flex; gap: 16px; flex-wrap: wrap; margin-top: 2px; }
.meta .m { font-size: .86rem; color: var(--ink2); }
.meta .m b { color: var(--ink); }
.anecdote { font-style: italic; font-size: .93rem; line-height: 1.6; }
.vois { display: flex; flex-wrap: wrap; gap: 8px; }
.vois span { border: 1px solid var(--line2); border-radius: 999px; padding: 4px 11px;
font-size: .82rem; background: var(--paper3); }
.badge { position: absolute; top: -16px; right: 14px; background: var(--greenbg); color: var(--badgefg);
font-size: .66rem; font-weight: 800; letter-spacing: 2px; text-transform: uppercase;
border-radius: 8px; padding: 6px 12px; transform: rotate(3deg);
box-shadow: 0 4px 10px rgba(0,0,0,.15); }
.badge.partial { background: var(--gold); color: #241e13; }
.stamp { font-size: .64rem; font-weight: 800; letter-spacing: 2px; border: 2px solid currentColor;
border-radius: 6px; padding: 2px 7px; transform: rotate(-3deg); text-transform: uppercase;
color: var(--gold); font-style: normal; }
.stamp.defi { transform: rotate(3deg); }
@keyframes stampIn { 0% { transform: rotate(3deg) scale(2.2); opacity: 0; }
60% { transform: rotate(3deg) scale(.9); opacity: 1; } 100% { transform: rotate(3deg) scale(1); } }
.badge { animation: stampIn .45s .15s backwards; }

803
jeu/static/jeu/index.html Executable file

File diff suppressed because one or more lines are too long

228
jeu/static/jeu/menu.css Executable file
View file

@ -0,0 +1,228 @@
/* ============================================================
Menu du site VocabulAyr — sert à la fois :
- la page du jeu (injection côté serveur dans index.html) ;
- l'historique et les autres pages (link Django).
PC : rail latéral qui se déplie au survol (modèle BibliothequAyr).
Mobile/tablette : entête collante à une ligne (modèle CulinAyr).
Les couleurs suivent la charte du jeu (papier, encre, vermillon).
============================================================ */
:root {
--sb-fond: #221b13;
--sb-texte: #f2ead7;
--sb-accent: #b23c2a;
--sb-largeur-fermee: 64px;
--sb-largeur-ouverte: 240px;
--sb-vitesse: .2s ease;
--sb-ic-taille: 1.25rem;
--sb-ic-largeur: 26px;
--rayon: 8px;
--papier: #f2ead7;
--papier2: #fbf6ea;
--encre: #282519;
--ligne: #c9bc9c;
}
.ic { width: 1.25rem; height: 1.25rem; stroke: currentColor; fill: none;
stroke-width: 1.8; stroke-linecap: round; stroke-linejoin: round; flex-shrink: 0; }
/* ---------- Palette des pages du site (historique, paramètres) ----------
Les mêmes teintes que le jeu, en clair puis en sombre : ces pages
suivent le choix Auto / Clair / Sombre fait dans le jeu. Les feuilles
des pages (historique.css, styles des paramètres) consomment ces
variables — un seul endroit à retoucher pour changer les couleurs. */
:root {
--pg-fond1: #f4ecda; --pg-fond2: #efe6cd; --pg-point: rgba(122,100,54,.10);
--pg-carte: #fbf6ea; --pg-carte2: #f7f0df;
--pg-encre: #282519; --pg-encre2: #7a7159;
--pg-ligne: #ddd2b6; --pg-ligne2: #c9bc9c;
--pg-champ: #ffffff;
--pg-rouge: #b23c2a; --pg-rouge-vif: #c74f36; --pg-rouge-doux: #f7e8e2;
--pg-or: #9a7a2b; --pg-vert: #47663f; --pg-vert-texte: #2e4527; --pg-vert-doux: #eef3e8;
--pg-badge: #fff7ea;
--pg-ombre: 0 12px 28px rgba(70,55,20,.12);
}
[data-theme="dark"] {
--pg-fond1: #211b13; --pg-fond2: #161106; --pg-point: rgba(230,205,150,.07);
--pg-carte: #262017; --pg-carte2: #2e2718;
--pg-encre: #ece2c9; --pg-encre2: #a3947a;
--pg-ligne: #3d3524; --pg-ligne2: #5a4d33;
--pg-champ: #1c1712;
--pg-rouge: #e0664a; --pg-rouge-vif: #ea7a60; --pg-rouge-doux: #3c2419;
--pg-or: #d3ab55; --pg-vert: #42572f; --pg-vert-texte: #cfe0c4; --pg-vert-doux: #26331f;
--pg-badge: #fff7ea;
--pg-ombre: 0 12px 28px rgba(0,0,0,.55);
}
/* ---------- Rail latéral PC (calque BibliothequAyr) ---------- */
.sidebar {
position: fixed; top: 0; left: 0; bottom: 0;
width: var(--sb-largeur-fermee); overflow: hidden;
display: flex; flex-direction: column;
transition: width var(--sb-vitesse); z-index: 100;
background: var(--sb-fond); color: var(--sb-texte);
}
.sidebar:hover { width: var(--sb-largeur-ouverte); }
.sidebar a, .sidebar .nav-item { color: var(--sb-texte); text-decoration: none; font: inherit; }
.sidebar form.m-0 { margin: 0; }
.sidebar .brand {
display: flex; align-items: center; gap: 14px;
padding: 16px 18px; font-weight: 600; white-space: nowrap;
}
.sidebar .brand .ic { width: 1.4rem; height: 1.4rem; }
.sidebar .brand .brand-name { opacity: 0; transition: opacity var(--sb-vitesse); }
.sidebar:hover .brand .brand-name { opacity: 1; }
.sidebar .spacer { flex: 1; }
.nav-item {
display: flex; align-items: center; gap: 14px;
padding: 12px 18px; white-space: nowrap;
background: none; border: 0; cursor: pointer;
width: 100%; text-align: left;
}
.nav-item .ic { font-size: var(--sb-ic-taille); width: var(--sb-ic-largeur);
height: var(--sb-ic-largeur); text-align: center; flex-shrink: 0; }
.nav-item span { opacity: 0; transition: opacity var(--sb-vitesse); }
.sidebar:hover .nav-item span { opacity: 1; }
.sidebar .nav-item:hover,
.sidebar .nav-item.actif { background: color-mix(in srgb, var(--sb-accent) 55%, transparent); }
/* ---------- Entête mobile/tablette (calque CulinAyr) ---------- */
.entete {
position: sticky; top: 0; z-index: 50;
display: none;
grid-template-columns: 1fr auto 1fr; align-items: center;
gap: .6rem; padding: .5rem .8rem;
background: var(--papier); color: var(--encre);
border-bottom: 1px solid var(--ligne);
}
.logo { grid-column: 2; justify-self: center;
font-family: Georgia, "Iowan Old Style", serif;
font-size: 1.12rem; letter-spacing: .4px;
color: inherit; text-decoration: none; }
.menu-gauche { grid-column: 1; justify-self: end; display: flex; }
.zone-droite { grid-column: 3; display: flex; align-items: center; justify-content: space-between; }
.menu-liste { display: flex; align-items: center; gap: .25rem; margin: 0; padding: 0; list-style: none; }
.menu-item { position: relative; }
.pastille-utilisateur { display: flex; align-items: center; gap: .4rem;
padding: .2rem .45rem; border-radius: var(--rayon); color: inherit; text-decoration: none; }
.avatar { width: 1.7rem; height: 1.7rem; border-radius: 50%;
background: var(--sb-accent); color: #fff7ea;
display: flex; align-items: center; justify-content: center;
font-weight: 700; font-size: .95rem; }
/* Quand l'utilisateur a un avatar, Django glisse une <img> dans la
pastille ronde ; elle épouse le cercle (le gabarit d'image commun
recadre en carré côté serveur, donc aucun débordement). */
.avatar img { width: 100%; height: 100%; object-fit: cover;
border-radius: 50%; display: block; }
.nom-utilisateur { font-size: .92rem; max-width: 6.5rem;
overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
.sous-menu {
display: none; position: absolute; top: 100%; right: 0;
min-width: 100%; width: max-content; margin: .25rem 0 0; padding: .25rem;
list-style: none; background: var(--papier2);
border: 1px solid var(--ligne); border-radius: var(--rayon);
box-shadow: 0 4px 12px rgba(40,37,25,.22); z-index: 60;
}
.menu-item:hover > .sous-menu,
.menu-item:focus-within > .sous-menu { display: block; }
.sous-menu a, .sous-menu .bouton-lien {
display: flex; align-items: center; gap: .45rem;
width: 100%; text-align: left;
padding: .45rem .6rem; border-radius: var(--rayon);
color: var(--encre); text-decoration: none;
background: none; border: 0; font: inherit; cursor: pointer;
}
.sous-menu .ic { width: 1.05rem; height: 1.05rem; flex-shrink: 0; }
.sous-menu a:hover, .sous-menu .bouton-lien:hover { background: rgba(40,37,25,.08); }
.menu-sep { border-top: 1px solid var(--ligne); margin: .25rem .4rem; list-style: none; }
.sous-menu form { margin: 0; }
.lien-entete { display: block; padding: .45rem .55rem; border-radius: var(--rayon);
color: inherit; text-decoration: none; font-size: .95rem; }
.lien-entete:hover, .lien-entete:focus-visible { background: rgba(40,37,25,.08); }
/* ---------- Mode sombre du jeu ---------- */
[data-theme="dark"] .entete {
background: #1c1712; color: #ece2c9; border-color: #3d3524;
}
[data-theme="dark"] .sous-menu { background: #262017; border-color: #3d3524; }
[data-theme="dark"] .sous-menu a, [data-theme="dark"] .sous-menu .bouton-lien { color: #ece2c9; }
[data-theme="dark"] .sous-menu a:hover, [data-theme="dark"] .sous-menu .bouton-lien:hover { background: rgba(236,226,201,.1); }
[data-theme="dark"] .lien-entete:hover, [data-theme="dark"] .lien-entete:focus-visible,
[data-theme="dark"] .pastille-utilisateur:hover { background: rgba(236,226,201,.1); }
/* ---------- Menu utilisateur du rail (PC) ----------
Le même bloc que l'entête mobile (_menu_utilisateur.html), habillé
aux couleurs du rail : la pastille joue le rôle d'icône de nav-item,
le sous-menu s'ouvre vers le haut en papier sombre. Le rail fermé
(64 px) le clippe, mais il n'apparaît qu'au survol — le rail est
alors déplié (240 px) et le panneau tient dedans. */
.menu-rail { list-style: none; margin: 0; padding: 0 0 8px; width: 100%; }
.sidebar .menu-utilisateur { position: relative; }
.sidebar .pastille-utilisateur {
display: flex; align-items: center; gap: 14px;
padding: 12px 18px; width: 100%; white-space: nowrap;
color: var(--sb-texte); text-decoration: none;
}
.sidebar .pastille-utilisateur:hover,
.sidebar .pastille-utilisateur:focus-visible {
background: color-mix(in srgb, var(--sb-accent) 55%, transparent);
}
.sidebar .avatar { background: var(--sb-accent); color: #fff7ea; flex-shrink: 0; }
.sidebar .nom-utilisateur { opacity: 0; transition: opacity var(--sb-vitesse); }
.sidebar:hover .nom-utilisateur { opacity: 1; }
.sidebar .sous-menu {
top: auto; right: auto; left: 6px; bottom: calc(100% + 6px);
min-width: 200px;
background: #2e2617; border-color: #3d3524;
box-shadow: 0 10px 24px rgba(0, 0, 0, .5);
}
.sidebar .sous-menu a, .sidebar .sous-menu .bouton-lien { color: var(--sb-texte); }
.sidebar .sous-menu a:hover, .sidebar .sous-menu .bouton-lien:hover { background: rgba(242, 234, 215, .08); }
.sidebar .menu-sep { border-color: #3d3524; }
/* ---------- Adaptation du contenu ----------
Tout se centre sur l'axe de la zone VISIBLE, c'est-à-dire la fenêtre
moins le rail fermé (64 px) : sinon la colonne paraît décalée à gauche
d'une demi-largeur de rail. Cet axe vaut 50% + 32px.
Sur grand écran la colonne de 920 px (le jeu) se cale au milieu du
papier visible ; en dessous de ~1050 px, simple marge qui libère le
rail. La barre d'action du jeu et le toast suivent le même axe. */
body.site-mode { margin: 0; }
.main-content {
margin-left: var(--sb-largeur-fermee); padding: 1.25rem;
}
.main-content > * { margin-left: auto; margin-right: auto; }
/* .histo (760 px) et .param (640 px) gardent leur propre largeur. */
body.site-mode #app {
margin-left: max(var(--sb-largeur-fermee),
calc(50% + var(--sb-largeur-fermee) / 2 - 460px));
}
/* .bar reste fixe sur toute la largeur visible : son contenu se centre
sur le même axe que la colonne du jeu. */
body.site-mode .bar { left: var(--sb-largeur-fermee); }
body.site-mode #toast {
left: calc(50% + var(--sb-largeur-fermee) / 2);
}
@media (max-width: 767.98px) {
.sidebar { display: none; }
.entete { display: grid; }
/* Sur téléphone et tablette, le titre du site cède la place :
la barre ne garde que les commandes (décision validée). */
.entete .logo { display: none; }
.main-content { margin-left: 0; padding: 1rem; }
body.site-mode #app { margin-left: 0; padding-top: 66px; }
body.site-mode .bar { left: 0; }
body.site-mode #toast { left: 50%; }
body.site-mode #toast { bottom: calc(78px + env(safe-area-inset-bottom)); }
}

97
jeu/static/jeu/ui.css Executable file
View file

@ -0,0 +1,97 @@
/* ============================================================
VocabulAyr — style des composants d'interface (ui.js).
Les variables --pg-* viennent de menu.css : le thème
clair/sombre du jeu s'applique tel quel, sur toutes les pages.
============================================================ */
/* ---------- BoiteDialog ---------- */
.dlg-voile {
position: fixed; inset: 0; z-index: 300;
display: flex; align-items: center; justify-content: center;
background: rgba(40, 37, 25, .45);
padding: 18px;
}
.dlg-carte {
background: var(--pg-carte, #fbf6ea);
color: var(--pg-encre, #282519);
border: 1px solid var(--pg-ligne2, #c9bc9c);
border-radius: 14px;
box-shadow: var(--pg-ombre, 0 12px 28px rgba(70, 55, 20, .12));
max-width: 420px; width: 100%;
padding: 20px 22px;
}
.dlg-titre { font-size: 1.25rem; margin: 0 0 8px; }
.dlg-corps { color: var(--pg-encre2, #7a7159); font-size: .95rem; line-height: 1.55; }
.dlg-corps p { margin: 0 0 6px; }
.dlg-actions { display: flex; justify-content: flex-end; gap: 10px; margin-top: 16px; }
.dlg-btn {
padding: .55rem 1.1rem; border: 1px solid var(--pg-ligne2, #c9bc9c);
border-radius: 8px; background: none; color: inherit;
font: inherit; cursor: pointer;
}
.dlg-btn:hover { background: var(--pg-carte2, #f7f0df); }
.dlg-btn.primaire {
background: var(--pg-rouge, #b23c2a); border-color: var(--pg-rouge, #b23c2a);
color: var(--pg-badge, #fff7ea); font-weight: 700;
}
.dlg-btn.primaire:hover { background: var(--pg-rouge-vif, #c74f36); }
/* ---------- Gabarit de chargement d'image (.zi) ----------
Le même gabarit habille l'avatar (pastille ronde) et l'image
de fond des Paramètres (cadre rectangulaire) — calque du
composant _image_upload.html de BibliothequAyr, charte papier. */
.zi { display: flex; flex-direction: column; align-items: center; gap: 12px; margin-top: 6px; }
.zi-etiquette { font-weight: 700; font-size: .95rem; align-self: flex-start; }
.zi-fichier { display: none; }
/* variante avatar : la grande pastille ronde */
.zi-pastille {
width: 132px; height: 132px; border-radius: 50%;
border: 2px solid var(--pg-ligne2, #c9bc9c);
background: var(--pg-carte2, #f7f0df); color: var(--pg-encre2, #7a7159);
display: flex; align-items: center; justify-content: center;
text-align: center; font-size: .88rem; padding: 8px;
}
.zi-apercu-rond {
width: 132px; height: 132px; border-radius: 50%;
border: 2px solid var(--pg-ligne2, #c9bc9c);
background: var(--pg-carte2, #f7f0df);
object-fit: cover; display: block;
}
/* variante fond : cadre rectangulaire (plein écran de connexion) */
.zi-vide {
width: 100%; max-width: 356px; min-height: 200px;
border: 1px dashed var(--pg-ligne2, #c9bc9c); border-radius: 10px;
background: var(--pg-carte2, #f7f0df); color: var(--pg-encre2, #7a7159);
display: flex; align-items: center; justify-content: center; gap: 8px;
font-size: .9rem; text-align: center; padding: 10px;
}
.zi-vide .ic { width: 1.4rem; height: 1.4rem; flex-shrink: 0; }
.zi-apercu {
display: block; width: 100%; max-width: 356px; max-height: 220px;
object-fit: cover; border-radius: 10px;
border: 1px solid var(--pg-ligne2, #c9bc9c);
}
/* les actions communes */
.zi-actions { display: flex; gap: 10px; flex-wrap: wrap; justify-content: center; }
.zi-bouton-choisir {
display: inline-flex; align-items: center; gap: 7px;
padding: .55rem 1.1rem; border: 0; border-radius: 8px;
background: var(--pg-rouge, #b23c2a); color: var(--pg-badge, #fff7ea);
font: inherit; font-weight: 700; cursor: pointer;
}
.zi-bouton-choisir:hover { background: var(--pg-rouge-vif, #c74f36); }
.zi-bouton-retirer {
display: inline-flex; align-items: center; gap: 7px;
padding: .55rem .95rem; border: 1px solid var(--pg-rouge, #b23c2a);
border-radius: 8px; background: none; color: var(--pg-rouge, #b23c2a);
font: inherit; font-size: .88rem; cursor: pointer;
}
.zi-bouton-retirer:hover { background: var(--pg-rouge-doux, #f7e8e2); }
.zi-bouton-choisir:disabled, .zi-bouton-retirer:disabled { opacity: .55; cursor: wait; }
.zi-erreur { color: var(--pg-rouge, #b23c2a); font-size: .88rem; text-align: center; }
/* commutateur commun (l'équivalent maison de d-none de Bootstrap) */
.hidden { display: none !important; }

210
jeu/static/jeu/ui.js Executable file
View file

@ -0,0 +1,210 @@
/* ============================================================
VocabulAyr — composants d'interface réutilisables.
Chaque composant est autonome : il ne crée pas d'HTML métier
et ne touche jamais au moteur du jeu (DB, run, rs, pistes...).
Contenu :
BoiteDialog — boîte de dialogue maison (papier, encre) qui
remplace les confirm() natifs du navigateur ;
brancherZi — le câblage du gabarit commun de chargement
d'image (_image_upload.html, calque du
composant BibliothequAyr) : choisir une image
l'envoie aussitôt (chargement = remplacement),
« Retirer » demande confirmation ;
ouvrirAvatar — la boîte « Mon avatar » : elle clone le gabarit
caché de la page (template.tpl-zi) et le branche
sur /api/avatar/.
Le style vit dans ui.css ; les couleurs suivent le thème
clair/sombre du jeu (variables --pg-* posées par menu.css).
============================================================ */
"use strict";
/* ------------------------------------------------ BoiteDialog ---
BoiteDialog.ouvrir({titre, corps, boutons, pret})
→ une promesse résolue avec la « valeur » du bouton choisi
(false si fermeture par la touche Échap ou le voile).
pret(carte) est appelé après insertion, pour brancher du
contenu vivant (ex. le gabarit d'avatar cloné).
BoiteDialog.confirm(titre, texte) → promesse résolue true/false. */
const BoiteDialog = {
_enCours: null,
ouvrir: function (opts) {
opts = opts || {};
const boutons = opts.boutons || [{ libelle: "Fermer", valeur: false }];
if (BoiteDialog._enCours) BoiteDialog._fermer(false); // jamais deux empilées
return new Promise(function (fin) {
const voile = document.createElement("div");
voile.className = "dlg-voile";
const carte = document.createElement("div");
carte.className = "dlg-carte";
carte.setAttribute("role", "dialog");
carte.setAttribute("aria-modal", "true");
const h = document.createElement("h2");
h.className = "dlg-titre serif";
h.textContent = opts.titre || "";
const corps = document.createElement("div");
corps.className = "dlg-corps";
if (opts.corps) corps.innerHTML = opts.corps; // HTML de confiance (le site, pas l'utilisateur)
const actions = document.createElement("div");
actions.className = "dlg-actions";
boutons.forEach(function (b) {
const bouton = document.createElement("button");
bouton.type = "button";
bouton.className = "dlg-btn" + (b.primaire ? " primaire" : "");
bouton.textContent = b.libelle || "OK";
bouton.addEventListener("click", function () { BoiteDialog._fermer(b.valeur); });
actions.appendChild(bouton);
});
carte.appendChild(h); carte.appendChild(corps); carte.appendChild(actions);
voile.appendChild(carte);
voile.addEventListener("click", function (e) { if (e.target === voile) BoiteDialog._fermer(false); });
document.body.appendChild(voile);
BoiteDialog._enCours = {
voile: voile, fin: fin,
echap: function (e) { if (e.key === "Escape") BoiteDialog._fermer(false); },
};
document.addEventListener("keydown", BoiteDialog._enCours.echap);
if (opts.pret) opts.pret(carte);
});
},
_fermer: function (valeur) {
const d = BoiteDialog._enCours;
if (!d) return;
BoiteDialog._enCours = null;
document.removeEventListener("keydown", d.echap);
d.voile.remove();
d.fin(valeur);
},
confirm: function (titre, texte) {
return BoiteDialog.ouvrir({
titre: titre, corps: "<p>" + texte + "</p>",
boutons: [
{ libelle: "Annuler", valeur: false },
{ libelle: "Confirmer", primaire: true, valeur: true },
],
});
},
};
/* ------------------------------------------------- brancherZi ---
Câble un fragment .zi déjà présent dans le DOM (page Paramètres)
ou cloné dans une boîte (avatar). Les réglages vivent dans les
data-* du fragment : data-envoyer (l'URL API), data-champ (le nom
du fichier dans le POST), data-effacer (la valeur de action= pour
le retrait), data-mode (« avatar » → mise à jour sur place,
« recharger » → la page se recharge), data-msg-max (le plafond
annoncé), data-csrf. options.surOk(zone, reponse) reçoit le succès
en mode avatar. */
function brancherZi(racine, options) {
const zone = racine.classList && racine.classList.contains("zi")
? racine : racine.querySelector(".zi");
if (!zone || zone.dataset.pret) return;
zone.dataset.pret = "1";
const fichier = zone.querySelector(".zi-fichier");
const boutonRetirer = zone.querySelector(".zi-bouton-retirer");
const erreur = zone.querySelector(".zi-erreur");
const boutons = zone.querySelectorAll(".zi-bouton-choisir, .zi-bouton-retirer");
const message = function (j) {
const connus = {
trop_grosse: "Image trop lourde : " + (zone.dataset.msgMax || "") + " maximum.",
pas_image: "Ce fichier n'est pas une image lisible.",
aucune_image: "Aucune image reçue.",
forbidden: "Seul l'administrateur peut faire cela.",
};
return connus[j.status] || "L'envoi a échoué — réessayez.";
};
const envoyer = function (f) {
if (zone.dataset.ocupe) return;
zone.dataset.ocupe = "1";
erreur.hidden = true;
boutons.forEach(function (b) { b.disabled = true; });
const corps = new FormData();
if (f) corps.append(zone.dataset.champ, f);
else corps.append("action", zone.dataset.effacer);
fetch(zone.dataset.envoyer, {
method: "POST",
headers: { "X-CSRFToken": zone.dataset.csrf },
body: corps,
})
.then(function (r) { return r.json().catch(function () { return { status: "erreur" }; }); })
.then(function (j) {
delete zone.dataset.ocupe;
boutons.forEach(function (b) { b.disabled = false; });
if (j.status !== "ok") {
erreur.textContent = message(j);
erreur.hidden = false;
return;
}
if (zone.dataset.mode === "recharger") { location.reload(); return; }
if (options && options.surOk) options.surOk(zone, j);
})
.catch(function () {
delete zone.dataset.ocupe;
boutons.forEach(function (b) { b.disabled = false; });
erreur.textContent = "L'envoi a échoué — vérifiez la connexion.";
erreur.hidden = false;
});
};
fichier.addEventListener("change", function () {
const f = fichier.files[0];
fichier.value = ""; // permet de re-choisir le même fichier
if (f) envoyer(f);
});
if (boutonRetirer) boutonRetirer.addEventListener("click", function () {
BoiteDialog.confirm("Retirer cette image ?",
zone.dataset.mode === "avatar"
? "La pastille redeviendra ton initiale."
: "La page de connexion redeviendra unie.")
.then(function (oui) { if (oui) envoyer(null); });
});
}
/* Branchement automatique des fragments visibles de la page
(ceux des Paramètres). Les <template> ne sont pas touchés :
leur contenu est hors du DOM — la boîte avatar les câble elle-même. */
document.addEventListener("DOMContentLoaded", function () {
document.querySelectorAll(".zi").forEach(function (zone) { brancherZi(zone); });
});
/* ----------------------------------------------- ouvrirAvatar ---
La boîte « Mon avatar » : elle clone le gabarit caché de la page
(template.tpl-zi, posé par le serveur — le même fragment que les
Paramètres) et le branche sur /api/avatar/. Après chaque réussite,
toutes les pastilles du menu sont rafraîchies. */
function ouvrirAvatar() {
const source = document.querySelector("template.tpl-zi");
if (!source) return; // hors mode site (jamais sur la page de connexion)
BoiteDialog.ouvrir({
titre: "Mon avatar",
corps: '<div class="dlg-avatar"></div>',
boutons: [{ libelle: "Fermer", valeur: false }],
pret: function (carte) {
const cible = carte.querySelector(".dlg-avatar");
cible.appendChild(source.content.cloneNode(true));
brancherZi(cible, {
surOk: function (zone, j) {
const url = j.avatar;
if (window.ETAT) window.ETAT.avatar = url;
const initiale = (zone.dataset.initiale ||
(window.ETAT && window.ETAT.user ? window.ETAT.user[0] : "?")).toUpperCase();
document.querySelectorAll(".avatar").forEach(function (el) {
el.innerHTML = url ? '<img alt="" src="' + url + "?v=" + Date.now() + '">' : "";
if (!url) el.textContent = initiale;
});
const apercu = zone.querySelector(".zi-apercu-rond");
const vide = zone.querySelector(".zi-pastille");
const retirer = zone.querySelector(".zi-bouton-retirer");
if (url) {
if (apercu) { apercu.src = url + "?v=" + Date.now(); apercu.classList.remove("hidden"); }
if (vide) vide.classList.add("hidden");
if (retirer) retirer.classList.remove("hidden");
} else {
if (apercu) { apercu.removeAttribute("src"); apercu.classList.add("hidden"); }
if (vide) vide.classList.remove("hidden");
if (retirer) retirer.classList.add("hidden");
}
if (window.toast) toast(url ? "Avatar mis à jour." : "Avatar effacé.");
},
});
},
});
}

View file

@ -0,0 +1,46 @@
{% load ico %}
{# ============================================================ #}
{# Fragment commun de chargement d'image (fonds, avatar). #}
{# Calque du composant _image_upload.html de BibliothequAyr : #}
{# mêmes rôles, habillé avec la charte papier/encre du site. #}
{# Paramètres : #}
{# variant "fond" (cadre rectangulaire) | "avatar" (rond) #}
{# input_id l'id du champ fichier (le bouton « Choisir » #}
{# est un label qui l'ouvre) #}
{# champ le nom du fichier dans le POST (avatar, image) #}
{# envoyer l'URL API qui reçoit l'image aussitôt #}
{# effacer la valeur action= du POST qui retire l'image #}
{# mode "avatar" → mise à jour des pastilles sur place #}
{# "recharger" → la page se recharge après succès #}
{# msg_max le plafond annoncé dans le message d'erreur #}
{# initiale l'initiale de repli (variante avatar) #}
{# current l'URL de l'image en place (ou rien) #}
{# label l'étiquette au-dessus (optionnelle) #}
{# empty_label le texte du cadre vide #}
{# preview_id / placeholder_id : ancres des deux états #}
{# Devise, comme chez BibliothequAyr : chargement = remplacement #}
{# — choisir une image l'envoie aussitôt, sans bouton intermédiaire. #}
{# ============================================================ #}
<div class="zi" data-envoyer="{{ envoyer }}" data-champ="{{ champ }}" data-effacer="{{ effacer }}"
data-mode="{{ mode }}" data-msg-max="{{ msg_max }}" data-csrf="{{ csrf_token }}"
data-initiale="{{ initiale }}">
{% if label %}<label class="zi-etiquette" for="{{ input_id }}">{{ label }}</label>{% endif %}
<input type="file" accept="image/*" id="{{ input_id }}" name="{{ champ }}" class="zi-fichier" hidden>
{% if variant == "avatar" %}
<div class="zi-pastille {% if current %}hidden{% endif %}" id="{{ placeholder_id }}">{{ empty_label }}</div>
<img class="zi-apercu-rond {% if not current %}hidden{% endif %}" id="{{ preview_id }}"
{% if current %}src="{{ current }}"{% endif %} alt="">
{% else %}
{% if current %}
<img class="zi-apercu" id="{{ preview_id }}" src="{{ current }}" alt="">
{% else %}
<div class="zi-vide" id="{{ placeholder_id }}">{% icone "image" %}<span>{{ empty_label }}</span></div>
{% endif %}
{% endif %}
<div class="zi-actions">
<label class="zi-bouton-choisir" for="{{ input_id }}">{% icone "image" %} Choisir une image</label>
{# Toujours rendu : après un premier envoi, la boîte l'affiche sans recharger. #}
<button type="button" class="zi-bouton-retirer {% if not current %}hidden{% endif %}">{% icone "gomme" %} Retirer</button>
</div>
<div class="zi-erreur" role="alert" hidden></div>
</div>

View file

@ -0,0 +1,25 @@
{% load ico %}
{# ============================================================ #}
{# Le bloc utilisateur : pastille (avatar, sinon initiale) + nom,#}
{# et son sous-menu — Mon avatar, [Paramètres, Admin pour #}
{# l'administrateur], Déconnexion. Inclus tel quel dans le rail #}
{# (PC) et l'entête (mobile) : une seule source, deux habillages#}
{# par menu.css (décision validée : « la version rail doit être #}
{# identique »). #}
{# ============================================================ #}
<li class="menu-item menu-utilisateur">
<a href="#" class="pastille-utilisateur">
<span class="avatar">{% if avatar_url %}<img src="{{ avatar_url }}" alt="">{% else %}{{ user.username|first|upper }}{% endif %}</span>
<span class="nom-utilisateur">{{ user.username }}</span>
</a>
<ul class="sous-menu">
<li><button type="button" class="bouton-lien" onclick="ouvrirAvatar()">{% icone "avatar" %}<span>Mon avatar</span></button></li>
{% if user.is_superuser %}
<li><a href="/parametres/">{% icone "reglages" %}<span>Paramètres</span></a></li>
<li><a href="/admin/">{% icone "cadenas" %}<span>Admin</span></a></li>
{% endif %}
<li class="menu-sep" role="separator"></li>
<li><form method="post" action="/logout/">{% csrf_token %}
<button type="submit" class="bouton-lien">{% icone "sortie" %}<span>Déconnexion</span></button></form></li>
</ul>
</li>

View file

@ -0,0 +1,31 @@
{% extends "admin/base_site.html" %}
{% load static %}
{% block branding %}
<div style="display:flex;align-items:center;gap:.5rem">
<h1 id="site-name" style="margin:0;font-size:1.05rem">
<a href="{% url 'admin:index' %}">{{ site_config.site_name|default:"VocabulAyr" }} — Administration</a>
</h1>
</div>
{% endblock %}
{% block extrastyle %}
{{ block.super }}
<link rel="icon" href="{% static 'jeu/favicons/favicon-32x32.png' %}" sizes="32x32">
<link rel="icon" href="{% static 'jeu/favicons/favicon-16x16.png' %}" sizes="16x16">
<style>
:root {
--primary: #b23c2a; --accent: #b23c2a; --link-fg: #b23c2a;
--header-color: #221b13; --header-branding-color: #f2ead7;
--breadcrumbs-bg: #221b13; --breadcrumbs-fg: #f2ead7;
--font-family-base: system-ui, -apple-system, "Segoe UI", Roboto, sans-serif;
--font-family-primary: var(--font-family-base);
}
#header { background: #221b13; }
#site-name a { color: inherit; }
@media (prefers-color-scheme: dark) {
:root {
--body-bg: #1c1712; --darkened-bg: #221b13; --lightened-bg: #2e2718;
--selected-row: #2e2718; --button-bg: #2e2718; --hovered-bg: #3a3120;
}
}
</style>
{% endblock %}

82
jeu/templates/base.html Executable file
View file

@ -0,0 +1,82 @@
{% load static %}
{% load ico %}
<!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="#f2ead7">
<title>{% block titre %}{{ site_config.site_name|default:"VocabulAyr" }}{% endblock %}</title>
<script>
/* Thème des pages du site : le même choix que dans le jeu (Auto / Clair /
Sombre), mémorisé dans la progression du compte et passé par la vue.
Posé sur <html> AVANT le premier rendu : aucun flash blanc en sombre.
« Auto » suit la préférence du système, comme l'écran du jeu. */
(function () {
var choix = "{{ theme|default:'auto' }}";
var sombre = (choix === "dark") ||
(choix === "auto" && window.matchMedia &&
matchMedia("(prefers-color-scheme: dark)").matches);
function appliquer() {
document.documentElement.setAttribute("data-theme", sombre ? "dark" : "light");
var m = document.querySelector('meta[name="theme-color"]');
if (m) m.setAttribute("content", sombre ? "#1c1712" : "#f2ead7");
}
appliquer();
if (choix === "auto" && window.matchMedia) {
try {
matchMedia("(prefers-color-scheme: dark)").addEventListener("change", function () {
sombre = matchMedia("(prefers-color-scheme: dark)").matches;
appliquer();
});
} catch (e) {}
}
})();
</script>
{# Favicons du projet : ils voyagent avec chaque version (plus de dépôt manuel). #}
<link rel="icon" type="image/png" sizes="16x16" href="{% static 'jeu/favicons/favicon-16x16.png' %}">
<link rel="icon" type="image/png" sizes="32x32" href="{% static 'jeu/favicons/favicon-32x32.png' %}">
<link rel="icon" type="image/png" sizes="48x48" href="{% static 'jeu/favicons/favicon-48x48.png' %}">
<link rel="icon" type="image/png" sizes="64x64" href="{% static 'jeu/favicons/favicon-64x64.png' %}">
<link rel="icon" type="image/png" sizes="128x128" href="{% static 'jeu/favicons/favicon-128x128.png' %}">
<link rel="icon" type="image/png" sizes="180x180" href="{% static 'jeu/favicons/apple-touch-icon.png' %}">
<link rel="icon" type="image/png" sizes="192x192" href="{% static 'jeu/favicons/android-chrome-192x192.png' %}">
<link rel="icon" type="image/png" sizes="256x256" href="{% static 'jeu/favicons/favicon-256x256.png' %}">
<link rel="icon" type="image/png" sizes="512x512" href="{% static 'jeu/favicons/android-chrome-512x512.png' %}">
<link rel="apple-touch-icon" href="{% static 'jeu/favicons/apple-touch-icon.png' %}">
<link rel="stylesheet" href="{% static 'jeu/menu.css' %}?v={{ asset_version }}">
<link rel="stylesheet" href="{% static 'jeu/ui.css' %}?v={{ asset_version }}">
<script src="{% static 'jeu/ui.js' %}?v={{ asset_version }}" defer></script>
{% block css %}{% endblock %}
</head>
<body class="site-mode">
{% if user.is_authenticated %}
<nav class="sidebar" aria-label="Navigation du site">
<div class="brand">{% icone "fil" %}<span class="brand-name">{{ site_config.site_name|default:"VocabulAyr" }}</span></div>
<a class="nav-item {% block nav_jeu %}{% endblock %}" href="/" title="Le jeu">{% icone "compas" %}<span>Le jeu</span></a>
<a class="nav-item {% block nav_hist %}{% endblock %}" href="/historique/" title="Historique">{% icone "horloge" %}<span>Historique</span></a>
<div class="spacer"></div>
<ul class="menu-liste menu-rail">
{% include "_menu_utilisateur.html" %}
</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="/">{{ site_config.site_name|default:"VocabulAyr" }}</a>
<div class="zone-droite">
<a class="lien-entete" href="/historique/">Historique</a>
<ul class="menu-liste">
{% include "_menu_utilisateur.html" %}
</ul>
</div>
</header>
<main class="main-content">{% block contenu %}{% endblock %}</main>
{# Le gabarit de chargement d'image (variante avatar), posé caché une #}
{# fois : la boîte « Mon avatar » le clone — le même fragment sert #}
{# l'avatar et l'image de fond des Paramètres. #}
<template class="tpl-zi">{% include "_image_upload.html" with variant="avatar" input_id="id-zi-avatar" champ="avatar" envoyer="/api/avatar/" effacer="effacer" mode="avatar" msg_max="2 Mo" initiale=user.username|first|upper current=avatar_url empty_label="Aucune image pour l'instant." preview_id="zi-avatar-apercu" placeholder_id="zi-avatar-vide" %}</template>
{% endif %}
</body>
</html>

53
jeu/templates/historique.html Executable file
View file

@ -0,0 +1,53 @@
{% extends "base.html" %}
{% load static %}
{% block titre %}Historique — {{ site_config.site_name|default:"VocabulAyr" }}{% endblock %}
{% block nav_hist %}actif{% endblock %}
{% block css %}<link rel="stylesheet" href="{% static 'jeu/historique.css' %}?v={{ asset_version }}">{% endblock %}
{% block contenu %}
<div class="histo">
<h1 class="serif">Historique</h1>
<p class="sous">Les mots en poche de {{ user.username }} — fiches à relire, fil à dérouler encore.</p>
<div class="resume" id="histo-resume"></div>
<div id="histo-liste"></div>
</div>
{{ donnees|json_script:"voca-donnees" }}
{{ progression|json_script:"voca-progression" }}
<script>
(function(){
var donnees=JSON.parse(document.getElementById("voca-donnees").textContent);
var prog=JSON.parse(document.getElementById("voca-progression").textContent);
var liste=document.getElementById("histo-liste");
var resume=document.getElementById("histo-resume");
var acquis=donnees.filter(function(w){return prog[w.id]&&prog[w.id].solved});
var parfaits=acquis.filter(function(w){return prog[w.id].badge==="parfaite"}).length;
resume.innerHTML='<span>'+acquis.length+' mot'+(acquis.length!==1?"s":"")+' sur '+donnees.length+'</span>'+
'<span>'+parfaits+' fiche'+(parfaits!==1?"s":"")+' parfaite'+(parfaits!==1?"s":"")+'</span>';
if(!acquis.length){
liste.innerHTML='<p class="vide">Aucun mot en poche pour l\'instant : le premier vous attend sur le chemin.</p>';
return;
}
liste.innerHTML=acquis.map(function(w){
var P=prog[w.id];
var np=Object.keys(P.p||{}).length;
var badge=P.badge==="parfaite"?'<span class="badge">Fiche parfaite</span>'
:'<span class="badge partial">Fiche improvisée · '+np+'/5 pistes</span>';
var i=donnees.indexOf(w)+1;
return '<article class="fiche">'+badge+
'<div class="numb">'+i+'</div>'+
'<h2 class="fw serif'+(w.id==="calligraphie"?" cal":"")+'">'+w.title+'</h2>'+
'<div class="fk">'+w.kind+' · <span class="stamp">'+w.stamp+'</span>'+(w.defi?' <span class="stamp defi">Défi</span>':'')+'</div>'+
'<hr><div class="lbl">Définition</div><p class="d">'+w.card.def+'</p><hr>'+
'<div class="lbl">Le fil de l\'étymologie</div><ul class="etym-list">'+
w.card.etym.map(function(e){return '<li>'+e+'</li>'}).join('')+'</ul><hr>'+
'<div class="meta"><span class="m">Première trace : <b>'+w.card.date+'</b></span>'+
'<span class="m">Registre : <b>'+w.card.registre+'</b></span></div><hr>'+
'<div class="lbl">Anecdote</div><p class="anecdote">'+w.card.anecdote+'</p><hr>'+
'<div class="lbl">Voisins &amp; famille</div><div class="vois">'+
w.card.vois.map(function(v){return '<span>'+v+'</span>'}).join('')+'</div>'+
'</article>';
}).join("");
})();
</script>
{% endblock %}

83
jeu/templates/parametres.html Executable file
View file

@ -0,0 +1,83 @@
{% extends "base.html" %}
{% load static %}
{% load ico %}
{% block titre %}Paramètres — {{ site_config.site_name|default:"VocabulAyr" }}{% endblock %}
{% block nav_param %}actif{% endblock %}
{% block css %}
<style>
* { box-sizing: border-box; margin: 0; padding: 0; }
body.site-mode { background: radial-gradient(var(--pg-point) 1px, transparent 1.3px) 0 0/22px 22px,
linear-gradient(180deg, var(--pg-fond1), var(--pg-fond2));
color: var(--pg-encre); min-height: 100vh;
font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif; }
.serif { font-family: Georgia, "Iowan Old Style", "Palatino Linotype", "Book Antiqua", Times, serif; }
.param { max-width: 640px; margin: 0 auto; }
.param h1 { font-size: clamp(1.9rem, 6vw, 2.6rem); }
.param .sous { color: var(--pg-encre2); margin-top: .35rem; font-size: .95rem; }
.retour { display: inline-block; margin-top: 14px; font-size: .9rem; color: var(--pg-encre2);
text-decoration: none; border: 1px solid var(--pg-ligne2); border-radius: 999px; padding: 6px 14px;
background: var(--pg-carte); }
.retour:hover { background: var(--pg-carte2); }
.messages { list-style: none; margin: 14px 0 0; display: flex; flex-direction: column; gap: 8px; }
.messages li { border-radius: 10px; padding: 10px 14px; font-size: .92rem;
border: 1px solid var(--pg-ligne2); background: var(--pg-carte); }
.messages li.success { border-color: var(--pg-vert); color: var(--pg-vert-texte); background: var(--pg-vert-doux); }
.messages li.error { border-color: var(--pg-rouge); color: var(--pg-rouge); background: var(--pg-rouge-doux); }
.carte { max-width: 640px; margin: 18px auto 0; background: var(--pg-carte); border: 1px solid var(--pg-ligne2);
border-radius: 14px; box-shadow: var(--pg-ombre); padding: 20px 22px; }
.carte h2 { font-size: 1.15rem; }
.carte h2 .ic { width: 1.1rem; height: 1.1rem; vertical-align: -0.18em; color: var(--pg-rouge); }
.carte .aide { color: var(--pg-encre2); font-size: .88rem; margin-top: 4px; line-height: 1.5; }
.ligne { display: flex; gap: 10px; margin-top: 14px; flex-wrap: wrap; }
.ligne input[type="text"] { flex: 1 1 220px; padding: .6rem .7rem; border: 1px solid var(--pg-ligne2);
border-radius: 8px; background: var(--pg-champ); font: inherit; color: inherit; }
.ligne button { padding: .6rem 1.1rem; border: 0; border-radius: 8px; background: var(--pg-rouge);
color: var(--pg-badge); font: inherit; font-weight: 700; cursor: pointer; }
.ligne button:hover { background: var(--pg-rouge-vif); }
.note-favicons { margin-top: 18px; color: var(--pg-encre2); font-size: .8rem; line-height: 1.5; }
</style>
{% endblock %}
{% block contenu %}
<div class="param">
<h1 class="serif">Paramètres</h1>
<p class="sous">Les réglages du site — pour l'administrateur.</p>
<a class="retour" href="/">&#8592; Retour au jeu</a>
{% if messages %}
<ul class="messages">
{% for message in messages %}<li class="{{ message.tags }}">{{ message }}</li>{% endfor %}
</ul>
{% endif %}
<section class="carte">
<h2>{% icone "fil" %} Titre du site</h2>
<p class="aide">Le nom affiché dans le menu, l'entête des téléphones et la page de connexion.</p>
<form method="post" action="{% url 'parametres' %}" class="ligne">
{% csrf_token %}
<input type="hidden" name="action" value="nom">
<input type="text" name="site_name" value="{{ cfg.site_name }}" maxlength="80" required aria-label="Titre du site">
<button type="submit">Enregistrer</button>
</form>
</section>
<section class="carte">
<h2>{% icone "reglages" %} Image de fond — page de connexion</h2>
<p class="aide">Elle habille l'écran de connexion de toute la famille, sur tous les appareils.
{% if cfg.background_image %}Une image est en place : en choisir une autre la remplace.{% else %}Pour l'instant, le fond est uni.{% endif %}</p>
{# Le même gabarit de chargement d'image que l'avatar : choix = envoi #}
{# immédiat, retrait confirmé (modèle BibliothequAyr). #}
{% include "_image_upload.html" with variant="fond" input_id="id-zi-fond" champ="image" envoyer="/api/fond/" effacer="retirer" mode="recharger" msg_max="5 Mo" current=fond_url empty_label="Aucune image pour l'instant." preview_id="zi-fond-apercu" placeholder_id="zi-fond-vide" %}
</section>
<p class="note-favicons">L'icône d'onglet (favicon) fait partie du projet
(<b>jeu/static/jeu/favicons/</b>) : elle voyage avec chaque version du site.</p>
</div>
{% endblock %}

View file

@ -0,0 +1,74 @@
{% load static %}
<!DOCTYPE html>
<html lang="fr">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>{% if installation %}Première installation{% else %}Connexion{% endif %} — {{ site_config.site_name|default:"VocabulAyr" }}</title>
<link rel="icon" href="{% static 'jeu/favicons/favicon-32x32.png' %}" sizes="32x32">
<link rel="icon" href="{% static 'jeu/favicons/favicon-16x16.png' %}" sizes="16x16">
<link rel="apple-touch-icon" href="{% static 'jeu/favicons/apple-touch-icon.png' %}">
<style>
* { box-sizing: border-box; }
body { margin:0; min-height:100vh; display:flex; align-items:center; justify-content:center;
font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,"Helvetica Neue",Arial,sans-serif;
background:#282519; color:#f2ead7; padding:1rem; }
.carte { width:min(360px,94vw); padding:2rem;
background:rgba(40,37,25,.42);
backdrop-filter:blur(16px) saturate(1.2);
-webkit-backdrop-filter:blur(16px) saturate(1.2);
border:1px solid rgba(242,234,215,.16);
border-radius:14px; box-shadow:0 8px 32px rgba(0,0,0,.45); }
@supports not ((backdrop-filter: blur(1px)) or (-webkit-backdrop-filter: blur(1px))) {
.carte { background:rgba(28,23,18,.94); }
}
h1 { margin:0; text-align:center; font-size:1.5rem; font-family:Georgia,"Iowan Old Style",serif; }
.surtitre { margin:0 0 1rem; text-align:center; font-size:.72rem; color:#c9bc9c;
letter-spacing:2px; text-transform:uppercase; }
label { display:block; font-size:.78rem; color:#c9bc9c; margin:.8rem 0 .25rem; letter-spacing:.5px; }
input { width:100%; padding:.6rem .7rem; border:1px solid rgba(242,234,215,.22);
border-radius:8px; background:rgba(28,23,18,.55); color:inherit; font:inherit; }
button { width:100%; margin-top:1.2rem; padding:.7rem; border:0; border-radius:8px;
background:#b23c2a; color:#fff7ea; font-size:1rem; font-weight:700; cursor:pointer; }
button:hover { background:#c74f36; }
.erreur { color:#ffb4a2; text-align:center; margin:.9rem 0 0; font-size:.9rem; }
.note { margin-top:1.1rem; text-align:center; font-size:.78rem; color:#c9bc9c; line-height:1.55; }
</style>
{% if site_config.background_image %}
<style>
body { background:url('{{ site_config.background_image.url }}') center / cover no-repeat #282519; }
</style>
{% endif %}
</head>
<body>
<div class="carte">
<p class="surtitre">Le fil des mots</p>
<h1>{{ site_config.site_name|default:"VocabulAyr" }}</h1>
{% if installation %}
<p class="note">Première connexion : créez ici le compte de l'administrateur du site —
c'est lui qui ouvrira ensuite les comptes de la famille, dans la partie Admin.</p>
{% if erreur %}<p class="erreur">{{ erreur }}</p>{% endif %}
<form method="post">{% csrf_token %}
<label for="id_u">Identifiant administrateur</label>
<input id="id_u" type="text" name="username" placeholder="Ayr" autofocus autocomplete="username" required>
<label for="id_p1">Mot de passe</label>
<input id="id_p1" type="password" name="password1" autocomplete="new-password" required>
<label for="id_p2">Confirmez le mot de passe</label>
<input id="id_p2" type="password" name="password2" autocomplete="new-password" required>
<button type="submit">Créer le compte administrateur</button>
</form>
{% else %}
{% if form.errors %}<p class="erreur">Identifiant ou mot de passe incorrect.</p>{% endif %}
<form method="post">{% csrf_token %}
<label for="id_u">Identifiant</label>
<input id="id_u" type="text" name="username" placeholder="Ayr" autofocus autocomplete="username" required>
<label for="id_p">Mot de passe</label>
<input id="id_p" type="password" name="password" placeholder="" autocomplete="current-password" required>
<button type="submit">Se connecter</button>
</form>
<p class="note">Les comptes sont ouverts par l'administrateur,
dans la partie <b>Admin</b> du site.</p>
{% endif %}
</div>
</body>
</html>

0
jeu/templatetags/__init__.py Executable file
View file

37
jeu/templatetags/ico.py Executable file
View file

@ -0,0 +1,37 @@
from django import template
from django.utils.safestring import mark_safe
register = template.Library()
ICONES = {
"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>',
"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>',
"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>',
"cadenas": '<svg class="ic" viewBox="0 0 24 24" aria-hidden="true">'
'<rect x="5" y="11" width="14" height="9" rx="2"/>'
'<path d="M8 11V8a4 4 0 0 1 8 0v3"/></svg>',
"reglages": '<svg class="ic" viewBox="0 0 24 24" aria-hidden="true">'
'<path d="M4 7h9M19 7h1M4 17h1M11 17h9"/>'
'<circle cx="16" cy="7" r="2.2"/><circle cx="8" cy="17" r="2.2"/></svg>',
"sortie": '<svg class="ic" viewBox="0 0 24 24" aria-hidden="true">'
'<path d="M14 8l-4 4 4 4"/><path d="M5 12h14"/><path d="M12 4h7v16h-7"/></svg>',
"avatar": '<svg class="ic" viewBox="0 0 24 24" aria-hidden="true">'
'<circle cx="12" cy="8.2" r="3.4"/>'
'<path d="M4.8 19.5c1.6-3.6 3.9-5.3 7.2-5.3s5.6 1.7 7.2 5.3"/></svg>',
"image": '<svg class="ic" viewBox="0 0 24 24" aria-hidden="true">'
'<rect x="3.5" y="5" width="17" height="14" rx="2"/>'
'<circle cx="9" cy="10" r="1.7"/><path d="M4.5 17.5l5-4.5 4 3.5 3-2.5 3 2.5"/></svg>',
"gomme": '<svg class="ic" viewBox="0 0 24 24" aria-hidden="true">'
'<path d="M4 16.5L13.5 7a2 2 0 0 1 2.8 0l2.7 2.7a2 2 0 0 1 0 2.8L12.5 19H7z"/>'
'<path d="M9.5 10.5l6 6"/><path d="M4 21h16"/></svg>',
}
@register.simple_tag
def icone(nom):
"""Icônes SVG inline (aucune bibliothèque externe, comme le jeu)."""
return mark_safe(ICONES.get(nom, ""))

384
jeu/tests.py Executable file
View file

@ -0,0 +1,384 @@
"""Tests de VocabulAyr : site fermé, première installation, progression en base."""
import io
import json
import shutil
import tempfile
from pathlib import Path
from django.contrib.auth.models import User
from django.core.files.base import ContentFile
from django.core.files.uploadedfile import SimpleUploadedFile
from django.core.management import call_command
from django.test import Client, TestCase, override_settings
from jeu.controle import verifier_base
from jeu.models import Mot, Progression, SiteConfig
REPCAT = Path(__file__).resolve().parent / "catalogue"
class SiteFermeTests(TestCase):
def test_accueil_redirige_vers_connexion(self):
r = self.client.get("/")
self.assertEqual(r.status_code, 302)
self.assertTrue(r.url.startswith("/login/"))
def test_historique_redirige_vers_connexion(self):
r = self.client.get("/historique/")
self.assertEqual(r.status_code, 302)
def test_api_etat_refuse_sans_compte(self):
r = self.client.post("/api/etat/", data='{"data":{}}', content_type="application/json")
self.assertEqual(r.status_code, 401)
class PremiereInstallationTests(TestCase):
def test_ecran_de_premiere_installation(self):
r = self.client.get("/login/")
self.assertEqual(r.status_code, 200)
self.assertContains(r, "Première installation")
self.assertContains(r, "Créer le compte administrateur")
def test_creation_du_compte_admin(self):
r = self.client.post("/login/", {
"username": "Ayr", "password1": "motsdepasse", "password2": "motsdepasse",
})
self.assertRedirects(r, "/", fetch_redirect_response=False)
self.assertTrue(User.objects.filter(username="Ayr", is_superuser=True).exists())
self.assertTrue(SiteConfig.objects.filter(pk=1).exists())
def test_apres_installation_lecran_devient_connexion(self):
User.objects.create_superuser("Ayr", "", "motsdepasse")
r = self.client.get("/login/")
self.assertEqual(r.status_code, 200)
self.assertNotContains(r, "Créer le compte administrateur")
self.assertContains(r, "Se connecter")
class JeuEtProgressionTests(TestCase):
def setUp(self):
self.user = User.objects.create_user("Elvire", password="clef1234")
self.client.force_login(self.user)
def test_page_jeu_sert_etat_et_menu(self):
r = self.client.get("/")
self.assertEqual(r.status_code, 200)
self.assertContains(r, "Le Fil des Mots")
self.assertContains(r, "window.MOTS=")
self.assertContains(r, "window.ETAT=")
self.assertContains(r, 'class="sidebar"')
self.assertContains(r, 'class="entete"')
self.assertContains(r, "Historique")
def test_sauvegarde_et_relecture_de_la_progression(self):
data = {"_g": {"idx": 1, "theme": "dark"},
"pyjama": {"p": {"sens": 1}, "solved": 1, "badge": "improvisée"}}
r = self.client.post("/api/etat/", data=json.dumps({"data": data}),
content_type="application/json")
self.assertEqual(r.status_code, 200)
self.assertEqual(Progression.load(self.user).data, data)
# l'état est de retour dans la page du jeu
r = self.client.get("/")
self.assertContains(r, '"solved": 1')
def test_api_etat_refuse_non_dict(self):
r = self.client.post("/api/etat/", data='{"data":"x"}', content_type="application/json")
self.assertEqual(r.status_code, 400)
def test_reinitialisation(self):
Progression.load(self.user).data = {"pyjama": {"solved": 1}}
r = self.client.post("/api/reinitialiser/")
self.assertEqual(r.status_code, 200)
self.assertEqual(Progression.load(self.user).data, {})
def test_historique_affiche_les_mots_en_poche(self):
data = {"pyjama": {"p": {"sens": 1}, "solved": 1, "badge": "parfaite"}}
self.client.post("/api/etat/", data=json.dumps({"data": data}),
content_type="application/json")
r = self.client.get("/historique/")
self.assertEqual(r.status_code, 200)
self.assertContains(r, "voca-donnees")
def _png_minuscule():
"""Une vraie image PNG de 4×4 pixels, pour tester l'envoi du fond."""
from PIL import Image
tampon = io.BytesIO()
Image.new("RGB", (4, 4), (178, 60, 42)).save(tampon, format="PNG")
return tampon.getvalue()
_REP_MEDIA_TESTS = tempfile.mkdtemp(prefix="vocabulayr-tests-media-")
@override_settings(MEDIA_ROOT=_REP_MEDIA_TESTS)
class ParametresTests(TestCase):
@classmethod
def tearDownClass(cls):
super().tearDownClass()
shutil.rmtree(_REP_MEDIA_TESTS, ignore_errors=True)
def setUp(self):
self.admin = User.objects.create_superuser("Ayr", "", "motsdepasse")
self.joueur = User.objects.create_user("Elvire", password="clef1234")
def test_page_reservee_a_l_administrateur(self):
self.client.force_login(self.joueur)
r = self.client.get("/parametres/")
self.assertRedirects(r, "/", fetch_redirect_response=False)
self.client.force_login(self.admin)
r = self.client.get("/parametres/")
self.assertEqual(r.status_code, 200)
self.assertContains(r, "Titre du site")
self.assertContains(r, "Image de fond")
def test_menu_parametres_visible_par_l_admin_seulement(self):
self.client.force_login(self.admin)
self.assertContains(self.client.get("/"), "/parametres/")
self.client.force_login(self.joueur)
self.assertNotContains(self.client.get("/"), "/parametres/")
def test_changer_le_titre_du_site(self):
self.client.force_login(self.admin)
r = self.client.post("/parametres/", {"action": "nom", "site_name": "Mots et Merveilles"})
self.assertRedirects(r, "/parametres/")
self.assertEqual(SiteConfig.load().site_name, "Mots et Merveilles")
# le nouveau titre apparaît sur la page de connexion et dans le menu
self.assertContains(self.client.get("/login/"), "Mots et Merveilles")
self.assertContains(self.client.get("/"), "Mots et Merveilles")
def test_installer_puis_retirer_le_fond(self):
self.client.force_login(self.admin)
image = SimpleUploadedFile("fond.png", _png_minuscule(), content_type="image/png")
r = self.client.post("/api/fond/", {"image": image})
self.assertEqual(r.status_code, 200)
self.assertEqual(r.json()["status"], "ok")
cfg = SiteConfig.load()
self.assertTrue(cfg.background_image, "l'image doit être enregistrée")
# la page de connexion utilise l'image
login = self.client.get("/login/")
self.assertContains(login, cfg.background_image.url)
# le fragment est en place sur la page des Paramètres
self.assertContains(self.client.get("/parametres/"), cfg.background_image.url)
# rejet d'un fichier qui n'est pas une image
faux = SimpleUploadedFile("faux.png", b"pas une image", content_type="image/png")
r = self.client.post("/api/fond/", {"image": faux})
self.assertEqual(r.status_code, 400)
self.assertEqual(r.json()["status"], "pas_image")
# retrait (après confirmation côté client)
url_image = cfg.background_image.url
r = self.client.post("/api/fond/", {"action": "retirer"})
self.assertEqual(r.status_code, 200)
self.assertFalse(SiteConfig.load().background_image)
self.assertNotContains(self.client.get("/login/"), url_image)
def test_api_fond_refusee_aux_autres_comptes(self):
self.client.force_login(self.joueur)
r = self.client.post("/api/fond/", {"action": "retirer"})
self.assertEqual(r.status_code, 403)
image = SimpleUploadedFile("fond.png", _png_minuscule(), content_type="image/png")
r = self.client.post("/api/fond/", {"image": image})
self.assertEqual(r.status_code, 403)
self.assertFalse(SiteConfig.load().background_image)
@override_settings(MEDIA_ROOT=_REP_MEDIA_TESTS)
class FragmentImageTests(TestCase):
"""Le gabarit commun de chargement d'image (calque BibliothequAyr) :
présent pour l'avatar et pour le fond, le menu utilisateur identique
sur le rail et l'entête, et les favicons embarqués dans le projet."""
FAVICONS = [
"favicon-16x16.png", "favicon-32x32.png", "favicon-48x48.png",
"favicon-64x64.png", "favicon-128x128.png", "favicon-256x256.png",
"apple-touch-icon.png", "android-chrome-192x192.png",
"android-chrome-512x512.png",
]
@classmethod
def setUpTestData(cls):
cls.admin = User.objects.create_superuser("Ayr", "", "motsdepasse")
cls.joueur = User.objects.create_user("Elvire", password="clef1234")
def test_le_gabarit_est_present_partout(self):
self.client.force_login(self.joueur)
# page du jeu : le gabarit caché de l'avatar
jeu = self.client.get("/")
self.assertContains(jeu, 'template class="tpl-zi"')
self.assertContains(jeu, 'class="zi"')
# pages du site : le gabarit caché + les composants partagés
hist = self.client.get("/historique/")
self.assertEqual(hist.status_code, 200)
self.assertContains(hist, "tpl-zi")
self.assertContains(hist, "menu.css")
self.assertContains(hist, "ui.js")
# Paramètres : le fragment du fond, branché sur /api/fond/
self.client.force_login(self.admin)
param = self.client.get("/parametres/")
self.assertContains(param, "/api/fond/")
self.assertContains(param, "Choisir une image")
def test_menu_utilisateur_identique_rail_et_entete(self):
self.client.force_login(self.admin)
page = self.client.get("/").content.decode("utf-8")
# le même bloc utilisateur est rendu deux fois : rail + entête
self.assertEqual(page.count('class="menu-item menu-utilisateur"'), 2)
# contenu validé : Mon avatar, Paramètres et Admin (admin), Déconnexion
self.assertEqual(page.count("Mon avatar"), 2)
self.assertEqual(page.count(">Déconnexion<"), 2)
self.assertEqual(page.count(">Paramètres<"), 2)
self.assertEqual(page.count(">Admin<"), 2)
# l'ancien bouton Déconnexion nu du rail a disparu
self.assertNotIn('nav-item" type="submit"', page)
def test_sous_menu_du_simple_joueur(self):
self.client.force_login(self.joueur)
page = self.client.get("/").content.decode("utf-8")
self.assertEqual(page.count("Mon avatar"), 2)
self.assertNotIn(">Paramètres<", page)
self.assertNotIn(">Admin<", page)
def test_favicons_embarques_et_declares(self):
rep = Path(__file__).resolve().parent / "static" / "jeu" / "favicons"
for nom in self.FAVICONS:
self.assertTrue((rep / nom).exists(), f"favicon manquant : {nom}")
self.client.force_login(self.joueur)
page = self.client.get("/").content.decode("utf-8")
for nom in self.FAVICONS:
self.assertIn(nom, page)
def test_avatar_dans_la_pastille(self):
from jeu.models import Profil
profil, _ = Profil.objects.get_or_create(user=self.joueur)
profil.avatar.save("avatar-essai.png", ContentFile(_png_minuscule()), save=True)
self.client.force_login(self.joueur)
page = self.client.get("/").content.decode("utf-8")
self.assertIn(profil.avatar.url, page)
class CatalogueMotsTests(TestCase):
"""Le savoir en base : import du catalogue, structure, Historique."""
@classmethod
def setUpTestData(cls):
call_command("importer_mots", verbosity=0)
def test_105_mots_en_base_et_structure_impeccable(self):
nb, erreurs = verifier_base()
self.assertEqual(nb, 105)
self.assertEqual(erreurs, [])
def test_export_identique_au_catalogue(self):
catalogue = json.loads((REPCAT / "mots-complet.json").read_text(encoding="utf-8"))
exporte = [m.vers_donnees(True) for m in Mot.objects.order_by("ordre")]
self.assertEqual(exporte, catalogue)
def test_registre_ternaire_sans_echelle(self):
reponses = set()
for m in Mot.objects.all():
steps = m.pistes["registre"]["steps"]
self.assertEqual(steps[0]["type"], "registre")
self.assertEqual(steps[0]["prompt"], "Dans quel registre s'inscrit le mot ?")
self.assertTrue(steps[0]["pourquoi"])
reponses.add(steps[0]["reponse"])
self.assertEqual(reponses, {"soutenu", "commun", "populaire"})
def test_l_historique_lit_la_base(self):
user = User.objects.create_user("Elvire", password="clef1234")
client = Client()
client.force_login(user)
r = client.get("/historique/")
self.assertEqual(r.status_code, 200)
self.assertContains(r, "Pyjama")
class PageJeuAvecMotsTests(TestCase):
"""La page du jeu reçoit le savoir complet par window.MOTS."""
@classmethod
def setUpTestData(cls):
call_command("importer_mots", verbosity=0)
cls.user = User.objects.create_user("Elvire", password="clef1234")
def test_la_page_du_jeu_recoit_les_105_mots(self):
self.client.force_login(self.user)
r = self.client.get("/")
self.assertEqual(r.status_code, 200)
corps = r.content.decode("utf-8")
self.assertIn("window.MOTS=", corps)
i = corps.index("window.MOTS=") + len("window.MOTS=")
fin = corps.index(";window.ETAT=", i) # les textes des mots contiennent des « ; »
mots = json.loads(corps[i:fin].replace("<\\/", "</"))
self.assertEqual(len(mots), 105)
self.assertEqual(mots[0]["id"], "pyjama")
self.assertIn("pistes", mots[0])
self.assertIn("resolve", mots[0])
class AjouterMotTests(TestCase):
"""Le script d'ajout : création, insertion, refus, mise à jour, export."""
@classmethod
def setUpTestData(cls):
call_command("importer_mots", verbosity=0)
def _mot_essai(self, slug="mot-essai", titre="Mot d'essai"):
source = Mot.objects.get(slug="pyjama").vers_donnees(True)
source["id"] = slug
source["title"] = titre
return source
def _fichier(self, donnees, nom="mot.json"):
tmp = tempfile.TemporaryDirectory()
self.addClassCleanup(tmp.cleanup)
f = Path(tmp.name) / nom
f.write_text(json.dumps(donnees, ensure_ascii=False), encoding="utf-8")
return str(f)
def test_ajout_a_la_suite(self):
call_command("ajouter_mot", self._fichier(self._mot_essai()), verbosity=0)
self.assertEqual(Mot.objects.count(), 106)
self.assertEqual(Mot.objects.order_by("-ordre").first().slug, "mot-essai")
nb, erreurs = verifier_base()
self.assertEqual(erreurs, [])
def test_ajout_avec_glissement_des_suivants(self):
call_command("ajouter_mot", self._fichier(self._mot_essai()), "--ordre", "3", verbosity=0)
self.assertEqual(Mot.objects.get(slug="mot-essai").ordre, 3)
self.assertEqual(Mot.objects.get(slug="pataugeoire").ordre, 4)
nb, erreurs = verifier_base()
self.assertEqual(erreurs, [])
def test_refus_d_un_mot_invalide_rien_n_est_ecrit(self):
mauvais = self._mot_essai()
mauvais["pistes"]["registre"]["steps"][0]["reponse"] = "moyen"
with self.assertRaises(SystemExit):
call_command("ajouter_mot", self._fichier(mauvais), verbosity=0)
self.assertEqual(Mot.objects.count(), 105)
def test_refus_d_une_echelle_slider(self):
vieux = self._mot_essai()
vieux["pistes"]["registre"]["steps"][0] = {
"type": "slider", "left": "soutenu", "right": "familier", "target": 3,
"note": "n", "hint": "h",
}
with self.assertRaises(SystemExit):
call_command("ajouter_mot", self._fichier(vieux), verbosity=0)
self.assertEqual(Mot.objects.count(), 105)
def test_mise_a_jour_d_un_mot_existant(self):
modifie = Mot.objects.get(slug="pyjama").vers_donnees(True)
modifie["teaser"] = "Nouvelle accroche d'essai."
call_command("ajouter_mot", self._fichier(modifie), verbosity=0)
self.assertEqual(Mot.objects.count(), 105)
self.assertEqual(Mot.objects.get(slug="pyjama").accroche, "Nouvelle accroche d'essai.")
def test_export_puis_reimport_sans_perte(self):
tmp = tempfile.TemporaryDirectory()
self.addClassCleanup(tmp.cleanup)
f = str(Path(tmp.name) / "export.json")
call_command("exporter_mots", "--fichier", f, verbosity=0)
avant = [m.vers_donnees(True) for m in Mot.objects.order_by("ordre")]
call_command("importer_mots", "--fichier", f, "--vider", verbosity=0)
apres = [m.vers_donnees(True) for m in Mot.objects.order_by("ordre")]
self.assertEqual(avant, apres)

131
jeu/validation.py Executable file
View file

@ -0,0 +1,131 @@
# -*- coding: utf-8 -*-
"""Contrôle de structure des mots : le filet de sécurité du savoir.
`verifier_entree(d)` contrôle une entrée de catalogue (la forme
historique complet=True) et renvoie la liste de ses erreurs (vide si
tout va bien). `verifier_base()` contrôle tous les mots en base.
Les commandes `importer_mots`, `ajouter_mot` et `verifier_mots`
s'appuient dessus : aucune écriture sans contrôle préalable.
"""
import re
TAMPONS = {"JUNIOR", "ADOS", "SÉNIOR"}
REGISTRES = {"soutenu", "commun", "populaire"}
PISTES = {"sens", "origines", "registre", "emplois", "voisins"}
SLUG_RE = re.compile(r"^[a-z0-9]+(?:-[a-z0-9]+)*$")
# champs requis par type de mini-jeu (ce que le moteur lit dans chaque étape)
ETAPES = {
"choose": ("prompt", "items"),
"choose1": ("prompt", "items"),
"chain": ("slots", "decoys"),
"registre": ("prompt", "reponse", "pourquoi"),
"judge": ("prompt", "items"),
"sort": ("prompt", "la", "lb", "items"),
}
def _err(cond, message, erreurs, ou):
if cond:
erreurs.append(f"{ou} : {message}" if ou else message)
def verifier_entree(d, ou=""):
"""Contrôle une entrée de catalogue ; renvoie une liste d'erreurs."""
e = []
_err(not isinstance(d, dict), "entrée illisible (objet attendu)", e, ou)
if not isinstance(d, dict):
return e
slug = d.get("id") or ""
_err(not SLUG_RE.match(slug), f"identifiant suspect « {slug} »", e, ou)
for champ in ("title", "kind", "teaser", "mapNote"):
_err(not str(d.get(champ) or "").strip(), f"« {champ} » est vide", e, ou)
_err(d.get("stamp") not in TAMPONS,
f"tampon inconnu « {d.get('stamp')} » (attendus : JUNIOR, ADOS, SÉNIOR)", e, ou)
carte = d.get("card") or {}
for champ in ("def", "date", "registre", "anecdote"):
_err(not str(carte.get(champ) or "").strip(), f"card.{champ} est vide", e, ou)
etym = carte.get("etym")
_err(not isinstance(etym, list) or not etym or
not all(isinstance(x, str) and x.strip() for x in etym),
"card.etym doit être une liste non vide de textes", e, ou)
vois = carte.get("vois")
_err(not isinstance(vois, list) or
not all(isinstance(x, str) and x.strip() for x in vois),
"card.vois doit être une liste de textes", e, ou)
pistes = d.get("pistes") or {}
_err(set(pistes.keys()) != PISTES,
f"les pistes doivent être exactement {sorted(PISTES)} (trouvées : {sorted(pistes.keys())})", e, ou)
for nom, piste in pistes.items():
sous = f"{ou}/pistes.{nom}" if ou else f"pistes.{nom}"
_err(not str(piste.get("one") or "").strip(), "l'introduction (one) est vide", e, sous)
_err(not str(piste.get("reward") or "").strip(), "la récompense (reward) est vide", e, sous)
steps = piste.get("steps")
_err(not isinstance(steps, list) or not steps, "aucune étape (steps)", e, sous)
if isinstance(steps, list):
for i, s in enumerate(steps):
_verifier_etape(s, e, f"{sous}.steps[{i}]")
resolve = d.get("resolve") or {}
perles = resolve.get("beads") or {}
ok = perles.get("ok")
_err(not isinstance(ok, list) or not ok or
not all(isinstance(x, str) and x.strip() for x in ok),
"resolve.beads.ok doit être une liste non vide de textes", e, ou)
intrus = perles.get("decoys")
_err(not isinstance(intrus, list) or not intrus or
not all(isinstance(x, dict) and str(x.get("t") or "").strip()
and str(x.get("why") or "").strip() for x in intrus),
"resolve.beads.decoys doit être une liste non vide de {t, why}", e, ou)
return e
def _verifier_etape(s, e, ou):
if not isinstance(s, dict):
_err(True, "étape illisible (objet attendu)", e, ou)
return
t = s.get("type")
if t == "slider":
_err(True, "le type « slider » a été retiré : étape « registre » attendue", e, ou)
return
if t not in ETAPES:
_err(True, f"type d'étape inconnu « {t} » (attendus : {sorted(ETAPES)})", e, ou)
return
for champ in ETAPES[t]:
_err(s.get(champ) in (None, ""), f"champ « {champ} » manquant", e, ou)
if t in ("choose", "choose1", "judge", "sort"):
items = s.get("items")
# un judge peut n'apporter qu'une seule phrase à juger ;
# les autres mini-jeux ont besoin de vrais choix
minimum = 1 if t == "judge" else 2
_err(not isinstance(items, list) or len(items) < minimum,
f"au moins {minimum} proposition(s) sont attendue(s)", e, ou)
if isinstance(items, list):
n_ok = 0
for j, it in enumerate(items):
sous = f"{ou}.items[{j}]"
if t == "judge":
_err(not str(it.get("s") or "").strip(), "phrase (s) vide", e, sous)
else:
_err(not str(it.get("t") or "").strip(), "texte (t) vide", e, sous)
_err(not str(it.get("why") or "").strip(), "explication (why) vide", e, sous)
n_ok += 1 if it.get("ok") else 0
if t == "choose":
_err(n_ok < 1, "aucune bonne réponse", e, ou)
if t == "choose1":
_err(n_ok != 1, "exactement une bonne réponse attendue", e, ou)
if t == "chain":
for cle in ("slots", "decoys"):
bloc = s.get(cle)
_err(not isinstance(bloc, list) or
not all(isinstance(x, dict) and str(x.get("t") or "").strip()
and str(x.get("why") or "").strip() for x in bloc),
f"{cle} doit être une liste de {{t, why}} remplis", e, ou)
_err(not s.get("slots"), "il faut au moins un maillon juste", e, ou)
if t == "registre":
_err(s.get("reponse") not in REGISTRES,
f"réponse « {s.get('reponse')} » hors du ternaire (soutenu, commun, populaire)", e, ou)

421
jeu/views.py Executable file
View file

@ -0,0 +1,421 @@
"""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 le fichier 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})

19
manage.py Executable file
View file

@ -0,0 +1,19 @@
#!/usr/bin/env python
import os
import sys
def main():
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "config.settings")
try:
from django.core.management import execute_from_command_line
except ImportError as exc:
raise ImportError(
"Django est introuvable : activez votre environnement virtuel et "
"installez les dépendances (pip install -r requirements.txt)."
) from exc
execute_from_command_line(sys.argv)
if __name__ == "__main__":
main()

2
requirements.txt Executable file
View file

@ -0,0 +1,2 @@
Django==6.1.1
Pillow==12.3.0

6
ruff.toml Executable file
View file

@ -0,0 +1,6 @@
ignore = [
"RUF012", # les attributs de classe muables (ModelAdmin) sont voulus
"I001", # l'ordre des imports suit la convention des autres projets Ayr
"BLE001", # except Exception large : toléré pour la validation d'images
"S110", # try/except/pass toléré sur la purge d'assets
]

View file

@ -0,0 +1,56 @@
#!/usr/bin/env bash
# Sauvegarde nocturne de VocabulAyr : backup SQLite à chaud (progression de
# toute la famille !), copie des médias (image de fond de connexion).
# Rétention : 7 jeux. Installé via timer systemd (voir README).
set -euo pipefail
CONTENEUR="vocabulayr"
DEST="/mnt/share/sauvegardes/vocabulayr/data"
RETENTION=7
dest_du_jour="${DEST}/$(date +%F)"
if ! findmnt /mnt/share > /dev/null; then
echo "[sauvegarde] Il y a un problème : /mnt/share n'est pas monté — sauvegarde annulée."
exit 1
fi
mkdir -p "${dest_du_jour}"
echo "[sauvegarde] backup SQLite à chaud"
docker exec "${CONTENEUR}" python manage.py shell -c "
import sqlite3
from django.conf import settings
src = sqlite3.connect(settings.DATABASES['default']['NAME'])
dst = sqlite3.connect('/tmp/vocabulayr-backup.sqlite3')
src.backup(dst)
dst.close(); src.close()
print('backup ok')
"
echo "[sauvegarde] contrôle d'intégrité du backup (dans le conteneur)"
if ! docker exec "${CONTENEUR}" python -c "import sqlite3, sys; c = sqlite3.connect('/tmp/vocabulayr-backup.sqlite3'); v = c.execute('PRAGMA integrity_check').fetchone()[0]; c.close(); print('integrity_check :', v); sys.exit(0 if v == 'ok' else 1)"; then
echo "[sauvegarde] Il y a un problème : intégrité du backup refusée — sauvegarde annulée, rien n'est copié."
docker exec "${CONTENEUR}" rm -f /tmp/vocabulayr-backup.sqlite3
exit 1
fi
SHA_IN=$(docker exec "${CONTENEUR}" python -c "import hashlib;print(hashlib.sha256(open('/tmp/vocabulayr-backup.sqlite3','rb').read()).hexdigest())")
echo "[sauvegarde] empreinte source : ${SHA_IN}"
docker cp "${CONTENEUR}:/tmp/vocabulayr-backup.sqlite3" "${dest_du_jour}/db.sqlite3"
docker exec "${CONTENEUR}" rm /tmp/vocabulayr-backup.sqlite3
SHA_OUT=$(sha256sum "${dest_du_jour}/db.sqlite3" | cut -d' ' -f1)
echo "[sauvegarde] empreinte copie : ${SHA_OUT}"
if [ "${SHA_IN}" != "${SHA_OUT}" ]; then
echo "[sauvegarde] Il y a un problème : les empreintes diffèrent — sauvegarde corrompue au transport."
exit 1
fi
echo "[sauvegarde] copie des médias"
if docker exec "${CONTENEUR}" test -d /app/data/media; then
docker cp "${CONTENEUR}:/app/data/media" "${dest_du_jour}/media"
else
mkdir -p "${dest_du_jour}/media"
echo "[sauvegarde] aucun média encore (normal tant qu'aucune image de fond n'est posée)"
fi
echo "[sauvegarde] rétention : garde les ${RETENTION} plus récents"
ls -1dt "${DEST}"/20* 2>/dev/null | tail -n +$((RETENTION + 1)) | xargs -r rm -rf
echo "[sauvegarde] terminée : ${dest_du_jour}"