Курнат Андрей
351 lines
12 KiB
Go
351 lines
12 KiB
Go
package svc
|
|
|
|
import (
|
|
"context"
|
|
"encoding/xml"
|
|
"fmt"
|
|
"io"
|
|
"net/http"
|
|
"net/url"
|
|
"path"
|
|
"slices"
|
|
"strconv"
|
|
"strings"
|
|
|
|
userv1beta1 "github.com/cs3org/go-cs3apis/cs3/identity/user/v1beta1"
|
|
provider "github.com/cs3org/go-cs3apis/cs3/storage/provider/v1beta1"
|
|
merrors "go-micro.dev/v4/errors"
|
|
"go-micro.dev/v4/metadata"
|
|
|
|
revactx "github.com/opencloud-eu/reva/v2/pkg/ctx"
|
|
"github.com/opencloud-eu/reva/v2/pkg/storagespace"
|
|
"github.com/opencloud-eu/reva/v2/pkg/tags"
|
|
"github.com/opencloud-eu/reva/v2/pkg/utils"
|
|
|
|
searchmsg "github.com/qsfera/server/protogen/gen/qsfera/messages/search/v0"
|
|
searchsvc "github.com/qsfera/server/protogen/gen/qsfera/services/search/v0"
|
|
"github.com/qsfera/server/services/thumbnails/pkg/thumbnail"
|
|
"github.com/qsfera/server/services/webdav/pkg/constants"
|
|
"github.com/qsfera/server/services/webdav/pkg/net"
|
|
"github.com/qsfera/server/services/webdav/pkg/prop"
|
|
"github.com/qsfera/server/services/webdav/pkg/propfind"
|
|
)
|
|
|
|
const (
|
|
elementNameSearchFiles = "search-files"
|
|
// TODO elementNameFilterFiles = "filter-files"
|
|
)
|
|
|
|
// Search is the endpoint for retrieving search results for REPORT requests
|
|
func (g Webdav) Search(w http.ResponseWriter, r *http.Request) {
|
|
logger := g.log.SubloggerWithRequestID(r.Context())
|
|
t := r.Header.Get(revactx.TokenHeader)
|
|
|
|
gatewayClient, err := g.gatewaySelector.Next()
|
|
if err != nil {
|
|
logger.Error().Err(err).Msg("could not get reva gatewayClient")
|
|
renderError(w, r, errInternalError("could not get reva gatewayClient"))
|
|
return
|
|
}
|
|
|
|
user, err := whoami(gatewayClient, r.Context(), t)
|
|
if err != nil {
|
|
logger.Error().Err(err).Msg("could not get user")
|
|
renderError(w, r, errInternalError("could not get user"))
|
|
return
|
|
}
|
|
|
|
rep, err := readReport(r.Body)
|
|
if err != nil {
|
|
renderError(w, r, errBadRequest(err.Error()))
|
|
logger.Debug().Err(err).Msg("error reading report")
|
|
return
|
|
}
|
|
|
|
if rep.SearchFiles == nil {
|
|
renderError(w, r, errBadRequest("missing search-files tag"))
|
|
logger.Debug().Err(err).Msg("error reading report")
|
|
return
|
|
}
|
|
|
|
ctx := revactx.ContextSetToken(r.Context(), t)
|
|
ctx = metadata.Set(ctx, revactx.TokenHeader, t)
|
|
|
|
req := &searchsvc.SearchRequest{
|
|
Query: rep.SearchFiles.Search.Pattern,
|
|
PageSize: int32(rep.SearchFiles.Search.Limit),
|
|
}
|
|
|
|
// Limit search to the according space when searching /dav/spaces/
|
|
if strings.HasPrefix(r.URL.Path, "/dav/spaces") {
|
|
space := strings.TrimPrefix(r.URL.Path, "/dav/spaces/")
|
|
rid, err := storagespace.ParseID(space)
|
|
if err != nil {
|
|
logger.Debug().Err(err).Msg("error parsing the space id for filtering")
|
|
} else {
|
|
req.Ref = &searchmsg.Reference{
|
|
ResourceId: &searchmsg.ResourceID{
|
|
StorageId: rid.StorageId,
|
|
SpaceId: rid.SpaceId,
|
|
OpaqueId: rid.SpaceId,
|
|
},
|
|
}
|
|
}
|
|
}
|
|
|
|
rsp, err := g.searchClient.Search(ctx, req)
|
|
if err != nil {
|
|
e := merrors.Parse(err.Error())
|
|
switch e.Code {
|
|
case http.StatusBadRequest:
|
|
renderError(w, r, errBadRequest(e.Detail))
|
|
default:
|
|
renderError(w, r, errInternalError(err.Error()))
|
|
}
|
|
logger.Error().Err(err).Msg("could not get search results")
|
|
return
|
|
}
|
|
g.sendSearchResponse(rsp, w, r, user)
|
|
}
|
|
|
|
func (g Webdav) sendSearchResponse(rsp *searchsvc.SearchResponse, w http.ResponseWriter, r *http.Request, user *userv1beta1.User) {
|
|
logger := g.log.SubloggerWithRequestID(r.Context())
|
|
responsesXML, err := multistatusResponse(r.Context(), g.config.QsferaPublicURL, rsp.Matches, user)
|
|
if err != nil {
|
|
logger.Error().Err(err).Msg("error formatting propfind")
|
|
w.WriteHeader(http.StatusInternalServerError)
|
|
return
|
|
}
|
|
w.Header().Set(net.HeaderDav, "1, 3, extended-mkcol")
|
|
w.Header().Set(net.HeaderContentType, "application/xml; charset=utf-8")
|
|
if len(rsp.Matches) > 0 {
|
|
w.Header().Set(net.HeaderContentRange, fmt.Sprintf("rows 0-%d/%d", len(rsp.Matches)-1, rsp.TotalMatches))
|
|
}
|
|
w.WriteHeader(http.StatusMultiStatus)
|
|
if _, err := w.Write(responsesXML); err != nil {
|
|
logger.Err(err).Msg("error writing response")
|
|
}
|
|
}
|
|
|
|
// multistatusResponse converts a list of matches into a multistatus response string
|
|
func multistatusResponse(ctx context.Context, publicURL string, matches []*searchmsg.Match, user *userv1beta1.User) ([]byte, error) {
|
|
responses := make([]*propfind.ResponseXML, 0, len(matches))
|
|
for i := range matches {
|
|
res, err := matchToPropResponse(ctx, publicURL, matches[i], user)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
responses = append(responses, res)
|
|
}
|
|
|
|
msr := propfind.NewMultiStatusResponseXML()
|
|
msr.Responses = responses
|
|
msg, err := xml.Marshal(msr)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return msg, nil
|
|
}
|
|
|
|
func matchToPropResponse(ctx context.Context, publicURL string, match *searchmsg.Match, user *userv1beta1.User) (*propfind.ResponseXML, error) {
|
|
// unfortunately, search uses own versions of ResourceId and Ref. So we need to assert them here
|
|
var (
|
|
ref string
|
|
err error
|
|
)
|
|
|
|
// to copy PROPFIND behaviour, we need to deliver different ids
|
|
// for shares it needs to be sharestorageproviderid!shareid
|
|
// for other spaces it needs to be storageproviderid$spaceid
|
|
switch match.Entity.Ref.ResourceId.StorageId {
|
|
default:
|
|
ref, err = storagespace.FormatReference(&provider.Reference{
|
|
ResourceId: &provider.ResourceId{
|
|
StorageId: match.Entity.Ref.ResourceId.StorageId,
|
|
SpaceId: match.Entity.Ref.ResourceId.SpaceId,
|
|
},
|
|
Path: match.Entity.Ref.Path,
|
|
})
|
|
case utils.ShareStorageProviderID:
|
|
ref, err = storagespace.FormatReference(&provider.Reference{
|
|
ResourceId: &provider.ResourceId{
|
|
//StorageId: match.Entity.Ref.ResourceId.StorageId,
|
|
SpaceId: match.Entity.Ref.ResourceId.SpaceId,
|
|
OpaqueId: match.Entity.Ref.ResourceId.OpaqueId,
|
|
},
|
|
Path: match.Entity.Ref.Path,
|
|
})
|
|
}
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
response := propfind.ResponseXML{
|
|
Href: net.EncodePath(path.Join("/remote.php/dav/spaces/", ref)),
|
|
Propstat: []propfind.PropstatXML{},
|
|
}
|
|
|
|
propstatOK := propfind.PropstatXML{
|
|
Status: "HTTP/1.1 200 OK",
|
|
Prop: []prop.PropertyXML{},
|
|
}
|
|
|
|
propstatOK.Prop = append(propstatOK.Prop, prop.Escaped("oc:fileid", storagespace.FormatResourceID(&provider.ResourceId{
|
|
StorageId: match.Entity.Id.StorageId,
|
|
SpaceId: match.Entity.Id.SpaceId,
|
|
OpaqueId: match.Entity.Id.OpaqueId,
|
|
})))
|
|
if match.Entity.ParentId != nil {
|
|
propstatOK.Prop = append(propstatOK.Prop, prop.Escaped("oc:file-parent", storagespace.FormatResourceID(&provider.ResourceId{
|
|
StorageId: match.Entity.ParentId.StorageId,
|
|
SpaceId: match.Entity.ParentId.SpaceId,
|
|
OpaqueId: match.Entity.ParentId.OpaqueId,
|
|
})))
|
|
}
|
|
if match.Entity.Ref.ResourceId.StorageId == utils.ShareStorageProviderID {
|
|
propstatOK.Prop = append(propstatOK.Prop, prop.Escaped("oc:shareid", match.Entity.Ref.ResourceId.OpaqueId))
|
|
propstatOK.Prop = append(propstatOK.Prop, prop.Escaped("oc:shareroot", match.Entity.ShareRootName))
|
|
propstatOK.Prop = append(propstatOK.Prop, prop.Escaped("oc:remote-item-id", storagespace.FormatResourceID(&provider.ResourceId{
|
|
StorageId: match.Entity.GetRemoteItemId().GetStorageId(),
|
|
SpaceId: match.Entity.GetRemoteItemId().GetSpaceId(),
|
|
OpaqueId: match.Entity.GetRemoteItemId().GetOpaqueId(),
|
|
})))
|
|
}
|
|
propstatOK.Prop = append(propstatOK.Prop, prop.Escaped("oc:name", match.Entity.Name))
|
|
propstatOK.Prop = append(propstatOK.Prop, prop.Escaped("d:getlastmodified", match.Entity.LastModifiedTime.AsTime().Format(constants.RFC1123)))
|
|
propstatOK.Prop = append(propstatOK.Prop, prop.Escaped("oc:permissions", match.Entity.Permissions))
|
|
propstatOK.Prop = append(propstatOK.Prop, prop.Escaped("oc:highlights", match.Entity.Highlights))
|
|
propstatOK.Prop = append(propstatOK.Prop, prop.Escaped("d:getcontenttype", match.Entity.MimeType))
|
|
_, isSupportedMimeType := thumbnail.SupportedMimeTypes[match.Entity.MimeType]
|
|
if isSupportedMimeType {
|
|
propstatOK.Prop = append(propstatOK.Prop, prop.Escaped("oc:has-preview", "1"))
|
|
} else {
|
|
propstatOK.Prop = append(propstatOK.Prop, prop.Escaped("oc:has-preview", "0"))
|
|
}
|
|
|
|
t := tags.New(match.Entity.Tags...)
|
|
propstatOK.Prop = append(propstatOK.Prop, prop.Escaped("oc:tags", t.AsList()))
|
|
|
|
// those seem empty - bug?
|
|
propstatOK.Prop = append(propstatOK.Prop, prop.Escaped("d:getetag", match.Entity.Etag))
|
|
|
|
size := strconv.FormatUint(match.Entity.Size, 10)
|
|
if match.Entity.Type == uint64(provider.ResourceType_RESOURCE_TYPE_CONTAINER) {
|
|
propstatOK.Prop = append(propstatOK.Prop, prop.Raw("d:resourcetype", "<d:collection/>"))
|
|
propstatOK.Prop = append(propstatOK.Prop, prop.Escaped("oc:size", size))
|
|
} else {
|
|
propstatOK.Prop = append(propstatOK.Prop,
|
|
prop.Escaped("d:resourcetype", ""),
|
|
prop.Escaped("d:getcontentlength", size),
|
|
)
|
|
}
|
|
score := strconv.FormatFloat(float64(match.Score), 'f', -1, 64)
|
|
propstatOK.Prop = append(propstatOK.Prop, prop.Escaped("oc:score", score))
|
|
|
|
if privateURL, err := url.Parse(publicURL); err == nil && match.Entity.Id != nil {
|
|
privateURL.Path = path.Join(privateURL.Path, "f", storagespace.FormatResourceID(&provider.ResourceId{
|
|
StorageId: match.Entity.Id.StorageId,
|
|
SpaceId: match.Entity.Id.SpaceId,
|
|
OpaqueId: match.Entity.Id.OpaqueId,
|
|
}))
|
|
propstatOK.Prop = append(propstatOK.Prop, prop.Escaped("oc:privatelink", privateURL.String()))
|
|
}
|
|
|
|
// enrich results with favorite flag for the user performing the search
|
|
if slices.Contains(match.Entity.Favorites, user.Id.OpaqueId) {
|
|
propstatOK.Prop = append(propstatOK.Prop, prop.Escaped("oc:favorite", "1"))
|
|
}
|
|
|
|
if len(propstatOK.Prop) > 0 {
|
|
response.Propstat = append(response.Propstat, propstatOK)
|
|
}
|
|
|
|
return &response, nil
|
|
}
|
|
|
|
func hasPreview(md *provider.ResourceInfo, appendToOK func(p ...prop.PropertyXML)) {
|
|
_, match := thumbnail.SupportedMimeTypes[md.MimeType]
|
|
if match {
|
|
appendToOK(prop.Escaped("oc:has-preview", "1"))
|
|
} else {
|
|
appendToOK(prop.Escaped("oc:has-preview", "0"))
|
|
}
|
|
}
|
|
|
|
type report struct {
|
|
SearchFiles *reportSearchFiles
|
|
// FilterFiles TODO add this for tag based search
|
|
FilterFiles *reportFilterFiles `xml:"filter-files"`
|
|
}
|
|
type reportSearchFiles struct {
|
|
XMLName xml.Name `xml:"search-files"`
|
|
Lang string `xml:"xml:lang,attr,omitempty"`
|
|
Prop Props `xml:"DAV: prop"`
|
|
Search reportSearchFilesSearch `xml:"search"`
|
|
}
|
|
type reportSearchFilesSearch struct {
|
|
Pattern string `xml:"pattern"`
|
|
Limit int `xml:"limit"`
|
|
Offset int `xml:"offset"`
|
|
}
|
|
|
|
type reportFilterFiles struct {
|
|
XMLName xml.Name `xml:"filter-files"`
|
|
Lang string `xml:"xml:lang,attr,omitempty"`
|
|
Prop Props `xml:"DAV: prop"`
|
|
Rules reportFilterFilesRules `xml:"filter-rules"`
|
|
}
|
|
|
|
type reportFilterFilesRules struct {
|
|
Favorite bool `xml:"favorite"`
|
|
SystemTag int `xml:"systemtag"`
|
|
}
|
|
|
|
// Props represents properties related to a resource
|
|
// http://www.webdav.org/specs/rfc4918.html#ELEMENT_prop (for propfind)
|
|
type Props []xml.Name
|
|
|
|
// XML holds the xml representation of a propfind
|
|
// http://www.webdav.org/specs/rfc4918.html#ELEMENT_propfind
|
|
type XML struct {
|
|
XMLName xml.Name `xml:"DAV: propfind"`
|
|
Allprop *struct{} `xml:"DAV: allprop"`
|
|
Propname *struct{} `xml:"DAV: propname"`
|
|
Prop Props `xml:"DAV: prop"`
|
|
Include Props `xml:"DAV: include"`
|
|
}
|
|
|
|
func readReport(r io.Reader) (rep *report, err error) {
|
|
decoder := xml.NewDecoder(r)
|
|
rep = &report{}
|
|
for {
|
|
t, err := decoder.Token()
|
|
if err == io.EOF {
|
|
// io.EOF is a successful end
|
|
return rep, nil
|
|
}
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if v, ok := t.(xml.StartElement); ok {
|
|
if v.Name.Local == elementNameSearchFiles {
|
|
var repSF reportSearchFiles
|
|
err = decoder.DecodeElement(&repSF, &v)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
rep.SearchFiles = &repSF
|
|
/*
|
|
} else if v.Name.Local == elementNameFilterFiles {
|
|
var repFF reportFilterFiles
|
|
err = decoder.DecodeElement(&repFF, &v)
|
|
if err != nil {
|
|
return nil, http.StatusBadRequest, err
|
|
}
|
|
rep.FilterFiles = &repFF
|
|
*/
|
|
}
|
|
}
|
|
}
|
|
}
|