Add warning detail popup and quick blocks for Vorgänge
CI / build-and-test (push) Canceled after 0s

Dashboard warnings (attendance, homework, lateness) get a "Details" flyout
with key figures, a list of dates and the compact month calendar from the
class teacher overview, now extracted as a shared control. The calendar
now aligns days under their weekday (Mo-So header, blank leading cells).

Creating Vorgänge and documentation is supported by quick blocks with the
current figures, dated standard phrases (e.g. "Klassenleitung informiert")
and documentation templates (status snapshot, conversation, informing the
class/subject teachers, parent call, parent letter). The class teacher
Vorgänge tab uses WebUntis figures (absences across all subjects, class
register) for the same blocks and templates.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
adminandClaude Opus 5.5 committed 2026-09-26 11:16:13 +02:00
1 parent 0f6cadc9c8
commit aa326cf8b6
25 files changed
+1571 -75

No files matched your search

@@ -0,0 +1,105 @@
using System.Text;
using LehrerApp.Core.Models;
using LehrerApp.Desktop.ViewModels.Students;
namespace LehrerApp.Desktop.ViewModels.ClassTeacher;
/// <summary>
/// WebUntis-Stand einer/eines Schüler*in der eigenen Klasse für Schnellbausteine und Vorlagen im
/// Klassenlehrer-"Vorgänge"-Tab — Gegenstück zu StudentWarningEvidence im Schülerdetail. Dort zählen
/// nur die lokal erfassten Mitarbeits-Einträge der eigenen Stunden; die Klassenleitung braucht
/// dagegen die Fehlzeiten über alle Fächer und die Klassenbucheinträge der Kolleg*innen, die
/// WebUntis ohnehin liefert (und <see cref="Services.UntisReportCacheService"/> für das laufende
/// Schuljahr bereits gecacht hat). Rein aus schon geladenen Zeilen berechnet, testbar ohne Untis.
/// </summary>
/// <param name="NaturalName">"Vorname Nachname" aus dem lokalen Schülerdatensatz — der Untis-Anzeigename
/// hat je nach Schule eine andere Reihenfolge und taugt nicht für eine Briefanrede.</param>
public sealed record ClassTeacherStudentFacts(StudentOption Student, string NaturalName, string SchoolYear, DateOnly AsOf,
IReadOnlyList<ClassAbsenceDaySummaryRow> AbsenceDays, IReadOnlyList<ClassAbsenceDaySummaryRow> LateDays,
IReadOnlyList<ClassTeacherClassRegisterRow> RegisterEntries)
{
public const int MaxListed = 15;
public int AbsentPeriods => AbsenceDays.Sum(d => d.TotalAbsentPeriods);
public int FullDays => AbsenceDays.Count(d => d.CountsAsFullDay);
public int UnexcusedDays => AbsenceDays.Count(d => d.IsUnexcused);
public int NegativeRegisterCount => RegisterEntries.Count(r => r.IsDangerStatus);
public IReadOnlyList<ClassTeacherClassRegisterRow> HomeworkEntries => RegisterEntries
.Where(r => ($"{r.CategoryName} {r.Text}").Contains("Hausauf", StringComparison.OrdinalIgnoreCase)).ToList();
private string Stand => $"WebUntis-Stand {AsOf:dd.MM.yyyy}";
public string AbsenceShort =>
$"{AbsentPeriods} Fehlstunde{(AbsentPeriods == 1 ? "" : "n")} an {AbsenceDays.Count} Tag{(AbsenceDays.Count == 1 ? "" : "en")} " +
$"im Schuljahr {SchoolYear} (davon {UnexcusedDays} Tag{(UnexcusedDays == 1 ? "" : "e")} unentschuldigt, " +
$"{FullDays} ganze Fehltag{(FullDays == 1 ? "" : "e")})";
public string LatenessShort => $"{LateDays.Count} Verspätung{(LateDays.Count == 1 ? "" : "en")} im Schuljahr {SchoolYear}";
public string RegisterShort =>
$"{RegisterEntries.Count} Klassenbucheintr{(RegisterEntries.Count == 1 ? "ag" : "äge")} im Schuljahr {SchoolYear}, davon {NegativeRegisterCount} negativ";
public string HomeworkShort => $"{HomeworkEntries.Count} Klassenbucheintr{(HomeworkEntries.Count == 1 ? "ag" : "äge")} zu Hausaufgaben im Schuljahr {SchoolYear}";
public string AbsenceBlock => $"{Stand}: {AbsenceShort}.\n" + List("Fehltage", AbsenceDays.Select(d =>
$"{d.DateLabel}: {d.KindLabel} · {d.FriendlyStatusLabel}" +
(string.IsNullOrWhiteSpace(d.DetailLabel) ? "" : $" · {d.DetailLabel}")).ToList());
public string LatenessBlock => $"{Stand}: {LatenessShort}.\n" + List("Termine", LateDays.Select(d =>
$"{d.DateLabel}: {d.KindLabel}").ToList());
public string RegisterBlock => $"{Stand}: {RegisterShort}.\n" + List("Einträge", RegisterEntries.Select(RegisterLine).ToList());
public string HomeworkBlock => $"{Stand}: {HomeworkShort}.\n" + List("Einträge", HomeworkEntries.Select(RegisterLine).ToList());
private static string RegisterLine(ClassTeacherClassRegisterRow r) =>
$"{r.DateLabel}" + (string.IsNullOrWhiteSpace(r.Subject) ? "" : $" · {r.Subject}") + ": " +
string.Join(" – ", new[] { r.CategoryName, r.Text }.Where(v => !string.IsNullOrWhiteSpace(v)));
private static string List(string header, IReadOnlyList<string> lines)
{
var sb = new StringBuilder($"{header}:");
foreach (var line in lines.Take(MaxListed)) sb.Append("\n- ").Append(line);
if (lines.Count > MaxListed) sb.Append($"\n- … und {lines.Count - MaxListed} weitere");
return sb.ToString();
}
/// Nur Bausteine mit Inhalt. Mit <paramref name="withName"/> (mehrere Beteiligte ausgewählt)
/// tragen Label und Text den Namen, sonst wäre unklar, wessen Zahlen gerade eingefügt werden.
public IEnumerable<VorgangQuickBlock> QuickBlocks(bool withName)
{
string L(string label) => withName ? $"{label} · {Student.Name}" : label;
string T(string text) => withName ? $"{Student.Name} – {text}" : text;
if (AbsenceDays.Count > 0) yield return new(L("Fehlzeiten"), T(AbsenceBlock));
if (LateDays.Count > 0) yield return new(L("Verspätungen"), T(LatenessBlock));
if (HomeworkEntries.Count > 0) yield return new(L("Hausaufgaben (Klassenbuch)"), T(HomeworkBlock));
if (RegisterEntries.Count > 0) yield return new(L("Klassenbucheinträge"), T(RegisterBlock));
}
/// Anlass-Zeilen passend zu den Vorgangs-Tags; ohne passendes Tag (z.B. "Konflikte") dienen die
/// negativen Klassenbucheinträge als Anlass, sofern vorhanden.
public VorgangTemplateContext TemplateContext(Vorgang vorgang)
{
var lines = new List<string>();
foreach (var tag in vorgang.Tags.Select(t => t.ToLowerInvariant()).Distinct())
{
if (tag == "absentismus" && AbsenceDays.Count > 0) lines.Add(AbsenceShort);
if (tag == "verspätungen" && LateDays.Count > 0) lines.Add(LatenessShort);
if (tag == "hausaufgaben" && HomeworkEntries.Count > 0) lines.Add(HomeworkShort);
}
if (lines.Count == 0 && NegativeRegisterCount > 0) lines.Add(RegisterShort);
return new VorgangTemplateContext(Student.Id, NaturalName, AsOf, lines,
new Dictionary<string, VorgangSnapshot>
{
[VorgangDocumentationTemplates.UntisAbsenceStatus] = new($"Fehlzeiten-Stand (WebUntis) {AsOf:dd.MM.yyyy}", AbsenceBlock),
[VorgangDocumentationTemplates.LatenessStatus] = new($"Verspätungs-Stand (WebUntis) {AsOf:dd.MM.yyyy}", LatenessBlock),
[VorgangDocumentationTemplates.ClassRegisterStatus] = new($"Klassenbuch-Stand {AsOf:dd.MM.yyyy}", RegisterBlock),
});
}
public static ClassTeacherStudentFacts Build(StudentOption student, string naturalName, string schoolYear, DateOnly asOf,
IReadOnlyList<ClassAbsenceDaySummaryRow> classAbsenceDays, IReadOnlyList<ClassTeacherClassRegisterRow> classRegister)
{
var own = classAbsenceDays.Where(a => UntisNameMatching.NamesMatch(a.StudentName, student.Name))
.OrderByDescending(a => a.Date).ToList();
var register = classRegister.Where(r => UntisNameMatching.NamesMatch(r.StudentName, student.Name))
.OrderByDescending(r => r.Date).ToList();
return new ClassTeacherStudentFacts(student, naturalName, schoolYear, asOf,
own.Where(a => !a.IsLate).ToList(), own.Where(a => a.IsLate).ToList(), register);
}
}
@@ -3,6 +3,7 @@ using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;
using LehrerApp.Core.Interfaces;
using LehrerApp.Core.Models;
using LehrerApp.Core.Services;
using LehrerApp.Desktop.Services;
using LehrerApp.Desktop.ViewModels.Students;
@@ -26,6 +27,10 @@ public partial class ClassTeacherCasesViewModel : ObservableObject
private string _className = "";
private List<StudentOption> _rosterStudentOptions = [];
// WebUntis-Stand je Schüler*in für Schnellbausteine/Vorlagen (ClassTeacherStudentFacts) — erst
// beim Öffnen eines Dialogs geladen (EnsureFactsAsync), nicht bei jedem Neuladen der Liste.
private Dictionary<Guid, ClassTeacherStudentFacts> _facts = [];
private Guid? _documentationDraftId;
public ObservableCollection<VorgangItem> Cases { get; } = [];
@@ -98,7 +103,10 @@ public partial class ClassTeacherCasesViewModel : ObservableObject
.Where(n => n != "");
var item = new VorgangItem(vorgang, string.Join(", ", names), LinkDocumentation,
UnlinkDocumentation, RemoveClassRegisterEntry, EditDocumentation)
{ IsRevealed = revealedIds.Contains(vorgang.Id) };
{
IsRevealed = revealedIds.Contains(vorgang.Id),
OnCreateFromTemplate = CreateDocumentationFromTemplate,
};
var linkedIds = vorgang.DocumentationIds.ToHashSet();
foreach (var doc in allDocs.Where(d => linkedIds.Contains(d.Id)))
@@ -117,10 +125,83 @@ public partial class ClassTeacherCasesViewModel : ObservableObject
private void NotifyState() => OnPropertyChanged(nameof(HasCases));
/// Lädt Fehlzeiten und Klassenbucheinträge des laufenden Schuljahres (aus dem Untis-Cache, der
/// kalte Bereich ist dort dauerhaft gespeichert) und leitet daraus den Stand je Schüler*in ab.
/// Scheitert der Abruf (offline, Sitzung abgelaufen), gibt es eben nur die Standardformulierungen
/// statt eines Fehlers — der Dialog selbst soll davon nicht abhängen.
private async Task EnsureFactsAsync()
{
try
{
var sy = new SchoolYearService();
var schoolYear = sy.CurrentSchoolYear();
var today = DateOnly.FromDateTime(DateTime.Today);
var start = sy.SchoolYearStart(schoolYear);
var absencesTask = _cache.GetAbsencesAsync(_className, start, today);
var registerTask = _cache.GetClassRegisterEventsAsync(_className, start, today);
await Task.WhenAll(absencesTask, registerTask);
var absenceDays = ClassAbsenceDaySummaryRow.GroupByStudentAndDay(absencesTask.Result);
var register = registerTask.Result
.Select(e => (Entry: e, Valid: DateOnly.TryParseExact(e.Date.ToString(), "yyyyMMdd", out var d), Date: d))
.Where(x => x.Valid)
.Select(x => new ClassTeacherClassRegisterRow(x.Date, x.Entry.Subject, x.Entry.StudentName,
x.Entry.TeacherUsername, x.Entry.CategoryName, x.Entry.CategoryGroup, x.Entry.Text))
.ToList();
_facts = _rosterStudentOptions.ToDictionary(o => o.Id, o => ClassTeacherStudentFacts.Build(o,
NaturalName(o), schoolYear, today, absenceDays, register));
}
catch (Exception)
{
// Bewusst still: ohne WebUntis fehlen nur die Zahlen-Bausteine, Standardformulierungen
// und Vorlagen (dann ohne Zahlen) bleiben nutzbar.
_facts = [];
}
}
private string NaturalName(StudentOption option) =>
_students.GetById(option.Id) is { } s ? $"{s.FirstName} {s.LastName}".Trim() : option.Name;
/// Schnellbausteine für die aktuell im Dialog ausgewählten Schüler*innen — bei mehreren mit Namen.
public IReadOnlyList<VorgangQuickBlock> QuickBlocksFor(IReadOnlyList<Guid> studentIds) => studentIds
.Where(_facts.ContainsKey)
.SelectMany(id => _facts[id].QuickBlocks(withName: studentIds.Count > 1))
.ToList();
public bool IsNewDocumentationDraft(Documentation doc) => doc.Id == _documentationDraftId;
/// Vorlagen beziehen sich auf die/den erste/n Beteiligte/n des Vorgangs (Dokumentation gehört immer
/// zu genau einer Person) — der Dialog bietet deshalb auch nur diese Person an, sonst passten die
/// eingesetzten Zahlen nicht mehr zur gewählten Person.
private async Task CreateDocumentationFromTemplate(VorgangItem item, string key)
{
if (OnEditDocumentation is null) return;
var option = _rosterStudentOptions.FirstOrDefault(o => item.Model.StudentIds.Contains(o.Id));
if (option is null) return;
await EnsureFactsAsync();
var context = _facts.TryGetValue(option.Id, out var facts)
? facts.TemplateContext(item.Model)
: new VorgangTemplateContext(option.Id, NaturalName(option), DateOnly.FromDateTime(DateTime.Today), [],
new Dictionary<string, VorgangSnapshot>());
var draft = VorgangDocumentationTemplates.Build(key, item.Model, context);
if (draft is null) return;
_documentationDraftId = draft.Id;
Documentation? result;
try { result = await OnEditDocumentation(option.Id, [option], draft); }
finally { _documentationDraftId = null; }
if (result is null) return;
_documentation.Save(result);
item.Model.DocumentationIds.Add(result.Id);
_vorgaenge.Save(item.Model);
await LoadInternal();
}
[RelayCommand]
private async Task AddVorgang()
{
if (OnEditVorgang is null) return;
await EnsureFactsAsync();
var result = await OnEditVorgang(_rosterStudentOptions, null);
if (result is null) return;
_vorgaenge.Save(result);
@@ -131,6 +212,7 @@ public partial class ClassTeacherCasesViewModel : ObservableObject
private async Task EditVorgang(VorgangItem? item)
{
if (item is null || OnEditVorgang is null) return;
await EnsureFactsAsync();
var result = await OnEditVorgang(_rosterStudentOptions, item.Model);
if (result is null) return;
_vorgaenge.Save(result);
@@ -94,6 +94,19 @@ public partial class VorgangItem : ObservableObject
[RelayCommand] private void Reveal() => IsRevealed = !IsRevealed;
/// Nutzer-Feedback: standardisierte Dokumentationseinträge statt alles von Hand — nur im
/// schülerbezogenen Vorgänge-Tab gesetzt (StudentVorgaengeViewModel), der Parameter ist ein
/// Schlüssel aus VorgangDocumentationTemplates. Eigener Command je Item statt $parent-Bindung,
/// weil die Auswahl in einem MenuFlyout-Popup liegt, das nicht im normalen visuellen Baum hängt.
public Func<VorgangItem, string, Task>? OnCreateFromTemplate { get; set; }
public bool HasDocumentationTemplates => OnCreateFromTemplate is not null;
[RelayCommand]
private async Task CreateFromTemplate(string? key)
{
if (key is not null && OnCreateFromTemplate is not null) await OnCreateFromTemplate(this, key);
}
/// Öffnet den vollen Dokumentations-Dialog zum Nachlesen/Bearbeiten, ohne den Vorgänge-Tab zu
/// verlassen (Nutzer-Feedback: bisher musste man dafür in den Schülerdatensatz wechseln).
[RelayCommand]
@@ -138,12 +151,35 @@ public partial class VorgangDialogViewModel : ObservableObject
[ObservableProperty] private string _titleError = "";
[ObservableProperty] private string _studentsError = "";
public string DialogTitle => _editing is null ? "Vorgang anlegen" : "Vorgang bearbeiten";
private readonly bool _isNewDraft;
public string DialogTitle => _editing is null || _isNewDraft ? "Vorgang anlegen" : "Vorgang bearbeiten";
public Vorgang? Result { get; private set; }
public VorgangDialogViewModel(List<StudentOption> rosterStudents, Vorgang? editing)
/// Per Klick in die Beschreibung einfügbare Textbausteine mit dem aktuellen Stand (Fehlquote,
/// Fehltermine, WebUntis-Fehlzeiten, …). Setzt sich aus festen Bausteinen (Schülerdetail) und —
/// im Klassenlehrer-Tab mit Mehrfachauswahl — aus Bausteinen je ausgewählter/m Schüler*in
/// zusammen, die bei jeder Änderung der Auswahl neu berechnet werden.
public ObservableCollection<VorgangQuickBlock> QuickBlocks { get; } = [];
public bool HasQuickBlocks => QuickBlocks.Count > 0;
/// Datumsgestempelte Standardformulierungen ("Klassenleitung informiert", …), siehe VorgangPhraseBlocks.
public IReadOnlyList<VorgangQuickBlock> PhraseBlocks { get; }
public bool HasPhraseBlocks => PhraseBlocks.Count > 0;
private readonly IReadOnlyList<VorgangQuickBlock> _fixedQuickBlocks;
private readonly Func<IReadOnlyList<Guid>, IReadOnlyList<VorgangQuickBlock>>? _studentQuickBlocks;
/// <param name="isNewDraft">editing ist ein noch nicht gespeicherter, vorbefüllter Entwurf (z.B.
/// aus einer Dashboard-Warnung) — Titel "anlegen" statt "bearbeiten".</param>
public VorgangDialogViewModel(List<StudentOption> rosterStudents, Vorgang? editing,
IReadOnlyList<VorgangQuickBlock>? quickBlocks = null, bool isNewDraft = false,
IReadOnlyList<VorgangQuickBlock>? phraseBlocks = null,
Func<IReadOnlyList<Guid>, IReadOnlyList<VorgangQuickBlock>>? studentQuickBlocks = null)
{
_editing = editing;
_isNewDraft = isNewDraft;
_fixedQuickBlocks = quickBlocks ?? [];
_studentQuickBlocks = studentQuickBlocks;
PhraseBlocks = phraseBlocks ?? [];
// Bei genau einem Kandidaten (z.B. der schülerbezogene Vorgänge-Tab im Schülerdetail) und
// einem neuen Vorgang ist ohnehin nur eine Auswahl möglich — Nutzer-Feedback: der sonst
// nötige Extra-Klick auf die einzige Checkbox ist unnötige Reibung.
@@ -153,6 +189,13 @@ public partial class VorgangDialogViewModel : ObservableObject
IsSelected = editing?.StudentIds.Contains(s.Id) == true
|| (editing is null && rosterStudents.Count == 1),
}));
if (_studentQuickBlocks is not null)
foreach (var option in StudentOptions)
option.PropertyChanged += (_, e) =>
{
if (e.PropertyName == nameof(VorgangStudentOption.IsSelected)) RebuildQuickBlocks();
};
RebuildQuickBlocks();
if (editing is null) return;
Title = editing.Title;
@@ -171,6 +214,36 @@ public partial class VorgangDialogViewModel : ObservableObject
[RelayCommand] private void RemoveTag(string? tag) { if (tag is not null) Tags.Remove(tag); }
/// Hängt den Baustein als eigenen Absatz an — nie überschreiben, damit bereits Getipptes bleibt.
[RelayCommand]
private void InsertQuickBlock(VorgangQuickBlock? block)
{
if (block is null) return;
var current = (Description ?? "").TrimEnd();
Description = current.Length == 0 ? block.Text : current + "\n\n" + block.Text;
}
/// Standardformulierungen sind Verlaufsnotizen — eine Zeile, kein eigener Absatz.
[RelayCommand]
private void InsertPhrase(VorgangQuickBlock? block)
{
if (block is null) return;
var current = (Description ?? "").TrimEnd();
Description = current.Length == 0 ? block.Text : current + "\n" + block.Text;
}
private void RebuildQuickBlocks()
{
QuickBlocks.Clear();
foreach (var block in _fixedQuickBlocks) QuickBlocks.Add(block);
if (_studentQuickBlocks is not null)
{
var selected = StudentOptions.Where(o => o.IsSelected).Select(o => o.StudentId).ToList();
foreach (var block in _studentQuickBlocks(selected)) QuickBlocks.Add(block);
}
OnPropertyChanged(nameof(HasQuickBlocks));
}
[RelayCommand]
private void Save()
{