Feature edit attachments (#29769)

* Updated patch/update post API to allow file modification (#29447)

* WIP

* WIP

* Atatched new files ton post

* WIP: deleting removed files

* Deleted removed files and invalidated file metadata cache

* removed file ignore logif from update post API

* Added TestFindExclusives

* Added tests for DeleteForPostByIds

* Added app layer tests

* Added tests

* Added API level tests

* test enhancements

* Fixed a test

* Edit history include file metadata (#29505)

* Send file metadata in edit history metadata

* Added app tests

* Added store tests

* Added tests for populateEditHistoryFileMetadata{

* Added cache to avoid repetitigve DB calls for edits with only message changes

* Added API tests

* i18m fix

* removed commented code

* Improved test helper

* Show attachments in edit history RHS (#29519)

* Send file metadata in edit history metadata

* Added app tests

* Added store tests

* Added tests for populateEditHistoryFileMetadata{

* Added cache to avoid repetitigve DB calls for edits with only message changes

* Added API tests

* i18m fix

* WIUP: displa files in edit

* removed commented code

* Displayed file in edit history

* Handled file icon

* Fixed closing history component on clicking on file

* Simplified selector

* Simplified selector

* Improved test helper

* Disabled action menu on edit history file

* Added tests

* Improved selector

* Updated snapshot

* review Fixes

* restructured componnets

* Updated test

* Updated test

* Restore post api (#29643)

* Restore post version API WIP

* Undelete files WIP

* Added store tests

* Created post restore API

* Updated updatepost safeUpdate signature

* review fixex and improvements

* Fixed an app test

* Added API laer tests

* Added API tests and OpenAPI specs

* Fixed a typo

* Allow editing files when editing posts (#29709)

* WIP - basic view files when editing post

* Cleanup

* bg color

* Added text editor tests for files

* WIP

* WIP

* removed debug log

* Allowed admin to add and remove files on someone else's post

* Handled drafts and scheduled posts

* linter fixes

* Updated snapshot

* server test fix

* CI

* Added doc

* Restore post api integration (#29719)

* WIP - basic view files when editing post

* Cleanup

* bg color

* Added text editor tests for files

* WIP

* WIP

* removed debug log

* Allowed admin to add and remove files on someone else's post

* Handled drafts and scheduled posts

* linter fixes

* Updated snapshot

* server test fix

* Used new API to restore post

* handled edut limit and undo

* lint fix

* added comments

* Fixed edit post item tests

* Fixed buttons

* Aded snapshots

* fix test

* Updated snapshot

* Minor fixes

* fixed snapshot

* Edit file dnd area (#29763)

* dnd wip

* DND continued

* Supported multiple unbind dragster funcs

* lint fixes

* Got center channel file drop working when editing a post

* file dnd working with center channel and rhs

* file dnd working with center channel and rhs

* removed unneeded stopPropogation calls

* cleanup

* DND overlay fix

* Lint fix

* Advanced text editor test updates for file upload overlay

* fixed use upload hook tests

* Updated some more snapshots

* minor cleanup

* Updated i18n

* removed need of array for dragster unbind events

* lint fixes

* edit history cursor

* Fixed bugu causing faliure to delete empty posts (#29778)

* Files in restore confirmation (#29781)

* Added files to restore post confirmation dialog

* Fixed post restore toast colors

* Fixed restore bug

* Fixed restore confirmation toast tests

* a11y improvement and modal width fix

* Edit attachment misc fixes (#29808)

* Removed single image actions in restore post confirmation dialog

* Fixed file drop overlay size and position

* Made edit indiator accessible

* Lint fix

* Added bunch of more tests

* ANother test migrated from enzyme to react testing library

* More test enhancements

* More test enhancements

* More test enhancements

* lint fixes

* Fixed  a test

* Added missing snapshots

* Test fixes

server/channels/api4/post.go

@@ -10,6 +10,8 @@ import (
 	"strconv"
 	"time"
 
+	"github.com/gorilla/mux"
+
 	"github.com/mattermost/mattermost/server/public/model"
 	"github.com/mattermost/mattermost/server/public/shared/mlog"
 	"github.com/mattermost/mattermost/server/v8/channels/app"
@@ -36,6 +38,7 @@ func (api *API) InitPost() {
 	api.BaseRoutes.Posts.Handle("/search", api.APISessionRequiredDisableWhenBusy(searchPostsInAllTeams)).Methods(http.MethodPost)
 	api.BaseRoutes.Post.Handle("", api.APISessionRequired(updatePost)).Methods(http.MethodPut)
 	api.BaseRoutes.Post.Handle("/patch", api.APISessionRequired(patchPost)).Methods(http.MethodPut)
+	api.BaseRoutes.Post.Handle("/restore/{restore_version_id:[A-Za-z0-9]+}", api.APISessionRequired(restorePostVersion)).Methods(http.MethodPost)
 	api.BaseRoutes.PostForUser.Handle("/set_unread", api.APISessionRequired(setPostUnread)).Methods(http.MethodPost)
 	api.BaseRoutes.PostForUser.Handle("/reminder", api.APISessionRequired(setPostReminder)).Methods(http.MethodPost)
 
@@ -859,8 +862,11 @@ func updatePost(c *Context, w http.ResponseWriter, r *http.Request) {
 	auditRec.AddEventPriorState(originalPost)
 	auditRec.AddEventObjectType("post")
 
-	// Updating the file_ids of a post is not a supported operation and will be ignored
-	post.FileIds = originalPost.FileIds
+	// passing a nil fileIds should not have any effect on a post's file IDs
+	// so, we restore the original file IDs in this case
+	if post.FileIds == nil {
+		post.FileIds = originalPost.FileIds
+	}
 
 	if c.AppContext.Session().UserId != originalPost.UserId {
 		if !c.App.SessionHasPermissionToChannel(c.AppContext, *c.AppContext.Session(), originalPost.ChannelId, model.PermissionEditOthersPosts) {
@@ -876,7 +882,7 @@ func updatePost(c *Context, w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	rpost, err := c.App.UpdatePost(c.AppContext, c.App.PostWithProxyRemovedFromImageURLs(&post), false)
+	rpost, err := c.App.UpdatePost(c.AppContext, c.App.PostWithProxyRemovedFromImageURLs(&post), &model.UpdatePostOptions{SafeUpdate: false})
 	if err != nil {
 		c.Err = err
 		return
@@ -914,9 +920,26 @@ func patchPost(c *Context, w http.ResponseWriter, r *http.Request) {
 		}
 	}
 
-	// Updating the file_ids of a post is not a supported operation and will be ignored
-	post.FileIds = nil
+	postPatchChecks(c, auditRec, post.Message)
+	if c.Err != nil {
+		return
+	}
 
+	patchedPost, err := c.App.PatchPost(c.AppContext, c.Params.PostId, c.App.PostPatchWithProxyRemovedFromImageURLs(&post), nil)
+	if err != nil {
+		c.Err = err
+		return
+	}
+
+	auditRec.Success()
+	auditRec.AddEventResultState(patchedPost)
+
+	if err := patchedPost.EncodeJSON(w); err != nil {
+		c.Logger.Warn("Error while writing response", mlog.Err(err))
+	}
+}
+
+func postPatchChecks(c *Context, auditRec *audit.Record, message *string) {
 	originalPost, err := c.App.GetSinglePost(c.AppContext, c.Params.PostId, false)
 	if err != nil {
 		c.SetPermissionError(model.PermissionEditPost)
@@ -926,6 +949,7 @@ func patchPost(c *Context, w http.ResponseWriter, r *http.Request) {
 	auditRec.AddEventObjectType("post")
 
 	var permission *model.Permission
+
 	if c.AppContext.Session().UserId == originalPost.UserId {
 		permission = model.PermissionEditPost
 	} else {
@@ -937,23 +961,10 @@ func patchPost(c *Context, w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	if *c.App.Config().ServiceSettings.PostEditTimeLimit != -1 && model.GetMillis() > originalPost.CreateAt+int64(*c.App.Config().ServiceSettings.PostEditTimeLimit*1000) && post.Message != nil {
+	if *c.App.Config().ServiceSettings.PostEditTimeLimit != -1 && model.GetMillis() > originalPost.CreateAt+int64(*c.App.Config().ServiceSettings.PostEditTimeLimit*1000) && message != nil {
 		c.Err = model.NewAppError("patchPost", "api.post.update_post.permissions_time_limit.app_error", map[string]any{"timeLimit": *c.App.Config().ServiceSettings.PostEditTimeLimit}, "", http.StatusBadRequest)
 		return
 	}
-
-	patchedPost, err := c.App.PatchPost(c.AppContext, c.Params.PostId, c.App.PostPatchWithProxyRemovedFromImageURLs(&post))
-	if err != nil {
-		c.Err = err
-		return
-	}
-
-	auditRec.Success()
-	auditRec.AddEventResultState(patchedPost)
-
-	if err := patchedPost.EncodeJSON(w); err != nil {
-		c.Logger.Warn("Error while writing response", mlog.Err(err))
-	}
 }
 
 func setPostUnread(c *Context, w http.ResponseWriter, r *http.Request) {
@@ -1045,7 +1056,7 @@ func saveIsPinnedPost(c *Context, w http.ResponseWriter, isPinned bool) {
 	patch := &model.PostPatch{}
 	patch.IsPinned = model.NewPointer(isPinned)
 
-	patchedPost, err := c.App.PatchPost(c.AppContext, c.Params.PostId, patch)
+	patchedPost, err := c.App.PatchPost(c.AppContext, c.Params.PostId, patch, nil)
 	if err != nil {
 		c.Err = err
 		return
@@ -1285,6 +1296,55 @@ func getPostInfo(c *Context, w http.ResponseWriter, r *http.Request) {
 	}
 }
 
+func restorePostVersion(c *Context, w http.ResponseWriter, r *http.Request) {
+	c.RequirePostId()
+	if c.Err != nil {
+		return
+	}
+
+	props := mux.Vars(r)
+	restoreVersionId, ok := props["restore_version_id"]
+	if !ok {
+		c.SetInvalidParam("restore_version_id")
+		return
+	}
+
+	auditRec := c.MakeAuditRecord("restorePostVersion", audit.Fail)
+	audit.AddEventParameter(auditRec, "id", c.Params.PostId)
+	audit.AddEventParameter(auditRec, "restore_version_id", restoreVersionId)
+	defer c.LogAuditRecWithLevel(auditRec, app.LevelContent)
+
+	toRestorePost, err := c.App.GetSinglePost(c.AppContext, restoreVersionId, true)
+	if err != nil {
+		c.SetPermissionError(model.PermissionEditPost)
+		return
+	}
+
+	// user can only restore their own posts
+	if c.AppContext.Session().UserId != toRestorePost.UserId {
+		c.SetPermissionError(model.PermissionEditPost)
+		return
+	}
+
+	postPatchChecks(c, auditRec, &toRestorePost.Message)
+	if c.Err != nil {
+		return
+	}
+
+	updatedPost, appErr := c.App.RestorePostVersion(c.AppContext, c.AppContext.Session().UserId, c.Params.PostId, restoreVersionId)
+	if appErr != nil {
+		c.Err = appErr
+		return
+	}
+
+	auditRec.Success()
+	auditRec.AddEventResultState(updatedPost)
+
+	if err := updatedPost.EncodeJSON(w); err != nil {
+		c.Logger.Warn("Error while writing response", mlog.Err(err))
+	}
+}
+
 func hasPermittedWranglerRole(c *Context, user *model.User, channelMember *model.ChannelMember) bool {
 	// If there are no configured PermittedWranglerRoles, skip the check
 	if len(c.App.Config().WranglerSettings.PermittedWranglerRoles) == 0 {

server/channels/api4/post_test.go

@@ -1328,30 +1328,6 @@ func TestUpdatePost(t *testing.T) {
 	assert.EqualValues(t, 0, rpost.EditAt, "Newly created post shouldn't have EditAt set")
 	assert.Equal(t, model.StringArray(fileIds), rpost.FileIds, "FileIds should have been set")
 
-	t.Run("same message, fewer files", func(t *testing.T) {
-		msg := "zz" + model.NewId() + " update post"
-		rpost.Message = msg
-		rpost.UserId = ""
-
-		rupost, _, err := client.UpdatePost(context.Background(), rpost.Id, &model.Post{
-			Id:      rpost.Id,
-			Message: rpost.Message,
-			FileIds: fileIds[0:2], // one fewer file id
-		})
-		require.NoError(t, err)
-
-		assert.Equal(t, rupost.Message, msg, "failed to updates")
-		assert.NotEqual(t, 0, rupost.EditAt, "EditAt not updated for post")
-		assert.Equal(t, model.StringArray(fileIds), rupost.FileIds, "FileIds should have not have been updated")
-
-		actual, _, err := client.GetPost(context.Background(), rpost.Id, "")
-		require.NoError(t, err)
-
-		assert.Equal(t, actual.Message, msg, "failed to updates")
-		assert.NotEqual(t, 0, actual.EditAt, "EditAt not updated for post")
-		assert.Equal(t, model.StringArray(fileIds), actual.FileIds, "FileIds should have not have been updated")
-	})
-
 	t.Run("new message, invalid props", func(t *testing.T) {
 		msg1 := "#hashtag a" + model.NewId() + " update post again"
 		rpost.Message = msg1
@@ -1398,22 +1374,6 @@ func TestUpdatePost(t *testing.T) {
 	}, channel, model.CreatePostFlags{SetOnline: true})
 	require.Nil(t, appErr)
 
-	t.Run("new message, add files", func(t *testing.T) {
-		up3 := &model.Post{
-			Id:        rpost3.Id,
-			ChannelId: channel.Id,
-			Message:   "zz" + model.NewId() + " update post 3",
-			FileIds:   fileIds[0:2],
-		}
-		rrupost3, _, err := client.UpdatePost(context.Background(), rpost3.Id, up3)
-		require.NoError(t, err)
-		assert.Empty(t, rrupost3.FileIds)
-
-		actual, _, err := client.GetPost(context.Background(), rpost.Id, "")
-		require.NoError(t, err)
-		assert.Equal(t, model.StringArray(fileIds), actual.FileIds)
-	})
-
 	t.Run("add slack attachments", func(t *testing.T) {
 		up4 := &model.Post{
 			Id:        rpost3.Id,
@@ -1509,6 +1469,184 @@ func TestUpdatePost(t *testing.T) {
 		_, _, err := th.SystemAdminClient.UpdatePost(context.Background(), rpost.Id, rpost)
 		require.NoError(t, err)
 	})
+
+	t.Run("should be able to add new files", func(t *testing.T) {
+		th.LoginBasic()
+		// create new file
+		fileResponse, _, err := client.UploadFile(context.Background(), data, channel.Id, "test.png")
+		require.NoError(t, err)
+		require.Equal(t, 1, len(fileResponse.FileInfos))
+		fileInfo := fileResponse.FileInfos[0]
+
+		// create new post
+		post, appErr := th.App.CreatePost(th.Context, &model.Post{
+			UserId:    th.BasicUser.Id,
+			ChannelId: channel.Id,
+			Message:   "zz" + model.NewId() + "a",
+		}, channel, model.CreatePostFlags{SetOnline: true})
+
+		require.Nil(t, appErr)
+		require.NotNil(t, post)
+
+		// update post with new file
+		post.FileIds = []string{fileInfo.Id}
+		_, _, err = client.UpdatePost(context.Background(), post.Id, post)
+		require.NoError(t, err)
+
+		updatedPost, _, err := client.GetPost(context.Background(), post.Id, "")
+		require.NoError(t, err)
+		require.Equal(t, post.Id, updatedPost.Id)
+		require.Equal(t, 1, len(updatedPost.FileIds))
+		require.Equal(t, fileInfo.Id, updatedPost.FileIds[0])
+
+		// verify file is attached to the post
+		fetchedFileInfo, _, err := client.GetFileInfo(context.Background(), fileInfo.Id)
+		require.NoError(t, err)
+		require.Equal(t, fileInfo.Id, fetchedFileInfo.Id)
+		require.Equal(t, post.Id, fetchedFileInfo.PostId)
+	})
+
+	t.Run("should be able to remove files", func(t *testing.T) {
+		th.LoginBasic()
+		// create new file
+		fileResponse, _, err := client.UploadFile(context.Background(), data, channel.Id, "test.png")
+		require.NoError(t, err)
+		require.Equal(t, 1, len(fileResponse.FileInfos))
+		fileInfo := fileResponse.FileInfos[0]
+
+		// create new post
+		post, appErr := th.App.CreatePost(th.Context, &model.Post{
+			UserId:    th.BasicUser.Id,
+			ChannelId: channel.Id,
+			Message:   "zz" + model.NewId() + "a",
+			FileIds:   []string{fileInfo.Id},
+		}, channel, model.CreatePostFlags{SetOnline: true})
+
+		require.Nil(t, appErr)
+		require.NotNil(t, post)
+		require.Equal(t, 1, len(post.FileIds))
+
+		// remove files from post
+		post.FileIds = []string{}
+		_, _, err = client.UpdatePost(context.Background(), post.Id, post)
+		require.NoError(t, err)
+
+		updatedPost, _, err := client.GetPost(context.Background(), post.Id, "")
+		require.NoError(t, err)
+		require.Equal(t, post.Id, updatedPost.Id)
+		require.Equal(t, 0, len(updatedPost.FileIds))
+
+		// verify file is removed from the post
+		postFileInfos, err := th.App.Srv().Store().FileInfo().GetForPost(post.Id, true, true, false)
+		require.NoError(t, err)
+		require.Equal(t, 1, len(postFileInfos))
+		require.Equal(t, fileInfo.Id, postFileInfos[0].Id)
+		require.Greater(t, postFileInfos[0].DeleteAt, int64(0))
+	})
+
+	t.Run("post files remain unchanged when fileIds is nil", func(t *testing.T) {
+		th.LoginBasic()
+		// create new file
+		fileResponse, _, err := client.UploadFile(context.Background(), data, channel.Id, "test.png")
+		require.NoError(t, err)
+		require.Equal(t, 1, len(fileResponse.FileInfos))
+		fileInfo := fileResponse.FileInfos[0]
+
+		// create new post
+		post, appErr := th.App.CreatePost(th.Context, &model.Post{
+			UserId:    th.BasicUser.Id,
+			ChannelId: channel.Id,
+			Message:   "zz" + model.NewId() + "a",
+			FileIds:   []string{fileInfo.Id},
+		}, channel, model.CreatePostFlags{SetOnline: true})
+
+		require.Nil(t, appErr)
+		require.NotNil(t, post)
+		require.Equal(t, 1, len(post.FileIds))
+
+		// update post without specifying fileIds
+		post.FileIds = nil
+		post.Message = "updated message"
+		_, _, err = client.UpdatePost(context.Background(), post.Id, post)
+		require.NoError(t, err)
+
+		updatedPost, _, err := client.GetPost(context.Background(), post.Id, "")
+		require.NoError(t, err)
+		require.Equal(t, post.Id, updatedPost.Id)
+		require.Equal(t, 1, len(updatedPost.FileIds))
+		require.Equal(t, fileInfo.Id, updatedPost.FileIds[0])
+		require.Equal(t, "updated message", updatedPost.Message)
+
+		// verify file is still part of the post
+		postFileInfos, err := th.App.Srv().Store().FileInfo().GetForPost(post.Id, true, false, false)
+		require.NoError(t, err)
+		require.Equal(t, 1, len(postFileInfos))
+		require.Equal(t, fileInfo.Id, postFileInfos[0].Id)
+		require.Equal(t, int64(0), postFileInfos[0].DeleteAt)
+	})
+
+	t.Run("should be able to add and remove files simultaneously", func(t *testing.T) {
+		th.LoginBasic()
+		// create new file
+		fileResponse1, _, err := client.UploadFile(context.Background(), data, channel.Id, "test.png")
+		require.NoError(t, err)
+		require.Equal(t, 1, len(fileResponse1.FileInfos))
+		fileInfo1 := fileResponse1.FileInfos[0]
+
+		fileResponse2, _, err := client.UploadFile(context.Background(), data, channel.Id, "test.png")
+		require.NoError(t, err)
+		require.Equal(t, 1, len(fileResponse2.FileInfos))
+		fileInfo2 := fileResponse2.FileInfos[0]
+
+		// create new post
+		post, appErr := th.App.CreatePost(th.Context, &model.Post{
+			UserId:    th.BasicUser.Id,
+			ChannelId: channel.Id,
+			Message:   "zz" + model.NewId() + "a",
+			FileIds:   model.StringArray{fileInfo1.Id, fileInfo2.Id},
+		}, channel, model.CreatePostFlags{SetOnline: true})
+
+		require.Nil(t, appErr)
+		require.NotNil(t, post)
+		require.Equal(t, 2, len(post.FileIds))
+
+		// update post with new file
+
+		fileResponse3, _, err := client.UploadFile(context.Background(), data, channel.Id, "test.png")
+		require.NoError(t, err)
+		require.Equal(t, 1, len(fileResponse3.FileInfos))
+		fileInfo3 := fileResponse3.FileInfos[0]
+
+		fileResponse4, _, err := client.UploadFile(context.Background(), data, channel.Id, "test.png")
+		require.NoError(t, err)
+		require.Equal(t, 1, len(fileResponse4.FileInfos))
+		fileInfo4 := fileResponse4.FileInfos[0]
+
+		post.FileIds = []string{fileInfo3.Id, fileInfo4.Id}
+		_, _, err = client.UpdatePost(context.Background(), post.Id, post)
+		require.NoError(t, err)
+
+		updatedPost, _, err := client.GetPost(context.Background(), post.Id, "")
+		require.NoError(t, err)
+		require.Equal(t, post.Id, updatedPost.Id)
+		require.Equal(t, 2, len(updatedPost.FileIds))
+		require.Contains(t, updatedPost.FileIds, fileInfo3.Id)
+		require.Contains(t, updatedPost.FileIds, fileInfo4.Id)
+
+		postFiles, err := th.App.Srv().Store().FileInfo().GetForPost(post.Id, true, true, false)
+		require.NoError(t, err)
+		require.Equal(t, 4, len(postFiles))
+
+		for _, postFile := range postFiles {
+			if postFile.Id == fileInfo1.Id || postFile.Id == fileInfo2.Id {
+				require.Greater(t, postFile.DeleteAt, int64(0))
+			}
+
+			if postFile.Id == fileInfo3.Id || postFile.Id == fileInfo4.Id {
+				require.Equal(t, postFile.PostId, post.Id)
+			}
+		}
+	})
 }
 
 func TestUpdateOthersPostInDirectMessageChannel(t *testing.T) {
@@ -1583,7 +1721,7 @@ func TestPatchPost(t *testing.T) {
 		assert.Equal(t, "#otherhashtag other message", rpost.Message, "Message did not update properly")
 		assert.Equal(t, *patch.Props, rpost.GetProps(), "Props did not update properly")
 		assert.Equal(t, "#otherhashtag", rpost.Hashtags, "Message did not update properly")
-		assert.Equal(t, model.StringArray(fileIDs[0:2]), rpost.FileIds, "FileIds should not update")
+		assert.Equal(t, model.StringArray(fileIDs), rpost.FileIds, "FileIds should not update")
 		assert.False(t, rpost.HasReactions, "HasReactions did not update properly")
 	})
 
@@ -1731,6 +1869,135 @@ func TestPatchPost(t *testing.T) {
 		require.Error(t, patchErr)
 		CheckBadRequestStatus(t, patchResp)
 	})
+
+	t.Run("should be able to add new files", func(t *testing.T) {
+		post, _, err := client.CreatePost(context.Background(), &model.Post{
+			ChannelId: channel.Id,
+			Message:   "#hashtag a message",
+			CreateAt:  model.GetMillis() - 2000,
+		})
+
+		require.NoError(t, err)
+
+		fileResponse, _, err := client.UploadFile(context.Background(), data, channel.Id, "test.png")
+		require.NoError(t, err)
+		require.Equal(t, 1, len(fileResponse.FileInfos))
+		fileInfo := fileResponse.FileInfos[0]
+
+		patch := &model.PostPatch{
+			FileIds: &model.StringArray{fileInfo.Id},
+		}
+
+		_, _, err = client.PatchPost(context.Background(), post.Id, patch)
+		require.NoError(t, err)
+
+		patchedPost, _, err := client.GetPost(context.Background(), post.Id, "")
+		require.NoError(t, err)
+		require.Equal(t, 1, len(patchedPost.FileIds))
+		require.Equal(t, fileInfo.Id, patchedPost.FileIds[0])
+	})
+
+	t.Run("should be able to remove some files", func(t *testing.T) {
+		fileResponse1, _, err := client.UploadFile(context.Background(), data, channel.Id, "test.png")
+		require.NoError(t, err)
+		require.Equal(t, 1, len(fileResponse1.FileInfos))
+		fileInfo1 := fileResponse1.FileInfos[0]
+
+		fileResponse2, _, err := client.UploadFile(context.Background(), data, channel.Id, "test.png")
+		require.NoError(t, err)
+		require.Equal(t, 1, len(fileResponse2.FileInfos))
+		fileInfo2 := fileResponse2.FileInfos[0]
+
+		post, _, err := client.CreatePost(context.Background(), &model.Post{
+			ChannelId: channel.Id,
+			Message:   "#hashtag a message",
+			CreateAt:  model.GetMillis() - 2000,
+			FileIds:   model.StringArray{fileInfo1.Id, fileInfo2.Id},
+		})
+
+		require.NoError(t, err)
+		require.Equal(t, 2, len(post.FileIds))
+
+		patch := &model.PostPatch{
+			FileIds: &model.StringArray{fileInfo2.Id},
+		}
+
+		_, _, err = client.PatchPost(context.Background(), post.Id, patch)
+		require.NoError(t, err)
+
+		patchedPost, _, err := client.GetPost(context.Background(), post.Id, "")
+		require.NoError(t, err)
+		require.Equal(t, 1, len(patchedPost.FileIds))
+		require.Equal(t, fileInfo2.Id, patchedPost.FileIds[0])
+	})
+
+	t.Run("should be able to remove all files", func(t *testing.T) {
+		fileResponse1, _, err := client.UploadFile(context.Background(), data, channel.Id, "test.png")
+		require.NoError(t, err)
+		require.Equal(t, 1, len(fileResponse1.FileInfos))
+		fileInfo1 := fileResponse1.FileInfos[0]
+
+		fileResponse2, _, err := client.UploadFile(context.Background(), data, channel.Id, "test.png")
+		require.NoError(t, err)
+		require.Equal(t, 1, len(fileResponse2.FileInfos))
+		fileInfo2 := fileResponse2.FileInfos[0]
+
+		post, _, err := client.CreatePost(context.Background(), &model.Post{
+			ChannelId: channel.Id,
+			Message:   "#hashtag a message",
+			CreateAt:  model.GetMillis() - 2000,
+			FileIds:   model.StringArray{fileInfo1.Id, fileInfo2.Id},
+		})
+
+		require.NoError(t, err)
+		require.Equal(t, 2, len(post.FileIds))
+
+		patch := &model.PostPatch{
+			FileIds: &model.StringArray{},
+		}
+
+		_, _, err = client.PatchPost(context.Background(), post.Id, patch)
+		require.NoError(t, err)
+
+		patchedPost, _, err := client.GetPost(context.Background(), post.Id, "")
+		require.NoError(t, err)
+		require.Equal(t, 0, len(patchedPost.FileIds))
+	})
+
+	t.Run("post files remain unchanged when fileIds is nil", func(t *testing.T) {
+		fileResponse1, _, err := client.UploadFile(context.Background(), data, channel.Id, "test.png")
+		require.NoError(t, err)
+		require.Equal(t, 1, len(fileResponse1.FileInfos))
+		fileInfo1 := fileResponse1.FileInfos[0]
+
+		fileResponse2, _, err := client.UploadFile(context.Background(), data, channel.Id, "test.png")
+		require.NoError(t, err)
+		require.Equal(t, 1, len(fileResponse2.FileInfos))
+		fileInfo2 := fileResponse2.FileInfos[0]
+
+		post, _, err := client.CreatePost(context.Background(), &model.Post{
+			ChannelId: channel.Id,
+			Message:   "#hashtag a message",
+			CreateAt:  model.GetMillis() - 2000,
+			FileIds:   model.StringArray{fileInfo1.Id, fileInfo2.Id},
+		})
+
+		require.NoError(t, err)
+		require.Equal(t, 2, len(post.FileIds))
+
+		patch := &model.PostPatch{
+			FileIds: nil,
+		}
+
+		_, _, err = client.PatchPost(context.Background(), post.Id, patch)
+		require.NoError(t, err)
+
+		patchedPost, _, err := client.GetPost(context.Background(), post.Id, "")
+		require.NoError(t, err)
+		require.Equal(t, 2, len(patchedPost.FileIds))
+		require.Contains(t, patchedPost.FileIds, fileInfo1.Id)
+		require.Contains(t, patchedPost.FileIds, fileInfo2.Id)
+	})
 }
 
 func TestPinPost(t *testing.T) {
@@ -4153,6 +4420,58 @@ func TestGetEditHistoryForPost(t *testing.T) {
 		require.Error(t, err)
 		CheckForbiddenStatus(t, resp)
 	})
+
+	t.Run("edit history includes file metadata", func(t *testing.T) {
+		th.LoginBasic()
+		fileInfo1, appErr := th.App.UploadFile(th.Context, []byte("data"), th.BasicChannel.Id, "test")
+		require.Nil(t, appErr)
+
+		fileInfo2, appErr := th.App.UploadFile(th.Context, []byte("data"), th.BasicChannel.Id, "test")
+		require.Nil(t, appErr)
+
+		post := &model.Post{
+			ChannelId: th.BasicChannel.Id,
+			Message:   "new message",
+			UserId:    th.BasicUser.Id,
+			FileIds:   []string{fileInfo1.Id, fileInfo2.Id},
+		}
+
+		createdPost, appErr := th.App.CreatePost(th.Context, post, th.BasicChannel, model.CreatePostFlags{SetOnline: true})
+		require.Nil(t, appErr)
+		require.Contains(t, createdPost.FileIds, fileInfo1.Id)
+		require.Contains(t, createdPost.FileIds, fileInfo2.Id)
+
+		patch = &model.PostPatch{
+			Message: model.NewPointer("new message 1"),
+		}
+		_, response, err := client.PatchPost(context.Background(), createdPost.Id, patch)
+		require.NoError(t, err)
+		CheckOKStatus(t, response)
+
+		patch = &model.PostPatch{
+			Message: model.NewPointer("new message 2"),
+		}
+		_, response, err = client.PatchPost(context.Background(), createdPost.Id, patch)
+		require.NoError(t, err)
+		CheckOKStatus(t, response)
+
+		patch = &model.PostPatch{
+			Message: model.NewPointer("new message 3"),
+		}
+		_, response, err = client.PatchPost(context.Background(), createdPost.Id, patch)
+		require.NoError(t, err)
+		CheckOKStatus(t, response)
+
+		editHistory, resp, err := client.GetEditHistoryForPost(context.Background(), createdPost.Id)
+		require.NoError(t, err)
+		CheckOKStatus(t, resp)
+
+		for _, editHistoryItem := range editHistory {
+			require.Len(t, editHistoryItem.FileIds, 2)
+			require.Contains(t, editHistoryItem.FileIds, fileInfo1.Id)
+			require.Contains(t, editHistoryItem.FileIds, fileInfo2.Id)
+		}
+	})
 }
 
 func TestCreatePostNotificationsWithCRT(t *testing.T) {
@@ -4779,3 +5098,230 @@ func TestUnacknowledgePost(t *testing.T) {
 	require.Error(t, err)
 	CheckUnauthorizedStatus(t, resp)
 }
+
+func TestRestorePostVersion(t *testing.T) {
+	th := Setup(t).InitBasic()
+	defer th.TearDown()
+	client := th.Client
+
+	t.Run("should restore post version successfully", func(t *testing.T) {
+		post := &model.Post{
+			ChannelId: th.BasicChannel.Id,
+			Message:   "original message",
+			UserId:    th.BasicUser.Id,
+		}
+
+		createdPost, response, err := client.CreatePost(context.Background(), post)
+		require.NoError(t, err)
+		CheckCreatedStatus(t, response)
+
+		patch, response, err := client.PatchPost(context.Background(), createdPost.Id, &model.PostPatch{
+			Message: model.NewPointer("edited message 1"),
+		})
+		require.NoError(t, err)
+		CheckOKStatus(t, response)
+		require.Equal(t, "edited message 1", patch.Message)
+
+		patch, response, err = client.PatchPost(context.Background(), createdPost.Id, &model.PostPatch{
+			Message: model.NewPointer("edited message 2"),
+		})
+		require.NoError(t, err)
+		CheckOKStatus(t, response)
+		require.Equal(t, "edited message 2", patch.Message)
+
+		// verify edit history
+		editHistory, response, err := client.GetEditHistoryForPost(context.Background(), createdPost.Id)
+		require.NoError(t, err)
+		CheckOKStatus(t, response)
+		require.Equal(t, 2, len(editHistory))
+		require.Equal(t, "edited message 1", editHistory[0].Message)
+		require.Equal(t, "original message", editHistory[1].Message)
+
+		// now we'll restore to the original version
+		restoredPost, response, err := client.RestorePostVersion(context.Background(), createdPost.Id, editHistory[1].Id)
+		require.NoError(t, err)
+		CheckOKStatus(t, response)
+		require.Equal(t, "original message", restoredPost.Message)
+		require.Equal(t, createdPost.Id, restoredPost.Id)
+
+		// verify restored post
+		fetchedPost, response, err := client.GetPost(context.Background(), createdPost.Id, "")
+		require.NoError(t, err)
+		CheckOKStatus(t, response)
+		require.Equal(t, "original message", fetchedPost.Message)
+
+		// verify edit history after restoring
+		editHistory, response, err = client.GetEditHistoryForPost(context.Background(), createdPost.Id)
+		require.NoError(t, err)
+		CheckOKStatus(t, response)
+		require.Equal(t, 3, len(editHistory))
+		require.Equal(t, "edited message 2", editHistory[0].Message)
+		require.Equal(t, "edited message 1", editHistory[1].Message)
+		require.Equal(t, "original message", editHistory[2].Message)
+	})
+
+	t.Run("should restore post version successfully with files", func(t *testing.T) {
+		fileResp, _, err := client.UploadFile(context.Background(), []byte("data"), th.BasicChannel.Id, "test")
+		require.NoError(t, err)
+		fileId := fileResp.FileInfos[0].Id
+
+		post := &model.Post{
+			ChannelId: th.BasicChannel.Id,
+			Message:   "original message",
+			UserId:    th.BasicUser.Id,
+			FileIds:   model.StringArray{fileId},
+		}
+
+		createdPost, response, err := client.CreatePost(context.Background(), post)
+		require.NoError(t, err)
+		CheckCreatedStatus(t, response)
+		require.Equal(t, 1, len(createdPost.FileIds))
+
+		patch, response, err := client.PatchPost(context.Background(), createdPost.Id, &model.PostPatch{
+			Message: model.NewPointer("edited message 1"),
+			FileIds: &model.StringArray{},
+		})
+		require.NoError(t, err)
+		CheckOKStatus(t, response)
+		require.Equal(t, "edited message 1", patch.Message)
+		require.Equal(t, 0, len(patch.FileIds))
+
+		// verify edit history
+		editHistory, response, err := client.GetEditHistoryForPost(context.Background(), createdPost.Id)
+		require.NoError(t, err)
+		CheckOKStatus(t, response)
+		require.Equal(t, 1, len(editHistory))
+		require.Equal(t, "original message", editHistory[0].Message)
+		require.Equal(t, 1, len(editHistory[0].FileIds))
+
+		// now we'll restore to the original version
+		restoredPost, response, err := client.RestorePostVersion(context.Background(), createdPost.Id, editHistory[0].Id)
+		require.NoError(t, err)
+		CheckOKStatus(t, response)
+		require.Equal(t, "original message", restoredPost.Message)
+		require.Equal(t, createdPost.Id, restoredPost.Id)
+		require.Equal(t, 1, len(restoredPost.FileIds))
+
+		// verify restored post
+		fetchedPost, response, err := client.GetPost(context.Background(), createdPost.Id, "")
+		require.NoError(t, err)
+		CheckOKStatus(t, response)
+		require.Equal(t, "original message", fetchedPost.Message)
+		require.Equal(t, 1, len(fetchedPost.FileIds))
+
+		// verify edit history after restoring
+		editHistory, response, err = client.GetEditHistoryForPost(context.Background(), createdPost.Id)
+		require.NoError(t, err)
+		CheckOKStatus(t, response)
+		require.Equal(t, 2, len(editHistory))
+		require.Equal(t, "edited message 1", editHistory[0].Message)
+		require.Equal(t, 0, len(editHistory[0].FileIds))
+
+		require.Equal(t, "original message", editHistory[1].Message)
+		require.Equal(t, 1, len(editHistory[1].FileIds))
+	})
+
+	t.Run("should get error when trying to restore non existent post ori history ID", func(t *testing.T) {
+		restoredPost, response, err := client.RestorePostVersion(context.Background(), model.NewId(), model.NewId())
+		require.Error(t, err)
+		CheckForbiddenStatus(t, response)
+		require.Nil(t, restoredPost)
+
+		post := &model.Post{
+			ChannelId: th.BasicChannel.Id,
+			Message:   "original message",
+			UserId:    th.BasicUser.Id,
+		}
+
+		createdPost, response, err := client.CreatePost(context.Background(), post)
+		require.NoError(t, err)
+		CheckCreatedStatus(t, response)
+
+		restoredPost, response, err = client.RestorePostVersion(context.Background(), createdPost.Id, model.NewId())
+		require.Error(t, err)
+		CheckForbiddenStatus(t, response)
+		require.Nil(t, restoredPost)
+
+		post2 := &model.Post{
+			ChannelId: th.BasicChannel.Id,
+			Message:   "original message 2",
+			UserId:    th.BasicUser.Id,
+		}
+
+		createdPost, response, err = client.CreatePost(context.Background(), post2)
+		require.NoError(t, err)
+		CheckCreatedStatus(t, response)
+
+		restoredPost, response, err = client.RestorePostVersion(context.Background(), createdPost.Id, post2.Id)
+		require.Error(t, err)
+		CheckNotFoundStatus(t, response)
+		require.Nil(t, restoredPost)
+	})
+
+	t.Run("user should not be able to restore someone else's post", func(t *testing.T) {
+		post := &model.Post{
+			ChannelId: th.BasicChannel.Id,
+			Message:   "original message",
+			UserId:    th.BasicUser.Id,
+		}
+
+		createdPost, response, err := client.CreatePost(context.Background(), post)
+		require.NoError(t, err)
+		CheckCreatedStatus(t, response)
+
+		patch, response, err := client.PatchPost(context.Background(), createdPost.Id, &model.PostPatch{
+			Message: model.NewPointer("edited message 1"),
+		})
+		require.NoError(t, err)
+		CheckOKStatus(t, response)
+		require.Equal(t, "edited message 1", patch.Message)
+
+		// verify edit history
+		editHistory, response, err := client.GetEditHistoryForPost(context.Background(), createdPost.Id)
+		require.NoError(t, err)
+		CheckOKStatus(t, response)
+		require.Equal(t, 1, len(editHistory))
+		require.Equal(t, "original message", editHistory[0].Message)
+
+		// now we'll restore to the original version
+		th.LoginBasic2()
+		restoredPost, response, err := th.Client.RestorePostVersion(context.Background(), createdPost.Id, editHistory[0].Id)
+		require.Error(t, err)
+		CheckForbiddenStatus(t, response)
+		require.Nil(t, restoredPost)
+	})
+
+	t.Run("system admin should not be able to restore someone else's post", func(t *testing.T) {
+		th.LoginBasic()
+		post := &model.Post{
+			ChannelId: th.BasicChannel.Id,
+			Message:   "original message",
+			UserId:    th.BasicUser.Id,
+		}
+
+		createdPost, response, err := th.Client.CreatePost(context.Background(), post)
+		require.NoError(t, err)
+		CheckCreatedStatus(t, response)
+
+		patch, response, err := th.Client.PatchPost(context.Background(), createdPost.Id, &model.PostPatch{
+			Message: model.NewPointer("edited message 1"),
+		})
+		require.NoError(t, err)
+		CheckOKStatus(t, response)
+		require.Equal(t, "edited message 1", patch.Message)
+
+		// verify edit history
+		editHistory, response, err := th.Client.GetEditHistoryForPost(context.Background(), createdPost.Id)
+		require.NoError(t, err)
+		CheckOKStatus(t, response)
+		require.Equal(t, 1, len(editHistory))
+		require.Equal(t, "original message", editHistory[0].Message)
+
+		// now we'll restore to the original version
+		th.LoginSystemAdmin()
+		restoredPost, response, err := th.SystemAdminClient.RestorePostVersion(context.Background(), createdPost.Id, editHistory[0].Id)
+		require.Error(t, err)
+		CheckForbiddenStatus(t, response)
+		require.Nil(t, restoredPost)
+	})
+}

server/channels/app/app_iface.go

@@ -975,7 +975,7 @@ type AppIface interface {
 	OutgoingOAuthConnections() einterfaces.OutgoingOAuthConnectionInterface
 	PatchChannel(c request.CTX, channel *model.Channel, patch *model.ChannelPatch, userID string) (*model.Channel, *model.AppError)
 	PatchChannelMembersNotifyProps(c request.CTX, members []*model.ChannelMemberIdentifier, notifyProps map[string]string) ([]*model.ChannelMember, *model.AppError)
-	PatchPost(c request.CTX, postID string, patch *model.PostPatch) (*model.Post, *model.AppError)
+	PatchPost(c request.CTX, postID string, patch *model.PostPatch, patchPostOptions *model.UpdatePostOptions) (*model.Post, *model.AppError)
 	PatchRemoteCluster(rcId string, patch *model.RemoteClusterPatch) (*model.RemoteCluster, *model.AppError)
 	PatchRetentionPolicy(patch *model.RetentionPolicyWithTeamAndChannelIDs) (*model.RetentionPolicyWithTeamAndChannelCounts, *model.AppError)
 	PatchRole(role *model.Role, patch *model.RolePatch) (*model.Role, *model.AppError)
@@ -1043,6 +1043,7 @@ type AppIface interface {
 	ResetSamlAuthDataToEmail(includeDeleted bool, dryRun bool, userIDs []string) (numAffected int, appErr *model.AppError)
 	RestoreChannel(c request.CTX, channel *model.Channel, userID string) (*model.Channel, *model.AppError)
 	RestoreGroup(groupID string) (*model.Group, *model.AppError)
+	RestorePostVersion(c request.CTX, userID, postID, restoreVersionID string) (*model.Post, *model.AppError)
 	RestoreTeam(teamID string) *model.AppError
 	RestrictUsersGetByPermissions(c request.CTX, userID string, options *model.UserGetOptions) (*model.UserGetOptions, *model.AppError)
 	RestrictUsersSearchByPermissions(c request.CTX, userID string, options *model.UserSearchOptions) (*model.UserSearchOptions, *model.AppError)
@@ -1200,7 +1201,7 @@ type AppIface interface {
 	UpdatePasswordAsUser(c request.CTX, userID, currentPassword, newPassword string) *model.AppError
 	UpdatePasswordByUserIdSendEmail(c request.CTX, userID, newPassword, method string) *model.AppError
 	UpdatePasswordSendEmail(c request.CTX, user *model.User, newPassword, method string) *model.AppError
-	UpdatePost(c request.CTX, receivedUpdatedPost *model.Post, safeUpdate bool) (*model.Post, *model.AppError)
+	UpdatePost(c request.CTX, receivedUpdatedPost *model.Post, updatePostOptions *model.UpdatePostOptions) (*model.Post, *model.AppError)
 	UpdatePreferences(c request.CTX, userID string, preferences model.Preferences) *model.AppError
 	UpdateRemoteCluster(rc *model.RemoteCluster) (*model.RemoteCluster, *model.AppError)
 	UpdateRemoteClusterTopics(remoteClusterId string, topics string) (*model.RemoteCluster, *model.AppError)

server/channels/app/channel_test.go

@@ -2647,7 +2647,7 @@ func TestMarkUnreadCRTOffUpdatesThreads(t *testing.T) {
 		require.Nil(t, appErr)
 		editedPost := r1.Clone()
 		editedPost.Message += " edited"
-		_, appErr = th.App.UpdatePost(th.Context, editedPost, false)
+		_, appErr = th.App.UpdatePost(th.Context, editedPost, &model.UpdatePostOptions{SafeUpdate: false})
 		require.Nil(t, appErr)
 
 		th.LinkUserToTeam(user3, th.BasicTeam)

server/channels/app/draft.go

@@ -116,7 +116,7 @@ func (a *App) getFileInfosForDraft(rctx request.CTX, draft *model.Draft) ([]*mod
 		return nil, nil
 	}
 
-	allFileInfos, err := a.Srv().Store().FileInfo().GetByIds(draft.FileIds)
+	allFileInfos, err := a.Srv().Store().FileInfo().GetByIds(draft.FileIds, false, true)
 	if err != nil {
 		return nil, model.NewAppError("GetFileInfosForDraft", "app.draft.get_for_draft.app_error", nil, "", http.StatusInternalServerError).Wrap(err)
 	}

server/channels/app/helper_test.go

@@ -50,6 +50,10 @@ type TestHelper struct {
 	tempWorkspace string
 }
 
+type PostOptions func(*model.Post)
+
+type PostPatchOptions func(patch *model.PostPatch)
+
 func setupTestHelper(dbStore store.Store, enterprise bool, includeCacheLayer bool,
 	updateConfig func(*model.Config), options []Option, tb testing.TB) *TestHelper {
 	tempWorkspace, err := os.MkdirTemp("", "apptest")
@@ -445,7 +449,7 @@ func (th *TestHelper) CreateGroupChannel(c request.CTX, user1 *model.User, user2
 	return channel
 }
 
-func (th *TestHelper) CreatePost(channel *model.Channel) *model.Post {
+func (th *TestHelper) CreatePost(channel *model.Channel, postOptions ...PostOptions) *model.Post {
 	id := model.NewId()
 
 	post := &model.Post{
@@ -455,6 +459,10 @@ func (th *TestHelper) CreatePost(channel *model.Channel) *model.Post {
 		CreateAt:  model.GetMillis() - 10000,
 	}
 
+	for _, option := range postOptions {
+		option(post)
+	}
+
 	var err *model.AppError
 	if post, err = th.App.CreatePost(th.Context, post, channel, model.CreatePostFlags{SetOnline: true}); err != nil {
 		panic(err)
@@ -772,6 +780,41 @@ func (th *TestHelper) AddPermissionToRole(permission string, roleName string) {
 	}
 }
 
+func (th *TestHelper) CreateFileInfo(userId, postId, channelId string) *model.FileInfo {
+	fileInfo := &model.FileInfo{
+		Id:        model.NewId(),
+		CreatorId: userId,
+		PostId:    postId,
+		ChannelId: channelId,
+		CreateAt:  model.GetMillis(),
+		Name:      model.NewRandomString(10),
+		Path:      model.NewRandomString(50),
+	}
+
+	createdFileInfo, err := th.App.Srv().Store().FileInfo().Save(th.Context, fileInfo)
+	if err != nil {
+		panic(err)
+	}
+
+	return createdFileInfo
+}
+
+func (th *TestHelper) PostPatch(post *model.Post, message string, options ...PostPatchOptions) *model.Post {
+	postPatch := &model.PostPatch{
+		Message: model.NewPointer(message),
+	}
+	for _, optionFunc := range options {
+		optionFunc(postPatch)
+	}
+
+	updatedPost, appErr := th.App.PatchPost(th.Context, post.Id, postPatch, nil)
+	if appErr != nil {
+		panic(appErr)
+	}
+
+	return updatedPost
+}
+
 // This function is copy of storetest/NewTestId
 // NewTestId is used for testing as a replacement for model.NewId(). It is a [A-Z0-9] string 26
 // characters long. It replaces every odd character with a digit.

server/channels/app/integration_action.go

@@ -271,7 +271,7 @@ func (a *App) DoPostActionWithCookie(c request.CTX, postID, actionId, userID, se
 		response.Update.IsPinned = originalIsPinned
 		response.Update.HasReactions = originalHasReactions
 
-		if _, appErr = a.UpdatePost(c, response.Update, false); appErr != nil {
+		if _, appErr = a.UpdatePost(c, response.Update, &model.UpdatePostOptions{SafeUpdate: false}); appErr != nil {
 			return "", appErr
 		}
 	}

server/channels/app/opentracing/opentracing_layer.go

@@ -13433,7 +13433,7 @@ func (a *OpenTracingAppLayer) PatchChannelModerationsForChannel(c request.CTX, c
 	return resultVar0, resultVar1
 }
 
-func (a *OpenTracingAppLayer) PatchPost(c request.CTX, postID string, patch *model.PostPatch) (*model.Post, *model.AppError) {
+func (a *OpenTracingAppLayer) PatchPost(c request.CTX, postID string, patch *model.PostPatch, patchPostOptions *model.UpdatePostOptions) (*model.Post, *model.AppError) {
 	origCtx := a.ctx
 	span, newCtx := tracing.StartSpanWithParentByContext(a.ctx, "app.PatchPost")
 
@@ -13445,7 +13445,7 @@ func (a *OpenTracingAppLayer) PatchPost(c request.CTX, postID string, patch *mod
 	}()
 
 	defer span.Finish()
-	resultVar0, resultVar1 := a.app.PatchPost(c, postID, patch)
+	resultVar0, resultVar1 := a.app.PatchPost(c, postID, patch, patchPostOptions)
 
 	if resultVar1 != nil {
 		span.LogFields(spanlog.Error(resultVar1))
@@ -15033,6 +15033,28 @@ func (a *OpenTracingAppLayer) RestoreGroup(groupID string) (*model.Group, *model
 	return resultVar0, resultVar1
 }
 
+func (a *OpenTracingAppLayer) RestorePostVersion(c request.CTX, userID string, postID string, restoreVersionID string) (*model.Post, *model.AppError) {
+	origCtx := a.ctx
+	span, newCtx := tracing.StartSpanWithParentByContext(a.ctx, "app.RestorePostVersion")
+
+	a.ctx = newCtx
+	a.app.Srv().Store().SetContext(newCtx)
+	defer func() {
+		a.app.Srv().Store().SetContext(origCtx)
+		a.ctx = origCtx
+	}()
+
+	defer span.Finish()
+	resultVar0, resultVar1 := a.app.RestorePostVersion(c, userID, postID, restoreVersionID)
+
+	if resultVar1 != nil {
+		span.LogFields(spanlog.Error(resultVar1))
+		ext.Error.Set(span, true)
+	}
+
+	return resultVar0, resultVar1
+}
+
 func (a *OpenTracingAppLayer) RestoreTeam(teamID string) *model.AppError {
 	origCtx := a.ctx
 	span, newCtx := tracing.StartSpanWithParentByContext(a.ctx, "app.RestoreTeam")
@@ -18660,7 +18682,7 @@ func (a *OpenTracingAppLayer) UpdatePasswordSendEmail(c request.CTX, user *model
 	return resultVar0
 }
 
-func (a *OpenTracingAppLayer) UpdatePost(c request.CTX, receivedUpdatedPost *model.Post, safeUpdate bool) (*model.Post, *model.AppError) {
+func (a *OpenTracingAppLayer) UpdatePost(c request.CTX, receivedUpdatedPost *model.Post, updatePostOptions *model.UpdatePostOptions) (*model.Post, *model.AppError) {
 	origCtx := a.ctx
 	span, newCtx := tracing.StartSpanWithParentByContext(a.ctx, "app.UpdatePost")
 
@@ -18672,7 +18694,7 @@ func (a *OpenTracingAppLayer) UpdatePost(c request.CTX, receivedUpdatedPost *mod
 	}()
 
 	defer span.Finish()
-	resultVar0, resultVar1 := a.app.UpdatePost(c, receivedUpdatedPost, safeUpdate)
+	resultVar0, resultVar1 := a.app.UpdatePost(c, receivedUpdatedPost, updatePostOptions)
 
 	if resultVar1 != nil {
 		span.LogFields(spanlog.Error(resultVar1))

server/channels/app/plugin_api.go

@@ -744,7 +744,7 @@ func (api *PluginAPI) GetPostsForChannel(channelID string, page, perPage int) (*
 }
 
 func (api *PluginAPI) UpdatePost(post *model.Post) (*model.Post, *model.AppError) {
-	post, appErr := api.app.UpdatePost(api.ctx, post, false)
+	post, appErr := api.app.UpdatePost(api.ctx, post, &model.UpdatePostOptions{SafeUpdate: false})
 	if post != nil {
 		post = post.ForPlugin()
 	}

server/channels/app/plugin_hooks_test.go

@@ -379,7 +379,7 @@ func TestHookMessageWillBeUpdated(t *testing.T) {
 	require.Nil(t, err)
 	assert.Equal(t, "message_", post.Message)
 	post.Message = post.Message + "edited_"
-	post, err = th.App.UpdatePost(th.Context, post, true)
+	post, err = th.App.UpdatePost(th.Context, post, &model.UpdatePostOptions{SafeUpdate: true})
 	require.Nil(t, err)
 	assert.Equal(t, "message_edited_fromplugin", post.Message)
 }
@@ -427,7 +427,7 @@ func TestHookMessageHasBeenUpdated(t *testing.T) {
 	require.Nil(t, err)
 	assert.Equal(t, "message_", post.Message)
 	post.Message = post.Message + "edited"
-	_, err = th.App.UpdatePost(th.Context, post, true)
+	_, err = th.App.UpdatePost(th.Context, post, &model.UpdatePostOptions{SafeUpdate: true})
 	require.Nil(t, err)
 }
 

server/channels/app/post.go

@@ -458,16 +458,7 @@ func (a *App) addPostPreviewProp(rctx request.CTX, post *model.Post) (*model.Pos
 }
 
 func (a *App) attachFilesToPost(rctx request.CTX, post *model.Post) *model.AppError {
-	var attachedIds []string
-	for _, fileID := range post.FileIds {
-		err := a.Srv().Store().FileInfo().AttachToPost(rctx, fileID, post.Id, post.ChannelId, post.UserId)
-		if err != nil {
-			rctx.Logger().Warn("Failed to attach file to post", mlog.String("file_id", fileID), mlog.String("post_id", post.Id), mlog.Err(err))
-			continue
-		}
-
-		attachedIds = append(attachedIds, fileID)
-	}
+	attachedIds := a.attachFileIDsToPost(rctx, post.Id, post.ChannelId, post.UserId, post.FileIds)
 
 	if len(post.FileIds) != len(attachedIds) {
 		// We couldn't attach all files to the post, so ensure that post.FileIds reflects what was actually attached
@@ -481,6 +472,20 @@ func (a *App) attachFilesToPost(rctx request.CTX, post *model.Post) *model.AppEr
 	return nil
 }
 
+func (a *App) attachFileIDsToPost(rctx request.CTX, postID, channelID, userID string, fileIDs []string) []string {
+	var attachedIds []string
+	for _, fileID := range fileIDs {
+		err := a.Srv().Store().FileInfo().AttachToPost(rctx, fileID, postID, channelID, userID)
+		if err != nil {
+			rctx.Logger().Warn("Failed to attach file to post", mlog.String("file_id", fileID), mlog.String("post_id", postID), mlog.Err(err))
+			continue
+		}
+
+		attachedIds = append(attachedIds, fileID)
+	}
+	return attachedIds
+}
+
 // FillInPostProps should be invoked before saving posts to fill in properties such as
 // channel_mentions.
 //
@@ -674,7 +679,11 @@ func (a *App) DeleteEphemeralPost(rctx request.CTX, userID, postID string) {
 	a.Publish(message)
 }
 
-func (a *App) UpdatePost(c request.CTX, receivedUpdatedPost *model.Post, safeUpdate bool) (*model.Post, *model.AppError) {
+func (a *App) UpdatePost(c request.CTX, receivedUpdatedPost *model.Post, updatePostOptions *model.UpdatePostOptions) (*model.Post, *model.AppError) {
+	if updatePostOptions == nil {
+		updatePostOptions = model.DefaultUpdatePostOptions()
+	}
+
 	receivedUpdatedPost.SanitizeProps()
 
 	postLists, nErr := a.Srv().Store().Post().Get(context.Background(), receivedUpdatedPost.Id, model.GetPostsOptions{}, "", a.Config().GetSanitizeOptions())
@@ -725,11 +734,17 @@ func (a *App) UpdatePost(c request.CTX, receivedUpdatedPost *model.Post, safeUpd
 		newPost.Hashtags, _ = model.ParseHashtags(receivedUpdatedPost.Message)
 	}
 
-	if !safeUpdate {
+	if !updatePostOptions.SafeUpdate {
 		newPost.IsPinned = receivedUpdatedPost.IsPinned
 		newPost.HasReactions = receivedUpdatedPost.HasReactions
-		newPost.FileIds = receivedUpdatedPost.FileIds
 		newPost.SetProps(receivedUpdatedPost.GetProps())
+
+		var fileIds []string
+		fileIds, appErr = a.processPostFileChanges(c, receivedUpdatedPost, oldPost, updatePostOptions)
+		if appErr != nil {
+			return nil, appErr
+		}
+		newPost.FileIds = fileIds
 	}
 
 	// Avoid deep-equal checks if EditAt was already modified through message change
@@ -928,7 +943,11 @@ func (a *App) setupBroadcastHookForPermalink(rctx request.CTX, post *model.Post,
 	return nil
 }
 
-func (a *App) PatchPost(c request.CTX, postID string, patch *model.PostPatch) (*model.Post, *model.AppError) {
+func (a *App) PatchPost(c request.CTX, postID string, patch *model.PostPatch, patchPostOptions *model.UpdatePostOptions) (*model.Post, *model.AppError) {
+	if patchPostOptions == nil {
+		patchPostOptions = model.DefaultUpdatePostOptions()
+	}
+
 	post, err := a.GetSinglePost(c, postID, false)
 	if err != nil {
 		return nil, err
@@ -950,7 +969,8 @@ func (a *App) PatchPost(c request.CTX, postID string, patch *model.PostPatch) (*
 
 	post.Patch(patch)
 
-	updatedPost, err := a.UpdatePost(c, post, false)
+	patchPostOptions.SafeUpdate = false
+	updatedPost, err := a.UpdatePost(c, post, patchPostOptions)
 	if err != nil {
 		return nil, err
 	}
@@ -2144,9 +2164,30 @@ func (a *App) GetEditHistoryForPost(postID string) ([]*model.Post, *model.AppErr
 		}
 	}
 
+	if appErr := a.populateEditHistoryFileMetadata(posts); appErr != nil {
+		return nil, appErr
+	}
+
 	return posts, nil
 }
 
+func (a *App) populateEditHistoryFileMetadata(editHistoryPosts []*model.Post) *model.AppError {
+	for _, post := range editHistoryPosts {
+		fileInfos, err := a.Srv().Store().FileInfo().GetByIds(post.FileIds, true, true)
+		if err != nil {
+			return model.NewAppError("app.populateEditHistoryFileMetadata", "app.file_info.get_by_ids.app_error", map[string]any{"post_id": post.Id}, "", http.StatusInternalServerError).Wrap(err)
+		}
+
+		if post.Metadata == nil {
+			post.Metadata = &model.PostMetadata{}
+		}
+
+		post.Metadata.Files = fileInfos
+	}
+
+	return nil
+}
+
 func (a *App) SetPostReminder(rctx request.CTX, postID, userID string, targetTime int64) *model.AppError {
 	// Store the reminder in the DB
 	reminder := &model.PostReminder{

server/channels/app/post_file_change.go

@@ -0,0 +1,70 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package app
+
+import (
+	"github.com/mattermost/mattermost/server/public/model"
+	"github.com/mattermost/mattermost/server/public/shared/request"
+	"github.com/mattermost/mattermost/server/public/utils"
+)
+
+func (a *App) processPostFileChanges(rctx request.CTX, newPost, oldPost *model.Post, updatePostOptions *model.UpdatePostOptions) (model.StringArray, *model.AppError) {
+	newFileIDs := model.RemoveDuplicateStrings(newPost.FileIds)
+	oldFileIDs := model.RemoveDuplicateStrings(oldPost.FileIds)
+
+	addedFileIDs, removedFileIDs, unchangedFileIDs := utils.FindExclusives(newFileIDs, oldFileIDs)
+
+	if len(addedFileIDs) > 0 {
+		if updatePostOptions != nil && updatePostOptions.IsRestorePost {
+			err := a.Srv().Store().FileInfo().RestoreForPostByIds(rctx, newPost.Id, addedFileIDs)
+			if err != nil {
+				return nil, model.NewAppError("app.processPostFileChanges", "app.file_info.undelete_for_post_ids.app_error", map[string]any{"post_id": newPost.Id}, "", 0).Wrap(err)
+			}
+		} else {
+			a.attachNewFilesToPost(rctx, newPost, addedFileIDs, unchangedFileIDs)
+		}
+	}
+
+	if len(removedFileIDs) > 0 {
+		if appErr := a.detachFilesFromPost(rctx, newPost.Id, removedFileIDs); appErr != nil {
+			return nil, appErr
+		}
+	}
+
+	filesChanged := len(addedFileIDs) > 0 || len(removedFileIDs) > 0
+	if filesChanged {
+		// if files were modified, invalidate the file metadata cache for the post
+		// so that the updated file metadata can be returned.
+		a.Srv().Store().FileInfo().InvalidateFileInfosForPostCache(newPost.Id, false)
+	}
+
+	return newPost.FileIds, nil
+}
+
+func (a *App) attachNewFilesToPost(rctx request.CTX, post *model.Post, addedFileIDs, unchangedFileIDs []string) {
+	// for newly added files, we need to attach them to the post
+
+	// intentionally using UserID from session instead of post.UserID
+	// to support admin attaching files in someone else's post.
+	// Admins can edit other's posts, including message, removing existing files,
+	// and attaching new files.
+	// When an admin uploads new files, they are associated with their user ID. So, when attaching
+	// these file to a post, we need to search for their FileInfo entry
+	// by the admin's user ID and not the post author's user ID.
+	userId := rctx.Session().UserId
+	attachedFileIDs := a.attachFileIDsToPost(rctx, post.Id, post.ChannelId, userId, addedFileIDs)
+	if len(attachedFileIDs) != len(addedFileIDs) {
+		// if not all files could be attached, the final list of files
+		// is those that could be attached + the existing, unchanged files
+		post.FileIds = append(attachedFileIDs, unchangedFileIDs...)
+	}
+}
+
+func (a *App) detachFilesFromPost(rctx request.CTX, postId string, removedFileIDs []string) *model.AppError {
+	if err := a.Srv().Store().FileInfo().DeleteForPostByIds(rctx, postId, removedFileIDs); err != nil {
+		return model.NewAppError("app.detachFilesFromPost", "app.file_info.delete_for_post_ids.app_error", map[string]any{"post_id": postId}, "", 0).Wrap(err)
+	}
+
+	return nil
+}

server/channels/app/post_file_change_test.go

@@ -0,0 +1,274 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package app
+
+import (
+	"testing"
+
+	"github.com/mattermost/mattermost/server/public/model"
+	"github.com/stretchr/testify/require"
+)
+
+func TestProcessPostFileChanges(t *testing.T) {
+	th := Setup(t).InitBasic()
+	defer th.TearDown()
+
+	t.Run("no files", func(t *testing.T) {
+		oldPost := &model.Post{FileIds: []string{}}
+		newPost := &model.Post{FileIds: []string{}}
+
+		fileIds, appErr := th.App.processPostFileChanges(th.Context, newPost, oldPost, nil)
+		require.Nil(t, appErr)
+		require.Equal(t, 0, len(fileIds))
+	})
+
+	t.Run("have files but nothing changed", func(t *testing.T) {
+		oldPost := &model.Post{FileIds: []string{"file_id_1", "file_id_2"}}
+		newPost := &model.Post{FileIds: []string{"file_id_1", "file_id_2"}}
+
+		fileIds, appErr := th.App.processPostFileChanges(th.Context, newPost, oldPost, nil)
+		require.Nil(t, appErr)
+		require.Equal(t, 2, len(fileIds))
+	})
+
+	t.Run("one file deleted", func(t *testing.T) {
+		postId := model.NewId()
+		fileInfo1 := th.CreateFileInfo(th.BasicUser.Id, postId, th.BasicChannel.Id)
+		fileInfo2 := th.CreateFileInfo(th.BasicUser.Id, postId, th.BasicChannel.Id)
+
+		oldPost := &model.Post{
+			Id:        postId,
+			UserId:    th.BasicUser.Id,
+			ChannelId: th.BasicChannel.Id,
+			Message:   "Message",
+			CreateAt:  model.GetMillis() - 10000,
+			FileIds:   []string{fileInfo1.Id, fileInfo2.Id},
+		}
+
+		newPost := &model.Post{
+			Id:        postId,
+			UserId:    th.BasicUser.Id,
+			ChannelId: th.BasicChannel.Id,
+			Message:   "Message",
+			CreateAt:  model.GetMillis() - 10000,
+			FileIds:   []string{fileInfo1.Id},
+		}
+
+		fileIds, appErr := th.App.processPostFileChanges(th.Context, newPost, oldPost, nil)
+		require.Nil(t, appErr)
+		require.Equal(t, 1, len(fileIds))
+		require.Equal(t, fileInfo1.Id, fileIds[0])
+
+		// verify file2 was soft deleted
+		updatedFileInfos, err := th.App.Srv().Store().FileInfo().GetForPost(postId, true, true, false)
+		require.NoError(t, err)
+		require.Equal(t, 2, len(updatedFileInfos))
+
+		for _, fileInfo := range updatedFileInfos {
+			if fileInfo.Id == fileInfo1.Id {
+				require.Equal(t, int64(0), fileInfo.DeleteAt)
+			} else if fileInfo.Id == fileInfo2.Id {
+				require.Greater(t, fileInfo.DeleteAt, int64(0))
+			} else {
+				require.Fail(t, "unexpected file info")
+			}
+		}
+	})
+
+	t.Run("one file added", func(t *testing.T) {
+		postId := model.NewId()
+		fileInfo1 := th.CreateFileInfo(th.BasicUser.Id, postId, th.BasicChannel.Id)
+		fileInfo2 := th.CreateFileInfo(th.BasicUser.Id, "", th.BasicChannel.Id)
+
+		oldPost := &model.Post{
+			Id:        postId,
+			UserId:    th.BasicUser.Id,
+			ChannelId: th.BasicChannel.Id,
+			Message:   "Message",
+			CreateAt:  model.GetMillis() - 10000,
+			FileIds:   []string{fileInfo1.Id},
+		}
+
+		newPost := &model.Post{
+			Id:        postId,
+			UserId:    th.BasicUser.Id,
+			ChannelId: th.BasicChannel.Id,
+			Message:   "Message",
+			CreateAt:  model.GetMillis() - 10000,
+			FileIds:   []string{fileInfo1.Id, fileInfo2.Id},
+		}
+
+		th.Context.Session().UserId = th.BasicUser.Id
+
+		fileIds, appErr := th.App.processPostFileChanges(th.Context, newPost, oldPost, nil)
+		require.Nil(t, appErr)
+		require.Equal(t, 2, len(fileIds))
+		require.Contains(t, fileIds, fileInfo1.Id)
+		require.Contains(t, fileIds, fileInfo2.Id)
+
+		// verify file2 is attached to the post
+		updatedFileInfo2, err := th.App.Srv().Store().FileInfo().Get(fileInfo2.Id)
+		require.NoError(t, err)
+		require.Equal(t, postId, updatedFileInfo2.PostId)
+	})
+
+	t.Run("all files removed", func(t *testing.T) {
+		postId := model.NewId()
+		fileInfo1 := th.CreateFileInfo(th.BasicUser.Id, postId, th.BasicChannel.Id)
+		fileInfo2 := th.CreateFileInfo(th.BasicUser.Id, postId, th.BasicChannel.Id)
+
+		oldPost := &model.Post{
+			Id:        postId,
+			UserId:    th.BasicUser.Id,
+			ChannelId: th.BasicChannel.Id,
+			Message:   "Message",
+			CreateAt:  model.GetMillis() - 10000,
+			FileIds:   []string{fileInfo1.Id, fileInfo2.Id},
+		}
+
+		newPost := &model.Post{
+			Id:        postId,
+			UserId:    th.BasicUser.Id,
+			ChannelId: th.BasicChannel.Id,
+			Message:   "Message",
+			CreateAt:  model.GetMillis() - 10000,
+			FileIds:   []string{},
+		}
+
+		fileIds, appErr := th.App.processPostFileChanges(th.Context, newPost, oldPost, nil)
+		require.Nil(t, appErr)
+		require.Equal(t, 0, len(fileIds))
+
+		// verify file2 was soft deleted
+		updatedFileInfos, err := th.App.Srv().Store().FileInfo().GetForPost(postId, true, true, false)
+		require.NoError(t, err)
+		require.Equal(t, 2, len(updatedFileInfos))
+
+		for _, fileInfo := range updatedFileInfos {
+			if fileInfo.Id == fileInfo1.Id || fileInfo.Id == fileInfo2.Id {
+				require.Greater(t, fileInfo.DeleteAt, int64(0))
+			} else {
+				require.Fail(t, "unexpected file info")
+			}
+		}
+	})
+
+	t.Run("files added when no files existed", func(t *testing.T) {
+		fileInfo1 := th.CreateFileInfo(th.BasicUser.Id, "", th.BasicChannel.Id)
+		fileInfo2 := th.CreateFileInfo(th.BasicUser.Id, "", th.BasicChannel.Id)
+
+		postId := model.NewId()
+		oldPost := &model.Post{
+			Id:        postId,
+			UserId:    th.BasicUser.Id,
+			ChannelId: th.BasicChannel.Id,
+			Message:   "Message",
+			CreateAt:  model.GetMillis() - 10000,
+			FileIds:   []string{},
+		}
+
+		newPost := &model.Post{
+			Id:        postId,
+			UserId:    th.BasicUser.Id,
+			ChannelId: th.BasicChannel.Id,
+			Message:   "Message",
+			CreateAt:  model.GetMillis() - 10000,
+			FileIds:   []string{fileInfo1.Id, fileInfo2.Id},
+		}
+
+		fileIds, appErr := th.App.processPostFileChanges(th.Context, newPost, oldPost, nil)
+		require.Nil(t, appErr)
+		require.Equal(t, 2, len(fileIds))
+		require.Contains(t, fileIds, fileInfo1.Id)
+		require.Contains(t, fileIds, fileInfo2.Id)
+
+		updatedFileInfo1, err := th.App.Srv().Store().FileInfo().Get(fileInfo2.Id)
+		require.NoError(t, err)
+		require.Equal(t, postId, updatedFileInfo1.PostId)
+
+		updatedFileInfo2, err := th.App.Srv().Store().FileInfo().Get(fileInfo2.Id)
+		require.NoError(t, err)
+		require.Equal(t, postId, updatedFileInfo2.PostId)
+	})
+
+	t.Run("other post's attached file added", func(t *testing.T) {
+		postId := model.NewId()
+		fileInfo1 := th.CreateFileInfo(th.BasicUser.Id, postId, th.BasicChannel.Id)
+		fileInfo2 := th.CreateFileInfo(th.BasicUser.Id, model.NewId(), th.BasicChannel.Id)
+
+		oldPost := &model.Post{
+			Id:        postId,
+			UserId:    th.BasicUser.Id,
+			ChannelId: th.BasicChannel.Id,
+			Message:   "Message",
+			CreateAt:  model.GetMillis() - 10000,
+			FileIds:   []string{fileInfo1.Id},
+		}
+
+		newPost := &model.Post{
+			Id:        postId,
+			UserId:    th.BasicUser.Id,
+			ChannelId: th.BasicChannel.Id,
+			Message:   "Message",
+			CreateAt:  model.GetMillis() - 10000,
+			FileIds:   []string{fileInfo1.Id, fileInfo2.Id},
+		}
+
+		fileIds, appErr := th.App.processPostFileChanges(th.Context, newPost, oldPost, nil)
+		require.Nil(t, appErr)
+		require.Equal(t, 1, len(fileIds))
+		require.Equal(t, fileInfo1.Id, fileIds[0])
+
+		// verify file2 is attached to the post
+		updatedFileInfo2, err := th.App.Srv().Store().FileInfo().Get(fileInfo2.Id)
+		require.NoError(t, err)
+		require.NotEqual(t, postId, updatedFileInfo2.PostId)
+	})
+
+	t.Run("when admin adds a file to other user's post", func(t *testing.T) {
+		postId := model.NewId()
+
+		// admin uploads the files
+		fileInfo1 := th.CreateFileInfo(th.SystemAdminUser.Id, "", th.BasicChannel.Id)
+		fileInfo2 := th.CreateFileInfo(th.SystemAdminUser.Id, "", th.BasicChannel.Id)
+
+		// basic user's post
+		oldPost := &model.Post{
+			Id:        postId,
+			UserId:    th.BasicUser.Id,
+			ChannelId: th.BasicChannel.Id,
+			Message:   "Message",
+			CreateAt:  model.GetMillis() - 10000,
+		}
+
+		newPost := &model.Post{
+			Id:        postId,
+			UserId:    th.BasicUser.Id,
+			ChannelId: th.BasicChannel.Id,
+			Message:   "Message",
+			CreateAt:  model.GetMillis() - 10000,
+			FileIds:   []string{fileInfo1.Id, fileInfo2.Id}, // admin attaching two files
+		}
+
+		// admin's session
+		th.Context.Session().UserId = th.SystemAdminUser.Id
+
+		fileIds, appErr := th.App.processPostFileChanges(th.Context, newPost, oldPost, nil)
+		require.Nil(t, appErr)
+		require.Equal(t, 2, len(fileIds))
+		require.Contains(t, fileIds, fileInfo1.Id)
+		require.Contains(t, fileIds, fileInfo2.Id)
+
+		// verify files are attached to the post and still belong tyo the admin
+		updatedFileInfo1, err := th.App.Srv().Store().FileInfo().Get(fileInfo1.Id)
+		require.NoError(t, err)
+		require.Equal(t, postId, updatedFileInfo1.PostId)
+		require.Equal(t, th.SystemAdminUser.Id, updatedFileInfo1.CreatorId)
+
+		updatedFileInfo2, err := th.App.Srv().Store().FileInfo().Get(fileInfo2.Id)
+		require.NoError(t, err)
+		require.Equal(t, postId, updatedFileInfo2.PostId)
+		require.Equal(t, th.SystemAdminUser.Id, updatedFileInfo2.CreatorId)
+	})
+}

server/channels/app/post_restore.go

@@ -0,0 +1,58 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package app
+
+import (
+	"net/http"
+
+	"github.com/mattermost/mattermost/server/v8/channels/store"
+	"github.com/pkg/errors"
+
+	"github.com/mattermost/mattermost/server/public/model"
+	"github.com/mattermost/mattermost/server/public/shared/request"
+)
+
+func (a *App) RestorePostVersion(c request.CTX, userID, postID, restoreVersionID string) (*model.Post, *model.AppError) {
+	toRestorePostVersion, err := a.Srv().Store().Post().GetSingle(c, restoreVersionID, true)
+	if err != nil {
+		var statusCode int
+		var notFoundErr *store.ErrNotFound
+		switch {
+		case errors.As(err, &notFoundErr):
+			statusCode = http.StatusNotFound
+		default:
+			statusCode = http.StatusInternalServerError
+		}
+
+		return nil, model.NewAppError("RestorePostVersion", "app.post.restore_post_version.get_single.app_error", nil, err.Error(), statusCode)
+	}
+
+	// restoreVersionID needs to be an old version of postID
+	// this is only a safeguard and this should never happen in practice.
+	if toRestorePostVersion.OriginalId != postID {
+		return nil, model.NewAppError("RestorePostVersion", "app.post.restore_post_version.not_an_history_item.app_error", nil, "", http.StatusBadRequest)
+	}
+
+	// the user needs to be the author of the post
+	// this is only a safeguard and this should never happen in practice.
+	if toRestorePostVersion.UserId != userID {
+		return nil, model.NewAppError("RestorePostVersion", "app.post.restore_post_version.not_allowed.app_error", nil, "", http.StatusForbidden)
+	}
+
+	// the old version of post needs to be a deleted post
+	if toRestorePostVersion.DeleteAt == 0 {
+		return nil, model.NewAppError("RestorePostVersion", "app.post.restore_post_version.not_valid_post_history_item.app_error", nil, "", http.StatusBadRequest)
+	}
+
+	postPatch := &model.PostPatch{
+		Message: &toRestorePostVersion.Message,
+		FileIds: &toRestorePostVersion.FileIds,
+	}
+
+	patchPostOptions := &model.UpdatePostOptions{
+		IsRestorePost: true,
+	}
+
+	return a.PatchPost(c, postID, postPatch, patchPostOptions)
+}

server/channels/app/post_restore_test.go

@@ -0,0 +1,180 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package app
+
+import (
+	"net/http"
+	"testing"
+
+	"github.com/mattermost/mattermost/server/public/model"
+	"github.com/stretchr/testify/require"
+)
+
+func TestRestorePostVersion(t *testing.T) {
+	th := Setup(t).InitBasic()
+	defer th.TearDown()
+
+	t.Run("is able to restore a post version", func(t *testing.T) {
+		post := th.CreatePost(th.BasicChannel, func(p *model.Post) {
+			p.Message = "original message"
+		})
+		th.PostPatch(post, "new message 2")
+		th.PostPatch(post, "new message 3")
+
+		// verify post's state
+		fetchedPost, err := th.App.Srv().Store().Post().GetSingle(th.Context, post.Id, true)
+		require.NoError(t, err)
+		require.Equal(t, "new message 3", fetchedPost.Message)
+
+		editHistory, appErr := th.App.GetEditHistoryForPost(post.Id)
+		require.Nil(t, appErr)
+		require.Equal(t, 2, len(editHistory))
+		require.Equal(t, "new message 2", editHistory[0].Message)
+
+		// now we'll restore a post version
+		restoredPost, appErr := th.App.RestorePostVersion(th.Context, th.BasicUser.Id, post.Id, editHistory[0].Id)
+		require.Nil(t, appErr)
+		require.Equal(t, "new message 2", restoredPost.Message)
+
+		// verify from database
+		fetchedPost, err = th.App.Srv().Store().Post().GetSingle(th.Context, post.Id, true)
+		require.NoError(t, err)
+		require.Equal(t, "new message 2", fetchedPost.Message)
+
+		// verify that we now have 3 items in post's edit history
+		editHistory, appErr = th.App.GetEditHistoryForPost(post.Id)
+		require.Nil(t, appErr)
+		require.Equal(t, 3, len(editHistory))
+		require.Equal(t, "new message 3", editHistory[0].Message)
+		require.Equal(t, "new message 2", editHistory[1].Message)
+		require.Equal(t, "original message", editHistory[2].Message)
+	})
+
+	t.Run("is able to restore a post version including its files", func(t *testing.T) {
+		fileBytes := []byte("file contents")
+		fileInfo, appErr := th.App.UploadFile(th.Context, fileBytes, th.BasicChannel.Id, "file.txt")
+		require.Nil(t, appErr)
+
+		post := th.CreatePost(th.BasicChannel, func(p *model.Post) {
+			p.FileIds = []string{fileInfo.Id}
+			p.Message = "original message"
+		})
+
+		// this update removes all files
+		th.PostPatch(post, "new message 2", func(p *model.PostPatch) {
+			p.FileIds = &model.StringArray{}
+		})
+		// this update only changes the message
+		th.PostPatch(post, "new message 3")
+
+		// verify post's state
+		fetchedPost, err := th.App.Srv().Store().Post().GetSingle(th.Context, post.Id, true)
+		require.NoError(t, err)
+		require.Equal(t, "new message 3", fetchedPost.Message)
+		require.Empty(t, fetchedPost.FileIds)
+
+		editHistory, appErr := th.App.GetEditHistoryForPost(post.Id)
+		require.Nil(t, appErr)
+		require.Equal(t, 2, len(editHistory))
+		require.Equal(t, "new message 2", editHistory[0].Message)
+		require.Equal(t, 0, len(editHistory[0].FileIds))
+
+		require.Equal(t, "original message", editHistory[1].Message)
+		require.Equal(t, 1, len(editHistory[1].FileIds))
+
+		// now we'll restore a post version
+		restoredPost, appErr := th.App.RestorePostVersion(th.Context, th.BasicUser.Id, post.Id, editHistory[1].Id)
+		require.Nil(t, appErr)
+		require.Equal(t, "original message", restoredPost.Message)
+		require.Equal(t, 1, len(restoredPost.FileIds))
+
+		// verify from database
+		fetchedPost, err = th.App.Srv().Store().Post().GetSingle(th.Context, post.Id, true)
+		require.NoError(t, err)
+		require.Equal(t, "original message", fetchedPost.Message)
+		require.Equal(t, 1, len(fetchedPost.FileIds))
+
+		// verify edit history\
+		editHistory, appErr = th.App.GetEditHistoryForPost(post.Id)
+		require.Nil(t, appErr)
+		require.Equal(t, 3, len(editHistory))
+
+		require.Equal(t, "new message 3", editHistory[0].Message)
+		require.Equal(t, 0, len(editHistory[0].FileIds))
+
+		require.Equal(t, "new message 2", editHistory[1].Message)
+		require.Equal(t, 0, len(editHistory[1].FileIds))
+
+		require.Equal(t, "original message", editHistory[2].Message)
+		require.Equal(t, 1, len(editHistory[2].FileIds))
+	})
+
+	t.Run("should return an error if trying to restore a post that is not in any edit history", func(t *testing.T) {
+		post := th.CreatePost(th.BasicChannel, func(p *model.Post) {
+			p.Message = "original message"
+		})
+		th.PostPatch(post, "new message 2")
+		th.PostPatch(post, "new message 3")
+
+		// verify post's state
+		fetchedPost, err := th.App.Srv().Store().Post().GetSingle(th.Context, post.Id, true)
+		require.NoError(t, err)
+		require.Equal(t, "new message 3", fetchedPost.Message)
+
+		// now we'll restore a post version
+		otherPost := th.CreatePost(th.BasicChannel)
+		restoredPost, appErr := th.App.RestorePostVersion(th.Context, th.BasicUser.Id, post.Id, otherPost.Id)
+		require.NotNil(t, appErr)
+		require.Equal(t, http.StatusBadRequest, appErr.StatusCode)
+		require.Equal(t, "app.post.restore_post_version.not_an_history_item.app_error", appErr.Id)
+		require.Nil(t, restoredPost)
+
+		// verify from database that the post wasn't modified
+		fetchedPost, err = th.App.Srv().Store().Post().GetSingle(th.Context, post.Id, true)
+		require.NoError(t, err)
+		require.Equal(t, "new message 3", fetchedPost.Message)
+	})
+
+	t.Run("should return an error if the post does not exist", func(t *testing.T) {
+		restoredPost, appErr := th.App.RestorePostVersion(th.Context, th.BasicUser.Id, model.NewId(), model.NewId())
+		require.NotNil(t, appErr)
+		require.Equal(t, http.StatusNotFound, appErr.StatusCode)
+		require.Equal(t, "app.post.restore_post_version.get_single.app_error", appErr.Id)
+		require.Nil(t, restoredPost)
+	})
+
+	t.Run("should return an error if the restore post does not exist", func(t *testing.T) {
+		post := th.CreatePost(th.BasicChannel)
+
+		// now we'll restore a post version
+		invalidRestorePostIUd := model.NewId()
+		restoredPost, appErr := th.App.RestorePostVersion(th.Context, th.BasicUser.Id, post.Id, invalidRestorePostIUd)
+		require.NotNil(t, appErr)
+		require.Equal(t, http.StatusNotFound, appErr.StatusCode)
+		require.Equal(t, "app.post.restore_post_version.get_single.app_error", appErr.Id)
+		require.Nil(t, restoredPost)
+	})
+
+	t.Run("should return an error if trying to restore a post that is in some other posts edit history", func(t *testing.T) {
+		post := th.CreatePost(th.BasicChannel)
+		th.PostPatch(post, "new message 2")
+
+		otherPost := th.CreatePost(th.BasicChannel, func(post *model.Post) {
+			post.Message = "other post original message"
+		})
+		th.PostPatch(otherPost, "other post new message 2")
+
+		otherPostEditHistory, appErr := th.App.GetEditHistoryForPost(otherPost.Id)
+		require.Nil(t, appErr)
+		require.Equal(t, 1, len(otherPostEditHistory))
+		require.Equal(t, "other post original message", otherPostEditHistory[0].Message)
+
+		// we'll specify post's ID and other post's version ID, his should fail
+		restoredPost, appErr := th.App.RestorePostVersion(th.Context, th.BasicUser.Id, post.Id, otherPostEditHistory[0].Id)
+		require.NotNil(t, appErr)
+		require.Equal(t, "app.post.restore_post_version.not_an_history_item.app_error", appErr.Id)
+		require.Equal(t, http.StatusBadRequest, appErr.StatusCode)
+		require.Nil(t, restoredPost)
+	})
+}

server/channels/app/post_test.go

@@ -269,7 +269,7 @@ func TestUpdatePostEditAt(t *testing.T) {
 	post := th.BasicPost.Clone()
 
 	post.IsPinned = true
-	saved, err := th.App.UpdatePost(th.Context, post, true)
+	saved, err := th.App.UpdatePost(th.Context, post, &model.UpdatePostOptions{SafeUpdate: true})
 	require.Nil(t, err)
 	assert.Equal(t, saved.EditAt, post.EditAt, "shouldn't have updated post.EditAt when pinning post")
 	post = saved.Clone()
@@ -277,7 +277,7 @@ func TestUpdatePostEditAt(t *testing.T) {
 	time.Sleep(time.Millisecond * 100)
 
 	post.Message = model.NewId()
-	saved, err = th.App.UpdatePost(th.Context, post, true)
+	saved, err = th.App.UpdatePost(th.Context, post, &model.UpdatePostOptions{SafeUpdate: true})
 	require.Nil(t, err)
 	assert.NotEqual(t, saved.EditAt, post.EditAt, "should have updated post.EditAt when updating post message")
 
@@ -295,7 +295,7 @@ func TestUpdatePostTimeLimit(t *testing.T) {
 	th.App.UpdateConfig(func(cfg *model.Config) {
 		*cfg.ServiceSettings.PostEditTimeLimit = -1
 	})
-	_, err := th.App.UpdatePost(th.Context, post, true)
+	_, err := th.App.UpdatePost(th.Context, post, &model.UpdatePostOptions{SafeUpdate: true})
 	require.Nil(t, err)
 
 	th.App.UpdateConfig(func(cfg *model.Config) {
@@ -303,14 +303,14 @@ func TestUpdatePostTimeLimit(t *testing.T) {
 	})
 	post.Message = model.NewId()
 
-	_, err = th.App.UpdatePost(th.Context, post, true)
+	_, err = th.App.UpdatePost(th.Context, post, &model.UpdatePostOptions{SafeUpdate: true})
 	require.Nil(t, err, "should allow you to edit the post")
 
 	th.App.UpdateConfig(func(cfg *model.Config) {
 		*cfg.ServiceSettings.PostEditTimeLimit = 1
 	})
 	post.Message = model.NewId()
-	_, err = th.App.UpdatePost(th.Context, post, true)
+	_, err = th.App.UpdatePost(th.Context, post, &model.UpdatePostOptions{SafeUpdate: true})
 	require.Nil(t, err, "should allow you to edit an old post because the time check is applied above in the call hierarchy")
 
 	th.App.UpdateConfig(func(cfg *model.Config) {
@@ -326,7 +326,7 @@ func TestUpdatePostInArchivedChannel(t *testing.T) {
 	post := th.CreatePost(archivedChannel)
 	th.App.DeleteChannel(th.Context, archivedChannel, "")
 
-	_, err := th.App.UpdatePost(th.Context, post, true)
+	_, err := th.App.UpdatePost(th.Context, post, &model.UpdatePostOptions{SafeUpdate: true})
 	require.NotNil(t, err)
 	require.Equal(t, "api.post.update_post.can_not_update_post_in_deleted.error", err.Id)
 }
@@ -472,7 +472,7 @@ func TestUpdatePostPluginHooks(t *testing.T) {
 		require.Nil(t, err)
 
 		post.Message = "new message"
-		updatedPost, err := th.App.UpdatePost(th.Context, post, false)
+		updatedPost, err := th.App.UpdatePost(th.Context, post, nil)
 		require.Nil(t, updatedPost)
 		require.NotNil(t, err)
 		require.Equal(t, "Post rejected by plugin. rejected", err.Id)
@@ -539,7 +539,7 @@ func TestUpdatePostPluginHooks(t *testing.T) {
 		require.Nil(t, err)
 
 		post.Message = "new message"
-		updatedPost, err := th.App.UpdatePost(th.Context, post, false)
+		updatedPost, err := th.App.UpdatePost(th.Context, post, nil)
 		require.Nil(t, err)
 		require.NotNil(t, updatedPost)
 		require.Equal(t, "2 new message 1", updatedPost.Message)
@@ -591,7 +591,7 @@ func TestPostChannelMentions(t *testing.T) {
 	}, post.GetProp("channel_mentions"))
 
 	post.Message = fmt.Sprintf("goodbye, ~%v!", channelToMention2.Name)
-	result, err := th.App.UpdatePost(th.Context, post, false)
+	result, err := th.App.UpdatePost(th.Context, post, nil)
 	require.Nil(t, err)
 	assert.Equal(t, map[string]any{
 		"mention-test2": map[string]any{
@@ -601,7 +601,7 @@ func TestPostChannelMentions(t *testing.T) {
 	}, result.GetProp("channel_mentions"))
 
 	result.Message = "no more mentions!"
-	result, err = th.App.UpdatePost(th.Context, result, false)
+	result, err = th.App.UpdatePost(th.Context, result, nil)
 	require.Nil(t, err)
 	assert.Nil(t, result.GetProp("channel_mentions"))
 }
@@ -1123,7 +1123,7 @@ func TestCreatePost(t *testing.T) {
 			go func() {
 				defer wg.Done()
 				post := previewPost.Clone()
-				th.App.UpdatePost(th.Context, post, false)
+				th.App.UpdatePost(th.Context, post, nil)
 			}()
 		}
 
@@ -1194,7 +1194,7 @@ func TestPatchPost(t *testing.T) {
 			Message: model.NewPointer("![image](" + imageURL + ")"),
 		}
 
-		rpost, err = th.App.PatchPost(th.Context, rpost.Id, patch)
+		rpost, err = th.App.PatchPost(th.Context, rpost.Id, patch, nil)
 		require.Nil(t, err)
 		assert.Equal(t, "![image]("+proxiedImageURL+")", rpost.Message)
 	})
@@ -1217,13 +1217,13 @@ func TestPatchPost(t *testing.T) {
 		t.Run("Does not set prop when user has USE_CHANNEL_MENTIONS", func(t *testing.T) {
 			patchWithNoMention := &model.PostPatch{Message: model.NewPointer("This patch has no channel mention")}
 
-			rpost, err = th.App.PatchPost(th.Context, rpost.Id, patchWithNoMention)
+			rpost, err = th.App.PatchPost(th.Context, rpost.Id, patchWithNoMention, nil)
 			require.Nil(t, err)
 			assert.Equal(t, rpost.GetProps(), model.StringInterface{})
 
 			patchWithMention := &model.PostPatch{Message: model.NewPointer("This patch has a mention now @here")}
 
-			rpost, err = th.App.PatchPost(th.Context, rpost.Id, patchWithMention)
+			rpost, err = th.App.PatchPost(th.Context, rpost.Id, patchWithMention, nil)
 			require.Nil(t, err)
 			assert.Equal(t, rpost.GetProps(), model.StringInterface{})
 		})
@@ -1233,13 +1233,13 @@ func TestPatchPost(t *testing.T) {
 			th.RemovePermissionFromRole(model.PermissionUseChannelMentions.Id, model.ChannelAdminRoleId)
 
 			patchWithNoMention := &model.PostPatch{Message: model.NewPointer("This patch still does not have a mention")}
-			rpost, err = th.App.PatchPost(th.Context, rpost.Id, patchWithNoMention)
+			rpost, err = th.App.PatchPost(th.Context, rpost.Id, patchWithNoMention, nil)
 			require.Nil(t, err)
 			assert.Equal(t, rpost.GetProps(), model.StringInterface{})
 
 			patchWithMention := &model.PostPatch{Message: model.NewPointer("This patch has a mention now @here")}
 
-			rpost, err = th.App.PatchPost(th.Context, rpost.Id, patchWithMention)
+			rpost, err = th.App.PatchPost(th.Context, rpost.Id, patchWithMention, nil)
 			require.Nil(t, err)
 			assert.Equal(t, rpost.GetProp(model.PostPropsMentionHighlightDisabled), true)
 
@@ -1433,7 +1433,7 @@ func TestPatchPostInArchivedChannel(t *testing.T) {
 	post := th.CreatePost(archivedChannel)
 	th.App.DeleteChannel(th.Context, archivedChannel, "")
 
-	_, err := th.App.PatchPost(th.Context, post.Id, &model.PostPatch{IsPinned: model.NewPointer(true)})
+	_, err := th.App.PatchPost(th.Context, post.Id, &model.PostPatch{IsPinned: model.NewPointer(true)}, nil)
 	require.NotNil(t, err)
 	require.Equal(t, "api.post.patch_post.can_not_update_post_in_deleted.error", err.Id)
 }
@@ -1539,7 +1539,7 @@ func TestUpdatePost(t *testing.T) {
 		post.Id = rpost.Id
 		post.Message = "![image](" + imageURL + ")"
 
-		rpost, err = th.App.UpdatePost(th.Context, post, false)
+		rpost, err = th.App.UpdatePost(th.Context, post, nil)
 		require.Nil(t, err)
 		assert.Equal(t, "![image]("+proxiedImageURL+")", rpost.Message)
 	})
@@ -1578,7 +1578,7 @@ func TestUpdatePost(t *testing.T) {
 		assert.Equal(t, model.StringInterface{}, testPost.GetProps())
 
 		testPost.Message = permalink
-		testPost, err = th.App.UpdatePost(th.Context, testPost, false)
+		testPost, err = th.App.UpdatePost(th.Context, testPost, nil)
 		require.Nil(t, err)
 		assert.Equal(t, model.StringInterface{model.PostPropsPreviewedPost: referencedPost.Id}, testPost.GetProps())
 	})
@@ -1639,7 +1639,7 @@ func TestUpdatePost(t *testing.T) {
 
 				permalink := fmt.Sprintf("%s/%s/pl/%s", *th.App.Config().ServiceSettings.SiteURL, th.BasicTeam.Name, referencedPost.Id)
 				previewPost.Message = permalink
-				previewPost, err = th.App.UpdatePost(th.Context, previewPost, false)
+				previewPost, err = th.App.UpdatePost(th.Context, previewPost, nil)
 				require.Nil(t, err)
 
 				require.Len(t, previewPost.Metadata.Embeds, testCase.Length)
@@ -3126,7 +3126,7 @@ func TestSharedChannelSyncForPostActions(t *testing.T) {
 		}, channel, model.CreatePostFlags{SetOnline: true})
 		require.Nil(t, err, "Creating a post should not error")
 
-		_, err = th.App.UpdatePost(th.Context, post, true)
+		_, err = th.App.UpdatePost(th.Context, post, &model.UpdatePostOptions{SafeUpdate: true})
 		require.Nil(t, err, "Updating a post should not error")
 
 		require.Len(t, sharedChannelService.channelNotifications, 2)
@@ -3410,7 +3410,6 @@ func TestComputeLastAccessiblePostTime(t *testing.T) {
 }
 
 func TestGetEditHistoryForPost(t *testing.T) {
-	t.Skip("This needs fixing, OriginalId seems to be empty for all posts")
 	th := Setup(t).InitBasic()
 	defer th.TearDown()
 
@@ -3427,7 +3426,7 @@ func TestGetEditHistoryForPost(t *testing.T) {
 	patch := &model.PostPatch{
 		Message: model.NewPointer("new message edited"),
 	}
-	_, err1 := th.App.PatchPost(th.Context, rpost.Id, patch)
+	_, err1 := th.App.PatchPost(th.Context, rpost.Id, patch, nil)
 	require.Nil(t, err1)
 
 	// update the post message again
@@ -3435,14 +3434,13 @@ func TestGetEditHistoryForPost(t *testing.T) {
 		Message: model.NewPointer("new message edited again"),
 	}
 
-	_, err2 := th.App.PatchPost(th.Context, rpost.Id, patch)
+	_, err2 := th.App.PatchPost(th.Context, rpost.Id, patch, nil)
 	require.Nil(t, err2)
 
-	// get the edit history
-	edits, err := th.App.GetEditHistoryForPost(post.Id)
-	require.Nil(t, err)
-
 	t.Run("should return the edit history", func(t *testing.T) {
+		edits, err := th.App.GetEditHistoryForPost(post.Id)
+		require.Nil(t, err)
+
 		require.Len(t, edits, 2)
 		require.Equal(t, "new message edited", edits[0].Message)
 		require.Equal(t, "new message", edits[1].Message)
@@ -3453,6 +3451,103 @@ func TestGetEditHistoryForPost(t *testing.T) {
 		require.NotNil(t, err)
 		require.Empty(t, edits)
 	})
+
+	t.Run("edit history should contain file metadata", func(t *testing.T) {
+		fileBytes := []byte("file contents")
+		fileInfo, err := th.App.UploadFile(th.Context, fileBytes, th.BasicChannel.Id, "file.txt")
+		require.Nil(t, err)
+
+		post := &model.Post{
+			ChannelId: th.BasicChannel.Id,
+			Message:   "new message",
+			UserId:    th.BasicUser.Id,
+			FileIds:   model.StringArray{fileInfo.Id},
+		}
+
+		_, err = th.App.CreatePost(th.Context, post, th.BasicChannel, model.CreatePostFlags{SetOnline: true})
+		require.Nil(t, err)
+
+		patch := &model.PostPatch{
+			Message: model.NewPointer("new message edited"),
+		}
+		_, appErr := th.App.PatchPost(th.Context, post.Id, patch, nil)
+		require.Nil(t, appErr)
+
+		patch = &model.PostPatch{
+			Message: model.NewPointer("new message edited 2"),
+		}
+		_, appErr = th.App.PatchPost(th.Context, post.Id, patch, nil)
+		require.Nil(t, appErr)
+
+		patch = &model.PostPatch{
+			Message: model.NewPointer("new message edited 3"),
+		}
+		_, appErr = th.App.PatchPost(th.Context, post.Id, patch, nil)
+		require.Nil(t, appErr)
+
+		edits, err := th.App.GetEditHistoryForPost(post.Id)
+		require.Nil(t, err)
+
+		require.Len(t, edits, 3)
+
+		for _, edit := range edits {
+			require.Len(t, edit.FileIds, 1)
+			require.Equal(t, fileInfo.Id, edit.FileIds[0])
+			require.Len(t, edit.Metadata.Files, 1)
+			require.Equal(t, fileInfo.Id, edit.Metadata.Files[0].Id)
+		}
+	})
+
+	t.Run("edit history should contain file metadata even if the file info is deleted", func(t *testing.T) {
+		fileBytes := []byte("file contents")
+		fileInfo, appErr := th.App.UploadFile(th.Context, fileBytes, th.BasicChannel.Id, "file.txt")
+		require.Nil(t, appErr)
+
+		post := &model.Post{
+			ChannelId: th.BasicChannel.Id,
+			Message:   "new message",
+			UserId:    th.BasicUser.Id,
+			FileIds:   model.StringArray{fileInfo.Id},
+		}
+
+		_, appErr = th.App.CreatePost(th.Context, post, th.BasicChannel, model.CreatePostFlags{SetOnline: true})
+		require.Nil(t, appErr)
+
+		patch := &model.PostPatch{
+			Message: model.NewPointer("new message edited"),
+		}
+		_, appErr = th.App.PatchPost(th.Context, post.Id, patch, nil)
+		require.Nil(t, appErr)
+
+		patch = &model.PostPatch{
+			Message: model.NewPointer("new message edited 2"),
+		}
+		_, appErr = th.App.PatchPost(th.Context, post.Id, patch, nil)
+		require.Nil(t, appErr)
+
+		patch = &model.PostPatch{
+			Message: model.NewPointer("new message edited 3"),
+		}
+		_, appErr = th.App.PatchPost(th.Context, post.Id, patch, nil)
+		require.Nil(t, appErr)
+
+		// now delete the file info, and it should still be include in edit history metadata
+		_, err := th.App.Srv().Store().FileInfo().DeleteForPost(th.Context, post.Id)
+		require.NoError(t, err)
+
+		edits, appErr := th.App.GetEditHistoryForPost(post.Id)
+		require.Nil(t, appErr)
+
+		require.Len(t, edits, 3)
+
+		for _, edit := range edits {
+			require.Len(t, edit.FileIds, 1)
+			require.Equal(t, fileInfo.Id, edit.FileIds[0])
+			require.Len(t, edit.Metadata.Files, 1)
+			require.Equal(t, fileInfo.Id, edit.Metadata.Files[0].Id)
+			require.Greater(t, edit.Metadata.Files[0].DeleteAt, int64(0))
+		}
+	})
 }
 
 func TestCopyWranglerPostlist(t *testing.T) {
@@ -3731,3 +3826,121 @@ func TestSendTestMessage(t *testing.T) {
 		assert.NotEmpty(t, post.GetProp(model.PostPropsForceNotification))
 	})
 }
+
+func TestPopulateEditHistoryFileMetadata(t *testing.T) {
+	th := Setup(t).InitBasic()
+	defer th.TearDown()
+
+	t.Run("should populate file metadata for all posts", func(t *testing.T) {
+		fileInfo1, err := th.App.Srv().Store().FileInfo().Save(th.Context,
+			&model.FileInfo{
+				CreatorId: th.BasicUser.Id,
+				Path:      "path.txt",
+			})
+		require.NoError(t, err)
+
+		fileInfo2, err := th.App.Srv().Store().FileInfo().Save(th.Context,
+			&model.FileInfo{
+				CreatorId: th.BasicUser.Id,
+				Path:      "path.txt",
+			})
+		require.NoError(t, err)
+
+		post1 := th.CreatePost(th.BasicChannel, func(post *model.Post) {
+			post.FileIds = model.StringArray{fileInfo1.Id}
+		})
+
+		post2 := th.CreatePost(th.BasicChannel, func(post *model.Post) {
+			post.FileIds = model.StringArray{fileInfo2.Id}
+		})
+
+		appErr := th.App.populateEditHistoryFileMetadata([]*model.Post{post1, post2})
+		require.Nil(t, appErr)
+
+		require.Len(t, post1.Metadata.Files, 1)
+		require.Equal(t, fileInfo1.Id, post1.Metadata.Files[0].Id)
+
+		require.Len(t, post2.Metadata.Files, 1)
+		require.Equal(t, fileInfo2.Id, post2.Metadata.Files[0].Id)
+	})
+
+	t.Run("should populate file metadata even for deleted posts", func(t *testing.T) {
+		fileInfo1, err := th.App.Srv().Store().FileInfo().Save(th.Context,
+			&model.FileInfo{
+				CreatorId: th.BasicUser.Id,
+				Path:      "path.txt",
+			})
+		require.NoError(t, err)
+
+		fileInfo2, err := th.App.Srv().Store().FileInfo().Save(th.Context,
+			&model.FileInfo{
+				CreatorId: th.BasicUser.Id,
+				Path:      "path.txt",
+			})
+		require.NoError(t, err)
+
+		post1 := th.CreatePost(th.BasicChannel, func(post *model.Post) {
+			post.FileIds = model.StringArray{fileInfo1.Id}
+		})
+
+		post2 := th.CreatePost(th.BasicChannel, func(post *model.Post) {
+			post.FileIds = model.StringArray{fileInfo2.Id}
+		})
+
+		_, appErr := th.App.DeletePost(th.Context, post1.Id, th.BasicUser.Id)
+		require.Nil(t, appErr)
+
+		_, appErr = th.App.DeletePost(th.Context, post2.Id, th.BasicUser.Id)
+		require.Nil(t, appErr)
+
+		appErr = th.App.populateEditHistoryFileMetadata([]*model.Post{post1, post2})
+		require.Nil(t, appErr)
+
+		require.Len(t, post1.Metadata.Files, 1)
+		require.Equal(t, fileInfo1.Id, post1.Metadata.Files[0].Id)
+
+		require.Len(t, post2.Metadata.Files, 1)
+		require.Equal(t, fileInfo2.Id, post2.Metadata.Files[0].Id)
+	})
+
+	t.Run("should populate file metadata even for deleted fileInfos", func(t *testing.T) {
+		fileInfo1, err := th.App.Srv().Store().FileInfo().Save(th.Context,
+			&model.FileInfo{
+				CreatorId: th.BasicUser.Id,
+				Path:      "path.txt",
+			})
+		require.NoError(t, err)
+
+		fileInfo2, err := th.App.Srv().Store().FileInfo().Save(th.Context,
+			&model.FileInfo{
+				CreatorId: th.BasicUser.Id,
+				Path:      "path.txt",
+			})
+		require.NoError(t, err)
+
+		post1 := th.CreatePost(th.BasicChannel, func(post *model.Post) {
+			post.FileIds = model.StringArray{fileInfo1.Id}
+		})
+
+		post2 := th.CreatePost(th.BasicChannel, func(post *model.Post) {
+			post.FileIds = model.StringArray{fileInfo2.Id}
+		})
+
+		_, err = th.App.Srv().Store().FileInfo().DeleteForPost(th.Context, post1.Id)
+		require.NoError(t, err)
+
+		_, err = th.App.Srv().Store().FileInfo().DeleteForPost(th.Context, post2.Id)
+		require.NoError(t, err)
+
+		appErr := th.App.populateEditHistoryFileMetadata([]*model.Post{post1, post2})
+		require.Nil(t, appErr)
+
+		require.Len(t, post1.Metadata.Files, 1)
+		require.Equal(t, fileInfo1.Id, post1.Metadata.Files[0].Id)
+		require.Greater(t, post1.Metadata.Files[0].DeleteAt, int64(0))
+
+		require.Len(t, post2.Metadata.Files, 1)
+		require.Equal(t, fileInfo2.Id, post2.Metadata.Files[0].Id)
+		require.Greater(t, post2.Metadata.Files[0].DeleteAt, int64(0))
+	})
+}

server/channels/store/localcachelayer/file_info_layer.go

@@ -5,6 +5,7 @@ package localcachelayer
 
 import (
 	"bytes"
+	"fmt"
 
 	"github.com/mattermost/mattermost/server/public/model"
 	"github.com/mattermost/mattermost/server/v8/channels/store"
@@ -50,6 +51,41 @@ func (s LocalCacheFileInfoStore) GetForPost(postId string, readFromMaster, inclu
 	return fileInfos, nil
 }
 
+func (s LocalCacheFileInfoStore) GetByIds(ids []string, includeDeleted, allowFromCache bool) ([]*model.FileInfo, error) {
+	if !allowFromCache {
+		return s.FileInfoStore.GetByIds(ids, includeDeleted, allowFromCache)
+	}
+
+	var fileIdsToFetch []string
+	var fileInfos []*model.FileInfo
+
+	for _, fileId := range ids {
+		cacheKey := fmt.Sprintf("%s_%t", fileId, includeDeleted)
+
+		var fileInfo *model.FileInfo
+		if err := s.rootStore.doStandardReadCache(s.rootStore.fileInfoCache, cacheKey, &fileInfo); err == nil {
+			fileInfos = append(fileInfos, fileInfo)
+		} else {
+			fileIdsToFetch = append(fileIdsToFetch, fileId)
+		}
+	}
+
+	if len(fileIdsToFetch) > 0 {
+		fetchedFileInfos, err := s.FileInfoStore.GetByIds(fileIdsToFetch, includeDeleted, false)
+		if err != nil {
+			return nil, err
+		}
+
+		for _, fileInfo := range fetchedFileInfos {
+			cacheKey := fmt.Sprintf("%s_%t", fileInfo.Id, includeDeleted)
+			s.rootStore.doStandardAddToCache(s.rootStore.fileInfoCache, cacheKey, fileInfo)
+			fileInfos = append(fileInfos, fileInfo)
+		}
+	}
+
+	return fileInfos, nil
+}
+
 func (s LocalCacheFileInfoStore) ClearCaches() {
 	s.rootStore.fileInfoCache.Purge()
 	if s.rootStore.metrics != nil {

server/channels/store/localcachelayer/file_info_layer_test.go

@@ -62,4 +62,19 @@ func TestFileInfoStoreCache(t *testing.T) {
 		cachedStore.FileInfo().GetForPost("123", true, true, true)
 		mockStore.FileInfo().(*mocks.FileInfoStore).AssertNumberOfCalls(t, "GetForPost", 2)
 	})
+
+	t.Run("GetByIds cache test", func(t *testing.T) {
+		mockStore := getMockStore(t)
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider, logger)
+		require.NoError(t, err)
+
+		fileInfos, err := cachedStore.FileInfo().GetByIds([]string{"123"}, true, true)
+		require.NoError(t, err)
+		assert.Equal(t, fileInfos, []*model.FileInfo{&fakeFileInfo})
+		mockStore.FileInfo().(*mocks.FileInfoStore).AssertNumberOfCalls(t, "GetByIds", 1)
+		assert.Equal(t, fileInfos, []*model.FileInfo{&fakeFileInfo})
+		cachedStore.FileInfo().GetForPost("123", true, true, true)
+		mockStore.FileInfo().(*mocks.FileInfoStore).AssertNumberOfCalls(t, "GetForPost", 1)
+	})
 }

server/channels/store/localcachelayer/main_test.go

@@ -64,6 +64,7 @@ func getMockStore(t *testing.T) *mocks.Store {
 	mockFileInfoStore := mocks.FileInfoStore{}
 	mockFileInfoStore.On("GetForPost", "123", true, true, false).Return([]*model.FileInfo{&fakeFileInfo}, nil)
 	mockFileInfoStore.On("GetForPost", "123", true, true, true).Return([]*model.FileInfo{&fakeFileInfo}, nil)
+	mockFileInfoStore.On("GetByIds", []string{"123"}, true, false).Return([]*model.FileInfo{&fakeFileInfo}, nil)
 	mockStore.On("FileInfo").Return(&mockFileInfoStore)
 
 	fakeWebhook := model.IncomingWebhook{Id: "123"}

server/channels/store/opentracinglayer/opentracinglayer.go

@@ -3943,6 +3943,24 @@ func (s *OpenTracingLayerFileInfoStore) DeleteForPost(c request.CTX, postID stri
 	return result, err
 }
 
+func (s *OpenTracingLayerFileInfoStore) DeleteForPostByIds(rctx request.CTX, postId string, fileIDs []string) error {
+	origCtx := s.Root.Store.Context()
+	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "FileInfoStore.DeleteForPostByIds")
+	s.Root.Store.SetContext(newCtx)
+	defer func() {
+		s.Root.Store.SetContext(origCtx)
+	}()
+
+	defer span.Finish()
+	err := s.FileInfoStore.DeleteForPostByIds(rctx, postId, fileIDs)
+	if err != nil {
+		span.LogFields(spanlog.Error(err))
+		ext.Error.Set(span, true)
+	}
+
+	return err
+}
+
 func (s *OpenTracingLayerFileInfoStore) Get(id string) (*model.FileInfo, error) {
 	origCtx := s.Root.Store.Context()
 	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "FileInfoStore.Get")
@@ -3961,7 +3979,7 @@ func (s *OpenTracingLayerFileInfoStore) Get(id string) (*model.FileInfo, error)
 	return result, err
 }
 
-func (s *OpenTracingLayerFileInfoStore) GetByIds(ids []string) ([]*model.FileInfo, error) {
+func (s *OpenTracingLayerFileInfoStore) GetByIds(ids []string, includeDeleted bool, allowFromCache bool) ([]*model.FileInfo, error) {
 	origCtx := s.Root.Store.Context()
 	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "FileInfoStore.GetByIds")
 	s.Root.Store.SetContext(newCtx)
@@ -3970,7 +3988,7 @@ func (s *OpenTracingLayerFileInfoStore) GetByIds(ids []string) ([]*model.FileInf
 	}()
 
 	defer span.Finish()
-	result, err := s.FileInfoStore.GetByIds(ids)
+	result, err := s.FileInfoStore.GetByIds(ids, includeDeleted, allowFromCache)
 	if err != nil {
 		span.LogFields(spanlog.Error(err))
 		ext.Error.Set(span, true)
@@ -4208,6 +4226,24 @@ func (s *OpenTracingLayerFileInfoStore) PermanentDeleteForPost(rctx request.CTX,
 	return err
 }
 
+func (s *OpenTracingLayerFileInfoStore) RestoreForPostByIds(rctx request.CTX, postId string, fileIDs []string) error {
+	origCtx := s.Root.Store.Context()
+	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "FileInfoStore.RestoreForPostByIds")
+	s.Root.Store.SetContext(newCtx)
+	defer func() {
+		s.Root.Store.SetContext(origCtx)
+	}()
+
+	defer span.Finish()
+	err := s.FileInfoStore.RestoreForPostByIds(rctx, postId, fileIDs)
+	if err != nil {
+		span.LogFields(spanlog.Error(err))
+		ext.Error.Set(span, true)
+	}
+
+	return err
+}
+
 func (s *OpenTracingLayerFileInfoStore) Save(ctx request.CTX, info *model.FileInfo) (*model.FileInfo, error) {
 	origCtx := s.Root.Store.Context()
 	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "FileInfoStore.Save")

server/channels/store/retrylayer/retrylayer.go

@@ -4425,6 +4425,27 @@ func (s *RetryLayerFileInfoStore) DeleteForPost(c request.CTX, postID string) (s
 
 }
 
+func (s *RetryLayerFileInfoStore) DeleteForPostByIds(rctx request.CTX, postId string, fileIDs []string) error {
+
+	tries := 0
+	for {
+		err := s.FileInfoStore.DeleteForPostByIds(rctx, postId, fileIDs)
+		if err == nil {
+			return nil
+		}
+		if !isRepeatableError(err) {
+			return err
+		}
+		tries++
+		if tries >= 3 {
+			err = errors.Wrap(err, "giving up after 3 consecutive repeatable transaction failures")
+			return err
+		}
+		timepkg.Sleep(100 * timepkg.Millisecond)
+	}
+
+}
+
 func (s *RetryLayerFileInfoStore) Get(id string) (*model.FileInfo, error) {
 
 	tries := 0
@@ -4446,11 +4467,11 @@ func (s *RetryLayerFileInfoStore) Get(id string) (*model.FileInfo, error) {
 
 }
 
-func (s *RetryLayerFileInfoStore) GetByIds(ids []string) ([]*model.FileInfo, error) {
+func (s *RetryLayerFileInfoStore) GetByIds(ids []string, includeDeleted bool, allowFromCache bool) ([]*model.FileInfo, error) {
 
 	tries := 0
 	for {
-		result, err := s.FileInfoStore.GetByIds(ids)
+		result, err := s.FileInfoStore.GetByIds(ids, includeDeleted, allowFromCache)
 		if err == nil {
 			return result, nil
 		}
@@ -4725,6 +4746,27 @@ func (s *RetryLayerFileInfoStore) PermanentDeleteForPost(rctx request.CTX, postI
 
 }
 
+func (s *RetryLayerFileInfoStore) RestoreForPostByIds(rctx request.CTX, postId string, fileIDs []string) error {
+
+	tries := 0
+	for {
+		err := s.FileInfoStore.RestoreForPostByIds(rctx, postId, fileIDs)
+		if err == nil {
+			return nil
+		}
+		if !isRepeatableError(err) {
+			return err
+		}
+		tries++
+		if tries >= 3 {
+			err = errors.Wrap(err, "giving up after 3 consecutive repeatable transaction failures")
+			return err
+		}
+		timepkg.Sleep(100 * timepkg.Millisecond)
+	}
+
+}
+
 func (s *RetryLayerFileInfoStore) Save(ctx request.CTX, info *model.FileInfo) (*model.FileInfo, error) {
 
 	tries := 0

server/channels/store/searchlayer/file_info_layer.go

@@ -209,7 +209,7 @@ func (s SearchFileInfoStore) Search(rctx request.CTX, paramsList []*model.Search
 			// Get the files
 			filesList := model.NewFileInfoList()
 			if len(fileIds) > 0 {
-				files, nErr := s.FileInfoStore.GetByIds(fileIds)
+				files, nErr := s.FileInfoStore.GetByIds(fileIds, false, true)
 				if nErr != nil {
 					return nil, nErr
 				}

server/channels/store/sqlstore/file_info_store.go

@@ -132,14 +132,17 @@ func (fs SqlFileInfoStore) Save(rctx request.CTX, info *model.FileInfo) (*model.
 	return info, nil
 }
 
-func (fs SqlFileInfoStore) GetByIds(ids []string) ([]*model.FileInfo, error) {
+func (fs SqlFileInfoStore) GetByIds(ids []string, includeDeleted, allowFromCache bool) ([]*model.FileInfo, error) {
 	query := fs.getQueryBuilder().
 		Select(fs.queryFields...).
 		From("FileInfo").
 		Where(sq.Eq{"FileInfo.Id": ids}).
-		Where(sq.Eq{"FileInfo.DeleteAt": 0}).
 		OrderBy("FileInfo.CreateAt DESC")
 
+	if !includeDeleted {
+		query = query.Where(sq.Eq{"FileInfo.DeleteAt": 0})
+	}
+
 	queryString, args, err := query.ToSql()
 	if err != nil {
 		return nil, errors.Wrap(err, "file_info_tosql")
@@ -455,6 +458,27 @@ func (fs SqlFileInfoStore) DeleteForPost(rctx request.CTX, postId string) (strin
 	return postId, nil
 }
 
+func (fs SqlFileInfoStore) DeleteForPostByIds(rctx request.CTX, postId string, fileIDs []string) error {
+	query := fs.getQueryBuilder().
+		Update("FileInfo").
+		Set("DeleteAt", model.GetMillis()).
+		Where(sq.Eq{
+			"PostId": postId,
+			"Id":     fileIDs,
+		})
+
+	queryString, args, err := query.ToSql()
+	if err != nil {
+		return errors.Wrap(err, "SqlFileInfoStore.DeleteForPostByIds: failed to generate sql from query")
+	}
+
+	if _, err := fs.GetMaster().Exec(queryString, args...); err != nil {
+		return errors.Wrap(err, "SqlFileInfoStore.DeleteForPostByIds: failed to soft delete FileInfo from database")
+	}
+
+	return nil
+}
+
 func (fs SqlFileInfoStore) PermanentDeleteForPost(rctx request.CTX, postID string) error {
 	if _, err := fs.GetMaster().Exec(`DELETE FROM FileInfo WHERE PostId = ?`, postID); err != nil {
 		return errors.Wrapf(err, "failed to delete FileInfo with PostId=%s", postID)
@@ -796,3 +820,24 @@ func (fs *SqlFileInfoStore) GetUptoNSizeFileTime(n int64) (int64, error) {
 
 	return createAt, nil
 }
+
+func (fs SqlFileInfoStore) RestoreForPostByIds(rctx request.CTX, postId string, fileIDs []string) error {
+	query := fs.getQueryBuilder().
+		Update("FileInfo").
+		Set("DeleteAt", 0).
+		Where(sq.Eq{
+			"PostId": postId,
+			"Id":     fileIDs,
+		})
+
+	queryString, args, err := query.ToSql()
+	if err != nil {
+		return errors.Wrap(err, "SqlFileInfoStore.RestoreForPostByIds: failed to generate sql from query")
+	}
+
+	if _, err := fs.GetMaster().Exec(queryString, args...); err != nil {
+		return errors.Wrap(err, "SqlFileInfoStore.RestoreForPostByIds: failed to undelete FileInfo from database")
+	}
+
+	return nil
+}

server/channels/store/store.go

@@ -722,7 +722,7 @@ type FileInfoStore interface {
 	Upsert(rctx request.CTX, info *model.FileInfo) (*model.FileInfo, error)
 	Get(id string) (*model.FileInfo, error)
 	GetFromMaster(id string) (*model.FileInfo, error)
-	GetByIds(ids []string) ([]*model.FileInfo, error)
+	GetByIds(ids []string, includeDeleted, allowFromCache bool) ([]*model.FileInfo, error)
 	GetByPath(path string) (*model.FileInfo, error)
 	GetForPost(postID string, readFromMaster, includeDeleted, allowFromCache bool) ([]*model.FileInfo, error)
 	GetForUser(userID string) ([]*model.FileInfo, error)
@@ -730,6 +730,8 @@ type FileInfoStore interface {
 	InvalidateFileInfosForPostCache(postID string, deleted bool)
 	AttachToPost(c request.CTX, fileID string, postID string, channelID, creatorID string) error
 	DeleteForPost(c request.CTX, postID string) (string, error)
+	DeleteForPostByIds(rctx request.CTX, postId string, fileIDs []string) error
+	RestoreForPostByIds(rctx request.CTX, postId string, fileIDs []string) error
 	PermanentDeleteForPost(rctx request.CTX, postID string) error
 	PermanentDelete(c request.CTX, fileID string) error
 	PermanentDeleteBatch(ctx request.CTX, endTime int64, limit int64) (int64, error)

server/channels/store/storetest/file_info_store.go

@@ -38,6 +38,9 @@ func TestFileInfoStore(t *testing.T, rctx request.CTX, ss store.Store, s SqlStor
 	t.Run("GetStorageUsage", func(t *testing.T) { testFileInfoGetStorageUsage(t, rctx, ss) })
 	t.Run("GetUptoNSizeFileTime", func(t *testing.T) { testGetUptoNSizeFileTime(t, rctx, ss, s) })
 	t.Run("FileInfoPermanentDeleteForPost", func(t *testing.T) { testPermanentDeleteForPost(t, rctx, ss) })
+	t.Run("FileInfoGetByIds", func(t *testing.T) { testGetByIds(t, rctx, ss) })
+	t.Run("FileInfoDeleteForPostByIds", func(t *testing.T) { testDeleteForPostByIds(t, rctx, ss) })
+	t.Run("FileInfoRestoreForPostByIds", func(t *testing.T) { testRestoreUndeleteForPostByIds(t, rctx, ss) })
 }
 
 func testFileInfoSaveGet(t *testing.T, rctx request.CTX, ss store.Store) {
@@ -967,3 +970,566 @@ func testPermanentDeleteForPost(t *testing.T, rctx request.CTX, ss store.Store)
 	require.NoError(t, err)
 	assert.Len(t, postInfos, 0)
 }
+
+func testGetByIds(t *testing.T, rctx request.CTX, ss store.Store) {
+	t.Run("Should get single file info", func(t *testing.T) {
+		info, err := ss.FileInfo().Save(rctx, &model.FileInfo{
+			CreatorId: model.NewId(),
+			Path:      "file.txt",
+		})
+		require.NoError(t, err)
+		require.NotEqual(t, len(info.Id), 0)
+
+		defer func() {
+			ss.FileInfo().PermanentDelete(rctx, info.Id)
+		}()
+
+		fileInfos, err := ss.FileInfo().GetByIds([]string{info.Id}, false, true)
+		require.NoError(t, err)
+		require.Len(t, fileInfos, 1)
+		require.Equal(t, info.Id, fileInfos[0].Id)
+	})
+
+	t.Run("Should get multiple file info", func(t *testing.T) {
+		info1, err := ss.FileInfo().Save(rctx, &model.FileInfo{
+			CreatorId: model.NewId(),
+			Path:      "file.txt",
+		})
+		require.NoError(t, err)
+		require.NotEqual(t, len(info1.Id), 0)
+
+		// waiting 1 second to add deterministic difference between the two file info's CreateAt time
+		time.Sleep(1 * time.Second)
+
+		info2, err := ss.FileInfo().Save(rctx, &model.FileInfo{
+			CreatorId: model.NewId(),
+			Path:      "file.txt",
+		})
+		require.NoError(t, err)
+		require.NotEqual(t, len(info2.Id), 0)
+
+		defer func() {
+			ss.FileInfo().PermanentDelete(rctx, info1.Id)
+			ss.FileInfo().PermanentDelete(rctx, info2.Id)
+		}()
+
+		fileInfos, err := ss.FileInfo().GetByIds([]string{info1.Id, info2.Id}, false, true)
+		require.NoError(t, err)
+		require.Len(t, fileInfos, 2)
+		require.Equal(t, info1.Id, fileInfos[1].Id)
+		require.Equal(t, info2.Id, fileInfos[0].Id)
+	})
+
+	t.Run("Should get deleted file infos when specified", func(t *testing.T) {
+		postId := model.NewId()
+
+		info1, err := ss.FileInfo().Save(rctx, &model.FileInfo{
+			CreatorId: model.NewId(),
+			Path:      "file.txt",
+			PostId:    postId,
+		})
+		require.NoError(t, err)
+		require.NotEqual(t, len(info1.Id), 0)
+
+		// waiting 1 second to add deterministic difference between the two file info's CreateAt time
+		time.Sleep(1 * time.Second)
+
+		info2, err := ss.FileInfo().Save(rctx, &model.FileInfo{
+			CreatorId: model.NewId(),
+			Path:      "file.txt",
+			PostId:    postId,
+		})
+		require.NoError(t, err)
+		require.NotEqual(t, len(info2.Id), 0)
+
+		defer func() {
+			ss.FileInfo().PermanentDelete(rctx, info1.Id)
+			ss.FileInfo().PermanentDelete(rctx, info2.Id)
+		}()
+
+		// we'll delete the two file infos
+		_, err = ss.FileInfo().DeleteForPost(rctx, postId)
+		require.NoError(t, err)
+
+		fileInfosIncludingDeleted, err := ss.FileInfo().GetByIds([]string{info1.Id, info2.Id}, true, true)
+		require.NoError(t, err)
+		require.Len(t, fileInfosIncludingDeleted, 2)
+		require.Equal(t, info2.Id, fileInfosIncludingDeleted[0].Id)
+		require.Greater(t, fileInfosIncludingDeleted[0].DeleteAt, int64(0))
+		require.Equal(t, info1.Id, fileInfosIncludingDeleted[1].Id)
+		require.Greater(t, fileInfosIncludingDeleted[1].DeleteAt, int64(0))
+
+		// verifying that the file infos are not returned when IncludeDeleted is false
+		fileInfosExcludingDeleted, err := ss.FileInfo().GetByIds([]string{info1.Id, info2.Id}, false, true)
+		require.NoError(t, err)
+		require.Len(t, fileInfosExcludingDeleted, 0)
+	})
+}
+
+func testDeleteForPostByIds(t *testing.T, rctx request.CTX, ss store.Store) {
+	t.Run("base case", func(t *testing.T) {
+		now := model.GetMillis()
+		postId := model.NewId()
+
+		fileInfo1, err := ss.FileInfo().Save(rctx, &model.FileInfo{
+			PostId:    postId,
+			CreatorId: model.NewId(),
+			Size:      10,
+			Path:      "file1.txt",
+			CreateAt:  now,
+		})
+		require.NoError(t, err)
+		defer ss.FileInfo().PermanentDelete(rctx, fileInfo1.Id)
+
+		fileInfo2, err := ss.FileInfo().Save(rctx, &model.FileInfo{
+			PostId:    postId,
+			CreatorId: model.NewId(),
+			Size:      10,
+			Path:      "file2.txt",
+			CreateAt:  now,
+		})
+		require.NoError(t, err)
+		defer ss.FileInfo().PermanentDelete(rctx, fileInfo2.Id)
+
+		fileInfo3, err := ss.FileInfo().Save(rctx, &model.FileInfo{
+			PostId:    postId,
+			CreatorId: model.NewId(),
+			Size:      10,
+			Path:      "file1.txt",
+			CreateAt:  now,
+		})
+		require.NoError(t, err)
+		defer ss.FileInfo().PermanentDelete(rctx, fileInfo3.Id)
+
+		err = ss.FileInfo().DeleteForPostByIds(rctx, postId, []string{fileInfo1.Id, fileInfo2.Id})
+		require.NoError(t, err)
+
+		fileInfos, err := ss.FileInfo().GetForPost(postId, true, true, false)
+		require.NoError(t, err)
+
+		for _, fileInfo := range fileInfos {
+			if fileInfo.Id == fileInfo1.Id || fileInfo.Id == fileInfo2.Id {
+				require.Greater(t, fileInfo.DeleteAt, int64(0))
+			} else {
+				require.Equal(t, int64(0), fileInfo.DeleteAt)
+			}
+		}
+	})
+
+	t.Run("with empty array", func(t *testing.T) {
+		now := model.GetMillis()
+		postId := model.NewId()
+
+		fileInfo1, err := ss.FileInfo().Save(rctx, &model.FileInfo{
+			PostId:    postId,
+			CreatorId: model.NewId(),
+			Size:      10,
+			Path:      "file1.txt",
+			CreateAt:  now,
+		})
+		require.NoError(t, err)
+		defer ss.FileInfo().PermanentDelete(rctx, fileInfo1.Id)
+
+		fileInfo2, err := ss.FileInfo().Save(rctx, &model.FileInfo{
+			PostId:    postId,
+			CreatorId: model.NewId(),
+			Size:      10,
+			Path:      "file2.txt",
+			CreateAt:  now,
+		})
+		require.NoError(t, err)
+		defer ss.FileInfo().PermanentDelete(rctx, fileInfo2.Id)
+
+		fileInfo3, err := ss.FileInfo().Save(rctx, &model.FileInfo{
+			PostId:    postId,
+			CreatorId: model.NewId(),
+			Size:      10,
+			Path:      "file1.txt",
+			CreateAt:  now,
+		})
+		require.NoError(t, err)
+		defer ss.FileInfo().PermanentDelete(rctx, fileInfo3.Id)
+
+		err = ss.FileInfo().DeleteForPostByIds(rctx, postId, []string{})
+		require.NoError(t, err)
+
+		fileInfos, err := ss.FileInfo().GetForPost(postId, true, true, false)
+		require.NoError(t, err)
+
+		for _, fileInfo := range fileInfos {
+			require.Equal(t, int64(0), fileInfo.DeleteAt)
+		}
+	})
+
+	t.Run("duplicate fileInfo Ids specified", func(t *testing.T) {
+		now := model.GetMillis()
+		postId := model.NewId()
+
+		fileInfo1, err := ss.FileInfo().Save(rctx, &model.FileInfo{
+			PostId:    postId,
+			CreatorId: model.NewId(),
+			Size:      10,
+			Path:      "file1.txt",
+			CreateAt:  now,
+		})
+		require.NoError(t, err)
+		defer ss.FileInfo().PermanentDelete(rctx, fileInfo1.Id)
+
+		fileInfo2, err := ss.FileInfo().Save(rctx, &model.FileInfo{
+			PostId:    postId,
+			CreatorId: model.NewId(),
+			Size:      10,
+			Path:      "file2.txt",
+			CreateAt:  now,
+		})
+		require.NoError(t, err)
+		defer ss.FileInfo().PermanentDelete(rctx, fileInfo2.Id)
+
+		fileInfo3, err := ss.FileInfo().Save(rctx, &model.FileInfo{
+			PostId:    postId,
+			CreatorId: model.NewId(),
+			Size:      10,
+			Path:      "file1.txt",
+			CreateAt:  now,
+		})
+		require.NoError(t, err)
+		defer ss.FileInfo().PermanentDelete(rctx, fileInfo3.Id)
+
+		err = ss.FileInfo().DeleteForPostByIds(rctx, postId, []string{fileInfo1.Id, fileInfo2.Id, fileInfo2.Id})
+		require.NoError(t, err)
+
+		fileInfos, err := ss.FileInfo().GetForPost(postId, true, true, false)
+		require.NoError(t, err)
+
+		for _, fileInfo := range fileInfos {
+			if fileInfo.Id == fileInfo1.Id || fileInfo.Id == fileInfo2.Id {
+				require.Greater(t, fileInfo.DeleteAt, int64(0))
+			} else {
+				require.Equal(t, int64(0), fileInfo.DeleteAt)
+			}
+		}
+	})
+
+	t.Run("non existent fileInfo IDs specified", func(t *testing.T) {
+		now := model.GetMillis()
+		postId := model.NewId()
+
+		fileInfo1, err := ss.FileInfo().Save(rctx, &model.FileInfo{
+			PostId:    postId,
+			CreatorId: model.NewId(),
+			Size:      10,
+			Path:      "file1.txt",
+			CreateAt:  now,
+		})
+		require.NoError(t, err)
+		defer ss.FileInfo().PermanentDelete(rctx, fileInfo1.Id)
+
+		fileInfo2, err := ss.FileInfo().Save(rctx, &model.FileInfo{
+			PostId:    postId,
+			CreatorId: model.NewId(),
+			Size:      10,
+			Path:      "file2.txt",
+			CreateAt:  now,
+		})
+		require.NoError(t, err)
+		defer ss.FileInfo().PermanentDelete(rctx, fileInfo2.Id)
+
+		fileInfo3, err := ss.FileInfo().Save(rctx, &model.FileInfo{
+			PostId:    postId,
+			CreatorId: model.NewId(),
+			Size:      10,
+			Path:      "file1.txt",
+			CreateAt:  now,
+		})
+		require.NoError(t, err)
+		defer ss.FileInfo().PermanentDelete(rctx, fileInfo3.Id)
+
+		err = ss.FileInfo().DeleteForPostByIds(rctx, postId, []string{model.NewId(), model.NewId()})
+		require.NoError(t, err)
+
+		fileInfos, err := ss.FileInfo().GetForPost(postId, true, true, false)
+		require.NoError(t, err)
+
+		for _, fileInfo := range fileInfos {
+			require.Equal(t, int64(0), fileInfo.DeleteAt)
+		}
+	})
+
+	t.Run("non existent postID specified", func(t *testing.T) {
+		err := ss.FileInfo().DeleteForPostByIds(rctx, model.NewId(), []string{model.NewId()})
+		require.NoError(t, err)
+	})
+
+	t.Run("delete already deleted fileInfos", func(t *testing.T) {
+		now := model.GetMillis()
+		postId := model.NewId()
+
+		fileInfo1, err := ss.FileInfo().Save(rctx, &model.FileInfo{
+			PostId:    postId,
+			CreatorId: model.NewId(),
+			Size:      10,
+			Path:      "file1.txt",
+			CreateAt:  now,
+		})
+		require.NoError(t, err)
+		defer ss.FileInfo().PermanentDelete(rctx, fileInfo1.Id)
+
+		fileInfo2, err := ss.FileInfo().Save(rctx, &model.FileInfo{
+			PostId:    postId,
+			CreatorId: model.NewId(),
+			Size:      10,
+			Path:      "file2.txt",
+			CreateAt:  now,
+		})
+		require.NoError(t, err)
+		defer ss.FileInfo().PermanentDelete(rctx, fileInfo2.Id)
+
+		fileInfo3, err := ss.FileInfo().Save(rctx, &model.FileInfo{
+			PostId:    postId,
+			CreatorId: model.NewId(),
+			Size:      10,
+			Path:      "file1.txt",
+			CreateAt:  now,
+		})
+		require.NoError(t, err)
+		defer ss.FileInfo().PermanentDelete(rctx, fileInfo3.Id)
+
+		err = ss.FileInfo().DeleteForPostByIds(rctx, postId, []string{fileInfo1.Id, fileInfo2.Id})
+		require.NoError(t, err)
+
+		fileInfos, err := ss.FileInfo().GetForPost(postId, true, true, false)
+		require.NoError(t, err)
+
+		for _, fileInfo := range fileInfos {
+			if fileInfo.Id == fileInfo1.Id || fileInfo.Id == fileInfo2.Id {
+				require.Greater(t, fileInfo.DeleteAt, int64(0))
+			} else {
+				require.Equal(t, int64(0), fileInfo.DeleteAt)
+			}
+		}
+
+		err = ss.FileInfo().DeleteForPostByIds(rctx, postId, []string{fileInfo1.Id, fileInfo2.Id})
+		require.NoError(t, err)
+
+		fileInfos, err = ss.FileInfo().GetForPost(postId, true, true, false)
+		require.NoError(t, err)
+
+		for _, fileInfo := range fileInfos {
+			if fileInfo.Id == fileInfo1.Id || fileInfo.Id == fileInfo2.Id {
+				require.Greater(t, fileInfo.DeleteAt, int64(0))
+			} else {
+				require.Equal(t, int64(0), fileInfo.DeleteAt)
+			}
+		}
+	})
+}
+
+func testRestoreUndeleteForPostByIds(t *testing.T, rctx request.CTX, ss store.Store) {
+	t.Run("base case", func(t *testing.T) {
+		now := model.GetMillis()
+		postId := model.NewId()
+
+		fileInfo1, err := ss.FileInfo().Save(rctx, &model.FileInfo{
+			PostId:    postId,
+			CreatorId: model.NewId(),
+			Size:      10,
+			Path:      "file1.txt",
+			CreateAt:  now,
+		})
+		require.NoError(t, err)
+		defer ss.FileInfo().PermanentDelete(rctx, fileInfo1.Id)
+
+		fileInfo2, err := ss.FileInfo().Save(rctx, &model.FileInfo{
+			PostId:    postId,
+			CreatorId: model.NewId(),
+			Size:      10,
+			Path:      "file2.txt",
+			CreateAt:  now,
+		})
+		require.NoError(t, err)
+		defer ss.FileInfo().PermanentDelete(rctx, fileInfo2.Id)
+
+		fileInfo3, err := ss.FileInfo().Save(rctx, &model.FileInfo{
+			PostId:    postId,
+			CreatorId: model.NewId(),
+			Size:      10,
+			Path:      "file1.txt",
+			CreateAt:  now,
+		})
+		require.NoError(t, err)
+		defer ss.FileInfo().PermanentDelete(rctx, fileInfo3.Id)
+
+		err = ss.FileInfo().DeleteForPostByIds(rctx, postId, []string{fileInfo1.Id, fileInfo2.Id})
+		require.NoError(t, err)
+
+		fileInfos, err := ss.FileInfo().GetForPost(postId, true, true, false)
+		require.NoError(t, err)
+
+		for _, fileInfo := range fileInfos {
+			if fileInfo.Id == fileInfo1.Id || fileInfo.Id == fileInfo2.Id {
+				require.Greater(t, fileInfo.DeleteAt, int64(0))
+			} else {
+				require.Equal(t, int64(0), fileInfo.DeleteAt)
+			}
+		}
+
+		// now we'll un-delete the files
+		err = ss.FileInfo().RestoreForPostByIds(rctx, postId, []string{fileInfo1.Id, fileInfo2.Id})
+		require.NoError(t, err)
+
+		fileInfos, err = ss.FileInfo().GetForPost(postId, true, true, false)
+		require.NoError(t, err)
+
+		for _, fileInfo := range fileInfos {
+			require.Equal(t, fileInfo.DeleteAt, int64(0))
+		}
+	})
+
+	t.Run("with empty array it should not impact any post files", func(t *testing.T) {
+		now := model.GetMillis()
+		postId := model.NewId()
+
+		fileInfo1, err := ss.FileInfo().Save(rctx, &model.FileInfo{
+			PostId:    postId,
+			CreatorId: model.NewId(),
+			Size:      10,
+			Path:      "file1.txt",
+			CreateAt:  now,
+		})
+		require.NoError(t, err)
+		defer ss.FileInfo().PermanentDelete(rctx, fileInfo1.Id)
+
+		fileInfo2, err := ss.FileInfo().Save(rctx, &model.FileInfo{
+			PostId:    postId,
+			CreatorId: model.NewId(),
+			Size:      10,
+			Path:      "file2.txt",
+			CreateAt:  now,
+		})
+		require.NoError(t, err)
+		defer ss.FileInfo().PermanentDelete(rctx, fileInfo2.Id)
+
+		err = ss.FileInfo().RestoreForPostByIds(rctx, postId, []string{})
+		require.NoError(t, err)
+
+		fileInfos, err := ss.FileInfo().GetForPost(postId, true, true, false)
+		require.NoError(t, err)
+
+		for _, fileInfo := range fileInfos {
+			require.Equal(t, int64(0), fileInfo.DeleteAt)
+		}
+	})
+
+	t.Run("duplicate fileInfo Ids specified", func(t *testing.T) {
+		now := model.GetMillis()
+		postId := model.NewId()
+
+		fileInfo1, err := ss.FileInfo().Save(rctx, &model.FileInfo{
+			PostId:    postId,
+			CreatorId: model.NewId(),
+			Size:      10,
+			Path:      "file1.txt",
+			CreateAt:  now,
+		})
+		require.NoError(t, err)
+		defer ss.FileInfo().PermanentDelete(rctx, fileInfo1.Id)
+
+		fileInfo2, err := ss.FileInfo().Save(rctx, &model.FileInfo{
+			PostId:    postId,
+			CreatorId: model.NewId(),
+			Size:      10,
+			Path:      "file2.txt",
+			CreateAt:  now,
+		})
+		require.NoError(t, err)
+		defer ss.FileInfo().PermanentDelete(rctx, fileInfo2.Id)
+
+		fileInfo3, err := ss.FileInfo().Save(rctx, &model.FileInfo{
+			PostId:    postId,
+			CreatorId: model.NewId(),
+			Size:      10,
+			Path:      "file1.txt",
+			CreateAt:  now,
+		})
+		require.NoError(t, err)
+		defer ss.FileInfo().PermanentDelete(rctx, fileInfo3.Id)
+
+		// delete file infos
+		err = ss.FileInfo().DeleteForPostByIds(rctx, postId, []string{fileInfo1.Id, fileInfo2.Id, fileInfo3.Id})
+		require.NoError(t, err)
+
+		// verify file infos are deleted
+		fileInfos, err := ss.FileInfo().GetForPost(postId, true, true, false)
+		require.NoError(t, err)
+
+		for _, fileInfo := range fileInfos {
+			require.Greater(t, fileInfo.DeleteAt, int64(0))
+		}
+
+		// undelete them specifying duplicate file info ids
+		err = ss.FileInfo().RestoreForPostByIds(rctx, postId, []string{fileInfo1.Id, fileInfo2.Id, fileInfo2.Id, fileInfo2.Id})
+		require.NoError(t, err)
+
+		// verify file infos are deleted
+		fileInfos, err = ss.FileInfo().GetForPost(postId, true, true, false)
+		require.NoError(t, err)
+
+		for _, fileInfo := range fileInfos {
+			if fileInfo.Id == fileInfo3.Id {
+				require.Greater(t, fileInfo.DeleteAt, int64(0))
+			} else {
+				require.Equal(t, int64(0), fileInfo.DeleteAt)
+			}
+		}
+	})
+
+	t.Run("non existent fileInfo IDs  and postId specified", func(t *testing.T) {
+		err := ss.FileInfo().RestoreForPostByIds(rctx, model.NewId(), []string{model.NewId(), model.NewId()})
+		require.NoError(t, err)
+	})
+
+	t.Run("undelete already undeleted fileInfos", func(t *testing.T) {
+		now := model.GetMillis()
+		postId := model.NewId()
+
+		fileInfo1, err := ss.FileInfo().Save(rctx, &model.FileInfo{
+			PostId:    postId,
+			CreatorId: model.NewId(),
+			Size:      10,
+			Path:      "file1.txt",
+			CreateAt:  now,
+		})
+		require.NoError(t, err)
+		defer ss.FileInfo().PermanentDelete(rctx, fileInfo1.Id)
+
+		fileInfo2, err := ss.FileInfo().Save(rctx, &model.FileInfo{
+			PostId:    postId,
+			CreatorId: model.NewId(),
+			Size:      10,
+			Path:      "file2.txt",
+			CreateAt:  now,
+		})
+		require.NoError(t, err)
+		defer ss.FileInfo().PermanentDelete(rctx, fileInfo2.Id)
+
+		fileInfo3, err := ss.FileInfo().Save(rctx, &model.FileInfo{
+			PostId:    postId,
+			CreatorId: model.NewId(),
+			Size:      10,
+			Path:      "file1.txt",
+			CreateAt:  now,
+		})
+		require.NoError(t, err)
+		defer ss.FileInfo().PermanentDelete(rctx, fileInfo3.Id)
+
+		err = ss.FileInfo().RestoreForPostByIds(rctx, postId, []string{fileInfo1.Id, fileInfo2.Id})
+		require.NoError(t, err)
+
+		fileInfos, err := ss.FileInfo().GetForPost(postId, true, true, false)
+		require.NoError(t, err)
+
+		for _, fileInfo := range fileInfos {
+			require.Equal(t, int64(0), fileInfo.DeleteAt)
+		}
+	})
+}

server/channels/store/storetest/mocks/FileInfoStore.go

@@ -94,6 +94,24 @@ func (_m *FileInfoStore) DeleteForPost(c request.CTX, postID string) (string, er
 	return r0, r1
 }
 
+// DeleteForPostByIds provides a mock function with given fields: rctx, postId, fileIDs
+func (_m *FileInfoStore) DeleteForPostByIds(rctx request.CTX, postId string, fileIDs []string) error {
+	ret := _m.Called(rctx, postId, fileIDs)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DeleteForPostByIds")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(request.CTX, string, []string) error); ok {
+		r0 = rf(rctx, postId, fileIDs)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
 // Get provides a mock function with given fields: id
 func (_m *FileInfoStore) Get(id string) (*model.FileInfo, error) {
 	ret := _m.Called(id)
@@ -124,9 +142,9 @@ func (_m *FileInfoStore) Get(id string) (*model.FileInfo, error) {
 	return r0, r1
 }
 
-// GetByIds provides a mock function with given fields: ids
-func (_m *FileInfoStore) GetByIds(ids []string) ([]*model.FileInfo, error) {
-	ret := _m.Called(ids)
+// GetByIds provides a mock function with given fields: ids, includeDeleted, allowFromCache
+func (_m *FileInfoStore) GetByIds(ids []string, includeDeleted bool, allowFromCache bool) ([]*model.FileInfo, error) {
+	ret := _m.Called(ids, includeDeleted, allowFromCache)
 
 	if len(ret) == 0 {
 		panic("no return value specified for GetByIds")
@@ -134,19 +152,19 @@ func (_m *FileInfoStore) GetByIds(ids []string) ([]*model.FileInfo, error) {
 
 	var r0 []*model.FileInfo
 	var r1 error
-	if rf, ok := ret.Get(0).(func([]string) ([]*model.FileInfo, error)); ok {
-		return rf(ids)
+	if rf, ok := ret.Get(0).(func([]string, bool, bool) ([]*model.FileInfo, error)); ok {
+		return rf(ids, includeDeleted, allowFromCache)
 	}
-	if rf, ok := ret.Get(0).(func([]string) []*model.FileInfo); ok {
-		r0 = rf(ids)
+	if rf, ok := ret.Get(0).(func([]string, bool, bool) []*model.FileInfo); ok {
+		r0 = rf(ids, includeDeleted, allowFromCache)
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).([]*model.FileInfo)
 		}
 	}
 
-	if rf, ok := ret.Get(1).(func([]string) error); ok {
-		r1 = rf(ids)
+	if rf, ok := ret.Get(1).(func([]string, bool, bool) error); ok {
+		r1 = rf(ids, includeDeleted, allowFromCache)
 	} else {
 		r1 = ret.Error(1)
 	}
@@ -487,6 +505,24 @@ func (_m *FileInfoStore) PermanentDeleteForPost(rctx request.CTX, postID string)
 	return r0
 }
 
+// RestoreForPostByIds provides a mock function with given fields: rctx, postId, fileIDs
+func (_m *FileInfoStore) RestoreForPostByIds(rctx request.CTX, postId string, fileIDs []string) error {
+	ret := _m.Called(rctx, postId, fileIDs)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RestoreForPostByIds")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(request.CTX, string, []string) error); ok {
+		r0 = rf(rctx, postId, fileIDs)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
 // Save provides a mock function with given fields: ctx, info
 func (_m *FileInfoStore) Save(ctx request.CTX, info *model.FileInfo) (*model.FileInfo, error) {
 	ret := _m.Called(ctx, info)

server/channels/store/timerlayer/timerlayer.go

@@ -3604,6 +3604,22 @@ func (s *TimerLayerFileInfoStore) DeleteForPost(c request.CTX, postID string) (s
 	return result, err
 }
 
+func (s *TimerLayerFileInfoStore) DeleteForPostByIds(rctx request.CTX, postId string, fileIDs []string) error {
+	start := time.Now()
+
+	err := s.FileInfoStore.DeleteForPostByIds(rctx, postId, fileIDs)
+
+	elapsed := float64(time.Since(start)) / float64(time.Second)
+	if s.Root.Metrics != nil {
+		success := "false"
+		if err == nil {
+			success = "true"
+		}
+		s.Root.Metrics.ObserveStoreMethodDuration("FileInfoStore.DeleteForPostByIds", success, elapsed)
+	}
+	return err
+}
+
 func (s *TimerLayerFileInfoStore) Get(id string) (*model.FileInfo, error) {
 	start := time.Now()
 
@@ -3620,10 +3636,10 @@ func (s *TimerLayerFileInfoStore) Get(id string) (*model.FileInfo, error) {
 	return result, err
 }
 
-func (s *TimerLayerFileInfoStore) GetByIds(ids []string) ([]*model.FileInfo, error) {
+func (s *TimerLayerFileInfoStore) GetByIds(ids []string, includeDeleted bool, allowFromCache bool) ([]*model.FileInfo, error) {
 	start := time.Now()
 
-	result, err := s.FileInfoStore.GetByIds(ids)
+	result, err := s.FileInfoStore.GetByIds(ids, includeDeleted, allowFromCache)
 
 	elapsed := float64(time.Since(start)) / float64(time.Second)
 	if s.Root.Metrics != nil {
@@ -3843,6 +3859,22 @@ func (s *TimerLayerFileInfoStore) PermanentDeleteForPost(rctx request.CTX, postI
 	return err
 }
 
+func (s *TimerLayerFileInfoStore) RestoreForPostByIds(rctx request.CTX, postId string, fileIDs []string) error {
+	start := time.Now()
+
+	err := s.FileInfoStore.RestoreForPostByIds(rctx, postId, fileIDs)
+
+	elapsed := float64(time.Since(start)) / float64(time.Second)
+	if s.Root.Metrics != nil {
+		success := "false"
+		if err == nil {
+			success = "true"
+		}
+		s.Root.Metrics.ObserveStoreMethodDuration("FileInfoStore.RestoreForPostByIds", success, elapsed)
+	}
+	return err
+}
+
 func (s *TimerLayerFileInfoStore) Save(ctx request.CTX, info *model.FileInfo) (*model.FileInfo, error) {
 	start := time.Now()