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>
This commit is contained in:
adminandClaude Sonnet 5 committed 2026-09-19 00:41:54 +02:00
1 parent f97edff2fe
commit dc2f58c4dc
28 files changed
+691 -202

No files matched your search

@@ -32,31 +32,54 @@ public sealed class CompetencyAnalysisService
IReadOnlyList<ExamResult> results)
{
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 item in domain.Items.OrderBy(x => x.SortOrder))
{
var builder = new ItemBuilder(domain.Name, domain.Code, item.Code, item.Description);
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();
if (byCode.TryGetValue(code, out var existing)) return existing;
var added = new ItemBuilder("Nicht im Katalog", "", code,
"Dieser Kompetenzcode wird noch verwendet, ist aber nicht im aktuellen Katalog enthalten.");
byCode[code] = added;
var description = string.IsNullOrWhiteSpace(reference.Description)
? "Diese Kompetenz wird noch verwendet, ist aber nicht (mehr) im aktuellen Katalog enthalten."
: reference.Description;
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);
return added;
}
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++;
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());
foreach (var exam in exams)
{
var examCodes = NormalizeCodes(exam.Tasks.SelectMany(x => x.CompetencyCodes));
foreach (var code in examCodes)
var examReferences = NormalizeReferences(exam.Tasks.SelectMany(x => x.Competencies));
foreach (var reference in examReferences)
{
var builder = GetOrAdd(code);
var builder = GetOrAdd(reference);
if (exam.Status == ExamStatus.Planned) builder.PlannedExams++;
else builder.AssessedExams++;
}
@@ -81,17 +104,16 @@ public sealed class CompetencyAnalysisService
var task = exam.Tasks[taskIndex];
if (task.MaxPoints <= 0) continue;
var achieved = Math.Clamp(result.Points[taskIndex], 0, task.MaxPoints);
foreach (var code in NormalizeCodes(task.CompetencyCodes))
GetOrAdd(code).AddScore(result.StudentId, achieved, task.MaxPoints);
foreach (var reference in NormalizeReferences(task.Competencies))
GetOrAdd(reference).AddScore(result.StudentId, achieved, task.MaxPoints);
}
}
return builders.Select(x => x.Build()).ToList();
}
private static bool HasCode(string? value) => !string.IsNullOrWhiteSpace(value);
private static IEnumerable<string> NormalizeCodes(IEnumerable<string> codes) =>
codes.Where(HasCode).Select(x => x.Trim()).Distinct(StringComparer.OrdinalIgnoreCase);
private static IEnumerable<CompetencyReference> NormalizeReferences(IEnumerable<CompetencyReference> references) =>
references.DistinctBy(x => x.ItemId);
private sealed class ItemBuilder(
string domainName, string domainCode, string code, string description)