feat: implement caldav search

vendor/github.com/dolanor/caldav-go/caldav/client.go

@@ -0,0 +1,191 @@
+package caldav
+
+import (
+	"fmt"
+	"log"
+	"net/http"
+	"strings"
+
+	cent "github.com/dolanor/caldav-go/caldav/entities"
+	"github.com/dolanor/caldav-go/icalendar/components"
+	"github.com/dolanor/caldav-go/utils"
+	"github.com/dolanor/caldav-go/webdav"
+	"github.com/dolanor/caldav-go/webdav/entities"
+)
+
+var _ = log.Print
+
+// a client for making WebDAV requests
+type Client webdav.Client
+
+// downcasts the client to the WebDAV interface
+func (c *Client) WebDAV() *webdav.Client {
+	return (*webdav.Client)(c)
+}
+
+// returns the embedded CalDAV server reference
+func (c *Client) Server() *Server {
+	return (*Server)(c.WebDAV().Server())
+}
+
+// fetches a list of CalDAV features supported by the server
+// returns an error if the server does not support DAV
+func (c *Client) Features(path string) ([]string, error) {
+	var cfeatures []string
+	if features, err := c.WebDAV().Features(path); err != nil {
+		return cfeatures, utils.NewError(c.Features, "unable to detect features", c, err)
+	} else {
+		for _, feature := range features {
+			if strings.HasPrefix(feature, "calendar-") {
+				cfeatures = append(cfeatures, feature)
+			}
+		}
+		return cfeatures, nil
+	}
+}
+
+// fetches a list of CalDAV features and checks if a certain one is supported by the server
+// returns an error if the server does not support DAV
+func (c *Client) SupportsFeature(name string, path string) (bool, error) {
+	if features, err := c.Features(path); err != nil {
+		return false, utils.NewError(c.SupportsFeature, "feature detection failed", c, err)
+	} else {
+		var test = fmt.Sprintf("calendar-%s", name)
+		for _, feature := range features {
+			if feature == test {
+				return true, nil
+			}
+		}
+		return false, nil
+	}
+}
+
+// fetches a list of CalDAV features and checks if a certain one is supported by the server
+// returns an error if the server does not support DAV
+func (c *Client) ValidateServer(path string) error {
+	if found, err := c.SupportsFeature("access", path); err != nil {
+		return utils.NewError(c.SupportsFeature, "feature detection failed", c, err)
+	} else if !found {
+		return utils.NewError(c.SupportsFeature, "calendar access feature missing", c, nil)
+	} else {
+		return nil
+	}
+}
+
+// creates a new calendar collection on a given path
+func (c *Client) MakeCalendar(path string) error {
+	if req, err := c.Server().NewRequest("MKCALENDAR", path); err != nil {
+		return utils.NewError(c.MakeCalendar, "unable to create request", c, err)
+	} else if resp, err := c.Do(req); err != nil {
+		return utils.NewError(c.MakeCalendar, "unable to execute request", c, err)
+	} else if resp.StatusCode != http.StatusCreated {
+		err := new(entities.Error)
+		resp.Decode(err)
+		msg := fmt.Sprintf("unexpected server response %s", resp.Status)
+		return utils.NewError(c.MakeCalendar, msg, c, err)
+	} else {
+		return nil
+	}
+}
+
+// creates or updates one or more events on the remote CalDAV server
+func (c *Client) PutEvents(path string, events ...*components.Event) error {
+	if len(events) <= 0 {
+		return utils.NewError(c.PutEvents, "no calendar events provided", c, nil)
+	} else if cal := components.NewCalendar(events...); events[0] == nil {
+		return utils.NewError(c.PutEvents, "icalendar event must not be nil", c, nil)
+	} else if err := c.PutCalendars(path, cal); err != nil {
+		return utils.NewError(c.PutEvents, "unable to put calendar", c, err)
+	}
+	return nil
+}
+
+// creates or updates one or more calendars on the remote CalDAV server
+func (c *Client) PutCalendars(path string, calendars ...*components.Calendar) error {
+	if req, err := c.Server().NewRequest("PUT", path, calendars); err != nil {
+		return utils.NewError(c.PutCalendars, "unable to encode request", c, err)
+	} else if resp, err := c.Do(req); err != nil {
+		return utils.NewError(c.PutCalendars, "unable to execute request", c, err)
+	} else if resp.StatusCode != http.StatusCreated && resp.StatusCode != http.StatusNoContent {
+		err := new(entities.Error)
+		resp.WebDAV().Decode(err)
+		msg := fmt.Sprintf("unexpected server response %s", resp.Status)
+		return utils.NewError(c.PutCalendars, msg, c, err)
+	}
+	return nil
+}
+
+// attempts to fetch an event on the remote CalDAV server
+func (c *Client) GetEvents(path string) ([]*components.Event, error) {
+	cal := new(components.Calendar)
+	if req, err := c.Server().NewRequest("GET", path); err != nil {
+		return nil, utils.NewError(c.GetEvents, "unable to create request", c, err)
+	} else if resp, err := c.Do(req); err != nil {
+		return nil, utils.NewError(c.GetEvents, "unable to execute request", c, err)
+	} else if resp.StatusCode != http.StatusOK {
+		err := new(entities.Error)
+		resp.WebDAV().Decode(err)
+		msg := fmt.Sprintf("unexpected server response %s", resp.Status)
+		return nil, utils.NewError(c.GetEvents, msg, c, err)
+	} else if err := resp.Decode(cal); err != nil {
+		return nil, utils.NewError(c.GetEvents, "unable to decode response", c, err)
+	} else {
+		return cal.Events, nil
+	}
+}
+
+// attempts to fetch an event on the remote CalDAV server
+func (c *Client) QueryEvents(path string, query *cent.CalendarQuery) (events []*components.Event, oerr error) {
+	ms := new(cent.Multistatus)
+	if req, err := c.Server().WebDAV().NewRequest("REPORT", path, query); err != nil {
+		oerr = utils.NewError(c.QueryEvents, "unable to create request", c, err)
+	} else if req.Http().Native().Header.Set("Depth", string(webdav.Depth1)); false {
+	} else if resp, err := c.WebDAV().Do(req); err != nil {
+		oerr = utils.NewError(c.QueryEvents, "unable to execute request", c, err)
+	} else if resp.StatusCode == http.StatusNotFound {
+		return // no events if not found
+	} else if resp.StatusCode != webdav.StatusMulti {
+		err := new(entities.Error)
+		msg := fmt.Sprintf("unexpected server response %s", resp.Status)
+		resp.Decode(err)
+		oerr = utils.NewError(c.QueryEvents, msg, c, err)
+	} else if err := resp.Decode(ms); err != nil {
+		msg := "unable to decode response"
+		oerr = utils.NewError(c.QueryEvents, msg, c, err)
+	} else {
+		for i, r := range ms.Responses {
+			for j, p := range r.PropStats {
+				if p.Prop == nil || p.Prop.CalendarData == nil {
+					continue
+				} else if cal, err := p.Prop.CalendarData.CalendarComponent(); err != nil {
+					msg := fmt.Sprintf("unable to decode property %d of response %d", j, i)
+					oerr = utils.NewError(c.QueryEvents, msg, c, err)
+					return
+				} else {
+					events = append(events, cal.Events...)
+				}
+			}
+		}
+	}
+	return
+}
+
+// executes a CalDAV request
+func (c *Client) Do(req *Request) (*Response, error) {
+	if resp, err := c.WebDAV().Do((*webdav.Request)(req)); err != nil {
+		return nil, utils.NewError(c.Do, "unable to execute CalDAV request", c, err)
+	} else {
+		return NewResponse(resp), nil
+	}
+}
+
+// creates a new client for communicating with an WebDAV server
+func NewClient(server *Server, native *http.Client) *Client {
+	return (*Client)(webdav.NewClient((*webdav.Server)(server), native))
+}
+
+// creates a new client for communicating with a WebDAV server
+// uses the default HTTP client from net/http
+func NewDefaultClient(server *Server) *Client {
+	return NewClient(server, http.DefaultClient)
+}

vendor/github.com/dolanor/caldav-go/caldav/entities/calendar_data.go

@@ -0,0 +1,51 @@
+package entities
+
+import (
+	"encoding/xml"
+	"github.com/dolanor/caldav-go/caldav/values"
+	"github.com/dolanor/caldav-go/icalendar"
+	"github.com/dolanor/caldav-go/icalendar/components"
+	"github.com/dolanor/caldav-go/utils"
+	"strings"
+)
+
+// a CalDAV calendar data object
+type CalendarData struct {
+	XMLName             xml.Name             `xml:"urn:ietf:params:xml:ns:caldav calendar-data"`
+	Component           *Component           `xml:",omitempty"`
+	RecurrenceSetLimit  *RecurrenceSetLimit  `xml:",omitempty"`
+	ExpandRecurrenceSet *ExpandRecurrenceSet `xml:",omitempty"`
+	Content             string               `xml:",chardata"`
+}
+
+func (c *CalendarData) CalendarComponent() (*components.Calendar, error) {
+	cal := new(components.Calendar)
+	if content := strings.TrimSpace(c.Content); content == "" {
+		return nil, utils.NewError(c.CalendarComponent, "no calendar data to decode", c, nil)
+	} else if err := icalendar.Unmarshal(content, cal); err != nil {
+		return nil, utils.NewError(c.CalendarComponent, "decoding calendar data failed", c, err)
+	} else {
+		return cal, nil
+	}
+}
+
+// an iCalendar specifier for returned calendar data
+type Component struct {
+	XMLName    xml.Name        `xml:"urn:ietf:params:xml:ns:caldav comp"`
+	Properties []*PropertyName `xml:",omitempty"`
+	Components []*Component    `xml:",omitempty"`
+}
+
+// used to restrict recurring event data to a particular time range
+type RecurrenceSetLimit struct {
+	XMLName   xml.Name         `xml:"urn:ietf:params:xml:ns:caldav limit-recurrence-set"`
+	StartTime *values.DateTime `xml:"start,attr"`
+	EndTime   *values.DateTime `xml:"end,attr"`
+}
+
+// used to expand recurring events into individual calendar event data
+type ExpandRecurrenceSet struct {
+	XMLName   xml.Name         `xml:"urn:ietf:params:xml:ns:caldav expand"`
+	StartTime *values.DateTime `xml:"start,attr"`
+	EndTime   *values.DateTime `xml:"end,attr"`
+}

vendor/github.com/dolanor/caldav-go/caldav/entities/calendar_query.go

@@ -0,0 +1,59 @@
+package entities
+
+import (
+	"encoding/xml"
+	"github.com/dolanor/caldav-go/caldav/values"
+	"github.com/dolanor/caldav-go/utils"
+	"github.com/dolanor/caldav-go/webdav/entities"
+	"time"
+)
+
+// a CalDAV calendar query object
+type CalendarQuery struct {
+	XMLName xml.Name          `xml:"urn:ietf:params:xml:ns:caldav calendar-query"`
+	Prop    *Prop             `xml:",omitempty"`
+	AllProp *entities.AllProp `xml:",omitempty"`
+	Filter  *Filter           `xml:",omitempty"`
+}
+
+// creates a new CalDAV query for iCalendar events from a particular time range
+func NewEventRangeQuery(start, end time.Time) (*CalendarQuery, error) {
+
+	var err error
+	var dtstart, dtend *values.DateTime
+	if dtstart, err = values.NewDateTime("start", start); err != nil {
+		return nil, utils.NewError(NewEventRangeQuery, "unable to encode start time", start, err)
+	} else if dtend, err = values.NewDateTime("end", end); err != nil {
+		return nil, utils.NewError(NewEventRangeQuery, "unable to encode end time", end, err)
+	}
+
+	// construct the query object
+	query := new(CalendarQuery)
+
+	// request all calendar data
+	query.Prop = new(Prop)
+	query.Prop.CalendarData = new(CalendarData)
+
+	// expand recurring events
+	query.Prop.CalendarData.ExpandRecurrenceSet = new(ExpandRecurrenceSet)
+	query.Prop.CalendarData.ExpandRecurrenceSet.StartTime = dtstart
+	query.Prop.CalendarData.ExpandRecurrenceSet.EndTime = dtend
+
+	// filter down calendar data to only iCalendar data
+	query.Filter = new(Filter)
+	query.Filter.ComponentFilter = new(ComponentFilter)
+	query.Filter.ComponentFilter.Name = values.CalendarComponentName
+
+	// filter down iCalendar data to only events
+	query.Filter.ComponentFilter.ComponentFilter = new(ComponentFilter)
+	query.Filter.ComponentFilter.ComponentFilter.Name = values.EventComponentName
+
+	// filter down the events to only those that fall within the time range
+	query.Filter.ComponentFilter.ComponentFilter.TimeRange = new(TimeRange)
+	query.Filter.ComponentFilter.ComponentFilter.TimeRange.StartTime = dtstart
+	query.Filter.ComponentFilter.ComponentFilter.TimeRange.EndTime = dtend
+
+	// return the event query
+	return query, nil
+
+}

vendor/github.com/dolanor/caldav-go/caldav/entities/filter.go

@@ -0,0 +1,62 @@
+package entities
+
+import (
+	"encoding/xml"
+	"github.com/dolanor/caldav-go/caldav/values"
+	"github.com/dolanor/caldav-go/icalendar/properties"
+)
+
+// a CalDAV query filter entity
+type Filter struct {
+	XMLName         xml.Name         `xml:"urn:ietf:params:xml:ns:caldav filter"`
+	ComponentFilter *ComponentFilter `xml:",omitempty"`
+}
+
+// used to filter down calendar components, such as VCALENDAR > VEVENT
+type ComponentFilter struct {
+	XMLName         xml.Name             `xml:"urn:ietf:params:xml:ns:caldav comp-filter"`
+	Name            values.ComponentName `xml:"name,attr"`
+	ComponentFilter *ComponentFilter     `xml:",omitempty"`
+	TimeRange       *TimeRange           `xml:",omitempty"`
+	PropertyFilter  *PropertyFilter      `xml:",omitempty"`
+	ParameterFilter *ParameterFilter     `xml:",omitempty"`
+}
+
+// used to restrict component filters to a particular time range
+type TimeRange struct {
+	XMLName   xml.Name         `xml:"urn:ietf:params:xml:ns:caldav time-range"`
+	StartTime *values.DateTime `xml:"start,attr"`
+	EndTime   *values.DateTime `xml:"end,attr"`
+}
+
+// used to restrict component filters to a property value
+type PropertyFilter struct {
+	XMLName         xml.Name                `xml:"urn:ietf:params:xml:ns:caldav prop-filter"`
+	Name            properties.PropertyName `xml:"name,attr"`
+	TextMatch       *TextMatch              `xml:",omitempty"`
+	ParameterFilter *ParameterFilter        `xml:",omitempty"`
+}
+
+// used to restrict component filters to a parameter value
+type ParameterFilter struct {
+	XMLName   xml.Name                 `xml:"urn:ietf:params:xml:ns:caldav param-filter"`
+	Name      properties.ParameterName `xml:"name,attr"`
+	TextMatch *TextMatch               `xml:",omitempty"`
+}
+
+// used to match properties by text value
+type TextMatch struct {
+	XMLName         xml.Name             `xml:"urn:ietf:params:xml:ns:caldav text-match"`
+	Collation       values.TextCollation `xml:"collation,attr,omitempty"`
+	NegateCondition values.HumanBoolean  `xml:"attr,negate-condition,omitempty"`
+	Content         string               `xml:",innerxml"`
+}
+
+// creates a new CalDAV property value matcher
+func NewPropertyMatcher(name properties.PropertyName, content string) *PropertyFilter {
+	pf := new(PropertyFilter)
+	pf.Name = name
+	pf.TextMatch = new(TextMatch)
+	pf.TextMatch.Content = content
+	return pf
+}

vendor/github.com/dolanor/caldav-go/caldav/entities/multistatus.go

@@ -0,0 +1,23 @@
+package entities
+
+import "encoding/xml"
+
+// metadata about a property
+type PropStat struct {
+	XMLName xml.Name `xml:"propstat"`
+	Status  string   `xml:"status"`
+	Prop    *Prop    `xml:",omitempty"`
+}
+
+// a multistatus response entity
+type Response struct {
+	XMLName   xml.Name    `xml:"response"`
+	Href      string      `xml:"href"`
+	PropStats []*PropStat `xml:"propstat,omitempty"`
+}
+
+// a request to find properties on an an entity or collection
+type Multistatus struct {
+	XMLName   xml.Name    `xml:"DAV: multistatus"`
+	Responses []*Response `xml:"response,omitempty"`
+}

vendor/github.com/dolanor/caldav-go/caldav/entities/prop.go

@@ -0,0 +1,23 @@
+package entities
+
+import (
+	"encoding/xml"
+	"github.com/dolanor/caldav-go/webdav/entities"
+)
+
+// a CalDAV Property resource
+type Prop struct {
+	XMLName        xml.Name               `xml:"DAV: prop"`
+	GetContentType string                 `xml:"getcontenttype,omitempty"`
+	DisplayName    string                 `xml:"displayname,omitempty"`
+	CalendarData   *CalendarData          `xml:",omitempty"`
+	ResourceType   *entities.ResourceType `xml:",omitempty"`
+	CTag           string                 `xml:"http://calendarserver.org/ns/ getctag,omitempty"`
+	ETag           string                 `xml:"http://calendarserver.org/ns/ getetag,omitempty"`
+}
+
+// used to restrict properties returned in calendar data
+type PropertyName struct {
+	XMLName xml.Name `xml:"urn:ietf:params:xml:ns:caldav prop"`
+	Name    string   `xml:"name,attr"`
+}

vendor/github.com/dolanor/caldav-go/caldav/request.go

@@ -0,0 +1,56 @@
+package caldav
+
+import (
+	"bytes"
+	"github.com/dolanor/caldav-go/http"
+	"github.com/dolanor/caldav-go/icalendar"
+	"github.com/dolanor/caldav-go/utils"
+	"github.com/dolanor/caldav-go/webdav"
+	"io"
+	"io/ioutil"
+	"log"
+	"strings"
+)
+
+var _ = log.Print
+
+// an CalDAV request object
+type Request webdav.Request
+
+// downcasts the request to the WebDAV interface
+func (r *Request) WebDAV() *webdav.Request {
+	return (*webdav.Request)(r)
+}
+
+// creates a new CalDAV request object
+func NewRequest(method string, urlstr string, icaldata ...interface{}) (*Request, error) {
+	if buffer, err := icalToReadCloser(icaldata...); err != nil {
+		return nil, utils.NewError(NewRequest, "unable to encode icalendar data", icaldata, err)
+	} else if r, err := http.NewRequest(method, urlstr, buffer); err != nil {
+		return nil, utils.NewError(NewRequest, "unable to create request", urlstr, err)
+	} else {
+		if buffer != nil {
+			// set the content type to XML if we have a body
+			r.Native().Header.Set("Content-Type", "text/calendar; charset=UTF-8")
+		}
+		return (*Request)(r), nil
+	}
+}
+
+func icalToReadCloser(icaldata ...interface{}) (io.ReadCloser, error) {
+	var buffer []string
+	for _, icaldatum := range icaldata {
+		if encoded, err := icalendar.Marshal(icaldatum); err != nil {
+			return nil, utils.NewError(icalToReadCloser, "unable to encode as icalendar data", icaldatum, err)
+		} else {
+			//			log.Printf("OUT: %+v", encoded)
+			buffer = append(buffer, encoded)
+		}
+	}
+	if len(buffer) > 0 {
+		var encoded = strings.Join(buffer, "\n")
+		return ioutil.NopCloser(bytes.NewBuffer([]byte(encoded))), nil
+	} else {
+		return nil, nil
+	}
+}

vendor/github.com/dolanor/caldav-go/caldav/response.go

@@ -0,0 +1,40 @@
+package caldav
+
+import (
+	"github.com/dolanor/caldav-go/icalendar"
+	"github.com/dolanor/caldav-go/utils"
+	"github.com/dolanor/caldav-go/webdav"
+	"io/ioutil"
+	"log"
+)
+
+var _ = log.Print
+
+// a WebDAV response object
+type Response webdav.Response
+
+// downcasts the response to the WebDAV interface
+func (r *Response) WebDAV() *webdav.Response {
+	return (*webdav.Response)(r)
+}
+
+// decodes a CalDAV iCalendar response into the provided interface
+func (r *Response) Decode(into interface{}) error {
+	if body := r.Body; body == nil {
+		return nil
+	} else if encoded, err := ioutil.ReadAll(body); err != nil {
+		return utils.NewError(r.Decode, "unable to read response body", r, err)
+	} else {
+		// log.Printf("IN: %+v", string(encoded))
+		if err := icalendar.Unmarshal(string(encoded), into); err != nil {
+			return utils.NewError(r.Decode, "unable to decode response body", r, err)
+		} else {
+			return nil
+		}
+	}
+}
+
+// creates a new WebDAV response object
+func NewResponse(response *webdav.Response) *Response {
+	return (*Response)(response)
+}

vendor/github.com/dolanor/caldav-go/caldav/server.go

@@ -0,0 +1,30 @@
+package caldav
+
+import (
+	"github.com/dolanor/caldav-go/utils"
+	"github.com/dolanor/caldav-go/webdav"
+)
+
+// a server that accepts CalDAV requests
+type Server webdav.Server
+
+// NewServer creates a reference to a CalDAV server.
+// host is the url to access the server, stopping at the port:
+// https://user:password@host:port/
+func NewServer(host string) (*Server, error) {
+	if s, err := webdav.NewServer(host); err != nil {
+		return nil, utils.NewError(NewServer, "unable to create WebDAV server", host, err)
+	} else {
+		return (*Server)(s), nil
+	}
+}
+
+// downcasts the server to the WebDAV interface
+func (s *Server) WebDAV() *webdav.Server {
+	return (*webdav.Server)(s)
+}
+
+// creates a new CalDAV request object
+func (s *Server) NewRequest(method string, path string, icaldata ...interface{}) (*Request, error) {
+	return NewRequest(method, s.WebDAV().Http().AbsUrlStr(path), icaldata...)
+}

vendor/github.com/dolanor/caldav-go/caldav/values/component_name.go

@@ -0,0 +1,8 @@
+package values
+
+type ComponentName string
+
+const (
+	CalendarComponentName ComponentName = "VCALENDAR"
+	EventComponentName                  = "VEVENT"
+)

vendor/github.com/dolanor/caldav-go/caldav/values/datetime.go

@@ -0,0 +1,31 @@
+package values
+
+import (
+	"encoding/xml"
+	"errors"
+	"github.com/dolanor/caldav-go/icalendar/values"
+	"time"
+)
+
+// a representation of a date and time for iCalendar
+type DateTime struct {
+	name string
+	t    time.Time
+}
+
+// creates a new caldav datetime representation, must be in UTC
+func NewDateTime(name string, t time.Time) (*DateTime, error) {
+	if t.Location() != time.UTC {
+		return nil, errors.New("CalDAV datetime must be in UTC")
+	} else {
+		return &DateTime{name: name, t: t.Truncate(time.Second)}, nil
+	}
+}
+
+// encodes the datetime value for the iCalendar specification
+func (d *DateTime) MarshalXMLAttr(name xml.Name) (xml.Attr, error) {
+	layout := values.UTCDateTimeFormatString
+	value := d.t.Format(layout)
+	attr := xml.Attr{Name: name, Value: value}
+	return attr, nil
+}

vendor/github.com/dolanor/caldav-go/caldav/values/human_boolean.go

@@ -0,0 +1,8 @@
+package values
+
+type HumanBoolean string
+
+const (
+	YesHumanBoolean HumanBoolean = "yes"
+	NoHumanBoolean               = "no"
+)

vendor/github.com/dolanor/caldav-go/caldav/values/text_collation.go

@@ -0,0 +1,8 @@
+package values
+
+type TextCollation string
+
+const (
+	OctetTextCollation    TextCollation = "i;octet"
+	ASCIICaseMapCollation               = "i;ascii-casemap"
+)