Zwischenstand: vorläufige Noten zu Stichtag und Anlass
CI / build-and-test (push) Canceled after 0s

Ein Zwischenstand ist ein Durchgang aus Stichtag, Anlass und
Schülerauswahl (ganze Gruppe, Teilgruppe oder Einzelfall, mit
Schnellfilter für gefährdete Schüler). Der Zeugnisnoten-Assistent geht
die gewählten Schüler im Zwischenstand-Modus durch und notiert
vorläufige schriftliche, mündliche und Gesamtnote samt Notiz.

Gespeichert wird das als eigenes Modell InterimGrade, getrennt von der
Zeugnisnote. Die Berechnung endet am Stichtag und rechnet den laufenden
Mitarbeits-Abschnitt mit ein. Zwischenstände erscheinen im Assistenten
als Liste und Marker im Verlauf sowie als graue Spalte in der
Notenübersicht (nicht in "Gesamt", nicht im PDF).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
adminandClaude Opus 5.5 committed 2026-10-06 13:01:34 +02:00
1 parent 67c5a906d1
commit d9eac0d1d2
24 files changed
+1038 -37

No files matched your search

+11
View File
@@ -681,6 +681,17 @@ public class FakeTimeEntries : ITimeEntryRepository
public void Restore(Guid trashId) { } // siehe FakeSeatingPlans.Restore
}
public class FakeInterimGrades : IInterimGradeRepository
{
private readonly List<InterimGrade> _all = [];
public List<InterimGrade> All => _all;
public List<InterimGrade> GetByGroup(Guid groupId) => _all.Where(g => g.GroupId == groupId).ToList();
public List<InterimGrade> GetByStudentAndGroup(Guid studentId, Guid groupId) =>
_all.Where(g => g.StudentId == studentId && g.GroupId == groupId).ToList();
public void Save(InterimGrade grade) { _all.RemoveAll(g => g.Id == grade.Id); _all.Add(grade); }
public void Delete(Guid id) => _all.RemoveAll(g => g.Id == id);
}
public class FakeReportGrades : IReportGradeRepository
{
private readonly List<ReportGrade> _all = [];
@@ -22,7 +22,7 @@ public sealed class GroupDetailViewModelTests
new FakeDocumentation(), tasks, groups, new AttendanceBalanceService(), new GradingService(), new SchoolYearService()),
new ParticipationTabViewModel(new FakeSessions([]), new FakeEntries(), new FakeAspects(),
students, memberships, groups, new FakeCompetencyDomains(), new FakeCompetencyCatalogVersions()),
new GradeOverviewTabViewModel(grades, exams, new FakeResults(), students, memberships, new GradingService()),
new GradeOverviewTabViewModel(grades, exams, new FakeResults(), students, memberships, new FakeInterimGrades(), new GradingService()),
new PlanningTabViewModel(new FakeUnits(), new FakeLessons(), groups, subjects,
new FakeCompetencyDomains(), new FakeCompetencyCatalogVersions(), TestSupport.BuildAiSettingsService(), new FakeSessions([])),
new CompetencyOverviewTabViewModel(new FakeUnits(), exams, new FakeResults(),
@@ -23,16 +23,36 @@ public sealed class ReportGradeAssistantViewModelTests
public List<ParticipationSession> Sessions { get; } = [];
public FakeEntries Entries { get; } = new();
public List<ParticipationSection> Sections { get; } = [];
public FakeInterimGrades InterimGrades { get; } = new();
public ReportGradeAssistantViewModel Build(DateOnly today, int gradeLevel = 8)
public ReportGradeAssistantViewModel Build(DateOnly today, int gradeLevel = 8, InterimRunOptions? interim = null)
{
var schemes = new FakeSchemes();
schemes.SetForGroup(GroupId, new GradingScheme { ExamsPercent = 50, ParticipationPercent = 40, OtherPercent = 10 });
return new ReportGradeAssistantViewModel(
Grades, new FakeExams(Exams), Results, new FakeStudents([Anna, Ben]), new FakeMemberships([]),
schemes, ReportGrades, new FakeSessions(Sessions), Entries, new FakeAspects(),
new FakeSections(Sections), new AttendanceBalanceService(), new GradingService(),
GroupId, GroupType.Class, GradingSystem.Grades1To6, "Testkurs", "2025/26", gradeLevel, today);
new FakeSections(Sections), InterimGrades, new AttendanceBalanceService(), new GradingService(),
GroupId, GroupType.Class, GradingSystem.Grades1To6, "Testkurs", "2025/26", gradeLevel, today, interim);
}
public InterimRunDialogViewModel BuildRunDialog(DateOnly today, Guid? preselected = null)
{
var schemes = new FakeSchemes();
schemes.SetForGroup(GroupId, new GradingScheme { ExamsPercent = 50, ParticipationPercent = 40, OtherPercent = 10 });
return new InterimRunDialogViewModel(
Grades, new FakeExams(Exams), Results, new FakeStudents([Anna, Ben]), new FakeMemberships([]),
schemes, ReportGrades, new FakeSessions(Sessions), Entries, new FakeAspects(),
new FakeSections(Sections), InterimGrades, new GradingService(),
GroupId, GroupType.Class, GradingSystem.Grades1To6, "Testkurs", "2025/26", preselected, today);
}
public void AddSession(DateOnly date, int rating)
{
var session = new ParticipationSession { Id = Guid.NewGuid(), GroupId = GroupId, Date = date };
Sessions.Add(session);
Entries.Add(new ParticipationEntry { SessionId = session.Id, StudentId = Anna.Id,
Ratings = [new AspectRating { Key = "quality", Value = rating }] });
}
public Exam AddExam(string title, DateOnly date, string annaGrade)
@@ -385,4 +405,171 @@ public sealed class ReportGradeAssistantViewModelTests
Assert.Equal(3, vm.ChartGroups.Count);
Assert.Equal(3, vm.ChartGroups.Sum(g => g.Points.Count));
}
// ── Zwischenstand (2.7.5) ────────────────────────────────────────────────
private static InterimRunOptions Sprechtag(params Guid[] students) =>
new(new DateOnly(2025, 11, 12), "Sprechtag", students);
[Fact]
public void Zwischenstand_RechnetNurBisZumStichtagUndMitLaufenderMitarbeit()
{
var f = new Fixture();
f.AddExam("K1", new DateOnly(2025, 10, 1), "2");
f.AddExam("K2", new DateOnly(2025, 12, 1), "6"); // nach dem Stichtag
f.AddSession(new DateOnly(2025, 10, 20), -2); // laufender Abschnitt, schwache Mitarbeit
var vm = f.Build(InH1, interim: Sprechtag(Anna.Id));
Assert.True(vm.IsInterimMode);
Assert.Equal(Anna.Id, Assert.Single(vm.Students).StudentId);
Assert.Equal("K1", Assert.Single(vm.Works).Title);
Assert.Equal("2", vm.InterimWritten);
Assert.NotNull(vm.InterimOral);
Assert.Contains("laufender Abschnitt", vm.Tiles.Single(t => t.Label == "Mitarbeit").Hint);
// Die schwache laufende Mitarbeit zieht den Gesamtstand unter die reine Klausurnote.
Assert.True(int.Parse(vm.InterimOverall!) > 2);
Assert.Contains("12.11.2025", vm.CalculationDetail);
// Die Zeugnisnoten-Berechnung selbst bleibt ohne laufenden Abschnitt.
var report = f.Build(InH1);
Assert.Equal("–", report.Tiles.Single(t => t.Label == "Mitarbeit").Value);
}
[Fact]
public void Zwischenstand_NotierenSpeichertGetrenntVonDerZeugnisnote()
{
var f = new Fixture();
f.AddExam("K1", new DateOnly(2025, 10, 1), "3");
var vm = f.Build(InH1, interim: Sprechtag(Anna.Id, Ben.Id));
vm.InterimOverall = "";
vm.NoteInterimCommand.Execute(null);
Assert.NotEmpty(vm.InterimOverallError);
Assert.Empty(f.InterimGrades.All);
vm.InterimOverall = "3-";
vm.InterimNote = "Mitarbeit muss besser werden";
vm.NoteInterimAndNextCommand.Execute(null);
var entry = Assert.Single(f.InterimGrades.All);
Assert.Equal(Anna.Id, entry.StudentId);
Assert.Equal(new DateOnly(2025, 11, 12), entry.Date);
Assert.Equal("Sprechtag", entry.Occasion);
Assert.Equal("3", entry.WrittenValue);
Assert.Equal("3-", entry.OverallValue);
Assert.Equal(0, f.ReportGrades.SavedCount);
Assert.Equal(AssistantGradeStatus.Noted, vm.Students[0].Status);
Assert.Equal("3-", vm.Students[0].GradeDisplay);
Assert.Equal(Ben.Id, vm.SelectedStudent!.StudentId);
// Erneutes Notieren im selben Durchgang überschreibt statt zu verdoppeln.
vm.SelectedStudent = vm.Students[0];
Assert.True(vm.HasInterimEntry);
Assert.Equal("3-", vm.InterimOverall);
vm.InterimOverall = "4";
vm.NoteInterimCommand.Execute(null);
Assert.Equal("4", Assert.Single(f.InterimGrades.All).OverallValue);
vm.RemoveInterimCommand.Execute(null);
Assert.Empty(f.InterimGrades.All);
Assert.Equal(AssistantGradeStatus.Open, vm.Students[0].Status);
}
[Fact]
public void Zwischenstaende_ErscheinenImZeugnisnotenModusAlsListeUndMarker()
{
var f = new Fixture();
f.AddExam("K1", new DateOnly(2025, 10, 1), "3");
f.InterimGrades.Save(new InterimGrade { StudentId = Anna.Id, GroupId = GroupId,
Date = new DateOnly(2025, 11, 12), Occasion = "Sprechtag", WrittenValue = "3", OverallValue = "3" });
var vm = f.Build(new DateOnly(2025, 12, 10));
var row = Assert.Single(vm.InterimEntries);
Assert.Equal("12.11.2025 · Sprechtag", row.Title);
Assert.Equal("schriftlich 3", row.Detail);
Assert.Contains(vm.ChartGroups.SelectMany(g => g.Points), p => p.ExamLabel == "Zwischenstand: 3");
Assert.True(vm.IsReportMode);
}
[Fact]
public void Startdialog_VorauswahlGefaehrdeteUndBestaetigen()
{
var f = new Fixture();
f.AddExam("K1", new DateOnly(2025, 10, 1), "5");
f.Results.Add(new ExamResult { ExamId = f.Exams[0].Id, StudentId = Ben.Id, Grade = "2" });
var vm = f.BuildRunDialog(new DateOnly(2025, 11, 12));
Assert.All(vm.Students, s => Assert.True(s.IsSelected));
Assert.Equal(["5", "2"], vm.Students.Select(s => s.ProvisionalDisplay));
vm.SelectAtRiskCommand.Execute(null);
Assert.Equal([Anna.Id], vm.Students.Where(s => s.IsSelected).Select(s => s.StudentId));
vm.OccasionName = "Blauer Brief";
Assert.True(vm.Confirm());
Assert.Equal(new DateOnly(2025, 11, 12), vm.Result!.Date);
Assert.Equal("Blauer Brief", vm.Result.Occasion);
Assert.Equal([Anna.Id], vm.Result.StudentIds);
}
[Fact]
public void Startdialog_EinzelfallUndValidierung()
{
var f = new Fixture();
var vm = f.BuildRunDialog(new DateOnly(2025, 11, 12), preselected: Ben.Id);
Assert.Equal([Ben.Id], vm.Students.Where(s => s.IsSelected).Select(s => s.StudentId));
vm.OccasionName = "Elternanfrage";
vm.OccasionDetail = "Frau Muster";
Assert.Equal("Elternanfrage: Frau Muster", vm.Occasion);
vm.SelectNoneCommand.Execute(null);
Assert.False(vm.Confirm());
Assert.NotEmpty(vm.SelectionError);
vm.DateText = "12.11.2030";
Assert.False(vm.Confirm());
Assert.NotEmpty(vm.DateTextError);
}
[Fact]
public void Startdialog_BegonnenenDurchgangFortsetzen()
{
var f = new Fixture();
f.InterimGrades.Save(new InterimGrade { StudentId = Anna.Id, GroupId = GroupId,
Date = new DateOnly(2025, 11, 12), Occasion = "Sprechtag: 1. Elternsprechtag", OverallValue = "3" });
var vm = f.BuildRunDialog(new DateOnly(2025, 12, 1));
vm.SelectedExistingRun = Assert.Single(vm.ExistingRuns);
Assert.Equal("12.11.2025", vm.DateText);
Assert.Equal("Sprechtag: 1. Elternsprechtag", vm.Occasion);
Assert.Equal("notiert: 3", vm.Students.Single(s => s.StudentId == Anna.Id).NotedDisplay);
Assert.Equal("", vm.Students.Single(s => s.StudentId == Ben.Id).NotedDisplay);
}
[Fact]
public void Notenuebersicht_ZeigtZwischenstaendeAlsEigeneSpalteOhneEinflussAufGesamt()
{
var f = new Fixture();
f.AddExam("K1", new DateOnly(2025, 10, 1), "2");
f.InterimGrades.Save(new InterimGrade { StudentId = Anna.Id, GroupId = GroupId,
Date = new DateOnly(2025, 11, 12), Occasion = "Sprechtag", OverallValue = "5" });
var vm = new GradeOverviewTabViewModel(f.Grades, new FakeExams(f.Exams), f.Results,
new FakeStudents([Anna, Ben]), new FakeMemberships([]), f.InterimGrades, new GradingService());
vm.Initialize(GroupId, GradingSystem.Grades1To6, GroupType.Class, "Testkurs", "2025/26");
var column = vm.Columns.Last();
Assert.True(column.IsInterim);
Assert.Equal("Zwischenstand 12.11. Sprechtag", column.Header);
var anna = vm.Rows.Single(r => r.StudentId == Anna.Id);
Assert.Equal("5", anna.Cells.Last());
Assert.Equal("2.00", anna.TotalDisplay);
Assert.Equal("", vm.Rows.Single(r => r.StudentId == Ben.Id).Cells.Last());
}
}