Migration of TeamStore Part 1 (#15246)

Automatic Merge

store/localcachelayer/team_layer.go

@@ -57,9 +57,9 @@ func (s LocalCacheTeamStore) GetUserTeamIds(userID string, allowFromCache bool)
 	return userTeamIds, nil
 }
 
-func (s LocalCacheTeamStore) Update(team *model.Team) (*model.Team, *model.AppError) {
+func (s LocalCacheTeamStore) Update(team *model.Team) (*model.Team, error) {
 	var oldTeam *model.Team
-	var err *model.AppError
+	var err error
 	if team.DeleteAt != 0 {
 		oldTeam, err = s.TeamStore.Get(team.Id)
 		if err != nil {

store/opentracinglayer/opentracinglayer.go

@@ -6494,7 +6494,7 @@ func (s *OpenTracingLayerTeamStore) AnalyticsGetTeamCountForScheme(schemeId stri
 	return result, err
 }
 
-func (s *OpenTracingLayerTeamStore) AnalyticsPrivateTeamCount() (int64, *model.AppError) {
+func (s *OpenTracingLayerTeamStore) AnalyticsPrivateTeamCount() (int64, error) {
 	origCtx := s.Root.Store.Context()
 	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "TeamStore.AnalyticsPrivateTeamCount")
 	s.Root.Store.SetContext(newCtx)
@@ -6512,7 +6512,7 @@ func (s *OpenTracingLayerTeamStore) AnalyticsPrivateTeamCount() (int64, *model.A
 	return result, err
 }
 
-func (s *OpenTracingLayerTeamStore) AnalyticsPublicTeamCount() (int64, *model.AppError) {
+func (s *OpenTracingLayerTeamStore) AnalyticsPublicTeamCount() (int64, error) {
 	origCtx := s.Root.Store.Context()
 	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "TeamStore.AnalyticsPublicTeamCount")
 	s.Root.Store.SetContext(newCtx)
@@ -6530,7 +6530,7 @@ func (s *OpenTracingLayerTeamStore) AnalyticsPublicTeamCount() (int64, *model.Ap
 	return result, err
 }
 
-func (s *OpenTracingLayerTeamStore) AnalyticsTeamCount(includeDeleted bool) (int64, *model.AppError) {
+func (s *OpenTracingLayerTeamStore) AnalyticsTeamCount(includeDeleted bool) (int64, error) {
 	origCtx := s.Root.Store.Context()
 	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "TeamStore.AnalyticsTeamCount")
 	s.Root.Store.SetContext(newCtx)
@@ -6579,7 +6579,7 @@ func (s *OpenTracingLayerTeamStore) ClearCaches() {
 
 }
 
-func (s *OpenTracingLayerTeamStore) Get(id string) (*model.Team, *model.AppError) {
+func (s *OpenTracingLayerTeamStore) Get(id string) (*model.Team, error) {
 	origCtx := s.Root.Store.Context()
 	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "TeamStore.Get")
 	s.Root.Store.SetContext(newCtx)
@@ -6615,7 +6615,7 @@ func (s *OpenTracingLayerTeamStore) GetActiveMemberCount(teamId string, restrict
 	return result, err
 }
 
-func (s *OpenTracingLayerTeamStore) GetAll() ([]*model.Team, *model.AppError) {
+func (s *OpenTracingLayerTeamStore) GetAll() ([]*model.Team, error) {
 	origCtx := s.Root.Store.Context()
 	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "TeamStore.GetAll")
 	s.Root.Store.SetContext(newCtx)
@@ -6651,7 +6651,7 @@ func (s *OpenTracingLayerTeamStore) GetAllForExportAfter(limit int, afterId stri
 	return result, err
 }
 
-func (s *OpenTracingLayerTeamStore) GetAllPage(offset int, limit int) ([]*model.Team, *model.AppError) {
+func (s *OpenTracingLayerTeamStore) GetAllPage(offset int, limit int) ([]*model.Team, error) {
 	origCtx := s.Root.Store.Context()
 	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "TeamStore.GetAllPage")
 	s.Root.Store.SetContext(newCtx)
@@ -6669,7 +6669,7 @@ func (s *OpenTracingLayerTeamStore) GetAllPage(offset int, limit int) ([]*model.
 	return result, err
 }
 
-func (s *OpenTracingLayerTeamStore) GetAllPrivateTeamListing() ([]*model.Team, *model.AppError) {
+func (s *OpenTracingLayerTeamStore) GetAllPrivateTeamListing() ([]*model.Team, error) {
 	origCtx := s.Root.Store.Context()
 	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "TeamStore.GetAllPrivateTeamListing")
 	s.Root.Store.SetContext(newCtx)
@@ -6687,7 +6687,7 @@ func (s *OpenTracingLayerTeamStore) GetAllPrivateTeamListing() ([]*model.Team, *
 	return result, err
 }
 
-func (s *OpenTracingLayerTeamStore) GetAllPrivateTeamPageListing(offset int, limit int) ([]*model.Team, *model.AppError) {
+func (s *OpenTracingLayerTeamStore) GetAllPrivateTeamPageListing(offset int, limit int) ([]*model.Team, error) {
 	origCtx := s.Root.Store.Context()
 	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "TeamStore.GetAllPrivateTeamPageListing")
 	s.Root.Store.SetContext(newCtx)
@@ -6705,7 +6705,7 @@ func (s *OpenTracingLayerTeamStore) GetAllPrivateTeamPageListing(offset int, lim
 	return result, err
 }
 
-func (s *OpenTracingLayerTeamStore) GetAllPublicTeamPageListing(offset int, limit int) ([]*model.Team, *model.AppError) {
+func (s *OpenTracingLayerTeamStore) GetAllPublicTeamPageListing(offset int, limit int) ([]*model.Team, error) {
 	origCtx := s.Root.Store.Context()
 	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "TeamStore.GetAllPublicTeamPageListing")
 	s.Root.Store.SetContext(newCtx)
@@ -6723,7 +6723,7 @@ func (s *OpenTracingLayerTeamStore) GetAllPublicTeamPageListing(offset int, limi
 	return result, err
 }
 
-func (s *OpenTracingLayerTeamStore) GetAllTeamListing() ([]*model.Team, *model.AppError) {
+func (s *OpenTracingLayerTeamStore) GetAllTeamListing() ([]*model.Team, error) {
 	origCtx := s.Root.Store.Context()
 	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "TeamStore.GetAllTeamListing")
 	s.Root.Store.SetContext(newCtx)
@@ -6741,7 +6741,7 @@ func (s *OpenTracingLayerTeamStore) GetAllTeamListing() ([]*model.Team, *model.A
 	return result, err
 }
 
-func (s *OpenTracingLayerTeamStore) GetAllTeamPageListing(offset int, limit int) ([]*model.Team, *model.AppError) {
+func (s *OpenTracingLayerTeamStore) GetAllTeamPageListing(offset int, limit int) ([]*model.Team, error) {
 	origCtx := s.Root.Store.Context()
 	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "TeamStore.GetAllTeamPageListing")
 	s.Root.Store.SetContext(newCtx)
@@ -6759,7 +6759,7 @@ func (s *OpenTracingLayerTeamStore) GetAllTeamPageListing(offset int, limit int)
 	return result, err
 }
 
-func (s *OpenTracingLayerTeamStore) GetByInviteId(inviteId string) (*model.Team, *model.AppError) {
+func (s *OpenTracingLayerTeamStore) GetByInviteId(inviteId string) (*model.Team, error) {
 	origCtx := s.Root.Store.Context()
 	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "TeamStore.GetByInviteId")
 	s.Root.Store.SetContext(newCtx)
@@ -6777,7 +6777,7 @@ func (s *OpenTracingLayerTeamStore) GetByInviteId(inviteId string) (*model.Team,
 	return result, err
 }
 
-func (s *OpenTracingLayerTeamStore) GetByName(name string) (*model.Team, *model.AppError) {
+func (s *OpenTracingLayerTeamStore) GetByName(name string) (*model.Team, error) {
 	origCtx := s.Root.Store.Context()
 	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "TeamStore.GetByName")
 	s.Root.Store.SetContext(newCtx)
@@ -6795,7 +6795,7 @@ func (s *OpenTracingLayerTeamStore) GetByName(name string) (*model.Team, *model.
 	return result, err
 }
 
-func (s *OpenTracingLayerTeamStore) GetByNames(name []string) ([]*model.Team, *model.AppError) {
+func (s *OpenTracingLayerTeamStore) GetByNames(name []string) ([]*model.Team, error) {
 	origCtx := s.Root.Store.Context()
 	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "TeamStore.GetByNames")
 	s.Root.Store.SetContext(newCtx)
@@ -6939,7 +6939,7 @@ func (s *OpenTracingLayerTeamStore) GetTeamsByScheme(schemeId string, offset int
 	return result, err
 }
 
-func (s *OpenTracingLayerTeamStore) GetTeamsByUserId(userId string) ([]*model.Team, *model.AppError) {
+func (s *OpenTracingLayerTeamStore) GetTeamsByUserId(userId string) ([]*model.Team, error) {
 	origCtx := s.Root.Store.Context()
 	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "TeamStore.GetTeamsByUserId")
 	s.Root.Store.SetContext(newCtx)
@@ -7078,7 +7078,7 @@ func (s *OpenTracingLayerTeamStore) MigrateTeamMembers(fromTeamId string, fromUs
 	return result, err
 }
 
-func (s *OpenTracingLayerTeamStore) PermanentDelete(teamId string) *model.AppError {
+func (s *OpenTracingLayerTeamStore) PermanentDelete(teamId string) error {
 	origCtx := s.Root.Store.Context()
 	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "TeamStore.PermanentDelete")
 	s.Root.Store.SetContext(newCtx)
@@ -7186,7 +7186,7 @@ func (s *OpenTracingLayerTeamStore) ResetAllTeamSchemes() *model.AppError {
 	return err
 }
 
-func (s *OpenTracingLayerTeamStore) Save(team *model.Team) (*model.Team, *model.AppError) {
+func (s *OpenTracingLayerTeamStore) Save(team *model.Team) (*model.Team, error) {
 	origCtx := s.Root.Store.Context()
 	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "TeamStore.Save")
 	s.Root.Store.SetContext(newCtx)
@@ -7240,7 +7240,7 @@ func (s *OpenTracingLayerTeamStore) SaveMultipleMembers(members []*model.TeamMem
 	return result, err
 }
 
-func (s *OpenTracingLayerTeamStore) SearchAll(term string, opts *model.TeamSearch) ([]*model.Team, *model.AppError) {
+func (s *OpenTracingLayerTeamStore) SearchAll(term string, opts *model.TeamSearch) ([]*model.Team, error) {
 	origCtx := s.Root.Store.Context()
 	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "TeamStore.SearchAll")
 	s.Root.Store.SetContext(newCtx)
@@ -7258,7 +7258,7 @@ func (s *OpenTracingLayerTeamStore) SearchAll(term string, opts *model.TeamSearc
 	return result, err
 }
 
-func (s *OpenTracingLayerTeamStore) SearchAllPaged(term string, opts *model.TeamSearch) ([]*model.Team, int64, *model.AppError) {
+func (s *OpenTracingLayerTeamStore) SearchAllPaged(term string, opts *model.TeamSearch) ([]*model.Team, int64, error) {
 	origCtx := s.Root.Store.Context()
 	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "TeamStore.SearchAllPaged")
 	s.Root.Store.SetContext(newCtx)
@@ -7276,7 +7276,7 @@ func (s *OpenTracingLayerTeamStore) SearchAllPaged(term string, opts *model.Team
 	return result, resultVar1, err
 }
 
-func (s *OpenTracingLayerTeamStore) SearchOpen(term string) ([]*model.Team, *model.AppError) {
+func (s *OpenTracingLayerTeamStore) SearchOpen(term string) ([]*model.Team, error) {
 	origCtx := s.Root.Store.Context()
 	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "TeamStore.SearchOpen")
 	s.Root.Store.SetContext(newCtx)
@@ -7294,7 +7294,7 @@ func (s *OpenTracingLayerTeamStore) SearchOpen(term string) ([]*model.Team, *mod
 	return result, err
 }
 
-func (s *OpenTracingLayerTeamStore) SearchPrivate(term string) ([]*model.Team, *model.AppError) {
+func (s *OpenTracingLayerTeamStore) SearchPrivate(term string) ([]*model.Team, error) {
 	origCtx := s.Root.Store.Context()
 	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "TeamStore.SearchPrivate")
 	s.Root.Store.SetContext(newCtx)
@@ -7312,7 +7312,7 @@ func (s *OpenTracingLayerTeamStore) SearchPrivate(term string) ([]*model.Team, *
 	return result, err
 }
 
-func (s *OpenTracingLayerTeamStore) Update(team *model.Team) (*model.Team, *model.AppError) {
+func (s *OpenTracingLayerTeamStore) Update(team *model.Team) (*model.Team, error) {
 	origCtx := s.Root.Store.Context()
 	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "TeamStore.Update")
 	s.Root.Store.SetContext(newCtx)

store/retrylayer/retrylayer.go

@@ -5118,21 +5118,63 @@ func (s *RetryLayerTeamStore) AnalyticsGetTeamCountForScheme(schemeId string) (i
 
 }
 
-func (s *RetryLayerTeamStore) AnalyticsPrivateTeamCount() (int64, *model.AppError) {
+func (s *RetryLayerTeamStore) AnalyticsPrivateTeamCount() (int64, error) {
 
-	return s.TeamStore.AnalyticsPrivateTeamCount()
+	tries := 0
+	for {
+		result, err := s.TeamStore.AnalyticsPrivateTeamCount()
+		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) AnalyticsPublicTeamCount() (int64, *model.AppError) {
+func (s *RetryLayerTeamStore) AnalyticsPublicTeamCount() (int64, error) {
 
-	return s.TeamStore.AnalyticsPublicTeamCount()
+	tries := 0
+	for {
+		result, err := s.TeamStore.AnalyticsPublicTeamCount()
+		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) AnalyticsTeamCount(includeDeleted bool) (int64, *model.AppError) {
+func (s *RetryLayerTeamStore) AnalyticsTeamCount(includeDeleted bool) (int64, error) {
 
-	return s.TeamStore.AnalyticsTeamCount(includeDeleted)
+	tries := 0
+	for {
+		result, err := s.TeamStore.AnalyticsTeamCount(includeDeleted)
+		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
+		}
+	}
 
 }
 
@@ -5148,9 +5190,23 @@ func (s *RetryLayerTeamStore) ClearCaches() {
 
 }
 
-func (s *RetryLayerTeamStore) Get(id string) (*model.Team, *model.AppError) {
+func (s *RetryLayerTeamStore) Get(id string) (*model.Team, error) {
 
-	return s.TeamStore.Get(id)
+	tries := 0
+	for {
+		result, err := s.TeamStore.Get(id)
+		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
+		}
+	}
 
 }
 
@@ -5160,9 +5216,23 @@ func (s *RetryLayerTeamStore) GetActiveMemberCount(teamId string, restrictions *
 
 }
 
-func (s *RetryLayerTeamStore) GetAll() ([]*model.Team, *model.AppError) {
+func (s *RetryLayerTeamStore) GetAll() ([]*model.Team, error) {
 
-	return s.TeamStore.GetAll()
+	tries := 0
+	for {
+		result, err := s.TeamStore.GetAll()
+		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
+		}
+	}
 
 }
 
@@ -5172,57 +5242,183 @@ func (s *RetryLayerTeamStore) GetAllForExportAfter(limit int, afterId string) ([
 
 }
 
-func (s *RetryLayerTeamStore) GetAllPage(offset int, limit int) ([]*model.Team, *model.AppError) {
+func (s *RetryLayerTeamStore) GetAllPage(offset int, limit int) ([]*model.Team, error) {
 
-	return s.TeamStore.GetAllPage(offset, limit)
+	tries := 0
+	for {
+		result, err := s.TeamStore.GetAllPage(offset, limit)
+		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) GetAllPrivateTeamListing() ([]*model.Team, *model.AppError) {
+func (s *RetryLayerTeamStore) GetAllPrivateTeamListing() ([]*model.Team, error) {
 
-	return s.TeamStore.GetAllPrivateTeamListing()
+	tries := 0
+	for {
+		result, err := s.TeamStore.GetAllPrivateTeamListing()
+		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) GetAllPrivateTeamPageListing(offset int, limit int) ([]*model.Team, *model.AppError) {
+func (s *RetryLayerTeamStore) GetAllPrivateTeamPageListing(offset int, limit int) ([]*model.Team, error) {
 
-	return s.TeamStore.GetAllPrivateTeamPageListing(offset, limit)
+	tries := 0
+	for {
+		result, err := s.TeamStore.GetAllPrivateTeamPageListing(offset, limit)
+		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) GetAllPublicTeamPageListing(offset int, limit int) ([]*model.Team, *model.AppError) {
+func (s *RetryLayerTeamStore) GetAllPublicTeamPageListing(offset int, limit int) ([]*model.Team, error) {
 
-	return s.TeamStore.GetAllPublicTeamPageListing(offset, limit)
+	tries := 0
+	for {
+		result, err := s.TeamStore.GetAllPublicTeamPageListing(offset, limit)
+		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) GetAllTeamListing() ([]*model.Team, *model.AppError) {
+func (s *RetryLayerTeamStore) GetAllTeamListing() ([]*model.Team, error) {
 
-	return s.TeamStore.GetAllTeamListing()
+	tries := 0
+	for {
+		result, err := s.TeamStore.GetAllTeamListing()
+		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) GetAllTeamPageListing(offset int, limit int) ([]*model.Team, *model.AppError) {
+func (s *RetryLayerTeamStore) GetAllTeamPageListing(offset int, limit int) ([]*model.Team, error) {
 
-	return s.TeamStore.GetAllTeamPageListing(offset, limit)
+	tries := 0
+	for {
+		result, err := s.TeamStore.GetAllTeamPageListing(offset, limit)
+		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) GetByInviteId(inviteId string) (*model.Team, *model.AppError) {
+func (s *RetryLayerTeamStore) GetByInviteId(inviteId string) (*model.Team, error) {
 
-	return s.TeamStore.GetByInviteId(inviteId)
+	tries := 0
+	for {
+		result, err := s.TeamStore.GetByInviteId(inviteId)
+		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) GetByName(name string) (*model.Team, *model.AppError) {
+func (s *RetryLayerTeamStore) GetByName(name string) (*model.Team, error) {
 
-	return s.TeamStore.GetByName(name)
+	tries := 0
+	for {
+		result, err := s.TeamStore.GetByName(name)
+		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) GetByNames(name []string) ([]*model.Team, *model.AppError) {
+func (s *RetryLayerTeamStore) GetByNames(name []string) ([]*model.Team, error) {
 
-	return s.TeamStore.GetByNames(name)
+	tries := 0
+	for {
+		result, err := s.TeamStore.GetByNames(name)
+		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
+		}
+	}
 
 }
 
@@ -5268,9 +5464,23 @@ func (s *RetryLayerTeamStore) GetTeamsByScheme(schemeId string, offset int, limi
 
 }
 
-func (s *RetryLayerTeamStore) GetTeamsByUserId(userId string) ([]*model.Team, *model.AppError) {
+func (s *RetryLayerTeamStore) GetTeamsByUserId(userId string) ([]*model.Team, error) {
 
-	return s.TeamStore.GetTeamsByUserId(userId)
+	tries := 0
+	for {
+		result, err := s.TeamStore.GetTeamsByUserId(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
+		}
+	}
 
 }
 
@@ -5316,9 +5526,23 @@ func (s *RetryLayerTeamStore) MigrateTeamMembers(fromTeamId string, fromUserId s
 
 }
 
-func (s *RetryLayerTeamStore) PermanentDelete(teamId string) *model.AppError {
+func (s *RetryLayerTeamStore) PermanentDelete(teamId string) error {
 
-	return s.TeamStore.PermanentDelete(teamId)
+	tries := 0
+	for {
+		err := s.TeamStore.PermanentDelete(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
+		}
+	}
 
 }
 
@@ -5352,9 +5576,23 @@ func (s *RetryLayerTeamStore) ResetAllTeamSchemes() *model.AppError {
 
 }
 
-func (s *RetryLayerTeamStore) Save(team *model.Team) (*model.Team, *model.AppError) {
+func (s *RetryLayerTeamStore) Save(team *model.Team) (*model.Team, error) {
 
-	return s.TeamStore.Save(team)
+	tries := 0
+	for {
+		result, err := s.TeamStore.Save(team)
+		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
+		}
+	}
 
 }
 
@@ -5398,33 +5636,103 @@ func (s *RetryLayerTeamStore) SaveMultipleMembers(members []*model.TeamMember, m
 
 }
 
-func (s *RetryLayerTeamStore) SearchAll(term string, opts *model.TeamSearch) ([]*model.Team, *model.AppError) {
+func (s *RetryLayerTeamStore) SearchAll(term string, opts *model.TeamSearch) ([]*model.Team, error) {
 
-	return s.TeamStore.SearchAll(term, opts)
+	tries := 0
+	for {
+		result, err := s.TeamStore.SearchAll(term, opts)
+		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) SearchAllPaged(term string, opts *model.TeamSearch) ([]*model.Team, int64, *model.AppError) {
+func (s *RetryLayerTeamStore) SearchAllPaged(term string, opts *model.TeamSearch) ([]*model.Team, int64, error) {
 
-	return s.TeamStore.SearchAllPaged(term, opts)
+	tries := 0
+	for {
+		result, resultVar1, err := s.TeamStore.SearchAllPaged(term, opts)
+		if err == nil {
+			return result, resultVar1, nil
+		}
+		if !isRepeatableError(err) {
+			return result, resultVar1, err
+		}
+		tries++
+		if tries >= 3 {
+			err = errors.Wrap(err, "giving up after 3 consecutive repeatable transaction failures")
+			return result, resultVar1, err
+		}
+	}
 
 }
 
-func (s *RetryLayerTeamStore) SearchOpen(term string) ([]*model.Team, *model.AppError) {
+func (s *RetryLayerTeamStore) SearchOpen(term string) ([]*model.Team, error) {
 
-	return s.TeamStore.SearchOpen(term)
+	tries := 0
+	for {
+		result, err := s.TeamStore.SearchOpen(term)
+		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) SearchPrivate(term string) ([]*model.Team, *model.AppError) {
+func (s *RetryLayerTeamStore) SearchPrivate(term string) ([]*model.Team, error) {
 
-	return s.TeamStore.SearchPrivate(term)
+	tries := 0
+	for {
+		result, err := s.TeamStore.SearchPrivate(term)
+		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) Update(team *model.Team) (*model.Team, *model.AppError) {
+func (s *RetryLayerTeamStore) Update(team *model.Team) (*model.Team, error) {
 
-	return s.TeamStore.Update(team)
+	tries := 0
+	for {
+		result, err := s.TeamStore.Update(team)
+		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/layer.go

@@ -66,9 +66,9 @@ func (s *SearchStore) indexUser(user *model.User) {
 	for _, engine := range s.searchEngine.GetActiveEngines() {
 		if engine.IsIndexingEnabled() {
 			runIndexFn(engine, func(engineCopy searchengine.SearchEngineInterface) {
-				userTeams, err := s.Team().GetTeamsByUserId(user.Id)
-				if err != nil {
-					mlog.Error("Encountered error indexing user", mlog.String("user_id", user.Id), mlog.String("search_engine", engineCopy.GetName()), mlog.Err(err))
+				userTeams, nErr := s.Team().GetTeamsByUserId(user.Id)
+				if nErr != nil {
+					mlog.Error("Encountered error indexing user", mlog.String("user_id", user.Id), mlog.String("search_engine", engineCopy.GetName()), mlog.Err(nErr))
 					return
 				}
 

store/searchtest/helper.go

@@ -164,9 +164,9 @@ func (th *SearchTestHelper) deleteTeam(team *model.Team) error {
 	if appError != nil {
 		return errors.New(appError.Error())
 	}
-	appError = th.Store.Team().PermanentDelete(team.Id)
-	if appError != nil {
-		return errors.New(appError.Error())
+	err := th.Store.Team().PermanentDelete(team.Id)
+	if err != nil {
+		return err
 	}
 
 	return nil

store/sqlstore/group_store.go

@@ -475,7 +475,13 @@ func (s *SqlGroupStore) CreateGroupSyncable(groupSyncable *model.GroupSyncable)
 	switch groupSyncable.Type {
 	case model.GroupSyncableTypeTeam:
 		if _, err := s.Team().Get(groupSyncable.SyncableId); err != nil {
-			return nil, err
+			var nfErr *store.ErrNotFound
+			switch {
+			case errors.As(err, &nfErr):
+				return nil, model.NewAppError("CreateGroupSyncable", "app.team.get.find.app_error", nil, nfErr.Error(), http.StatusNotFound)
+			default:
+				return nil, model.NewAppError("CreateGroupSyncable", "app.team.get.finding.app_error", nil, err.Error(), http.StatusInternalServerError)
+			}
 		}
 
 		insertErr = s.GetMaster().Insert(groupSyncableToGroupTeam(groupSyncable))

store/sqlstore/team_store.go

@@ -250,10 +250,9 @@ func (s SqlTeamStore) createIndexesIfNotExists() {
 
 // Save adds the team to the database if a team with the same name does not already
 // exist in the database. It returns the team added if the operation is successful.
-func (s SqlTeamStore) Save(team *model.Team) (*model.Team, *model.AppError) {
+func (s SqlTeamStore) Save(team *model.Team) (*model.Team, error) {
 	if len(team.Id) > 0 {
-		return nil, model.NewAppError("SqlTeamStore.Save",
-			"store.sql_team.save.existing.app_error", nil, "id="+team.Id, http.StatusBadRequest)
+		return nil, store.NewErrInvalidInput("Team", "id", team.Id)
 	}
 
 	team.PreSave()
@@ -264,9 +263,9 @@ func (s SqlTeamStore) Save(team *model.Team) (*model.Team, *model.AppError) {
 
 	if err := s.GetMaster().Insert(team); err != nil {
 		if IsUniqueConstraintError(err, []string{"Name", "teams_name_key"}) {
-			return nil, model.NewAppError("SqlTeamStore.Save", "store.sql_team.save.domain_exists.app_error", nil, "id="+team.Id+", "+err.Error(), http.StatusBadRequest)
+			return nil, store.NewErrInvalidInput("Team", "id", team.Id)
 		}
-		return nil, model.NewAppError("SqlTeamStore.Save", "store.sql_team.save.app_error", nil, "id="+team.Id+", "+err.Error(), http.StatusInternalServerError)
+		return nil, errors.Wrapf(err, "failed to save Team with id=%s", team.Id)
 	}
 	return team, nil
 }
@@ -274,7 +273,7 @@ func (s SqlTeamStore) Save(team *model.Team) (*model.Team, *model.AppError) {
 // Update updates the details of the team passed as the parameter using the team Id
 // if the team exists in the database.
 // It returns the updated team if the operation is successful.
-func (s SqlTeamStore) Update(team *model.Team) (*model.Team, *model.AppError) {
+func (s SqlTeamStore) Update(team *model.Team) (*model.Team, error) {
 
 	team.PreUpdate()
 
@@ -284,12 +283,12 @@ func (s SqlTeamStore) Update(team *model.Team) (*model.Team, *model.AppError) {
 
 	oldResult, err := s.GetMaster().Get(model.Team{}, team.Id)
 	if err != nil {
-		return nil, model.NewAppError("SqlTeamStore.Update", "store.sql_team.update.finding.app_error", nil, "id="+team.Id+", "+err.Error(), http.StatusInternalServerError)
+		return nil, errors.Wrapf(err, "failed to get Team with id=%s", team.Id)
 
 	}
 
 	if oldResult == nil {
-		return nil, model.NewAppError("SqlTeamStore.Update", "store.sql_team.update.find.app_error", nil, "id="+team.Id, http.StatusBadRequest)
+		return nil, store.NewErrInvalidInput("Team", "id", team.Id)
 	}
 
 	oldTeam := oldResult.(*model.Team)
@@ -298,10 +297,10 @@ func (s SqlTeamStore) Update(team *model.Team) (*model.Team, *model.AppError) {
 
 	count, err := s.GetMaster().Update(team)
 	if err != nil {
-		return nil, model.NewAppError("SqlTeamStore.Update", "store.sql_team.update.updating.app_error", nil, "id="+team.Id+", "+err.Error(), http.StatusInternalServerError)
+		return nil, errors.Wrapf(err, "failed to update Team with id=%s", team.Id)
 	}
 	if count > 1 {
-		return nil, model.NewAppError("SqlTeamStore.Update", "store.sql_team.update.app_error", nil, "id="+team.Id, http.StatusInternalServerError)
+		return nil, errors.Wrapf(err, "multiple Teams updated with id=%s", team.Id)
 	}
 
 	return team, nil
@@ -310,13 +309,13 @@ func (s SqlTeamStore) Update(team *model.Team) (*model.Team, *model.AppError) {
 // Get returns from the database the team that matches the id provided as parameter.
 // If the team doesn't exist it returns a model.AppError with a
 // http.StatusNotFound in the StatusCode field.
-func (s SqlTeamStore) Get(id string) (*model.Team, *model.AppError) {
+func (s SqlTeamStore) Get(id string) (*model.Team, error) {
 	obj, err := s.GetReplica().Get(model.Team{}, id)
 	if err != nil {
-		return nil, model.NewAppError("SqlTeamStore.Get", "store.sql_team.get.finding.app_error", nil, "id="+id+", "+err.Error(), http.StatusInternalServerError)
+		return nil, errors.Wrapf(err, "failed to get Team with id=%s", id)
 	}
 	if obj == nil {
-		return nil, model.NewAppError("SqlTeamStore.Get", "store.sql_team.get.find.app_error", nil, "id="+id, http.StatusNotFound)
+		return nil, store.NewErrNotFound("Team", id)
 	}
 
 	return obj.(*model.Team), nil
@@ -325,20 +324,20 @@ func (s SqlTeamStore) Get(id string) (*model.Team, *model.AppError) {
 // GetByInviteId returns from the database the team that matches the inviteId provided as parameter.
 // If the parameter provided is empty or if there is no match in the database, it returns a model.AppError
 // with a http.StatusNotFound in the StatusCode field.
-func (s SqlTeamStore) GetByInviteId(inviteId string) (*model.Team, *model.AppError) {
+func (s SqlTeamStore) GetByInviteId(inviteId string) (*model.Team, error) {
 	team := model.Team{}
 
 	query, args, err := s.teamsQuery.Where(sq.Eq{"InviteId": inviteId}).ToSql()
 	if err != nil {
-		return nil, model.NewAppError("SqlTeamStore.GetByInviteId", "store.sql.build_query.app_error", nil, err.Error(), http.StatusInternalServerError)
+		return nil, errors.Wrap(err, "team_tosql")
 	}
 	err = s.GetReplica().SelectOne(&team, query, args...)
 	if err != nil {
-		return nil, model.NewAppError("SqlTeamStore.GetByInviteId", "store.sql_team.get_by_invite_id.finding.app_error", nil, "inviteId="+inviteId+", "+err.Error(), http.StatusNotFound)
+		return nil, store.NewErrNotFound("Team", fmt.Sprintf("inviteId=%s", inviteId))
 	}
 
 	if len(inviteId) == 0 || team.InviteId != inviteId {
-		return nil, model.NewAppError("SqlTeamStore.GetByInviteId", "store.sql_team.get_by_invite_id.find.app_error", nil, "inviteId="+inviteId, http.StatusNotFound)
+		return nil, store.NewErrNotFound("Team", fmt.Sprintf("inviteId=%s", inviteId))
 	}
 	return &team, nil
 }
@@ -346,42 +345,42 @@ func (s SqlTeamStore) GetByInviteId(inviteId string) (*model.Team, *model.AppErr
 // GetByName returns from the database the team that matches the name provided as parameter.
 // If there is no match in the database, it returns a model.AppError with a
 // http.StatusNotFound in the StatusCode field.
-func (s SqlTeamStore) GetByName(name string) (*model.Team, *model.AppError) {
+func (s SqlTeamStore) GetByName(name string) (*model.Team, error) {
 
 	team := model.Team{}
 	query, args, err := s.teamsQuery.Where(sq.Eq{"Name": name}).ToSql()
 	if err != nil {
-		return nil, model.NewAppError("SqlTeamStore.GetByName", "store.sql.build_query.app_error", nil, err.Error(), http.StatusInternalServerError)
+		return nil, errors.Wrap(err, "team_tosql")
 	}
 	err = s.GetReplica().SelectOne(&team, query, args...)
 	if err != nil {
 		if err == sql.ErrNoRows {
-			return nil, model.NewAppError("SqlTeamStore.GetByName", "store.sql_team.get_by_name.missing.app_error", nil, "name="+name+","+err.Error(), http.StatusNotFound)
+			return nil, store.NewErrNotFound("Team", fmt.Sprintf("name=%s", name))
 		}
-		return nil, model.NewAppError("SqlTeamStore.GetByName", "store.sql_team.get_by_name.app_error", nil, "name="+name+", "+err.Error(), http.StatusInternalServerError)
+		return nil, errors.Wrapf(err, "failed to find Team with name=%s", name)
 	}
 	return &team, nil
 }
 
-func (s SqlTeamStore) GetByNames(names []string) ([]*model.Team, *model.AppError) {
+func (s SqlTeamStore) GetByNames(names []string) ([]*model.Team, error) {
 	uniqueNames := utils.RemoveDuplicatesFromStringArray(names)
 
 	query, args, err := s.teamsQuery.Where(sq.Eq{"Name": uniqueNames}).ToSql()
 
 	if err != nil {
-		return nil, model.NewAppError("SqlTeamStore.GetByNames", "store.sql.build_query.app_error", nil, err.Error(), http.StatusInternalServerError)
+		return nil, errors.Wrap(err, "team_tosql")
 	}
 
 	teams := []*model.Team{}
 	_, err = s.GetReplica().Select(&teams, query, args...)
 	if err != nil {
 		if err == sql.ErrNoRows {
-			return nil, model.NewAppError("SqlTeamStore.GetByNames", "store.sql_team.get_by_names.missing.app_error", nil, err.Error(), http.StatusNotFound)
+			return nil, store.NewErrNotFound("Team", fmt.Sprintf("nameIn=%v", names))
 		}
-		return nil, model.NewAppError("SqlTeamStore.GetByNames", "store.sql_team.get_by_names.app_error", nil, err.Error(), http.StatusInternalServerError)
+		return nil, errors.Wrap(err, "failed to find Teams")
 	}
 	if len(teams) != len(uniqueNames) {
-		return nil, model.NewAppError("SqlTeamStore.GetByNames", "store.sql_team.get_by_names.missing.app_error", nil, "", http.StatusNotFound)
+		return nil, store.NewErrNotFound("Team", fmt.Sprintf("nameIn=%v", names))
 	}
 	return teams, nil
 }
@@ -465,41 +464,41 @@ func (s SqlTeamStore) teamSearchQuery(term string, opts *model.TeamSearch, count
 
 // SearchAll returns from the database a list of teams that match the Name or DisplayName
 // passed as the term search parameter.
-func (s SqlTeamStore) SearchAll(term string, opts *model.TeamSearch) ([]*model.Team, *model.AppError) {
+func (s SqlTeamStore) SearchAll(term string, opts *model.TeamSearch) ([]*model.Team, error) {
 	var teams []*model.Team
 
 	queryString, args, err := s.teamSearchQuery(term, opts, false).ToSql()
 	if err != nil {
-		return nil, model.NewAppError("SqlTeamStore.SearchAll", "store.sql.build_query.app_error", nil, err.Error(), http.StatusInternalServerError)
+		return nil, errors.Wrap(err, "team_tosql")
 	}
 
 	if _, err = s.GetReplica().Select(&teams, queryString, args...); err != nil {
-		return nil, model.NewAppError("SqlTeamStore.SearchAll", "store.sql_team.search_all_team.app_error", nil, "term="+term+", "+err.Error(), http.StatusInternalServerError)
+		return nil, errors.Wrapf(err, "failed to find Teams with term=%s", term)
 	}
 
 	return teams, nil
 }
 
 // SearchAllPaged returns a teams list and the total count of teams that matched the search.
-func (s SqlTeamStore) SearchAllPaged(term string, opts *model.TeamSearch) ([]*model.Team, int64, *model.AppError) {
+func (s SqlTeamStore) SearchAllPaged(term string, opts *model.TeamSearch) ([]*model.Team, int64, error) {
 	var teams []*model.Team
 	var totalCount int64
 
 	queryString, args, err := s.teamSearchQuery(term, opts, false).ToSql()
 	if err != nil {
-		return nil, 0, model.NewAppError("SqlTeamStore.SearchAllPage", "store.sql.build_query.app_error", nil, err.Error(), http.StatusInternalServerError)
+		return nil, 0, errors.Wrap(err, "team_tosql")
 	}
 	if _, err = s.GetReplica().Select(&teams, queryString, args...); err != nil {
-		return nil, 0, model.NewAppError("SqlTeamStore.SearchAllPage", "store.sql_team.search_all_team.app_error", nil, "term="+term+", "+err.Error(), http.StatusInternalServerError)
+		return nil, 0, errors.Wrapf(err, "failed to find Teams with term=%s", term)
 	}
 
 	queryString, args, err = s.teamSearchQuery(term, opts, true).ToSql()
 	if err != nil {
-		return nil, 0, model.NewAppError("SqlTeamStore.SearchAllPage", "store.sql.build_query.app_error", nil, err.Error(), http.StatusInternalServerError)
+		return nil, 0, errors.Wrap(err, "team_tosql")
 	}
 	totalCount, err = s.GetReplica().SelectInt(queryString, args...)
 	if err != nil {
-		return nil, 0, model.NewAppError("SqlTeamStore.SearchAllPage", "store.sql_team.search_all_team.app_error", nil, "term="+term+", "+err.Error(), http.StatusInternalServerError)
+		return nil, 0, errors.Wrapf(err, "failed to count Teams with term=%s", term)
 	}
 
 	return teams, totalCount, nil
@@ -507,7 +506,7 @@ func (s SqlTeamStore) SearchAllPaged(term string, opts *model.TeamSearch) ([]*mo
 
 // SearchOpen returns from the database a list of public teams that match the Name or DisplayName
 // passed as the term search parameter.
-func (s SqlTeamStore) SearchOpen(term string) ([]*model.Team, *model.AppError) {
+func (s SqlTeamStore) SearchOpen(term string) ([]*model.Team, error) {
 	var teams []*model.Team
 
 	term = sanitizeSearchTerm(term, "\\")
@@ -521,11 +520,11 @@ func (s SqlTeamStore) SearchOpen(term string) ([]*model.Team, *model.AppError) {
 
 	queryString, args, err := query.ToSql()
 	if err != nil {
-		return nil, model.NewAppError("SqlTeamStore.SearchOpen", "store.sql.build_query.app_error", nil, err.Error(), http.StatusInternalServerError)
+		return nil, errors.Wrap(err, "team_tosql")
 	}
 
 	if _, err = s.GetReplica().Select(&teams, queryString, args...); err != nil {
-		return nil, model.NewAppError("SqlTeamStore.SearchOpen", "store.sql_team.search_open_team.app_error", nil, "term="+term+", "+err.Error(), http.StatusInternalServerError)
+		return nil, errors.Wrapf(err, "failed to count Teams with term=%s", term)
 	}
 
 	return teams, nil
@@ -533,7 +532,7 @@ func (s SqlTeamStore) SearchOpen(term string) ([]*model.Team, *model.AppError) {
 
 // SearchPrivate returns from the database a list of private teams that match the Name or DisplayName
 // passed as the term search parameter.
-func (s SqlTeamStore) SearchPrivate(term string) ([]*model.Team, *model.AppError) {
+func (s SqlTeamStore) SearchPrivate(term string) ([]*model.Team, error) {
 	var teams []*model.Team
 
 	term = sanitizeSearchTerm(term, "\\")
@@ -547,34 +546,34 @@ func (s SqlTeamStore) SearchPrivate(term string) ([]*model.Team, *model.AppError
 
 	queryString, args, err := query.ToSql()
 	if err != nil {
-		return nil, model.NewAppError("SqlTeamStore.SearchPrivate", "store.sql.build_query.app_error", nil, err.Error(), http.StatusInternalServerError)
+		return nil, errors.Wrap(err, "team_tosql")
 	}
 
 	if _, err = s.GetReplica().Select(&teams, queryString, args...); err != nil {
-		return nil, model.NewAppError("SqlTeamStore.SearchPrivate", "store.sql_team.search_private_team.app_error", nil, "term="+term+", "+err.Error(), http.StatusInternalServerError)
+		return nil, errors.Wrapf(err, "failed to count Teams with term=%s", term)
 	}
 	return teams, nil
 }
 
 // GetAll returns all teams
-func (s SqlTeamStore) GetAll() ([]*model.Team, *model.AppError) {
+func (s SqlTeamStore) GetAll() ([]*model.Team, error) {
 	var teams []*model.Team
 
 	query, args, err := s.teamsQuery.OrderBy("DisplayName").ToSql()
 
 	if err != nil {
-		return nil, model.NewAppError("SqlTeamStore.GetAllTeams", "store.sql.build_query.app_error", nil, err.Error(), http.StatusInternalServerError)
+		return nil, errors.Wrap(err, "team_tosql")
 	}
 
 	_, err = s.GetReplica().Select(&teams, query, args...)
 	if err != nil {
-		return nil, model.NewAppError("SqlTeamStore.GetAllTeams", "store.sql_team.get_all.app_error", nil, err.Error(), http.StatusInternalServerError)
+		return nil, errors.Wrap(err, "failed to find Teams")
 	}
 	return teams, nil
 }
 
 // GetAllPage returns teams, up to a total limit passed as parameter and paginated by offset number passed as parameter.
-func (s SqlTeamStore) GetAllPage(offset int, limit int) ([]*model.Team, *model.AppError) {
+func (s SqlTeamStore) GetAllPage(offset int, limit int) ([]*model.Team, error) {
 	var teams []*model.Team
 
 	query, args, err := s.teamsQuery.
@@ -583,116 +582,115 @@ func (s SqlTeamStore) GetAllPage(offset int, limit int) ([]*model.Team, *model.A
 		Offset(uint64(offset)).ToSql()
 
 	if err != nil {
-		return nil, model.NewAppError("SqlTeamStore.GetAllTeams", "store.sql.build_query.app_error", nil, err.Error(), http.StatusInternalServerError)
+		return nil, errors.Wrap(err, "team_tosql")
 	}
 	if _, err = s.GetReplica().Select(&teams, query, args...); err != nil {
-		return nil, model.NewAppError("SqlTeamStore.GetAllTeams",
-			"store.sql_team.get_all.app_error", nil, err.Error(), http.StatusInternalServerError)
+		return nil, errors.Wrap(err, "failed to find Teams")
 	}
 
 	return teams, nil
 }
 
 // GetTeamsByUserId returns from the database all teams that userId belongs to.
-func (s SqlTeamStore) GetTeamsByUserId(userId string) ([]*model.Team, *model.AppError) {
+func (s SqlTeamStore) GetTeamsByUserId(userId string) ([]*model.Team, error) {
 	var teams []*model.Team
 	query, args, err := s.teamsQuery.
 		Join("TeamMembers ON TeamMembers.TeamId = Teams.Id").
 		Where(sq.Eq{"TeamMembers.UserId": userId, "TeamMembers.DeleteAt": 0, "Teams.DeleteAt": 0}).ToSql()
 
 	if err != nil {
-		return nil, model.NewAppError("SqlTeamStore.GetTeamsByUserId", "store.sql.build_query.app_error", nil, err.Error(), http.StatusInternalServerError)
+		return nil, errors.Wrap(err, "team_tosql")
 	}
 
 	if _, err = s.GetReplica().Select(&teams, query, args...); err != nil {
-		return nil, model.NewAppError("SqlTeamStore.GetTeamsByUserId", "store.sql_team.get_all.app_error", nil, err.Error(), http.StatusInternalServerError)
+		return nil, errors.Wrap(err, "failed to find Teams")
 	}
 
 	return teams, nil
 }
 
 // GetAllPrivateTeamListing returns all private teams.
-func (s SqlTeamStore) GetAllPrivateTeamListing() ([]*model.Team, *model.AppError) {
+func (s SqlTeamStore) GetAllPrivateTeamListing() ([]*model.Team, error) {
 	query, args, err := s.teamsQuery.Where(sq.Eq{"AllowOpenInvite": false}).
 		OrderBy("DisplayName").ToSql()
 	if err != nil {
-		return nil, model.NewAppError("SqlTeamStore.GetAllPrivateTeamListing", "store.sql.build_query.app_error", nil, err.Error(), http.StatusInternalServerError)
+		return nil, errors.Wrap(err, "team_tosql")
 	}
 	var data []*model.Team
 	if _, err = s.GetReplica().Select(&data, query, args...); err != nil {
-		return nil, model.NewAppError("SqlTeamStore.GetAllPrivateTeamListing", "store.sql_team.get_all_private_team_listing.app_error", nil, err.Error(), http.StatusInternalServerError)
+		return nil, errors.Wrap(err, "failed to find Teams")
 	}
 	return data, nil
 }
 
 // GetAllPublicTeamPageListing returns public teams, up to a total limit passed as parameter and paginated by offset number passed as parameter.
-func (s SqlTeamStore) GetAllPublicTeamPageListing(offset int, limit int) ([]*model.Team, *model.AppError) {
+func (s SqlTeamStore) GetAllPublicTeamPageListing(offset int, limit int) ([]*model.Team, error) {
 	query, args, err := s.teamsQuery.Where(sq.Eq{"AllowOpenInvite": true}).
 		OrderBy("DisplayName").
 		Limit(uint64(limit)).
 		Offset(uint64(offset)).ToSql()
 	if err != nil {
-		return nil, model.NewAppError("SqlTeamStore.GetAllPublicTeamPageListing", "store.sql.build_query.app_error", nil, err.Error(), http.StatusInternalServerError)
+		return nil, errors.Wrap(err, "team_tosql")
 	}
 
 	var data []*model.Team
 	if _, err = s.GetReplica().Select(&data, query, args...); err != nil {
-		return nil, model.NewAppError("SqlTeamStore.GetAllPublicTeamPageListing", "store.sql_team.get_all_private_team_listing.app_error", nil, err.Error(), http.StatusInternalServerError)
+		return nil, errors.Wrap(err, "failed to find Teams")
 	}
 
 	return data, nil
 }
 
 // GetAllPrivateTeamPageListing returns private teams, up to a total limit passed as paramater and paginated by offset number passed as parameter.
-func (s SqlTeamStore) GetAllPrivateTeamPageListing(offset int, limit int) ([]*model.Team, *model.AppError) {
+func (s SqlTeamStore) GetAllPrivateTeamPageListing(offset int, limit int) ([]*model.Team, error) {
 	query, args, err := s.teamsQuery.Where(sq.Eq{"AllowOpenInvite": false}).
 		OrderBy("DisplayName").
 		Limit(uint64(limit)).
 		Offset(uint64(offset)).ToSql()
 
 	if err != nil {
-		return nil, model.NewAppError("SqlTeamStore.GetAllPrivateTeamPageListing", "store.sql.build_query.app_error", nil, err.Error(), http.StatusInternalServerError)
+		return nil, errors.Wrap(err, "team_tosql")
 	}
 
 	var data []*model.Team
 	if _, err = s.GetReplica().Select(&data, query, args...); err != nil {
-		return nil, model.NewAppError("SqlTeamStore.GetAllPrivateTeamPageListing", "store.sql_team.get_all_private_team_page_listing.app_error", nil, err.Error(), http.StatusInternalServerError)
+		return nil, errors.Wrap(err, "failed to find Teams")
 	}
 
 	return data, nil
 }
 
 // GetAllTeamListing returns all public teams.
-func (s SqlTeamStore) GetAllTeamListing() ([]*model.Team, *model.AppError) {
+func (s SqlTeamStore) GetAllTeamListing() ([]*model.Team, error) {
 	query, args, err := s.teamsQuery.Where(sq.Eq{"AllowOpenInvite": true}).
 		OrderBy("DisplayName").ToSql()
 
 	if err != nil {
-		return nil, model.NewAppError("SqlTeamStore.GetAllTeamListing", "store.sql.build_query.app_error", nil, err.Error(), http.StatusInternalServerError)
+		return nil, errors.Wrap(err, "team_tosql")
 	}
 
 	var data []*model.Team
 	if _, err = s.GetReplica().Select(&data, query, args...); err != nil {
-		return nil, model.NewAppError("SqlTeamStore.GetAllTeamListing", "store.sql_team.get_all_team_listing.app_error", nil, err.Error(), http.StatusInternalServerError)
+		return nil, errors.Wrap(err, "failed to find Teams")
 	}
 
 	return data, nil
 }
 
 // GetAllTeamPageListing returns public teams, up to a total limit passed as parameter and paginated by offset number passed as parameter.
-func (s SqlTeamStore) GetAllTeamPageListing(offset int, limit int) ([]*model.Team, *model.AppError) {
+func (s SqlTeamStore) GetAllTeamPageListing(offset int, limit int) ([]*model.Team, error) {
 	query, args, err := s.teamsQuery.Where(sq.Eq{"AllowOpenInvite": true}).
 		OrderBy("DisplayName").
 		Limit(uint64(limit)).
 		Offset(uint64(offset)).ToSql()
 
 	if err != nil {
-		return nil, model.NewAppError("SqlTeamStore.GetAllTeamPageListing", "store.sql.build_query.app_error", nil, err.Error(), http.StatusInternalServerError)
+		return nil, errors.Wrap(err, "team_tosql")
 	}
 
 	var teams []*model.Team
 	if _, err = s.GetReplica().Select(&teams, query, args...); err != nil {
-		return nil, model.NewAppError("SqlTeamStore.GetAllTeamPageListing", "store.sql_team.get_all_team_listing.app_error", nil, err.Error(), http.StatusInternalServerError)
+		return nil, errors.Wrap(err, "failed to find Teams")
 	}
 
 	return teams, nil
@@ -700,58 +698,58 @@ func (s SqlTeamStore) GetAllTeamPageListing(offset int, limit int) ([]*model.Tea
 
 // PermanentDelete permanently deletes from the database the team entry that matches the teamId passed as parameter.
 // To soft-delete the team you can Update it with the DeleteAt field set to the current millisecond using model.GetMillis()
-func (s SqlTeamStore) PermanentDelete(teamId string) *model.AppError {
+func (s SqlTeamStore) PermanentDelete(teamId string) error {
 	sql, args, err := s.getQueryBuilder().
 		Delete("Teams").
 		Where(sq.Eq{"Id": teamId}).ToSql()
 	if err != nil {
-		return model.NewAppError("SqlTeamStore.Delete", "store.sql.build_query.app_error", nil, err.Error(), http.StatusInternalServerError)
+		return errors.Wrap(err, "team_tosql")
 	}
 	if _, err = s.GetMaster().Exec(sql, args...); err != nil {
-		return model.NewAppError("SqlTeamStore.Delete", "store.sql_team.permanent_delete.app_error", nil, "teamId="+teamId+", "+err.Error(), http.StatusInternalServerError)
+		return errors.Wrapf(err, "failed to delete Team with id=%s", teamId)
 	}
 	return nil
 }
 
 // AnalyticsPublicTeamCount returns the number of active public teams.
-func (s SqlTeamStore) AnalyticsPublicTeamCount() (int64, *model.AppError) {
+func (s SqlTeamStore) AnalyticsPublicTeamCount() (int64, error) {
 	query, args, err := s.getQueryBuilder().
 		Select("COUNT(*) FROM Teams").
 		Where(sq.Eq{"DeleteAt": 0, "AllowOpenInvite": true}).ToSql()
 
 	if err != nil {
-		return 0, model.NewAppError("SqlTeamStore.AnalyticsPublicTeamCount", "store.sql.build_query.app_error", nil, err.Error(), http.StatusInternalServerError)
+		return 0, errors.Wrap(err, "team_tosql")
 	}
 
 	c, err := s.GetReplica().SelectInt(query, args...)
 
 	if err != nil {
-		return int64(0), model.NewAppError("SqlTeamStore.AnalyticsPublicTeamCount", "store.sql_team.analytics_public_team_count.app_error", nil, err.Error(), http.StatusInternalServerError)
+		return int64(0), errors.Wrap(err, "failed to count Teams")
 	}
 
 	return c, nil
 }
 
 // AnalyticsPrivateTeamCount returns the number of active private teams.
-func (s SqlTeamStore) AnalyticsPrivateTeamCount() (int64, *model.AppError) {
+func (s SqlTeamStore) AnalyticsPrivateTeamCount() (int64, error) {
 	query, args, err := s.getQueryBuilder().
 		Select("COUNT(*) FROM Teams").
 		Where(sq.Eq{"DeleteAt": 0, "AllowOpenInvite": false}).ToSql()
 
 	if err != nil {
-		return 0, model.NewAppError("SqlTeamStore.AnalyticsPrivateTeamCount", "store.sql.build_query.app_error", nil, err.Error(), http.StatusInternalServerError)
+		return 0, errors.Wrap(err, "team_tosql")
 	}
 	c, err := s.GetReplica().SelectInt(query, args...)
 
 	if err != nil {
-		return int64(0), model.NewAppError("SqlTeamStore.AnalyticsPrivateTeamCount", "store.sql_team.analytics_private_team_count.app_error", nil, err.Error(), http.StatusInternalServerError)
+		return int64(0), errors.Wrap(err, "failed to count Teams")
 	}
 
 	return c, nil
 }
 
 // AnalyticsTeamCount returns the total number of teams including deleted teams if parameter passed is set to 'true'.
-func (s SqlTeamStore) AnalyticsTeamCount(includeDeleted bool) (int64, *model.AppError) {
+func (s SqlTeamStore) AnalyticsTeamCount(includeDeleted bool) (int64, error) {
 	query := s.getQueryBuilder().Select("COUNT(*) FROM Teams")
 	if !includeDeleted {
 		query = query.Where(sq.Eq{"DeleteAt": 0})
@@ -759,13 +757,13 @@ func (s SqlTeamStore) AnalyticsTeamCount(includeDeleted bool) (int64, *model.App
 
 	queryString, args, err := query.ToSql()
 	if err != nil {
-		return 0, model.NewAppError("SqlTeamStore.AnalyticsTeamCount", "store.sql.build_query.app_error", nil, err.Error(), http.StatusInternalServerError)
+		return 0, errors.Wrap(err, "team_tosql")
 	}
 
 	c, err := s.GetReplica().SelectInt(queryString, args...)
 
 	if err != nil {
-		return int64(0), model.NewAppError("SqlTeamStore.AnalyticsTeamCount", "store.sql_team.analytics_team_count.app_error", nil, err.Error(), http.StatusInternalServerError)
+		return int64(0), errors.Wrap(err, "failed to count Teams")
 	}
 
 	return c, nil
@@ -1466,7 +1464,7 @@ func (s SqlTeamStore) GetAllForExportAfter(limit int, afterId string) ([]*model.
 		return nil, model.NewAppError("SqlTeamStore.GetAllTeams", "store.sql.build_query.app_error", nil, err.Error(), http.StatusInternalServerError)
 	}
 	if _, err = s.GetReplica().Select(&data, query, args...); err != nil {
-		return nil, model.NewAppError("SqlTeamStore.GetAllTeams", "store.sql_team.get_all.app_error", nil, err.Error(), http.StatusInternalServerError)
+		return nil, model.NewAppError("SqlTeamStore.GetAllTeams", "app.team.get_all.app_error", nil, err.Error(), http.StatusInternalServerError)
 	}
 
 	return data, nil

store/store.go

@@ -69,28 +69,28 @@ type Store interface {
 }
 
 type TeamStore interface {
-	Save(team *model.Team) (*model.Team, *model.AppError)
-	Update(team *model.Team) (*model.Team, *model.AppError)
-	Get(id string) (*model.Team, *model.AppError)
-	GetByName(name string) (*model.Team, *model.AppError)
-	GetByNames(name []string) ([]*model.Team, *model.AppError)
-	SearchAll(term string, opts *model.TeamSearch) ([]*model.Team, *model.AppError)
-	SearchAllPaged(term string, opts *model.TeamSearch) ([]*model.Team, int64, *model.AppError)
-	SearchOpen(term string) ([]*model.Team, *model.AppError)
-	SearchPrivate(term string) ([]*model.Team, *model.AppError)
-	GetAll() ([]*model.Team, *model.AppError)
-	GetAllPage(offset int, limit int) ([]*model.Team, *model.AppError)
-	GetAllPrivateTeamListing() ([]*model.Team, *model.AppError)
-	GetAllPrivateTeamPageListing(offset int, limit int) ([]*model.Team, *model.AppError)
-	GetAllPublicTeamPageListing(offset int, limit int) ([]*model.Team, *model.AppError)
-	GetAllTeamListing() ([]*model.Team, *model.AppError)
-	GetAllTeamPageListing(offset int, limit int) ([]*model.Team, *model.AppError)
-	GetTeamsByUserId(userId string) ([]*model.Team, *model.AppError)
-	GetByInviteId(inviteId string) (*model.Team, *model.AppError)
-	PermanentDelete(teamId string) *model.AppError
-	AnalyticsTeamCount(includeDeleted bool) (int64, *model.AppError)
-	AnalyticsPublicTeamCount() (int64, *model.AppError)
-	AnalyticsPrivateTeamCount() (int64, *model.AppError)
+	Save(team *model.Team) (*model.Team, error)
+	Update(team *model.Team) (*model.Team, error)
+	Get(id string) (*model.Team, error)
+	GetByName(name string) (*model.Team, error)
+	GetByNames(name []string) ([]*model.Team, error)
+	SearchAll(term string, opts *model.TeamSearch) ([]*model.Team, error)
+	SearchAllPaged(term string, opts *model.TeamSearch) ([]*model.Team, int64, error)
+	SearchOpen(term string) ([]*model.Team, error)
+	SearchPrivate(term string) ([]*model.Team, error)
+	GetAll() ([]*model.Team, error)
+	GetAllPage(offset int, limit int) ([]*model.Team, error)
+	GetAllPrivateTeamListing() ([]*model.Team, error)
+	GetAllPrivateTeamPageListing(offset int, limit int) ([]*model.Team, error)
+	GetAllPublicTeamPageListing(offset int, limit int) ([]*model.Team, error)
+	GetAllTeamListing() ([]*model.Team, error)
+	GetAllTeamPageListing(offset int, limit int) ([]*model.Team, error)
+	GetTeamsByUserId(userId string) ([]*model.Team, error)
+	GetByInviteId(inviteId string) (*model.Team, error)
+	PermanentDelete(teamId string) error
+	AnalyticsTeamCount(includeDeleted bool) (int64, error)
+	AnalyticsPublicTeamCount() (int64, error)
+	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)

store/storetest/channel_store.go

@@ -925,8 +925,8 @@ func testChannelSaveMember(t *testing.T, ss store.Store) {
 			Type:        model.TEAM_OPEN,
 		}
 
-		team, err = ss.Team().Save(team)
-		require.Nil(t, err)
+		team, nErr := ss.Team().Save(team)
+		require.Nil(t, nErr)
 
 		channel := &model.Channel{
 			DisplayName: "DisplayName",
@@ -934,7 +934,7 @@ func testChannelSaveMember(t *testing.T, ss store.Store) {
 			Type:        model.CHANNEL_OPEN,
 			TeamId:      team.Id,
 		}
-		channel, nErr := ss.Channel().Save(channel, -1)
+		channel, nErr = ss.Channel().Save(channel, -1)
 		require.Nil(t, nErr)
 		defer func() { ss.Channel().PermanentDelete(channel.Id) }()
 
@@ -1086,8 +1086,8 @@ func testChannelSaveMember(t *testing.T, ss store.Store) {
 			SchemeId:    &ts.Id,
 		}
 
-		team, err = ss.Team().Save(team)
-		require.Nil(t, err)
+		team, nErr = ss.Team().Save(team)
+		require.Nil(t, nErr)
 
 		channel := &model.Channel{
 			DisplayName: "DisplayName",
@@ -1246,8 +1246,8 @@ func testChannelSaveMember(t *testing.T, ss store.Store) {
 			Type:        model.TEAM_OPEN,
 		}
 
-		team, err = ss.Team().Save(team)
-		require.Nil(t, err)
+		team, nErr = ss.Team().Save(team)
+		require.Nil(t, nErr)
 
 		channel, nErr := ss.Channel().Save(&model.Channel{
 			DisplayName: "DisplayName",
@@ -1422,8 +1422,8 @@ func testChannelSaveMultipleMembers(t *testing.T, ss store.Store) {
 			Type:        model.TEAM_OPEN,
 		}
 
-		team, err = ss.Team().Save(team)
-		require.Nil(t, err)
+		team, nErr := ss.Team().Save(team)
+		require.Nil(t, nErr)
 
 		channel := &model.Channel{
 			DisplayName: "DisplayName",
@@ -1431,7 +1431,7 @@ func testChannelSaveMultipleMembers(t *testing.T, ss store.Store) {
 			Type:        model.CHANNEL_OPEN,
 			TeamId:      team.Id,
 		}
-		channel, nErr := ss.Channel().Save(channel, -1)
+		channel, nErr = ss.Channel().Save(channel, -1)
 		require.Nil(t, nErr)
 		defer func() { ss.Channel().PermanentDelete(channel.Id) }()
 
@@ -1597,8 +1597,8 @@ func testChannelSaveMultipleMembers(t *testing.T, ss store.Store) {
 			SchemeId:    &ts.Id,
 		}
 
-		team, err = ss.Team().Save(team)
-		require.Nil(t, err)
+		team, nErr = ss.Team().Save(team)
+		require.Nil(t, nErr)
 
 		channel := &model.Channel{
 			DisplayName: "DisplayName",
@@ -1771,8 +1771,8 @@ func testChannelSaveMultipleMembers(t *testing.T, ss store.Store) {
 			Type:        model.TEAM_OPEN,
 		}
 
-		team, err = ss.Team().Save(team)
-		require.Nil(t, err)
+		team, nErr = ss.Team().Save(team)
+		require.Nil(t, nErr)
 
 		channel, nErr := ss.Channel().Save(&model.Channel{
 			DisplayName: "DisplayName",
@@ -1948,8 +1948,8 @@ func testChannelUpdateMember(t *testing.T, ss store.Store) {
 			Type:        model.TEAM_OPEN,
 		}
 
-		team, err = ss.Team().Save(team)
-		require.Nil(t, err)
+		team, nErr := ss.Team().Save(team)
+		require.Nil(t, nErr)
 
 		channel := &model.Channel{
 			DisplayName: "DisplayName",
@@ -1957,7 +1957,7 @@ func testChannelUpdateMember(t *testing.T, ss store.Store) {
 			Type:        model.CHANNEL_OPEN,
 			TeamId:      team.Id,
 		}
-		channel, nErr := ss.Channel().Save(channel, -1)
+		channel, nErr = ss.Channel().Save(channel, -1)
 		require.Nil(t, nErr)
 		defer func() { ss.Channel().PermanentDelete(channel.Id) }()
 
@@ -2111,8 +2111,8 @@ func testChannelUpdateMember(t *testing.T, ss store.Store) {
 			SchemeId:    &ts.Id,
 		}
 
-		team, err = ss.Team().Save(team)
-		require.Nil(t, err)
+		team, nErr = ss.Team().Save(team)
+		require.Nil(t, nErr)
 
 		channel := &model.Channel{
 			DisplayName: "DisplayName",
@@ -2273,8 +2273,8 @@ func testChannelUpdateMember(t *testing.T, ss store.Store) {
 			Type:        model.TEAM_OPEN,
 		}
 
-		team, err = ss.Team().Save(team)
-		require.Nil(t, err)
+		team, nErr = ss.Team().Save(team)
+		require.Nil(t, nErr)
 
 		channel, nErr := ss.Channel().Save(&model.Channel{
 			DisplayName: "DisplayName",
@@ -2451,8 +2451,8 @@ func testChannelUpdateMultipleMembers(t *testing.T, ss store.Store) {
 			Type:        model.TEAM_OPEN,
 		}
 
-		team, err = ss.Team().Save(team)
-		require.Nil(t, err)
+		team, nErr := ss.Team().Save(team)
+		require.Nil(t, nErr)
 
 		channel := &model.Channel{
 			DisplayName: "DisplayName",
@@ -2460,7 +2460,7 @@ func testChannelUpdateMultipleMembers(t *testing.T, ss store.Store) {
 			Type:        model.CHANNEL_OPEN,
 			TeamId:      team.Id,
 		}
-		channel, nErr := ss.Channel().Save(channel, -1)
+		channel, nErr = ss.Channel().Save(channel, -1)
 		require.Nil(t, nErr)
 		defer func() { ss.Channel().PermanentDelete(channel.Id) }()
 
@@ -2621,8 +2621,8 @@ func testChannelUpdateMultipleMembers(t *testing.T, ss store.Store) {
 			SchemeId:    &ts.Id,
 		}
 
-		team, err = ss.Team().Save(team)
-		require.Nil(t, err)
+		team, nErr = ss.Team().Save(team)
+		require.Nil(t, nErr)
 
 		channel := &model.Channel{
 			DisplayName: "DisplayName",
@@ -2790,8 +2790,8 @@ func testChannelUpdateMultipleMembers(t *testing.T, ss store.Store) {
 			Type:        model.TEAM_OPEN,
 		}
 
-		team, err = ss.Team().Save(team)
-		require.Nil(t, err)
+		team, nErr = ss.Team().Save(team)
+		require.Nil(t, nErr)
 
 		channel, nErr := ss.Channel().Save(&model.Channel{
 			DisplayName: "DisplayName",

store/storetest/compliance_store.go

@@ -31,13 +31,13 @@ func cleanupStoreState(t *testing.T, ss store.Store) {
 	allChannels, nErr := ss.Channel().GetAllChannels(0, 100000, store.ChannelSearchOpts{IncludeDeleted: true})
 	require.Nilf(t, nErr, "error cleaning all test channels: %v", nErr)
 	for _, channel := range *allChannels {
-		nErr := ss.Channel().PermanentDelete(channel.Id)
+		nErr = ss.Channel().PermanentDelete(channel.Id)
 		require.Nil(t, nErr, "failed cleaning up test channel %s", channel.Id)
 	}
 
 	//remove existing teams
-	allTeams, err := ss.Team().GetAll()
-	require.Nilf(t, err, "error cleaning all test teams: %v", err)
+	allTeams, nErr := ss.Team().GetAll()
+	require.Nilf(t, nErr, "error cleaning all test teams: %v", nErr)
 	for _, team := range allTeams {
 		err := ss.Team().PermanentDelete(team.Id)
 		require.Nil(t, err, "failed cleaning up test team %s", team.Id)

store/storetest/group_store.go

@@ -1071,8 +1071,8 @@ func testCreateGroupSyncable(t *testing.T, ss store.Store) {
 		Email:           "success+" + model.NewId() + "@simulator.amazonses.com",
 		Type:            model.TEAM_OPEN,
 	}
-	team, err := ss.Team().Save(t1)
-	require.Nil(t, err)
+	team, nErr := ss.Team().Save(t1)
+	require.Nil(t, nErr)
 
 	// New GroupSyncable, happy path
 	gt1 := model.NewGroupTeam(group.Id, team.Id, false)
@@ -1108,8 +1108,8 @@ func testGetGroupSyncable(t *testing.T, ss store.Store) {
 		Email:           "success+" + model.NewId() + "@simulator.amazonses.com",
 		Type:            model.TEAM_OPEN,
 	}
-	team, err := ss.Team().Save(t1)
-	require.Nil(t, err)
+	team, nErr := ss.Team().Save(t1)
+	require.Nil(t, nErr)
 
 	// Create GroupSyncable
 	gt1 := model.NewGroupTeam(group.Id, team.Id, false)
@@ -1157,8 +1157,8 @@ func testGetAllGroupSyncablesByGroup(t *testing.T, ss store.Store) {
 			Type:            model.TEAM_OPEN,
 		}
 		var team *model.Team
-		team, err = ss.Team().Save(t1)
-		require.Nil(t, err)
+		team, nErr := ss.Team().Save(t1)
+		require.Nil(t, nErr)
 
 		// create groupteam
 		var groupTeam *model.GroupSyncable
@@ -1208,8 +1208,8 @@ func testUpdateGroupSyncable(t *testing.T, ss store.Store) {
 		Email:           "success+" + model.NewId() + "@simulator.amazonses.com",
 		Type:            model.TEAM_OPEN,
 	}
-	team, err := ss.Team().Save(t1)
-	require.Nil(t, err)
+	team, nErr := ss.Team().Save(t1)
+	require.Nil(t, nErr)
 
 	// New GroupSyncable, happy path
 	gt1 := model.NewGroupTeam(group.Id, team.Id, false)
@@ -1274,8 +1274,8 @@ func testDeleteGroupSyncable(t *testing.T, ss store.Store) {
 		Email:           "success+" + model.NewId() + "@simulator.amazonses.com",
 		Type:            model.TEAM_OPEN,
 	}
-	team, err := ss.Team().Save(t1)
-	require.Nil(t, err)
+	team, nErr := ss.Team().Save(t1)
+	require.Nil(t, nErr)
 
 	// Create GroupSyncable
 	gt1 := model.NewGroupTeam(group.Id, team.Id, false)
@@ -1339,8 +1339,8 @@ func testTeamMembersToAdd(t *testing.T, ss store.Store) {
 		Email:           "success+" + model.NewId() + "@simulator.amazonses.com",
 		Type:            model.TEAM_OPEN,
 	}
-	team, err = ss.Team().Save(team)
-	require.Nil(t, err)
+	team, nErr := ss.Team().Save(team)
+	require.Nil(t, nErr)
 
 	// Create GroupTeam
 	syncable, err := ss.Group().CreateGroupSyncable(model.NewGroupTeam(group.Id, team.Id, true))
@@ -1416,16 +1416,16 @@ func testTeamMembersToAdd(t *testing.T, ss store.Store) {
 
 	// No result if Team deleted
 	team.DeleteAt = model.GetMillis()
-	team, err = ss.Team().Update(team)
-	require.Nil(t, err)
+	team, nErr = ss.Team().Update(team)
+	require.Nil(t, nErr)
 	teamMembers, err = ss.Group().TeamMembersToAdd(0, nil)
 	require.Nil(t, err)
 	require.Empty(t, teamMembers)
 
 	// reset state of team and verify
 	team.DeleteAt = 0
-	team, err = ss.Team().Update(team)
-	require.Nil(t, err)
+	team, nErr = ss.Team().Update(team)
+	require.Nil(t, nErr)
 	teamMembers, err = ss.Group().TeamMembersToAdd(0, nil)
 	require.Nil(t, err)
 	require.Len(t, teamMembers, 1)
@@ -1459,7 +1459,7 @@ func testTeamMembersToAdd(t *testing.T, ss store.Store) {
 	require.Len(t, teamMembers, 1)
 
 	// adding team membership stops returning result
-	_, nErr := ss.Team().SaveMember(&model.TeamMember{
+	_, nErr = ss.Team().SaveMember(&model.TeamMember{
 		TeamId: team.Id,
 		UserId: user.Id,
 	}, 999)
@@ -1524,8 +1524,8 @@ func testTeamMembersToAddSingleTeam(t *testing.T, ss store.Store) {
 		Email:           "success+" + model.NewId() + "@simulator.amazonses.com",
 		Type:            model.TEAM_OPEN,
 	}
-	team1, err = ss.Team().Save(team1)
-	require.Nil(t, err)
+	team1, nErr := ss.Team().Save(team1)
+	require.Nil(t, nErr)
 
 	team2 := &model.Team{
 		DisplayName:     "Name",
@@ -1537,8 +1537,8 @@ func testTeamMembersToAddSingleTeam(t *testing.T, ss store.Store) {
 		Email:           "success+" + model.NewId() + "@simulator.amazonses.com",
 		Type:            model.TEAM_OPEN,
 	}
-	team2, err = ss.Team().Save(team2)
-	require.Nil(t, err)
+	team2, nErr = ss.Team().Save(team2)
+	require.Nil(t, nErr)
 
 	_, err = ss.Group().CreateGroupSyncable(model.NewGroupTeam(group1.Id, team1.Id, true))
 	require.Nil(t, err)
@@ -1916,8 +1916,8 @@ func testTeamMembersToRemoveSingleTeam(t *testing.T, ss store.Store) {
 		Type:             model.TEAM_OPEN,
 		GroupConstrained: model.NewBool(true),
 	}
-	team1, err = ss.Team().Save(team1)
-	require.Nil(t, err)
+	team1, nErr := ss.Team().Save(team1)
+	require.Nil(t, nErr)
 
 	team2 := &model.Team{
 		DisplayName:      "Name",
@@ -1930,18 +1930,18 @@ func testTeamMembersToRemoveSingleTeam(t *testing.T, ss store.Store) {
 		Type:             model.TEAM_OPEN,
 		GroupConstrained: model.NewBool(true),
 	}
-	team2, err = ss.Team().Save(team2)
-	require.Nil(t, err)
+	team2, nErr = ss.Team().Save(team2)
+	require.Nil(t, nErr)
 
 	for _, user := range []*model.User{user1, user2} {
-		_, nErr := ss.Team().SaveMember(&model.TeamMember{
+		_, nErr = ss.Team().SaveMember(&model.TeamMember{
 			TeamId: team1.Id,
 			UserId: user.Id,
 		}, 999)
 		require.Nil(t, nErr)
 	}
 
-	_, nErr := ss.Team().SaveMember(&model.TeamMember{
+	_, nErr = ss.Team().SaveMember(&model.TeamMember{
 		TeamId: team2.Id,
 		UserId: user3.Id,
 	}, 999)
@@ -2189,8 +2189,8 @@ func pendingMemberRemovalsDataSetup(t *testing.T, ss store.Store) *removalsData
 		Type:             model.TEAM_INVITE,
 		GroupConstrained: model.NewBool(true),
 	}
-	teamConstrained, err = ss.Team().Save(teamConstrained)
-	require.Nil(t, err)
+	teamConstrained, nErr = ss.Team().Save(teamConstrained)
+	require.Nil(t, nErr)
 
 	teamUnconstrained := &model.Team{
 		DisplayName:     "Name",
@@ -2202,8 +2202,8 @@ func pendingMemberRemovalsDataSetup(t *testing.T, ss store.Store) *removalsData
 		Email:           "success+" + model.NewId() + "@simulator.amazonses.com",
 		Type:            model.TEAM_INVITE,
 	}
-	teamUnconstrained, err = ss.Team().Save(teamUnconstrained)
-	require.Nil(t, err)
+	teamUnconstrained, nErr = ss.Team().Save(teamUnconstrained)
+	require.Nil(t, nErr)
 
 	// create groupteams
 	_, err = ss.Group().CreateGroupSyncable(model.NewGroupTeam(group.Id, teamConstrained.Id, true))
@@ -3900,8 +3900,8 @@ func groupTestAdminRoleGroupsForSyncableMemberTeam(t *testing.T, ss store.Store)
 		Name:        "zz" + model.NewId(),
 		Type:        model.CHANNEL_OPEN,
 	}
-	team, err = ss.Team().Save(team)
-	require.Nil(t, err)
+	team, nErr := ss.Team().Save(team)
+	require.Nil(t, nErr)
 
 	_, err = ss.Group().CreateGroupSyncable(&model.GroupSyncable{
 		AutoAdd:     true,
@@ -4003,8 +4003,8 @@ func groupTestPermittedSyncableAdminsTeam(t *testing.T, ss store.Store) {
 		Name:        "zz" + model.NewId(),
 		Type:        model.CHANNEL_OPEN,
 	}
-	team, err = ss.Team().Save(team)
-	require.Nil(t, err)
+	team, nErr := ss.Team().Save(team)
+	require.Nil(t, nErr)
 
 	_, err = ss.Group().CreateGroupSyncable(&model.GroupSyncable{
 		AutoAdd:     true,

store/storetest/mocks/TeamStore.go

@@ -38,7 +38,7 @@ func (_m *TeamStore) AnalyticsGetTeamCountForScheme(schemeId string) (int64, *mo
 }
 
 // AnalyticsPrivateTeamCount provides a mock function with given fields:
-func (_m *TeamStore) AnalyticsPrivateTeamCount() (int64, *model.AppError) {
+func (_m *TeamStore) AnalyticsPrivateTeamCount() (int64, error) {
 	ret := _m.Called()
 
 	var r0 int64
@@ -48,20 +48,18 @@ func (_m *TeamStore) AnalyticsPrivateTeamCount() (int64, *model.AppError) {
 		r0 = ret.Get(0).(int64)
 	}
 
-	var r1 *model.AppError
-	if rf, ok := ret.Get(1).(func() *model.AppError); ok {
+	var r1 error
+	if rf, ok := ret.Get(1).(func() error); ok {
 		r1 = rf()
 	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*model.AppError)
-		}
+		r1 = ret.Error(1)
 	}
 
 	return r0, r1
 }
 
 // AnalyticsPublicTeamCount provides a mock function with given fields:
-func (_m *TeamStore) AnalyticsPublicTeamCount() (int64, *model.AppError) {
+func (_m *TeamStore) AnalyticsPublicTeamCount() (int64, error) {
 	ret := _m.Called()
 
 	var r0 int64
@@ -71,20 +69,18 @@ func (_m *TeamStore) AnalyticsPublicTeamCount() (int64, *model.AppError) {
 		r0 = ret.Get(0).(int64)
 	}
 
-	var r1 *model.AppError
-	if rf, ok := ret.Get(1).(func() *model.AppError); ok {
+	var r1 error
+	if rf, ok := ret.Get(1).(func() error); ok {
 		r1 = rf()
 	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*model.AppError)
-		}
+		r1 = ret.Error(1)
 	}
 
 	return r0, r1
 }
 
 // AnalyticsTeamCount provides a mock function with given fields: includeDeleted
-func (_m *TeamStore) AnalyticsTeamCount(includeDeleted bool) (int64, *model.AppError) {
+func (_m *TeamStore) AnalyticsTeamCount(includeDeleted bool) (int64, error) {
 	ret := _m.Called(includeDeleted)
 
 	var r0 int64
@@ -94,13 +90,11 @@ func (_m *TeamStore) AnalyticsTeamCount(includeDeleted bool) (int64, *model.AppE
 		r0 = ret.Get(0).(int64)
 	}
 
-	var r1 *model.AppError
-	if rf, ok := ret.Get(1).(func(bool) *model.AppError); ok {
+	var r1 error
+	if rf, ok := ret.Get(1).(func(bool) error); ok {
 		r1 = rf(includeDeleted)
 	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*model.AppError)
-		}
+		r1 = ret.Error(1)
 	}
 
 	return r0, r1
@@ -128,7 +122,7 @@ func (_m *TeamStore) ClearCaches() {
 }
 
 // Get provides a mock function with given fields: id
-func (_m *TeamStore) Get(id string) (*model.Team, *model.AppError) {
+func (_m *TeamStore) Get(id string) (*model.Team, error) {
 	ret := _m.Called(id)
 
 	var r0 *model.Team
@@ -140,13 +134,11 @@ func (_m *TeamStore) Get(id string) (*model.Team, *model.AppError) {
 		}
 	}
 
-	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(id)
 	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*model.AppError)
-		}
+		r1 = ret.Error(1)
 	}
 
 	return r0, r1
@@ -176,7 +168,7 @@ func (_m *TeamStore) GetActiveMemberCount(teamId string, restrictions *model.Vie
 }
 
 // GetAll provides a mock function with given fields:
-func (_m *TeamStore) GetAll() ([]*model.Team, *model.AppError) {
+func (_m *TeamStore) GetAll() ([]*model.Team, error) {
 	ret := _m.Called()
 
 	var r0 []*model.Team
@@ -188,13 +180,11 @@ func (_m *TeamStore) GetAll() ([]*model.Team, *model.AppError) {
 		}
 	}
 
-	var r1 *model.AppError
-	if rf, ok := ret.Get(1).(func() *model.AppError); ok {
+	var r1 error
+	if rf, ok := ret.Get(1).(func() error); ok {
 		r1 = rf()
 	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*model.AppError)
-		}
+		r1 = ret.Error(1)
 	}
 
 	return r0, r1
@@ -226,7 +216,7 @@ func (_m *TeamStore) GetAllForExportAfter(limit int, afterId string) ([]*model.T
 }
 
 // GetAllPage provides a mock function with given fields: offset, limit
-func (_m *TeamStore) GetAllPage(offset int, limit int) ([]*model.Team, *model.AppError) {
+func (_m *TeamStore) GetAllPage(offset int, limit int) ([]*model.Team, error) {
 	ret := _m.Called(offset, limit)
 
 	var r0 []*model.Team
@@ -238,20 +228,18 @@ func (_m *TeamStore) GetAllPage(offset int, limit int) ([]*model.Team, *model.Ap
 		}
 	}
 
-	var r1 *model.AppError
-	if rf, ok := ret.Get(1).(func(int, int) *model.AppError); ok {
+	var r1 error
+	if rf, ok := ret.Get(1).(func(int, int) error); ok {
 		r1 = rf(offset, limit)
 	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*model.AppError)
-		}
+		r1 = ret.Error(1)
 	}
 
 	return r0, r1
 }
 
 // GetAllPrivateTeamListing provides a mock function with given fields:
-func (_m *TeamStore) GetAllPrivateTeamListing() ([]*model.Team, *model.AppError) {
+func (_m *TeamStore) GetAllPrivateTeamListing() ([]*model.Team, error) {
 	ret := _m.Called()
 
 	var r0 []*model.Team
@@ -263,20 +251,18 @@ func (_m *TeamStore) GetAllPrivateTeamListing() ([]*model.Team, *model.AppError)
 		}
 	}
 
-	var r1 *model.AppError
-	if rf, ok := ret.Get(1).(func() *model.AppError); ok {
+	var r1 error
+	if rf, ok := ret.Get(1).(func() error); ok {
 		r1 = rf()
 	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*model.AppError)
-		}
+		r1 = ret.Error(1)
 	}
 
 	return r0, r1
 }
 
 // GetAllPrivateTeamPageListing provides a mock function with given fields: offset, limit
-func (_m *TeamStore) GetAllPrivateTeamPageListing(offset int, limit int) ([]*model.Team, *model.AppError) {
+func (_m *TeamStore) GetAllPrivateTeamPageListing(offset int, limit int) ([]*model.Team, error) {
 	ret := _m.Called(offset, limit)
 
 	var r0 []*model.Team
@@ -288,20 +274,18 @@ func (_m *TeamStore) GetAllPrivateTeamPageListing(offset int, limit int) ([]*mod
 		}
 	}
 
-	var r1 *model.AppError
-	if rf, ok := ret.Get(1).(func(int, int) *model.AppError); ok {
+	var r1 error
+	if rf, ok := ret.Get(1).(func(int, int) error); ok {
 		r1 = rf(offset, limit)
 	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*model.AppError)
-		}
+		r1 = ret.Error(1)
 	}
 
 	return r0, r1
 }
 
 // GetAllPublicTeamPageListing provides a mock function with given fields: offset, limit
-func (_m *TeamStore) GetAllPublicTeamPageListing(offset int, limit int) ([]*model.Team, *model.AppError) {
+func (_m *TeamStore) GetAllPublicTeamPageListing(offset int, limit int) ([]*model.Team, error) {
 	ret := _m.Called(offset, limit)
 
 	var r0 []*model.Team
@@ -313,20 +297,18 @@ func (_m *TeamStore) GetAllPublicTeamPageListing(offset int, limit int) ([]*mode
 		}
 	}
 
-	var r1 *model.AppError
-	if rf, ok := ret.Get(1).(func(int, int) *model.AppError); ok {
+	var r1 error
+	if rf, ok := ret.Get(1).(func(int, int) error); ok {
 		r1 = rf(offset, limit)
 	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*model.AppError)
-		}
+		r1 = ret.Error(1)
 	}
 
 	return r0, r1
 }
 
 // GetAllTeamListing provides a mock function with given fields:
-func (_m *TeamStore) GetAllTeamListing() ([]*model.Team, *model.AppError) {
+func (_m *TeamStore) GetAllTeamListing() ([]*model.Team, error) {
 	ret := _m.Called()
 
 	var r0 []*model.Team
@@ -338,20 +320,18 @@ func (_m *TeamStore) GetAllTeamListing() ([]*model.Team, *model.AppError) {
 		}
 	}
 
-	var r1 *model.AppError
-	if rf, ok := ret.Get(1).(func() *model.AppError); ok {
+	var r1 error
+	if rf, ok := ret.Get(1).(func() error); ok {
 		r1 = rf()
 	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*model.AppError)
-		}
+		r1 = ret.Error(1)
 	}
 
 	return r0, r1
 }
 
 // GetAllTeamPageListing provides a mock function with given fields: offset, limit
-func (_m *TeamStore) GetAllTeamPageListing(offset int, limit int) ([]*model.Team, *model.AppError) {
+func (_m *TeamStore) GetAllTeamPageListing(offset int, limit int) ([]*model.Team, error) {
 	ret := _m.Called(offset, limit)
 
 	var r0 []*model.Team
@@ -363,20 +343,18 @@ func (_m *TeamStore) GetAllTeamPageListing(offset int, limit int) ([]*model.Team
 		}
 	}
 
-	var r1 *model.AppError
-	if rf, ok := ret.Get(1).(func(int, int) *model.AppError); ok {
+	var r1 error
+	if rf, ok := ret.Get(1).(func(int, int) error); ok {
 		r1 = rf(offset, limit)
 	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*model.AppError)
-		}
+		r1 = ret.Error(1)
 	}
 
 	return r0, r1
 }
 
 // GetByInviteId provides a mock function with given fields: inviteId
-func (_m *TeamStore) GetByInviteId(inviteId string) (*model.Team, *model.AppError) {
+func (_m *TeamStore) GetByInviteId(inviteId string) (*model.Team, error) {
 	ret := _m.Called(inviteId)
 
 	var r0 *model.Team
@@ -388,20 +366,18 @@ func (_m *TeamStore) GetByInviteId(inviteId string) (*model.Team, *model.AppErro
 		}
 	}
 
-	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(inviteId)
 	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*model.AppError)
-		}
+		r1 = ret.Error(1)
 	}
 
 	return r0, r1
 }
 
 // GetByName provides a mock function with given fields: name
-func (_m *TeamStore) GetByName(name string) (*model.Team, *model.AppError) {
+func (_m *TeamStore) GetByName(name string) (*model.Team, error) {
 	ret := _m.Called(name)
 
 	var r0 *model.Team
@@ -413,20 +389,18 @@ func (_m *TeamStore) GetByName(name string) (*model.Team, *model.AppError) {
 		}
 	}
 
-	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(name)
 	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*model.AppError)
-		}
+		r1 = ret.Error(1)
 	}
 
 	return r0, r1
 }
 
 // GetByNames provides a mock function with given fields: name
-func (_m *TeamStore) GetByNames(name []string) ([]*model.Team, *model.AppError) {
+func (_m *TeamStore) GetByNames(name []string) ([]*model.Team, error) {
 	ret := _m.Called(name)
 
 	var r0 []*model.Team
@@ -438,13 +412,11 @@ func (_m *TeamStore) GetByNames(name []string) ([]*model.Team, *model.AppError)
 		}
 	}
 
-	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(name)
 	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*model.AppError)
-		}
+		r1 = ret.Error(1)
 	}
 
 	return r0, r1
@@ -626,7 +598,7 @@ func (_m *TeamStore) GetTeamsByScheme(schemeId string, offset int, limit int) ([
 }
 
 // GetTeamsByUserId provides a mock function with given fields: userId
-func (_m *TeamStore) GetTeamsByUserId(userId string) ([]*model.Team, *model.AppError) {
+func (_m *TeamStore) GetTeamsByUserId(userId string) ([]*model.Team, error) {
 	ret := _m.Called(userId)
 
 	var r0 []*model.Team
@@ -638,13 +610,11 @@ func (_m *TeamStore) GetTeamsByUserId(userId string) ([]*model.Team, *model.AppE
 		}
 	}
 
-	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
@@ -802,16 +772,14 @@ func (_m *TeamStore) MigrateTeamMembers(fromTeamId string, fromUserId string) (m
 }
 
 // PermanentDelete provides a mock function with given fields: teamId
-func (_m *TeamStore) PermanentDelete(teamId string) *model.AppError {
+func (_m *TeamStore) PermanentDelete(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
@@ -898,7 +866,7 @@ func (_m *TeamStore) ResetAllTeamSchemes() *model.AppError {
 }
 
 // Save provides a mock function with given fields: team
-func (_m *TeamStore) Save(team *model.Team) (*model.Team, *model.AppError) {
+func (_m *TeamStore) Save(team *model.Team) (*model.Team, error) {
 	ret := _m.Called(team)
 
 	var r0 *model.Team
@@ -910,13 +878,11 @@ func (_m *TeamStore) Save(team *model.Team) (*model.Team, *model.AppError) {
 		}
 	}
 
-	var r1 *model.AppError
-	if rf, ok := ret.Get(1).(func(*model.Team) *model.AppError); ok {
+	var r1 error
+	if rf, ok := ret.Get(1).(func(*model.Team) error); ok {
 		r1 = rf(team)
 	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*model.AppError)
-		}
+		r1 = ret.Error(1)
 	}
 
 	return r0, r1
@@ -969,7 +935,7 @@ func (_m *TeamStore) SaveMultipleMembers(members []*model.TeamMember, maxUsersPe
 }
 
 // SearchAll provides a mock function with given fields: term, opts
-func (_m *TeamStore) SearchAll(term string, opts *model.TeamSearch) ([]*model.Team, *model.AppError) {
+func (_m *TeamStore) SearchAll(term string, opts *model.TeamSearch) ([]*model.Team, error) {
 	ret := _m.Called(term, opts)
 
 	var r0 []*model.Team
@@ -981,20 +947,18 @@ func (_m *TeamStore) SearchAll(term string, opts *model.TeamSearch) ([]*model.Te
 		}
 	}
 
-	var r1 *model.AppError
-	if rf, ok := ret.Get(1).(func(string, *model.TeamSearch) *model.AppError); ok {
+	var r1 error
+	if rf, ok := ret.Get(1).(func(string, *model.TeamSearch) error); ok {
 		r1 = rf(term, opts)
 	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*model.AppError)
-		}
+		r1 = ret.Error(1)
 	}
 
 	return r0, r1
 }
 
 // SearchAllPaged provides a mock function with given fields: term, opts
-func (_m *TeamStore) SearchAllPaged(term string, opts *model.TeamSearch) ([]*model.Team, int64, *model.AppError) {
+func (_m *TeamStore) SearchAllPaged(term string, opts *model.TeamSearch) ([]*model.Team, int64, error) {
 	ret := _m.Called(term, opts)
 
 	var r0 []*model.Team
@@ -1013,20 +977,18 @@ func (_m *TeamStore) SearchAllPaged(term string, opts *model.TeamSearch) ([]*mod
 		r1 = ret.Get(1).(int64)
 	}
 
-	var r2 *model.AppError
-	if rf, ok := ret.Get(2).(func(string, *model.TeamSearch) *model.AppError); ok {
+	var r2 error
+	if rf, ok := ret.Get(2).(func(string, *model.TeamSearch) error); ok {
 		r2 = rf(term, opts)
 	} else {
-		if ret.Get(2) != nil {
-			r2 = ret.Get(2).(*model.AppError)
-		}
+		r2 = ret.Error(2)
 	}
 
 	return r0, r1, r2
 }
 
 // SearchOpen provides a mock function with given fields: term
-func (_m *TeamStore) SearchOpen(term string) ([]*model.Team, *model.AppError) {
+func (_m *TeamStore) SearchOpen(term string) ([]*model.Team, error) {
 	ret := _m.Called(term)
 
 	var r0 []*model.Team
@@ -1038,20 +1000,18 @@ func (_m *TeamStore) SearchOpen(term string) ([]*model.Team, *model.AppError) {
 		}
 	}
 
-	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(term)
 	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*model.AppError)
-		}
+		r1 = ret.Error(1)
 	}
 
 	return r0, r1
 }
 
 // SearchPrivate provides a mock function with given fields: term
-func (_m *TeamStore) SearchPrivate(term string) ([]*model.Team, *model.AppError) {
+func (_m *TeamStore) SearchPrivate(term string) ([]*model.Team, error) {
 	ret := _m.Called(term)
 
 	var r0 []*model.Team
@@ -1063,20 +1023,18 @@ func (_m *TeamStore) SearchPrivate(term string) ([]*model.Team, *model.AppError)
 		}
 	}
 
-	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(term)
 	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*model.AppError)
-		}
+		r1 = ret.Error(1)
 	}
 
 	return r0, r1
 }
 
 // Update provides a mock function with given fields: team
-func (_m *TeamStore) Update(team *model.Team) (*model.Team, *model.AppError) {
+func (_m *TeamStore) Update(team *model.Team) (*model.Team, error) {
 	ret := _m.Called(team)
 
 	var r0 *model.Team
@@ -1088,13 +1046,11 @@ func (_m *TeamStore) Update(team *model.Team) (*model.Team, *model.AppError) {
 		}
 	}
 
-	var r1 *model.AppError
-	if rf, ok := ret.Get(1).(func(*model.Team) *model.AppError); ok {
+	var r1 error
+	if rf, ok := ret.Get(1).(func(*model.Team) error); ok {
 		r1 = rf(team)
 	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*model.AppError)
-		}
+		r1 = ret.Error(1)
 	}
 
 	return r0, r1

store/storetest/team_store.go

@@ -1298,8 +1298,8 @@ func testTeamSaveMember(t *testing.T, ss store.Store) {
 			Type:        model.TEAM_OPEN,
 		}
 
-		team, err = ss.Team().Save(team)
-		require.Nil(t, err)
+		team, nErr := ss.Team().Save(team)
+		require.Nil(t, nErr)
 
 		testCases := []struct {
 			Name                  string
@@ -1449,8 +1449,8 @@ func testTeamSaveMember(t *testing.T, ss store.Store) {
 			SchemeId:    &ts.Id,
 		}
 
-		team, err = ss.Team().Save(team)
-		require.Nil(t, err)
+		team, nErr = ss.Team().Save(team)
+		require.Nil(t, nErr)
 
 		testCases := []struct {
 			Name                  string
@@ -1654,8 +1654,8 @@ func testTeamSaveMultipleMembers(t *testing.T, ss store.Store) {
 			Type:        model.TEAM_OPEN,
 		}
 
-		team, err = ss.Team().Save(team)
-		require.Nil(t, err)
+		team, nErr := ss.Team().Save(team)
+		require.Nil(t, nErr)
 
 		testCases := []struct {
 			Name                  string
@@ -1817,8 +1817,8 @@ func testTeamSaveMultipleMembers(t *testing.T, ss store.Store) {
 			SchemeId:    &ts.Id,
 		}
 
-		team, err = ss.Team().Save(team)
-		require.Nil(t, err)
+		team, nErr = ss.Team().Save(team)
+		require.Nil(t, nErr)
 
 		testCases := []struct {
 			Name                  string
@@ -1981,11 +1981,11 @@ func testTeamUpdateMember(t *testing.T, ss store.Store) {
 			Type:        model.TEAM_OPEN,
 		}
 
-		team, err = ss.Team().Save(team)
-		require.Nil(t, err)
+		team, nErr := ss.Team().Save(team)
+		require.Nil(t, nErr)
 
 		member := &model.TeamMember{TeamId: team.Id, UserId: u1.Id}
-		member, nErr := ss.Team().SaveMember(member, -1)
+		member, nErr = ss.Team().SaveMember(member, -1)
 		require.Nil(t, nErr)
 
 		testCases := []struct {
@@ -2132,8 +2132,8 @@ func testTeamUpdateMember(t *testing.T, ss store.Store) {
 			SchemeId:    &ts.Id,
 		}
 
-		team, err = ss.Team().Save(team)
-		require.Nil(t, err)
+		team, nErr = ss.Team().Save(team)
+		require.Nil(t, nErr)
 
 		member := &model.TeamMember{TeamId: team.Id, UserId: u1.Id}
 		member, nErr = ss.Team().SaveMember(member, -1)
@@ -2288,13 +2288,13 @@ func testTeamUpdateMultipleMembers(t *testing.T, ss store.Store) {
 			Type:        model.TEAM_OPEN,
 		}
 
-		team, err = ss.Team().Save(team)
-		require.Nil(t, err)
+		team, nErr := ss.Team().Save(team)
+		require.Nil(t, nErr)
 
 		member := &model.TeamMember{TeamId: team.Id, UserId: u1.Id}
 		otherMember := &model.TeamMember{TeamId: team.Id, UserId: u2.Id}
 		var members []*model.TeamMember
-		members, nErr := ss.Team().SaveMultipleMembers([]*model.TeamMember{member, otherMember}, -1)
+		members, nErr = ss.Team().SaveMultipleMembers([]*model.TeamMember{member, otherMember}, -1)
 		require.Nil(t, nErr)
 		require.Len(t, members, 2)
 		member = members[0]
@@ -2872,13 +2872,13 @@ func testGetTeamMember(t *testing.T, ss store.Store) {
 	require.Nil(t, nErr)
 	t.Log(s2)
 
-	t2, err := ss.Team().Save(&model.Team{
+	t2, nErr := ss.Team().Save(&model.Team{
 		DisplayName: "DisplayName",
 		Name:        "z-z-z" + model.NewId() + "b",
 		Type:        model.TEAM_OPEN,
 		SchemeId:    &s2.Id,
 	})
-	require.Nil(t, err)
+	require.Nil(t, nErr)
 
 	defer func() {
 		ss.Team().PermanentDelete(t2.Id)

store/timerlayer/timerlayer.go

@@ -5868,7 +5868,7 @@ func (s *TimerLayerTeamStore) AnalyticsGetTeamCountForScheme(schemeId string) (i
 	return result, err
 }
 
-func (s *TimerLayerTeamStore) AnalyticsPrivateTeamCount() (int64, *model.AppError) {
+func (s *TimerLayerTeamStore) AnalyticsPrivateTeamCount() (int64, error) {
 	start := timemodule.Now()
 
 	result, err := s.TeamStore.AnalyticsPrivateTeamCount()
@@ -5884,7 +5884,7 @@ func (s *TimerLayerTeamStore) AnalyticsPrivateTeamCount() (int64, *model.AppErro
 	return result, err
 }
 
-func (s *TimerLayerTeamStore) AnalyticsPublicTeamCount() (int64, *model.AppError) {
+func (s *TimerLayerTeamStore) AnalyticsPublicTeamCount() (int64, error) {
 	start := timemodule.Now()
 
 	result, err := s.TeamStore.AnalyticsPublicTeamCount()
@@ -5900,7 +5900,7 @@ func (s *TimerLayerTeamStore) AnalyticsPublicTeamCount() (int64, *model.AppError
 	return result, err
 }
 
-func (s *TimerLayerTeamStore) AnalyticsTeamCount(includeDeleted bool) (int64, *model.AppError) {
+func (s *TimerLayerTeamStore) AnalyticsTeamCount(includeDeleted bool) (int64, error) {
 	start := timemodule.Now()
 
 	result, err := s.TeamStore.AnalyticsTeamCount(includeDeleted)
@@ -5947,7 +5947,7 @@ func (s *TimerLayerTeamStore) ClearCaches() {
 	}
 }
 
-func (s *TimerLayerTeamStore) Get(id string) (*model.Team, *model.AppError) {
+func (s *TimerLayerTeamStore) Get(id string) (*model.Team, error) {
 	start := timemodule.Now()
 
 	result, err := s.TeamStore.Get(id)
@@ -5979,7 +5979,7 @@ func (s *TimerLayerTeamStore) GetActiveMemberCount(teamId string, restrictions *
 	return result, err
 }
 
-func (s *TimerLayerTeamStore) GetAll() ([]*model.Team, *model.AppError) {
+func (s *TimerLayerTeamStore) GetAll() ([]*model.Team, error) {
 	start := timemodule.Now()
 
 	result, err := s.TeamStore.GetAll()
@@ -6011,7 +6011,7 @@ func (s *TimerLayerTeamStore) GetAllForExportAfter(limit int, afterId string) ([
 	return result, err
 }
 
-func (s *TimerLayerTeamStore) GetAllPage(offset int, limit int) ([]*model.Team, *model.AppError) {
+func (s *TimerLayerTeamStore) GetAllPage(offset int, limit int) ([]*model.Team, error) {
 	start := timemodule.Now()
 
 	result, err := s.TeamStore.GetAllPage(offset, limit)
@@ -6027,7 +6027,7 @@ func (s *TimerLayerTeamStore) GetAllPage(offset int, limit int) ([]*model.Team,
 	return result, err
 }
 
-func (s *TimerLayerTeamStore) GetAllPrivateTeamListing() ([]*model.Team, *model.AppError) {
+func (s *TimerLayerTeamStore) GetAllPrivateTeamListing() ([]*model.Team, error) {
 	start := timemodule.Now()
 
 	result, err := s.TeamStore.GetAllPrivateTeamListing()
@@ -6043,7 +6043,7 @@ func (s *TimerLayerTeamStore) GetAllPrivateTeamListing() ([]*model.Team, *model.
 	return result, err
 }
 
-func (s *TimerLayerTeamStore) GetAllPrivateTeamPageListing(offset int, limit int) ([]*model.Team, *model.AppError) {
+func (s *TimerLayerTeamStore) GetAllPrivateTeamPageListing(offset int, limit int) ([]*model.Team, error) {
 	start := timemodule.Now()
 
 	result, err := s.TeamStore.GetAllPrivateTeamPageListing(offset, limit)
@@ -6059,7 +6059,7 @@ func (s *TimerLayerTeamStore) GetAllPrivateTeamPageListing(offset int, limit int
 	return result, err
 }
 
-func (s *TimerLayerTeamStore) GetAllPublicTeamPageListing(offset int, limit int) ([]*model.Team, *model.AppError) {
+func (s *TimerLayerTeamStore) GetAllPublicTeamPageListing(offset int, limit int) ([]*model.Team, error) {
 	start := timemodule.Now()
 
 	result, err := s.TeamStore.GetAllPublicTeamPageListing(offset, limit)
@@ -6075,7 +6075,7 @@ func (s *TimerLayerTeamStore) GetAllPublicTeamPageListing(offset int, limit int)
 	return result, err
 }
 
-func (s *TimerLayerTeamStore) GetAllTeamListing() ([]*model.Team, *model.AppError) {
+func (s *TimerLayerTeamStore) GetAllTeamListing() ([]*model.Team, error) {
 	start := timemodule.Now()
 
 	result, err := s.TeamStore.GetAllTeamListing()
@@ -6091,7 +6091,7 @@ func (s *TimerLayerTeamStore) GetAllTeamListing() ([]*model.Team, *model.AppErro
 	return result, err
 }
 
-func (s *TimerLayerTeamStore) GetAllTeamPageListing(offset int, limit int) ([]*model.Team, *model.AppError) {
+func (s *TimerLayerTeamStore) GetAllTeamPageListing(offset int, limit int) ([]*model.Team, error) {
 	start := timemodule.Now()
 
 	result, err := s.TeamStore.GetAllTeamPageListing(offset, limit)
@@ -6107,7 +6107,7 @@ func (s *TimerLayerTeamStore) GetAllTeamPageListing(offset int, limit int) ([]*m
 	return result, err
 }
 
-func (s *TimerLayerTeamStore) GetByInviteId(inviteId string) (*model.Team, *model.AppError) {
+func (s *TimerLayerTeamStore) GetByInviteId(inviteId string) (*model.Team, error) {
 	start := timemodule.Now()
 
 	result, err := s.TeamStore.GetByInviteId(inviteId)
@@ -6123,7 +6123,7 @@ func (s *TimerLayerTeamStore) GetByInviteId(inviteId string) (*model.Team, *mode
 	return result, err
 }
 
-func (s *TimerLayerTeamStore) GetByName(name string) (*model.Team, *model.AppError) {
+func (s *TimerLayerTeamStore) GetByName(name string) (*model.Team, error) {
 	start := timemodule.Now()
 
 	result, err := s.TeamStore.GetByName(name)
@@ -6139,7 +6139,7 @@ func (s *TimerLayerTeamStore) GetByName(name string) (*model.Team, *model.AppErr
 	return result, err
 }
 
-func (s *TimerLayerTeamStore) GetByNames(name []string) ([]*model.Team, *model.AppError) {
+func (s *TimerLayerTeamStore) GetByNames(name []string) ([]*model.Team, error) {
 	start := timemodule.Now()
 
 	result, err := s.TeamStore.GetByNames(name)
@@ -6267,7 +6267,7 @@ func (s *TimerLayerTeamStore) GetTeamsByScheme(schemeId string, offset int, limi
 	return result, err
 }
 
-func (s *TimerLayerTeamStore) GetTeamsByUserId(userId string) ([]*model.Team, *model.AppError) {
+func (s *TimerLayerTeamStore) GetTeamsByUserId(userId string) ([]*model.Team, error) {
 	start := timemodule.Now()
 
 	result, err := s.TeamStore.GetTeamsByUserId(userId)
@@ -6394,7 +6394,7 @@ func (s *TimerLayerTeamStore) MigrateTeamMembers(fromTeamId string, fromUserId s
 	return result, err
 }
 
-func (s *TimerLayerTeamStore) PermanentDelete(teamId string) *model.AppError {
+func (s *TimerLayerTeamStore) PermanentDelete(teamId string) error {
 	start := timemodule.Now()
 
 	err := s.TeamStore.PermanentDelete(teamId)
@@ -6490,7 +6490,7 @@ func (s *TimerLayerTeamStore) ResetAllTeamSchemes() *model.AppError {
 	return err
 }
 
-func (s *TimerLayerTeamStore) Save(team *model.Team) (*model.Team, *model.AppError) {
+func (s *TimerLayerTeamStore) Save(team *model.Team) (*model.Team, error) {
 	start := timemodule.Now()
 
 	result, err := s.TeamStore.Save(team)
@@ -6538,7 +6538,7 @@ func (s *TimerLayerTeamStore) SaveMultipleMembers(members []*model.TeamMember, m
 	return result, err
 }
 
-func (s *TimerLayerTeamStore) SearchAll(term string, opts *model.TeamSearch) ([]*model.Team, *model.AppError) {
+func (s *TimerLayerTeamStore) SearchAll(term string, opts *model.TeamSearch) ([]*model.Team, error) {
 	start := timemodule.Now()
 
 	result, err := s.TeamStore.SearchAll(term, opts)
@@ -6554,7 +6554,7 @@ func (s *TimerLayerTeamStore) SearchAll(term string, opts *model.TeamSearch) ([]
 	return result, err
 }
 
-func (s *TimerLayerTeamStore) SearchAllPaged(term string, opts *model.TeamSearch) ([]*model.Team, int64, *model.AppError) {
+func (s *TimerLayerTeamStore) SearchAllPaged(term string, opts *model.TeamSearch) ([]*model.Team, int64, error) {
 	start := timemodule.Now()
 
 	result, resultVar1, err := s.TeamStore.SearchAllPaged(term, opts)
@@ -6570,7 +6570,7 @@ func (s *TimerLayerTeamStore) SearchAllPaged(term string, opts *model.TeamSearch
 	return result, resultVar1, err
 }
 
-func (s *TimerLayerTeamStore) SearchOpen(term string) ([]*model.Team, *model.AppError) {
+func (s *TimerLayerTeamStore) SearchOpen(term string) ([]*model.Team, error) {
 	start := timemodule.Now()
 
 	result, err := s.TeamStore.SearchOpen(term)
@@ -6586,7 +6586,7 @@ func (s *TimerLayerTeamStore) SearchOpen(term string) ([]*model.Team, *model.App
 	return result, err
 }
 
-func (s *TimerLayerTeamStore) SearchPrivate(term string) ([]*model.Team, *model.AppError) {
+func (s *TimerLayerTeamStore) SearchPrivate(term string) ([]*model.Team, error) {
 	start := timemodule.Now()
 
 	result, err := s.TeamStore.SearchPrivate(term)
@@ -6602,7 +6602,7 @@ func (s *TimerLayerTeamStore) SearchPrivate(term string) ([]*model.Team, *model.
 	return result, err
 }
 
-func (s *TimerLayerTeamStore) Update(team *model.Team) (*model.Team, *model.AppError) {
+func (s *TimerLayerTeamStore) Update(team *model.Team) (*model.Team, error) {
 	start := timemodule.Now()
 
 	result, err := s.TeamStore.Update(team)