Nachschreibarbeiten und Arbeitsarten (Test, kontrollierte Hausaufgabe)
CI / build-and-test (push) Canceled after 0s

Nachschreibarbeiten nutzen die Wiederholungs-Verknüpfung, ersetzen aber nur
fehlende Noten; mehrere Folgearbeiten je erster Arbeit sind möglich.
Exam.Kind trennt Klausuren (schriftlich) von Tests u. Ä. (Sonstige).

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
adminandClaude Sonnet 5.5 committed 2026-10-05 22:54:31 +02:00
1 parent d7898d5678
commit c0f8b98202
15 files changed
+238 -44

No files matched your search

@@ -42,6 +42,9 @@ public partial class ExamEvaluationDialogViewModel : ObservableObject
public ObservableCollection<RepeatComparisonItem> RepeatComparison { get; } = [];
public bool HasRepeatComparison => RepeatComparison.Count > 0;
public string RepeatComparisonTitle { get; private set; } = "";
/// "Wiederholung" bzw. "Nachschreibarbeit" — Beschriftung der Folgearbeit im Vergleich.
public string FollowUpLabel { get; private set; } = "Wiederholung";
public string FollowUpComparisonHeading => $"Vergleich mit der {FollowUpLabel}";
public ObservableCollection<GradingKeyEntryEditItem> GradingKeyEntries { get; } = [];
public ExamEvaluationDialogViewModel(IExamRepository exams, IExamResultRepository results,
@@ -66,15 +69,17 @@ public partial class ExamEvaluationDialogViewModel : ObservableObject
var original = _exam.RepeatOfExamId is { } originalId ? _exams.GetById(originalId) : _exam;
if (original is null) return;
var repeat = _exam.RepeatOfExamId is not null ? _exam
: _exams.GetByGroup(_exam.GroupId).FirstOrDefault(e => e.RepeatOfExamId == _exam.Id);
: _exams.GetByGroup(_exam.GroupId).Where(e => e.RepeatOfExamId == _exam.Id)
.OrderBy(e => e.Date).FirstOrDefault();
if (repeat is null) return;
var rule = repeat.RepeatGradeRule switch
FollowUpLabel = repeat.IsMakeUp ? "Nachschreibarbeit" : "Wiederholung";
var rule = repeat.IsMakeUp ? "ersetzt fehlende Note" : repeat.RepeatGradeRule switch
{
RepeatGradeRule.Repeat => "Wiederholung zählt",
RepeatGradeRule.Original => "Erste Arbeit zählt",
_ => "Bessere zählt",
};
RepeatComparisonTitle = $"Erste Arbeit: {original.Title} · Wiederholung: {repeat.Title} · {rule}";
RepeatComparisonTitle = $"Erste Arbeit: {original.Title} · {FollowUpLabel}: {repeat.Title} · {rule}";
var first = _results.GetByExam(original.Id).Where(r => !r.Absent && r.Grade is not null)
.ToDictionary(r => r.StudentId);
var second = _results.GetByExam(repeat.Id).Where(r => !r.Absent && r.Grade is not null)
@@ -96,6 +101,7 @@ public partial class ExamEvaluationDialogViewModel : ObservableObject
}
OnPropertyChanged(nameof(HasRepeatComparison));
OnPropertyChanged(nameof(RepeatComparisonTitle));
OnPropertyChanged(nameof(FollowUpLabel));
}
private void LoadResults()
@@ -271,7 +277,7 @@ public partial class ExamEvaluationDialogViewModel : ObservableObject
if (HasRepeatComparison)
{
csv.AddBlankRow().AddRow("Vergleich", RepeatComparisonTitle)
.AddRow("Schüler", "Erste Arbeit", "Wiederholung", "Zählt");
.AddRow("Schüler", "Erste Arbeit", FollowUpLabel, "Zählt");
foreach (var item in RepeatComparison)
csv.AddRow(item.StudentName, item.OriginalGrade, item.RepeatGrade, item.EffectiveGrade);
}
@@ -54,6 +54,14 @@ public partial class ExamGradingDialogViewModel : ObservableObject
var membershipList = memberships.GetByGroup(groupId);
var existing = results.GetByExam(exam.Id).ToDictionary(r => r.StudentId);
// Nachschreibarbeit: nur Schüler, die die erste Arbeit nicht mitgeschrieben haben. Wer dort
// schon eine Note hat, taucht nicht auf — außer es gibt hier bereits ein Ergebnis (nichts
// verstecken, was schon eingetragen wurde).
var wroteOriginal = new HashSet<Guid>();
if (exam.IsMakeUp && exam.RepeatOfExamId is { } originalId)
foreach (var r in results.GetByExam(originalId).Where(r => !r.Absent && r.Grade is not null))
wroteOriginal.Add(r.StudentId);
foreach (var s in enrolled.OrderBy(s => s.LastName).ThenBy(s => s.FirstName))
{
var membership = membershipList.FirstOrDefault(e => e.StudentId == s.Id);
@@ -64,6 +72,7 @@ public partial class ExamGradingDialogViewModel : ObservableObject
if (exam.Niveau.HasValue && membership?.Niveau != exam.Niveau) continue;
existing.TryGetValue(s.Id, out var result);
if (result is null && wroteOriginal.Contains(s.Id)) continue;
var row = new ExamResultRow(s.Id, s.FullName, Tasks, result, _exam.GradingKey,
ExamScoringService.Maximum(Tasks, ExamVariant.A), _grading);
row.OnChanged = SaveRow;
@@ -46,11 +46,21 @@ public partial class ExamDialogViewModel : ObservableObject
[ObservableProperty] private string _repeatRuleName = "Bessere zählt";
[ObservableProperty] private string _repeatError = "";
[ObservableProperty] private string _taskPointsError = "";
[ObservableProperty] private string _kindName = ExamKind.Klausur.Label();
[ObservableProperty] private bool _isMakeUp;
public bool IsDifferentiated { get; }
public string[] NiveauOptions => NiveauDisplay.Options;
public string[] KindOptions { get; } = Enum.GetValues<ExamKind>().Select(k => k.Label()).ToArray();
public string[] RepeatRuleOptions => ["Bessere zählt", "Wiederholung zählt", "Erste Arbeit zählt"];
public bool HasSelectedOriginalExam => SelectedOriginalExam is not null;
/// Art und Zählweise sind bei einer verknüpften Folgearbeit festgelegt: sie erbt die Art der
/// ersten Arbeit, eine Nachschreibarbeit ersetzt nur fehlende Noten (keine Regelwahl nötig).
public bool CanChooseKind => !HasSelectedOriginalExam;
public bool ShowRepeatRule => HasSelectedOriginalExam && !IsMakeUp;
public string LinkedExamLabel => IsMakeUp
? "Nachschreibarbeit zu (optional)" : "Wiederholung oder Nachschreibarbeit zu (optional)";
private ExamKind Kind => Enum.GetValues<ExamKind>().FirstOrDefault(k => k.Label() == KindName);
public ObservableCollection<Exam> AvailableOriginalExams { get; } = [];
public bool TotalPointsWarning => TotalPoints <= 0;
@@ -63,7 +73,7 @@ public partial class ExamDialogViewModel : ObservableObject
public ObservableCollection<GradingKeyTemplate> AvailableTemplates { get; } = [];
public Exam? Result { get; private set; }
public string DialogTitle => _editingExam is null ? "Neue Klausur anlegen" : "Klausur bearbeiten";
public string DialogTitle => _editingExam is null ? "Neue Arbeit anlegen" : "Arbeit bearbeiten";
public string SaveButtonText => _editingExam is null ? "Anlegen" : "Speichern";
/// Fach kommt von der Lerngruppe, nicht editierbar (jede Gruppe unterrichtet ein Fach).
@@ -87,9 +97,10 @@ public partial class ExamDialogViewModel : ObservableObject
_subjectName = defaultSubjectName;
IsDifferentiated = isDifferentiated;
var groupExams = _exams.GetByGroup(groupId);
// Mehrere Folgearbeiten je erster Arbeit sind erlaubt (z. B. Nachschreibtermin und
// später eine Wiederholung); Folgearbeiten selbst sind keine Bezugsarbeit.
foreach (var exam in groupExams
.Where(e => e.Id != editingExam?.Id && e.RepeatOfExamId is null)
.Where(e => !groupExams.Any(r => r.RepeatOfExamId == e.Id && r.Id != editingExam?.Id))
.OrderByDescending(e => e.Date))
AvailableOriginalExams.Add(exam);
@@ -113,9 +124,11 @@ public partial class ExamDialogViewModel : ObservableObject
// Beim Duplizieren bewusst kein Niveau übernehmen — meist wird dupliziert, um
// gerade eine andere Niveau-Variante (E/G/Förder) derselben Klausur anzulegen.
SelectedNiveauName = isDuplicate ? "–" : NiveauDisplay.ToName(source.Niveau);
KindName = source.Kind.Label();
if (!isDuplicate)
{
SelectedOriginalExam = AvailableOriginalExams.FirstOrDefault(e => e.Id == source.RepeatOfExamId);
IsMakeUp = source.IsMakeUp && SelectedOriginalExam is not null;
RepeatRuleName = source.RepeatGradeRule switch
{
RepeatGradeRule.Repeat => "Wiederholung zählt",
@@ -145,7 +158,23 @@ public partial class ExamDialogViewModel : ObservableObject
{
foreach (var t in Tasks) t.ShowWeight = value;
}
partial void OnSelectedOriginalExamChanged(Exam? value) => OnPropertyChanged(nameof(HasSelectedOriginalExam));
partial void OnSelectedOriginalExamChanged(Exam? value)
{
if (value is not null) KindName = value.Kind.Label();
else IsMakeUp = false;
OnPropertyChanged(nameof(HasSelectedOriginalExam));
OnPropertyChanged(nameof(CanChooseKind));
OnPropertyChanged(nameof(ShowRepeatRule));
UpdateWeekLoadHint();
}
partial void OnIsMakeUpChanged(bool value)
{
OnPropertyChanged(nameof(ShowRepeatRule));
OnPropertyChanged(nameof(LinkedExamLabel));
}
partial void OnKindNameChanged(string value) => UpdateWeekLoadHint();
[RelayCommand] private void ClearOriginalExam() => SelectedOriginalExam = null;
@@ -156,7 +185,8 @@ public partial class ExamDialogViewModel : ObservableObject
/// ExamWeekLoadService), hier geht es um die eigene Häufung über alle Kurse hinweg.
private void UpdateWeekLoadHint()
{
if (!DateOnly.TryParseExact(DateText, "dd.MM.yyyy", null, DateTimeStyles.None, out var date))
if (!Kind.CountsAsWritten()
|| !DateOnly.TryParseExact(DateText, "dd.MM.yyyy", null, DateTimeStyles.None, out var date))
{
WeekLoadHint = "";
return;
@@ -354,7 +384,9 @@ public partial class ExamDialogViewModel : ObservableObject
if (gradingKeyError is not null) { GradingKeyValidation = gradingKeyError; valid = false; }
if (SelectedOriginalExam is not null && SelectedOriginalExam.Date >= date)
{
RepeatError = "Die erste Arbeit muss vor der Wiederholung liegen.";
RepeatError = IsMakeUp
? "Die erste Arbeit muss vor der Nachschreibarbeit liegen."
: "Die erste Arbeit muss vor der Wiederholung liegen.";
valid = false;
}
if (Tasks.Any(t => t.VariantName != "Beide") &&
@@ -376,6 +408,8 @@ public partial class ExamDialogViewModel : ObservableObject
Result.Tasks = Tasks.Select(t => t.ToModel()).ToList();
Result.GradingKey = gradingKey;
Result.RepeatOfExamId = SelectedOriginalExam?.Id;
Result.Kind = SelectedOriginalExam?.Kind ?? Kind;
Result.IsMakeUp = IsMakeUp && SelectedOriginalExam is not null;
Result.RepeatGradeRule = RepeatRuleName switch
{
"Wiederholung zählt" => RepeatGradeRule.Repeat,
@@ -192,8 +192,8 @@ public partial class GradeOverviewTabViewModel : ObservableObject
cells.Add(display);
if (result.Grade is not null) examEntries.Add((exam, result.Grade));
}
numeric.AddRange(ExamScoringService.EffectiveGrades(examEntries, _gradingSystem)
.Select(grade => (Grade: grade, Weight: 1.0)));
var (writtenGrades, testGrades) = ExamScoringService.EffectiveGradesByKind(examEntries, _gradingSystem);
numeric.AddRange(writtenGrades.Concat(testGrades).Select(grade => (Grade: grade, Weight: 1.0)));
foreach (var key in gradeColumnKeys)
{
@@ -213,7 +213,7 @@ public partial class GroupOverviewViewModel : ObservableObject
.Select(r => (r.StudentId, Exam: e, Grade: r.Grade!)))
.GroupBy(x => x.StudentId)
.SelectMany(g => ExamScoringService.EffectiveGrades(
g.Select(x => (x.Exam, x.Grade)), system))
g.Where(x => x.Exam.Kind.CountsAsWritten()).Select(x => (x.Exam, x.Grade)), system))
.Select(grade => (Grade: grade, Weight: 1.0)).ToList();
return grades.Count == 0 ? null : (_grading.WeightedAverage(grades), grades.Count);
}
@@ -630,8 +630,15 @@ public class ExamSummary
Id = e.Id; Title = e.Title; Date = e.Date.ToString("dd.MM.yyyy"); Status = e.Status;
ReturnedAtDisplay = e.ReturnedAt?.ToString("dd.MM.yyyy") ?? "";
NiveauLabel = e.Niveau.HasValue ? NiveauDisplay.ToName(e.Niveau) : "alle";
TypeLabel = e.RepeatOfExamId is not null ? (e.Tasks.Any(t => t.Variant is not null) ? "Wdh. · A/B" : "Wiederholung")
: e.Tasks.Any(t => t.Variant is not null) ? "A/B" : "Klausur";
var hasVariants = e.Tasks.Any(t => t.Variant is not null);
var followUp = e.RepeatOfExamId is null ? null
: e.IsMakeUp ? (hasVariants ? "Nachschr. · A/B" : "Nachschreiben")
: hasVariants ? "Wdh. · A/B" : "Wiederholung";
// Folgearbeiten behalten ihre Art im Hintergrund (sie erben sie), die Spalte nennt nur
// die Beziehung; bei eigenständigen Arbeiten steht die Art selbst.
TypeLabel = followUp ?? (e.Kind == ExamKind.Klausur
? (hasVariants ? "A/B" : "Klausur")
: hasVariants ? $"{e.Kind.Label()} · A/B" : e.Kind.Label());
StatusLabel = e.Status switch
{
ExamStatus.Planned => "Geplant",
@@ -141,8 +141,8 @@ public partial class ReportGradeDialogViewModel : ObservableObject
if (result.Absent || result.Grade is null) continue;
examEntries.Add((exam, result.Grade));
}
var examGrades = ExamScoringService.EffectiveGrades(examEntries, _gradingSystem)
.Select(grade => (Grade: grade, Weight: 1.0)).ToList();
var (writtenGrades, testGrades) = ExamScoringService.EffectiveGradesByKind(examEntries, _gradingSystem);
var examGrades = writtenGrades.Select(grade => (Grade: grade, Weight: 1.0)).ToList();
var participationGrades = allGrades
.Where(g => g.StudentId == student.Id && g.Category == GradeCategory.Participation
@@ -152,6 +152,8 @@ public partial class ReportGradeDialogViewModel : ObservableObject
.Where(g => g.StudentId == student.Id && g.Category != GradeCategory.Participation
&& (membership is null || GroupMembershipService.IsActiveOn(membership, g.Date)))
.Select(g => (g.Value, g.Weight)).ToList();
// Tests, kontrollierte Hausaufgaben u. Ä. aus der Klausurfunktion zählen als Sonstige.
otherGrades.AddRange(testGrades.Select(grade => (grade, 1.0)));
var calculated = _grading.CalculateReportGrade(examGrades, participationGrades, otherGrades,
scheme, _gradingSystem, RoundingRule);
@@ -181,8 +181,8 @@ public partial class StudentPerformanceOverviewViewModel : ObservableObject
noteEquivalent, warnings.Count > 0, string.Join(" · ", warnings)));
if (noteEquivalent.HasValue) previousNoteEquivalent = noteEquivalent;
}
_examGradesRaw = ExamScoringService.EffectiveGrades(effectiveExamEntries, _gradingSystem)
.Select(grade => (Grade: grade, Weight: 1.0)).ToList();
var (writtenGrades, testGrades) = ExamScoringService.EffectiveGradesByKind(effectiveExamEntries, _gradingSystem);
_examGradesRaw = writtenGrades.Select(grade => (Grade: grade, Weight: 1.0)).ToList();
_examsAverage = _examGradesRaw.Count > 0 ? _grading.WeightedAverage(_examGradesRaw) : null;
// ── Mitarbeit & Sonstige ──────────────────────────────────────────
@@ -207,6 +207,9 @@ public partial class StudentPerformanceOverviewViewModel : ObservableObject
_otherGradesRaw.Add((g.Value, g.Weight));
OtherRows.Add(new StudentSimpleGradeRow(g, SaveGrade));
}
// Tests u. Ä. aus der Klausurfunktion zählen mit, sind aber hier nicht editierbar
// (sie werden in der Punkteeingabe der Arbeit gepflegt).
_otherGradesRaw.AddRange(testGrades.Select(grade => (grade, 1.0)));
_otherAverage = _otherGradesRaw.Count > 0 ? _grading.WeightedAverage(_otherGradesRaw) : null;
ExamsAverageDisplay = _examsAverage.HasValue ? FormatGrade(_examsAverage.Value) : null;