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

+12 -1
View File
@@ -59,12 +59,20 @@ public sealed class AttentionItem
public bool IsDefused { get; }
public IReadOnlyList<AttentionAction> Actions { get; }
public Action? Navigate { get; }
/// <summary>Nur bei Attendance/MissingHomework/Lateness gesetzt: Inhalt des "Details"-Popups
/// (Nutzer-Feedback: im Dashboard-Eintrag mehr erfahren). Erst beim ersten Zugriff erzeugt — die
/// Flyout-Bindung greift darauf erst beim Öffnen zu, damit das Dashboard nicht für jede Warnzeile
/// vorab alle Belege sammelt.</summary>
public StudentWarningDetailViewModel? Detail => _detail ??= _detailFactory?.Invoke();
private readonly Func<StudentWarningDetailViewModel>? _detailFactory;
private StudentWarningDetailViewModel? _detail;
public AttentionItem(AttentionKind kind, string title, string subtitle = "", string trailingText = "",
string dateDisplay = "", bool isOverdue = false, AlertSeverity? severity = null,
int progressPercent = 0, string progressLabel = "", bool hasProgress = false,
bool isWarningTrailing = false, bool isDefused = false,
IReadOnlyList<AttentionAction>? actions = null, Action? navigate = null)
IReadOnlyList<AttentionAction>? actions = null, Action? navigate = null,
Func<StudentWarningDetailViewModel>? detailFactory = null)
{
Kind = kind;
Title = title;
@@ -80,12 +88,15 @@ public sealed class AttentionItem
IsDefused = isDefused;
Actions = actions ?? [];
Navigate = navigate;
_detailFactory = detailFactory;
}
public bool HasSubtitle => !string.IsNullOrWhiteSpace(Subtitle);
public bool HasTrailingText => !string.IsNullOrWhiteSpace(TrailingText);
public bool HasDate => !string.IsNullOrWhiteSpace(DateDisplay);
public bool HasActions => Actions.Count > 0;
public bool HasDetail => _detailFactory is not null;
public bool HasFooter => HasActions || HasDetail;
public bool HasSeverity => Severity is not null;
public bool IsHighSeverity => Severity == AlertSeverity.High;
public bool IsMediumSeverity => Severity == AlertSeverity.Medium;
@@ -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()
{
@@ -43,6 +43,7 @@ public partial class DashboardViewModel : ObservableObject
private readonly SchoolWeatherService? _schoolWeather;
private readonly UntisHubService _untisHub;
private readonly WebUntisIntegrationService _webUntis;
private readonly StudentWarningEvidenceService _evidence;
private readonly Func<DateTime> _now;
private const int OpenExcuseMaxAgeDays = 21;
@@ -240,6 +241,11 @@ public partial class DashboardViewModel : ObservableObject
// waeren Tests fuer "kurz vor/nach Ablauf einer Wartezeit" je nach Ausfuehrungsuhrzeit
// zufaellig rot oder gruen (siehe TODO.md, Abschnitt 9, Nachtrag Uhrzeit-Wraparound).
_now = now ?? (() => DateTime.Now);
// Bewusst hier aus den ohnehin injizierten Repositories gebaut statt als weiterer
// Konstruktor-Parameter — dieselben Datenquellen wie die Warnungen selbst, und die lange
// Parameterliste (inkl. aller Test-Aufrufer) bleibt unverändert.
_evidence = new StudentWarningEvidenceService(students, participationSessions, participationEntries,
groups, sy, attendanceBalance, _now);
if (annualPlanSync is not null)
{
annualPlanSync.DataChanged += () => Avalonia.Threading.Dispatcher.UIThread.Post(LoadCalendar);
@@ -518,7 +524,8 @@ public partial class DashboardViewModel : ObservableObject
AttentionKind.Attendance, w.StudentName, trailingText: $"{w.AbsenceRatePercent:0.#} %",
isWarningTrailing: true, isDefused: isDefused,
actions: [SnoozeAction(w.StudentId, AbsentismusTag, $"Fehlzeiten – {w.StudentName}")],
navigate: () => OnNavigateToStudentCase?.Invoke(w.StudentId, AbsentismusTag, "Fehlzeiten"));
navigate: () => OnNavigateToStudentCase?.Invoke(w.StudentId, AbsentismusTag, "Fehlzeiten"),
detailFactory: () => new StudentWarningDetailViewModel(AttentionKind.Attendance, _evidence.Build(w.StudentId)));
// ── Hausaufgaben-Warnung (Nutzer-Feedback: analog zur Fehlzeiten-Warnung, klassenübergreifend) ──
@@ -552,7 +559,8 @@ public partial class DashboardViewModel : ObservableObject
AttentionKind.MissingHomework, w.StudentName, trailingText: $"{w.MissingCount} offen",
isWarningTrailing: true, isDefused: isDefused,
actions: [SnoozeAction(w.StudentId, HausaufgabenTag, $"Hausaufgaben – {w.StudentName}")],
navigate: () => OnNavigateToStudentCase?.Invoke(w.StudentId, HausaufgabenTag, "Hausaufgaben"));
navigate: () => OnNavigateToStudentCase?.Invoke(w.StudentId, HausaufgabenTag, "Hausaufgaben"),
detailFactory: () => new StudentWarningDetailViewModel(AttentionKind.MissingHomework, _evidence.Build(w.StudentId)));
// ── Verspätungs-Warnung (Nutzer-Feedback: analog zur Fehlzeiten-Warnung, klassenübergreifend) ──
//
@@ -590,7 +598,8 @@ public partial class DashboardViewModel : ObservableObject
AttentionKind.Lateness, w.StudentName, trailingText: $"{w.LateCount}× verspätet",
isWarningTrailing: true, isDefused: isDefused,
actions: [SnoozeAction(w.StudentId, VerspaetungenTag, $"Verspätungen – {w.StudentName}")],
navigate: () => OnNavigateToStudentCase?.Invoke(w.StudentId, VerspaetungenTag, "Verspätungen"));
navigate: () => OnNavigateToStudentCase?.Invoke(w.StudentId, VerspaetungenTag, "Verspätungen"),
detailFactory: () => new StudentWarningDetailViewModel(AttentionKind.Lateness, _evidence.Build(w.StudentId)));
// ── Klausurwochen (Nutzer-Feedback) ───────────────────────────────────────
//
@@ -0,0 +1,158 @@
using System.Collections.ObjectModel;
using System.Globalization;
using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;
using LehrerApp.Desktop.Services;
using LehrerApp.Desktop.ViewModels.ClassTeacher;
namespace LehrerApp.Desktop.ViewModels;
public sealed record WarningDetailFigure(string Label, string Value);
/// <summary>
/// Inhalt des "Details"-Popups einer klassenübergreifenden Dashboard-Warnung (Nutzer-Feedback: im
/// Eintrag mehr erfahren, ohne erst ins Schülerdetail zu springen). Recycelt das Monats-Widget der
/// Klassenlehrer-Übersicht ("Monat auf einen Blick", <see cref="ClassTeacherCompactCalendarDay"/> +
/// Views/Shared/CompactMonthCalendar) — dort aus WebUntis-Daten der eigenen Klasse, hier aus den
/// lokal erfassten Mitarbeits-Einträgen aller Lerngruppen, mit denselben Kürzeln/Farben.
/// Wird erst beim Öffnen des Popups erzeugt (AttentionItem.Detail ist lazy), damit das Dashboard
/// nicht für jede Warnzeile vorab alle Belege zusammensucht.
/// </summary>
public partial class StudentWarningDetailViewModel : ObservableObject
{
private static readonly CultureInfo De = new("de-DE");
private const int MaxListedEvents = 10;
private readonly IReadOnlyList<StudentEvidenceEvent> _calendarEvents;
private readonly DateOnly _firstMonth;
private readonly DateOnly _lastMonth;
private readonly DateOnly _today;
public string Header { get; }
public string Summary { get; }
public IReadOnlyList<WarningDetailFigure> Figures { get; }
public string ListHeader { get; }
public IReadOnlyList<StudentEvidenceEvent> Events { get; }
public string MoreEventsHint { get; }
public bool HasMoreEvents => !string.IsNullOrEmpty(MoreEventsHint);
public bool HasEvents => Events.Count > 0;
public string Legend { get; }
public ObservableCollection<ClassTeacherCompactCalendarDay> CalendarDays { get; } = [];
[ObservableProperty]
[NotifyPropertyChangedFor(nameof(MonthLabel))]
[NotifyCanExecuteChangedFor(nameof(PreviousMonthCommand), nameof(NextMonthCommand))]
private DateOnly _month;
public string MonthLabel => Month.ToString("MMMM yyyy", De);
public StudentWarningDetailViewModel(AttentionKind kind, StudentWarningEvidence e)
{
var b = e.Balance;
Header = e.StudentName;
switch (kind)
{
case AttentionKind.MissingHomework:
Summary = $"{e.MissingHomework.Count} offene Hausaufgaben · Schuljahr {e.SchoolYear}";
Figures =
[
new("Nicht gemacht", e.MissingHomework.Count(x => x.Label.StartsWith("Nicht", StringComparison.Ordinal)).ToString()),
new("Teilweise", e.MissingHomework.Count(x => x.Label.StartsWith("Teilweise", StringComparison.Ordinal)).ToString()),
];
ListHeader = "Betroffene Termine";
_calendarEvents = e.MissingHomework;
Events = e.MissingHomework;
Legend = "H Hausaufgabe offen/unvollständig";
break;
case AttentionKind.Lateness:
Summary = $"{e.Lateness.Count}× verspätet · Schuljahr {e.SchoolYear}";
Figures =
[
new("Verspätet", (e.Lateness.Count - e.SignificantlyLateCount).ToString()),
new("Erheblich", e.SignificantlyLateCount.ToString()),
new("Fehlquote", $"{b.AbsenceRatePercent.ToString("0.#", De)} %"),
];
ListHeader = "Verspätungen";
_calendarEvents = [.. e.Absences, .. e.Lateness];
Events = e.Lateness;
Legend = "V verspätet · U unentsch. · A Entsch. offen · E entsch.";
break;
default:
Summary = $"Fehlquote {b.AbsenceRatePercent.ToString("0.#", De)} % · {b.TotalChecked} Stunden erfasst · Schuljahr {e.SchoolYear}";
Figures =
[
new("Entschuldigt", b.Excused.ToString()),
new("Unentschuldigt", b.Unexcused.ToString()),
new("Entsch. offen", b.ExcusePending.ToString()),
new("Verspätet", e.Lateness.Count.ToString()),
];
ListHeader = "Fehltermine";
_calendarEvents = [.. e.Absences, .. e.Lateness];
Events = e.Absences;
Legend = "U unentsch. · A Entsch. offen · E entsch. · V verspätet";
break;
}
if (Events.Count > MaxListedEvents)
{
MoreEventsHint = $"… und {Events.Count - MaxListedEvents} weitere";
Events = Events.Take(MaxListedEvents).ToList();
}
else MoreEventsHint = "";
_firstMonth = FirstOfMonth(e.From);
_lastMonth = FirstOfMonth(e.AsOf < e.To ? e.AsOf : e.To);
if (_lastMonth < _firstMonth) _lastMonth = _firstMonth;
// Startet beim Monat des jüngsten Belegs — der aktuelle Monat kann zu Monatsbeginn noch
// leer sein, obwohl die Warnung gerade wegen der Vorwochen anschlägt.
var latest = Events.Count > 0 ? FirstOfMonth(Events[0].Date) : _lastMonth;
_today = e.AsOf;
Month = latest < _firstMonth ? _firstMonth : latest > _lastMonth ? _lastMonth : latest;
RebuildCalendar();
}
private static DateOnly FirstOfMonth(DateOnly d) => new(d.Year, d.Month, 1);
partial void OnMonthChanged(DateOnly value) => RebuildCalendar();
private bool CanGoPrevious() => Month > _firstMonth;
private bool CanGoNext() => Month < _lastMonth;
[RelayCommand(CanExecute = nameof(CanGoPrevious))] private void PreviousMonth() => Month = Month.AddMonths(-1);
[RelayCommand(CanExecute = nameof(CanGoNext))] private void NextMonth() => Month = Month.AddMonths(1);
private void RebuildCalendar()
{
CalendarDays.Clear();
foreach (var day in BuildMonth(Month, _calendarEvents, _today)) CalendarDays.Add(day);
}
/// Gleiche Verdichtung wie ClassTeacherOverviewViewModel.BuildCompactMonthDays: eine Zelle je
/// Kalendertag, das stärkste Kürzel ersetzt die Tageszahl, alle Details stehen im Tooltip.
public static IReadOnlyList<ClassTeacherCompactCalendarDay> BuildMonth(DateOnly month,
IReadOnlyList<StudentEvidenceEvent> events, DateOnly today)
{
var result = new List<ClassTeacherCompactCalendarDay>();
var byDate = events.Where(e => e.Date.Year == month.Year && e.Date.Month == month.Month)
.GroupBy(e => e.Date).ToDictionary(g => g.Key, g => g.ToList());
for (var n = 1; n <= DateTime.DaysInMonth(month.Year, month.Month); n++)
{
var date = new DateOnly(month.Year, month.Month, n);
if (!byDate.TryGetValue(date, out var dayEvents))
{
result.Add(new ClassTeacherCompactCalendarDay(date, "", "#00000000",
$"{date:dd.MM.yyyy}: unauffällig", date == today));
continue;
}
var strongest = dayEvents.OrderBy(e => Priority(e.Code)).First();
var tooltip = $"{date:dd.MM.yyyy}\n" + string.Join("\n", dayEvents.Select(e => $"{e.GroupName}: {e.Label}"));
result.Add(new ClassTeacherCompactCalendarDay(date, strongest.Code.TrimEnd('!'), strongest.ColorHex,
tooltip, date == today));
}
return result;
}
private static int Priority(string code) => code switch
{
"U" => 0, "A" => 1, "E" => 2, "V!" => 3, "V" => 4, _ => 5,
};
}
@@ -157,16 +157,20 @@ public partial class DocumentationDialogViewModel : ObservableObject
public string[] TypeOptions => DocumentationTypeDisplay.Options;
public string[] SupportStatusOptions => SupportStatusDisplay.Options;
public string DialogTitle => _editing is null ? "Dokumentation hinzufügen" : "Dokumentation bearbeiten";
private readonly bool _isNewDraft;
public string DialogTitle => _editing is null || _isNewDraft ? "Dokumentation hinzufügen" : "Dokumentation bearbeiten";
public long MaxAttachmentSizeBytes => IAttachmentStorage.MaxSizeBytes;
public Documentation? Result { get; private set; }
public DocumentationDialogViewModel(Guid studentId, Documentation? editing, IAttachmentStorage attachmentStorage,
List<StudentOption>? studentOptions = null, Guid? contextGroupId = null)
List<StudentOption>? studentOptions = null, Guid? contextGroupId = null, bool isNewDraft = false)
{
_studentId = studentId;
_editing = editing;
// editing ist dann ein vorbefüllter, noch ungespeicherter Entwurf (z.B. aus einer
// Vorgangs-Vorlage) — wird wie ein Bestandseintrag vorbelegt, aber als "hinzufügen" betitelt.
_isNewDraft = isNewDraft;
_attachmentStorage = attachmentStorage;
_contextGroupId = contextGroupId;
StudentOptions = studentOptions ?? [];
@@ -3,6 +3,7 @@ using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;
using LehrerApp.Core.Interfaces;
using LehrerApp.Core.Models;
using LehrerApp.Desktop.Services;
using LehrerApp.Desktop.ViewModels.ClassTeacher;
namespace LehrerApp.Desktop.ViewModels.Students;
@@ -21,8 +22,12 @@ public partial class StudentVorgaengeViewModel : ObservableObject
private readonly IVorgangRepository _vorgaenge;
private readonly IDocumentationRepository _documentation;
private readonly IStudentRepository _students;
private readonly StudentWarningEvidenceService? _evidence;
private Guid _studentId;
// Id eines aus einer Vorlage erzeugten, noch ungespeicherten Dokumentations-Entwurfs — damit
// der Dialog "hinzufügen" statt "bearbeiten" titelt (siehe IsNewDocumentationDraft).
private Guid? _documentationDraftId;
private string _studentName = "";
private List<StudentOption> _studentOptions = [];
@@ -39,14 +44,29 @@ public partial class StudentVorgaengeViewModel : ObservableObject
/// (siehe <see cref="HandleWarningNavigation"/>) — Parameter ist das gesuchte Tag.
public Func<string, Task<bool>>? OnConfirmCreateForWarning { get; set; }
/// <param name="evidence">Quelle für Schnellbausteine/Vorlagen mit dem aktuellen Stand
/// (Fehlquote, Hausaufgaben, Verspätungen). Optional, damit Tests ohne Mitarbeits-Repositories
/// auskommen — ohne sie entfallen Bausteine und Vorlagen einfach.</param>
public StudentVorgaengeViewModel(IVorgangRepository vorgaenge, IDocumentationRepository documentation,
IStudentRepository students)
IStudentRepository students, StudentWarningEvidenceService? evidence = null)
{
_vorgaenge = vorgaenge;
_documentation = documentation;
_students = students;
_evidence = evidence;
}
/// Frisch berechnet bei jedem Dialog-Aufruf statt beim Laden gecacht — der Tab kann lange offen
/// bleiben, während im Unterricht weiter Anwesenheit erfasst wird.
public IReadOnlyList<VorgangQuickBlock> BuildQuickBlocks() =>
_evidence is null ? [] : StudentEvidenceText.QuickBlocks(_evidence.Build(_studentId));
/// Ob ein an OnEditVorgang übergebener Vorgang schon gespeichert ist oder nur ein vorbefüllter
/// Entwurf (HandleWarningNavigation) — steuert den Dialogtitel "anlegen"/"bearbeiten".
public bool IsPersisted(Vorgang vorgang) => _vorgaenge.GetById(vorgang.Id) is not null;
public bool IsNewDocumentationDraft(Documentation doc) => doc.Id == _documentationDraftId;
partial void OnOnlyOpenChanged(bool value) => Load(_studentId);
[RelayCommand] private void Refresh() => Load(_studentId);
@@ -80,7 +100,10 @@ public partial class StudentVorgaengeViewModel : ObservableObject
.Where(n => !string.IsNullOrEmpty(n)));
var item = new VorgangItem(vorgang, names, LinkDocumentation, UnlinkDocumentation,
RemoveClassRegisterEntry, EditDocumentation)
{ IsRevealed = revealedIds.Contains(vorgang.Id) };
{
IsRevealed = revealedIds.Contains(vorgang.Id),
OnCreateFromTemplate = _evidence is null ? null : CreateDocumentationFromTemplate,
};
var linkedIds = vorgang.DocumentationIds.ToHashSet();
foreach (var doc in ownDocs.Where(d => linkedIds.Contains(d.Id)))
@@ -146,6 +169,27 @@ public partial class StudentVorgaengeViewModel : ObservableObject
Load(_studentId);
}
/// Erzeugt aus einer Vorlage (VorgangDocumentationTemplates) einen vorbefüllten Entwurf mit dem
/// aktuellen Stand, öffnet ihn im normalen Dokumentations-Dialog und verknüpft ihn nach dem
/// Speichern mit dem Vorgang — gleicher Abschluss wie CreateAndLinkDocumentation.
private async Task CreateDocumentationFromTemplate(VorgangItem item, string key)
{
if (_evidence is null || OnEditDocumentation is null) return;
var draft = VorgangDocumentationTemplates.Build(key, item.Model, _evidence.Build(_studentId));
if (draft is null) return;
_documentationDraftId = draft.Id;
Documentation? result;
try { result = await OnEditDocumentation(_studentId, draft); }
finally { _documentationDraftId = null; }
if (result is null) return;
_documentation.Save(result);
item.Model.DocumentationIds.Add(result.Id);
_vorgaenge.Save(item.Model);
Load(_studentId);
var reloaded = Cases.FirstOrDefault(c => c.Model.Id == item.Model.Id);
if (reloaded is not null) reloaded.IsRevealed = true;
}
private async Task EditDocumentation(DocumentationItem doc)
{
if (OnEditDocumentation is null) return;
@@ -199,7 +243,14 @@ public partial class StudentVorgaengeViewModel : ObservableObject
if (OnConfirmCreateForWarning is null || OnEditVorgang is null) return;
if (!await OnConfirmCreateForWarning(suggestedTag)) return;
var draft = new Vorgang { Title = suggestedTitle, StudentIds = [_studentId], Tags = [suggestedTag] };
// Nutzer-Feedback: die Zahlen, die die Warnung ausgelöst haben, gleich als Beschreibung
// mitgeben, statt sie im Dialog von Hand abzutippen — bleibt im Dialog frei editierbar.
var description = _evidence is null ? ""
: StudentEvidenceText.StatusBlockForTag(suggestedTag, _evidence.Build(_studentId)) ?? "";
var draft = new Vorgang
{
Title = suggestedTitle, Description = description, StudentIds = [_studentId], Tags = [suggestedTag],
};
var result = await OnEditVorgang(_studentOptions, draft);
if (result is null) return;
_vorgaenge.Save(result);
@@ -0,0 +1,246 @@
using System.Globalization;
using System.Text;
using LehrerApp.Core.Models;
using LehrerApp.Desktop.Services;
namespace LehrerApp.Desktop.ViewModels.Students;
/// <summary>Ein per Klick einfügbarer Textbaustein im Vorgang-Dialog (Nutzer-Feedback: Fehlquoten
/// etc. nicht von Hand abtippen müssen).</summary>
public sealed record VorgangQuickBlock(string Label, string Text);
/// <summary>
/// Formuliert die Belege aus <see cref="StudentWarningEvidence"/> als deutschen Fließtext — für
/// Schnellbausteine im Vorgang-Dialog, die Vorbelegung eines aus einer Dashboard-Warnung heraus
/// angelegten Vorgangs und die Dokumentationsvorlagen (<see cref="VorgangDocumentationTemplates"/>).
/// Jeder Block nennt das Stichtagsdatum, weil der Text eingefroren in Vorgang/Dokumentation landet,
/// während die Zahlen dahinter weiterlaufen.
/// </summary>
public static class StudentEvidenceText
{
private static readonly CultureInfo De = new("de-DE");
/// Die Terminlisten sollen den Beleg stützen, nicht die Beschreibung fluten.
public const int MaxListedEvents = 15;
public static string AttendanceShort(StudentWarningEvidence e)
{
var b = e.Balance;
var absent = b.Excused + b.Unexcused + b.ExcusePending;
return $"Fehlquote {b.AbsenceRatePercent.ToString("0.#", De)} % im Schuljahr {e.SchoolYear} " +
$"({absent} von {b.TotalChecked} erfassten Stunden; entschuldigt {b.Excused}, " +
$"unentschuldigt {b.Unexcused}, Entschuldigung offen {b.ExcusePending})";
}
public static string HomeworkShort(StudentWarningEvidence e) =>
$"{e.MissingHomework.Count} nicht bzw. unvollständig erledigte Hausaufgabe{(e.MissingHomework.Count == 1 ? "" : "n")} im Schuljahr {e.SchoolYear}";
public static string LatenessShort(StudentWarningEvidence e) =>
$"{e.Lateness.Count} Verspätung{(e.Lateness.Count == 1 ? "" : "en")} im Schuljahr {e.SchoolYear}" +
(e.SignificantlyLateCount > 0 ? $" (davon {e.SignificantlyLateCount} erheblich)" : "");
public static string AttendanceBlock(StudentWarningEvidence e) =>
$"Stand {e.AsOf:dd.MM.yyyy}: {AttendanceShort(e)}.";
public static string AbsenceListBlock(StudentWarningEvidence e) => ListBlock("Fehltermine", e.Absences);
public static string HomeworkBlock(StudentWarningEvidence e) =>
$"Stand {e.AsOf:dd.MM.yyyy}: {HomeworkShort(e)}.\n" + ListBlock("Betroffene Termine", e.MissingHomework);
public static string LatenessBlock(StudentWarningEvidence e) =>
$"Stand {e.AsOf:dd.MM.yyyy}: {LatenessShort(e)}.\n" + ListBlock("Betroffene Termine", e.Lateness);
private static string ListBlock(string header, IReadOnlyList<StudentEvidenceEvent> events)
{
var sb = new StringBuilder($"{header}:");
foreach (var ev in events.Take(MaxListedEvents)) sb.Append("\n- ").Append(ev.ListLine);
if (events.Count > MaxListedEvents) sb.Append($"\n- … und {events.Count - MaxListedEvents} weitere");
return sb.ToString();
}
/// Welcher Stand zu welchem Vorgangs-Schlagwort gehört — dieselben drei Tags, mit denen das
/// Dashboard seine Warnungen an Vorgänge knüpft (DashboardViewModel.AbsentismusTag usw.).
public static string? StatusBlockForTag(string tag, StudentWarningEvidence e) => tag.ToLowerInvariant() switch
{
"absentismus" => AttendanceBlock(e) + "\n" + AbsenceListBlock(e),
"hausaufgaben" => HomeworkBlock(e),
"verspätungen" => LatenessBlock(e),
_ => null,
};
/// Kurzfassungen für die Tags eines Vorgangs, z.B. als Anlass eines Gesprächs. Ohne passendes
/// Tag bleibt die Liste leer statt ungefragt alle Zahlen einzustreuen.
public static List<string> ShortLinesForTags(IEnumerable<string> tags, StudentWarningEvidence e)
{
var lines = new List<string>();
foreach (var tag in tags.Select(t => t.ToLowerInvariant()).Distinct())
{
var line = tag switch
{
"absentismus" => AttendanceShort(e),
"hausaufgaben" => HomeworkShort(e),
"verspätungen" => LatenessShort(e),
_ => null,
};
if (line is not null) lines.Add(line);
}
return lines;
}
/// Schnellbausteine für den Vorgang-Dialog — nur solche mit tatsächlichem Inhalt, ein
/// "0 Verspätungen"-Baustein wäre nur Rauschen.
public static List<VorgangQuickBlock> QuickBlocks(StudentWarningEvidence e)
{
var blocks = new List<VorgangQuickBlock>();
if (e.Balance.TotalChecked > 0) blocks.Add(new("Fehlquote", AttendanceBlock(e)));
if (e.Absences.Count > 0) blocks.Add(new("Fehltermine", AbsenceListBlock(e)));
if (e.MissingHomework.Count > 0) blocks.Add(new("Hausaufgaben", HomeworkBlock(e)));
if (e.Lateness.Count > 0) blocks.Add(new("Verspätungen", LatenessBlock(e)));
return blocks;
}
/// Übersetzt die lokalen Mitarbeits-Belege in den neutralen Vorlagen-Kontext (die
/// Klassenlehreransicht baut ihren Kontext stattdessen aus WebUntis-Daten, siehe
/// ClassTeacherCaseFacts).
public static VorgangTemplateContext TemplateContext(Vorgang vorgang, StudentWarningEvidence e) => new(
e.StudentId, e.StudentNaturalName, e.AsOf, ShortLinesForTags(vorgang.Tags, e),
new Dictionary<string, VorgangSnapshot>
{
[VorgangDocumentationTemplates.AttendanceStatus] = new($"Fehlzeiten-Stand {e.AsOf:dd.MM.yyyy}",
AttendanceBlock(e) + "\n\n" + AbsenceListBlock(e)),
[VorgangDocumentationTemplates.HomeworkStatus] = new($"Hausaufgaben-Stand {e.AsOf:dd.MM.yyyy}", HomeworkBlock(e)),
[VorgangDocumentationTemplates.LatenessStatus] = new($"Verspätungs-Stand {e.AsOf:dd.MM.yyyy}", LatenessBlock(e)),
});
}
/// <summary>Ein festhaltbarer Stand ("Fehlzeiten-Stand …") als fertiger Titel + Text.</summary>
public sealed record VorgangSnapshot(string Title, string Content);
/// <summary>Neutraler Zahlen-Kontext für <see cref="VorgangDocumentationTemplates"/> — gespeist
/// entweder aus den lokalen Mitarbeits-Einträgen (Schülerdetail, <see cref="StudentEvidenceText"/>)
/// oder aus WebUntis (Klassenlehrer-Vorgänge, siehe ClassTeacherCaseFacts). So bleiben die
/// Vorlagentexte an einer Stelle.</summary>
/// <param name="SituationLines">Kurzfassungen passend zu den Tags des Vorgangs (Anlass).</param>
/// <param name="Snapshots">Je Vorlagen-Schlüssel ein festhaltbarer Stand.</param>
public sealed record VorgangTemplateContext(Guid StudentId, string StudentNaturalName, DateOnly AsOf,
IReadOnlyList<string> SituationLines, IReadOnlyDictionary<string, VorgangSnapshot> Snapshots);
/// <summary>Standardformulierungen für den Vorgang-Dialog (Nutzer-Feedback: "den Klassenlehrer
/// informiert" u.ä. nicht jedes Mal tippen). Datumsgestempelt, weil sie als Verlaufsnotiz in der
/// Beschreibung landen. Getrennte Listen je Kontext: aus Sicht der Fachlehrkraft (Schülerdetail) wird
/// die Klassenleitung informiert, aus Sicht der Klassenleitung die Fachlehrkräfte.</summary>
public static class VorgangPhraseBlocks
{
public static IReadOnlyList<VorgangQuickBlock> ForStudent(DateOnly today) =>
[
new("Klassenleitung informiert", $"{today:dd.MM.yyyy}: Klassenleitung informiert."),
new("Eltern informiert", $"{today:dd.MM.yyyy}: Erziehungsberechtigte informiert."),
new("Gespräch geführt", $"{today:dd.MM.yyyy}: Gespräch mit der Schülerin/dem Schüler geführt."),
new("Vereinbarung getroffen", $"{today:dd.MM.yyyy}: Vereinbarung getroffen: "),
new("Weiter beobachten", $"{today:dd.MM.yyyy}: Weiter beobachten, Überprüfung am "),
];
public static IReadOnlyList<VorgangQuickBlock> ForClassTeacher(DateOnly today) =>
[
new("Fachlehrkräfte informiert", $"{today:dd.MM.yyyy}: Fachlehrkräfte der Klasse informiert."),
new("Eltern informiert", $"{today:dd.MM.yyyy}: Erziehungsberechtigte informiert."),
new("Gespräch geführt", $"{today:dd.MM.yyyy}: Gespräch mit der Schülerin/dem Schüler geführt."),
new("Attestpflicht angekündigt", $"{today:dd.MM.yyyy}: Attestpflicht angekündigt – Fehlzeiten gelten künftig nur mit ärztlichem Attest als entschuldigt."),
new("Schulsozialarbeit eingebunden", $"{today:dd.MM.yyyy}: Schulsozialarbeit/Beratung eingebunden."),
new("Schulleitung informiert", $"{today:dd.MM.yyyy}: Schulleitung informiert."),
new("Vereinbarung getroffen", $"{today:dd.MM.yyyy}: Vereinbarung getroffen: "),
new("Weiter beobachten", $"{today:dd.MM.yyyy}: Weiter beobachten, Überprüfung am "),
];
}
/// <summary>
/// Standardisierte Dokumentationseinträge für einen Vorgang (Nutzer-Feedback: nicht jeden Eintrag
/// komplett von Hand anlegen). Erzeugt nur einen vorbefüllten, noch nicht gespeicherten Entwurf —
/// der landet anschließend im normalen Dokumentations-Dialog, gespeichert wird erst nach bewusster
/// Bestätigung dort.
/// </summary>
public static class VorgangDocumentationTemplates
{
// Stand festhalten — lokal (Schülerdetail) …
public const string AttendanceStatus = "attendance";
public const string HomeworkStatus = "homework";
public const string LatenessStatus = "lateness";
// … bzw. aus WebUntis (Klassenlehrer-Vorgänge)
public const string UntisAbsenceStatus = "untisabsences";
public const string ClassRegisterStatus = "classregister";
public const string Conversation = "conversation";
public const string ParentCall = "parentcall";
public const string ParentLetter = "parentletter";
public const string InformClassTeacher = "informclassteacher";
public const string InformSubjectTeachers = "informsubjectteachers";
public static Documentation? Build(string key, Vorgang vorgang, StudentWarningEvidence e) =>
Build(key, vorgang, StudentEvidenceText.TemplateContext(vorgang, e));
public static Documentation? Build(string key, Vorgang vorgang, VorgangTemplateContext ctx)
{
var doc = new Documentation { StudentId = ctx.StudentId, Date = ctx.AsOf };
if (ctx.Snapshots.TryGetValue(key, out var snapshot))
{
doc.Type = DocumentationType.Incident;
doc.Title = snapshot.Title;
doc.Content = snapshot.Content;
doc.Tags = ["Beobachten"];
return doc;
}
switch (key)
{
case Conversation:
doc.Type = DocumentationType.Conversation;
doc.Title = $"Gespräch: {vorgang.Title}";
doc.Participants = [ctx.StudentNaturalName];
doc.Content = "Anlass:\n" + Occasion(vorgang, ctx) +
"\n\nSicht der Schülerin/des Schülers:\n\n\nVereinbarung:\n\n\nÜberprüfung am:\n";
return doc;
case InformClassTeacher:
case InformSubjectTeachers:
var who = key == InformClassTeacher ? "Klassenleitung" : "Fachlehrkräfte";
doc.Type = DocumentationType.Conversation;
doc.Title = $"{who} informiert: {vorgang.Title}";
doc.Participants = [who];
doc.Content = $"{who} am {ctx.AsOf:dd.MM.yyyy} informiert über:\n" + Occasion(vorgang, ctx) +
"\n\nWeg (persönlich / Nachricht / E-Mail):\n\n\nRückmeldung / Absprache:\n";
return doc;
case ParentCall:
doc.Type = DocumentationType.ParentCall;
doc.Title = $"Elternanruf: {vorgang.Title}";
var points = ctx.SituationLines.Select(l => $"Aktueller Stand: {l}").ToList();
if (points.Count == 0) points.Add($"Anlass schildern: {vorgang.Title}");
points.AddRange(["Sicht der Eltern / mögliche Gründe erfragen", "Unterstützung und Vereinbarung abstimmen",
"Nächsten Kontakt vereinbaren"]);
doc.ParentCallData = new ParentCallData
{ Points = points.Select(p => new ParentCallPoint { Text = p }).ToList() };
return doc;
case ParentLetter:
doc.Type = DocumentationType.ParentLetter;
doc.Title = $"Elternbrief: {vorgang.Title}";
doc.ParentLetterData = new ParentLetterData { DraftContent = LetterDraft(vorgang, ctx) };
return doc;
default:
return null;
}
}
private static string Occasion(Vorgang vorgang, VorgangTemplateContext ctx) =>
ctx.SituationLines.Count == 0 ? $"- {vorgang.Title}"
: string.Join("\n", ctx.SituationLines.Select(l => $"- {l} (Stand {ctx.AsOf:dd.MM.yyyy})"));
private static string LetterDraft(Vorgang vorgang, VorgangTemplateContext ctx)
{
var facts = ctx.SituationLines.Count == 0
? $"es gibt Anlass zur Sorge ({vorgang.Title})."
: $"mit Stand {ctx.AsOf:dd.MM.yyyy} ergibt sich folgendes Bild:\n" +
string.Join("\n", ctx.SituationLines.Select(l => $"- {l}"));
return $"Sehr geehrte Erziehungsberechtigte von {ctx.StudentNaturalName},\n\n" +
$"ich möchte Sie darüber informieren, dass {facts}\n\n" +
"Ich bitte Sie, mit Ihrem Kind darüber zu sprechen und sich bei Fragen mit mir in Verbindung zu setzen. " +
"Für ein gemeinsames Gespräch stehe ich gerne zur Verfügung.\n\n" +
"Mit freundlichen Grüßen";
}
}