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

Migration of TeamStore Part 1 (#15246)

Просмотр исходного кода 
Automatic Merge
Этот коммит содержится в:
Rodrigo Villablanca
2020-09-03 00:29:57 -04:00
коммит произвёл GitHub
родитель 953899ad95
Коммит 54f86e7fb1
29 изменённых файлов: 1131 добавлений и 616 удалений
Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

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

@@ -9,6 +9,9 @@ import (
"github.com/mattermost/mattermost-server/v5/audit"
"github.com/mattermost/mattermost-server/v5/model"
"github.com/mattermost/mattermost-server/v5/store"
"github.com/pkg/errors"
)
func (api *API) InitTeamLocal() {
@@ -89,9 +92,15 @@ func localInviteUsersToTeam(c *Context, w http.ResponseWriter, r *http.Request)
auditRec.AddMeta("count", len(emailList))
auditRec.AddMeta("emails", emailList)
team, err := c.App.Srv().Store.Team().Get(c.Params.TeamId)
if err != nil {
c.Err = err
team, nErr := c.App.Srv().Store.Team().Get(c.Params.TeamId)
if nErr != nil {
var nfErr *store.ErrNotFound
switch {
case errors.As(nErr, &nfErr):
c.Err = model.NewAppError("localInviteUsersToTeam", "app.team.get.find.app_error", nil, nfErr.Error(), http.StatusNotFound)
default:
c.Err = model.NewAppError("localInviteUsersToTeam", "app.team.get.finding.app_error", nil, nErr.Error(), http.StatusInternalServerError)
}
return
}
@@ -115,7 +124,7 @@ func localInviteUsersToTeam(c *Context, w http.ResponseWriter, r *http.Request)
}
auditRec.AddMeta("errors", errList)
if len(goodEmails) > 0 {
err = c.App.Srv().EmailService.SendInviteEmails(team, "Administrator", "mmctl "+model.NewId(), goodEmails, *c.App.Config().ServiceSettings.SiteURL)
err := c.App.Srv().EmailService.SendInviteEmails(team, "Administrator", "mmctl "+model.NewId(), goodEmails, *c.App.Config().ServiceSettings.SiteURL)
if err != nil {
c.Err = err
return
@@ -136,7 +145,7 @@ func localInviteUsersToTeam(c *Context, w http.ResponseWriter, r *http.Request)
c.Err = model.NewAppError("localInviteUsersToTeam", "api.team.invite_members.invalid_email.app_error", map[string]interface{}{"Addresses": s}, "", http.StatusBadRequest)
return
}
err = c.App.Srv().EmailService.SendInviteEmails(team, "Administrator", "mmctl "+model.NewId(), emailList, *c.App.Config().ServiceSettings.SiteURL)
err := c.App.Srv().EmailService.SendInviteEmails(team, "Administrator", "mmctl "+model.NewId(), emailList, *c.App.Config().ServiceSettings.SiteURL)
if err != nil {
c.Err = err
return

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

@@ -42,7 +42,7 @@ func TestCreateTeam(t *testing.T) {
rteam.Id = ""
_, resp = client.CreateTeam(rteam)
CheckErrorMessage(t, resp, "store.sql_team.save.domain_exists.app_error")
CheckErrorMessage(t, resp, "app.team.save.existing.app_error")
CheckBadRequestStatus(t, resp)
rteam.Name = ""

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

@@ -495,7 +495,7 @@ func TestCreateUserWithInviteId(t *testing.T) {
_, resp := th.Client.CreateUserWithInviteId(&user, inviteId)
CheckNotFoundStatus(t, resp)
CheckErrorMessage(t, resp, "store.sql_team.get_by_invite_id.finding.app_error")
CheckErrorMessage(t, resp, "app.team.get_by_invite_id.finding.app_error")
})
t.Run("NoInviteId", func(t *testing.T) {
@@ -516,7 +516,7 @@ func TestCreateUserWithInviteId(t *testing.T) {
_, resp = th.Client.CreateUserWithInviteId(&user, inviteId)
CheckNotFoundStatus(t, resp)
CheckErrorMessage(t, resp, "store.sql_team.get_by_invite_id.finding.app_error")
CheckErrorMessage(t, resp, "app.team.get_by_invite_id.finding.app_error")
})
t.Run("EnableUserCreationDisable", func(t *testing.T) {

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

@@ -87,7 +87,7 @@ func (a *App) GetAnalytics(name string, teamId string) (model.AnalyticsRows, *mo
teamCountChan := make(chan store.StoreResult, 1)
go func() {
teamCount, err2 := a.Srv().Store.Team().AnalyticsTeamCount(false)
teamCountChan <- store.StoreResult{Data: teamCount, Err: err2}
teamCountChan <- store.StoreResult{Data: teamCount, NErr: err2}
close(teamCountChan)
}()
@@ -148,8 +148,8 @@ func (a *App) GetAnalytics(name string, teamId string) (model.AnalyticsRows, *mo
}
r = <-teamCountChan
if r.Err != nil {
return nil, r.Err
if r.NErr != nil {
return nil, model.NewAppError("GetAnalytics", "app.team.analytics_team_count.app_error", nil, r.NErr.Error(), http.StatusInternalServerError)
}
rows[4].Value = float64(r.Data.(int64))

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

@@ -1528,8 +1528,13 @@ func (a *App) GetChannelByNameForTeamName(channelName, teamName string, includeD
team, err := a.Srv().Store.Team().GetByName(teamName)
if err != nil {
err.StatusCode = http.StatusNotFound
return nil, err
var nfErr *store.ErrNotFound
switch {
case errors.As(err, &nfErr):
return nil, model.NewAppError("GetChannelByNameForTeamName", "app.team.get_by_name.missing.app_error", nil, nfErr.Error(), http.StatusNotFound)
default:
return nil, model.NewAppError("GetChannelByNameForTeamName", "app.team.get_by_name.app_error", nil, err.Error(), http.StatusNotFound)
}
}
var result *model.Channel
@@ -2399,9 +2404,15 @@ func (a *App) MoveChannel(team *model.Team, channel *model.Channel, user *model.
}
// keep instance of the previous team
previousTeam, err := a.Srv().Store.Team().Get(channel.TeamId)
if err != nil {
return err
previousTeam, nErr := a.Srv().Store.Team().Get(channel.TeamId)
if nErr != nil {
var nfErr *store.ErrNotFound
switch {
case errors.As(nErr, &nfErr):
return model.NewAppError("MoveChannel", "app.team.get.find.app_error", nil, nfErr.Error(), http.StatusNotFound)
default:
return model.NewAppError("MoveChannel", "app.team.get.finding.app_error", nil, nErr.Error(), http.StatusInternalServerError)
}
}
if appErr := a.Srv().Store.Channel().UpdateSidebarChannelCategoryOnMove(channel, team.Id); appErr != nil {

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

@@ -360,7 +360,7 @@ func (a *App) tryExecuteCustomCommand(args *model.CommandArgs, trigger string, m
teamChan := make(chan store.StoreResult, 1)
go func() {
team, err := a.Srv().Store.Team().Get(args.TeamId)
teamChan <- store.StoreResult{Data: team, Err: err}
teamChan <- store.StoreResult{Data: team, NErr: err}
close(teamChan)
}()
@@ -377,8 +377,14 @@ func (a *App) tryExecuteCustomCommand(args *model.CommandArgs, trigger string, m
}
tr := <-teamChan
if tr.Err != nil {
return nil, nil, tr.Err
if tr.NErr != nil {
var nfErr *store.ErrNotFound
switch {
case errors.As(tr.NErr, &nfErr):
return nil, nil, model.NewAppError("tryExecuteCustomCommand", "app.team.get.find.app_error", nil, nfErr.Error(), http.StatusNotFound)
default:
return nil, nil, model.NewAppError("tryExecuteCustomCommand", "app.team.get.finding.app_error", nil, tr.NErr.Error(), http.StatusInternalServerError)
}
}
team := tr.Data.(*model.Team)

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

@@ -140,9 +140,9 @@ func (job *EmailBatchingJob) checkPendingNotifications(now time.Time, handler fu
continue
}
team, err := job.server.Store.Team().GetByName(notifications[0].teamName)
if err != nil {
mlog.Error("Unable to find Team id for notification", mlog.Err(err))
team, nErr := job.server.Store.Team().GetByName(notifications[0].teamName)
if nErr != nil {
mlog.Error("Unable to find Team id for notification", mlog.Err(nErr))
continue
}

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

@@ -108,9 +108,15 @@ func (a *App) UpsertGroupSyncable(groupSyncable *model.GroupSyncable) (*model.Gr
}
var team *model.Team
team, err = a.Srv().Store.Team().Get(channel.TeamId)
if err != nil {
return nil, err
team, nErr = a.Srv().Store.Team().Get(channel.TeamId)
if nErr != nil {
var nfErr *store.ErrNotFound
switch {
case errors.As(nErr, &nfErr):
return nil, model.NewAppError("UpsertGroupSyncable", "app.team.get.find.app_error", nil, nfErr.Error(), http.StatusNotFound)
default:
return nil, model.NewAppError("UpsertGroupSyncable", "app.team.get.finding.app_error", nil, nErr.Error(), http.StatusInternalServerError)
}
}
if team.IsGroupConstrained() {
var teamGroups []*model.GroupWithSchemeAdmin

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

@@ -140,7 +140,7 @@ func (a *App) DoPostActionWithCookie(postId, actionId, userId, selectedOption st
action := post.GetAction(actionId)
if action == nil || action.Integration == nil {
return "", model.NewAppError("DoPostAction", "api.post.do_action.action_id.app_error", nil, fmt.Sprintf("action=%v", action), http.StatusNotFound)
return "", model.NewAppError("DoPostActionWithCookie", "api.post.do_action.action_id.app_error", nil, fmt.Sprintf("action=%v", action), http.StatusNotFound)
}
upstreamRequest.ChannelId = post.ChannelId
@@ -184,7 +184,7 @@ func (a *App) DoPostActionWithCookie(postId, actionId, userId, selectedOption st
}
team, err := a.Srv().Store.Team().Get(upstreamRequest.TeamId)
teamChan <- store.StoreResult{Data: team, Err: err}
teamChan <- store.StoreResult{Data: team, NErr: err}
}()
ur := <-userChan
@@ -196,8 +196,14 @@ func (a *App) DoPostActionWithCookie(postId, actionId, userId, selectedOption st
tr, ok := <-teamChan
if ok {
if tr.Err != nil {
return "", tr.Err
if tr.NErr != nil {
var nfErr *store.ErrNotFound
switch {
case errors.As(tr.NErr, &nfErr):
return "", model.NewAppError("DoPostActionWithCookie", "app.team.get.find.app_error", nil, nfErr.Error(), http.StatusNotFound)
default:
return "", model.NewAppError("DoPostActionWithCookie", "app.team.get.finding.app_error", nil, tr.NErr.Error(), http.StatusInternalServerError)
}
}
team := tr.Data.(*model.Team)
@@ -236,7 +242,7 @@ func (a *App) DoPostActionWithCookie(postId, actionId, userId, selectedOption st
var response model.PostActionIntegrationResponse
if err := json.NewDecoder(resp.Body).Decode(&response); err != nil {
return "", model.NewAppError("DoPostAction", "api.post.do_action.action_integration.app_error", nil, "err="+err.Error(), http.StatusBadRequest)
return "", model.NewAppError("DoPostActionWithCookie", "api.post.do_action.action_integration.app_error", nil, "err="+err.Error(), http.StatusBadRequest)
}
if response.Update != nil {

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

@@ -7,6 +7,7 @@ import (
"fmt"
"html"
"html/template"
"net/http"
"net/url"
"path/filepath"
"strings"
@@ -25,7 +26,7 @@ func (a *App) sendNotificationEmail(notification *PostNotification, user *model.
if channel.IsGroupOrDirect() {
teams, err := a.Srv().Store.Team().GetTeamsByUserId(user.Id)
if err != nil {
return err
return model.NewAppError("sendNotificationEmail", "app.team.get_all.app_error", nil, err.Error(), http.StatusInternalServerError)
}
// if the recipient isn't in the current user's team, just pick one

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

@@ -27,7 +27,16 @@ func (a *App) CreateTeam(team *model.Team) (*model.Team, *model.AppError) {
team.InviteId = ""
rteam, err := a.Srv().Store.Team().Save(team)
if err != nil {
return nil, err
var invErr *store.ErrInvalidInput
var appErr *model.AppError
switch {
case errors.As(err, &invErr):
return nil, model.NewAppError("CreateTeam", "app.team.save.existing.app_error", nil, invErr.Error(), http.StatusBadRequest)
case errors.As(err, &appErr):
return nil, appErr
default:
return nil, model.NewAppError("CreateTeam", "app.team.save.app_error", nil, err.Error(), http.StatusInternalServerError)
}
}
if _, err := a.CreateDefaultChannels(rteam.Id); err != nil {
@@ -154,7 +163,21 @@ func (a *App) UpdateTeam(team *model.Team) (*model.Team, *model.AppError) {
}
func (a *App) updateTeamUnsanitized(team *model.Team) (*model.Team, *model.AppError) {
return a.Srv().Store.Team().Update(team)
team, err := a.Srv().Store.Team().Update(team)
if err != nil {
var invErr *store.ErrInvalidInput
var appErr *model.AppError
switch {
case errors.As(err, &invErr):
return nil, model.NewAppError("updateTeamUnsanitized", "app.team.update.find.app_error", nil, invErr.Error(), http.StatusBadRequest)
case errors.As(err, &appErr):
return nil, appErr
default:
return nil, model.NewAppError("updateTeamUnsanitized", "app.team.update.updating.app_error", nil, err.Error(), http.StatusInternalServerError)
}
}
return team, nil
}
// RenameTeam is used to rename the team Name and the DisplayName fields
@@ -193,8 +216,18 @@ func (a *App) UpdateTeamScheme(team *model.Team) (*model.Team, *model.AppError)
oldTeam.SchemeId = team.SchemeId
if oldTeam, err = a.Srv().Store.Team().Update(oldTeam); err != nil {
return nil, err
oldTeam, nErr := a.Srv().Store.Team().Update(oldTeam)
if nErr != nil {
var invErr *store.ErrInvalidInput
var appErr *model.AppError
switch {
case errors.As(nErr, &invErr):
return nil, model.NewAppError("UpdateTeamScheme", "app.team.update.find.app_error", nil, invErr.Error(), http.StatusBadRequest)
case errors.As(nErr, &appErr):
return nil, appErr
default:
return nil, model.NewAppError("UpdateTeamScheme", "app.team.update.updating.app_error", nil, nErr.Error(), http.StatusInternalServerError)
}
}
a.sendTeamEvent(oldTeam, model.WEBSOCKET_EVENT_UPDATE_TEAM_SCHEME)
@@ -216,8 +249,18 @@ func (a *App) UpdateTeamPrivacy(teamId string, teamType string, allowOpenInvite
oldTeam.Type = teamType
oldTeam.AllowOpenInvite = allowOpenInvite
if oldTeam, err = a.Srv().Store.Team().Update(oldTeam); err != nil {
return err
oldTeam, nErr := a.Srv().Store.Team().Update(oldTeam)
if nErr != nil {
var invErr *store.ErrInvalidInput
var appErr *model.AppError
switch {
case errors.As(nErr, &invErr):
return model.NewAppError("UpdateTeamPrivacy", "app.team.update.find.app_error", nil, invErr.Error(), http.StatusBadRequest)
case errors.As(nErr, &appErr):
return appErr
default:
return model.NewAppError("UpdateTeamPrivacy", "app.team.update.updating.app_error", nil, nErr.Error(), http.StatusInternalServerError)
}
}
a.sendTeamEvent(oldTeam, model.WEBSOCKET_EVENT_UPDATE_TEAM)
@@ -258,9 +301,18 @@ func (a *App) RegenerateTeamInviteId(teamId string) (*model.Team, *model.AppErro
team.InviteId = model.NewId()
updatedTeam, err := a.Srv().Store.Team().Update(team)
if err != nil {
return nil, err
updatedTeam, nErr := a.Srv().Store.Team().Update(team)
if nErr != nil {
var invErr *store.ErrInvalidInput
var appErr *model.AppError
switch {
case errors.As(nErr, &invErr):
return nil, model.NewAppError("RegenerateTeamInviteId", "app.team.update.find.app_error", nil, invErr.Error(), http.StatusBadRequest)
case errors.As(nErr, &appErr):
return nil, appErr
default:
return nil, model.NewAppError("RegenerateTeamInviteId", "app.team.update.updating.app_error", nil, nErr.Error(), http.StatusInternalServerError)
}
}
a.sendTeamEvent(updatedTeam, model.WEBSOCKET_EVENT_UPDATE_TEAM)
@@ -412,7 +464,7 @@ func (a *App) AddUserToTeam(teamId string, userId string, userRequestorId string
tchan := make(chan store.StoreResult, 1)
go func() {
team, err := a.Srv().Store.Team().Get(teamId)
tchan <- store.StoreResult{Data: team, Err: err}
tchan <- store.StoreResult{Data: team, NErr: err}
close(tchan)
}()
@@ -424,8 +476,14 @@ func (a *App) AddUserToTeam(teamId string, userId string, userRequestorId string
}()
result := <-tchan
if result.Err != nil {
return nil, result.Err
if result.NErr != nil {
var nfErr *store.ErrNotFound
switch {
case errors.As(result.NErr, &nfErr):
return nil, model.NewAppError("AddUserToTeam", "app.team.get.find.app_error", nil, nfErr.Error(), http.StatusNotFound)
default:
return nil, model.NewAppError("AddUserToTeam", "app.team.get.finding.app_error", nil, result.NErr.Error(), http.StatusInternalServerError)
}
}
team := result.Data.(*model.Team)
@@ -445,7 +503,13 @@ func (a *App) AddUserToTeam(teamId string, userId string, userRequestorId string
func (a *App) AddUserToTeamByTeamId(teamId string, user *model.User) *model.AppError {
team, err := a.Srv().Store.Team().Get(teamId)
if err != nil {
return err
var nfErr *store.ErrNotFound
switch {
case errors.As(err, &nfErr):
return model.NewAppError("AddUserToTeamByTeamId", "app.team.get.find.app_error", nil, nfErr.Error(), http.StatusNotFound)
default:
return model.NewAppError("AddUserToTeamByTeamId", "app.team.get.finding.app_error", nil, err.Error(), http.StatusInternalServerError)
}
}
return a.JoinUserToTeam(team, user, "")
@@ -471,7 +535,7 @@ func (a *App) AddUserToTeamByToken(userId string, tokenId string) (*model.Team,
tchan := make(chan store.StoreResult, 1)
go func() {
team, err := a.Srv().Store.Team().Get(tokenData["teamId"])
tchan <- store.StoreResult{Data: team, Err: err}
tchan <- store.StoreResult{Data: team, NErr: err}
close(tchan)
}()
@@ -483,8 +547,14 @@ func (a *App) AddUserToTeamByToken(userId string, tokenId string) (*model.Team,
}()
result := <-tchan
if result.Err != nil {
return nil, result.Err
if result.NErr != nil {
var nfErr *store.ErrNotFound
switch {
case errors.As(result.NErr, &nfErr):
return nil, model.NewAppError("AddUserToTeamByToken", "app.team.get.find.app_error", nil, nfErr.Error(), http.StatusNotFound)
default:
return nil, model.NewAppError("AddUserToTeamByToken", "app.team.get.finding.app_error", nil, result.NErr.Error(), http.StatusInternalServerError)
}
}
team := result.Data.(*model.Team)
@@ -534,7 +604,7 @@ func (a *App) AddUserToTeamByInviteId(inviteId string, userId string) (*model.Te
tchan := make(chan store.StoreResult, 1)
go func() {
team, err := a.Srv().Store.Team().GetByInviteId(inviteId)
tchan <- store.StoreResult{Data: team, Err: err}
tchan <- store.StoreResult{Data: team, NErr: err}
close(tchan)
}()
@@ -546,8 +616,14 @@ func (a *App) AddUserToTeamByInviteId(inviteId string, userId string) (*model.Te
}()
result := <-tchan
if result.Err != nil {
return nil, result.Err
if result.NErr != nil {
var nfErr *store.ErrNotFound
switch {
case errors.As(result.NErr, &nfErr):
return nil, model.NewAppError("AddUserToTeamByInviteId", "app.team.get_by_invite_id.finding.app_error", nil, nfErr.Error(), http.StatusNotFound)
default:
return nil, model.NewAppError("AddUserToTeamByInviteId", "app.team.get_by_invite_id.finding.app_error", nil, result.NErr.Error(), http.StatusInternalServerError)
}
}
team := result.Data.(*model.Team)
@@ -700,73 +776,136 @@ func (a *App) JoinUserToTeam(team *model.Team, user *model.User, userRequestorId
}
func (a *App) GetTeam(teamId string) (*model.Team, *model.AppError) {
return a.Srv().Store.Team().Get(teamId)
team, err := a.Srv().Store.Team().Get(teamId)
if err != nil {
var nfErr *store.ErrNotFound
switch {
case errors.As(err, &nfErr):
return nil, model.NewAppError("GetTeam", "app.team.get.find.app_error", nil, nfErr.Error(), http.StatusNotFound)
default:
return nil, model.NewAppError("GetTeam", "app.team.get.finding.app_error", nil, err.Error(), http.StatusInternalServerError)
}
}
return team, nil
}
func (a *App) GetTeamByName(name string) (*model.Team, *model.AppError) {
return a.Srv().Store.Team().GetByName(name)
team, err := a.Srv().Store.Team().GetByName(name)
if err != nil {
var nfErr *store.ErrNotFound
switch {
case errors.As(err, &nfErr):
return nil, model.NewAppError("GetTeamByName", "app.team.get_by_name.missing.app_error", nil, nfErr.Error(), http.StatusNotFound)
default:
return nil, model.NewAppError("GetTeamByName", "app.team.get_by_name.app_error", nil, err.Error(), http.StatusNotFound)
}
}
return team, nil
}
func (a *App) GetTeamByInviteId(inviteId string) (*model.Team, *model.AppError) {
return a.Srv().Store.Team().GetByInviteId(inviteId)
team, err := a.Srv().Store.Team().GetByInviteId(inviteId)
if err != nil {
var nfErr *store.ErrNotFound
switch {
case errors.As(err, &nfErr):
return nil, model.NewAppError("GetTeamByInviteId", "app.team.get_by_invite_id.finding.app_error", nil, nfErr.Error(), http.StatusNotFound)
default:
return nil, model.NewAppError("GetTeamByInviteId", "app.team.get_by_invite_id.finding.app_error", nil, err.Error(), http.StatusInternalServerError)
}
}
return team, nil
}
func (a *App) GetAllTeams() ([]*model.Team, *model.AppError) {
return a.Srv().Store.Team().GetAll()
teams, err := a.Srv().Store.Team().GetAll()
if err != nil {
return nil, model.NewAppError("GetAllTeams", "app.team.get_all.app_error", nil, err.Error(), http.StatusInternalServerError)
}
return teams, nil
}
func (a *App) GetAllTeamsPage(offset int, limit int) ([]*model.Team, *model.AppError) {
return a.Srv().Store.Team().GetAllPage(offset, limit)
teams, err := a.Srv().Store.Team().GetAllPage(offset, limit)
if err != nil {
return nil, model.NewAppError("GetAllTeamsPage", "app.team.get_all.app_error", nil, err.Error(), http.StatusInternalServerError)
}
return teams, nil
}
func (a *App) GetAllTeamsPageWithCount(offset int, limit int) (*model.TeamsWithCount, *model.AppError) {
totalCount, err := a.Srv().Store.Team().AnalyticsTeamCount(true)
if err != nil {
return nil, err
return nil, model.NewAppError("GetAllTeamsPageWithCount", "app.team.analytics_team_count.app_error", nil, err.Error(), http.StatusInternalServerError)
}
teams, err := a.Srv().Store.Team().GetAllPage(offset, limit)
if err != nil {
return nil, err
return nil, model.NewAppError("GetAllTeamsPageWithCount", "app.team.get_all.app_error", nil, err.Error(), http.StatusInternalServerError)
}
return &model.TeamsWithCount{Teams: teams, TotalCount: totalCount}, nil
}
func (a *App) GetAllPrivateTeams() ([]*model.Team, *model.AppError) {
return a.Srv().Store.Team().GetAllPrivateTeamListing()
teams, err := a.Srv().Store.Team().GetAllPrivateTeamListing()
if err != nil {
return nil, model.NewAppError("GetAllPrivateTeams", "app.team.get_all_private_team_listing.app_error", nil, err.Error(), http.StatusInternalServerError)
}
return teams, nil
}
func (a *App) GetAllPrivateTeamsPage(offset int, limit int) ([]*model.Team, *model.AppError) {
return a.Srv().Store.Team().GetAllPrivateTeamPageListing(offset, limit)
teams, err := a.Srv().Store.Team().GetAllPrivateTeamPageListing(offset, limit)
if err != nil {
return nil, model.NewAppError("GetAllPrivateTeamsPage", "app.team.get_all_private_team_page_listing.app_error", nil, err.Error(), http.StatusInternalServerError)
}
return teams, nil
}
func (a *App) GetAllPrivateTeamsPageWithCount(offset int, limit int) (*model.TeamsWithCount, *model.AppError) {
totalCount, err := a.Srv().Store.Team().AnalyticsPrivateTeamCount()
if err != nil {
return nil, err
return nil, model.NewAppError("GetAllPrivateTeamsPageWithCount", "app.team.analytics_private_team_count.app_error", nil, err.Error(), http.StatusInternalServerError)
}
teams, err := a.Srv().Store.Team().GetAllPrivateTeamPageListing(offset, limit)
if err != nil {
return nil, err
return nil, model.NewAppError("GetAllPrivateTeamsPageWithCount", "app.team.get_all_private_team_page_listing.app_error", nil, err.Error(), http.StatusInternalServerError)
}
return &model.TeamsWithCount{Teams: teams, TotalCount: totalCount}, nil
}
func (a *App) GetAllPublicTeams() ([]*model.Team, *model.AppError) {
return a.Srv().Store.Team().GetAllTeamListing()
teams, err := a.Srv().Store.Team().GetAllTeamListing()
if err != nil {
return nil, model.NewAppError("GetAllPublicTeams", "app.team.get_all_team_listing.app_error", nil, err.Error(), http.StatusInternalServerError)
}
return teams, nil
}
func (a *App) GetAllPublicTeamsPage(offset int, limit int) ([]*model.Team, *model.AppError) {
return a.Srv().Store.Team().GetAllTeamPageListing(offset, limit)
teams, err := a.Srv().Store.Team().GetAllTeamPageListing(offset, limit)
if err != nil {
return nil, model.NewAppError("GetAllPublicTeamsPage", "app.team.get_all_team_listing.app_error", nil, err.Error(), http.StatusInternalServerError)
}
return teams, nil
}
func (a *App) GetAllPublicTeamsPageWithCount(offset int, limit int) (*model.TeamsWithCount, *model.AppError) {
totalCount, err := a.Srv().Store.Team().AnalyticsPublicTeamCount()
if err != nil {
return nil, err
return nil, model.NewAppError("GetAllPublicTeamsPageWithCount", "app.team.analytics_public_team_count.app_error", nil, err.Error(), http.StatusInternalServerError)
}
teams, err := a.Srv().Store.Team().GetAllPublicTeamPageListing(offset, limit)
if err != nil {
return nil, err
return nil, model.NewAppError("GetAllPublicTeamsPageWithCount", "app.team.get_all_private_team_listing.app_error", nil, err.Error(), http.StatusInternalServerError)
}
return &model.TeamsWithCount{Teams: teams, TotalCount: totalCount}, nil
}
@@ -774,22 +913,45 @@ func (a *App) GetAllPublicTeamsPageWithCount(offset int, limit int) (*model.Team
// SearchAllTeams returns a team list and the total count of the results
func (a *App) SearchAllTeams(searchOpts *model.TeamSearch) ([]*model.Team, int64, *model.AppError) {
if searchOpts.IsPaginated() {
return a.Srv().Store.Team().SearchAllPaged(searchOpts.Term, searchOpts)
teams, count, err := a.Srv().Store.Team().SearchAllPaged(searchOpts.Term, searchOpts)
if err != nil {
return nil, 0, model.NewAppError("SearchAllTeams", "app.team.search_all_team.app_error", nil, err.Error(), http.StatusInternalServerError)
}
return teams, count, nil
}
results, err := a.Srv().Store.Team().SearchAll(searchOpts.Term, searchOpts)
return results, int64(len(results)), err
if err != nil {
return nil, 0, model.NewAppError("SearchAllTeams", "app.team.search_all_team.app_error", nil, err.Error(), http.StatusInternalServerError)
}
return results, int64(len(results)), nil
}
func (a *App) SearchPublicTeams(term string) ([]*model.Team, *model.AppError) {
return a.Srv().Store.Team().SearchOpen(term)
teams, err := a.Srv().Store.Team().SearchOpen(term)
if err != nil {
return nil, model.NewAppError("SearchPublicTeams", "app.team.search_open_team.app_error", nil, err.Error(), http.StatusInternalServerError)
}
return teams, nil
}
func (a *App) SearchPrivateTeams(term string) ([]*model.Team, *model.AppError) {
return a.Srv().Store.Team().SearchPrivate(term)
teams, err := a.Srv().Store.Team().SearchPrivate(term)
if err != nil {
return nil, model.NewAppError("SearchPrivateTeams", "app.team.search_private_team.app_error", nil, err.Error(), http.StatusInternalServerError)
}
return teams, nil
}
func (a *App) GetTeamsForUser(userId string) ([]*model.Team, *model.AppError) {
return a.Srv().Store.Team().GetTeamsByUserId(userId)
teams, err := a.Srv().Store.Team().GetTeamsByUserId(userId)
if err != nil {
return nil, model.NewAppError("GetTeamsForUser", "app.team.get_all.app_error", nil, err.Error(), http.StatusInternalServerError)
}
return teams, nil
}
func (a *App) GetTeamMember(teamId, userId string) (*model.TeamMember, *model.AppError) {
@@ -921,7 +1083,7 @@ func (a *App) RemoveUserFromTeam(teamId string, userId string, requestorId strin
tchan := make(chan store.StoreResult, 1)
go func() {
team, err := a.Srv().Store.Team().Get(teamId)
tchan <- store.StoreResult{Data: team, Err: err}
tchan <- store.StoreResult{Data: team, NErr: err}
close(tchan)
}()
@@ -933,8 +1095,14 @@ func (a *App) RemoveUserFromTeam(teamId string, userId string, requestorId strin
}()
result := <-tchan
if result.Err != nil {
return result.Err
if result.NErr != nil {
var nfErr *store.ErrNotFound
switch {
case errors.As(result.NErr, &nfErr):
return model.NewAppError("RemoveUserFromTeam", "app.team.get_by_invite_id.finding.app_error", nil, nfErr.Error(), http.StatusNotFound)
default:
return model.NewAppError("RemoveUserFromTeam", "app.team.get_by_invite_id.finding.app_error", nil, result.NErr.Error(), http.StatusInternalServerError)
}
}
team := result.Data.(*model.Team)
@@ -1102,7 +1270,7 @@ func (a *App) prepareInviteNewUsersToTeam(teamId, senderId string) (*model.User,
tchan := make(chan store.StoreResult, 1)
go func() {
team, err := a.Srv().Store.Team().Get(teamId)
tchan <- store.StoreResult{Data: team, Err: err}
tchan <- store.StoreResult{Data: team, NErr: err}
close(tchan)
}()
@@ -1114,8 +1282,14 @@ func (a *App) prepareInviteNewUsersToTeam(teamId, senderId string) (*model.User,
}()
result := <-tchan
if result.Err != nil {
return nil, nil, result.Err
if result.NErr != nil {
var nfErr *store.ErrNotFound
switch {
case errors.As(result.NErr, &nfErr):
return nil, nil, model.NewAppError("prepareInviteNewUsersToTeam", "app.team.get_by_invite_id.finding.app_error", nil, nfErr.Error(), http.StatusNotFound)
default:
return nil, nil, model.NewAppError("prepareInviteNewUsersToTeam", "app.team.get_by_invite_id.finding.app_error", nil, result.NErr.Error(), http.StatusInternalServerError)
}
}
team := result.Data.(*model.Team)
@@ -1216,7 +1390,7 @@ func (a *App) prepareInviteGuestsToChannels(teamId string, guestsInvite *model.G
tchan := make(chan store.StoreResult, 1)
go func() {
team, err := a.Srv().Store.Team().Get(teamId)
tchan <- store.StoreResult{Data: team, Err: err}
tchan <- store.StoreResult{Data: team, NErr: err}
close(tchan)
}()
cchan := make(chan store.StoreResult, 1)
@@ -1245,8 +1419,14 @@ func (a *App) prepareInviteGuestsToChannels(teamId string, guestsInvite *model.G
user := result.Data.(*model.User)
result = <-tchan
if result.Err != nil {
return nil, nil, nil, result.Err
if result.NErr != nil {
var nfErr *store.ErrNotFound
switch {
case errors.As(result.NErr, &nfErr):
return nil, nil, nil, model.NewAppError("prepareInviteGuestsToChannels", "app.team.get_by_invite_id.finding.app_error", nil, nfErr.Error(), http.StatusNotFound)
default:
return nil, nil, nil, model.NewAppError("prepareInviteGuestsToChannels", "app.team.get_by_invite_id.finding.app_error", nil, result.NErr.Error(), http.StatusInternalServerError)
}
}
team := result.Data.(*model.Team)
@@ -1428,7 +1608,16 @@ func (a *App) PermanentDeleteTeamId(teamId string) *model.AppError {
func (a *App) PermanentDeleteTeam(team *model.Team) *model.AppError {
team.DeleteAt = model.GetMillis()
if _, err := a.Srv().Store.Team().Update(team); err != nil {
return err
var invErr *store.ErrInvalidInput
var appErr *model.AppError
switch {
case errors.As(err, &invErr):
return model.NewAppError("PermanentDeleteTeam", "app.team.update.find.app_error", nil, invErr.Error(), http.StatusBadRequest)
case errors.As(err, &appErr):
return appErr
default:
return model.NewAppError("PermanentDeleteTeam", "app.team.update.updating.app_error", nil, err.Error(), http.StatusInternalServerError)
}
}
if channels, err := a.Srv().Store.Channel().GetTeamChannels(team.Id); err != nil {
@@ -1450,7 +1639,7 @@ func (a *App) PermanentDeleteTeam(team *model.Team) *model.AppError {
}
if err := a.Srv().Store.Team().PermanentDelete(team.Id); err != nil {
return err
return model.NewAppError("PermanentDeleteTeam", "app.team.permanent_delete.app_error", nil, err.Error(), http.StatusInternalServerError)
}
a.sendTeamEvent(team, model.WEBSOCKET_EVENT_DELETE_TEAM)
@@ -1465,8 +1654,18 @@ func (a *App) SoftDeleteTeam(teamId string) *model.AppError {
}
team.DeleteAt = model.GetMillis()
if team, err = a.Srv().Store.Team().Update(team); err != nil {
return err
team, nErr := a.Srv().Store.Team().Update(team)
if nErr != nil {
var invErr *store.ErrInvalidInput
var appErr *model.AppError
switch {
case errors.As(nErr, &invErr):
return model.NewAppError("SoftDeleteTeam", "app.team.update.find.app_error", nil, invErr.Error(), http.StatusBadRequest)
case errors.As(nErr, &appErr):
return appErr
default:
return model.NewAppError("SoftDeleteTeam", "app.team.update.updating.app_error", nil, nErr.Error(), http.StatusInternalServerError)
}
}
a.sendTeamEvent(team, model.WEBSOCKET_EVENT_DELETE_TEAM)
@@ -1481,8 +1680,18 @@ func (a *App) RestoreTeam(teamId string) *model.AppError {
}
team.DeleteAt = 0
if team, err = a.Srv().Store.Team().Update(team); err != nil {
return err
team, nErr := a.Srv().Store.Team().Update(team)
if nErr != nil {
var invErr *store.ErrInvalidInput
var appErr *model.AppError
switch {
case errors.As(nErr, &invErr):
return model.NewAppError("RestoreTeam", "app.team.update.find.app_error", nil, invErr.Error(), http.StatusBadRequest)
case errors.As(nErr, &appErr):
return appErr
default:
return model.NewAppError("RestoreTeam", "app.team.update.updating.app_error", nil, nErr.Error(), http.StatusInternalServerError)
}
}
a.sendTeamEvent(team, model.WEBSOCKET_EVENT_RESTORE_TEAM)

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

@@ -64,9 +64,15 @@ func (a *App) CreateUserWithToken(user *model.User, token *model.Token) (*model.
tokenData := model.MapFromJson(strings.NewReader(token.Extra))
team, err := a.Srv().Store.Team().Get(tokenData["teamId"])
if err != nil {
return nil, err
team, nErr := a.Srv().Store.Team().Get(tokenData["teamId"])
if nErr != nil {
var nfErr *store.ErrNotFound
switch {
case errors.As(nErr, &nfErr):
return nil, model.NewAppError("CreateUserWithToken", "app.team.get.find.app_error", nil, nfErr.Error(), http.StatusNotFound)
default:
return nil, model.NewAppError("CreateUserWithToken", "app.team.get.finding.app_error", nil, nErr.Error(), http.StatusInternalServerError)
}
}
channels, err := a.Srv().Store.Channel().GetChannelsByIds(strings.Split(tokenData["channels"], " "), false)
@@ -114,9 +120,15 @@ func (a *App) CreateUserWithInviteId(user *model.User, inviteId, redirect string
return nil, err
}
team, err := a.Srv().Store.Team().GetByInviteId(inviteId)
if err != nil {
return nil, err
team, nErr := a.Srv().Store.Team().GetByInviteId(inviteId)
if nErr != nil {
var nfErr *store.ErrNotFound
switch {
case errors.As(nErr, &nfErr):
return nil, model.NewAppError("CreateUserWithInviteId", "app.team.get_by_invite_id.finding.app_error", nil, nfErr.Error(), http.StatusNotFound)
default:
return nil, model.NewAppError("CreateUserWithInviteId", "app.team.get_by_invite_id.finding.app_error", nil, nErr.Error(), http.StatusInternalServerError)
}
}
if team.IsGroupConstrained() {
@@ -2034,9 +2046,9 @@ func (a *App) PromoteGuestToUser(user *model.User, requestorId string) *model.Ap
if err != nil {
return err
}
userTeams, err := a.Srv().Store.Team().GetTeamsByUserId(user.Id)
if err != nil {
return err
userTeams, nErr := a.Srv().Store.Team().GetTeamsByUserId(user.Id)
if nErr != nil {
return model.NewAppError("PromoteGuestToUser", "app.team.get_all.app_error", nil, nErr.Error(), http.StatusInternalServerError)
}
for _, team := range userTeams {

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

@@ -608,14 +608,14 @@ func TestCreateUserWithInviteId(t *testing.T) {
t.Run("invalid invite id", func(t *testing.T) {
_, err := th.App.CreateUserWithInviteId(&user, "", "")
require.NotNil(t, err)
require.Contains(t, err.Id, "store.sql_team.get_by_invite_id")
require.Contains(t, err.Id, "app.team.get_by_invite_id")
})
t.Run("invalid domain", func(t *testing.T) {
th.BasicTeam.AllowedDomains = "mattermost.com"
_, err := th.App.Srv().Store.Team().Update(th.BasicTeam)
require.Nil(t, err)
_, err = th.App.CreateUserWithInviteId(&user, th.BasicTeam.InviteId, "")
_, nErr := th.App.Srv().Store.Team().Update(th.BasicTeam)
require.Nil(t, nErr)
_, err := th.App.CreateUserWithInviteId(&user, th.BasicTeam.InviteId, "")
require.NotNil(t, err)
require.Equal(t, "api.team.invite_members.invalid_email.app_error", err.Id)
})

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

@@ -4642,6 +4642,54 @@
"id": "app.system_install_date.parse_int.app_error",
"translation": "Failed to parse installation date."
},
{
"id": "app.team.analytics_private_team_count.app_error",
"translation": "Unable to count the private teams."
},
{
"id": "app.team.analytics_public_team_count.app_error",
"translation": "Unable to count the public teams."
},
{
"id": "app.team.analytics_team_count.app_error",
"translation": "Unable to count the teams."
},
{
"id": "app.team.get.find.app_error",
"translation": "Unable to find the existing team."
},
{
"id": "app.team.get.finding.app_error",
"translation": "We encountered an error finding the team."
},
{
"id": "app.team.get_all.app_error",
"translation": "We could not get all teams."
},
{
"id": "app.team.get_all_private_team_listing.app_error",
"translation": "We could not get all private teams."
},
{
"id": "app.team.get_all_private_team_page_listing.app_error",
"translation": "We could not get all private teams in page."
},
{
"id": "app.team.get_all_team_listing.app_error",
"translation": "We could not get all teams."
},
{
"id": "app.team.get_by_invite_id.finding.app_error",
"translation": "Unable to find the existing team."
},
{
"id": "app.team.get_by_name.app_error",
"translation": "Unable to find the existing team."
},
{
"id": "app.team.get_by_name.missing.app_error",
"translation": "Unable to find the existing team."
},
{
"id": "app.team.invite_id.group_constrained.error",
"translation": "Unable to join a group-constrained team by invite."
@@ -4666,6 +4714,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.permanent_delete.app_error",
"translation": "Unable to delete the existing team."
},
{
"id": "app.team.permanentdeleteteam.internal_error",
"translation": "Unable to delete team."
@@ -4674,6 +4726,34 @@
"id": "app.team.rename_team.name_occupied",
"translation": "Unable to rename the team, the name is already in use."
},
{
"id": "app.team.save.app_error",
"translation": "Unable to save the team."
},
{
"id": "app.team.save.existing.app_error",
"translation": "Must call update for existing team."
},
{
"id": "app.team.search_all_team.app_error",
"translation": "We encountered an error searching teams."
},
{
"id": "app.team.search_open_team.app_error",
"translation": "We encountered an error searching open teams."
},
{
"id": "app.team.search_private_team.app_error",
"translation": "We encountered an error searching private teams."
},
{
"id": "app.team.update.find.app_error",
"translation": "Unable to find the existing team to update."
},
{
"id": "app.team.update.updating.app_error",
"translation": "We encountered an error updating the team."
},
{
"id": "app.terms_of_service.create.app_error",
"translation": "Unable to save terms of service."
@@ -7446,18 +7526,6 @@
"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.analytics_private_team_count.app_error",
"translation": "Unable to count the private teams."
},
{
"id": "store.sql_team.analytics_public_team_count.app_error",
"translation": "Unable to count the public teams."
},
{
"id": "store.sql_team.analytics_team_count.app_error",
"translation": "Unable to count the teams."
},
{
"id": "store.sql_team.clear_all_custom_role_assignments.commit_transaction.app_error",
"translation": "Failed to commit the database transaction."
@@ -7474,58 +7542,10 @@
"id": "store.sql_team.clear_all_custom_role_assignments.update.app_error",
"translation": "Failed to update the team member."
},
{
"id": "store.sql_team.get.find.app_error",
"translation": "Unable to find the existing team."
},
{
"id": "store.sql_team.get.finding.app_error",
"translation": "We encountered an error finding the team."
},
{
"id": "store.sql_team.get_active_member_count.app_error",
"translation": "Unable to count the team members."
},
{
"id": "store.sql_team.get_all.app_error",
"translation": "We could not get all teams."
},
{
"id": "store.sql_team.get_all_private_team_listing.app_error",
"translation": "We could not get all private teams."
},
{
"id": "store.sql_team.get_all_private_team_page_listing.app_error",
"translation": "We could not get all private teams in page."
},
{
"id": "store.sql_team.get_all_team_listing.app_error",
"translation": "We could not get all teams."
},
{
"id": "store.sql_team.get_by_invite_id.find.app_error",
"translation": "Unable to find the existing team."
},
{
"id": "store.sql_team.get_by_invite_id.finding.app_error",
"translation": "Unable to find the existing team."
},
{
"id": "store.sql_team.get_by_name.app_error",
"translation": "Unable to find the existing team."
},
{
"id": "store.sql_team.get_by_name.missing.app_error",
"translation": "Unable to find the existing team."
},
{
"id": "store.sql_team.get_by_names.app_error",
"translation": "Unable to get the teams by names"
},
{
"id": "store.sql_team.get_by_names.missing.app_error",
"translation": "Unable to find some of the requested teams"
},
{
"id": "store.sql_team.get_by_scheme.app_error",
"translation": "Unable to get the channels for the provided scheme."
@@ -7574,10 +7594,6 @@
"id": "store.sql_team.migrate_team_members.update.app_error",
"translation": "Failed to update the team member."
},
{
"id": "store.sql_team.permanent_delete.app_error",
"translation": "Unable to delete the existing team."
},
{
"id": "store.sql_team.remove_member.app_error",
"translation": "Unable to remove the team member."
@@ -7586,18 +7602,6 @@
"id": "store.sql_team.reset_all_team_schemes.app_error",
"translation": "We could not reset the team schemes."
},
{
"id": "store.sql_team.save.app_error",
"translation": "Unable to save the team."
},
{
"id": "store.sql_team.save.domain_exists.app_error",
"translation": "A team with that name already exists."
},
{
"id": "store.sql_team.save.existing.app_error",
"translation": "Must call update for existing team."
},
{
"id": "store.sql_team.save_member.exists.app_error",
"translation": "A team member with that ID already exists."
@@ -7606,34 +7610,6 @@
"id": "store.sql_team.save_member.save.app_error",
"translation": "Unable to save the team member."
},
{
"id": "store.sql_team.search_all_team.app_error",
"translation": "We encountered an error searching teams."
},
{
"id": "store.sql_team.search_open_team.app_error",
"translation": "We encountered an error searching open teams."
},
{
"id": "store.sql_team.search_private_team.app_error",
"translation": "We encountered an error searching private teams."
},
{
"id": "store.sql_team.update.app_error",
"translation": "Unable to update the team."
},
{
"id": "store.sql_team.update.find.app_error",
"translation": "Unable to find the existing team to update."
},
{
"id": "store.sql_team.update.finding.app_error",
"translation": "We encountered an error finding the team."
},
{
"id": "store.sql_team.update.updating.app_error",
"translation": "We encountered an error updating the team."
},
{
"id": "store.sql_team.update_last_team_icon_update.app_error",
"translation": "Unable to update the date of the last team icon update."

13
manualtesting/manual_testing.go
Просмотреть файл

@@ -4,6 +4,7 @@
package manualtesting
import (
"errors"
"hash/fnv"
"math/rand"
"net/http"
@@ -16,6 +17,7 @@ import (
"github.com/mattermost/mattermost-server/v5/app/slashcommands"
"github.com/mattermost/mattermost-server/v5/mlog"
"github.com/mattermost/mattermost-server/v5/model"
"github.com/mattermost/mattermost-server/v5/store"
"github.com/mattermost/mattermost-server/v5/utils"
"github.com/mattermost/mattermost-server/v5/web"
)
@@ -78,7 +80,16 @@ func manualTest(c *web.Context, w http.ResponseWriter, r *http.Request) {
createdTeam, err := c.App.Srv().Store.Team().Save(team)
if err != nil {
c.Err = err
var invErr *store.ErrInvalidInput
var appErr *model.AppError
switch {
case errors.As(err, &invErr):
c.Err = model.NewAppError("manualTest", "app.team.save.existing.app_error", nil, invErr.Error(), http.StatusBadRequest)
case errors.As(err, &appErr):
c.Err = appErr
default:
c.Err = model.NewAppError("manualTest", "app.team.save.app_error", nil, err.Error(), http.StatusInternalServerError)
}
return
}

4
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 {

44
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)

396
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
}
}
}

6
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
}

6
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

8
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))

154
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

44
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)

56
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",

6
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)

70
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,

220
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

36
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)

44
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)