feat(calendar): Kalender anlegen, umbenennen, loeschen -- vom Client aus

Bisher konnte ein CalDAV-Client Termine verwalten, aber keine Kalender:

  MKCALENDAR -> 405    anlegen
  PROPPATCH  -> 501    umbenennen, umfaerben
  DELETE     -> 404    loeschen

go-webdav deckt davon nur MKCOL ab, und selbst da verwarf unser Backend
die vom Client gewaehlte Adresse. Alle drei Verben faengt der Handler
jetzt vorher ab (collections.go).

Der Kern steckt aber nicht in den Verben, sondern in der Adresse: Bei
MKCALENDAR sucht *der Client* aus, wo der Kalender liegen soll
("…/calendars/max/arbeit/"). Unsere Kalender lagen bisher zwingend unter
ihrer UUID -- der Client haette angelegt und auf seine eigene Adresse
sofort ein 404 bekommen.

Deshalb Migration 23 mit einer Spalte path_segment: gesetzt = die
gewaehlte Adresse, NULL = es gilt weiterhin die UUID. Bestehende
Kalender bleiben damit unter genau der Adresse erreichbar, unter der die
eingerichteten Geraete sie kennen -- ein Wechsel haette jedes Telefon
dazu gebracht, seine Termine fuer geloescht zu halten. Aufgeloest wird
beides in einer Abfrage (GetCalendarByRef), die gewaehlte Adresse hat
Vorrang.

PROPPATCH antwortet mit einem Status je Eigenschaft, auch wenn alles
geklappt hat: Es kann teilweise gelingen, und ein nacktes 200
verschwiege, welcher Teil angekommen ist. Was wir nicht aendern koennen,
bekommt 403 statt stillem Schlucken -- ein Client, der seine Aenderung
fuer angekommen haelt, ist schlimmer dran als einer mit klarer Absage.
Ebenso eine unlesbare Farbe: absagen statt raten.

DELETE auf eine Sammlung loescht den Kalender mitsamt allen Terminen --
das ist in WebDAV seine Bedeutung.

CalDAV-Selbsttest von 45 auf 62 Pruefungen: anlegen, unter der
gewaehlten Adresse erreichbar, Farbe aus dem MKCALENDAR uebernommen,
Termin darin ablegen und abrufen, zweites Anlegen auf dieselbe Adresse
405, umbenennen und umfaerben mit Status je Eigenschaft, loeschen, danach
404 -- und dasselbe noch einmal ueber MKCOL, das Verb, das DAVx5 nimmt.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

backend/internal/calendar/backend.go

@@ -14,7 +14,6 @@ import (
 	ical "github.com/emersion/go-ical"
 	"github.com/emersion/go-webdav"
 	"github.com/emersion/go-webdav/caldav"
-	"github.com/google/uuid"
 
 	"aether/internal/auth"
 )
@@ -83,19 +82,24 @@ func (b *Backend) CalendarHomeSetPath(ctx context.Context) (string, error) {
 	return davPrefix + "/calendars/" + u.Username + "/", nil
 }
 
-func calendarPath(username string, id uuid.UUID) string {
-	return davPrefix + "/calendars/" + username + "/" + id.String() + "/"
+// calendarPath baut die Adresse eines Kalenders. ref ist sein Pfadsegment –
+// die vom Client gewählte Adresse, sonst die UUID (siehe Calendar.Ref).
+func calendarPath(username, ref string) string {
+	return davPrefix + "/calendars/" + username + "/" + ref + "/"
 }
 
-func objectPath(username string, id uuid.UUID, uid string) string {
-	return calendarPath(username, id) + uid + ".ics"
+func objectPath(username, ref, uid string) string {
+	return calendarPath(username, ref) + uid + ".ics"
 }
 
-// parseCalendarPath erwartet "/caldav/calendars/{username}/{calendar-id}(/...)"
-// und liefert die Kalender-ID. Der Benutzername im Pfad wird nicht gegen den
-// angemeldeten Nutzer geprüft – Phase 1 kennt ohnehin nur den eigenen Pfad,
-// spätere Freigaben ändern das gezielt in resolveCalendar.
-func parseCalendarPath(p string) (calID uuid.UUID, rest string, err error) {
+// parseCalendarPath erwartet "/caldav/calendars/{username}/{segment}(/...)"
+// und liefert das Pfadsegment des Kalenders – nicht dessen UUID: Legt ein
+// Client per MKCALENDAR einen Kalender an, sucht **er** die Adresse aus
+// ("…/calendars/max/arbeit/"). Aufgelöst wird sie in resolveCalendar.
+//
+// Der Benutzername im Pfad wird hier nicht geprüft; das tut der Handler,
+// bevor die Anfrage überhaupt hier ankommt (pathBelongsTo).
+func parseCalendarPath(p string) (ref string, rest string, err error) {
 	// Kommt vor: ein Browser macht GET auf eine Sammlung (Principal,
 	// Home-Set) statt PROPFIND – go-webdav reicht das trotzdem unverändert
 	// an GetCalendarObject durch, siehe backend.go-Kommentar zum Pfadschema.
@@ -104,20 +108,16 @@ func parseCalendarPath(p string) (calID uuid.UUID, rest string, err error) {
 	// UUID-Parsing-Fehler nach außen geben.
 	const calPrefix = davPrefix + "/calendars/"
 	if !strings.HasPrefix(p, calPrefix) {
-		return uuid.UUID{}, "", fmt.Errorf("calendar: not a calendar path: %q", p)
+		return "", "", fmt.Errorf("calendar: not a calendar path: %q", p)
 	}
 	parts := strings.SplitN(strings.TrimPrefix(p, calPrefix), "/", 3)
 	if len(parts) < 2 || parts[1] == "" {
-		return uuid.UUID{}, "", fmt.Errorf("calendar: malformed path %q", p)
-	}
-	id, err := uuid.Parse(parts[1])
-	if err != nil {
-		return uuid.UUID{}, "", fmt.Errorf("calendar: malformed calendar id in %q: %w", p, err)
+		return "", "", fmt.Errorf("calendar: malformed path %q", p)
 	}
 	if len(parts) == 3 {
 		rest = parts[2]
 	}
-	return id, rest, nil
+	return parts[1], rest, nil
 }
 
 func (b *Backend) resolveCalendar(ctx context.Context, p string) (*auth.User, *Calendar, error) {
@@ -125,11 +125,11 @@ func (b *Backend) resolveCalendar(ctx context.Context, p string) (*auth.User, *C
 	if err != nil {
 		return nil, nil, err
 	}
-	calID, _, err := parseCalendarPath(p)
+	ref, _, err := parseCalendarPath(p)
 	if err != nil {
 		return nil, nil, webdav.NewHTTPError(http.StatusNotFound, err)
 	}
-	cal, err := b.store.GetCalendar(ctx, u.ID, calID)
+	cal, err := b.store.GetCalendarByRef(ctx, u.ID, ref)
 	if errors.Is(err, ErrNotFound) {
 		return nil, nil, webdav.NewHTTPError(http.StatusNotFound, err)
 	}
@@ -145,7 +145,7 @@ func toCalDAVCalendar(username string, c *Calendar) caldav.Calendar {
 		comps = append(comps, "VTODO")
 	}
 	return caldav.Calendar{
-		Path:                  calendarPath(username, c.ID),
+		Path:                  calendarPath(username, c.Ref()),
 		Name:                  c.Name,
 		Description:           c.Description,
 		MaxResourceSize:       5 * 1024 * 1024,
@@ -162,11 +162,26 @@ func (b *Backend) CreateCalendar(ctx context.Context, cal *caldav.Calendar) erro
 	if name == "" {
 		name = "Kalender"
 	}
-	created, err := b.store.CreateCalendar(ctx, u.ID, name, "", cal.Description)
+	// Die Adresse sucht der Client aus (MKCOL/MKCALENDAR). Sie zu ersetzen
+	// wäre der eine Fehler, den man hier machen kann: Der Client legt an
+	// unter "…/arbeit/", fragt gleich darauf dieselbe Adresse ab – und bekäme
+	// ein 404, weil der Kalender in Wahrheit unter seiner UUID läge.
+	ref, rest, err := parseCalendarPath(cal.Path)
+	if err != nil || rest != "" {
+		return webdav.NewHTTPError(http.StatusForbidden,
+			fmt.Errorf("calendar: cannot create a calendar at %q", cal.Path))
+	}
+	created, err := b.store.CreateCalendarAt(ctx, u.ID, ref, name, "", cal.Description)
+	if errors.Is(err, ErrConflict) {
+		// RFC 4918: Anlegen, wo schon etwas liegt, ist 405 – nicht stilles
+		// Überschreiben.
+		return webdav.NewHTTPError(http.StatusMethodNotAllowed,
+			fmt.Errorf("calendar: %q already exists", ref))
+	}
 	if err != nil {
 		return fmt.Errorf("create calendar: %w", err)
 	}
-	cal.Path = calendarPath(u.Username, created.ID)
+	cal.Path = calendarPath(u.Username, created.Ref())
 	return nil
 }
 
@@ -199,14 +214,14 @@ func (b *Backend) GetCalendar(ctx context.Context, p string) (*caldav.Calendar,
 	return &c, nil
 }
 
-func toCalendarObject(username string, calID uuid.UUID, o *Object) (*caldav.CalendarObject, error) {
+func toCalendarObject(username, calRef string, o *Object) (*caldav.CalendarObject, error) {
 	dec := ical.NewDecoder(strings.NewReader(o.Data))
 	data, err := dec.Decode()
 	if err != nil {
 		return nil, fmt.Errorf("decode object %s: %w", o.UID, err)
 	}
 	return &caldav.CalendarObject{
-		Path:          objectPath(username, calID, o.UID),
+		Path:          objectPath(username, calRef, o.UID),
 		ModTime:       o.UpdatedAt,
 		ContentLength: int64(len(o.Data)),
 		ETag:          o.ETag,
@@ -231,7 +246,7 @@ func (b *Backend) GetCalendarObject(ctx context.Context, p string, _ *caldav.Cal
 	if err != nil {
 		return nil, err
 	}
-	return toCalendarObject(u.Username, cal.ID, obj)
+	return toCalendarObject(u.Username, cal.Ref(), obj)
 }
 
 func (b *Backend) ListCalendarObjects(ctx context.Context, p string, _ *caldav.CalendarCompRequest) ([]caldav.CalendarObject, error) {
@@ -245,7 +260,7 @@ func (b *Backend) ListCalendarObjects(ctx context.Context, p string, _ *caldav.C
 	}
 	out := make([]caldav.CalendarObject, 0, len(objs))
 	for i := range objs {
-		co, err := toCalendarObject(u.Username, cal.ID, &objs[i])
+		co, err := toCalendarObject(u.Username, cal.Ref(), &objs[i])
 		if err != nil {
 			// Eine kaputte Einzeldatei darf nicht die gesamte Synchronisation
 			// blockieren; der Client bekommt die übrigen Termine trotzdem.
@@ -347,7 +362,7 @@ func (b *Backend) PutCalendarObject(ctx context.Context, p string, cal *ical.Cal
 	if err != nil {
 		return nil, fmt.Errorf("put object: %w", err)
 	}
-	return toCalendarObject(u.Username, calRow.ID, obj)
+	return toCalendarObject(u.Username, calRow.Ref(), obj)
 }
 
 func (b *Backend) DeleteCalendarObject(ctx context.Context, p string) error {