libdav package - code.pfad.fr/gopim/webdav

import "code.pfad.fr/gopim/webdav/libdav"

func ContextWith(ctx context.Context, name property.Responder, resp func(p property.Responder) (interface{}, error)) context.Context

func ContextWithCurrentUserPrincipal(ctx context.Context, cup func(p property.Responder) (interface{}, error)) context.Context

func DecodeXMLRequest[T any](r *http.Request, decode func(http.Header, *xml.Decoder) (T, error)) (v T, err error)

type Depth int

const (
	// DepthZero indicates that the request applies only to the resource.
	DepthZero Depth = 0
	// DepthOne indicates that the request applies to the resource and its
	// internal members only.
	DepthOne Depth = 1
	// DepthInfinity indicates that the request applies to the resource and all
	// of its members.
	DepthInfinity Depth = -1
)

func DecodeDepth(header http.Header) (Depth, error)

func (d Depth) String() string

type Get struct {
	Request        *http.Request
	ResponseWriter http.ResponseWriter
}

func (g Get) ServeContent(contentType string, etagQuoted string, modtime time.Time, content io.ReadSeeker)

func (g Get) ServeList(names []string, modTime time.Time) error

type HTTPError interface {
	error
	StatusCode() int
}

func NewHTTPError(code int, err error) HTTPError

type HandleWriter interface {
	Handler
	Delete(req Request) error // recursive delete

	// rfc4918#section-9.7
	Put(req Request,
		header http.Header,
		body io.ReadCloser,
	) (statusCode int, headers http.Header, err error)
}

type Handler interface {
	Options(req Request) (caps []string, methods []string, err error)
	Get(req Request, get Get) error
	Propfind(req Request, propfind Propfind) ([]Response, error)
	Report(req Request, report Report) ([]Response, error)
}

type MultiStatus struct {
	XMLName             xml.Name   `xml:"DAV: multistatus"`
	Responses           []Response `xml:"response"`
	ResponseDescription string     `xml:"responsedescription,omitempty"`
	SyncToken           string     `xml:"sync-token,omitempty"`
}

func NewMultiStatus(resps ...Response) MultiStatus

type Overwrite bool

func DecodeOverwrite(header http.Header) (Overwrite, error)

func (o Overwrite) String() string

type PrincipalHandler struct {
	StatusHandler
	AddressbookHomeSet string
}

func (p PrincipalHandler) Options(req Request) (caps []string, methods []string, err error)

func (ph PrincipalHandler) Propfind(req Request, propfind Propfind) ([]Response, error)

type PropStat struct {
	Prop     PropsRequest
	Allprop  bool
	Propname bool
	// Include indicates additional props when Allprop is set
	Include []xml.Name
}

func (ps PropStat) Response(ctx context.Context, path string, props property.ResponseMap) Response

func (ps PropStat) Validate() error

type Propfind struct {
	PropStat PropStat

	Depth Depth
}

func DecodePropfind(header http.Header, dec *xml.Decoder) (Propfind, error)

func (pf Propfind) Response(ctx context.Context, path string, props property.ResponseMap) Response

type PropsRequest []struct {
	XMLName  xml.Name
	SubProps []struct {
		XMLName xml.Name
		Name    string `xml:"name,attr"`
	} `xml:",any"`
}

func (pr PropsRequest) Names() []xml.Name

func (pr PropsRequest) SubnameAttr(parent, child xml.Name) []string

type Propstat struct {
	Prop                []any          `xml:"prop>any"`
	Status              ResponseStatus `xml:"status"`
	Responsedescription string         `xml:"responsedescription,omitempty"`
	Error               any            `xml:"error,omitempty"`
}

type Report struct {
	Unmarshal func(m map[xml.Name]any) (xml.Name, error)
	Depth     Depth
}

func DecodeReport(header http.Header, dec *xml.Decoder) (Report, error)

type Request struct {
	Context              context.Context
	Segments             []string
	SegmentTrailingSlash bool
	Resource             Resource
}

func (r Request) Children() iter.Seq[Request]

func (r Request) Path() string

func (r Request) Segment(i int) string

type Resource struct {
	Handler  Handler
	Children map[string]Resource
	CatchAll *Resource
	IsLeaf   bool // true if not a collection
}

type Response struct {
	Href                property.Href   `xml:"href"`
	Propstats           []Propstat      `xml:"propstat,omitempty"`
	Responsedescription string          `xml:"responsedescription,omitempty"`
	Status              *ResponseStatus `xml:"status,omitempty"`
	Error               any             `xml:"error,omitempty"`
	Location            *property.Href  `xml:"location>href,omitempty"`
}

type ResponseStatus struct {
	Code int    // will default to 200 if left empty
	Text string // will be the default http status text for the code if left empty
}

func (s ResponseStatus) MarshalText() ([]byte, error)

func (s *ResponseStatus) UnmarshalText(b []byte) error

type StaticHandler struct {
	StatusHandler
	Caps       []string
	Properties property.ResponseMap
}

func (p StaticHandler) Options(req Request) (caps []string, methods []string, err error)

func (p StaticHandler) Propfind(req Request, propfind Propfind) ([]Response, error)

type StatusHandler struct {
	Code int
}

func (p StatusHandler) Delete(req Request) error

func (p StatusHandler) Get(req Request, get Get) error

func (p StatusHandler) Options(req Request) (caps []string, methods []string, err error)

func (p StatusHandler) Propfind(req Request, propfind Propfind) ([]Response, error)

func (p StatusHandler) Put(req Request, header http.Header, body io.ReadCloser) (statusCode int, headers http.Header, err error)

func (p StatusHandler) Report(req Request, report Report) ([]Response, error)