From dcbec168187d535b6372166a0a46e9b2056201b4 Mon Sep 17 00:00:00 2001 From: william Date: Sat, 29 Aug 2026 19:14:19 +0200 Subject: [PATCH] =?UTF-8?q?Ajoute=20les=20=C3=A9v=C3=A9nements=20personnal?= =?UTF-8?q?is=C3=A9s=20(backend)=20:=20d=C3=A9clencher/=C3=A9couter?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Première moitié de la fonctionnalité "événements" (NEED_ACTION et autres) : une entité game-wide (nom, description, "a un paramètre élément" oui/non), déclenchable comme nouvelle action du graphe de logique depuis n'importe quelle scène/modèle, et écoutable comme nouveau type de déclencheur depuis n'importe quel autre. L'UI (nouvel onglet "Événements" dans screen_edit.html, formulaires de nœud, exécution côté client dans play.html) suit dans un commit séparé. - db/custom_events/ (calqué sur db/global_vars/) : CRUD de la table _custom_events (nom unique, description, has_element_param). create_custom_event est idempotent par nom (même convention que create_global_variable) — sans risque en cas de double soumission. - screens/flow/ : 3 nouvelles colonnes sur _flow_nodes (trigger_custom_event_id/target_custom_event_id : quel événement un nœud écoute/déclenche ; target_element_from_event : indicateur réutilisable par n'importe quel nœud Action utilisant déjà target_element_id, pour résoudre "l'élément transmis par l'événement en cours" au lieu d'une cible fixe — contourne la contrainte de clé étrangère de target_element_id, qui empêche d'y stocker un sentinel comme EVENT_ROW_ID directement). Nouveau trigger_event "evenement" et action_type "declencher_evenement". - screens/custom_events/ (PAS dans db/, même séparation que screens/elements/delete_element.py) : delete_custom_event, la SEULE suppression d'entité game-wide du moteur à vraiment cascader (demande explicite) — supprime tous les nœuds/arêtes qui référencent l'événement, sur TOUTES les scènes ET tous les modèles à la fois (aucun filtre screen_id nécessaire : un modèle est un écran caché, même table _flow_nodes). list_custom_event_usages : où un événement est écouté/déclenché, pour l'onglet Événements à venir. - routes/custom_events/ : CRUD monté sous /game//events/..., redirige vers l'éditeur de scène/modèle d'origine (screen_id transmis par le formulaire) avec l'onglet "events" à ouvrir. tests/test_custom_events.py (nouveau) : idempotence à la création, usages détectés sur deux écrans différents, suppression qui retire bien les DEUX nœuds (un sur une vraie scène, un sur un modèle/écran caché) en une seule opération, sans toucher aux écrans eux-mêmes. 207 tests au total. Co-Authored-By: Claude Sonnet 5 --- db/__init__.py | 6 + db/custom_events/__init__.py | 0 db/custom_events/create_custom_event.py | 26 ++++ .../ensure_custom_events_schema.py | 25 ++++ db/custom_events/get_custom_event.py | 12 ++ db/custom_events/list_custom_events.py | 10 ++ db/custom_events/update_custom_event.py | 19 +++ routes/__init__.py | 2 +- routes/custom_events/__init__.py | 1 + routes/custom_events/custom_event_delete.py | 18 +++ routes/custom_events/custom_event_edit.py | 14 +++ routes/custom_events/custom_event_new.py | 21 ++++ screens/__init__.py | 7 +- screens/custom_events/__init__.py | 9 ++ screens/custom_events/delete_custom_event.py | 30 +++++ .../custom_events/list_custom_event_usages.py | 37 ++++++ screens/flow/constants.py | 30 +++++ screens/flow/ensure_flow_schema.py | 19 +++ screens/labels/action_type_labels.py | 1 + screens/labels/trigger_labels.py | 1 + tests/test_custom_events.py | 112 ++++++++++++++++++ 21 files changed, 398 insertions(+), 2 deletions(-) create mode 100644 db/custom_events/__init__.py create mode 100644 db/custom_events/create_custom_event.py create mode 100644 db/custom_events/ensure_custom_events_schema.py create mode 100644 db/custom_events/get_custom_event.py create mode 100644 db/custom_events/list_custom_events.py create mode 100644 db/custom_events/update_custom_event.py create mode 100644 routes/custom_events/__init__.py create mode 100644 routes/custom_events/custom_event_delete.py create mode 100644 routes/custom_events/custom_event_edit.py create mode 100644 routes/custom_events/custom_event_new.py create mode 100644 screens/custom_events/__init__.py create mode 100644 screens/custom_events/delete_custom_event.py create mode 100644 screens/custom_events/list_custom_event_usages.py create mode 100644 tests/test_custom_events.py diff --git a/db/__init__.py b/db/__init__.py index 0232189c..6a67b117 100644 --- a/db/__init__.py +++ b/db/__init__.py @@ -61,6 +61,11 @@ from .global_vars.update_global_variable import update_global_variable from .global_vars.delete_global_variable import delete_global_variable from .global_vars.delete_global_variable_by_id import delete_global_variable_by_id +from .custom_events.list_custom_events import list_custom_events +from .custom_events.get_custom_event import get_custom_event +from .custom_events.create_custom_event import create_custom_event +from .custom_events.update_custom_event import update_custom_event + __all__ = [ "PROJECTS_DIR", "FIELD_TYPES", "GLOBAL_VARIABLE_TYPES", "slugify", "table_name_for", "game_dir", "db_path", "connect", @@ -73,4 +78,5 @@ __all__ = [ "list_global_variables", "get_global_variable", "create_global_variable", "update_global_variable_value", "update_global_variable", "delete_global_variable", "delete_global_variable_by_id", + "list_custom_events", "get_custom_event", "create_custom_event", "update_custom_event", ] diff --git a/db/custom_events/__init__.py b/db/custom_events/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/db/custom_events/create_custom_event.py b/db/custom_events/create_custom_event.py new file mode 100644 index 00000000..e071bded --- /dev/null +++ b/db/custom_events/create_custom_event.py @@ -0,0 +1,26 @@ +from ..connection import connect +from .ensure_custom_events_schema import ensure_custom_events_schema + + +def create_custom_event(slug, name, description="", has_element_param=False): + """Idempotent par nom (même convention que create_global_variable.py) : + si le nom existe déjà, ne touche à rien et renvoie simplement son id + existant plutôt que de lever une erreur — sans risque en cas de + double clic/soumission depuis l'onglet Événements (screen_edit.html).""" + name = (name or "").strip() + if not name: + return None + ensure_custom_events_schema(slug) + conn = connect(slug) + existing = conn.execute("SELECT id FROM _custom_events WHERE name = ?", (name,)).fetchone() + if existing: + conn.close() + return existing["id"] + conn.execute( + "INSERT INTO _custom_events (name, description, has_element_param) VALUES (?, ?, ?)", + (name, (description or "").strip(), 1 if has_element_param else 0), + ) + new_id = conn.execute("SELECT last_insert_rowid() AS id").fetchone()["id"] + conn.commit() + conn.close() + return new_id diff --git a/db/custom_events/ensure_custom_events_schema.py b/db/custom_events/ensure_custom_events_schema.py new file mode 100644 index 00000000..8da80e61 --- /dev/null +++ b/db/custom_events/ensure_custom_events_schema.py @@ -0,0 +1,25 @@ +from ..connection import connect + + +def ensure_custom_events_schema(slug): + """Migration légère (même principe que ensure_global_vars_schema.py) : + crée _custom_events si absente. Un événement personnalisé vit pour + TOUT le jeu (pas par écran, pas par modèle) : "name" est donc UNIQUE — + c'est par ce nom qu'on le désigne dans l'interface, même si les nœuds + du graphe le référencent par id technique (voir + screens/flow/ensure_flow_schema.py, trigger_custom_event_id/ + target_custom_event_id).""" + conn = connect(slug) + conn.execute( + """ + CREATE TABLE IF NOT EXISTS _custom_events ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + name TEXT NOT NULL UNIQUE, + description TEXT, + has_element_param INTEGER NOT NULL DEFAULT 0, + created_at TEXT DEFAULT CURRENT_TIMESTAMP + ); + """ + ) + conn.commit() + conn.close() diff --git a/db/custom_events/get_custom_event.py b/db/custom_events/get_custom_event.py new file mode 100644 index 00000000..453deb07 --- /dev/null +++ b/db/custom_events/get_custom_event.py @@ -0,0 +1,12 @@ +from ..connection import connect +from .ensure_custom_events_schema import ensure_custom_events_schema + + +def get_custom_event(slug, event_id): + if not event_id: + return None + ensure_custom_events_schema(slug) + conn = connect(slug) + row = conn.execute("SELECT * FROM _custom_events WHERE id = ?", (event_id,)).fetchone() + conn.close() + return dict(row) if row else None diff --git a/db/custom_events/list_custom_events.py b/db/custom_events/list_custom_events.py new file mode 100644 index 00000000..624fb80c --- /dev/null +++ b/db/custom_events/list_custom_events.py @@ -0,0 +1,10 @@ +from ..connection import connect +from .ensure_custom_events_schema import ensure_custom_events_schema + + +def list_custom_events(slug): + ensure_custom_events_schema(slug) + conn = connect(slug) + rows = conn.execute("SELECT * FROM _custom_events ORDER BY name").fetchall() + conn.close() + return [dict(r) for r in rows] diff --git a/db/custom_events/update_custom_event.py b/db/custom_events/update_custom_event.py new file mode 100644 index 00000000..839d6606 --- /dev/null +++ b/db/custom_events/update_custom_event.py @@ -0,0 +1,19 @@ +from ..connection import connect +from .ensure_custom_events_schema import ensure_custom_events_schema + + +def update_custom_event(slug, event_id, description="", has_element_param=False): + """Le NOM reste volontairement immuable après création — comme une + variable globale (voir update_global_variable.py) : c'est par ce nom + qu'on désigne l'événement dans l'interface, mais surtout par son ID + TECHNIQUE que les nœuds du graphe le référencent + (trigger_custom_event_id/target_custom_event_id) — le renommer ne + casserait donc rien niveau logique.""" + ensure_custom_events_schema(slug) + conn = connect(slug) + conn.execute( + "UPDATE _custom_events SET description = ?, has_element_param = ? WHERE id = ?", + ((description or "").strip(), 1 if has_element_param else 0, event_id), + ) + conn.commit() + conn.close() diff --git a/routes/__init__.py b/routes/__init__.py index 722a00c0..66bd2092 100644 --- a/routes/__init__.py +++ b/routes/__init__.py @@ -1 +1 @@ -from . import auth, games, objects, screens, elements, legacy_actions, flow, element_types, uploads, play, animations, global_vars, publish +from . import auth, games, objects, screens, elements, legacy_actions, flow, element_types, uploads, play, animations, global_vars, publish, custom_events diff --git a/routes/custom_events/__init__.py b/routes/custom_events/__init__.py new file mode 100644 index 00000000..bdf004b1 --- /dev/null +++ b/routes/custom_events/__init__.py @@ -0,0 +1 @@ +from . import custom_event_new, custom_event_edit, custom_event_delete diff --git a/routes/custom_events/custom_event_delete.py b/routes/custom_events/custom_event_delete.py new file mode 100644 index 00000000..9e41bfda --- /dev/null +++ b/routes/custom_events/custom_event_delete.py @@ -0,0 +1,18 @@ +from flask import request, redirect, url_for + +import screens + +from core.flask_app import app + + +@app.route("/game//events//delete", methods=["POST"]) +def custom_event_delete(slug, event_id): + """Supprime aussi TOUS les nœuds Déclencheur/Action qui référencent cet + événement, sur toutes les scènes et tous les modèles (voir + screens/custom_events/delete_custom_event.py) — seule suppression + d'entité game-wide du moteur à vraiment cascader, sur demande + explicite (une variable globale ou une définition d'objet supprimée, + elles, laissent des références pendantes tolérées ailleurs).""" + screen_id = request.form.get("screen_id", type=int) + screens.delete_custom_event(slug, event_id) + return redirect(url_for("screen_edit", slug=slug, screen_id=screen_id, tab="events")) diff --git a/routes/custom_events/custom_event_edit.py b/routes/custom_events/custom_event_edit.py new file mode 100644 index 00000000..ea8ec496 --- /dev/null +++ b/routes/custom_events/custom_event_edit.py @@ -0,0 +1,14 @@ +from flask import request, redirect, url_for + +import db + +from core.flask_app import app + + +@app.route("/game//events//edit", methods=["POST"]) +def custom_event_edit(slug, event_id): + description = request.form.get("description") or "" + has_element_param = request.form.get("has_element_param") == "on" + screen_id = request.form.get("screen_id", type=int) + db.update_custom_event(slug, event_id, description, has_element_param) + return redirect(url_for("screen_edit", slug=slug, screen_id=screen_id, tab="events")) diff --git a/routes/custom_events/custom_event_new.py b/routes/custom_events/custom_event_new.py new file mode 100644 index 00000000..d2468475 --- /dev/null +++ b/routes/custom_events/custom_event_new.py @@ -0,0 +1,21 @@ +from flask import request, redirect, url_for + +import db + +from core.flask_app import app + + +@app.route("/game//events/new", methods=["POST"]) +def custom_event_new(slug): + """Depuis l'onglet Événements de l'éditeur de scène/modèle + (screen_edit.html) — idempotent par nom (voir db.create_custom_event), + sans risque en cas de double soumission. screen_id (l'écran/modèle + depuis lequel on a créé l'événement) sert uniquement à revenir sur le + bon écran ensuite, jamais stocké sur l'événement lui-même (game-wide).""" + name = (request.form.get("name") or "").strip() + description = request.form.get("description") or "" + has_element_param = request.form.get("has_element_param") == "on" + screen_id = request.form.get("screen_id", type=int) + if name: + db.create_custom_event(slug, name, description, has_element_param) + return redirect(url_for("screen_edit", slug=slug, screen_id=screen_id, tab="events")) diff --git a/screens/__init__.py b/screens/__init__.py index 8d8f6990..36706271 100644 --- a/screens/__init__.py +++ b/screens/__init__.py @@ -55,7 +55,9 @@ from .labels.element_action_properties import ( from .labels.element_visibility import ELEMENT_VISIBILITY_VALUES, ELEMENT_VISIBILITY_LABELS from .labels.data_operations import DATA_OPERATIONS, DATA_OPERATION_LABELS -from .flow.constants import TRIGGER_EVENTS, CONDITION_OPERATORS, CONDITION_OPERATOR_LABELS, CLICKED_ROW_ID +from .flow.constants import ( + TRIGGER_EVENTS, CONDITION_OPERATORS, CONDITION_OPERATOR_LABELS, CLICKED_ROW_ID, EVENT_ROW_ID, +) from .rendering.render_element_html import render_element_html from .rendering.trigger_for import _trigger_for @@ -117,4 +119,7 @@ from .animations.update_animation_clip import update_animation_clip from .animations.delete_animation_clip import delete_animation_clip from .animations.animate_css_catalog import ANIMATE_CSS_CATALOG, ANIMATE_CSS_LABELS +from .custom_events.list_custom_event_usages import list_custom_event_usages +from .custom_events.delete_custom_event import delete_custom_event + from .payload.full_game_payload import full_game_payload diff --git a/screens/custom_events/__init__.py b/screens/custom_events/__init__.py new file mode 100644 index 00000000..f486ccdb --- /dev/null +++ b/screens/custom_events/__init__.py @@ -0,0 +1,9 @@ +"""Tout ce qui touche à la fois _custom_events (db/custom_events/) ET +_flow_nodes/_flow_edges (screens/flow/) — jamais dans db/custom_events/, +pour la même raison que screens/elements/delete_element.py n'est pas +dans db/ : ce sont deux domaines différents (une entité game-wide, des +nœuds de graphe), le nettoyage croisé vit dans screens/, pas db/.""" +from .list_custom_event_usages import list_custom_event_usages +from .delete_custom_event import delete_custom_event + +__all__ = ["list_custom_event_usages", "delete_custom_event"] diff --git a/screens/custom_events/delete_custom_event.py b/screens/custom_events/delete_custom_event.py new file mode 100644 index 00000000..1f2b9826 --- /dev/null +++ b/screens/custom_events/delete_custom_event.py @@ -0,0 +1,30 @@ +import db +from ..flow.ensure_flow_schema import ensure_flow_schema + + +def delete_custom_event(slug, event_id): + """Seule suppression d'entité game-wide du moteur qui cascade + RÉELLEMENT (demande explicite) : une variable globale ou une + définition d'objet supprimée laisse des références pendantes + tolérées ailleurs (voir db/global_vars/, db/definitions/) — un + événement, lui, doit emporter avec lui TOUS ses écouteurs (nœuds + Déclencheur, trigger_custom_event_id) et déclencheurs (nœuds Action, + target_custom_event_id), sur TOUS les écrans ET modèles à la fois + (aucun filtre screen_id, comme screens/elements/delete_element.py — + un modèle est un écran caché, même table _flow_nodes).""" + ensure_flow_schema(slug) + conn = db.connect(slug) + conn.execute( + """DELETE FROM _flow_edges WHERE from_node_id IN + (SELECT id FROM _flow_nodes WHERE trigger_custom_event_id = ? OR target_custom_event_id = ?) + OR to_node_id IN + (SELECT id FROM _flow_nodes WHERE trigger_custom_event_id = ? OR target_custom_event_id = ?)""", + (event_id, event_id, event_id, event_id), + ) + conn.execute( + "DELETE FROM _flow_nodes WHERE trigger_custom_event_id = ? OR target_custom_event_id = ?", + (event_id, event_id), + ) + conn.execute("DELETE FROM _custom_events WHERE id = ?", (event_id,)) + conn.commit() + conn.close() diff --git a/screens/custom_events/list_custom_event_usages.py b/screens/custom_events/list_custom_event_usages.py new file mode 100644 index 00000000..aa965630 --- /dev/null +++ b/screens/custom_events/list_custom_event_usages.py @@ -0,0 +1,37 @@ +import db +from ..flow.ensure_flow_schema import ensure_flow_schema + + +def list_custom_event_usages(slug): + """Pour CHAQUE événement, où est-il écouté ("ecoute", nœud Déclencheur) + et déclenché ("declenche", nœud Action) — une seule requête plutôt + qu'une par événement, pour l'onglet Événements (screen_edit.html) qui + les affiche tous à la fois. Aucun filtre screen_id : couvre aussi bien + les écrans que les modèles (un modèle est un écran caché, voir + screens/element_types/create_element_type.py), exactement comme la + suppression en cascade (delete_custom_event.py). + + Renvoie {event_id: [{"screen_id", "screen_name", "is_template", "role"}, ...]}.""" + ensure_flow_schema(slug) + conn = db.connect(slug) + rows = conn.execute( + """ + SELECT DISTINCT n.id AS node_id, s.id AS screen_id, s.name AS screen_name, s.is_template AS is_template, + CASE WHEN n.trigger_custom_event_id IS NOT NULL THEN n.trigger_custom_event_id + ELSE n.target_custom_event_id END AS event_id, + CASE WHEN n.trigger_custom_event_id IS NOT NULL THEN 'ecoute' + ELSE 'declenche' END AS role + FROM _flow_nodes n + JOIN _screens s ON s.id = n.screen_id + WHERE n.trigger_custom_event_id IS NOT NULL OR n.target_custom_event_id IS NOT NULL + ORDER BY s.name + """ + ).fetchall() + conn.close() + usages = {} + for row in rows: + usages.setdefault(row["event_id"], []).append({ + "screen_id": row["screen_id"], "screen_name": row["screen_name"], + "is_template": bool(row["is_template"]), "role": row["role"], + }) + return usages diff --git a/screens/flow/constants.py b/screens/flow/constants.py index 3460ca17..23a087ab 100644 --- a/screens/flow/constants.py +++ b/screens/flow/constants.py @@ -21,6 +21,16 @@ # AUTOINCREMENT SQLite). CLICKED_ROW_ID = -1 +# Même principe que CLICKED_ROW_ID, pour un second contexte dynamique : +# "la ligne de Répéteur transmise par l'événement personnalisé en cours +# d'exécution" (voir screens/custom_events/, nœud Déclencheur +# trigger_event="evenement") — stockable directement dans target_row_id +# (déjà sans contrainte de clé étrangère, voir ensure_flow_schema.py) au +# même titre que CLICKED_ROW_ID, résolu côté client (templates/play.html) +# via window.lastEventParams.row_id au lieu de window.lastClickedRowId. +# Valeur distincte de CLICKED_ROW_ID pour ne jamais les confondre. +EVENT_ROW_ID = -2 + TRIGGER_EVENTS = [ ("clic", "Au clic"), ("soumission", "À la soumission"), @@ -42,6 +52,14 @@ TRIGGER_EVENTS = [ # cacher/montrer un élément selon l'état de la partie SANS qu'un clic # explicite soit nécessaire pour le réévaluer. ("affichage", "À l'affichage de l'écran"), + # Écoute un événement personnalisé (voir screens/custom_events/), + # déclenché depuis N'IMPORTE QUEL autre graphe (une autre scène, un + # autre modèle) via l'action "declencher_evenement" — ni élément ni + # écran précis : trigger_custom_event_id (quel événement) est le seul + # réglage propre à ce nœud, retrouvé par un scan global de + # gameData.flows côté client (voir dispatchGameEvent() dans + # templates/play.html), au même titre que findTriggerNode(). + ("evenement", "Sur un événement personnalisé"), ] CONDITION_OPERATORS = [ @@ -69,4 +87,16 @@ FLOW_NODE_FIELDS = { "action_type", "target_screen_id", "target_element_id", "element_property", "element_value", "target_definition_id", "target_row_id", "target_field", "data_operation", "data_value", "target_variable", + # Événements personnalisés (voir screens/custom_events/) : quel + # événement un nœud Déclencheur écoute (trigger_event="evenement") ou + # un nœud Action déclenche (action_type="declencher_evenement") — + # target_element_id/target_row_id (déjà ci-dessus, EVENT_ROW_ID + # compris) portent les paramètres transmis au déclenchement. + # target_element_from_event : indicateur réutilisable par N'IMPORTE + # QUEL nœud Action qui accepte déjà target_element_id (v1 : seule + # "modifier_element" le supporte) — contourne la contrainte de clé + # étrangère de target_element_id (impossible d'y stocker un sentinel + # comme EVENT_ROW_ID sur target_row_id) en résolvant "l'élément + # transmis par l'événement en cours" côté client à la place. + "trigger_custom_event_id", "target_custom_event_id", "target_element_from_event", } diff --git a/screens/flow/ensure_flow_schema.py b/screens/flow/ensure_flow_schema.py index 155f2430..aeae3bdf 100644 --- a/screens/flow/ensure_flow_schema.py +++ b/screens/flow/ensure_flow_schema.py @@ -72,5 +72,24 @@ def ensure_flow_schema(slug): conn.execute("ALTER TABLE _flow_nodes ADD COLUMN cond_variable TEXT") if "cond_variable_chemin" not in cols: conn.execute("ALTER TABLE _flow_nodes ADD COLUMN cond_variable_chemin TEXT") + if "trigger_custom_event_id" not in cols: + # Événements personnalisés (voir screens/custom_events/) : quel + # événement un nœud Déclencheur écoute (trigger_event="evenement") + # ou un nœud Action déclenche (action_type="declencher_evenement"). + # Pas de FK vers _custom_events : une suppression d'événement + # nettoie déjà ces colonnes elle-même (voir + # screens/custom_events/delete_custom_event.py), une contrainte + # ferait double emploi sans rien apporter de plus. + conn.execute("ALTER TABLE _flow_nodes ADD COLUMN trigger_custom_event_id INTEGER") + if "target_custom_event_id" not in cols: + conn.execute("ALTER TABLE _flow_nodes ADD COLUMN target_custom_event_id INTEGER") + if "target_element_from_event" not in cols: + # Indicateur réutilisable par n'importe quel nœud Action qui + # accepte déjà target_element_id (v1 : seule "modifier_element") — + # contourne la contrainte de clé étrangère de target_element_id + # (impossible d'y stocker un sentinel comme EVENT_ROW_ID sur + # target_row_id) en résolvant "l'élément transmis par l'événement + # en cours" côté client (templates/play.html) à la place. + conn.execute("ALTER TABLE _flow_nodes ADD COLUMN target_element_from_event INTEGER NOT NULL DEFAULT 0") conn.commit() conn.close() diff --git a/screens/labels/action_type_labels.py b/screens/labels/action_type_labels.py index cd0f65ef..df15c443 100644 --- a/screens/labels/action_type_labels.py +++ b/screens/labels/action_type_labels.py @@ -8,5 +8,6 @@ ACTION_TYPE_LABELS = { "ouvrir_ligne": "Ouvrir la ligne de Répéteur cliquée", "activer_onglet": "Afficher cet élément, masquer tous ses frères", "attendre": "Attendre quelques secondes avant de continuer", + "declencher_evenement": "Déclencher un événement", "rien": "Ne rien faire", } diff --git a/screens/labels/trigger_labels.py b/screens/labels/trigger_labels.py index 49bc3531..594fd32a 100644 --- a/screens/labels/trigger_labels.py +++ b/screens/labels/trigger_labels.py @@ -4,4 +4,5 @@ TRIGGER_LABELS = { "affichage": "À l'affichage de l'écran", "survol": "Au survol", "fin_survol": "Fin du survol", + "evenement": "Sur un événement personnalisé", } diff --git a/tests/test_custom_events.py b/tests/test_custom_events.py new file mode 100644 index 00000000..76bf3801 --- /dev/null +++ b/tests/test_custom_events.py @@ -0,0 +1,112 @@ +"""Événements personnalisés (db/custom_events/, screens/custom_events/) : +un événement game-wide (ex. NEED_ACTION) écouté par un nœud Déclencheur +("trigger_event"="evenement") sur UNE scène/UN modèle, et déclenché par +un nœud Action ("action_type"="declencher_evenement") sur UNE AUTRE +scène/UN AUTRE modèle — la seule entité game-wide du moteur dont la +suppression cascade RÉELLEMENT vers les nœuds qui la référencent, +partout à la fois (voir screens/custom_events/delete_custom_event.py).""" +import json +import re + +import db +import screens + + +def _create_screen(client, slug, name="Accueil"): + resp = client.post(f"/game/{slug}/screens/new", data={"name": name}, follow_redirects=False) + return int(re.search(r"/screens/(\d+)/edit", resp.headers["Location"]).group(1)) + + +def _add_element(client, slug, screen_id, widget="bouton"): + resp = client.post(f"/game/{slug}/screens/{screen_id}/elements/add", data={"widget": widget}, follow_redirects=False) + return int(re.search(r"selected=(\d+)", resp.headers["Location"]).group(1)) + + +def _add_flow_node(client, slug, screen_id, **fields): + resp = client.post( + f"/game/{slug}/screens/{screen_id}/flow/nodes/add", + data=json.dumps(fields), + content_type="application/json", + ) + assert resp.status_code == 200 + return resp.get_json()["id"] + + +def test_create_event_is_idempotent_by_name(client, game): + screen_id = _create_screen(client, game) + resp = client.post(f"/game/{game}/events/new", data={ + "name": "NEED_ACTION", "description": "Besoin d'action", "has_element_param": "on", "screen_id": screen_id, + }) + assert resp.status_code == 302 + events = db.list_custom_events(game) + assert len(events) == 1 + assert events[0]["name"] == "NEED_ACTION" + assert events[0]["has_element_param"] == 1 + + # Double soumission : ne crée pas un deuxième événement du même nom. + client.post(f"/game/{game}/events/new", data={"name": "NEED_ACTION", "screen_id": screen_id}) + assert len(db.list_custom_events(game)) == 1 + + +def test_edit_event_updates_description_and_param_flag(client, game): + screen_id = _create_screen(client, game) + event_id = db.create_custom_event(game, "NEED_ACTION", "old", False) + resp = client.post(f"/game/{game}/events/{event_id}/edit", data={ + "description": "new", "has_element_param": "on", "screen_id": screen_id, + }) + assert resp.status_code == 302 + event = db.get_custom_event(game, event_id) + assert event["description"] == "new" + assert event["has_element_param"] == 1 + + +def test_usages_reports_listener_and_dispatcher_across_different_screens(client, game): + event_id = db.create_custom_event(game, "NEED_ACTION", "", True) + + listener_screen = _create_screen(client, game, "Écran écouteur") + _add_flow_node(client, game, listener_screen, node_type="trigger", trigger_event="evenement", trigger_custom_event_id=event_id) + + dispatcher_screen = _create_screen(client, game, "Écran déclencheur") + element_id = _add_element(client, game, dispatcher_screen) + _add_flow_node( + client, game, dispatcher_screen, + node_type="action", action_type="declencher_evenement", + target_custom_event_id=event_id, target_element_id=element_id, + ) + + usages = screens.list_custom_event_usages(game) + roles = {u["role"] for u in usages[event_id]} + screen_ids = {u["screen_id"] for u in usages[event_id]} + assert roles == {"ecoute", "declenche"} + assert screen_ids == {listener_screen, dispatcher_screen} + + +def test_deleting_an_event_cascades_to_every_referencing_node_everywhere(client, game): + event_id = db.create_custom_event(game, "NEED_ACTION", "", True) + + listener_screen = _create_screen(client, game, "Écran écouteur") + listener_node_id = _add_flow_node( + client, game, listener_screen, + node_type="trigger", trigger_event="evenement", trigger_custom_event_id=event_id, + ) + + # Le modèle (élément de jeu réutilisable) est un écran caché — voir + # screens.create_element_type — le déclencheur y est posé exactement + # comme sur une vraie scène. + screens.create_element_type(game, "Carte email", "📧") + template = next(t for t in screens.list_element_types(game) if t["name"] == "Carte email") + template_screen_id = template["template_screen_id"] + dispatcher_node_id = _add_flow_node( + client, game, template_screen_id, + node_type="action", action_type="declencher_evenement", target_custom_event_id=event_id, + ) + + resp = client.post(f"/game/{game}/events/{event_id}/delete", data={"screen_id": listener_screen}, follow_redirects=False) + assert resp.status_code == 302 + + assert db.get_custom_event(game, event_id) is None + assert screens.get_flow_node(game, listener_node_id) is None + assert screens.get_flow_node(game, dispatcher_node_id) is None + # Les écrans/modèles eux-mêmes ne sont pas touchés, seuls les nœuds. + assert screens.get_screen(game, listener_screen) is not None + assert screens.get_screen(game, template_screen_id) is not None