Better caldav support (#73)
This commit is contained in:
konrad
229
vendor/github.com/samedi/caldav-go/data/storage.go
generated
vendored
Normal file
229
vendor/github.com/samedi/caldav-go/data/storage.go
generated
vendored
Normal file
@ -0,0 +1,229 @@
|
||||
package data
|
||||
|
||||
import (
|
||||
"github.com/samedi/caldav-go/errs"
|
||||
"github.com/samedi/caldav-go/files"
|
||||
"io/ioutil"
|
||||
"log"
|
||||
"os"
|
||||
)
|
||||
|
||||
// Storage is the inteface responsible for the CRUD operations on the CalDAV resources. It represents
|
||||
// where the resources should be fetched from and the various operations which can be performed on it.
|
||||
// This is the interface one should implement in case it needs a custom storage strategy, like fetching
|
||||
// data from the cloud, local DB, etc. After that, the custom storage implementation can be setup to be used
|
||||
// in the server by passing the object instance to `caldav.SetupStorage`.
|
||||
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. Non-collection resources are just plain files.
|
||||
// Each file represents then a CalAV resource and the data expects to contain the iCal data to feed the calendar events.
|
||||
type FileStorage struct {
|
||||
}
|
||||
|
||||
// GetResources get the file resources based on the `rpath`. See `Storage.GetResources` doc.
|
||||
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
|
||||
}
|
||||
|
||||
// GetResourcesByFilters get the file resources based on the `rpath` and a set of filters. See `Storage.GetResourcesByFilters` doc.
|
||||
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
|
||||
}
|
||||
|
||||
// GetResourcesByList get a list of file resources based on a list of `rpaths`. See `Storage.GetResourcesByList` doc.
|
||||
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
|
||||
}
|
||||
|
||||
// GetResource fetches and returns a single resource for a `rpath`. See `Storage.GetResoure` doc.
|
||||
func (fs *FileStorage) GetResource(rpath string) (*Resource, bool, error) {
|
||||
// For simplicity we just return the shallow resource.
|
||||
return fs.GetShallowResource(rpath)
|
||||
}
|
||||
|
||||
// GetShallowResource fetches and returns a single resource file/directory without any related children. See `Storage.GetShallowResource` doc.
|
||||
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
|
||||
}
|
||||
|
||||
// CreateResource creates a file resource with the provided `content`. See `Storage.CreateResource` doc.
|
||||
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
|
||||
}
|
||||
|
||||
// UpdateResource updates a file resource with the provided `content`. See `Storage.UpdateResource` doc.
|
||||
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
|
||||
}
|
||||
|
||||
// DeleteResource deletes a file resource (and possibly all its children in case of a collection). See `Storage.DeleteResource` doc.
|
||||
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
|
||||
}
|
||||
Reference in New Issue
Block a user