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"}, "": {"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", {}), )