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:
1 parent
4ffba35eff
commit
f97edff2fe
45 files changed
+1020
-163
No files matched your search
@@ -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());
|
||||
}
|
||||
@@ -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}}"/>
|
||||
|
||||
Reference in new issue
Block a user