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

WebhookStore migration (#15042)

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

* Fix tests

Co-authored-by: Jesús Espino <jespinog@gmail.com>
Этот коммит содержится в:
Rodrigo Villablanca
2020-07-31 09:53:10 -04:00
коммит произвёл GitHub
родитель ed3c93716d
Коммит 1c5b6522e3
14 изменённых файлов: 467 добавлений и 424 удалений
Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

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

@@ -232,14 +232,14 @@ func (a *App) GetAnalytics(name string, teamId string) (model.AnalyticsRows, *mo
iHookChan := make(chan store.StoreResult, 1)
go func() {
c, err2 := a.Srv().Store.Webhook().AnalyticsIncomingCount(teamId)
iHookChan <- store.StoreResult{Data: c, Err: err2}
iHookChan <- store.StoreResult{Data: c, NErr: err2}
close(iHookChan)
}()
oHookChan := make(chan store.StoreResult, 1)
go func() {
c, err2 := a.Srv().Store.Webhook().AnalyticsOutgoingCount(teamId)
oHookChan <- store.StoreResult{Data: c, Err: err2}
oHookChan <- store.StoreResult{Data: c, NErr: err2}
close(oHookChan)
}()
@@ -297,14 +297,14 @@ func (a *App) GetAnalytics(name string, teamId string) (model.AnalyticsRows, *mo
}
r := <-iHookChan
if r.Err != nil {
return nil, r.Err
if r.NErr != nil {
return nil, model.NewAppError("GetAnalytics", "app.webhooks.analytics_incoming_count.app_error", nil, r.NErr.Error(), http.StatusInternalServerError)
}
rows[2].Value = float64(r.Data.(int64))
r = <-oHookChan
if r.Err != nil {
return nil, r.Err
if r.NErr != nil {
return nil, model.NewAppError("GetAnalytics", "app.webhooks.analytics_outgoing_count.app_error", nil, r.NErr.Error(), http.StatusInternalServerError)
}
rows[3].Value = float64(r.Data.(int64))

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

@@ -1128,13 +1128,13 @@ func (a *App) DeleteChannel(channel *model.Channel, userId string) *model.AppErr
go func() {
webhooks, err := a.Srv().Store.Webhook().GetIncomingByChannel(channel.Id)
ihc <- store.StoreResult{Data: webhooks, Err: err}
ihc <- store.StoreResult{Data: webhooks, NErr: err}
close(ihc)
}()
go func() {
outgoingHooks, err := a.Srv().Store.Webhook().GetOutgoingByChannel(channel.Id, -1, -1)
ohc <- store.StoreResult{Data: outgoingHooks, Err: err}
ohc <- store.StoreResult{Data: outgoingHooks, NErr: err}
close(ohc)
}()
@@ -1148,13 +1148,13 @@ func (a *App) DeleteChannel(channel *model.Channel, userId string) *model.AppErr
}
ihcresult := <-ihc
if ihcresult.Err != nil {
return ihcresult.Err
if ihcresult.NErr != nil {
return model.NewAppError("DeleteChannel", "app.webhooks.get_incoming_by_channel.app_error", nil, ihcresult.NErr.Error(), http.StatusInternalServerError)
}
ohcresult := <-ohc
if ohcresult.Err != nil {
return ohcresult.Err
if ohcresult.NErr != nil {
return model.NewAppError("DeleteChannel", "app.webhooks.get_outgoing_by_channel.app_error", nil, ohcresult.NErr.Error(), http.StatusInternalServerError)
}
incomingHooks := ihcresult.Data.([]*model.IncomingWebhook)
@@ -2340,11 +2340,11 @@ func (a *App) PermanentDeleteChannel(channel *model.Channel) *model.AppError {
}
if err := a.Srv().Store.Webhook().PermanentDeleteIncomingByChannel(channel.Id); err != nil {
return err
return model.NewAppError("PermanentDeleteChannel", "app.webhooks.permanent_delete_incoming_by_channel.app_error", nil, err.Error(), http.StatusInternalServerError)
}
if err := a.Srv().Store.Webhook().PermanentDeleteOutgoingByChannel(channel.Id); err != nil {
return err
return model.NewAppError("PermanentDeleteChannel", "app.webhooks.permanent_delete_outgoing_by_channel.app_error", nil, err.Error(), http.StatusInternalServerError)
}
if nErr := a.Srv().Store.Channel().PermanentDelete(channel.Id); nErr != nil {

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

@@ -1465,11 +1465,11 @@ func (a *App) PermanentDeleteUser(user *model.User) *model.AppError {
}
if err := a.Srv().Store.Webhook().PermanentDeleteIncomingByUser(user.Id); err != nil {
return err
return model.NewAppError("PermanentDeleteUser", "app.webhooks.permanent_delete_incoming_by_user.app_error", nil, err.Error(), http.StatusInternalServerError)
}
if err := a.Srv().Store.Webhook().PermanentDeleteOutgoingByUser(user.Id); err != nil {
return err
return model.NewAppError("PermanentDeleteUser", "app.webhooks.permanent_delete_outgoing_by_user.app_error", nil, err.Error(), http.StatusInternalServerError)
}
if err := a.Srv().Store.Command().PermanentDeleteByUser(user.Id); err != nil {

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

@@ -35,7 +35,7 @@ func (a *App) handleWebhookEvents(post *model.Post, team *model.Team, channel *m
hooks, err := a.Srv().Store.Webhook().GetOutgoingByTeam(team.Id, -1, -1)
if err != nil {
return err
return model.NewAppError("handleWebhookEvents", "app.webhooks.get_outgoing_by_team.app_error", nil, err.Error(), http.StatusInternalServerError)
}
if len(hooks) == 0 {
@@ -325,7 +325,21 @@ func (a *App) CreateIncomingWebhookForChannel(creatorId string, channel *model.C
return nil, model.NewAppError("CreateIncomingWebhookForChannel", "api.incoming_webhook.invalid_username.app_error", nil, "", http.StatusBadRequest)
}
return a.Srv().Store.Webhook().SaveIncoming(hook)
webhook, err := a.Srv().Store.Webhook().SaveIncoming(hook)
if err != nil {
var invErr *store.ErrInvalidInput
var appErr *model.AppError
switch {
case errors.As(err, &appErr):
return nil, appErr
case errors.As(err, &invErr):
return nil, model.NewAppError("CreateIncomingWebhookForChannel", "app.webhooks.save_incoming.existing.app_error", nil, invErr.Error(), http.StatusBadRequest)
default:
return nil, model.NewAppError("CreateIncomingWebhookForChannel", "app.webhooks.save_incoming.app_error", nil, err.Error(), http.StatusInternalServerError)
}
}
return webhook, nil
}
func (a *App) UpdateIncomingWebhook(oldHook, updatedHook *model.IncomingWebhook) (*model.IncomingWebhook, *model.AppError) {
@@ -353,7 +367,7 @@ func (a *App) UpdateIncomingWebhook(oldHook, updatedHook *model.IncomingWebhook)
newWebhook, err := a.Srv().Store.Webhook().UpdateIncoming(updatedHook)
if err != nil {
return nil, err
return nil, model.NewAppError("UpdateIncomingWebhook", "app.webhooks.update_incoming.app_error", nil, err.Error(), http.StatusInternalServerError)
}
a.invalidateCacheForWebhook(oldHook.Id)
return newWebhook, nil
@@ -365,7 +379,7 @@ func (a *App) DeleteIncomingWebhook(hookId string) *model.AppError {
}
if err := a.Srv().Store.Webhook().DeleteIncoming(hookId, model.GetMillis()); err != nil {
return err
return model.NewAppError("DeleteIncomingWebhook", "app.webhooks.delete_incoming.app_error", nil, err.Error(), http.StatusInternalServerError)
}
a.invalidateCacheForWebhook(hookId)
@@ -378,7 +392,18 @@ func (a *App) GetIncomingWebhook(hookId string) (*model.IncomingWebhook, *model.
return nil, model.NewAppError("GetIncomingWebhook", "api.incoming_webhook.disabled.app_error", nil, "", http.StatusNotImplemented)
}
return a.Srv().Store.Webhook().GetIncoming(hookId, true)
webhook, err := a.Srv().Store.Webhook().GetIncoming(hookId, true)
if err != nil {
var nfErr *store.ErrNotFound
switch {
case errors.As(err, &nfErr):
return nil, model.NewAppError("GetIncomingWebhook", "app.webhooks.get_incoming.app_error", nil, nfErr.Error(), http.StatusNotFound)
default:
return nil, model.NewAppError("GetIncomingWebhook", "app.webhooks.get_incoming.app_error", nil, err.Error(), http.StatusInternalServerError)
}
}
return webhook, nil
}
func (a *App) GetIncomingWebhooksForTeamPage(teamId string, page, perPage int) ([]*model.IncomingWebhook, *model.AppError) {
@@ -390,15 +415,25 @@ func (a *App) GetIncomingWebhooksForTeamPageByUser(teamId string, userId string,
return nil, model.NewAppError("GetIncomingWebhooksForTeamPage", "api.incoming_webhook.disabled.app_error", nil, "", http.StatusNotImplemented)
}
return a.Srv().Store.Webhook().GetIncomingByTeamByUser(teamId, userId, page*perPage, perPage)
webhooks, err := a.Srv().Store.Webhook().GetIncomingByTeamByUser(teamId, userId, page*perPage, perPage)
if err != nil {
return nil, model.NewAppError("GetIncomingWebhooksForTeamPage", "app.webhooks.get_incoming_by_user.app_error", nil, err.Error(), http.StatusInternalServerError)
}
return webhooks, nil
}
func (a *App) GetIncomingWebhooksPageByUser(userId string, page, perPage int) ([]*model.IncomingWebhook, *model.AppError) {
if !*a.Config().ServiceSettings.EnableIncomingWebhooks {
return nil, model.NewAppError("GetIncomingWebhooksPage", "api.incoming_webhook.disabled.app_error", nil, "", http.StatusNotImplemented)
return nil, model.NewAppError("GetIncomingWebhooksPageByUser", "api.incoming_webhook.disabled.app_error", nil, "", http.StatusNotImplemented)
}
return a.Srv().Store.Webhook().GetIncomingListByUser(userId, page*perPage, perPage)
webhooks, err := a.Srv().Store.Webhook().GetIncomingListByUser(userId, page*perPage, perPage)
if err != nil {
return nil, model.NewAppError("GetIncomingWebhooksPageByUser", "app.webhooks.get_incoming_by_user.app_error", nil, err.Error(), http.StatusInternalServerError)
}
return webhooks, nil
}
func (a *App) GetIncomingWebhooksPage(page, perPage int) ([]*model.IncomingWebhook, *model.AppError) {
@@ -434,7 +469,7 @@ func (a *App) CreateOutgoingWebhook(hook *model.OutgoingWebhook) (*model.Outgoin
}
if allHooks, err := a.Srv().Store.Webhook().GetOutgoingByTeam(hook.TeamId, -1, -1); err != nil {
return nil, err
return nil, model.NewAppError("CreateOutgoingWebhook", "app.webhooks.get_outgoing_by_team.app_error", nil, err.Error(), http.StatusInternalServerError)
} else {
for _, existingOutHook := range allHooks {
@@ -449,7 +484,16 @@ func (a *App) CreateOutgoingWebhook(hook *model.OutgoingWebhook) (*model.Outgoin
webhook, err := a.Srv().Store.Webhook().SaveOutgoing(hook)
if err != nil {
return nil, err
var appErr *model.AppError
var invErr *store.ErrInvalidInput
switch {
case errors.As(err, &appErr):
return nil, appErr
case errors.As(err, &invErr):
return nil, model.NewAppError("CreateOutgoingWebhook", "app.webhooks.save_outgoing.override.app_error", nil, invErr.Error(), http.StatusBadRequest)
default:
return nil, model.NewAppError("CreateOutgoingWebhook", "app.webhooks.save_outgoing.app_error", nil, err.Error(), http.StatusInternalServerError)
}
}
return webhook, nil
@@ -479,7 +523,7 @@ func (a *App) UpdateOutgoingWebhook(oldHook, updatedHook *model.OutgoingWebhook)
allHooks, err := a.Srv().Store.Webhook().GetOutgoingByTeam(oldHook.TeamId, -1, -1)
if err != nil {
return nil, err
return nil, model.NewAppError("UpdateOutgoingWebhook", "app.webhooks.get_outgoing_by_team.app_error", nil, err.Error(), http.StatusInternalServerError)
}
for _, existingOutHook := range allHooks {
@@ -497,7 +541,12 @@ func (a *App) UpdateOutgoingWebhook(oldHook, updatedHook *model.OutgoingWebhook)
updatedHook.TeamId = oldHook.TeamId
updatedHook.UpdateAt = model.GetMillis()
return a.Srv().Store.Webhook().UpdateOutgoing(updatedHook)
webhook, err := a.Srv().Store.Webhook().UpdateOutgoing(updatedHook)
if err != nil {
return nil, model.NewAppError("UpdateOutgoingWebhook", "app.webhooks.update_outgoing.app_error", nil, err.Error(), http.StatusInternalServerError)
}
return webhook, nil
}
func (a *App) GetOutgoingWebhook(hookId string) (*model.OutgoingWebhook, *model.AppError) {
@@ -505,7 +554,18 @@ func (a *App) GetOutgoingWebhook(hookId string) (*model.OutgoingWebhook, *model.
return nil, model.NewAppError("GetOutgoingWebhook", "api.outgoing_webhook.disabled.app_error", nil, "", http.StatusNotImplemented)
}
return a.Srv().Store.Webhook().GetOutgoing(hookId)
webhook, err := a.Srv().Store.Webhook().GetOutgoing(hookId)
if err != nil {
var nfErr *store.ErrNotFound
switch {
case errors.As(err, &nfErr):
return nil, model.NewAppError("GetOutgoingWebhook", "app.webhooks.get_outgoing.app_error", nil, nfErr.Error(), http.StatusNotFound)
default:
return nil, model.NewAppError("GetOutgoingWebhook", "app.webhooks.get_outgoing.app_error", nil, err.Error(), http.StatusInternalServerError)
}
}
return webhook, nil
}
func (a *App) GetOutgoingWebhooksPage(page, perPage int) ([]*model.OutgoingWebhook, *model.AppError) {
@@ -514,10 +574,15 @@ func (a *App) GetOutgoingWebhooksPage(page, perPage int) ([]*model.OutgoingWebho
func (a *App) GetOutgoingWebhooksPageByUser(userId string, page, perPage int) ([]*model.OutgoingWebhook, *model.AppError) {
if !*a.Config().ServiceSettings.EnableOutgoingWebhooks {
return nil, model.NewAppError("GetOutgoingWebhooksPage", "api.outgoing_webhook.disabled.app_error", nil, "", http.StatusNotImplemented)
return nil, model.NewAppError("GetOutgoingWebhooksPageByUser", "api.outgoing_webhook.disabled.app_error", nil, "", http.StatusNotImplemented)
}
return a.Srv().Store.Webhook().GetOutgoingListByUser(userId, page*perPage, perPage)
webhooks, err := a.Srv().Store.Webhook().GetOutgoingListByUser(userId, page*perPage, perPage)
if err != nil {
return nil, model.NewAppError("GetOutgoingWebhooksPageByUser", "app.webhooks.get_outgoing_by_channel.app_error", nil, err.Error(), http.StatusInternalServerError)
}
return webhooks, nil
}
func (a *App) GetOutgoingWebhooksForChannelPageByUser(channelId string, userId string, page, perPage int) ([]*model.OutgoingWebhook, *model.AppError) {
@@ -525,7 +590,12 @@ func (a *App) GetOutgoingWebhooksForChannelPageByUser(channelId string, userId s
return nil, model.NewAppError("GetOutgoingWebhooksForChannelPage", "api.outgoing_webhook.disabled.app_error", nil, "", http.StatusNotImplemented)
}
return a.Srv().Store.Webhook().GetOutgoingByChannelByUser(channelId, userId, page*perPage, perPage)
webhooks, err := a.Srv().Store.Webhook().GetOutgoingByChannelByUser(channelId, userId, page*perPage, perPage)
if err != nil {
return nil, model.NewAppError("GetOutgoingWebhooksForChannelPage", "app.webhooks.get_outgoing_by_channel.app_error", nil, err.Error(), http.StatusInternalServerError)
}
return webhooks, nil
}
func (a *App) GetOutgoingWebhooksForTeamPage(teamId string, page, perPage int) ([]*model.OutgoingWebhook, *model.AppError) {
@@ -534,10 +604,15 @@ func (a *App) GetOutgoingWebhooksForTeamPage(teamId string, page, perPage int) (
func (a *App) GetOutgoingWebhooksForTeamPageByUser(teamId string, userId string, page, perPage int) ([]*model.OutgoingWebhook, *model.AppError) {
if !*a.Config().ServiceSettings.EnableOutgoingWebhooks {
return nil, model.NewAppError("GetOutgoingWebhooksForTeamPage", "api.outgoing_webhook.disabled.app_error", nil, "", http.StatusNotImplemented)
return nil, model.NewAppError("GetOutgoingWebhooksForTeamPageByUser", "api.outgoing_webhook.disabled.app_error", nil, "", http.StatusNotImplemented)
}
return a.Srv().Store.Webhook().GetOutgoingByTeamByUser(teamId, userId, page*perPage, perPage)
webhooks, err := a.Srv().Store.Webhook().GetOutgoingByTeamByUser(teamId, userId, page*perPage, perPage)
if err != nil {
return nil, model.NewAppError("GetOutgoingWebhooksForTeamPageByUser", "app.webhooks.get_outgoing_by_team.app_error", nil, err.Error(), http.StatusInternalServerError)
}
return webhooks, nil
}
func (a *App) DeleteOutgoingWebhook(hookId string) *model.AppError {
@@ -545,7 +620,11 @@ func (a *App) DeleteOutgoingWebhook(hookId string) *model.AppError {
return model.NewAppError("DeleteOutgoingWebhook", "api.outgoing_webhook.disabled.app_error", nil, "", http.StatusNotImplemented)
}
return a.Srv().Store.Webhook().DeleteOutgoing(hookId, model.GetMillis())
if err := a.Srv().Store.Webhook().DeleteOutgoing(hookId, model.GetMillis()); err != nil {
return model.NewAppError("DeleteOutgoingWebhook", "app.webhooks.delete_outgoing.app_error", nil, err.Error(), http.StatusInternalServerError)
}
return nil
}
func (a *App) RegenOutgoingWebhookToken(hook *model.OutgoingWebhook) (*model.OutgoingWebhook, *model.AppError) {
@@ -555,7 +634,12 @@ func (a *App) RegenOutgoingWebhookToken(hook *model.OutgoingWebhook) (*model.Out
hook.Token = model.NewId()
return a.Srv().Store.Webhook().UpdateOutgoing(hook)
webhook, err := a.Srv().Store.Webhook().UpdateOutgoing(hook)
if err != nil {
return nil, model.NewAppError("RegenOutgoingWebhookToken", "app.webhooks.update_outgoing.app_error", nil, err.Error(), http.StatusInternalServerError)
}
return webhook, nil
}
func (a *App) HandleIncomingWebhook(hookId string, req *model.IncomingWebhookRequest) *model.AppError {
@@ -566,7 +650,7 @@ func (a *App) HandleIncomingWebhook(hookId string, req *model.IncomingWebhookReq
hchan := make(chan store.StoreResult, 1)
go func() {
webhook, err := a.Srv().Store.Webhook().GetIncoming(hookId, true)
hchan <- store.StoreResult{Data: webhook, Err: err}
hchan <- store.StoreResult{Data: webhook, NErr: err}
close(hchan)
}()
@@ -583,8 +667,8 @@ func (a *App) HandleIncomingWebhook(hookId string, req *model.IncomingWebhookReq
webhookType := req.Type
var hook *model.IncomingWebhook
if result := <-hchan; result.Err != nil {
return model.NewAppError("HandleIncomingWebhook", "web.incoming_webhook.invalid.app_error", nil, "err="+result.Err.Message, http.StatusBadRequest)
if result := <-hchan; result.NErr != nil {
return model.NewAppError("HandleIncomingWebhook", "web.incoming_webhook.invalid.app_error", nil, result.NErr.Error(), http.StatusBadRequest)
} else {
hook = result.Data.(*model.IncomingWebhook)
}