mirrors/mostlymatter
1
0
Форкнуть 0
Код Задачи Запросы на слияние Действия Пакеты Проекты Релизы Вики Активность

TeamStore migration Part 3 (#15397)

Просмотр исходного кода 
* Migration completed

* TODO
Этот коммит содержится в:
Rodrigo Villablanca
2020-09-16 12:12:10 -03:00
коммит произвёл GitHub
родитель b683a9020e
Коммит f0fc51244c
17 изменённых файлов: 419 добавлений и 298 удалений
Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

5
app/export.go
Просмотреть файл

@@ -124,9 +124,8 @@ func (a *App) exportAllTeams(writer io.Writer) *model.AppError {
afterId := strings.Repeat("0", 26)
for {
teams, err := a.Srv().Store.Team().GetAllForExportAfter(1000, afterId)
if err != nil {
return err
return model.NewAppError("exportAllTeams", "app.team.get_all.app_error", nil, err.Error(), http.StatusInternalServerError)
}
if len(teams) == 0 {
@@ -263,7 +262,7 @@ func (a *App) buildUserTeamAndChannelMemberships(userId string) (*[]UserTeamImpo
members, err := a.Srv().Store.Team().GetTeamMembersForExport(userId)
if err != nil {
return nil, err
return nil, model.NewAppError("buildUserTeamAndChannelMemberships", "app.team.get_members.app_error", nil, err.Error(), http.StatusInternalServerError)
}
for _, member := range members {

4
app/permissions.go
Просмотреть файл

@@ -20,7 +20,7 @@ const systemSchemeName = "00000000-0000-0000-0000-000000000000" // Prevents coll
func (a *App) ResetPermissionsSystem() *model.AppError {
// Reset all Teams to not have a scheme.
if err := a.Srv().Store.Team().ResetAllTeamSchemes(); err != nil {
return err
return model.NewAppError("ResetPermissionsSystem", "app.team.reset_all_team_schemes.app_error", nil, err.Error(), http.StatusInternalServerError)
}
// Reset all Channels to not have a scheme.
@@ -35,7 +35,7 @@ func (a *App) ResetPermissionsSystem() *model.AppError {
// Reset all Custom Role assignments to TeamMembers.
if err := a.Srv().Store.Team().ClearAllCustomRoleAssignments(); err != nil {
return err
return model.NewAppError("ResetPermissionsSystem", "app.team.clear_all_custom_role_assignments.select.app_error", nil, err.Error(), http.StatusInternalServerError)
}
// Reset all Custom Role assignments to ChannelMembers.

2
app/scheme.go
Просмотреть файл

@@ -171,7 +171,7 @@ func (a *App) GetTeamsForScheme(scheme *model.Scheme, offset int, limit int) ([]
teams, err := a.Srv().Store.Team().GetTeamsByScheme(scheme.Id, offset, limit)
if err != nil {
return nil, err
return nil, model.NewAppError("GetTeamsForScheme", "app.team.get_by_scheme.app_error", nil, err.Error(), http.StatusInternalServerError)
}
return teams, nil
}

19
app/syncables.go
Просмотреть файл

@@ -204,23 +204,20 @@ func (a *App) SyncSyncableRoles(syncableID string, syncableType model.GroupSynca
mlog.Any("permitted_admins", permittedAdmins),
)
var updateFunc func(string, []string) *model.AppError
switch syncableType {
case model.GroupSyncableTypeTeam:
updateFunc = a.Srv().Store.Team().UpdateMembersRole
nErr := a.Srv().Store.Team().UpdateMembersRole(syncableID, permittedAdmins)
if nErr != nil {
// TODO: Should we change the key "store.update_error" to "app.update_error"? It is very general and changing it now will modify lots of files
return model.NewAppError("SyncSyncableRoles", "store.update_error", nil, nErr.Error(), http.StatusInternalServerError)
}
return nil
case model.GroupSyncableTypeChannel:
updateFunc = a.Srv().Store.Channel().UpdateMembersRole
return a.Srv().Store.Channel().UpdateMembersRole(syncableID, permittedAdmins)
default:
return model.NewAppError("App.SyncSyncableRoles", "groups.unsupported_syncable_type", map[string]interface{}{"Value": syncableType}, "", http.StatusInternalServerError)
}
err = updateFunc(syncableID, permittedAdmins)
if err != nil {
return err
}
return nil
}
// SyncRolesAndMembership updates the SchemeAdmin status and membership of all of the members of the given

10
app/user.go
Просмотреть файл

@@ -1580,7 +1580,7 @@ func (a *App) PermanentDeleteUser(user *model.User) *model.AppError {
}
if err := a.Srv().Store.Team().RemoveAllMembersByUser(user.Id); err != nil {
return err
return model.NewAppError("PermanentDeleteUser", "app.team.remove_member.app_error", nil, err.Error(), http.StatusInternalServerError)
}
mlog.Warn("Permanently deleted account", mlog.String("user_email", user.Email), mlog.String("user_id", user.Id))
@@ -1985,7 +1985,7 @@ func (a *App) UserCanSeeOtherUser(userId string, otherUserId string) (bool, *mod
if len(restrictions.Teams) > 0 {
result, err := a.Srv().Store.Team().UserBelongsToTeams(otherUserId, restrictions.Teams)
if err != nil {
return false, err
return false, model.NewAppError("UserCanSeeOtherUser", "app.team.user_belongs_to_teams.app_error", nil, err.Error(), http.StatusInternalServerError)
}
if result {
return true, nil
@@ -2014,9 +2014,9 @@ func (a *App) GetViewUsersRestrictions(userId string) (*model.ViewUsersRestricti
return nil, nil
}
teamIds, getTeamErr := a.Srv().Store.Team().GetUserTeamIds(userId, true)
if getTeamErr != nil {
return nil, getTeamErr
teamIds, nErr := a.Srv().Store.Team().GetUserTeamIds(userId, true)
if nErr != nil {
return nil, model.NewAppError("GetViewUsersRestrictions", "app.team.get_user_team_ids.app_error", nil, nErr.Error(), http.StatusInternalServerError)
}
teamIdsWithPermission := []string{}

96
i18n/en.json
Просмотреть файл

@@ -4798,6 +4798,10 @@
"id": "app.team.analytics_team_count.app_error",
"translation": "Unable to count the teams."
},
{
"id": "app.team.clear_all_custom_role_assignments.select.app_error",
"translation": "Failed to retrieve the team members."
},
{
"id": "app.team.get.find.app_error",
"translation": "Unable to find the existing team."
@@ -4834,6 +4838,18 @@
"id": "app.team.get_by_name.missing.app_error",
"translation": "Unable to find the existing team."
},
{
"id": "app.team.get_by_scheme.app_error",
"translation": "Unable to get the channels for the provided scheme."
},
{
"id": "app.team.get_members.app_error",
"translation": "Unable to get the team members."
},
{
"id": "app.team.get_user_team_ids.app_error",
"translation": "Unable to get the list of teams of a user."
},
{
"id": "app.team.invite_id.group_constrained.error",
"translation": "Unable to join a group-constrained team by invite."
@@ -4858,6 +4874,10 @@
"id": "app.team.join_user_to_team.save_member.max_accounts.app_error",
"translation": "Unable to create the new team membership because the team has reached the limit of members"
},
{
"id": "app.team.migrate_team_members.update.app_error",
"translation": "Failed to update the team member."
},
{
"id": "app.team.permanent_delete.app_error",
"translation": "Unable to delete the existing team."
@@ -4866,10 +4886,18 @@
"id": "app.team.permanentdeleteteam.internal_error",
"translation": "Unable to delete team."
},
{
"id": "app.team.remove_member.app_error",
"translation": "Unable to remove the team member."
},
{
"id": "app.team.rename_team.name_occupied",
"translation": "Unable to rename the team, the name is already in use."
},
{
"id": "app.team.reset_all_team_schemes.app_error",
"translation": "We could not reset the team schemes."
},
{
"id": "app.team.save.app_error",
"translation": "Unable to save the team."
@@ -4898,6 +4926,10 @@
"id": "app.team.update.updating.app_error",
"translation": "We encountered an error updating the team."
},
{
"id": "app.team.user_belongs_to_teams.app_error",
"translation": "Unable to determine if the user belongs to a list of teams."
},
{
"id": "app.terms_of_service.create.app_error",
"translation": "Unable to save terms of service."
@@ -7638,34 +7670,10 @@
"id": "store.sql_post.search.disabled",
"translation": "Searching has been disabled on this server. Please contact your System Administrator."
},
{
"id": "store.sql_team.analytics_get_team_count_for_scheme.app_error",
"translation": "Unable to get the channel count for the scheme."
},
{
"id": "store.sql_team.clear_all_custom_role_assignments.commit_transaction.app_error",
"translation": "Failed to commit the database transaction."
},
{
"id": "store.sql_team.clear_all_custom_role_assignments.open_transaction.app_error",
"translation": "Failed to begin the database transaction."
},
{
"id": "store.sql_team.clear_all_custom_role_assignments.select.app_error",
"translation": "Failed to retrieve the team members."
},
{
"id": "store.sql_team.clear_all_custom_role_assignments.update.app_error",
"translation": "Failed to update the team member."
},
{
"id": "store.sql_team.get_active_member_count.app_error",
"translation": "Unable to count the team members."
},
{
"id": "store.sql_team.get_by_scheme.app_error",
"translation": "Unable to get the channels for the provided scheme."
},
{
"id": "store.sql_team.get_member.app_error",
"translation": "Unable to get the team member."
@@ -7678,10 +7686,6 @@
"id": "store.sql_team.get_member_count.app_error",
"translation": "Unable to count the team members."
},
{
"id": "store.sql_team.get_members.app_error",
"translation": "Unable to get the team members."
},
{
"id": "store.sql_team.get_members_by_ids.app_error",
"translation": "Unable to get the team members."
@@ -7690,34 +7694,6 @@
"id": "store.sql_team.get_unread.app_error",
"translation": "Unable to get the teams unread messages."
},
{
"id": "store.sql_team.get_user_team_ids.app_error",
"translation": "Unable to get the list of teams of a user."
},
{
"id": "store.sql_team.migrate_team_members.commit_transaction.app_error",
"translation": "Failed to commit the database transaction."
},
{
"id": "store.sql_team.migrate_team_members.open_transaction.app_error",
"translation": "Failed to open the database transaction."
},
{
"id": "store.sql_team.migrate_team_members.select.app_error",
"translation": " Failed to select the batch of team members."
},
{
"id": "store.sql_team.migrate_team_members.update.app_error",
"translation": "Failed to update the team member."
},
{
"id": "store.sql_team.remove_member.app_error",
"translation": "Unable to remove the team member."
},
{
"id": "store.sql_team.reset_all_team_schemes.app_error",
"translation": "We could not reset the team schemes."
},
{
"id": "store.sql_team.save_member.exists.app_error",
"translation": "A team member with that ID already exists."
@@ -7726,14 +7702,6 @@
"id": "store.sql_team.save_member.save.app_error",
"translation": "Unable to save the team member."
},
{
"id": "store.sql_team.update_last_team_icon_update.app_error",
"translation": "Unable to update the date of the last team icon update."
},
{
"id": "store.sql_team.user_belongs_to_teams.app_error",
"translation": "Unable to determine if the user belongs to a list of teams."
},
{
"id": "store.sql_user.analytics_daily_active_users.app_error",
"translation": "Unable to get the active users during the requested period."

2
migrations/advanced_permissions_phase_2.go
Просмотреть файл

@@ -72,7 +72,7 @@ func (worker *Worker) runAdvancedPermissionsPhase2Migration(lastDone string) (bo
if progress.CurrentTable == "TeamMembers" {
// Run a TeamMembers migration batch.
if result, err := worker.srv.Store.Team().MigrateTeamMembers(progress.LastTeamId, progress.LastUserId); err != nil {
return false, progress.ToJson(), err
return false, progress.ToJson(), model.NewAppError("MigrationsWorker.runAdvancedPermissionsPhase2Migration", "app.team.migrate_team_members.update.app_error", nil, err.Error(), http.StatusInternalServerError)
} else {
if result == nil {
// We haven't progressed. That means that we've reached the end of this stage of the migration, and should now advance to the next stage.

6
services/telemetry/telemetry.go
Просмотреть файл

@@ -1055,9 +1055,9 @@ func (ts *TelemetryService) trackGroups() {
mlog.Error(err.Error())
}
groupSyncedTeamCount, err := ts.dbStore.Team().GroupSyncedTeamCount()
if err != nil {
mlog.Error(err.Error())
groupSyncedTeamCount, nErr := ts.dbStore.Team().GroupSyncedTeamCount()
if nErr != nil {
mlog.Error(nErr.Error())
}
groupSyncedChannelCount, err := ts.dbStore.Channel().GroupSyncedChannelCount()

2
store/localcachelayer/team_layer.go
Просмотреть файл

@@ -35,7 +35,7 @@ func (s LocalCacheTeamStore) InvalidateAllTeamIdsForUser(userId string) {
}
}
func (s LocalCacheTeamStore) GetUserTeamIds(userID string, allowFromCache bool) ([]string, *model.AppError) {
func (s LocalCacheTeamStore) GetUserTeamIds(userID string, allowFromCache bool) ([]string, error) {
if !allowFromCache {
return s.TeamStore.GetUserTeamIds(userID, allowFromCache)
}

26
store/opentracinglayer/opentracinglayer.go
Просмотреть файл

@@ -6486,7 +6486,7 @@ func (s *OpenTracingLayerSystemStore) Update(system *model.System) error {
return err
}
func (s *OpenTracingLayerTeamStore) AnalyticsGetTeamCountForScheme(schemeId string) (int64, *model.AppError) {
func (s *OpenTracingLayerTeamStore) AnalyticsGetTeamCountForScheme(schemeId string) (int64, error) {
origCtx := s.Root.Store.Context()
span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "TeamStore.AnalyticsGetTeamCountForScheme")
s.Root.Store.SetContext(newCtx)
@@ -6558,7 +6558,7 @@ func (s *OpenTracingLayerTeamStore) AnalyticsTeamCount(includeDeleted bool) (int
return result, err
}
func (s *OpenTracingLayerTeamStore) ClearAllCustomRoleAssignments() *model.AppError {
func (s *OpenTracingLayerTeamStore) ClearAllCustomRoleAssignments() error {
origCtx := s.Root.Store.Context()
span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "TeamStore.ClearAllCustomRoleAssignments")
s.Root.Store.SetContext(newCtx)
@@ -6643,7 +6643,7 @@ func (s *OpenTracingLayerTeamStore) GetAll() ([]*model.Team, error) {
return result, err
}
func (s *OpenTracingLayerTeamStore) GetAllForExportAfter(limit int, afterId string) ([]*model.TeamForExport, *model.AppError) {
func (s *OpenTracingLayerTeamStore) GetAllForExportAfter(limit int, afterId string) ([]*model.TeamForExport, error) {
origCtx := s.Root.Store.Context()
span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "TeamStore.GetAllForExportAfter")
s.Root.Store.SetContext(newCtx)
@@ -6913,7 +6913,7 @@ func (s *OpenTracingLayerTeamStore) GetMembersByIds(teamId string, userIds []str
return result, err
}
func (s *OpenTracingLayerTeamStore) GetTeamMembersForExport(userId string) ([]*model.TeamMemberForExport, *model.AppError) {
func (s *OpenTracingLayerTeamStore) GetTeamMembersForExport(userId string) ([]*model.TeamMemberForExport, error) {
origCtx := s.Root.Store.Context()
span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "TeamStore.GetTeamMembersForExport")
s.Root.Store.SetContext(newCtx)
@@ -6931,7 +6931,7 @@ func (s *OpenTracingLayerTeamStore) GetTeamMembersForExport(userId string) ([]*m
return result, err
}
func (s *OpenTracingLayerTeamStore) GetTeamsByScheme(schemeId string, offset int, limit int) ([]*model.Team, *model.AppError) {
func (s *OpenTracingLayerTeamStore) GetTeamsByScheme(schemeId string, offset int, limit int) ([]*model.Team, error) {
origCtx := s.Root.Store.Context()
span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "TeamStore.GetTeamsByScheme")
s.Root.Store.SetContext(newCtx)
@@ -7021,7 +7021,7 @@ func (s *OpenTracingLayerTeamStore) GetTotalMemberCount(teamId string, restricti
return result, err
}
func (s *OpenTracingLayerTeamStore) GetUserTeamIds(userId string, allowFromCache bool) ([]string, *model.AppError) {
func (s *OpenTracingLayerTeamStore) GetUserTeamIds(userId string, allowFromCache bool) ([]string, error) {
origCtx := s.Root.Store.Context()
span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "TeamStore.GetUserTeamIds")
s.Root.Store.SetContext(newCtx)
@@ -7039,7 +7039,7 @@ func (s *OpenTracingLayerTeamStore) GetUserTeamIds(userId string, allowFromCache
return result, err
}
func (s *OpenTracingLayerTeamStore) GroupSyncedTeamCount() (int64, *model.AppError) {
func (s *OpenTracingLayerTeamStore) GroupSyncedTeamCount() (int64, error) {
origCtx := s.Root.Store.Context()
span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "TeamStore.GroupSyncedTeamCount")
s.Root.Store.SetContext(newCtx)
@@ -7070,7 +7070,7 @@ func (s *OpenTracingLayerTeamStore) InvalidateAllTeamIdsForUser(userId string) {
}
func (s *OpenTracingLayerTeamStore) MigrateTeamMembers(fromTeamId string, fromUserId string) (map[string]string, *model.AppError) {
func (s *OpenTracingLayerTeamStore) MigrateTeamMembers(fromTeamId string, fromUserId string) (map[string]string, error) {
origCtx := s.Root.Store.Context()
span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "TeamStore.MigrateTeamMembers")
s.Root.Store.SetContext(newCtx)
@@ -7124,7 +7124,7 @@ func (s *OpenTracingLayerTeamStore) RemoveAllMembersByTeam(teamId string) *model
return err
}
func (s *OpenTracingLayerTeamStore) RemoveAllMembersByUser(userId string) *model.AppError {
func (s *OpenTracingLayerTeamStore) RemoveAllMembersByUser(userId string) error {
origCtx := s.Root.Store.Context()
span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "TeamStore.RemoveAllMembersByUser")
s.Root.Store.SetContext(newCtx)
@@ -7178,7 +7178,7 @@ func (s *OpenTracingLayerTeamStore) RemoveMembers(teamId string, userIds []strin
return err
}
func (s *OpenTracingLayerTeamStore) ResetAllTeamSchemes() *model.AppError {
func (s *OpenTracingLayerTeamStore) ResetAllTeamSchemes() error {
origCtx := s.Root.Store.Context()
span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "TeamStore.ResetAllTeamSchemes")
s.Root.Store.SetContext(newCtx)
@@ -7340,7 +7340,7 @@ func (s *OpenTracingLayerTeamStore) Update(team *model.Team) (*model.Team, error
return result, err
}
func (s *OpenTracingLayerTeamStore) UpdateLastTeamIconUpdate(teamId string, curTime int64) *model.AppError {
func (s *OpenTracingLayerTeamStore) UpdateLastTeamIconUpdate(teamId string, curTime int64) error {
origCtx := s.Root.Store.Context()
span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "TeamStore.UpdateLastTeamIconUpdate")
s.Root.Store.SetContext(newCtx)
@@ -7376,7 +7376,7 @@ func (s *OpenTracingLayerTeamStore) UpdateMember(member *model.TeamMember) (*mod
return result, err
}
func (s *OpenTracingLayerTeamStore) UpdateMembersRole(teamID string, userIDs []string) *model.AppError {
func (s *OpenTracingLayerTeamStore) UpdateMembersRole(teamID string, userIDs []string) error {
origCtx := s.Root.Store.Context()
span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "TeamStore.UpdateMembersRole")
s.Root.Store.SetContext(newCtx)
@@ -7412,7 +7412,7 @@ func (s *OpenTracingLayerTeamStore) UpdateMultipleMembers(members []*model.TeamM
return result, err
}
func (s *OpenTracingLayerTeamStore) UserBelongsToTeams(userId string, teamIds []string) (bool, *model.AppError) {
func (s *OpenTracingLayerTeamStore) UserBelongsToTeams(userId string, teamIds []string) (bool, error) {
origCtx := s.Root.Store.Context()
span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "TeamStore.UserBelongsToTeams")
s.Root.Store.SetContext(newCtx)

234
store/retrylayer/retrylayer.go
Просмотреть файл

@@ -5752,9 +5752,23 @@ func (s *RetryLayerSystemStore) Update(system *model.System) error {
}
func (s *RetryLayerTeamStore) AnalyticsGetTeamCountForScheme(schemeId string) (int64, *model.AppError) {
func (s *RetryLayerTeamStore) AnalyticsGetTeamCountForScheme(schemeId string) (int64, error) {
return s.TeamStore.AnalyticsGetTeamCountForScheme(schemeId)
tries := 0
for {
result, err := s.TeamStore.AnalyticsGetTeamCountForScheme(schemeId)
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
}
}
}
@@ -5818,9 +5832,23 @@ func (s *RetryLayerTeamStore) AnalyticsTeamCount(includeDeleted bool) (int64, er
}
func (s *RetryLayerTeamStore) ClearAllCustomRoleAssignments() *model.AppError {
func (s *RetryLayerTeamStore) ClearAllCustomRoleAssignments() error {
return s.TeamStore.ClearAllCustomRoleAssignments()
tries := 0
for {
err := s.TeamStore.ClearAllCustomRoleAssignments()
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
}
}
}
@@ -5876,9 +5904,23 @@ func (s *RetryLayerTeamStore) GetAll() ([]*model.Team, error) {
}
func (s *RetryLayerTeamStore) GetAllForExportAfter(limit int, afterId string) ([]*model.TeamForExport, *model.AppError) {
func (s *RetryLayerTeamStore) GetAllForExportAfter(limit int, afterId string) ([]*model.TeamForExport, error) {
return s.TeamStore.GetAllForExportAfter(limit, afterId)
tries := 0
for {
result, err := s.TeamStore.GetAllForExportAfter(limit, afterId)
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
}
}
}
@@ -6092,15 +6134,43 @@ func (s *RetryLayerTeamStore) GetMembersByIds(teamId string, userIds []string, r
}
func (s *RetryLayerTeamStore) GetTeamMembersForExport(userId string) ([]*model.TeamMemberForExport, *model.AppError) {
func (s *RetryLayerTeamStore) GetTeamMembersForExport(userId string) ([]*model.TeamMemberForExport, error) {
return s.TeamStore.GetTeamMembersForExport(userId)
tries := 0
for {
result, err := s.TeamStore.GetTeamMembersForExport(userId)
if err == nil {
return result, nil
}
if !isRepeatableError(err) {
return result, err
}
tries++
if tries >= 3 {
err = errors.Wrap(err, "giving up after 3 consecutive repeatable transaction failures")
return result, err
}
}
}
func (s *RetryLayerTeamStore) GetTeamsByScheme(schemeId string, offset int, limit int) ([]*model.Team, *model.AppError) {
func (s *RetryLayerTeamStore) GetTeamsByScheme(schemeId string, offset int, limit int) ([]*model.Team, error) {
return s.TeamStore.GetTeamsByScheme(schemeId, offset, limit)
tries := 0
for {
result, err := s.TeamStore.GetTeamsByScheme(schemeId, 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
}
}
}
@@ -6142,15 +6212,43 @@ func (s *RetryLayerTeamStore) GetTotalMemberCount(teamId string, restrictions *m
}
func (s *RetryLayerTeamStore) GetUserTeamIds(userId string, allowFromCache bool) ([]string, *model.AppError) {
func (s *RetryLayerTeamStore) GetUserTeamIds(userId string, allowFromCache bool) ([]string, error) {
return s.TeamStore.GetUserTeamIds(userId, allowFromCache)
tries := 0
for {
result, err := s.TeamStore.GetUserTeamIds(userId, allowFromCache)
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) GroupSyncedTeamCount() (int64, *model.AppError) {
func (s *RetryLayerTeamStore) GroupSyncedTeamCount() (int64, error) {
return s.TeamStore.GroupSyncedTeamCount()
tries := 0
for {
result, err := s.TeamStore.GroupSyncedTeamCount()
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
}
}
}
@@ -6160,9 +6258,23 @@ func (s *RetryLayerTeamStore) InvalidateAllTeamIdsForUser(userId string) {
}
func (s *RetryLayerTeamStore) MigrateTeamMembers(fromTeamId string, fromUserId string) (map[string]string, *model.AppError) {
func (s *RetryLayerTeamStore) MigrateTeamMembers(fromTeamId string, fromUserId string) (map[string]string, error) {
return s.TeamStore.MigrateTeamMembers(fromTeamId, fromUserId)
tries := 0
for {
result, err := s.TeamStore.MigrateTeamMembers(fromTeamId, fromUserId)
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
}
}
}
@@ -6192,9 +6304,23 @@ func (s *RetryLayerTeamStore) RemoveAllMembersByTeam(teamId string) *model.AppEr
}
func (s *RetryLayerTeamStore) RemoveAllMembersByUser(userId string) *model.AppError {
func (s *RetryLayerTeamStore) RemoveAllMembersByUser(userId string) error {
return s.TeamStore.RemoveAllMembersByUser(userId)
tries := 0
for {
err := s.TeamStore.RemoveAllMembersByUser(userId)
if err == nil {
return nil
}
if !isRepeatableError(err) {
return err
}
tries++
if tries >= 3 {
err = errors.Wrap(err, "giving up after 3 consecutive repeatable transaction failures")
return err
}
}
}
@@ -6210,9 +6336,23 @@ func (s *RetryLayerTeamStore) RemoveMembers(teamId string, userIds []string) *mo
}
func (s *RetryLayerTeamStore) ResetAllTeamSchemes() *model.AppError {
func (s *RetryLayerTeamStore) ResetAllTeamSchemes() error {
return s.TeamStore.ResetAllTeamSchemes()
tries := 0
for {
err := s.TeamStore.ResetAllTeamSchemes()
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
}
}
}
@@ -6376,9 +6516,23 @@ func (s *RetryLayerTeamStore) Update(team *model.Team) (*model.Team, error) {
}
func (s *RetryLayerTeamStore) UpdateLastTeamIconUpdate(teamId string, curTime int64) *model.AppError {
func (s *RetryLayerTeamStore) UpdateLastTeamIconUpdate(teamId string, curTime int64) error {
return s.TeamStore.UpdateLastTeamIconUpdate(teamId, curTime)
tries := 0
for {
err := s.TeamStore.UpdateLastTeamIconUpdate(teamId, curTime)
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
}
}
}
@@ -6388,9 +6542,23 @@ func (s *RetryLayerTeamStore) UpdateMember(member *model.TeamMember) (*model.Tea
}
func (s *RetryLayerTeamStore) UpdateMembersRole(teamID string, userIDs []string) *model.AppError {
func (s *RetryLayerTeamStore) UpdateMembersRole(teamID string, userIDs []string) error {
return s.TeamStore.UpdateMembersRole(teamID, userIDs)
tries := 0
for {
err := s.TeamStore.UpdateMembersRole(teamID, userIDs)
if err == nil {
return nil
}
if !isRepeatableError(err) {
return err
}
tries++
if tries >= 3 {
err = errors.Wrap(err, "giving up after 3 consecutive repeatable transaction failures")
return err
}
}
}
@@ -6400,9 +6568,23 @@ func (s *RetryLayerTeamStore) UpdateMultipleMembers(members []*model.TeamMember)
}
func (s *RetryLayerTeamStore) UserBelongsToTeams(userId string, teamIds []string) (bool, *model.AppError) {
func (s *RetryLayerTeamStore) UserBelongsToTeams(userId string, teamIds []string) (bool, error) {
return s.TeamStore.UserBelongsToTeams(userId, teamIds)
tries := 0
for {
result, err := s.TeamStore.UserBelongsToTeams(userId, teamIds)
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
}
}
}

2
store/searchlayer/team_layer.go
Просмотреть файл

@@ -37,7 +37,7 @@ func (s SearchTeamStore) RemoveMember(teamId string, userId string) *model.AppEr
return err
}
func (s SearchTeamStore) RemoveAllMembersByUser(userId string) *model.AppError {
func (s SearchTeamStore) RemoveAllMembersByUser(userId string) error {
err := s.TeamStore.RemoveAllMembersByUser(userId)
if err == nil {
s.rootStore.indexUserFromID(userId)

115
store/sqlstore/team_store.go
Просмотреть файл

@@ -1059,7 +1059,7 @@ func (s SqlTeamStore) GetMembers(teamId string, offset int, limit int, teamMembe
var dbMembers teamMemberWithSchemeRolesList
_, err = s.GetReplica().Select(&dbMembers, queryString, args...)
if err != nil {
return nil, model.NewAppError("SqlTeamStore.GetMembers", "store.sql_team.get_members.app_error", nil, "teamId="+teamId+" "+err.Error(), http.StatusInternalServerError)
return nil, model.NewAppError("SqlTeamStore.GetMembers", "app.team.get_members.app_error", nil, "teamId="+teamId+" "+err.Error(), http.StatusInternalServerError)
}
return dbMembers.ToModel(), nil
@@ -1145,7 +1145,7 @@ func (s SqlTeamStore) GetTeamsForUser(userId string) ([]*model.TeamMember, *mode
var dbMembers teamMemberWithSchemeRolesList
_, err = s.GetReplica().Select(&dbMembers, queryString, args...)
if err != nil {
return nil, model.NewAppError("SqlTeamStore.GetMembers", "store.sql_team.get_members.app_error", nil, "userId="+userId+" "+err.Error(), http.StatusInternalServerError)
return nil, model.NewAppError("SqlTeamStore.GetMembers", "app.team.get_members.app_error", nil, "userId="+userId+" "+err.Error(), http.StatusInternalServerError)
}
return dbMembers.ToModel(), nil
@@ -1167,7 +1167,7 @@ func (s SqlTeamStore) GetTeamsForUserWithPagination(userId string, page, perPage
var dbMembers teamMemberWithSchemeRolesList
_, err = s.GetReplica().Select(&dbMembers, queryString, args...)
if err != nil {
return nil, model.NewAppError("SqlTeamStore.GetTeamsForUserWithPagination", "store.sql_team.get_members.app_error", nil, "userId="+userId+" "+err.Error(), http.StatusInternalServerError)
return nil, model.NewAppError("SqlTeamStore.GetTeamsForUserWithPagination", "app.team.get_members.app_error", nil, "userId="+userId+" "+err.Error(), http.StatusInternalServerError)
}
return dbMembers.ToModel(), nil
@@ -1229,7 +1229,7 @@ func (s SqlTeamStore) RemoveMembers(teamId string, userIds []string) *model.AppE
}
_, err = s.GetMaster().Exec(sql, args...)
if err != nil {
return model.NewAppError("SqlTeamStore.RemoveMembers", "store.sql_team.remove_member.app_error", nil, "team_id="+teamId+", "+err.Error(), http.StatusInternalServerError)
return model.NewAppError("SqlTeamStore.RemoveMembers", "app.team.remove_member.app_error", nil, "team_id="+teamId+", "+err.Error(), http.StatusInternalServerError)
}
return nil
}
@@ -1250,57 +1250,57 @@ func (s SqlTeamStore) RemoveAllMembersByTeam(teamId string) *model.AppError {
_, err = s.GetMaster().Exec(sql, args...)
if err != nil {
return model.NewAppError("SqlTeamStore.RemoveMember", "store.sql_team.remove_member.app_error", nil, "team_id="+teamId+", "+err.Error(), http.StatusInternalServerError)
return model.NewAppError("SqlTeamStore.RemoveMember", "app.team.remove_member.app_error", nil, "team_id="+teamId+", "+err.Error(), http.StatusInternalServerError)
}
return nil
}
// RemoveAllMembersByUser removes from the database the team members that match the userId passed as parameter.
func (s SqlTeamStore) RemoveAllMembersByUser(userId string) *model.AppError {
sql, args, err := s.getQueryBuilder().
func (s SqlTeamStore) RemoveAllMembersByUser(userId string) error {
query, args, err := s.getQueryBuilder().
Delete("TeamMembers").
Where(sq.Eq{"UserId": userId}).ToSql()
if err != nil {
return model.NewAppError("SqlTeamStore.RemoveMembers", "store.sql.build_query.app_error", nil, "team_id="+userId+", "+err.Error(), http.StatusInternalServerError)
return errors.Wrap(err, "team_tosql")
}
_, err = s.GetMaster().Exec(sql, args...)
_, err = s.GetMaster().Exec(query, args...)
if err != nil {
return model.NewAppError("SqlTeamStore.RemoveMember", "store.sql_team.remove_member.app_error", nil, "user_id="+userId+", "+err.Error(), http.StatusInternalServerError)
return errors.Wrapf(err, "failed to delete TeamMembers with userId=%s", userId)
}
return nil
}
func (s SqlTeamStore) UpdateLastTeamIconUpdate(teamId string, curTime int64) *model.AppError {
sql, args, err := s.getQueryBuilder().
func (s SqlTeamStore) UpdateLastTeamIconUpdate(teamId string, curTime int64) error {
query, args, err := s.getQueryBuilder().
Update("Teams").
SetMap(sq.Eq{"LastTeamIconUpdate": curTime, "UpdateAt": curTime}).
Where(sq.Eq{"Id": teamId}).ToSql()
if err != nil {
return model.NewAppError("SqlTeamStore.UpdateLastTeamIconUpdate", "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.UpdateLastTeamIconUpdate", "store.sql_team.update_last_team_icon_update.app_error", nil, "team_id="+teamId, http.StatusInternalServerError)
if _, err = s.GetMaster().Exec(query, args...); err != nil {
return errors.Wrap(err, "failed to update Team")
}
return nil
}
// GetTeamsByScheme returns from the database all teams that match the schemeId provided as parameter, up to
// a total limit passed as paramater and paginated by offset number passed as parameter.
func (s SqlTeamStore) GetTeamsByScheme(schemeId string, offset int, limit int) ([]*model.Team, *model.AppError) {
func (s SqlTeamStore) GetTeamsByScheme(schemeId string, offset int, limit int) ([]*model.Team, error) {
query, args, err := s.teamsQuery.Where(sq.Eq{"SchemeId": schemeId}).
OrderBy("DisplayName").
Limit(uint64(limit)).
Offset(uint64(offset)).ToSql()
if err != nil {
return nil, model.NewAppError("SqlTeamStore.GetTeamsByScheme", "store.sql.build_query.app_error", nil, err.Error(), http.StatusInternalServerError)
return nil, errors.Wrap(err, "team_tosql")
}
var teams []*model.Team
_, err = s.GetReplica().Select(&teams, query, args...)
if err != nil {
return nil, model.NewAppError("SqlTeamStore.GetTeamsByScheme", "store.sql_team.get_by_scheme.app_error", nil, "schemeId="+schemeId+" "+err.Error(), http.StatusInternalServerError)
return nil, errors.Wrapf(err, "failed to find Teams with schemeId=%s", schemeId)
}
return teams, nil
}
@@ -1309,18 +1309,18 @@ func (s SqlTeamStore) GetTeamsByScheme(schemeId string, offset int, limit int) (
// in batches as a single transaction per batch to ensure consistency but to also minimise execution time to avoid
// causing unnecessary table locks. **THIS FUNCTION SHOULD NOT BE USED FOR ANY OTHER PURPOSE.** Executing this function
// *after* the new Schemes functionality has been used on an installation will have unintended consequences.
func (s SqlTeamStore) MigrateTeamMembers(fromTeamId string, fromUserId string) (map[string]string, *model.AppError) {
func (s SqlTeamStore) MigrateTeamMembers(fromTeamId string, fromUserId string) (map[string]string, error) {
var transaction *gorp.Transaction
var err error
if transaction, err = s.GetMaster().Begin(); err != nil {
return nil, model.NewAppError("SqlTeamStore.MigrateTeamMembers", "store.sql_team.migrate_team_members.open_transaction.app_error", nil, err.Error(), http.StatusInternalServerError)
return nil, errors.Wrap(err, "begin_transaction")
}
defer finalizeTransaction(transaction)
var teamMembers []teamMember
if _, err := transaction.Select(&teamMembers, "SELECT * from TeamMembers WHERE (TeamId, UserId) > (:FromTeamId, :FromUserId) ORDER BY TeamId, UserId LIMIT 100", map[string]interface{}{"FromTeamId": fromTeamId, "FromUserId": fromUserId}); err != nil {
return nil, model.NewAppError("SqlTeamStore.MigrateTeamMembers", "store.sql_team.migrate_team_members.select.app_error", nil, err.Error(), http.StatusInternalServerError)
return nil, errors.Wrap(err, "failed to find TeamMembers")
}
if len(teamMembers) == 0 {
@@ -1355,13 +1355,13 @@ func (s SqlTeamStore) MigrateTeamMembers(fromTeamId string, fromUserId string) (
member.Roles = strings.Join(newRoles, " ")
if _, err := transaction.Update(&member); err != nil {
return nil, model.NewAppError("SqlTeamStore.MigrateTeamMembers", "store.sql_team.migrate_team_members.update.app_error", nil, err.Error(), http.StatusInternalServerError)
return nil, errors.Wrap(err, "failed to update TeamMember")
}
}
if err := transaction.Commit(); err != nil {
return nil, model.NewAppError("SqlTeamStore.MigrateTeamMembers", "store.sql_team.migrate_team_members.commit_transaction.app_error", nil, err.Error(), http.StatusInternalServerError)
return nil, errors.Wrap(err, "commit_transaction")
}
data := make(map[string]string)
@@ -1371,9 +1371,9 @@ func (s SqlTeamStore) MigrateTeamMembers(fromTeamId string, fromUserId string) (
return data, nil
}
func (s SqlTeamStore) ResetAllTeamSchemes() *model.AppError {
func (s SqlTeamStore) ResetAllTeamSchemes() error {
if _, err := s.GetMaster().Exec("UPDATE Teams SET SchemeId=''"); err != nil {
return model.NewAppError("SqlTeamStore.ResetAllTeamSchemes", "store.sql_team.reset_all_team_schemes.app_error", nil, err.Error(), http.StatusInternalServerError)
return errors.Wrap(err, "failed to update Teams")
}
return nil
}
@@ -1383,7 +1383,7 @@ func (s SqlTeamStore) ClearCaches() {}
func (s SqlTeamStore) InvalidateAllTeamIdsForUser(userId string) {}
func (s SqlTeamStore) ClearAllCustomRoleAssignments() *model.AppError {
func (s SqlTeamStore) ClearAllCustomRoleAssignments() error {
builtInRoles := model.MakeDefaultRoles()
lastUserId := strings.Repeat("0", 26)
@@ -1394,13 +1394,13 @@ func (s SqlTeamStore) ClearAllCustomRoleAssignments() *model.AppError {
var err error
if transaction, err = s.GetMaster().Begin(); err != nil {
return model.NewAppError("SqlTeamStore.ClearAllCustomRoleAssignments", "store.sql_team.clear_all_custom_role_assignments.open_transaction.app_error", nil, err.Error(), http.StatusInternalServerError)
return errors.Wrap(err, "begin_transaction")
}
defer finalizeTransaction(transaction)
var teamMembers []*teamMember
if _, err := transaction.Select(&teamMembers, "SELECT * from TeamMembers WHERE (TeamId, UserId) > (:TeamId, :UserId) ORDER BY TeamId, UserId LIMIT 1000", map[string]interface{}{"TeamId": lastTeamId, "UserId": lastUserId}); err != nil {
return model.NewAppError("SqlTeamStore.ClearAllCustomRoleAssignments", "store.sql_team.clear_all_custom_role_assignments.select.app_error", nil, err.Error(), http.StatusInternalServerError)
return errors.Wrap(err, "failed to find TeamMembers")
}
if len(teamMembers) == 0 {
@@ -1425,38 +1425,38 @@ func (s SqlTeamStore) ClearAllCustomRoleAssignments() *model.AppError {
newRolesString := strings.Join(newRoles, " ")
if newRolesString != member.Roles {
if _, err := transaction.Exec("UPDATE TeamMembers SET Roles = :Roles WHERE UserId = :UserId AND TeamId = :TeamId", map[string]interface{}{"Roles": newRolesString, "TeamId": member.TeamId, "UserId": member.UserId}); err != nil {
return model.NewAppError("SqlTeamStore.ClearAllCustomRoleAssignments", "store.sql_team.clear_all_custom_role_assignments.update.app_error", nil, err.Error(), http.StatusInternalServerError)
return errors.Wrap(err, "failed to update TeamMembers")
}
}
}
if err := transaction.Commit(); err != nil {
return model.NewAppError("SqlTeamStore.ClearAllCustomRoleAssignments", "store.sql_team.clear_all_custom_role_assignments.commit_transaction.app_error", nil, err.Error(), http.StatusInternalServerError)
return errors.Wrap(err, "commit_transaction")
}
}
return nil
}
// AnalyticsGetTeamCountForScheme returns the number of active teams that match the schemeId passed as parameter.
func (s SqlTeamStore) AnalyticsGetTeamCountForScheme(schemeId string) (int64, *model.AppError) {
func (s SqlTeamStore) AnalyticsGetTeamCountForScheme(schemeId string) (int64, error) {
query, args, err := s.getQueryBuilder().
Select("count(*)").
From("Teams").
Where(sq.Eq{"SchemeId": schemeId, "DeleteAt": 0}).ToSql()
if err != nil {
return 0, model.NewAppError("SqlTeamStore.AnalyticsGetTeamCountForScheme", "store.sql.build_query.app_error", nil, err.Error(), http.StatusInternalServerError)
return 0, errors.Wrap(err, "team_tosql")
}
count, err := s.GetReplica().SelectInt(query, args...)
if err != nil {
return 0, model.NewAppError("SqlTeamStore.AnalyticsGetTeamCountForScheme", "store.sql_team.analytics_get_team_count_for_scheme.app_error", nil, "schemeId="+schemeId+" "+err.Error(), http.StatusInternalServerError)
return 0, errors.Wrapf(err, "failed to count Teams with schemdId=%s", schemeId)
}
return count, nil
}
// GetAllForExportAfter returns teams for export, up to a total limit passed as paramater where Teams.Id is greater than the afterId passed as parameter.
func (s SqlTeamStore) GetAllForExportAfter(limit int, afterId string) ([]*model.TeamForExport, *model.AppError) {
func (s SqlTeamStore) GetAllForExportAfter(limit int, afterId string) ([]*model.TeamForExport, error) {
var data []*model.TeamForExport
query, args, err := s.getQueryBuilder().
Select("Teams.*", "Schemes.Name as SchemeName").
@@ -1467,36 +1467,36 @@ func (s SqlTeamStore) GetAllForExportAfter(limit int, afterId string) ([]*model.
Limit(uint64(limit)).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(&data, query, args...); err != nil {
return nil, model.NewAppError("SqlTeamStore.GetAllTeams", "app.team.get_all.app_error", nil, err.Error(), http.StatusInternalServerError)
return nil, errors.Wrap(err, "failed to find Teams")
}
return data, nil
}
// GetUserTeamIds get the team ids to which the user belongs to. allowFromCache parameter does not have any effect in this Store
func (s SqlTeamStore) GetUserTeamIds(userID string, allowFromCache bool) ([]string, *model.AppError) {
func (s SqlTeamStore) GetUserTeamIds(userId string, allowFromCache bool) ([]string, error) {
var teamIds []string
query, args, err := s.getQueryBuilder().
Select("TeamId").
From("TeamMembers").
Join("Teams ON TeamMembers.TeamId = Teams.Id").
Where(sq.Eq{"TeamMembers.UserId": userID, "TeamMembers.DeleteAt": 0, "Teams.DeleteAt": 0}).ToSql()
Where(sq.Eq{"TeamMembers.UserId": userId, "TeamMembers.DeleteAt": 0, "Teams.DeleteAt": 0}).ToSql()
if err != nil {
return []string{}, model.NewAppError("SqlTeamStore.GetUserTeamIds", "store.sql.build_query.app_error", nil, err.Error(), http.StatusInternalServerError)
return []string{}, errors.Wrap(err, "team_tosql")
}
_, err = s.GetReplica().Select(&teamIds, query, args...)
if err != nil {
return []string{}, model.NewAppError("SqlTeamStore.GetUserTeamIds", "store.sql_team.get_user_team_ids.app_error", nil, "userID="+userID+" "+err.Error(), http.StatusInternalServerError)
return []string{}, errors.Wrapf(err, "failed to find TeamMembers with userId=%s", userId)
}
return teamIds, nil
}
func (s SqlTeamStore) GetTeamMembersForExport(userId string) ([]*model.TeamMemberForExport, *model.AppError) {
func (s SqlTeamStore) GetTeamMembersForExport(userId string) ([]*model.TeamMemberForExport, error) {
var members []*model.TeamMemberForExport
query, args, err := s.getQueryBuilder().
Select("TeamMembers.TeamId", "TeamMembers.UserId", "TeamMembers.Roles", "TeamMembers.DeleteAt",
@@ -1507,16 +1507,16 @@ func (s SqlTeamStore) GetTeamMembersForExport(userId string) ([]*model.TeamMembe
Where(sq.Eq{"TeamMembers.UserId": userId, "Teams.DeleteAt": 0}).ToSql()
if err != nil {
return nil, model.NewAppError("SqlTeamStore.GetTeamMembersForExport", "store.sql.build_query.app_error", nil, err.Error(), http.StatusInternalServerError)
return nil, errors.Wrap(err, "team_tosql")
}
_, err = s.GetReplica().Select(&members, query, args...)
if err != nil {
return nil, model.NewAppError("SqlTeamStore.GetTeamMembersForExport", "store.sql_team.get_members.app_error", nil, "userId="+userId+" "+err.Error(), http.StatusInternalServerError)
return nil, errors.Wrapf(err, "failed to find TeamMembers with userId=%s", userId)
}
return members, nil
}
func (s SqlTeamStore) UserBelongsToTeams(userId string, teamIds []string) (bool, *model.AppError) {
func (s SqlTeamStore) UserBelongsToTeams(userId string, teamIds []string) (bool, error) {
idQuery := sq.Eq{
"UserId": userId,
"TeamId": teamIds,
@@ -1525,28 +1525,29 @@ func (s SqlTeamStore) UserBelongsToTeams(userId string, teamIds []string) (bool,
query, params, err := s.getQueryBuilder().Select("Count(*)").From("TeamMembers").Where(idQuery).ToSql()
if err != nil {
return false, model.NewAppError("SqlTeamStore.UserBelongsToTeams", "store.sql.build_query.app_error", nil, err.Error(), http.StatusInternalServerError)
return false, errors.Wrap(err, "team_tosql")
}
c, err := s.GetReplica().SelectInt(query, params...)
if err != nil {
return false, model.NewAppError("SqlTeamStore.UserBelongsToTeams", "store.sql_team.user_belongs_to_teams.app_error", nil, err.Error(), http.StatusInternalServerError)
return false, errors.Wrap(err, "failed to count TeamMembers")
}
return c > 0, nil
}
func (s SqlTeamStore) UpdateMembersRole(teamID string, userIDs []string) *model.AppError {
sql, args, err := s.getQueryBuilder().
func (s SqlTeamStore) UpdateMembersRole(teamID string, userIDs []string) error {
query, args, err := s.getQueryBuilder().
Update("TeamMembers").
Set("SchemeAdmin", sq.Case().When(sq.Eq{"UserId": userIDs}, "true").Else("false")).
Where(sq.Eq{"TeamId": teamID, "DeleteAt": 0}).
Where(sq.Or{sq.Eq{"SchemeGuest": false}, sq.Expr("SchemeGuest IS NULL")}).ToSql()
if err != nil {
return model.NewAppError("SqlTeamStore.UpdateMembersRole", "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.UpdateMembersRole", "store.update_error", nil, err.Error(), http.StatusInternalServerError)
if _, err = s.GetMaster().Exec(query, args...); err != nil {
return errors.Wrap(err, "failed to update TeamMembers")
}
return nil
@@ -1612,17 +1613,17 @@ func applyTeamMemberViewRestrictionsFilterForStats(query sq.SelectBuilder, teamI
return resultQuery
}
func (s SqlTeamStore) GroupSyncedTeamCount() (int64, *model.AppError) {
query := s.getQueryBuilder().Select("COUNT(*)").From("Teams").Where(sq.Eq{"GroupConstrained": true, "DeleteAt": 0})
func (s SqlTeamStore) GroupSyncedTeamCount() (int64, error) {
builder := s.getQueryBuilder().Select("COUNT(*)").From("Teams").Where(sq.Eq{"GroupConstrained": true, "DeleteAt": 0})
sql, args, err := query.ToSql()
query, args, err := builder.ToSql()
if err != nil {
return 0, model.NewAppError("SqlTeamStore.GroupSyncedTeamCount", "store.sql.build_query.app_error", nil, err.Error(), http.StatusInternalServerError)
return 0, errors.Wrap(err, "team_tosql")
}
count, err := s.GetReplica().SelectInt(sql, args...)
count, err := s.GetReplica().SelectInt(query, args...)
if err != nil {
return 0, model.NewAppError("SqlTeamStore.GroupSyncedTeamCount", "store.select_error", nil, err.Error(), http.StatusInternalServerError)
return 0, errors.Wrap(err, "failed to count Teams")
}
return count, nil

26
store/store.go
Просмотреть файл

@@ -108,26 +108,26 @@ type TeamStore interface {
RemoveMember(teamId string, userId string) *model.AppError
RemoveMembers(teamId string, userIds []string) *model.AppError
RemoveAllMembersByTeam(teamId string) *model.AppError
RemoveAllMembersByUser(userId string) *model.AppError
UpdateLastTeamIconUpdate(teamId string, curTime int64) *model.AppError
GetTeamsByScheme(schemeId string, offset int, limit int) ([]*model.Team, *model.AppError)
MigrateTeamMembers(fromTeamId string, fromUserId string) (map[string]string, *model.AppError)
ResetAllTeamSchemes() *model.AppError
ClearAllCustomRoleAssignments() *model.AppError
AnalyticsGetTeamCountForScheme(schemeId string) (int64, *model.AppError)
GetAllForExportAfter(limit int, afterId string) ([]*model.TeamForExport, *model.AppError)
GetTeamMembersForExport(userId string) ([]*model.TeamMemberForExport, *model.AppError)
UserBelongsToTeams(userId string, teamIds []string) (bool, *model.AppError)
GetUserTeamIds(userId string, allowFromCache bool) ([]string, *model.AppError)
RemoveAllMembersByUser(userId string) error
UpdateLastTeamIconUpdate(teamId string, curTime int64) error
GetTeamsByScheme(schemeId string, offset int, limit int) ([]*model.Team, error)
MigrateTeamMembers(fromTeamId string, fromUserId string) (map[string]string, error)
ResetAllTeamSchemes() error
ClearAllCustomRoleAssignments() error
AnalyticsGetTeamCountForScheme(schemeId string) (int64, error)
GetAllForExportAfter(limit int, afterId string) ([]*model.TeamForExport, error)
GetTeamMembersForExport(userId string) ([]*model.TeamMemberForExport, error)
UserBelongsToTeams(userId string, teamIds []string) (bool, error)
GetUserTeamIds(userId string, allowFromCache bool) ([]string, error)
InvalidateAllTeamIdsForUser(userId string)
ClearCaches()
// UpdateMembersRole sets all of the given team members to admins and all of the other members of the team to
// non-admin members.
UpdateMembersRole(teamID string, userIDs []string) *model.AppError
UpdateMembersRole(teamID string, userIDs []string) error
// GroupSyncedTeamCount returns the count of non-deleted group-constrained teams.
GroupSyncedTeamCount() (int64, *model.AppError)
GroupSyncedTeamCount() (int64, error)
}
type ChannelStore interface {

130
store/storetest/mocks/TeamStore.go
Просмотреть файл

@@ -15,7 +15,7 @@ type TeamStore struct {
}
// AnalyticsGetTeamCountForScheme provides a mock function with given fields: schemeId
func (_m *TeamStore) AnalyticsGetTeamCountForScheme(schemeId string) (int64, *model.AppError) {
func (_m *TeamStore) AnalyticsGetTeamCountForScheme(schemeId string) (int64, error) {
ret := _m.Called(schemeId)
var r0 int64
@@ -25,13 +25,11 @@ func (_m *TeamStore) AnalyticsGetTeamCountForScheme(schemeId string) (int64, *mo
r0 = ret.Get(0).(int64)
}
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(schemeId)
} else {
if ret.Get(1) != nil {
r1 = ret.Get(1).(*model.AppError)
}
r1 = ret.Error(1)
}
return r0, r1
@@ -101,16 +99,14 @@ func (_m *TeamStore) AnalyticsTeamCount(includeDeleted bool) (int64, error) {
}
// ClearAllCustomRoleAssignments provides a mock function with given fields:
func (_m *TeamStore) ClearAllCustomRoleAssignments() *model.AppError {
func (_m *TeamStore) ClearAllCustomRoleAssignments() error {
ret := _m.Called()
var r0 *model.AppError
if rf, ok := ret.Get(0).(func() *model.AppError); ok {
var r0 error
if rf, ok := ret.Get(0).(func() error); ok {
r0 = rf()
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*model.AppError)
}
r0 = ret.Error(0)
}
return r0
@@ -191,7 +187,7 @@ func (_m *TeamStore) GetAll() ([]*model.Team, error) {
}
// GetAllForExportAfter provides a mock function with given fields: limit, afterId
func (_m *TeamStore) GetAllForExportAfter(limit int, afterId string) ([]*model.TeamForExport, *model.AppError) {
func (_m *TeamStore) GetAllForExportAfter(limit int, afterId string) ([]*model.TeamForExport, error) {
ret := _m.Called(limit, afterId)
var r0 []*model.TeamForExport
@@ -203,13 +199,11 @@ func (_m *TeamStore) GetAllForExportAfter(limit int, afterId string) ([]*model.T
}
}
var r1 *model.AppError
if rf, ok := ret.Get(1).(func(int, string) *model.AppError); ok {
var r1 error
if rf, ok := ret.Get(1).(func(int, string) error); ok {
r1 = rf(limit, afterId)
} else {
if ret.Get(1) != nil {
r1 = ret.Get(1).(*model.AppError)
}
r1 = ret.Error(1)
}
return r0, r1
@@ -548,7 +542,7 @@ func (_m *TeamStore) GetMembersByIds(teamId string, userIds []string, restrictio
}
// GetTeamMembersForExport provides a mock function with given fields: userId
func (_m *TeamStore) GetTeamMembersForExport(userId string) ([]*model.TeamMemberForExport, *model.AppError) {
func (_m *TeamStore) GetTeamMembersForExport(userId string) ([]*model.TeamMemberForExport, error) {
ret := _m.Called(userId)
var r0 []*model.TeamMemberForExport
@@ -560,20 +554,18 @@ func (_m *TeamStore) GetTeamMembersForExport(userId string) ([]*model.TeamMember
}
}
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
}
// GetTeamsByScheme provides a mock function with given fields: schemeId, offset, limit
func (_m *TeamStore) GetTeamsByScheme(schemeId string, offset int, limit int) ([]*model.Team, *model.AppError) {
func (_m *TeamStore) GetTeamsByScheme(schemeId string, offset int, limit int) ([]*model.Team, error) {
ret := _m.Called(schemeId, offset, limit)
var r0 []*model.Team
@@ -585,13 +577,11 @@ func (_m *TeamStore) GetTeamsByScheme(schemeId string, offset int, limit int) ([
}
}
var r1 *model.AppError
if rf, ok := ret.Get(1).(func(string, int, int) *model.AppError); ok {
var r1 error
if rf, ok := ret.Get(1).(func(string, int, int) error); ok {
r1 = rf(schemeId, offset, limit)
} else {
if ret.Get(1) != nil {
r1 = ret.Get(1).(*model.AppError)
}
r1 = ret.Error(1)
}
return r0, r1
@@ -694,7 +684,7 @@ func (_m *TeamStore) GetTotalMemberCount(teamId string, restrictions *model.View
}
// GetUserTeamIds provides a mock function with given fields: userId, allowFromCache
func (_m *TeamStore) GetUserTeamIds(userId string, allowFromCache bool) ([]string, *model.AppError) {
func (_m *TeamStore) GetUserTeamIds(userId string, allowFromCache bool) ([]string, error) {
ret := _m.Called(userId, allowFromCache)
var r0 []string
@@ -706,20 +696,18 @@ func (_m *TeamStore) GetUserTeamIds(userId string, allowFromCache bool) ([]strin
}
}
var r1 *model.AppError
if rf, ok := ret.Get(1).(func(string, bool) *model.AppError); ok {
var r1 error
if rf, ok := ret.Get(1).(func(string, bool) error); ok {
r1 = rf(userId, allowFromCache)
} else {
if ret.Get(1) != nil {
r1 = ret.Get(1).(*model.AppError)
}
r1 = ret.Error(1)
}
return r0, r1
}
// GroupSyncedTeamCount provides a mock function with given fields:
func (_m *TeamStore) GroupSyncedTeamCount() (int64, *model.AppError) {
func (_m *TeamStore) GroupSyncedTeamCount() (int64, error) {
ret := _m.Called()
var r0 int64
@@ -729,13 +717,11 @@ func (_m *TeamStore) GroupSyncedTeamCount() (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
@@ -747,7 +733,7 @@ func (_m *TeamStore) InvalidateAllTeamIdsForUser(userId string) {
}
// MigrateTeamMembers provides a mock function with given fields: fromTeamId, fromUserId
func (_m *TeamStore) MigrateTeamMembers(fromTeamId string, fromUserId string) (map[string]string, *model.AppError) {
func (_m *TeamStore) MigrateTeamMembers(fromTeamId string, fromUserId string) (map[string]string, error) {
ret := _m.Called(fromTeamId, fromUserId)
var r0 map[string]string
@@ -759,13 +745,11 @@ func (_m *TeamStore) MigrateTeamMembers(fromTeamId string, fromUserId string) (m
}
}
var r1 *model.AppError
if rf, ok := ret.Get(1).(func(string, string) *model.AppError); ok {
var r1 error
if rf, ok := ret.Get(1).(func(string, string) error); ok {
r1 = rf(fromTeamId, fromUserId)
} else {
if ret.Get(1) != nil {
r1 = ret.Get(1).(*model.AppError)
}
r1 = ret.Error(1)
}
return r0, r1
@@ -802,16 +786,14 @@ func (_m *TeamStore) RemoveAllMembersByTeam(teamId string) *model.AppError {
}
// RemoveAllMembersByUser provides a mock function with given fields: userId
func (_m *TeamStore) RemoveAllMembersByUser(userId string) *model.AppError {
func (_m *TeamStore) RemoveAllMembersByUser(userId string) error {
ret := _m.Called(userId)
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(userId)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*model.AppError)
}
r0 = ret.Error(0)
}
return r0
@@ -850,16 +832,14 @@ func (_m *TeamStore) RemoveMembers(teamId string, userIds []string) *model.AppEr
}
// ResetAllTeamSchemes provides a mock function with given fields:
func (_m *TeamStore) ResetAllTeamSchemes() *model.AppError {
func (_m *TeamStore) ResetAllTeamSchemes() error {
ret := _m.Called()
var r0 *model.AppError
if rf, ok := ret.Get(0).(func() *model.AppError); ok {
var r0 error
if rf, ok := ret.Get(0).(func() error); ok {
r0 = rf()
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*model.AppError)
}
r0 = ret.Error(0)
}
return r0
@@ -1057,16 +1037,14 @@ func (_m *TeamStore) Update(team *model.Team) (*model.Team, error) {
}
// UpdateLastTeamIconUpdate provides a mock function with given fields: teamId, curTime
func (_m *TeamStore) UpdateLastTeamIconUpdate(teamId string, curTime int64) *model.AppError {
func (_m *TeamStore) UpdateLastTeamIconUpdate(teamId string, curTime int64) error {
ret := _m.Called(teamId, curTime)
var r0 *model.AppError
if rf, ok := ret.Get(0).(func(string, int64) *model.AppError); ok {
var r0 error
if rf, ok := ret.Get(0).(func(string, int64) error); ok {
r0 = rf(teamId, curTime)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*model.AppError)
}
r0 = ret.Error(0)
}
return r0
@@ -1098,16 +1076,14 @@ func (_m *TeamStore) UpdateMember(member *model.TeamMember) (*model.TeamMember,
}
// UpdateMembersRole provides a mock function with given fields: teamID, userIDs
func (_m *TeamStore) UpdateMembersRole(teamID string, userIDs []string) *model.AppError {
func (_m *TeamStore) UpdateMembersRole(teamID string, userIDs []string) error {
ret := _m.Called(teamID, userIDs)
var r0 *model.AppError
if rf, ok := ret.Get(0).(func(string, []string) *model.AppError); ok {
var r0 error
if rf, ok := ret.Get(0).(func(string, []string) error); ok {
r0 = rf(teamID, userIDs)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*model.AppError)
}
r0 = ret.Error(0)
}
return r0
@@ -1139,7 +1115,7 @@ func (_m *TeamStore) UpdateMultipleMembers(members []*model.TeamMember) ([]*mode
}
// UserBelongsToTeams provides a mock function with given fields: userId, teamIds
func (_m *TeamStore) UserBelongsToTeams(userId string, teamIds []string) (bool, *model.AppError) {
func (_m *TeamStore) UserBelongsToTeams(userId string, teamIds []string) (bool, error) {
ret := _m.Called(userId, teamIds)
var r0 bool
@@ -1149,13 +1125,11 @@ func (_m *TeamStore) UserBelongsToTeams(userId string, teamIds []string) (bool,
r0 = ret.Get(0).(bool)
}
var r1 *model.AppError
if rf, ok := ret.Get(1).(func(string, []string) *model.AppError); ok {
var r1 error
if rf, ok := ret.Get(1).(func(string, []string) error); ok {
r1 = rf(userId, teamIds)
} else {
if ret.Get(1) != nil {
r1 = ret.Get(1).(*model.AppError)
}
r1 = ret.Error(1)
}
return r0, r1

12
store/storetest/team_store.go
Просмотреть файл

@@ -1240,8 +1240,8 @@ func testTeamMembers(t *testing.T, ss store.Store) {
require.Nil(t, err)
require.Len(t, ms, 2)
err = ss.Team().RemoveAllMembersByUser(uid)
require.Nil(t, err)
nErr = ss.Team().RemoveAllMembersByUser(uid)
require.Nil(t, nErr)
ms, err = ss.Team().GetTeamsForUser(m1.UserId)
require.Nil(t, err)
@@ -2730,8 +2730,8 @@ func testTeamMembersWithPagination(t *testing.T, ss store.Store) {
require.Nil(t, err)
require.Len(t, result, 1)
err = ss.Team().RemoveAllMembersByUser(uid)
require.Nil(t, err)
nErr = ss.Team().RemoveAllMembersByUser(uid)
require.Nil(t, nErr)
result, err = ss.Team().GetTeamsForUserWithPagination(uid, 1, 1)
require.Nil(t, err)
@@ -3030,8 +3030,8 @@ func testGetChannelUnreadsForAllTeams(t *testing.T, ss store.Store) {
require.Equal(t, 10, int(ms2[0].MsgCount), "subtraction failed")
err = ss.Team().RemoveAllMembersByUser(uid)
require.Nil(t, err)
nErr = ss.Team().RemoveAllMembersByUser(uid)
require.Nil(t, nErr)
}
func testGetChannelUnreadsForTeam(t *testing.T, ss store.Store) {

26
store/timerlayer/timerlayer.go
Просмотреть файл

@@ -5862,7 +5862,7 @@ func (s *TimerLayerSystemStore) Update(system *model.System) error {
return err
}
func (s *TimerLayerTeamStore) AnalyticsGetTeamCountForScheme(schemeId string) (int64, *model.AppError) {
func (s *TimerLayerTeamStore) AnalyticsGetTeamCountForScheme(schemeId string) (int64, error) {
start := timemodule.Now()
result, err := s.TeamStore.AnalyticsGetTeamCountForScheme(schemeId)
@@ -5926,7 +5926,7 @@ func (s *TimerLayerTeamStore) AnalyticsTeamCount(includeDeleted bool) (int64, er
return result, err
}
func (s *TimerLayerTeamStore) ClearAllCustomRoleAssignments() *model.AppError {
func (s *TimerLayerTeamStore) ClearAllCustomRoleAssignments() error {
start := timemodule.Now()
err := s.TeamStore.ClearAllCustomRoleAssignments()
@@ -6005,7 +6005,7 @@ func (s *TimerLayerTeamStore) GetAll() ([]*model.Team, error) {
return result, err
}
func (s *TimerLayerTeamStore) GetAllForExportAfter(limit int, afterId string) ([]*model.TeamForExport, *model.AppError) {
func (s *TimerLayerTeamStore) GetAllForExportAfter(limit int, afterId string) ([]*model.TeamForExport, error) {
start := timemodule.Now()
result, err := s.TeamStore.GetAllForExportAfter(limit, afterId)
@@ -6245,7 +6245,7 @@ func (s *TimerLayerTeamStore) GetMembersByIds(teamId string, userIds []string, r
return result, err
}
func (s *TimerLayerTeamStore) GetTeamMembersForExport(userId string) ([]*model.TeamMemberForExport, *model.AppError) {
func (s *TimerLayerTeamStore) GetTeamMembersForExport(userId string) ([]*model.TeamMemberForExport, error) {
start := timemodule.Now()
result, err := s.TeamStore.GetTeamMembersForExport(userId)
@@ -6261,7 +6261,7 @@ func (s *TimerLayerTeamStore) GetTeamMembersForExport(userId string) ([]*model.T
return result, err
}
func (s *TimerLayerTeamStore) GetTeamsByScheme(schemeId string, offset int, limit int) ([]*model.Team, *model.AppError) {
func (s *TimerLayerTeamStore) GetTeamsByScheme(schemeId string, offset int, limit int) ([]*model.Team, error) {
start := timemodule.Now()
result, err := s.TeamStore.GetTeamsByScheme(schemeId, offset, limit)
@@ -6341,7 +6341,7 @@ func (s *TimerLayerTeamStore) GetTotalMemberCount(teamId string, restrictions *m
return result, err
}
func (s *TimerLayerTeamStore) GetUserTeamIds(userId string, allowFromCache bool) ([]string, *model.AppError) {
func (s *TimerLayerTeamStore) GetUserTeamIds(userId string, allowFromCache bool) ([]string, error) {
start := timemodule.Now()
result, err := s.TeamStore.GetUserTeamIds(userId, allowFromCache)
@@ -6357,7 +6357,7 @@ func (s *TimerLayerTeamStore) GetUserTeamIds(userId string, allowFromCache bool)
return result, err
}
func (s *TimerLayerTeamStore) GroupSyncedTeamCount() (int64, *model.AppError) {
func (s *TimerLayerTeamStore) GroupSyncedTeamCount() (int64, error) {
start := timemodule.Now()
result, err := s.TeamStore.GroupSyncedTeamCount()
@@ -6388,7 +6388,7 @@ func (s *TimerLayerTeamStore) InvalidateAllTeamIdsForUser(userId string) {
}
}
func (s *TimerLayerTeamStore) MigrateTeamMembers(fromTeamId string, fromUserId string) (map[string]string, *model.AppError) {
func (s *TimerLayerTeamStore) MigrateTeamMembers(fromTeamId string, fromUserId string) (map[string]string, error) {
start := timemodule.Now()
result, err := s.TeamStore.MigrateTeamMembers(fromTeamId, fromUserId)
@@ -6436,7 +6436,7 @@ func (s *TimerLayerTeamStore) RemoveAllMembersByTeam(teamId string) *model.AppEr
return err
}
func (s *TimerLayerTeamStore) RemoveAllMembersByUser(userId string) *model.AppError {
func (s *TimerLayerTeamStore) RemoveAllMembersByUser(userId string) error {
start := timemodule.Now()
err := s.TeamStore.RemoveAllMembersByUser(userId)
@@ -6484,7 +6484,7 @@ func (s *TimerLayerTeamStore) RemoveMembers(teamId string, userIds []string) *mo
return err
}
func (s *TimerLayerTeamStore) ResetAllTeamSchemes() *model.AppError {
func (s *TimerLayerTeamStore) ResetAllTeamSchemes() error {
start := timemodule.Now()
err := s.TeamStore.ResetAllTeamSchemes()
@@ -6628,7 +6628,7 @@ func (s *TimerLayerTeamStore) Update(team *model.Team) (*model.Team, error) {
return result, err
}
func (s *TimerLayerTeamStore) UpdateLastTeamIconUpdate(teamId string, curTime int64) *model.AppError {
func (s *TimerLayerTeamStore) UpdateLastTeamIconUpdate(teamId string, curTime int64) error {
start := timemodule.Now()
err := s.TeamStore.UpdateLastTeamIconUpdate(teamId, curTime)
@@ -6660,7 +6660,7 @@ func (s *TimerLayerTeamStore) UpdateMember(member *model.TeamMember) (*model.Tea
return result, err
}
func (s *TimerLayerTeamStore) UpdateMembersRole(teamID string, userIDs []string) *model.AppError {
func (s *TimerLayerTeamStore) UpdateMembersRole(teamID string, userIDs []string) error {
start := timemodule.Now()
err := s.TeamStore.UpdateMembersRole(teamID, userIDs)
@@ -6692,7 +6692,7 @@ func (s *TimerLayerTeamStore) UpdateMultipleMembers(members []*model.TeamMember)
return result, err
}
func (s *TimerLayerTeamStore) UserBelongsToTeams(userId string, teamIds []string) (bool, *model.AppError) {
func (s *TimerLayerTeamStore) UserBelongsToTeams(userId string, teamIds []string) (bool, error) {
start := timemodule.Now()
result, err := s.TeamStore.UserBelongsToTeams(userId, teamIds)