Mise en place du picker d'image pour la partie header / illustration des fiches personnage

Migration pour l'ancienne partie des fiches perso vers les nouvelles pages Vue retravaillée pour les fiches perso
2026-04-30 10:54:27 +02:00
parent 52e389db24
commit 7c4a42327d
28 changed files with 1103 additions and 112 deletions
--- a/core/src/main/java/com/loremind/infrastructure/persistence/CharacterNpcMarkdownBackfill.java
+++ b/core/src/main/java/com/loremind/infrastructure/persistence/CharacterNpcMarkdownBackfill.java
@@ -0,0 +1,93 @@
+package com.loremind.infrastructure.persistence;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.boot.context.event.ApplicationReadyEvent;
+import org.springframework.context.event.EventListener;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.stereotype.Component;
+
+import java.util.Map;
+
+/**
+ * Backfill one-shot des fiches Character / Npc post-refonte 2026-04-30.
+ * <p>
+ * Avant la refonte, les fiches stockaient leur contenu dans la colonne
+ * {@code markdown_content}. Apres la refonte, le contenu est dans
+ * {@code field_values} (JSON Map<String,String>). La colonne
+ * {@code markdown_content} subsiste car Hibernate ddl-auto=update ne drop pas.
+ * <p>
+ * Ce backfill copie {@code markdown_content} dans {@code field_values["Notes"]}
+ * pour toutes les fiches qui ont un markdown non vide ET un field_values vide.
+ * Idempotent : si field_values contient deja des donnees, on ne touche pas.
+ * <p>
+ * La colonne {@code markdown_content} n'est PAS supprimee apres backfill —
+ * permet un rollback applicatif au cas ou. Suppression definitive a faire dans
+ * une release ulterieure quand la confiance est etablie.
+ */
+@Component
+public class CharacterNpcMarkdownBackfill {
+
+    private static final Logger log = LoggerFactory.getLogger(CharacterNpcMarkdownBackfill.class);
+
+    private final JdbcTemplate jdbc;
+    private final ObjectMapper mapper = new ObjectMapper();
+
+    public CharacterNpcMarkdownBackfill(JdbcTemplate jdbc) {
+        this.jdbc = jdbc;
+    }
+
+    @EventListener(ApplicationReadyEvent.class)
+    public void backfillIfNeeded() {
+        if (!hasMarkdownContentColumn("characters")) {
+            log.debug("Backfill skip : colonne markdown_content absente (deja migre ou install propre).");
+            return;
+        }
+        int chars = backfillTable("characters");
+        int npcs = backfillTable("npcs");
+        if (chars + npcs > 0) {
+            log.info("Backfill markdown -> field_values : {} character(s), {} npc(s) migre(s).", chars, npcs);
+        }
+    }
+
+    private boolean hasMarkdownContentColumn(String table) {
+        try {
+            Integer count = jdbc.queryForObject(
+                    "SELECT COUNT(*) FROM information_schema.columns "
+                            + "WHERE table_name = ? AND column_name = 'markdown_content'",
+                    Integer.class, table);
+            return count != null && count > 0;
+        } catch (Exception e) {
+            log.warn("Backfill : impossible de verifier la colonne markdown_content sur {}: {}",
+                    table, e.getMessage());
+            return false;
+        }
+    }
+
+    private int backfillTable(String table) {
+        // Selection : fiches avec markdown non vide ET field_values vide ou absent.
+        // field_values peut etre NULL (legacy avant refonte) ou "{}" (refonte appliquee mais sans data).
+        String selectSql = "SELECT id, markdown_content FROM " + table
+                + " WHERE markdown_content IS NOT NULL "
+                + "   AND markdown_content <> '' "
+                + "   AND (field_values IS NULL OR field_values = '' OR field_values = '{}')";
+
+        var rows = jdbc.queryForList(selectSql);
+        int migrated = 0;
+        for (var row : rows) {
+            Long id = ((Number) row.get("id")).longValue();
+            String markdown = (String) row.get("markdown_content");
+            String json;
+            try {
+                json = mapper.writeValueAsString(Map.of("Notes", markdown));
+            } catch (Exception e) {
+                log.error("Backfill {} id={} : echec serialisation JSON, ignore. {}", table, id, e.getMessage());
+                continue;
+            }
+            jdbc.update("UPDATE " + table + " SET field_values = ? WHERE id = ?", json, id);
+            migrated++;
+        }
+        return migrated;
+    }
+}
--- a/core/src/main/java/com/loremind/infrastructure/persistence/GameSystemSeeder.java
+++ b/core/src/main/java/com/loremind/infrastructure/persistence/GameSystemSeeder.java
@@ -2,6 +2,8 @@ package com.loremind.infrastructure.persistence;

 import com.loremind.domain.gamesystemcontext.GameSystem;
 import com.loremind.domain.gamesystemcontext.ports.GameSystemRepository;
+import com.loremind.domain.shared.template.ImageLayout;
+import com.loremind.domain.shared.template.TemplateField;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.boot.context.event.ApplicationReadyEvent;
@@ -23,6 +25,10 @@ import java.util.List;
 * <p>
 * Idempotence : ne seed qu'une fois. Si l'utilisateur supprime un ruleset seedé,
 * il ne revient pas au redémarrage — c'est voulu (respect du choix utilisateur).
+ * <p>
+ * Backfill 2026-04-30 : pour les GameSystems existants (avant la refonte
+ * template-based), on remplit aussi les templates PJ/PNJ par defaut s'ils
+ * sont vides — sinon les fiches restent inutilisables.
 */
@Component
 public class GameSystemSeeder {
@@ -37,15 +43,37 @@ public class GameSystemSeeder {

    @EventListener(ApplicationReadyEvent.class)
    public void seedIfEmpty() {
-        if (!gameSystemRepository.findAll().isEmpty()) {
-            log.debug("GameSystem seed skipped — table non vide.");
+        List<GameSystem> existing = gameSystemRepository.findAll();
+        if (existing.isEmpty()) {
+            log.info("Seed initial des GameSystems (table vide)...");
+            for (GameSystem gs : defaultSystems()) {
+                gameSystemRepository.save(gs);
+            }
+            log.info("GameSystems seedés : {}", defaultSystems().size());
            return;
        }
-        log.info("Seed initial des GameSystems (table vide)...");
-        for (GameSystem gs : defaultSystems()) {
-            gameSystemRepository.save(gs);
+        log.debug("GameSystem seed skipped — table non vide. Backfill templates si necessaire...");
+        backfillEmptyTemplates(existing);
+    }
+
+    /**
+     * Backfill idempotent : pour chaque GameSystem existant ou les deux templates
+     * sont vides (PJ ET PNJ), injecte le template generique. Si l'utilisateur a
+     * deja personnalise au moins un des deux, on ne touche a rien.
+     */
+    private void backfillEmptyTemplates(List<GameSystem> systems) {
+        int patched = 0;
+        for (GameSystem gs : systems) {
+            boolean charEmpty = gs.getCharacterTemplate() == null || gs.getCharacterTemplate().isEmpty();
+            boolean npcEmpty = gs.getNpcTemplate() == null || gs.getNpcTemplate().isEmpty();
+            if (charEmpty && npcEmpty) {
+                gs.replaceCharacterTemplate(genericCharacterTemplate());
+                gs.replaceNpcTemplate(genericNpcTemplate());
+                gameSystemRepository.save(gs);
+                patched++;
+            }
        }
-        log.info("GameSystems seedés : {}", defaultSystems().size());
+        if (patched > 0) log.info("Backfill templates GameSystem : {} systeme(s) patche(s).", patched);
    }

    private List<GameSystem> defaultSystems() {
@@ -56,6 +84,8 @@ public class GameSystemSeeder {
                        .author("LoreMind seed")
                        .isPublic(false)
                        .rulesMarkdown(NIMBLE_RULES)
+                        .characterTemplate(nimbleCharacterTemplate())
+                        .npcTemplate(genericNpcTemplate())
                        .build(),
                GameSystem.builder()
                        .name("D&D 5e SRD (extrait)")
@@ -63,6 +93,8 @@ public class GameSystemSeeder {
                        .author("LoreMind seed")
                        .isPublic(false)
                        .rulesMarkdown(DND_SRD_RULES)
+                        .characterTemplate(dndCharacterTemplate())
+                        .npcTemplate(genericNpcTemplate())
                        .build(),
                GameSystem.builder()
                        .name("Homebrew Exemple")
@@ -70,10 +102,70 @@ public class GameSystemSeeder {
                        .author("LoreMind seed")
                        .isPublic(false)
                        .rulesMarkdown(HOMEBREW_EXAMPLE)
+                        .characterTemplate(genericCharacterTemplate())
+                        .npcTemplate(genericNpcTemplate())
                        .build()
        );
    }

+    // --- Templates par defaut ---------------------------------------------
+
+    /** Template generique PJ — utilise pour Homebrew, backfill, et fallback. */
+    private static List<TemplateField> genericCharacterTemplate() {
+        return List.of(
+                TemplateField.text("Histoire"),
+                TemplateField.text("Personnalite"),
+                TemplateField.text("Apparence"),
+                TemplateField.image("Galerie", ImageLayout.GALLERY),
+                TemplateField.text("Notes")
+        );
+    }
+
+    /** Template generique PNJ — focus besoins MJ. */
+    private static List<TemplateField> genericNpcTemplate() {
+        return List.of(
+                TemplateField.text("Apparence"),
+                TemplateField.text("Motivation"),
+                TemplateField.text("Faction"),
+                TemplateField.text("Notes MJ")
+        );
+    }
+
+    private static List<TemplateField> nimbleCharacterTemplate() {
+        return List.of(
+                TemplateField.text("Classe"),
+                TemplateField.number("Blessures graves max"),
+                TemplateField.text("Capacites de classe"),
+                TemplateField.text("Equipement"),
+                TemplateField.text("Histoire"),
+                TemplateField.text("Objectifs personnels"),
+                TemplateField.image("Galerie", ImageLayout.GALLERY)
+        );
+    }
+
+    private static List<TemplateField> dndCharacterTemplate() {
+        return List.of(
+                TemplateField.text("Classe"),
+                TemplateField.text("Race"),
+                TemplateField.text("Historique"),
+                TemplateField.text("Alignement"),
+                TemplateField.number("Niveau"),
+                TemplateField.number("PV max"),
+                TemplateField.number("CA"),
+                TemplateField.number("FOR"),
+                TemplateField.number("DEX"),
+                TemplateField.number("CON"),
+                TemplateField.number("INT"),
+                TemplateField.number("SAG"),
+                TemplateField.number("CHA"),
+                TemplateField.text("Competences"),
+                TemplateField.text("Equipement"),
+                TemplateField.text("Sorts"),
+                TemplateField.text("Histoire"),
+                TemplateField.image("Galerie", ImageLayout.GALLERY)
+        );
+    }
+
    private static final String NIMBLE_RULES = """
            Système Nimble — résolution rapide, narration fluide, peu de tableaux. Agnostique (aucun univers imposé).