feat(calendar): Kalender an Nutzer und Gruppen freigeben

Nicht als eigene Tabelle, wie im Plan vorgesehen: acl_entries beantwortet
fuer Ordner und Dateien laengst dieselbe Frage -- wer darf was, direkt oder
ueber eine Gruppe. Ein zweites Rechtesystem daneben waere eine zweite
Antwort auf dieselbe Frage, mit eigener Gruppenaufloesung, eigenem
Widerruf, eigenem Pruefpfad; die Luecke dazwischen faellt erst auf, wenn
jemand sieht, was er nicht sehen soll. Migration 25 haengt deshalb nur eine
dritte Ressourcenspalte an.

Der Gewinn: Freigeben an eine **Gruppe** kostete keine Zeile extra.

Drei Entscheidungen, die nicht offensichtlich waren:

* Ein fremder Kalender steht immer unter seiner UUID, nie unter dem
  Pfadsegment des Eigentuemers -- das hat der sich ausgesucht, und zwei
  Leute duerfen denselben Namen waehlen. Sonst laegen im Kalenderbestand
  des Empfaengers zwei Kalender auf derselben Adresse.
* Alle Wege laufen durch RequireCalendar. CalDAV und Weboberflaeche sind
  zwei getrennte Zugaenge zu denselben Daten; ein Recht, das nur einer von
  beiden prueft, ist kein Recht. Im CalDAV-Teil genuegte, resolveCalendar
  umzustellen -- dort kommt jede Operation vorbei.
* Wer ein Recht geliehen hat, darf es nicht weiterverleihen: Umbenennen,
  Loeschen und Freigeben bleiben auch mit Schreibrecht beim Eigentuemer.

Oberflaeche: fremde Kalender tragen Eigentuemer und "(nur lesen)", das
Menue zeigt nur, was auch geht, und ein Termin laesst sich gar nicht erst
in einen Kalender ziehen, den der Server danach ablehnen wuerde.

scripts/kalender-teilen-selbsttest.py, 41 Pruefungen, jede ueber beide
Zugaenge. Er beginnt damit, dass der Empfaenger vorher nichts sieht --
ohne diesen Anfang beweist der Rest nichts.

Dabei hatte der Test selbst eine Falle: Mit festem Testdatum lief die
Terminliste aus ihrem Standardzeitraum, und die Pruefung "beim Eigentuemer
ist nichts angekommen" bestand **leer**.

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

backend/internal/acl/acl.go

@@ -349,3 +349,119 @@ func stronger(a, b Permission) Permission {
 	}
 	return ""
 }
+
+// ── Kalender ─────────────────────────────────────────────────────────────────
+//
+// Kalender liegen in derselben Rechtetabelle wie Ordner und Dateien. Nicht aus
+// Sparsamkeit, sondern weil zwei Tabellen zwei Antworten auf dieselbe Frage
+// wären – und die Lücke zwischen ihnen fällt erst auf, wenn jemand sieht, was
+// er nicht sehen soll. Die Auflösung über Gruppen ist deshalb wörtlich
+// dieselbe Bedingung wie bei Ordnern.
+
+// ResolveCalendar klärt, was userID mit diesem Kalender darf.
+//
+// Der Eigentümer darf schreiben. Alle anderen nur, wenn es eine Freigabe gibt –
+// direkt oder über eine Gruppe, in der sie sind. Gibt es keine, ist die
+// Antwort ErrNoAccess, und der Aufrufer macht daraus ein 404: Ein 403 verriete,
+// dass es den Kalender gibt.
+func (s *Store) ResolveCalendar(ctx context.Context, userID, calendarID uuid.UUID) (Permission, error) {
+	var ownerID uuid.UUID
+	err := s.db.QueryRow(ctx,
+		`SELECT owner_id FROM cal_calendars WHERE id = $1`, calendarID).Scan(&ownerID)
+	if errors.Is(err, pgx.ErrNoRows) {
+		return "", ErrNotFound
+	}
+	if err != nil {
+		return "", fmt.Errorf("load calendar owner: %w", err)
+	}
+	if ownerID == userID {
+		return PermWrite, nil
+	}
+
+	rows, err := s.db.Query(ctx,
+		`SELECT e.permission
+		   FROM acl_entries e
+		  WHERE e.resource_calendar_id = $1
+		    AND ( e.subject_user_id = $2
+		       OR e.subject_group_id IN (SELECT group_id FROM group_members WHERE user_id = $2) )`,
+		calendarID, userID)
+	if err != nil {
+		return "", fmt.Errorf("resolve calendar permission: %w", err)
+	}
+	defer rows.Close()
+
+	// Mehrere Wege zum selben Kalender sind möglich – persönlich *und* über
+	// eine Gruppe. Dann gilt das weitergehende Recht; alles andere wäre für
+	// den Betroffenen nicht nachvollziehbar.
+	var best Permission
+	for rows.Next() {
+		var p Permission
+		if err := rows.Scan(&p); err != nil {
+			return "", fmt.Errorf("scan permission: %w", err)
+		}
+		if p == PermWrite {
+			best = PermWrite
+		} else if best == "" {
+			best = p
+		}
+	}
+	if err := rows.Err(); err != nil {
+		return "", err
+	}
+	if best == "" {
+		return "", ErrNoAccess
+	}
+	return best, nil
+}
+
+// SharedCalendar ist ein fremder Kalender, den jemand sehen darf.
+type SharedCalendar struct {
+	CalendarID uuid.UUID
+	Permission Permission
+	OwnerName  string
+	// ViaGroup nennt die Gruppe, über die der Zugriff kommt – sonst wundert
+	// man sich über einen Kalender, den einem nie jemand persönlich gab.
+	ViaGroup string
+}
+
+// SharedCalendars liefert alle **fremden** Kalender, die userID sehen darf.
+// Die eigenen stehen nicht darin; die kennt der Kalenderteil selbst.
+func (s *Store) SharedCalendars(ctx context.Context, userID uuid.UUID) ([]SharedCalendar, error) {
+	rows, err := s.db.Query(ctx,
+		`SELECT c.id, e.permission,
+		        COALESCE(NULLIF(o.display_name, ''), o.username, ''),
+		        COALESCE(g.name, '')
+		   FROM acl_entries e
+		   JOIN cal_calendars c ON c.id = e.resource_calendar_id
+		   JOIN users o         ON o.id = c.owner_id
+		   LEFT JOIN groups g   ON g.id = e.subject_group_id
+		  WHERE c.owner_id <> $1
+		    AND ( e.subject_user_id = $1
+		       OR e.subject_group_id IN (SELECT group_id FROM group_members WHERE user_id = $1) )
+		  ORDER BY o.username, c.created_at`,
+		userID)
+	if err != nil {
+		return nil, fmt.Errorf("list shared calendars: %w", err)
+	}
+	defer rows.Close()
+
+	// Zwei Wege zum selben Kalender ergeben zwei Zeilen – angezeigt wird er
+	// einmal, mit dem weitergehenden Recht.
+	byID := map[uuid.UUID]int{}
+	out := []SharedCalendar{}
+	for rows.Next() {
+		var sc SharedCalendar
+		if err := rows.Scan(&sc.CalendarID, &sc.Permission, &sc.OwnerName, &sc.ViaGroup); err != nil {
+			return nil, fmt.Errorf("scan shared calendar: %w", err)
+		}
+		if i, da := byID[sc.CalendarID]; da {
+			if sc.Permission == PermWrite {
+				out[i].Permission = PermWrite
+			}
+			continue
+		}
+		byID[sc.CalendarID] = len(out)
+		out = append(out, sc)
+	}
+	return out, rows.Err()
+}