Zurückgestellte Dashboard-Warnungen in eigener Gruppe sammeln
CI / build-and-test (push) Canceled after 0s

Entschärfte Warnungen (zurückgestellt oder Vorgang in Bearbeitung) liefen
bisher grau am Ende ihrer Art-Gruppe mit und zählten weiter zu den offenen
Punkten. Sie stehen jetzt in einer eingeklappten "Zurückgestellt"-Gruppe
ganz unten, mit dem Grund als Untertitel, und zählen nicht mehr mit. Nach
Fristablauf kehren sie automatisch in ihre Gruppe und die Zählung zurück.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
adminandClaude Opus 5.5 committed 2026-09-28 09:20:16 +02:00
1 parent 7d8deaf79c
commit 770a1833c8
5 files changed
+184 -47

No files matched your search

@@ -66,8 +66,8 @@ public partial class DashboardViewModel : ObservableObject
/// (alle Gruppen) wird gewarnt.
private const int LatenessWarningThreshold = 8;
/// Nutzer-Feedback: eine Warnung, zu der bereits ein offener Vorgang mit passendem Tag existiert
/// ODER die manuell zurückgestellt wurde, erscheint "entschärft" (grau, ans Ende der Gruppe
/// einsortiert) statt weiter rot hervorgehoben — aber nur befristet: bessert sich die zugrunde
/// ODER die manuell zurückgestellt wurde, erscheint "entschärft" (grau, in der eingeklappten
/// "Zurückgestellt"-Gruppe, nicht mitgezählt) statt weiter rot hervorgehoben — aber nur befristet: bessert sich die zugrunde
/// liegende Zahl innerhalb dieser Frist nicht, soll die Warnung wieder auffallen, statt durch
/// einen dauerhaft offenen Vorgang für immer entschärft zu bleiben. Für den Vorgang-Fall zählt
/// dessen UpdatedAt (jede Interaktion setzt die Frist zurück); für "Zurückstellen" wählt die
@@ -194,9 +194,16 @@ public partial class DashboardViewModel : ObservableObject
public int TodayLessonCount => TodaysLessons.Count;
public int OpenTaskCount => OpenTasks.Count;
public int UpcomingCount => UpcomingDates.Count;
public int AttentionCount => _excuses.Count + _attendanceItems.Count + _supportItems.Count
/// Zurückgestellte/entschärfte Warnungen zählen bewusst nicht mit (Nutzer-Feedback) — sie stehen
/// eingeklappt in der eigenen "Zurückgestellt"-Gruppe, bis ihre Frist abläuft.
public int AttentionCount => _excuses.Count + _supportItems.Count
+ _correctionItems.Count + _unplannedItems.Count + _alertItems.Count + _missingTimeItems.Count
+ _missingHomeworkItems.Count + _latenessItems.Count;
+ CrossClassWarnings.Count(i => !i.IsDefused);
/// Steuert den Hinweis "Keine offenen Punkte." — die eingeklappte "Zurückgestellt"-Gruppe allein
/// gilt nicht als offener Punkt.
public bool HasOpenAttention => Attention.Any(g => !g.IsDeferred);
private IEnumerable<AttentionItem> CrossClassWarnings =>
_attendanceItems.Concat(_latenessItems).Concat(_missingHomeworkItems);
public string TodayLessonSummary => TodayLessonCount == 1 ? "1 Stunde" : $"{TodayLessonCount} Stunden";
public string OpenTaskSummary => OpenTaskCount == 1 ? "1 Aufgabe" : $"{OpenTaskCount} Aufgaben";
public string AttentionSummary => AttentionCount == 1 ? "1 offener Punkt" : $"{AttentionCount} offene Punkte";
@@ -350,7 +357,9 @@ public partial class DashboardViewModel : ObservableObject
UpcomingCard.IsEmpty = UpcomingDates.Count == 0;
ExamLoadCard.IsEmpty = ExamWeekLoads.Count == 0;
GroupsCard.IsEmpty = CurrentGroups.Count == 0;
AttentionCard.IsEmpty = AttentionCount == 0;
// Nicht über AttentionCount: die Kachel muss auch dann stehen bleiben, wenn nur noch
// zurückgestellte Warnungen übrig sind, sonst wären diese bis zum Fristablauf unerreichbar.
AttentionCard.IsEmpty = AttentionCount == 0 && !CrossClassWarnings.Any();
// Erst nachdem alle IsEmpty-Werte stehen: welche Kachel tatsaechlich gerendert wird, haengt
// ueber EffectiveIsVisible daran, und davon wiederum die Zeilen-/Spaltenzuordnung.
@@ -427,8 +436,8 @@ public partial class DashboardViewModel : ObservableObject
// ── Entschärfen (Nutzer-Feedback) ─────────────────────────────────────────
//
// Eine der drei klassenübergreifenden Warnungen gilt als "entschärft" (grau, ans Ende ihrer
// Gruppe sortiert), solange entweder ein offener Vorgang mit passendem Tag kürzlich bearbeitet
// Eine der drei klassenübergreifenden Warnungen gilt als "entschärft" (grau, in der
// eingeklappten "Zurückgestellt"-Gruppe, siehe RebuildAttention), solange entweder ein offener Vorgang mit passendem Tag kürzlich bearbeitet
// wurde, oder eine manuelle Rückstellung noch läuft — beides zeitlich befristet (siehe
// VorgangDefusalGraceDays-Kommentar), damit ausbleibende Besserung nach Fristablauf wieder
// auffällt statt dauerhaft entschärft zu bleiben. Beide Nachschlage-Mengen bulk-geladen wie
@@ -451,15 +460,24 @@ public partial class DashboardViewModel : ObservableObject
return set;
}
private HashSet<(Guid StudentId, string Tag)> BuildActiveSnoozeSet(DateOnly today) =>
// Bei doppelten Einträgen für dasselbe Paar (z.B. Altbestand vor der abgeleiteten Id) zählt die
// längste noch laufende Frist.
private Dictionary<(Guid StudentId, string Tag), DateOnly> BuildActiveSnoozeSet(DateOnly today) =>
_warningSnoozes.GetAll().Where(s => s.SnoozedUntil >= today)
.Select(s => (s.StudentId, s.WarningTag.ToLowerInvariant())).ToHashSet();
.GroupBy(s => (s.StudentId, s.WarningTag.ToLowerInvariant()))
.ToDictionary(g => g.Key, g => g.Max(s => s.SnoozedUntil));
private static bool IsDefused(Guid studentId, string tag,
HashSet<(Guid StudentId, string Tag)> recentVorgaenge, HashSet<(Guid StudentId, string Tag)> activeSnoozes)
/// Grund, warum eine Warnung entschärft ist, als Untertitel für die "Zurückgestellt"-Gruppe
/// (dort stehen alle drei Warnarten gemischt, deshalb mit Art-Präfix) — null, wenn sie scharf ist.
/// Eine manuelle Rückstellung hat Vorrang, weil sie ein konkretes Ablaufdatum nennen kann.
private static string? DefusalReason(Guid studentId, string tag, string kindLabel,
HashSet<(Guid StudentId, string Tag)> recentVorgaenge,
Dictionary<(Guid StudentId, string Tag), DateOnly> activeSnoozes)
{
var key = (studentId, tag.ToLowerInvariant());
return recentVorgaenge.Contains(key) || activeSnoozes.Contains(key);
if (activeSnoozes.TryGetValue(key, out var until))
return $"{kindLabel} · zurückgestellt bis {until:dd.MM.}";
return recentVorgaenge.Contains(key) ? $"{kindLabel} · Vorgang in Bearbeitung" : null;
}
/// Von der "Zurückstellen"-Aktion einer Warnung aufgerufen (siehe ToAttentionItem-Überladungen
@@ -514,15 +532,15 @@ public partial class DashboardViewModel : ObservableObject
items.Add(new AttendanceWarningItem(student.Id, student.FullName, balance.AbsenceRatePercent));
}
var ordered = items
.Select(i => (Item: i, Defused: IsDefused(i.StudentId, AbsentismusTag, recentVorgaenge, activeSnoozes)))
.OrderBy(x => x.Defused).ThenByDescending(x => x.Item.AbsenceRatePercent);
.Select(i => (Item: i, Defused: DefusalReason(i.StudentId, AbsentismusTag, "Fehlzeiten", recentVorgaenge, activeSnoozes)))
.OrderByDescending(x => x.Item.AbsenceRatePercent);
foreach (var (item, defused) in ordered)
_attendanceItems.Add(ToAttentionItem(item, defused));
}
private AttentionItem ToAttentionItem(AttendanceWarningItem w, bool isDefused) => new(
private AttentionItem ToAttentionItem(AttendanceWarningItem w, string? defusedReason) => new(
AttentionKind.Attendance, w.StudentName, trailingText: $"{w.AbsenceRatePercent:0.#} %",
isWarningTrailing: true, isDefused: isDefused,
subtitle: defusedReason ?? "", isWarningTrailing: true, isDefused: defusedReason is not null,
actions: [SnoozeAction(w.StudentId, AbsentismusTag, $"Fehlzeiten – {w.StudentName}")],
navigate: () => OnNavigateToStudentCase?.Invoke(w.StudentId, AbsentismusTag, "Fehlzeiten"),
detailFactory: () => new StudentWarningDetailViewModel(AttentionKind.Attendance, _evidence.Build(w.StudentId)));
@@ -549,15 +567,15 @@ public partial class DashboardViewModel : ObservableObject
items.Add(new MissingHomeworkWarningItem(student.Id, student.FullName, count));
}
var ordered = items
.Select(i => (Item: i, Defused: IsDefused(i.StudentId, HausaufgabenTag, recentVorgaenge, activeSnoozes)))
.OrderBy(x => x.Defused).ThenByDescending(x => x.Item.MissingCount);
.Select(i => (Item: i, Defused: DefusalReason(i.StudentId, HausaufgabenTag, "Hausaufgaben", recentVorgaenge, activeSnoozes)))
.OrderByDescending(x => x.Item.MissingCount);
foreach (var (item, defused) in ordered)
_missingHomeworkItems.Add(ToAttentionItem(item, defused));
}
private AttentionItem ToAttentionItem(MissingHomeworkWarningItem w, bool isDefused) => new(
private AttentionItem ToAttentionItem(MissingHomeworkWarningItem w, string? defusedReason) => new(
AttentionKind.MissingHomework, w.StudentName, trailingText: $"{w.MissingCount} offen",
isWarningTrailing: true, isDefused: isDefused,
subtitle: defusedReason ?? "", isWarningTrailing: true, isDefused: defusedReason is not null,
actions: [SnoozeAction(w.StudentId, HausaufgabenTag, $"Hausaufgaben – {w.StudentName}")],
navigate: () => OnNavigateToStudentCase?.Invoke(w.StudentId, HausaufgabenTag, "Hausaufgaben"),
detailFactory: () => new StudentWarningDetailViewModel(AttentionKind.MissingHomework, _evidence.Build(w.StudentId)));
@@ -588,15 +606,15 @@ public partial class DashboardViewModel : ObservableObject
items.Add(new LatenessWarningItem(student.Id, student.FullName, count));
}
var ordered = items
.Select(i => (Item: i, Defused: IsDefused(i.StudentId, VerspaetungenTag, recentVorgaenge, activeSnoozes)))
.OrderBy(x => x.Defused).ThenByDescending(x => x.Item.LateCount);
.Select(i => (Item: i, Defused: DefusalReason(i.StudentId, VerspaetungenTag, "Verspätungen", recentVorgaenge, activeSnoozes)))
.OrderByDescending(x => x.Item.LateCount);
foreach (var (item, defused) in ordered)
_latenessItems.Add(ToAttentionItem(item, defused));
}
private AttentionItem ToAttentionItem(LatenessWarningItem w, bool isDefused) => new(
private AttentionItem ToAttentionItem(LatenessWarningItem w, string? defusedReason) => new(
AttentionKind.Lateness, w.StudentName, trailingText: $"{w.LateCount}× verspätet",
isWarningTrailing: true, isDefused: isDefused,
subtitle: defusedReason ?? "", isWarningTrailing: true, isDefused: defusedReason is not null,
actions: [SnoozeAction(w.StudentId, VerspaetungenTag, $"Verspätungen – {w.StudentName}")],
navigate: () => OnNavigateToStudentCase?.Invoke(w.StudentId, VerspaetungenTag, "Verspätungen"),
detailFactory: () => new StudentWarningDetailViewModel(AttentionKind.Lateness, _evidence.Build(w.StudentId)));
@@ -958,15 +976,27 @@ public partial class DashboardViewModel : ObservableObject
};
Attention.Clear();
var deferred = new List<AttentionItem>();
foreach (var (kind, header) in AttentionGroupOrder)
{
if (!IsAttentionFilterActive(kind)) continue;
var items = byKind[kind];
var items = byKind[kind].Where(i => !i.IsDefused).ToList();
deferred.AddRange(byKind[kind].Where(i => i.IsDefused));
if (items.Count == 0) continue;
Attention.Add(new AttentionGroup(kind, header, items));
}
// Entschärfte Warnungen aller drei klassenübergreifenden Arten gesammelt ganz unten und
// eingeklappt (Nutzer-Feedback), statt grau in ihrer jeweiligen Gruppe mitzulaufen. Der
// Aufklapp-Zustand überlebt das Neuaufbauen der Gruppen (z.B. nach einem Zurückstellen).
if (deferred.Count > 0)
Attention.Add(new AttentionGroup(null, "Zurückgestellt", deferred,
isDeferred: true, isExpanded: _deferredGroupExpanded,
onExpandedChanged: expanded => _deferredGroupExpanded = expanded));
OnPropertyChanged(nameof(HasOpenAttention));
}
private bool _deferredGroupExpanded;
private static AttentionItem ToAttentionItem(OpenExcuseItem e) => new(
AttentionKind.Excuse, e.StudentName, subtitle: $"{e.GroupName} · {e.DateDisplay}",
actions: [new AttentionAction("Entschuldigt", e.MarkExcusedCommand),