first draft for listing favorites

changelog/unreleased/list-favorites.md

@@ -0,0 +1,10 @@
+Bugfix: Fix behavior for foobar (in present tense)
+
+We've fixed the behavior for foobar, a long-standing annoyance for Reva
+users.
+
+The text in the paragraphs is written in past tense. The last section is a list
+of issue URLs, PR URLs and other URLs. The first issue ID (or the first PR ID,
+in case there aren't any issue links) is used as the primary ID.
+
+https://github.com/cs3org/reva/pull/2071

internal/http/services/owncloud/ocdav/ocdav.go

@@ -40,6 +40,7 @@ import (
 	"github.com/cs3org/reva/pkg/rhttp/global"
 	"github.com/cs3org/reva/pkg/rhttp/router"
 	"github.com/cs3org/reva/pkg/sharedconf"
+	"github.com/cs3org/reva/pkg/storage/favorite"
 	"github.com/cs3org/reva/pkg/storage/utils/templates"
 	"github.com/mitchellh/mapstructure"
 	"github.com/pkg/errors"
@@ -110,10 +111,11 @@ func (c *Config) init() {
 }
 
 type svc struct {
-	c             *Config
-	webDavHandler *WebDavHandler
-	davHandler    *DavHandler
-	client        *http.Client
+	c                *Config
+	webDavHandler    *WebDavHandler
+	davHandler       *DavHandler
+	favoritesManager favorite.Manager
+	client           *http.Client
 }
 
 // New returns a new ocdav
@@ -133,6 +135,7 @@ func New(m map[string]interface{}, log *zerolog.Logger) (global.Service, error)
 			rhttp.Timeout(time.Duration(conf.Timeout*int64(time.Second))),
 			rhttp.Insecure(conf.Insecure),
 		),
+		favoritesManager: favorite.NewInMemoryManager(),
 	}
 	// initialize handlers and set default configs
 	if err := s.webDavHandler.init(conf.WebdavNamespace, true); err != nil {

internal/http/services/owncloud/ocdav/propfind.go

@@ -134,7 +134,7 @@ func (s *svc) handleSpacesPropfind(w http.ResponseWriter, r *http.Request, space
 }
 
 func (s *svc) propfindResponse(ctx context.Context, w http.ResponseWriter, r *http.Request, namespace string, pf propfindXML, parentInfo *provider.ResourceInfo, resourceInfos []*provider.ResourceInfo, log zerolog.Logger) {
-	propRes, err := s.formatPropfind(ctx, &pf, resourceInfos, namespace)
+	propRes, err := s.multistatusResponse(ctx, &pf, resourceInfos, namespace)
 	if err != nil {
 		log.Error().Err(err).Msg("error formatting propfind")
 		w.WriteHeader(http.StatusInternalServerError)
@@ -342,7 +342,7 @@ func readPropfind(r io.Reader) (pf propfindXML, status int, err error) {
 	return pf, 0, nil
 }
 
-func (s *svc) formatPropfind(ctx context.Context, pf *propfindXML, mds []*provider.ResourceInfo, ns string) (string, error) {
+func (s *svc) multistatusResponse(ctx context.Context, pf *propfindXML, mds []*provider.ResourceInfo, ns string) (string, error) {
 	responses := make([]*responseXML, 0, len(mds))
 	for i := range mds {
 		res, err := s.mdToPropResponse(ctx, pf, mds[i], ns)

internal/http/services/owncloud/ocdav/proppatch.go

@@ -30,6 +30,7 @@ import (
 	rpc "github.com/cs3org/go-cs3apis/cs3/rpc/v1beta1"
 	provider "github.com/cs3org/go-cs3apis/cs3/storage/provider/v1beta1"
 	"github.com/cs3org/reva/pkg/appctx"
+	ctxpkg "github.com/cs3org/reva/pkg/ctx"
 	rtrace "github.com/cs3org/reva/pkg/trace"
 	"github.com/pkg/errors"
 	"github.com/rs/zerolog"
@@ -232,6 +233,19 @@ func (s *svc) handleProppatch(ctx context.Context, w http.ResponseWriter, r *htt
 					HandleErrorStatus(&log, w, res.Status)
 					return nil, nil, false
 				}
+				if key == "http://owncloud.org/ns/favorite" {
+					statRes, err := c.Stat(ctx, &provider.StatRequest{Ref: ref})
+					if err != nil {
+						w.WriteHeader(http.StatusInternalServerError)
+						return nil, nil, false
+					}
+					currentUser := ctxpkg.ContextMustGetUser(ctx)
+					err = s.favoritesManager.UnsetFavorite(currentUser.Id, statRes.Info)
+					if err != nil {
+						w.WriteHeader(http.StatusInternalServerError)
+						return nil, nil, false
+					}
+				}
 				removedProps = append(removedProps, propNameXML)
 			} else {
 				sreq.ArbitraryMetadata.Metadata[key] = value
@@ -259,6 +273,20 @@ func (s *svc) handleProppatch(ctx context.Context, w http.ResponseWriter, r *htt
 
 				acceptedProps = append(acceptedProps, propNameXML)
 				delete(sreq.ArbitraryMetadata.Metadata, key)
+
+				if key == "http://owncloud.org/ns/favorite" {
+					statRes, err := c.Stat(ctx, &provider.StatRequest{Ref: ref})
+					if err != nil {
+						w.WriteHeader(http.StatusInternalServerError)
+						return nil, nil, false
+					}
+					currentUser := ctxpkg.ContextMustGetUser(ctx)
+					err = s.favoritesManager.SetFavorite(currentUser.Id, statRes.Info)
+					if err != nil {
+						w.WriteHeader(http.StatusInternalServerError)
+						return nil, nil, false
+					}
+				}
 			}
 		}
 		// FIXME: in case of error, need to set all properties back to the original state,

internal/http/services/owncloud/ocdav/publicfile.go

@@ -186,7 +186,7 @@ func (s *svc) handlePropfindOnToken(w http.ResponseWriter, r *http.Request, ns s
 
 	infos := s.getPublicFileInfos(onContainer, depth == "0", tokenStatInfo)
 
-	propRes, err := s.formatPropfind(ctx, &pf, infos, ns)
+	propRes, err := s.multistatusResponse(ctx, &pf, infos, ns)
 	if err != nil {
 		sublog.Error().Err(err).Msg("error formatting propfind")
 		w.WriteHeader(http.StatusInternalServerError)

internal/http/services/owncloud/ocdav/report.go

@@ -24,6 +24,12 @@ import (
 	"net/http"
 
 	"github.com/cs3org/reva/pkg/appctx"
+	ctxpkg "github.com/cs3org/reva/pkg/ctx"
+)
+
+const (
+	elementNameSearchFiles = "search-files"
+	elementNameFilterFiles = "filter-files"
 )
 
 func (s *svc) handleReport(w http.ResponseWriter, r *http.Request, ns string) {
@@ -42,6 +48,11 @@ func (s *svc) handleReport(w http.ResponseWriter, r *http.Request, ns string) {
 		return
 	}
 
+	if rep.FilterFiles != nil {
+		s.doFilterFiles(w, r, rep.FilterFiles, ns)
+		return
+	}
+
 	// TODO(jfd): implement report
 
 	w.WriteHeader(http.StatusNotImplemented)
@@ -59,9 +70,39 @@ func (s *svc) doSearchFiles(w http.ResponseWriter, r *http.Request, sf *reportSe
 	w.WriteHeader(http.StatusNotImplemented)
 }
 
+func (s *svc) doFilterFiles(w http.ResponseWriter, r *http.Request, ff *reportFilterFiles, namespace string) {
+	ctx := r.Context()
+	log := appctx.GetLogger(ctx)
+
+	if ff.Rules.Favorite {
+		// List the users favorite resources.
+		currentUser := ctxpkg.ContextMustGetUser(ctx)
+		favorites, err := s.favoritesManager.ListFavorites(currentUser.Id)
+		if err != nil {
+			log.Error().Err(err).Msg("error getting favorites")
+			w.WriteHeader(http.StatusInternalServerError)
+			return
+		}
+
+		responsesXML, err := s.multistatusResponse(ctx, &propfindXML{Prop: ff.Prop}, favorites, namespace)
+		if err != nil {
+			log.Error().Err(err).Msg("error formatting propfind")
+			w.WriteHeader(http.StatusInternalServerError)
+			return
+		}
+		w.Header().Set(HeaderDav, "1, 3, extended-mkcol")
+		w.Header().Set(HeaderContentType, "application/xml; charset=utf-8")
+		w.WriteHeader(http.StatusMultiStatus)
+		if _, err := w.Write([]byte(responsesXML)); err != nil {
+			log.Err(err).Msg("error writing response")
+		}
+	}
+}
+
 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"`
@@ -75,6 +116,18 @@ type reportSearchFilesSearch struct {
 	Offset  int    `xml:"offset"`
 }
 
+type reportFilterFiles struct {
+	XMLName xml.Name               `xml:"filter-files"`
+	Lang    string                 `xml:"xml:lang,attr,omitempty"`
+	Prop    propfindProps          `xml:"DAV: prop"`
+	Rules   reportFilterFilesRules `xml:"filter-rules"`
+}
+
+type reportFilterFilesRules struct {
+	Favorite  bool `xml:"favorite"`
+	SystemTag int  `xml:"systemtag"`
+}
+
 func readReport(r io.Reader) (rep *report, status int, err error) {
 	decoder := xml.NewDecoder(r)
 	rep = &report{}
@@ -89,13 +142,20 @@ func readReport(r io.Reader) (rep *report, status int, err error) {
 		}
 
 		if v, ok := t.(xml.StartElement); ok {
-			if v.Name.Local == "search-files" {
+			if v.Name.Local == elementNameSearchFiles {
 				var repSF reportSearchFiles
 				err = decoder.DecodeElement(&repSF, &v)
 				if err != nil {
 					return nil, http.StatusBadRequest, 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
 			}
 		}
 	}

internal/http/services/owncloud/ocdav/report_test.go

@@ -0,0 +1,63 @@
+// Copyright 2018-2021 CERN
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// In applying this license, CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+package ocdav
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestUnmarshallReportFilterFiles(t *testing.T) {
+	ffXML := `<oc:filter-files  xmlns:d="DAV:" xmlns:oc="http://owncloud.org/ns">
+    <d:prop>
+        <d:getlastmodified />
+        <d:getetag />
+        <d:getcontenttype />
+        <d:resourcetype />
+        <oc:fileid />
+        <oc:permissions />
+        <oc:size />
+        <d:getcontentlength />
+        <oc:tags />
+        <oc:favorite />
+        <d:lockdiscovery />
+        <oc:comments-unread />
+        <oc:owner-display-name />
+        <oc:share-types />
+    </d:prop>
+    <oc:filter-rules>
+        <oc:favorite>1</oc:favorite>
+    </oc:filter-rules>
+</oc:filter-files>`
+
+	reader := strings.NewReader(ffXML)
+
+	report, status, err := readReport(reader)
+	if status != 0 || err != nil {
+		t.Error("Failed to unmarshal filter-files xml")
+	}
+
+	if report.FilterFiles == nil {
+		t.Error("Failed to unmarshal filter-files xml. FilterFiles is nil")
+	}
+
+	if report.FilterFiles.Rules.Favorite == false {
+		t.Error("Failed to correctly unmarshal filter-rules. Favorite is expected to be true.")
+	}
+}

internal/http/services/owncloud/ocdav/versions.go

@@ -164,7 +164,7 @@ func (h *VersionsHandler) doListVersions(w http.ResponseWriter, r *http.Request,
 		infos = append(infos, vi)
 	}
 
-	propRes, err := s.formatPropfind(ctx, &pf, infos, "")
+	propRes, err := s.multistatusResponse(ctx, &pf, infos, "")
 	if err != nil {
 		sublog.Error().Err(err).Msg("error formatting propfind")
 		w.WriteHeader(http.StatusInternalServerError)

pkg/storage/favorite/favorite.go

@@ -0,0 +1,67 @@
+// Copyright 2018-2021 CERN
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// In applying this license, CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+package favorite
+
+import (
+	user "github.com/cs3org/go-cs3apis/cs3/identity/user/v1beta1"
+	provider "github.com/cs3org/go-cs3apis/cs3/storage/provider/v1beta1"
+)
+
+// Manager defines an interface for a favorites manager.
+type Manager interface {
+	// ListFavorites returns all resources that were favorited by a user.
+	ListFavorites(userID *user.UserId) ([]*provider.ResourceInfo, error)
+	// SetFavorite marks a resource as favorited by a user.
+	SetFavorite(userID *user.UserId, id *provider.ResourceInfo) error
+	// UnsetFavorite unmarks a resource as favorited by a user.
+	UnsetFavorite(userID *user.UserId, id *provider.ResourceInfo) error
+}
+
+// NewInMemoryManager returns an instance of a favorites manager using an in-memory storage.
+func NewInMemoryManager() Manager {
+	return InMemoryManager{favorites: make(map[string]map[string]*provider.ResourceInfo)}
+}
+
+// InMemoryManager implements the Manager interface to manage favorites using an in-memory storage.
+type InMemoryManager struct {
+	favorites map[string]map[string]*provider.ResourceInfo
+}
+
+func (m InMemoryManager) ListFavorites(userID *user.UserId) ([]*provider.ResourceInfo, error) {
+	favorites := make([]*provider.ResourceInfo, 0, len(m.favorites[userID.OpaqueId]))
+	for _, info := range m.favorites[userID.OpaqueId] {
+		favorites = append(favorites, info)
+	}
+	return favorites, nil
+}
+
+func (m InMemoryManager) SetFavorite(userID *user.UserId, info *provider.ResourceInfo) error {
+	if m.favorites[userID.OpaqueId] == nil {
+		m.favorites[userID.OpaqueId] = make(map[string]*provider.ResourceInfo)
+	}
+	m.favorites[userID.OpaqueId][info.Id.OpaqueId] = info
+
+	return nil
+}
+
+func (m InMemoryManager) UnsetFavorite(userID *user.UserId, info *provider.ResourceInfo) error {
+	delete(m.favorites[userID.OpaqueId], info.Id.OpaqueId)
+
+	return nil
+}