feat: add planning JSON exchange

LehrerApp.Desktop.Tests/PlanningExchangeServiceTests.cs

@@ -0,0 +1,130 @@
+using LehrerApp.Core.Models;
+using LehrerApp.Desktop.Services;
+using System.Text.Json;
+using Xunit;
+
+namespace LehrerApp.Desktop.Tests;
+
+public sealed class PlanningExchangeServiceTests
+{
+    [Fact]
+    public void UnitRoundtrip_ErzeugtNeueObjekteUndErhaeltPlanungsdaten()
+    {
+        var units = new FakeUnits();
+        var lessons = new FakeLessons();
+        var shortPath = new AlternativeLessonPath { Name = "Kurzversion" };
+        var paths = new FakeAlternativeLessonPaths([shortPath]);
+        var service = new PlanningExchangeService(units, lessons, paths);
+        var sourceGroupId = Guid.NewGuid();
+        var targetGroupId = Guid.NewGuid();
+        var unit = new Unit
+        {
+            GroupId = sourceGroupId,
+            Title = "Optik",
+            StartDate = new DateOnly(2026, 9, 1),
+            EndDate = new DateOnly(2026, 10, 1),
+            Competencies = ["UF1", "E4"],
+            Status = UnitStatus.Active,
+            Notes = "Experimente",
+        };
+        units.Add(unit);
+        var sourceLesson = new Lesson
+        {
+            UnitId = unit.Id,
+            GroupId = sourceGroupId,
+            Date = new DateOnly(2026, 9, 8),
+            LessonNumber = 3,
+            Topic = "Reflexion",
+            StartTime = new TimeOnly(9, 50),
+            Status = LessonStatus.Planned,
+            Homework = "Aufgabe 2",
+            Phases =
+            [
+                new LessonPhaseStep
+                {
+                    Name = "Experiment", DurationMinutes = 25, Activity = "Winkel messen",
+                    Material = "Optikbox", Shorthand = "PA", AlternativePathId = shortPath.Id,
+                },
+            ],
+        };
+        lessons.Add(sourceLesson);
+
+        var json = service.ExportUnit(unit, new PlanningExchangeContext
+        {
+            Group = "8a", Subject = "Physik", GradeLevel = 8,
+        });
+        var result = service.ImportUnit(json, targetGroupId);
+
+        Assert.DoesNotContain(unit.Id.ToString(), json, StringComparison.OrdinalIgnoreCase);
+        Assert.DoesNotContain(sourceLesson.Id.ToString(), json, StringComparison.OrdinalIgnoreCase);
+        Assert.NotEqual(unit.Id, result.Unit.Id);
+        Assert.Equal(targetGroupId, result.Unit.GroupId);
+        Assert.Equal("Optik", result.Unit.Title);
+        Assert.Equal(UnitStatus.Active, result.Unit.Status);
+        Assert.Equal(["UF1", "E4"], result.Unit.Competencies);
+        var importedLesson = Assert.Single(result.Lessons);
+        Assert.NotEqual(sourceLesson.Id, importedLesson.Id);
+        Assert.Equal(result.Unit.Id, importedLesson.UnitId);
+        Assert.Equal(targetGroupId, importedLesson.GroupId);
+        Assert.Equal(new TimeOnly(9, 50), importedLesson.StartTime);
+        Assert.Equal(shortPath.Id, Assert.Single(importedLesson.Phases).AlternativePathId);
+    }
+
+    [Fact]
+    public void LessonImport_AkzeptiertMarkdownCodeblockUndLegtNeueStundeAn()
+    {
+        var units = new FakeUnits();
+        var lessons = new FakeLessons();
+        var service = new PlanningExchangeService(units, lessons, new FakeAlternativeLessonPaths([]));
+        var source = new Lesson
+        {
+            UnitId = Guid.NewGuid(), GroupId = Guid.NewGuid(), Date = new DateOnly(2026, 9, 8),
+            Topic = "Reflexion", Phases = [new LessonPhaseStep { Name = "Einstieg", DurationMinutes = 10 }],
+        };
+        lessons.Add(source);
+        var json = service.ExportLesson(source, new PlanningExchangeContext());
+        var targetUnitId = Guid.NewGuid();
+        var targetGroupId = Guid.NewGuid();
+
+        var imported = service.ImportLesson($"```json\n{json}\n```", targetUnitId, targetGroupId);
+
+        Assert.NotEqual(source.Id, imported.Id);
+        Assert.Equal(targetUnitId, imported.UnitId);
+        Assert.Equal(targetGroupId, imported.GroupId);
+        Assert.Equal("Reflexion", imported.Topic);
+        Assert.Equal(10, Assert.Single(imported.Phases).DurationMinutes);
+    }
+
+    [Fact]
+    public void ImportMitFalschemSchema_SchreibtKeineDaten()
+    {
+        var units = new FakeUnits();
+        var lessons = new FakeLessons();
+        var service = new PlanningExchangeService(units, lessons, new FakeAlternativeLessonPaths([]));
+        const string json = """
+            { "schema": "anderes.format", "version": 1, "unit": { "title": "Optik" } }
+            """;
+        var groupId = Guid.NewGuid();
+
+        var error = Assert.Throws<PlanningExchangeException>(() => service.ImportUnit(json, groupId));
+
+        Assert.Contains("Falsches Format", error.Message);
+        Assert.Empty(units.GetByGroup(groupId));
+        Assert.Empty(lessons.GetByGroupAndRange(groupId, DateOnly.MinValue, DateOnly.MaxValue));
+    }
+
+    [Fact]
+    public void ExportVerwendetDokumentiertesSchemaUndCamelCase()
+    {
+        var service = new PlanningExchangeService(new FakeUnits(), new FakeLessons(),
+            new FakeAlternativeLessonPaths([]));
+        var lesson = new Lesson { Date = new DateOnly(2026, 9, 8), Topic = "Optik" };
+
+        using var json = JsonDocument.Parse(service.ExportLesson(lesson, new PlanningExchangeContext()));
+
+        Assert.Equal(PlanningExchangeService.LessonSchema, json.RootElement.GetProperty("schema").GetString());
+        Assert.Equal(1, json.RootElement.GetProperty("version").GetInt32());
+        Assert.Equal("2026-09-08", json.RootElement.GetProperty("lesson").GetProperty("date").GetString());
+        Assert.Equal("planned", json.RootElement.GetProperty("lesson").GetProperty("status").GetString());
+    }
+}

LehrerApp.Desktop/AppBootstrapper.cs

@@ -156,6 +156,7 @@ public static class AppBootstrapper
         services.AddSingleton(_ => new WorkloadSettingsService(appData));
         services.AddSingleton(_ => new DashboardSettingsService(appData));
         services.AddSingleton(_ => new LetterTemplateService(appData));
+        services.AddSingleton<PlanningExchangeService>();
 
         // ── KI-Unterstützung (4.5.9, optional – nur wenn in den Einstellungen aktiviert) ──────
         services.AddSingleton(_ => new AiSettingsService(appData));

LehrerApp.Desktop/Assets/PlanningFormats/Einheitenplanung-Format.md

@@ -0,0 +1,107 @@
+# LehrerApp-Austauschformat: Unterrichtseinheit
+
+Dieses Dokument beschreibt Version 1 des JSON-Formats `lehrerapp.unit-planning`.
+Es dient zum Austausch einer vollständigen Unterrichtseinheit einschließlich ihrer Stunden.
+
+## Grundregeln
+
+- Die Datei enthält reines UTF-8-JSON. Beim Import wird auch ein einzelner Markdown-Codeblock akzeptiert.
+- Datumswerte verwenden `JJJJ-MM-TT`, Uhrzeiten `HH:MM` oder `HH:MM:SS`.
+- Statuswerte sind `planned`, `active`, `completed` für Einheiten und `planned`, `conducted` für Stunden.
+- Interne IDs werden nicht übertragen. Der Import legt eine neue Einheit und neue Stunden in der aktuell geöffneten Lerngruppe an.
+- `context` hilft bei der Bearbeitung mit einer KI, wird beim Import aber nicht zur Zuordnung verwendet.
+- Unbekannte zusätzliche Felder werden ignoriert.
+
+## Beispiel
+
+```json
+{
+  "schema": "lehrerapp.unit-planning",
+  "version": 1,
+  "context": {
+    "group": "8a",
+    "subject": "Physik",
+    "gradeLevel": 8,
+    "unitTitle": null
+  },
+  "unit": {
+    "title": "Optik: Reflexion und Brechung",
+    "startDate": "2026-09-01",
+    "endDate": "2026-10-06",
+    "competencies": ["UF1", "E4"],
+    "status": "planned",
+    "notes": "Experimente in Kleingruppen",
+    "lessons": [
+      {
+        "date": "2026-09-01",
+        "lessonNumber": 3,
+        "topic": "Lichtausbreitung",
+        "startTime": "09:50:00",
+        "status": "planned",
+        "homework": "Aufgabe 2 beenden",
+        "reflection": null,
+        "phases": [
+          {
+            "name": "Einstieg",
+            "durationMinutes": 10,
+            "activity": "Impulsbild beschreiben und Vermutungen sammeln",
+            "material": "Beamer",
+            "shorthand": "Plenum",
+            "alternativePath": null
+          },
+          {
+            "name": "Erarbeitung",
+            "durationMinutes": 25,
+            "activity": "Versuch zur geradlinigen Lichtausbreitung",
+            "material": "Experimentierbox",
+            "shorthand": "GA",
+            "alternativePath": "Kurzversion"
+          }
+        ]
+      }
+    ]
+  }
+}
+```
+
+## Felder
+
+### Dokument
+
+- `schema` (Pflicht): exakt `lehrerapp.unit-planning`
+- `version` (Pflicht): aktuell `1`
+- `context` (optional): `group`, `subject`, `gradeLevel` und optional `unitTitle`
+- `unit` (Pflicht): die zu importierende Einheit
+
+### Einheit
+
+- `title` (Pflicht, Text)
+- `startDate`, `endDate` (optional, Datum oder `null`); das Ende darf nicht vor dem Start liegen
+- `competencies` (Liste von Kompetenzcodes oder Freitexten)
+- `status` (optional, Standard `planned`)
+- `notes` (optional, Text oder `null`)
+- `lessons` (Liste, darf leer sein); Aufbau siehe Stundenformat unten
+
+### Stunde
+
+- `date` (Pflicht, Datum)
+- `lessonNumber` (optional, Ganzzahl 1–20 oder `null`)
+- `topic` (Pflicht, Text)
+- `startTime` (optional, Uhrzeit oder `null`)
+- `status` (optional: `planned` oder `conducted`, Standard `planned`)
+- `homework`, `reflection` (optional, Text oder `null`)
+- `phases` (Liste, darf leer sein)
+
+### Phase
+
+- `name`, `activity`, `material`, `shorthand` (Text; leere Werte sind erlaubt)
+- `durationMinutes` (Ganzzahl 0–180)
+- `alternativePath` (optional): lesbarer Name eines alternativen Verlaufs, z. B. `Kurzversion`. Beim Import wird ein vorhandener gleichnamiger Ablauf verwendet oder neu angelegt.
+
+## Hinweise für KI-Bearbeitung
+
+- JSON-Struktur, `schema` und `version` unverändert lassen.
+- Nur gültige ISO-Daten verwenden.
+- Phasendauern so wählen, dass ihre Summe zur verfügbaren Unterrichtszeit passt.
+- Keine IDs ergänzen; Beziehungen werden beim Import automatisch hergestellt.
+

LehrerApp.Desktop/Assets/PlanningFormats/Stundenplanung-Format.md

@@ -0,0 +1,90 @@
+# LehrerApp-Austauschformat: einzelne Stundenplanung
+
+Dieses Dokument beschreibt Version 1 des JSON-Formats `lehrerapp.lesson-planning`.
+Es dient zum Austausch genau einer Stunde mit ihrem Verlaufsplan.
+
+## Grundregeln
+
+- Die Datei enthält reines UTF-8-JSON. Beim Import wird auch ein einzelner Markdown-Codeblock akzeptiert.
+- Datum: `JJJJ-MM-TT`; Uhrzeit: `HH:MM` oder `HH:MM:SS`.
+- Interne IDs werden nicht übertragen. Der Import legt eine neue Stunde in der aktuell ausgewählten Einheit an.
+- `context` ist nur Bearbeitungshilfe und entscheidet nicht über das Importziel.
+- Unbekannte zusätzliche Felder werden ignoriert.
+
+## Beispiel
+
+```json
+{
+  "schema": "lehrerapp.lesson-planning",
+  "version": 1,
+  "context": {
+    "group": "8a",
+    "subject": "Physik",
+    "gradeLevel": 8,
+    "unitTitle": "Optik"
+  },
+  "lesson": {
+    "date": "2026-09-08",
+    "lessonNumber": 3,
+    "topic": "Reflexionsgesetz",
+    "startTime": "09:50:00",
+    "status": "planned",
+    "homework": "Versuchsprotokoll fertigstellen",
+    "reflection": null,
+    "phases": [
+      {
+        "name": "Einstieg",
+        "durationMinutes": 8,
+        "activity": "Alltagsbeispiele für Reflexion sammeln",
+        "material": "Spiegel",
+        "shorthand": "UG",
+        "alternativePath": null
+      },
+      {
+        "name": "Experiment",
+        "durationMinutes": 27,
+        "activity": "Einfalls- und Ausfallswinkel messen",
+        "material": "Optikbox, AB 03",
+        "shorthand": "PA",
+        "alternativePath": null
+      }
+    ]
+  }
+}
+```
+
+## Felder
+
+### Dokument
+
+- `schema` (Pflicht): exakt `lehrerapp.lesson-planning`
+- `version` (Pflicht): aktuell `1`
+- `context` (optional): `group`, `subject`, `gradeLevel`, `unitTitle`
+- `lesson` (Pflicht): die neue Stundenplanung
+
+### Stunde
+
+- `date` (Pflicht, Datum)
+- `lessonNumber` (optional, Ganzzahl 1–20 oder `null`)
+- `topic` (Pflicht, Text)
+- `startTime` (optional, Uhrzeit oder `null`)
+- `status` (optional: `planned` oder `conducted`, Standard `planned`)
+- `homework`, `reflection` (optional, Text oder `null`)
+- `phases` (Liste, darf leer sein)
+
+### Phase
+
+- `name`: Bezeichnung, z. B. `Einstieg` oder `Sicherung`
+- `durationMinutes`: Ganzzahl 0–180
+- `activity`: Lehrer-/Schüler-Tätigkeit
+- `material`: benötigte Medien und Materialien
+- `shorthand`: Kurzsymbol oder Sozialform
+- `alternativePath` (optional): Name eines alternativen Verlaufs. Ein vorhandener gleichnamiger Ablauf wird wiederverwendet, andernfalls neu angelegt.
+
+## Hinweise für KI-Bearbeitung
+
+- JSON-Struktur, `schema` und `version` unverändert lassen.
+- Keine IDs ergänzen.
+- Das Datum muss gesetzt sein; die Stundennummer darf fehlen.
+- Die Summe der `durationMinutes` sollte zur verfügbaren Unterrichtszeit passen.
+

LehrerApp.Desktop/Services/PlanningExchangeService.cs

@@ -0,0 +1,278 @@
+using LehrerApp.Core.Interfaces;
+using LehrerApp.Core.Models;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace LehrerApp.Desktop.Services;
+
+/// <summary>
+/// Portables, menschen- und KI-lesbares Austauschformat für Unterrichtseinheiten und
+/// Einzelstunden. Interne Datenbank-IDs werden nie übertragen; jeder Import legt neue Objekte an.
+/// </summary>
+public sealed class PlanningExchangeService(IUnitRepository units, ILessonRepository lessons,
+    IAlternativeLessonPathRepository alternativePaths)
+{
+    public const string UnitSchema = "lehrerapp.unit-planning";
+    public const string LessonSchema = "lehrerapp.lesson-planning";
+    public const int CurrentVersion = 1;
+
+    private static readonly JsonSerializerOptions JsonOptions = new()
+    {
+        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+        PropertyNameCaseInsensitive = true,
+        WriteIndented = true,
+        AllowTrailingCommas = true,
+        ReadCommentHandling = JsonCommentHandling.Skip,
+        Converters = { new JsonStringEnumConverter(JsonNamingPolicy.CamelCase) },
+    };
+
+    public string ExportUnit(Unit unit, PlanningExchangeContext context)
+    {
+        var document = new UnitPlanningDocument
+        {
+            Schema = UnitSchema,
+            Version = CurrentVersion,
+            Context = context,
+            Unit = ToPayload(unit, lessons.GetByUnit(unit.Id)),
+        };
+        return JsonSerializer.Serialize(document, JsonOptions);
+    }
+
+    public string ExportLesson(Lesson lesson, PlanningExchangeContext context)
+    {
+        var document = new LessonPlanningDocument
+        {
+            Schema = LessonSchema,
+            Version = CurrentVersion,
+            Context = context,
+            Lesson = ToPayload(lesson),
+        };
+        return JsonSerializer.Serialize(document, JsonOptions);
+    }
+
+    public UnitImportResult ImportUnit(string json, Guid targetGroupId)
+    {
+        var document = Deserialize<UnitPlanningDocument>(json, UnitSchema);
+        ValidateUnit(document.Unit);
+        foreach (var lesson in document.Unit.Lessons) ValidateLesson(lesson);
+
+        var unit = new Unit
+        {
+            GroupId = targetGroupId,
+            Title = document.Unit.Title.Trim(),
+            StartDate = document.Unit.StartDate,
+            EndDate = document.Unit.EndDate,
+            Competencies = document.Unit.Competencies
+                .Where(c => !string.IsNullOrWhiteSpace(c)).Select(c => c.Trim())
+                .Distinct(StringComparer.OrdinalIgnoreCase).ToList(),
+            Status = document.Unit.Status,
+            Notes = Clean(document.Unit.Notes),
+        };
+        units.Save(unit);
+
+        var importedLessons = new List<Lesson>();
+        foreach (var payload in document.Unit.Lessons)
+        {
+            var lesson = ToModel(payload, unit.Id, targetGroupId);
+            lessons.Save(lesson);
+            importedLessons.Add(lesson);
+        }
+        return new UnitImportResult(unit, importedLessons);
+    }
+
+    public Lesson ImportLesson(string json, Guid targetUnitId, Guid targetGroupId)
+    {
+        var document = Deserialize<LessonPlanningDocument>(json, LessonSchema);
+        ValidateLesson(document.Lesson);
+        var lesson = ToModel(document.Lesson, targetUnitId, targetGroupId);
+        lessons.Save(lesson);
+        return lesson;
+    }
+
+    private UnitPlanningPayload ToPayload(Unit unit, List<Lesson> unitLessons) => new()
+    {
+        Title = unit.Title,
+        StartDate = unit.StartDate,
+        EndDate = unit.EndDate,
+        Competencies = [.. unit.Competencies],
+        Status = unit.Status,
+        Notes = unit.Notes,
+        Lessons = [.. unitLessons.Select(ToPayload)],
+    };
+
+    private LessonPlanningPayload ToPayload(Lesson lesson) => new()
+    {
+        Date = lesson.Date,
+        LessonNumber = lesson.LessonNumber,
+        Topic = lesson.Topic,
+        StartTime = lesson.StartTime,
+        Status = lesson.Status,
+        Homework = lesson.Homework,
+        Reflection = lesson.Reflection,
+        Phases = [.. lesson.Phases.Select(p => new LessonPhasePayload
+        {
+            Name = p.Name,
+            DurationMinutes = p.DurationMinutes,
+            Activity = p.Activity,
+            Material = p.Material,
+            Shorthand = p.Shorthand,
+            AlternativePath = p.AlternativePathId is Guid id ? alternativePaths.GetById(id)?.Name : null,
+        })],
+    };
+
+    private Lesson ToModel(LessonPlanningPayload payload, Guid unitId, Guid groupId) => new()
+    {
+        UnitId = unitId,
+        GroupId = groupId,
+        Date = payload.Date!.Value,
+        LessonNumber = payload.LessonNumber,
+        Topic = payload.Topic.Trim(),
+        StartTime = payload.StartTime,
+        Status = payload.Status,
+        Homework = Clean(payload.Homework),
+        Reflection = Clean(payload.Reflection),
+        Phases = [.. payload.Phases.Select(p => new LessonPhaseStep
+        {
+            Name = p.Name?.Trim() ?? "",
+            DurationMinutes = p.DurationMinutes,
+            Activity = p.Activity?.Trim() ?? "",
+            Material = p.Material?.Trim() ?? "",
+            Shorthand = p.Shorthand?.Trim() ?? "",
+            AlternativePathId = ResolveAlternativePath(p.AlternativePath),
+        })],
+    };
+
+    private Guid? ResolveAlternativePath(string? name)
+    {
+        name = Clean(name);
+        if (name is null) return null;
+        var existing = alternativePaths.GetAll().FirstOrDefault(p =>
+            string.Equals(p.Name, name, StringComparison.OrdinalIgnoreCase));
+        if (existing is not null) return existing.Id;
+        var created = new AlternativeLessonPath { Name = name };
+        alternativePaths.Save(created);
+        return created.Id;
+    }
+
+    private static T Deserialize<T>(string json, string expectedSchema) where T : PlanningDocument
+    {
+        try
+        {
+            var document = JsonSerializer.Deserialize<T>(RemoveMarkdownFence(json), JsonOptions)
+                ?? throw new PlanningExchangeException("Die JSON-Datei ist leer.");
+            if (!string.Equals(document.Schema, expectedSchema, StringComparison.Ordinal))
+                throw new PlanningExchangeException($"Falsches Format: Erwartet wird „{expectedSchema}“.");
+            if (document.Version != CurrentVersion)
+                throw new PlanningExchangeException($"Die Formatversion {document.Version} wird nicht unterstützt.");
+            return document;
+        }
+        catch (JsonException ex)
+        {
+            throw new PlanningExchangeException($"Die JSON-Datei ist ungültig: {ex.Message}", ex);
+        }
+    }
+
+    private static string RemoveMarkdownFence(string json)
+    {
+        var value = json.Trim();
+        if (!value.StartsWith("```", StringComparison.Ordinal)) return value;
+        var firstLineEnd = value.IndexOf('\n');
+        if (firstLineEnd < 0) return value;
+        value = value[(firstLineEnd + 1)..];
+        var closingFence = value.LastIndexOf("```", StringComparison.Ordinal);
+        return closingFence >= 0 ? value[..closingFence].Trim() : value.Trim();
+    }
+
+    private static void ValidateUnit(UnitPlanningPayload? unit)
+    {
+        if (unit is null) throw new PlanningExchangeException("Das Feld „unit“ fehlt.");
+        if (string.IsNullOrWhiteSpace(unit.Title))
+            throw new PlanningExchangeException("Die Einheit benötigt einen Titel.");
+        if (unit.StartDate is not null && unit.EndDate is not null && unit.EndDate < unit.StartDate)
+            throw new PlanningExchangeException("Das Enddatum der Einheit liegt vor dem Startdatum.");
+        unit.Competencies ??= [];
+        unit.Lessons ??= [];
+    }
+
+    private static void ValidateLesson(LessonPlanningPayload? lesson)
+    {
+        if (lesson is null) throw new PlanningExchangeException("Das Feld „lesson“ fehlt.");
+        if (lesson.Date is null) throw new PlanningExchangeException("Die Stunde benötigt ein Datum im Format JJJJ-MM-TT.");
+        if (string.IsNullOrWhiteSpace(lesson.Topic))
+            throw new PlanningExchangeException("Die Stunde benötigt ein Thema.");
+        if (lesson.LessonNumber is < 1 or > 20)
+            throw new PlanningExchangeException("Die Stundennummer muss zwischen 1 und 20 liegen.");
+        lesson.Phases ??= [];
+        if (lesson.Phases.Any(p => p.DurationMinutes is < 0 or > 180))
+            throw new PlanningExchangeException("Die Dauer jeder Phase muss zwischen 0 und 180 Minuten liegen.");
+    }
+
+    private static string? Clean(string? value) =>
+        string.IsNullOrWhiteSpace(value) ? null : value.Trim();
+}
+
+public abstract class PlanningDocument
+{
+    public string Schema { get; set; } = "";
+    public int Version { get; set; }
+    public PlanningExchangeContext? Context { get; set; }
+}
+
+public sealed class UnitPlanningDocument : PlanningDocument
+{
+    public UnitPlanningPayload Unit { get; set; } = new();
+}
+
+public sealed class LessonPlanningDocument : PlanningDocument
+{
+    public LessonPlanningPayload Lesson { get; set; } = new();
+}
+
+public sealed class PlanningExchangeContext
+{
+    public string Group { get; set; } = "";
+    public string Subject { get; set; } = "";
+    public int GradeLevel { get; set; }
+    public string? UnitTitle { get; set; }
+}
+
+public sealed class UnitPlanningPayload
+{
+    public string Title { get; set; } = "";
+    public DateOnly? StartDate { get; set; }
+    public DateOnly? EndDate { get; set; }
+    public List<string> Competencies { get; set; } = [];
+    public UnitStatus Status { get; set; } = UnitStatus.Planned;
+    public string? Notes { get; set; }
+    public List<LessonPlanningPayload> Lessons { get; set; } = [];
+}
+
+public sealed class LessonPlanningPayload
+{
+    public DateOnly? Date { get; set; }
+    public int? LessonNumber { get; set; }
+    public string Topic { get; set; } = "";
+    public TimeOnly? StartTime { get; set; }
+    public LessonStatus Status { get; set; } = LessonStatus.Planned;
+    public string? Homework { get; set; }
+    public string? Reflection { get; set; }
+    public List<LessonPhasePayload> Phases { get; set; } = [];
+}
+
+public sealed class LessonPhasePayload
+{
+    public string Name { get; set; } = "";
+    public int DurationMinutes { get; set; }
+    public string Activity { get; set; } = "";
+    public string Material { get; set; } = "";
+    public string Shorthand { get; set; } = "";
+    public string? AlternativePath { get; set; }
+}
+
+public sealed record UnitImportResult(Unit Unit, List<Lesson> Lessons);
+
+public sealed class PlanningExchangeException : Exception
+{
+    public PlanningExchangeException(string message) : base(message) { }
+    public PlanningExchangeException(string message, Exception innerException) : base(message, innerException) { }
+}

LehrerApp.Desktop/ViewModels/Groups/PlanningViewModels.cs

@@ -49,6 +49,10 @@ public partial class PlanningTabViewModel : ObservableObject
     // Gruppenwechsel/Laden kurzzeitig null — ein verschachtelter Pfad würde dafür jedes Mal
     // einen Binding-Fehler loggen (siehe GroupDetailViewModel.IsDifferentiated für dasselbe Muster).
     public string SelectedUnitTitleSuffix => SelectedUnit is null ? "" : $" – {SelectedUnit.Title}";
+    public bool HasUnitSelection => SelectedUnit is not null;
+    public bool HasLessonSelection => SelectedLesson is not null;
+    public bool CanImportUnitPlanning => !IsReadOnly;
+    public bool CanImportLessonPlanning => !IsReadOnly && SelectedUnit is not null;
 
     public ObservableCollection<UnitSummary> Units { get; } = [];
     public ObservableCollection<LessonSummary> Lessons { get; } = [];
@@ -123,6 +127,8 @@ public partial class PlanningTabViewModel : ObservableObject
     {
         LoadLessons();
         OnPropertyChanged(nameof(SelectedUnitTitleSuffix));
+        OnPropertyChanged(nameof(HasUnitSelection));
+        OnPropertyChanged(nameof(CanImportLessonPlanning));
         EditUnitCommand.NotifyCanExecuteChanged();
         DeleteUnitCommand.NotifyCanExecuteChanged();
         CopyUnitCommand.NotifyCanExecuteChanged();
@@ -143,6 +149,7 @@ public partial class PlanningTabViewModel : ObservableObject
 
     partial void OnSelectedLessonChanged(LessonSummary? value)
     {
+        OnPropertyChanged(nameof(HasLessonSelection));
         ShowLessonCommand.NotifyCanExecuteChanged();
         EditLessonCommand.NotifyCanExecuteChanged();
         DeleteLessonCommand.NotifyCanExecuteChanged();
@@ -150,6 +157,23 @@ public partial class PlanningTabViewModel : ObservableObject
         AdvanceLessonStatusCommand.NotifyCanExecuteChanged();
     }
 
+    partial void OnIsReadOnlyChanged(bool value)
+    {
+        OnPropertyChanged(nameof(CanImportUnitPlanning));
+        OnPropertyChanged(nameof(CanImportLessonPlanning));
+    }
+
+    public void RefreshPlanning(Guid? selectUnitId = null, Guid? selectLessonId = null)
+    {
+        selectUnitId ??= SelectedUnit?.Id;
+        selectLessonId ??= SelectedLesson?.Id;
+        LoadUnits();
+        if (selectUnitId is Guid unitId)
+            SelectedUnit = Units.FirstOrDefault(u => u.Id == unitId) ?? SelectedUnit;
+        if (selectLessonId is Guid lessonId)
+            SelectedLesson = Lessons.FirstOrDefault(l => l.Id == lessonId);
+    }
+
     private bool HasSelectedUnit()   => SelectedUnit   is not null;
     private bool HasSelectedLesson() => SelectedLesson is not null;
     private bool CanAiAssist() => SelectedUnit is not null && _aiSettings.Enabled;

LehrerApp.Desktop/Views/Groups/PlanningTabView.axaml

@@ -8,8 +8,28 @@
 
     <!-- Einheiten-Toolbar -->
     <Grid Grid.Row="0" ColumnDefinitions="*,Auto" Margin="0,0,0,8">
-      <TextBlock Grid.Column="0" Text="Unterrichtseinheiten" FontSize="14" FontWeight="SemiBold"
+      <StackPanel Grid.Column="0" Orientation="Horizontal" Spacing="8" VerticalAlignment="Center">
-                 VerticalAlignment="Center"/>
+        <TextBlock Text="Unterrichtseinheiten" FontSize="14" FontWeight="SemiBold"
+                   VerticalAlignment="Center"/>
+        <Button Content="↕ JSON" FontSize="11" Padding="7,3"
+                ToolTip.Tip="Einheiten und Stunden importieren, exportieren oder die Formatbeschreibung kopieren">
+          <Button.Flyout>
+            <MenuFlyout Placement="BottomEdgeAlignedLeft">
+              <MenuItem Header="Einheit mit Stunden exportieren…" Click="OnExportUnit"
+                        IsEnabled="{Binding HasUnitSelection}"/>
+              <MenuItem Header="Neue Einheit importieren…" Click="OnImportUnit"
+                        IsEnabled="{Binding CanImportUnitPlanning}"/>
+              <MenuItem Header="Formatbeschreibung Einheit kopieren" Click="OnCopyUnitFormat"/>
+              <Separator/>
+              <MenuItem Header="Ausgewählte Stunde exportieren…" Click="OnExportLesson"
+                        IsEnabled="{Binding HasLessonSelection}"/>
+              <MenuItem Header="Neue Stunde importieren…" Click="OnImportLesson"
+                        IsEnabled="{Binding CanImportLessonPlanning}"/>
+              <MenuItem Header="Formatbeschreibung Stunde kopieren" Click="OnCopyLessonFormat"/>
+            </MenuFlyout>
+          </Button.Flyout>
+        </Button>
+      </StackPanel>
       <StackPanel Grid.Column="1" Orientation="Horizontal" Spacing="8">
         <Button Content="＋ Einheit"          Command="{Binding AddUnitCommand}" IsEnabled="{Binding !IsReadOnly}"/>
         <Button Content="Bearbeiten"          Command="{Binding EditUnitCommand}" IsEnabled="{Binding !IsReadOnly}"/>

LehrerApp.Desktop/Views/Groups/PlanningTabView.axaml.cs

@@ -1,4 +1,8 @@
 using Avalonia.Controls;
+using Avalonia.Input.Platform;
+using Avalonia.Interactivity;
+using Avalonia.Platform;
+using Avalonia.Platform.Storage;
 using LehrerApp.Core.Interfaces;
 using LehrerApp.Core.Models;
 using LehrerApp.Core.Services;
@@ -11,6 +15,12 @@ namespace LehrerApp.Desktop.Views.Groups;
 
 public partial class PlanningTabView : UserControl
 {
+    private static readonly FilePickerFileType JsonFileType = new("JSON-Dateien")
+    {
+        Patterns = ["*.json"],
+        MimeTypes = ["application/json"],
+    };
+
     public PlanningTabView() => InitializeComponent();
 
     protected override void OnDataContextChanged(EventArgs e)
@@ -167,4 +177,139 @@ public partial class PlanningTabView : UserControl
         await dialog.ShowDialog<bool>(owner);
         return dialogVm.Result;
     }
+
+    private async void OnExportUnit(object? sender, RoutedEventArgs e) => await RunExchange(async () =>
+    {
+        if (DataContext is not PlanningTabViewModel { SelectedUnit: { } selected } vm) return;
+        var topLevel = TopLevel.GetTopLevel(this);
+        if (topLevel is null) return;
+        var file = await topLevel.StorageProvider.SaveFilePickerAsync(new FilePickerSaveOptions
+        {
+            Title = "Unterrichtseinheit exportieren",
+            SuggestedFileName = $"Einheit_{SafeFileName(selected.Title)}.json",
+            FileTypeChoices = [JsonFileType],
+        });
+        if (file is null) return;
+        var json = Exchange.ExportUnit(selected.Model, CreateExchangeContext(vm, selected.Title));
+        await WriteTextAsync(file, json);
+        Notifications.ShowSuccess("Unterrichtseinheit als JSON exportiert.");
+    });
+
+    private async void OnImportUnit(object? sender, RoutedEventArgs e) => await RunExchange(async () =>
+    {
+        if (DataContext is not PlanningTabViewModel { CanImportUnitPlanning: true } vm) return;
+        var file = await PickJsonFile("Neue Unterrichtseinheit importieren");
+        if (file is null) return;
+        var result = Exchange.ImportUnit(await ReadTextAsync(file), vm.GroupId);
+        vm.RefreshPlanning(result.Unit.Id, result.Lessons.FirstOrDefault()?.Id);
+        Notifications.ShowSuccess($"Einheit „{result.Unit.Title}“ mit {result.Lessons.Count} Stunde(n) importiert.");
+    });
+
+    private async void OnExportLesson(object? sender, RoutedEventArgs e) => await RunExchange(async () =>
+    {
+        if (DataContext is not PlanningTabViewModel { SelectedLesson: { } lesson } vm) return;
+        var topLevel = TopLevel.GetTopLevel(this);
+        if (topLevel is null) return;
+        var file = await topLevel.StorageProvider.SaveFilePickerAsync(new FilePickerSaveOptions
+        {
+            Title = "Stundenplanung exportieren",
+            SuggestedFileName = $"Stunde_{lesson.Model.Date:yyyy-MM-dd}_{SafeFileName(lesson.Topic)}.json",
+            FileTypeChoices = [JsonFileType],
+        });
+        if (file is null) return;
+        var json = Exchange.ExportLesson(lesson.Model,
+            CreateExchangeContext(vm, vm.SelectedUnit?.Title));
+        await WriteTextAsync(file, json);
+        Notifications.ShowSuccess("Stundenplanung als JSON exportiert.");
+    });
+
+    private async void OnImportLesson(object? sender, RoutedEventArgs e) => await RunExchange(async () =>
+    {
+        if (DataContext is not PlanningTabViewModel
+            { CanImportLessonPlanning: true, SelectedUnit: { } unit } vm) return;
+        var file = await PickJsonFile("Neue Stundenplanung importieren");
+        if (file is null) return;
+        var lesson = Exchange.ImportLesson(await ReadTextAsync(file), unit.Id, vm.GroupId);
+        vm.RefreshPlanning(unit.Id, lesson.Id);
+        Notifications.ShowSuccess($"Stunde „{lesson.Topic}“ importiert.");
+    });
+
+    private async void OnCopyUnitFormat(object? sender, RoutedEventArgs e) =>
+        await CopyFormatDescription("Einheitenplanung-Format.md", "Formatbeschreibung für Einheiten kopiert.");
+
+    private async void OnCopyLessonFormat(object? sender, RoutedEventArgs e) =>
+        await CopyFormatDescription("Stundenplanung-Format.md", "Formatbeschreibung für Stunden kopiert.");
+
+    private async Task CopyFormatDescription(string fileName, string successMessage) => await RunExchange(async () =>
+    {
+        var clipboard = TopLevel.GetTopLevel(this)?.Clipboard;
+        if (clipboard is null) throw new InvalidOperationException("Die Zwischenablage ist nicht verfügbar.");
+        var uri = new Uri($"avares://LehrerApp.Desktop/Assets/PlanningFormats/{fileName}");
+        await using var stream = AssetLoader.Open(uri);
+        using var reader = new StreamReader(stream);
+        await clipboard.SetTextAsync(await reader.ReadToEndAsync());
+        Notifications.ShowSuccess(successMessage);
+    });
+
+    private async Task<IStorageFile?> PickJsonFile(string title)
+    {
+        var topLevel = TopLevel.GetTopLevel(this);
+        if (topLevel is null) return null;
+        var files = await topLevel.StorageProvider.OpenFilePickerAsync(new FilePickerOpenOptions
+        {
+            Title = title,
+            AllowMultiple = false,
+            FileTypeFilter = [JsonFileType],
+        });
+        return files.FirstOrDefault();
+    }
+
+    private static async Task<string> ReadTextAsync(IStorageFile file)
+    {
+        await using var stream = await file.OpenReadAsync();
+        using var reader = new StreamReader(stream);
+        return await reader.ReadToEndAsync();
+    }
+
+    private static async Task WriteTextAsync(IStorageFile file, string content)
+    {
+        await using var stream = await file.OpenWriteAsync();
+        stream.SetLength(0);
+        await using var writer = new StreamWriter(stream);
+        await writer.WriteAsync(content);
+    }
+
+    private static PlanningExchangeContext CreateExchangeContext(PlanningTabViewModel vm, string? unitTitle) => new()
+    {
+        Group = vm.GroupLabel,
+        Subject = vm.SubjectName,
+        GradeLevel = vm.GradeLevel,
+        UnitTitle = unitTitle,
+    };
+
+    private static string SafeFileName(string value)
+    {
+        var invalid = Path.GetInvalidFileNameChars().ToHashSet();
+        var safe = new string(value.Select(c => invalid.Contains(c) ? '_' : c).ToArray()).Trim();
+        return string.IsNullOrWhiteSpace(safe) ? "Planung" : safe;
+    }
+
+    private async Task RunExchange(Func<Task> action)
+    {
+        try
+        {
+            await action();
+        }
+        catch (Exception ex) when (ex is PlanningExchangeException or IOException
+                                   or UnauthorizedAccessException or InvalidOperationException)
+        {
+            Notifications.ShowError(ex.Message);
+        }
+    }
+
+    private static PlanningExchangeService Exchange =>
+        App.Services.GetRequiredService<PlanningExchangeService>();
+
+    private static NotificationService Notifications =>
+        App.Services.GetRequiredService<NotificationService>();
 }