First part of PostStore migration (#15123)

Automatic Merge

app/channel.go

@@ -2330,7 +2330,7 @@ func (a *App) ViewChannel(view *model.ChannelView, userId string, currentSession
 
 func (a *App) PermanentDeleteChannel(channel *model.Channel) *model.AppError {
 	if err := a.Srv().Store.Post().PermanentDeleteByChannel(channel.Id); err != nil {
-		return err
+		return model.NewAppError("PermanentDeleteChannel", "app.post.permanent_delete_by_channel.app_error", nil, err.Error(), http.StatusInternalServerError)
 	}
 
 	if err := a.Srv().Store.Channel().PermanentDeleteMembersByChannel(channel.Id); err != nil {

app/file.go

@@ -291,12 +291,13 @@ func (a *App) MigrateFilenamesToFileInfos(post *model.Post) []*model.FileInfo {
 	fileMigrationLock.Lock()
 	defer fileMigrationLock.Unlock()
 
-	result, err := a.Srv().Store.Post().Get(post.Id, false)
+	result, nErr := a.Srv().Store.Post().Get(post.Id, false)
-	if err != nil {
+	if nErr != nil {
-		mlog.Error("Unable to get post when migrating post to use FileInfos", mlog.Err(err), mlog.String("post_id", post.Id))
+		mlog.Error("Unable to get post when migrating post to use FileInfos", mlog.Err(nErr), mlog.String("post_id", post.Id))
 		return []*model.FileInfo{}
 	}
 
+	var err *model.AppError
 	if newPost := result.Posts[post.Id]; len(newPost.Filenames) != len(post.Filenames) {
 		// Another thread has already created FileInfos for this post, so just return those
 		var fileInfos []*model.FileInfo
@@ -337,13 +338,13 @@ func (a *App) MigrateFilenamesToFileInfos(post *model.Post) []*model.FileInfo {
 	newPost.FileIds = fileIds
 
 	// Update Posts to clear Filenames and set FileIds
-	if _, err = a.Srv().Store.Post().Update(newPost, post); err != nil {
+	if _, nErr = a.Srv().Store.Post().Update(newPost, post); nErr != nil {
 		mlog.Error(
 			"Unable to save migrated post when migrating to use FileInfos",
 			mlog.String("new_file_ids", strings.Join(newPost.FileIds, ",")),
 			mlog.String("old_filenames", strings.Join(post.Filenames, ",")),
 			mlog.String("post_id", post.Id),
-			mlog.Err(err),
+			mlog.Err(nErr),
 		)
 		return []*model.FileInfo{}
 	}

app/import_functions.go

@@ -1038,7 +1038,16 @@ func (a *App) importReplies(data []ReplyImportData, post *model.Post, teamId str
 
 	if len(postsForCreateList) > 0 {
 		if _, _, err := a.Srv().Store.Post().SaveMultiple(postsForCreateList); err != nil {
-			return err
+			var appErr *model.AppError
+			var invErr *store.ErrInvalidInput
+			switch {
+			case errors.As(err, &appErr):
+				return appErr
+			case errors.As(err, &invErr):
+				return model.NewAppError("importReplies", "app.post.save.existing.app_error", nil, invErr.Error(), http.StatusBadRequest)
+			default:
+				return model.NewAppError("importReplies", "app.post.save.app_error", nil, err.Error(), http.StatusInternalServerError)
+			}
 		}
 	}
 
@@ -1229,9 +1238,9 @@ func (a *App) importMultiplePostLines(lines []LineImportWorkerData, dryRun bool)
 		user := users[*line.Post.User]
 
 		// Check if this post already exists.
-		posts, err := a.Srv().Store.Post().GetPostsCreatedAt(channel.Id, *line.Post.CreateAt)
+		posts, appErr := a.Srv().Store.Post().GetPostsCreatedAt(channel.Id, *line.Post.CreateAt)
-		if err != nil {
+		if appErr != nil {
-			return line.LineNumber, err
+			return line.LineNumber, appErr
 		}
 
 		var post *model.Post
@@ -1256,9 +1265,9 @@ func (a *App) importMultiplePostLines(lines []LineImportWorkerData, dryRun bool)
 			post.Props = *line.Post.Props
 		}
 
-		fileIds, err := a.uploadAttachments(line.Post.Attachments, post, team.Id, dryRun)
+		fileIds, appErr := a.uploadAttachments(line.Post.Attachments, post, team.Id, dryRun)
-		if err != nil {
+		if appErr != nil {
-			return line.LineNumber, err
+			return line.LineNumber, appErr
 		}
 		for _, fileID := range post.FileIds {
 			if _, ok := fileIds[fileID]; !ok {
@@ -1281,14 +1290,26 @@ func (a *App) importMultiplePostLines(lines []LineImportWorkerData, dryRun bool)
 	}
 
 	if len(postsForCreateList) > 0 {
-		if _, idx, err := a.Srv().Store.Post().SaveMultiple(postsForCreateList); err != nil {
+		if _, idx, nErr := a.Srv().Store.Post().SaveMultiple(postsForCreateList); nErr != nil {
+			var appErr *model.AppError
+			var invErr *store.ErrInvalidInput
+			var retErr *model.AppError
+			switch {
+			case errors.As(nErr, &appErr):
+				retErr = appErr
+			case errors.As(nErr, &invErr):
+				retErr = model.NewAppError("importMultiplePostLines", "app.post.save.existing.app_error", nil, invErr.Error(), http.StatusBadRequest)
+			default:
+				retErr = model.NewAppError("importMultiplePostLines", "app.post.save.app_error", nil, nErr.Error(), http.StatusInternalServerError)
+			}
+
 			if idx != -1 && idx < len(postsForCreateList) {
 				post := postsForCreateList[idx]
 				if lineNumber, ok := postsForCreateMap[getPostStrID(post)]; ok {
-					return lineNumber, err
+					return lineNumber, retErr
 				}
 			}
-			return 0, err
+			return 0, retErr
 		}
 	}
 
@@ -1566,13 +1587,25 @@ func (a *App) importMultipleDirectPostLines(lines []LineImportWorkerData, dryRun
 
 	if len(postsForCreateList) > 0 {
 		if _, idx, err := a.Srv().Store.Post().SaveMultiple(postsForCreateList); err != nil {
+			var appErr *model.AppError
+			var invErr *store.ErrInvalidInput
+			var retErr *model.AppError
+			switch {
+			case errors.As(err, &appErr):
+				retErr = appErr
+			case errors.As(err, &invErr):
+				retErr = model.NewAppError("importMultiplePostLines", "app.post.save.existing.app_error", nil, invErr.Error(), http.StatusBadRequest)
+			default:
+				retErr = model.NewAppError("importMultiplePostLines", "app.post.save.app_error", nil, err.Error(), http.StatusInternalServerError)
+			}
+
 			if idx != -1 && idx < len(postsForCreateList) {
 				post := postsForCreateList[idx]
 				if lineNumber, ok := postsForCreateMap[getPostStrID(post)]; ok {
-					return lineNumber, err
+					return lineNumber, retErr
 				}
 			}
-			return 0, err
+			return 0, retErr
 		}
 	}
 	if _, idx, err := a.Srv().Store.Post().OverwriteMultiple(postsForOverwriteList); err != nil {

app/integration_action.go

@@ -71,7 +71,7 @@ func (a *App) DoPostActionWithCookie(postId, actionId, userId, selectedOption st
 	pchan := make(chan store.StoreResult, 1)
 	go func() {
 		post, err := a.Srv().Store.Post().GetSingle(postId)
-		pchan <- store.StoreResult{Data: post, Err: err}
+		pchan <- store.StoreResult{Data: post, NErr: err}
 		close(pchan)
 	}()
 
@@ -90,16 +90,22 @@ func (a *App) DoPostActionWithCookie(postId, actionId, userId, selectedOption st
 	}()
 
 	result := <-pchan
-	if result.Err != nil {
+	if result.NErr != nil {
 		if cookie == nil {
-			return "", result.Err
+			var nfErr *store.ErrNotFound
+			switch {
+			case errors.As(result.NErr, &nfErr):
+				return "", model.NewAppError("DoPostActionWithCookie", "app.post.get.app_error", nil, nfErr.Error(), http.StatusNotFound)
+			default:
+				return "", model.NewAppError("DoPostActionWithCookie", "app.post.get.app_error", nil, result.NErr.Error(), http.StatusInternalServerError)
+			}
 		}
 		if cookie.Integration == nil {
-			return "", model.NewAppError("DoPostAction", "api.post.do_action.action_integration.app_error", nil, "no Integration in action cookie", http.StatusBadRequest)
+			return "", model.NewAppError("DoPostActionWithCookie", "api.post.do_action.action_integration.app_error", nil, "no Integration in action cookie", http.StatusBadRequest)
 		}
 
 		if postId != cookie.PostId {
-			return "", model.NewAppError("DoPostAction", "api.post.do_action.action_integration.app_error", nil, "postId doesn't match", http.StatusBadRequest)
+			return "", model.NewAppError("DoPostActionWithCookie", "api.post.do_action.action_integration.app_error", nil, "postId doesn't match", http.StatusBadRequest)
 		}
 
 		channel, err := a.Srv().Store.Channel().Get(cookie.ChannelId, true)

app/integration_action_test.go

@@ -419,8 +419,8 @@ func TestPostActionProps(t *testing.T) {
 	require.Nil(t, err)
 	assert.True(t, len(clientTriggerId) == 26)
 
-	newPost, err := th.App.Srv().Store.Post().GetSingle(post.Id)
+	newPost, nErr := th.App.Srv().Store.Post().GetSingle(post.Id)
-	require.Nil(t, err)
+	require.Nil(t, nErr)
 
 	assert.True(t, newPost.IsPinned)
 	assert.False(t, newPost.HasReactions)

app/post.go

@@ -180,7 +180,7 @@ func (a *App) CreatePost(post *model.Post, channel *model.Channel, triggerWebhoo
 		pchan = make(chan store.StoreResult, 1)
 		go func() {
 			r, pErr := a.Srv().Store.Post().Get(post.RootId, false)
-			pchan <- store.StoreResult{Data: r, Err: pErr}
+			pchan <- store.StoreResult{Data: r, NErr: pErr}
 			close(pchan)
 		}()
 	}
@@ -221,7 +221,7 @@ func (a *App) CreatePost(post *model.Post, channel *model.Channel, triggerWebhoo
 	var parentPostList *model.PostList
 	if pchan != nil {
 		result := <-pchan
-		if result.Err != nil {
+		if result.NErr != nil {
 			return nil, model.NewAppError("createPost", "api.post.create_post.root_id.app_error", nil, "", http.StatusBadRequest)
 		}
 		parentPostList = result.Data.(*model.PostList)
@@ -290,9 +290,18 @@ func (a *App) CreatePost(post *model.Post, channel *model.Channel, triggerWebhoo
 		}
 	}
 
-	rpost, err := a.Srv().Store.Post().Save(post)
+	rpost, nErr := a.Srv().Store.Post().Save(post)
-	if err != nil {
+	if nErr != nil {
-		return nil, err
+		var appErr *model.AppError
+		var invErr *store.ErrInvalidInput
+		switch {
+		case errors.As(nErr, &appErr):
+			return nil, appErr
+		case errors.As(nErr, &invErr):
+			return nil, model.NewAppError("CreatePost", "app.post.save.existing.app_error", nil, invErr.Error(), http.StatusBadRequest)
+		default:
+			return nil, model.NewAppError("CreatePost", "app.post.save.app_error", nil, nErr.Error(), http.StatusInternalServerError)
+		}
 	}
 
 	// Update the mapping from pending post id to the actual post id, for any clients that
@@ -512,12 +521,22 @@ func (a *App) DeleteEphemeralPost(userId, postId string) {
 func (a *App) UpdatePost(post *model.Post, safeUpdate bool) (*model.Post, *model.AppError) {
 	post.SanitizeProps()
 
-	postLists, err := a.Srv().Store.Post().Get(post.Id, false)
+	postLists, nErr := a.Srv().Store.Post().Get(post.Id, false)
-	if err != nil {
+	if nErr != nil {
-		return nil, err
+		var nfErr *store.ErrNotFound
+		var invErr *store.ErrInvalidInput
+		switch {
+		case errors.As(nErr, &invErr):
+			return nil, model.NewAppError("UpdatePost", "app.post.get.app_error", nil, invErr.Error(), http.StatusBadRequest)
+		case errors.As(nErr, &nfErr):
+			return nil, model.NewAppError("UpdatePost", "app.post.get.app_error", nil, nfErr.Error(), http.StatusNotFound)
+		default:
+			return nil, model.NewAppError("UpdatePost", "app.post.get.app_error", nil, nErr.Error(), http.StatusInternalServerError)
+		}
 	}
 	oldPost := postLists.Posts[post.Id]
 
+	var err *model.AppError
 	if oldPost == nil {
 		err = model.NewAppError("UpdatePost", "api.post.update_post.find.app_error", nil, "id="+post.Id, http.StatusBadRequest)
 		return nil, err
@@ -586,9 +605,15 @@ func (a *App) UpdatePost(post *model.Post, safeUpdate bool) (*model.Post, *model
 		}
 	}
 
-	rpost, err := a.Srv().Store.Post().Update(newPost, oldPost)
+	rpost, nErr := a.Srv().Store.Post().Update(newPost, oldPost)
-	if err != nil {
+	if nErr != nil {
-		return nil, err
+		var appErr *model.AppError
+		switch {
+		case errors.As(nErr, &appErr):
+			return nil, appErr
+		default:
+			return nil, model.NewAppError("UpdatePost", "app.post.update.app_error", nil, nErr.Error(), http.StatusInternalServerError)
+		}
 	}
 
 	if pluginsEnvironment := a.GetPluginsEnvironment(); pluginsEnvironment != nil {
@@ -659,11 +684,36 @@ func (a *App) GetPostsSince(options model.GetPostsSinceOptions) (*model.PostList
 }
 
 func (a *App) GetSinglePost(postId string) (*model.Post, *model.AppError) {
-	return a.Srv().Store.Post().GetSingle(postId)
+	post, err := a.Srv().Store.Post().GetSingle(postId)
+	if err != nil {
+		var nfErr *store.ErrNotFound
+		switch {
+		case errors.As(err, &nfErr):
+			return nil, model.NewAppError("GetSinglePost", "app.post.get.app_error", nil, nfErr.Error(), http.StatusNotFound)
+		default:
+			return nil, model.NewAppError("GetSinglePost", "app.post.get.app_error", nil, err.Error(), http.StatusInternalServerError)
+		}
+	}
+
+	return post, nil
 }
 
 func (a *App) GetPostThread(postId string, skipFetchThreads bool) (*model.PostList, *model.AppError) {
-	return a.Srv().Store.Post().Get(postId, skipFetchThreads)
+	posts, err := a.Srv().Store.Post().Get(postId, skipFetchThreads)
+	if err != nil {
+		var nfErr *store.ErrNotFound
+		var invErr *store.ErrInvalidInput
+		switch {
+		case errors.As(err, &invErr):
+			return nil, model.NewAppError("GetPostThread", "app.post.get.app_error", nil, invErr.Error(), http.StatusBadRequest)
+		case errors.As(err, &nfErr):
+			return nil, model.NewAppError("GetPostThread", "app.post.get.app_error", nil, nfErr.Error(), http.StatusNotFound)
+		default:
+			return nil, model.NewAppError("GetPostThread", "app.post.get.app_error", nil, err.Error(), http.StatusInternalServerError)
+		}
+	}
+
+	return posts, nil
 }
 
 func (a *App) GetFlaggedPosts(userId string, offset int, limit int) (*model.PostList, *model.AppError) {
@@ -679,9 +729,18 @@ func (a *App) GetFlaggedPostsForChannel(userId, channelId string, offset int, li
 }
 
 func (a *App) GetPermalinkPost(postId string, userId string) (*model.PostList, *model.AppError) {
-	list, err := a.Srv().Store.Post().Get(postId, false)
+	list, nErr := a.Srv().Store.Post().Get(postId, false)
-	if err != nil {
+	if nErr != nil {
-		return nil, err
+		var nfErr *store.ErrNotFound
+		var invErr *store.ErrInvalidInput
+		switch {
+		case errors.As(nErr, &invErr):
+			return nil, model.NewAppError("GetPermalinkPost", "app.post.get.app_error", nil, invErr.Error(), http.StatusBadRequest)
+		case errors.As(nErr, &nfErr):
+			return nil, model.NewAppError("GetPermalinkPost", "app.post.get.app_error", nil, nfErr.Error(), http.StatusNotFound)
+		default:
+			return nil, model.NewAppError("GetPermalinkPost", "app.post.get.app_error", nil, nErr.Error(), http.StatusInternalServerError)
+		}
 	}
 
 	if len(list.Order) != 1 {
@@ -842,10 +901,9 @@ func (a *App) GetPostsForChannelAroundLastUnread(channelId, userId string, limit
 }
 
 func (a *App) DeletePost(postId, deleteByID string) (*model.Post, *model.AppError) {
-	post, err := a.Srv().Store.Post().GetSingle(postId)
+	post, nErr := a.Srv().Store.Post().GetSingle(postId)
-	if err != nil {
+	if nErr != nil {
-		err.StatusCode = http.StatusBadRequest
+		return nil, model.NewAppError("DeletePost", "app.post.get.app_error", nil, nErr.Error(), http.StatusBadRequest)
-		return nil, err
 	}
 
 	channel, err := a.GetChannel(post.ChannelId)
@@ -859,7 +917,13 @@ func (a *App) DeletePost(postId, deleteByID string) (*model.Post, *model.AppErro
 	}
 
 	if err := a.Srv().Store.Post().Delete(postId, model.GetMillis(), deleteByID); err != nil {
-		return nil, err
+		var nfErr *store.ErrNotFound
+		switch {
+		case errors.As(err, &nfErr):
+			return nil, model.NewAppError("DeletePost", "app.post.delete.app_error", nil, nfErr.Error(), http.StatusNotFound)
+		default:
+			return nil, model.NewAppError("DeletePost", "app.post.delete.app_error", nil, err.Error(), http.StatusInternalServerError)
+		}
 	}
 
 	message := model.NewWebSocketEvent(model.WEBSOCKET_EVENT_POST_DELETED, "", post.ChannelId, "", nil)
@@ -1047,7 +1111,7 @@ func (a *App) GetFileInfosForPostWithMigration(postId string) ([]*model.FileInfo
 	pchan := make(chan store.StoreResult, 1)
 	go func() {
 		post, err := a.Srv().Store.Post().GetSingle(postId)
-		pchan <- store.StoreResult{Data: post, Err: err}
+		pchan <- store.StoreResult{Data: post, NErr: err}
 		close(pchan)
 	}()
 
@@ -1059,8 +1123,14 @@ func (a *App) GetFileInfosForPostWithMigration(postId string) ([]*model.FileInfo
 	if len(infos) == 0 {
 		// No FileInfos were returned so check if they need to be created for this post
 		result := <-pchan
-		if result.Err != nil {
+		if result.NErr != nil {
-			return nil, result.Err
+			var nfErr *store.ErrNotFound
+			switch {
+			case errors.As(result.NErr, &nfErr):
+				return nil, model.NewAppError("GetFileInfosForPostWithMigration", "app.post.get.app_error", nil, nfErr.Error(), http.StatusNotFound)
+			default:
+				return nil, model.NewAppError("GetFileInfosForPostWithMigration", "app.post.get.app_error", nil, result.NErr.Error(), http.StatusInternalServerError)
+			}
 		}
 		post := result.Data.(*model.Post)
 

app/user.go

@@ -1489,7 +1489,7 @@ func (a *App) PermanentDeleteUser(user *model.User) *model.AppError {
 	}
 
 	if err := a.Srv().Store.Post().PermanentDeleteByUser(user.Id); err != nil {
-		return err
+		return model.NewAppError("PermanentDeleteUser", "app.post.permanent_delete_by_user.app_error", nil, err.Error(), http.StatusInternalServerError)
 	}
 
 	if err := a.Srv().Store.Bot().PermanentDelete(user.Id); err != nil {

i18n/en.json

@@ -4246,6 +4246,34 @@
     "id": "app.plugin.write_file.saving.app_error",
     "translation": "An error occurred while saving the file."
   },
+  {
+    "id": "app.post.delete.app_error",
+    "translation": "Unable to delete the post."
+  },
+  {
+    "id": "app.post.get.app_error",
+    "translation": "Unable to get the post."
+  },
+  {
+    "id": "app.post.permanent_delete_by_channel.app_error",
+    "translation": "Unable to delete the posts by channel."
+  },
+  {
+    "id": "app.post.permanent_delete_by_user.app_error",
+    "translation": "Unable to select the posts to delete for the user."
+  },
+  {
+    "id": "app.post.save.app_error",
+    "translation": "Unable to save the Post."
+  },
+  {
+    "id": "app.post.save.existing.app_error",
+    "translation": "You cannot update an existing Post."
+  },
+  {
+    "id": "app.post.update.app_error",
+    "translation": "Unable to update the Post."
+  },
   {
     "id": "app.preference.delete.app_error",
     "translation": "We encountered an error while deleting preferences."
@@ -7174,14 +7202,6 @@
     "id": "store.sql_post.analytics_user_counts_posts_by_day.app_error",
     "translation": "Unable to get user counts with posts."
   },
-  {
-    "id": "store.sql_post.delete.app_error",
-    "translation": "Unable to delete the post."
-  },
-  {
-    "id": "store.sql_post.get.app_error",
-    "translation": "Unable to get the post."
-  },
   {
     "id": "store.sql_post.get_direct_posts.app_error",
     "translation": "Unable to get direct posts."
@@ -7242,50 +7262,18 @@
     "id": "store.sql_post.overwrite.app_error",
     "translation": "Unable to overwrite the Post."
   },
-  {
-    "id": "store.sql_post.permanent_delete.app_error",
-    "translation": "Unable to delete the post."
-  },
-  {
-    "id": "store.sql_post.permanent_delete_all_comments_by_user.app_error",
-    "translation": "Unable to delete the comments for user."
-  },
   {
     "id": "store.sql_post.permanent_delete_batch.app_error",
     "translation": "We encountered an error permanently deleting the batch of posts."
   },
-  {
-    "id": "store.sql_post.permanent_delete_by_channel.app_error",
-    "translation": "Unable to delete the posts by channel."
-  },
-  {
-    "id": "store.sql_post.permanent_delete_by_user.app_error",
-    "translation": "Unable to select the posts to delete for the user."
-  },
-  {
-    "id": "store.sql_post.permanent_delete_by_user.too_many.app_error",
-    "translation": "Unable to select the posts to delete for the user (too many), please re-run."
-  },
   {
     "id": "store.sql_post.populate_reply_count.app_error",
     "translation": "Unable to get the post replies count"
   },
-  {
-    "id": "store.sql_post.save.app_error",
-    "translation": "Unable to save the Post."
-  },
-  {
-    "id": "store.sql_post.save.existing.app_error",
-    "translation": "You cannot update an existing Post."
-  },
   {
     "id": "store.sql_post.search.disabled",
     "translation": "Searching has been disabled on this server. Please contact your System Administrator."
   },
-  {
-    "id": "store.sql_post.update.app_error",
-    "translation": "Unable to update the Post."
-  },
   {
     "id": "store.sql_status.get.app_error",
     "translation": "Encountered an error retrieving the status."

store/opentracinglayer/opentracinglayer.go

@@ -4742,7 +4742,7 @@ func (s *OpenTracingLayerPostStore) ClearCaches() {
 
 }
 
-func (s *OpenTracingLayerPostStore) Delete(postId string, time int64, deleteByID string) *model.AppError {
+func (s *OpenTracingLayerPostStore) Delete(postId string, time int64, deleteByID string) error {
 	origCtx := s.Root.Store.Context()
 	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "PostStore.Delete")
 	s.Root.Store.SetContext(newCtx)
@@ -4760,7 +4760,7 @@ func (s *OpenTracingLayerPostStore) Delete(postId string, time int64, deleteByID
 	return resultVar0
 }
 
-func (s *OpenTracingLayerPostStore) Get(id string, skipFetchThreads bool) (*model.PostList, *model.AppError) {
+func (s *OpenTracingLayerPostStore) Get(id string, skipFetchThreads bool) (*model.PostList, error) {
 	origCtx := s.Root.Store.Context()
 	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "PostStore.Get")
 	s.Root.Store.SetContext(newCtx)
@@ -5136,7 +5136,7 @@ func (s *OpenTracingLayerPostStore) GetRepliesForExport(parentId string) ([]*mod
 	return resultVar0, resultVar1
 }
 
-func (s *OpenTracingLayerPostStore) GetSingle(id string) (*model.Post, *model.AppError) {
+func (s *OpenTracingLayerPostStore) GetSingle(id string) (*model.Post, error) {
 	origCtx := s.Root.Store.Context()
 	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "PostStore.GetSingle")
 	s.Root.Store.SetContext(newCtx)
@@ -5221,7 +5221,7 @@ func (s *OpenTracingLayerPostStore) PermanentDeleteBatch(endTime int64, limit in
 	return resultVar0, resultVar1
 }
 
-func (s *OpenTracingLayerPostStore) PermanentDeleteByChannel(channelId string) *model.AppError {
+func (s *OpenTracingLayerPostStore) PermanentDeleteByChannel(channelId string) error {
 	origCtx := s.Root.Store.Context()
 	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "PostStore.PermanentDeleteByChannel")
 	s.Root.Store.SetContext(newCtx)
@@ -5239,7 +5239,7 @@ func (s *OpenTracingLayerPostStore) PermanentDeleteByChannel(channelId string) *
 	return resultVar0
 }
 
-func (s *OpenTracingLayerPostStore) PermanentDeleteByUser(userId string) *model.AppError {
+func (s *OpenTracingLayerPostStore) PermanentDeleteByUser(userId string) error {
 	origCtx := s.Root.Store.Context()
 	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "PostStore.PermanentDeleteByUser")
 	s.Root.Store.SetContext(newCtx)
@@ -5257,7 +5257,7 @@ func (s *OpenTracingLayerPostStore) PermanentDeleteByUser(userId string) *model.
 	return resultVar0
 }
 
-func (s *OpenTracingLayerPostStore) Save(post *model.Post) (*model.Post, *model.AppError) {
+func (s *OpenTracingLayerPostStore) Save(post *model.Post) (*model.Post, error) {
 	origCtx := s.Root.Store.Context()
 	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "PostStore.Save")
 	s.Root.Store.SetContext(newCtx)
@@ -5275,7 +5275,7 @@ func (s *OpenTracingLayerPostStore) Save(post *model.Post) (*model.Post, *model.
 	return resultVar0, resultVar1
 }
 
-func (s *OpenTracingLayerPostStore) SaveMultiple(posts []*model.Post) ([]*model.Post, int, *model.AppError) {
+func (s *OpenTracingLayerPostStore) SaveMultiple(posts []*model.Post) ([]*model.Post, int, error) {
 	origCtx := s.Root.Store.Context()
 	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "PostStore.SaveMultiple")
 	s.Root.Store.SetContext(newCtx)
@@ -5329,7 +5329,7 @@ func (s *OpenTracingLayerPostStore) SearchPostsInTeamForUser(paramsList []*model
 	return resultVar0, resultVar1
 }
 
-func (s *OpenTracingLayerPostStore) Update(newPost *model.Post, oldPost *model.Post) (*model.Post, *model.AppError) {
+func (s *OpenTracingLayerPostStore) Update(newPost *model.Post, oldPost *model.Post) (*model.Post, error) {
 	origCtx := s.Root.Store.Context()
 	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "PostStore.Update")
 	s.Root.Store.SetContext(newCtx)

store/searchlayer/post_layer.go

@@ -75,7 +75,7 @@ func (s SearchPostStore) deleteUserPostsIndex(userID string) {
 	}
 }
 
-func (s SearchPostStore) Update(newPost, oldPost *model.Post) (*model.Post, *model.AppError) {
+func (s SearchPostStore) Update(newPost, oldPost *model.Post) (*model.Post, error) {
 	post, err := s.PostStore.Update(newPost, oldPost)
 
 	if err == nil {
@@ -92,7 +92,7 @@ func (s *SearchPostStore) Overwrite(post *model.Post) (*model.Post, *model.AppEr
 	return post, err
 }
 
-func (s SearchPostStore) Save(post *model.Post) (*model.Post, *model.AppError) {
+func (s SearchPostStore) Save(post *model.Post) (*model.Post, error) {
 	npost, err := s.PostStore.Save(post)
 
 	if err == nil {
@@ -101,7 +101,7 @@ func (s SearchPostStore) Save(post *model.Post) (*model.Post, *model.AppError) {
 	return npost, err
 }
 
-func (s SearchPostStore) Delete(postId string, date int64, deletedByID string) *model.AppError {
+func (s SearchPostStore) Delete(postId string, date int64, deletedByID string) error {
 	err := s.PostStore.Delete(postId, date, deletedByID)
 
 	if err == nil {
@@ -115,7 +115,7 @@ func (s SearchPostStore) Delete(postId string, date int64, deletedByID string) *
 	return err
 }
 
-func (s SearchPostStore) PermanentDeleteByUser(userID string) *model.AppError {
+func (s SearchPostStore) PermanentDeleteByUser(userID string) error {
 	err := s.PostStore.PermanentDeleteByUser(userID)
 	if err == nil {
 		s.deleteUserPostsIndex(userID)
@@ -123,7 +123,7 @@ func (s SearchPostStore) PermanentDeleteByUser(userID string) *model.AppError {
 	return err
 }
 
-func (s SearchPostStore) PermanentDeleteByChannel(channelID string) *model.AppError {
+func (s SearchPostStore) PermanentDeleteByChannel(channelID string) error {
 	err := s.PostStore.PermanentDeleteByChannel(channelID)
 	if err == nil {
 		s.deleteChannelPostsIndex(channelID)

store/sqlstore/post_store.go

@@ -12,6 +12,8 @@ import (
 	"strings"
 	"sync"
 
+	"github.com/pkg/errors"
+
 	sq "github.com/Masterminds/squirrel"
 	"github.com/mattermost/mattermost-server/v5/einterfaces"
 	"github.com/mattermost/mattermost-server/v5/mlog"
@@ -99,14 +101,14 @@ func (s *SqlPostStore) createIndexesIfNotExists() {
 	s.CreateFullTextIndexIfNotExists("idx_posts_hashtags_txt", "Posts", "Hashtags")
 }
 
-func (s *SqlPostStore) SaveMultiple(posts []*model.Post) ([]*model.Post, int, *model.AppError) {
+func (s *SqlPostStore) SaveMultiple(posts []*model.Post) ([]*model.Post, int, error) {
 	channelNewPosts := make(map[string]int)
 	maxDateNewPosts := make(map[string]int64)
 	rootIds := make(map[string]int)
 	maxDateRootIds := make(map[string]int64)
 	for idx, post := range posts {
 		if len(post.Id) > 0 {
-			return nil, idx, model.NewAppError("SqlPostStore.Save", "store.sql_post.save.existing.app_error", nil, "id="+post.Id, http.StatusBadRequest)
+			return nil, idx, store.NewErrInvalidInput("Post", "id", post.Id)
 		}
 		post.PreSave()
 		maxPostSize := s.GetMaxPostSize()
@@ -147,17 +149,17 @@ func (s *SqlPostStore) SaveMultiple(posts []*model.Post) ([]*model.Post, int, *m
 		}
 	}
 
-	query := s.getQueryBuilder().Insert("Posts").Columns(postSliceColumns()...)
+	builder := s.getQueryBuilder().Insert("Posts").Columns(postSliceColumns()...)
 	for _, post := range posts {
-		query = query.Values(postToSlice(post)...)
+		builder = builder.Values(postToSlice(post)...)
 	}
-	sql, args, err := query.ToSql()
+	query, args, err := builder.ToSql()
 	if err != nil {
-		return nil, -1, model.NewAppError("SqlPostStore.Save", "store.sql_post.save.app_error", nil, err.Error(), http.StatusInternalServerError)
+		return nil, -1, errors.Wrap(err, "post_tosql")
 	}
 
-	if _, err := s.GetMaster().Exec(sql, args...); err != nil {
+	if _, err := s.GetMaster().Exec(query, args...); err != nil {
-		return nil, -1, model.NewAppError("SqlPostStore.Save", "store.sql_post.save.app_error", nil, err.Error(), http.StatusInternalServerError)
+		return nil, -1, errors.Wrap(err, "failed to save Post")
 	}
 
 	for channelId, count := range channelNewPosts {
@@ -193,7 +195,7 @@ func (s *SqlPostStore) SaveMultiple(posts []*model.Post) ([]*model.Post, int, *m
 	return posts, -1, nil
 }
 
-func (s *SqlPostStore) Save(post *model.Post) (*model.Post, *model.AppError) {
+func (s *SqlPostStore) Save(post *model.Post) (*model.Post, error) {
 	posts, _, err := s.SaveMultiple([]*model.Post{post})
 	if err != nil {
 		return nil, err
@@ -237,7 +239,7 @@ func (s *SqlPostStore) populateReplyCount(posts []*model.Post) *model.AppError {
 	return nil
 }
 
-func (s *SqlPostStore) Update(newPost *model.Post, oldPost *model.Post) (*model.Post, *model.AppError) {
+func (s *SqlPostStore) Update(newPost *model.Post, oldPost *model.Post) (*model.Post, error) {
 	newPost.UpdateAt = model.GetMillis()
 	newPost.PreCommit()
 
@@ -254,7 +256,7 @@ func (s *SqlPostStore) Update(newPost *model.Post, oldPost *model.Post) (*model.
 	}
 
 	if _, err := s.GetMaster().Update(newPost); err != nil {
-		return nil, model.NewAppError("SqlPostStore.Update", "store.sql_post.update.app_error", nil, "id="+newPost.Id+", "+err.Error(), http.StatusInternalServerError)
+		return nil, errors.Wrapf(err, "failed to update Post with id=%s", newPost.Id)
 	}
 
 	time := model.GetMillis()
@@ -396,18 +398,22 @@ func (s *SqlPostStore) GetFlaggedPostsForChannel(userId, channelId string, offse
 	return pl, nil
 }
 
-func (s *SqlPostStore) Get(id string, skipFetchThreads bool) (*model.PostList, *model.AppError) {
+func (s *SqlPostStore) Get(id string, skipFetchThreads bool) (*model.PostList, error) {
 	pl := model.NewPostList()
 
 	if len(id) == 0 {
-		return nil, model.NewAppError("SqlPostStore.GetPost", "store.sql_post.get.app_error", nil, "id="+id, http.StatusBadRequest)
+		return nil, store.NewErrInvalidInput("Post", "id", id)
 	}
 
 	var post model.Post
 	postFetchQuery := "SELECT p.*, (SELECT count(Posts.Id) FROM Posts WHERE Posts.RootId = (CASE WHEN p.RootId = '' THEN p.Id ELSE p.RootId END) AND Posts.DeleteAt = 0) as ReplyCount FROM Posts p WHERE p.Id = :Id AND p.DeleteAt = 0"
 	err := s.GetReplica().SelectOne(&post, postFetchQuery, map[string]interface{}{"Id": id})
 	if err != nil {
-		return nil, model.NewAppError("SqlPostStore.GetPost", "store.sql_post.get.app_error", nil, "id="+id+err.Error(), http.StatusNotFound)
+		if err == sql.ErrNoRows {
+			return nil, store.NewErrNotFound("Post", id)
+		}
+
+		return nil, errors.Wrapf(err, "failed to get Post with id=%s", id)
 	}
 	pl.AddPost(&post)
 	pl.AddOrder(id)
@@ -419,13 +425,13 @@ func (s *SqlPostStore) Get(id string, skipFetchThreads bool) (*model.PostList, *
 		}
 
 		if len(rootId) == 0 {
-			return nil, model.NewAppError("SqlPostStore.GetPost", "store.sql_post.get.app_error", nil, "root_id="+rootId, http.StatusInternalServerError)
+			return nil, errors.Wrapf(err, "invalid rootId with value=%s", rootId)
 		}
 
 		var posts []*model.Post
 		_, err = s.GetReplica().Select(&posts, "SELECT *, (SELECT count(Id) FROM Posts WHERE Posts.RootId = (CASE WHEN p.RootId = '' THEN p.Id ELSE p.RootId END) AND Posts.DeleteAt = 0) as ReplyCount FROM Posts p WHERE (Id = :Id OR RootId = :RootId) AND DeleteAt = 0", map[string]interface{}{"Id": rootId, "RootId": rootId})
 		if err != nil {
-			return nil, model.NewAppError("SqlPostStore.GetPost", "store.sql_post.get.app_error", nil, "root_id="+rootId+err.Error(), http.StatusInternalServerError)
+			return nil, errors.Wrap(err, "failed to find Posts")
 		}
 
 		for _, p := range posts {
@@ -436,11 +442,15 @@ func (s *SqlPostStore) Get(id string, skipFetchThreads bool) (*model.PostList, *
 	return pl, nil
 }
 
-func (s *SqlPostStore) GetSingle(id string) (*model.Post, *model.AppError) {
+func (s *SqlPostStore) GetSingle(id string) (*model.Post, error) {
 	var post model.Post
 	err := s.GetReplica().SelectOne(&post, "SELECT * FROM Posts WHERE Id = :Id AND DeleteAt = 0", map[string]interface{}{"Id": id})
 	if err != nil {
-		return nil, model.NewAppError("SqlPostStore.GetSingle", "store.sql_post.get.app_error", nil, "id="+id+err.Error(), http.StatusNotFound)
+		if err == sql.ErrNoRows {
+			return nil, store.NewErrNotFound("Post", id)
+		}
+
+		return nil, errors.Wrapf(err, "failed to get Post with id=%s", id)
 	}
 	return &post, nil
 }
@@ -466,45 +476,44 @@ func (s *SqlPostStore) GetEtag(channelId string, allowFromCache bool) string {
 	return result
 }
 
-func (s *SqlPostStore) Delete(postId string, time int64, deleteByID string) *model.AppError {
+func (s *SqlPostStore) Delete(postId string, time int64, deleteByID string) error {
-
-	appErr := func(errMsg string) *model.AppError {
-		return model.NewAppError("SqlPostStore.Delete", "store.sql_post.delete.app_error", nil, "id="+postId+", err="+errMsg, http.StatusInternalServerError)
-	}
-
 	var post model.Post
 	err := s.GetReplica().SelectOne(&post, "SELECT * FROM Posts WHERE Id = :Id AND DeleteAt = 0", map[string]interface{}{"Id": postId})
 	if err != nil {
-		return appErr(err.Error())
+		if err == sql.ErrNoRows {
+			return store.NewErrNotFound("Post", postId)
+		}
+
+		return errors.Wrapf(err, "failed to delete Post with id=%s", postId)
 	}
 
 	post.AddProp(model.POST_PROPS_DELETE_BY, deleteByID)
 
 	_, err = s.GetMaster().Exec("UPDATE Posts SET DeleteAt = :DeleteAt, UpdateAt = :UpdateAt, Props = :Props WHERE Id = :Id OR RootId = :RootId", map[string]interface{}{"DeleteAt": time, "UpdateAt": time, "Id": postId, "RootId": postId, "Props": model.StringInterfaceToJson(post.GetProps())})
 	if err != nil {
-		return appErr(err.Error())
+		return errors.Wrap(err, "failed to update Posts")
 	}
 
 	return nil
 }
 
-func (s *SqlPostStore) permanentDelete(postId string) *model.AppError {
+func (s *SqlPostStore) permanentDelete(postId string) error {
 	_, err := s.GetMaster().Exec("DELETE FROM Posts WHERE Id = :Id OR RootId = :RootId", map[string]interface{}{"Id": postId, "RootId": postId})
 	if err != nil {
-		return model.NewAppError("SqlPostStore.Delete", "store.sql_post.permanent_delete.app_error", nil, "id="+postId+", err="+err.Error(), http.StatusInternalServerError)
+		return errors.Wrapf(err, "failed to delete Post with id=%s", postId)
 	}
 	return nil
 }
 
-func (s *SqlPostStore) permanentDeleteAllCommentByUser(userId string) *model.AppError {
+func (s *SqlPostStore) permanentDeleteAllCommentByUser(userId string) error {
 	_, err := s.GetMaster().Exec("DELETE FROM Posts WHERE UserId = :UserId AND RootId != ''", map[string]interface{}{"UserId": userId})
 	if err != nil {
-		return model.NewAppError("SqlPostStore.permanentDeleteAllCommentByUser", "store.sql_post.permanent_delete_all_comments_by_user.app_error", nil, "userId="+userId+", err="+err.Error(), http.StatusInternalServerError)
+		return errors.Wrapf(err, "failed to delete Posts with userId=%s", userId)
 	}
 	return nil
 }
 
-func (s *SqlPostStore) PermanentDeleteByUser(userId string) *model.AppError {
+func (s *SqlPostStore) PermanentDeleteByUser(userId string) error {
 	// First attempt to delete all the comments for a user
 	if err := s.permanentDeleteAllCommentByUser(userId); err != nil {
 		return err
@@ -519,13 +528,13 @@ func (s *SqlPostStore) PermanentDeleteByUser(userId string) *model.AppError {
 		var ids []string
 		_, err := s.GetMaster().Select(&ids, "SELECT Id FROM Posts WHERE UserId = :UserId LIMIT 1000", map[string]interface{}{"UserId": userId})
 		if err != nil {
-			return model.NewAppError("SqlPostStore.PermanentDeleteByUser.select", "store.sql_post.permanent_delete_by_user.app_error", nil, "userId="+userId+", err="+err.Error(), http.StatusInternalServerError)
+			return errors.Wrapf(err, "failed to find Posts with userId=%s", userId)
 		}
 
 		found = false
 		for _, id := range ids {
 			found = true
-			if err := s.permanentDelete(id); err != nil {
+			if err = s.permanentDelete(id); err != nil {
 				return err
 			}
 		}
@@ -533,16 +542,16 @@ func (s *SqlPostStore) PermanentDeleteByUser(userId string) *model.AppError {
 		// This is a fail safe, give up if more than 10k messages
 		count++
 		if count >= 10 {
-			return model.NewAppError("SqlPostStore.PermanentDeleteByUser.toolarge", "store.sql_post.permanent_delete_by_user.too_many.app_error", nil, "userId="+userId, http.StatusInternalServerError)
+			return errors.Wrapf(err, "too many Posts to delete with userId=%s", userId)
 		}
 	}
 
 	return nil
 }
 
-func (s *SqlPostStore) PermanentDeleteByChannel(channelId string) *model.AppError {
+func (s *SqlPostStore) PermanentDeleteByChannel(channelId string) error {
 	if _, err := s.GetMaster().Exec("DELETE FROM Posts WHERE ChannelId = :ChannelId", map[string]interface{}{"ChannelId": channelId}); err != nil {
-		return model.NewAppError("SqlPostStore.PermanentDeleteByChannel", "store.sql_post.permanent_delete_by_channel.app_error", nil, "channel_id="+channelId+", "+err.Error(), http.StatusInternalServerError)
+		return errors.Wrapf(err, "failed to delete Posts with channelId=%s", channelId)
 	}
 	return nil
 }
@@ -1541,7 +1550,7 @@ func (s *SqlPostStore) GetOldest() (*model.Post, *model.AppError) {
 	var post model.Post
 	err := s.GetReplica().SelectOne(&post, "SELECT * FROM Posts ORDER BY CreateAt LIMIT 1")
 	if err != nil {
-		return nil, model.NewAppError("SqlPostStore.GetOldest", "store.sql_post.get.app_error", nil, err.Error(), http.StatusNotFound)
+		return nil, model.NewAppError("SqlPostStore.GetOldest", "app.post.get.app_error", nil, err.Error(), http.StatusNotFound)
 	}
 
 	return &post, nil

store/store.go

@@ -249,14 +249,14 @@ type ChannelMemberHistoryStore interface {
 }
 
 type PostStore interface {
-	SaveMultiple(posts []*model.Post) ([]*model.Post, int, *model.AppError)
+	SaveMultiple(posts []*model.Post) ([]*model.Post, int, error)
-	Save(post *model.Post) (*model.Post, *model.AppError)
+	Save(post *model.Post) (*model.Post, error)
-	Update(newPost *model.Post, oldPost *model.Post) (*model.Post, *model.AppError)
+	Update(newPost *model.Post, oldPost *model.Post) (*model.Post, error)
-	Get(id string, skipFetchThreads bool) (*model.PostList, *model.AppError)
+	Get(id string, skipFetchThreads bool) (*model.PostList, error)
-	GetSingle(id string) (*model.Post, *model.AppError)
+	GetSingle(id string) (*model.Post, error)
-	Delete(postId string, time int64, deleteByID string) *model.AppError
+	Delete(postId string, time int64, deleteByID string) error
-	PermanentDeleteByUser(userId string) *model.AppError
+	PermanentDeleteByUser(userId string) error
-	PermanentDeleteByChannel(channelId string) *model.AppError
+	PermanentDeleteByChannel(channelId string) error
 	GetPosts(options model.GetPostsOptions, allowFromCache bool) (*model.PostList, *model.AppError)
 	GetFlaggedPosts(userId string, offset int, limit int) (*model.PostList, *model.AppError)
 	// @openTracingParams userId, teamId, offset, limit

store/storetest/channel_store.go

@@ -4311,12 +4311,12 @@ func testChannelStoreGetMemberForPost(t *testing.T, ss store.Store) {
 	})
 	require.Nil(t, err)
 
-	p1, err := ss.Post().Save(&model.Post{
+	p1, nErr := ss.Post().Save(&model.Post{
 		UserId:    model.NewId(),
 		ChannelId: o1.Id,
 		Message:   "test",
 	})
-	require.Nil(t, err)
+	require.Nil(t, nErr)
 
 	r1, err := ss.Channel().GetMemberForPost(p1.Id, m1.UserId)
 	require.Nil(t, err, err)

store/storetest/compliance_store.go

@@ -23,8 +23,8 @@ func cleanupStoreState(t *testing.T, ss store.Store) {
 		require.Nil(t, err, "failed cleaning up test user %s", u.Username)
 
 		//remove all posts by this user
-		err = ss.Post().PermanentDeleteByUser(u.Id)
+		nErr := ss.Post().PermanentDeleteByUser(u.Id)
-		require.Nil(t, err, "failed cleaning all posts of test user %s", u.Username)
+		require.Nil(t, nErr, "failed cleaning all posts of test user %s", u.Username)
 	}
 
 	//remove existing channels
@@ -135,32 +135,32 @@ func testComplianceExport(t *testing.T, ss store.Store) {
 	o1.UserId = u1.Id
 	o1.CreateAt = model.GetMillis()
 	o1.Message = "zz" + model.NewId() + "b"
-	o1, err = ss.Post().Save(o1)
+	o1, nErr = ss.Post().Save(o1)
-	require.Nil(t, err)
+	require.Nil(t, nErr)
 
 	o1a := &model.Post{}
 	o1a.ChannelId = c1.Id
 	o1a.UserId = u1.Id
 	o1a.CreateAt = o1.CreateAt + 10
 	o1a.Message = "zz" + model.NewId() + "b"
-	_, err = ss.Post().Save(o1a)
+	_, nErr = ss.Post().Save(o1a)
-	require.Nil(t, err)
+	require.Nil(t, nErr)
 
 	o2 := &model.Post{}
 	o2.ChannelId = c1.Id
 	o2.UserId = u1.Id
 	o2.CreateAt = o1.CreateAt + 20
 	o2.Message = "zz" + model.NewId() + "b"
-	_, err = ss.Post().Save(o2)
+	_, nErr = ss.Post().Save(o2)
-	require.Nil(t, err)
+	require.Nil(t, nErr)
 
 	o2a := &model.Post{}
 	o2a.ChannelId = c1.Id
 	o2a.UserId = u2.Id
 	o2a.CreateAt = o1.CreateAt + 30
 	o2a.Message = "zz" + model.NewId() + "b"
-	o2a, err = ss.Post().Save(o2a)
+	o2a, nErr = ss.Post().Save(o2a)
-	require.Nil(t, err)
+	require.Nil(t, nErr)
 
 	time.Sleep(100 * time.Millisecond)
 
@@ -246,40 +246,40 @@ func testComplianceExportDirectMessages(t *testing.T, ss store.Store) {
 	o1.UserId = u1.Id
 	o1.CreateAt = model.GetMillis()
 	o1.Message = "zz" + model.NewId() + "b"
-	o1, err = ss.Post().Save(o1)
+	o1, nErr = ss.Post().Save(o1)
-	require.Nil(t, err)
+	require.Nil(t, nErr)
 
 	o1a := &model.Post{}
 	o1a.ChannelId = c1.Id
 	o1a.UserId = u1.Id
 	o1a.CreateAt = o1.CreateAt + 10
 	o1a.Message = "zz" + model.NewId() + "b"
-	_, err = ss.Post().Save(o1a)
+	_, nErr = ss.Post().Save(o1a)
-	require.Nil(t, err)
+	require.Nil(t, nErr)
 
 	o2 := &model.Post{}
 	o2.ChannelId = c1.Id
 	o2.UserId = u1.Id
 	o2.CreateAt = o1.CreateAt + 20
 	o2.Message = "zz" + model.NewId() + "b"
-	_, err = ss.Post().Save(o2)
+	_, nErr = ss.Post().Save(o2)
-	require.Nil(t, err)
+	require.Nil(t, nErr)
 
 	o2a := &model.Post{}
 	o2a.ChannelId = c1.Id
 	o2a.UserId = u2.Id
 	o2a.CreateAt = o1.CreateAt + 30
 	o2a.Message = "zz" + model.NewId() + "b"
-	_, err = ss.Post().Save(o2a)
+	_, nErr = ss.Post().Save(o2a)
-	require.Nil(t, err)
+	require.Nil(t, nErr)
 
 	o3 := &model.Post{}
 	o3.ChannelId = cDM.Id
 	o3.UserId = u1.Id
 	o3.CreateAt = o1.CreateAt + 40
 	o3.Message = "zz" + model.NewId() + "b"
-	o3, err = ss.Post().Save(o3)
+	o3, nErr = ss.Post().Save(o3)
-	require.Nil(t, err)
+	require.Nil(t, nErr)
 
 	time.Sleep(100 * time.Millisecond)
 

store/storetest/mocks/PostStore.go

@@ -93,23 +93,21 @@ func (_m *PostStore) ClearCaches() {
 }
 
 // Delete provides a mock function with given fields: postId, time, deleteByID
-func (_m *PostStore) Delete(postId string, time int64, deleteByID string) *model.AppError {
+func (_m *PostStore) Delete(postId string, time int64, deleteByID string) error {
 	ret := _m.Called(postId, time, deleteByID)
 
-	var r0 *model.AppError
+	var r0 error
-	if rf, ok := ret.Get(0).(func(string, int64, string) *model.AppError); ok {
+	if rf, ok := ret.Get(0).(func(string, int64, string) error); ok {
 		r0 = rf(postId, time, deleteByID)
 	} else {
-		if ret.Get(0) != nil {
+		r0 = ret.Error(0)
-			r0 = ret.Get(0).(*model.AppError)
-		}
 	}
 
 	return r0
 }
 
 // Get provides a mock function with given fields: id, skipFetchThreads
-func (_m *PostStore) Get(id string, skipFetchThreads bool) (*model.PostList, *model.AppError) {
+func (_m *PostStore) Get(id string, skipFetchThreads bool) (*model.PostList, error) {
 	ret := _m.Called(id, skipFetchThreads)
 
 	var r0 *model.PostList
@@ -121,13 +119,11 @@ func (_m *PostStore) Get(id string, skipFetchThreads bool) (*model.PostList, *mo
 		}
 	}
 
-	var r1 *model.AppError
+	var r1 error
-	if rf, ok := ret.Get(1).(func(string, bool) *model.AppError); ok {
+	if rf, ok := ret.Get(1).(func(string, bool) error); ok {
 		r1 = rf(id, skipFetchThreads)
 	} else {
-		if ret.Get(1) != nil {
+		r1 = ret.Error(1)
-			r1 = ret.Get(1).(*model.AppError)
-		}
 	}
 
 	return r0, r1
@@ -606,7 +602,7 @@ func (_m *PostStore) GetRepliesForExport(parentId string) ([]*model.ReplyForExpo
 }
 
 // GetSingle provides a mock function with given fields: id
-func (_m *PostStore) GetSingle(id string) (*model.Post, *model.AppError) {
+func (_m *PostStore) GetSingle(id string) (*model.Post, error) {
 	ret := _m.Called(id)
 
 	var r0 *model.Post
@@ -618,13 +614,11 @@ func (_m *PostStore) GetSingle(id string) (*model.Post, *model.AppError) {
 		}
 	}
 
-	var r1 *model.AppError
+	var r1 error
-	if rf, ok := ret.Get(1).(func(string) *model.AppError); ok {
+	if rf, ok := ret.Get(1).(func(string) error); ok {
 		r1 = rf(id)
 	} else {
-		if ret.Get(1) != nil {
+		r1 = ret.Error(1)
-			r1 = ret.Get(1).(*model.AppError)
-		}
 	}
 
 	return r0, r1
@@ -716,39 +710,35 @@ func (_m *PostStore) PermanentDeleteBatch(endTime int64, limit int64) (int64, *m
 }
 
 // PermanentDeleteByChannel provides a mock function with given fields: channelId
-func (_m *PostStore) PermanentDeleteByChannel(channelId string) *model.AppError {
+func (_m *PostStore) PermanentDeleteByChannel(channelId string) error {
 	ret := _m.Called(channelId)
 
-	var r0 *model.AppError
+	var r0 error
-	if rf, ok := ret.Get(0).(func(string) *model.AppError); ok {
+	if rf, ok := ret.Get(0).(func(string) error); ok {
 		r0 = rf(channelId)
 	} else {
-		if ret.Get(0) != nil {
+		r0 = ret.Error(0)
-			r0 = ret.Get(0).(*model.AppError)
-		}
 	}
 
 	return r0
 }
 
 // PermanentDeleteByUser provides a mock function with given fields: userId
-func (_m *PostStore) PermanentDeleteByUser(userId string) *model.AppError {
+func (_m *PostStore) PermanentDeleteByUser(userId string) error {
 	ret := _m.Called(userId)
 
-	var r0 *model.AppError
+	var r0 error
-	if rf, ok := ret.Get(0).(func(string) *model.AppError); ok {
+	if rf, ok := ret.Get(0).(func(string) error); ok {
 		r0 = rf(userId)
 	} else {
-		if ret.Get(0) != nil {
+		r0 = ret.Error(0)
-			r0 = ret.Get(0).(*model.AppError)
-		}
 	}
 
 	return r0
 }
 
 // Save provides a mock function with given fields: post
-func (_m *PostStore) Save(post *model.Post) (*model.Post, *model.AppError) {
+func (_m *PostStore) Save(post *model.Post) (*model.Post, error) {
 	ret := _m.Called(post)
 
 	var r0 *model.Post
@@ -760,20 +750,18 @@ func (_m *PostStore) Save(post *model.Post) (*model.Post, *model.AppError) {
 		}
 	}
 
-	var r1 *model.AppError
+	var r1 error
-	if rf, ok := ret.Get(1).(func(*model.Post) *model.AppError); ok {
+	if rf, ok := ret.Get(1).(func(*model.Post) error); ok {
 		r1 = rf(post)
 	} else {
-		if ret.Get(1) != nil {
+		r1 = ret.Error(1)
-			r1 = ret.Get(1).(*model.AppError)
-		}
 	}
 
 	return r0, r1
 }
 
 // SaveMultiple provides a mock function with given fields: posts
-func (_m *PostStore) SaveMultiple(posts []*model.Post) ([]*model.Post, int, *model.AppError) {
+func (_m *PostStore) SaveMultiple(posts []*model.Post) ([]*model.Post, int, error) {
 	ret := _m.Called(posts)
 
 	var r0 []*model.Post
@@ -792,13 +780,11 @@ func (_m *PostStore) SaveMultiple(posts []*model.Post) ([]*model.Post, int, *mod
 		r1 = ret.Get(1).(int)
 	}
 
-	var r2 *model.AppError
+	var r2 error
-	if rf, ok := ret.Get(2).(func([]*model.Post) *model.AppError); ok {
+	if rf, ok := ret.Get(2).(func([]*model.Post) error); ok {
 		r2 = rf(posts)
 	} else {
-		if ret.Get(2) != nil {
+		r2 = ret.Error(2)
-			r2 = ret.Get(2).(*model.AppError)
-		}
 	}
 
 	return r0, r1, r2
@@ -855,7 +841,7 @@ func (_m *PostStore) SearchPostsInTeamForUser(paramsList []*model.SearchParams,
 }
 
 // Update provides a mock function with given fields: newPost, oldPost
-func (_m *PostStore) Update(newPost *model.Post, oldPost *model.Post) (*model.Post, *model.AppError) {
+func (_m *PostStore) Update(newPost *model.Post, oldPost *model.Post) (*model.Post, error) {
 	ret := _m.Called(newPost, oldPost)
 
 	var r0 *model.Post
@@ -867,13 +853,11 @@ func (_m *PostStore) Update(newPost *model.Post, oldPost *model.Post) (*model.Po
 		}
 	}
 
-	var r1 *model.AppError
+	var r1 error
-	if rf, ok := ret.Get(1).(func(*model.Post, *model.Post) *model.AppError); ok {
+	if rf, ok := ret.Get(1).(func(*model.Post, *model.Post) error); ok {
 		r1 = rf(newPost, oldPost)
 	} else {
-		if ret.Get(1) != nil {
+		r1 = ret.Error(1)
-			r1 = ret.Get(1).(*model.AppError)
-		}
 	}
 
 	return r0, r1

store/storetest/post_store.go

@@ -1543,32 +1543,32 @@ func testUserCountsWithPostsByDay(t *testing.T, ss store.Store) {
 	o1.UserId = model.NewId()
 	o1.CreateAt = utils.MillisFromTime(utils.Yesterday())
 	o1.Message = "zz" + model.NewId() + "b"
-	o1, err = ss.Post().Save(o1)
+	o1, nErr = ss.Post().Save(o1)
-	require.Nil(t, err)
+	require.Nil(t, nErr)
 
 	o1a := &model.Post{}
 	o1a.ChannelId = c1.Id
 	o1a.UserId = model.NewId()
 	o1a.CreateAt = o1.CreateAt
 	o1a.Message = "zz" + model.NewId() + "b"
-	_, err = ss.Post().Save(o1a)
+	_, nErr = ss.Post().Save(o1a)
-	require.Nil(t, err)
+	require.Nil(t, nErr)
 
 	o2 := &model.Post{}
 	o2.ChannelId = c1.Id
 	o2.UserId = model.NewId()
 	o2.CreateAt = o1.CreateAt - (1000 * 60 * 60 * 24)
 	o2.Message = "zz" + model.NewId() + "b"
-	o2, err = ss.Post().Save(o2)
+	o2, nErr = ss.Post().Save(o2)
-	require.Nil(t, err)
+	require.Nil(t, nErr)
 
 	o2a := &model.Post{}
 	o2a.ChannelId = c1.Id
 	o2a.UserId = o2.UserId
 	o2a.CreateAt = o1.CreateAt - (1000 * 60 * 60 * 24)
 	o2a.Message = "zz" + model.NewId() + "b"
-	_, err = ss.Post().Save(o2a)
+	_, nErr = ss.Post().Save(o2a)
-	require.Nil(t, err)
+	require.Nil(t, nErr)
 
 	r1, err := ss.Post().AnalyticsUserCountsWithPostsByDay(t1.Id)
 	require.Nil(t, err)
@@ -1602,32 +1602,32 @@ func testPostCountsByDay(t *testing.T, ss store.Store) {
 	o1.UserId = model.NewId()
 	o1.CreateAt = utils.MillisFromTime(utils.Yesterday())
 	o1.Message = "zz" + model.NewId() + "b"
-	o1, err = ss.Post().Save(o1)
+	o1, nErr = ss.Post().Save(o1)
-	require.Nil(t, err)
+	require.Nil(t, nErr)
 
 	o1a := &model.Post{}
 	o1a.ChannelId = c1.Id
 	o1a.UserId = model.NewId()
 	o1a.CreateAt = o1.CreateAt
 	o1a.Message = "zz" + model.NewId() + "b"
-	_, err = ss.Post().Save(o1a)
+	_, nErr = ss.Post().Save(o1a)
-	require.Nil(t, err)
+	require.Nil(t, nErr)
 
 	o2 := &model.Post{}
 	o2.ChannelId = c1.Id
 	o2.UserId = model.NewId()
 	o2.CreateAt = o1.CreateAt - (1000 * 60 * 60 * 24 * 2)
 	o2.Message = "zz" + model.NewId() + "b"
-	o2, err = ss.Post().Save(o2)
+	o2, nErr = ss.Post().Save(o2)
-	require.Nil(t, err)
+	require.Nil(t, nErr)
 
 	o2a := &model.Post{}
 	o2a.ChannelId = c1.Id
 	o2a.UserId = o2.UserId
 	o2a.CreateAt = o1.CreateAt - (1000 * 60 * 60 * 24 * 2)
 	o2a.Message = "zz" + model.NewId() + "b"
-	_, err = ss.Post().Save(o2a)
+	_, nErr = ss.Post().Save(o2a)
-	require.Nil(t, err)
+	require.Nil(t, nErr)
 
 	bot1 := &model.Bot{
 		Username:    "username",
@@ -1643,16 +1643,16 @@ func testPostCountsByDay(t *testing.T, ss store.Store) {
 	b1.ChannelId = c1.Id
 	b1.UserId = bot1.UserId
 	b1.CreateAt = utils.MillisFromTime(utils.Yesterday())
-	_, err = ss.Post().Save(b1)
+	_, nErr = ss.Post().Save(b1)
-	require.Nil(t, err)
+	require.Nil(t, nErr)
 
 	b1a := &model.Post{}
 	b1a.Message = "bot message two"
 	b1a.ChannelId = c1.Id
 	b1a.UserId = bot1.UserId
 	b1a.CreateAt = utils.MillisFromTime(utils.Yesterday()) - (1000 * 60 * 60 * 24 * 2)
-	_, err = ss.Post().Save(b1a)
+	_, nErr = ss.Post().Save(b1a)
-	require.Nil(t, err)
+	require.Nil(t, nErr)
 
 	time.Sleep(1 * time.Second)
 
@@ -2163,16 +2163,16 @@ func testPostStoreOverwriteMultiple(t *testing.T, ss store.Store) {
 		require.Nil(t, err)
 		require.Equal(t, -1, errIdx)
 
-		r1, err = ss.Post().Get(o1.Id, false)
+		r1, nErr := ss.Post().Get(o1.Id, false)
-		require.Nil(t, err)
+		require.Nil(t, nErr)
 		ro1a := r1.Posts[o1.Id]
 
-		r2, err = ss.Post().Get(o1.Id, false)
+		r2, nErr = ss.Post().Get(o1.Id, false)
-		require.Nil(t, err)
+		require.Nil(t, nErr)
 		ro2a := r2.Posts[o2.Id]
 
-		r3, err = ss.Post().Get(o3.Id, false)
+		r3, nErr = ss.Post().Get(o3.Id, false)
-		require.Nil(t, err)
+		require.Nil(t, nErr)
 		ro3a := r3.Posts[o3.Id]
 
 		assert.Equal(t, ro1a.Message, o1a.Message, "Failed to overwrite/get")
@@ -2193,12 +2193,12 @@ func testPostStoreOverwriteMultiple(t *testing.T, ss store.Store) {
 		require.Nil(t, err)
 		require.Equal(t, -1, errIdx)
 
-		r4, err = ss.Post().Get(o4.Id, false)
+		r4, nErr := ss.Post().Get(o4.Id, false)
-		require.Nil(t, err)
+		require.Nil(t, nErr)
 		ro4a := r4.Posts[o4.Id]
 
-		r5, err = ss.Post().Get(o5.Id, false)
+		r5, nErr = ss.Post().Get(o5.Id, false)
-		require.Nil(t, err)
+		require.Nil(t, nErr)
 		ro5a := r5.Posts[o5.Id]
 
 		require.Empty(t, ro4a.Filenames, "Failed to clear Filenames")
@@ -2522,8 +2522,8 @@ func testPostStoreGetParentsForExportAfter(t *testing.T, ss store.Store) {
 	p1.UserId = u1.Id
 	p1.Message = "zz" + model.NewId() + "AAAAAAAAAAA"
 	p1.CreateAt = 1000
-	p1, err = ss.Post().Save(p1)
+	p1, nErr = ss.Post().Save(p1)
-	require.Nil(t, err)
+	require.Nil(t, nErr)
 
 	posts, err := ss.Post().GetParentsForExportAfter(10000, strings.Repeat("0", 26))
 	assert.Nil(t, err)
@@ -2570,8 +2570,8 @@ func testPostStoreGetRepliesForExport(t *testing.T, ss store.Store) {
 	p1.UserId = u1.Id
 	p1.Message = "zz" + model.NewId() + "AAAAAAAAAAA"
 	p1.CreateAt = 1000
-	p1, err = ss.Post().Save(p1)
+	p1, nErr = ss.Post().Save(p1)
-	require.Nil(t, err)
+	require.Nil(t, nErr)
 
 	p2 := &model.Post{}
 	p2.ChannelId = c1.Id
@@ -2580,8 +2580,8 @@ func testPostStoreGetRepliesForExport(t *testing.T, ss store.Store) {
 	p2.CreateAt = 1001
 	p2.ParentId = p1.Id
 	p2.RootId = p1.Id
-	p2, err = ss.Post().Save(p2)
+	p2, nErr = ss.Post().Save(p2)
-	require.Nil(t, err)
+	require.Nil(t, nErr)
 
 	r1, err := ss.Post().GetRepliesForExport(p1.Id)
 	assert.Nil(t, err)
@@ -2652,8 +2652,8 @@ func testPostStoreGetDirectPostParentsForExportAfter(t *testing.T, ss store.Stor
 	p1.UserId = u1.Id
 	p1.Message = "zz" + model.NewId() + "AAAAAAAAAAA"
 	p1.CreateAt = 1000
-	p1, err = ss.Post().Save(p1)
+	p1, nErr := ss.Post().Save(p1)
-	require.Nil(t, err)
+	require.Nil(t, nErr)
 
 	r1, err := ss.Post().GetDirectPostParentsForExportAfter(10000, strings.Repeat("0", 26))
 	assert.Nil(t, err)
@@ -2712,14 +2712,14 @@ func testPostStoreGetDirectPostParentsForExportAfterDeleted(t *testing.T, ss sto
 	p1.UserId = u1.Id
 	p1.Message = "zz" + model.NewId() + "BBBBBBBBBBBB"
 	p1.CreateAt = 1000
-	p1, err = ss.Post().Save(p1)
+	p1, nErr = ss.Post().Save(p1)
-	require.Nil(t, err)
+	require.Nil(t, nErr)
 
 	o1a := p1.Clone()
 	o1a.DeleteAt = 1
 	o1a.Message = p1.Message + "BBBBBBBBBB"
-	_, err = ss.Post().Update(o1a, p1)
+	_, nErr = ss.Post().Update(o1a, p1)
-	require.Nil(t, err)
+	require.Nil(t, nErr)
 
 	r1, err := ss.Post().GetDirectPostParentsForExportAfter(10000, strings.Repeat("0", 26))
 	assert.Nil(t, err)
@@ -2774,8 +2774,8 @@ func testPostStoreGetDirectPostParentsForExportAfterBatched(t *testing.T, ss sto
 		p1.UserId = u1.Id
 		p1.Message = "zz" + model.NewId() + "AAAAAAAAAAA"
 		p1.CreateAt = 1000
-		p1, err = ss.Post().Save(p1)
+		p1, nErr := ss.Post().Save(p1)
-		require.Nil(t, err)
+		require.Nil(t, nErr)
 		postIds = append(postIds, p1.Id)
 	}
 	sort.Slice(postIds, func(i, j int) bool { return postIds[i] < postIds[j] })

store/storetest/user_store.go

@@ -2042,8 +2042,8 @@ func testUserUnreadCount(t *testing.T, ss store.Store) {
 	p1.Message = "this is a message for @" + u2.Username
 
 	// Post one message with mention to open channel
-	_, err = ss.Post().Save(&p1)
+	_, nErr = ss.Post().Save(&p1)
-	require.Nil(t, err)
+	require.Nil(t, nErr)
 	err = ss.Channel().IncrementMentionCount(c1.Id, u2.Id)
 	require.Nil(t, err)
 
@@ -2053,8 +2053,8 @@ func testUserUnreadCount(t *testing.T, ss store.Store) {
 	p2.UserId = u1.Id
 	p2.Message = "first message"
 
-	_, err = ss.Post().Save(&p2)
+	_, nErr = ss.Post().Save(&p2)
-	require.Nil(t, err)
+	require.Nil(t, nErr)
 	err = ss.Channel().IncrementMentionCount(c2.Id, u2.Id)
 	require.Nil(t, err)
 
@@ -2062,8 +2062,8 @@ func testUserUnreadCount(t *testing.T, ss store.Store) {
 	p3.ChannelId = c2.Id
 	p3.UserId = u1.Id
 	p3.Message = "second message"
-	_, err = ss.Post().Save(&p3)
+	_, nErr = ss.Post().Save(&p3)
-	require.Nil(t, err)
+	require.Nil(t, nErr)
 
 	err = ss.Channel().IncrementMentionCount(c2.Id, u2.Id)
 	require.Nil(t, err)

store/timerlayer/timerlayer.go

@@ -4302,7 +4302,7 @@ func (s *TimerLayerPostStore) ClearCaches() {
 	}
 }
 
-func (s *TimerLayerPostStore) Delete(postId string, time int64, deleteByID string) *model.AppError {
+func (s *TimerLayerPostStore) Delete(postId string, time int64, deleteByID string) error {
 	start := timemodule.Now()
 
 	resultVar0 := s.PostStore.Delete(postId, time, deleteByID)
@@ -4318,7 +4318,7 @@ func (s *TimerLayerPostStore) Delete(postId string, time int64, deleteByID strin
 	return resultVar0
 }
 
-func (s *TimerLayerPostStore) Get(id string, skipFetchThreads bool) (*model.PostList, *model.AppError) {
+func (s *TimerLayerPostStore) Get(id string, skipFetchThreads bool) (*model.PostList, error) {
 	start := timemodule.Now()
 
 	resultVar0, resultVar1 := s.PostStore.Get(id, skipFetchThreads)
@@ -4654,7 +4654,7 @@ func (s *TimerLayerPostStore) GetRepliesForExport(parentId string) ([]*model.Rep
 	return resultVar0, resultVar1
 }
 
-func (s *TimerLayerPostStore) GetSingle(id string) (*model.Post, *model.AppError) {
+func (s *TimerLayerPostStore) GetSingle(id string) (*model.Post, error) {
 	start := timemodule.Now()
 
 	resultVar0, resultVar1 := s.PostStore.GetSingle(id)
@@ -4733,7 +4733,7 @@ func (s *TimerLayerPostStore) PermanentDeleteBatch(endTime int64, limit int64) (
 	return resultVar0, resultVar1
 }
 
-func (s *TimerLayerPostStore) PermanentDeleteByChannel(channelId string) *model.AppError {
+func (s *TimerLayerPostStore) PermanentDeleteByChannel(channelId string) error {
 	start := timemodule.Now()
 
 	resultVar0 := s.PostStore.PermanentDeleteByChannel(channelId)
@@ -4749,7 +4749,7 @@ func (s *TimerLayerPostStore) PermanentDeleteByChannel(channelId string) *model.
 	return resultVar0
 }
 
-func (s *TimerLayerPostStore) PermanentDeleteByUser(userId string) *model.AppError {
+func (s *TimerLayerPostStore) PermanentDeleteByUser(userId string) error {
 	start := timemodule.Now()
 
 	resultVar0 := s.PostStore.PermanentDeleteByUser(userId)
@@ -4765,7 +4765,7 @@ func (s *TimerLayerPostStore) PermanentDeleteByUser(userId string) *model.AppErr
 	return resultVar0
 }
 
-func (s *TimerLayerPostStore) Save(post *model.Post) (*model.Post, *model.AppError) {
+func (s *TimerLayerPostStore) Save(post *model.Post) (*model.Post, error) {
 	start := timemodule.Now()
 
 	resultVar0, resultVar1 := s.PostStore.Save(post)
@@ -4781,7 +4781,7 @@ func (s *TimerLayerPostStore) Save(post *model.Post) (*model.Post, *model.AppErr
 	return resultVar0, resultVar1
 }
 
-func (s *TimerLayerPostStore) SaveMultiple(posts []*model.Post) ([]*model.Post, int, *model.AppError) {
+func (s *TimerLayerPostStore) SaveMultiple(posts []*model.Post) ([]*model.Post, int, error) {
 	start := timemodule.Now()
 
 	resultVar0, resultVar1, resultVar2 := s.PostStore.SaveMultiple(posts)
@@ -4829,7 +4829,7 @@ func (s *TimerLayerPostStore) SearchPostsInTeamForUser(paramsList []*model.Searc
 	return resultVar0, resultVar1
 }
 
-func (s *TimerLayerPostStore) Update(newPost *model.Post, oldPost *model.Post) (*model.Post, *model.AppError) {
+func (s *TimerLayerPostStore) Update(newPost *model.Post, oldPost *model.Post) (*model.Post, error) {
 	start := timemodule.Now()
 
 	resultVar0, resultVar1 := s.PostStore.Update(newPost, oldPost)