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

MM-25476: Migrate AppError from command_store.go (#14643)

Просмотр исходного кода 
Automatic Merge
Этот коммит содержится в:
Joshua Bezaleel Abednego
2020-07-16 20:26:07 +07:00
коммит произвёл GitHub
родитель 5ddf8d4099
Коммит 48f0b7fd76
13 изменённых файлов: 353 добавлений и 257 удалений
Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

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

@@ -46,13 +46,13 @@ func (a *App) GetAnalytics(name string, teamId string) (model.AnalyticsRows, *mo
openChan := make(chan store.StoreResult, 1)
privateChan := make(chan store.StoreResult, 1)
go func() {
count, err := a.Srv().Store.Channel().AnalyticsTypeCount(teamId, model.CHANNEL_OPEN)
openChan <- store.StoreResult{Data: count, Err: err}
count, err2 := a.Srv().Store.Channel().AnalyticsTypeCount(teamId, model.CHANNEL_OPEN)
openChan <- store.StoreResult{Data: count, Err: err2}
close(openChan)
}()
go func() {
count, err := a.Srv().Store.Channel().AnalyticsTypeCount(teamId, model.CHANNEL_PRIVATE)
privateChan <- store.StoreResult{Data: count, Err: err}
count, err2 := a.Srv().Store.Channel().AnalyticsTypeCount(teamId, model.CHANNEL_PRIVATE)
privateChan <- store.StoreResult{Data: count, Err: err2}
close(privateChan)
}()
@@ -61,15 +61,15 @@ func (a *App) GetAnalytics(name string, teamId string) (model.AnalyticsRows, *mo
if teamId == "" {
userInactiveChan = make(chan store.StoreResult, 1)
go func() {
count, err := a.Srv().Store.User().AnalyticsGetInactiveUsersCount()
userInactiveChan <- store.StoreResult{Data: count, Err: err}
count, err2 := a.Srv().Store.User().AnalyticsGetInactiveUsersCount()
userInactiveChan <- store.StoreResult{Data: count, Err: err2}
close(userInactiveChan)
}()
} else {
userChan = make(chan store.StoreResult, 1)
go func() {
count, err := a.Srv().Store.User().Count(model.UserCountOptions{TeamId: teamId})
userChan <- store.StoreResult{Data: count, Err: err}
count, err2 := a.Srv().Store.User().Count(model.UserCountOptions{TeamId: teamId})
userChan <- store.StoreResult{Data: count, Err: err2}
close(userChan)
}()
}
@@ -78,30 +78,30 @@ func (a *App) GetAnalytics(name string, teamId string) (model.AnalyticsRows, *mo
if !skipIntensiveQueries {
postChan = make(chan store.StoreResult, 1)
go func() {
count, err := a.Srv().Store.Post().AnalyticsPostCount(teamId, false, false)
postChan <- store.StoreResult{Data: count, Err: err}
count, err2 := a.Srv().Store.Post().AnalyticsPostCount(teamId, false, false)
postChan <- store.StoreResult{Data: count, Err: err2}
close(postChan)
}()
}
teamCountChan := make(chan store.StoreResult, 1)
go func() {
teamCount, err := a.Srv().Store.Team().AnalyticsTeamCount(false)
teamCountChan <- store.StoreResult{Data: teamCount, Err: err}
teamCount, err2 := a.Srv().Store.Team().AnalyticsTeamCount(false)
teamCountChan <- store.StoreResult{Data: teamCount, Err: err2}
close(teamCountChan)
}()
dailyActiveChan := make(chan store.StoreResult, 1)
go func() {
dailyActive, err := a.Srv().Store.User().AnalyticsActiveCount(DAY_MILLISECONDS, model.UserCountOptions{IncludeBotAccounts: false, IncludeDeleted: false})
dailyActiveChan <- store.StoreResult{Data: dailyActive, Err: err}
dailyActive, err2 := a.Srv().Store.User().AnalyticsActiveCount(DAY_MILLISECONDS, model.UserCountOptions{IncludeBotAccounts: false, IncludeDeleted: false})
dailyActiveChan <- store.StoreResult{Data: dailyActive, Err: err2}
close(dailyActiveChan)
}()
monthlyActiveChan := make(chan store.StoreResult, 1)
go func() {
monthlyActive, err := a.Srv().Store.User().AnalyticsActiveCount(MONTH_MILLISECONDS, model.UserCountOptions{IncludeBotAccounts: false, IncludeDeleted: false})
monthlyActiveChan <- store.StoreResult{Data: monthlyActive, Err: err}
monthlyActive, err2 := a.Srv().Store.User().AnalyticsActiveCount(MONTH_MILLISECONDS, model.UserCountOptions{IncludeBotAccounts: false, IncludeDeleted: false})
monthlyActiveChan <- store.StoreResult{Data: monthlyActive, Err: err2}
close(monthlyActiveChan)
}()
@@ -155,9 +155,9 @@ func (a *App) GetAnalytics(name string, teamId string) (model.AnalyticsRows, *mo
// If in HA mode then aggregate all the stats
if a.Cluster() != nil && *a.Config().ClusterSettings.Enable {
stats, err := a.Cluster().GetClusterStats()
if err != nil {
return nil, err
stats, err2 := a.Cluster().GetClusterStats()
if err2 != nil {
return nil, err2
}
totalSockets := a.TotalWebsocketConnections()
@@ -231,29 +231,29 @@ func (a *App) GetAnalytics(name string, teamId string) (model.AnalyticsRows, *mo
iHookChan := make(chan store.StoreResult, 1)
go func() {
c, err := a.Srv().Store.Webhook().AnalyticsIncomingCount(teamId)
iHookChan <- store.StoreResult{Data: c, Err: err}
c, err2 := a.Srv().Store.Webhook().AnalyticsIncomingCount(teamId)
iHookChan <- store.StoreResult{Data: c, Err: err2}
close(iHookChan)
}()
oHookChan := make(chan store.StoreResult, 1)
go func() {
c, err := a.Srv().Store.Webhook().AnalyticsOutgoingCount(teamId)
oHookChan <- store.StoreResult{Data: c, Err: err}
c, err2 := a.Srv().Store.Webhook().AnalyticsOutgoingCount(teamId)
oHookChan <- store.StoreResult{Data: c, Err: err2}
close(oHookChan)
}()
commandChan := make(chan store.StoreResult, 1)
go func() {
c, err := a.Srv().Store.Command().AnalyticsCommandCount(teamId)
commandChan <- store.StoreResult{Data: c, Err: err}
c, nErr := a.Srv().Store.Command().AnalyticsCommandCount(teamId)
commandChan <- store.StoreResult{Data: c, NErr: nErr}
close(commandChan)
}()
sessionChan := make(chan store.StoreResult, 1)
go func() {
count, err := a.Srv().Store.Session().AnalyticsSessionCount()
sessionChan <- store.StoreResult{Data: count, NErr: err}
count, err2 := a.Srv().Store.Session().AnalyticsSessionCount()
sessionChan <- store.StoreResult{Data: count, NErr: err2}
close(sessionChan)
}()
@@ -263,15 +263,15 @@ func (a *App) GetAnalytics(name string, teamId string) (model.AnalyticsRows, *mo
if !skipIntensiveQueries {
fileChan = make(chan store.StoreResult, 1)
go func() {
count, err := a.Srv().Store.Post().AnalyticsPostCount(teamId, true, false)
fileChan <- store.StoreResult{Data: count, Err: err}
count, err2 := a.Srv().Store.Post().AnalyticsPostCount(teamId, true, false)
fileChan <- store.StoreResult{Data: count, Err: err2}
close(fileChan)
}()
hashtagChan = make(chan store.StoreResult, 1)
go func() {
count, err := a.Srv().Store.Post().AnalyticsPostCount(teamId, false, true)
hashtagChan <- store.StoreResult{Data: count, Err: err}
count, err2 := a.Srv().Store.Post().AnalyticsPostCount(teamId, false, true)
hashtagChan <- store.StoreResult{Data: count, Err: err2}
close(hashtagChan)
}()
}
@@ -309,8 +309,8 @@ func (a *App) GetAnalytics(name string, teamId string) (model.AnalyticsRows, *mo
rows[3].Value = float64(r.Data.(int64))
r = <-commandChan
if r.Err != nil {
return nil, r.Err
if r.NErr != nil {
return nil, model.NewAppError("GetAnalytics", "app.analytics.getanalytics.internal_error", nil, err.Error(), http.StatusInternalServerError)
}
rows[4].Value = float64(r.Data.(int64))

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

@@ -88,7 +88,7 @@ func (a *App) ListAutocompleteCommands(teamId string, T goi18n.TranslateFunc) ([
if *a.Config().ServiceSettings.EnableCommands {
teamCmds, err := a.Srv().Store.Command().GetByTeam(teamId)
if err != nil {
return nil, err
return nil, model.NewAppError("ListAutocompleteCommands", "app.command.listautocompletecommands.internal_error", nil, err.Error(), http.StatusInternalServerError)
}
for _, cmd := range teamCmds {
@@ -119,7 +119,12 @@ func (a *App) ListTeamCommands(teamId string) ([]*model.Command, *model.AppError
return nil, model.NewAppError("ListTeamCommands", "api.command.disabled.app_error", nil, "", http.StatusNotImplemented)
}
return a.Srv().Store.Command().GetByTeam(teamId)
teamCmds, err := a.Srv().Store.Command().GetByTeam(teamId)
if err != nil {
return nil, model.NewAppError("ListTeamCommands", "app.command.listteamcommands.internal_error", nil, err.Error(), http.StatusInternalServerError)
}
return teamCmds, nil
}
func (a *App) ListAllCommands(teamId string, T goi18n.TranslateFunc) ([]*model.Command, *model.AppError) {
@@ -146,7 +151,7 @@ func (a *App) ListAllCommands(teamId string, T goi18n.TranslateFunc) ([]*model.C
if *a.Config().ServiceSettings.EnableCommands {
teamCmds, err := a.Srv().Store.Command().GetByTeam(teamId)
if err != nil {
return nil, err
return nil, model.NewAppError("ListAllCommands", "app.command.listallcommands.internal_error", nil, err.Error(), http.StatusInternalServerError)
}
for _, cmd := range teamCmds {
if !seen[cmd.Trigger] {
@@ -368,7 +373,7 @@ func (a *App) tryExecuteCustomCommand(args *model.CommandArgs, trigger string, m
teamCmds, err := a.Srv().Store.Command().GetByTeam(args.TeamId)
if err != nil {
return nil, nil, err
return nil, nil, model.NewAppError("tryExecuteCustomCommand", "app.command.tryexecutecustomcommand.internal_error", nil, err.Error(), http.StatusInternalServerError)
}
tr := <-teamChan
@@ -602,7 +607,7 @@ func (a *App) CreateCommand(cmd *model.Command) (*model.Command, *model.AppError
teamCmds, err := a.Srv().Store.Command().GetByTeam(cmd.TeamId)
if err != nil {
return nil, err
return nil, model.NewAppError("CreateCommand", "app.command.createcommand.internal_error", nil, err.Error(), http.StatusInternalServerError)
}
for _, existingCommand := range teamCmds {
@@ -618,7 +623,18 @@ func (a *App) CreateCommand(cmd *model.Command) (*model.Command, *model.AppError
}
}
return a.Srv().Store.Command().Save(cmd)
command, nErr := a.Srv().Store.Command().Save(cmd)
if nErr != nil {
var appErr *model.AppError
switch {
case errors.As(nErr, &appErr):
return nil, appErr
default:
return nil, model.NewAppError("CreateCommand", "app.command.createcommand.internal_error", nil, nErr.Error(), http.StatusInternalServerError)
}
}
return command, nil
}
func (a *App) GetCommand(commandId string) (*model.Command, *model.AppError) {
@@ -626,13 +642,17 @@ func (a *App) GetCommand(commandId string) (*model.Command, *model.AppError) {
return nil, model.NewAppError("GetCommand", "api.command.disabled.app_error", nil, "", http.StatusNotImplemented)
}
cmd, err := a.Srv().Store.Command().Get(commandId)
command, err := a.Srv().Store.Command().Get(commandId)
if err != nil {
err.StatusCode = http.StatusNotFound
return nil, err
var nfErr *store.ErrNotFound
switch {
case errors.As(err, &nfErr):
return nil, model.NewAppError("SqlCommandStore.Get", "store.sql_command.get.missing.app_error", map[string]interface{}{"command_id": commandId}, "", http.StatusNotFound)
default:
return nil, model.NewAppError("GetCommand", "app.command.getcommand.internal_error", nil, err.Error(), http.StatusInternalServerError)
}
}
return cmd, nil
return command, nil
}
func (a *App) UpdateCommand(oldCmd, updatedCmd *model.Command) (*model.Command, *model.AppError) {
@@ -649,7 +669,21 @@ func (a *App) UpdateCommand(oldCmd, updatedCmd *model.Command) (*model.Command,
updatedCmd.CreatorId = oldCmd.CreatorId
updatedCmd.TeamId = oldCmd.TeamId
return a.Srv().Store.Command().Update(updatedCmd)
command, err := a.Srv().Store.Command().Update(updatedCmd)
if err != nil {
var nfErr *store.ErrNotFound
var appErr *model.AppError
switch {
case errors.As(err, &nfErr):
return nil, model.NewAppError("SqlCommandStore.Update", "store.sql_command.update.missing.app_error", map[string]interface{}{"command_id": updatedCmd.Id}, "", http.StatusNotFound)
case errors.As(err, &appErr):
return nil, appErr
default:
return nil, model.NewAppError("UpdateCommand", "app.command.updatecommand.internal_error", nil, err.Error(), http.StatusInternalServerError)
}
}
return command, nil
}
func (a *App) MoveCommand(team *model.Team, command *model.Command) *model.AppError {
@@ -657,7 +691,16 @@ func (a *App) MoveCommand(team *model.Team, command *model.Command) *model.AppEr
_, err := a.Srv().Store.Command().Update(command)
if err != nil {
return err
var nfErr *store.ErrNotFound
var appErr *model.AppError
switch {
case errors.As(err, &nfErr):
return model.NewAppError("SqlCommandStore.Update", "store.sql_command.update.missing.app_error", map[string]interface{}{"command_id": command.Id}, "", http.StatusNotFound)
case errors.As(err, &appErr):
return appErr
default:
return model.NewAppError("MoveCommand", "app.command.movecommand.internal_error", nil, err.Error(), http.StatusInternalServerError)
}
}
return nil
@@ -670,7 +713,21 @@ func (a *App) RegenCommandToken(cmd *model.Command) (*model.Command, *model.AppE
cmd.Token = model.NewId()
return a.Srv().Store.Command().Update(cmd)
command, err := a.Srv().Store.Command().Update(cmd)
if err != nil {
var nfErr *store.ErrNotFound
var appErr *model.AppError
switch {
case errors.As(err, &nfErr):
return nil, model.NewAppError("SqlCommandStore.Update", "store.sql_command.update.missing.app_error", map[string]interface{}{"command_id": cmd.Id}, "", http.StatusNotFound)
case errors.As(err, &appErr):
return nil, appErr
default:
return nil, model.NewAppError("RegenCommandToken", "app.command.regencommandtoken.internal_error", nil, err.Error(), http.StatusInternalServerError)
}
}
return command, nil
}
func (a *App) DeleteCommand(commandId string) *model.AppError {
@@ -678,5 +735,10 @@ func (a *App) DeleteCommand(commandId string) *model.AppError {
return model.NewAppError("DeleteCommand", "api.command.disabled.app_error", nil, "", http.StatusNotImplemented)
}
return a.Srv().Store.Command().Delete(commandId, model.GetMillis())
err := a.Srv().Store.Command().Delete(commandId, model.GetMillis())
if err != nil {
return model.NewAppError("DeleteCommand", "app.command.deletecommand.internal_error", nil, err.Error(), http.StatusInternalServerError)
}
return nil
}

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

@@ -1384,7 +1384,7 @@ func (a *App) PermanentDeleteTeam(team *model.Team) *model.AppError {
}
if err := a.Srv().Store.Command().PermanentDeleteByTeam(team.Id); err != nil {
return err
return model.NewAppError("PermanentDeleteTeam", "app.team.permanentdeleteteam.internal_error", nil, err.Error(), http.StatusInternalServerError)
}
if err := a.Srv().Store.Team().PermanentDelete(team.Id); err != nil {

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

@@ -1473,7 +1473,7 @@ func (a *App) PermanentDeleteUser(user *model.User) *model.AppError {
}
if err := a.Srv().Store.Command().PermanentDeleteByUser(user.Id); err != nil {
return err
return model.NewAppError("PermanentDeleteUser", "app.user.permanentdeleteuser.internal_error", nil, err.Error(), http.StatusInternalServerError)
}
if err := a.Srv().Store.Preference().PermanentDeleteByUser(user.Id); err != nil {

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

@@ -724,9 +724,15 @@ func (a *App) HandleCommandWebhook(hookId string, response *model.CommandRespons
return model.NewAppError("HandleCommandWebhook", "web.command_webhook.invalid.app_error", nil, "err="+err.Message, err.StatusCode)
}
cmd, err := a.Srv().Store.Command().Get(hook.CommandId)
if err != nil {
return model.NewAppError("HandleCommandWebhook", "web.command_webhook.command.app_error", nil, "err="+err.Message, http.StatusBadRequest)
cmd, cmdErr := a.Srv().Store.Command().Get(hook.CommandId)
if cmdErr != nil {
var appErr *model.AppError
switch {
case errors.As(cmdErr, &appErr):
return appErr
default:
return model.NewAppError("HandleCommandWebhook", "web.command_webhook.command.app_error", nil, "err="+cmdErr.Error(), http.StatusBadRequest)
}
}
args := &model.CommandArgs{