vendoring and caldav

vendor/github.com/samedi/caldav-go/.gitignore

@@ -0,0 +1,2 @@
+test-data/
+vendor

vendor/github.com/samedi/caldav-go/CHANGELOG.md

@@ -0,0 +1,69 @@
+# CHANGELOG
+
+v3.0.0
+-----------
+2017-08-01  Daniel Ferraz  <d.ferrazm@gmail.com>
+
+Main change:
+
+Add two ways to get resource from the storage: shallow or not.
+
+`data.GetShallowResource`: means that, if it's collection resource, it will not include its child VEVENTs in the ICS data.
+This is used throughout the palces where the children dont matter.
+
+`data.GetResource`: means that the child VEVENTs will be included in the returned ICS content data for collection resources.
+This is used then sending a GET request to fetch a specific resource and expecting its full ICS data in response.
+
+Other changes:
+
+* Removed the need to pass the useless `writer http.ResponseWriter` parameter when calling the `caldav.HandleRequest` function.
+* Added a `caldav.HandleRequestWithStorage` function that makes it easy to pass a custom storage to be used and handle the request with a single function call.
+
+
+v2.0.0
+-----------
+2017-05-10  Daniel Ferraz  <d.ferrazm@gmail.com>
+
+All commits squashed and LICENSE updated to release as OSS in github.
+Feature-wise it remains the same.
+
+
+v1.0.1
+-----------
+2017-01-25  Daniel Ferraz  <d.ferrazm@gmail.com>
+
+Escape the contents in `<calendar-data>` and `<displayname>` in the `multistatus` XML responses. Fixing possible bugs
+related to having special characters (e.g. &) in the XML multistatus responses that would possible break the encoding.
+
+v1.0.0
+-----------
+2017-01-18  Daniel Ferraz  <d.ferrazm@gmail.com>
+
+Main feature:
+
+* Handles the `Prefer` header on PROPFIND and REPORT requests (defined in this [draft/proposal](https://tools.ietf.org/html/draft-murchison-webdav-prefer-05)). Useful to shrink down possible big and verbose responses when the client demands. Ex: current iOS calendar client uses this feature on its PROPFIND requests.
+
+Other changes:
+
+* Added the `handlers.Response` to allow clients of the lib to interact with the generated response before being written/sent back to the client.
+* Added `GetResourcesByFilters` to the storage interface to allow filtering of resources in the storage level. Useful to provide an already filtered and smaller resource collection to a the REPORT handler when dealing with a filtered REPORT request.
+* Added `GetResourcesByList` to the storage interface to fetch a set a of resources based on a set of paths. Useful to provide, in one call, the correct resource collection to the REPORT handler when dealing with a REPORT request for specific `hrefs`.
+* Remove useless `IsResourcePresent` from the storage interface.
+
+
+v0.1.0
+-----------
+2016-09-23  Daniel Ferraz  <d.ferrazm@gmail.com>
+
+This version implements:
+
+* Allow: "GET, HEAD, PUT, DELETE, OPTIONS, PROPFIND, REPORT"
+* DAV: "1, 3, calendar-access"
+* Also only handles the following components: `VCALENDAR`, `VEVENT`
+
+Currently unsupported:
+
+* Components `VTODO`, `VJOURNAL`, `VFREEBUSY`
+* `VEVENT` recurrences
+* Resource locking
+* User authentication

vendor/github.com/samedi/caldav-go/LICENSE

@@ -0,0 +1,20 @@
+Copyright 2017 samedi GmbH
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NON INFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

vendor/github.com/samedi/caldav-go/README.md

@@ -0,0 +1,140 @@
+# go CalDAV
+
+This is a Go lib that aims to implement the CalDAV specification ([RFC4791]). It allows the quick implementation of a CalDAV server in Go. Basically, it provides the request handlers that will handle the several CalDAV HTTP requests, fetch the appropriate resources, build and return the responses.
+
+### How to install
+
+```
+go get github.com/samedi/caldav-go
+```
+
+### Dependencies
+
+For dependency management, `glide` is used.
+
+```bash
+# install glide (once!)
+curl https://glide.sh/get | sh
+
+# install dependencies
+glide install
+```
+
+### How to use it
+
+The easiest way to quickly implement a CalDAV server is by just using the lib's request handler. Example:
+
+```go
+package mycaldav
+
+import (
+  "net/http"
+  "github.com/samedi/caldav-go"
+)
+
+func runServer() {
+  http.HandleFunc(PATH, caldav.RequestHandler)
+  http.ListenAndServe(PORT, nil)
+}
+```
+
+With that, all the HTTP requests (GET, PUT, REPORT, PROPFIND, etc) will be handled and responded by the `caldav` handler. In case of any HTTP methods not supported by the lib, a `501 Not Implemented` response will be returned.
+
+In case you want more flexibility to handle the requests, e.g., if you wanted to access the generated response before being sent back to the caller, you could do like:
+
+```go
+package mycaldav
+
+import (
+  "net/http"
+  "github.com/samedi/caldav-go"
+)
+
+func runServer() {
+  http.HandleFunc(PATH, myHandler)
+  http.ListenAndServe(PORT, nil)
+}
+
+func myHandler(writer http.ResponseWriter, request *http.Request) {
+  response := caldav.HandleRequest(writer, request)
+  // ... do something with the `response` ...
+  // the response is written with the current `http.ResponseWriter` and ready to be sent back
+  response.Write(writer)
+}
+```
+
+### Storage & Resources
+
+The storage is where the caldav resources are stored. To interact with that, the caldav lib needs only a type that conforms with the  `data.Storage` interface to operate on top of the storage. Basically, this interface defines all the CRUD functions to work on top of the resources. With that, resources can be stored anywhere: in the filesystem, in the cloud, database, etc. As long as the used storage implements all the required storage interface functions, the caldav lib will work fine.
+
+For example, we could use the following dummy storage implementation:
+
+```go
+type DummyStorage struct{
+}
+
+func (d *DummyStorage) GetResources(rpath string, withChildren bool) ([]Resource, error) {
+  return []Resource{}, nil
+}
+
+func (d *DummyStorage) GetResourcesByFilters(rpath string, filters *ResourceFilter) ([]Resource, error) {
+  return []Resource{}, nil
+}
+
+func (d *DummyStorage) GetResourcesByList(rpaths []string) ([]Resource, error) {
+  return []Resource{}, nil
+}
+
+func (d *DummyStorage) GetResource(rpath string) (*Resource, bool, error) {
+  return nil, false, nil
+}
+
+func (d *DummyStorage) GetShallowResource(rpath string) (*Resource, bool, error) {
+  return nil, false, nil
+}
+
+func (d *DummyStorage) CreateResource(rpath, content string) (*Resource, error) {
+  return nil, nil
+}
+
+func (d *DummyStorage) UpdateResource(rpath, content string) (*Resource, error) {
+  return nil, nil
+}
+
+func (d *DummyStorage) DeleteResource(rpath string) error {
+  return nil
+}
+```
+
+Then we just need to tell the caldav lib to use our dummy storage:
+
+```go
+dummyStg := new(DummyStorage)
+caldav.SetupStorage(dummyStg)
+```
+
+All the CRUD operations on resources will then be forwarded to our dummy storage.
+
+The default storage used (if none is explicitly set) is the `data.FileStorage` which deals with resources as files in the File System.
+
+The resources can be of two types: collection and non-collection. A collection resource is basically a resource that has children resources, but does not have any data content. A non-collection resource is a resource that does not have children, but has data. In the case of a file storage, collections correspond to directories and non-collection to plain files. The data of a caldav resource is all the info that shows up in the calendar client, in the [iCalendar](https://en.wikipedia.org/wiki/ICalendar) format.
+
+### Features
+
+Please check the **CHANGELOG** to see specific features that are currently implemented.
+
+### Contributing and testing
+
+Everyone is welcome to contribute. Please raise an issue or pull request accordingly.
+
+To run the tests:
+
+```
+./test.sh
+```
+
+### License
+
+MIT License.
+
+[RFC4791]: https://tools.ietf.org/html/rfc4791

vendor/github.com/samedi/caldav-go/config.go

@@ -0,0 +1,14 @@
+package caldav
+
+import (
+  "github.com/samedi/caldav-go/data"
+  "github.com/samedi/caldav-go/global"
+)
+
+func SetupStorage(stg data.Storage) {
+  global.Storage = stg
+}
+
+func SetupUser(username string) {
+  global.User = &data.CalUser{username}
+}

vendor/github.com/samedi/caldav-go/data/filters.go

@@ -0,0 +1,362 @@
+package data
+
+import (
+  "log"
+  "time"
+  "strings"
+  "errors"
+  "github.com/beevik/etree"
+
+  "github.com/samedi/caldav-go/lib"
+)
+
+// ================ FILTERS ==================
+// Filters are a set of rules used to retrieve a range of resources. It is used primarily
+// on REPORT requests and is described in details here (RFC4791#7.8).
+
+const (
+  TAG_FILTER = "filter"
+  TAG_COMP_FILTER = "comp-filter"
+  TAG_PROP_FILTER = "prop-filter"
+  TAG_PARAM_FILTER = "param-filter"
+  TAG_TIME_RANGE = "time-range"
+  TAG_TEXT_MATCH = "text-match"
+  TAG_IS_NOT_DEFINED = "is-not-defined"
+
+  // from the RFC, the time range `start` and `end` attributes MUST be in UTC and in this specific format
+  FILTER_TIME_FORMAT = "20060102T150405Z"
+)
+
+type ResourceFilter struct {
+  name       string
+  text       string
+  attrs      map[string]string
+  children   []ResourceFilter // collection of child filters.
+  etreeElem  *etree.Element // holds the parsed XML node/tag as an `etree` element.
+}
+
+// This function creates a new filter object from a piece of XML string.
+func ParseResourceFilters(xml string) (*ResourceFilter, error) {
+  doc := etree.NewDocument()
+  if err := doc.ReadFromString(xml); err != nil {
+    log.Printf("ERROR: Could not parse filter from XML string. XML:\n%s", xml)
+    return new(ResourceFilter), err
+  }
+
+  // Right now we're searching for a <filter> tag to initialize the filter struct from it.
+  // It SHOULD be a valid XML CALDAV:filter tag (RFC4791#9.7). We're not checking namespaces yet.
+  // TODO: check for XML namespaces and restrict it to accept only CALDAV:filter tag.
+  elem := doc.FindElement("//" + TAG_FILTER)
+  if elem == nil {
+    log.Printf("WARNING: The filter XML should contain a <%s> element. XML:\n%s", TAG_FILTER, xml)
+    return new(ResourceFilter), errors.New("invalid XML filter")
+  }
+
+  filter := newFilterFromEtreeElem(elem)
+  return &filter, nil
+}
+
+func newFilterFromEtreeElem(elem *etree.Element) ResourceFilter {
+  // init filter from etree element
+  filter := ResourceFilter{
+    name:      elem.Tag,
+    text:      strings.TrimSpace(elem.Text()),
+    etreeElem: elem,
+    attrs:     make(map[string]string),
+  }
+
+  // set attributes
+  for _, attr := range elem.Attr {
+    filter.attrs[attr.Key] = attr.Value
+  }
+
+  return filter
+}
+
+func (f *ResourceFilter) Attr(attrName string) string {
+  return f.attrs[attrName]
+}
+
+func (f *ResourceFilter) TimeAttr(attrName string) *time.Time {
+
+
+  t, err := time.Parse(FILTER_TIME_FORMAT, f.attrs[attrName])
+  if err != nil {
+    return nil
+  }
+
+  return &t
+}
+
+// GetTimeRangeFilter checks if the current filter has a child "time-range" filter and
+// returns it (wrapped in a `ResourceFilter` type). It returns nil if the current filter does
+// not contain any "time-range" filter.
+func (f *ResourceFilter) GetTimeRangeFilter() *ResourceFilter {
+  return f.findChild(TAG_TIME_RANGE, true)
+}
+
+func (f *ResourceFilter) Match(target ResourceInterface) bool {
+  if f.name == TAG_FILTER {
+    return f.rootFilterMatch(target)
+  }
+
+  return false
+}
+
+func (f *ResourceFilter) rootFilterMatch(target ResourceInterface) bool {
+  if f.isEmpty() {
+    return false
+  }
+
+  return f.rootChildrenMatch(target)
+}
+
+// checks if all the root's child filters match the target resource
+func (f *ResourceFilter) rootChildrenMatch(target ResourceInterface) bool {
+  scope := []string{}
+
+  for _, child := range f.getChildren() {
+    // root filters only accept comp filters as children
+    if child.name != TAG_COMP_FILTER || !child.compMatch(target, scope) {
+      return false
+    }
+  }
+
+  return true
+}
+
+// See RFC4791-9.7.1.
+func (f *ResourceFilter) compMatch(target ResourceInterface, scope []string) bool {
+  targetComp := target.ComponentName()
+  compName   := f.attrs["name"]
+
+  if f.isEmpty() {
+    // Point #1 of RFC4791#9.7.1
+    return compName == targetComp
+  } else if f.contains(TAG_IS_NOT_DEFINED) {
+    // Point #2 of RFC4791#9.7.1
+    return compName != targetComp
+  } else {
+    // check each child of the current filter if they all match.
+    childrenScope := append(scope, compName)
+    return f.compChildrenMatch(target, childrenScope)
+  }
+}
+
+// checks if all the comp's child filters match the target resource
+func (f *ResourceFilter) compChildrenMatch(target ResourceInterface, scope []string) bool {
+  for _, child := range f.getChildren() {
+    var match bool
+
+    switch child.name {
+    case TAG_TIME_RANGE:
+      // Point #3 of RFC4791#9.7.1
+      match = child.timeRangeMatch(target)
+    case TAG_PROP_FILTER:
+      // Point #4 of RFC4791#9.7.1
+      match = child.propMatch(target, scope)
+    case TAG_COMP_FILTER:
+      // Point #4 of RFC4791#9.7.1
+      match = child.compMatch(target, scope)
+    }
+
+    if !match {
+      return false
+    }
+  }
+
+  return true
+}
+
+// See RFC4791-9.9
+func (f *ResourceFilter) timeRangeMatch(target ResourceInterface) bool {
+  startAttr := f.attrs["start"]
+  endAttr   := f.attrs["end"]
+
+  // at least one of the two MUST be present
+  if startAttr == "" && endAttr == "" {
+    // if both of them are missing, return false
+    return false
+  } else if startAttr == "" {
+    // if missing only the `start`, set it open ended to the left
+    startAttr = "00010101T000000Z"
+  } else if endAttr == "" {
+    // if missing only the `end`, set it open ended to the right
+    endAttr = "99991231T235959Z"
+  }
+
+  // The logic below is only applicable for VEVENT components. So
+  // we return false if the resource is not a VEVENT component.
+  if target.ComponentName() != lib.VEVENT {
+    return false
+  }
+
+  rangeStart, err := time.Parse(FILTER_TIME_FORMAT, startAttr)
+  if err != nil {
+    log.Printf("ERROR: Could not parse start time in time-range filter.\nError: %s.\nStart attr: %s", err, startAttr)
+    return false
+  }
+
+  rangeEnd, err := time.Parse(FILTER_TIME_FORMAT, endAttr)
+  if err != nil {
+    log.Printf("ERROR: Could not parse end time in time-range filter.\nError: %s.\nEnd attr: %s", err, endAttr)
+    return false
+  }
+
+  // the following logic is inferred from the rules table for VEVENT components,
+  // described in RFC4791-9.9.
+  overlapRange := func(dtStart, dtEnd, rangeStart, rangeEnd time.Time) bool {
+    if dtStart.Equal(dtEnd) {
+      // Lines 3 and 4 of the table deal when the DTSTART and DTEND dates are equals.
+      // In this case we use the rule: (start <= DTSTART && end > DTSTART)
+      return (rangeStart.Before(dtStart) || rangeStart.Equal(dtStart)) && rangeEnd.After(dtStart)
+    } else {
+      // Lines 1, 2 and 6 of the table deal when the DTSTART and DTEND dates are different.
+      // In this case we use the rule: (start < DTEND && end > DTSTART)
+      return rangeStart.Before(dtEnd) && rangeEnd.After(dtStart)
+    }
+  }
+
+  // first we check each of the target recurrences (if any).
+  for _, recurrence := range target.Recurrences() {
+    // if any of them overlap the filter range, we return true right away
+    if overlapRange(recurrence.StartTime, recurrence.EndTime, rangeStart, rangeEnd) {
+      return true
+    }
+  }
+
+  // if none of the recurrences match, we just return if the actual
+  // resource's `start` and `end` times match the filter range
+  return overlapRange(target.StartTimeUTC(), target.EndTimeUTC(), rangeStart, rangeEnd)
+}
+
+// See RFC4791-9.7.2.
+func (f *ResourceFilter) propMatch(target ResourceInterface, scope []string) bool {
+  propName := f.attrs["name"]
+  propPath := append(scope, propName)
+
+  if f.isEmpty() {
+    // Point #1 of RFC4791#9.7.2
+    return target.HasProperty(propPath...)
+  } else if f.contains(TAG_IS_NOT_DEFINED) {
+    // Point #2 of RFC4791#9.7.2
+    return !target.HasProperty(propPath...)
+  } else {
+    // check each child of the current filter if they all match.
+    return f.propChildrenMatch(target, propPath)
+  }
+}
+
+// checks if all the prop's child filters match the target resource
+func (f *ResourceFilter) propChildrenMatch(target ResourceInterface, propPath []string) bool {
+  for _, child := range f.getChildren() {
+    var match bool
+
+    switch child.name {
+    case TAG_TIME_RANGE:
+      // Point #3 of RFC4791#9.7.2
+      // TODO: this point is not very clear on how to match time range against properties.
+      // So we're returning `false` in the meantime.
+      match = false
+    case TAG_TEXT_MATCH:
+      // Point #4 of RFC4791#9.7.2
+      propText := target.GetPropertyValue(propPath...)
+      match = child.textMatch(propText)
+    case TAG_PARAM_FILTER:
+      // Point #4 of RFC4791#9.7.2
+      match = child.paramMatch(target, propPath)
+    }
+
+    if !match {
+      return false
+    }
+  }
+
+  return true
+}
+
+// See RFC4791-9.7.3
+func (f *ResourceFilter) paramMatch(target ResourceInterface, parentPropPath []string) bool {
+  paramName := f.attrs["name"]
+  paramPath := append(parentPropPath, paramName)
+
+  if f.isEmpty() {
+    // Point #1 of RFC4791#9.7.3
+    return target.HasPropertyParam(paramPath...)
+  } else if f.contains(TAG_IS_NOT_DEFINED) {
+    // Point #2 of RFC4791#9.7.3
+    return !target.HasPropertyParam(paramPath...)
+  } else {
+    child := f.getChildren()[0]
+    // param filters can also have (only-one) nested text-match filter
+    if child.name == TAG_TEXT_MATCH {
+      paramValue := target.GetPropertyParamValue(paramPath...)
+      return child.textMatch(paramValue)
+    }
+  }
+
+  return false
+}
+
+// See RFC4791-9.7.5
+func (f *ResourceFilter) textMatch(targetText string) bool {
+  // TODO: collations are not being considered/supported yet.
+  // Texts are lowered to be case-insensitive, almost as the "i;ascii-casemap" value.
+
+  targetText = strings.ToLower(targetText)
+  expectedSubstr := strings.ToLower(f.text)
+
+  match := strings.Contains(targetText, expectedSubstr)
+
+  if f.attrs["negate-condition"] == "yes" {
+    return !match
+  }
+
+  return match
+}
+
+func (f *ResourceFilter) isEmpty() bool {
+  return len(f.getChildren()) == 0 && f.text == ""
+}
+
+func (f *ResourceFilter) contains(filterName string) bool {
+  if f.findChild(filterName, false) != nil {
+    return true
+  }
+
+  return false
+}
+
+func (f *ResourceFilter) findChild(filterName string, dig bool) *ResourceFilter {
+  for _, child := range f.getChildren() {
+    if child.name == filterName {
+      return &child
+    }
+
+    if !dig {
+      continue
+    }
+
+    dugChild := child.findChild(filterName, true)
+
+    if dugChild != nil {
+      return dugChild
+    }
+  }
+
+  return nil
+}
+
+// lazy evaluation of the child filters
+func (f *ResourceFilter) getChildren() []ResourceFilter {
+  if f.children == nil {
+    f.children = []ResourceFilter{}
+
+    for _, childElem := range f.etreeElem.ChildElements() {
+      childFilter := newFilterFromEtreeElem(childElem)
+      f.children = append(f.children, childFilter)
+    }
+  }
+
+  return f.children
+}

vendor/github.com/samedi/caldav-go/data/resource.go

@@ -0,0 +1,277 @@
+package data
+
+import (
+  "os"
+  "fmt"
+  "log"
+  "time"
+  "strings"
+  "strconv"
+  "io/ioutil"
+
+  "github.com/laurent22/ical-go/ical"
+
+  "github.com/samedi/caldav-go/lib"
+  "github.com/samedi/caldav-go/files"
+)
+
+type ResourceInterface interface {
+  ComponentName() string
+  StartTimeUTC() time.Time
+  EndTimeUTC() time.Time
+  Recurrences() []ResourceRecurrence
+  HasProperty(propPath... string) bool
+  GetPropertyValue(propPath... string) string
+  HasPropertyParam(paramName... string) bool
+  GetPropertyParamValue(paramName... string) string
+}
+
+type ResourceAdapter interface {
+  IsCollection() bool
+  CalculateEtag() string
+  GetContent() string
+  GetContentSize() int64
+  GetModTime() time.Time
+}
+
+type ResourceRecurrence struct {
+  StartTime time.Time
+  EndTime   time.Time
+}
+
+type Resource struct {
+  Name string
+  Path string
+
+  pathSplit []string
+  adapter ResourceAdapter
+
+  emptyTime time.Time
+}
+
+func NewResource(resPath string, adp ResourceAdapter) Resource {
+  pClean  := lib.ToSlashPath(resPath)
+  pSplit  := strings.Split(strings.Trim(pClean, "/"), "/")
+
+  return Resource {
+    Name: pSplit[len(pSplit) - 1],
+    Path: pClean,
+    pathSplit: pSplit,
+    adapter: adp,
+  }
+}
+
+func (r *Resource) IsCollection() bool {
+  return r.adapter.IsCollection()
+}
+
+func (r *Resource) IsPrincipal() bool {
+  return len(r.pathSplit) <= 1
+}
+
+func (r *Resource) ComponentName() string {
+  if r.IsCollection() {
+    return lib.VCALENDAR
+  } else {
+    return lib.VEVENT
+  }
+}
+
+func (r *Resource) StartTimeUTC() time.Time {
+  vevent := r.icalVEVENT()
+  dtstart := vevent.PropDate(ical.DTSTART, r.emptyTime)
+
+  if dtstart == r.emptyTime {
+    log.Printf("WARNING: The property DTSTART was not found in the resource's ical data.\nResource path: %s", r.Path)
+    return r.emptyTime
+  }
+
+  return dtstart.UTC()
+}
+
+func (r *Resource) EndTimeUTC() time.Time {
+  vevent := r.icalVEVENT()
+  dtend := vevent.PropDate(ical.DTEND, r.emptyTime)
+
+  // when the DTEND property is not present, we just add the DURATION (if any) to the DTSTART
+  if dtend == r.emptyTime {
+    duration := vevent.PropDuration(ical.DURATION)
+    dtend = r.StartTimeUTC().Add(duration)
+  }
+
+  return dtend.UTC()
+}
+
+func (r *Resource) Recurrences() []ResourceRecurrence {
+  // TODO: Implement. This server does not support ical recurrences yet. We just return an empty array.
+  return []ResourceRecurrence{}
+}
+
+func (r *Resource) HasProperty(propPath... string) bool {
+  return r.GetPropertyValue(propPath...) != ""
+}
+
+func (r *Resource) GetPropertyValue(propPath... string) string {
+  if propPath[0] == ical.VCALENDAR {
+    propPath = propPath[1:]
+  }
+
+  prop, _ := r.icalendar().DigProperty(propPath...)
+  return prop
+}
+
+func (r *Resource) HasPropertyParam(paramPath... string) bool {
+  return r.GetPropertyParamValue(paramPath...) != ""
+}
+
+func (r *Resource) GetPropertyParamValue(paramPath... string) string {
+  if paramPath[0] == ical.VCALENDAR {
+    paramPath = paramPath[1:]
+  }
+
+  param, _ := r.icalendar().DigParameter(paramPath...)
+  return param
+}
+
+func (r *Resource) GetEtag() (string, bool) {
+  if r.IsCollection() {
+    return "", false
+  }
+
+  return r.adapter.CalculateEtag(), true
+}
+
+func (r *Resource) GetContentType() (string, bool) {
+  if r.IsCollection() {
+    return "text/calendar", true
+  } else {
+    return "text/calendar; component=vcalendar", true
+  }
+}
+
+func (r *Resource) GetDisplayName() (string, bool) {
+   return r.Name, true
+}
+
+func (r *Resource) GetContentData() (string, bool) {
+  data := r.adapter.GetContent()
+  found := data != ""
+
+  return data, found
+}
+
+func (r *Resource) GetContentLength() (string, bool) {
+  // If its collection, it does not have any content, so mark it as not found
+  if r.IsCollection() {
+    return "", false
+  }
+
+  contentSize := r.adapter.GetContentSize()
+  return strconv.FormatInt(contentSize, 10), true
+}
+
+func (r *Resource) GetLastModified(format string) (string, bool) {
+  return r.adapter.GetModTime().Format(format), true
+}
+
+func (r *Resource) GetOwner() (string, bool) {
+  var owner string
+  if len(r.pathSplit) > 1 {
+    owner = r.pathSplit[0]
+  } else {
+    owner = ""
+  }
+
+  return owner, true
+}
+
+func (r *Resource) GetOwnerPath() (string, bool) {
+  owner, _ := r.GetOwner()
+
+  if owner != "" {
+    return fmt.Sprintf("/%s/", owner), true
+  } else {
+    return "", false
+  }
+}
+
+// TODO: memoize
+func (r *Resource) icalVEVENT() *ical.Node {
+  vevent := r.icalendar().ChildByName(ical.VEVENT)
+
+  // if nil, log it and return an empty vevent
+  if vevent == nil {
+    log.Printf("WARNING: The resource's ical data is missing the VEVENT property.\nResource path: %s", r.Path)
+
+    return &ical.Node{
+      Name: ical.VEVENT,
+    }
+  }
+
+  return vevent
+}
+
+// TODO: memoize
+func (r *Resource) icalendar() *ical.Node {
+  data, found := r.GetContentData()
+
+  if !found {
+    log.Printf("WARNING: The resource's ical data does not have any data.\nResource path: %s", r.Path)
+    return &ical.Node{
+      Name: ical.VCALENDAR,
+    }
+  }
+
+  icalNode, err := ical.ParseCalendar(data)
+  if err != nil {
+    log.Printf("ERROR: Could not parse the resource's ical data.\nError: %s.\nResource path: %s", err, r.Path)
+    return &ical.Node{
+      Name: ical.VCALENDAR,
+    }
+  }
+
+  return icalNode
+}
+
+type FileResourceAdapter struct {
+  finfo        os.FileInfo
+  resourcePath string
+}
+
+func (adp *FileResourceAdapter) IsCollection() bool {
+  return adp.finfo.IsDir()
+}
+
+func (adp *FileResourceAdapter) GetContent() string {
+  if adp.IsCollection() {
+    return ""
+  }
+
+  data, err := ioutil.ReadFile(files.AbsPath(adp.resourcePath))
+  if err != nil {
+    log.Printf("ERROR: Could not read file content for the resource.\nError: %s.\nResource path: %s.", err, adp.resourcePath)
+    return ""
+  }
+
+  return string(data)
+}
+
+func (adp *FileResourceAdapter) GetContentSize() int64 {
+  return adp.finfo.Size()
+}
+
+func (adp *FileResourceAdapter) CalculateEtag() string {
+  // returns ETag as the concatenated hex values of a file's
+	// modification time and size. This is not a reliable synchronization
+	// mechanism for directories, so for collections we return empty.
+  if adp.IsCollection() {
+    return ""
+  }
+
+  fi := adp.finfo
+  return fmt.Sprintf(`"%x%x"`, fi.ModTime().UnixNano(), fi.Size())
+}
+
+func (adp *FileResourceAdapter) GetModTime() time.Time {
+  return adp.finfo.ModTime()
+}

vendor/github.com/samedi/caldav-go/data/storage.go

@@ -0,0 +1,217 @@
+package data
+
+import (
+  "os"
+  "log"
+  "io/ioutil"
+  "github.com/samedi/caldav-go/errs"
+  "github.com/samedi/caldav-go/files"
+)
+
+// The Storage is the responsible for the CRUD operations on the caldav resources.
+type Storage interface {
+  // GetResources gets a list of resources based on a given `rpath`. The
+  // `rpath` is the path to the original resource that's being requested. The resultant list
+  // will/must contain that original resource in it, apart from any additional resources. It also receives
+  // `withChildren` flag to say if the result must also include all the original resource`s
+  // children (if original is a collection resource). If `true`, the result will have the requested resource + children.
+  // If `false`, it will have only the requested original resource (from the `rpath` path).
+  // It returns errors if anything went wrong or if it could not find any resource on `rpath` path.
+  GetResources(rpath string, withChildren bool) ([]Resource, error)
+  // GetResourcesByList fetches a list of resources by path from the storage.
+  // This method fetches all the `rpaths` and return an array of the reosurces found.
+  // No error 404 will be returned if one of the resources cannot be found.
+  // Errors are returned if any errors other than "not found" happens.
+  GetResourcesByList(rpaths []string) ([]Resource, error)
+  // GetResourcesByFilters returns the filtered children of a target collection resource.
+  // The target collection resource is the one pointed by the `rpath` parameter. All of its children
+  // will be checked against a set of `filters` and the matching ones are returned. The results
+  // contains only the filtered children and does NOT include the target resource. If the target resource
+  // is not a collection, an empty array is returned as the result.
+  GetResourcesByFilters(rpath string, filters *ResourceFilter) ([]Resource, error)
+  // GetResource gets the requested resource based on a given `rpath` path. It returns the resource (if found) or
+  // nil (if not found). Also returns a flag specifying if the resource was found or not.
+  GetResource(rpath string) (*Resource, bool, error)
+  // GetShallowResource has the same behaviour of `storage.GetResource`. The only difference is that, for collection resources,
+  // it does not return its children in the collection `storage.Resource` struct (hence the name shallow). The motive is
+  // for optimizations reasons, as this function is used on places where the collection's children are not important.
+  GetShallowResource(rpath string) (*Resource, bool, error)
+  // CreateResource creates a new resource on the `rpath` path with a given `content`.
+  CreateResource(rpath, content string) (*Resource, error)
+  // UpdateResource udpates a resource on the `rpath` path with a given `content`.
+  UpdateResource(rpath, content string) (*Resource, error)
+  // DeleteResource deletes a resource on the `rpath` path.
+  DeleteResource(rpath string) error
+}
+
+// FileStorage is the storage that deals with resources as files in the file system. So, a collection resource
+// is treated as a folder/directory and its children resources are the files it contains. On the other hand, non-collection
+// resources are just plain files.
+type FileStorage struct {
+}
+
+func (fs *FileStorage) GetResources(rpath string, withChildren bool) ([]Resource, error) {
+  result := []Resource{}
+
+  // tries to open the file by the given path
+  f, e := fs.openResourceFile(rpath, os.O_RDONLY)
+  if e != nil {
+		return nil, e
+  }
+
+  // add it as a resource to the result list
+  finfo, _ := f.Stat()
+  resource := NewResource(rpath, &FileResourceAdapter{finfo, rpath})
+  result = append(result, resource)
+
+  // if the file is a dir, add its children to the result list
+  if withChildren && finfo.IsDir() {
+    dirFiles, _ := f.Readdir(0)
+    for _, finfo := range dirFiles {
+      childPath := files.JoinPaths(rpath, finfo.Name())
+      resource = NewResource(childPath, &FileResourceAdapter{finfo, childPath})
+      result = append(result, resource)
+    }
+  }
+
+  return result, nil
+}
+
+func (fs *FileStorage) GetResourcesByFilters(rpath string, filters *ResourceFilter) ([]Resource, error) {
+  result := []Resource{}
+
+  childPaths := fs.getDirectoryChildPaths(rpath)
+  for _, path := range childPaths {
+    resource, _, err := fs.GetShallowResource(path)
+
+    if err != nil {
+      // if we can't find this resource, something weird went wrong, but not that serious, so we log it and continue
+      log.Printf("WARNING: returned error when trying to get resource with path %s from collection with path %s. Error: %s", path, rpath, err)
+      continue
+    }
+
+    // only add it if the resource matches the filters
+    if filters == nil || filters.Match(resource) {
+      result = append(result, *resource)
+    }
+  }
+
+  return result, nil
+}
+
+func (fs *FileStorage) GetResourcesByList(rpaths []string) ([]Resource, error) {
+  results := []Resource{}
+
+  for _, rpath := range rpaths {
+    resource, found, err := fs.GetShallowResource(rpath)
+
+    if err != nil && err != errs.ResourceNotFoundError {
+      return nil, err
+    }
+
+    if found {
+      results = append(results, *resource)
+    }
+  }
+
+  return results, nil
+}
+
+func (fs *FileStorage) GetResource(rpath string) (*Resource, bool, error) {
+  // For simplicity we just return the shallow resource.
+  return fs.GetShallowResource(rpath)
+}
+
+func (fs *FileStorage) GetShallowResource(rpath string) (*Resource, bool, error) {
+  resources, err := fs.GetResources(rpath, false)
+
+  if err != nil {
+    return nil, false, err
+  }
+
+  if resources == nil || len(resources) == 0 {
+    return nil, false, errs.ResourceNotFoundError
+  }
+
+  res := resources[0]
+  return &res, true, nil
+}
+
+func (fs *FileStorage) CreateResource(rpath, content string) (*Resource, error) {
+  rAbsPath := files.AbsPath(rpath)
+
+  if fs.isResourcePresent(rAbsPath) {
+    return nil, errs.ResourceAlreadyExistsError
+  }
+
+  // create parent directories (if needed)
+  if err := os.MkdirAll(files.DirPath(rAbsPath), os.ModePerm); err != nil {
+    return nil, err
+  }
+
+  // create file/resource and write content
+  f, err := os.Create(rAbsPath)
+  if err != nil {
+    return nil, err
+  }
+  f.WriteString(content)
+
+  finfo, _ := f.Stat()
+  res := NewResource(rpath, &FileResourceAdapter{finfo, rpath})
+  return &res, nil
+}
+
+func (fs *FileStorage) UpdateResource(rpath, content string) (*Resource, error) {
+  f, e := fs.openResourceFile(rpath, os.O_RDWR)
+  if e != nil {
+		return nil, e
+  }
+
+  // update content
+  f.Truncate(0)
+  f.WriteString(content)
+
+  finfo, _ := f.Stat()
+  res := NewResource(rpath, &FileResourceAdapter{finfo, rpath})
+  return &res, nil
+}
+
+func (fs *FileStorage) DeleteResource(rpath string) error {
+  err := os.Remove(files.AbsPath(rpath))
+
+  return err
+}
+
+func (fs *FileStorage) isResourcePresent(rpath string) bool {
+  _, found, _ := fs.GetShallowResource(rpath)
+
+  return found
+}
+
+func (fs *FileStorage) openResourceFile(filepath string, mode int) (*os.File, error) {
+  f, e := os.OpenFile(files.AbsPath(filepath), mode, 0666)
+  if e != nil {
+    if os.IsNotExist(e) {
+			return nil, errs.ResourceNotFoundError
+		}
+		return nil, e
+  }
+
+  return f, nil
+}
+
+func (fs *FileStorage) getDirectoryChildPaths(dirpath string) []string {
+  content, err := ioutil.ReadDir(files.AbsPath(dirpath))
+	if err != nil {
+    log.Printf("ERROR: Could not read resource as file directory.\nError: %s.\nResource path: %s.", err, dirpath)
+    return nil
+	}
+
+  result := []string{}
+	for _, file := range content {
+    fpath := files.JoinPaths(dirpath, file.Name())
+    result = append(result, fpath)
+	}
+
+  return result
+}

vendor/github.com/samedi/caldav-go/data/user.go

@@ -0,0 +1,5 @@
+package data
+
+type CalUser struct {
+  Name string
+}

vendor/github.com/samedi/caldav-go/errs/errors.go

@@ -0,0 +1,12 @@
+package errs
+
+import (
+  "errors"
+)
+
+var (
+  ResourceNotFoundError = errors.New("caldav: resource not found")
+  ResourceAlreadyExistsError = errors.New("caldav: resource already exists")
+  UnauthorizedError = errors.New("caldav: unauthorized. credentials needed.")
+  ForbiddenError = errors.New("caldav: forbidden operation.")
+)

vendor/github.com/samedi/caldav-go/files/paths.go

@@ -0,0 +1,30 @@
+package files
+
+import (
+  "strings"
+  "path/filepath"
+  "github.com/samedi/caldav-go/lib"
+)
+
+const (
+  Separator = string(filepath.Separator)
+)
+
+func AbsPath(path string) string {
+  path = strings.Trim(path, "/")
+  absPath, _ := filepath.Abs(path)
+
+  return absPath
+}
+
+func DirPath(path string) string {
+  return filepath.Dir(path)
+}
+
+func JoinPaths(paths ...string) string {
+  return filepath.Join(paths...)
+}
+
+func ToSlashPath(path string) string {
+  return lib.ToSlashPath(path)
+}

vendor/github.com/samedi/caldav-go/glide.lock

@@ -0,0 +1,10 @@
+hash: 2796726e69757f4af1a13f6ebd056ebc626d712051aa213875bb03f5bdc1ebfd
+updated: 2017-01-18T11:43:23.127761353+01:00
+imports:
+- name: github.com/beevik/etree
+  version: 4cd0dd976db869f817248477718071a28e978df0
+- name: github.com/laurent22/ical-go
+  version: 4811ac5553eae5fed7cd5d7a9024727f1311b2a2
+  subpackages:
+  - ical
+testImports: []

vendor/github.com/samedi/caldav-go/glide.yaml

@@ -0,0 +1,7 @@
+package: github.com/samedi/caldav-go
+import:
+- package: github.com/beevik/etree
+- package: github.com/laurent22/ical-go
+  version: ~0.1.0
+  subpackages:
+  - ical

vendor/github.com/samedi/caldav-go/global/global.go

@@ -0,0 +1,12 @@
+package global
+
+// This file defines accessible variables used to setup the caldav server.
+
+import (
+  "github.com/samedi/caldav-go/data"
+)
+
+// The global storage used in the CRUD operations of resources. Default storage is the `FileStorage`.
+var Storage data.Storage = new(data.FileStorage)
+// Current caldav user. It is used to keep the info of the current user that is interacting with the calendar.
+var User *data.CalUser

vendor/github.com/samedi/caldav-go/handler.go

@@ -0,0 +1,28 @@
+package caldav
+
+import (
+  "net/http"
+  "github.com/samedi/caldav-go/data"
+  "github.com/samedi/caldav-go/handlers"
+)
+
+// RequestHandler handles the given CALDAV request and writes the reponse righ away. This function is to be
+// used by passing it directly as the handle func to the `http` lib. Example: http.HandleFunc("/", caldav.RequestHandler).
+func RequestHandler(writer http.ResponseWriter, request *http.Request) {
+  response := HandleRequest(request)
+  response.Write(writer)
+}
+
+// HandleRequest handles the given CALDAV request and returns the response. Useful when the caller
+// wants to do something else with the response before writing it to the response stream.
+func HandleRequest(request *http.Request) *handlers.Response {
+  handler := handlers.NewHandler(request)
+  return handler.Handle()
+}
+
+// HandleRequestWithStorage handles the request the same way as `HandleRequest` does, but before,
+// it sets the given storage that will be used throughout the request handling flow.
+func HandleRequestWithStorage(request *http.Request, stg data.Storage) *handlers.Response {
+  SetupStorage(stg)
+  return HandleRequest(request)
+}

vendor/github.com/samedi/caldav-go/handlers/builder.go

@@ -0,0 +1,24 @@
+package handlers
+
+import (
+  "net/http"
+)
+
+type handlerInterface interface {
+  Handle() *Response
+}
+
+func NewHandler(request *http.Request) handlerInterface {
+  response := NewResponse()
+
+  switch request.Method {
+  case "GET": return getHandler{request, response, false}
+  case "HEAD": return getHandler{request, response, true}
+  case "PUT": return putHandler{request, response}
+  case "DELETE": return deleteHandler{request, response}
+  case "PROPFIND": return propfindHandler{request, response}
+  case "OPTIONS": return optionsHandler{response}
+  case "REPORT": return reportHandler{request, response}
+  default: return notImplementedHandler{response}
+  }
+}

vendor/github.com/samedi/caldav-go/handlers/delete.go

@@ -0,0 +1,40 @@
+package handlers
+
+import (
+  "net/http"
+  "github.com/samedi/caldav-go/global"
+)
+
+type deleteHandler struct {
+  request *http.Request
+  response *Response
+}
+
+func (dh deleteHandler) Handle() *Response {
+  precond := requestPreconditions{dh.request}
+
+  // get the event from the storage
+  resource, _, err := global.Storage.GetShallowResource(dh.request.URL.Path)
+  if err != nil {
+    return dh.response.SetError(err)
+  }
+
+  // TODO: Handle delete on collections
+  if resource.IsCollection() {
+    return dh.response.Set(http.StatusMethodNotAllowed, "")
+  }
+
+  // check ETag pre-condition
+  resourceEtag, _ := resource.GetEtag()
+  if !precond.IfMatch(resourceEtag) {
+    return dh.response.Set(http.StatusPreconditionFailed, "")
+  }
+
+  // delete event after pre-condition passed
+  err = global.Storage.DeleteResource(resource.Path)
+  if err != nil {
+    return dh.response.SetError(err)
+  }
+
+  return dh.response.Set(http.StatusNoContent, "")
+}

vendor/github.com/samedi/caldav-go/handlers/get.go

@@ -0,0 +1,37 @@
+package handlers
+
+import (
+  "net/http"
+  "github.com/samedi/caldav-go/global"
+)
+
+type getHandler struct {
+  request *http.Request
+  response *Response
+  onlyHeaders bool
+}
+
+func (gh getHandler) Handle() *Response {
+  resource, _, err := global.Storage.GetResource(gh.request.URL.Path)
+  if err != nil {
+    return gh.response.SetError(err)
+  }
+
+  var response string
+  if gh.onlyHeaders {
+    response = ""
+  } else {
+    response, _ = resource.GetContentData()
+  }
+
+  etag, _ := resource.GetEtag()
+  lastm, _ := resource.GetLastModified(http.TimeFormat)
+  ctype, _ := resource.GetContentType()
+
+  gh.response.SetHeader("ETag", etag).
+              SetHeader("Last-Modified", lastm).
+              SetHeader("Content-Type", ctype).
+              Set(http.StatusOK, response)
+
+  return gh.response
+}

vendor/github.com/samedi/caldav-go/handlers/headers.go

@@ -0,0 +1,27 @@
+package handlers
+
+import (
+  "net/http"
+)
+
+const (
+  HD_DEPTH = "Depth"
+  HD_DEPTH_DEEP = "1"
+  HD_PREFER = "Prefer"
+  HD_PREFER_MINIMAL = "return=minimal"
+  HD_PREFERENCE_APPLIED = "Preference-Applied"
+)
+
+type headers struct {
+  http.Header
+}
+
+func (this headers) IsDeep() bool {
+  depth := this.Get(HD_DEPTH)
+  return (depth == HD_DEPTH_DEEP)
+}
+
+func (this headers) IsMinimal() bool {
+  prefer := this.Get(HD_PREFER)
+  return (prefer == HD_PREFER_MINIMAL)
+}

vendor/github.com/samedi/caldav-go/handlers/multistatus.go

@@ -0,0 +1,207 @@
+package handlers
+
+import (
+  "fmt"
+  "net/http"
+  "encoding/xml"
+  "github.com/samedi/caldav-go/lib"
+  "github.com/samedi/caldav-go/global"
+  "github.com/samedi/caldav-go/data"
+  "github.com/samedi/caldav-go/ixml"
+)
+
+// Wraps a multistatus response. It contains the set of `Responses`
+// that will serve to build the final XML. Multistatus responses are
+// used by the REPORT and PROPFIND methods.
+type multistatusResp struct {
+  // The set of multistatus responses used to build each of the <DAV:response> nodes.
+  Responses []msResponse
+  // Flag that XML should be minimal or not
+  // [defined in the draft https://tools.ietf.org/html/draft-murchison-webdav-prefer-05]
+  Minimal bool
+}
+
+type msResponse struct {
+  Href string
+  Found bool
+  Propstats msPropstats
+}
+
+type msPropstats map[int]msProps
+
+// Adds a msProp to the map with the key being the prop status.
+func (stats msPropstats) Add(prop msProp) {
+  stats[prop.Status] = append(stats[prop.Status], prop)
+}
+
+func (stats msPropstats) Clone() msPropstats {
+  clone := make(msPropstats)
+
+  for k, v := range stats {
+    clone[k] = v
+  }
+
+  return clone
+}
+
+type msProps []msProp
+
+type msProp struct {
+  Tag      xml.Name
+  Content  string
+  Contents []string
+  Status   int
+}
+
+// Function that processes all the required props for a given resource.
+// ## Params
+// resource: the target calendar resource.
+// reqprops: set of required props that must be processed for the resource.
+// ## Returns
+// The set of props (msProp) processed. Each prop is mapped to a HTTP status code.
+// So if a prop is found and processed ok, it'll be mapped to 200. If it's not found,
+// it'll be mapped to 404, and so on.
+func (ms *multistatusResp) Propstats(resource *data.Resource, reqprops []xml.Name) msPropstats {
+  if resource == nil {
+    return nil
+  }
+
+  result := make(msPropstats)
+
+  for _, ptag := range reqprops {
+    pvalue := msProp{
+      Tag: ptag,
+      Status: http.StatusOK,
+    }
+
+    pfound := false
+    switch ptag {
+    case ixml.CALENDAR_DATA_TG:
+      pvalue.Content, pfound = resource.GetContentData()
+      if pfound {
+        pvalue.Content = ixml.EscapeText(pvalue.Content)
+      }
+    case ixml.GET_ETAG_TG:
+      pvalue.Content, pfound = resource.GetEtag()
+    case ixml.GET_CONTENT_TYPE_TG:
+      pvalue.Content, pfound = resource.GetContentType()
+    case ixml.GET_CONTENT_LENGTH_TG:
+      pvalue.Content, pfound = resource.GetContentLength()
+    case ixml.DISPLAY_NAME_TG:
+      pvalue.Content, pfound = resource.GetDisplayName()
+      if pfound {
+        pvalue.Content = ixml.EscapeText(pvalue.Content)
+      }
+    case ixml.GET_LAST_MODIFIED_TG:
+      pvalue.Content, pfound = resource.GetLastModified(http.TimeFormat)
+    case ixml.OWNER_TG:
+      pvalue.Content, pfound = resource.GetOwnerPath()
+    case ixml.GET_CTAG_TG:
+      pvalue.Content, pfound = resource.GetEtag()
+    case ixml.PRINCIPAL_URL_TG,
+         ixml.PRINCIPAL_COLLECTION_SET_TG,
+         ixml.CALENDAR_USER_ADDRESS_SET_TG,
+         ixml.CALENDAR_HOME_SET_TG:
+      pvalue.Content, pfound = ixml.HrefTag(resource.Path), true
+    case ixml.RESOURCE_TYPE_TG:
+      if resource.IsCollection() {
+        pvalue.Content, pfound = ixml.Tag(ixml.COLLECTION_TG, "") + ixml.Tag(ixml.CALENDAR_TG, ""), true
+
+        if resource.IsPrincipal() {
+          pvalue.Content += ixml.Tag(ixml.PRINCIPAL_TG, "")
+        }
+      } else {
+        // resourcetype must be returned empty for non-collection elements
+        pvalue.Content, pfound = "", true
+      }
+    case ixml.CURRENT_USER_PRINCIPAL_TG:
+      if global.User != nil {
+        path := fmt.Sprintf("/%s/", global.User.Name)
+        pvalue.Content, pfound = ixml.HrefTag(path), true
+      }
+    case ixml.SUPPORTED_CALENDAR_COMPONENT_SET_TG:
+      if resource.IsCollection() {
+        for _, component := range supportedComponents {
+          // TODO: use ixml somehow to build the below tag
+          compTag := fmt.Sprintf(`<C:comp name="%s"/>`, component)
+          pvalue.Contents = append(pvalue.Contents, compTag)
+        }
+        pfound = true
+      }
+    }
+
+    if !pfound {
+      pvalue.Status = http.StatusNotFound
+    }
+
+    result.Add(pvalue)
+  }
+
+  return result
+}
+
+// Adds a new `msResponse` to the `Responses` array.
+func (ms *multistatusResp) AddResponse(href string, found bool, propstats msPropstats) {
+  ms.Responses = append(ms.Responses, msResponse{
+    Href: href,
+    Found: found,
+    Propstats: propstats,
+  })
+}
+
+func (ms *multistatusResp) ToXML() string {
+  // init multistatus
+  var bf lib.StringBuffer
+  bf.Write(`<?xml version="1.0" encoding="UTF-8"?>`)
+  bf.Write(`<D:multistatus %s>`, ixml.Namespaces())
+
+  // iterate over event hrefs and build multistatus XML on the fly
+  for _, response := range ms.Responses {
+    bf.Write("<D:response>")
+    bf.Write(ixml.HrefTag(response.Href))
+
+    if response.Found {
+      propstats := response.Propstats.Clone()
+
+      if ms.Minimal {
+        delete(propstats, http.StatusNotFound)
+
+        if len(propstats) == 0 {
+          bf.Write("<D:propstat>")
+          bf.Write("<D:prop/>")
+          bf.Write(ixml.StatusTag(http.StatusOK))
+          bf.Write("</D:propstat>")
+          bf.Write("</D:response>")
+
+          continue
+        }
+      }
+
+      for status, props := range propstats {
+        bf.Write("<D:propstat>")
+        bf.Write("<D:prop>")
+        for _, prop := range props {
+          bf.Write(ms.propToXML(prop))
+        }
+        bf.Write("</D:prop>")
+        bf.Write(ixml.StatusTag(status))
+        bf.Write("</D:propstat>")
+      }
+    } else {
+      // if does not find the resource set 404
+      bf.Write(ixml.StatusTag(http.StatusNotFound))
+    }
+    bf.Write("</D:response>")
+  }
+  bf.Write("</D:multistatus>")
+
+  return bf.String()
+}
+
+func (ms *multistatusResp) propToXML(prop msProp) string {
+  for _, content := range prop.Contents {
+    prop.Content += content
+  }
+  xmlString := ixml.Tag(prop.Tag, prop.Content)
+  return xmlString
+}

vendor/github.com/samedi/caldav-go/handlers/not_implemented.go

@@ -0,0 +1,13 @@
+package handlers
+
+import (
+  "net/http"
+)
+
+type notImplementedHandler struct {
+  response *Response
+}
+
+func (h notImplementedHandler) Handle() *Response {
+  return h.response.Set(http.StatusNotImplemented, "")
+}

vendor/github.com/samedi/caldav-go/handlers/options.go

@@ -0,0 +1,23 @@
+package handlers
+
+import (
+  "net/http"
+)
+
+type optionsHandler struct {
+  response *Response
+}
+
+// Returns the allowed methods and the DAV features implemented by the current server.
+// For more information about the values and format read RFC4918 Sections 10.1 and 18.
+func (oh optionsHandler) Handle() *Response {
+  // Set the DAV compliance header:
+  // 1: Server supports all the requirements specified in RFC2518
+  // 3: Server supports all the revisions specified in RFC4918
+  // calendar-access: Server supports all the extensions specified in RFC4791
+  oh.response.SetHeader("DAV", "1, 3, calendar-access").
+              SetHeader("Allow", "GET, HEAD, PUT, DELETE, OPTIONS, PROPFIND, REPORT").
+              Set(http.StatusOK, "")
+
+  return oh.response
+}

vendor/github.com/samedi/caldav-go/handlers/preconditions.go

@@ -0,0 +1,23 @@
+package handlers
+
+import (
+  "net/http"
+)
+
+type requestPreconditions struct {
+  request *http.Request
+}
+
+func (p *requestPreconditions) IfMatch(etag string) bool {
+  etagMatch := p.request.Header["If-Match"]
+  return len(etagMatch) == 0 || etagMatch[0] == "*" || etagMatch[0] == etag
+}
+
+func (p *requestPreconditions) IfMatchPresent() bool {
+  return len(p.request.Header["If-Match"]) != 0
+}
+
+func (p *requestPreconditions) IfNoneMatch(value string) bool {
+  valueMatch := p.request.Header["If-None-Match"]
+  return len(valueMatch) == 1 && valueMatch[0] == value
+}

vendor/github.com/samedi/caldav-go/handlers/propfind.go

@@ -0,0 +1,49 @@
+package handlers
+
+import (
+  "net/http"
+  "encoding/xml"
+  "github.com/samedi/caldav-go/global"
+)
+
+type propfindHandler struct {
+  request *http.Request
+  response *Response
+}
+
+func (ph propfindHandler) Handle() *Response {
+  requestBody := readRequestBody(ph.request)
+  header := headers{ph.request.Header}
+
+  // get the target resources based on the request URL
+  resources, err := global.Storage.GetResources(ph.request.URL.Path, header.IsDeep())
+  if err != nil {
+    return ph.response.SetError(err)
+  }
+
+  // read body string to xml struct
+  type XMLProp2 struct {
+    Tags []xml.Name `xml:",any"`
+  }
+  type XMLRoot2 struct {
+    XMLName xml.Name
+    Prop    XMLProp2  `xml:"DAV: prop"`
+  }
+  var requestXML XMLRoot2
+  xml.Unmarshal([]byte(requestBody), &requestXML)
+
+  multistatus := &multistatusResp{
+    Minimal: header.IsMinimal(),
+  }
+  // for each href, build the multistatus responses
+  for _, resource := range resources {
+    propstats := multistatus.Propstats(&resource, requestXML.Prop.Tags)
+    multistatus.AddResponse(resource.Path, true, propstats)
+  }
+
+  if multistatus.Minimal {
+    ph.response.SetHeader(HD_PREFERENCE_APPLIED, HD_PREFER_MINIMAL)
+  }
+
+  return ph.response.Set(207, multistatus.ToXML())
+}

vendor/github.com/samedi/caldav-go/handlers/put.go

@@ -0,0 +1,65 @@
+package handlers
+
+import (
+  "net/http"
+  "github.com/samedi/caldav-go/errs"
+  "github.com/samedi/caldav-go/global"
+)
+
+type putHandler struct {
+  request *http.Request
+  response *Response
+}
+
+func (ph putHandler) Handle() *Response {
+  requestBody := readRequestBody(ph.request)
+  precond := requestPreconditions{ph.request}
+  success := false
+
+  // check if resource exists
+  resourcePath := ph.request.URL.Path
+  resource, found, err := global.Storage.GetShallowResource(resourcePath)
+  if err != nil && err != errs.ResourceNotFoundError {
+    return ph.response.SetError(err)
+  }
+
+  // PUT is allowed in 2 cases:
+  //
+  // 1. Item NOT FOUND and there is NO ETAG match header: CREATE a new item
+  if !found && !precond.IfMatchPresent() {
+    // create new event resource
+    resource, err = global.Storage.CreateResource(resourcePath, requestBody)
+    if err != nil {
+      return ph.response.SetError(err)
+    }
+
+    success = true
+  }
+
+  if found {
+    // TODO: Handle PUT on collections
+    if resource.IsCollection() {
+      return ph.response.Set(http.StatusPreconditionFailed, "")
+    }
+
+    // 2. Item exists, the resource etag is verified and there's no IF-NONE-MATCH=* header: UPDATE the item
+    resourceEtag, _ := resource.GetEtag()
+    if found && precond.IfMatch(resourceEtag) && !precond.IfNoneMatch("*") {
+      // update resource
+      resource, err = global.Storage.UpdateResource(resourcePath, requestBody)
+      if err != nil {
+        return ph.response.SetError(err)
+      }
+
+      success = true
+    }
+  }
+
+  if !success {
+    return ph.response.Set(http.StatusPreconditionFailed, "")
+  }
+
+  resourceEtag, _ := resource.GetEtag()
+  return ph.response.SetHeader("ETag", resourceEtag).
+                     Set(http.StatusCreated, "")
+}

vendor/github.com/samedi/caldav-go/handlers/report.go

@@ -0,0 +1,168 @@
+package handlers
+
+import (
+  "fmt"
+  "strings"
+  "net/http"
+  "encoding/xml"
+
+  "github.com/samedi/caldav-go/data"
+  "github.com/samedi/caldav-go/ixml"
+  "github.com/samedi/caldav-go/global"
+)
+
+type reportHandler struct{
+  request *http.Request
+  response *Response
+}
+
+// See more at RFC4791#section-7.1
+func (rh reportHandler) Handle() *Response {
+  requestBody := readRequestBody(rh.request)
+  header := headers{rh.request.Header}
+
+  urlResource, found, err := global.Storage.GetShallowResource(rh.request.URL.Path)
+  if !found {
+    return rh.response.Set(http.StatusNotFound, "")
+  } else if err != nil {
+    return rh.response.SetError(err)
+  }
+
+  // read body string to xml struct
+  var requestXML reportRootXML
+  xml.Unmarshal([]byte(requestBody), &requestXML)
+
+  // The resources to be reported are fetched by the type of the request. If it is
+  // a `calendar-multiget`, the resources come based on a set of `hrefs` in the request body.
+  // If it is a `calendar-query`, the resources are calculated based on set of filters in the request.
+  var resourcesToReport []reportRes
+  switch requestXML.XMLName {
+  case ixml.CALENDAR_MULTIGET_TG:
+    resourcesToReport, err = rh.fetchResourcesByList(urlResource, requestXML.Hrefs)
+  case ixml.CALENDAR_QUERY_TG:
+    resourcesToReport, err = rh.fetchResourcesByFilters(urlResource, requestXML.Filters)
+  default:
+    return rh.response.Set(http.StatusPreconditionFailed, "")
+  }
+
+  if err != nil {
+    return rh.response.SetError(err)
+  }
+
+  multistatus := &multistatusResp{
+    Minimal: header.IsMinimal(),
+  }
+  // for each href, build the multistatus responses
+  for _, r := range resourcesToReport {
+    propstats := multistatus.Propstats(r.resource, requestXML.Prop.Tags)
+    multistatus.AddResponse(r.href, r.found, propstats)
+  }
+
+  if multistatus.Minimal {
+    rh.response.SetHeader(HD_PREFERENCE_APPLIED, HD_PREFER_MINIMAL)
+  }
+
+  return rh.response.Set(207, multistatus.ToXML())
+}
+
+type reportPropXML struct {
+  Tags []xml.Name `xml:",any"`
+}
+
+type reportRootXML struct {
+  XMLName xml.Name
+  Prop    reportPropXML   `xml:"DAV: prop"`
+  Hrefs   []string        `xml:"DAV: href"`
+  Filters reportFilterXML `xml:"urn:ietf:params:xml:ns:caldav filter"`
+}
+
+type reportFilterXML struct {
+  XMLName      xml.Name
+  InnerContent string    `xml:",innerxml"`
+}
+
+func (this reportFilterXML) toString() string {
+  return fmt.Sprintf("<%s>%s</%s>", this.XMLName.Local, this.InnerContent, this.XMLName.Local)
+}
+
+// Wraps a resource that has to be reported, either fetched by filters or by a list.
+// Basically it contains the original requested `href`, the actual `resource` (can be nil)
+// and if the `resource` was `found` or not
+type reportRes struct {
+  href string
+  resource *data.Resource
+  found bool
+}
+
+// The resources are fetched based on the origin resource and a set of filters.
+// If the origin resource is a collection, the filters are checked against each of the collection's resources
+// to see if they match. The collection's resources that match the filters are returned. The ones that will be returned
+// are the resources that were not found (does not exist) and the ones that matched the filters. The ones that did not
+// match the filter will not appear in the response result.
+// If the origin resource is not a collection, the function just returns it and ignore any filter processing.
+// [See RFC4791#section-7.8]
+func (rh reportHandler) fetchResourcesByFilters(origin *data.Resource, filtersXML reportFilterXML) ([]reportRes, error) {
+  // The list of resources that has to be reported back in the response.
+  reps := []reportRes{}
+
+  if origin.IsCollection() {
+    filters, _ := data.ParseResourceFilters(filtersXML.toString())
+    resources, err := global.Storage.GetResourcesByFilters(origin.Path, filters)
+
+    if err != nil {
+      return reps, err
+    }
+
+    for _, resource := range resources {
+      reps = append(reps, reportRes{resource.Path, &resource, true})
+    }
+  } else {
+    // the origin resource is not a collection, so returns just that as the result
+    reps = append(reps, reportRes{origin.Path, origin, true})
+  }
+
+  return reps, nil
+}
+
+// The hrefs can come from (1) the request URL or (2) from the request body itself.
+// If the origin resource from the URL points to a collection (2), we will check the request body
+// to get the requested `hrefs` (resource paths). Each requested href has to be related to the collection.
+// The ones that are not, we simply ignore them.
+// If the resource from the URL is NOT a collection (1) we process the the report only for this resource
+// and ignore any othre requested hrefs that might be present in the request body.
+// [See RFC4791#section-7.9]
+func (rh reportHandler) fetchResourcesByList(origin *data.Resource, requestedPaths []string) ([]reportRes, error) {
+  reps := []reportRes{}
+
+  if origin.IsCollection() {
+    resources, err := global.Storage.GetResourcesByList(requestedPaths)
+
+    if err != nil {
+      return reps, err
+    }
+
+    // we put all the resources found in a map path -> resource.
+    // this will be used later to query which requested resource was found
+    // or not and mount the response
+    resourcesMap := make(map[string]*data.Resource)
+    for _, resource := range resources {
+      r := resource
+      resourcesMap[resource.Path] = &r
+    }
+
+    for _, requestedPath := range requestedPaths {
+      // if the requested path does not belong to the origin collection, skip
+      // ('belonging' means that the path's prefix is the same as the collection path)
+      if !strings.HasPrefix(requestedPath, origin.Path) {
+        continue
+      }
+
+      resource, found := resourcesMap[requestedPath]
+      reps = append(reps, reportRes{requestedPath, resource, found})
+    }
+  } else {
+    reps = append(reps, reportRes{origin.Path, origin, true})
+  }
+
+  return reps, nil
+}

vendor/github.com/samedi/caldav-go/handlers/response.go

@@ -0,0 +1,65 @@
+package handlers
+
+import (
+  "io"
+  "net/http"
+  "github.com/samedi/caldav-go/errs"
+)
+
+type Response struct {
+  Status int
+  Header http.Header
+  Body string
+  Error error
+}
+
+func NewResponse() *Response {
+  return &Response{
+    Header: make(http.Header),
+  }
+}
+
+func (this *Response) Set(status int, body string) *Response {
+  this.Status = status
+  this.Body = body
+
+  return this
+}
+
+func (this *Response) SetHeader(key, value string) *Response {
+  this.Header.Set(key, value)
+
+  return this
+}
+
+func (this *Response) SetError(err error) *Response {
+  this.Error = err
+
+  switch err {
+  case errs.ResourceNotFoundError:
+    this.Status = http.StatusNotFound
+  case errs.UnauthorizedError:
+    this.Status = http.StatusUnauthorized
+  case errs.ForbiddenError:
+    this.Status = http.StatusForbidden
+  default:
+    this.Status = http.StatusInternalServerError
+  }
+
+  return this
+}
+
+func (this *Response) Write(writer http.ResponseWriter) {
+  if this.Error == errs.UnauthorizedError {
+    this.SetHeader("WWW-Authenticate", `Basic realm="Restricted"`)
+  }
+
+  for key, values := range this.Header {
+    for _, value := range values {
+      writer.Header().Set(key, value)
+    }
+  }
+
+  writer.WriteHeader(this.Status)
+  io.WriteString(writer, this.Body)
+}

vendor/github.com/samedi/caldav-go/handlers/shared.go

@@ -0,0 +1,22 @@
+package handlers
+
+import (
+  "net/http"
+  "io/ioutil"
+  "bytes"
+  "github.com/samedi/caldav-go/lib"
+)
+
+// Supported ICal components on this server.
+var supportedComponents = []string{lib.VCALENDAR, lib.VEVENT}
+
+// This function reads the request body and restore its content, so that
+// the request body can be read a second time.
+func readRequestBody(request *http.Request) string {
+  // Read the content
+  body, _ := ioutil.ReadAll(request.Body)
+  // Restore the io.ReadCloser to its original state
+  request.Body = ioutil.NopCloser(bytes.NewBuffer(body))
+  // Use the content
+  return string(body)
+}

vendor/github.com/samedi/caldav-go/ixml/ixml.go

@@ -0,0 +1,93 @@
+package ixml
+
+import (
+  "fmt"
+  "bytes"
+  "net/http"
+  "encoding/xml"
+
+  "github.com/samedi/caldav-go/lib"
+)
+
+const (
+  DAV_NS = "DAV:"
+  CALDAV_NS = "urn:ietf:params:xml:ns:caldav"
+  CALSERV_NS = "http://calendarserver.org/ns/"
+)
+
+var NS_PREFIXES = map[string]string{
+  DAV_NS: "D",
+  CALDAV_NS: "C",
+  CALSERV_NS: "CS",
+}
+
+var (
+  CALENDAR_TG = xml.Name{CALDAV_NS, "calendar"}
+  CALENDAR_DATA_TG = xml.Name{CALDAV_NS, "calendar-data"}
+  CALENDAR_HOME_SET_TG = xml.Name{CALDAV_NS, "calendar-home-set"}
+  CALENDAR_QUERY_TG = xml.Name{CALDAV_NS, "calendar-query"}
+  CALENDAR_MULTIGET_TG = xml.Name{CALDAV_NS, "calendar-multiget"}
+  CALENDAR_USER_ADDRESS_SET_TG = xml.Name{CALDAV_NS, "calendar-user-address-set"}
+  COLLECTION_TG = xml.Name{DAV_NS, "collection"}
+  CURRENT_USER_PRINCIPAL_TG = xml.Name{DAV_NS, "current-user-principal"}
+  DISPLAY_NAME_TG = xml.Name{DAV_NS, "displayname"}
+  GET_CONTENT_LENGTH_TG = xml.Name{DAV_NS, "getcontentlength"}
+  GET_CONTENT_TYPE_TG = xml.Name{DAV_NS, "getcontenttype"}
+  GET_CTAG_TG = xml.Name{CALSERV_NS, "getctag"}
+  GET_ETAG_TG = xml.Name{DAV_NS, "getetag"}
+  GET_LAST_MODIFIED_TG = xml.Name{DAV_NS, "getlastmodified"}
+  HREF_TG = xml.Name{DAV_NS, "href"}
+  OWNER_TG = xml.Name{DAV_NS, "owner"}
+  PRINCIPAL_TG = xml.Name{DAV_NS, "principal"}
+  PRINCIPAL_COLLECTION_SET_TG = xml.Name{DAV_NS, "principal-collection-set"}
+  PRINCIPAL_URL_TG = xml.Name{DAV_NS, "principal-URL"}
+  RESOURCE_TYPE_TG = xml.Name{DAV_NS, "resourcetype"}
+  STATUS_TG = xml.Name{DAV_NS, "status"}
+  SUPPORTED_CALENDAR_COMPONENT_SET_TG = xml.Name{CALDAV_NS, "supported-calendar-component-set"}
+)
+
+func Namespaces() string {
+  bf := new(lib.StringBuffer)
+  bf.Write(`xmlns:%s="%s" `, NS_PREFIXES[DAV_NS], DAV_NS)
+  bf.Write(`xmlns:%s="%s" `, NS_PREFIXES[CALDAV_NS], CALDAV_NS)
+  bf.Write(`xmlns:%s="%s"`,  NS_PREFIXES[CALSERV_NS], CALSERV_NS)
+
+  return bf.String()
+}
+
+// Tag returns a XML tag as string based on the given tag name and content. It
+// takes in consideration the namespace and also if it is an empty content or not.
+func Tag(xmlName xml.Name, content string) string {
+  name := xmlName.Local
+  ns := NS_PREFIXES[xmlName.Space]
+
+  if ns != "" {
+    ns = ns + ":"
+  }
+
+  if content != "" {
+    return fmt.Sprintf("<%s%s>%s</%s%s>", ns, name, content, ns, name)
+  } else {
+    return fmt.Sprintf("<%s%s/>", ns, name)
+  }
+}
+
+// HrefTag returns a DAV <D:href> tag with the given href path.
+func HrefTag(href string) (tag string) {
+  return Tag(HREF_TG, href)
+}
+
+// StatusTag returns a DAV <D:status> tag with the given HTTP status. The
+// status is translated into a label, e.g.: HTTP/1.1 404 NotFound.
+func StatusTag(status int) string {
+  statusText := fmt.Sprintf("HTTP/1.1 %d %s", status, http.StatusText(status))
+  return Tag(STATUS_TG, statusText)
+}
+
+// EscapeText escapes any special character in the given text and returns the result.
+func EscapeText(text string) string {
+  buffer := bytes.NewBufferString("")
+  xml.EscapeText(buffer, []byte(text))
+
+  return buffer.String()
+}

vendor/github.com/samedi/caldav-go/lib/components.go

@@ -0,0 +1,8 @@
+package lib
+
+const (
+  VCALENDAR = "VCALENDAR"
+  VEVENT    = "VEVENT"
+  VJOURNAL  = "VJOURNAL"
+  VTODO     = "VTODO"
+)

vendor/github.com/samedi/caldav-go/lib/paths.go

@@ -0,0 +1,10 @@
+package lib
+
+import (
+  "path/filepath"
+)
+
+func ToSlashPath(path string) string {
+  cleanPath := filepath.Clean(path)
+  return filepath.ToSlash(cleanPath)
+}

vendor/github.com/samedi/caldav-go/lib/strbuff.go

@@ -0,0 +1,18 @@
+package lib
+
+import (
+  "fmt"
+  "bytes"
+)
+
+type StringBuffer struct {
+  buffer bytes.Buffer
+}
+
+func (b *StringBuffer) Write(format string, elem ...interface{}) {
+  b.buffer.WriteString(fmt.Sprintf(format, elem...))
+}
+
+func (b *StringBuffer) String() string {
+  return b.buffer.String()
+}

vendor/github.com/samedi/caldav-go/test.sh

@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+
+go test -race ./...
+rm -rf test-data

vendor/github.com/samedi/caldav-go/version.go

@@ -0,0 +1,5 @@
+package caldav
+
+const (
+  VERSION = "3.0.0"
+)