Angenommen, Sie helfen bei der Verwaltung einer kleinen Organisation oder eines Clubs und verfügen über eine Datenbank, in der alle Mitgliederdaten (Namen, Telefonnummer, E-Mail usw.) gespeichert sind.
Wäre es nicht schön, überall dort Zugriff auf diese aktuellen Informationen zu haben, wo Sie sie benötigen? Mit CardDAV ist das möglich!

CardDAV ist ein gut unterstützter offener Standard für die Kontaktverwaltung; Es verfügt über eine native Integration in die iOS-Kontakte-App und viele Apps, die für Android verfügbar sind.

Serverseitig ist die Implementierung von CardDAV ein http-Server, der auf ungewöhnliche http-Methoden reagiert (PROPFIND, REPORT statt GET, POST...). Glücklicherweise gibt es ein Go-Modul, das die Arbeit erheblich vereinfacht: github.com/emersion/go-webdav. Diese Bibliothek erwartet ein implementiertes Backend und stellt einen Standard-http.Handler bereit, der HTTP-Anfragen nach der Authentifizierung bedienen soll.

Authentifizierung

Interessanterweise bietet die Bibliothek keine Hilfe zur Benutzerauthentifizierung, aber dank der Zusammensetzbarkeit von Go ist dies kein Problem.
CardDAV verwendet Basic Auth-Anmeldeinformationen. Sobald die Anmeldeinformationen überprüft wurden, können wir diese Anmeldeinformationen im Kontext speichern (wird später nützlich sein):

package main

import (
    "context"
    "net/http"

    "github.com/emersion/go-webdav/carddav"
)

type (
    ctxKey   struct{}
    ctxValue struct {
        username string
    }
)

func NewCardDAVHandler() http.Handler {
    actualHandler := carddav.Handler{
        Backend: &ownBackend{},
    }

    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        username, password, ok := r.BasicAuth()
        // check username and password: adjust the logic to your system (do NOT store passwords in plaintext)
        if !ok || username != "admin" || password != "s3cr3t" {
            // abort the request handling on failure
            w.Header().Add("WWW-Authenticate", `Basic realm="Please authenticate", charset="UTF-8"`)
            http.Error(w, "HTTP Basic auth is required", http.StatusUnauthorized)
            return
        }

        // user is authenticated: store this info in the context
        ctx := context.WithValue(r.Context(), ctxKey{}, ctxValue{username})
        // delegate the work to the CardDAV handle
        actualHandler.ServeHTTP(w, r.WithContext(ctx))
    })
}

Implementierung der CardDAV-Schnittstelle

Die ownBackend-Struktur muss die Schnittstelle carddav.Backend implementieren, die nicht sehr dünn, aber dennoch verwaltbar ist.

CurrentUserPrincipal und AddressBookHomeSetPath müssen URLs bereitstellen (die mit einem Schrägstrich beginnen und enden). Normalerweise sind es Benutzername/Kontakte. Hier müssen Sie den Benutzernamen aus dem Kontext extrahieren (was das einzige verfügbare Argument ist):

func currentUsername(ctx context.Context) (string, error) {
    if v, ok := ctx.Value(ctxKey{}).(ctxValue); ok {
        return v.username, nil
    }
    return "", errors.New("not authenticated")
}

type ownBackend struct{}

// must begin and end with a slash
func (b *ownBackend) CurrentUserPrincipal(ctx context.Context) (string, error) {
    username, err := currentUsername(ctx)
    return "/"   url.PathEscape(username)   "/", err
}

// must begin and end with a slash as well
func (b *ownBackend) AddressBookHomeSetPath(ctx context.Context) (string, error) {
    principal, err := b.CurrentUserPrincipal(ctx)
    return principal   "contacts/", err
}

Danach kann der Spaß beginnen: Sie müssen die Methoden AddressBook, GetAddressObject und ListAddressObjects implementieren.

AddressBook gibt eine einfache Struktur zurück, wobei der Pfad mit dem obigen AddressBookHomeSetPath beginnen (und mit einem Schrägstrich enden sollte)

GetAddressObject und ListAddressObjects müssen den aktuellen Pfad überprüfen (um sicherzustellen, dass der aktuell authentifizierte Benutzer auf diese Kontakte zugreifen kann) und die Kontakte dann als AddressObject zurückgeben.

Adressobjekt

Das AddressObject hat mehrere Attribute, am wichtigsten:

• der Pfad zur Identifizierung dieses bestimmten Kontakts (kann beliebig sein, beginnen Sie mit einem Schrägstrich)
• das ETag, damit der Client schnell überprüfen kann, ob ein Update stattgefunden hat (wenn Sie es vergessen, zeigt iOS nichts an)
• die Karte, die eine VCard erwartet

Die VCard stellt die eigentlichen Kontaktdaten dar und muss ggf. angepasst werden, je nachdem, wie Sie Ihre Kontakte speichern. In meinem Fall endete es so:

func utf8Field(v string) *vcard.Field {
    return &vcard.Field{
        Value: v,
        Params: vcard.Params{
            "CHARSET": []string{"UTF-8"},
        },
    }
}

func vcardFromUser(u graphqlient.User) vcard.Card {
    c := vcard.Card{}

    c.Set(vcard.FieldFormattedName, utf8Field(u.Firstname " " u.Lastname))
    c.SetName(&vcard.Name{
        Field:      utf8Field(""),
        FamilyName: u.Lastname,
        GivenName:  u.Firstname,
    })
    c.SetRevision(u.UpdatedAt)
    c.SetValue(vcard.FieldUID, u.Extid)

    c.Set(vcard.FieldOrganization, utf8Field(u.Unit))

    // addFields sorts the key to ensure a stable order
    addFields := func(fieldName string, values map[string]string) {
        for _, k := range slices.Sorted(maps.Keys(values)) {
            v := values[k]
            c.Add(fieldName, &vcard.Field{
                Value: v,
                Params: vcard.Params{
                    vcard.ParamType: []string{k   ";CHARSET=UTF-8"}, // hacky but prevent maps ordering issues
                    // "CHARSET":       []string{"UTF-8"},
                },
            })
        }
    }

    addFields(vcard.FieldEmail, u.Emails)
    addFields(vcard.FieldTelephone, u.Phones)

    vcard.ToV4(c)
    return c
}

Verwenden Sie die Readonly-Verknüpfung

Einige Methoden ermöglichen das Aktualisieren eines Kontakts. Da ich nicht möchte, dass meine Mitgliederliste über CardDAV aktualisiert wird, gebe ich einen 403-Fehler an die Put- und Delete-Methoden zurück: return webdav.NewHTTPError(http.StatusForbidden,errors.New("carddav: operation notsupported"))

Testen vor Ort

iOS erfordert, dass der CardDAV-Server über https bedient. Sie können selbstsignierte Zertifikate lokal mit OpenSSL generieren (ersetzen Sie 192.168.XXX.XXX durch Ihre IP-Adresse), um sie in http.ListenAndServeTLS(addr, "localhost.crt", "localhost.key", NewCardDAVHandler())

openssl req -new -subj "/C=US/ST=Utah/CN=192.168.XXX.XXX" -newkey rsa:2048 -nodes -keyout localhost.key -out localhost.csr
openssl x509 -req -days 365 -in localhost.csr -signkey localhost.key -out localhost.crt

Danach sollten Sie in der Lage sein, lokal zu experimentieren, indem Sie ein „CardDAV-Kontaktkonto“ hinzufügen, das auf Ihre eigene IP-Adresse und Ihren eigenen Port verweist.

Abschluss

Die Implementierung eines CardDAV-Servers in Go ist etwas aufwändig, aber es lohnt sich auf jeden Fall: Ihre Kontakte werden automatisch mit den Daten synchronisiert, die Sie auf dem Server Ihrer Organisation haben!

Kennen Sie andere coole Protokolle, die diese Art der nativen Integration ermöglichen? Teilen Sie gerne Ihre Erfahrungen!