TeamStore migration part 2 (#15396)

* Migration completed

* Fix tests

* Reduce to one line

* Fix: change to plain error

* Fix imports

* Trigger CI

* Fix i18

* Fix merge with master

* Trigger CI

app/channel.go

@@ -1347,11 +1347,17 @@ func (a *App) addUserToChannel(user *model.User, channel *model.Channel, teamMem
 }
 
 func (a *App) AddUserToChannel(user *model.User, channel *model.Channel) (*model.ChannelMember, *model.AppError) {
-	teamMember, err := a.Srv().Store.Team().GetMember(channel.TeamId, user.Id)
-
-	if err != nil {
-		return nil, err
+	teamMember, nErr := a.Srv().Store.Team().GetMember(channel.TeamId, user.Id)
+	if nErr != nil {
+		var nfErr *store.ErrNotFound
+		switch {
+		case errors.As(nErr, &nfErr):
+			return nil, model.NewAppError("AddUserToChannel", "app.team.get_member.missing.app_error", nil, nfErr.Error(), http.StatusNotFound)
+		default:
+			return nil, model.NewAppError("AddUserToChannel", "app.team.get_member.app_error", nil, nErr.Error(), http.StatusInternalServerError)
+		}
 	}
+
 	if teamMember.DeleteAt > 0 {
 		return nil, model.NewAppError("AddUserToChannel", "api.channel.add_user.to.channel.failed.deleted.app_error", nil, "", http.StatusBadRequest)
 	}

app/import_functions.go

@@ -670,9 +670,9 @@ func (a *App) importUserTeams(user *model.User, data *[]UserTeamImportData) *mod
 	isGuestByTeamId := map[string]bool{}
 	isUserByTeamId := map[string]bool{}
 	isAdminByTeamId := map[string]bool{}
-	existingMemberships, err := a.Srv().Store.Team().GetTeamsForUser(user.Id)
-	if err != nil {
-		return err
+	existingMemberships, nErr := a.Srv().Store.Team().GetTeamsForUser(user.Id)
+	if nErr != nil {
+		return model.NewAppError("importUserTeams", "app.team.get_members.app_error", nil, nErr.Error(), http.StatusInternalServerError)
 	}
 	existingMembershipsByTeamId := map[string]*model.TeamMember{}
 	for _, teamMembership := range existingMemberships {
@@ -747,9 +747,15 @@ func (a *App) importUserTeams(user *model.User, data *[]UserTeamImportData) *mod
 		}
 	}
 
-	oldMembers, err := a.Srv().Store.Team().UpdateMultipleMembers(oldTeamMembers)
-	if err != nil {
-		return err
+	oldMembers, nErr := a.Srv().Store.Team().UpdateMultipleMembers(oldTeamMembers)
+	if nErr != nil {
+		var appErr *model.AppError
+		switch {
+		case errors.As(nErr, &appErr):
+			return appErr
+		default:
+			return model.NewAppError("importUserTeams", "app.team.save_member.save.app_error", nil, nErr.Error(), http.StatusInternalServerError)
+		}
 	}
 
 	newMembers := []*model.TeamMember{}

app/import_functions_test.go

@@ -1711,8 +1711,8 @@ func TestImportUserTeams(t *testing.T) {
 				} else {
 					require.Nil(t, err)
 				}
-				teamMembers, err := th.App.Srv().Store.Team().GetTeamsForUser(user.Id)
-				require.Nil(t, err)
+				teamMembers, nErr := th.App.Srv().Store.Team().GetTeamsForUser(user.Id)
+				require.Nil(t, nErr)
 				require.Len(t, teamMembers, tc.expectedUserTeams)
 				if tc.expectedUserTeams == 1 {
 					require.Equal(t, tc.expectedExplicitRoles, teamMembers[0].ExplicitRoles, "Not matching expected explicit roles")

app/slashcommands/command_invite.go

@@ -144,7 +144,7 @@ func (me *InviteProvider) DoCommand(a *app.App, args *model.CommandArgs, message
 		var text string
 		if err.Id == "api.channel.add_members.user_denied" {
 			text = args.T("api.command_invite.group_constrained_user_denied")
-		} else if err.Id == "store.sql_team.get_member.missing.app_error" ||
+		} else if err.Id == "app.team.get_member.missing.app_error" ||
 			err.Id == "api.channel.add_user.to.channel.failed.deleted.app_error" {
 			text = args.T("api.command_invite.user_not_in_team.app_error", map[string]interface{}{
 				"Username": userProfile.Username,

app/syncables.go

@@ -28,7 +28,7 @@ func (a *App) createDefaultChannelMemberships(since int64, channelID *string) er
 		}
 
 		tmem, err := a.GetTeamMember(channel.TeamId, userChannel.UserID)
-		if err != nil && err.Id != "store.sql_team.get_member.missing.app_error" {
+		if err != nil && err.Id != "app.team.get_member.missing.app_error" {
 			return err
 		}
 

app/syncables_test.go

@@ -137,7 +137,7 @@ func TestCreateDefaultMemberships(t *testing.T) {
 
 	// Scientist should not be in team or channel
 	_, err = th.App.GetTeamMember(nerdsTeam.Id, scientist1.Id)
-	if err.Id != "store.sql_team.get_member.missing.app_error" {
+	if err.Id != "app.team.get_member.missing.app_error" {
 		t.Errorf("wrong error: %s", err.Id)
 	}
 

app/team.go

@@ -353,14 +353,19 @@ func (a *App) GetSchemeRolesForTeam(teamId string) (string, string, string, *mod
 }
 
 func (a *App) UpdateTeamMemberRoles(teamId string, userId string, newRoles string) (*model.TeamMember, *model.AppError) {
-	member, err := a.Srv().Store.Team().GetMember(teamId, userId)
-	if err != nil {
-		return nil, err
+	member, nErr := a.Srv().Store.Team().GetMember(teamId, userId)
+	if nErr != nil {
+		var nfErr *store.ErrNotFound
+		switch {
+		case errors.As(nErr, &nfErr):
+			return nil, model.NewAppError("UpdateTeamMemberRoles", "app.team.get_member.missing.app_error", nil, nfErr.Error(), http.StatusNotFound)
+		default:
+			return nil, model.NewAppError("UpdateTeamMemberRoles", "app.team.get_member.app_error", nil, nErr.Error(), http.StatusInternalServerError)
+		}
 	}
 
 	if member == nil {
-		err = model.NewAppError("UpdateTeamMemberRoles", "api.team.update_member_roles.not_a_member", nil, "userId="+userId+" teamId="+teamId, http.StatusBadRequest)
-		return nil, err
+		return nil, model.NewAppError("UpdateTeamMemberRoles", "api.team.update_member_roles.not_a_member", nil, "userId="+userId+" teamId="+teamId, http.StatusBadRequest)
 	}
 
 	schemeGuestRole, schemeUserRole, schemeAdminRole, err := a.GetSchemeRolesForTeam(teamId)
@@ -411,9 +416,15 @@ func (a *App) UpdateTeamMemberRoles(teamId string, userId string, newRoles strin
 
 	member.ExplicitRoles = strings.Join(newExplicitRoles, " ")
 
-	member, err = a.Srv().Store.Team().UpdateMember(member)
-	if err != nil {
-		return nil, err
+	member, nErr = a.Srv().Store.Team().UpdateMember(member)
+	if nErr != nil {
+		var appErr *model.AppError
+		switch {
+		case errors.As(nErr, &appErr):
+			return nil, appErr
+		default:
+			return nil, model.NewAppError("UpdateTeamMemberRoles", "app.team.save_member.save.app_error", nil, nErr.Error(), http.StatusInternalServerError)
+		}
 	}
 
 	a.ClearSessionCacheForUser(userId)
@@ -442,9 +453,15 @@ func (a *App) UpdateTeamMemberSchemeRoles(teamId string, userId string, isScheme
 		member.ExplicitRoles = RemoveRoles([]string{model.TEAM_GUEST_ROLE_ID, model.TEAM_USER_ROLE_ID, model.TEAM_ADMIN_ROLE_ID}, member.ExplicitRoles)
 	}
 
-	member, err = a.Srv().Store.Team().UpdateMember(member)
-	if err != nil {
-		return nil, err
+	member, nErr := a.Srv().Store.Team().UpdateMember(member)
+	if nErr != nil {
+		var appErr *model.AppError
+		switch {
+		case errors.As(nErr, &appErr):
+			return nil, appErr
+		default:
+			return nil, model.NewAppError("UpdateTeamMemberSchemeRoles", "app.team.save_member.save.app_error", nil, nErr.Error(), http.StatusInternalServerError)
+		}
 	}
 
 	a.ClearSessionCacheForUser(userId)
@@ -694,16 +711,22 @@ func (a *App) joinUserToTeam(team *model.Team, user *model.User) (*model.TeamMem
 
 	membersCount, err := a.Srv().Store.Team().GetActiveMemberCount(tm.TeamId, nil)
 	if err != nil {
-		return nil, false, err
+		return nil, false, model.NewAppError("joinUserToTeam", "app.team.get_active_member_count.app_error", nil, err.Error(), http.StatusInternalServerError)
 	}
 
 	if membersCount >= int64(*a.Config().TeamSettings.MaxUsersPerTeam) {
 		return nil, false, model.NewAppError("joinUserToTeam", "app.team.join_user_to_team.max_accounts.app_error", nil, "teamId="+tm.TeamId, http.StatusBadRequest)
 	}
 
-	member, err := a.Srv().Store.Team().UpdateMember(tm)
-	if err != nil {
-		return nil, false, err
+	member, nErr := a.Srv().Store.Team().UpdateMember(tm)
+	if nErr != nil {
+		var appErr *model.AppError
+		switch {
+		case errors.As(nErr, &appErr):
+			return nil, false, appErr
+		default:
+			return nil, false, model.NewAppError("joinUserToTeam", "app.team.save_member.save.app_error", nil, nErr.Error(), http.StatusInternalServerError)
+		}
 	}
 
 	return member, false, nil
@@ -955,23 +978,54 @@ func (a *App) GetTeamsForUser(userId string) ([]*model.Team, *model.AppError) {
 }
 
 func (a *App) GetTeamMember(teamId, userId string) (*model.TeamMember, *model.AppError) {
-	return a.Srv().Store.Team().GetMember(teamId, userId)
+	teamMember, err := a.Srv().Store.Team().GetMember(teamId, userId)
+	if err != nil {
+		var nfErr *store.ErrNotFound
+		switch {
+		case errors.As(err, &nfErr):
+			return nil, model.NewAppError("GetTeamMember", "app.team.get_member.missing.app_error", nil, nfErr.Error(), http.StatusNotFound)
+		default:
+			return nil, model.NewAppError("GetTeamMember", "app.team.get_member.app_error", nil, err.Error(), http.StatusInternalServerError)
+		}
+	}
+
+	return teamMember, nil
 }
 
 func (a *App) GetTeamMembersForUser(userId string) ([]*model.TeamMember, *model.AppError) {
-	return a.Srv().Store.Team().GetTeamsForUser(userId)
+	teamMembers, err := a.Srv().Store.Team().GetTeamsForUser(userId)
+	if err != nil {
+		return nil, model.NewAppError("GetTeamMembersForUser", "app.team.get_members.app_error", nil, err.Error(), http.StatusInternalServerError)
+	}
+
+	return teamMembers, nil
 }
 
 func (a *App) GetTeamMembersForUserWithPagination(userId string, page, perPage int) ([]*model.TeamMember, *model.AppError) {
-	return a.Srv().Store.Team().GetTeamsForUserWithPagination(userId, page, perPage)
+	teamMembers, err := a.Srv().Store.Team().GetTeamsForUserWithPagination(userId, page, perPage)
+	if err != nil {
+		return nil, model.NewAppError("GetTeamMembersForUserWithPagination", "app.team.get_members.app_error", nil, err.Error(), http.StatusInternalServerError)
+	}
+
+	return teamMembers, nil
 }
 
 func (a *App) GetTeamMembers(teamId string, offset int, limit int, teamMembersGetOptions *model.TeamMembersGetOptions) ([]*model.TeamMember, *model.AppError) {
-	return a.Srv().Store.Team().GetMembers(teamId, offset, limit, teamMembersGetOptions)
+	teamMembers, err := a.Srv().Store.Team().GetMembers(teamId, offset, limit, teamMembersGetOptions)
+	if err != nil {
+		return nil, model.NewAppError("GetTeamMembers", "app.team.get_members.app_error", nil, err.Error(), http.StatusInternalServerError)
+	}
+
+	return teamMembers, nil
 }
 
 func (a *App) GetTeamMembersByIds(teamId string, userIds []string, restrictions *model.ViewUsersRestrictions) ([]*model.TeamMember, *model.AppError) {
-	return a.Srv().Store.Team().GetMembersByIds(teamId, userIds, restrictions)
+	teamMembers, err := a.Srv().Store.Team().GetMembersByIds(teamId, userIds, restrictions)
+	if err != nil {
+		return nil, model.NewAppError("GetTeamMembersByIds", "app.team.get_members_by_ids.app_error", nil, err.Error(), http.StatusInternalServerError)
+	}
+
+	return teamMembers, nil
 }
 
 func (a *App) AddTeamMember(teamId, userId string) (*model.TeamMember, *model.AppError) {
@@ -1059,7 +1113,7 @@ func (a *App) AddTeamMemberByInviteId(inviteId, userId string) (*model.TeamMembe
 func (a *App) GetTeamUnread(teamId, userId string) (*model.TeamUnread, *model.AppError) {
 	channelUnreads, err := a.Srv().Store.Team().GetChannelUnreadsForTeam(teamId, userId)
 	if err != nil {
-		return nil, err
+		return nil, model.NewAppError("GetTeamUnread", "app.team.get_unread.app_error", nil, err.Error(), http.StatusInternalServerError)
 	}
 
 	var teamUnread = &model.TeamUnread{
@@ -1134,8 +1188,14 @@ func (a *App) RemoveTeamMemberFromTeam(teamMember *model.TeamMember, requestorId
 	teamMember.Roles = ""
 	teamMember.DeleteAt = model.GetMillis()
 
-	if _, err := a.Srv().Store.Team().UpdateMember(teamMember); err != nil {
-		return err
+	if _, nErr := a.Srv().Store.Team().UpdateMember(teamMember); nErr != nil {
+		var appErr *model.AppError
+		switch {
+		case errors.As(nErr, &appErr):
+			return appErr
+		default:
+			return model.NewAppError("RemoveTeamMemberFromTeam", "app.team.save_member.save.app_error", nil, nErr.Error(), http.StatusInternalServerError)
+		}
 	}
 
 	if pluginsEnvironment := a.GetPluginsEnvironment(); pluginsEnvironment != nil {
@@ -1561,8 +1621,9 @@ func (a *App) FindTeamByName(name string) bool {
 func (a *App) GetTeamsUnreadForUser(excludeTeamId string, userId string) ([]*model.TeamUnread, *model.AppError) {
 	data, err := a.Srv().Store.Team().GetChannelUnreadsForAllTeams(excludeTeamId, userId)
 	if err != nil {
-		return nil, err
+		return nil, model.NewAppError("GetTeamsUnreadForUser", "app.team.get_unread.app_error", nil, err.Error(), http.StatusInternalServerError)
 	}
+
 	members := []*model.TeamUnread{}
 	membersMap := make(map[string]*model.TeamUnread)
 
@@ -1632,7 +1693,7 @@ func (a *App) PermanentDeleteTeam(team *model.Team) *model.AppError {
 	}
 
 	if err := a.Srv().Store.Team().RemoveAllMembersByTeam(team.Id); err != nil {
-		return err
+		return model.NewAppError("PermanentDeleteTeam", "app.team.remove_member.app_error", nil, err.Error(), http.StatusInternalServerError)
 	}
 
 	if err := a.Srv().Store.Command().PermanentDeleteByTeam(team.Id); err != nil {
@@ -1703,13 +1764,13 @@ func (a *App) GetTeamStats(teamId string, restrictions *model.ViewUsersRestricti
 	tchan := make(chan store.StoreResult, 1)
 	go func() {
 		totalMemberCount, err := a.Srv().Store.Team().GetTotalMemberCount(teamId, restrictions)
-		tchan <- store.StoreResult{Data: totalMemberCount, Err: err}
+		tchan <- store.StoreResult{Data: totalMemberCount, NErr: err}
 		close(tchan)
 	}()
 	achan := make(chan store.StoreResult, 1)
 	go func() {
 		memberCount, err := a.Srv().Store.Team().GetActiveMemberCount(teamId, restrictions)
-		achan <- store.StoreResult{Data: memberCount, Err: err}
+		achan <- store.StoreResult{Data: memberCount, NErr: err}
 		close(achan)
 	}()
 
@@ -1717,14 +1778,14 @@ func (a *App) GetTeamStats(teamId string, restrictions *model.ViewUsersRestricti
 	stats.TeamId = teamId
 
 	result := <-tchan
-	if result.Err != nil {
-		return nil, result.Err
+	if result.NErr != nil {
+		return nil, model.NewAppError("GetTeamStats", "app.team.get_member_count.app_error", nil, result.NErr.Error(), http.StatusInternalServerError)
 	}
 	stats.TotalMemberCount = result.Data.(int64)
 
 	result = <-achan
-	if result.Err != nil {
-		return nil, result.Err
+	if result.NErr != nil {
+		return nil, model.NewAppError("GetTeamStats", "app.team.get_active_member_count.app_error", nil, result.NErr.Error(), http.StatusInternalServerError)
 	}
 	stats.ActiveMemberCount = result.Data.(int64)
 

i18n/en.json

@@ -4810,6 +4810,10 @@
     "id": "app.team.get.finding.app_error",
     "translation": "We encountered an error finding the team."
   },
+  {
+    "id": "app.team.get_active_member_count.app_error",
+    "translation": "Unable to count the team members."
+  },
   {
     "id": "app.team.get_all.app_error",
     "translation": "We could not get all teams."
@@ -4842,10 +4846,30 @@
     "id": "app.team.get_by_scheme.app_error",
     "translation": "Unable to get the channels for the provided scheme."
   },
+  {
+    "id": "app.team.get_member.app_error",
+    "translation": "Unable to get the team member."
+  },
+  {
+    "id": "app.team.get_member.missing.app_error",
+    "translation": "No team member found for that user ID and team ID."
+  },
+  {
+    "id": "app.team.get_member_count.app_error",
+    "translation": "Unable to count the team members."
+  },
   {
     "id": "app.team.get_members.app_error",
     "translation": "Unable to get the team members."
   },
+  {
+    "id": "app.team.get_members_by_ids.app_error",
+    "translation": "Unable to get the team members."
+  },
+  {
+    "id": "app.team.get_unread.app_error",
+    "translation": "Unable to get the teams unread messages."
+  },
   {
     "id": "app.team.get_user_team_ids.app_error",
     "translation": "Unable to get the list of teams of a user."
@@ -4906,6 +4930,10 @@
     "id": "app.team.save.existing.app_error",
     "translation": "Must call update for existing team."
   },
+  {
+    "id": "app.team.save_member.save.app_error",
+    "translation": "Unable to save the team member."
+  },
   {
     "id": "app.team.search_all_team.app_error",
     "translation": "We encountered an error searching teams."
@@ -7670,38 +7698,10 @@
     "id": "store.sql_post.search.disabled",
     "translation": "Searching has been disabled on this server. Please contact your System Administrator."
   },
-  {
-    "id": "store.sql_team.get_active_member_count.app_error",
-    "translation": "Unable to count the team members."
-  },
-  {
-    "id": "store.sql_team.get_member.app_error",
-    "translation": "Unable to get the team member."
-  },
-  {
-    "id": "store.sql_team.get_member.missing.app_error",
-    "translation": "No team member found for that user ID and team ID."
-  },
-  {
-    "id": "store.sql_team.get_member_count.app_error",
-    "translation": "Unable to count the team members."
-  },
-  {
-    "id": "store.sql_team.get_members_by_ids.app_error",
-    "translation": "Unable to get the team members."
-  },
-  {
-    "id": "store.sql_team.get_unread.app_error",
-    "translation": "Unable to get the teams unread messages."
-  },
   {
     "id": "store.sql_team.save_member.exists.app_error",
     "translation": "A team member with that ID already exists."
   },
-  {
-    "id": "store.sql_team.save_member.save.app_error",
-    "translation": "Unable to save the team member."
-  },
   {
     "id": "store.sql_user.analytics_daily_active_users.app_error",
     "translation": "Unable to get the active users during the requested period."
@@ -7874,10 +7874,6 @@
     "id": "store.sql_user.save.existing.app_error",
     "translation": "Must call update for existing user."
   },
-  {
-    "id": "store.sql_user.save.member_count.app_error",
-    "translation": "Failed to get current team member count."
-  },
   {
     "id": "store.sql_user.save.username_exists.app_error",
     "translation": "An account with that username already exists."

store/opentracinglayer/opentracinglayer.go

@@ -6607,7 +6607,7 @@ func (s *OpenTracingLayerTeamStore) Get(id string) (*model.Team, error) {
 	return result, err
 }
 
-func (s *OpenTracingLayerTeamStore) GetActiveMemberCount(teamId string, restrictions *model.ViewUsersRestrictions) (int64, *model.AppError) {
+func (s *OpenTracingLayerTeamStore) GetActiveMemberCount(teamId string, restrictions *model.ViewUsersRestrictions) (int64, error) {
 	origCtx := s.Root.Store.Context()
 	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "TeamStore.GetActiveMemberCount")
 	s.Root.Store.SetContext(newCtx)
@@ -6823,7 +6823,7 @@ func (s *OpenTracingLayerTeamStore) GetByNames(name []string) ([]*model.Team, er
 	return result, err
 }
 
-func (s *OpenTracingLayerTeamStore) GetChannelUnreadsForAllTeams(excludeTeamId string, userId string) ([]*model.ChannelUnread, *model.AppError) {
+func (s *OpenTracingLayerTeamStore) GetChannelUnreadsForAllTeams(excludeTeamId string, userId string) ([]*model.ChannelUnread, error) {
 	origCtx := s.Root.Store.Context()
 	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "TeamStore.GetChannelUnreadsForAllTeams")
 	s.Root.Store.SetContext(newCtx)
@@ -6841,7 +6841,7 @@ func (s *OpenTracingLayerTeamStore) GetChannelUnreadsForAllTeams(excludeTeamId s
 	return result, err
 }
 
-func (s *OpenTracingLayerTeamStore) GetChannelUnreadsForTeam(teamId string, userId string) ([]*model.ChannelUnread, *model.AppError) {
+func (s *OpenTracingLayerTeamStore) GetChannelUnreadsForTeam(teamId string, userId string) ([]*model.ChannelUnread, error) {
 	origCtx := s.Root.Store.Context()
 	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "TeamStore.GetChannelUnreadsForTeam")
 	s.Root.Store.SetContext(newCtx)
@@ -6859,7 +6859,7 @@ func (s *OpenTracingLayerTeamStore) GetChannelUnreadsForTeam(teamId string, user
 	return result, err
 }
 
-func (s *OpenTracingLayerTeamStore) GetMember(teamId string, userId string) (*model.TeamMember, *model.AppError) {
+func (s *OpenTracingLayerTeamStore) GetMember(teamId string, userId string) (*model.TeamMember, error) {
 	origCtx := s.Root.Store.Context()
 	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "TeamStore.GetMember")
 	s.Root.Store.SetContext(newCtx)
@@ -6877,7 +6877,7 @@ func (s *OpenTracingLayerTeamStore) GetMember(teamId string, userId string) (*mo
 	return result, err
 }
 
-func (s *OpenTracingLayerTeamStore) GetMembers(teamId string, offset int, limit int, teamMembersGetOptions *model.TeamMembersGetOptions) ([]*model.TeamMember, *model.AppError) {
+func (s *OpenTracingLayerTeamStore) GetMembers(teamId string, offset int, limit int, teamMembersGetOptions *model.TeamMembersGetOptions) ([]*model.TeamMember, error) {
 	origCtx := s.Root.Store.Context()
 	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "TeamStore.GetMembers")
 	s.Root.Store.SetContext(newCtx)
@@ -6895,7 +6895,7 @@ func (s *OpenTracingLayerTeamStore) GetMembers(teamId string, offset int, limit
 	return result, err
 }
 
-func (s *OpenTracingLayerTeamStore) GetMembersByIds(teamId string, userIds []string, restrictions *model.ViewUsersRestrictions) ([]*model.TeamMember, *model.AppError) {
+func (s *OpenTracingLayerTeamStore) GetMembersByIds(teamId string, userIds []string, restrictions *model.ViewUsersRestrictions) ([]*model.TeamMember, error) {
 	origCtx := s.Root.Store.Context()
 	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "TeamStore.GetMembersByIds")
 	s.Root.Store.SetContext(newCtx)
@@ -6967,7 +6967,7 @@ func (s *OpenTracingLayerTeamStore) GetTeamsByUserId(userId string) ([]*model.Te
 	return result, err
 }
 
-func (s *OpenTracingLayerTeamStore) GetTeamsForUser(userId string) ([]*model.TeamMember, *model.AppError) {
+func (s *OpenTracingLayerTeamStore) GetTeamsForUser(userId string) ([]*model.TeamMember, error) {
 	origCtx := s.Root.Store.Context()
 	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "TeamStore.GetTeamsForUser")
 	s.Root.Store.SetContext(newCtx)
@@ -6985,7 +6985,7 @@ func (s *OpenTracingLayerTeamStore) GetTeamsForUser(userId string) ([]*model.Tea
 	return result, err
 }
 
-func (s *OpenTracingLayerTeamStore) GetTeamsForUserWithPagination(userId string, page int, perPage int) ([]*model.TeamMember, *model.AppError) {
+func (s *OpenTracingLayerTeamStore) GetTeamsForUserWithPagination(userId string, page int, perPage int) ([]*model.TeamMember, error) {
 	origCtx := s.Root.Store.Context()
 	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "TeamStore.GetTeamsForUserWithPagination")
 	s.Root.Store.SetContext(newCtx)
@@ -7003,7 +7003,7 @@ func (s *OpenTracingLayerTeamStore) GetTeamsForUserWithPagination(userId string,
 	return result, err
 }
 
-func (s *OpenTracingLayerTeamStore) GetTotalMemberCount(teamId string, restrictions *model.ViewUsersRestrictions) (int64, *model.AppError) {
+func (s *OpenTracingLayerTeamStore) GetTotalMemberCount(teamId string, restrictions *model.ViewUsersRestrictions) (int64, error) {
 	origCtx := s.Root.Store.Context()
 	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "TeamStore.GetTotalMemberCount")
 	s.Root.Store.SetContext(newCtx)
@@ -7106,7 +7106,7 @@ func (s *OpenTracingLayerTeamStore) PermanentDelete(teamId string) error {
 	return err
 }
 
-func (s *OpenTracingLayerTeamStore) RemoveAllMembersByTeam(teamId string) *model.AppError {
+func (s *OpenTracingLayerTeamStore) RemoveAllMembersByTeam(teamId string) error {
 	origCtx := s.Root.Store.Context()
 	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "TeamStore.RemoveAllMembersByTeam")
 	s.Root.Store.SetContext(newCtx)
@@ -7142,7 +7142,7 @@ func (s *OpenTracingLayerTeamStore) RemoveAllMembersByUser(userId string) error
 	return err
 }
 
-func (s *OpenTracingLayerTeamStore) RemoveMember(teamId string, userId string) *model.AppError {
+func (s *OpenTracingLayerTeamStore) RemoveMember(teamId string, userId string) error {
 	origCtx := s.Root.Store.Context()
 	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "TeamStore.RemoveMember")
 	s.Root.Store.SetContext(newCtx)
@@ -7160,7 +7160,7 @@ func (s *OpenTracingLayerTeamStore) RemoveMember(teamId string, userId string) *
 	return err
 }
 
-func (s *OpenTracingLayerTeamStore) RemoveMembers(teamId string, userIds []string) *model.AppError {
+func (s *OpenTracingLayerTeamStore) RemoveMembers(teamId string, userIds []string) error {
 	origCtx := s.Root.Store.Context()
 	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "TeamStore.RemoveMembers")
 	s.Root.Store.SetContext(newCtx)
@@ -7358,7 +7358,7 @@ func (s *OpenTracingLayerTeamStore) UpdateLastTeamIconUpdate(teamId string, curT
 	return err
 }
 
-func (s *OpenTracingLayerTeamStore) UpdateMember(member *model.TeamMember) (*model.TeamMember, *model.AppError) {
+func (s *OpenTracingLayerTeamStore) UpdateMember(member *model.TeamMember) (*model.TeamMember, error) {
 	origCtx := s.Root.Store.Context()
 	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "TeamStore.UpdateMember")
 	s.Root.Store.SetContext(newCtx)
@@ -7394,7 +7394,7 @@ func (s *OpenTracingLayerTeamStore) UpdateMembersRole(teamID string, userIDs []s
 	return err
 }
 
-func (s *OpenTracingLayerTeamStore) UpdateMultipleMembers(members []*model.TeamMember) ([]*model.TeamMember, *model.AppError) {
+func (s *OpenTracingLayerTeamStore) UpdateMultipleMembers(members []*model.TeamMember) ([]*model.TeamMember, error) {
 	origCtx := s.Root.Store.Context()
 	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "TeamStore.UpdateMultipleMembers")
 	s.Root.Store.SetContext(newCtx)

store/retrylayer/retrylayer.go

@@ -5878,9 +5878,23 @@ func (s *RetryLayerTeamStore) Get(id string) (*model.Team, error) {
 
 }
 
-func (s *RetryLayerTeamStore) GetActiveMemberCount(teamId string, restrictions *model.ViewUsersRestrictions) (int64, *model.AppError) {
+func (s *RetryLayerTeamStore) GetActiveMemberCount(teamId string, restrictions *model.ViewUsersRestrictions) (int64, error) {
 
-	return s.TeamStore.GetActiveMemberCount(teamId, restrictions)
+	tries := 0
+	for {
+		result, err := s.TeamStore.GetActiveMemberCount(teamId, restrictions)
+		if err == nil {
+			return result, nil
+		}
+		if !isRepeatableError(err) {
+			return result, err
+		}
+		tries++
+		if tries >= 3 {
+			err = errors.Wrap(err, "giving up after 3 consecutive repeatable transaction failures")
+			return result, err
+		}
+	}
 
 }
 
@@ -6104,33 +6118,103 @@ func (s *RetryLayerTeamStore) GetByNames(name []string) ([]*model.Team, error) {
 
 }
 
-func (s *RetryLayerTeamStore) GetChannelUnreadsForAllTeams(excludeTeamId string, userId string) ([]*model.ChannelUnread, *model.AppError) {
+func (s *RetryLayerTeamStore) GetChannelUnreadsForAllTeams(excludeTeamId string, userId string) ([]*model.ChannelUnread, error) {
 
-	return s.TeamStore.GetChannelUnreadsForAllTeams(excludeTeamId, userId)
+	tries := 0
+	for {
+		result, err := s.TeamStore.GetChannelUnreadsForAllTeams(excludeTeamId, userId)
+		if err == nil {
+			return result, nil
+		}
+		if !isRepeatableError(err) {
+			return result, err
+		}
+		tries++
+		if tries >= 3 {
+			err = errors.Wrap(err, "giving up after 3 consecutive repeatable transaction failures")
+			return result, err
+		}
+	}
 
 }
 
-func (s *RetryLayerTeamStore) GetChannelUnreadsForTeam(teamId string, userId string) ([]*model.ChannelUnread, *model.AppError) {
+func (s *RetryLayerTeamStore) GetChannelUnreadsForTeam(teamId string, userId string) ([]*model.ChannelUnread, error) {
 
-	return s.TeamStore.GetChannelUnreadsForTeam(teamId, userId)
+	tries := 0
+	for {
+		result, err := s.TeamStore.GetChannelUnreadsForTeam(teamId, userId)
+		if err == nil {
+			return result, nil
+		}
+		if !isRepeatableError(err) {
+			return result, err
+		}
+		tries++
+		if tries >= 3 {
+			err = errors.Wrap(err, "giving up after 3 consecutive repeatable transaction failures")
+			return result, err
+		}
+	}
 
 }
 
-func (s *RetryLayerTeamStore) GetMember(teamId string, userId string) (*model.TeamMember, *model.AppError) {
+func (s *RetryLayerTeamStore) GetMember(teamId string, userId string) (*model.TeamMember, error) {
 
-	return s.TeamStore.GetMember(teamId, userId)
+	tries := 0
+	for {
+		result, err := s.TeamStore.GetMember(teamId, userId)
+		if err == nil {
+			return result, nil
+		}
+		if !isRepeatableError(err) {
+			return result, err
+		}
+		tries++
+		if tries >= 3 {
+			err = errors.Wrap(err, "giving up after 3 consecutive repeatable transaction failures")
+			return result, err
+		}
+	}
 
 }
 
-func (s *RetryLayerTeamStore) GetMembers(teamId string, offset int, limit int, teamMembersGetOptions *model.TeamMembersGetOptions) ([]*model.TeamMember, *model.AppError) {
+func (s *RetryLayerTeamStore) GetMembers(teamId string, offset int, limit int, teamMembersGetOptions *model.TeamMembersGetOptions) ([]*model.TeamMember, error) {
 
-	return s.TeamStore.GetMembers(teamId, offset, limit, teamMembersGetOptions)
+	tries := 0
+	for {
+		result, err := s.TeamStore.GetMembers(teamId, offset, limit, teamMembersGetOptions)
+		if err == nil {
+			return result, nil
+		}
+		if !isRepeatableError(err) {
+			return result, err
+		}
+		tries++
+		if tries >= 3 {
+			err = errors.Wrap(err, "giving up after 3 consecutive repeatable transaction failures")
+			return result, err
+		}
+	}
 
 }
 
-func (s *RetryLayerTeamStore) GetMembersByIds(teamId string, userIds []string, restrictions *model.ViewUsersRestrictions) ([]*model.TeamMember, *model.AppError) {
+func (s *RetryLayerTeamStore) GetMembersByIds(teamId string, userIds []string, restrictions *model.ViewUsersRestrictions) ([]*model.TeamMember, error) {
 
-	return s.TeamStore.GetMembersByIds(teamId, userIds, restrictions)
+	tries := 0
+	for {
+		result, err := s.TeamStore.GetMembersByIds(teamId, userIds, restrictions)
+		if err == nil {
+			return result, nil
+		}
+		if !isRepeatableError(err) {
+			return result, err
+		}
+		tries++
+		if tries >= 3 {
+			err = errors.Wrap(err, "giving up after 3 consecutive repeatable transaction failures")
+			return result, err
+		}
+	}
 
 }
 
@@ -6194,21 +6278,63 @@ func (s *RetryLayerTeamStore) GetTeamsByUserId(userId string) ([]*model.Team, er
 
 }
 
-func (s *RetryLayerTeamStore) GetTeamsForUser(userId string) ([]*model.TeamMember, *model.AppError) {
+func (s *RetryLayerTeamStore) GetTeamsForUser(userId string) ([]*model.TeamMember, error) {
 
-	return s.TeamStore.GetTeamsForUser(userId)
+	tries := 0
+	for {
+		result, err := s.TeamStore.GetTeamsForUser(userId)
+		if err == nil {
+			return result, nil
+		}
+		if !isRepeatableError(err) {
+			return result, err
+		}
+		tries++
+		if tries >= 3 {
+			err = errors.Wrap(err, "giving up after 3 consecutive repeatable transaction failures")
+			return result, err
+		}
+	}
 
 }
 
-func (s *RetryLayerTeamStore) GetTeamsForUserWithPagination(userId string, page int, perPage int) ([]*model.TeamMember, *model.AppError) {
+func (s *RetryLayerTeamStore) GetTeamsForUserWithPagination(userId string, page int, perPage int) ([]*model.TeamMember, error) {
 
-	return s.TeamStore.GetTeamsForUserWithPagination(userId, page, perPage)
+	tries := 0
+	for {
+		result, err := s.TeamStore.GetTeamsForUserWithPagination(userId, page, perPage)
+		if err == nil {
+			return result, nil
+		}
+		if !isRepeatableError(err) {
+			return result, err
+		}
+		tries++
+		if tries >= 3 {
+			err = errors.Wrap(err, "giving up after 3 consecutive repeatable transaction failures")
+			return result, err
+		}
+	}
 
 }
 
-func (s *RetryLayerTeamStore) GetTotalMemberCount(teamId string, restrictions *model.ViewUsersRestrictions) (int64, *model.AppError) {
+func (s *RetryLayerTeamStore) GetTotalMemberCount(teamId string, restrictions *model.ViewUsersRestrictions) (int64, error) {
 
-	return s.TeamStore.GetTotalMemberCount(teamId, restrictions)
+	tries := 0
+	for {
+		result, err := s.TeamStore.GetTotalMemberCount(teamId, restrictions)
+		if err == nil {
+			return result, nil
+		}
+		if !isRepeatableError(err) {
+			return result, err
+		}
+		tries++
+		if tries >= 3 {
+			err = errors.Wrap(err, "giving up after 3 consecutive repeatable transaction failures")
+			return result, err
+		}
+	}
 
 }
 
@@ -6298,9 +6424,23 @@ func (s *RetryLayerTeamStore) PermanentDelete(teamId string) error {
 
 }
 
-func (s *RetryLayerTeamStore) RemoveAllMembersByTeam(teamId string) *model.AppError {
+func (s *RetryLayerTeamStore) RemoveAllMembersByTeam(teamId string) error {
 
-	return s.TeamStore.RemoveAllMembersByTeam(teamId)
+	tries := 0
+	for {
+		err := s.TeamStore.RemoveAllMembersByTeam(teamId)
+		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
+		}
+	}
 
 }
 
@@ -6324,15 +6464,43 @@ func (s *RetryLayerTeamStore) RemoveAllMembersByUser(userId string) error {
 
 }
 
-func (s *RetryLayerTeamStore) RemoveMember(teamId string, userId string) *model.AppError {
+func (s *RetryLayerTeamStore) RemoveMember(teamId string, userId string) error {
 
-	return s.TeamStore.RemoveMember(teamId, userId)
+	tries := 0
+	for {
+		err := s.TeamStore.RemoveMember(teamId, userId)
+		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
+		}
+	}
 
 }
 
-func (s *RetryLayerTeamStore) RemoveMembers(teamId string, userIds []string) *model.AppError {
+func (s *RetryLayerTeamStore) RemoveMembers(teamId string, userIds []string) error {
 
-	return s.TeamStore.RemoveMembers(teamId, userIds)
+	tries := 0
+	for {
+		err := s.TeamStore.RemoveMembers(teamId, userIds)
+		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
+		}
+	}
 
 }
 
@@ -6536,9 +6704,23 @@ func (s *RetryLayerTeamStore) UpdateLastTeamIconUpdate(teamId string, curTime in
 
 }
 
-func (s *RetryLayerTeamStore) UpdateMember(member *model.TeamMember) (*model.TeamMember, *model.AppError) {
+func (s *RetryLayerTeamStore) UpdateMember(member *model.TeamMember) (*model.TeamMember, error) {
 
-	return s.TeamStore.UpdateMember(member)
+	tries := 0
+	for {
+		result, err := s.TeamStore.UpdateMember(member)
+		if err == nil {
+			return result, nil
+		}
+		if !isRepeatableError(err) {
+			return result, err
+		}
+		tries++
+		if tries >= 3 {
+			err = errors.Wrap(err, "giving up after 3 consecutive repeatable transaction failures")
+			return result, err
+		}
+	}
 
 }
 
@@ -6562,9 +6744,23 @@ func (s *RetryLayerTeamStore) UpdateMembersRole(teamID string, userIDs []string)
 
 }
 
-func (s *RetryLayerTeamStore) UpdateMultipleMembers(members []*model.TeamMember) ([]*model.TeamMember, *model.AppError) {
+func (s *RetryLayerTeamStore) UpdateMultipleMembers(members []*model.TeamMember) ([]*model.TeamMember, error) {
 
-	return s.TeamStore.UpdateMultipleMembers(members)
+	tries := 0
+	for {
+		result, err := s.TeamStore.UpdateMultipleMembers(members)
+		if err == nil {
+			return result, nil
+		}
+		if !isRepeatableError(err) {
+			return result, err
+		}
+		tries++
+		if tries >= 3 {
+			err = errors.Wrap(err, "giving up after 3 consecutive repeatable transaction failures")
+			return result, err
+		}
+	}
 
 }
 

store/searchlayer/team_layer.go

@@ -21,7 +21,7 @@ func (s SearchTeamStore) SaveMember(teamMember *model.TeamMember, maxUsersPerTea
 	return member, err
 }
 
-func (s SearchTeamStore) UpdateMember(teamMember *model.TeamMember) (*model.TeamMember, *model.AppError) {
+func (s SearchTeamStore) UpdateMember(teamMember *model.TeamMember) (*model.TeamMember, error) {
 	member, err := s.TeamStore.UpdateMember(teamMember)
 	if err == nil {
 		s.rootStore.indexUserFromID(member.UserId)
@@ -29,7 +29,7 @@ func (s SearchTeamStore) UpdateMember(teamMember *model.TeamMember) (*model.Team
 	return member, err
 }
 
-func (s SearchTeamStore) RemoveMember(teamId string, userId string) *model.AppError {
+func (s SearchTeamStore) RemoveMember(teamId string, userId string) error {
 	err := s.TeamStore.RemoveMember(teamId, userId)
 	if err == nil {
 		s.rootStore.indexUserFromID(userId)

store/sqlstore/team_store.go

@@ -6,12 +6,10 @@ package sqlstore
 import (
 	"database/sql"
 	"fmt"
-	"net/http"
 	"strings"
 
-	"github.com/pkg/errors"
-
 	sq "github.com/Masterminds/squirrel"
+	"github.com/pkg/errors"
 
 	"github.com/mattermost/gorp"
 	"github.com/mattermost/mattermost-server/v5/model"
@@ -924,7 +922,7 @@ func (s SqlTeamStore) SaveMember(member *model.TeamMember, maxUsersPerTeam int)
 	return members[0], nil
 }
 
-func (s SqlTeamStore) UpdateMultipleMembers(members []*model.TeamMember) ([]*model.TeamMember, *model.AppError) {
+func (s SqlTeamStore) UpdateMultipleMembers(members []*model.TeamMember) ([]*model.TeamMember, error) {
 	teams := []string{}
 	for _, member := range members {
 		member.PreUpdate()
@@ -934,7 +932,7 @@ func (s SqlTeamStore) UpdateMultipleMembers(members []*model.TeamMember) ([]*mod
 		}
 
 		if _, err := s.GetMaster().Update(NewTeamMemberFromModel(member)); err != nil {
-			return nil, model.NewAppError("SqlTeamStore.UpdateMember", "store.sql_team.save_member.save.app_error", nil, err.Error(), http.StatusInternalServerError)
+			return nil, errors.Wrap(err, "failed to update TeamMember")
 		}
 		teams = append(teams, member.TeamId)
 	}
@@ -952,7 +950,7 @@ func (s SqlTeamStore) UpdateMultipleMembers(members []*model.TeamMember) ([]*mod
 
 	sqlQuery, args, err := query.ToSql()
 	if err != nil {
-		return nil, model.NewAppError("SqlUserStore.Save", "store.sql.build_query.app_error", nil, err.Error(), http.StatusInternalServerError)
+		return nil, errors.Wrap(err, "team_tosql")
 	}
 	var defaultTeamsRoles []struct {
 		Id    string
@@ -962,7 +960,7 @@ func (s SqlTeamStore) UpdateMultipleMembers(members []*model.TeamMember) ([]*mod
 	}
 	_, err = s.GetMaster().Select(&defaultTeamsRoles, sqlQuery, args...)
 	if err != nil {
-		return nil, model.NewAppError("SqlUserStore.Save", "store.sql_user.save.member_count.app_error", nil, err.Error(), http.StatusInternalServerError)
+		return nil, errors.Wrap(err, "failed to find Teams")
 	}
 
 	defaultTeamRolesByTeam := map[string]struct {
@@ -994,7 +992,7 @@ func (s SqlTeamStore) UpdateMultipleMembers(members []*model.TeamMember) ([]*mod
 	return updatedMembers, nil
 }
 
-func (s SqlTeamStore) UpdateMember(member *model.TeamMember) (*model.TeamMember, *model.AppError) {
+func (s SqlTeamStore) UpdateMember(member *model.TeamMember) (*model.TeamMember, error) {
 	members, err := s.UpdateMultipleMembers([]*model.TeamMember{member})
 	if err != nil {
 		return nil, err
@@ -1002,29 +1000,29 @@ func (s SqlTeamStore) UpdateMember(member *model.TeamMember) (*model.TeamMember,
 	return members[0], nil
 }
 
-func (s SqlTeamStore) GetMember(teamId string, userId string) (*model.TeamMember, *model.AppError) {
+func (s SqlTeamStore) GetMember(teamId string, userId string) (*model.TeamMember, error) {
 	query := s.getTeamMembersWithSchemeSelectQuery().
 		Where(sq.Eq{"TeamMembers.TeamId": teamId}).
 		Where(sq.Eq{"TeamMembers.UserId": userId})
 
 	queryString, args, err := query.ToSql()
 	if err != nil {
-		return nil, model.NewAppError("SqlTeamStore.GetMember", "store.sql.build_query.app_error", nil, err.Error(), http.StatusInternalServerError)
+		return nil, errors.Wrap(err, "team_tosql")
 	}
 
 	var dbMember teamMemberWithSchemeRoles
 	err = s.GetReplica().SelectOne(&dbMember, queryString, args...)
 	if err != nil {
 		if err == sql.ErrNoRows {
-			return nil, model.NewAppError("SqlTeamStore.GetMember", "store.sql_team.get_member.missing.app_error", nil, "teamId="+teamId+" userId="+userId+" "+err.Error(), http.StatusNotFound)
+			return nil, store.NewErrNotFound("TeamMember", fmt.Sprintf("teamId=%s, userId=%s", teamId, userId))
 		}
-		return nil, model.NewAppError("SqlTeamStore.GetMember", "store.sql_team.get_member.app_error", nil, "teamId="+teamId+" userId="+userId+" "+err.Error(), http.StatusInternalServerError)
+		return nil, errors.Wrapf(err, "failed to find TeamMembers with teamId=%s and userId=%s", teamId, userId)
 	}
 
 	return dbMember.ToModel(), nil
 }
 
-func (s SqlTeamStore) GetMembers(teamId string, offset int, limit int, teamMembersGetOptions *model.TeamMembersGetOptions) ([]*model.TeamMember, *model.AppError) {
+func (s SqlTeamStore) GetMembers(teamId string, offset int, limit int, teamMembersGetOptions *model.TeamMembersGetOptions) ([]*model.TeamMember, error) {
 	query := s.getTeamMembersWithSchemeSelectQuery().
 		Where(sq.Eq{"TeamMembers.TeamId": teamId}).
 		Where(sq.Eq{"TeamMembers.DeleteAt": 0}).
@@ -1053,19 +1051,19 @@ func (s SqlTeamStore) GetMembers(teamId string, offset int, limit int, teamMembe
 
 	queryString, args, err := query.ToSql()
 	if err != nil {
-		return nil, model.NewAppError("SqlTeamStore.GetMembers", "store.sql.build_query.app_error", nil, err.Error(), http.StatusInternalServerError)
+		return nil, errors.Wrap(err, "team_tosql")
 	}
 
 	var dbMembers teamMemberWithSchemeRolesList
 	_, err = s.GetReplica().Select(&dbMembers, queryString, args...)
 	if err != nil {
-		return nil, model.NewAppError("SqlTeamStore.GetMembers", "app.team.get_members.app_error", nil, "teamId="+teamId+" "+err.Error(), http.StatusInternalServerError)
+		return nil, errors.Wrapf(err, "failed to find TeamMembers with teamId=%s", teamId)
 	}
 
 	return dbMembers.ToModel(), nil
 }
 
-func (s SqlTeamStore) GetTotalMemberCount(teamId string, restrictions *model.ViewUsersRestrictions) (int64, *model.AppError) {
+func (s SqlTeamStore) GetTotalMemberCount(teamId string, restrictions *model.ViewUsersRestrictions) (int64, error) {
 	query := s.getQueryBuilder().
 		Select("count(DISTINCT TeamMembers.UserId)").
 		From("TeamMembers, Users").
@@ -1076,17 +1074,17 @@ func (s SqlTeamStore) GetTotalMemberCount(teamId string, restrictions *model.Vie
 	query = applyTeamMemberViewRestrictionsFilterForStats(query, teamId, restrictions)
 	queryString, args, err := query.ToSql()
 	if err != nil {
-		return int64(0), model.NewAppError("SqlTeamStore.GetTotalMemberCount", "store.sql.build_query.app_error", nil, err.Error(), http.StatusInternalServerError)
+		return int64(0), errors.Wrap(err, "team_tosql")
 	}
 
 	count, err := s.GetReplica().SelectInt(queryString, args...)
 	if err != nil {
-		return int64(0), model.NewAppError("SqlTeamStore.GetTotalMemberCount", "store.sql_team.get_member_count.app_error", nil, "teamId="+teamId+" "+err.Error(), http.StatusInternalServerError)
+		return int64(0), errors.Wrap(err, "failed to count TeamMembers")
 	}
 	return count, nil
 }
 
-func (s SqlTeamStore) GetActiveMemberCount(teamId string, restrictions *model.ViewUsersRestrictions) (int64, *model.AppError) {
+func (s SqlTeamStore) GetActiveMemberCount(teamId string, restrictions *model.ViewUsersRestrictions) (int64, error) {
 	query := s.getQueryBuilder().
 		Select("count(DISTINCT TeamMembers.UserId)").
 		From("TeamMembers, Users").
@@ -1098,20 +1096,20 @@ func (s SqlTeamStore) GetActiveMemberCount(teamId string, restrictions *model.Vi
 	query = applyTeamMemberViewRestrictionsFilterForStats(query, teamId, restrictions)
 	queryString, args, err := query.ToSql()
 	if err != nil {
-		return 0, model.NewAppError("SqlTeamStore.GetActiveMemberCount", "store.sql.build_query.app_error", nil, err.Error(), http.StatusInternalServerError)
+		return 0, errors.Wrap(err, "team_tosql")
 	}
 
 	count, err := s.GetReplica().SelectInt(queryString, args...)
 	if err != nil {
-		return 0, model.NewAppError("SqlTeamStore.GetActiveMemberCount", "store.sql_team.get_active_member_count.app_error", nil, "teamId="+teamId+" "+err.Error(), http.StatusInternalServerError)
+		return 0, errors.Wrap(err, "failed to count TeamMembers")
 	}
 
 	return count, nil
 }
 
-func (s SqlTeamStore) GetMembersByIds(teamId string, userIds []string, restrictions *model.ViewUsersRestrictions) ([]*model.TeamMember, *model.AppError) {
+func (s SqlTeamStore) GetMembersByIds(teamId string, userIds []string, restrictions *model.ViewUsersRestrictions) ([]*model.TeamMember, error) {
 	if len(userIds) == 0 {
-		return nil, model.NewAppError("SqlTeamStore.GetMembersByIds", "store.sql_team.get_members_by_ids.app_error", nil, "Invalid list of user ids", http.StatusInternalServerError)
+		return nil, errors.New("invalid list of user ids")
 	}
 
 	query := s.getTeamMembersWithSchemeSelectQuery().
@@ -1123,29 +1121,29 @@ func (s SqlTeamStore) GetMembersByIds(teamId string, userIds []string, restricti
 
 	queryString, args, err := query.ToSql()
 	if err != nil {
-		return nil, model.NewAppError("SqlTeamStore.GetMembersByIds", "store.sql.build_query.app_error", nil, err.Error(), http.StatusInternalServerError)
+		return nil, errors.Wrap(err, "team_tosql")
 	}
 
 	var dbMembers teamMemberWithSchemeRolesList
 	if _, err = s.GetReplica().Select(&dbMembers, queryString, args...); err != nil {
-		return nil, model.NewAppError("SqlTeamStore.GetMembersByIds", "store.sql_team.get_members_by_ids.app_error", nil, "teamId="+teamId+" "+err.Error(), http.StatusInternalServerError)
+		return nil, errors.Wrap(err, "failed to find TeamMembers")
 	}
 	return dbMembers.ToModel(), nil
 }
 
-func (s SqlTeamStore) GetTeamsForUser(userId string) ([]*model.TeamMember, *model.AppError) {
+func (s SqlTeamStore) GetTeamsForUser(userId string) ([]*model.TeamMember, error) {
 	query := s.getTeamMembersWithSchemeSelectQuery().
 		Where(sq.Eq{"TeamMembers.UserId": userId})
 
 	queryString, args, err := query.ToSql()
 	if err != nil {
-		return nil, model.NewAppError("SqlTeamStore.GetMembers", "store.sql.build_query.app_error", nil, err.Error(), http.StatusInternalServerError)
+		return nil, errors.Wrap(err, "team_tosql")
 	}
 
 	var dbMembers teamMemberWithSchemeRolesList
 	_, err = s.GetReplica().Select(&dbMembers, queryString, args...)
 	if err != nil {
-		return nil, model.NewAppError("SqlTeamStore.GetMembers", "app.team.get_members.app_error", nil, "userId="+userId+" "+err.Error(), http.StatusInternalServerError)
+		return nil, errors.Wrapf(err, "failed to find TeamMembers with userId=%s", userId)
 	}
 
 	return dbMembers.ToModel(), nil
@@ -1153,7 +1151,7 @@ func (s SqlTeamStore) GetTeamsForUser(userId string) ([]*model.TeamMember, *mode
 
 // GetTeamsForUserWithPagination returns limited TeamMembers according to the perPage parameter specified.
 // It also offsets the records as per the page parameter supplied.
-func (s SqlTeamStore) GetTeamsForUserWithPagination(userId string, page, perPage int) ([]*model.TeamMember, *model.AppError) {
+func (s SqlTeamStore) GetTeamsForUserWithPagination(userId string, page, perPage int) ([]*model.TeamMember, error) {
 	query := s.getTeamMembersWithSchemeSelectQuery().
 		Where(sq.Eq{"TeamMembers.UserId": userId}).
 		Limit(uint64(perPage)).
@@ -1161,13 +1159,13 @@ func (s SqlTeamStore) GetTeamsForUserWithPagination(userId string, page, perPage
 
 	queryString, args, err := query.ToSql()
 	if err != nil {
-		return nil, model.NewAppError("SqlTeamStore.GetTeamsForUserWithPagination", "store.sql.build_query.app_error", nil, err.Error(), http.StatusInternalServerError)
+		return nil, errors.Wrap(err, "team_tosql")
 	}
 
 	var dbMembers teamMemberWithSchemeRolesList
 	_, err = s.GetReplica().Select(&dbMembers, queryString, args...)
 	if err != nil {
-		return nil, model.NewAppError("SqlTeamStore.GetTeamsForUserWithPagination", "app.team.get_members.app_error", nil, "userId="+userId+" "+err.Error(), http.StatusInternalServerError)
+		return nil, errors.Wrapf(err, "failed to find TeamMembers with userId=%s", userId)
 	}
 
 	return dbMembers.ToModel(), nil
@@ -1175,7 +1173,7 @@ func (s SqlTeamStore) GetTeamsForUserWithPagination(userId string, page, perPage
 
 // GetChannelUnreadsForAllTeams returns unreads msg count, mention counts, and notifyProps
 // for all the channels in all the teams except the excluded ones.
-func (s SqlTeamStore) GetChannelUnreadsForAllTeams(excludeTeamId, userId string) ([]*model.ChannelUnread, *model.AppError) {
+func (s SqlTeamStore) GetChannelUnreadsForAllTeams(excludeTeamId, userId string) ([]*model.ChannelUnread, error) {
 	query, args, err := s.getQueryBuilder().
 		Select("Channels.TeamId TeamId", "Channels.Id ChannelId", "(Channels.TotalMsgCount - ChannelMembers.MsgCount) MsgCount", "ChannelMembers.MentionCount MentionCount", "ChannelMembers.NotifyProps NotifyProps").
 		From("Channels").
@@ -1184,20 +1182,20 @@ func (s SqlTeamStore) GetChannelUnreadsForAllTeams(excludeTeamId, userId string)
 		Where(sq.NotEq{"TeamId": excludeTeamId}).ToSql()
 
 	if err != nil {
-		return nil, model.NewAppError("SqlTeamStore.GetChannelUnreadsForAllTeams", "store.sql.build_query.app_error", nil, err.Error(), http.StatusInternalServerError)
+		return nil, errors.Wrap(err, "team_tosql")
 	}
 	var data []*model.ChannelUnread
 	_, err = s.GetReplica().Select(&data, query, args...)
 
 	if err != nil {
-		return nil, model.NewAppError("SqlTeamStore.GetChannelUnreadsForAllTeams", "store.sql_team.get_unread.app_error", nil, "userId="+userId+" "+err.Error(), http.StatusInternalServerError)
+		return nil, errors.Wrapf(err, "failed to find Channels with userId=%s and teamId!=%s", userId, excludeTeamId)
 	}
 
 	return data, nil
 }
 
 // GetChannelUnreadsForTeam returns unreads msg count, mention counts and notifyProps for all the channels in a single team.
-func (s SqlTeamStore) GetChannelUnreadsForTeam(teamId, userId string) ([]*model.ChannelUnread, *model.AppError) {
+func (s SqlTeamStore) GetChannelUnreadsForTeam(teamId, userId string) ([]*model.ChannelUnread, error) {
 	query, args, err := s.getQueryBuilder().
 		Select("Channels.TeamId TeamId", "Channels.Id ChannelId", "(Channels.TotalMsgCount - ChannelMembers.MsgCount) MsgCount", "ChannelMembers.MentionCount MentionCount", "ChannelMembers.NotifyProps NotifyProps").
 		From("Channels").
@@ -1205,52 +1203,52 @@ func (s SqlTeamStore) GetChannelUnreadsForTeam(teamId, userId string) ([]*model.
 		Where(sq.Eq{"UserId": userId, "TeamId": teamId, "DeleteAt": 0}).ToSql()
 
 	if err != nil {
-		return nil, model.NewAppError("SqlTeamStore.GetChannelUnreadsForTeam", "store.sql.build_query.app_error", nil, err.Error(), http.StatusInternalServerError)
+		return nil, errors.Wrap(err, "team_tosql")
 	}
 
 	var channels []*model.ChannelUnread
 	_, err = s.GetReplica().Select(&channels, query, args...)
 
 	if err != nil {
-		return nil, model.NewAppError("SqlTeamStore.GetChannelUnreadsForTeam", "store.sql_team.get_unread.app_error", nil, "teamId="+teamId+" "+err.Error(), http.StatusInternalServerError)
+		return nil, errors.Wrapf(err, "failed to find Channels with teamId=%s and userId=%s", teamId, userId)
 	}
 	return channels, nil
 }
 
-func (s SqlTeamStore) RemoveMembers(teamId string, userIds []string) *model.AppError {
-	query := s.getQueryBuilder().
+func (s SqlTeamStore) RemoveMembers(teamId string, userIds []string) error {
+	builder := s.getQueryBuilder().
 		Delete("TeamMembers").
 		Where(sq.Eq{"TeamId": teamId}).
 		Where(sq.Eq{"UserId": userIds})
 
-	sql, args, err := query.ToSql()
+	query, args, err := builder.ToSql()
 	if err != nil {
-		return model.NewAppError("SqlTeamStore.RemoveMembers", "store.sql.build_query.app_error", nil, "team_id="+teamId+", "+err.Error(), http.StatusInternalServerError)
+		return errors.Wrap(err, "team_tosql")
 	}
-	_, err = s.GetMaster().Exec(sql, args...)
+	_, err = s.GetMaster().Exec(query, args...)
 	if err != nil {
-		return model.NewAppError("SqlTeamStore.RemoveMembers", "app.team.remove_member.app_error", nil, "team_id="+teamId+", "+err.Error(), http.StatusInternalServerError)
+		return errors.Wrapf(err, "failed to delete TeamMembers with teamId=%s and userId in %v", teamId, userIds)
 	}
 	return nil
 }
 
 // RemoveMember remove from the database the team members that match the userId and teamId passed as parameter.
-func (s SqlTeamStore) RemoveMember(teamId string, userId string) *model.AppError {
+func (s SqlTeamStore) RemoveMember(teamId string, userId string) error {
 	return s.RemoveMembers(teamId, []string{userId})
 }
 
 // RemoveAllMembersByTeam removes from the database the team members that belong to the teamId passed as parameter.
-func (s SqlTeamStore) RemoveAllMembersByTeam(teamId string) *model.AppError {
-	sql, args, err := s.getQueryBuilder().
+func (s SqlTeamStore) RemoveAllMembersByTeam(teamId string) error {
+	query, args, err := s.getQueryBuilder().
 		Delete("TeamMembers").
 		Where(sq.Eq{"TeamId": teamId}).ToSql()
 	if err != nil {
-		return model.NewAppError("SqlTeamStore.RemoveMembers", "store.sql.build_query.app_error", nil, "team_id="+teamId+", "+err.Error(), http.StatusInternalServerError)
+		return errors.Wrap(err, "team_tosql")
 	}
 
-	_, err = s.GetMaster().Exec(sql, args...)
+	_, err = s.GetMaster().Exec(query, args...)
 	if err != nil {
-		return model.NewAppError("SqlTeamStore.RemoveMember", "app.team.remove_member.app_error", nil, "team_id="+teamId+", "+err.Error(), http.StatusInternalServerError)
+		return errors.Wrapf(err, "failed to delete TeamMembers with teamId=%s", teamId)
 	}
 	return nil
 }

store/store.go

@@ -94,20 +94,20 @@ type TeamStore interface {
 	AnalyticsPrivateTeamCount() (int64, error)
 	SaveMultipleMembers(members []*model.TeamMember, maxUsersPerTeam int) ([]*model.TeamMember, error)
 	SaveMember(member *model.TeamMember, maxUsersPerTeam int) (*model.TeamMember, error)
-	UpdateMember(member *model.TeamMember) (*model.TeamMember, *model.AppError)
-	UpdateMultipleMembers(members []*model.TeamMember) ([]*model.TeamMember, *model.AppError)
-	GetMember(teamId string, userId string) (*model.TeamMember, *model.AppError)
-	GetMembers(teamId string, offset int, limit int, teamMembersGetOptions *model.TeamMembersGetOptions) ([]*model.TeamMember, *model.AppError)
-	GetMembersByIds(teamId string, userIds []string, restrictions *model.ViewUsersRestrictions) ([]*model.TeamMember, *model.AppError)
-	GetTotalMemberCount(teamId string, restrictions *model.ViewUsersRestrictions) (int64, *model.AppError)
-	GetActiveMemberCount(teamId string, restrictions *model.ViewUsersRestrictions) (int64, *model.AppError)
-	GetTeamsForUser(userId string) ([]*model.TeamMember, *model.AppError)
-	GetTeamsForUserWithPagination(userId string, page, perPage int) ([]*model.TeamMember, *model.AppError)
-	GetChannelUnreadsForAllTeams(excludeTeamId, userId string) ([]*model.ChannelUnread, *model.AppError)
-	GetChannelUnreadsForTeam(teamId, userId string) ([]*model.ChannelUnread, *model.AppError)
-	RemoveMember(teamId string, userId string) *model.AppError
-	RemoveMembers(teamId string, userIds []string) *model.AppError
-	RemoveAllMembersByTeam(teamId string) *model.AppError
+	UpdateMember(member *model.TeamMember) (*model.TeamMember, error)
+	UpdateMultipleMembers(members []*model.TeamMember) ([]*model.TeamMember, error)
+	GetMember(teamId string, userId string) (*model.TeamMember, error)
+	GetMembers(teamId string, offset int, limit int, teamMembersGetOptions *model.TeamMembersGetOptions) ([]*model.TeamMember, error)
+	GetMembersByIds(teamId string, userIds []string, restrictions *model.ViewUsersRestrictions) ([]*model.TeamMember, error)
+	GetTotalMemberCount(teamId string, restrictions *model.ViewUsersRestrictions) (int64, error)
+	GetActiveMemberCount(teamId string, restrictions *model.ViewUsersRestrictions) (int64, error)
+	GetTeamsForUser(userId string) ([]*model.TeamMember, error)
+	GetTeamsForUserWithPagination(userId string, page, perPage int) ([]*model.TeamMember, error)
+	GetChannelUnreadsForAllTeams(excludeTeamId, userId string) ([]*model.ChannelUnread, error)
+	GetChannelUnreadsForTeam(teamId, userId string) ([]*model.ChannelUnread, error)
+	RemoveMember(teamId string, userId string) error
+	RemoveMembers(teamId string, userIds []string) error
+	RemoveAllMembersByTeam(teamId string) error
 	RemoveAllMembersByUser(userId string) error
 	UpdateLastTeamIconUpdate(teamId string, curTime int64) error
 	GetTeamsByScheme(schemeId string, offset int, limit int) ([]*model.Team, error)

store/storetest/mocks/TeamStore.go

@@ -141,7 +141,7 @@ func (_m *TeamStore) Get(id string) (*model.Team, error) {
 }
 
 // GetActiveMemberCount provides a mock function with given fields: teamId, restrictions
-func (_m *TeamStore) GetActiveMemberCount(teamId string, restrictions *model.ViewUsersRestrictions) (int64, *model.AppError) {
+func (_m *TeamStore) GetActiveMemberCount(teamId string, restrictions *model.ViewUsersRestrictions) (int64, error) {
 	ret := _m.Called(teamId, restrictions)
 
 	var r0 int64
@@ -151,13 +151,11 @@ func (_m *TeamStore) GetActiveMemberCount(teamId string, restrictions *model.Vie
 		r0 = ret.Get(0).(int64)
 	}
 
-	var r1 *model.AppError
-	if rf, ok := ret.Get(1).(func(string, *model.ViewUsersRestrictions) *model.AppError); ok {
+	var r1 error
+	if rf, ok := ret.Get(1).(func(string, *model.ViewUsersRestrictions) error); ok {
 		r1 = rf(teamId, restrictions)
 	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*model.AppError)
-		}
+		r1 = ret.Error(1)
 	}
 
 	return r0, r1
@@ -417,7 +415,7 @@ func (_m *TeamStore) GetByNames(name []string) ([]*model.Team, error) {
 }
 
 // GetChannelUnreadsForAllTeams provides a mock function with given fields: excludeTeamId, userId
-func (_m *TeamStore) GetChannelUnreadsForAllTeams(excludeTeamId string, userId string) ([]*model.ChannelUnread, *model.AppError) {
+func (_m *TeamStore) GetChannelUnreadsForAllTeams(excludeTeamId string, userId string) ([]*model.ChannelUnread, error) {
 	ret := _m.Called(excludeTeamId, userId)
 
 	var r0 []*model.ChannelUnread
@@ -429,20 +427,18 @@ func (_m *TeamStore) GetChannelUnreadsForAllTeams(excludeTeamId string, userId s
 		}
 	}
 
-	var r1 *model.AppError
-	if rf, ok := ret.Get(1).(func(string, string) *model.AppError); ok {
+	var r1 error
+	if rf, ok := ret.Get(1).(func(string, string) error); ok {
 		r1 = rf(excludeTeamId, userId)
 	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*model.AppError)
-		}
+		r1 = ret.Error(1)
 	}
 
 	return r0, r1
 }
 
 // GetChannelUnreadsForTeam provides a mock function with given fields: teamId, userId
-func (_m *TeamStore) GetChannelUnreadsForTeam(teamId string, userId string) ([]*model.ChannelUnread, *model.AppError) {
+func (_m *TeamStore) GetChannelUnreadsForTeam(teamId string, userId string) ([]*model.ChannelUnread, error) {
 	ret := _m.Called(teamId, userId)
 
 	var r0 []*model.ChannelUnread
@@ -454,20 +450,18 @@ func (_m *TeamStore) GetChannelUnreadsForTeam(teamId string, userId string) ([]*
 		}
 	}
 
-	var r1 *model.AppError
-	if rf, ok := ret.Get(1).(func(string, string) *model.AppError); ok {
+	var r1 error
+	if rf, ok := ret.Get(1).(func(string, string) error); ok {
 		r1 = rf(teamId, userId)
 	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*model.AppError)
-		}
+		r1 = ret.Error(1)
 	}
 
 	return r0, r1
 }
 
 // GetMember provides a mock function with given fields: teamId, userId
-func (_m *TeamStore) GetMember(teamId string, userId string) (*model.TeamMember, *model.AppError) {
+func (_m *TeamStore) GetMember(teamId string, userId string) (*model.TeamMember, error) {
 	ret := _m.Called(teamId, userId)
 
 	var r0 *model.TeamMember
@@ -479,20 +473,18 @@ func (_m *TeamStore) GetMember(teamId string, userId string) (*model.TeamMember,
 		}
 	}
 
-	var r1 *model.AppError
-	if rf, ok := ret.Get(1).(func(string, string) *model.AppError); ok {
+	var r1 error
+	if rf, ok := ret.Get(1).(func(string, string) error); ok {
 		r1 = rf(teamId, userId)
 	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*model.AppError)
-		}
+		r1 = ret.Error(1)
 	}
 
 	return r0, r1
 }
 
 // GetMembers provides a mock function with given fields: teamId, offset, limit, teamMembersGetOptions
-func (_m *TeamStore) GetMembers(teamId string, offset int, limit int, teamMembersGetOptions *model.TeamMembersGetOptions) ([]*model.TeamMember, *model.AppError) {
+func (_m *TeamStore) GetMembers(teamId string, offset int, limit int, teamMembersGetOptions *model.TeamMembersGetOptions) ([]*model.TeamMember, error) {
 	ret := _m.Called(teamId, offset, limit, teamMembersGetOptions)
 
 	var r0 []*model.TeamMember
@@ -504,20 +496,18 @@ func (_m *TeamStore) GetMembers(teamId string, offset int, limit int, teamMember
 		}
 	}
 
-	var r1 *model.AppError
-	if rf, ok := ret.Get(1).(func(string, int, int, *model.TeamMembersGetOptions) *model.AppError); ok {
+	var r1 error
+	if rf, ok := ret.Get(1).(func(string, int, int, *model.TeamMembersGetOptions) error); ok {
 		r1 = rf(teamId, offset, limit, teamMembersGetOptions)
 	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*model.AppError)
-		}
+		r1 = ret.Error(1)
 	}
 
 	return r0, r1
 }
 
 // GetMembersByIds provides a mock function with given fields: teamId, userIds, restrictions
-func (_m *TeamStore) GetMembersByIds(teamId string, userIds []string, restrictions *model.ViewUsersRestrictions) ([]*model.TeamMember, *model.AppError) {
+func (_m *TeamStore) GetMembersByIds(teamId string, userIds []string, restrictions *model.ViewUsersRestrictions) ([]*model.TeamMember, error) {
 	ret := _m.Called(teamId, userIds, restrictions)
 
 	var r0 []*model.TeamMember
@@ -529,13 +519,11 @@ func (_m *TeamStore) GetMembersByIds(teamId string, userIds []string, restrictio
 		}
 	}
 
-	var r1 *model.AppError
-	if rf, ok := ret.Get(1).(func(string, []string, *model.ViewUsersRestrictions) *model.AppError); ok {
+	var r1 error
+	if rf, ok := ret.Get(1).(func(string, []string, *model.ViewUsersRestrictions) error); ok {
 		r1 = rf(teamId, userIds, restrictions)
 	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*model.AppError)
-		}
+		r1 = ret.Error(1)
 	}
 
 	return r0, r1
@@ -611,7 +599,7 @@ func (_m *TeamStore) GetTeamsByUserId(userId string) ([]*model.Team, error) {
 }
 
 // GetTeamsForUser provides a mock function with given fields: userId
-func (_m *TeamStore) GetTeamsForUser(userId string) ([]*model.TeamMember, *model.AppError) {
+func (_m *TeamStore) GetTeamsForUser(userId string) ([]*model.TeamMember, error) {
 	ret := _m.Called(userId)
 
 	var r0 []*model.TeamMember
@@ -623,20 +611,18 @@ func (_m *TeamStore) GetTeamsForUser(userId string) ([]*model.TeamMember, *model
 		}
 	}
 
-	var r1 *model.AppError
-	if rf, ok := ret.Get(1).(func(string) *model.AppError); ok {
+	var r1 error
+	if rf, ok := ret.Get(1).(func(string) error); ok {
 		r1 = rf(userId)
 	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*model.AppError)
-		}
+		r1 = ret.Error(1)
 	}
 
 	return r0, r1
 }
 
 // GetTeamsForUserWithPagination provides a mock function with given fields: userId, page, perPage
-func (_m *TeamStore) GetTeamsForUserWithPagination(userId string, page int, perPage int) ([]*model.TeamMember, *model.AppError) {
+func (_m *TeamStore) GetTeamsForUserWithPagination(userId string, page int, perPage int) ([]*model.TeamMember, error) {
 	ret := _m.Called(userId, page, perPage)
 
 	var r0 []*model.TeamMember
@@ -648,20 +634,18 @@ func (_m *TeamStore) GetTeamsForUserWithPagination(userId string, page int, perP
 		}
 	}
 
-	var r1 *model.AppError
-	if rf, ok := ret.Get(1).(func(string, int, int) *model.AppError); ok {
+	var r1 error
+	if rf, ok := ret.Get(1).(func(string, int, int) error); ok {
 		r1 = rf(userId, page, perPage)
 	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*model.AppError)
-		}
+		r1 = ret.Error(1)
 	}
 
 	return r0, r1
 }
 
 // GetTotalMemberCount provides a mock function with given fields: teamId, restrictions
-func (_m *TeamStore) GetTotalMemberCount(teamId string, restrictions *model.ViewUsersRestrictions) (int64, *model.AppError) {
+func (_m *TeamStore) GetTotalMemberCount(teamId string, restrictions *model.ViewUsersRestrictions) (int64, error) {
 	ret := _m.Called(teamId, restrictions)
 
 	var r0 int64
@@ -671,13 +655,11 @@ func (_m *TeamStore) GetTotalMemberCount(teamId string, restrictions *model.View
 		r0 = ret.Get(0).(int64)
 	}
 
-	var r1 *model.AppError
-	if rf, ok := ret.Get(1).(func(string, *model.ViewUsersRestrictions) *model.AppError); ok {
+	var r1 error
+	if rf, ok := ret.Get(1).(func(string, *model.ViewUsersRestrictions) error); ok {
 		r1 = rf(teamId, restrictions)
 	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*model.AppError)
-		}
+		r1 = ret.Error(1)
 	}
 
 	return r0, r1
@@ -770,16 +752,14 @@ func (_m *TeamStore) PermanentDelete(teamId string) error {
 }
 
 // RemoveAllMembersByTeam provides a mock function with given fields: teamId
-func (_m *TeamStore) RemoveAllMembersByTeam(teamId string) *model.AppError {
+func (_m *TeamStore) RemoveAllMembersByTeam(teamId string) error {
 	ret := _m.Called(teamId)
 
-	var r0 *model.AppError
-	if rf, ok := ret.Get(0).(func(string) *model.AppError); ok {
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
 		r0 = rf(teamId)
 	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*model.AppError)
-		}
+		r0 = ret.Error(0)
 	}
 
 	return r0
@@ -800,32 +780,28 @@ func (_m *TeamStore) RemoveAllMembersByUser(userId string) error {
 }
 
 // RemoveMember provides a mock function with given fields: teamId, userId
-func (_m *TeamStore) RemoveMember(teamId string, userId string) *model.AppError {
+func (_m *TeamStore) RemoveMember(teamId string, userId string) error {
 	ret := _m.Called(teamId, userId)
 
-	var r0 *model.AppError
-	if rf, ok := ret.Get(0).(func(string, string) *model.AppError); ok {
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, string) error); ok {
 		r0 = rf(teamId, userId)
 	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*model.AppError)
-		}
+		r0 = ret.Error(0)
 	}
 
 	return r0
 }
 
 // RemoveMembers provides a mock function with given fields: teamId, userIds
-func (_m *TeamStore) RemoveMembers(teamId string, userIds []string) *model.AppError {
+func (_m *TeamStore) RemoveMembers(teamId string, userIds []string) error {
 	ret := _m.Called(teamId, userIds)
 
-	var r0 *model.AppError
-	if rf, ok := ret.Get(0).(func(string, []string) *model.AppError); ok {
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, []string) error); ok {
 		r0 = rf(teamId, userIds)
 	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*model.AppError)
-		}
+		r0 = ret.Error(0)
 	}
 
 	return r0
@@ -1051,7 +1027,7 @@ func (_m *TeamStore) UpdateLastTeamIconUpdate(teamId string, curTime int64) erro
 }
 
 // UpdateMember provides a mock function with given fields: member
-func (_m *TeamStore) UpdateMember(member *model.TeamMember) (*model.TeamMember, *model.AppError) {
+func (_m *TeamStore) UpdateMember(member *model.TeamMember) (*model.TeamMember, error) {
 	ret := _m.Called(member)
 
 	var r0 *model.TeamMember
@@ -1063,13 +1039,11 @@ func (_m *TeamStore) UpdateMember(member *model.TeamMember) (*model.TeamMember,
 		}
 	}
 
-	var r1 *model.AppError
-	if rf, ok := ret.Get(1).(func(*model.TeamMember) *model.AppError); ok {
+	var r1 error
+	if rf, ok := ret.Get(1).(func(*model.TeamMember) error); ok {
 		r1 = rf(member)
 	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*model.AppError)
-		}
+		r1 = ret.Error(1)
 	}
 
 	return r0, r1
@@ -1090,7 +1064,7 @@ func (_m *TeamStore) UpdateMembersRole(teamID string, userIDs []string) error {
 }
 
 // UpdateMultipleMembers provides a mock function with given fields: members
-func (_m *TeamStore) UpdateMultipleMembers(members []*model.TeamMember) ([]*model.TeamMember, *model.AppError) {
+func (_m *TeamStore) UpdateMultipleMembers(members []*model.TeamMember) ([]*model.TeamMember, error) {
 	ret := _m.Called(members)
 
 	var r0 []*model.TeamMember
@@ -1102,13 +1076,11 @@ func (_m *TeamStore) UpdateMultipleMembers(members []*model.TeamMember) ([]*mode
 		}
 	}
 
-	var r1 *model.AppError
-	if rf, ok := ret.Get(1).(func([]*model.TeamMember) *model.AppError); ok {
+	var r1 error
+	if rf, ok := ret.Get(1).(func([]*model.TeamMember) error); ok {
 		r1 = rf(members)
 	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*model.AppError)
-		}
+		r1 = ret.Error(1)
 	}
 
 	return r0, r1

store/storetest/team_store.go

@@ -4,6 +4,7 @@
 package storetest
 
 import (
+	"errors"
 	"strings"
 	"testing"
 	"time"
@@ -1118,8 +1119,8 @@ func testGetMembers(t *testing.T, ss store.Store) {
 		require.Nil(t, nErr)
 
 		// Gets users ordered by UserName
-		ms, err := ss.Team().GetMembers(teamId1, 0, 100, &model.TeamMembersGetOptions{Sort: model.USERNAME})
-		require.Nil(t, err)
+		ms, nErr := ss.Team().GetMembers(teamId1, 0, 100, &model.TeamMembersGetOptions{Sort: model.USERNAME})
+		require.Nil(t, nErr)
 		assert.Len(t, ms, 5)
 		assert.Equal(t, u1.Id, ms[0].UserId)
 		assert.Equal(t, u3.Id, ms[1].UserId)
@@ -1128,8 +1129,8 @@ func testGetMembers(t *testing.T, ss store.Store) {
 		assert.Equal(t, u4.Id, ms[4].UserId)
 
 		// Gets users ordered by UserName and excludes deleted members
-		ms, err = ss.Team().GetMembers(teamId1, 0, 100, &model.TeamMembersGetOptions{Sort: model.USERNAME, ExcludeDeletedUsers: true})
-		require.Nil(t, err)
+		ms, nErr = ss.Team().GetMembers(teamId1, 0, 100, &model.TeamMembersGetOptions{Sort: model.USERNAME, ExcludeDeletedUsers: true})
+		require.Nil(t, nErr)
 		assert.Len(t, ms, 2)
 		assert.Equal(t, u2.Id, ms[0].UserId)
 		assert.Equal(t, u4.Id, ms[1].UserId)
@@ -1180,8 +1181,8 @@ func testGetMembers(t *testing.T, ss store.Store) {
 		require.Nil(t, nErr)
 
 		// Gets users ordered by UserName
-		ms, err := ss.Team().GetMembers(teamId1, 0, 100, &model.TeamMembersGetOptions{ExcludeDeletedUsers: true})
-		require.Nil(t, err)
+		ms, nErr := ss.Team().GetMembers(teamId1, 0, 100, &model.TeamMembersGetOptions{ExcludeDeletedUsers: true})
+		require.Nil(t, nErr)
 		assert.Len(t, ms, 3)
 		require.ElementsMatch(t, ms, [3]*model.TeamMember{t1, t3, t5})
 	})
@@ -1968,9 +1969,11 @@ func testTeamUpdateMember(t *testing.T, ss store.Store) {
 
 	t.Run("not valid team member", func(t *testing.T) {
 		member := &model.TeamMember{TeamId: "wrong", UserId: u1.Id}
-		_, err = ss.Team().UpdateMember(member)
-		require.NotNil(t, err)
-		require.Equal(t, "model.team_member.is_valid.team_id.app_error", err.Id)
+		_, nErr := ss.Team().UpdateMember(member)
+		require.NotNil(t, nErr)
+		var appErr *model.AppError
+		require.True(t, errors.As(nErr, &appErr))
+		require.Equal(t, "model.team_member.is_valid.team_id.app_error", appErr.Id)
 	})
 
 	t.Run("insert member correctly (in team without scheme)", func(t *testing.T) {
@@ -2102,8 +2105,8 @@ func testTeamUpdateMember(t *testing.T, ss store.Store) {
 				member.SchemeAdmin = tc.SchemeAdmin
 				member.ExplicitRoles = tc.ExplicitRoles
 
-				member, err = ss.Team().UpdateMember(member)
-				require.Nil(t, err)
+				member, nErr = ss.Team().UpdateMember(member)
+				require.Nil(t, nErr)
 
 				assert.Equal(t, tc.ExpectedRoles, member.Roles)
 				assert.Equal(t, tc.ExpectedExplicitRoles, member.ExplicitRoles)
@@ -2253,8 +2256,8 @@ func testTeamUpdateMember(t *testing.T, ss store.Store) {
 				member.SchemeAdmin = tc.SchemeAdmin
 				member.ExplicitRoles = tc.ExplicitRoles
 
-				member, err = ss.Team().UpdateMember(member)
-				require.Nil(t, err)
+				member, nErr = ss.Team().UpdateMember(member)
+				require.Nil(t, nErr)
 
 				assert.Equal(t, tc.ExpectedRoles, member.Roles)
 				assert.Equal(t, tc.ExpectedExplicitRoles, member.ExplicitRoles)
@@ -2275,9 +2278,11 @@ func testTeamUpdateMultipleMembers(t *testing.T, ss store.Store) {
 	t.Run("any not valid team member", func(t *testing.T) {
 		m1 := &model.TeamMember{TeamId: "wrong", UserId: u1.Id}
 		m2 := &model.TeamMember{TeamId: model.NewId(), UserId: u2.Id}
-		_, err = ss.Team().UpdateMultipleMembers([]*model.TeamMember{m1, m2})
-		require.NotNil(t, err)
-		require.Equal(t, "model.team_member.is_valid.team_id.app_error", err.Id)
+		_, nErr := ss.Team().UpdateMultipleMembers([]*model.TeamMember{m1, m2})
+		require.NotNil(t, nErr)
+		var appErr *model.AppError
+		require.True(t, errors.As(nErr, &appErr))
+		require.Equal(t, "model.team_member.is_valid.team_id.app_error", appErr.Id)
 	})
 
 	t.Run("update members correctly (in team without scheme)", func(t *testing.T) {
@@ -2415,8 +2420,8 @@ func testTeamUpdateMultipleMembers(t *testing.T, ss store.Store) {
 				member.ExplicitRoles = tc.ExplicitRoles
 
 				var members []*model.TeamMember
-				members, err = ss.Team().UpdateMultipleMembers([]*model.TeamMember{member, otherMember})
-				require.Nil(t, err)
+				members, nErr = ss.Team().UpdateMultipleMembers([]*model.TeamMember{member, otherMember})
+				require.Nil(t, nErr)
 				require.Len(t, members, 2)
 				member = members[0]
 
@@ -2605,30 +2610,30 @@ func testTeamRemoveMember(t *testing.T, ss store.Store) {
 	require.Nil(t, nErr)
 
 	t.Run("remove member from not existing team", func(t *testing.T) {
-		err = ss.Team().RemoveMember("not-existing-team", u1.Id)
-		require.Nil(t, err)
+		nErr = ss.Team().RemoveMember("not-existing-team", u1.Id)
+		require.Nil(t, nErr)
 		var membersOtherTeam []*model.TeamMember
-		membersOtherTeam, err = ss.Team().GetMembers(teamID, 0, 100, nil)
-		require.Nil(t, err)
+		membersOtherTeam, nErr = ss.Team().GetMembers(teamID, 0, 100, nil)
+		require.Nil(t, nErr)
 		require.Len(t, membersOtherTeam, 4)
 	})
 
 	t.Run("remove not existing member from an existing team", func(t *testing.T) {
-		err = ss.Team().RemoveMember(teamID, model.NewId())
-		require.Nil(t, err)
+		nErr = ss.Team().RemoveMember(teamID, model.NewId())
+		require.Nil(t, nErr)
 		var membersOtherTeam []*model.TeamMember
-		membersOtherTeam, err = ss.Team().GetMembers(teamID, 0, 100, nil)
-		require.Nil(t, err)
+		membersOtherTeam, nErr = ss.Team().GetMembers(teamID, 0, 100, nil)
+		require.Nil(t, nErr)
 		require.Len(t, membersOtherTeam, 4)
 	})
 
 	t.Run("remove existing member from an existing team", func(t *testing.T) {
-		err = ss.Team().RemoveMember(teamID, u1.Id)
-		require.Nil(t, err)
+		nErr = ss.Team().RemoveMember(teamID, u1.Id)
+		require.Nil(t, nErr)
 		defer ss.Team().SaveMember(m1, -1)
 		var membersOtherTeam []*model.TeamMember
-		membersOtherTeam, err = ss.Team().GetMembers(teamID, 0, 100, nil)
-		require.Nil(t, err)
+		membersOtherTeam, nErr = ss.Team().GetMembers(teamID, 0, 100, nil)
+		require.Nil(t, nErr)
 		require.Len(t, membersOtherTeam, 3)
 	})
 }
@@ -2651,39 +2656,39 @@ func testTeamRemoveMembers(t *testing.T, ss store.Store) {
 	require.Nil(t, nErr)
 
 	t.Run("remove members from not existing team", func(t *testing.T) {
-		err = ss.Team().RemoveMembers("not-existing-team", []string{u1.Id, u2.Id, u3.Id, u4.Id})
-		require.Nil(t, err)
+		nErr = ss.Team().RemoveMembers("not-existing-team", []string{u1.Id, u2.Id, u3.Id, u4.Id})
+		require.Nil(t, nErr)
 		var membersOtherTeam []*model.TeamMember
-		membersOtherTeam, err = ss.Team().GetMembers(teamID, 0, 100, nil)
-		require.Nil(t, err)
+		membersOtherTeam, nErr = ss.Team().GetMembers(teamID, 0, 100, nil)
+		require.Nil(t, nErr)
 		require.Len(t, membersOtherTeam, 4)
 	})
 
 	t.Run("remove not existing members from an existing team", func(t *testing.T) {
-		err = ss.Team().RemoveMembers(teamID, []string{model.NewId(), model.NewId()})
-		require.Nil(t, err)
+		nErr = ss.Team().RemoveMembers(teamID, []string{model.NewId(), model.NewId()})
+		require.Nil(t, nErr)
 		var membersOtherTeam []*model.TeamMember
-		membersOtherTeam, err = ss.Team().GetMembers(teamID, 0, 100, nil)
-		require.Nil(t, err)
+		membersOtherTeam, nErr = ss.Team().GetMembers(teamID, 0, 100, nil)
+		require.Nil(t, nErr)
 		require.Len(t, membersOtherTeam, 4)
 	})
 
 	t.Run("remove not existing and not existing members from an existing team", func(t *testing.T) {
-		err = ss.Team().RemoveMembers(teamID, []string{u1.Id, u2.Id, model.NewId(), model.NewId()})
-		require.Nil(t, err)
+		nErr = ss.Team().RemoveMembers(teamID, []string{u1.Id, u2.Id, model.NewId(), model.NewId()})
+		require.Nil(t, nErr)
 		defer ss.Team().SaveMultipleMembers([]*model.TeamMember{m1, m2}, -1)
 		var membersOtherTeam []*model.TeamMember
-		membersOtherTeam, err = ss.Team().GetMembers(teamID, 0, 100, nil)
-		require.Nil(t, err)
+		membersOtherTeam, nErr = ss.Team().GetMembers(teamID, 0, 100, nil)
+		require.Nil(t, nErr)
 		require.Len(t, membersOtherTeam, 2)
 	})
 	t.Run("remove existing members from an existing team", func(t *testing.T) {
-		err = ss.Team().RemoveMembers(teamID, []string{u1.Id, u2.Id, u3.Id})
-		require.Nil(t, err)
+		nErr = ss.Team().RemoveMembers(teamID, []string{u1.Id, u2.Id, u3.Id})
+		require.Nil(t, nErr)
 		defer ss.Team().SaveMultipleMembers([]*model.TeamMember{m1, m2, m3}, -1)
 		var membersOtherTeam []*model.TeamMember
-		membersOtherTeam, err = ss.Team().GetMembers(teamID, 0, 100, nil)
-		require.Nil(t, err)
+		membersOtherTeam, nErr = ss.Team().GetMembers(teamID, 0, 100, nil)
+		require.Nil(t, nErr)
 		require.Len(t, membersOtherTeam, 1)
 	})
 }
@@ -2954,25 +2959,25 @@ func testTeamStoreMemberCount(t *testing.T, ss store.Store) {
 	require.Nil(t, nErr)
 
 	var totalMemberCount int64
-	totalMemberCount, err = ss.Team().GetTotalMemberCount(teamId1, nil)
-	require.Nil(t, err)
+	totalMemberCount, nErr = ss.Team().GetTotalMemberCount(teamId1, nil)
+	require.Nil(t, nErr)
 	require.Equal(t, int(totalMemberCount), 2, "wrong count")
 
 	var result int64
-	result, err = ss.Team().GetActiveMemberCount(teamId1, nil)
-	require.Nil(t, err)
+	result, nErr = ss.Team().GetActiveMemberCount(teamId1, nil)
+	require.Nil(t, nErr)
 	require.Equal(t, 1, int(result), "wrong count")
 
 	m3 := &model.TeamMember{TeamId: teamId1, UserId: model.NewId()}
 	_, nErr = ss.Team().SaveMember(m3, -1)
 	require.Nil(t, nErr)
 
-	totalMemberCount, err = ss.Team().GetTotalMemberCount(teamId1, nil)
-	require.Nil(t, err)
+	totalMemberCount, nErr = ss.Team().GetTotalMemberCount(teamId1, nil)
+	require.Nil(t, nErr)
 	require.Equal(t, 2, int(totalMemberCount), "wrong count")
 
-	result, err = ss.Team().GetActiveMemberCount(teamId1, nil)
-	require.Nil(t, err)
+	result, nErr = ss.Team().GetActiveMemberCount(teamId1, nil)
+	require.Nil(t, nErr)
 	require.Equal(t, 1, int(result), "wrong count")
 }
 
@@ -3003,8 +3008,8 @@ func testGetChannelUnreadsForAllTeams(t *testing.T, ss store.Store) {
 	_, err = ss.Channel().SaveMember(cm2)
 	require.Nil(t, err)
 
-	ms1, err := ss.Team().GetChannelUnreadsForAllTeams("", uid)
-	require.Nil(t, err)
+	ms1, nErr := ss.Team().GetChannelUnreadsForAllTeams("", uid)
+	require.Nil(t, nErr)
 	membersMap := make(map[string]bool)
 	for i := range ms1 {
 		id := ms1[i].TeamId
@@ -3016,8 +3021,8 @@ func testGetChannelUnreadsForAllTeams(t *testing.T, ss store.Store) {
 
 	require.Equal(t, 10, int(ms1[0].MsgCount), "subtraction failed")
 
-	ms2, err := ss.Team().GetChannelUnreadsForAllTeams(teamId1, uid)
-	require.Nil(t, err)
+	ms2, nErr := ss.Team().GetChannelUnreadsForAllTeams(teamId1, uid)
+	require.Nil(t, nErr)
 	membersMap = make(map[string]bool)
 	for i := range ms2 {
 		id := ms2[i].TeamId

store/storetest/user_store.go

@@ -4641,8 +4641,8 @@ func testUserStorePromoteGuestToUser(t *testing.T, ss store.Store) {
 		require.Equal(t, "system_user", updatedUser.Roles)
 		require.True(t, user.UpdateAt < updatedUser.UpdateAt)
 
-		updatedTeamMember, err := ss.Team().GetMember(teamId, user.Id)
-		require.Nil(t, err)
+		updatedTeamMember, nErr := ss.Team().GetMember(teamId, user.Id)
+		require.Nil(t, nErr)
 		require.False(t, updatedTeamMember.SchemeGuest)
 		require.True(t, updatedTeamMember.SchemeUser)
 
@@ -4686,8 +4686,8 @@ func testUserStorePromoteGuestToUser(t *testing.T, ss store.Store) {
 		require.Nil(t, err)
 		require.Equal(t, "system_user system_admin", updatedUser.Roles)
 
-		updatedTeamMember, err := ss.Team().GetMember(teamId, user.Id)
-		require.Nil(t, err)
+		updatedTeamMember, nErr := ss.Team().GetMember(teamId, user.Id)
+		require.Nil(t, nErr)
 		require.False(t, updatedTeamMember.SchemeGuest)
 		require.True(t, updatedTeamMember.SchemeUser)
 
@@ -4742,8 +4742,8 @@ func testUserStorePromoteGuestToUser(t *testing.T, ss store.Store) {
 		require.Nil(t, err)
 		require.Equal(t, "system_user", updatedUser.Roles)
 
-		updatedTeamMember, err := ss.Team().GetMember(teamId, user.Id)
-		require.Nil(t, err)
+		updatedTeamMember, nErr := ss.Team().GetMember(teamId, user.Id)
+		require.Nil(t, nErr)
 		require.False(t, updatedTeamMember.SchemeGuest)
 		require.True(t, updatedTeamMember.SchemeUser)
 	})
@@ -4782,8 +4782,8 @@ func testUserStorePromoteGuestToUser(t *testing.T, ss store.Store) {
 		require.Nil(t, err)
 		require.Equal(t, "system_user", updatedUser.Roles)
 
-		updatedTeamMember, err := ss.Team().GetMember(teamId, user.Id)
-		require.Nil(t, err)
+		updatedTeamMember, nErr := ss.Team().GetMember(teamId, user.Id)
+		require.Nil(t, nErr)
 		require.False(t, updatedTeamMember.SchemeGuest)
 		require.True(t, updatedTeamMember.SchemeUser)
 
@@ -4827,8 +4827,8 @@ func testUserStorePromoteGuestToUser(t *testing.T, ss store.Store) {
 		require.Nil(t, err)
 		require.Equal(t, "system_user custom_role", updatedUser.Roles)
 
-		updatedTeamMember, err := ss.Team().GetMember(teamId, user.Id)
-		require.Nil(t, err)
+		updatedTeamMember, nErr := ss.Team().GetMember(teamId, user.Id)
+		require.Nil(t, nErr)
 		require.False(t, updatedTeamMember.SchemeGuest)
 		require.True(t, updatedTeamMember.SchemeUser)
 
@@ -4893,8 +4893,8 @@ func testUserStorePromoteGuestToUser(t *testing.T, ss store.Store) {
 		require.Nil(t, err)
 		require.Equal(t, "system_user", updatedUser.Roles)
 
-		updatedTeamMember, err := ss.Team().GetMember(teamId1, user1.Id)
-		require.Nil(t, err)
+		updatedTeamMember, nErr := ss.Team().GetMember(teamId1, user1.Id)
+		require.Nil(t, nErr)
 		require.False(t, updatedTeamMember.SchemeGuest)
 		require.True(t, updatedTeamMember.SchemeUser)
 
@@ -4907,8 +4907,8 @@ func testUserStorePromoteGuestToUser(t *testing.T, ss store.Store) {
 		require.Nil(t, err)
 		require.Equal(t, "system_guest", notUpdatedUser.Roles)
 
-		notUpdatedTeamMember, err := ss.Team().GetMember(teamId2, user2.Id)
-		require.Nil(t, err)
+		notUpdatedTeamMember, nErr := ss.Team().GetMember(teamId2, user2.Id)
+		require.Nil(t, nErr)
 		require.True(t, notUpdatedTeamMember.SchemeGuest)
 		require.False(t, notUpdatedTeamMember.SchemeUser)
 
@@ -4956,8 +4956,8 @@ func testUserStoreDemoteUserToGuest(t *testing.T, ss store.Store) {
 		require.Equal(t, "system_guest", updatedUser.Roles)
 		require.True(t, user.UpdateAt < updatedUser.UpdateAt)
 
-		updatedTeamMember, err := ss.Team().GetMember(teamId, user.Id)
-		require.Nil(t, err)
+		updatedTeamMember, nErr := ss.Team().GetMember(teamId, user.Id)
+		require.Nil(t, nErr)
 		require.True(t, updatedTeamMember.SchemeGuest)
 		require.False(t, updatedTeamMember.SchemeUser)
 
@@ -5001,8 +5001,8 @@ func testUserStoreDemoteUserToGuest(t *testing.T, ss store.Store) {
 		require.Nil(t, err)
 		require.Equal(t, "system_guest", updatedUser.Roles)
 
-		updatedTeamMember, err := ss.Team().GetMember(teamId, user.Id)
-		require.Nil(t, err)
+		updatedTeamMember, nErr := ss.Team().GetMember(teamId, user.Id)
+		require.Nil(t, nErr)
 		require.True(t, updatedTeamMember.SchemeGuest)
 		require.False(t, updatedTeamMember.SchemeUser)
 
@@ -5057,8 +5057,8 @@ func testUserStoreDemoteUserToGuest(t *testing.T, ss store.Store) {
 		require.Nil(t, err)
 		require.Equal(t, "system_guest", updatedUser.Roles)
 
-		updatedTeamMember, err := ss.Team().GetMember(teamId, user.Id)
-		require.Nil(t, err)
+		updatedTeamMember, nErr := ss.Team().GetMember(teamId, user.Id)
+		require.Nil(t, nErr)
 		require.True(t, updatedTeamMember.SchemeGuest)
 		require.False(t, updatedTeamMember.SchemeUser)
 	})
@@ -5097,8 +5097,8 @@ func testUserStoreDemoteUserToGuest(t *testing.T, ss store.Store) {
 		require.Nil(t, err)
 		require.Equal(t, "system_guest", updatedUser.Roles)
 
-		updatedTeamMember, err := ss.Team().GetMember(teamId, user.Id)
-		require.Nil(t, err)
+		updatedTeamMember, nErr := ss.Team().GetMember(teamId, user.Id)
+		require.Nil(t, nErr)
 		require.True(t, updatedTeamMember.SchemeGuest)
 		require.False(t, updatedTeamMember.SchemeUser)
 
@@ -5142,8 +5142,8 @@ func testUserStoreDemoteUserToGuest(t *testing.T, ss store.Store) {
 		require.Nil(t, err)
 		require.Equal(t, "system_guest custom_role", updatedUser.Roles)
 
-		updatedTeamMember, err := ss.Team().GetMember(teamId, user.Id)
-		require.Nil(t, err)
+		updatedTeamMember, nErr := ss.Team().GetMember(teamId, user.Id)
+		require.Nil(t, nErr)
 		require.True(t, updatedTeamMember.SchemeGuest)
 		require.False(t, updatedTeamMember.SchemeUser)
 
@@ -5208,8 +5208,8 @@ func testUserStoreDemoteUserToGuest(t *testing.T, ss store.Store) {
 		require.Nil(t, err)
 		require.Equal(t, "system_guest", updatedUser.Roles)
 
-		updatedTeamMember, err := ss.Team().GetMember(teamId1, user1.Id)
-		require.Nil(t, err)
+		updatedTeamMember, nErr := ss.Team().GetMember(teamId1, user1.Id)
+		require.Nil(t, nErr)
 		require.True(t, updatedTeamMember.SchemeGuest)
 		require.False(t, updatedTeamMember.SchemeUser)
 
@@ -5222,8 +5222,8 @@ func testUserStoreDemoteUserToGuest(t *testing.T, ss store.Store) {
 		require.Nil(t, err)
 		require.Equal(t, "system_user", notUpdatedUser.Roles)
 
-		notUpdatedTeamMember, err := ss.Team().GetMember(teamId2, user2.Id)
-		require.Nil(t, err)
+		notUpdatedTeamMember, nErr := ss.Team().GetMember(teamId2, user2.Id)
+		require.Nil(t, nErr)
 		require.False(t, notUpdatedTeamMember.SchemeGuest)
 		require.True(t, notUpdatedTeamMember.SchemeUser)
 

store/timerlayer/timerlayer.go

@@ -5973,7 +5973,7 @@ func (s *TimerLayerTeamStore) Get(id string) (*model.Team, error) {
 	return result, err
 }
 
-func (s *TimerLayerTeamStore) GetActiveMemberCount(teamId string, restrictions *model.ViewUsersRestrictions) (int64, *model.AppError) {
+func (s *TimerLayerTeamStore) GetActiveMemberCount(teamId string, restrictions *model.ViewUsersRestrictions) (int64, error) {
 	start := timemodule.Now()
 
 	result, err := s.TeamStore.GetActiveMemberCount(teamId, restrictions)
@@ -6165,7 +6165,7 @@ func (s *TimerLayerTeamStore) GetByNames(name []string) ([]*model.Team, error) {
 	return result, err
 }
 
-func (s *TimerLayerTeamStore) GetChannelUnreadsForAllTeams(excludeTeamId string, userId string) ([]*model.ChannelUnread, *model.AppError) {
+func (s *TimerLayerTeamStore) GetChannelUnreadsForAllTeams(excludeTeamId string, userId string) ([]*model.ChannelUnread, error) {
 	start := timemodule.Now()
 
 	result, err := s.TeamStore.GetChannelUnreadsForAllTeams(excludeTeamId, userId)
@@ -6181,7 +6181,7 @@ func (s *TimerLayerTeamStore) GetChannelUnreadsForAllTeams(excludeTeamId string,
 	return result, err
 }
 
-func (s *TimerLayerTeamStore) GetChannelUnreadsForTeam(teamId string, userId string) ([]*model.ChannelUnread, *model.AppError) {
+func (s *TimerLayerTeamStore) GetChannelUnreadsForTeam(teamId string, userId string) ([]*model.ChannelUnread, error) {
 	start := timemodule.Now()
 
 	result, err := s.TeamStore.GetChannelUnreadsForTeam(teamId, userId)
@@ -6197,7 +6197,7 @@ func (s *TimerLayerTeamStore) GetChannelUnreadsForTeam(teamId string, userId str
 	return result, err
 }
 
-func (s *TimerLayerTeamStore) GetMember(teamId string, userId string) (*model.TeamMember, *model.AppError) {
+func (s *TimerLayerTeamStore) GetMember(teamId string, userId string) (*model.TeamMember, error) {
 	start := timemodule.Now()
 
 	result, err := s.TeamStore.GetMember(teamId, userId)
@@ -6213,7 +6213,7 @@ func (s *TimerLayerTeamStore) GetMember(teamId string, userId string) (*model.Te
 	return result, err
 }
 
-func (s *TimerLayerTeamStore) GetMembers(teamId string, offset int, limit int, teamMembersGetOptions *model.TeamMembersGetOptions) ([]*model.TeamMember, *model.AppError) {
+func (s *TimerLayerTeamStore) GetMembers(teamId string, offset int, limit int, teamMembersGetOptions *model.TeamMembersGetOptions) ([]*model.TeamMember, error) {
 	start := timemodule.Now()
 
 	result, err := s.TeamStore.GetMembers(teamId, offset, limit, teamMembersGetOptions)
@@ -6229,7 +6229,7 @@ func (s *TimerLayerTeamStore) GetMembers(teamId string, offset int, limit int, t
 	return result, err
 }
 
-func (s *TimerLayerTeamStore) GetMembersByIds(teamId string, userIds []string, restrictions *model.ViewUsersRestrictions) ([]*model.TeamMember, *model.AppError) {
+func (s *TimerLayerTeamStore) GetMembersByIds(teamId string, userIds []string, restrictions *model.ViewUsersRestrictions) ([]*model.TeamMember, error) {
 	start := timemodule.Now()
 
 	result, err := s.TeamStore.GetMembersByIds(teamId, userIds, restrictions)
@@ -6293,7 +6293,7 @@ func (s *TimerLayerTeamStore) GetTeamsByUserId(userId string) ([]*model.Team, er
 	return result, err
 }
 
-func (s *TimerLayerTeamStore) GetTeamsForUser(userId string) ([]*model.TeamMember, *model.AppError) {
+func (s *TimerLayerTeamStore) GetTeamsForUser(userId string) ([]*model.TeamMember, error) {
 	start := timemodule.Now()
 
 	result, err := s.TeamStore.GetTeamsForUser(userId)
@@ -6309,7 +6309,7 @@ func (s *TimerLayerTeamStore) GetTeamsForUser(userId string) ([]*model.TeamMembe
 	return result, err
 }
 
-func (s *TimerLayerTeamStore) GetTeamsForUserWithPagination(userId string, page int, perPage int) ([]*model.TeamMember, *model.AppError) {
+func (s *TimerLayerTeamStore) GetTeamsForUserWithPagination(userId string, page int, perPage int) ([]*model.TeamMember, error) {
 	start := timemodule.Now()
 
 	result, err := s.TeamStore.GetTeamsForUserWithPagination(userId, page, perPage)
@@ -6325,7 +6325,7 @@ func (s *TimerLayerTeamStore) GetTeamsForUserWithPagination(userId string, page
 	return result, err
 }
 
-func (s *TimerLayerTeamStore) GetTotalMemberCount(teamId string, restrictions *model.ViewUsersRestrictions) (int64, *model.AppError) {
+func (s *TimerLayerTeamStore) GetTotalMemberCount(teamId string, restrictions *model.ViewUsersRestrictions) (int64, error) {
 	start := timemodule.Now()
 
 	result, err := s.TeamStore.GetTotalMemberCount(teamId, restrictions)
@@ -6420,7 +6420,7 @@ func (s *TimerLayerTeamStore) PermanentDelete(teamId string) error {
 	return err
 }
 
-func (s *TimerLayerTeamStore) RemoveAllMembersByTeam(teamId string) *model.AppError {
+func (s *TimerLayerTeamStore) RemoveAllMembersByTeam(teamId string) error {
 	start := timemodule.Now()
 
 	err := s.TeamStore.RemoveAllMembersByTeam(teamId)
@@ -6452,7 +6452,7 @@ func (s *TimerLayerTeamStore) RemoveAllMembersByUser(userId string) error {
 	return err
 }
 
-func (s *TimerLayerTeamStore) RemoveMember(teamId string, userId string) *model.AppError {
+func (s *TimerLayerTeamStore) RemoveMember(teamId string, userId string) error {
 	start := timemodule.Now()
 
 	err := s.TeamStore.RemoveMember(teamId, userId)
@@ -6468,7 +6468,7 @@ func (s *TimerLayerTeamStore) RemoveMember(teamId string, userId string) *model.
 	return err
 }
 
-func (s *TimerLayerTeamStore) RemoveMembers(teamId string, userIds []string) *model.AppError {
+func (s *TimerLayerTeamStore) RemoveMembers(teamId string, userIds []string) error {
 	start := timemodule.Now()
 
 	err := s.TeamStore.RemoveMembers(teamId, userIds)
@@ -6644,7 +6644,7 @@ func (s *TimerLayerTeamStore) UpdateLastTeamIconUpdate(teamId string, curTime in
 	return err
 }
 
-func (s *TimerLayerTeamStore) UpdateMember(member *model.TeamMember) (*model.TeamMember, *model.AppError) {
+func (s *TimerLayerTeamStore) UpdateMember(member *model.TeamMember) (*model.TeamMember, error) {
 	start := timemodule.Now()
 
 	result, err := s.TeamStore.UpdateMember(member)
@@ -6676,7 +6676,7 @@ func (s *TimerLayerTeamStore) UpdateMembersRole(teamID string, userIDs []string)
 	return err
 }
 
-func (s *TimerLayerTeamStore) UpdateMultipleMembers(members []*model.TeamMember) ([]*model.TeamMember, *model.AppError) {
+func (s *TimerLayerTeamStore) UpdateMultipleMembers(members []*model.TeamMember) ([]*model.TeamMember, error) {
 	start := timemodule.Now()
 
 	result, err := s.TeamStore.UpdateMultipleMembers(members)