GetSummary agrege en SQL au lieu de charger 13 mois en memoire

eventsQuery.ToList() ramenait la fenetre entiere, toutes colonnes comprises,
pour n'en faire que des comptages. La retention est passee de 30 jours a 13
mois (StatsRetentionDays = 395) : la methode charge donc desormais treize
fois ce pour quoi elle avait ete ecrite, et ca grossit tout seul.

Ce qui part en SQL : sessions distinctes, sommes de duree par session,
duree moyenne par section, top sections, visites par jour, distributions
par session, top articles, total des scans QR.

Ce qui ne peut pas y aller : POI, agenda, quiz, jeux, menus et validite des
QR se regroupent sur du JSON dans Metadata. On ne remonte plus que les deux
colonnes utiles, et seulement pour le type d'evenement concerne (MetadataOf).

Deux effets de bord voulus :

- les stats avancees ne sont plus calculees puis effacees pour les plans qui
  n'y ont pas droit -- les six requetes ne partent pas ;
- les titres de section ne sont resolus que pour les ids reellement affiches
  (top 10 + quiz), plus pour tous les ids vus dans la fenetre.

Un changement de semantique, delibere : « la langue de la session » etait
prise sur le premier evenement rendu par la base, dans un ordre indefini.
C'est desormais le plus ancien horodatage. Meme chose pour AppType.

Le reste est preserve a l'identique, y compris les cas tordus : un scan QR
sans metadata compte dans le total sans etre ni valide ni invalide, une
metadata illisible compte la completion de quiz a zero.

11 tests ajoutes -- la branche « stats avancees » n'etait couverte par
AUCUN test : les cas existants ne seedent pas d'Instance, donc
hasAdvancedStats etait toujours faux et la moitie de la methode n'etait
jamais executee. dotnet test 186/186.

⚠️ Ces tests tournent sur le provider InMemory, qui evalue tout cote client :
ils tiennent la semantique, pas la traduction SQL. La verification sur un
vrai Postgres arrive avec les tests Testcontainers.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

ManagerService.Tests/Controllers/StatsControllerTests.cs

@@ -1,8 +1,12 @@
+using Manager.DTOs;
 using ManagerService.Controllers;
 using ManagerService.Data;
 using ManagerService.DTOs;
 using ManagerService.Tests.Infrastructure;
 using Microsoft.AspNetCore.Mvc;
+using System;
+using System.Collections.Generic;
+using System.Linq;
 using Xunit;
 
 namespace ManagerService.Tests.Controllers
@@ -164,6 +168,280 @@ namespace ManagerService.Tests.Controllers
             Assert.Equal(1, summary.TotalSessions);
         }
 
+        // ── STATS AVANCÉES ───────────────────────────────────────────────────
+        //
+        // Sans Instance en base, hasAdvancedStats est faux et toute cette branche est
+        // sautée : c'est le cas des tests ci-dessus. Ceux qui suivent la seedent, sans
+        // quoi la moitié de GetSummary ne serait jamais exécutée par la suite.
+
+        private static void SeedAdvancedInstance(MyInfoMateDbContext db)
+        {
+            db.Instances.Add(new Instance
+            {
+                Id = "i1",
+                Name = "Instance de test",
+                HasStats = true,
+                HasAdvancedStats = true,
+                StatsHistoryDays = MyInfoMateDbContext.StatsRetentionDays
+            });
+            db.SaveChanges();
+        }
+
+        private static VisitEvent Event(string id, VisitEventType type, string sessionId = "s1",
+            string sectionId = null, string metadata = null, string language = null,
+            AppType appType = AppType.Mobile, int? durationSeconds = null, DateTime? timestamp = null) =>
+            new VisitEvent
+            {
+                Id = id,
+                InstanceId = "i1",
+                SessionId = sessionId,
+                EventType = type,
+                SectionId = sectionId,
+                Metadata = metadata,
+                Language = language,
+                AppType = appType,
+                DurationSeconds = durationSeconds,
+                Timestamp = timestamp ?? DateTime.UtcNow
+            };
+
+        private static StatsSummaryDTO Summarize(MyInfoMateDbContext db, StatsController controller = null)
+        {
+            var result = (controller ?? BuildControllerStatic(db)).GetSummary("i1", null, null, null);
+            var ok = Assert.IsType<OkObjectResult>(result);
+            return Assert.IsType<StatsSummaryDTO>(ok.Value);
+        }
+
+        private static StatsController BuildControllerStatic(MyInfoMateDbContext db)
+        {
+            var controller = new StatsController(db);
+            FakeUser.SetUser(controller, FakeUser.Create(Permissions.SuperAdmin, "i1"));
+            return controller;
+        }
+
+        [Fact]
+        public void GetSummary_WithoutAdvancedStats_SkipsAdvancedBlocks()
+        {
+            using var db = DbContextFactory.Create();
+            db.Instances.Add(new Instance { Id = "i1", Name = "Basique", HasStats = true, HasAdvancedStats = false });
+            db.VisitEvents.AddRange(
+                Event("e1", VisitEventType.SectionView, sectionId: "sect-a", language: "fr"),
+                Event("e2", VisitEventType.QrScan, metadata: "{\"valid\":true}"),
+                Event("e3", VisitEventType.ArticleRead, sectionId: "sect-a")
+            );
+            db.SaveChanges();
+
+            var summary = Summarize(db);
+
+            Assert.Equal(1, summary.TotalSessions);
+            Assert.Empty(summary.LanguageDistribution);
+            Assert.Empty(summary.TopArticles);
+            Assert.Equal(0, summary.QrScans.TotalScans);
+            // Les stats de base, elles, restent servies
+            Assert.Single(summary.TopSections);
+            Assert.NotEmpty(summary.AppTypeDistribution);
+        }
+
+        [Fact]
+        public void GetSummary_AvgVisitDuration_SumsPerSessionThenAverages()
+        {
+            using var db = DbContextFactory.Create();
+            SeedAdvancedInstance(db);
+            db.VisitEvents.AddRange(
+                Event("e1", VisitEventType.SectionLeave, "s1", "sect-a", durationSeconds: 10),
+                Event("e2", VisitEventType.SectionLeave, "s1", "sect-b", durationSeconds: 30),
+                Event("e3", VisitEventType.SectionLeave, "s2", "sect-a", durationSeconds: 20)
+            );
+            db.SaveChanges();
+
+            // s1 = 40, s2 = 20 → moyenne 30. Une moyenne sur les événements donnerait 20.
+            Assert.Equal(30, Summarize(db).AvgVisitDurationSeconds);
+        }
+
+        [Fact]
+        public void GetSummary_TopSections_CarryAvgDurationAndTitle()
+        {
+            using var db = DbContextFactory.Create();
+            SeedAdvancedInstance(db);
+            var section = TestSection.Article("sect-a", "i1", "A", "c1");
+            section.Title = new List<TranslationDTO>
+            {
+                new TranslationDTO { language = "en", value = "Cellar" },
+                new TranslationDTO { language = "fr", value = "La cave" }
+            };
+            db.Sections.Add(section);
+            db.VisitEvents.AddRange(
+                Event("e1", VisitEventType.SectionView, "s1", "sect-a"),
+                Event("e2", VisitEventType.SectionLeave, "s1", "sect-a", durationSeconds: 10),
+                Event("e3", VisitEventType.SectionLeave, "s2", "sect-a", durationSeconds: 20)
+            );
+            db.SaveChanges();
+
+            var stat = Assert.Single(Summarize(db).TopSections);
+            Assert.Equal("La cave", stat.SectionTitle);  // FR privilégié
+            Assert.Equal(1, stat.Views);
+            Assert.Equal(15, stat.AvgDurationSeconds);
+        }
+
+        [Fact]
+        public void GetSummary_VisitsByDay_GroupsByCalendarDayAndChannel()
+        {
+            using var db = DbContextFactory.Create();
+            SeedAdvancedInstance(db);
+            var day = DateTime.UtcNow.AddDays(-3);
+            db.VisitEvents.AddRange(
+                Event("e1", VisitEventType.SectionView, "s1", timestamp: day, appType: AppType.Mobile),
+                Event("e2", VisitEventType.SectionView, "s2", timestamp: day.AddHours(2), appType: AppType.Tablet),
+                Event("e3", VisitEventType.SectionView, "s3", timestamp: day.AddDays(1), appType: AppType.Mobile)
+            );
+            db.SaveChanges();
+
+            var days = Summarize(db).VisitsByDay;
+
+            Assert.Equal(2, days.Count);
+            Assert.Equal(day.ToString("yyyy-MM-dd"), days[0].Date);
+            Assert.Equal(2, days[0].Total);
+            Assert.Equal(1, days[0].Mobile);
+            Assert.Equal(1, days[0].Tablet);
+        }
+
+        [Fact]
+        public void GetSummary_LanguageDistribution_CountsOneEntryPerSession()
+        {
+            using var db = DbContextFactory.Create();
+            SeedAdvancedInstance(db);
+            var start = DateTime.UtcNow.AddHours(-2);
+            db.VisitEvents.AddRange(
+                Event("e1", VisitEventType.SectionView, "s1", language: "fr", timestamp: start),
+                Event("e2", VisitEventType.SectionView, "s1", language: "fr", timestamp: start.AddMinutes(1)),
+                // La session bascule en cours de route : c'est sa première langue qui compte
+                Event("e3", VisitEventType.SectionView, "s1", language: "nl", timestamp: start.AddMinutes(2)),
+                Event("e4", VisitEventType.SectionView, "s2", language: "nl", timestamp: start)
+            );
+            db.SaveChanges();
+
+            var languages = Summarize(db).LanguageDistribution;
+
+            Assert.Equal(1, languages["fr"]);
+            Assert.Equal(1, languages["nl"]);
+        }
+
+        [Fact]
+        public void GetSummary_AppTypeDistribution_CountsOneEntryPerSession()
+        {
+            using var db = DbContextFactory.Create();
+            SeedAdvancedInstance(db);
+            db.VisitEvents.AddRange(
+                Event("e1", VisitEventType.SectionView, "s1", appType: AppType.Tablet),
+                Event("e2", VisitEventType.SectionView, "s1", appType: AppType.Tablet),
+                Event("e3", VisitEventType.SectionView, "s2", appType: AppType.Mobile)
+            );
+            db.SaveChanges();
+
+            var appTypes = Summarize(db).AppTypeDistribution;
+
+            Assert.Equal(1, appTypes["Tablet"]);
+            Assert.Equal(1, appTypes["Mobile"]);
+        }
+
+        [Fact]
+        public void GetSummary_MetadataStats_AreAggregated()
+        {
+            using var db = DbContextFactory.Create();
+            SeedAdvancedInstance(db);
+            db.VisitEvents.AddRange(
+                Event("p1", VisitEventType.MapPoiTap, sectionId: "sect-map", metadata: "{\"geoPointId\":7,\"geoPointTitle\":\"Ruche\"}"),
+                Event("p2", VisitEventType.MapPoiTap, sectionId: "sect-map", metadata: "{\"geoPointId\":7,\"geoPointTitle\":\"Ruche\"}"),
+                Event("a1", VisitEventType.AgendaEventTap, metadata: "{\"eventId\":\"ev1\",\"eventTitle\":\"Concert\"}"),
+                Event("g1", VisitEventType.GameComplete, metadata: "{\"gameType\":\"Puzzle\",\"durationSeconds\":60}"),
+                Event("g2", VisitEventType.GameComplete, metadata: "{\"gameType\":\"Puzzle\",\"durationSeconds\":40}"),
+                Event("m1", VisitEventType.MenuItemTap, metadata: "{\"targetSectionId\":\"sect-a\",\"menuItemTitle\":\"Accueil\"}"),
+                Event("r1", VisitEventType.ArticleRead, sectionId: "sect-a")
+            );
+            db.SaveChanges();
+
+            var summary = Summarize(db);
+
+            var poi = Assert.Single(summary.TopPois);
+            Assert.Equal(7, poi.GeoPointId);
+            Assert.Equal(2, poi.Taps);
+            Assert.Equal("sect-map", poi.SectionId);
+
+            Assert.Equal("Concert", Assert.Single(summary.TopAgendaEvents).EventTitle);
+            var game = Assert.Single(summary.GameStats);
+            Assert.Equal(2, game.Completions);
+            Assert.Equal(50, game.AvgDurationSeconds);
+            Assert.Equal("Accueil", Assert.Single(summary.TopMenuItems).MenuItemTitle);
+            Assert.Equal(1, Assert.Single(summary.TopArticles).Reads);
+        }
+
+        [Fact]
+        public void GetSummary_QuizStats_AverageScorePerSection()
+        {
+            using var db = DbContextFactory.Create();
+            SeedAdvancedInstance(db);
+            db.VisitEvents.AddRange(
+                Event("q1", VisitEventType.QuizComplete, "s1", "sect-quiz", "{\"score\":4,\"totalQuestions\":5}"),
+                Event("q2", VisitEventType.QuizComplete, "s2", "sect-quiz", "{\"score\":2,\"totalQuestions\":5}"),
+                // Metadata illisible : compté, à zéro, comme avant
+                Event("q3", VisitEventType.QuizComplete, "s3", "sect-quiz", "pas du json")
+            );
+            db.SaveChanges();
+
+            var quiz = Assert.Single(Summarize(db).QuizStats);
+            Assert.Equal("sect-quiz", quiz.SectionId);
+            Assert.Equal(3, quiz.Completions);
+            Assert.Equal(2.0, quiz.AvgScore);
+        }
+
+        [Fact]
+        public void GetSummary_QrScans_CountsScansWithoutMetadataInTotalOnly()
+        {
+            using var db = DbContextFactory.Create();
+            SeedAdvancedInstance(db);
+            db.VisitEvents.AddRange(
+                Event("qr1", VisitEventType.QrScan, metadata: "{\"valid\":true}"),
+                Event("qr2", VisitEventType.QrScan, metadata: "{\"valid\":false}"),
+                Event("qr3", VisitEventType.QrScan)  // sans metadata : ni valide ni invalide
+            );
+            db.SaveChanges();
+
+            var qr = Summarize(db).QrScans;
+
+            Assert.Equal(3, qr.TotalScans);
+            Assert.Equal(1, qr.ValidScans);
+            Assert.Equal(1, qr.InvalidScans);
+        }
+
+        [Fact]
+        public void GetSummary_HasStatsDisabled_ReturnsEmptySummary()
+        {
+            using var db = DbContextFactory.Create();
+            db.Instances.Add(new Instance { Id = "i1", Name = "Sans stats", HasStats = false });
+            db.VisitEvents.Add(Event("e1", VisitEventType.SectionView, sectionId: "sect-a"));
+            db.SaveChanges();
+
+            Assert.Equal(0, Summarize(db).TotalSessions);
+        }
+
+        [Fact]
+        public void GetSummary_RetentionCapsTheRequestedRange()
+        {
+            // Le plan borne l'historique : une plage plus large que la rétention est
+            // ramenée à la rétention, pas honorée.
+            using var db = DbContextFactory.Create();
+            db.Instances.Add(new Instance { Id = "i1", Name = "30 jours", HasStats = true, StatsHistoryDays = 30 });
+            db.VisitEvents.AddRange(
+                Event("e1", VisitEventType.SectionView, "s1", timestamp: DateTime.UtcNow.AddDays(-10)),
+                Event("e2", VisitEventType.SectionView, "s2", timestamp: DateTime.UtcNow.AddDays(-90))
+            );
+            db.SaveChanges();
+
+            var result = BuildControllerStatic(db).GetSummary("i1", DateTime.UtcNow.AddDays(-365), DateTime.UtcNow, null);
+            var summary = Assert.IsType<StatsSummaryDTO>(Assert.IsType<OkObjectResult>(result).Value);
+
+            Assert.Equal(1, summary.TotalSessions);
+        }
+
         [Fact]
         public void GetSummary_TopSections_AggregatesByViewCount()
         {

ManagerService/Controllers/StatsController.cs

@@ -75,6 +75,29 @@ namespace ManagerService.Controllers
             }
         }
 
+        /// <summary>
+        /// Metadata (et section) des événements d'un type donné.
+        /// </summary>
+        /// <remarks>
+        /// Ces agrégats-là se lisent dans le JSON de <c>Metadata</c>, donc hors de portée de
+        /// SQL. On ne remonte que les deux colonnes utiles, et seulement pour le type
+        /// d'événement concerné — au lieu de la fenêtre entière, colonnes comprises.
+        /// </remarks>
+        private static List<(string Metadata, string SectionId)> MetadataOf(
+            IQueryable<VisitEvent> events, VisitEventType type, bool sectionIdRequired = false)
+        {
+            var query = events.Where(e => e.EventType == type && e.Metadata != null);
+
+            if (sectionIdRequired)
+                query = query.Where(e => e.SectionId != null);
+
+            return query
+                .Select(e => new { e.Metadata, e.SectionId })
+                .ToList()
+                .Select(e => (e.Metadata!, e.SectionId))
+                .ToList();
+        }
+
         /// <summary>Get aggregated statistics for an instance</summary>
         [Authorize(Policy = ManagerService.Service.Security.Policies.Viewer)]
         [HttpGet("summary")]
@@ -113,100 +136,103 @@ namespace ManagerService.Controllers
                 if (!string.IsNullOrEmpty(appType) && Enum.TryParse<AppType>(appType, ignoreCase: true, out var appTypeFilter))
                     eventsQuery = eventsQuery.Where(e => e.AppType == appTypeFilter);
 
-                var events = eventsQuery.ToList();
-
                 var summary = new StatsSummaryDTO();
 
                 // Sessions
-                summary.TotalSessions = events.Select(e => e.SessionId).Distinct().Count();
+                summary.TotalSessions = eventsQuery.Select(e => e.SessionId).Distinct().Count();
 
-                // Avg visit duration (from SectionLeave events with duration)
+                // Durée moyenne de visite : somme des durées par session, puis moyenne de
-                var leaveEvents = events.Where(e => e.EventType == VisitEventType.SectionLeave && e.DurationSeconds.HasValue).ToList();
+                // ces sommes. Une ligne par session remonte, pas une par événement.
-                if (leaveEvents.Any())
+                var leaveQuery = eventsQuery
-                {
+                    .Where(e => e.EventType == VisitEventType.SectionLeave && e.DurationSeconds.HasValue);
-                    var sessionsWithDuration = leaveEvents
+
+                var sessionDurations = leaveQuery
                     .GroupBy(e => e.SessionId)
-                        .Select(g => g.Sum(e => e.DurationSeconds!.Value));
+                    .Select(g => g.Sum(e => e.DurationSeconds!.Value))
-                    summary.AvgVisitDurationSeconds = (int)sessionsWithDuration.Average();
+                    .ToList();
-                }
+                if (sessionDurations.Count > 0)
+                    summary.AvgVisitDurationSeconds = (int)sessionDurations.Average();
 
-                // Section title lookup (FR preferred, fallback to first available)
+                var sectionDurations = leaveQuery
-                var allSectionIds = events.Where(e => e.SectionId != null).Select(e => e.SectionId!).Distinct().ToList();
+                    .Where(e => e.SectionId != null)
-                var sectionTitles = _db.Sections
+                    .GroupBy(e => e.SectionId!)
-                    .Where(s => allSectionIds.Contains(s.Id))
+                    .Select(g => new { SectionId = g.Key, Avg = g.Average(e => (double)e.DurationSeconds!.Value) })
-                    .Select(s => new { s.Id, s.Title })
+                    .ToDictionary(x => x.SectionId, x => (int)x.Avg);
-                    .ToList()
-                    .ToDictionary(
-                        s => s.Id,
-                        s => s.Title?.FirstOrDefault(t => t.language == "fr")?.value
-                            ?? s.Title?.FirstOrDefault()?.value
-                    );
 
                 // Top sections
-                var sectionViews = events
+                var sectionViews = eventsQuery
                     .Where(e => e.EventType == VisitEventType.SectionView && e.SectionId != null)
                     .GroupBy(e => e.SectionId!)
-                    .Select(g =>
+                    .Select(g => new { SectionId = g.Key, Views = g.Count() })
-                    {
+                    .OrderByDescending(x => x.Views)
-                        var leaveDurations = leaveEvents
-                            .Where(l => l.SectionId == g.Key)
-                            .Select(l => l.DurationSeconds!.Value)
-                            .ToList();
-                        return new SectionStatDTO
-                        {
-                            SectionId = g.Key,
-                            SectionTitle = sectionTitles.GetValueOrDefault(g.Key),
-                            Views = g.Count(),
-                            AvgDurationSeconds = leaveDurations.Any() ? (int)leaveDurations.Average() : 0
-                        };
-                    })
-                    .OrderByDescending(s => s.Views)
                     .Take(10)
                     .ToList();
-                summary.TopSections = sectionViews;
 
                 // Visits by day
-                summary.VisitsByDay = events
+                summary.VisitsByDay = eventsQuery
                     .Where(e => e.EventType == VisitEventType.SectionView)
-                    .GroupBy(e => e.Timestamp.Date.ToString("yyyy-MM-dd"))
+                    .GroupBy(e => e.Timestamp.Date)
-                    .Select(g => new DayStatDTO
+                    .Select(g => new
                     {
-                        Date = g.Key,
+                        Day = g.Key,
                         Total = g.Count(),
-                        Mobile = g.Count(e => e.AppType == AppType.Mobile),
+                        Mobile = g.Sum(e => e.AppType == AppType.Mobile ? 1 : 0),
-                        Tablet = g.Count(e => e.AppType == AppType.Tablet)
+                        Tablet = g.Sum(e => e.AppType == AppType.Tablet ? 1 : 0)
+                    })
+                    .OrderBy(x => x.Day)
+                    .ToList()
+                    .Select(x => new DayStatDTO
+                    {
+                        Date = x.Day.ToString("yyyy-MM-dd"),
+                        Total = x.Total,
+                        Mobile = x.Mobile,
+                        Tablet = x.Tablet
                     })
-                    .OrderBy(d => d.Date)
                     .ToList();
 
-                // Language distribution (one entry per distinct session)
+                // AppType distribution (une entrée par session distincte). Le couple
-                summary.LanguageDistribution = events
+                // (session, valeur) est agrégé en SQL ; seule la levée d'ambiguïté d'une
-                    .Where(e => e.Language != null)
+                // session qui aurait changé de valeur se fait ici, sur la plus ancienne.
-                    .GroupBy(e => e.SessionId)
+                summary.AppTypeDistribution = eventsQuery
-                    .Select(g => g.First().Language!)
+                    .GroupBy(e => new { e.SessionId, e.AppType })
-                    .GroupBy(lang => lang)
+                    .Select(g => new { g.Key.SessionId, g.Key.AppType, FirstSeen = g.Min(e => e.Timestamp) })
-                    .ToDictionary(g => g.Key, g => g.Count());
+                    .ToList()
-
+                    .GroupBy(x => x.SessionId)
-                // AppType distribution (one entry per distinct session)
+                    .Select(g => g.OrderBy(x => x.FirstSeen).First().AppType.ToString())
-                summary.AppTypeDistribution = events
-                    .GroupBy(e => e.SessionId)
-                    .Select(g => g.First().AppType.ToString())
                     .GroupBy(t => t)
                     .ToDictionary(g => g.Key, g => g.Count());
 
-                // Top POIs
+                // Les statistiques avancées ne sont pas seulement masquées : elles ne sont
-                var poiEvents = events.Where(e => e.EventType == VisitEventType.MapPoiTap && e.Metadata != null).ToList();
+                // plus calculées. Les six requêtes ci-dessous ne partent pas du tout sur un
+                // plan qui n'y donne pas droit.
+                var quizScores = new List<(string sectionId, double score, int total)>();
+
+                if (hasAdvancedStats)
+                {
+                    // Language distribution (une entrée par session distincte)
+                    summary.LanguageDistribution = eventsQuery
+                        .Where(e => e.Language != null)
+                        .GroupBy(e => new { e.SessionId, e.Language })
+                        .Select(g => new { g.Key.SessionId, g.Key.Language, FirstSeen = g.Min(e => e.Timestamp) })
+                        .ToList()
+                        .GroupBy(x => x.SessionId)
+                        .Select(g => g.OrderBy(x => x.FirstSeen).First().Language!)
+                        .GroupBy(lang => lang)
+                        .ToDictionary(g => g.Key, g => g.Count());
+
+                    // Top POIs — le regroupement vit dans le JSON de Metadata, donc hors de
+                    // portée de SQL : on ne remonte que les deux colonnes nécessaires.
                     var poiGroups = new Dictionary<int, (string title, int taps, string sectionId)>();
-                foreach (var ev in poiEvents)
+                    foreach (var (metadata, eventSectionId) in MetadataOf(eventsQuery, VisitEventType.MapPoiTap))
                     {
                         try
                         {
-                        var meta = JsonSerializer.Deserialize<JsonElement>(ev.Metadata!);
+                            var meta = JsonSerializer.Deserialize<JsonElement>(metadata);
                             if (meta.TryGetProperty("geoPointId", out var idEl) && meta.TryGetProperty("geoPointTitle", out var titleEl))
                             {
                                 int id = idEl.GetInt32();
                                 string title = titleEl.GetString() ?? "";
-                            string sectionId = ev.SectionId ?? "";
+                                string sectionId = eventSectionId ?? "";
                                 if (poiGroups.TryGetValue(id, out var existing))
                                     poiGroups[id] = (existing.title, existing.taps + 1, existing.sectionId);
                                 else
@@ -222,13 +248,12 @@ namespace ManagerService.Controllers
                         .ToList();
 
                     // Top agenda events
-                var agendaEvents = events.Where(e => e.EventType == VisitEventType.AgendaEventTap && e.Metadata != null).ToList();
                     var agendaGroups = new Dictionary<string, (string title, int taps)>();
-                foreach (var ev in agendaEvents)
+                    foreach (var (metadata, _) in MetadataOf(eventsQuery, VisitEventType.AgendaEventTap))
                     {
                         try
                         {
-                        var meta = JsonSerializer.Deserialize<JsonElement>(ev.Metadata!);
+                            var meta = JsonSerializer.Deserialize<JsonElement>(metadata);
                             if (meta.TryGetProperty("eventId", out var idEl) && meta.TryGetProperty("eventTitle", out var titleEl))
                             {
                                 string id = idEl.GetString() ?? "";
@@ -247,42 +272,26 @@ namespace ManagerService.Controllers
                         .Take(10)
                         .ToList();
 
-                // Quiz stats
+                    // Quiz stats — assemblées plus bas, une fois les titres de section connus
-                var quizEvents = events.Where(e => e.EventType == VisitEventType.QuizComplete && e.SectionId != null && e.Metadata != null).ToList();
+                    foreach (var (metadata, quizSectionId) in MetadataOf(eventsQuery, VisitEventType.QuizComplete, sectionIdRequired: true))
-                summary.QuizStats = quizEvents
-                    .GroupBy(e => e.SectionId!)
-                    .Select(g =>
-                    {
-                        var scores = g.Select(e =>
                     {
                         try
                         {
-                                var meta = JsonSerializer.Deserialize<JsonElement>(e.Metadata!);
+                            var meta = JsonSerializer.Deserialize<JsonElement>(metadata);
-                                double score = meta.TryGetProperty("score", out var s) ? s.GetDouble() : 0;
+                            double score = meta.TryGetProperty("score", out var scoreEl) ? scoreEl.GetDouble() : 0;
-                                int total = meta.TryGetProperty("totalQuestions", out var t) ? t.GetInt32() : 1;
+                            int total = meta.TryGetProperty("totalQuestions", out var totalEl) ? totalEl.GetInt32() : 1;
-                                return (score, total);
+                            quizScores.Add((quizSectionId, score, total));
+                        }
+                        catch { quizScores.Add((quizSectionId, 0.0, 1)); }
                     }
-                            catch { return (score: 0.0, total: 1); }
-                        }).ToList();
-                        return new QuizStatDTO
-                        {
-                            SectionId = g.Key,
-                            SectionTitle = sectionTitles.GetValueOrDefault(g.Key),
-                            Completions = g.Count(),
-                            AvgScore = scores.Any() ? scores.Average(s => s.score) : 0,
-                            TotalQuestions = scores.Any() ? (int)scores.Average(s => s.total) : 0
-                        };
-                    })
-                    .ToList();
 
                     // Game stats
-                var gameEvents = events.Where(e => e.EventType == VisitEventType.GameComplete && e.Metadata != null).ToList();
                     var gameGroups = new Dictionary<string, (int completions, List<int> durations)>();
-                foreach (var ev in gameEvents)
+                    foreach (var (metadata, _) in MetadataOf(eventsQuery, VisitEventType.GameComplete))
                     {
                         try
                         {
-                        var meta = JsonSerializer.Deserialize<JsonElement>(ev.Metadata!);
+                            var meta = JsonSerializer.Deserialize<JsonElement>(metadata);
                             if (meta.TryGetProperty("gameType", out var typeEl))
                             {
                                 string gameType = typeEl.GetString() ?? "Unknown";
@@ -304,7 +313,7 @@ namespace ManagerService.Controllers
                         .ToList();
 
                     // Top articles lus
-                summary.TopArticles = events
+                    summary.TopArticles = eventsQuery
                         .Where(e => e.EventType == VisitEventType.ArticleRead && e.SectionId != null)
                         .GroupBy(e => e.SectionId!)
                         .Select(g => new ArticleStatDTO { SectionId = g.Key, Reads = g.Count() })
@@ -313,13 +322,12 @@ namespace ManagerService.Controllers
                         .ToList();
 
                     // Top menu items
-                var menuEvents = events.Where(e => e.EventType == VisitEventType.MenuItemTap && e.Metadata != null).ToList();
                     var menuGroups = new Dictionary<string, (string title, int taps)>();
-                foreach (var ev in menuEvents)
+                    foreach (var (metadata, _) in MetadataOf(eventsQuery, VisitEventType.MenuItemTap))
                     {
                         try
                         {
-                        var meta = JsonSerializer.Deserialize<JsonElement>(ev.Metadata!);
+                            var meta = JsonSerializer.Deserialize<JsonElement>(metadata);
                             if (meta.TryGetProperty("targetSectionId", out var idEl))
                             {
                                 string id = idEl.GetString() ?? "";
@@ -338,36 +346,62 @@ namespace ManagerService.Controllers
                         .Take(10)
                         .ToList();
 
-                // QR scans
+                    // QR scans — le total compte aussi les scans sans metadata, qui ne sont
-                var qrEvents = events.Where(e => e.EventType == VisitEventType.QrScan).ToList();
+                    // ni valides ni invalides. Compté en SQL, séparément du dépouillement.
+                    var qrQuery = eventsQuery.Where(e => e.EventType == VisitEventType.QrScan);
                     var validQr = 0; var invalidQr = 0;
-                foreach (var ev in qrEvents)
+                    foreach (var qrMetadata in qrQuery.Where(e => e.Metadata != null).Select(e => e.Metadata!).ToList())
                     {
                         try
                         {
-                        if (ev.Metadata != null)
+                            var meta = JsonSerializer.Deserialize<JsonElement>(qrMetadata);
-                        {
-                            var meta = JsonSerializer.Deserialize<JsonElement>(ev.Metadata);
                             if (meta.TryGetProperty("valid", out var validEl) && validEl.GetBoolean()) validQr++;
                             else invalidQr++;
                         }
-                    }
                         catch { invalidQr++; }
                     }
-                summary.QrScans = new QrScanStatDTO { TotalScans = qrEvents.Count, ValidScans = validQr, InvalidScans = invalidQr };
+                    summary.QrScans = new QrScanStatDTO { TotalScans = qrQuery.Count(), ValidScans = validQr, InvalidScans = invalidQr };
-
-                if (!hasAdvancedStats)
-                {
-                    summary.LanguageDistribution = new Dictionary<string, int>();
-                    summary.TopPois = new List<PoiStatDTO>();
-                    summary.TopAgendaEvents = new List<AgendaEventStatDTO>();
-                    summary.QuizStats = new List<QuizStatDTO>();
-                    summary.GameStats = new List<GameStatDTO>();
-                    summary.TopArticles = new List<ArticleStatDTO>();
-                    summary.TopMenuItems = new List<MenuItemStatDTO>();
-                    summary.QrScans = new QrScanStatDTO { TotalScans = 0, ValidScans = 0, InvalidScans = 0 };
                 }
 
+                // Titres de section (FR par défaut, sinon la première traduction disponible).
+                // Seuls les ids réellement affichés sont résolus, pas tous ceux vus.
+                var titledSectionIds = sectionViews.Select(s => s.SectionId)
+                    .Concat(quizScores.Select(q => q.sectionId))
+                    .Distinct()
+                    .ToList();
+
+                var sectionTitles = _db.Sections
+                    .Where(s => titledSectionIds.Contains(s.Id))
+                    .Select(s => new { s.Id, s.Title })
+                    .ToList()
+                    .ToDictionary(
+                        s => s.Id,
+                        s => s.Title?.FirstOrDefault(t => t.language == "fr")?.value
+                            ?? s.Title?.FirstOrDefault()?.value
+                    );
+
+                summary.TopSections = sectionViews
+                    .Select(s => new SectionStatDTO
+                    {
+                        SectionId = s.SectionId,
+                        SectionTitle = sectionTitles.GetValueOrDefault(s.SectionId),
+                        Views = s.Views,
+                        AvgDurationSeconds = sectionDurations.GetValueOrDefault(s.SectionId)
+                    })
+                    .ToList();
+
+                summary.QuizStats = quizScores
+                    .GroupBy(q => q.sectionId)
+                    .Select(g => new QuizStatDTO
+                    {
+                        SectionId = g.Key,
+                        SectionTitle = sectionTitles.GetValueOrDefault(g.Key),
+                        Completions = g.Count(),
+                        AvgScore = g.Average(q => q.score),
+                        TotalQuestions = (int)g.Average(q => q.total)
+                    })
+                    .ToList();
+
                 return Ok(summary);
             }
             catch (Exception ex)