mirror of
https://github.com/1f349/go-webdav.git
synced 2024-12-23 00:34:23 +00:00
377 lines
9.2 KiB
Go
377 lines
9.2 KiB
Go
package caldav
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"fmt"
|
|
"mime"
|
|
"net/http"
|
|
"net/url"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/emersion/go-ical"
|
|
"github.com/emersion/go-webdav"
|
|
"github.com/emersion/go-webdav/internal"
|
|
)
|
|
|
|
// DiscoverContextURL performs a DNS-based CardDAV service discovery as
|
|
// described in RFC 6352 section 11. It returns the URL to the CardDAV server.
|
|
func DiscoverContextURL(ctx context.Context, domain string) (string, error) {
|
|
return internal.DiscoverContextURL(ctx, "caldavs", domain)
|
|
}
|
|
|
|
// Client provides access to a remote CardDAV server.
|
|
type Client struct {
|
|
*webdav.Client
|
|
|
|
ic *internal.Client
|
|
}
|
|
|
|
func NewClient(c webdav.HTTPClient, endpoint string) (*Client, error) {
|
|
wc, err := webdav.NewClient(c, endpoint)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
ic, err := internal.NewClient(c, endpoint)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &Client{wc, ic}, nil
|
|
}
|
|
|
|
func (c *Client) FindCalendarHomeSet(ctx context.Context, principal string) (string, error) {
|
|
propfind := internal.NewPropNamePropFind(calendarHomeSetName)
|
|
resp, err := c.ic.PropFindFlat(ctx, principal, propfind)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
var prop calendarHomeSet
|
|
if err := resp.DecodeProp(&prop); err != nil {
|
|
return "", err
|
|
}
|
|
|
|
return prop.Href.Path, nil
|
|
}
|
|
|
|
func (c *Client) FindCalendars(ctx context.Context, calendarHomeSet string) ([]Calendar, error) {
|
|
propfind := internal.NewPropNamePropFind(
|
|
internal.ResourceTypeName,
|
|
internal.DisplayNameName,
|
|
calendarDescriptionName,
|
|
maxResourceSizeName,
|
|
supportedCalendarComponentSetName,
|
|
)
|
|
ms, err := c.ic.PropFind(ctx, calendarHomeSet, internal.DepthOne, propfind)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
l := make([]Calendar, 0, len(ms.Responses))
|
|
for _, resp := range ms.Responses {
|
|
path, err := resp.Path()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var resType internal.ResourceType
|
|
if err := resp.DecodeProp(&resType); err != nil {
|
|
return nil, err
|
|
}
|
|
if !resType.Is(calendarName) {
|
|
continue
|
|
}
|
|
|
|
var desc calendarDescription
|
|
if err := resp.DecodeProp(&desc); err != nil && !internal.IsNotFound(err) {
|
|
return nil, err
|
|
}
|
|
|
|
var dispName internal.DisplayName
|
|
if err := resp.DecodeProp(&dispName); err != nil && !internal.IsNotFound(err) {
|
|
return nil, err
|
|
}
|
|
|
|
var maxResSize maxResourceSize
|
|
if err := resp.DecodeProp(&maxResSize); err != nil && !internal.IsNotFound(err) {
|
|
return nil, err
|
|
}
|
|
if maxResSize.Size < 0 {
|
|
return nil, fmt.Errorf("carddav: max-resource-size must be a positive integer")
|
|
}
|
|
|
|
var supportedCompSet supportedCalendarComponentSet
|
|
if err := resp.DecodeProp(&supportedCompSet); err != nil && !internal.IsNotFound(err) {
|
|
return nil, err
|
|
}
|
|
|
|
compNames := make([]string, 0, len(supportedCompSet.Comp))
|
|
for _, comp := range supportedCompSet.Comp {
|
|
compNames = append(compNames, comp.Name)
|
|
}
|
|
|
|
l = append(l, Calendar{
|
|
Path: path,
|
|
Name: dispName.Name,
|
|
Description: desc.Description,
|
|
MaxResourceSize: maxResSize.Size,
|
|
SupportedComponentSet: compNames,
|
|
})
|
|
}
|
|
|
|
return l, nil
|
|
}
|
|
|
|
func encodeCalendarCompReq(c *CalendarCompRequest) (*comp, error) {
|
|
encoded := comp{Name: c.Name}
|
|
|
|
if c.AllProps {
|
|
encoded.Allprop = &struct{}{}
|
|
}
|
|
for _, name := range c.Props {
|
|
encoded.Prop = append(encoded.Prop, prop{Name: name})
|
|
}
|
|
|
|
if c.AllComps {
|
|
encoded.Allcomp = &struct{}{}
|
|
}
|
|
for _, child := range c.Comps {
|
|
encodedChild, err := encodeCalendarCompReq(&child)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
encoded.Comp = append(encoded.Comp, *encodedChild)
|
|
}
|
|
|
|
return &encoded, nil
|
|
}
|
|
|
|
func encodeCalendarReq(c *CalendarCompRequest) (*internal.Prop, error) {
|
|
compReq, err := encodeCalendarCompReq(c)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
calDataReq := calendarDataReq{Comp: compReq}
|
|
|
|
getLastModReq := internal.NewRawXMLElement(internal.GetLastModifiedName, nil, nil)
|
|
getETagReq := internal.NewRawXMLElement(internal.GetETagName, nil, nil)
|
|
return internal.EncodeProp(&calDataReq, getLastModReq, getETagReq)
|
|
}
|
|
|
|
func encodeCompFilter(filter *CompFilter) *compFilter {
|
|
encoded := compFilter{Name: filter.Name}
|
|
if !filter.Start.IsZero() || !filter.End.IsZero() {
|
|
encoded.TimeRange = &timeRange{
|
|
Start: dateWithUTCTime(filter.Start),
|
|
End: dateWithUTCTime(filter.End),
|
|
}
|
|
}
|
|
for _, child := range filter.Comps {
|
|
encoded.CompFilters = append(encoded.CompFilters, *encodeCompFilter(&child))
|
|
}
|
|
return &encoded
|
|
}
|
|
|
|
func decodeCalendarObjectList(ms *internal.MultiStatus) ([]CalendarObject, error) {
|
|
addrs := make([]CalendarObject, 0, len(ms.Responses))
|
|
for _, resp := range ms.Responses {
|
|
path, err := resp.Path()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var calData calendarDataResp
|
|
if err := resp.DecodeProp(&calData); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var getLastMod internal.GetLastModified
|
|
if err := resp.DecodeProp(&getLastMod); err != nil && !internal.IsNotFound(err) {
|
|
return nil, err
|
|
}
|
|
|
|
var getETag internal.GetETag
|
|
if err := resp.DecodeProp(&getETag); err != nil && !internal.IsNotFound(err) {
|
|
return nil, err
|
|
}
|
|
|
|
var getContentLength internal.GetContentLength
|
|
if err := resp.DecodeProp(&getContentLength); err != nil && !internal.IsNotFound(err) {
|
|
return nil, err
|
|
}
|
|
|
|
r := bytes.NewReader(calData.Data)
|
|
data, err := ical.NewDecoder(r).Decode()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
addrs = append(addrs, CalendarObject{
|
|
Path: path,
|
|
ModTime: time.Time(getLastMod.LastModified),
|
|
ContentLength: getContentLength.Length,
|
|
ETag: string(getETag.ETag),
|
|
Data: data,
|
|
})
|
|
}
|
|
|
|
return addrs, nil
|
|
}
|
|
|
|
func (c *Client) QueryCalendar(ctx context.Context, calendar string, query *CalendarQuery) ([]CalendarObject, error) {
|
|
propReq, err := encodeCalendarReq(&query.CompRequest)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
calendarQuery := calendarQuery{Prop: propReq}
|
|
calendarQuery.Filter.CompFilter = *encodeCompFilter(&query.CompFilter)
|
|
req, err := c.ic.NewXMLRequest("REPORT", calendar, &calendarQuery)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
req.Header.Add("Depth", "1")
|
|
|
|
ms, err := c.ic.DoMultiStatus(req.WithContext(ctx))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return decodeCalendarObjectList(ms)
|
|
}
|
|
|
|
func (c *Client) MultiGetCalendar(ctx context.Context, path string, multiGet *CalendarMultiGet) ([]CalendarObject, error) {
|
|
propReq, err := encodeCalendarReq(&multiGet.CompRequest)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
calendarMultiget := calendarMultiget{Prop: propReq}
|
|
|
|
if len(multiGet.Paths) == 0 {
|
|
href := internal.Href{Path: path}
|
|
calendarMultiget.Hrefs = []internal.Href{href}
|
|
} else {
|
|
calendarMultiget.Hrefs = make([]internal.Href, len(multiGet.Paths))
|
|
for i, p := range multiGet.Paths {
|
|
calendarMultiget.Hrefs[i] = internal.Href{Path: p}
|
|
}
|
|
}
|
|
|
|
req, err := c.ic.NewXMLRequest("REPORT", path, &calendarMultiget)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
req.Header.Add("Depth", "1")
|
|
|
|
ms, err := c.ic.DoMultiStatus(req.WithContext(ctx))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return decodeCalendarObjectList(ms)
|
|
}
|
|
|
|
func populateCalendarObject(co *CalendarObject, h http.Header) error {
|
|
if loc := h.Get("Location"); loc != "" {
|
|
u, err := url.Parse(loc)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
co.Path = u.Path
|
|
}
|
|
if etag := h.Get("ETag"); etag != "" {
|
|
etag, err := strconv.Unquote(etag)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
co.ETag = etag
|
|
}
|
|
if contentLength := h.Get("Content-Length"); contentLength != "" {
|
|
n, err := strconv.ParseInt(contentLength, 10, 64)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
co.ContentLength = n
|
|
}
|
|
if lastModified := h.Get("Last-Modified"); lastModified != "" {
|
|
t, err := http.ParseTime(lastModified)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
co.ModTime = t
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (c *Client) GetCalendarObject(ctx context.Context, path string) (*CalendarObject, error) {
|
|
req, err := c.ic.NewRequest(http.MethodGet, path, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
req.Header.Set("Accept", ical.MIMEType)
|
|
|
|
resp, err := c.ic.Do(req.WithContext(ctx))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
mediaType, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if !strings.EqualFold(mediaType, ical.MIMEType) {
|
|
return nil, fmt.Errorf("caldav: expected Content-Type %q, got %q", ical.MIMEType, mediaType)
|
|
}
|
|
|
|
cal, err := ical.NewDecoder(resp.Body).Decode()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
co := &CalendarObject{
|
|
Path: resp.Request.URL.Path,
|
|
Data: cal,
|
|
}
|
|
if err := populateCalendarObject(co, resp.Header); err != nil {
|
|
return nil, err
|
|
}
|
|
return co, nil
|
|
}
|
|
|
|
func (c *Client) PutCalendarObject(ctx context.Context, path string, cal *ical.Calendar) (*CalendarObject, error) {
|
|
// TODO: add support for If-None-Match and If-Match
|
|
|
|
// TODO: some servers want a Content-Length header, so we can't stream the
|
|
// request body here. See the Radicale issue:
|
|
// https://github.com/Kozea/Radicale/issues/1016
|
|
|
|
var buf bytes.Buffer
|
|
if err := ical.NewEncoder(&buf).Encode(cal); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
req, err := c.ic.NewRequest(http.MethodPut, path, &buf)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
req.Header.Set("Content-Type", ical.MIMEType)
|
|
|
|
resp, err := c.ic.Do(req.WithContext(ctx))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
resp.Body.Close()
|
|
|
|
co := &CalendarObject{Path: path}
|
|
if err := populateCalendarObject(co, resp.Header); err != nil {
|
|
return nil, err
|
|
}
|
|
return co, nil
|
|
}
|