Klassenlehrer-Tab: Theme-Ressourcen statt Hex-Farben, gestapelter Trend, Fehlquote seit Schuljahresbeginn

Semantische Brushes (Light/Dark) lösen die fest codierten Dark-Hex-Werte ab, die im hellen Theme unbenutzbar waren. Trend-Chart zeigt jetzt einen echten gestapelten Balken über die letzten 7 Schultage statt drei unabhängig skalierten über Kalendertage; neue Fehlquote je Schüler*in seit Schuljahresbeginn ergänzt den Heute-Snapshot. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-08-27 12:47:13 +02:00
parent cf8de08501
commit 9d375caf14
9 changed files with 510 additions and 119 deletions
@@ -13,8 +13,11 @@ public sealed record ClassTeacherClassRegisterRow(DateOnly Date, string? Subject
 {
    public string DateLabel => Date.ToString("dd.MM.yyyy");
    public string StudentDisplayName => DisplayName(StudentName);
-    public string CategoryColor => CategoryGroup?.Contains("Negativ", StringComparison.OrdinalIgnoreCase) == true
-        ? "#FF5A67" : "#4C8DFF";
+    public ClassTeacherStatusKind CategoryKind =>
+        CategoryGroup?.Contains("Negativ", StringComparison.OrdinalIgnoreCase) == true
+            ? ClassTeacherStatusKind.Danger : ClassTeacherStatusKind.Info;
+    public bool IsDangerStatus => CategoryKind == ClassTeacherStatusKind.Danger;
+    public bool IsInfoStatus => CategoryKind == ClassTeacherStatusKind.Info;

    private static string DisplayName(string value)
    {
@@ -46,10 +49,6 @@ public sealed record ClassAbsenceDaySummaryRow(DateOnly Date, string StudentName
    public string PeriodsLabel => string.Join(", ", PeriodNumbers.Order());
    public string StatusLabel => string.Join(", ", Statuses);
    public string ReasonLabel => string.Join("; ", AbsenceReasons);
-    /// Nutzer-Feedback: ein ganzer Fehltag ist in der Liste sonst nicht auf einen Blick erkennbar -
-    /// dezente Hervorhebung statt einer weiteren Text-/Icon-Spalte.
-    public string RowBackground => CountsAsFullDay ? "#1FFFA000" : "Transparent";
-    public string? FullDayTooltip => CountsAsFullDay ? "Ganzer Fehltag" : null;
    public bool IsLate => TotalAbsentPeriods == 0 || AbsenceReasons.Any(r =>
        r.Contains("verspät", StringComparison.OrdinalIgnoreCase));
    public bool IsUnexcused => Statuses.Any(s =>
@@ -58,7 +57,10 @@ public sealed record ClassAbsenceDaySummaryRow(DateOnly Date, string StudentName
        CountsAsFullDay ? "Ganzer Fehltag" : $"{TotalAbsentPeriods} Fehlstunde{(TotalAbsentPeriods == 1 ? "" : "n")}";
    public string FriendlyStatusLabel => IsUnexcused ? "Unentschuldigt" :
        Statuses.Any(s => s.Contains("entsch", StringComparison.OrdinalIgnoreCase)) ? "Entschuldigt" : StatusLabel;
-    public string StatusColor => IsUnexcused ? "#FF5A67" : IsLate ? "#F59E0B" : "#73C45A";
+    public ClassTeacherStatusKind StatusKind => IsUnexcused ? ClassTeacherStatusKind.Danger :
+        IsLate ? ClassTeacherStatusKind.Warning : ClassTeacherStatusKind.Ok;
+    public bool IsDangerStatus => StatusKind == ClassTeacherStatusKind.Danger;
+    public bool IsWarningStatus => StatusKind == ClassTeacherStatusKind.Warning;
    public string DetailLabel => string.Join(" · ", new[] { ReasonLabel, Note, ExcuseNote }
        .Where(value => !string.IsNullOrWhiteSpace(value)));

@@ -2,10 +2,17 @@ using System.Collections.ObjectModel;
 using CommunityToolkit.Mvvm.ComponentModel;
 using CommunityToolkit.Mvvm.Input;
 using LehrerApp.Core.Models;
+using LehrerApp.Core.Services;
 using LehrerApp.Desktop.Services;

 namespace LehrerApp.Desktop.ViewModels.ClassTeacher;

+/// <summary>Semantische Statusstufe einer Zeile bzw. eines Hinweises. Bewusst ohne Farbwert im
+/// ViewModel: Die Zuordnung zu einem Pinsel passiert über Style-Klassen in XAML
+/// (<c>Styles/SemanticBrushes.axaml</c>), damit ein Theme-Wechsel hell/dunkel sie live mitnimmt —
+/// ein hart codierter Hex-String aus dem ViewModel bliebe beim Wechsel unverändert stehen.</summary>
+public enum ClassTeacherStatusKind { Ok, Info, Warning, Danger }
+
 public sealed record ClassTeacherRosterRow(string StudentName, int? ExternKey, bool HasAbsenceToday,
    string? AbsenceTooltip, bool HasRecentClassRegisterEntry)
 {
@@ -43,12 +50,30 @@ public sealed record ClassTeacherRosterRow(string StudentName, int? ExternKey, b
        }
    }

-    public string StatusColor => IsUnexcused ? "#FF5A67" :
-        HasAbsenceToday ? "#F59E0B" : HasRecentClassRegisterEntry ? "#4C8DFF" : "#73C45A";
-    public string StatusBarColor => StatusColor;
+    public ClassTeacherStatusKind StatusKind => IsUnexcused ? ClassTeacherStatusKind.Danger :
+        HasAbsenceToday ? ClassTeacherStatusKind.Warning :
+        HasRecentClassRegisterEntry ? ClassTeacherStatusKind.Info : ClassTeacherStatusKind.Ok;
+    public bool IsDangerStatus => StatusKind == ClassTeacherStatusKind.Danger;
+    public bool IsWarningStatus => StatusKind == ClassTeacherStatusKind.Warning;
+    public bool IsInfoStatus => StatusKind == ClassTeacherStatusKind.Info;
    public string ClassRegisterLabel => HasClassRegisterToday ? "Eintrag heute" :
        HasRecentClassRegisterEntry ? "Eintrag diese Woche" : "";

+    /// Kumulierte Fehlzeiten seit Schuljahresbeginn (Nutzer-Feedback: der Heute-Snapshot allein
+    /// sagt für Zeugnis/Attestpflicht wenig aus). <see cref="SchoolDaysElapsed"/> zählt nur
+    /// Werktage, ohne Ferienkalender — eine bewusste Vereinfachung, siehe TODO.md 12.4-Nachtrag.
+    public int YearAbsenceDayCount { get; init; }
+    public int YearUnexcusedDayCount { get; init; }
+    public int SchoolDaysElapsed { get; init; }
+    public bool HasYearSummary => SchoolDaysElapsed > 0 && YearAbsenceDayCount > 0;
+    public int YearAbsenceRatePercent =>
+        SchoolDaysElapsed <= 0 ? 0 : (int)Math.Round(100d * YearAbsenceDayCount / SchoolDaysElapsed);
+    public string YearSummaryLabel => HasYearSummary
+        ? $"{YearAbsenceRatePercent} % Fehlzeit seit Schuljahresbeginn" : "";
+    public string? YearSummaryTooltip => !HasYearSummary ? null :
+        $"{YearAbsenceDayCount} von {SchoolDaysElapsed} Schultagen mit Fehlzeit" +
+        (YearUnexcusedDayCount > 0 ? $" · {YearUnexcusedDayCount} unentschuldigt" : "");
+
    private static bool IsLateReason(string reason) =>
        reason.Contains("verspät", StringComparison.OrdinalIgnoreCase);

@@ -56,7 +81,9 @@ public sealed record ClassTeacherRosterRow(string StudentName, int? ExternKey, b
        IReadOnlyList<UntisStudentRosterCacheEntry> students,
        IReadOnlyList<ClassAbsenceDaySummaryRow> todayAbsences,
        IReadOnlyList<UntisForeignClassRegisterEventDto> recentClassRegisterEntries,
-        DateOnly? today = null)
+        DateOnly? today = null,
+        IReadOnlyList<ClassAbsenceDaySummaryRow>? yearAbsences = null,
+        int schoolDaysElapsed = 0)
    {
        var referenceDate = today ?? todayAbsences.FirstOrDefault()?.Date ?? DateOnly.FromDateTime(DateTime.Today);
        var absenceByKey = todayAbsences.Where(a => a.ExternKey is not null)
@@ -65,6 +92,11 @@ public sealed record ClassTeacherRosterRow(string StudentName, int? ExternKey, b
            .ToDictionary(g => g.Key, g => g.First());
        var recentByName = recentClassRegisterEntries.GroupBy(e => UntisNameMatching.NameKey(e.StudentName))
            .ToDictionary(g => g.Key, g => g.ToList());
+        var yearRows = yearAbsences ?? [];
+        var yearByKey = yearRows.Where(a => a.ExternKey is not null)
+            .GroupBy(a => a.ExternKey!.Value).ToDictionary(g => g.Key, g => g.ToList());
+        var yearByName = yearRows.GroupBy(a => UntisNameMatching.NameKey(a.StudentName))
+            .ToDictionary(g => g.Key, g => g.ToList());

        return students.Select(student =>
            {
@@ -72,12 +104,17 @@ public sealed record ClassTeacherRosterRow(string StudentName, int? ExternKey, b
                var absence = (student.ExternKey is { } key ? absenceByKey.GetValueOrDefault(key) : null)
                    ?? absenceByName.GetValueOrDefault(nameKey);
                var registerEntries = recentByName.GetValueOrDefault(nameKey) ?? [];
+                var yearEntries = (student.ExternKey is { } yearKey ? yearByKey.GetValueOrDefault(yearKey) : null)
+                    ?? yearByName.GetValueOrDefault(nameKey) ?? [];
                return new ClassTeacherRosterRow(student.DisplayName, student.ExternKey, absence is not null,
                    absence is null ? null : $"{absence.TotalAbsentPeriods} Stunde(n) — {absence.StatusLabel}",
                    registerEntries.Count > 0)
                {
                    TodayAbsence = absence,
                    HasClassRegisterToday = registerEntries.Any(e => TryDate(e.Date, out var date) && date == referenceDate),
+                    YearAbsenceDayCount = yearEntries.Count,
+                    YearUnexcusedDayCount = yearEntries.Count(r => r.IsUnexcused),
+                    SchoolDaysElapsed = schoolDaysElapsed,
                };
            })
            .OrderBy(r => r.AttentionRank).ThenBy(r => r.StudentName).ToList();
@@ -87,14 +124,31 @@ public sealed record ClassTeacherRosterRow(string StudentName, int? ExternKey, b
        DateOnly.TryParseExact(value.ToString(), "yyyyMMdd", out date);
 }

-public sealed record ClassTeacherTrendDay(string DayLabel, int AlertCount, int UnexcusedCount, int LateCount,
-    double AlertBarWidth, double UnexcusedBarWidth, double LateBarWidth);
-public sealed record ClassTeacherPatternNotice(string StudentName, string Message, string Color);
+/// Ein gestapelter Tages-Balken statt drei unabhängig skalierter (Nutzer-Feedback: die vorherige
+/// Version zeigte Alerts/Unentschuldigt/Verspätet als drei separate, gleich hohe Balken, obwohl
+/// Unentschuldigt und Verspätet Teilmengen von Alerts sind — das suggerierte fälschlich drei
+/// unabhängige Größen). Die drei Segmente sind überschneidungsfrei (Unentschuldigt hat Vorrang
+/// vor Verspätet, wie bei <see cref="ClassTeacherRosterRow.AttentionRank"/>) und ihre Breiten
+/// summieren sich exakt zu <see cref="TotalBarWidth"/>.
+public sealed record ClassTeacherTrendDay(string DayLabel, int AlertCount, int UnexcusedCount,
+    int LateExcusedCount, int ExcusedCount, double UnexcusedBarWidth, double LateExcusedBarWidth,
+    double ExcusedBarWidth)
+{
+    public double TotalBarWidth => UnexcusedBarWidth + LateExcusedBarWidth + ExcusedBarWidth;
+}
+public sealed record ClassTeacherPatternNotice(string StudentName, string Message,
+    ClassTeacherStatusKind Kind)
+{
+    public bool IsDangerStatus => Kind == ClassTeacherStatusKind.Danger;
+    public bool IsWarningStatus => Kind == ClassTeacherStatusKind.Warning;
+    public bool IsInfoStatus => Kind == ClassTeacherStatusKind.Info;
+}

 public partial class ClassTeacherOverviewViewModel : ObservableObject
 {
    private readonly WebUntisSettingsService _settings;
    private readonly UntisReportCacheService _cache;
+    private readonly SchoolYearService _schoolYear;

    public ClassTeacherDetailsViewModel DetailsTab { get; }
    public ObservableCollection<ClassTeacherRosterRow> Roster { get; } = [];
@@ -139,10 +193,11 @@ public partial class ClassTeacherOverviewViewModel : ObservableObject
    public Func<Task>? OnNavigateToWorkload { get; set; }

    public ClassTeacherOverviewViewModel(WebUntisSettingsService settings,
-        UntisReportCacheService cache, ClassTeacherDetailsViewModel detailsTab)
+        UntisReportCacheService cache, SchoolYearService schoolYear, ClassTeacherDetailsViewModel detailsTab)
    {
        _settings = settings;
        _cache = cache;
+        _schoolYear = schoolYear;
        DetailsTab = detailsTab;
    }

@@ -176,16 +231,24 @@ public partial class ClassTeacherOverviewViewModel : ObservableObject
        try
        {
            var today = DateOnly.FromDateTime(DateTime.Today);
-            var start = today.AddDays(-6);
+            var sevenDayStart = today.AddDays(-6);
+            var trendDays = LastSchoolDays(today, 7);
+            // Fehlzeiten seit Schuljahresbeginn statt nur der letzten 7 Tage: liefert die
+            // Kennzahl unten (YearSummaryLabel) und den Nenner für die Fehlquote in einem Abruf.
+            // UntisReportCacheService cached diesen "kalten" Bereich dauerhaft (siehe dort) —
+            // teuer ist nur der erste Abruf pro Schuljahr, nicht jedes Öffnen der Ansicht.
+            var yearStart = _schoolYear.SchoolYearStart(_schoolYear.CurrentSchoolYear(today));
            var studentsTask = _cache.GetStudentRosterAsync(className);
-            var absencesTask = _cache.GetAbsencesAsync(className, start, today);
-            var classRegisterTask = _cache.GetClassRegisterEventsAsync(className, start, today);
+            var absencesTask = _cache.GetAbsencesAsync(className, yearStart, today);
+            var classRegisterTask = _cache.GetClassRegisterEventsAsync(className, sevenDayStart, today);
            await Task.WhenAll(studentsTask, absencesTask, classRegisterTask);

-            var absenceDays = ClassAbsenceDaySummaryRow.GroupByStudentAndDay(absencesTask.Result);
-            var todayAbsences = absenceDays.Where(a => a.Date == today).ToList();
+            var absenceDaysYear = ClassAbsenceDaySummaryRow.GroupByStudentAndDay(absencesTask.Result);
+            var todayAbsences = absenceDaysYear.Where(a => a.Date == today).ToList();
+            var weekAbsenceDays = absenceDaysYear.Where(a => a.Date >= sevenDayStart).ToList();
+            var schoolDaysElapsed = CountWeekdays(yearStart, today);
            foreach (var row in ClassTeacherRosterRow.Build(studentsTask.Result, todayAbsences,
-                         classRegisterTask.Result, today)) Roster.Add(row);
+                         classRegisterTask.Result, today, absenceDaysYear, schoolDaysElapsed)) Roster.Add(row);

            StudentCount = Roster.Count;
            TodayAlertCount = Roster.Count(r => r.HasAbsenceToday);
@@ -195,8 +258,8 @@ public partial class ClassTeacherOverviewViewModel : ObservableObject
            ExcusedAbsenceCount = Roster.Count(r => r.HasAbsenceToday && !r.IsLate && !r.IsUnexcused);
            UnexcusedAbsenceCount = Roster.Count(r => r.HasAbsenceToday && !r.IsLate && r.IsUnexcused);
            RecentClassRegisterCount = classRegisterTask.Result.Count;
-            BuildTrend(absenceDays, start, today);
-            BuildPatternNotices(absenceDays);
+            BuildTrend(absenceDaysYear, trendDays);
+            BuildPatternNotices(weekAbsenceDays);
            LastUpdatedLabel = $"Zuletzt aktualisiert: Heute, {DateTime.Now:HH:mm}";
            Status = $"{StudentCount} Schüler*innen · {TodayAlertCount} heute auffällig";
            ApplyRosterFilter();
@@ -266,21 +329,50 @@ public partial class ClassTeacherOverviewViewModel : ObservableObject
        NotifyRosterState();
    }

-    private void BuildTrend(IReadOnlyList<ClassAbsenceDaySummaryRow> absenceDays, DateOnly start, DateOnly end)
+    /// Letzte <paramref name="days"/> statt letzte 7 Kalendertage (Nutzer-Feedback: an zwei von
+    /// sieben Tagen war der Trend bislang systematisch leer, weil Wochenenden mitzählten). Ohne
+    /// Ferienkalender — siehe <see cref="LastSchoolDays"/>.
+    private void BuildTrend(IReadOnlyList<ClassAbsenceDaySummaryRow> absenceDays, IReadOnlyList<DateOnly> days)
    {
-        var counts = Enumerable.Range(0, 7).Select(offset => start.AddDays(offset)).Select(date =>
+        var today = days[^1];
+        var counts = days.Select(date =>
        {
            var rows = absenceDays.Where(r => r.Date == date).ToList();
-            return (Date: date, Alerts: rows.Count,
-                Unexcused: rows.Count(r => r.Statuses.Any(s => s.Contains("nicht entsch", StringComparison.OrdinalIgnoreCase))),
-                Late: rows.Count(r => r.TotalAbsentPeriods == 0 || r.AbsenceReasons.Any(a =>
-                    a.Contains("verspät", StringComparison.OrdinalIgnoreCase))));
+            var unexcused = rows.Count(r => r.IsUnexcused);
+            var lateExcused = rows.Count(r => !r.IsUnexcused && r.IsLate);
+            var excused = rows.Count(r => !r.IsUnexcused && !r.IsLate);
+            return (Date: date, Unexcused: unexcused, LateExcused: lateExcused, Excused: excused,
+                Total: unexcused + lateExcused + excused);
        }).ToList();
-        var max = Math.Max(1, counts.Max(c => c.Alerts));
+        var max = Math.Max(1, counts.Max(c => c.Total));
        foreach (var day in counts)
-            TrendDays.Add(new ClassTeacherTrendDay(day.Date == end ? "Heute" : day.Date.ToString("ddd"),
-                day.Alerts, day.Unexcused, day.Late,
-                112d * day.Alerts / max, 112d * day.Unexcused / max, 112d * day.Late / max));
+            TrendDays.Add(new ClassTeacherTrendDay(day.Date == today ? "Heute" : day.Date.ToString("ddd"),
+                day.Total, day.Unexcused, day.LateExcused, day.Excused,
+                112d * day.Unexcused / max, 112d * day.LateExcused / max, 112d * day.Excused / max));
+    }
+
+    /// Letzte <paramref name="count"/> Werktage bis einschließlich <paramref name="end"/>, ohne
+    /// Ferienkalender (bewusste Vereinfachung, siehe TODO.md 12.4-Nachtrag) — die App kennt keine
+    /// Schulferien, nur Wochenenden.
+    private static IReadOnlyList<DateOnly> LastSchoolDays(DateOnly end, int count)
+    {
+        var days = new List<DateOnly>();
+        for (var cursor = end; days.Count < count; cursor = cursor.AddDays(-1))
+            if (cursor.DayOfWeek is not (DayOfWeek.Saturday or DayOfWeek.Sunday))
+                days.Add(cursor);
+        days.Reverse();
+        return days;
+    }
+
+    /// Nenner für <see cref="ClassTeacherRosterRow.YearAbsenceRatePercent"/> — Werktage zwischen
+    /// Schuljahresbeginn und heute, ebenfalls ohne Ferienkalender.
+    private static int CountWeekdays(DateOnly start, DateOnly end)
+    {
+        if (end < start) return 0;
+        var count = 0;
+        for (var d = start; d <= end; d = d.AddDays(1))
+            if (d.DayOfWeek is not (DayOfWeek.Saturday or DayOfWeek.Sunday)) count++;
+        return count;
    }

    private void BuildPatternNotices(IReadOnlyList<ClassAbsenceDaySummaryRow> absenceDays)
@@ -294,10 +386,10 @@ public partial class ClassTeacherOverviewViewModel : ObservableObject
            var unexcusedDays = rows.Count(row => row.IsUnexcused && !row.IsLate);
            if (unexcusedDays >= 2)
                PatternNotices.Add(new ClassTeacherPatternNotice(displayName,
-                    $"{unexcusedDays} unentschuldigte Fehltage in 7 Tagen", "#FF5A67"));
+                    $"{unexcusedDays} unentschuldigte Fehltage in 7 Tagen", ClassTeacherStatusKind.Danger));
            else if (lateDays >= 2)
                PatternNotices.Add(new ClassTeacherPatternNotice(displayName,
-                    $"{lateDays}-mal verspätet in 7 Tagen", "#F59E0B"));
+                    $"{lateDays}-mal verspätet in 7 Tagen", ClassTeacherStatusKind.Warning));
        }
        OnPropertyChanged(nameof(HasPatternNotices));
    }