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>
This commit is contained in:
adminandClaude Sonnet 5 committed 2026-09-19 00:07:29 +02:00
1 parent 4ffba35eff
commit f97edff2fe
45 files changed
+1020 -163

No files matched your search

+1
View File
@@ -176,6 +176,7 @@ public static class AppBootstrapper
services.AddSingleton<IParticipationSectionRepository, ParticipationSectionRepository>();
services.AddSingleton<ISubjectRepository, SubjectRepository>();
services.AddSingleton<ICompetencyDomainRepository, CompetencyDomainRepository>();
services.AddSingleton<ICompetencyCatalogVersionRepository, CompetencyCatalogVersionRepository>();
services.AddSingleton<IShorthandCodeRepository, ShorthandCodeRepository>();
services.AddSingleton<IAlternativeLessonPathRepository, AlternativeLessonPathRepository>();
services.AddSingleton<IAttachmentStorage, LiteAttachmentStorage>();
@@ -1,6 +1,7 @@
using LehrerApp.Core.AiPlanning;
using LehrerApp.Core.Interfaces;
using LehrerApp.Core.Models;
using LehrerApp.Core.Services;
using System.Globalization;
using System.Net;
using System.Net.Http.Json;
@@ -72,7 +73,8 @@ public class GermanTimeOnlyJsonConverter : JsonConverter<TimeOnly>
/// </summary>
public class AiPlanningService(HttpClient http, ILessonRepository lessons,
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
// 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
? []
: competencyDomains.GetBySubjectAndGrade(subject.Id, gradeLevel)
: competencyDomains.GetBySubjectAndGrade(subject.Id, gradeLevel,
CompetencyCatalogVersionResolver.Resolve(competencyVersions, subject.Id, group?.CompetencyCatalogVersionId))
.Select(d => new AiCompetencyDomain
{
Name = d.Name,
@@ -177,8 +177,10 @@ public sealed class McpServerHostedService : IAsyncDisposable
"Erzeugt einen Elternbrief aus einer Vorlage für einen Schüler als Base64-PDF.");
AddReadTool(competencyTools.GetSubjects, "get_subjects",
"Listet alle Fächer.");
AddReadTool(competencyTools.GetCompetencyPlanVersions, "get_competency_plan_versions",
"Listet die Bildungsplan-Versionen eines Fachs.");
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",
"Listet die Fälligkeit der Untis-Hub-Abgleiche, ohne selbst WebUntis anzufragen.");
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).");
AddWriteTool(competencyTools.RemoveCompetencyItem, "remove_competency_item",
"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",
"Ü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).");
AddDestructiveWriteTool(competencyTools.DeleteCompetencyDomain, "delete_competency_domain",
"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(
toolCollection.Select(t => t.ProtocolTool.Name).OrderBy(n => n)
@@ -29,6 +29,7 @@ public static class McpToolScope
"list_letter_templates",
"render_letter",
"get_subjects",
"get_competency_plan_versions",
"get_competency_catalog",
"get_untis_hub_status",
"get_untis_absence_rows",
@@ -63,6 +64,9 @@ public static class McpToolScope
"add_competency_item",
"update_competency_item",
"remove_competency_item",
"create_competency_plan_version",
"update_competency_plan_version",
"update_group_competency_version",
"apply_untis_absence_status",
];
@@ -77,5 +81,6 @@ public static class McpToolScope
"delete_lesson",
"delete_subject",
"delete_competency_domain",
"delete_competency_plan_version",
];
}
@@ -5,18 +5,21 @@ using LehrerApp.Core.Models;
namespace LehrerApp.Desktop.Services.Mcp.Tools;
/// <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
/// anlegen/ändern/löschen. Die Zuordnung von Kompetenzcodes zu einzelnen Stunden lebt bewusst in
/// <see cref="LessonPlanTools"/> (AddLessonCompetency/RemoveLessonCompetency), nicht hier - sie
/// gehört fachlich zur Stundenverwaltung, nicht zum Katalog selbst.
/// <summary>MCP-Tools für die Fach- und Kompetenzkatalog-Verwaltung (Nutzer-Nachtrag zu 4.5.28ff.,
/// später um Bildungsplan-Versionierung erweitert): <see cref="Subject"/>,
/// <see cref="CompetencyCatalogVersion"/> und <see cref="CompetencyDomain"/>/<see cref="CompetencyItem"/>
/// vollständig anlegen/ändern/löschen. Die Zuordnung von Kompetenzcodes zu einzelnen Stunden lebt
/// 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)
/// endgültige Löschungen ohne Papierkorb (die Repository-Implementierungen löschen direkt in der
/// LiteDB-Collection statt über MoveToTrash) - deshalb als Destructive registriert (siehe
/// McpServerHostedService) und mit entsprechend deutlicher Bestätigungsnachricht.</summary>
/// "delete_subject", "delete_competency_domain" und "delete_competency_plan_version" sind wie
/// "delete_lesson" (LessonPlanTools) endgültige Löschungen ohne Papierkorb (die
/// Repository-Implementierungen löschen direkt in der LiteDB-Collection statt über MoveToTrash) -
/// deshalb als Destructive registriert (siehe McpServerHostedService) und mit entsprechend
/// deutlicher Bestätigungsnachricht.</summary>
public class CompetencyTools(
ISubjectRepository subjects, ICompetencyDomainRepository domains, IMcpConfirmationService confirmation)
ISubjectRepository subjects, ICompetencyDomainRepository domains,
ICompetencyCatalogVersionRepository versions, IMcpConfirmationService confirmation)
{
// ── Lesen ────────────────────────────────────────────────────────────────────────────────
@@ -24,17 +27,93 @@ public class CompetencyTools(
public List<SubjectDto> GetSubjects() =>
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(
[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
? domains.GetBySubjectAndGrade(subjectId, gradeLevel.Value)
: domains.GetBySubject(subjectId);
? domains.GetBySubjectAndGrade(subjectId, gradeLevel.Value, effectiveVersionId)
: domains.GetBySubjectAndVersion(subjectId, effectiveVersionId);
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) ─────────────────────────────────────────────────────────────────────
[Description("Legt ein neues Fach an. Muss der Nutzer erst bestätigen.")]
@@ -109,26 +188,30 @@ public class CompetencyTools(
// ── 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(
[Description("Fach-ID, aus get_subjects.")] Guid subjectId,
[Description("Klassenstufe.")] int gradeLevel,
[Description("Name des Bereichs.")] string name,
[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)
{
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, "Bereichsname darf nicht leer sein.");
var sortOrder = domains.GetBySubjectAndGrade(subjectId, gradeLevel).Count;
var message = $"Neuen Kompetenzbereich „{name.Trim()}“ für {subject.Name}, Klasse {gradeLevel}, anlegen?";
var effectiveVersionId = versionId ?? versions.GetOrCreateDefault(subjectId).Id;
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))
return new WriteResultDto(false, null, "Vom Nutzer abgelehnt oder nicht bestätigt.");
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);
return new WriteResultDto(true, domain.Id, "Kompetenzbereich gespeichert.");
@@ -246,7 +329,7 @@ public class CompetencyTools(
}
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)
.Select(i => new CompetencyItemDto(i.Id, i.Code, i.Description, i.SortOrder)).ToList());
}
+5 -2
View File
@@ -56,9 +56,12 @@ public record SubjectDto(Guid Id, string Name, string ShortName);
public record CompetencyItemDto(Guid Id, string Code, string Description, int SortOrder);
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);
/// <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(
Guid Id, Guid StudentId, Guid GroupId, MembershipPeriod Period,
DateOnly? JoinedAt, DateOnly? LeftAt, Niveau? Niveau);
@@ -91,7 +94,7 @@ public record UntisHubStatusRowDto(
/// Fach-Datensatz mitzuschleppen.</summary>
public record GroupDto(
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):
/// bewusst KEIN Schülername/keine Klasse - <see cref="RowId"/> ist die einzige Kennung, über die
@@ -1,14 +1,18 @@
using System.ComponentModel;
using System.Text;
using LehrerApp.Core.Interfaces;
namespace LehrerApp.Desktop.Services.Mcp.Tools;
/// <summary>MCP-Read-Tool "get_groups" (Nutzer-Nachtrag: die GroupId, die praktisch jedes andere
/// Tool als Pflichtparameter verlangt - get_grades, get_schedule, get_lesson_plans,
/// get_untis_absence_rows usw. - war nirgends über MCP auflösbar; ein KI-Client kannte bestenfalls
/// den Klarnamen einer Lerngruppe aus dem Gespräch, nie ihre Id). Reiner Lesezugriff auf das
/// bestehende Repository, keine eigene Datenzugriffslogik.</summary>
public class GroupTools(IGroupRepository groups)
/// <summary>MCP-Tools für Lerngruppen (Klassen/Kurse). "get_groups" (Nutzer-Nachtrag: die GroupId,
/// die praktisch jedes andere Tool als Pflichtparameter verlangt - get_grades, get_schedule,
/// get_lesson_plans, get_untis_absence_rows usw. - war nirgends über MCP auflösbar; ein KI-Client
/// kannte bestenfalls den Klarnamen einer Lerngruppe aus dem Gespräch, nie ihre Id) ist reiner
/// Lesezugriff. "update_group_competency_version" ist das erste Schreib-Tool auf einem
/// 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.")]
public List<GroupDto> GetGroups(
@@ -18,6 +22,32 @@ public class GroupTools(IGroupRepository groups)
var list = schoolYear is null
? groups.GetAll(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.");
}
}
@@ -13,6 +13,7 @@ public partial class CompetencyOverviewTabViewModel : ObservableObject
private readonly IExamRepository _exams;
private readonly IExamResultRepository _results;
private readonly ICompetencyDomainRepository _catalog;
private readonly ICompetencyCatalogVersionRepository _versions;
private readonly IStudentRepository _students;
private readonly CompetencyAnalysisService _analysis;
private LearningGroup? _group;
@@ -23,6 +24,7 @@ public partial class CompetencyOverviewTabViewModel : ObservableObject
[ObservableProperty] private string _emptyMessage = "";
public string GroupLabel => _group?.Name ?? "";
public string VersionLabel { get; private set; } = "";
public ObservableCollection<CompetencyStudentOption> StudentOptions { get; } = [];
public ObservableCollection<CompetencyOverviewRow> Rows { get; } = [];
@@ -32,12 +34,14 @@ public partial class CompetencyOverviewTabViewModel : ObservableObject
public CompetencyOverviewTabViewModel(IUnitRepository units, IExamRepository exams,
IExamResultRepository results, ICompetencyDomainRepository catalog,
ICompetencyCatalogVersionRepository versions,
IStudentRepository students, CompetencyAnalysisService analysis)
{
_units = units;
_exams = exams;
_results = results;
_catalog = catalog;
_versions = versions;
_students = students;
_analysis = analysis;
}
@@ -53,9 +57,18 @@ public partial class CompetencyOverviewTabViewModel : ObservableObject
{
if (_group is null) return;
var selectedStudentId = SelectedStudent?.Id;
var domains = _group.SubjectId is Guid subjectId
? _catalog.GetBySubjectAndGrade(subjectId, _group.GradeLevel)
: [];
List<CompetencyDomain> domains;
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 exams = _exams.GetByGroup(_group.Id);
var results = exams.SelectMany(x => _results.GetByExam(x.Id)).ToList();
@@ -81,6 +94,7 @@ public partial class CompetencyOverviewTabViewModel : ObservableObject
: "";
OnPropertyChanged(nameof(HasRows));
OnPropertyChanged(nameof(HasStudents));
OnPropertyChanged(nameof(VersionLabel));
}
partial void OnSelectedStudentChanged(CompetencyStudentOption? value)
@@ -19,6 +19,7 @@ public partial class ExamDialogViewModel : ObservableObject
private readonly Guid _groupId;
private readonly Guid? _subjectId;
private readonly int _gradeLevel;
private readonly Guid _competencyCatalogVersionId;
private readonly GradingSystem _gradingSystem;
private readonly Exam? _editingExam;
private readonly Exam? _duplicateSource;
@@ -63,11 +64,13 @@ public partial class ExamDialogViewModel : ObservableObject
public ExamDialogViewModel(IExamRepository exams, ICompetencyDomainRepository competencyDomains,
IGradingKeyTemplateRepository gradingKeyTemplates, GradingService grading,
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;
_gradingKeyTemplates = gradingKeyTemplates; _grading = grading;
_groupId = groupId; _subjectId = subjectId; _gradeLevel = gradeLevel;
_competencyCatalogVersionId = competencyCatalogVersionId;
_gradingSystem = gradingSystem;
_editingExam = editingExam;
_duplicateSource = duplicateSource;
@@ -75,7 +78,7 @@ public partial class ExamDialogViewModel : ObservableObject
IsDifferentiated = isDifferentiated;
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))
AvailableTemplates.Add(t);
@@ -164,7 +167,7 @@ public partial class ExamDialogViewModel : ObservableObject
var groups = new List<CompetencyTagGroup>();
if (!_subjectId.HasValue) return groups;
var selected = selectedCodes.ToHashSet();
foreach (var domain in _competencyDomains.GetBySubjectAndGrade(_subjectId.Value, _gradeLevel))
foreach (var domain in _competencyDomains.GetBySubjectAndGrade(_subjectId.Value, _gradeLevel, _competencyCatalogVersionId))
{
var group = new CompetencyTagGroup(domain.Name, domain.Code);
foreach (var item in domain.Items.OrderBy(i => i.SortOrder))
@@ -799,8 +799,10 @@ public partial class AddGroupDialogViewModel : ObservableObject
{
private readonly IGroupRepository _groups;
private readonly ISubjectRepository _subjects;
private readonly ICompetencyCatalogVersionRepository _competencyVersions;
private List<Subject> _allSubjects = [];
private LearningGroup? _editingGroup;
private Guid? _pendingCompetencyVersionId;
public List<string> TypeOptions { get; } = ["Klasse", "Kurs"];
[ObservableProperty] private string _selectedTypeName = "Kurs";
@@ -829,18 +831,21 @@ public partial class AddGroupDialogViewModel : ObservableObject
[ObservableProperty] private bool _excludedFromUntisHub;
[ObservableProperty] private string _nameError = "";
[ObservableProperty] private string _gradeLevelError = "";
[ObservableProperty] private CompetencyVersionListItem? _selectedCompetencyVersion;
public List<string> SchoolYears { get; }
public List<string> GradingOptions { get; } = ["Noten 1–6", "Punkte 0–15"];
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 string DialogTitle => _editingGroup is null ? "Neue Lerngruppe anlegen" : "Lerngruppe bearbeiten";
public string SaveButtonText => _editingGroup is null ? "Anlegen" : "Speichern";
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();
KnownSubjectNames = _allSubjects.Select(s => s.Name).ToList();
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)
{
_editingGroup = group;
SelectedTypeName = group.Type == GroupType.Class ? "Klasse" : "Kurs";
Name = group.Name;
_pendingCompetencyVersionId = group.CompetencyCatalogVersionId;
Subject = group.SubjectId is Guid subjectId ? _subjects.GetById(subjectId)?.Name ?? "" : "";
GradeLevel = group.GradeLevel;
SelectedGradingName = group.GradingSystem == GradingSystem.Grades1To6
@@ -905,6 +939,7 @@ public partial class AddGroupDialogViewModel : ObservableObject
Result = _editingGroup ?? new LearningGroup();
Result.Name = Name.Trim();
Result.SubjectId = subjectId;
Result.CompetencyCatalogVersionId = subjectId is null ? null : SelectedCompetencyVersion?.Id;
Result.Type = IsKurs ? GroupType.Course : GroupType.Class;
Result.GradeLevel = GradeLevel;
Result.GradingSystem = SelectedGradingName == "Punkte 0–15"
@@ -919,3 +954,13 @@ public partial class AddGroupDialogViewModel : ObservableObject
_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 IGroupRepository _groups;
private readonly ICompetencyDomainRepository _competencyDomains;
private readonly ICompetencyCatalogVersionRepository _competencyVersions;
private Guid _groupId;
private string _schoolYear = "";
private Guid? _subjectId;
private int _gradeLevel;
private Guid _competencyCatalogVersionId;
private GradingSystem _gradingSystem;
public Guid GroupId => _groupId;
@@ -63,12 +65,14 @@ public partial class ParticipationTabViewModel : ObservableObject
IStudentRepository students,
IGroupMembershipRepository memberships,
IGroupRepository groups,
ICompetencyDomainRepository competencyDomains)
ICompetencyDomainRepository competencyDomains,
ICompetencyCatalogVersionRepository competencyVersions)
{
_sessions = sessions; _entries = entries;
_aspects = aspects; _students = students;
_memberships = memberships; _groups = groups;
_competencyDomains = competencyDomains;
_competencyVersions = competencyVersions;
}
public void Initialize(Guid groupId, string schoolYear, bool isReadOnly = false)
@@ -80,11 +84,13 @@ public partial class ParticipationTabViewModel : ObservableObject
var group = _groups.GetById(groupId);
_subjectId = group?.SubjectId;
_gradeLevel = group?.GradeLevel ?? 0;
_competencyCatalogVersionId = CompetencyCatalogVersionResolver.Resolve(
_competencyVersions, _subjectId, group?.CompetencyCatalogVersionId);
_gradingSystem = group?.GradingSystem ?? GradingSystem.Grades1To6;
GroupLabel = group?.Name ?? "";
HasCompetencyCatalog = _subjectId.HasValue
&& _competencyDomains.GetBySubjectAndGrade(_subjectId.Value, _gradeLevel).Count > 0;
&& _competencyDomains.GetBySubjectAndGrade(_subjectId.Value, _gradeLevel, _competencyCatalogVersionId).Count > 0;
LoadAspects();
LoadSessions();
@@ -236,7 +242,7 @@ public partial class ParticipationTabViewModel : ObservableObject
if (!_subjectId.HasValue) return;
var active = ActiveCompetencyCodes.ToHashSet();
foreach (var domain in _competencyDomains.GetBySubjectAndGrade(_subjectId.Value, _gradeLevel))
foreach (var domain in _competencyDomains.GetBySubjectAndGrade(_subjectId.Value, _gradeLevel, _competencyCatalogVersionId))
{
var group = new CompetencyTagGroup(domain.Name, domain.Code);
foreach (var item in domain.Items.OrderBy(i => i.SortOrder))
@@ -34,6 +34,7 @@ public partial class PlanningTabViewModel : ObservableObject
private readonly IGroupRepository _groups;
private readonly ISubjectRepository _subjects;
private readonly ICompetencyDomainRepository _competencyDomains;
private readonly ICompetencyCatalogVersionRepository _competencyVersions;
private readonly AiSettingsService _aiSettings;
private readonly IParticipationSessionRepository _participationSessions;
@@ -44,6 +45,9 @@ public partial class PlanningTabViewModel : ObservableObject
public int GradeLevel { get; private set; }
public string SubjectName { 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 LessonSummary? _selectedLesson;
@@ -85,11 +89,12 @@ public partial class PlanningTabViewModel : ObservableObject
public PlanningTabViewModel(IUnitRepository units, ILessonRepository lessons,
IGroupRepository groups, ISubjectRepository subjects,
ICompetencyDomainRepository competencyDomains, AiSettingsService aiSettings,
IParticipationSessionRepository participationSessions)
ICompetencyDomainRepository competencyDomains, ICompetencyCatalogVersionRepository competencyVersions,
AiSettingsService aiSettings, IParticipationSessionRepository participationSessions)
{
_units = units; _lessons = lessons; _groups = groups;
_subjects = subjects; _competencyDomains = competencyDomains;
_competencyVersions = competencyVersions;
_aiSettings = aiSettings; _participationSessions = participationSessions;
}
@@ -102,6 +107,8 @@ public partial class PlanningTabViewModel : ObservableObject
GradeLevel = group?.GradeLevel ?? 0;
SubjectName = SubjectId is Guid sid ? _subjects.GetById(sid)?.Name ?? "" : "";
GroupLabel = group?.Name ?? "";
CompetencyCatalogVersionId = CompetencyCatalogVersionResolver.Resolve(
_competencyVersions, SubjectId, group?.CompetencyCatalogVersionId);
LoadUnits(preferActive: true);
}
@@ -577,6 +584,7 @@ public partial class UnitDialogViewModel : ObservableObject
private readonly Guid _groupId;
private readonly Guid? _subjectId;
private readonly int _gradeLevel;
private readonly Guid _competencyCatalogVersionId;
private readonly Unit? _editingUnit;
private readonly List<string> _competencyCodes;
@@ -620,10 +628,12 @@ public partial class UnitDialogViewModel : ObservableObject
}
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;
_groupId = groupId; _subjectId = subjectId; _gradeLevel = gradeLevel;
_competencyCatalogVersionId = competencyCatalogVersionId;
_editingUnit = editingUnit;
GroupSubjectDisplay = string.IsNullOrWhiteSpace(subjectName)
? $"{groupName} · kein Fach hinterlegt (siehe Lerngruppe)" : $"{groupName} · {subjectName}";
@@ -646,7 +656,7 @@ public partial class UnitDialogViewModel : ObservableObject
CompetencyTagGroups.Clear();
if (!_subjectId.HasValue) return;
var selected = _competencyCodes.ToHashSet();
foreach (var domain in _competencyDomains.GetBySubjectAndGrade(_subjectId.Value, _gradeLevel))
foreach (var domain in _competencyDomains.GetBySubjectAndGrade(_subjectId.Value, _gradeLevel, _competencyCatalogVersionId))
{
var group = new CompetencyTagGroup(domain.Name, domain.Code);
foreach (var item in domain.Items.OrderBy(i => i.SortOrder))
@@ -22,39 +22,97 @@ public partial class SettingsViewModel
[ObservableProperty] private SubjectListItem? _catalogSubject;
[ObservableProperty] private int _catalogGradeLevel = 10;
[ObservableProperty] private CompetencyCatalogVersion? _catalogVersion;
[ObservableProperty] private string _newDomainName = "";
[ObservableProperty] private string _newDomainCode = "";
[ObservableProperty] private string _catalogValidation = "";
[ObservableProperty] private string _newVersionName = "";
[ObservableProperty] private string _versionValidation = "";
public ObservableCollection<DomainEditItem> Domains { get; } = [];
public ObservableCollection<CompetencyCatalogVersion> CatalogVersions { get; } = [];
// ── Katalog: Laden ────────────────────────────────────────────────────────
partial void OnCatalogSubjectChanged(SubjectListItem? value) => LoadCatalog();
partial void OnCatalogSubjectChanged(SubjectListItem? value) => LoadVersions();
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()
{
Domains.Clear();
CatalogValidation = "";
if (CatalogSubject is null) return;
foreach (var d in _domainRepo.GetBySubjectAndGrade(CatalogSubject.Id, CatalogGradeLevel))
if (CatalogSubject is null || CatalogVersion is null) return;
foreach (var d in _domainRepo.GetBySubjectAndGrade(CatalogSubject.Id, CatalogGradeLevel, CatalogVersion.Id))
Domains.Add(CreateDomainEditItem(d));
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 ────────────────────────────────
[RelayCommand]
private void AddDomain()
{
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; }
var domain = new CompetencyDomain
{
SubjectId = CatalogSubject.Id,
GradeLevel = CatalogGradeLevel,
VersionId = CatalogVersion.Id,
Name = NewDomainName.Trim(),
Code = NewDomainCode.Trim(),
SortOrder = Domains.Count,
@@ -27,11 +27,16 @@ public partial class SettingsViewModel
CatalogValidation = "Bitte zuerst ein Fach auswählen.";
return null;
}
if (CatalogVersion is null)
{
CatalogValidation = "Bitte zuerst eine Version auswählen.";
return null;
}
try
{
CatalogValidation = "";
return _catalogImport.Analyze(
json, CatalogSubject.Id, CatalogSubject.Name, CatalogGradeLevel);
json, CatalogSubject.Id, CatalogSubject.Name, CatalogGradeLevel, CatalogVersion.Id);
}
catch (InvalidDataException ex)
{
@@ -71,9 +76,15 @@ public partial class SettingsViewModel
return null;
}
if (CatalogVersion is null)
{
CatalogValidation = "Bitte zuerst eine Version auswählen.";
return null;
}
CatalogValidation = "";
return _catalogImport.Analyze(SerializeCatalog(targetGradeLevel), CatalogSubject.Id,
CatalogSubject.Name, targetGradeLevel);
CatalogSubject.Name, targetGradeLevel, CatalogVersion.Id);
}
public void SetCatalogCopyStatus(int targetGradeLevel) =>
@@ -49,6 +49,7 @@ public partial class SettingsViewModel : ObservableObject
{
private readonly ISubjectRepository _subjects;
private readonly ICompetencyDomainRepository _domainRepo;
private readonly ICompetencyCatalogVersionRepository _versionRepo;
private readonly IGradingKeyTemplateRepository _gradingKeyTemplates;
private readonly IGradingSchemeRepository _gradingSchemes;
private readonly GradingService _grading;
@@ -95,6 +96,7 @@ public partial class SettingsViewModel : ObservableObject
public TrashViewModel TrashTab { get; }
public SettingsViewModel(ISubjectRepository subjects, ICompetencyDomainRepository domainRepo,
ICompetencyCatalogVersionRepository versionRepo,
IGradingKeyTemplateRepository gradingKeyTemplates, IGradingSchemeRepository gradingSchemes,
GradingService grading, BackupService backups, BackupSettingsService backupSettings,
DatabaseEncryptionService dbEncryption,
@@ -123,6 +125,7 @@ public partial class SettingsViewModel : ObservableObject
TrashTab = trashTab;
_subjects = subjects;
_domainRepo = domainRepo;
_versionRepo = versionRepo;
_gradingKeyTemplates = gradingKeyTemplates;
_gradingSchemes = gradingSchemes;
_grading = grading;
@@ -39,6 +39,21 @@
HorizontalAlignment="Stretch"/>
</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,*">
<StackPanel Grid.Column="0" Spacing="4">
<TextBlock Text="Klassenstufe *" FontSize="12" Opacity="0.7"/>
@@ -8,6 +8,8 @@
<Grid ColumnDefinitions="*,Auto">
<StackPanel Grid.Column="0" Spacing="3">
<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"/>
</StackPanel>
<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;
var competencyCatalogVersionId = CompetencyCatalogVersionResolver.Resolve(
App.Services.GetRequiredService<ICompetencyCatalogVersionRepository>(),
vm.Group.SubjectId, vm.Group.CompetencyCatalogVersionId);
var dialogVm = new ExamDialogViewModel(
App.Services.GetRequiredService<IExamRepository>(),
App.Services.GetRequiredService<ICompetencyDomainRepository>(),
App.Services.GetRequiredService<IGradingKeyTemplateRepository>(),
App.Services.GetRequiredService<GradingService>(),
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 owner = TopLevel.GetTopLevel(this) as Window;
@@ -54,7 +54,8 @@ public partial class PlanningTabView : UserControl
var dialogVm = new UnitDialogViewModel(
App.Services.GetRequiredService<IUnitRepository>(),
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 owner = TopLevel.GetTopLevel(this) as Window;
@@ -2,6 +2,7 @@
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:vm="clr-namespace:LehrerApp.Desktop.ViewModels.Settings"
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"
x:Class="LehrerApp.Desktop.Views.Settings.SettingsView"
x:DataType="vm:SettingsViewModel">
@@ -112,8 +113,8 @@
<ScrollViewer>
<StackPanel Margin="32,20,32,28" Spacing="14" MaxWidth="640">
<!-- Fach + Klassenstufe Auswahl + Import/Export -->
<Grid ColumnDefinitions="*,12,100,12,Auto,8,Auto,8,Auto">
<!-- Fach + Klassenstufe + Bildungsplan-Version Auswahl + Import/Export -->
<Grid ColumnDefinitions="*,12,90,12,160,12,Auto,8,Auto,8,Auto">
<ComboBox Grid.Column="0"
ItemsSource="{Binding Subjects}"
SelectedItem="{Binding CatalogSubject}"
@@ -128,15 +129,63 @@
<NumericUpDown Grid.Column="2"
Value="{Binding CatalogGradeLevel}"
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}}"/>
<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}}"/>
<Button Grid.Column="8" Content="Kopieren…" Click="OnCopyCatalogClick"
<Button Grid.Column="10" Content="Kopieren…" Click="OnCopyCatalogClick"
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>
<!-- 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 -->
<TextBlock Text="{Binding CatalogValidation}" Foreground="Red" FontSize="12"
IsVisible="{Binding CatalogValidation, Converter={x:Static StringConverters.IsNotNullOrEmpty}}"/>