feat: track trash actors in cozyMetadata

Author: shepilov

docs/files.md

@@ -1758,6 +1758,12 @@ restored. Or, after some time, it will be removed from the trash and permanently
 destroyed.
 
 The file `trashed` attribute will be set to true.
+When a file or folder is moved to the trash, `cozyMetadata` also records:
+
+- `trashedAt`: the server timestamp of the trash action
+- `trashedBy`: the request actor that triggered the trash action, with:
+  - `kind`: `member` or `anonymous-share`
+  - `displayName` and `domain` for `member`
 
 ### GET /files/trash
 
@@ -1814,6 +1820,12 @@ Content-Type: application/vnd.api+json
           "createdByApp": "drive",
           "createdOn": "https://cozy.example.com/",
           "updatedAt": "2016-09-20T18:32:49Z",
+          "trashedAt": "2016-09-20T18:32:49Z",
+          "trashedBy": {
+            "kind": "member",
+            "displayName": "Alice",
+            "domain": "cozy.example.com"
+          },
           "uploadedAt": "2016-09-20T18:32:49Z",
           "uploadedOn": "https://cozy.example.com/",
           "uploadedBy": {
@@ -1852,6 +1864,12 @@ Content-Type: application/vnd.api+json
           "createdByApp": "drive",
           "createdOn": "https://cozy.example.com/",
           "updatedAt": "2016-09-20T18:32:49Z",
+          "trashedAt": "2016-09-20T18:32:49Z",
+          "trashedBy": {
+            "kind": "member",
+            "displayName": "Alice",
+            "domain": "cozy.example.com"
+          },
           "uploadedAt": "2016-09-20T18:32:49Z",
           "uploadedOn": "https://cozy.example.com/",
           "uploadedBy": {

docs/shared-drives.md

@@ -769,6 +769,13 @@ drive.
 #### POST /sharings/drives/trash/:file-id
 #### DELETE /sharings/drives/trash/:file-id
 
+Trash operations keep the same file metadata shape as `/files`: when an item is
+moved to the trash, `cozyMetadata.trashedAt` and `cozyMetadata.trashedBy` are
+exposed on both the caller side and the replicated shared-drive copies. On
+shared-drive requests, `trashedBy.kind` is `member` and
+`trashedBy.displayName` / `trashedBy.domain` are derived from the sharing
+member linked to the `DriveToken`.
+
 ## Share-by-link permissions
 
 The following routes manage share-by-link permissions scoped to files inside a

model/sharing/files.go

@@ -909,6 +909,11 @@ func copySafeFieldsToDir(target map[string]interface{}, dir *vfs.DirDoc) {
 				dir.CozyMetadata.UpdatedAt = at
 			}
 		}
+		if trashed, ok := meta["trashedAt"].(string); ok {
+			if at, err := time.Parse(time.RFC3339Nano, trashed); err == nil {
+				dir.CozyMetadata.TrashedAt = &at
+			}
+		}
 		if updates, ok := meta["updatedByApps"].([]map[string]interface{}); ok {
 			for _, update := range updates {
 				if slug, ok := update["slug"].(string); ok {
@@ -928,6 +933,21 @@ func copySafeFieldsToDir(target map[string]interface{}, dir *vfs.DirDoc) {
 				}
 			}
 		}
+		if trashedBy, ok := meta["trashedBy"].(map[string]interface{}); ok {
+			entry := &vfs.TrashedByEntry{}
+			if kind, ok := trashedBy["kind"].(string); ok {
+				entry.Kind = kind
+			}
+			if displayName, ok := trashedBy["displayName"].(string); ok {
+				entry.DisplayName = displayName
+			}
+			if domain, ok := trashedBy["domain"].(string); ok {
+				entry.Domain = domain
+			} else if legacyInstance, ok := trashedBy["instance"].(string); ok {
+				entry.Domain = legacyInstance
+			}
+			dir.CozyMetadata.TrashedBy = entry
+		}
 
 		// No upload* for directories
 		if account, ok := meta["sourceAccount"].(string); ok {

model/vfs/cozy_metadata.go

@@ -18,6 +18,20 @@ type UploadedByEntry struct {
 	Client  map[string]string `json:"oauthClient,omitempty"`
 }
 
+const (
+	// TrashedByKindMember identifies a concrete authenticated/member actor.
+	TrashedByKindMember = "member"
+	// TrashedByKindAnonymousShare identifies anonymous/public share access.
+	TrashedByKindAnonymousShare = "anonymous-share"
+)
+
+// TrashedByEntry identifies who sent a file or folder to the trash.
+type TrashedByEntry struct {
+	Kind        string `json:"kind,omitempty"`
+	DisplayName string `json:"displayName,omitempty"`
+	Domain      string `json:"domain,omitempty"`
+}
+
 // FilesCozyMetadata is an extended version of cozyMetadata with some specific fields.
 type FilesCozyMetadata struct {
 	metadata.CozyMetadata
@@ -29,6 +43,10 @@ type FilesCozyMetadata struct {
 	UploadedBy *UploadedByEntry `json:"uploadedBy,omitempty"`
 	// Instance URL where the content has been changed the last time
 	UploadedOn string `json:"uploadedOn,omitempty"`
+	// Date of the last trash action
+	TrashedAt *time.Time `json:"trashedAt,omitempty"`
+	// Information about who sent the file or folder to the trash
+	TrashedBy *TrashedByEntry `json:"trashedBy,omitempty"`
 }
 
 // NewCozyMetadata initializes a new FilesCozyMetadata struct
@@ -65,6 +83,17 @@ func (fcm *FilesCozyMetadata) Clone() *FilesCozyMetadata {
 		at := *fcm.UploadedAt
 		cloned.UploadedAt = &at
 	}
+	if fcm.TrashedAt != nil {
+		at := *fcm.TrashedAt
+		cloned.TrashedAt = &at
+	}
+	if fcm.TrashedBy != nil {
+		cloned.TrashedBy = &TrashedByEntry{
+			Kind:        fcm.TrashedBy.Kind,
+			DisplayName: fcm.TrashedBy.DisplayName,
+			Domain:      fcm.TrashedBy.Domain,
+		}
+	}
 	return &cloned
 }
 
@@ -149,6 +178,22 @@ func (fcm *FilesCozyMetadata) ToJSONDoc() map[string]interface{} {
 	if fcm.UploadedOn != "" {
 		doc["uploadedOn"] = fcm.UploadedOn
 	}
+	if fcm.TrashedAt != nil {
+		doc["trashedAt"] = *fcm.TrashedAt
+	}
+	if fcm.TrashedBy != nil {
+		trashed := make(map[string]interface{})
+		if fcm.TrashedBy.Kind != "" {
+			trashed["kind"] = fcm.TrashedBy.Kind
+		}
+		if fcm.TrashedBy.DisplayName != "" {
+			trashed["displayName"] = fcm.TrashedBy.DisplayName
+		}
+		if fcm.TrashedBy.Domain != "" {
+			trashed["domain"] = fcm.TrashedBy.Domain
+		}
+		doc["trashedBy"] = trashed
+	}
 	if fcm.SourceAccount != "" {
 		doc["sourceAccount"] = fcm.SourceAccount
 	}

model/vfs/cozy_metadata_test.go

@@ -89,3 +89,33 @@ func TestUpdatedByApp(t *testing.T) {
 	assert.Equal(t, "alice.cozy.localhost", fcm.UpdatedByApps[2].Instance)
 	assert.Equal(t, entry.Date, fcm.UpdatedByApps[2].Date)
 }
+
+func TestFilesCozyMetadataCloneAndToJSONDoc(t *testing.T) {
+	trashedAt := time.Now().UTC().Round(0)
+	fcm := NewCozyMetadata("alice.cozy.localhost")
+	fcm.TrashedAt = &trashedAt
+	fcm.TrashedBy = &TrashedByEntry{
+		Kind:        TrashedByKindMember,
+		DisplayName: "Alice",
+		Domain:      "alice.cozy.localhost",
+	}
+
+	cloned := fcm.Clone()
+	if assert.NotNil(t, cloned.TrashedAt) {
+		assert.Equal(t, trashedAt, *cloned.TrashedAt)
+	}
+	if assert.NotNil(t, cloned.TrashedBy) {
+		assert.Equal(t, fcm.TrashedBy, cloned.TrashedBy)
+		cloned.TrashedBy.DisplayName = "Bob"
+		assert.Equal(t, "Alice", fcm.TrashedBy.DisplayName)
+	}
+
+	doc := fcm.ToJSONDoc()
+	assert.Equal(t, trashedAt, doc["trashedAt"])
+	trashedBy, ok := doc["trashedBy"].(map[string]interface{})
+	if assert.True(t, ok) {
+		assert.Equal(t, TrashedByKindMember, trashedBy["kind"])
+		assert.Equal(t, "Alice", trashedBy["displayName"])
+		assert.Equal(t, "alice.cozy.localhost", trashedBy["domain"])
+	}
+}

web/files/files.go

@@ -731,10 +731,10 @@ func applyPatch(c echo.Context, fs vfs.VFS, patch *docPatch) (err error) {
 		}
 	} else if patch.Trash {
 		if dir != nil {
-			UpdateDirCozyMetadata(c, dir)
+			UpdateDirTrashCozyMetadata(c, dir)
 			dir, err = vfs.TrashDir(fs, dir)
 		} else {
-			UpdateFileCozyMetadata(c, file, false)
+			UpdateFileTrashCozyMetadata(c, file)
 			file, err = vfs.TrashFile(fs, file)
 		}
 	} else {
@@ -783,10 +783,10 @@ func applyPatches(c echo.Context, fs vfs.VFS, patches []*docPatch) (errors []*js
 			}
 		} else if patch.Trash {
 			if dir != nil {
-				UpdateDirCozyMetadata(c, dir)
+				UpdateDirTrashCozyMetadata(c, dir)
 				_, errp = vfs.TrashDir(fs, dir)
 			} else if file != nil {
-				UpdateFileCozyMetadata(c, file, false)
+				UpdateFileTrashCozyMetadata(c, file)
 				_, errp = vfs.TrashFile(fs, file)
 			}
 		} else if dir != nil {
@@ -1446,15 +1446,15 @@ func Trash(c echo.Context, sharedDrive *sharing.Sharing) error {
 	ensureCleanOldTrashedTrigger(instance)
 
 	if dir != nil {
-		UpdateDirCozyMetadata(c, dir)
+		UpdateDirTrashCozyMetadata(c, dir)
 		doc, errt := vfs.TrashDir(instance.VFS(), dir)
 		if errt != nil {
 			return WrapVfsError(errt)
 		}
 		return DirData(c, http.StatusOK, doc, sharedDrive)
 	}
 
-	UpdateFileCozyMetadata(c, file, false)
+	UpdateFileTrashCozyMetadata(c, file)
 	doc, errt := vfs.TrashFile(instance.VFS(), file)
 	if errt != nil {
 		return WrapVfsError(errt)
@@ -2489,6 +2489,33 @@ func UpdateFileCozyMetadata(c echo.Context, file *vfs.FileDoc, setUploadFields b
 	}
 }
 
+func UpdateDirTrashCozyMetadata(c echo.Context, dir *vfs.DirDoc) {
+	UpdateDirCozyMetadata(c, dir)
+	setTrashCozyMetadata(c, dir.CozyMetadata)
+}
+
+func UpdateFileTrashCozyMetadata(c echo.Context, file *vfs.FileDoc) {
+	UpdateFileCozyMetadata(c, file, false)
+	setTrashCozyMetadata(c, file.CozyMetadata)
+}
+
+func setTrashCozyMetadata(c echo.Context, fcm *vfs.FilesCozyMetadata) {
+	if fcm == nil {
+		return
+	}
+	trashedAt := fcm.UpdatedAt
+	fcm.TrashedAt = &trashedAt
+	if actor, ok := middlewares.GetActor(c); ok {
+		fcm.TrashedBy = &vfs.TrashedByEntry{
+			Kind:        actor.Kind,
+			DisplayName: actor.DisplayName,
+			Domain:      actor.Domain,
+		}
+		return
+	}
+	fcm.TrashedBy = nil
+}
+
 // CozyMetadataFromClaims returns a FilesCozyMetadata struct, with the app
 // fields filled with information from the permission claims.
 func CozyMetadataFromClaims(c echo.Context, setUploadFields bool) (*vfs.FilesCozyMetadata, string) {