Compare commits

..
3 Commits
Author SHA1 Message Date
admin 845cc5fc4c settings update für claude
CI / build-and-test (push) Canceled after 0s
2026-09-19 00:44:30 +02:00
adminandClaude Sonnet 5 dc2f58c4dc feat: Kompetenzzuordnungen von Freitext-Code auf stabile CompetencyItem.Id umgestellt (TODO 16.5)
Unit/Lesson/ExamTask/ParticipationSession referenzierten Kompetenzen bisher per Freitext-Code,
case-insensitiv gegen den Katalog gematcht - fragil bei Umbenennungen und seit der
Bildungsplan-Versionierung nicht mehr eindeutig (zwei Versionen können denselben Code vergeben).
Neuer Werttyp CompetencyReference (ItemId + Code/Description-Momentaufnahme) löst das: solange die
Id noch im Katalog auflösbar ist, zählt die live Fassung (Rename wirkt sofort), sonst bleibt die
gespeicherte historische Fassung sichtbar statt spurlos zu verschwinden.

Migration (Schema-Version 6) löst bestehende Codes gegen den Katalog auf; die zuvor dreifach
duplizierte Kompetenz-Tag-UI ist jetzt in CompetencyTagGroupBuilder konsolidiert.
add_lesson_competency/remove_lesson_competency nehmen jetzt itemId statt code und validieren gegen
den Katalog (vorher ungeprüft).

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-19 00:41:54 +02:00
adminandClaude Sonnet 5 f97edff2fe feat: Bildungsplan-Versionierung für Kompetenzkataloge, vollständig über MCP exponiert
Neue Bildungspläne wachsen je Fach klassenstufenweise hoch, sodass Kurse abhängig vom
Einschulungsjahr entweder dem alten oder dem neuen Bildungsplan folgen. CompetencyCatalogVersion
(Fach + Name + IsDefault) macht das abbildbar: CompetencyDomain bekommt eine VersionId, Kurse
wählen über LearningGroup.CompetencyCatalogVersionId (null = Standardversion des Fachs) welche
Version gilt. Migration legt für bestehende Kataloge automatisch eine Standardversion an, damit
alte Datenbanken unverändert weiterlaufen.

MCP: neue Tools für Versions-CRUD (get/create/update/delete_competency_plan_version,
update_group_competency_version), get_competency_catalog/create_competency_domain um optionalen
versionId-Parameter erweitert.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-19 00:07:29 +02:00
57 changed files with 1712 additions and 359 deletions

No files matched your search

+7
View File
@@ -0,0 +1,7 @@
{
"permissions": {
"allow": [
"Bash(git commit -m ' *)"
]
}
}
+25 -7
View File
@@ -284,16 +284,34 @@ public interface ISubjectRepository
} }
public interface ICompetencyDomainRepository public interface ICompetencyDomainRepository
{ {
List<CompetencyDomain> GetBySubjectAndGrade(Guid subjectId, int gradeLevel); List<CompetencyDomain> GetBySubjectAndGrade(Guid subjectId, int gradeLevel, Guid versionId);
// Über alle Klassenstufen eines Fachs hinweg - für einen Überblick über den gesamten Katalog // Über alle Klassenstufen einer Version eines Fachs hinweg - für einen Überblick über den
// eines Fachs (z.B. MCP-Tool get_competency_catalog ohne gradeLevel-Filter), ohne dass der // gesamten Katalog einer Version (z.B. MCP-Tool get_competency_catalog ohne gradeLevel-Filter),
// Aufrufer erst jede vorkommende Klassenstufe einzeln erraten/abfragen müsste. // ohne dass der Aufrufer erst jede vorkommende Klassenstufe einzeln erraten/abfragen müsste.
List<CompetencyDomain> GetBySubject(Guid subjectId); List<CompetencyDomain> GetBySubjectAndVersion(Guid subjectId, Guid versionId);
// Über alle Fächer/Klassenstufen/Versionen hinweg - für Aufrufer, die eine CompetencyItem.Id
// auflösen müssen, ohne vorher das Fach der Zuordnung zu kennen (z.B. MCP add_lesson_competency).
List<CompetencyDomain> GetAll();
CompetencyDomain? GetById(Guid id); CompetencyDomain? GetById(Guid id);
void Save(CompetencyDomain domain); void Save(CompetencyDomain domain);
void Delete(Guid id); void Delete(Guid id);
void DeleteBySubjectAndGrade(Guid subjectId, int gradeLevel); void DeleteBySubjectGradeAndVersion(Guid subjectId, int gradeLevel, Guid versionId);
void ReplaceForSubjectAndGrade(Guid subjectId, int gradeLevel, List<CompetencyDomain> domains); void ReplaceForSubjectGradeAndVersion(Guid subjectId, int gradeLevel, Guid versionId, List<CompetencyDomain> domains);
}
public interface ICompetencyCatalogVersionRepository
{
List<CompetencyCatalogVersion> GetBySubject(Guid subjectId);
CompetencyCatalogVersion? GetById(Guid id);
/// <summary>Liefert die Standardversion des Fachs und legt sie an ("Bestehender Kompetenzkatalog"),
/// falls noch keine existiert - so brauchen Aufrufer, die nur einen Guid für die Domain-Suche
/// benötigen, keinen eigenen Anlegen-oder-Lesen-Ablauf.</summary>
CompetencyCatalogVersion GetOrCreateDefault(Guid subjectId);
void Save(CompetencyCatalogVersion version);
/// <summary>Blockiert (InvalidOperationException), wenn noch ein CompetencyDomain oder eine
/// LearningGroup diese Version referenziert, oder wenn sie die Standardversion ihres Fachs ist
/// (erst eine andere Version des Fachs als Standard setzen).</summary>
void Delete(Guid id);
} }
public interface IShorthandCodeRepository public interface IShorthandCodeRepository
{ {
+35
View File
@@ -5,6 +5,11 @@ public class CompetencyDomain
public Guid Id { get; set; } = Guid.NewGuid(); public Guid Id { get; set; } = Guid.NewGuid();
public Guid SubjectId { get; set; } public Guid SubjectId { get; set; }
public int GradeLevel { get; set; } public int GradeLevel { get; set; }
/// <summary>Bildungsplan-Version dieses Bereichs (<see cref="CompetencyCatalogVersion"/>) - ein
/// Fach kann mehrere parallel gültige Versionen haben (altes/neues Bildungsplan, während dieser
/// klassenstufenweise hochwächst). Wird von der Migration für bestehende Datensätze auf die
/// jeweilige Standardversion des Fachs gesetzt.</summary>
public Guid VersionId { get; set; }
public string Name { get; set; } = ""; public string Name { get; set; } = "";
public string Code { get; set; } = ""; public string Code { get; set; } = "";
public int SortOrder { get; set; } public int SortOrder { get; set; }
@@ -12,6 +17,22 @@ public class CompetencyDomain
public DateTime UpdatedAt { get; set; } = DateTime.UtcNow; public DateTime UpdatedAt { get; set; } = DateTime.UtcNow;
} }
/// <summary>Eine Bildungsplan-Version eines Fachs (z.B. "Bildungsplan 2016" vs. "Bildungsplan 2026").
/// Ermöglicht es, während ein neuer Bildungsplan klassenstufenweise hochwächst, alten und neuen
/// Kompetenzkatalog parallel zu pflegen - <see cref="LearningGroup.CompetencyCatalogVersionId"/>
/// wählt je Kurs/Klasse, welche Version gilt. Je Fach ist genau eine Version <see cref="IsDefault"/>
/// (Kurse ohne explizite Wahl nutzen sie, siehe Doc-Kommentar auf <see cref="LearningGroup"/>).</summary>
public class CompetencyCatalogVersion
{
public Guid Id { get; set; } = Guid.NewGuid();
public Guid SubjectId { get; set; }
public string Name { get; set; } = "";
public bool IsDefault { get; set; }
public int SortOrder { get; set; }
public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
public DateTime UpdatedAt { get; set; } = DateTime.UtcNow;
}
public class CompetencyItem public class CompetencyItem
{ {
public Guid Id { get; set; } = Guid.NewGuid(); public Guid Id { get; set; } = Guid.NewGuid();
@@ -19,3 +40,17 @@ public class CompetencyItem
public string Description { get; set; } = ""; public string Description { get; set; } = "";
public int SortOrder { get; set; } public int SortOrder { get; set; }
} }
/// <summary>Referenz auf eine Kompetenz aus dem Katalog, momentaufnahmeartig gespeichert (analog zu
/// Exam.GradingKey/Exam.Tasks, siehe Datenmodell.md "Bewusst gespeicherte Momentaufnahmen"):
/// Code/Description werden zum Zuordnungszeitpunkt kopiert. Solange ItemId noch im Katalog
/// auflösbar ist, zeigt die UI die live aufgelöste Fassung (ein Rename wirkt sich sofort überall
/// aus); wird das Item gelöscht, bleibt die hier gespeicherte historische Fassung lesbar statt
/// spurlos zu verschwinden. ItemId == Guid.Empty markiert eine nie aufgelöste Referenz (z.B. aus
/// einem plattformübergreifenden Import) - Code/Description sind dann die einzige Information.</summary>
public class CompetencyReference
{
public Guid ItemId { get; set; }
public string Code { get; set; } = "";
public string Description { get; set; } = "";
}
+1 -1
View File
@@ -28,7 +28,7 @@ public class ExamTask
public string? Title { get; set; } public string? Title { get; set; }
public double MaxPoints { get; set; } public double MaxPoints { get; set; }
public double Weight { get; set; } = 1.0; public double Weight { get; set; } = 1.0;
public List<string> CompetencyCodes { get; set; } = []; public List<CompetencyReference> Competencies { get; set; } = [];
} }
public class GradingKeyEntry public class GradingKeyEntry
{ {
+8
View File
@@ -8,6 +8,14 @@ public class LearningGroup
public Guid? SubjectId { get; set; } public Guid? SubjectId { get; set; }
public string SchoolYear { get; set; } = ""; public string SchoolYear { get; set; } = "";
public int GradeLevel { get; set; } public int GradeLevel { get; set; }
/// <summary>
/// Gewählte Bildungsplan-Version (<see cref="CompetencyCatalogVersion"/>) für den Kompetenzkatalog
/// dieses Kurses/dieser Klasse. Null bedeutet bewusst nicht "keine Version", sondern "Standardversion
/// des Fachs" (<see cref="CompetencyCatalogVersion.IsDefault"/>) - analog dazu, dass das Schuljahr
/// nicht auf der Mitgliedschaft dupliziert wird, sondern von der Gruppe geerbt wird. So brauchen
/// bestehende Kurse ohne neuen Bildungsplan keine Migration.
/// </summary>
public Guid? CompetencyCatalogVersionId { get; set; }
public GradingSystem GradingSystem { get; set; } public GradingSystem GradingSystem { get; set; }
public int? HoursPerWeek { get; set; } public int? HoursPerWeek { get; set; }
public bool IsActive { get; set; } = true; public bool IsActive { get; set; } = true;
+3 -3
View File
@@ -7,7 +7,7 @@ public class ParticipationSession
public DateOnly Date { get; set; } = DateOnly.FromDateTime(DateTime.Today); public DateOnly Date { get; set; } = DateOnly.FromDateTime(DateTime.Today);
public Guid? LessonId { get; set; } public Guid? LessonId { get; set; }
public string? Comment { get; set; } public string? Comment { get; set; }
public List<string> CompetencyCodes { get; set; } = []; public List<CompetencyReference> Competencies { get; set; } = [];
public DateTime CreatedAt { get; set; } = DateTime.UtcNow; public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
public DateTime UpdatedAt { get; set; } = DateTime.UtcNow; public DateTime UpdatedAt { get; set; } = DateTime.UtcNow;
} }
@@ -101,8 +101,8 @@ public class ParticipationSection
public class CompetencyRating public class CompetencyRating
{ {
public string Code { get; set; } = ""; public Guid ItemId { get; set; }
public int Value { get; set; } public int Value { get; set; }
} }
public class AspectRating public class AspectRating
+6 -6
View File
@@ -37,7 +37,7 @@ public class Unit
public string Title { get; set; } = ""; public string Title { get; set; } = "";
public DateOnly? StartDate { get; set; } public DateOnly? StartDate { get; set; }
public DateOnly? EndDate { get; set; } public DateOnly? EndDate { get; set; }
public List<string> Competencies { get; set; } = []; public List<CompetencyReference> Competencies { get; set; } = [];
public UnitStatus Status { get; set; } = UnitStatus.Planned; public UnitStatus Status { get; set; } = UnitStatus.Planned;
public string? Notes { get; set; } public string? Notes { get; set; }
public DateTime CreatedAt { get; set; } = DateTime.UtcNow; public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
@@ -71,11 +71,11 @@ public class Lesson : IHasAttachments
/// wenn die Hausaufgabe absichtlich nicht mehr kontrolliert wird). /// wenn die Hausaufgabe absichtlich nicht mehr kontrolliert wird).
public bool HomeworkCheckDismissed { get; set; } public bool HomeworkCheckDismissed { get; set; }
public string? Reflection { get; set; } public string? Reflection { get; set; }
/// Kompetenzcodes (<see cref="CompetencyItem.Code"/>) aus dem Katalog, die dieser Stunde als /// Kompetenzen aus dem Katalog, die dieser Stunde als Ganzes zugeordnet sind — analog zu
/// Ganzes zugeordnet sind — analog zu <see cref="Unit.Competencies"/>, aber auf Stundenebene statt /// <see cref="Unit.Competencies"/>, aber auf Stundenebene statt Einheitenebene. Bewusst noch
/// Einheitenebene. Bewusst noch keine Verknüpfung je einzelner <see cref="LessonPhaseStep"/> /// keine Verknüpfung je einzelner <see cref="LessonPhaseStep"/> (siehe TODO.md 4.5.8, weiterhin
/// (siehe TODO.md 4.5.8, weiterhin offen); diese Liste deckt nur die gröbere Zuordnung ab. /// offen); diese Liste deckt nur die gröbere Zuordnung ab.
public List<string> Competencies { get; set; } = []; public List<CompetencyReference> Competencies { get; set; } = [];
public LessonStatus Status { get; set; } = LessonStatus.Planned; public LessonStatus Status { get; set; } = LessonStatus.Planned;
/// Material/Arbeitsblätter sowie fachspezifische Anhänge (z.B. Experiment- und /// Material/Arbeitsblätter sowie fachspezifische Anhänge (z.B. Experiment- und
/// Gefährdungsbeurteilungs-Dokumente im Chemieunterricht) — dieselbe Anhang-Infrastruktur wie /// Gefährdungsbeurteilungs-Dokumente im Chemieunterricht) — dieselbe Anhang-Infrastruktur wie
@@ -32,31 +32,54 @@ public sealed class CompetencyAnalysisService
IReadOnlyList<ExamResult> results) IReadOnlyList<ExamResult> results)
{ {
var builders = new List<ItemBuilder>(); var builders = new List<ItemBuilder>();
var byCode = new Dictionary<string, ItemBuilder>(StringComparer.OrdinalIgnoreCase); var byId = new Dictionary<Guid, ItemBuilder>();
// Referenzen, die nie einem Katalogeintrag zugeordnet werden konnten (ItemId == Guid.Empty,
// z.B. aus einem plattformübergreifenden Import) haben keine gemeinsame Id, über die
// mehrfache Zuordnungen derselben Kompetenz zusammengeführt werden könnten - dafür wird
// ersatzweise der Code-Text als Merge-Schlüssel verwendet.
var byUnresolvedCode = new Dictionary<string, ItemBuilder>(StringComparer.OrdinalIgnoreCase);
foreach (var domain in catalog.OrderBy(x => x.SortOrder)) foreach (var domain in catalog.OrderBy(x => x.SortOrder))
foreach (var item in domain.Items.OrderBy(x => x.SortOrder)) foreach (var item in domain.Items.OrderBy(x => x.SortOrder))
{ {
var builder = new ItemBuilder(domain.Name, domain.Code, item.Code, item.Description); var builder = new ItemBuilder(domain.Name, domain.Code, item.Code, item.Description);
builders.Add(builder); builders.Add(builder);
if (!string.IsNullOrWhiteSpace(item.Code)) byCode.TryAdd(item.Code.Trim(), builder); byId.TryAdd(item.Id, builder);
} }
ItemBuilder GetOrAdd(string rawCode) // Solange die Referenz noch im aktuellen Katalog auflösbar ist, zählt die LIVE-Fassung
// (ein Rename wirkt sich damit sofort aus). Ist sie es nicht mehr (gelöscht, andere
// Bildungsplan-Version, oder nie aufgelöster plattformübergreifender Import), wird ein
// Platzhalter aus der zum Zuordnungszeitpunkt gespeicherten Momentaufnahme synthetisiert -
// dadurch bleibt (anders als bei der bisherigen reinen Code-Textkonserve) sogar die echte
// historische Beschreibung erhalten.
ItemBuilder GetOrAdd(CompetencyReference reference)
{ {
var code = rawCode.Trim(); var description = string.IsNullOrWhiteSpace(reference.Description)
if (byCode.TryGetValue(code, out var existing)) return existing; ? "Diese Kompetenz wird noch verwendet, ist aber nicht (mehr) im aktuellen Katalog enthalten."
var added = new ItemBuilder("Nicht im Katalog", "", code, : reference.Description;
"Dieser Kompetenzcode wird noch verwendet, ist aber nicht im aktuellen Katalog enthalten.");
byCode[code] = added; if (reference.ItemId == Guid.Empty)
{
var codeKey = reference.Code.Trim();
if (byUnresolvedCode.TryGetValue(codeKey, out var existingUnresolved)) return existingUnresolved;
var addedUnresolved = new ItemBuilder("Nicht im Katalog", "", reference.Code, description);
byUnresolvedCode[codeKey] = addedUnresolved;
builders.Add(addedUnresolved);
return addedUnresolved;
}
if (byId.TryGetValue(reference.ItemId, out var existing)) return existing;
var added = new ItemBuilder("Nicht im Katalog", "", reference.Code, description);
byId[reference.ItemId] = added;
builders.Add(added); builders.Add(added);
return added; return added;
} }
foreach (var unit in units) foreach (var unit in units)
foreach (var code in NormalizeCodes(unit.Competencies)) foreach (var reference in NormalizeReferences(unit.Competencies))
{ {
var builder = GetOrAdd(code); var builder = GetOrAdd(reference);
if (unit.Status == UnitStatus.Planned) builder.PlannedUnits++; if (unit.Status == UnitStatus.Planned) builder.PlannedUnits++;
else builder.TaughtUnits++; else builder.TaughtUnits++;
} }
@@ -64,10 +87,10 @@ public sealed class CompetencyAnalysisService
var resultsByExam = results.GroupBy(x => x.ExamId).ToDictionary(x => x.Key, x => x.ToList()); var resultsByExam = results.GroupBy(x => x.ExamId).ToDictionary(x => x.Key, x => x.ToList());
foreach (var exam in exams) foreach (var exam in exams)
{ {
var examCodes = NormalizeCodes(exam.Tasks.SelectMany(x => x.CompetencyCodes)); var examReferences = NormalizeReferences(exam.Tasks.SelectMany(x => x.Competencies));
foreach (var code in examCodes) foreach (var reference in examReferences)
{ {
var builder = GetOrAdd(code); var builder = GetOrAdd(reference);
if (exam.Status == ExamStatus.Planned) builder.PlannedExams++; if (exam.Status == ExamStatus.Planned) builder.PlannedExams++;
else builder.AssessedExams++; else builder.AssessedExams++;
} }
@@ -81,17 +104,16 @@ public sealed class CompetencyAnalysisService
var task = exam.Tasks[taskIndex]; var task = exam.Tasks[taskIndex];
if (task.MaxPoints <= 0) continue; if (task.MaxPoints <= 0) continue;
var achieved = Math.Clamp(result.Points[taskIndex], 0, task.MaxPoints); var achieved = Math.Clamp(result.Points[taskIndex], 0, task.MaxPoints);
foreach (var code in NormalizeCodes(task.CompetencyCodes)) foreach (var reference in NormalizeReferences(task.Competencies))
GetOrAdd(code).AddScore(result.StudentId, achieved, task.MaxPoints); GetOrAdd(reference).AddScore(result.StudentId, achieved, task.MaxPoints);
} }
} }
return builders.Select(x => x.Build()).ToList(); return builders.Select(x => x.Build()).ToList();
} }
private static bool HasCode(string? value) => !string.IsNullOrWhiteSpace(value); private static IEnumerable<CompetencyReference> NormalizeReferences(IEnumerable<CompetencyReference> references) =>
private static IEnumerable<string> NormalizeCodes(IEnumerable<string> codes) => references.DistinctBy(x => x.ItemId);
codes.Where(HasCode).Select(x => x.Trim()).Distinct(StringComparer.OrdinalIgnoreCase);
private sealed class ItemBuilder( private sealed class ItemBuilder(
string domainName, string domainCode, string code, string description) string domainName, string domainCode, string code, string description)
@@ -15,6 +15,7 @@ public sealed class CompetencyCatalogImportPreview
public required Guid SubjectId { get; init; } public required Guid SubjectId { get; init; }
public required string SubjectName { get; init; } public required string SubjectName { get; init; }
public required int GradeLevel { get; init; } public required int GradeLevel { get; init; }
public required Guid VersionId { get; init; }
public required List<CompetencyDomain> ImportedDomains { get; init; } public required List<CompetencyDomain> ImportedDomains { get; init; }
public required string ExistingFingerprint { get; init; } public required string ExistingFingerprint { get; init; }
public List<string> Warnings { get; init; } = []; public List<string> Warnings { get; init; } = [];
@@ -28,7 +29,7 @@ public sealed class CompetencyCatalogImportPreview
public sealed class CompetencyCatalogImportService(ICompetencyDomainRepository repository) public sealed class CompetencyCatalogImportService(ICompetencyDomainRepository repository)
{ {
public CompetencyCatalogImportPreview Analyze( public CompetencyCatalogImportPreview Analyze(
string json, Guid subjectId, string subjectName, int gradeLevel) string json, Guid subjectId, string subjectName, int gradeLevel, Guid versionId)
{ {
CatalogDto dto; CatalogDto dto;
try try
@@ -100,7 +101,7 @@ public sealed class CompetencyCatalogImportService(ICompetencyDomainRepository r
if (dto.GradeLevel is > 0 and <= 13 && dto.GradeLevel != gradeLevel) if (dto.GradeLevel is > 0 and <= 13 && dto.GradeLevel != gradeLevel)
warnings.Add($"Die Datei nennt Klassenstufe {dto.GradeLevel}, ausgewählt ist Klassenstufe {gradeLevel}."); warnings.Add($"Die Datei nennt Klassenstufe {dto.GradeLevel}, ausgewählt ist Klassenstufe {gradeLevel}.");
var existing = repository.GetBySubjectAndGrade(subjectId, gradeLevel); var existing = repository.GetBySubjectAndGrade(subjectId, gradeLevel, versionId);
var conflicts = new List<CompetencyCatalogImportConflict>(); var conflicts = new List<CompetencyCatalogImportConflict>();
var newDomains = 0; var newDomains = 0;
var newItems = 0; var newItems = 0;
@@ -147,6 +148,7 @@ public sealed class CompetencyCatalogImportService(ICompetencyDomainRepository r
SubjectId = subjectId, SubjectId = subjectId,
SubjectName = subjectName, SubjectName = subjectName,
GradeLevel = gradeLevel, GradeLevel = gradeLevel,
VersionId = versionId,
ImportedDomains = imported, ImportedDomains = imported,
ExistingFingerprint = Fingerprint(existing), ExistingFingerprint = Fingerprint(existing),
Warnings = warnings, Warnings = warnings,
@@ -160,7 +162,7 @@ public sealed class CompetencyCatalogImportService(ICompetencyDomainRepository r
public void Apply(CompetencyCatalogImportPreview preview, CompetencyCatalogImportMode mode, public void Apply(CompetencyCatalogImportPreview preview, CompetencyCatalogImportMode mode,
IReadOnlySet<string>? useImportedConflicts = null) IReadOnlySet<string>? useImportedConflicts = null)
{ {
var current = repository.GetBySubjectAndGrade(preview.SubjectId, preview.GradeLevel); var current = repository.GetBySubjectAndGrade(preview.SubjectId, preview.GradeLevel, preview.VersionId);
if (Fingerprint(current) != preview.ExistingFingerprint) if (Fingerprint(current) != preview.ExistingFingerprint)
throw new InvalidOperationException( throw new InvalidOperationException(
"Der Kompetenzkatalog wurde seit der Vorschau verändert. Bitte öffne den Import erneut."); "Der Kompetenzkatalog wurde seit der Vorschau verändert. Bitte öffne den Import erneut.");
@@ -169,7 +171,7 @@ public sealed class CompetencyCatalogImportService(ICompetencyDomainRepository r
? preview.ImportedDomains.Select((d, index) => CloneAsNew(d, preview.SubjectId, preview.GradeLevel, index)).ToList() ? preview.ImportedDomains.Select((d, index) => CloneAsNew(d, preview.SubjectId, preview.GradeLevel, index)).ToList()
: Merge(current, preview, useImportedConflicts ?? new HashSet<string>()); : Merge(current, preview, useImportedConflicts ?? new HashSet<string>());
repository.ReplaceForSubjectAndGrade(preview.SubjectId, preview.GradeLevel, result); repository.ReplaceForSubjectGradeAndVersion(preview.SubjectId, preview.GradeLevel, preview.VersionId, result);
} }
private static List<CompetencyDomain> Merge(List<CompetencyDomain> existing, private static List<CompetencyDomain> Merge(List<CompetencyDomain> existing,
@@ -0,0 +1,17 @@
using LehrerApp.Core.Interfaces;
namespace LehrerApp.Core.Services;
/// <summary>Löst die für einen Kurs/eine Klasse geltende Bildungsplan-Version auf: die explizit am
/// Kurs gewählte Version (<see cref="Models.LearningGroup.CompetencyCatalogVersionId"/>), falls sie
/// noch existiert, sonst die Standardversion des Fachs (siehe Doc-Kommentar auf dem Feld). Ohne Fach
/// gibt es keine Version (<see cref="Guid.Empty"/>).</summary>
public static class CompetencyCatalogVersionResolver
{
public static Guid Resolve(ICompetencyCatalogVersionRepository versions, Guid? subjectId, Guid? groupVersionId)
{
if (subjectId is not Guid sid) return Guid.Empty;
if (groupVersionId is Guid vid && versions.GetById(vid) is { } explicitVersion) return explicitVersion.Id;
return versions.GetOrCreateDefault(sid).Id;
}
}
@@ -123,7 +123,7 @@ public sealed class ChangeHookCascadeTests
} }
[Fact] [Fact]
public void CompetencyDomainRepository_ReplaceForSubjectAndGrade_LoestDeleteFuerAlteUndSaveFuerNeueAus() public void CompetencyDomainRepository_ReplaceForSubjectGradeAndVersion_LoestDeleteFuerAlteUndSaveFuerNeueAus()
{ {
using var db = NewInMemoryContext(); using var db = NewInMemoryContext();
var repo = new CompetencyDomainRepository(db); var repo = new CompetencyDomainRepository(db);
@@ -132,7 +132,7 @@ public sealed class ChangeHookCascadeTests
var calls = new List<(string EntityType, string Operation)>(); var calls = new List<(string EntityType, string Operation)>();
db.OnChange = (type, id, op, payload) => calls.Add((type, op)); db.OnChange = (type, id, op, payload) => calls.Add((type, op));
repo.ReplaceForSubjectAndGrade(subjectId, 8, repo.ReplaceForSubjectGradeAndVersion(subjectId, 8, Guid.Empty,
[ [
new CompetencyDomain { Name = "Neu 1" }, new CompetencyDomain { Name = "Neu 1" },
new CompetencyDomain { Name = "Neu 2" }, new CompetencyDomain { Name = "Neu 2" },
@@ -145,7 +145,7 @@ public sealed class ChangeHookCascadeTests
} }
[Fact] [Fact]
public void CompetencyDomainRepository_DeleteBySubjectAndGrade_LoestEinEreignisProDomaenAus() public void CompetencyDomainRepository_DeleteBySubjectGradeAndVersion_LoestEinEreignisProDomaenAus()
{ {
using var db = NewInMemoryContext(); using var db = NewInMemoryContext();
var repo = new CompetencyDomainRepository(db); var repo = new CompetencyDomainRepository(db);
@@ -155,7 +155,7 @@ public sealed class ChangeHookCascadeTests
var calls = new List<(string EntityType, string Operation)>(); var calls = new List<(string EntityType, string Operation)>();
db.OnChange = (type, id, op, payload) => calls.Add((type, op)); db.OnChange = (type, id, op, payload) => calls.Add((type, op));
repo.DeleteBySubjectAndGrade(subjectId, 8); repo.DeleteBySubjectGradeAndVersion(subjectId, 8, Guid.Empty);
Assert.Equal(2, calls.Count); Assert.Equal(2, calls.Count);
Assert.All(calls, c => Assert.Equal((nameof(CompetencyDomain), "Delete"), c)); Assert.All(calls, c => Assert.Equal((nameof(CompetencyDomain), "Delete"), c));
@@ -121,6 +121,14 @@ public sealed class ChangeHookMatrixTests
return (subject.Id, () => repo.Delete(subject.Id)); return (subject.Id, () => repo.Delete(subject.Id));
}); });
yield return Case("CompetencyCatalogVersion", nameof(CompetencyCatalogVersion), db =>
{
var repo = new CompetencyCatalogVersionRepository(db);
var version = new CompetencyCatalogVersion { SubjectId = Guid.NewGuid(), Name = "Bildungsplan 2026" };
repo.Save(version);
return (version.Id, () => repo.Delete(version.Id));
});
yield return Case("ShorthandCode", nameof(ShorthandCode), db => yield return Case("ShorthandCode", nameof(ShorthandCode), db =>
{ {
var repo = new ShorthandCodeRepository(db); var repo = new ShorthandCodeRepository(db);
+134 -2
View File
@@ -121,7 +121,7 @@ public sealed class LiteDbContextTests
using var temp = new TempDatabase(); using var temp = new TempDatabase();
using var context = new LiteDbContext(temp.Path); using var context = new LiteDbContext(temp.Path);
Assert.Equal(4, context.SchemaVersion); Assert.Equal(6, context.SchemaVersion);
} }
[Fact] [Fact]
@@ -132,7 +132,139 @@ public sealed class LiteDbContextTests
using var second = new LiteDbContext(temp.Path); using var second = new LiteDbContext(temp.Path);
Assert.Equal(4, second.SchemaVersion); Assert.Equal(6, second.SchemaVersion);
}
[Fact]
public void MigrateCompetencyCatalogVersions_ErzeugtStandardversionJeFachUndVerknuepftBestehendeBereiche()
{
using var temp = new TempDatabase();
var subjectAId = Guid.NewGuid();
var subjectBId = Guid.NewGuid();
var domainA1Id = Guid.NewGuid();
var domainA2Id = Guid.NewGuid();
var domainBId = Guid.NewGuid();
using (var legacy = new LiteDatabase(temp.Path))
{
var domains = legacy.GetCollection<BsonDocument>("competency_domains");
domains.Insert(new BsonDocument
{
["_id"] = domainA1Id, [nameof(CompetencyDomain.SubjectId)] = subjectAId,
[nameof(CompetencyDomain.GradeLevel)] = 8, [nameof(CompetencyDomain.Name)] = "Bereich A1",
});
domains.Insert(new BsonDocument
{
["_id"] = domainA2Id, [nameof(CompetencyDomain.SubjectId)] = subjectAId,
[nameof(CompetencyDomain.GradeLevel)] = 9, [nameof(CompetencyDomain.Name)] = "Bereich A2",
});
domains.Insert(new BsonDocument
{
["_id"] = domainBId, [nameof(CompetencyDomain.SubjectId)] = subjectBId,
[nameof(CompetencyDomain.GradeLevel)] = 8, [nameof(CompetencyDomain.Name)] = "Bereich B",
});
}
using var context = new LiteDbContext(temp.Path);
var versions = context.CompetencyCatalogVersions.FindAll().ToList();
var versionA = Assert.Single(versions, v => v.SubjectId == subjectAId);
var versionB = Assert.Single(versions, v => v.SubjectId == subjectBId);
Assert.True(versionA.IsDefault);
Assert.True(versionB.IsDefault);
Assert.Equal("Bestehender Kompetenzkatalog", versionA.Name);
var domainsAfter = context.CompetencyDomains.FindAll().ToDictionary(d => d.Id);
Assert.Equal(versionA.Id, domainsAfter[domainA1Id].VersionId);
Assert.Equal(versionA.Id, domainsAfter[domainA2Id].VersionId);
Assert.Equal(versionB.Id, domainsAfter[domainBId].VersionId);
}
[Fact]
public void MigrateCompetencyReferences_LoestCodesGegenKatalogAufUndBehaeltUnbekannteAlsText()
{
using var temp = new TempDatabase();
var unitId = Guid.NewGuid();
var examId = Guid.NewGuid();
var sessionId = Guid.NewGuid();
var entryId = Guid.NewGuid();
var itemId = Guid.NewGuid();
using (var legacy = new LiteDatabase(temp.Path))
{
legacy.GetCollection<BsonDocument>("competency_domains").Insert(new BsonDocument
{
["_id"] = Guid.NewGuid(),
[nameof(CompetencyDomain.Name)] = "Bereich",
[nameof(CompetencyDomain.Items)] = new BsonArray
{
new BsonDocument
{
["_id"] = itemId,
[nameof(CompetencyItem.Code)] = "K1",
[nameof(CompetencyItem.Description)] = "Erste Kompetenz",
},
},
});
legacy.GetCollection<BsonDocument>("units").Insert(new BsonDocument
{
["_id"] = unitId,
[nameof(Unit.GroupId)] = Guid.NewGuid(),
[nameof(Unit.Competencies)] = new BsonArray { "K1", "ALT" },
});
legacy.GetCollection<BsonDocument>("exams").Insert(new BsonDocument
{
["_id"] = examId,
[nameof(Exam.GroupId)] = Guid.NewGuid(),
[nameof(Exam.Tasks)] = new BsonArray
{
new BsonDocument { ["Nr"] = 1, ["MaxPoints"] = 10.0, ["CompetencyCodes"] = new BsonArray { "K1" } },
},
});
legacy.GetCollection<BsonDocument>("participation_sessions").Insert(new BsonDocument
{
["_id"] = sessionId,
[nameof(ParticipationSession.GroupId)] = Guid.NewGuid(),
["CompetencyCodes"] = new BsonArray { "K1" },
});
legacy.GetCollection<BsonDocument>("participation").Insert(new BsonDocument
{
["_id"] = entryId,
[nameof(ParticipationEntry.SessionId)] = sessionId,
[nameof(ParticipationEntry.StudentId)] = Guid.NewGuid(),
[nameof(ParticipationEntry.CompetencyRatings)] = new BsonArray
{
new BsonDocument { ["Code"] = "K1", ["Value"] = 2 },
new BsonDocument { ["Code"] = "UNBEKANNT", ["Value"] = 1 },
},
});
}
using var context = new LiteDbContext(temp.Path);
var unit = context.Units.FindById(unitId);
Assert.Equal(2, unit!.Competencies.Count);
var known = unit.Competencies.Single(c => c.Code == "K1");
Assert.Equal(itemId, known.ItemId);
Assert.Equal("Erste Kompetenz", known.Description);
var unknown = unit.Competencies.Single(c => c.Code == "ALT");
Assert.Equal(Guid.Empty, unknown.ItemId);
var exam = context.Exams.FindById(examId);
var task = Assert.Single(exam!.Tasks);
var examRef = Assert.Single(task.Competencies);
Assert.Equal(itemId, examRef.ItemId);
var session = context.ParticipationSessions.FindById(sessionId);
var sessionRef = Assert.Single(session!.Competencies);
Assert.Equal(itemId, sessionRef.ItemId);
// Rating mit unbekanntem Code wird verworfen (kein sinnvoll erhaltbarer Zahlenwert ohne
// erkennbare Identität) - nur das auflösbare Rating bleibt übrig.
var entry = context.ParticipationEntries.FindById(entryId);
var rating = Assert.Single(entry!.CompetencyRatings);
Assert.Equal(itemId, rating.ItemId);
Assert.Equal(2, rating.Value);
} }
[Fact] [Fact]
+89
View File
@@ -1249,4 +1249,93 @@ public sealed class RepositoryTests
Assert.Equal(studentId, item.StudentId); Assert.Equal(studentId, item.StudentId);
Assert.True(item.IsDone); Assert.True(item.IsDone);
} }
// ── CompetencyCatalogVersionRepository ──────────────────────────────────────────────────
[Fact]
public void CompetencyCatalogVersionRepository_GetOrCreateDefault_LegtGenauEinmalAn()
{
using var db = NewInMemoryContext();
var repo = new CompetencyCatalogVersionRepository(db);
var subjectId = Guid.NewGuid();
var first = repo.GetOrCreateDefault(subjectId);
var second = repo.GetOrCreateDefault(subjectId);
Assert.Equal(first.Id, second.Id);
Assert.True(first.IsDefault);
Assert.Single(repo.GetBySubject(subjectId));
}
[Fact]
public void CompetencyCatalogVersionRepository_Save_NimmtVorherigeStandardversionZurueck()
{
using var db = NewInMemoryContext();
var repo = new CompetencyCatalogVersionRepository(db);
var subjectId = Guid.NewGuid();
var alt = repo.GetOrCreateDefault(subjectId);
var neu = new CompetencyCatalogVersion { SubjectId = subjectId, Name = "Bildungsplan 2026", IsDefault = true };
repo.Save(neu);
Assert.False(repo.GetById(alt.Id)!.IsDefault);
Assert.True(repo.GetById(neu.Id)!.IsDefault);
}
[Fact]
public void CompetencyCatalogVersionRepository_Delete_BlockiertStandardversion()
{
using var db = NewInMemoryContext();
var repo = new CompetencyCatalogVersionRepository(db);
var version = repo.GetOrCreateDefault(Guid.NewGuid());
Assert.Throws<InvalidOperationException>(() => repo.Delete(version.Id));
}
[Fact]
public void CompetencyCatalogVersionRepository_Delete_BlockiertBeiReferenzierendemKompetenzbereich()
{
using var db = NewInMemoryContext();
var versionRepo = new CompetencyCatalogVersionRepository(db);
var domainRepo = new CompetencyDomainRepository(db);
var subjectId = Guid.NewGuid();
var version = new CompetencyCatalogVersion { SubjectId = subjectId, Name = "Bildungsplan 2026" };
versionRepo.Save(version);
domainRepo.Save(new CompetencyDomain { SubjectId = subjectId, GradeLevel = 5, VersionId = version.Id, Name = "Bereich" });
Assert.Throws<InvalidOperationException>(() => versionRepo.Delete(version.Id));
}
[Fact]
public void CompetencyCatalogVersionRepository_Delete_BlockiertBeiReferenzierenderGruppe()
{
using var db = NewInMemoryContext();
var versionRepo = new CompetencyCatalogVersionRepository(db);
var groupRepo = new GroupRepository(db);
var subject = new Subject { Name = "Chemie" };
new SubjectRepository(db).Save(subject);
var version = new CompetencyCatalogVersion { SubjectId = subject.Id, Name = "Bildungsplan 2026" };
versionRepo.Save(version);
groupRepo.Save(new LearningGroup
{
Name = "9a", SchoolYear = "2025/26", SubjectId = subject.Id, CompetencyCatalogVersionId = version.Id,
});
Assert.Throws<InvalidOperationException>(() => versionRepo.Delete(version.Id));
}
[Fact]
public void CompetencyCatalogVersionRepository_Delete_ErlaubtUnbenutzteNichtStandardversion()
{
using var db = NewInMemoryContext();
var repo = new CompetencyCatalogVersionRepository(db);
var subjectId = Guid.NewGuid();
repo.GetOrCreateDefault(subjectId);
var extra = new CompetencyCatalogVersion { SubjectId = subjectId, Name = "Entwurf" };
repo.Save(extra);
repo.Delete(extra.Id);
Assert.Null(repo.GetById(extra.Id));
}
} }
+147 -1
View File
@@ -15,7 +15,7 @@ public class LiteDbContext : IDisposable
/// Aktuelle Schema-Version. Migrationsschritte werden versioniert unter /// Aktuelle Schema-Version. Migrationsschritte werden versioniert unter
/// <see cref="RunVersionedMigrations"/> ergänzt, statt bei jedem Start erneut /// <see cref="RunVersionedMigrations"/> ergänzt, statt bei jedem Start erneut
/// (idempotent, aber unnötig) über alle Daten zu laufen. /// (idempotent, aber unnötig) über alle Daten zu laufen.
private const int CurrentSchemaVersion = 4; private const int CurrentSchemaVersion = 6;
private readonly LiteDatabase _db; private readonly LiteDatabase _db;
@@ -61,6 +61,7 @@ public class LiteDbContext : IDisposable
public ILiteCollection<ParticipationSection> ParticipationSections => _db.GetCollection<ParticipationSection>("participation_sections"); public ILiteCollection<ParticipationSection> ParticipationSections => _db.GetCollection<ParticipationSection>("participation_sections");
public ILiteCollection<Subject> Subjects => _db.GetCollection<Subject>("subjects"); public ILiteCollection<Subject> Subjects => _db.GetCollection<Subject>("subjects");
public ILiteCollection<CompetencyDomain> CompetencyDomains => _db.GetCollection<CompetencyDomain>("competency_domains"); public ILiteCollection<CompetencyDomain> CompetencyDomains => _db.GetCollection<CompetencyDomain>("competency_domains");
public ILiteCollection<CompetencyCatalogVersion> CompetencyCatalogVersions => _db.GetCollection<CompetencyCatalogVersion>("competency_catalog_versions");
public ILiteCollection<ShorthandCode> ShorthandCodes => _db.GetCollection<ShorthandCode>("shorthand_codes"); public ILiteCollection<ShorthandCode> ShorthandCodes => _db.GetCollection<ShorthandCode>("shorthand_codes");
public ILiteCollection<AlternativeLessonPath> AlternativeLessonPaths => _db.GetCollection<AlternativeLessonPath>("alternative_lesson_paths"); public ILiteCollection<AlternativeLessonPath> AlternativeLessonPaths => _db.GetCollection<AlternativeLessonPath>("alternative_lesson_paths");
public ILiteCollection<TimetableSlot> TimetableSlots => _db.GetCollection<TimetableSlot>("timetable_slots"); public ILiteCollection<TimetableSlot> TimetableSlots => _db.GetCollection<TimetableSlot>("timetable_slots");
@@ -262,6 +263,16 @@ public class LiteDbContext : IDisposable
MigrateLessonAlternativePaths(); MigrateLessonAlternativePaths();
version = 4; version = 4;
} }
if (version < 5)
{
MigrateCompetencyCatalogVersions();
version = 5;
}
if (version < 6)
{
MigrateCompetencyReferences();
version = 6;
}
WriteSchemaVersion(version); WriteSchemaVersion(version);
} }
@@ -485,6 +496,139 @@ public class LiteDbContext : IDisposable
} }
} }
/// <summary>Backfill für <see cref="CompetencyDomain.VersionId"/>: bestehende Bereiche (vor
/// Einführung der Bildungsplan-Versionierung, also ohne VersionId) bekommen je Fach genau eine
/// neu angelegte Standardversion ("Bestehender Kompetenzkatalog"). LearningGroup.CompetencyCatalogVersionId
/// bleibt bewusst null (= Standardversion) - siehe Doc-Kommentar auf dem Feld.</summary>
private void MigrateCompetencyCatalogVersions()
{
var defaultVersionBySubject = new Dictionary<Guid, Guid>();
foreach (var domain in CompetencyDomains.FindAll().ToList())
{
if (domain.VersionId != Guid.Empty) continue;
if (!defaultVersionBySubject.TryGetValue(domain.SubjectId, out var versionId))
{
var version = new CompetencyCatalogVersion
{
SubjectId = domain.SubjectId, Name = "Bestehender Kompetenzkatalog", IsDefault = true,
};
CompetencyCatalogVersions.Upsert(version);
versionId = version.Id;
defaultVersionBySubject[domain.SubjectId] = versionId;
}
domain.VersionId = versionId;
CompetencyDomains.Update(domain);
}
}
/// <summary>TODO 16.5: stellt Unit/Lesson/ExamTask/ParticipationSession-Kompetenzzuordnungen von
/// Freitext-Codes auf stabile CompetencyItem.Id-Referenzen um (siehe CompetencyReference).
/// Jeder alte Code wird gegen den Katalog aufgelöst (erster Treffer über alle Fächer/Versionen
/// hinweg, case-insensitiv) und als Momentaufnahme {ItemId, Code, Description} gespeichert;
/// ohne Treffer bleibt der Text als ItemId=Guid.Empty erhalten statt verloren zu gehen. Bei
/// ExamTask/ParticipationSession wird das Feld zugleich von "CompetencyCodes" auf "Competencies"
/// umbenannt (das alte typisierte Feld existiert nicht mehr). ParticipationEntry.CompetencyRatings
/// ohne auflösbaren Code werden verworfen - ein Zahlenwert ohne erkennbare Identität ist nicht
/// sinnvoll erhaltbar.</summary>
private void MigrateCompetencyReferences()
{
var byCode = new Dictionary<string, CompetencyItem>(StringComparer.OrdinalIgnoreCase);
foreach (var domain in CompetencyDomains.FindAll())
foreach (var item in domain.Items)
{
if (string.IsNullOrWhiteSpace(item.Code)) continue;
byCode.TryAdd(item.Code.Trim(), item);
}
BsonArray ConvertCodesToReferences(BsonValue oldValue)
{
var result = new BsonArray();
if (!oldValue.IsArray) return result;
foreach (var entry in oldValue.AsArray)
{
if (!entry.IsString) continue;
var code = entry.AsString.Trim();
if (code.Length == 0) continue;
result.Add(byCode.TryGetValue(code, out var item)
? new BsonDocument
{
[nameof(CompetencyReference.ItemId)] = item.Id,
[nameof(CompetencyReference.Code)] = item.Code,
[nameof(CompetencyReference.Description)] = item.Description,
}
: new BsonDocument
{
[nameof(CompetencyReference.ItemId)] = Guid.Empty,
[nameof(CompetencyReference.Code)] = code,
[nameof(CompetencyReference.Description)] = "",
});
}
return result;
}
var units = _db.GetCollection<BsonDocument>("units");
foreach (var doc in units.FindAll().ToList())
{
if (!doc.TryGetValue(nameof(Unit.Competencies), out var old)) continue;
doc[nameof(Unit.Competencies)] = ConvertCodesToReferences(old);
units.Update(doc);
}
var lessonDocs = _db.GetCollection<BsonDocument>("lessons");
foreach (var doc in lessonDocs.FindAll().ToList())
{
if (!doc.TryGetValue(nameof(Lesson.Competencies), out var old)) continue;
doc[nameof(Lesson.Competencies)] = ConvertCodesToReferences(old);
lessonDocs.Update(doc);
}
var exams = _db.GetCollection<BsonDocument>("exams");
foreach (var doc in exams.FindAll().ToList())
{
if (!doc.TryGetValue(nameof(Exam.Tasks), out var tasksValue) || !tasksValue.IsArray) continue;
var changed = false;
foreach (var taskValue in tasksValue.AsArray)
{
if (taskValue is not BsonDocument task) continue;
if (!task.TryGetValue("CompetencyCodes", out var old)) continue;
task.Remove("CompetencyCodes");
task[nameof(ExamTask.Competencies)] = ConvertCodesToReferences(old);
changed = true;
}
if (changed) exams.Update(doc);
}
var sessions = _db.GetCollection<BsonDocument>("participation_sessions");
foreach (var doc in sessions.FindAll().ToList())
{
if (!doc.TryGetValue("CompetencyCodes", out var old)) continue;
doc.Remove("CompetencyCodes");
doc[nameof(ParticipationSession.Competencies)] = ConvertCodesToReferences(old);
sessions.Update(doc);
}
var entries = _db.GetCollection<BsonDocument>("participation");
foreach (var doc in entries.FindAll().ToList())
{
if (!doc.TryGetValue(nameof(ParticipationEntry.CompetencyRatings), out var ratingsValue) || !ratingsValue.IsArray) continue;
var newRatings = new BsonArray();
foreach (var ratingValue in ratingsValue.AsArray)
{
if (ratingValue is not BsonDocument rating) continue;
if (!rating.TryGetValue("Code", out var codeVal) || !codeVal.IsString) continue;
if (!byCode.TryGetValue(codeVal.AsString.Trim(), out var item)) continue;
var value = rating.TryGetValue(nameof(CompetencyRating.Value), out var v) && v.IsNumber ? v.AsInt32 : 0;
newRatings.Add(new BsonDocument
{
[nameof(CompetencyRating.ItemId)] = item.Id,
[nameof(CompetencyRating.Value)] = value,
});
}
doc[nameof(ParticipationEntry.CompetencyRatings)] = newRatings;
entries.Update(doc);
}
}
private void EnsureIndexes() private void EnsureIndexes()
{ {
Students.EnsureIndex(x => x.LastName); Students.EnsureIndex(x => x.LastName);
@@ -530,6 +674,8 @@ public class LiteDbContext : IDisposable
Subjects.EnsureIndex("ux_subject_name", BsonExpression.Create("LOWER(TRIM($.Name))"), unique: true); Subjects.EnsureIndex("ux_subject_name", BsonExpression.Create("LOWER(TRIM($.Name))"), unique: true);
CompetencyDomains.EnsureIndex(x => x.SubjectId); CompetencyDomains.EnsureIndex(x => x.SubjectId);
CompetencyDomains.EnsureIndex(x => x.GradeLevel); CompetencyDomains.EnsureIndex(x => x.GradeLevel);
CompetencyDomains.EnsureIndex(x => x.VersionId);
CompetencyCatalogVersions.EnsureIndex(x => x.SubjectId);
ShorthandCodes.EnsureIndex("ux_shorthand_code", BsonExpression.Create("LOWER(TRIM($.Code))"), unique: true); ShorthandCodes.EnsureIndex("ux_shorthand_code", BsonExpression.Create("LOWER(TRIM($.Code))"), unique: true);
AlternativeLessonPaths.EnsureIndex("ux_alt_lesson_path_name", BsonExpression.Create("LOWER(TRIM($.Name))"), unique: true); AlternativeLessonPaths.EnsureIndex("ux_alt_lesson_path_name", BsonExpression.Create("LOWER(TRIM($.Name))"), unique: true);
TimetableSlots.EnsureIndex(x => x.GroupId); TimetableSlots.EnsureIndex(x => x.GroupId);
+64 -10
View File
@@ -670,8 +670,9 @@ public class SubjectRepository(LiteDbContext db) : ISubjectRepository
} }
public void Delete(Guid id) public void Delete(Guid id)
{ {
if (db.Groups.Exists(g => g.SubjectId == id) || db.CompetencyDomains.Exists(d => d.SubjectId == id)) if (db.Groups.Exists(g => g.SubjectId == id) || db.CompetencyDomains.Exists(d => d.SubjectId == id)
throw new InvalidOperationException("Das Fach wird noch von einer Lerngruppe oder einem Kompetenzkatalog verwendet."); || db.CompetencyCatalogVersions.Exists(v => v.SubjectId == id))
throw new InvalidOperationException("Das Fach wird noch von einer Lerngruppe, einem Kompetenzkatalog oder einer Bildungsplan-Version verwendet.");
db.Subjects.Delete(id); db.Subjects.Delete(id);
db.OnChange?.Invoke(nameof(Subject), id.ToString(), "Delete", null); db.OnChange?.Invoke(nameof(Subject), id.ToString(), "Delete", null);
} }
@@ -916,16 +917,17 @@ public class UntisHubJobStateRepository(LiteDbContext db) : IUntisHubJobStateRep
public class CompetencyDomainRepository(LiteDbContext db) : ICompetencyDomainRepository public class CompetencyDomainRepository(LiteDbContext db) : ICompetencyDomainRepository
{ {
public List<CompetencyDomain> GetBySubjectAndGrade(Guid subjectId, int gradeLevel) => public List<CompetencyDomain> GetBySubjectAndGrade(Guid subjectId, int gradeLevel, Guid versionId) =>
db.CompetencyDomains db.CompetencyDomains
.Find(d => d.SubjectId == subjectId && d.GradeLevel == gradeLevel) .Find(d => d.SubjectId == subjectId && d.GradeLevel == gradeLevel && d.VersionId == versionId)
.OrderBy(d => d.SortOrder) .OrderBy(d => d.SortOrder)
.ToList(); .ToList();
public List<CompetencyDomain> GetBySubject(Guid subjectId) => public List<CompetencyDomain> GetBySubjectAndVersion(Guid subjectId, Guid versionId) =>
db.CompetencyDomains db.CompetencyDomains
.Find(d => d.SubjectId == subjectId) .Find(d => d.SubjectId == subjectId && d.VersionId == versionId)
.OrderBy(d => d.GradeLevel).ThenBy(d => d.SortOrder) .OrderBy(d => d.GradeLevel).ThenBy(d => d.SortOrder)
.ToList(); .ToList();
public List<CompetencyDomain> GetAll() => db.CompetencyDomains.FindAll().ToList();
public CompetencyDomain? GetById(Guid id) => db.CompetencyDomains.FindById(id); public CompetencyDomain? GetById(Guid id) => db.CompetencyDomains.FindById(id);
public void Save(CompetencyDomain d) public void Save(CompetencyDomain d)
{ {
@@ -938,22 +940,22 @@ public class CompetencyDomainRepository(LiteDbContext db) : ICompetencyDomainRep
db.CompetencyDomains.Delete(id); db.CompetencyDomains.Delete(id);
db.OnChange?.Invoke(nameof(CompetencyDomain), id.ToString(), "Delete", null); db.OnChange?.Invoke(nameof(CompetencyDomain), id.ToString(), "Delete", null);
} }
public void DeleteBySubjectAndGrade(Guid subjectId, int gradeLevel) public void DeleteBySubjectGradeAndVersion(Guid subjectId, int gradeLevel, Guid versionId)
{ {
foreach (var d in db.CompetencyDomains foreach (var d in db.CompetencyDomains
.Find(d => d.SubjectId == subjectId && d.GradeLevel == gradeLevel) .Find(d => d.SubjectId == subjectId && d.GradeLevel == gradeLevel && d.VersionId == versionId)
.ToList()) .ToList())
{ {
db.CompetencyDomains.Delete(d.Id); db.CompetencyDomains.Delete(d.Id);
db.OnChange?.Invoke(nameof(CompetencyDomain), d.Id.ToString(), "Delete", null); db.OnChange?.Invoke(nameof(CompetencyDomain), d.Id.ToString(), "Delete", null);
} }
} }
public void ReplaceForSubjectAndGrade(Guid subjectId, int gradeLevel, List<CompetencyDomain> domains) public void ReplaceForSubjectGradeAndVersion(Guid subjectId, int gradeLevel, Guid versionId, List<CompetencyDomain> domains)
{ {
db.ExecuteInTransaction(() => db.ExecuteInTransaction(() =>
{ {
foreach (var domain in db.CompetencyDomains foreach (var domain in db.CompetencyDomains
.Find(d => d.SubjectId == subjectId && d.GradeLevel == gradeLevel).ToList()) .Find(d => d.SubjectId == subjectId && d.GradeLevel == gradeLevel && d.VersionId == versionId).ToList())
{ {
db.CompetencyDomains.Delete(domain.Id); db.CompetencyDomains.Delete(domain.Id);
db.OnChange?.Invoke(nameof(CompetencyDomain), domain.Id.ToString(), "Delete", null); db.OnChange?.Invoke(nameof(CompetencyDomain), domain.Id.ToString(), "Delete", null);
@@ -963,6 +965,7 @@ public class CompetencyDomainRepository(LiteDbContext db) : ICompetencyDomainRep
{ {
domain.SubjectId = subjectId; domain.SubjectId = subjectId;
domain.GradeLevel = gradeLevel; domain.GradeLevel = gradeLevel;
domain.VersionId = versionId;
domain.UpdatedAt = now; domain.UpdatedAt = now;
db.CompetencyDomains.Upsert(domain); db.CompetencyDomains.Upsert(domain);
db.OnChange?.Invoke(nameof(CompetencyDomain), domain.Id.ToString(), "Save", domain); db.OnChange?.Invoke(nameof(CompetencyDomain), domain.Id.ToString(), "Save", domain);
@@ -971,6 +974,57 @@ public class CompetencyDomainRepository(LiteDbContext db) : ICompetencyDomainRep
} }
} }
public class CompetencyCatalogVersionRepository(LiteDbContext db) : ICompetencyCatalogVersionRepository
{
public List<CompetencyCatalogVersion> GetBySubject(Guid subjectId) =>
db.CompetencyCatalogVersions
.Find(v => v.SubjectId == subjectId)
.OrderBy(v => v.SortOrder)
.ToList();
public CompetencyCatalogVersion? GetById(Guid id) => db.CompetencyCatalogVersions.FindById(id);
public CompetencyCatalogVersion GetOrCreateDefault(Guid subjectId)
{
var existing = GetBySubject(subjectId).FirstOrDefault(v => v.IsDefault);
if (existing is not null) return existing;
var version = new CompetencyCatalogVersion
{
SubjectId = subjectId, Name = "Bestehender Kompetenzkatalog", IsDefault = true,
};
Save(version);
return version;
}
public void Save(CompetencyCatalogVersion v)
{
v.Name = v.Name.Trim();
if (v.Name.Length == 0) throw new ArgumentException("Der Name der Version darf nicht leer sein.");
if (v.IsDefault)
{
// Höchstens eine Standardversion je Fach - beim Setzen alle anderen des Fachs zurücknehmen.
foreach (var other in db.CompetencyCatalogVersions.Find(o => o.SubjectId == v.SubjectId && o.Id != v.Id && o.IsDefault).ToList())
{
other.IsDefault = false;
other.UpdatedAt = DateTime.UtcNow;
db.CompetencyCatalogVersions.Upsert(other);
db.OnChange?.Invoke(nameof(CompetencyCatalogVersion), other.Id.ToString(), "Save", other);
}
}
v.UpdatedAt = DateTime.UtcNow;
db.CompetencyCatalogVersions.Upsert(v);
db.OnChange?.Invoke(nameof(CompetencyCatalogVersion), v.Id.ToString(), "Save", v);
}
public void Delete(Guid id)
{
var version = db.CompetencyCatalogVersions.FindById(id);
if (version is null) return;
if (version.IsDefault)
throw new InvalidOperationException("Die Standardversion eines Fachs kann nicht gelöscht werden. Erst eine andere Version als Standard setzen.");
if (db.CompetencyDomains.Exists(d => d.VersionId == id) || db.Groups.Exists(g => g.CompetencyCatalogVersionId == id))
throw new InvalidOperationException("Die Version wird noch von einem Kompetenzkatalog oder einem Kurs verwendet.");
db.CompetencyCatalogVersions.Delete(id);
db.OnChange?.Invoke(nameof(CompetencyCatalogVersion), id.ToString(), "Delete", null);
}
}
/// <summary>Papierkorb (14.3) — bewusst nicht sync-fähig: TrashedItem wird nie über /// <summary>Papierkorb (14.3) — bewusst nicht sync-fähig: TrashedItem wird nie über
/// db.OnChange gemeldet, bleibt also rein lokal auf dem Gerät, auf dem gelöscht wurde. Ein /// db.OnChange gemeldet, bleibt also rein lokal auf dem Gerät, auf dem gelöscht wurde. Ein
/// "Fehlklick sofort rückgängig machen"-Werkzeug, kein geräteübergreifendes Archiv.</summary> /// "Fehlklick sofort rückgängig machen"-Werkzeug, kein geräteübergreifendes Archiv.</summary>
@@ -15,8 +15,10 @@ namespace LehrerApp.Desktop.Tests;
public sealed class AiPlanningServiceTests public sealed class AiPlanningServiceTests
{ {
private static AiPlanningService Build(FakeLessons lessons, FakeGroups groups, FakeSubjects subjects, private static AiPlanningService Build(FakeLessons lessons, FakeGroups groups, FakeSubjects subjects,
FakeCompetencyDomains competencyDomains, FakeAlternativeLessonPaths altPaths) => FakeCompetencyDomains competencyDomains, FakeAlternativeLessonPaths altPaths,
new(new HttpClient(), lessons, groups, subjects, competencyDomains, altPaths); FakeCompetencyCatalogVersions? competencyVersions = null) =>
new(new HttpClient(), lessons, groups, subjects, competencyDomains,
competencyVersions ?? new FakeCompetencyCatalogVersions(), altPaths);
[Fact] [Fact]
public void ParsePlanningLessons_AkzeptiertNormaleAntwortUndDeutschesDatum() public void ParsePlanningLessons_AkzeptiertNormaleAntwortUndDeutschesDatum()
@@ -90,7 +92,7 @@ public sealed class AiPlanningServiceTests
BaseAddress = new Uri("https://example.invalid/"), BaseAddress = new Uri("https://example.invalid/"),
}; };
var service = new AiPlanningService(http, new FakeLessons(), new FakeGroups([]), new FakeSubjects([]), var service = new AiPlanningService(http, new FakeLessons(), new FakeGroups([]), new FakeSubjects([]),
new FakeCompetencyDomains(), new FakeAlternativeLessonPaths([])); new FakeCompetencyDomains(), new FakeCompetencyCatalogVersions(), new FakeAlternativeLessonPaths([]));
var error = await Assert.ThrowsAsync<AiBackendException>(() => var error = await Assert.ThrowsAsync<AiBackendException>(() =>
service.RequestPlanAsync(new Unit(), "", "token")); service.RequestPlanAsync(new Unit(), "", "token"));
@@ -189,7 +191,7 @@ public sealed class AiPlanningServiceTests
BaseAddress = new Uri("https://example.invalid/"), BaseAddress = new Uri("https://example.invalid/"),
}; };
return new AiPlanningService(http, new FakeLessons(), new FakeGroups([]), new FakeSubjects([]), return new AiPlanningService(http, new FakeLessons(), new FakeGroups([]), new FakeSubjects([]),
new FakeCompetencyDomains(), new FakeAlternativeLessonPaths([])); new FakeCompetencyDomains(), new FakeCompetencyCatalogVersions(), new FakeAlternativeLessonPaths([]));
} }
private sealed class StaticResponseHandler(HttpStatusCode status, string body) : HttpMessageHandler private sealed class StaticResponseHandler(HttpStatusCode status, string body) : HttpMessageHandler
@@ -235,14 +237,16 @@ public sealed class AiPlanningServiceTests
var unit = new Unit { GroupId = group.Id, Title = "T" }; var unit = new Unit { GroupId = group.Id, Title = "T" };
var domains = new FakeCompetencyDomains(); var domains = new FakeCompetencyDomains();
var versions = new FakeCompetencyCatalogVersions();
var version = versions.GetOrCreateDefault(subject.Id);
domains.Add(new CompetencyDomain domains.Add(new CompetencyDomain
{ {
SubjectId = subject.Id, GradeLevel = 9, Name = "Chemische Reaktionen", SubjectId = subject.Id, GradeLevel = 9, VersionId = version.Id, Name = "Chemische Reaktionen",
Items = [new CompetencyItem { Code = "C1", Description = "Redoxreaktionen erklären" }], Items = [new CompetencyItem { Code = "C1", Description = "Redoxreaktionen erklären" }],
}); });
var service = Build(new FakeLessons(), new FakeGroups([group]), new FakeSubjects([subject]), var service = Build(new FakeLessons(), new FakeGroups([group]), new FakeSubjects([subject]),
domains, new FakeAlternativeLessonPaths([])); domains, new FakeAlternativeLessonPaths([]), versions);
var context = service.BuildContext(unit, ""); var context = service.BuildContext(unit, "");
@@ -13,29 +13,34 @@ public sealed class CompetencyOverviewViewModelTests
var subjectId = Guid.NewGuid(); var subjectId = Guid.NewGuid();
var group = new LearningGroup { SubjectId = subjectId, GradeLevel = 8 }; var group = new LearningGroup { SubjectId = subjectId, GradeLevel = 8 };
var student = new Student { FirstName = "Ada", LastName = "Lovelace" }; var student = new Student { FirstName = "Ada", LastName = "Lovelace" };
var k1 = new CompetencyItem { Code = "K1", Description = "Kompetenz" };
var units = new FakeUnits(); var units = new FakeUnits();
units.Add(new Unit units.Add(new Unit
{ {
GroupId = group.Id, Status = UnitStatus.Completed, Competencies = ["K1"], GroupId = group.Id, Status = UnitStatus.Completed,
Competencies = [new CompetencyReference { ItemId = k1.Id, Code = k1.Code, Description = k1.Description }],
}); });
var exam = new Exam var exam = new Exam
{ {
GroupId = group.Id, GroupId = group.Id,
Status = ExamStatus.Graded, Status = ExamStatus.Graded,
Tasks = [new ExamTask { MaxPoints = 10, CompetencyCodes = ["K1"] }], Tasks = [new ExamTask { MaxPoints = 10, Competencies = [new CompetencyReference { ItemId = k1.Id, Code = k1.Code, Description = k1.Description }] }],
}; };
var results = new FakeResults(); var results = new FakeResults();
results.Add(new ExamResult { ExamId = exam.Id, StudentId = student.Id, Points = [5] }); results.Add(new ExamResult { ExamId = exam.Id, StudentId = student.Id, Points = [5] });
var versions = new FakeCompetencyCatalogVersions();
var version = versions.GetOrCreateDefault(subjectId);
var catalog = new FakeCompetencyDomains(); var catalog = new FakeCompetencyDomains();
catalog.Add(new CompetencyDomain catalog.Add(new CompetencyDomain
{ {
SubjectId = subjectId, SubjectId = subjectId,
GradeLevel = 8, GradeLevel = 8,
VersionId = version.Id,
Name = "Bereich", Name = "Bereich",
Items = [new CompetencyItem { Code = "K1", Description = "Kompetenz" }], Items = [k1],
}); });
var vm = new CompetencyOverviewTabViewModel(units, new FakeExams([exam]), results, var vm = new CompetencyOverviewTabViewModel(units, new FakeExams([exam]), results,
catalog, new FakeStudents([student]), new CompetencyAnalysisService()); catalog, versions, new FakeStudents([student]), new CompetencyAnalysisService());
vm.Initialize(group); vm.Initialize(group);
@@ -0,0 +1,64 @@
using LehrerApp.Core.Models;
using LehrerApp.Desktop.ViewModels.Groups;
using Xunit;
namespace LehrerApp.Desktop.Tests;
public sealed class CompetencyTagGroupBuilderTests
{
[Fact]
public void Build_MarkiertAusgewaehlteItemsAlsSelected()
{
var item = new CompetencyItem { Code = "K1", Description = "Erste Kompetenz" };
var catalog = new List<CompetencyDomain> { new() { Name = "Bereich", Items = [item] } };
var selected = new List<CompetencyReference> { new() { ItemId = item.Id, Code = item.Code, Description = item.Description } };
var groups = CompetencyTagGroupBuilder.Build(catalog, selected, _ => { });
var group = Assert.Single(groups);
var tag = Assert.Single(group.Items);
Assert.True(tag.IsSelected);
Assert.Equal(item.Id, tag.ItemId);
}
[Fact]
public void Build_ReferenzOhneKatalogTreffer_LandetInEigenerGruppeMitMomentaufnahme()
{
var catalog = new List<CompetencyDomain>
{
new() { Name = "Bereich", Items = [new CompetencyItem { Code = "K1", Description = "Erste Kompetenz" }] },
};
var orphaned = new CompetencyReference
{
ItemId = Guid.NewGuid(), Code = "ALT1", Description = "Alte, gelöschte Kompetenz",
};
var selected = new List<CompetencyReference> { orphaned };
var groups = CompetencyTagGroupBuilder.Build(catalog, selected, _ => { });
Assert.Equal(2, groups.Count);
var fallbackGroup = groups.Single(g => g.Name == "Nicht mehr im Katalog");
var tag = Assert.Single(fallbackGroup.Items);
Assert.True(tag.IsSelected);
Assert.Equal("ALT1", tag.Code);
Assert.Equal("Alte, gelöschte Kompetenz", tag.Description);
// Der reguläre Katalog-Bereich bleibt unberührt und zeigt sein einziges Item als abwählbar.
var catalogGroup = groups.Single(g => g.Name == "Bereich");
Assert.False(Assert.Single(catalogGroup.Items).IsSelected);
}
[Fact]
public void Build_ToggleAufTag_RuftOnChangedMitDerTagInstanzAuf()
{
var item = new CompetencyItem { Code = "K1", Description = "Erste Kompetenz" };
var catalog = new List<CompetencyDomain> { new() { Name = "Bereich", Items = [item] } };
CompetencyTag? changed = null;
var groups = CompetencyTagGroupBuilder.Build(catalog, [], tag => changed = tag);
var tag = Assert.Single(Assert.Single(groups).Items);
tag.IsSelected = true;
Assert.Same(tag, changed);
Assert.Equal(item.Id, changed!.ItemId);
}
}
+43 -9
View File
@@ -30,7 +30,7 @@ public static class TestSupport
/// solange AiSettingsService.IsLoggedIn false ist. /// solange AiSettingsService.IsLoggedIn false ist.
public static AiPlanningService BuildAiPlanningService() => new( public static AiPlanningService BuildAiPlanningService() => new(
new HttpClient(), new FakeLessons(), new FakeGroups([]), new FakeSubjects([]), new HttpClient(), new FakeLessons(), new FakeGroups([]), new FakeSubjects([]),
new FakeCompetencyDomains(), new FakeAlternativeLessonPaths([])); new FakeCompetencyDomains(), new FakeCompetencyCatalogVersions(), new FakeAlternativeLessonPaths([]));
/// Analog zu <see cref="BuildAiSettingsService"/>, eigenes Temp-Verzeichnis je Aufruf. /// Analog zu <see cref="BuildAiSettingsService"/>, eigenes Temp-Verzeichnis je Aufruf.
public static McpSettingsService BuildMcpSettingsService() public static McpSettingsService BuildMcpSettingsService()
@@ -391,24 +391,58 @@ public class FakeCompetencyDomains : ICompetencyDomainRepository
{ {
private readonly List<CompetencyDomain> _all = []; private readonly List<CompetencyDomain> _all = [];
public void Add(CompetencyDomain d) => _all.Add(d); public void Add(CompetencyDomain d) => _all.Add(d);
public List<CompetencyDomain> GetBySubjectAndGrade(Guid subjectId, int gradeLevel) => public List<CompetencyDomain> GetBySubjectAndGrade(Guid subjectId, int gradeLevel, Guid versionId) =>
_all.Where(d => d.SubjectId == subjectId && d.GradeLevel == gradeLevel) _all.Where(d => d.SubjectId == subjectId && d.GradeLevel == gradeLevel && d.VersionId == versionId)
.OrderBy(d => d.SortOrder).ToList(); .OrderBy(d => d.SortOrder).ToList();
public List<CompetencyDomain> GetBySubject(Guid subjectId) => public List<CompetencyDomain> GetBySubjectAndVersion(Guid subjectId, Guid versionId) =>
_all.Where(d => d.SubjectId == subjectId) _all.Where(d => d.SubjectId == subjectId && d.VersionId == versionId)
.OrderBy(d => d.GradeLevel).ThenBy(d => d.SortOrder).ToList(); .OrderBy(d => d.GradeLevel).ThenBy(d => d.SortOrder).ToList();
public List<CompetencyDomain> GetAll() => _all.ToList();
public CompetencyDomain? GetById(Guid id) => _all.FirstOrDefault(d => d.Id == id); public CompetencyDomain? GetById(Guid id) => _all.FirstOrDefault(d => d.Id == id);
public void Save(CompetencyDomain domain) { _all.RemoveAll(d => d.Id == domain.Id); _all.Add(domain); } public void Save(CompetencyDomain domain) { _all.RemoveAll(d => d.Id == domain.Id); _all.Add(domain); }
public void Delete(Guid id) => _all.RemoveAll(d => d.Id == id); public void Delete(Guid id) => _all.RemoveAll(d => d.Id == id);
public void DeleteBySubjectAndGrade(Guid subjectId, int gradeLevel) => public void DeleteBySubjectGradeAndVersion(Guid subjectId, int gradeLevel, Guid versionId) =>
_all.RemoveAll(d => d.SubjectId == subjectId && d.GradeLevel == gradeLevel); _all.RemoveAll(d => d.SubjectId == subjectId && d.GradeLevel == gradeLevel && d.VersionId == versionId);
public void ReplaceForSubjectAndGrade(Guid subjectId, int gradeLevel, List<CompetencyDomain> domains) public void ReplaceForSubjectGradeAndVersion(Guid subjectId, int gradeLevel, Guid versionId, List<CompetencyDomain> domains)
{ {
DeleteBySubjectAndGrade(subjectId, gradeLevel); DeleteBySubjectGradeAndVersion(subjectId, gradeLevel, versionId);
foreach (var d in domains) { d.SubjectId = subjectId; d.GradeLevel = gradeLevel; d.VersionId = versionId; }
_all.AddRange(domains); _all.AddRange(domains);
} }
} }
public class FakeCompetencyCatalogVersions : ICompetencyCatalogVersionRepository
{
private readonly List<CompetencyCatalogVersion> _all = [];
public void Add(CompetencyCatalogVersion v) => _all.Add(v);
public List<CompetencyCatalogVersion> GetBySubject(Guid subjectId) =>
_all.Where(v => v.SubjectId == subjectId).OrderBy(v => v.SortOrder).ToList();
public CompetencyCatalogVersion? GetById(Guid id) => _all.FirstOrDefault(v => v.Id == id);
public CompetencyCatalogVersion GetOrCreateDefault(Guid subjectId)
{
var existing = GetBySubject(subjectId).FirstOrDefault(v => v.IsDefault);
if (existing is not null) return existing;
var version = new CompetencyCatalogVersion { SubjectId = subjectId, Name = "Bestehender Kompetenzkatalog", IsDefault = true };
Save(version);
return version;
}
public void Save(CompetencyCatalogVersion version)
{
if (version.IsDefault)
foreach (var other in _all.Where(v => v.SubjectId == version.SubjectId && v.Id != version.Id)) other.IsDefault = false;
_all.RemoveAll(v => v.Id == version.Id);
_all.Add(version);
}
public void Delete(Guid id)
{
var version = _all.FirstOrDefault(v => v.Id == id);
if (version is null) return;
if (version.IsDefault)
throw new InvalidOperationException("Die Standardversion eines Fachs kann nicht gelöscht werden. Erst eine andere Version als Standard setzen.");
_all.RemoveAll(v => v.Id == id);
}
}
public class FakeShorthandCodes(List<ShorthandCode> all) : IShorthandCodeRepository public class FakeShorthandCodes(List<ShorthandCode> all) : IShorthandCodeRepository
{ {
public List<ShorthandCode> GetAll() => all; public List<ShorthandCode> GetAll() => all;
@@ -21,12 +21,12 @@ public sealed class GroupDetailViewModelTests
new GroupOverviewViewModel(new FakeLessons(), exams, new FakeResults(), new FakeSessions([]), new FakeEntries(), students, new GroupOverviewViewModel(new FakeLessons(), exams, new FakeResults(), new FakeSessions([]), new FakeEntries(), students,
new FakeDocumentation(), tasks, groups, new AttendanceBalanceService(), new GradingService(), new SchoolYearService()), new FakeDocumentation(), tasks, groups, new AttendanceBalanceService(), new GradingService(), new SchoolYearService()),
new ParticipationTabViewModel(new FakeSessions([]), new FakeEntries(), new FakeAspects(), new ParticipationTabViewModel(new FakeSessions([]), new FakeEntries(), new FakeAspects(),
students, memberships, groups, new FakeCompetencyDomains()), 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 GradingService()),
new PlanningTabViewModel(new FakeUnits(), new FakeLessons(), groups, subjects, new PlanningTabViewModel(new FakeUnits(), new FakeLessons(), groups, subjects,
new FakeCompetencyDomains(), TestSupport.BuildAiSettingsService(), new FakeSessions([])), new FakeCompetencyDomains(), new FakeCompetencyCatalogVersions(), TestSupport.BuildAiSettingsService(), new FakeSessions([])),
new CompetencyOverviewTabViewModel(new FakeUnits(), exams, new FakeResults(), new CompetencyOverviewTabViewModel(new FakeUnits(), exams, new FakeResults(),
new FakeCompetencyDomains(), students, new CompetencyAnalysisService()), new FakeCompetencyDomains(), new FakeCompetencyCatalogVersions(), students, new CompetencyAnalysisService()),
new SeatingPlanTabViewModel(new FakeSeatingPlans(), students, memberships, new SeatingPlanTabViewModel(new FakeSeatingPlans(), students, memberships,
new FakeSessions([]), new FakeEntries(), new FakeAspects()), new FakeSessions([]), new FakeEntries(), new FakeAspects()),
new GroupDocumentationTabViewModel(new FakeDocumentation(), students, groups)); new GroupDocumentationTabViewModel(new FakeDocumentation(), students, groups));
@@ -254,7 +254,7 @@ public sealed class HazardAssessmentWizardViewModelTests
aiSettings.SetEnabled(true); aiSettings.SetEnabled(true);
aiSettings.SetCredentialsAndToken("sebastian", "token-abc"); aiSettings.SetCredentialsAndToken("sebastian", "token-abc");
var ai = new AiPlanningService(new HttpClient(), new FakeLessons(), new FakeGroups([]), var ai = new AiPlanningService(new HttpClient(), new FakeLessons(), new FakeGroups([]),
new FakeSubjects([]), new FakeCompetencyDomains(), new FakeAlternativeLessonPaths([])); new FakeSubjects([]), new FakeCompetencyDomains(), new FakeCompetencyCatalogVersions(), new FakeAlternativeLessonPaths([]));
var unit = new Unit { Title = "Redoxreaktionen" }; var unit = new Unit { Title = "Redoxreaktionen" };
var lesson = new Lesson { Topic = "Natrium in Wasser" }; var lesson = new Lesson { Topic = "Natrium in Wasser" };
+161 -33
View File
@@ -15,7 +15,8 @@ public sealed class McpToolsTests
Assert.Equal( Assert.Equal(
new[] new[]
{ {
"download_lesson_attachment", "get_competency_catalog", "get_exams", "get_grades", "download_lesson_attachment", "get_competency_catalog", "get_competency_plan_versions",
"get_exams", "get_grades",
"get_groups", "get_lesson_plans", "get_named_untis_absence_pattern", "get_schedule", "get_groups", "get_lesson_plans", "get_named_untis_absence_pattern", "get_schedule",
"get_students", "get_subjects", "get_time_entries", "get_untis_absence_rows", "get_students", "get_subjects", "get_time_entries", "get_untis_absence_rows",
"get_untis_hub_status", "list_letter_templates", "render_letter", "get_untis_hub_status", "list_letter_templates", "render_letter",
@@ -30,10 +31,12 @@ public sealed class McpToolsTests
new[] new[]
{ {
"add_competency_item", "add_lesson_attachment", "add_lesson_competency", "add_lesson_phase", "add_competency_item", "add_lesson_attachment", "add_lesson_competency", "add_lesson_phase",
"apply_untis_absence_status", "create_competency_domain", "create_grade_entry", "create_lesson", "apply_untis_absence_status", "create_competency_domain", "create_competency_plan_version",
"create_grade_entry", "create_lesson",
"create_subject", "create_time_entry", "create_unit", "move_lesson", "remove_competency_item", "create_subject", "create_time_entry", "create_unit", "move_lesson", "remove_competency_item",
"remove_lesson_competency", "remove_lesson_phase", "update_competency_domain", "remove_lesson_competency", "remove_lesson_phase", "update_competency_domain",
"update_competency_item", "update_lesson", "update_lesson_phase", "update_student_group_assignment", "update_competency_item", "update_competency_plan_version", "update_group_competency_version",
"update_lesson", "update_lesson_phase", "update_student_group_assignment",
"update_subject", "update_unit", "update_subject", "update_unit",
}, },
McpToolScope.AllowedWriteTools.OrderBy(n => n, StringComparer.Ordinal)); McpToolScope.AllowedWriteTools.OrderBy(n => n, StringComparer.Ordinal));
@@ -43,7 +46,7 @@ public sealed class McpToolsTests
public void AllowedDestructiveWriteTools_EnthaeltDeleteLessonSubjectUndCompetencyDomain() public void AllowedDestructiveWriteTools_EnthaeltDeleteLessonSubjectUndCompetencyDomain()
{ {
Assert.Equal( Assert.Equal(
new[] { "delete_competency_domain", "delete_lesson", "delete_subject" }, new[] { "delete_competency_domain", "delete_competency_plan_version", "delete_lesson", "delete_subject" },
McpToolScope.AllowedDestructiveWriteTools.OrderBy(n => n, StringComparer.Ordinal)); McpToolScope.AllowedDestructiveWriteTools.OrderBy(n => n, StringComparer.Ordinal));
} }
@@ -68,7 +71,7 @@ public sealed class McpToolsTests
{ {
Name = "9a", Type = GroupType.Class, SchoolYear = "2025/26", GradeLevel = 9, IsActive = true, Name = "9a", Type = GroupType.Class, SchoolYear = "2025/26", GradeLevel = 9, IsActive = true,
}; };
var tool = new GroupTools(new FakeGroups([group])); var tool = new GroupTools(new FakeGroups([group]), new FakeCompetencyCatalogVersions(), new FakeMcpConfirmation());
var result = Assert.Single(tool.GetGroups()); var result = Assert.Single(tool.GetGroups());
@@ -255,9 +258,11 @@ public sealed class McpToolsTests
private static LessonPlanTools BuildLessonPlanTools( private static LessonPlanTools BuildLessonPlanTools(
FakeUnits? units = null, FakeLessons? lessons = null, FakeGroups? groups = null, FakeUnits? units = null, FakeLessons? lessons = null, FakeGroups? groups = null,
FakeAttachmentStorage? attachments = null, FakeMcpConfirmation? confirmation = null) => FakeAttachmentStorage? attachments = null, FakeCompetencyDomains? competencyDomains = null,
FakeMcpConfirmation? confirmation = null) =>
new(units ?? new FakeUnits(), lessons ?? new FakeLessons(), groups ?? new FakeGroups([]), new(units ?? new FakeUnits(), lessons ?? new FakeLessons(), groups ?? new FakeGroups([]),
attachments ?? new FakeAttachmentStorage(), confirmation ?? new FakeMcpConfirmation()); attachments ?? new FakeAttachmentStorage(), competencyDomains ?? new FakeCompetencyDomains(),
confirmation ?? new FakeMcpConfirmation());
[Fact] [Fact]
public void GetLessonPlans_LiefertEinheitenDerGruppeUndStundenImZeitraum() public void GetLessonPlans_LiefertEinheitenDerGruppeUndStundenImZeitraum()
@@ -668,31 +673,58 @@ public sealed class McpToolsTests
// ── LessonPlanTools — Kompetenzzuordnung ──────────────────────────────────────────────────── // ── LessonPlanTools — Kompetenzzuordnung ────────────────────────────────────────────────────
private static FakeCompetencyDomains CatalogWithItem(out CompetencyItem item)
{
item = new CompetencyItem { Code = "PH.9.1", Description = "Brechungsgesetz anwenden" };
var domains = new FakeCompetencyDomains();
domains.Add(new CompetencyDomain { Name = "Optik", Items = [item] });
return domains;
}
[Fact] [Fact]
public async Task AddLessonCompetency_NutzerBestaetigt_OrdnetCodeZu() public async Task AddLessonCompetency_NutzerBestaetigt_OrdnetKompetenzZu()
{ {
var lesson = new Lesson { Topic = "Brechung" }; var lesson = new Lesson { Topic = "Brechung" };
var lessons = new FakeLessons(); var lessons = new FakeLessons();
lessons.Add(lesson); lessons.Add(lesson);
var tool = BuildLessonPlanTools(lessons: lessons); var domains = CatalogWithItem(out var item);
var tool = BuildLessonPlanTools(lessons: lessons, competencyDomains: domains);
var result = await tool.AddLessonCompetency(lesson.Id, "PH.9.1"); var result = await tool.AddLessonCompetency(lesson.Id, item.Id);
Assert.True(result.Applied); Assert.True(result.Applied);
Assert.Contains("PH.9.1", lessons.GetById(lesson.Id)!.Competencies); var stored = Assert.Single(lessons.GetById(lesson.Id)!.Competencies);
Assert.Equal(item.Id, stored.ItemId);
Assert.Equal("PH.9.1", stored.Code);
}
[Fact]
public async Task AddLessonCompetency_UnbekannteId_LiefertFehlerOhneNachfrage()
{
var lesson = new Lesson { Topic = "Brechung" };
var lessons = new FakeLessons();
lessons.Add(lesson);
var confirmation = new FakeMcpConfirmation();
var tool = BuildLessonPlanTools(lessons: lessons, confirmation: confirmation);
var result = await tool.AddLessonCompetency(lesson.Id, Guid.NewGuid());
Assert.False(result.Applied);
Assert.Equal(0, confirmation.CallCount);
} }
[Fact] [Fact]
public async Task AddLessonCompetency_BereitsZugeordnet_FragtNichtNochmalNach() public async Task AddLessonCompetency_BereitsZugeordnet_FragtNichtNochmalNach()
{ {
var lesson = new Lesson { Topic = "Brechung" }; var lesson = new Lesson { Topic = "Brechung" };
lesson.Competencies.Add("PH.9.1"); var domains = CatalogWithItem(out var item);
lesson.Competencies.Add(new CompetencyReference { ItemId = item.Id, Code = item.Code, Description = item.Description });
var lessons = new FakeLessons(); var lessons = new FakeLessons();
lessons.Add(lesson); lessons.Add(lesson);
var confirmation = new FakeMcpConfirmation(); var confirmation = new FakeMcpConfirmation();
var tool = BuildLessonPlanTools(lessons: lessons, confirmation: confirmation); var tool = BuildLessonPlanTools(lessons: lessons, competencyDomains: domains, confirmation: confirmation);
var result = await tool.AddLessonCompetency(lesson.Id, "PH.9.1"); var result = await tool.AddLessonCompetency(lesson.Id, item.Id);
Assert.True(result.Applied); Assert.True(result.Applied);
Assert.Equal(0, confirmation.CallCount); Assert.Equal(0, confirmation.CallCount);
@@ -700,15 +732,16 @@ public sealed class McpToolsTests
} }
[Fact] [Fact]
public async Task RemoveLessonCompetency_NutzerBestaetigt_EntferntCode() public async Task RemoveLessonCompetency_NutzerBestaetigt_EntferntKompetenz()
{ {
var lesson = new Lesson { Topic = "Brechung" }; var lesson = new Lesson { Topic = "Brechung" };
lesson.Competencies.Add("PH.9.1"); var item = new CompetencyItem { Code = "PH.9.1", Description = "Brechungsgesetz anwenden" };
lesson.Competencies.Add(new CompetencyReference { ItemId = item.Id, Code = item.Code, Description = item.Description });
var lessons = new FakeLessons(); var lessons = new FakeLessons();
lessons.Add(lesson); lessons.Add(lesson);
var tool = BuildLessonPlanTools(lessons: lessons); var tool = BuildLessonPlanTools(lessons: lessons);
var result = await tool.RemoveLessonCompetency(lesson.Id, "PH.9.1"); var result = await tool.RemoveLessonCompetency(lesson.Id, item.Id);
Assert.True(result.Applied); Assert.True(result.Applied);
Assert.Empty(lessons.GetById(lesson.Id)!.Competencies); Assert.Empty(lessons.GetById(lesson.Id)!.Competencies);
@@ -723,7 +756,7 @@ public sealed class McpToolsTests
var confirmation = new FakeMcpConfirmation(); var confirmation = new FakeMcpConfirmation();
var tool = BuildLessonPlanTools(lessons: lessons, confirmation: confirmation); var tool = BuildLessonPlanTools(lessons: lessons, confirmation: confirmation);
var result = await tool.RemoveLessonCompetency(lesson.Id, "PH.9.1"); var result = await tool.RemoveLessonCompetency(lesson.Id, Guid.NewGuid());
Assert.False(result.Applied); Assert.False(result.Applied);
Assert.Equal(0, confirmation.CallCount); Assert.Equal(0, confirmation.CallCount);
@@ -735,7 +768,7 @@ public sealed class McpToolsTests
public void GetSubjects_LiefertAlleFaecher() public void GetSubjects_LiefertAlleFaecher()
{ {
var subject = new Subject { Name = "Mathematik", ShortName = "Ma" }; var subject = new Subject { Name = "Mathematik", ShortName = "Ma" };
var tool = new CompetencyTools(new FakeSubjects([subject]), new FakeCompetencyDomains(), new FakeMcpConfirmation()); var tool = new CompetencyTools(new FakeSubjects([subject]), new FakeCompetencyDomains(), new FakeCompetencyCatalogVersions(), new FakeMcpConfirmation());
var dto = Assert.Single(tool.GetSubjects()); var dto = Assert.Single(tool.GetSubjects());
@@ -746,7 +779,7 @@ public sealed class McpToolsTests
public async Task CreateSubject_NutzerBestaetigt_SpeichertFach() public async Task CreateSubject_NutzerBestaetigt_SpeichertFach()
{ {
var subjects = new FakeSubjects([]); var subjects = new FakeSubjects([]);
var tool = new CompetencyTools(subjects, new FakeCompetencyDomains(), new FakeMcpConfirmation()); var tool = new CompetencyTools(subjects, new FakeCompetencyDomains(), new FakeCompetencyCatalogVersions(), new FakeMcpConfirmation());
var result = await tool.CreateSubject("Mathematik", "Ma"); var result = await tool.CreateSubject("Mathematik", "Ma");
@@ -759,7 +792,7 @@ public sealed class McpToolsTests
public async Task CreateSubject_NameBereitsVergeben_LiefertFehler() public async Task CreateSubject_NameBereitsVergeben_LiefertFehler()
{ {
var subjects = new FakeSubjects([new Subject { Name = "Mathematik" }]); var subjects = new FakeSubjects([new Subject { Name = "Mathematik" }]);
var tool = new CompetencyTools(subjects, new FakeCompetencyDomains(), new FakeMcpConfirmation()); var tool = new CompetencyTools(subjects, new FakeCompetencyDomains(), new FakeCompetencyCatalogVersions(), new FakeMcpConfirmation());
var result = await tool.CreateSubject("Mathematik"); var result = await tool.CreateSubject("Mathematik");
@@ -772,7 +805,7 @@ public sealed class McpToolsTests
{ {
var subject = new Subject { Name = "Mathematik", ShortName = "Ma" }; var subject = new Subject { Name = "Mathematik", ShortName = "Ma" };
var subjects = new FakeSubjects([subject]); var subjects = new FakeSubjects([subject]);
var tool = new CompetencyTools(subjects, new FakeCompetencyDomains(), new FakeMcpConfirmation()); var tool = new CompetencyTools(subjects, new FakeCompetencyDomains(), new FakeCompetencyCatalogVersions(), new FakeMcpConfirmation());
var result = await tool.UpdateSubject(subject.Id, shortName: "M"); var result = await tool.UpdateSubject(subject.Id, shortName: "M");
@@ -787,7 +820,7 @@ public sealed class McpToolsTests
{ {
var subject = new Subject { Name = "Mathematik" }; var subject = new Subject { Name = "Mathematik" };
var subjects = new FakeSubjects([subject]); var subjects = new FakeSubjects([subject]);
var tool = new CompetencyTools(subjects, new FakeCompetencyDomains(), new FakeMcpConfirmation()); var tool = new CompetencyTools(subjects, new FakeCompetencyDomains(), new FakeCompetencyCatalogVersions(), new FakeMcpConfirmation());
var result = await tool.DeleteSubject(subject.Id); var result = await tool.DeleteSubject(subject.Id);
@@ -799,7 +832,7 @@ public sealed class McpToolsTests
public async Task DeleteSubject_UnbekannteId_LiefertFehlerOhneNachfrage() public async Task DeleteSubject_UnbekannteId_LiefertFehlerOhneNachfrage()
{ {
var confirmation = new FakeMcpConfirmation(); var confirmation = new FakeMcpConfirmation();
var tool = new CompetencyTools(new FakeSubjects([]), new FakeCompetencyDomains(), confirmation); var tool = new CompetencyTools(new FakeSubjects([]), new FakeCompetencyDomains(), new FakeCompetencyCatalogVersions(), confirmation);
var result = await tool.DeleteSubject(Guid.NewGuid()); var result = await tool.DeleteSubject(Guid.NewGuid());
@@ -812,9 +845,11 @@ public sealed class McpToolsTests
{ {
var subjectId = Guid.NewGuid(); var subjectId = Guid.NewGuid();
var domains = new FakeCompetencyDomains(); var domains = new FakeCompetencyDomains();
domains.Add(new CompetencyDomain { SubjectId = subjectId, GradeLevel = 5, Name = "Zahlen" }); var versions = new FakeCompetencyCatalogVersions();
domains.Add(new CompetencyDomain { SubjectId = subjectId, GradeLevel = 9, Name = "Funktionen" }); var version = versions.GetOrCreateDefault(subjectId);
var tool = new CompetencyTools(new FakeSubjects([]), domains, new FakeMcpConfirmation()); domains.Add(new CompetencyDomain { SubjectId = subjectId, GradeLevel = 5, VersionId = version.Id, Name = "Zahlen" });
domains.Add(new CompetencyDomain { SubjectId = subjectId, GradeLevel = 9, VersionId = version.Id, Name = "Funktionen" });
var tool = new CompetencyTools(new FakeSubjects([]), domains, versions, new FakeMcpConfirmation());
var result = tool.GetCompetencyCatalog(subjectId); var result = tool.GetCompetencyCatalog(subjectId);
@@ -826,12 +861,14 @@ public sealed class McpToolsTests
{ {
var subject = new Subject { Name = "Mathematik" }; var subject = new Subject { Name = "Mathematik" };
var domains = new FakeCompetencyDomains(); var domains = new FakeCompetencyDomains();
var tool = new CompetencyTools(new FakeSubjects([subject]), domains, new FakeMcpConfirmation()); var versions = new FakeCompetencyCatalogVersions();
var tool = new CompetencyTools(new FakeSubjects([subject]), domains, versions, new FakeMcpConfirmation());
var result = await tool.CreateCompetencyDomain(subject.Id, 9, "Funktionen"); var result = await tool.CreateCompetencyDomain(subject.Id, 9, "Funktionen");
Assert.True(result.Applied); Assert.True(result.Applied);
var domain = Assert.Single(domains.GetBySubjectAndGrade(subject.Id, 9)); var defaultVersionId = versions.GetOrCreateDefault(subject.Id).Id;
var domain = Assert.Single(domains.GetBySubjectAndGrade(subject.Id, 9, defaultVersionId));
Assert.Equal("Funktionen", domain.Name); Assert.Equal("Funktionen", domain.Name);
} }
@@ -842,7 +879,7 @@ public sealed class McpToolsTests
domain.Items.Add(new CompetencyItem { Code = "M.9.1", Description = "..." }); domain.Items.Add(new CompetencyItem { Code = "M.9.1", Description = "..." });
var domains = new FakeCompetencyDomains(); var domains = new FakeCompetencyDomains();
domains.Add(domain); domains.Add(domain);
var tool = new CompetencyTools(new FakeSubjects([]), domains, new FakeMcpConfirmation()); var tool = new CompetencyTools(new FakeSubjects([]), domains, new FakeCompetencyCatalogVersions(), new FakeMcpConfirmation());
var result = await tool.DeleteCompetencyDomain(domain.Id); var result = await tool.DeleteCompetencyDomain(domain.Id);
@@ -856,7 +893,7 @@ public sealed class McpToolsTests
var domain = new CompetencyDomain { Name = "Funktionen" }; var domain = new CompetencyDomain { Name = "Funktionen" };
var domains = new FakeCompetencyDomains(); var domains = new FakeCompetencyDomains();
domains.Add(domain); domains.Add(domain);
var tool = new CompetencyTools(new FakeSubjects([]), domains, new FakeMcpConfirmation()); var tool = new CompetencyTools(new FakeSubjects([]), domains, new FakeCompetencyCatalogVersions(), new FakeMcpConfirmation());
var result = await tool.AddCompetencyItem(domain.Id, "M.9.1", "lineare Funktionen erkennen"); var result = await tool.AddCompetencyItem(domain.Id, "M.9.1", "lineare Funktionen erkennen");
@@ -873,7 +910,7 @@ public sealed class McpToolsTests
domain.Items.Add(item); domain.Items.Add(item);
var domains = new FakeCompetencyDomains(); var domains = new FakeCompetencyDomains();
domains.Add(domain); domains.Add(domain);
var tool = new CompetencyTools(new FakeSubjects([]), domains, new FakeMcpConfirmation()); var tool = new CompetencyTools(new FakeSubjects([]), domains, new FakeCompetencyCatalogVersions(), new FakeMcpConfirmation());
var result = await tool.UpdateCompetencyItem(domain.Id, item.Id, description: "neu"); var result = await tool.UpdateCompetencyItem(domain.Id, item.Id, description: "neu");
@@ -891,11 +928,102 @@ public sealed class McpToolsTests
domain.Items.Add(item); domain.Items.Add(item);
var domains = new FakeCompetencyDomains(); var domains = new FakeCompetencyDomains();
domains.Add(domain); domains.Add(domain);
var tool = new CompetencyTools(new FakeSubjects([]), domains, new FakeMcpConfirmation()); var tool = new CompetencyTools(new FakeSubjects([]), domains, new FakeCompetencyCatalogVersions(), new FakeMcpConfirmation());
var result = await tool.RemoveCompetencyItem(domain.Id, item.Id); var result = await tool.RemoveCompetencyItem(domain.Id, item.Id);
Assert.True(result.Applied); Assert.True(result.Applied);
Assert.Empty(domains.GetById(domain.Id)!.Items); Assert.Empty(domains.GetById(domain.Id)!.Items);
} }
// ── CompetencyTools: Bildungsplan-Versionen ─────────────────────────────────────────────
[Fact]
public void GetCompetencyPlanVersions_ListetVersionenDesFachs()
{
var subjectId = Guid.NewGuid();
var versions = new FakeCompetencyCatalogVersions();
versions.GetOrCreateDefault(subjectId);
var tool = new CompetencyTools(new FakeSubjects([]), new FakeCompetencyDomains(), versions, new FakeMcpConfirmation());
var result = Assert.Single(tool.GetCompetencyPlanVersions(subjectId));
Assert.True(result.IsDefault);
Assert.Equal("Bestehender Kompetenzkatalog", result.Name);
}
[Fact]
public async Task CreateCompetencyPlanVersion_NutzerBestaetigt_SpeichertVersion()
{
var subject = new Subject { Name = "Chemie" };
var versions = new FakeCompetencyCatalogVersions();
var tool = new CompetencyTools(new FakeSubjects([subject]), new FakeCompetencyDomains(), versions, new FakeMcpConfirmation());
var result = await tool.CreateCompetencyPlanVersion(subject.Id, "Bildungsplan 2026");
Assert.True(result.Applied);
Assert.Single(versions.GetBySubject(subject.Id), v => v.Name == "Bildungsplan 2026");
}
[Fact]
public async Task UpdateCompetencyPlanVersion_SetAsDefault_NimmtBisherigeStandardversionZurueck()
{
var subjectId = Guid.NewGuid();
var versions = new FakeCompetencyCatalogVersions();
var alt = versions.GetOrCreateDefault(subjectId);
var neu = new CompetencyCatalogVersion { SubjectId = subjectId, Name = "Bildungsplan 2026" };
versions.Add(neu);
var tool = new CompetencyTools(new FakeSubjects([]), new FakeCompetencyDomains(), versions, new FakeMcpConfirmation());
var result = await tool.UpdateCompetencyPlanVersion(neu.Id, setAsDefault: true);
Assert.True(result.Applied);
Assert.False(versions.GetById(alt.Id)!.IsDefault);
Assert.True(versions.GetById(neu.Id)!.IsDefault);
}
[Fact]
public async Task DeleteCompetencyPlanVersion_Standardversion_LiefertFehler()
{
var versions = new FakeCompetencyCatalogVersions();
var version = versions.GetOrCreateDefault(Guid.NewGuid());
var tool = new CompetencyTools(new FakeSubjects([]), new FakeCompetencyDomains(), versions, new FakeMcpConfirmation());
var result = await tool.DeleteCompetencyPlanVersion(version.Id);
Assert.False(result.Applied);
}
// ── GroupTools: Bildungsplan-Version eines Kurses ───────────────────────────────────────
[Fact]
public async Task UpdateGroupCompetencyVersion_NutzerBestaetigt_SpeichertVersion()
{
var subjectId = Guid.NewGuid();
var group = new LearningGroup { Name = "9a", SchoolYear = "2025/26", SubjectId = subjectId };
var groups = new FakeGroups([group]);
var versions = new FakeCompetencyCatalogVersions();
var version = new CompetencyCatalogVersion { SubjectId = subjectId, Name = "Bildungsplan 2026" };
versions.Add(version);
var tool = new GroupTools(groups, versions, new FakeMcpConfirmation());
var result = await tool.UpdateGroupCompetencyVersion(group.Id, version.Id);
Assert.True(result.Applied);
Assert.Equal(version.Id, groups.GetById(group.Id)!.CompetencyCatalogVersionId);
}
[Fact]
public async Task UpdateGroupCompetencyVersion_UnbekannteVersion_LiefertFehlerOhneNachfrage()
{
var group = new LearningGroup { Name = "9a", SchoolYear = "2025/26" };
var groups = new FakeGroups([group]);
var confirmation = new FakeMcpConfirmation();
var tool = new GroupTools(groups, new FakeCompetencyCatalogVersions(), confirmation);
var result = await tool.UpdateGroupCompetencyVersion(group.Id, Guid.NewGuid());
Assert.False(result.Applied);
Assert.Equal(0, confirmation.CallCount);
}
} }
@@ -15,7 +15,7 @@ public sealed class ParticipationSessionEditingTests
Date = new DateOnly(2026, 8, 19), Date = new DateOnly(2026, 8, 19),
Comment = "Sitzplan", Comment = "Sitzplan",
LessonId = Guid.NewGuid(), LessonId = Guid.NewGuid(),
CompetencyCodes = ["K1"], Competencies = [new CompetencyReference { ItemId = Guid.NewGuid(), Code = "K1", Description = "Kompetenz" }],
}; };
var vm = new AddSessionDialogViewModel(session) var vm = new AddSessionDialogViewModel(session)
{ {
@@ -29,7 +29,7 @@ public sealed class ParticipationSessionEditingTests
Assert.Equal(new DateOnly(2026, 8, 20), session.Date); Assert.Equal(new DateOnly(2026, 8, 20), session.Date);
Assert.Equal("Elektrische Stromkreise", session.Comment); Assert.Equal("Elektrische Stromkreise", session.Comment);
Assert.NotNull(session.LessonId); Assert.NotNull(session.LessonId);
Assert.Equal(["K1"], session.CompetencyCodes); Assert.Equal(["K1"], session.Competencies.Select(c => c.Code));
} }
[Fact] [Fact]
@@ -45,7 +45,7 @@ public sealed class ParticipationSessionEditingTests
var sessions = new FakeSessions([session]); var sessions = new FakeSessions([session]);
var vm = new ParticipationTabViewModel( var vm = new ParticipationTabViewModel(
sessions, new FakeEntries(), new FakeAspects(), new FakeStudents([]), sessions, new FakeEntries(), new FakeAspects(), new FakeStudents([]),
new FakeMemberships([]), new FakeGroups([group]), new FakeCompetencyDomains()); new FakeMemberships([]), new FakeGroups([group]), new FakeCompetencyDomains(), new FakeCompetencyCatalogVersions());
vm.OnEditSession = existing => vm.OnEditSession = existing =>
{ {
existing.Comment = "Nachbesprechung Elektrizität"; existing.Comment = "Nachbesprechung Elektrizität";
@@ -70,7 +70,7 @@ public sealed class ParticipationSessionEditingTests
entries.Add(new ParticipationEntry { SessionId = session.Id, StudentId = Guid.NewGuid() }); entries.Add(new ParticipationEntry { SessionId = session.Id, StudentId = Guid.NewGuid() });
var vm = new ParticipationTabViewModel( var vm = new ParticipationTabViewModel(
sessions, entries, new FakeAspects(), new FakeStudents([]), sessions, entries, new FakeAspects(), new FakeStudents([]),
new FakeMemberships([]), new FakeGroups([group]), new FakeCompetencyDomains()); new FakeMemberships([]), new FakeGroups([group]), new FakeCompetencyDomains(), new FakeCompetencyCatalogVersions());
vm.Initialize(group.Id, group.SchoolYear); vm.Initialize(group.Id, group.SchoolYear);
vm.SelectedSession = vm.Sessions.Single(s => s.Id == session.Id); vm.SelectedSession = vm.Sessions.Single(s => s.Id == session.Id);
@@ -95,7 +95,7 @@ public sealed class ParticipationSessionEditingTests
var sessions = new FakeSessions([session]); var sessions = new FakeSessions([session]);
var vm = new ParticipationTabViewModel( var vm = new ParticipationTabViewModel(
sessions, new FakeEntries(), new FakeAspects(), new FakeStudents([]), sessions, new FakeEntries(), new FakeAspects(), new FakeStudents([]),
new FakeMemberships([]), new FakeGroups([group]), new FakeCompetencyDomains()); new FakeMemberships([]), new FakeGroups([group]), new FakeCompetencyDomains(), new FakeCompetencyCatalogVersions());
vm.Initialize(group.Id, group.SchoolYear); vm.Initialize(group.Id, group.SchoolYear);
vm.SelectedSession = vm.Sessions.Single(s => s.Id == session.Id); vm.SelectedSession = vm.Sessions.Single(s => s.Id == session.Id);
vm.OnConfirmDeleteSession = (_, _) => Task.FromResult(false); vm.OnConfirmDeleteSession = (_, _) => Task.FromResult(false);
@@ -23,7 +23,11 @@ public sealed class PlanningExchangeServiceTests
Title = "Optik", Title = "Optik",
StartDate = new DateOnly(2026, 9, 1), StartDate = new DateOnly(2026, 9, 1),
EndDate = new DateOnly(2026, 10, 1), EndDate = new DateOnly(2026, 10, 1),
Competencies = ["UF1", "E4"], Competencies =
[
new CompetencyReference { ItemId = Guid.NewGuid(), Code = "UF1", Description = "" },
new CompetencyReference { ItemId = Guid.NewGuid(), Code = "E4", Description = "" },
],
Status = UnitStatus.Active, Status = UnitStatus.Active,
Notes = "Experimente", Notes = "Experimente",
}; };
@@ -61,7 +65,11 @@ public sealed class PlanningExchangeServiceTests
Assert.Equal(targetGroupId, result.Unit.GroupId); Assert.Equal(targetGroupId, result.Unit.GroupId);
Assert.Equal("Optik", result.Unit.Title); Assert.Equal("Optik", result.Unit.Title);
Assert.Equal(UnitStatus.Active, result.Unit.Status); Assert.Equal(UnitStatus.Active, result.Unit.Status);
Assert.Equal(["UF1", "E4"], result.Unit.Competencies); // Codes werden exportiert/importiert (Momentaufnahme-Text), aber bewusst NICHT gegen den
// Katalog der Zielinstallation aufgelöst - jede importierte Referenz bleibt ItemId=Guid.Empty
// (siehe PlanningExchangeService-Klassenkommentar: nie interne IDs übertragen).
Assert.Equal(["UF1", "E4"], result.Unit.Competencies.Select(c => c.Code));
Assert.All(result.Unit.Competencies, c => Assert.Equal(Guid.Empty, c.ItemId));
var importedLesson = Assert.Single(result.Lessons); var importedLesson = Assert.Single(result.Lessons);
Assert.NotEqual(sourceLesson.Id, importedLesson.Id); Assert.NotEqual(sourceLesson.Id, importedLesson.Id);
Assert.Equal(result.Unit.Id, importedLesson.UnitId); Assert.Equal(result.Unit.Id, importedLesson.UnitId);
@@ -20,7 +20,7 @@ public class PlanningTabViewModelTests
var lessons = new FakeLessons(); var lessons = new FakeLessons();
var vm = new PlanningTabViewModel(units, lessons, groups, subjects, competencyDomains, var vm = new PlanningTabViewModel(units, lessons, groups, subjects, competencyDomains,
TestSupport.BuildAiSettingsService(), new FakeSessions([])); new FakeCompetencyCatalogVersions(), TestSupport.BuildAiSettingsService(), new FakeSessions([]));
vm.Initialize(groupId); vm.Initialize(groupId);
return (vm, units, lessons, groupId); return (vm, units, lessons, groupId);
@@ -277,7 +277,7 @@ public class PlanningTabViewModelTests
var lessons = new FakeLessons(); var lessons = new FakeLessons();
var sessions = new FakeSessions([]); var sessions = new FakeSessions([]);
var vm = new PlanningTabViewModel(units, lessons, groups, new FakeSubjects([]), var vm = new PlanningTabViewModel(units, lessons, groups, new FakeSubjects([]),
new FakeCompetencyDomains(), TestSupport.BuildAiSettingsService(), sessions); new FakeCompetencyDomains(), new FakeCompetencyCatalogVersions(), TestSupport.BuildAiSettingsService(), sessions);
vm.Initialize(groupId); vm.Initialize(groupId);
var unit = new Unit { GroupId = groupId, Title = "Optik" }; var unit = new Unit { GroupId = groupId, Title = "Optik" };
@@ -312,7 +312,7 @@ public class PlanningTabViewModelTests
var lessons = new FakeLessons(); var lessons = new FakeLessons();
var sessions = new FakeSessions([]); var sessions = new FakeSessions([]);
var vm = new PlanningTabViewModel(units, lessons, groups, new FakeSubjects([]), var vm = new PlanningTabViewModel(units, lessons, groups, new FakeSubjects([]),
new FakeCompetencyDomains(), TestSupport.BuildAiSettingsService(), sessions); new FakeCompetencyDomains(), new FakeCompetencyCatalogVersions(), TestSupport.BuildAiSettingsService(), sessions);
vm.Initialize(groupId); vm.Initialize(groupId);
var unit = new Unit { GroupId = groupId, Title = "Optik" }; var unit = new Unit { GroupId = groupId, Title = "Optik" };
@@ -346,7 +346,7 @@ public class PlanningTabViewModelTests
var lessons = new FakeLessons(); var lessons = new FakeLessons();
var sessions = new FakeSessions([]); var sessions = new FakeSessions([]);
var vm = new PlanningTabViewModel(units, lessons, groups, new FakeSubjects([]), var vm = new PlanningTabViewModel(units, lessons, groups, new FakeSubjects([]),
new FakeCompetencyDomains(), TestSupport.BuildAiSettingsService(), sessions); new FakeCompetencyDomains(), new FakeCompetencyCatalogVersions(), TestSupport.BuildAiSettingsService(), sessions);
vm.Initialize(groupId); vm.Initialize(groupId);
var unit = new Unit { GroupId = groupId, Title = "Optik" }; var unit = new Unit { GroupId = groupId, Title = "Optik" };
@@ -16,6 +16,7 @@ public sealed class SettingsViewModelTests
private static SettingsViewModel BuildViewModel(FakeSchoolHolidays? holidays = null, private static SettingsViewModel BuildViewModel(FakeSchoolHolidays? holidays = null,
FakeSupervisionDuties? supervisionDuties = null, FakeSupervisionDuties? supervisionDuties = null,
FakeSubjects? subjects = null, FakeCompetencyDomains? competencyDomains = null, FakeSubjects? subjects = null, FakeCompetencyDomains? competencyDomains = null,
FakeCompetencyCatalogVersions? competencyVersions = null,
EventQueue? eventQueue = null, SyncKeyStatus? syncKeyStatus = null, EventQueue? eventQueue = null, SyncKeyStatus? syncKeyStatus = null,
SyncKeyRecoveryService? syncKeyRecovery = null, AppearanceSettingsService? appearance = null, SyncKeyRecoveryService? syncKeyRecovery = null, AppearanceSettingsService? appearance = null,
TrashViewModel? trashTab = null) TrashViewModel? trashTab = null)
@@ -27,7 +28,8 @@ public sealed class SettingsViewModelTests
Directory.CreateDirectory(tempPath); Directory.CreateDirectory(tempPath);
return new SettingsViewModel( return new SettingsViewModel(
subjects ?? new FakeSubjects([]), competencyDomains ?? new FakeCompetencyDomains(), new FakeGradingKeyTemplates(), subjects ?? new FakeSubjects([]), competencyDomains ?? new FakeCompetencyDomains(),
competencyVersions ?? new FakeCompetencyCatalogVersions(), new FakeGradingKeyTemplates(),
new FakeSchemes(), new GradingService(), new BackupService(tempPath), new FakeSchemes(), new GradingService(), new BackupService(tempPath),
new BackupSettingsService(tempPath), new BackupSettingsService(tempPath),
new DatabaseEncryptionService(), new AppLockService(tempPath), new DatabaseEncryptionService(), new AppLockService(tempPath),
@@ -335,7 +337,7 @@ public sealed class SettingsViewModelTests
var calendarSettings = new SchoolCalendarSettingsService(tempPath); var calendarSettings = new SchoolCalendarSettingsService(tempPath);
var vm = new SettingsViewModel( var vm = new SettingsViewModel(
new FakeSubjects([]), new FakeCompetencyDomains(), new FakeGradingKeyTemplates(), new FakeSubjects([]), new FakeCompetencyDomains(), new FakeCompetencyCatalogVersions(), new FakeGradingKeyTemplates(),
new FakeSchemes(), new GradingService(), new BackupService(tempPath), new FakeSchemes(), new GradingService(), new BackupService(tempPath),
new BackupSettingsService(tempPath), new BackupSettingsService(tempPath),
new DatabaseEncryptionService(), new AppLockService(tempPath), new DatabaseEncryptionService(), new AppLockService(tempPath),
@@ -365,7 +367,7 @@ public sealed class SettingsViewModelTests
var periodSchedule = new PeriodScheduleService(tempPath); var periodSchedule = new PeriodScheduleService(tempPath);
var vm = new SettingsViewModel( var vm = new SettingsViewModel(
new FakeSubjects([]), new FakeCompetencyDomains(), new FakeGradingKeyTemplates(), new FakeSubjects([]), new FakeCompetencyDomains(), new FakeCompetencyCatalogVersions(), new FakeGradingKeyTemplates(),
new FakeSchemes(), new GradingService(), new BackupService(tempPath), new FakeSchemes(), new GradingService(), new BackupService(tempPath),
new BackupSettingsService(tempPath), new BackupSettingsService(tempPath),
new DatabaseEncryptionService(), new AppLockService(tempPath), new DatabaseEncryptionService(), new AppLockService(tempPath),
@@ -399,7 +401,7 @@ public sealed class SettingsViewModelTests
var periodSchedule = new PeriodScheduleService(tempPath); var periodSchedule = new PeriodScheduleService(tempPath);
var vm = new SettingsViewModel( var vm = new SettingsViewModel(
new FakeSubjects([]), new FakeCompetencyDomains(), new FakeGradingKeyTemplates(), new FakeSubjects([]), new FakeCompetencyDomains(), new FakeCompetencyCatalogVersions(), new FakeGradingKeyTemplates(),
new FakeSchemes(), new GradingService(), new BackupService(tempPath), new FakeSchemes(), new GradingService(), new BackupService(tempPath),
new BackupSettingsService(tempPath), new BackupSettingsService(tempPath),
new DatabaseEncryptionService(), new AppLockService(tempPath), new DatabaseEncryptionService(), new AppLockService(tempPath),
@@ -489,21 +491,24 @@ public sealed class SettingsViewModelTests
{ {
var subject = new Subject { Name = "Biologie", ShortName = "Bio" }; var subject = new Subject { Name = "Biologie", ShortName = "Bio" };
var repository = new FakeCompetencyDomains(); var repository = new FakeCompetencyDomains();
var versions = new FakeCompetencyCatalogVersions();
var version = versions.GetOrCreateDefault(subject.Id);
repository.Add(new CompetencyDomain repository.Add(new CompetencyDomain
{ {
SubjectId = subject.Id, GradeLevel = 10, Name = "Erster Bereich", SortOrder = 0, SubjectId = subject.Id, GradeLevel = 10, VersionId = version.Id, Name = "Erster Bereich", SortOrder = 0,
}); });
repository.Add(new CompetencyDomain repository.Add(new CompetencyDomain
{ {
SubjectId = subject.Id, GradeLevel = 10, Name = "Zweiter Bereich", SortOrder = 1, SubjectId = subject.Id, GradeLevel = 10, VersionId = version.Id, Name = "Zweiter Bereich", SortOrder = 1,
}); });
var vm = BuildViewModel(subjects: new FakeSubjects([subject]), competencyDomains: repository); var vm = BuildViewModel(subjects: new FakeSubjects([subject]), competencyDomains: repository,
competencyVersions: versions);
vm.CatalogSubject = vm.Subjects.Single(); vm.CatalogSubject = vm.Subjects.Single();
vm.Domains[1].MoveUpCommand.Execute(null); vm.Domains[1].MoveUpCommand.Execute(null);
Assert.Equal(["Zweiter Bereich", "Erster Bereich"], vm.Domains.Select(x => x.Name)); Assert.Equal(["Zweiter Bereich", "Erster Bereich"], vm.Domains.Select(x => x.Name));
var stored = repository.GetBySubjectAndGrade(subject.Id, 10); var stored = repository.GetBySubjectAndGrade(subject.Id, 10, version.Id);
Assert.Equal(["Zweiter Bereich", "Erster Bereich"], stored.Select(x => x.Name)); Assert.Equal(["Zweiter Bereich", "Erster Bereich"], stored.Select(x => x.Name));
Assert.Equal([0, 1], stored.Select(x => x.SortOrder)); Assert.Equal([0, 1], stored.Select(x => x.SortOrder));
} }
@@ -537,15 +542,19 @@ public sealed class SettingsViewModelTests
{ {
var subject = new Subject { Name = "Biologie", ShortName = "Bio" }; var subject = new Subject { Name = "Biologie", ShortName = "Bio" };
var repository = new FakeCompetencyDomains(); var repository = new FakeCompetencyDomains();
var versions = new FakeCompetencyCatalogVersions();
var version = versions.GetOrCreateDefault(subject.Id);
repository.Add(new CompetencyDomain repository.Add(new CompetencyDomain
{ {
SubjectId = subject.Id, SubjectId = subject.Id,
GradeLevel = 10, GradeLevel = 10,
VersionId = version.Id,
Name = "Erkenntnisgewinnung", Name = "Erkenntnisgewinnung",
Code = "EG", Code = "EG",
Items = [new CompetencyItem { Code = "EG1", Description = "Modelle verwenden" }], Items = [new CompetencyItem { Code = "EG1", Description = "Modelle verwenden" }],
}); });
var vm = BuildViewModel(subjects: new FakeSubjects([subject]), competencyDomains: repository); var vm = BuildViewModel(subjects: new FakeSubjects([subject]), competencyDomains: repository,
competencyVersions: versions);
vm.CatalogSubject = vm.Subjects.Single(); vm.CatalogSubject = vm.Subjects.Single();
var preview = vm.PrepareCatalogCopy(11); var preview = vm.PrepareCatalogCopy(11);
@@ -556,9 +565,9 @@ public sealed class SettingsViewModelTests
Assert.Equal(1, preview.NewCompetencies); Assert.Equal(1, preview.NewCompetencies);
vm.ApplyCatalogImport(preview, CompetencyCatalogImportMode.Merge, new HashSet<string>()); vm.ApplyCatalogImport(preview, CompetencyCatalogImportMode.Merge, new HashSet<string>());
var copied = repository.GetBySubjectAndGrade(subject.Id, 11); var copied = repository.GetBySubjectAndGrade(subject.Id, 11, version.Id);
Assert.Single(copied); Assert.Single(copied);
Assert.NotEqual(repository.GetBySubjectAndGrade(subject.Id, 10)[0].Id, copied[0].Id); Assert.NotEqual(repository.GetBySubjectAndGrade(subject.Id, 10, version.Id)[0].Id, copied[0].Id);
Assert.Equal("EG1", copied[0].Items.Single().Code); Assert.Equal("EG1", copied[0].Items.Single().Code);
} }
} }
@@ -22,7 +22,7 @@ public sealed class TeachingModeViewModelTests
FakeSessions? sessions = null) => FakeSessions? sessions = null) =>
new(sessions ?? new FakeSessions([]), new FakeEntries(), new FakeAspects(), new(sessions ?? new FakeSessions([]), new FakeEntries(), new FakeAspects(),
new FakeStudents([]), new FakeMemberships([]), new FakeGroups([group]), new FakeStudents([]), new FakeMemberships([]), new FakeGroups([group]),
new FakeCompetencyDomains()); new FakeCompetencyDomains(), new FakeCompetencyCatalogVersions());
[Fact] [Fact]
public void Konstruktor_LaedtVerlaufsplanUndInitialisiertSitzplanFuerDieGruppe() public void Konstruktor_LaedtVerlaufsplanUndInitialisiertSitzplanFuerDieGruppe()
+1
View File
@@ -176,6 +176,7 @@ public static class AppBootstrapper
services.AddSingleton<IParticipationSectionRepository, ParticipationSectionRepository>(); services.AddSingleton<IParticipationSectionRepository, ParticipationSectionRepository>();
services.AddSingleton<ISubjectRepository, SubjectRepository>(); services.AddSingleton<ISubjectRepository, SubjectRepository>();
services.AddSingleton<ICompetencyDomainRepository, CompetencyDomainRepository>(); services.AddSingleton<ICompetencyDomainRepository, CompetencyDomainRepository>();
services.AddSingleton<ICompetencyCatalogVersionRepository, CompetencyCatalogVersionRepository>();
services.AddSingleton<IShorthandCodeRepository, ShorthandCodeRepository>(); services.AddSingleton<IShorthandCodeRepository, ShorthandCodeRepository>();
services.AddSingleton<IAlternativeLessonPathRepository, AlternativeLessonPathRepository>(); services.AddSingleton<IAlternativeLessonPathRepository, AlternativeLessonPathRepository>();
services.AddSingleton<IAttachmentStorage, LiteAttachmentStorage>(); services.AddSingleton<IAttachmentStorage, LiteAttachmentStorage>();
@@ -1,6 +1,7 @@
using LehrerApp.Core.AiPlanning; using LehrerApp.Core.AiPlanning;
using LehrerApp.Core.Interfaces; using LehrerApp.Core.Interfaces;
using LehrerApp.Core.Models; using LehrerApp.Core.Models;
using LehrerApp.Core.Services;
using System.Globalization; using System.Globalization;
using System.Net; using System.Net;
using System.Net.Http.Json; using System.Net.Http.Json;
@@ -72,7 +73,8 @@ public class GermanTimeOnlyJsonConverter : JsonConverter<TimeOnly>
/// </summary> /// </summary>
public class AiPlanningService(HttpClient http, ILessonRepository lessons, public class AiPlanningService(HttpClient http, ILessonRepository lessons,
IGroupRepository groups, ISubjectRepository subjects, IGroupRepository groups, ISubjectRepository subjects,
ICompetencyDomainRepository competencyDomains, IAlternativeLessonPathRepository altPaths) ICompetencyDomainRepository competencyDomains, ICompetencyCatalogVersionRepository competencyVersions,
IAlternativeLessonPathRepository altPaths)
{ {
// Wire-Format zum PHP-Backend ist camelCase (siehe ai-backend/) — beide Seiten sind hier // Wire-Format zum PHP-Backend ist camelCase (siehe ai-backend/) — beide Seiten sind hier
// im eigenen Zugriff, daher bewusst konsistent camelCase statt der C#-üblichen PascalCase-Defaults. // im eigenen Zugriff, daher bewusst konsistent camelCase statt der C#-üblichen PascalCase-Defaults.
@@ -165,7 +167,8 @@ public class AiPlanningService(HttpClient http, ILessonRepository lessons,
var competencyCatalog = subject is null var competencyCatalog = subject is null
? [] ? []
: competencyDomains.GetBySubjectAndGrade(subject.Id, gradeLevel) : competencyDomains.GetBySubjectAndGrade(subject.Id, gradeLevel,
CompetencyCatalogVersionResolver.Resolve(competencyVersions, subject.Id, group?.CompetencyCatalogVersionId))
.Select(d => new AiCompetencyDomain .Select(d => new AiCompetencyDomain
{ {
Name = d.Name, Name = d.Name,
@@ -202,7 +205,7 @@ public class AiPlanningService(HttpClient http, ILessonRepository lessons,
Title = unit.Title, Title = unit.Title,
StartDate = unit.StartDate, StartDate = unit.StartDate,
EndDate = unit.EndDate, EndDate = unit.EndDate,
Competencies = unit.Competencies, Competencies = unit.Competencies.Select(c => c.Code).ToList(),
Notes = unit.Notes, Notes = unit.Notes,
SubjectName = subject?.Name ?? "", SubjectName = subject?.Name ?? "",
GradeLevel = gradeLevel, GradeLevel = gradeLevel,
@@ -177,8 +177,10 @@ public sealed class McpServerHostedService : IAsyncDisposable
"Erzeugt einen Elternbrief aus einer Vorlage für einen Schüler als Base64-PDF."); "Erzeugt einen Elternbrief aus einer Vorlage für einen Schüler als Base64-PDF.");
AddReadTool(competencyTools.GetSubjects, "get_subjects", AddReadTool(competencyTools.GetSubjects, "get_subjects",
"Listet alle Fächer."); "Listet alle Fächer.");
AddReadTool(competencyTools.GetCompetencyPlanVersions, "get_competency_plan_versions",
"Listet die Bildungsplan-Versionen eines Fachs.");
AddReadTool(competencyTools.GetCompetencyCatalog, "get_competency_catalog", AddReadTool(competencyTools.GetCompetencyCatalog, "get_competency_catalog",
"Listet den Kompetenzkatalog eines Fachs, optional gefiltert auf eine Klassenstufe."); "Listet den Kompetenzkatalog eines Fachs für eine Bildungsplan-Version, optional gefiltert auf eine Klassenstufe.");
AddReadTool(untisComparisonTools.GetUntisHubStatus, "get_untis_hub_status", AddReadTool(untisComparisonTools.GetUntisHubStatus, "get_untis_hub_status",
"Listet die Fälligkeit der Untis-Hub-Abgleiche, ohne selbst WebUntis anzufragen."); "Listet die Fälligkeit der Untis-Hub-Abgleiche, ohne selbst WebUntis anzufragen.");
AddReadTool(untisComparisonTools.GetUntisAbsenceRows, "get_untis_absence_rows", AddReadTool(untisComparisonTools.GetUntisAbsenceRows, "get_untis_absence_rows",
@@ -228,6 +230,12 @@ public sealed class McpServerHostedService : IAsyncDisposable
"Ändert Code/Beschreibung einer Einzelkompetenz (Bestätigung durch den Nutzer nötig)."); "Ändert Code/Beschreibung einer Einzelkompetenz (Bestätigung durch den Nutzer nötig).");
AddWriteTool(competencyTools.RemoveCompetencyItem, "remove_competency_item", AddWriteTool(competencyTools.RemoveCompetencyItem, "remove_competency_item",
"Entfernt eine Einzelkompetenz aus einem Kompetenzbereich (Bestätigung durch den Nutzer nötig)."); "Entfernt eine Einzelkompetenz aus einem Kompetenzbereich (Bestätigung durch den Nutzer nötig).");
AddWriteTool(competencyTools.CreateCompetencyPlanVersion, "create_competency_plan_version",
"Legt eine neue Bildungsplan-Version für ein Fach an (Bestätigung durch den Nutzer nötig).");
AddWriteTool(competencyTools.UpdateCompetencyPlanVersion, "update_competency_plan_version",
"Ändert Name/Standardstatus einer Bildungsplan-Version (Bestätigung durch den Nutzer nötig).");
AddWriteTool(groupTools.UpdateGroupCompetencyVersion, "update_group_competency_version",
"Setzt oder löscht die Bildungsplan-Version eines Kurses/einer Klasse (Bestätigung durch den Nutzer nötig).");
AddWriteTool(untisComparisonTools.ApplyUntisAbsenceStatus, "apply_untis_absence_status", AddWriteTool(untisComparisonTools.ApplyUntisAbsenceStatus, "apply_untis_absence_status",
"Übernimmt einen Statusvorschlag für eine über get_untis_absence_rows gelieferte row-id (Bestätigung durch den Nutzer nötig, nennt keinen Schülernamen)."); "Übernimmt einen Statusvorschlag für eine über get_untis_absence_rows gelieferte row-id (Bestätigung durch den Nutzer nötig, nennt keinen Schülernamen).");
@@ -237,6 +245,8 @@ public sealed class McpServerHostedService : IAsyncDisposable
"Löscht ein Fach endgültig, ohne Papierkorb (Bestätigung durch den Nutzer nötig)."); "Löscht ein Fach endgültig, ohne Papierkorb (Bestätigung durch den Nutzer nötig).");
AddDestructiveWriteTool(competencyTools.DeleteCompetencyDomain, "delete_competency_domain", AddDestructiveWriteTool(competencyTools.DeleteCompetencyDomain, "delete_competency_domain",
"Löscht einen Kompetenzbereich endgültig samt Einzelkompetenzen, ohne Papierkorb (Bestätigung durch den Nutzer nötig)."); "Löscht einen Kompetenzbereich endgültig samt Einzelkompetenzen, ohne Papierkorb (Bestätigung durch den Nutzer nötig).");
AddDestructiveWriteTool(competencyTools.DeleteCompetencyPlanVersion, "delete_competency_plan_version",
"Löscht eine Bildungsplan-Version endgültig, ohne Papierkorb (Bestätigung durch den Nutzer nötig).");
System.Diagnostics.Debug.Assert( System.Diagnostics.Debug.Assert(
toolCollection.Select(t => t.ProtocolTool.Name).OrderBy(n => n) toolCollection.Select(t => t.ProtocolTool.Name).OrderBy(n => n)
@@ -29,6 +29,7 @@ public static class McpToolScope
"list_letter_templates", "list_letter_templates",
"render_letter", "render_letter",
"get_subjects", "get_subjects",
"get_competency_plan_versions",
"get_competency_catalog", "get_competency_catalog",
"get_untis_hub_status", "get_untis_hub_status",
"get_untis_absence_rows", "get_untis_absence_rows",
@@ -63,6 +64,9 @@ public static class McpToolScope
"add_competency_item", "add_competency_item",
"update_competency_item", "update_competency_item",
"remove_competency_item", "remove_competency_item",
"create_competency_plan_version",
"update_competency_plan_version",
"update_group_competency_version",
"apply_untis_absence_status", "apply_untis_absence_status",
]; ];
@@ -77,5 +81,6 @@ public static class McpToolScope
"delete_lesson", "delete_lesson",
"delete_subject", "delete_subject",
"delete_competency_domain", "delete_competency_domain",
"delete_competency_plan_version",
]; ];
} }
@@ -5,18 +5,21 @@ using LehrerApp.Core.Models;
namespace LehrerApp.Desktop.Services.Mcp.Tools; namespace LehrerApp.Desktop.Services.Mcp.Tools;
/// <summary>MCP-Tools für die Fach- und Kompetenzkatalog-Verwaltung (Nutzer-Nachtrag zu 4.5.28ff.): /// <summary>MCP-Tools für die Fach- und Kompetenzkatalog-Verwaltung (Nutzer-Nachtrag zu 4.5.28ff.,
/// <see cref="Subject"/> und <see cref="CompetencyDomain"/>/<see cref="CompetencyItem"/> vollständig /// später um Bildungsplan-Versionierung erweitert): <see cref="Subject"/>,
/// anlegen/ändern/löschen. Die Zuordnung von Kompetenzcodes zu einzelnen Stunden lebt bewusst in /// <see cref="CompetencyCatalogVersion"/> und <see cref="CompetencyDomain"/>/<see cref="CompetencyItem"/>
/// <see cref="LessonPlanTools"/> (AddLessonCompetency/RemoveLessonCompetency), nicht hier - sie /// vollständig anlegen/ändern/löschen. Die Zuordnung von Kompetenzcodes zu einzelnen Stunden lebt
/// gehört fachlich zur Stundenverwaltung, nicht zum Katalog selbst. /// bewusst in <see cref="LessonPlanTools"/> (AddLessonCompetency/RemoveLessonCompetency), nicht hier -
/// sie gehört fachlich zur Stundenverwaltung, nicht zum Katalog selbst.
/// ///
/// "delete_subject" und "delete_competency_domain" sind wie "delete_lesson" (LessonPlanTools) /// "delete_subject", "delete_competency_domain" und "delete_competency_plan_version" sind wie
/// endgültige Löschungen ohne Papierkorb (die Repository-Implementierungen löschen direkt in der /// "delete_lesson" (LessonPlanTools) endgültige Löschungen ohne Papierkorb (die
/// LiteDB-Collection statt über MoveToTrash) - deshalb als Destructive registriert (siehe /// Repository-Implementierungen löschen direkt in der LiteDB-Collection statt über MoveToTrash) -
/// McpServerHostedService) und mit entsprechend deutlicher Bestätigungsnachricht.</summary> /// deshalb als Destructive registriert (siehe McpServerHostedService) und mit entsprechend
/// deutlicher Bestätigungsnachricht.</summary>
public class CompetencyTools( public class CompetencyTools(
ISubjectRepository subjects, ICompetencyDomainRepository domains, IMcpConfirmationService confirmation) ISubjectRepository subjects, ICompetencyDomainRepository domains,
ICompetencyCatalogVersionRepository versions, IMcpConfirmationService confirmation)
{ {
// ── Lesen ──────────────────────────────────────────────────────────────────────────────── // ── Lesen ────────────────────────────────────────────────────────────────────────────────
@@ -24,17 +27,93 @@ public class CompetencyTools(
public List<SubjectDto> GetSubjects() => public List<SubjectDto> GetSubjects() =>
subjects.GetAll().Select(s => new SubjectDto(s.Id, s.Name, s.ShortName)).ToList(); subjects.GetAll().Select(s => new SubjectDto(s.Id, s.Name, s.ShortName)).ToList();
[Description("Listet den Kompetenzkatalog (Bereiche mit Einzelkompetenzen) eines Fachs, optional gefiltert auf eine Klassenstufe.")] [Description("Listet die Bildungsplan-Versionen eines Fachs (z.B. \"Bildungsplan 2016\" vs. \"Bildungsplan 2026\", während ein neuer Plan klassenstufenweise hochwächst). Genau eine Version je Fach ist die Standardversion.")]
public List<CompetencyPlanVersionDto> GetCompetencyPlanVersions(
[Description("Fach-ID, aus get_subjects.")] Guid subjectId) =>
versions.GetBySubject(subjectId)
.Select(v => new CompetencyPlanVersionDto(v.Id, v.SubjectId, v.Name, v.IsDefault, v.SortOrder))
.ToList();
[Description("Listet den Kompetenzkatalog (Bereiche mit Einzelkompetenzen) eines Fachs für eine Bildungsplan-Version, optional gefiltert auf eine Klassenstufe.")]
public List<CompetencyDomainDto> GetCompetencyCatalog( public List<CompetencyDomainDto> GetCompetencyCatalog(
[Description("Fach-ID, aus get_subjects.")] Guid subjectId, [Description("Fach-ID, aus get_subjects.")] Guid subjectId,
[Description("Optionale Klassenstufe. Weglassen: alle Klassenstufen dieses Fachs.")] int? gradeLevel = null) [Description("Optionale Klassenstufe. Weglassen: alle Klassenstufen dieser Version.")] int? gradeLevel = null,
[Description("Bildungsplan-Version, aus get_competency_plan_versions. Weglassen: Standardversion des Fachs.")] Guid? versionId = null)
{ {
var effectiveVersionId = versionId ?? versions.GetOrCreateDefault(subjectId).Id;
var result = gradeLevel is not null var result = gradeLevel is not null
? domains.GetBySubjectAndGrade(subjectId, gradeLevel.Value) ? domains.GetBySubjectAndGrade(subjectId, gradeLevel.Value, effectiveVersionId)
: domains.GetBySubject(subjectId); : domains.GetBySubjectAndVersion(subjectId, effectiveVersionId);
return result.Select(ToDto).ToList(); return result.Select(ToDto).ToList();
} }
// ── Bildungsplan-Versionen (CompetencyCatalogVersion) ────────────────────────────────────
[Description("Legt eine neue Bildungsplan-Version für ein Fach an (z.B. \"Bildungsplan 2026\"), um einen neuen, parallel gültigen Kompetenzkatalog zu pflegen. Muss der Nutzer erst bestätigen.")]
public async Task<WriteResultDto> CreateCompetencyPlanVersion(
[Description("Fach-ID, aus get_subjects.")] Guid subjectId,
[Description("Name der Version, z.B. \"Bildungsplan 2026\".")] string name,
CancellationToken ct = default)
{
var subject = subjects.GetById(subjectId);
if (subject is null) return new WriteResultDto(false, null, "Unbekannte Fach-ID.");
if (string.IsNullOrWhiteSpace(name)) return new WriteResultDto(false, null, "Name der Version darf nicht leer sein.");
var message = $"Neue Bildungsplan-Version „{name.Trim()}“ für {subject.Name} anlegen?";
if (!await confirmation.ConfirmAsync("Version anlegen?", message, ct))
return new WriteResultDto(false, null, "Vom Nutzer abgelehnt oder nicht bestätigt.");
var version = new CompetencyCatalogVersion
{
SubjectId = subjectId, Name = name, SortOrder = versions.GetBySubject(subjectId).Count,
};
try { versions.Save(version); }
catch (ArgumentException ex) { return new WriteResultDto(false, null, ex.Message); }
return new WriteResultDto(true, version.Id, "Version gespeichert.");
}
[Description("Ändert Name/Standardstatus einer bestehenden Bildungsplan-Version. Nur angegebene Felder werden geändert.")]
public async Task<WriteResultDto> UpdateCompetencyPlanVersion(
[Description("ID der Version, aus get_competency_plan_versions.")] Guid versionId,
[Description("Neuer Name. Unverändert lassen: weglassen.")] string? name = null,
[Description("Auf true setzen, um diese Version zur Standardversion ihres Fachs zu machen (bisherige Standardversion wird automatisch zurückgenommen).")] bool? setAsDefault = null,
CancellationToken ct = default)
{
var version = versions.GetById(versionId);
if (version is null) return new WriteResultDto(false, null, "Unbekannte Versions-ID.");
var changes = new StringBuilder();
if (name is not null && name != version.Name) { changes.AppendLine($"Name: „{version.Name}“ → „{name}“"); version.Name = name; }
if (setAsDefault is true && !version.IsDefault) { changes.AppendLine("wird Standardversion des Fachs"); version.IsDefault = true; }
if (changes.Length == 0)
return new WriteResultDto(true, version.Id, "Keine Änderung nötig.");
if (!await confirmation.ConfirmAsync("Version ändern?", $"„{version.Name}“\n{changes}".TrimEnd(), ct))
return new WriteResultDto(false, null, "Vom Nutzer abgelehnt oder nicht bestätigt.");
try { versions.Save(version); }
catch (ArgumentException ex) { return new WriteResultDto(false, null, ex.Message); }
return new WriteResultDto(true, version.Id, "Version gespeichert.");
}
[Description("Löscht eine Bildungsplan-Version endgültig. Schlägt fehl, wenn sie noch Kompetenzbereiche oder Kurse referenziert, oder wenn sie die Standardversion ihres Fachs ist. Kein Papierkorb - nicht rückgängig zu machen. Muss der Nutzer erst bestätigen.")]
public async Task<WriteResultDto> DeleteCompetencyPlanVersion(
[Description("ID der Version.")] Guid versionId,
CancellationToken ct = default)
{
var version = versions.GetById(versionId);
if (version is null) return new WriteResultDto(false, null, "Unbekannte Versions-ID.");
var message = $"Die Bildungsplan-Version „{version.Name}“ wird endgültig gelöscht. Das kann NICHT rückgängig gemacht werden (kein Papierkorb für Versionen). Schlägt fehl, falls noch Kompetenzbereiche oder Kurse diese Version nutzen.";
if (!await confirmation.ConfirmAsync("Version endgültig löschen?", message, ct))
return new WriteResultDto(false, null, "Vom Nutzer abgelehnt oder nicht bestätigt.");
try { versions.Delete(versionId); }
catch (InvalidOperationException ex) { return new WriteResultDto(false, null, ex.Message); }
return new WriteResultDto(true, versionId, "Version gelöscht.");
}
// ── Fächer (Subject) ───────────────────────────────────────────────────────────────────── // ── Fächer (Subject) ─────────────────────────────────────────────────────────────────────
[Description("Legt ein neues Fach an. Muss der Nutzer erst bestätigen.")] [Description("Legt ein neues Fach an. Muss der Nutzer erst bestätigen.")]
@@ -109,26 +188,30 @@ public class CompetencyTools(
// ── Kompetenzbereiche (CompetencyDomain) ──────────────────────────────────────────────── // ── Kompetenzbereiche (CompetencyDomain) ────────────────────────────────────────────────
[Description("Legt einen neuen Kompetenzbereich (z.B. \"Zahlen und Operationen\") für ein Fach und eine Klassenstufe an, zunächst ohne Einzelkompetenzen. Muss der Nutzer erst bestätigen.")] [Description("Legt einen neuen Kompetenzbereich (z.B. \"Zahlen und Operationen\") für ein Fach, eine Klassenstufe und eine Bildungsplan-Version an, zunächst ohne Einzelkompetenzen. Muss der Nutzer erst bestätigen.")]
public async Task<WriteResultDto> CreateCompetencyDomain( public async Task<WriteResultDto> CreateCompetencyDomain(
[Description("Fach-ID, aus get_subjects.")] Guid subjectId, [Description("Fach-ID, aus get_subjects.")] Guid subjectId,
[Description("Klassenstufe.")] int gradeLevel, [Description("Klassenstufe.")] int gradeLevel,
[Description("Name des Bereichs.")] string name, [Description("Name des Bereichs.")] string name,
[Description("Optionales Kürzel, z.B. \"ZO\".")] string code = "", [Description("Optionales Kürzel, z.B. \"ZO\".")] string code = "",
[Description("Bildungsplan-Version, aus get_competency_plan_versions. Weglassen: Standardversion des Fachs.")] Guid? versionId = null,
CancellationToken ct = default) CancellationToken ct = default)
{ {
var subject = subjects.GetById(subjectId); var subject = subjects.GetById(subjectId);
if (subject is null) return new WriteResultDto(false, null, "Unbekannte Fach-ID."); if (subject is null) return new WriteResultDto(false, null, "Unbekannte Fach-ID.");
if (string.IsNullOrWhiteSpace(name)) return new WriteResultDto(false, null, "Bereichsname darf nicht leer sein."); if (string.IsNullOrWhiteSpace(name)) return new WriteResultDto(false, null, "Bereichsname darf nicht leer sein.");
var sortOrder = domains.GetBySubjectAndGrade(subjectId, gradeLevel).Count; var effectiveVersionId = versionId ?? versions.GetOrCreateDefault(subjectId).Id;
var message = $"Neuen Kompetenzbereich „{name.Trim()}“ für {subject.Name}, Klasse {gradeLevel}, anlegen?"; var versionName = versions.GetById(effectiveVersionId)?.Name ?? "";
var sortOrder = domains.GetBySubjectAndGrade(subjectId, gradeLevel, effectiveVersionId).Count;
var message = $"Neuen Kompetenzbereich „{name.Trim()}“ für {subject.Name}, Klasse {gradeLevel} ({versionName}), anlegen?";
if (!await confirmation.ConfirmAsync("Kompetenzbereich anlegen?", message, ct)) if (!await confirmation.ConfirmAsync("Kompetenzbereich anlegen?", message, ct))
return new WriteResultDto(false, null, "Vom Nutzer abgelehnt oder nicht bestätigt."); return new WriteResultDto(false, null, "Vom Nutzer abgelehnt oder nicht bestätigt.");
var domain = new CompetencyDomain var domain = new CompetencyDomain
{ {
SubjectId = subjectId, GradeLevel = gradeLevel, Name = name, Code = code, SortOrder = sortOrder, SubjectId = subjectId, GradeLevel = gradeLevel, VersionId = effectiveVersionId,
Name = name, Code = code, SortOrder = sortOrder,
}; };
domains.Save(domain); domains.Save(domain);
return new WriteResultDto(true, domain.Id, "Kompetenzbereich gespeichert."); return new WriteResultDto(true, domain.Id, "Kompetenzbereich gespeichert.");
@@ -246,7 +329,7 @@ public class CompetencyTools(
} }
private static CompetencyDomainDto ToDto(CompetencyDomain d) => new( private static CompetencyDomainDto ToDto(CompetencyDomain d) => new(
d.Id, d.SubjectId, d.GradeLevel, d.Name, d.Code, d.SortOrder, d.Id, d.SubjectId, d.GradeLevel, d.VersionId, d.Name, d.Code, d.SortOrder,
d.Items.OrderBy(i => i.SortOrder) d.Items.OrderBy(i => i.SortOrder)
.Select(i => new CompetencyItemDto(i.Id, i.Code, i.Description, i.SortOrder)).ToList()); .Select(i => new CompetencyItemDto(i.Id, i.Code, i.Description, i.SortOrder)).ToList());
} }
+12 -4
View File
@@ -34,9 +34,14 @@ public record LessonPhaseDto(
public record LessonAttachmentDto(string StorageId, string FileName, long SizeBytes); public record LessonAttachmentDto(string StorageId, string FileName, long SizeBytes);
/// <summary>Eine über MCP zugeordnete Kompetenz - Id + zum Zuordnungszeitpunkt gespeicherte
/// Momentaufnahme aus Code/Description (siehe CompetencyReference), damit ein KI-Client sie ohne
/// Zusatzabfrage lesen kann, auch wenn das Katalog-Item inzwischen gelöscht wurde.</summary>
public record CompetencyReferenceDto(Guid ItemId, string Code, string Description);
public record LessonDto( public record LessonDto(
Guid Id, Guid UnitId, Guid GroupId, DateOnly Date, int? LessonNumber, string Topic, Guid Id, Guid UnitId, Guid GroupId, DateOnly Date, int? LessonNumber, string Topic,
string? Homework, string? PlanningIdeas, LessonStatus Status, List<string> Competencies, string? Homework, string? PlanningIdeas, LessonStatus Status, List<CompetencyReferenceDto> Competencies,
List<LessonPhaseDto> Phases, List<LessonAttachmentDto> Attachments); List<LessonPhaseDto> Phases, List<LessonAttachmentDto> Attachments);
/// <summary>Ergebnis von "download_lesson_attachment": Inhalt Base64-kodiert, weil MCP-Tool-Antworten /// <summary>Ergebnis von "download_lesson_attachment": Inhalt Base64-kodiert, weil MCP-Tool-Antworten
@@ -47,7 +52,7 @@ public record AttachmentContentDto(string FileName, long SizeBytes, string Base6
public record UnitDto( public record UnitDto(
Guid Id, Guid GroupId, string Title, DateOnly? StartDate, DateOnly? EndDate, Guid Id, Guid GroupId, string Title, DateOnly? StartDate, DateOnly? EndDate,
UnitStatus Status, List<string> Competencies); UnitStatus Status, List<CompetencyReferenceDto> Competencies);
public record LessonPlanResultDto(List<UnitDto> Units, List<LessonDto> Lessons); public record LessonPlanResultDto(List<UnitDto> Units, List<LessonDto> Lessons);
@@ -56,9 +61,12 @@ public record SubjectDto(Guid Id, string Name, string ShortName);
public record CompetencyItemDto(Guid Id, string Code, string Description, int SortOrder); public record CompetencyItemDto(Guid Id, string Code, string Description, int SortOrder);
public record CompetencyDomainDto( public record CompetencyDomainDto(
Guid Id, Guid SubjectId, int GradeLevel, string Name, string Code, int SortOrder, Guid Id, Guid SubjectId, int GradeLevel, Guid VersionId, string Name, string Code, int SortOrder,
List<CompetencyItemDto> Items); List<CompetencyItemDto> Items);
/// <summary>Eine Bildungsplan-Version eines Fachs, siehe CompetencyTools.GetCompetencyPlanVersions.</summary>
public record CompetencyPlanVersionDto(Guid Id, Guid SubjectId, string Name, bool IsDefault, int SortOrder);
public record GroupMembershipDto( public record GroupMembershipDto(
Guid Id, Guid StudentId, Guid GroupId, MembershipPeriod Period, Guid Id, Guid StudentId, Guid GroupId, MembershipPeriod Period,
DateOnly? JoinedAt, DateOnly? LeftAt, Niveau? Niveau); DateOnly? JoinedAt, DateOnly? LeftAt, Niveau? Niveau);
@@ -91,7 +99,7 @@ public record UntisHubStatusRowDto(
/// Fach-Datensatz mitzuschleppen.</summary> /// Fach-Datensatz mitzuschleppen.</summary>
public record GroupDto( public record GroupDto(
Guid Id, string Name, GroupType Type, string SchoolYear, int GradeLevel, Guid Id, string Name, GroupType Type, string SchoolYear, int GradeLevel,
Guid? SubjectId, bool IsActive); Guid? SubjectId, bool IsActive, Guid? CompetencyPlanVersionId);
/// <summary>Anonymisierte Fehlzeiten-Diskrepanz (siehe UntisComparisonTools.GetUntisAbsenceRows): /// <summary>Anonymisierte Fehlzeiten-Diskrepanz (siehe UntisComparisonTools.GetUntisAbsenceRows):
/// bewusst KEIN Schülername/keine Klasse - <see cref="RowId"/> ist die einzige Kennung, über die /// bewusst KEIN Schülername/keine Klasse - <see cref="RowId"/> ist die einzige Kennung, über die
@@ -1,14 +1,18 @@
using System.ComponentModel; using System.ComponentModel;
using System.Text;
using LehrerApp.Core.Interfaces; using LehrerApp.Core.Interfaces;
namespace LehrerApp.Desktop.Services.Mcp.Tools; namespace LehrerApp.Desktop.Services.Mcp.Tools;
/// <summary>MCP-Read-Tool "get_groups" (Nutzer-Nachtrag: die GroupId, die praktisch jedes andere /// <summary>MCP-Tools für Lerngruppen (Klassen/Kurse). "get_groups" (Nutzer-Nachtrag: die GroupId,
/// Tool als Pflichtparameter verlangt - get_grades, get_schedule, get_lesson_plans, /// die praktisch jedes andere Tool als Pflichtparameter verlangt - get_grades, get_schedule,
/// get_untis_absence_rows usw. - war nirgends über MCP auflösbar; ein KI-Client kannte bestenfalls /// get_lesson_plans, get_untis_absence_rows usw. - war nirgends über MCP auflösbar; ein KI-Client
/// den Klarnamen einer Lerngruppe aus dem Gespräch, nie ihre Id). Reiner Lesezugriff auf das /// kannte bestenfalls den Klarnamen einer Lerngruppe aus dem Gespräch, nie ihre Id) ist reiner
/// bestehende Repository, keine eigene Datenzugriffslogik.</summary> /// Lesezugriff. "update_group_competency_version" ist das erste Schreib-Tool auf einem
public class GroupTools(IGroupRepository groups) /// LearningGroup-Feld selbst (Nutzer-Nachtrag zur Bildungsplan-Versionierung) - deshalb bewusst eng
/// auf genau dieses eine Feld geschnitten statt eines allgemeinen "update_group".</summary>
public class GroupTools(IGroupRepository groups, ICompetencyCatalogVersionRepository versions,
IMcpConfirmationService confirmation)
{ {
[Description("Listet Lerngruppen (Klassen/Kurse) mit ihrer Id - Voraussetzung, um andere Tools (z.B. get_grades, get_schedule, get_untis_absence_rows) für eine bestimmte Gruppe aufzurufen, wenn nur ihr Name bekannt ist. Ohne schoolYear werden alle Schuljahre zurückgegeben.")] [Description("Listet Lerngruppen (Klassen/Kurse) mit ihrer Id - Voraussetzung, um andere Tools (z.B. get_grades, get_schedule, get_untis_absence_rows) für eine bestimmte Gruppe aufzurufen, wenn nur ihr Name bekannt ist. Ohne schoolYear werden alle Schuljahre zurückgegeben.")]
public List<GroupDto> GetGroups( public List<GroupDto> GetGroups(
@@ -18,6 +22,32 @@ public class GroupTools(IGroupRepository groups)
var list = schoolYear is null var list = schoolYear is null
? groups.GetAll(includeInactive) ? groups.GetAll(includeInactive)
: groups.GetBySchoolYear(schoolYear, includeInactive); : groups.GetBySchoolYear(schoolYear, includeInactive);
return list.Select(g => new GroupDto(g.Id, g.Name, g.Type, g.SchoolYear, g.GradeLevel, g.SubjectId, g.IsActive)).ToList(); return list.Select(g => new GroupDto(g.Id, g.Name, g.Type, g.SchoolYear, g.GradeLevel,
g.SubjectId, g.IsActive, g.CompetencyCatalogVersionId)).ToList();
}
[Description("Setzt oder löscht die Bildungsplan-Version eines Kurses/einer Klasse (welcher Kompetenzkatalog für diese Gruppe gilt). Muss der Nutzer erst bestätigen.")]
public async Task<WriteResultDto> UpdateGroupCompetencyVersion(
[Description("Gruppen-ID, aus get_groups.")] Guid groupId,
[Description("Bildungsplan-Version, aus get_competency_plan_versions. Weglassen: zurück auf die Standardversion des Fachs.")] Guid? versionId = null,
CancellationToken ct = default)
{
var group = groups.GetById(groupId);
if (group is null) return new WriteResultDto(false, null, "Unbekannte Gruppen-ID.");
if (versionId is Guid vid && versions.GetById(vid) is null)
return new WriteResultDto(false, null, "Unbekannte Versions-ID.");
var oldName = group.CompetencyCatalogVersionId is Guid oldId ? versions.GetById(oldId)?.Name ?? "unbekannt" : "Standardversion";
var newName = versionId is Guid newId ? versions.GetById(newId)?.Name ?? "unbekannt" : "Standardversion";
if (oldName == newName && group.CompetencyCatalogVersionId == versionId)
return new WriteResultDto(true, group.Id, "Keine Änderung nötig.");
var message = new StringBuilder($"Bildungsplan-Version von „{group.Name}“ ändern:\n{oldName} → {newName}");
if (!await confirmation.ConfirmAsync("Bildungsplan-Version ändern?", message.ToString(), ct))
return new WriteResultDto(false, null, "Vom Nutzer abgelehnt oder nicht bestätigt.");
group.CompetencyCatalogVersionId = versionId;
groups.Save(group);
return new WriteResultDto(true, group.Id, "Bildungsplan-Version gespeichert.");
} }
} }
@@ -25,7 +25,8 @@ namespace LehrerApp.Desktop.Services.Mcp.Tools;
/// (siehe McpServerHostedService) und mit besonders deutlicher Bestätigungsnachricht.</summary> /// (siehe McpServerHostedService) und mit besonders deutlicher Bestätigungsnachricht.</summary>
public class LessonPlanTools( public class LessonPlanTools(
IUnitRepository units, ILessonRepository lessons, IGroupRepository groups, IUnitRepository units, ILessonRepository lessons, IGroupRepository groups,
IAttachmentStorage attachments, IMcpConfirmationService confirmation) IAttachmentStorage attachments, ICompetencyDomainRepository competencyDomains,
IMcpConfirmationService confirmation)
{ {
/// <summary>Deckelt die Antwortgröße von "download_lesson_attachment" (Base64 bläht ca. um /// <summary>Deckelt die Antwortgröße von "download_lesson_attachment" (Base64 bläht ca. um
/// Faktor 1,33 auf). Kleiner als <see cref="IAttachmentStorage.MaxSizeBytes"/> (App-weites /// Faktor 1,33 auf). Kleiner als <see cref="IAttachmentStorage.MaxSizeBytes"/> (App-weites
@@ -42,7 +43,7 @@ public class LessonPlanTools(
[Description("Enddatum (einschließlich) für die Einzelstunden, Format YYYY-MM-DD.")] DateOnly to) [Description("Enddatum (einschließlich) für die Einzelstunden, Format YYYY-MM-DD.")] DateOnly to)
{ {
var unitDtos = units.GetByGroup(groupId) var unitDtos = units.GetByGroup(groupId)
.Select(u => new UnitDto(u.Id, u.GroupId, u.Title, u.StartDate, u.EndDate, u.Status, u.Competencies)) .Select(u => new UnitDto(u.Id, u.GroupId, u.Title, u.StartDate, u.EndDate, u.Status, ToDto(u.Competencies)))
.ToList(); .ToList();
var lessonDtos = lessons.GetByGroupAndRange(groupId, from, to) var lessonDtos = lessons.GetByGroupAndRange(groupId, from, to)
.Select(ToDto) .Select(ToDto)
@@ -311,40 +312,40 @@ public class LessonPlanTools(
// Race-Condition-Überlegung wie bei den Verlaufsplan-Phasen (add/update/remove_lesson_phase) - // Race-Condition-Überlegung wie bei den Verlaufsplan-Phasen (add/update/remove_lesson_phase) -
// ein Tool-Aufruf ändert nur einen Code, kein "letzter Schreiber gewinnt" über die ganze Liste. // ein Tool-Aufruf ändert nur einen Code, kein "letzter Schreiber gewinnt" über die ganze Liste.
[Description("Ordnet einer Einzelstunde einen Kompetenzcode aus dem Katalog zu (siehe get_competency_catalog). Muss der Nutzer erst bestätigen.")] [Description("Ordnet einer Einzelstunde eine Kompetenz aus dem Katalog zu (siehe get_competency_catalog). Muss der Nutzer erst bestätigen.")]
public async Task<WriteResultDto> AddLessonCompetency( public async Task<WriteResultDto> AddLessonCompetency(
[Description("ID der Einzelstunde.")] Guid lessonId, [Description("ID der Einzelstunde.")] Guid lessonId,
[Description("Kompetenzcode, z.B. \"M.5.1\".")] string code, [Description("ID der Einzelkompetenz, aus get_competency_catalog.")] Guid itemId,
CancellationToken ct = default) CancellationToken ct = default)
{ {
var lesson = lessons.GetById(lessonId); var lesson = lessons.GetById(lessonId);
if (lesson is null) return new WriteResultDto(false, null, "Unbekannte Stunden-ID."); if (lesson is null) return new WriteResultDto(false, null, "Unbekannte Stunden-ID.");
code = code.Trim(); var item = FindCompetencyItem(itemId);
if (code.Length == 0) return new WriteResultDto(false, null, "Leerer Kompetenzcode."); if (item is null) return new WriteResultDto(false, null, "Unbekannte Kompetenz-ID.");
if (lesson.Competencies.Contains(code, StringComparer.OrdinalIgnoreCase)) if (lesson.Competencies.Any(c => c.ItemId == itemId))
return new WriteResultDto(true, lesson.Id, "Kompetenzcode ist bereits zugeordnet."); return new WriteResultDto(true, lesson.Id, "Kompetenz ist bereits zugeordnet.");
var message = $"Kompetenz „{code}“ zu „{lesson.Topic}“ am {lesson.Date:dd.MM.yyyy} hinzufügen?"; var message = $"Kompetenz „{item.Code}“ zu „{lesson.Topic}“ am {lesson.Date:dd.MM.yyyy} hinzufügen?";
if (!await confirmation.ConfirmAsync("Kompetenz zuordnen?", message, ct)) if (!await confirmation.ConfirmAsync("Kompetenz zuordnen?", message, ct))
return new WriteResultDto(false, null, "Vom Nutzer abgelehnt oder nicht bestätigt."); return new WriteResultDto(false, null, "Vom Nutzer abgelehnt oder nicht bestätigt.");
lesson.Competencies.Add(code); lesson.Competencies.Add(new CompetencyReference { ItemId = item.Id, Code = item.Code, Description = item.Description });
lessons.Save(lesson); lessons.Save(lesson);
return new WriteResultDto(true, lesson.Id, "Kompetenz zugeordnet."); return new WriteResultDto(true, lesson.Id, "Kompetenz zugeordnet.");
} }
[Description("Entfernt einen Kompetenzcode von einer Einzelstunde. Muss der Nutzer erst bestätigen.")] [Description("Entfernt eine Kompetenz von einer Einzelstunde. Muss der Nutzer erst bestätigen.")]
public async Task<WriteResultDto> RemoveLessonCompetency( public async Task<WriteResultDto> RemoveLessonCompetency(
[Description("ID der Einzelstunde.")] Guid lessonId, [Description("ID der Einzelstunde.")] Guid lessonId,
[Description("Kompetenzcode, wie in get_lesson_plans hinterlegt.")] string code, [Description("ID der Einzelkompetenz, wie in get_lesson_plans hinterlegt.")] Guid itemId,
CancellationToken ct = default) CancellationToken ct = default)
{ {
var lesson = lessons.GetById(lessonId); var lesson = lessons.GetById(lessonId);
if (lesson is null) return new WriteResultDto(false, null, "Unbekannte Stunden-ID."); if (lesson is null) return new WriteResultDto(false, null, "Unbekannte Stunden-ID.");
var existing = lesson.Competencies.FirstOrDefault(c => string.Equals(c, code, StringComparison.OrdinalIgnoreCase)); var existing = lesson.Competencies.FirstOrDefault(c => c.ItemId == itemId);
if (existing is null) return new WriteResultDto(false, null, "Dieser Kompetenzcode ist dieser Stunde nicht zugeordnet."); if (existing is null) return new WriteResultDto(false, null, "Diese Kompetenz ist dieser Stunde nicht zugeordnet.");
var message = $"Kompetenz „{existing}“ von „{lesson.Topic}“ am {lesson.Date:dd.MM.yyyy} entfernen?"; var message = $"Kompetenz „{existing.Code}“ von „{lesson.Topic}“ am {lesson.Date:dd.MM.yyyy} entfernen?";
if (!await confirmation.ConfirmAsync("Kompetenz entfernen?", message, ct)) if (!await confirmation.ConfirmAsync("Kompetenz entfernen?", message, ct))
return new WriteResultDto(false, null, "Vom Nutzer abgelehnt oder nicht bestätigt."); return new WriteResultDto(false, null, "Vom Nutzer abgelehnt oder nicht bestätigt.");
@@ -353,6 +354,9 @@ public class LessonPlanTools(
return new WriteResultDto(true, lesson.Id, "Kompetenz entfernt."); return new WriteResultDto(true, lesson.Id, "Kompetenz entfernt.");
} }
private CompetencyItem? FindCompetencyItem(Guid itemId) =>
competencyDomains.GetAll().SelectMany(d => d.Items).FirstOrDefault(i => i.Id == itemId);
// ── Einzelstunden (Lesson) — Verschieben & Löschen ─────────────────────────────────────── // ── Einzelstunden (Lesson) — Verschieben & Löschen ───────────────────────────────────────
[Description("Verschiebt eine Einzelstunde auf ein neues Datum (und optional eine neue Stundennummer). Mit shiftFollowingLessons=true verschieben sich alle noch nicht durchgeführten, späteren Stunden derselben Einheit um denselben Tages-Versatz mit — so lässt sich eine Lücke für eine neue Stunde öffnen: diese Stunde auf den Termin der übernächsten verschieben (mit shiftFollowingLessons), dann create_lesson auf das dadurch freigewordene ursprüngliche Datum. Muss der Nutzer erst bestätigen.")] [Description("Verschiebt eine Einzelstunde auf ein neues Datum (und optional eine neue Stundennummer). Mit shiftFollowingLessons=true verschieben sich alle noch nicht durchgeführten, späteren Stunden derselben Einheit um denselben Tages-Versatz mit — so lässt sich eine Lücke für eine neue Stunde öffnen: diese Stunde auf den Termin der übernächsten verschieben (mit shiftFollowingLessons), dann create_lesson auf das dadurch freigewordene ursprüngliche Datum. Muss der Nutzer erst bestätigen.")]
@@ -414,7 +418,10 @@ public class LessonPlanTools(
} }
private static LessonDto ToDto(Lesson l) => new( private static LessonDto ToDto(Lesson l) => new(
l.Id, l.UnitId, l.GroupId, l.Date, l.LessonNumber, l.Topic, l.Homework, l.PlanningIdeas, l.Status, l.Competencies, l.Id, l.UnitId, l.GroupId, l.Date, l.LessonNumber, l.Topic, l.Homework, l.PlanningIdeas, l.Status, ToDto(l.Competencies),
l.Phases.Select(p => new LessonPhaseDto(p.Id, p.Name, p.DurationMinutes, p.Activity, p.Material, p.Shorthand, p.MaterialPrompt)).ToList(), l.Phases.Select(p => new LessonPhaseDto(p.Id, p.Name, p.DurationMinutes, p.Activity, p.Material, p.Shorthand, p.MaterialPrompt)).ToList(),
l.Attachments.Select(a => new LessonAttachmentDto(a.StorageId, a.FileName, a.SizeBytes)).ToList()); l.Attachments.Select(a => new LessonAttachmentDto(a.StorageId, a.FileName, a.SizeBytes)).ToList());
private static List<CompetencyReferenceDto> ToDto(List<CompetencyReference> competencies) =>
competencies.Select(c => new CompetencyReferenceDto(c.ItemId, c.Code, c.Description)).ToList();
} }
@@ -62,9 +62,16 @@ public sealed class PlanningExchangeService(IUnitRepository units, ILessonReposi
Title = document.Unit.Title.Trim(), Title = document.Unit.Title.Trim(),
StartDate = document.Unit.StartDate, StartDate = document.Unit.StartDate,
EndDate = document.Unit.EndDate, EndDate = document.Unit.EndDate,
// Das Austauschformat überträgt bewusst nie interne DB-IDs ("jeder Import legt neue
// Objekte an", siehe Klassenkommentar) - jeder importierte Code wird deshalb als NICHT
// aufgelöste Referenz gespeichert (kein Matching gegen den Katalog der Zielinstallation,
// das wäre wieder dasselbe fragile Code-Matching, das TODO 16.5 vermeiden soll, nur
// installationsübergreifend). Die Tag-UI zeigt sie ehrlich als "Nicht mehr im Katalog";
// der Nutzer kann sie bei Bedarf manuell dem echten Katalogeintrag neu zuordnen.
Competencies = document.Unit.Competencies Competencies = document.Unit.Competencies
.Where(c => !string.IsNullOrWhiteSpace(c)).Select(c => c.Trim()) .Where(c => !string.IsNullOrWhiteSpace(c)).Select(c => c.Trim())
.Distinct(StringComparer.OrdinalIgnoreCase).ToList(), .Distinct(StringComparer.OrdinalIgnoreCase)
.Select(c => new CompetencyReference { ItemId = Guid.Empty, Code = c }).ToList(),
Status = document.Unit.Status, Status = document.Unit.Status,
Notes = Clean(document.Unit.Notes), Notes = Clean(document.Unit.Notes),
}; };
@@ -94,7 +101,7 @@ public sealed class PlanningExchangeService(IUnitRepository units, ILessonReposi
Title = unit.Title, Title = unit.Title,
StartDate = unit.StartDate, StartDate = unit.StartDate,
EndDate = unit.EndDate, EndDate = unit.EndDate,
Competencies = [.. unit.Competencies], Competencies = [.. unit.Competencies.Select(c => c.Code)],
Status = unit.Status, Status = unit.Status,
Notes = unit.Notes, Notes = unit.Notes,
Lessons = [.. unitLessons.Select(ToPayload)], Lessons = [.. unitLessons.Select(ToPayload)],
@@ -13,6 +13,7 @@ public partial class CompetencyOverviewTabViewModel : ObservableObject
private readonly IExamRepository _exams; private readonly IExamRepository _exams;
private readonly IExamResultRepository _results; private readonly IExamResultRepository _results;
private readonly ICompetencyDomainRepository _catalog; private readonly ICompetencyDomainRepository _catalog;
private readonly ICompetencyCatalogVersionRepository _versions;
private readonly IStudentRepository _students; private readonly IStudentRepository _students;
private readonly CompetencyAnalysisService _analysis; private readonly CompetencyAnalysisService _analysis;
private LearningGroup? _group; private LearningGroup? _group;
@@ -23,6 +24,7 @@ public partial class CompetencyOverviewTabViewModel : ObservableObject
[ObservableProperty] private string _emptyMessage = ""; [ObservableProperty] private string _emptyMessage = "";
public string GroupLabel => _group?.Name ?? ""; public string GroupLabel => _group?.Name ?? "";
public string VersionLabel { get; private set; } = "";
public ObservableCollection<CompetencyStudentOption> StudentOptions { get; } = []; public ObservableCollection<CompetencyStudentOption> StudentOptions { get; } = [];
public ObservableCollection<CompetencyOverviewRow> Rows { get; } = []; public ObservableCollection<CompetencyOverviewRow> Rows { get; } = [];
@@ -32,12 +34,14 @@ public partial class CompetencyOverviewTabViewModel : ObservableObject
public CompetencyOverviewTabViewModel(IUnitRepository units, IExamRepository exams, public CompetencyOverviewTabViewModel(IUnitRepository units, IExamRepository exams,
IExamResultRepository results, ICompetencyDomainRepository catalog, IExamResultRepository results, ICompetencyDomainRepository catalog,
ICompetencyCatalogVersionRepository versions,
IStudentRepository students, CompetencyAnalysisService analysis) IStudentRepository students, CompetencyAnalysisService analysis)
{ {
_units = units; _units = units;
_exams = exams; _exams = exams;
_results = results; _results = results;
_catalog = catalog; _catalog = catalog;
_versions = versions;
_students = students; _students = students;
_analysis = analysis; _analysis = analysis;
} }
@@ -53,9 +57,18 @@ public partial class CompetencyOverviewTabViewModel : ObservableObject
{ {
if (_group is null) return; if (_group is null) return;
var selectedStudentId = SelectedStudent?.Id; var selectedStudentId = SelectedStudent?.Id;
var domains = _group.SubjectId is Guid subjectId List<CompetencyDomain> domains;
? _catalog.GetBySubjectAndGrade(subjectId, _group.GradeLevel) if (_group.SubjectId is Guid subjectId)
: []; {
var versionId = CompetencyCatalogVersionResolver.Resolve(_versions, subjectId, _group.CompetencyCatalogVersionId);
VersionLabel = _versions.GetById(versionId)?.Name ?? "";
domains = _catalog.GetBySubjectAndGrade(subjectId, _group.GradeLevel, versionId);
}
else
{
VersionLabel = "";
domains = [];
}
var units = _units.GetByGroup(_group.Id); var units = _units.GetByGroup(_group.Id);
var exams = _exams.GetByGroup(_group.Id); var exams = _exams.GetByGroup(_group.Id);
var results = exams.SelectMany(x => _results.GetByExam(x.Id)).ToList(); var results = exams.SelectMany(x => _results.GetByExam(x.Id)).ToList();
@@ -81,6 +94,7 @@ public partial class CompetencyOverviewTabViewModel : ObservableObject
: ""; : "";
OnPropertyChanged(nameof(HasRows)); OnPropertyChanged(nameof(HasRows));
OnPropertyChanged(nameof(HasStudents)); OnPropertyChanged(nameof(HasStudents));
OnPropertyChanged(nameof(VersionLabel));
} }
partial void OnSelectedStudentChanged(CompetencyStudentOption? value) partial void OnSelectedStudentChanged(CompetencyStudentOption? value)
@@ -0,0 +1,91 @@
using CommunityToolkit.Mvvm.ComponentModel;
using LehrerApp.Core.Models;
namespace LehrerApp.Desktop.ViewModels.Groups;
// ── Kompetenz-Tags ──────────────────────────────────────────────────────────────
//
// Gemeinsame Toggle-UI für die drei Stellen, an denen Kompetenzen aus dem Katalog einem anderen
// Objekt zugeordnet werden (Unterrichtseinheit, Klausuraufgabe, Mitarbeit-Sitzung) - vor der
// Umstellung auf CompetencyItem.Id (TODO 16.5) war die Bau-Logik dreifach fast identisch
// dupliziert, jetzt an einer Stelle.
public class CompetencyTagGroup(string name, string code)
{
public string Name { get; } = name;
public string Code { get; } = code;
public string DisplayName { get; } = string.IsNullOrEmpty(code) ? name : $"{name} ({code})";
public List<CompetencyTag> Items { get; } = [];
}
public partial class CompetencyTag : ObservableObject
{
public Guid ItemId { get; }
public string Code { get; }
public string Description { get; }
public string Display { get; }
[ObservableProperty] private bool _isSelected;
/// <summary>Reicht die Tag-Instanz selbst durch, statt nur Id/Zustand - der Aufrufer liest
/// Code/Description direkt vom Tag, ohne eine eigene Lookup-Tabelle führen zu müssen.</summary>
public Action<CompetencyTag>? OnChanged { get; set; }
public CompetencyTag(Guid itemId, string code, string description, bool isSelected)
{
ItemId = itemId;
Code = code;
Description = description;
Display = string.IsNullOrEmpty(code) ? description : $"[{code}] {description}";
_isSelected = isSelected;
}
partial void OnIsSelectedChanged(bool value) => OnChanged?.Invoke(this);
}
public static class CompetencyTagGroupBuilder
{
/// <summary>Baut Tag-Gruppen aus dem aktuellen Katalog plus eine synthetische Gruppe "Nicht mehr
/// im Katalog" für bereits zugeordnete Referenzen, deren ItemId im übergebenen Katalog nicht
/// auflösbar ist (gelöscht, andere Bildungsplan-Version, oder nie aufgelöster Import) - zeigt
/// deren gespeicherte Momentaufnahme, damit eine Zuordnung nie stillschweigend verschwindet
/// (Kernanliegen von TODO 16.5). Tags der Katalog-Gruppen sind auf/abwählbar; Tags der
/// "Nicht mehr im Katalog"-Gruppe sind immer bereits ausgewählt (es gibt keinen Katalogeintrag,
/// dem man sie stattdessen zuordnen könnte) und lassen sich nur abwählen/entfernen.</summary>
public static List<CompetencyTagGroup> Build(
IReadOnlyList<CompetencyDomain> catalog, List<CompetencyReference> selected,
Action<CompetencyTag> onChanged)
{
var groups = new List<CompetencyTagGroup>();
var matchedIds = new HashSet<Guid>();
foreach (var domain in catalog.OrderBy(d => d.SortOrder))
{
var group = new CompetencyTagGroup(domain.Name, domain.Code);
foreach (var item in domain.Items.OrderBy(i => i.SortOrder))
{
var isSelected = selected.Any(s => s.ItemId == item.Id);
if (isSelected) matchedIds.Add(item.Id);
group.Items.Add(new CompetencyTag(item.Id, item.Code, item.Description, isSelected)
{
OnChanged = onChanged,
});
}
if (group.Items.Count > 0) groups.Add(group);
}
var orphaned = selected.Where(s => !matchedIds.Contains(s.ItemId)).ToList();
if (orphaned.Count > 0)
{
var group = new CompetencyTagGroup("Nicht mehr im Katalog", "");
foreach (var reference in orphaned)
group.Items.Add(new CompetencyTag(reference.ItemId, reference.Code, reference.Description, isSelected: true)
{
OnChanged = onChanged,
});
groups.Add(group);
}
return groups;
}
}
@@ -19,6 +19,7 @@ public partial class ExamDialogViewModel : ObservableObject
private readonly Guid _groupId; private readonly Guid _groupId;
private readonly Guid? _subjectId; private readonly Guid? _subjectId;
private readonly int _gradeLevel; private readonly int _gradeLevel;
private readonly Guid _competencyCatalogVersionId;
private readonly GradingSystem _gradingSystem; private readonly GradingSystem _gradingSystem;
private readonly Exam? _editingExam; private readonly Exam? _editingExam;
private readonly Exam? _duplicateSource; private readonly Exam? _duplicateSource;
@@ -63,11 +64,13 @@ public partial class ExamDialogViewModel : ObservableObject
public ExamDialogViewModel(IExamRepository exams, ICompetencyDomainRepository competencyDomains, public ExamDialogViewModel(IExamRepository exams, ICompetencyDomainRepository competencyDomains,
IGradingKeyTemplateRepository gradingKeyTemplates, GradingService grading, IGradingKeyTemplateRepository gradingKeyTemplates, GradingService grading,
Guid groupId, Guid? subjectId, int gradeLevel, GradingSystem gradingSystem, Guid groupId, Guid? subjectId, int gradeLevel, GradingSystem gradingSystem,
string defaultSubjectName, bool isDifferentiated, Exam? editingExam, Exam? duplicateSource) string defaultSubjectName, bool isDifferentiated, Exam? editingExam, Exam? duplicateSource,
Guid competencyCatalogVersionId = default)
{ {
_exams = exams; _competencyDomains = competencyDomains; _exams = exams; _competencyDomains = competencyDomains;
_gradingKeyTemplates = gradingKeyTemplates; _grading = grading; _gradingKeyTemplates = gradingKeyTemplates; _grading = grading;
_groupId = groupId; _subjectId = subjectId; _gradeLevel = gradeLevel; _groupId = groupId; _subjectId = subjectId; _gradeLevel = gradeLevel;
_competencyCatalogVersionId = competencyCatalogVersionId;
_gradingSystem = gradingSystem; _gradingSystem = gradingSystem;
_editingExam = editingExam; _editingExam = editingExam;
_duplicateSource = duplicateSource; _duplicateSource = duplicateSource;
@@ -75,7 +78,7 @@ public partial class ExamDialogViewModel : ObservableObject
IsDifferentiated = isDifferentiated; IsDifferentiated = isDifferentiated;
HasCompetencyCatalog = subjectId.HasValue HasCompetencyCatalog = subjectId.HasValue
&& _competencyDomains.GetBySubjectAndGrade(subjectId.Value, gradeLevel).Count > 0; && _competencyDomains.GetBySubjectAndGrade(subjectId.Value, gradeLevel, competencyCatalogVersionId).Count > 0;
foreach (var t in _gradingKeyTemplates.GetByGradingSystem(gradingSystem)) foreach (var t in _gradingKeyTemplates.GetByGradingSystem(gradingSystem))
AvailableTemplates.Add(t); AvailableTemplates.Add(t);
@@ -95,7 +98,7 @@ public partial class ExamDialogViewModel : ObservableObject
// gerade eine andere Niveau-Variante (E/G/Förder) derselben Klausur anzulegen. // gerade eine andere Niveau-Variante (E/G/Förder) derselben Klausur anzulegen.
SelectedNiveauName = isDuplicate ? "–" : NiveauDisplay.ToName(source.Niveau); SelectedNiveauName = isDuplicate ? "–" : NiveauDisplay.ToName(source.Niveau);
foreach (var t in source.Tasks.OrderBy(t => t.Nr)) foreach (var t in source.Tasks.OrderBy(t => t.Nr))
AddTaskInternal(t.Title, t.MaxPoints, t.Weight, [.. t.CompetencyCodes]); AddTaskInternal(t.Title, t.MaxPoints, t.Weight, [.. t.Competencies]);
UseWeighting = Tasks.Any(t => Math.Abs(t.Weight - 1.0) > 0.0001); UseWeighting = Tasks.Any(t => Math.Abs(t.Weight - 1.0) > 0.0001);
foreach (var e in source.GradingKey.OrderByDescending(e => e.MinPercent)) foreach (var e in source.GradingKey.OrderByDescending(e => e.MinPercent))
AddGradingKeyRowInternal(e.Grade, e.MinPercent); AddGradingKeyRowInternal(e.Grade, e.MinPercent);
@@ -145,10 +148,10 @@ public partial class ExamDialogViewModel : ObservableObject
RecomputeTotals(); RecomputeTotals();
} }
private void AddTaskInternal(string? title, double maxPoints, double weight, List<string> competencyCodes) private void AddTaskInternal(string? title, double maxPoints, double weight, List<CompetencyReference> competencies)
{ {
var item = new ExamTaskEditItem(title, maxPoints, weight, competencyCodes, var item = new ExamTaskEditItem(title, maxPoints, weight, competencies,
BuildCompetencyTagGroups(competencyCodes)) BuildCompetencyTagGroups(competencies))
{ {
OnChanged = RecomputeTotals, OnChanged = RecomputeTotals,
OnRemove = RemoveTask, OnRemove = RemoveTask,
@@ -159,19 +162,13 @@ public partial class ExamDialogViewModel : ObservableObject
RenumberTasks(); RenumberTasks();
} }
private List<CompetencyTagGroup> BuildCompetencyTagGroups(List<string> selectedCodes) private List<CompetencyTagGroup> BuildCompetencyTagGroups(List<CompetencyReference> selected)
{ {
var groups = new List<CompetencyTagGroup>(); if (!_subjectId.HasValue) return [];
if (!_subjectId.HasValue) return groups; var catalog = _competencyDomains.GetBySubjectAndGrade(_subjectId.Value, _gradeLevel, _competencyCatalogVersionId);
var selected = selectedCodes.ToHashSet(); // onChanged wird hier bewusst nicht gesetzt (bleibt null) - ExamTaskEditItem verdrahtet
foreach (var domain in _competencyDomains.GetBySubjectAndGrade(_subjectId.Value, _gradeLevel)) // tag.OnChanged selbst auf seinen eigenen OnCompetencyToggled-Handler, siehe Konstruktor.
{ return CompetencyTagGroupBuilder.Build(catalog, selected, _ => { });
var group = new CompetencyTagGroup(domain.Name, domain.Code);
foreach (var item in domain.Items.OrderBy(i => i.SortOrder))
group.Items.Add(new CompetencyTag(item.Code, item.Description, selected.Contains(item.Code)));
if (group.Items.Count > 0) groups.Add(group);
}
return groups;
} }
private void RemoveTask(ExamTaskEditItem item) private void RemoveTask(ExamTaskEditItem item)
@@ -365,12 +362,12 @@ public partial class ExamTaskEditItem : ObservableObject
[ObservableProperty] private bool _isCompetencyPanelOpen; [ObservableProperty] private bool _isCompetencyPanelOpen;
[ObservableProperty] private bool _showWeight; [ObservableProperty] private bool _showWeight;
public List<string> CompetencyCodes { get; } public List<CompetencyReference> Competencies { get; }
public ObservableCollection<CompetencyTagGroup> CompetencyTagGroups { get; } = []; public ObservableCollection<CompetencyTagGroup> CompetencyTagGroups { get; } = [];
public string CompetencySummary => CompetencyCodes.Count == 0 public string CompetencySummary => Competencies.Count == 0
? "Keine Kompetenzen" ? "Keine Kompetenzen"
: $"{CompetencyCodes.Count} Kompetenz(en)"; : $"{Competencies.Count} Kompetenz(en)";
public Action? OnChanged { get; set; } public Action? OnChanged { get; set; }
public Action<ExamTaskEditItem>? OnRemove { get; set; } public Action<ExamTaskEditItem>? OnRemove { get; set; }
@@ -378,12 +375,12 @@ public partial class ExamTaskEditItem : ObservableObject
public Action<ExamTaskEditItem>? OnMoveDown { get; set; } public Action<ExamTaskEditItem>? OnMoveDown { get; set; }
public ExamTaskEditItem(string? title, double maxPoints, double weight, public ExamTaskEditItem(string? title, double maxPoints, double weight,
List<string> competencyCodes, List<CompetencyTagGroup> tagGroups) List<CompetencyReference> competencies, List<CompetencyTagGroup> tagGroups)
{ {
_title = title ?? ""; _title = title ?? "";
_maxPoints = maxPoints; _maxPoints = maxPoints;
_weight = weight; _weight = weight;
CompetencyCodes = competencyCodes; Competencies = competencies;
foreach (var g in tagGroups) foreach (var g in tagGroups)
{ {
foreach (var tag in g.Items) tag.OnChanged = OnCompetencyToggled; foreach (var tag in g.Items) tag.OnChanged = OnCompetencyToggled;
@@ -391,10 +388,17 @@ public partial class ExamTaskEditItem : ObservableObject
} }
} }
private void OnCompetencyToggled(string code, bool selected) private void OnCompetencyToggled(CompetencyTag tag)
{ {
if (selected) { if (!CompetencyCodes.Contains(code)) CompetencyCodes.Add(code); } if (tag.IsSelected)
else CompetencyCodes.Remove(code); {
if (!Competencies.Any(r => r.ItemId == tag.ItemId))
Competencies.Add(new CompetencyReference { ItemId = tag.ItemId, Code = tag.Code, Description = tag.Description });
}
else
{
Competencies.RemoveAll(r => r.ItemId == tag.ItemId);
}
OnPropertyChanged(nameof(CompetencySummary)); OnPropertyChanged(nameof(CompetencySummary));
OnChanged?.Invoke(); OnChanged?.Invoke();
} }
@@ -412,6 +416,6 @@ public partial class ExamTaskEditItem : ObservableObject
Title = string.IsNullOrWhiteSpace(Title) ? null : Title.Trim(), Title = string.IsNullOrWhiteSpace(Title) ? null : Title.Trim(),
MaxPoints = MaxPoints, MaxPoints = MaxPoints,
Weight = Weight, Weight = Weight,
CompetencyCodes = CompetencyCodes, Competencies = Competencies,
}; };
} }
@@ -799,8 +799,10 @@ public partial class AddGroupDialogViewModel : ObservableObject
{ {
private readonly IGroupRepository _groups; private readonly IGroupRepository _groups;
private readonly ISubjectRepository _subjects; private readonly ISubjectRepository _subjects;
private readonly ICompetencyCatalogVersionRepository _competencyVersions;
private List<Subject> _allSubjects = []; private List<Subject> _allSubjects = [];
private LearningGroup? _editingGroup; private LearningGroup? _editingGroup;
private Guid? _pendingCompetencyVersionId;
public List<string> TypeOptions { get; } = ["Klasse", "Kurs"]; public List<string> TypeOptions { get; } = ["Klasse", "Kurs"];
[ObservableProperty] private string _selectedTypeName = "Kurs"; [ObservableProperty] private string _selectedTypeName = "Kurs";
@@ -829,18 +831,21 @@ public partial class AddGroupDialogViewModel : ObservableObject
[ObservableProperty] private bool _excludedFromUntisHub; [ObservableProperty] private bool _excludedFromUntisHub;
[ObservableProperty] private string _nameError = ""; [ObservableProperty] private string _nameError = "";
[ObservableProperty] private string _gradeLevelError = ""; [ObservableProperty] private string _gradeLevelError = "";
[ObservableProperty] private CompetencyVersionListItem? _selectedCompetencyVersion;
public List<string> SchoolYears { get; } public List<string> SchoolYears { get; }
public List<string> GradingOptions { get; } = ["Noten 1–6", "Punkte 0–15"]; public List<string> GradingOptions { get; } = ["Noten 1–6", "Punkte 0–15"];
public List<string> KnownSubjectNames { get; private set; } = []; public List<string> KnownSubjectNames { get; private set; } = [];
public ObservableCollection<CompetencyVersionListItem> AvailableCompetencyVersions { get; } = [];
public bool HasCompetencyVersionChoice => AvailableCompetencyVersions.Count > 0;
public LearningGroup? Result { get; private set; } public LearningGroup? Result { get; private set; }
public string DialogTitle => _editingGroup is null ? "Neue Lerngruppe anlegen" : "Lerngruppe bearbeiten"; public string DialogTitle => _editingGroup is null ? "Neue Lerngruppe anlegen" : "Lerngruppe bearbeiten";
public string SaveButtonText => _editingGroup is null ? "Anlegen" : "Speichern"; public string SaveButtonText => _editingGroup is null ? "Anlegen" : "Speichern";
public AddGroupDialogViewModel(IGroupRepository groups, ISubjectRepository subjects, public AddGroupDialogViewModel(IGroupRepository groups, ISubjectRepository subjects,
SchoolYearService sy) ICompetencyCatalogVersionRepository competencyVersions, SchoolYearService sy)
{ {
_groups = groups; _subjects = subjects; _groups = groups; _subjects = subjects; _competencyVersions = competencyVersions;
_allSubjects = subjects.GetAll(); _allSubjects = subjects.GetAll();
KnownSubjectNames = _allSubjects.Select(s => s.Name).ToList(); KnownSubjectNames = _allSubjects.Select(s => s.Name).ToList();
SchoolYears = sy.RecentSchoolYears(3); SchoolYears = sy.RecentSchoolYears(3);
@@ -852,11 +857,40 @@ public partial class AddGroupDialogViewModel : ObservableObject
}; };
} }
partial void OnSubjectChanged(string value) => LoadCompetencyVersions();
/// <summary>Baut die Versionsliste für das aktuell im Freitextfeld <see cref="Subject"/> erkannte
/// Fach neu auf. Ein neues, noch nicht angelegtes Fach hat noch keine Versionen - die Auswahl
/// bleibt dann leer (<see cref="HasCompetencyVersionChoice"/> blendet den Picker aus), der Kurs
/// bekommt beim Speichern automatisch die Standardversion, sobald das Fach existiert.</summary>
private void LoadCompetencyVersions()
{
var targetId = _pendingCompetencyVersionId ?? SelectedCompetencyVersion?.Id;
_pendingCompetencyVersionId = null;
AvailableCompetencyVersions.Clear();
var subjectName = Subject.Trim();
var subject = subjectName.Length == 0 ? null : _allSubjects.FirstOrDefault(
s => s.Name.Equals(subjectName, StringComparison.OrdinalIgnoreCase));
if (subject is not null)
{
var versions = _competencyVersions.GetBySubject(subject.Id);
if (versions.Count == 0) versions = [_competencyVersions.GetOrCreateDefault(subject.Id)];
foreach (var v in versions) AvailableCompetencyVersions.Add(new CompetencyVersionListItem(v));
}
SelectedCompetencyVersion = AvailableCompetencyVersions.FirstOrDefault(v => v.Id == targetId)
?? AvailableCompetencyVersions.FirstOrDefault(v => v.IsDefault)
?? AvailableCompetencyVersions.FirstOrDefault();
OnPropertyChanged(nameof(HasCompetencyVersionChoice));
}
public void LoadForEdit(LearningGroup group) public void LoadForEdit(LearningGroup group)
{ {
_editingGroup = group; _editingGroup = group;
SelectedTypeName = group.Type == GroupType.Class ? "Klasse" : "Kurs"; SelectedTypeName = group.Type == GroupType.Class ? "Klasse" : "Kurs";
Name = group.Name; Name = group.Name;
_pendingCompetencyVersionId = group.CompetencyCatalogVersionId;
Subject = group.SubjectId is Guid subjectId ? _subjects.GetById(subjectId)?.Name ?? "" : ""; Subject = group.SubjectId is Guid subjectId ? _subjects.GetById(subjectId)?.Name ?? "" : "";
GradeLevel = group.GradeLevel; GradeLevel = group.GradeLevel;
SelectedGradingName = group.GradingSystem == GradingSystem.Grades1To6 SelectedGradingName = group.GradingSystem == GradingSystem.Grades1To6
@@ -905,6 +939,7 @@ public partial class AddGroupDialogViewModel : ObservableObject
Result = _editingGroup ?? new LearningGroup(); Result = _editingGroup ?? new LearningGroup();
Result.Name = Name.Trim(); Result.Name = Name.Trim();
Result.SubjectId = subjectId; Result.SubjectId = subjectId;
Result.CompetencyCatalogVersionId = subjectId is null ? null : SelectedCompetencyVersion?.Id;
Result.Type = IsKurs ? GroupType.Course : GroupType.Class; Result.Type = IsKurs ? GroupType.Course : GroupType.Class;
Result.GradeLevel = GradeLevel; Result.GradeLevel = GradeLevel;
Result.GradingSystem = SelectedGradingName == "Punkte 0–15" Result.GradingSystem = SelectedGradingName == "Punkte 0–15"
@@ -919,3 +954,13 @@ public partial class AddGroupDialogViewModel : ObservableObject
_groups.Save(Result); _groups.Save(Result);
} }
} }
/// <summary>Anzeige-Wrapper für den Bildungsplan-Versions-Picker im Kursdialog, analog zu
/// <see cref="SubjectListItem"/>.</summary>
public sealed class CompetencyVersionListItem(CompetencyCatalogVersion v)
{
public Guid Id { get; } = v.Id;
public string Name { get; } = v.Name;
public bool IsDefault { get; } = v.IsDefault;
public string DisplayName => IsDefault ? $"{Name} (Standard)" : Name;
}
@@ -19,11 +19,13 @@ public partial class ParticipationTabViewModel : ObservableObject
private readonly IGroupMembershipRepository _memberships; private readonly IGroupMembershipRepository _memberships;
private readonly IGroupRepository _groups; private readonly IGroupRepository _groups;
private readonly ICompetencyDomainRepository _competencyDomains; private readonly ICompetencyDomainRepository _competencyDomains;
private readonly ICompetencyCatalogVersionRepository _competencyVersions;
private Guid _groupId; private Guid _groupId;
private string _schoolYear = ""; private string _schoolYear = "";
private Guid? _subjectId; private Guid? _subjectId;
private int _gradeLevel; private int _gradeLevel;
private Guid _competencyCatalogVersionId;
private GradingSystem _gradingSystem; private GradingSystem _gradingSystem;
public Guid GroupId => _groupId; public Guid GroupId => _groupId;
@@ -40,7 +42,7 @@ public partial class ParticipationTabViewModel : ObservableObject
[ObservableProperty] private bool _isReadOnly; [ObservableProperty] private bool _isReadOnly;
public string SelectedSessionDisplay => SelectedSession?.Display ?? ""; public string SelectedSessionDisplay => SelectedSession?.Display ?? "";
public List<string> ActiveCompetencyCodes { get; private set; } = []; public List<CompetencyReference> ActiveCompetencies { get; private set; } = [];
public ObservableCollection<ParticipationSessionItem> Sessions { get; } = []; public ObservableCollection<ParticipationSessionItem> Sessions { get; } = [];
public ObservableCollection<ParticipationStudentRow> StudentRows { get; } = []; public ObservableCollection<ParticipationStudentRow> StudentRows { get; } = [];
@@ -63,12 +65,14 @@ public partial class ParticipationTabViewModel : ObservableObject
IStudentRepository students, IStudentRepository students,
IGroupMembershipRepository memberships, IGroupMembershipRepository memberships,
IGroupRepository groups, IGroupRepository groups,
ICompetencyDomainRepository competencyDomains) ICompetencyDomainRepository competencyDomains,
ICompetencyCatalogVersionRepository competencyVersions)
{ {
_sessions = sessions; _entries = entries; _sessions = sessions; _entries = entries;
_aspects = aspects; _students = students; _aspects = aspects; _students = students;
_memberships = memberships; _groups = groups; _memberships = memberships; _groups = groups;
_competencyDomains = competencyDomains; _competencyDomains = competencyDomains;
_competencyVersions = competencyVersions;
} }
public void Initialize(Guid groupId, string schoolYear, bool isReadOnly = false) public void Initialize(Guid groupId, string schoolYear, bool isReadOnly = false)
@@ -80,11 +84,13 @@ public partial class ParticipationTabViewModel : ObservableObject
var group = _groups.GetById(groupId); var group = _groups.GetById(groupId);
_subjectId = group?.SubjectId; _subjectId = group?.SubjectId;
_gradeLevel = group?.GradeLevel ?? 0; _gradeLevel = group?.GradeLevel ?? 0;
_competencyCatalogVersionId = CompetencyCatalogVersionResolver.Resolve(
_competencyVersions, _subjectId, group?.CompetencyCatalogVersionId);
_gradingSystem = group?.GradingSystem ?? GradingSystem.Grades1To6; _gradingSystem = group?.GradingSystem ?? GradingSystem.Grades1To6;
GroupLabel = group?.Name ?? ""; GroupLabel = group?.Name ?? "";
HasCompetencyCatalog = _subjectId.HasValue HasCompetencyCatalog = _subjectId.HasValue
&& _competencyDomains.GetBySubjectAndGrade(_subjectId.Value, _gradeLevel).Count > 0; && _competencyDomains.GetBySubjectAndGrade(_subjectId.Value, _gradeLevel, _competencyCatalogVersionId).Count > 0;
LoadAspects(); LoadAspects();
LoadSessions(); LoadSessions();
@@ -126,14 +132,14 @@ public partial class ParticipationTabViewModel : ObservableObject
{ {
StudentRows.Clear(); StudentRows.Clear();
CompetencyTagGroups.Clear(); CompetencyTagGroups.Clear();
ActiveCompetencyCodes = []; ActiveCompetencies = [];
QuickInputCommand.NotifyCanExecuteChanged(); QuickInputCommand.NotifyCanExecuteChanged();
StatusQuickInputCommand.NotifyCanExecuteChanged(); StatusQuickInputCommand.NotifyCanExecuteChanged();
RebuildColumnsSignal++; RebuildColumnsSignal++;
return; return;
} }
LoadCompetencyTags(value.Id); // sets ActiveCompetencyCodes first LoadCompetencyTags(value.Id); // sets ActiveCompetencies first
LoadGrid(value.Id); // uses ActiveCompetencyCodes, fires RebuildColumnsSignal++ LoadGrid(value.Id); // uses ActiveCompetencies, fires RebuildColumnsSignal++
} }
private void LoadGrid(Guid sessionId) private void LoadGrid(Guid sessionId)
@@ -153,7 +159,7 @@ public partial class ParticipationTabViewModel : ObservableObject
var entry = entries.FirstOrDefault(e => e.StudentId == s.Id) var entry = entries.FirstOrDefault(e => e.StudentId == s.Id)
?? new ParticipationEntry { SessionId = sessionId, StudentId = s.Id }; ?? new ParticipationEntry { SessionId = sessionId, StudentId = s.Id };
var row = new ParticipationStudentRow(s.Id, s.FullName, entry, Aspects.ToList(), ActiveCompetencyCodes); var row = new ParticipationStudentRow(s.Id, s.FullName, entry, Aspects.ToList(), ActiveCompetencies);
row.OnRatingChanged = (sid, key, val) => SaveRating(sessionId, sid, key, val); row.OnRatingChanged = (sid, key, val) => SaveRating(sessionId, sid, key, val);
row.OnCompetencyRatingChanged = (sid, code, val) => SaveCompetencyRating(sessionId, sid, code, val); row.OnCompetencyRatingChanged = (sid, code, val) => SaveCompetencyRating(sessionId, sid, code, val);
row.HomeworkChangedCallback = (sid, val) => SaveHomework(sessionId, sid, val); row.HomeworkChangedCallback = (sid, val) => SaveHomework(sessionId, sid, val);
@@ -231,35 +237,31 @@ public partial class ParticipationTabViewModel : ObservableObject
{ {
CompetencyTagGroups.Clear(); CompetencyTagGroups.Clear();
var session = _sessions.GetById(sessionId); var session = _sessions.GetById(sessionId);
ActiveCompetencyCodes = session?.CompetencyCodes?.ToList() ?? []; ActiveCompetencies = session?.Competencies?.ToList() ?? [];
if (!_subjectId.HasValue) return; if (!_subjectId.HasValue) return;
var active = ActiveCompetencyCodes.ToHashSet(); var catalog = _competencyDomains.GetBySubjectAndGrade(_subjectId.Value, _gradeLevel, _competencyCatalogVersionId);
foreach (var group in CompetencyTagGroupBuilder.Build(catalog, ActiveCompetencies, OnTagToggled))
foreach (var domain in _competencyDomains.GetBySubjectAndGrade(_subjectId.Value, _gradeLevel)) CompetencyTagGroups.Add(group);
{
var group = new CompetencyTagGroup(domain.Name, domain.Code);
foreach (var item in domain.Items.OrderBy(i => i.SortOrder))
{
var tag = new CompetencyTag(item.Code, item.Description, active.Contains(item.Code));
tag.OnChanged = (code, sel) => OnTagToggled(code, sel);
group.Items.Add(tag);
}
if (group.Items.Count > 0)
CompetencyTagGroups.Add(group);
}
} }
private void OnTagToggled(string code, bool selected) private void OnTagToggled(CompetencyTag tag)
{ {
if (SelectedSession is null) return; if (SelectedSession is null) return;
var session = _sessions.GetById(SelectedSession.Id); var session = _sessions.GetById(SelectedSession.Id);
if (session is null) return; if (session is null) return;
if (selected) { if (!session.CompetencyCodes.Contains(code)) session.CompetencyCodes.Add(code); } if (tag.IsSelected)
else { session.CompetencyCodes.Remove(code); } {
if (!session.Competencies.Any(r => r.ItemId == tag.ItemId))
session.Competencies.Add(new CompetencyReference { ItemId = tag.ItemId, Code = tag.Code, Description = tag.Description });
}
else
{
session.Competencies.RemoveAll(r => r.ItemId == tag.ItemId);
}
_sessions.Save(session); _sessions.Save(session);
ActiveCompetencyCodes = session.CompetencyCodes.ToList(); ActiveCompetencies = session.Competencies.ToList();
if (StudentCompetencyRatingsVisible) if (StudentCompetencyRatingsVisible)
LoadGrid(SelectedSession.Id); // reloads rows with updated cells, fires RebuildColumnsSignal++ LoadGrid(SelectedSession.Id); // reloads rows with updated cells, fires RebuildColumnsSignal++
} }
@@ -363,22 +365,25 @@ public partial class ParticipationTabViewModel : ObservableObject
_entries.Save(entry); _entries.Save(entry);
} }
private void SaveCompetencyRating(Guid sessionId, Guid studentId, string code, int? value) // "key" ist der Kompetenz-ItemId als String (siehe ParticipationStudentRow/RatingCell) - reiner
// In-Memory-Transport zwischen Zelle und Save-Callback, nie persistiert.
private void SaveCompetencyRating(Guid sessionId, Guid studentId, string key, int? value)
{ {
var itemId = Guid.Parse(key);
var entry = _entries.GetBySessionAndStudent(sessionId, studentId) var entry = _entries.GetBySessionAndStudent(sessionId, studentId)
?? new ParticipationEntry ?? new ParticipationEntry
{ {
SessionId = sessionId, SessionId = sessionId,
StudentId = studentId, StudentId = studentId,
}; };
var existing = entry.CompetencyRatings.FirstOrDefault(r => r.Code == code); var existing = entry.CompetencyRatings.FirstOrDefault(r => r.ItemId == itemId);
if (value is null) if (value is null)
{ {
if (existing is not null) entry.CompetencyRatings.Remove(existing); if (existing is not null) entry.CompetencyRatings.Remove(existing);
} }
else else
{ {
if (existing is null) entry.CompetencyRatings.Add(new CompetencyRating { Code = code, Value = value.Value }); if (existing is null) entry.CompetencyRatings.Add(new CompetencyRating { ItemId = itemId, Value = value.Value });
else existing.Value = value.Value; else existing.Value = value.Value;
} }
_entries.Save(entry); _entries.Save(entry);
@@ -419,7 +424,7 @@ public partial class ParticipationStudentRow : ObservableObject
public Action<Guid, DayHighlightKind?>? DayHighlightChangedCallback { get; set; } public Action<Guid, DayHighlightKind?>? DayHighlightChangedCallback { get; set; }
public ParticipationStudentRow(Guid id, string name, ParticipationEntry entry, public ParticipationStudentRow(Guid id, string name, ParticipationEntry entry,
List<AspectColumnDef> aspects, List<string> competencyCodes) List<AspectColumnDef> aspects, List<CompetencyReference> competencies)
{ {
StudentId = id; StudentId = id;
Name = name; Name = name;
@@ -436,10 +441,12 @@ public partial class ParticipationStudentRow : ObservableObject
Cells.Add(cell); Cells.Add(cell);
} }
foreach (var code in competencyCodes) // AspectKey trägt hier den Kompetenz-ItemId als String - reiner In-Memory-Transport
// zwischen Zelle und Save-Callback (siehe SaveCompetencyRating), nie persistiert.
foreach (var competency in competencies)
{ {
var existing = entry.CompetencyRatings.FirstOrDefault(r => r.Code == code); var existing = entry.CompetencyRatings.FirstOrDefault(r => r.ItemId == competency.ItemId);
var cell = new RatingCell(id, code, existing?.Value); var cell = new RatingCell(id, competency.ItemId.ToString("D"), existing?.Value);
cell.OnChanged = (sid, key, val) => OnCompetencyRatingChanged?.Invoke(sid, key, val); cell.OnChanged = (sid, key, val) => OnCompetencyRatingChanged?.Invoke(sid, key, val);
CompetencyCells.Add(cell); CompetencyCells.Add(cell);
} }
@@ -720,37 +727,6 @@ public partial class RatingCell : ObservableObject
private void UpdateLabel() => DisplayLabel = ParticipationRatingScale.DisplayLabel(Type, Value); private void UpdateLabel() => DisplayLabel = ParticipationRatingScale.DisplayLabel(Type, Value);
} }
// ── Kompetenz-Tags ────────────────────────────────────────────────────────────
public class CompetencyTagGroup(string name, string code)
{
public string Name { get; } = name;
public string Code { get; } = code;
public string DisplayName { get; } = string.IsNullOrEmpty(code) ? name : $"{name} ({code})";
public List<CompetencyTag> Items { get; } = [];
}
public partial class CompetencyTag : ObservableObject
{
public string Code { get; }
public string Description { get; }
public string Display { get; }
[ObservableProperty] private bool _isSelected;
public Action<string, bool>? OnChanged { get; set; }
public CompetencyTag(string code, string description, bool isSelected)
{
Code = code;
Description = description;
Display = string.IsNullOrEmpty(code) ? description : $"[{code}] {description}";
_isSelected = isSelected;
}
partial void OnIsSelectedChanged(bool value) => OnChanged?.Invoke(Code, value);
}
// ── Hilfsklassen ────────────────────────────────────────────────────────────── // ── Hilfsklassen ──────────────────────────────────────────────────────────────
public class AspectColumnDef public class AspectColumnDef
@@ -34,6 +34,7 @@ public partial class PlanningTabViewModel : ObservableObject
private readonly IGroupRepository _groups; private readonly IGroupRepository _groups;
private readonly ISubjectRepository _subjects; private readonly ISubjectRepository _subjects;
private readonly ICompetencyDomainRepository _competencyDomains; private readonly ICompetencyDomainRepository _competencyDomains;
private readonly ICompetencyCatalogVersionRepository _competencyVersions;
private readonly AiSettingsService _aiSettings; private readonly AiSettingsService _aiSettings;
private readonly IParticipationSessionRepository _participationSessions; private readonly IParticipationSessionRepository _participationSessions;
@@ -44,6 +45,9 @@ public partial class PlanningTabViewModel : ObservableObject
public int GradeLevel { get; private set; } public int GradeLevel { get; private set; }
public string SubjectName { get; private set; } = ""; public string SubjectName { get; private set; } = "";
public string GroupLabel { get; private set; } = ""; public string GroupLabel { get; private set; } = "";
/// <summary>Aufgelöste Bildungsplan-Version dieser Gruppe (Gruppenwahl, sonst Standardversion des
/// Fachs) - <see cref="Guid.Empty"/> ohne Fach.</summary>
public Guid CompetencyCatalogVersionId { get; private set; }
[ObservableProperty] private UnitSummary? _selectedUnit; [ObservableProperty] private UnitSummary? _selectedUnit;
[ObservableProperty] private LessonSummary? _selectedLesson; [ObservableProperty] private LessonSummary? _selectedLesson;
@@ -85,11 +89,12 @@ public partial class PlanningTabViewModel : ObservableObject
public PlanningTabViewModel(IUnitRepository units, ILessonRepository lessons, public PlanningTabViewModel(IUnitRepository units, ILessonRepository lessons,
IGroupRepository groups, ISubjectRepository subjects, IGroupRepository groups, ISubjectRepository subjects,
ICompetencyDomainRepository competencyDomains, AiSettingsService aiSettings, ICompetencyDomainRepository competencyDomains, ICompetencyCatalogVersionRepository competencyVersions,
IParticipationSessionRepository participationSessions) AiSettingsService aiSettings, IParticipationSessionRepository participationSessions)
{ {
_units = units; _lessons = lessons; _groups = groups; _units = units; _lessons = lessons; _groups = groups;
_subjects = subjects; _competencyDomains = competencyDomains; _subjects = subjects; _competencyDomains = competencyDomains;
_competencyVersions = competencyVersions;
_aiSettings = aiSettings; _participationSessions = participationSessions; _aiSettings = aiSettings; _participationSessions = participationSessions;
} }
@@ -102,6 +107,8 @@ public partial class PlanningTabViewModel : ObservableObject
GradeLevel = group?.GradeLevel ?? 0; GradeLevel = group?.GradeLevel ?? 0;
SubjectName = SubjectId is Guid sid ? _subjects.GetById(sid)?.Name ?? "" : ""; SubjectName = SubjectId is Guid sid ? _subjects.GetById(sid)?.Name ?? "" : "";
GroupLabel = group?.Name ?? ""; GroupLabel = group?.Name ?? "";
CompetencyCatalogVersionId = CompetencyCatalogVersionResolver.Resolve(
_competencyVersions, SubjectId, group?.CompetencyCatalogVersionId);
LoadUnits(preferActive: true); LoadUnits(preferActive: true);
} }
@@ -577,8 +584,9 @@ public partial class UnitDialogViewModel : ObservableObject
private readonly Guid _groupId; private readonly Guid _groupId;
private readonly Guid? _subjectId; private readonly Guid? _subjectId;
private readonly int _gradeLevel; private readonly int _gradeLevel;
private readonly Guid _competencyCatalogVersionId;
private readonly Unit? _editingUnit; private readonly Unit? _editingUnit;
private readonly List<string> _competencyCodes; private readonly List<CompetencyReference> _competencyRefs;
[ObservableProperty] private string _title = ""; [ObservableProperty] private string _title = "";
[ObservableProperty] private string _startDateText = ""; [ObservableProperty] private string _startDateText = "";
@@ -593,8 +601,8 @@ public partial class UnitDialogViewModel : ObservableObject
public string[] StatusOptions => UnitStatusDisplay.Options; public string[] StatusOptions => UnitStatusDisplay.Options;
public ObservableCollection<CompetencyTagGroup> CompetencyTagGroups { get; } = []; public ObservableCollection<CompetencyTagGroup> CompetencyTagGroups { get; } = [];
public string CompetencySummary => _competencyCodes.Count == 0 public string CompetencySummary => _competencyRefs.Count == 0
? "Keine Kompetenzen" : $"{_competencyCodes.Count} Kompetenz(en)"; ? "Keine Kompetenzen" : $"{_competencyRefs.Count} Kompetenz(en)";
/// Gruppe + Fach kommen von der Lerngruppe, nicht editierbar (jede Gruppe unterrichtet ein /// Gruppe + Fach kommen von der Lerngruppe, nicht editierbar (jede Gruppe unterrichtet ein
/// Fach) — beide zusammen zeigen, da dieselbe Klasse in mehreren Fächern (mehrere /// Fach) — beide zusammen zeigen, da dieselbe Klasse in mehreren Fächern (mehrere
@@ -620,15 +628,17 @@ public partial class UnitDialogViewModel : ObservableObject
} }
public UnitDialogViewModel(IUnitRepository units, ICompetencyDomainRepository competencyDomains, public UnitDialogViewModel(IUnitRepository units, ICompetencyDomainRepository competencyDomains,
Guid groupId, Guid? subjectId, int gradeLevel, string groupName, string subjectName, Unit? editingUnit) Guid groupId, Guid? subjectId, int gradeLevel, string groupName, string subjectName, Unit? editingUnit,
Guid competencyCatalogVersionId = default)
{ {
_units = units; _competencyDomains = competencyDomains; _units = units; _competencyDomains = competencyDomains;
_groupId = groupId; _subjectId = subjectId; _gradeLevel = gradeLevel; _groupId = groupId; _subjectId = subjectId; _gradeLevel = gradeLevel;
_competencyCatalogVersionId = competencyCatalogVersionId;
_editingUnit = editingUnit; _editingUnit = editingUnit;
GroupSubjectDisplay = string.IsNullOrWhiteSpace(subjectName) GroupSubjectDisplay = string.IsNullOrWhiteSpace(subjectName)
? $"{groupName} · kein Fach hinterlegt (siehe Lerngruppe)" : $"{groupName} · {subjectName}"; ? $"{groupName} · kein Fach hinterlegt (siehe Lerngruppe)" : $"{groupName} · {subjectName}";
_competencyCodes = editingUnit is not null ? [.. editingUnit.Competencies] : []; _competencyRefs = editingUnit is not null ? [.. editingUnit.Competencies] : [];
BuildCompetencyTagGroups(); BuildCompetencyTagGroups();
if (editingUnit is not null) if (editingUnit is not null)
@@ -645,24 +655,22 @@ public partial class UnitDialogViewModel : ObservableObject
{ {
CompetencyTagGroups.Clear(); CompetencyTagGroups.Clear();
if (!_subjectId.HasValue) return; if (!_subjectId.HasValue) return;
var selected = _competencyCodes.ToHashSet(); var catalog = _competencyDomains.GetBySubjectAndGrade(_subjectId.Value, _gradeLevel, _competencyCatalogVersionId);
foreach (var domain in _competencyDomains.GetBySubjectAndGrade(_subjectId.Value, _gradeLevel)) foreach (var group in CompetencyTagGroupBuilder.Build(catalog, _competencyRefs, OnCompetencyToggled))
{ CompetencyTagGroups.Add(group);
var group = new CompetencyTagGroup(domain.Name, domain.Code);
foreach (var item in domain.Items.OrderBy(i => i.SortOrder))
{
var tag = new CompetencyTag(item.Code, item.Description, selected.Contains(item.Code));
tag.OnChanged = OnCompetencyToggled;
group.Items.Add(tag);
}
if (group.Items.Count > 0) CompetencyTagGroups.Add(group);
}
} }
private void OnCompetencyToggled(string code, bool selected) private void OnCompetencyToggled(CompetencyTag tag)
{ {
if (selected) { if (!_competencyCodes.Contains(code)) _competencyCodes.Add(code); } if (tag.IsSelected)
else _competencyCodes.Remove(code); {
if (!_competencyRefs.Any(r => r.ItemId == tag.ItemId))
_competencyRefs.Add(new CompetencyReference { ItemId = tag.ItemId, Code = tag.Code, Description = tag.Description });
}
else
{
_competencyRefs.RemoveAll(r => r.ItemId == tag.ItemId);
}
OnPropertyChanged(nameof(CompetencySummary)); OnPropertyChanged(nameof(CompetencySummary));
} }
@@ -703,7 +711,7 @@ public partial class UnitDialogViewModel : ObservableObject
Result.EndDate = endDate; Result.EndDate = endDate;
Result.Status = UnitStatusDisplay.FromName(StatusName); Result.Status = UnitStatusDisplay.FromName(StatusName);
Result.Notes = string.IsNullOrWhiteSpace(Notes) ? null : Notes.Trim(); Result.Notes = string.IsNullOrWhiteSpace(Notes) ? null : Notes.Trim();
Result.Competencies = _competencyCodes; Result.Competencies = _competencyRefs;
if (Result.Status == UnitStatus.Active) if (Result.Status == UnitStatus.Active)
{ {
// Pro Lerngruppe gibt es genau einen aktuellen Arbeitskontext. Frühere laufende // Pro Lerngruppe gibt es genau einen aktuellen Arbeitskontext. Frühere laufende
@@ -22,39 +22,97 @@ public partial class SettingsViewModel
[ObservableProperty] private SubjectListItem? _catalogSubject; [ObservableProperty] private SubjectListItem? _catalogSubject;
[ObservableProperty] private int _catalogGradeLevel = 10; [ObservableProperty] private int _catalogGradeLevel = 10;
[ObservableProperty] private CompetencyCatalogVersion? _catalogVersion;
[ObservableProperty] private string _newDomainName = ""; [ObservableProperty] private string _newDomainName = "";
[ObservableProperty] private string _newDomainCode = ""; [ObservableProperty] private string _newDomainCode = "";
[ObservableProperty] private string _catalogValidation = ""; [ObservableProperty] private string _catalogValidation = "";
[ObservableProperty] private string _newVersionName = "";
[ObservableProperty] private string _versionValidation = "";
public ObservableCollection<DomainEditItem> Domains { get; } = []; public ObservableCollection<DomainEditItem> Domains { get; } = [];
public ObservableCollection<CompetencyCatalogVersion> CatalogVersions { get; } = [];
// ── Katalog: Laden ──────────────────────────────────────────────────────── // ── Katalog: Laden ────────────────────────────────────────────────────────
partial void OnCatalogSubjectChanged(SubjectListItem? value) => LoadCatalog(); partial void OnCatalogSubjectChanged(SubjectListItem? value) => LoadVersions();
partial void OnCatalogGradeLevelChanged(int value) => LoadCatalog(); partial void OnCatalogGradeLevelChanged(int value) => LoadCatalog();
partial void OnCatalogVersionChanged(CompetencyCatalogVersion? value) => LoadCatalog();
private void LoadVersions()
{
var selectedId = CatalogVersion?.Id;
CatalogVersions.Clear();
if (CatalogSubject is null) { LoadCatalog(); return; }
foreach (var v in _versionRepo.GetBySubject(CatalogSubject.Id))
CatalogVersions.Add(v);
if (CatalogVersions.Count == 0)
CatalogVersions.Add(_versionRepo.GetOrCreateDefault(CatalogSubject.Id));
CatalogVersion = CatalogVersions.FirstOrDefault(v => v.Id == selectedId)
?? CatalogVersions.FirstOrDefault(v => v.IsDefault)
?? CatalogVersions.FirstOrDefault();
}
private void LoadCatalog() private void LoadCatalog()
{ {
Domains.Clear(); Domains.Clear();
CatalogValidation = ""; CatalogValidation = "";
if (CatalogSubject is null) return; if (CatalogSubject is null || CatalogVersion is null) return;
foreach (var d in _domainRepo.GetBySubjectAndGrade(CatalogSubject.Id, CatalogGradeLevel)) foreach (var d in _domainRepo.GetBySubjectAndGrade(CatalogSubject.Id, CatalogGradeLevel, CatalogVersion.Id))
Domains.Add(CreateDomainEditItem(d)); Domains.Add(CreateDomainEditItem(d));
RefreshDomainMoveState(); RefreshDomainMoveState();
} }
// ── Versionen (Bildungspläne) verwalten ──────────────────────────────────
[RelayCommand]
private void AddCatalogVersion()
{
if (CatalogSubject is null) { VersionValidation = "Bitte zuerst ein Fach auswählen."; return; }
if (string.IsNullOrWhiteSpace(NewVersionName)) { VersionValidation = "Name der Version erforderlich."; return; }
var version = new CompetencyCatalogVersion
{
SubjectId = CatalogSubject.Id, Name = NewVersionName.Trim(),
SortOrder = CatalogVersions.Count,
};
_versionRepo.Save(version);
CatalogVersions.Add(version);
CatalogVersion = version;
NewVersionName = ""; VersionValidation = "";
}
[RelayCommand]
private void SetCatalogVersionAsDefault(CompetencyCatalogVersion? version)
{
if (version is null || CatalogSubject is null) return;
version.IsDefault = true;
_versionRepo.Save(version);
LoadVersions();
}
[RelayCommand]
private void DeleteCatalogVersion(CompetencyCatalogVersion? version)
{
if (version is null) return;
try { _versionRepo.Delete(version.Id); }
catch (InvalidOperationException ex) { VersionValidation = ex.Message; return; }
LoadVersions();
}
// ── Katalog: Bereich hinzufügen / löschen ──────────────────────────────── // ── Katalog: Bereich hinzufügen / löschen ────────────────────────────────
[RelayCommand] [RelayCommand]
private void AddDomain() private void AddDomain()
{ {
if (CatalogSubject is null) { CatalogValidation = "Bitte zuerst ein Fach auswählen."; return; } if (CatalogSubject is null) { CatalogValidation = "Bitte zuerst ein Fach auswählen."; return; }
if (CatalogVersion is null) { CatalogValidation = "Bitte zuerst eine Version auswählen."; return; }
if (string.IsNullOrWhiteSpace(NewDomainName)) { CatalogValidation = "Bereichsname erforderlich."; return; } if (string.IsNullOrWhiteSpace(NewDomainName)) { CatalogValidation = "Bereichsname erforderlich."; return; }
var domain = new CompetencyDomain var domain = new CompetencyDomain
{ {
SubjectId = CatalogSubject.Id, SubjectId = CatalogSubject.Id,
GradeLevel = CatalogGradeLevel, GradeLevel = CatalogGradeLevel,
VersionId = CatalogVersion.Id,
Name = NewDomainName.Trim(), Name = NewDomainName.Trim(),
Code = NewDomainCode.Trim(), Code = NewDomainCode.Trim(),
SortOrder = Domains.Count, SortOrder = Domains.Count,
@@ -27,11 +27,16 @@ public partial class SettingsViewModel
CatalogValidation = "Bitte zuerst ein Fach auswählen."; CatalogValidation = "Bitte zuerst ein Fach auswählen.";
return null; return null;
} }
if (CatalogVersion is null)
{
CatalogValidation = "Bitte zuerst eine Version auswählen.";
return null;
}
try try
{ {
CatalogValidation = ""; CatalogValidation = "";
return _catalogImport.Analyze( return _catalogImport.Analyze(
json, CatalogSubject.Id, CatalogSubject.Name, CatalogGradeLevel); json, CatalogSubject.Id, CatalogSubject.Name, CatalogGradeLevel, CatalogVersion.Id);
} }
catch (InvalidDataException ex) catch (InvalidDataException ex)
{ {
@@ -71,9 +76,15 @@ public partial class SettingsViewModel
return null; return null;
} }
if (CatalogVersion is null)
{
CatalogValidation = "Bitte zuerst eine Version auswählen.";
return null;
}
CatalogValidation = ""; CatalogValidation = "";
return _catalogImport.Analyze(SerializeCatalog(targetGradeLevel), CatalogSubject.Id, return _catalogImport.Analyze(SerializeCatalog(targetGradeLevel), CatalogSubject.Id,
CatalogSubject.Name, targetGradeLevel); CatalogSubject.Name, targetGradeLevel, CatalogVersion.Id);
} }
public void SetCatalogCopyStatus(int targetGradeLevel) => public void SetCatalogCopyStatus(int targetGradeLevel) =>
@@ -49,6 +49,7 @@ public partial class SettingsViewModel : ObservableObject
{ {
private readonly ISubjectRepository _subjects; private readonly ISubjectRepository _subjects;
private readonly ICompetencyDomainRepository _domainRepo; private readonly ICompetencyDomainRepository _domainRepo;
private readonly ICompetencyCatalogVersionRepository _versionRepo;
private readonly IGradingKeyTemplateRepository _gradingKeyTemplates; private readonly IGradingKeyTemplateRepository _gradingKeyTemplates;
private readonly IGradingSchemeRepository _gradingSchemes; private readonly IGradingSchemeRepository _gradingSchemes;
private readonly GradingService _grading; private readonly GradingService _grading;
@@ -95,6 +96,7 @@ public partial class SettingsViewModel : ObservableObject
public TrashViewModel TrashTab { get; } public TrashViewModel TrashTab { get; }
public SettingsViewModel(ISubjectRepository subjects, ICompetencyDomainRepository domainRepo, public SettingsViewModel(ISubjectRepository subjects, ICompetencyDomainRepository domainRepo,
ICompetencyCatalogVersionRepository versionRepo,
IGradingKeyTemplateRepository gradingKeyTemplates, IGradingSchemeRepository gradingSchemes, IGradingKeyTemplateRepository gradingKeyTemplates, IGradingSchemeRepository gradingSchemes,
GradingService grading, BackupService backups, BackupSettingsService backupSettings, GradingService grading, BackupService backups, BackupSettingsService backupSettings,
DatabaseEncryptionService dbEncryption, DatabaseEncryptionService dbEncryption,
@@ -123,6 +125,7 @@ public partial class SettingsViewModel : ObservableObject
TrashTab = trashTab; TrashTab = trashTab;
_subjects = subjects; _subjects = subjects;
_domainRepo = domainRepo; _domainRepo = domainRepo;
_versionRepo = versionRepo;
_gradingKeyTemplates = gradingKeyTemplates; _gradingKeyTemplates = gradingKeyTemplates;
_gradingSchemes = gradingSchemes; _gradingSchemes = gradingSchemes;
_grading = grading; _grading = grading;
@@ -39,6 +39,21 @@
HorizontalAlignment="Stretch"/> HorizontalAlignment="Stretch"/>
</StackPanel> </StackPanel>
<!-- Bildungsplan-Version: nur sichtbar, wenn das Fach bereits existiert und mehr als eine
Version hat (neue Bildungspläne wachsen klassenstufenweise hoch, siehe Settings/Kompetenzen) -->
<StackPanel Spacing="4" IsVisible="{Binding HasCompetencyVersionChoice}">
<TextBlock Text="Bildungsplan-Version" FontSize="12" Opacity="0.7"/>
<ComboBox ItemsSource="{Binding AvailableCompetencyVersions}"
SelectedItem="{Binding SelectedCompetencyVersion}"
HorizontalAlignment="Stretch">
<ComboBox.ItemTemplate>
<DataTemplate DataType="vm:CompetencyVersionListItem">
<TextBlock Text="{Binding DisplayName}"/>
</DataTemplate>
</ComboBox.ItemTemplate>
</ComboBox>
</StackPanel>
<Grid ColumnDefinitions="*,12,*"> <Grid ColumnDefinitions="*,12,*">
<StackPanel Grid.Column="0" Spacing="4"> <StackPanel Grid.Column="0" Spacing="4">
<TextBlock Text="Klassenstufe *" FontSize="12" Opacity="0.7"/> <TextBlock Text="Klassenstufe *" FontSize="12" Opacity="0.7"/>
@@ -8,6 +8,8 @@
<Grid ColumnDefinitions="*,Auto"> <Grid ColumnDefinitions="*,Auto">
<StackPanel Grid.Column="0" Spacing="3"> <StackPanel Grid.Column="0" Spacing="3">
<TextBlock Text="Kompetenzübersicht" FontSize="18" FontWeight="SemiBold"/> <TextBlock Text="Kompetenzübersicht" FontSize="18" FontWeight="SemiBold"/>
<TextBlock Text="{Binding VersionLabel, StringFormat='Bildungsplan-Version: {0}'}" FontSize="12" Opacity="0.65"
IsVisible="{Binding VersionLabel, Converter={x:Static StringConverters.IsNotNullOrEmpty}}"/>
<TextBlock Text="{Binding Summary}" FontSize="12" Opacity="0.65"/> <TextBlock Text="{Binding Summary}" FontSize="12" Opacity="0.65"/>
</StackPanel> </StackPanel>
<StackPanel Grid.Column="1" Orientation="Horizontal" Spacing="8" VerticalAlignment="Top"> <StackPanel Grid.Column="1" Orientation="Horizontal" Spacing="8" VerticalAlignment="Top">
@@ -245,13 +245,17 @@ public partial class GroupDetailView : UserControl
{ {
if (DataContext is not GroupDetailViewModel vm || vm.Group is null) return false; if (DataContext is not GroupDetailViewModel vm || vm.Group is null) return false;
var competencyCatalogVersionId = CompetencyCatalogVersionResolver.Resolve(
App.Services.GetRequiredService<ICompetencyCatalogVersionRepository>(),
vm.Group.SubjectId, vm.Group.CompetencyCatalogVersionId);
var dialogVm = new ExamDialogViewModel( var dialogVm = new ExamDialogViewModel(
App.Services.GetRequiredService<IExamRepository>(), App.Services.GetRequiredService<IExamRepository>(),
App.Services.GetRequiredService<ICompetencyDomainRepository>(), App.Services.GetRequiredService<ICompetencyDomainRepository>(),
App.Services.GetRequiredService<IGradingKeyTemplateRepository>(), App.Services.GetRequiredService<IGradingKeyTemplateRepository>(),
App.Services.GetRequiredService<GradingService>(), App.Services.GetRequiredService<GradingService>(),
groupId, vm.Group.SubjectId, vm.Group.GradeLevel, vm.Group.GradingSystem, groupId, vm.Group.SubjectId, vm.Group.GradeLevel, vm.Group.GradingSystem,
vm.SubjectName, vm.Group.IsDifferentiated, editingExam, duplicateSource); vm.SubjectName, vm.Group.IsDifferentiated, editingExam, duplicateSource,
competencyCatalogVersionId);
var dialog = new ExamDialog { DataContext = dialogVm }; var dialog = new ExamDialog { DataContext = dialogVm };
var owner = TopLevel.GetTopLevel(this) as Window; var owner = TopLevel.GetTopLevel(this) as Window;
@@ -81,14 +81,14 @@ public partial class ParticipationTabView : UserControl
}); });
// Kompetenz-Spalten (opt-in) // Kompetenz-Spalten (opt-in)
if (_vm.StudentCompetencyRatingsVisible && _vm.ActiveCompetencyCodes.Count > 0) if (_vm.StudentCompetencyRatingsVisible && _vm.ActiveCompetencies.Count > 0)
{ {
foreach (var (code, i) in _vm.ActiveCompetencyCodes.Select((c, i) => (c, i))) foreach (var (competency, i) in _vm.ActiveCompetencies.Select((c, i) => (c, i)))
{ {
var idx = i; var idx = i;
grid.Columns.Add(new DataGridTemplateColumn grid.Columns.Add(new DataGridTemplateColumn
{ {
Header = code, Header = string.IsNullOrEmpty(competency.Code) ? competency.Description : competency.Code,
Width = new DataGridLength(80, DataGridLengthUnitType.Pixel), Width = new DataGridLength(80, DataGridLengthUnitType.Pixel),
CellTemplate = BuildCellTemplate(idx, forCompetency: true, _vm.IsReadOnly), CellTemplate = BuildCellTemplate(idx, forCompetency: true, _vm.IsReadOnly),
}); });
@@ -54,7 +54,8 @@ public partial class PlanningTabView : UserControl
var dialogVm = new UnitDialogViewModel( var dialogVm = new UnitDialogViewModel(
App.Services.GetRequiredService<IUnitRepository>(), App.Services.GetRequiredService<IUnitRepository>(),
App.Services.GetRequiredService<ICompetencyDomainRepository>(), App.Services.GetRequiredService<ICompetencyDomainRepository>(),
groupId, vm.SubjectId, vm.GradeLevel, vm.GroupLabel, vm.SubjectName, editingUnit); groupId, vm.SubjectId, vm.GradeLevel, vm.GroupLabel, vm.SubjectName, editingUnit,
vm.CompetencyCatalogVersionId);
var dialog = new UnitDialog { DataContext = dialogVm }; var dialog = new UnitDialog { DataContext = dialogVm };
var owner = TopLevel.GetTopLevel(this) as Window; var owner = TopLevel.GetTopLevel(this) as Window;
@@ -2,6 +2,7 @@
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:vm="clr-namespace:LehrerApp.Desktop.ViewModels.Settings" xmlns:vm="clr-namespace:LehrerApp.Desktop.ViewModels.Settings"
xmlns:services="clr-namespace:LehrerApp.Core.Services;assembly=LehrerApp.Core" xmlns:services="clr-namespace:LehrerApp.Core.Services;assembly=LehrerApp.Core"
xmlns:models="clr-namespace:LehrerApp.Core.Models;assembly=LehrerApp.Core"
xmlns:shared="clr-namespace:LehrerApp.Desktop.Views.Shared" xmlns:shared="clr-namespace:LehrerApp.Desktop.Views.Shared"
x:Class="LehrerApp.Desktop.Views.Settings.SettingsView" x:Class="LehrerApp.Desktop.Views.Settings.SettingsView"
x:DataType="vm:SettingsViewModel"> x:DataType="vm:SettingsViewModel">
@@ -112,8 +113,8 @@
<ScrollViewer> <ScrollViewer>
<StackPanel Margin="32,20,32,28" Spacing="14" MaxWidth="640"> <StackPanel Margin="32,20,32,28" Spacing="14" MaxWidth="640">
<!-- Fach + Klassenstufe Auswahl + Import/Export --> <!-- Fach + Klassenstufe + Bildungsplan-Version Auswahl + Import/Export -->
<Grid ColumnDefinitions="*,12,100,12,Auto,8,Auto,8,Auto"> <Grid ColumnDefinitions="*,12,90,12,160,12,Auto,8,Auto,8,Auto">
<ComboBox Grid.Column="0" <ComboBox Grid.Column="0"
ItemsSource="{Binding Subjects}" ItemsSource="{Binding Subjects}"
SelectedItem="{Binding CatalogSubject}" SelectedItem="{Binding CatalogSubject}"
@@ -128,15 +129,63 @@
<NumericUpDown Grid.Column="2" <NumericUpDown Grid.Column="2"
Value="{Binding CatalogGradeLevel}" Value="{Binding CatalogGradeLevel}"
Minimum="1" Maximum="13" FormatString="0"/> Minimum="1" Maximum="13" FormatString="0"/>
<Button Grid.Column="4" Content="JSON importieren" Click="OnImportClick" <ComboBox Grid.Column="4"
ItemsSource="{Binding CatalogVersions}"
SelectedItem="{Binding CatalogVersion}"
IsEnabled="{Binding CatalogSubject, Converter={x:Static ObjectConverters.IsNotNull}}"
HorizontalAlignment="Stretch"
ToolTip.Tip="Bildungsplan-Version dieses Katalogs">
<ComboBox.ItemTemplate>
<DataTemplate DataType="models:CompetencyCatalogVersion">
<TextBlock Text="{Binding Name}"/>
</DataTemplate>
</ComboBox.ItemTemplate>
</ComboBox>
<Button Grid.Column="6" Content="JSON importieren" Click="OnImportClick"
IsEnabled="{Binding CatalogSubject, Converter={x:Static ObjectConverters.IsNotNull}}"/> IsEnabled="{Binding CatalogSubject, Converter={x:Static ObjectConverters.IsNotNull}}"/>
<Button Grid.Column="6" Content="JSON exportieren" Click="OnExportClick" <Button Grid.Column="8" Content="JSON exportieren" Click="OnExportClick"
IsEnabled="{Binding CatalogSubject, Converter={x:Static ObjectConverters.IsNotNull}}"/> IsEnabled="{Binding CatalogSubject, Converter={x:Static ObjectConverters.IsNotNull}}"/>
<Button Grid.Column="8" Content="Kopieren…" Click="OnCopyCatalogClick" <Button Grid.Column="10" Content="Kopieren…" Click="OnCopyCatalogClick"
IsEnabled="{Binding CatalogSubject, Converter={x:Static ObjectConverters.IsNotNull}}" IsEnabled="{Binding CatalogSubject, Converter={x:Static ObjectConverters.IsNotNull}}"
ToolTip.Tip="Katalog in eine andere Klassenstufe kopieren"/> ToolTip.Tip="Katalog in eine andere Klassenstufe (derselben Version) kopieren"/>
</Grid> </Grid>
<!-- Bildungsplan-Versionen verwalten -->
<Border BorderBrush="{DynamicResource SystemControlForegroundBaseLowBrush}"
BorderThickness="1" CornerRadius="6" Padding="14,12"
IsVisible="{Binding CatalogSubject, Converter={x:Static ObjectConverters.IsNotNull}}">
<StackPanel Spacing="10">
<TextBlock Text="Bildungsplan-Versionen" FontSize="12" FontWeight="SemiBold" Opacity="0.7"
ToolTip.Tip="Für schrittweise hochwachsende neue Bildungspläne: mehrere parallel gültige Kompetenzkataloge je Fach, je Kurs auswählbar."/>
<ItemsControl ItemsSource="{Binding CatalogVersions}">
<ItemsControl.ItemTemplate>
<DataTemplate DataType="models:CompetencyCatalogVersion">
<Grid ColumnDefinitions="*,Auto,8,Auto,8,Auto" Margin="0,3">
<TextBlock Grid.Column="0" Text="{Binding Name}" VerticalAlignment="Center"/>
<TextBlock Grid.Column="1" Text="Standard" FontSize="11" Opacity="0.6"
VerticalAlignment="Center" IsVisible="{Binding IsDefault}"/>
<Button Grid.Column="3" Content="Als Standard" FontSize="12" Padding="8,3"
IsVisible="{Binding !IsDefault}"
Command="{Binding $parent[ItemsControl].((vm:SettingsViewModel)DataContext).SetCatalogVersionAsDefaultCommand}"
CommandParameter="{Binding}"/>
<Button Grid.Column="5" Content="Löschen" FontSize="12" Padding="8,3"
Command="{Binding $parent[ItemsControl].((vm:SettingsViewModel)DataContext).DeleteCatalogVersionCommand}"
CommandParameter="{Binding}"/>
</Grid>
</DataTemplate>
</ItemsControl.ItemTemplate>
</ItemsControl>
<Grid ColumnDefinitions="*,12,Auto">
<TextBox Grid.Column="0" Text="{Binding NewVersionName}"
PlaceholderText="Name der neuen Version (z.B. Bildungsplan 2026)"/>
<Button Grid.Column="2" Content="Version anlegen" Command="{Binding AddCatalogVersionCommand}"/>
</Grid>
<TextBlock Text="{Binding VersionValidation}" Foreground="Red" FontSize="12"
TextWrapping="Wrap"
IsVisible="{Binding VersionValidation, Converter={x:Static StringConverters.IsNotNullOrEmpty}}"/>
</StackPanel>
</Border>
<!-- Katalog-Validierungsmeldung --> <!-- Katalog-Validierungsmeldung -->
<TextBlock Text="{Binding CatalogValidation}" Foreground="Red" FontSize="12" <TextBlock Text="{Binding CatalogValidation}" Foreground="Red" FontSize="12"
IsVisible="{Binding CatalogValidation, Converter={x:Static StringConverters.IsNotNullOrEmpty}}"/> IsVisible="{Binding CatalogValidation, Converter={x:Static StringConverters.IsNotNullOrEmpty}}"/>
+1
View File
@@ -146,6 +146,7 @@ public class EventApplier(LiteDbContext db, byte[] syncKey, HttpClient? http = n
Simple<SupervisionDuty>(context => context.SupervisionDuties); Simple<SupervisionDuty>(context => context.SupervisionDuties);
Simple<SubstitutionEntry>(context => context.SubstitutionEntries); Simple<SubstitutionEntry>(context => context.SubstitutionEntries);
Simple<CompetencyDomain>(context => context.CompetencyDomains); Simple<CompetencyDomain>(context => context.CompetencyDomains);
Simple<CompetencyCatalogVersion>(context => context.CompetencyCatalogVersions);
Simple<Vorgang>(context => context.Vorgaenge); Simple<Vorgang>(context => context.Vorgaenge);
Simple<UntisHubJobState>(context => context.UntisHubJobStates); Simple<UntisHubJobState>(context => context.UntisHubJobStates);
@@ -8,6 +8,12 @@ public sealed class CompetencyAnalysisServiceTests
{ {
private readonly CompetencyAnalysisService _service = new(); private readonly CompetencyAnalysisService _service = new();
private static readonly CompetencyItem K1 = new() { Code = "K1", Description = "Erste Kompetenz" };
private static readonly CompetencyItem K2 = new() { Code = "K2", Description = "Zweite Kompetenz", SortOrder = 1 };
private static CompetencyReference Ref(CompetencyItem item) =>
new() { ItemId = item.Id, Code = item.Code, Description = item.Description };
[Fact] [Fact]
public void Analyze_UnterscheidetPlanungBehandlungUndPruefung() public void Analyze_UnterscheidetPlanungBehandlungUndPruefung()
{ {
@@ -15,16 +21,16 @@ public sealed class CompetencyAnalysisServiceTests
var catalog = Catalog(); var catalog = Catalog();
var units = new List<Unit> var units = new List<Unit>
{ {
new() { GroupId = groupId, Status = UnitStatus.Planned, Competencies = ["K1"] }, new() { GroupId = groupId, Status = UnitStatus.Planned, Competencies = [Ref(K1)] },
new() { GroupId = groupId, Status = UnitStatus.Active, Competencies = ["K1"] }, new() { GroupId = groupId, Status = UnitStatus.Active, Competencies = [Ref(K1)] },
new() { GroupId = groupId, Status = UnitStatus.Completed, Competencies = ["K1"] }, new() { GroupId = groupId, Status = UnitStatus.Completed, Competencies = [Ref(K1)] },
}; };
var exams = new List<Exam> var exams = new List<Exam>
{ {
new() { GroupId = groupId, Status = ExamStatus.Planned, new() { GroupId = groupId, Status = ExamStatus.Planned,
Tasks = [new ExamTask { MaxPoints = 10, CompetencyCodes = ["K1"] }] }, Tasks = [new ExamTask { MaxPoints = 10, Competencies = [Ref(K1)] }] },
new() { GroupId = groupId, Status = ExamStatus.Graded, new() { GroupId = groupId, Status = ExamStatus.Graded,
Tasks = [new ExamTask { MaxPoints = 10, CompetencyCodes = ["K1"] }] }, Tasks = [new ExamTask { MaxPoints = 10, Competencies = [Ref(K1)] }] },
}; };
var item = Assert.Single(_service.Analyze(catalog, units, exams, [])); var item = Assert.Single(_service.Analyze(catalog, units, exams, []));
@@ -46,8 +52,8 @@ public sealed class CompetencyAnalysisServiceTests
Status = ExamStatus.Graded, Status = ExamStatus.Graded,
Tasks = Tasks =
[ [
new ExamTask { MaxPoints = 10, CompetencyCodes = ["K1"] }, new ExamTask { MaxPoints = 10, Competencies = [Ref(K1)] },
new ExamTask { MaxPoints = 20, CompetencyCodes = ["K1"] }, new ExamTask { MaxPoints = 20, Competencies = [Ref(K1)] },
], ],
}; };
var results = new List<ExamResult> var results = new List<ExamResult>
@@ -69,13 +75,13 @@ public sealed class CompetencyAnalysisServiceTests
} }
[Fact] [Fact]
public void Analyze_AufgabeMitMehrerenCodes_WertetJedeZugeordneteKompetenzAus() public void Analyze_AufgabeMitMehrerenKompetenzen_WertetJedeZugeordneteKompetenzAus()
{ {
var studentId = Guid.NewGuid(); var studentId = Guid.NewGuid();
var exam = new Exam var exam = new Exam
{ {
Status = ExamStatus.Returned, Status = ExamStatus.Returned,
Tasks = [new ExamTask { MaxPoints = 8, CompetencyCodes = ["K1", "K2"] }], Tasks = [new ExamTask { MaxPoints = 8, Competencies = [Ref(K1), Ref(K2)] }],
}; };
var result = new ExamResult { ExamId = exam.Id, StudentId = studentId, Points = [6] }; var result = new ExamResult { ExamId = exam.Id, StudentId = studentId, Points = [6] };
@@ -91,7 +97,7 @@ public sealed class CompetencyAnalysisServiceTests
var exam = new Exam var exam = new Exam
{ {
Status = ExamStatus.Conducted, Status = ExamStatus.Conducted,
Tasks = [new ExamTask { MaxPoints = 10, CompetencyCodes = ["K1"] }], Tasks = [new ExamTask { MaxPoints = 10, Competencies = [Ref(K1)] }],
}; };
var result = new ExamResult { ExamId = exam.Id, StudentId = studentId, Points = [5] }; var result = new ExamResult { ExamId = exam.Id, StudentId = studentId, Points = [5] };
@@ -103,30 +109,59 @@ public sealed class CompetencyAnalysisServiceTests
} }
[Fact] [Fact]
public void Analyze_VerwendeterUnbekannterCode_BleibtInUebersichtSichtbar() public void Analyze_GeloeschteKompetenz_BleibtMitGespeicherterMomentaufnahmeSichtbar()
{ {
var unit = new Unit { Status = UnitStatus.Active, Competencies = ["ALT1"] }; // ItemId zeigt auf kein (mehr) existierendes Katalog-Item (z.B. gelöscht) - Code/Description
// stammen aus der zum Zuordnungszeitpunkt gespeicherten Momentaufnahme.
var reference = new CompetencyReference
{
ItemId = Guid.NewGuid(), Code = "ALT1", Description = "Alte, inzwischen gelöschte Kompetenz",
};
var unit = new Unit { Status = UnitStatus.Active, Competencies = [reference] };
var analysis = _service.Analyze(Catalog(), [unit], [], []); var analysis = _service.Analyze(Catalog(), [unit], [], []);
var unknown = Assert.Single(analysis, x => x.Code == "ALT1"); var unknown = Assert.Single(analysis, x => x.Code == "ALT1");
Assert.Equal("Nicht im Katalog", unknown.DomainName); Assert.Equal("Nicht im Katalog", unknown.DomainName);
Assert.Equal("Alte, inzwischen gelöschte Kompetenz", unknown.Description);
Assert.Equal(1, unknown.TaughtUnitCount); Assert.Equal(1, unknown.TaughtUnitCount);
} }
[Fact]
public void Analyze_NieAufgeloesteReferenz_OhneBeschreibung_ZeigtFallbacktext()
{
// ItemId == Guid.Empty simuliert eine nie aufgelöste Referenz (z.B. aus einem
// plattformübergreifenden Import über PlanningExchangeService) ohne gespeicherte Beschreibung.
var reference = new CompetencyReference { ItemId = Guid.Empty, Code = "IMPORT1", Description = "" };
var unit = new Unit { Status = UnitStatus.Active, Competencies = [reference] };
var analysis = _service.Analyze(Catalog(), [unit], [], []);
var unknown = Assert.Single(analysis, x => x.Code == "IMPORT1");
Assert.Contains("nicht (mehr) im aktuellen Katalog", unknown.Description);
}
[Fact]
public void Analyze_UmbenannteKompetenz_ZeigtLiveFassungStattMomentaufnahme()
{
// Referenz trägt eine veraltete Momentaufnahme (Description von vor dem Rename) - solange
// ItemId noch im Katalog auflösbar ist, muss die LIVE-Fassung gewinnen.
var reference = new CompetencyReference { ItemId = K1.Id, Code = "K1", Description = "Veraltete Beschreibung" };
var unit = new Unit { Status = UnitStatus.Active, Competencies = [reference] };
var item = Assert.Single(_service.Analyze(Catalog(), [unit], [], []));
Assert.Equal("Erste Kompetenz", item.Description);
Assert.Equal("Bereich", item.DomainName);
}
private static List<CompetencyDomain> Catalog(bool includeSecond = false) => private static List<CompetencyDomain> Catalog(bool includeSecond = false) =>
[ [
new CompetencyDomain new CompetencyDomain
{ {
Name = "Bereich", Name = "Bereich",
Code = "B", Code = "B",
Items = includeSecond Items = includeSecond ? [K1, K2] : [K1],
?
[
new CompetencyItem { Code = "K1", Description = "Erste Kompetenz", SortOrder = 0 },
new CompetencyItem { Code = "K2", Description = "Zweite Kompetenz", SortOrder = 1 },
]
: [new CompetencyItem { Code = "K1", Description = "Erste Kompetenz" }],
}, },
]; ];
} }
@@ -16,7 +16,7 @@ public sealed class CompetencyCatalogImportServiceTests
var service = new CompetencyCatalogImportService(repository); var service = new CompetencyCatalogImportService(repository);
Assert.Throws<InvalidDataException>(() => Assert.Throws<InvalidDataException>(() =>
service.Analyze("{ kaputt", SubjectId, "Mathematik", 7)); service.Analyze("{ kaputt", SubjectId, "Mathematik", 7, Guid.Empty));
Assert.False(repository.ReplaceWasCalled); Assert.False(repository.ReplaceWasCalled);
Assert.Equal("Alte Beschreibung", repository.Current.Single().Items.Single().Description); Assert.Equal("Alte Beschreibung", repository.Current.Single().Items.Single().Description);
@@ -27,7 +27,7 @@ public sealed class CompetencyCatalogImportServiceTests
{ {
var service = new CompetencyCatalogImportService(RepositoryWithExistingCatalog()); var service = new CompetencyCatalogImportService(RepositoryWithExistingCatalog());
var preview = service.Analyze(JsonWithConflictAndNewItem(), SubjectId, "Mathematik", 7); var preview = service.Analyze(JsonWithConflictAndNewItem(), SubjectId, "Mathematik", 7, Guid.Empty);
Assert.Equal(0, preview.NewDomains); Assert.Equal(0, preview.NewDomains);
Assert.Equal(1, preview.NewCompetencies); Assert.Equal(1, preview.NewCompetencies);
@@ -40,7 +40,7 @@ public sealed class CompetencyCatalogImportServiceTests
{ {
var repository = RepositoryWithExistingCatalog(); var repository = RepositoryWithExistingCatalog();
var service = new CompetencyCatalogImportService(repository); var service = new CompetencyCatalogImportService(repository);
var preview = service.Analyze(JsonWithConflictAndNewItem(), SubjectId, "Mathematik", 7); var preview = service.Analyze(JsonWithConflictAndNewItem(), SubjectId, "Mathematik", 7, Guid.Empty);
service.Apply(preview, CompetencyCatalogImportMode.Merge); service.Apply(preview, CompetencyCatalogImportMode.Merge);
@@ -55,7 +55,7 @@ public sealed class CompetencyCatalogImportServiceTests
{ {
var repository = RepositoryWithExistingCatalog(); var repository = RepositoryWithExistingCatalog();
var service = new CompetencyCatalogImportService(repository); var service = new CompetencyCatalogImportService(repository);
var preview = service.Analyze(JsonWithConflictAndNewItem(), SubjectId, "Mathematik", 7); var preview = service.Analyze(JsonWithConflictAndNewItem(), SubjectId, "Mathematik", 7, Guid.Empty);
service.Apply(preview, CompetencyCatalogImportMode.Merge, new HashSet<string> { "item:A1" }); service.Apply(preview, CompetencyCatalogImportMode.Merge, new HashSet<string> { "item:A1" });
@@ -75,7 +75,7 @@ public sealed class CompetencyCatalogImportServiceTests
] } ] }
] } ] }
"""; """;
var preview = service.Analyze(json, SubjectId, "Mathematik", 7); var preview = service.Analyze(json, SubjectId, "Mathematik", 7, Guid.Empty);
service.Apply(preview, CompetencyCatalogImportMode.Merge); service.Apply(preview, CompetencyCatalogImportMode.Merge);
@@ -89,7 +89,7 @@ public sealed class CompetencyCatalogImportServiceTests
{ {
var repository = RepositoryWithExistingCatalog(); var repository = RepositoryWithExistingCatalog();
var service = new CompetencyCatalogImportService(repository); var service = new CompetencyCatalogImportService(repository);
var preview = service.Analyze(JsonWithConflictAndNewItem(), SubjectId, "Mathematik", 7); var preview = service.Analyze(JsonWithConflictAndNewItem(), SubjectId, "Mathematik", 7, Guid.Empty);
service.Apply(preview, CompetencyCatalogImportMode.Replace); service.Apply(preview, CompetencyCatalogImportMode.Replace);
@@ -103,7 +103,7 @@ public sealed class CompetencyCatalogImportServiceTests
{ {
var repository = RepositoryWithExistingCatalog(); var repository = RepositoryWithExistingCatalog();
var service = new CompetencyCatalogImportService(repository); var service = new CompetencyCatalogImportService(repository);
var preview = service.Analyze(JsonWithConflictAndNewItem(), SubjectId, "Mathematik", 7); var preview = service.Analyze(JsonWithConflictAndNewItem(), SubjectId, "Mathematik", 7, Guid.Empty);
repository.Current[0].UpdatedAt = repository.Current[0].UpdatedAt.AddSeconds(1); repository.Current[0].UpdatedAt = repository.Current[0].UpdatedAt.AddSeconds(1);
var exception = Assert.Throws<InvalidOperationException>(() => var exception = Assert.Throws<InvalidOperationException>(() =>
@@ -121,7 +121,7 @@ public sealed class CompetencyCatalogImportServiceTests
.Replace("Mathematik", "Deutsch") .Replace("Mathematik", "Deutsch")
.Replace("\"gradeLevel\": 7", "\"gradeLevel\": 8"); .Replace("\"gradeLevel\": 7", "\"gradeLevel\": 8");
var preview = service.Analyze(json, SubjectId, "Mathematik", 7); var preview = service.Analyze(json, SubjectId, "Mathematik", 7, Guid.Empty);
Assert.Equal(2, preview.Warnings.Count); Assert.Equal(2, preview.Warnings.Count);
} }
@@ -138,7 +138,7 @@ public sealed class CompetencyCatalogImportServiceTests
"""; """;
Assert.Throws<InvalidDataException>(() => Assert.Throws<InvalidDataException>(() =>
service.Analyze(json, SubjectId, "Mathematik", 7)); service.Analyze(json, SubjectId, "Mathematik", 7, Guid.Empty));
} }
private static InMemoryCompetencyDomainRepository RepositoryWithExistingCatalog() => new( private static InMemoryCompetencyDomainRepository RepositoryWithExistingCatalog() => new(
@@ -179,21 +179,23 @@ public sealed class CompetencyCatalogImportServiceTests
public List<CompetencyDomain> Current { get; private set; } = initial; public List<CompetencyDomain> Current { get; private set; } = initial;
public bool ReplaceWasCalled { get; private set; } public bool ReplaceWasCalled { get; private set; }
public List<CompetencyDomain> GetBySubjectAndGrade(Guid subjectId, int gradeLevel) => public List<CompetencyDomain> GetBySubjectAndGrade(Guid subjectId, int gradeLevel, Guid versionId) =>
Current.Where(x => x.SubjectId == subjectId && x.GradeLevel == gradeLevel).ToList(); Current.Where(x => x.SubjectId == subjectId && x.GradeLevel == gradeLevel && x.VersionId == versionId).ToList();
public List<CompetencyDomain> GetBySubject(Guid subjectId) => public List<CompetencyDomain> GetBySubjectAndVersion(Guid subjectId, Guid versionId) =>
Current.Where(x => x.SubjectId == subjectId).ToList(); Current.Where(x => x.SubjectId == subjectId && x.VersionId == versionId).ToList();
public List<CompetencyDomain> GetAll() => Current.ToList();
public CompetencyDomain? GetById(Guid id) => Current.FirstOrDefault(x => x.Id == id); public CompetencyDomain? GetById(Guid id) => Current.FirstOrDefault(x => x.Id == id);
public void Save(CompetencyDomain domain) => Current.Add(domain); public void Save(CompetencyDomain domain) => Current.Add(domain);
public void Delete(Guid id) => Current.RemoveAll(x => x.Id == id); public void Delete(Guid id) => Current.RemoveAll(x => x.Id == id);
public void DeleteBySubjectAndGrade(Guid subjectId, int gradeLevel) => public void DeleteBySubjectGradeAndVersion(Guid subjectId, int gradeLevel, Guid versionId) =>
Current.RemoveAll(x => x.SubjectId == subjectId && x.GradeLevel == gradeLevel); Current.RemoveAll(x => x.SubjectId == subjectId && x.GradeLevel == gradeLevel && x.VersionId == versionId);
public void ReplaceForSubjectAndGrade(Guid subjectId, int gradeLevel, List<CompetencyDomain> domains) public void ReplaceForSubjectGradeAndVersion(Guid subjectId, int gradeLevel, Guid versionId, List<CompetencyDomain> domains)
{ {
ReplaceWasCalled = true; ReplaceWasCalled = true;
Current.RemoveAll(x => x.SubjectId == subjectId && x.GradeLevel == gradeLevel); Current.RemoveAll(x => x.SubjectId == subjectId && x.GradeLevel == gradeLevel && x.VersionId == versionId);
foreach (var d in domains) { d.SubjectId = subjectId; d.GradeLevel = gradeLevel; d.VersionId = versionId; }
Current.AddRange(domains); Current.AddRange(domains);
} }
} }
+47 -1
View File
@@ -3601,6 +3601,35 @@ Format dokumentiert in [Kompetenzkatalog-KI-Prompt.md](docs/Kompetenzkatalog-KI-
der Kompetenzübersicht (Details siehe 11.4, "Kompetenzbericht"): druckt die Analyse für der Kompetenzübersicht (Details siehe 11.4, "Kompetenzbericht"): druckt die Analyse für
den aktuell im Tab ausgewählten Schüler. den aktuell im Tab ausgewählten Schüler.
### 8.4 Bildungsplan-Versionierung (Nutzer-Nachtrag)
Neue Bildungspläne wachsen je Fach klassenstufenweise hoch — über mehrere Schuljahre hinweg gelten
alter und neuer Plan parallel, je nachdem, wann ein Kurs/eine Klasse eingeschult wurde.
- [x] **8.4.1** `CompetencyCatalogVersion` (Fach + Name + `IsDefault`) eingeführt;
`CompetencyDomain.VersionId` und `LearningGroup.CompetencyCatalogVersionId` (nullable = "nutzt
die Standardversion des Fachs") verknüpfen Katalog bzw. Kurs mit einer Version. Migration legt
für jedes Fach mit bestehendem Katalog automatisch eine Standardversion an, bestehende Kurse
bleiben unverändert nutzbar. Details siehe [Datenmodell.md](docs/Datenmodell.md).
- [x] **8.4.2** Versionen verwalten (anlegen, als Standard setzen, löschen — blockiert bei
Referenzen oder für die Standardversion) im Settings-Tab „Kompetenzen“, dort auch als dritte
Auswahl neben Fach/Klassenstufe zum Filtern des bearbeiteten Katalogs.
`CompetencyCatalogImportService` (JSON-Import/Kopieren zwischen Klassenstufen) ist
versionsscharf: Import/Kopieren wirkt immer nur innerhalb der gerade gewählten Version.
- [x] **8.4.3** Kursanlage/-bearbeitung: Bildungsplan-Version je Kurs auswählbar
(`AddGroupDialogViewModel`/`AddGroupDialog.axaml`), sobald das gewählte Fach mehr als eine
Version hat. Kompetenzen-Tab, Kompetenzauswahl in Unterrichtseinheiten und in Klausuraufgaben
sowie die Kompetenz-Sichtbarkeit im Mitarbeit-Tab zeigen jeweils den Katalog der für den Kurs
geltenden Version (`CompetencyCatalogVersionResolver.Resolve`).
- [x] **8.4.4** MCP: Bildungsplan-Versionen vollständig exponiert (`get_competency_plan_versions`,
`create_competency_plan_version`, `update_competency_plan_version`,
`delete_competency_plan_version`), `get_competency_catalog`/`create_competency_domain` um einen
optionalen `versionId`-Parameter erweitert (weglassen = Standardversion), sowie
`update_group_competency_version` zum Setzen der Version eines Kurses.
Bewusst nicht Teil dieses Nachtrags: TODO 16.5 (Kompetenz-Referenzen in Unit/Lesson/ExamTask von
Freitext-`Code` auf stabile `CompetencyItem.Id` umstellen) — unabhängiges, vorbestehendes Thema.
--- ---
## 9. Dashboard ## 9. Dashboard
@@ -4823,9 +4852,26 @@ von 4.2.2) der Tab "Kürzel-Katalog" für die Von/Nach-Kürzel des Stundenverlau
- [ ] **16.4** Redundant gespeicherte Bewertungswerte (`ExamResult.TotalPoints`, berechnete Note) - [ ] **16.4** Redundant gespeicherte Bewertungswerte (`ExamResult.TotalPoints`, berechnete Note)
entweder ableiten oder zusammen mit einer unveränderlichen Version des verwendeten entweder ableiten oder zusammen mit einer unveränderlichen Version des verwendeten
Notenschlüssels als historischen Snapshot speichern. Notenschlüssels als historischen Snapshot speichern.
- [ ] **16.5** Kompetenzzuordnungen auf stabile `CompetencyItem.Id` umstellen; Code/Beschreibung bei - [x] **16.5** Kompetenzzuordnungen auf stabile `CompetencyItem.Id` umstellen; Code/Beschreibung bei
Bedarf zusätzlich als historischen Snapshot speichern, damit Umbenennungen keine alten Bedarf zusätzlich als historischen Snapshot speichern, damit Umbenennungen keine alten
Klausur- oder Sitzungsreferenzen brechen. Klausur- oder Sitzungsreferenzen brechen.
Neuer Werttyp `CompetencyReference` (`ItemId` + Code/Description-Momentaufnahme, siehe
Datenmodell.md "Bewusst gespeicherte Momentaufnahmen") ersetzt `List<string>` in
`Unit.Competencies`, `Lesson.Competencies`, `ExamTask.Competencies` (umbenannt von
`CompetencyCodes`), `ParticipationSession.Competencies` (umbenannt) und
`CompetencyRating.ItemId` (umbenannt von `.Code`). Solange `ItemId` noch im Katalog auflösbar
ist, zeigt die Analyse/UI die live Fassung (Rename wirkt sofort); ohne Treffer erscheint die
Momentaufnahme in einer eigenen "Nicht mehr im Katalog"-Gruppe, statt zu verschwinden.
Migration (Schema-Version 6, `LiteDbContext.MigrateCompetencyReferences`) löst alte Codes
gegen den bestehenden Katalog auf; unauflösbare Codes bleiben als Text erhalten
(`ItemId = Guid.Empty`), unauflösbare Mitarbeit-Ratings werden verworfen. Die dreifach
duplizierte Tag-Auswahl-UI (Einheit/Klausuraufgabe/Mitarbeit-Sitzung) wurde dabei in
`CompetencyTagGroupBuilder`/`CompetencyTagging.cs` konsolidiert. MCP:
`add_lesson_competency`/`remove_lesson_competency` nehmen jetzt `itemId` statt `code` und
validieren gegen den Katalog (vorher ungeprüft). `PlanningExchangeService` überträgt weiterhin
nur Code-Text (nie IDs, wie im Format ohnehin vorgesehen) und speichert importierte
Kompetenzen bewusst als nicht aufgelöste Referenz statt sie gegen den Katalog der
Zielinstallation zu raten.
- [ ] **16.6** Navigation und manuelle Callback-Verdrahtung in `App.axaml.cs` langfristig durch - [ ] **16.6** Navigation und manuelle Callback-Verdrahtung in `App.axaml.cs` langfristig durch
einen testbaren Navigationsdienst oder Messenger ersetzen; statischen Servicezugriff abbauen. einen testbaren Navigationsdienst oder Messenger ersetzen; statischen Servicezugriff abbauen.
+44
View File
@@ -37,6 +37,38 @@ ein eigenes Feld wie `Student.SchoolEntryDate` zu verwenden.
Pro Kombination aus Schüler und Lerngruppe darf es höchstens eine Zuordnung Pro Kombination aus Schüler und Lerngruppe darf es höchstens eine Zuordnung
geben. geben.
## Bildungsplan-Version (`CompetencyCatalogVersion`)
Bildet ab, dass für ein Fach mehrere Kompetenzkataloge parallel gültig sein können — typischerweise
weil ein neuer Bildungsplan klassenstufenweise hochwächst (z.B. beginnend in Klasse 5, ein Jahrgang
pro Schuljahr) und deshalb über mehrere Schuljahre hinweg sowohl der alte als auch der neue Plan
gleichzeitig unterrichtet werden.
- `SubjectId`: Fach, zu dem die Version gehört
- `Name`: frei gewählte Bezeichnung, z.B. `Bildungsplan 2016` oder `Bildungsplan 2026`
- `IsDefault`: je Fach höchstens eine Version — Kurse ohne explizite Wahl (siehe
`LearningGroup.CompetencyCatalogVersionId`) nutzen sie. `CompetencyCatalogVersionRepository.Save`
nimmt beim Setzen automatisch die bisherige Standardversion desselben Fachs zurück.
`CompetencyDomain.VersionId` verweist auf die Version, zu der ein Kompetenzbereich gehört — derselbe
Katalog-Slot (Fach + Klassenstufe) kann also mehrfach existieren, einmal je Version.
`LearningGroup.CompetencyCatalogVersionId` (`Guid?`) wählt je Kurs/Klasse, welche Version gilt.
Analog zum Verhältnis von `GroupMembership` zu `LearningGroup.SchoolYear` (siehe oben) ist dieses
Feld bewusst nullable mit einer Sonderbedeutung: `null` heißt nicht "keine Version", sondern "die
Standardversion des Fachs" — so brauchen bestehende Kurse und Kompetenzkataloge beim Einführen der
Versionierung keine Migration außer dem einmaligen Anlegen je einer Standardversion pro Fach
(`LiteDbContext.MigrateCompetencyCatalogVersions`, Schema-Version 5).
`CompetencyCatalogVersionRepository.Delete` blockiert (statt in den Papierkorb zu verschieben, siehe
14.2), wenn die Version noch von einem Kompetenzbereich oder einem Kurs referenziert wird, oder wenn
sie die Standardversion ihres Fachs ist — erst eine andere Version des Fachs muss zum Standard
werden, damit nie ein Fach ganz ohne Standardversion dasteht.
Bewusst **nicht** Teil dieser Versionierung: die Verknüpfung von Kompetenzcodes zu Unterrichtseinheiten,
Einzelstunden und Klausuraufgaben (`Unit.Competencies`, `Lesson.Competencies`, `ExamTask.CompetencyCodes`)
bleibt Freitext-Code-basiert, nicht auf `CompetencyItem.Id` umgestellt — ein vorbestehendes, unabhängiges
Thema (siehe TODO 16.5).
## Gewichtungsschema (`GradingScheme`) ## Gewichtungsschema (`GradingScheme`)
Legt die prozentuale Gewichtung von Klausuren, Mitarbeit und sonstigen Leistungen für die Legt die prozentuale Gewichtung von Klausuren, Mitarbeit und sonstigen Leistungen für die
@@ -66,6 +98,18 @@ Einige berechnete Werte bleiben absichtlich gespeichert:
- `Exam.GradingKey` hält den für die konkrete Klausur verwendeten Notenschlüssel - `Exam.GradingKey` hält den für die konkrete Klausur verwendeten Notenschlüssel
fest und ist unabhängig von später geänderten Vorlagen. fest und ist unabhängig von später geänderten Vorlagen.
- `Exam.Tasks` hält die Aufgabenstruktur der konkreten Klausur fest. - `Exam.Tasks` hält die Aufgabenstruktur der konkreten Klausur fest.
- `CompetencyReference` (`Unit.Competencies`, `Lesson.Competencies`, `ExamTask.Competencies`,
`ParticipationSession.Competencies`) verweist über `ItemId` auf ein `CompetencyItem`, hält aber
zusätzlich `Code`/`Description` zum Zuordnungszeitpunkt fest (TODO 16.5, abgelöst von einer reinen
Freitext-Code-Zuordnung). Solange `ItemId` noch im Katalog auflösbar ist, zeigt die Anwendung die
**live** Fassung (ein Rename im Katalog wirkt sich überall sofort aus); wird das Item gelöscht,
bleibt die hier gespeicherte historische Fassung lesbar statt spurlos zu verschwinden.
`ItemId == Guid.Empty` markiert eine nie aufgelöste Referenz (z.B. aus einem
plattformübergreifenden `PlanningExchangeService`-Import, der bewusst keine installationsfremden
IDs überträgt) — Code/Description sind dann die einzige Information.
`CompetencyRating.ItemId` (Mitarbeit, je Schüler) referenziert ebenso per Id, aber ohne eigenen
Snapshot — die Identität kommt aus der Zuordnungsliste der zugehörigen `ParticipationSession`,
die bereits eine Momentaufnahme trägt.
Änderungen an Aufgaben oder Notenschlüssel müssen die betroffenen Ergebnisse Änderungen an Aufgaben oder Notenschlüssel müssen die betroffenen Ergebnisse
kontrolliert neu berechnen. Diese Werte sind daher fachliche Momentaufnahmen und kontrolliert neu berechnen. Diese Werte sind daher fachliche Momentaufnahmen und