2015-12-05 19:24:13 +01:00
|
|
|
// Copyright 2015 The Gogs Authors. All rights reserved.
|
2017-05-29 09:17:15 +02:00
|
|
|
// Copyright 2017 The Gitea Authors. All rights reserved.
|
2022-11-27 19:20:29 +01:00
|
|
|
// SPDX-License-Identifier: MIT
|
2015-12-05 19:24:13 +01:00
|
|
|
|
2023-07-02 02:59:32 +02:00
|
|
|
package setting
|
2015-12-05 19:24:13 +01:00
|
|
|
|
|
|
|
import (
|
|
|
|
"errors"
|
|
|
|
"fmt"
|
2021-04-05 17:30:52 +02:00
|
|
|
"net/http"
|
2021-11-16 19:18:25 +01:00
|
|
|
"net/url"
|
2019-03-19 03:33:20 +01:00
|
|
|
"path"
|
2015-12-05 19:24:13 +01:00
|
|
|
"strings"
|
|
|
|
|
2023-11-24 04:49:41 +01:00
|
|
|
"code.gitea.io/gitea/models/db"
|
2021-11-28 12:58:28 +01:00
|
|
|
"code.gitea.io/gitea/models/perm"
|
2023-06-22 15:08:08 +02:00
|
|
|
access_model "code.gitea.io/gitea/models/perm/access"
|
2021-11-24 10:49:20 +01:00
|
|
|
user_model "code.gitea.io/gitea/models/user"
|
2021-11-10 06:13:16 +01:00
|
|
|
"code.gitea.io/gitea/models/webhook"
|
2016-11-10 17:24:48 +01:00
|
|
|
"code.gitea.io/gitea/modules/base"
|
2019-03-27 10:33:00 +01:00
|
|
|
"code.gitea.io/gitea/modules/git"
|
2021-07-24 18:03:58 +02:00
|
|
|
"code.gitea.io/gitea/modules/json"
|
2016-11-10 17:24:48 +01:00
|
|
|
"code.gitea.io/gitea/modules/setting"
|
2019-05-11 12:21:34 +02:00
|
|
|
api "code.gitea.io/gitea/modules/structs"
|
2020-12-25 10:59:32 +01:00
|
|
|
"code.gitea.io/gitea/modules/util"
|
2021-01-26 16:36:53 +01:00
|
|
|
"code.gitea.io/gitea/modules/web"
|
2023-01-01 16:23:15 +01:00
|
|
|
webhook_module "code.gitea.io/gitea/modules/webhook"
|
2024-02-27 08:12:22 +01:00
|
|
|
"code.gitea.io/gitea/services/context"
|
2022-12-29 03:57:15 +01:00
|
|
|
"code.gitea.io/gitea/services/convert"
|
2021-04-06 21:44:05 +02:00
|
|
|
"code.gitea.io/gitea/services/forms"
|
2021-11-10 06:13:16 +01:00
|
|
|
webhook_service "code.gitea.io/gitea/services/webhook"
|
2015-12-05 19:24:13 +01:00
|
|
|
)
|
|
|
|
|
|
|
|
const (
|
2019-03-19 03:33:20 +01:00
|
|
|
tplHooks base.TplName = "repo/settings/webhook/base"
|
|
|
|
tplHookNew base.TplName = "repo/settings/webhook/new"
|
|
|
|
tplOrgHookNew base.TplName = "org/settings/hook_new"
|
2023-03-10 15:28:32 +01:00
|
|
|
tplUserHookNew base.TplName = "user/settings/hook_new"
|
2019-03-19 03:33:20 +01:00
|
|
|
tplAdminHookNew base.TplName = "admin/hook_new"
|
2015-12-05 19:24:13 +01:00
|
|
|
)
|
|
|
|
|
2016-11-24 08:04:31 +01:00
|
|
|
// Webhooks render web hooks list page
|
2016-03-11 17:56:52 +01:00
|
|
|
func Webhooks(ctx *context.Context) {
|
2015-12-05 19:24:13 +01:00
|
|
|
ctx.Data["Title"] = ctx.Tr("repo.settings.hooks")
|
|
|
|
ctx.Data["PageIsSettingsHooks"] = true
|
2019-03-19 03:33:20 +01:00
|
|
|
ctx.Data["BaseLink"] = ctx.Repo.RepoLink + "/settings/hooks"
|
2021-01-15 00:24:03 +01:00
|
|
|
ctx.Data["BaseLinkNew"] = ctx.Repo.RepoLink + "/settings/hooks"
|
2023-01-14 10:07:01 +01:00
|
|
|
ctx.Data["Description"] = ctx.Tr("repo.settings.hooks_desc", "https://forgejo.org/docs/latest/user/webhooks/")
|
2015-12-05 19:24:13 +01:00
|
|
|
|
2023-11-24 04:49:41 +01:00
|
|
|
ws, err := db.Find[webhook.Webhook](ctx, webhook.ListWebhookOptions{RepoID: ctx.Repo.Repository.ID})
|
2015-12-05 19:24:13 +01:00
|
|
|
if err != nil {
|
2018-01-10 22:34:17 +01:00
|
|
|
ctx.ServerError("GetWebhooksByRepoID", err)
|
2015-12-05 19:24:13 +01:00
|
|
|
return
|
|
|
|
}
|
|
|
|
ctx.Data["Webhooks"] = ws
|
|
|
|
|
2021-04-05 17:30:52 +02:00
|
|
|
ctx.HTML(http.StatusOK, tplHooks)
|
2015-12-05 19:24:13 +01:00
|
|
|
}
|
|
|
|
|
2023-03-10 15:28:32 +01:00
|
|
|
type ownerRepoCtx struct {
|
|
|
|
OwnerID int64
|
2020-03-08 23:08:05 +01:00
|
|
|
RepoID int64
|
|
|
|
IsAdmin bool
|
|
|
|
IsSystemWebhook bool
|
|
|
|
Link string
|
2021-01-15 00:24:03 +01:00
|
|
|
LinkNew string
|
2020-03-08 23:08:05 +01:00
|
|
|
NewTemplate base.TplName
|
2015-12-05 19:24:13 +01:00
|
|
|
}
|
|
|
|
|
2023-03-10 15:28:32 +01:00
|
|
|
// getOwnerRepoCtx determines whether this is a repo, owner, or admin (both default and system) context.
|
|
|
|
func getOwnerRepoCtx(ctx *context.Context) (*ownerRepoCtx, error) {
|
2023-04-28 02:08:47 +02:00
|
|
|
if ctx.Data["PageIsRepoSettings"] == true {
|
2023-03-10 15:28:32 +01:00
|
|
|
return &ownerRepoCtx{
|
2015-12-05 19:24:13 +01:00
|
|
|
RepoID: ctx.Repo.Repository.ID,
|
2019-03-19 03:33:20 +01:00
|
|
|
Link: path.Join(ctx.Repo.RepoLink, "settings/hooks"),
|
2021-01-15 00:24:03 +01:00
|
|
|
LinkNew: path.Join(ctx.Repo.RepoLink, "settings/hooks"),
|
2016-11-07 21:58:22 +01:00
|
|
|
NewTemplate: tplHookNew,
|
2015-12-05 19:24:13 +01:00
|
|
|
}, nil
|
|
|
|
}
|
|
|
|
|
2023-04-28 02:08:47 +02:00
|
|
|
if ctx.Data["PageIsOrgSettings"] == true {
|
2023-03-10 15:28:32 +01:00
|
|
|
return &ownerRepoCtx{
|
|
|
|
OwnerID: ctx.ContextUser.ID,
|
2019-03-19 03:33:20 +01:00
|
|
|
Link: path.Join(ctx.Org.OrgLink, "settings/hooks"),
|
2021-01-15 00:24:03 +01:00
|
|
|
LinkNew: path.Join(ctx.Org.OrgLink, "settings/hooks"),
|
2016-11-07 21:58:22 +01:00
|
|
|
NewTemplate: tplOrgHookNew,
|
2015-12-05 19:24:13 +01:00
|
|
|
}, nil
|
|
|
|
}
|
|
|
|
|
2023-04-28 02:08:47 +02:00
|
|
|
if ctx.Data["PageIsUserSettings"] == true {
|
2023-03-10 15:28:32 +01:00
|
|
|
return &ownerRepoCtx{
|
|
|
|
OwnerID: ctx.Doer.ID,
|
|
|
|
Link: path.Join(setting.AppSubURL, "/user/settings/hooks"),
|
|
|
|
LinkNew: path.Join(setting.AppSubURL, "/user/settings/hooks"),
|
|
|
|
NewTemplate: tplUserHookNew,
|
|
|
|
}, nil
|
|
|
|
}
|
2020-03-08 23:08:05 +01:00
|
|
|
|
2023-04-28 02:08:47 +02:00
|
|
|
if ctx.Data["PageIsAdmin"] == true {
|
2023-03-10 15:28:32 +01:00
|
|
|
return &ownerRepoCtx{
|
2020-03-08 23:08:05 +01:00
|
|
|
IsAdmin: true,
|
2023-03-10 15:28:32 +01:00
|
|
|
IsSystemWebhook: ctx.Params(":configType") == "system-hooks",
|
2021-01-15 00:24:03 +01:00
|
|
|
Link: path.Join(setting.AppSubURL, "/admin/hooks"),
|
Reenable creating default webhooks. (#24626)
Fixes #24624
This seems to have been broken in
https://github.com/go-gitea/gitea/pull/21563
Previously, this code read
```
// Are we looking at default webhooks?
if ctx.Params(":configType") == "default-hooks" {
return &orgRepoCtx{
IsAdmin: true,
Link: path.Join(setting.AppSubURL, "/admin/hooks"),
LinkNew: path.Join(setting.AppSubURL, "/admin/default-hooks"),
NewTemplate: tplAdminHookNew,
}, nil
}
// Must be system webhooks instead
return &orgRepoCtx{
IsAdmin: true,
IsSystemWebhook: true,
Link: path.Join(setting.AppSubURL, "/admin/hooks"),
LinkNew: path.Join(setting.AppSubURL, "/admin/system-hooks"),
NewTemplate: tplAdminHookNew,
}, nil
```
but was simplified to
```
return &ownerRepoCtx{
IsAdmin: true,
IsSystemWebhook: ctx.Params(":configType") == "system-hooks",
Link: path.Join(setting.AppSubURL, "/admin/hooks"),
LinkNew: path.Join(setting.AppSubURL, "/admin/system-hooks"),
NewTemplate: tplAdminHookNew,
}, nil
```
In other words, combining the `IsSystemWebhook` check into a one-liner
and forgetting that `LinkNew` also depended on it. This meant the
rendered `<form>` always POSTed to `/admin/system-hooks`, even when you
had GETed `/admin/default-hooks/gitea/new`.
2023-05-11 04:10:57 +02:00
|
|
|
LinkNew: path.Join(setting.AppSubURL, "/admin/", ctx.Params(":configType")),
|
2020-03-08 23:08:05 +01:00
|
|
|
NewTemplate: tplAdminHookNew,
|
2019-03-19 03:33:20 +01:00
|
|
|
}, nil
|
|
|
|
}
|
|
|
|
|
2023-03-10 15:28:32 +01:00
|
|
|
return nil, errors.New("unable to set OwnerRepo context")
|
2015-12-05 19:24:13 +01:00
|
|
|
}
|
|
|
|
|
2016-03-11 17:56:52 +01:00
|
|
|
func checkHookType(ctx *context.Context) string {
|
2015-12-05 19:24:13 +01:00
|
|
|
hookType := strings.ToLower(ctx.Params(":type"))
|
Improve utils of slices (#22379)
- Move the file `compare.go` and `slice.go` to `slice.go`.
- Fix `ExistsInSlice`, it's buggy
- It uses `sort.Search`, so it assumes that the input slice is sorted.
- It passes `func(i int) bool { return slice[i] == target })` to
`sort.Search`, that's incorrect, check the doc of `sort.Search`.
- Conbine `IsInt64InSlice(int64, []int64)` and `ExistsInSlice(string,
[]string)` to `SliceContains[T]([]T, T)`.
- Conbine `IsSliceInt64Eq([]int64, []int64)` and `IsEqualSlice([]string,
[]string)` to `SliceSortedEqual[T]([]T, T)`.
- Add `SliceEqual[T]([]T, T)` as a distinction from
`SliceSortedEqual[T]([]T, T)`.
- Redesign `RemoveIDFromList([]int64, int64) ([]int64, bool)` to
`SliceRemoveAll[T]([]T, T) []T`.
- Add `SliceContainsFunc[T]([]T, func(T) bool)` and
`SliceRemoveAllFunc[T]([]T, func(T) bool)` for general use.
- Add comments to explain why not `golang.org/x/exp/slices`.
- Add unit tests.
2023-01-11 06:31:16 +01:00
|
|
|
if !util.SliceContainsString(setting.Webhook.Types, hookType, true) {
|
2018-01-10 22:34:17 +01:00
|
|
|
ctx.NotFound("checkHookType", nil)
|
2015-12-05 19:24:13 +01:00
|
|
|
return ""
|
|
|
|
}
|
|
|
|
return hookType
|
|
|
|
}
|
|
|
|
|
2016-11-24 08:04:31 +01:00
|
|
|
// WebhooksNew render creating webhook page
|
2016-03-11 17:56:52 +01:00
|
|
|
func WebhooksNew(ctx *context.Context) {
|
2015-12-05 19:24:13 +01:00
|
|
|
ctx.Data["Title"] = ctx.Tr("repo.settings.add_webhook")
|
2023-01-01 16:23:15 +01:00
|
|
|
ctx.Data["Webhook"] = webhook.Webhook{HookEvent: &webhook_module.HookEvent{}}
|
2015-12-05 19:24:13 +01:00
|
|
|
|
2023-03-10 15:28:32 +01:00
|
|
|
orCtx, err := getOwnerRepoCtx(ctx)
|
2015-12-05 19:24:13 +01:00
|
|
|
if err != nil {
|
2023-03-10 15:28:32 +01:00
|
|
|
ctx.ServerError("getOwnerRepoCtx", err)
|
2015-12-05 19:24:13 +01:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2020-03-08 23:08:05 +01:00
|
|
|
if orCtx.IsAdmin && orCtx.IsSystemWebhook {
|
|
|
|
ctx.Data["PageIsAdminSystemHooks"] = true
|
|
|
|
ctx.Data["PageIsAdminSystemHooksNew"] = true
|
|
|
|
} else if orCtx.IsAdmin {
|
2021-01-15 00:24:03 +01:00
|
|
|
ctx.Data["PageIsAdminDefaultHooks"] = true
|
|
|
|
ctx.Data["PageIsAdminDefaultHooksNew"] = true
|
2019-03-19 03:33:20 +01:00
|
|
|
} else {
|
|
|
|
ctx.Data["PageIsSettingsHooks"] = true
|
|
|
|
ctx.Data["PageIsSettingsHooksNew"] = true
|
|
|
|
}
|
|
|
|
|
2017-08-28 07:06:45 +02:00
|
|
|
hookType := checkHookType(ctx)
|
|
|
|
ctx.Data["HookType"] = hookType
|
2015-12-05 19:24:13 +01:00
|
|
|
if ctx.Written() {
|
|
|
|
return
|
|
|
|
}
|
2017-08-28 07:06:45 +02:00
|
|
|
if hookType == "discord" {
|
2023-07-04 20:36:08 +02:00
|
|
|
ctx.Data["DiscordHook"] = map[string]any{
|
2017-08-28 07:06:45 +02:00
|
|
|
"Username": "Gitea",
|
|
|
|
}
|
|
|
|
}
|
2021-01-15 00:24:03 +01:00
|
|
|
ctx.Data["BaseLink"] = orCtx.LinkNew
|
2024-02-15 14:59:48 +01:00
|
|
|
ctx.Data["BaseLinkNew"] = orCtx.LinkNew
|
2015-12-05 19:24:13 +01:00
|
|
|
|
2021-04-05 17:30:52 +02:00
|
|
|
ctx.HTML(http.StatusOK, orCtx.NewTemplate)
|
2015-12-05 19:24:13 +01:00
|
|
|
}
|
|
|
|
|
2021-11-10 06:13:16 +01:00
|
|
|
// ParseHookEvent convert web form content to webhook.HookEvent
|
2023-01-01 16:23:15 +01:00
|
|
|
func ParseHookEvent(form forms.WebhookForm) *webhook_module.HookEvent {
|
|
|
|
return &webhook_module.HookEvent{
|
2015-12-05 19:24:13 +01:00
|
|
|
PushOnly: form.PushOnly(),
|
|
|
|
SendEverything: form.SendEverything(),
|
|
|
|
ChooseEvents: form.ChooseEvents(),
|
2023-01-01 16:23:15 +01:00
|
|
|
HookEvents: webhook_module.HookEvents{
|
2023-05-25 04:06:27 +02:00
|
|
|
Create: form.Create,
|
|
|
|
Delete: form.Delete,
|
|
|
|
Fork: form.Fork,
|
|
|
|
Issues: form.Issues,
|
|
|
|
IssueAssign: form.IssueAssign,
|
|
|
|
IssueLabel: form.IssueLabel,
|
|
|
|
IssueMilestone: form.IssueMilestone,
|
|
|
|
IssueComment: form.IssueComment,
|
|
|
|
Release: form.Release,
|
|
|
|
Push: form.Push,
|
|
|
|
PullRequest: form.PullRequest,
|
|
|
|
PullRequestAssign: form.PullRequestAssign,
|
|
|
|
PullRequestLabel: form.PullRequestLabel,
|
|
|
|
PullRequestMilestone: form.PullRequestMilestone,
|
|
|
|
PullRequestComment: form.PullRequestComment,
|
|
|
|
PullRequestReview: form.PullRequestReview,
|
|
|
|
PullRequestSync: form.PullRequestSync,
|
|
|
|
PullRequestReviewRequest: form.PullRequestReviewRequest,
|
|
|
|
Wiki: form.Wiki,
|
|
|
|
Repository: form.Repository,
|
|
|
|
Package: form.Package,
|
2015-12-05 19:24:13 +01:00
|
|
|
},
|
2019-09-09 07:48:21 +02:00
|
|
|
BranchFilter: form.BranchFilter,
|
2015-12-05 19:24:13 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-08-23 08:52:35 +02:00
|
|
|
type webhookParams struct {
|
|
|
|
// Type should be imported from webhook package (webhook.XXX)
|
|
|
|
Type string
|
|
|
|
|
2022-08-11 17:48:23 +02:00
|
|
|
URL string
|
|
|
|
ContentType webhook.HookContentType
|
|
|
|
Secret string
|
|
|
|
HTTPMethod string
|
|
|
|
WebhookForm forms.WebhookForm
|
2023-07-04 20:36:08 +02:00
|
|
|
Meta any
|
2022-08-11 17:48:23 +02:00
|
|
|
}
|
|
|
|
|
2022-08-23 08:52:35 +02:00
|
|
|
func createWebhook(ctx *context.Context, params webhookParams) {
|
2017-05-29 09:17:15 +02:00
|
|
|
ctx.Data["Title"] = ctx.Tr("repo.settings.add_webhook")
|
|
|
|
ctx.Data["PageIsSettingsHooks"] = true
|
|
|
|
ctx.Data["PageIsSettingsHooksNew"] = true
|
2023-01-01 16:23:15 +01:00
|
|
|
ctx.Data["Webhook"] = webhook.Webhook{HookEvent: &webhook_module.HookEvent{}}
|
2022-08-11 17:48:23 +02:00
|
|
|
ctx.Data["HookType"] = params.Type
|
2017-05-29 09:17:15 +02:00
|
|
|
|
2023-03-10 15:28:32 +01:00
|
|
|
orCtx, err := getOwnerRepoCtx(ctx)
|
2017-05-29 09:17:15 +02:00
|
|
|
if err != nil {
|
2023-03-10 15:28:32 +01:00
|
|
|
ctx.ServerError("getOwnerRepoCtx", err)
|
2017-05-29 09:17:15 +02:00
|
|
|
return
|
|
|
|
}
|
2021-01-15 00:24:03 +01:00
|
|
|
ctx.Data["BaseLink"] = orCtx.LinkNew
|
2024-03-20 17:39:02 +01:00
|
|
|
ctx.Data["BaseLinkNew"] = orCtx.LinkNew
|
2017-05-29 09:17:15 +02:00
|
|
|
|
|
|
|
if ctx.HasError() {
|
2024-03-20 17:39:02 +01:00
|
|
|
ctx.HTML(http.StatusUnprocessableEntity, orCtx.NewTemplate)
|
2017-05-29 09:17:15 +02:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2022-08-11 17:48:23 +02:00
|
|
|
var meta []byte
|
|
|
|
if params.Meta != nil {
|
|
|
|
meta, err = json.Marshal(params.Meta)
|
|
|
|
if err != nil {
|
|
|
|
ctx.ServerError("Marshal", err)
|
|
|
|
return
|
|
|
|
}
|
2017-05-29 09:17:15 +02:00
|
|
|
}
|
|
|
|
|
2021-11-10 06:13:16 +01:00
|
|
|
w := &webhook.Webhook{
|
2020-03-08 23:08:05 +01:00
|
|
|
RepoID: orCtx.RepoID,
|
2022-08-11 17:48:23 +02:00
|
|
|
URL: params.URL,
|
|
|
|
HTTPMethod: params.HTTPMethod,
|
|
|
|
ContentType: params.ContentType,
|
|
|
|
Secret: params.Secret,
|
|
|
|
HookEvent: ParseHookEvent(params.WebhookForm),
|
|
|
|
IsActive: params.WebhookForm.Active,
|
|
|
|
Type: params.Type,
|
|
|
|
Meta: string(meta),
|
2023-03-10 15:28:32 +01:00
|
|
|
OwnerID: orCtx.OwnerID,
|
2020-03-08 23:08:05 +01:00
|
|
|
IsSystemWebhook: orCtx.IsSystemWebhook,
|
2017-05-29 09:17:15 +02:00
|
|
|
}
|
2022-11-03 19:23:20 +01:00
|
|
|
err = w.SetHeaderAuthorization(params.WebhookForm.AuthorizationHeader)
|
|
|
|
if err != nil {
|
|
|
|
ctx.ServerError("SetHeaderAuthorization", err)
|
|
|
|
return
|
|
|
|
}
|
2017-05-29 09:17:15 +02:00
|
|
|
if err := w.UpdateEvent(); err != nil {
|
2018-01-10 22:34:17 +01:00
|
|
|
ctx.ServerError("UpdateEvent", err)
|
2017-05-29 09:17:15 +02:00
|
|
|
return
|
2022-03-22 16:22:54 +01:00
|
|
|
} else if err := webhook.CreateWebhook(ctx, w); err != nil {
|
2018-01-10 22:34:17 +01:00
|
|
|
ctx.ServerError("CreateWebhook", err)
|
2017-05-29 09:17:15 +02:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx.Flash.Success(ctx.Tr("repo.settings.add_hook_success"))
|
2019-03-19 03:33:20 +01:00
|
|
|
ctx.Redirect(orCtx.Link)
|
2017-05-29 09:17:15 +02:00
|
|
|
}
|
|
|
|
|
2022-08-23 08:52:35 +02:00
|
|
|
func editWebhook(ctx *context.Context, params webhookParams) {
|
|
|
|
ctx.Data["Title"] = ctx.Tr("repo.settings.update_webhook")
|
|
|
|
ctx.Data["PageIsSettingsHooks"] = true
|
|
|
|
ctx.Data["PageIsSettingsHooksEdit"] = true
|
|
|
|
|
|
|
|
orCtx, w := checkWebhook(ctx)
|
|
|
|
if ctx.Written() {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
ctx.Data["Webhook"] = w
|
|
|
|
|
|
|
|
if ctx.HasError() {
|
2024-03-20 17:39:02 +01:00
|
|
|
ctx.HTML(http.StatusUnprocessableEntity, orCtx.NewTemplate)
|
2022-08-23 08:52:35 +02:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
var meta []byte
|
|
|
|
var err error
|
|
|
|
if params.Meta != nil {
|
|
|
|
meta, err = json.Marshal(params.Meta)
|
|
|
|
if err != nil {
|
|
|
|
ctx.ServerError("Marshal", err)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
w.URL = params.URL
|
|
|
|
w.ContentType = params.ContentType
|
|
|
|
w.Secret = params.Secret
|
|
|
|
w.HookEvent = ParseHookEvent(params.WebhookForm)
|
|
|
|
w.IsActive = params.WebhookForm.Active
|
|
|
|
w.HTTPMethod = params.HTTPMethod
|
|
|
|
w.Meta = string(meta)
|
|
|
|
|
2022-11-03 19:23:20 +01:00
|
|
|
err = w.SetHeaderAuthorization(params.WebhookForm.AuthorizationHeader)
|
|
|
|
if err != nil {
|
|
|
|
ctx.ServerError("SetHeaderAuthorization", err)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2022-08-23 08:52:35 +02:00
|
|
|
if err := w.UpdateEvent(); err != nil {
|
|
|
|
ctx.ServerError("UpdateEvent", err)
|
|
|
|
return
|
2023-10-14 10:37:24 +02:00
|
|
|
} else if err := webhook.UpdateWebhook(ctx, w); err != nil {
|
2022-08-23 08:52:35 +02:00
|
|
|
ctx.ServerError("UpdateWebhook", err)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx.Flash.Success(ctx.Tr("repo.settings.update_hook_success"))
|
|
|
|
ctx.Redirect(fmt.Sprintf("%s/%d", orCtx.Link, w.ID))
|
|
|
|
}
|
|
|
|
|
2023-01-14 10:07:01 +01:00
|
|
|
// ForgejoHooksNewPost response for creating Forgejo webhook
|
|
|
|
func ForgejoHooksNewPost(ctx *context.Context) {
|
|
|
|
createWebhook(ctx, forgejoHookParams(ctx))
|
|
|
|
}
|
|
|
|
|
|
|
|
// ForgejoHooksEditPost response for editing Forgejo webhook
|
|
|
|
func ForgejoHooksEditPost(ctx *context.Context) {
|
|
|
|
editWebhook(ctx, forgejoHookParams(ctx))
|
|
|
|
}
|
|
|
|
|
|
|
|
func forgejoHookParams(ctx *context.Context) webhookParams {
|
|
|
|
form := web.GetForm(ctx).(*forms.NewWebhookForm)
|
|
|
|
|
|
|
|
contentType := webhook.ContentTypeJSON
|
|
|
|
if webhook.HookContentType(form.ContentType) == webhook.ContentTypeForm {
|
|
|
|
contentType = webhook.ContentTypeForm
|
|
|
|
}
|
|
|
|
|
|
|
|
return webhookParams{
|
|
|
|
Type: webhook_module.FORGEJO,
|
|
|
|
URL: form.PayloadURL,
|
|
|
|
ContentType: contentType,
|
|
|
|
Secret: form.Secret,
|
|
|
|
HTTPMethod: form.HTTPMethod,
|
|
|
|
WebhookForm: form.WebhookForm,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-08-11 17:48:23 +02:00
|
|
|
// GiteaHooksNewPost response for creating Gitea webhook
|
|
|
|
func GiteaHooksNewPost(ctx *context.Context) {
|
2022-08-23 08:52:35 +02:00
|
|
|
createWebhook(ctx, giteaHookParams(ctx))
|
|
|
|
}
|
|
|
|
|
|
|
|
// GiteaHooksEditPost response for editing Gitea webhook
|
|
|
|
func GiteaHooksEditPost(ctx *context.Context) {
|
|
|
|
editWebhook(ctx, giteaHookParams(ctx))
|
|
|
|
}
|
|
|
|
|
|
|
|
func giteaHookParams(ctx *context.Context) webhookParams {
|
2022-08-11 17:48:23 +02:00
|
|
|
form := web.GetForm(ctx).(*forms.NewWebhookForm)
|
2015-12-05 19:24:13 +01:00
|
|
|
|
2022-08-11 17:48:23 +02:00
|
|
|
contentType := webhook.ContentTypeJSON
|
|
|
|
if webhook.HookContentType(form.ContentType) == webhook.ContentTypeForm {
|
|
|
|
contentType = webhook.ContentTypeForm
|
2015-12-05 19:24:13 +01:00
|
|
|
}
|
|
|
|
|
2022-08-23 08:52:35 +02:00
|
|
|
return webhookParams{
|
2023-01-01 16:23:15 +01:00
|
|
|
Type: webhook_module.GITEA,
|
2022-08-11 17:48:23 +02:00
|
|
|
URL: form.PayloadURL,
|
|
|
|
ContentType: contentType,
|
|
|
|
Secret: form.Secret,
|
|
|
|
HTTPMethod: form.HTTPMethod,
|
|
|
|
WebhookForm: form.WebhookForm,
|
2022-08-23 08:52:35 +02:00
|
|
|
}
|
2022-08-11 17:48:23 +02:00
|
|
|
}
|
|
|
|
|
2022-08-23 08:52:35 +02:00
|
|
|
// GogsHooksNewPost response for creating Gogs webhook
|
2022-08-11 17:48:23 +02:00
|
|
|
func GogsHooksNewPost(ctx *context.Context) {
|
2022-08-23 08:52:35 +02:00
|
|
|
createWebhook(ctx, gogsHookParams(ctx))
|
|
|
|
}
|
|
|
|
|
|
|
|
// GogsHooksEditPost response for editing Gogs webhook
|
|
|
|
func GogsHooksEditPost(ctx *context.Context) {
|
|
|
|
editWebhook(ctx, gogsHookParams(ctx))
|
|
|
|
}
|
|
|
|
|
|
|
|
func gogsHookParams(ctx *context.Context) webhookParams {
|
2022-08-11 17:48:23 +02:00
|
|
|
form := web.GetForm(ctx).(*forms.NewGogshookForm)
|
2015-12-05 19:24:13 +01:00
|
|
|
|
2021-11-10 06:13:16 +01:00
|
|
|
contentType := webhook.ContentTypeJSON
|
|
|
|
if webhook.HookContentType(form.ContentType) == webhook.ContentTypeForm {
|
|
|
|
contentType = webhook.ContentTypeForm
|
2015-12-05 19:24:13 +01:00
|
|
|
}
|
|
|
|
|
2022-08-23 08:52:35 +02:00
|
|
|
return webhookParams{
|
2023-01-01 16:23:15 +01:00
|
|
|
Type: webhook_module.GOGS,
|
2022-08-11 17:48:23 +02:00
|
|
|
URL: form.PayloadURL,
|
|
|
|
ContentType: contentType,
|
|
|
|
Secret: form.Secret,
|
|
|
|
WebhookForm: form.WebhookForm,
|
2022-08-23 08:52:35 +02:00
|
|
|
}
|
2015-12-05 19:24:13 +01:00
|
|
|
}
|
|
|
|
|
2022-08-23 08:52:35 +02:00
|
|
|
// DiscordHooksNewPost response for creating Discord webhook
|
2021-01-26 16:36:53 +01:00
|
|
|
func DiscordHooksNewPost(ctx *context.Context) {
|
2022-08-23 08:52:35 +02:00
|
|
|
createWebhook(ctx, discordHookParams(ctx))
|
|
|
|
}
|
|
|
|
|
|
|
|
// DiscordHooksEditPost response for editing Discord webhook
|
|
|
|
func DiscordHooksEditPost(ctx *context.Context) {
|
|
|
|
editWebhook(ctx, discordHookParams(ctx))
|
|
|
|
}
|
|
|
|
|
|
|
|
func discordHookParams(ctx *context.Context) webhookParams {
|
2021-04-06 21:44:05 +02:00
|
|
|
form := web.GetForm(ctx).(*forms.NewDiscordHookForm)
|
2017-08-28 07:06:45 +02:00
|
|
|
|
2022-08-23 08:52:35 +02:00
|
|
|
return webhookParams{
|
2023-01-01 16:23:15 +01:00
|
|
|
Type: webhook_module.DISCORD,
|
2022-08-11 17:48:23 +02:00
|
|
|
URL: form.PayloadURL,
|
|
|
|
ContentType: webhook.ContentTypeJSON,
|
|
|
|
WebhookForm: form.WebhookForm,
|
|
|
|
Meta: &webhook_service.DiscordMeta{
|
|
|
|
Username: form.Username,
|
|
|
|
IconURL: form.IconURL,
|
|
|
|
},
|
2022-08-23 08:52:35 +02:00
|
|
|
}
|
2017-08-28 07:06:45 +02:00
|
|
|
}
|
|
|
|
|
2022-08-23 08:52:35 +02:00
|
|
|
// DingtalkHooksNewPost response for creating Dingtalk webhook
|
2021-01-26 16:36:53 +01:00
|
|
|
func DingtalkHooksNewPost(ctx *context.Context) {
|
2022-08-23 08:52:35 +02:00
|
|
|
createWebhook(ctx, dingtalkHookParams(ctx))
|
|
|
|
}
|
|
|
|
|
|
|
|
// DingtalkHooksEditPost response for editing Dingtalk webhook
|
|
|
|
func DingtalkHooksEditPost(ctx *context.Context) {
|
|
|
|
editWebhook(ctx, dingtalkHookParams(ctx))
|
|
|
|
}
|
|
|
|
|
|
|
|
func dingtalkHookParams(ctx *context.Context) webhookParams {
|
2021-04-06 21:44:05 +02:00
|
|
|
form := web.GetForm(ctx).(*forms.NewDingtalkHookForm)
|
2017-11-21 05:26:43 +01:00
|
|
|
|
2022-08-23 08:52:35 +02:00
|
|
|
return webhookParams{
|
2023-01-01 16:23:15 +01:00
|
|
|
Type: webhook_module.DINGTALK,
|
2022-08-11 17:48:23 +02:00
|
|
|
URL: form.PayloadURL,
|
|
|
|
ContentType: webhook.ContentTypeJSON,
|
|
|
|
WebhookForm: form.WebhookForm,
|
2022-08-23 08:52:35 +02:00
|
|
|
}
|
2017-11-21 05:26:43 +01:00
|
|
|
}
|
|
|
|
|
2022-08-23 08:52:35 +02:00
|
|
|
// TelegramHooksNewPost response for creating Telegram webhook
|
2021-01-26 16:36:53 +01:00
|
|
|
func TelegramHooksNewPost(ctx *context.Context) {
|
2022-08-23 08:52:35 +02:00
|
|
|
createWebhook(ctx, telegramHookParams(ctx))
|
|
|
|
}
|
|
|
|
|
|
|
|
// TelegramHooksEditPost response for editing Telegram webhook
|
|
|
|
func TelegramHooksEditPost(ctx *context.Context) {
|
|
|
|
editWebhook(ctx, telegramHookParams(ctx))
|
|
|
|
}
|
|
|
|
|
|
|
|
func telegramHookParams(ctx *context.Context) webhookParams {
|
2021-04-06 21:44:05 +02:00
|
|
|
form := web.GetForm(ctx).(*forms.NewTelegramHookForm)
|
2019-04-19 04:45:02 +02:00
|
|
|
|
2022-08-23 08:52:35 +02:00
|
|
|
return webhookParams{
|
2023-01-01 16:23:15 +01:00
|
|
|
Type: webhook_module.TELEGRAM,
|
2023-08-13 16:00:06 +02:00
|
|
|
URL: fmt.Sprintf("https://api.telegram.org/bot%s/sendMessage?chat_id=%s&message_thread_id=%s", url.PathEscape(form.BotToken), url.QueryEscape(form.ChatID), url.QueryEscape(form.ThreadID)),
|
2022-08-11 17:48:23 +02:00
|
|
|
ContentType: webhook.ContentTypeJSON,
|
|
|
|
WebhookForm: form.WebhookForm,
|
|
|
|
Meta: &webhook_service.TelegramMeta{
|
|
|
|
BotToken: form.BotToken,
|
|
|
|
ChatID: form.ChatID,
|
2023-08-13 16:00:06 +02:00
|
|
|
ThreadID: form.ThreadID,
|
2022-08-11 17:48:23 +02:00
|
|
|
},
|
2022-08-23 08:52:35 +02:00
|
|
|
}
|
2019-04-19 04:45:02 +02:00
|
|
|
}
|
|
|
|
|
2022-08-23 08:52:35 +02:00
|
|
|
// MatrixHooksNewPost response for creating Matrix webhook
|
2021-01-26 16:36:53 +01:00
|
|
|
func MatrixHooksNewPost(ctx *context.Context) {
|
2022-08-23 08:52:35 +02:00
|
|
|
createWebhook(ctx, matrixHookParams(ctx))
|
|
|
|
}
|
|
|
|
|
|
|
|
// MatrixHooksEditPost response for editing Matrix webhook
|
|
|
|
func MatrixHooksEditPost(ctx *context.Context) {
|
|
|
|
editWebhook(ctx, matrixHookParams(ctx))
|
|
|
|
}
|
|
|
|
|
|
|
|
func matrixHookParams(ctx *context.Context) webhookParams {
|
2021-04-06 21:44:05 +02:00
|
|
|
form := web.GetForm(ctx).(*forms.NewMatrixHookForm)
|
2020-03-28 14:09:55 +01:00
|
|
|
|
2022-08-23 08:52:35 +02:00
|
|
|
return webhookParams{
|
2023-01-01 16:23:15 +01:00
|
|
|
Type: webhook_module.MATRIX,
|
2022-08-11 17:48:23 +02:00
|
|
|
URL: fmt.Sprintf("%s/_matrix/client/r0/rooms/%s/send/m.room.message", form.HomeserverURL, url.PathEscape(form.RoomID)),
|
|
|
|
ContentType: webhook.ContentTypeJSON,
|
|
|
|
HTTPMethod: http.MethodPut,
|
|
|
|
WebhookForm: form.WebhookForm,
|
|
|
|
Meta: &webhook_service.MatrixMeta{
|
|
|
|
HomeserverURL: form.HomeserverURL,
|
|
|
|
Room: form.RoomID,
|
|
|
|
MessageType: form.MessageType,
|
|
|
|
},
|
2022-08-23 08:52:35 +02:00
|
|
|
}
|
2020-03-28 14:09:55 +01:00
|
|
|
}
|
|
|
|
|
2022-08-23 08:52:35 +02:00
|
|
|
// MSTeamsHooksNewPost response for creating MSTeams webhook
|
2021-01-26 16:36:53 +01:00
|
|
|
func MSTeamsHooksNewPost(ctx *context.Context) {
|
2022-08-23 08:52:35 +02:00
|
|
|
createWebhook(ctx, mSTeamsHookParams(ctx))
|
|
|
|
}
|
|
|
|
|
|
|
|
// MSTeamsHooksEditPost response for editing MSTeams webhook
|
|
|
|
func MSTeamsHooksEditPost(ctx *context.Context) {
|
|
|
|
editWebhook(ctx, mSTeamsHookParams(ctx))
|
|
|
|
}
|
|
|
|
|
|
|
|
func mSTeamsHookParams(ctx *context.Context) webhookParams {
|
2021-04-06 21:44:05 +02:00
|
|
|
form := web.GetForm(ctx).(*forms.NewMSTeamsHookForm)
|
2019-04-19 16:18:06 +02:00
|
|
|
|
2022-08-23 08:52:35 +02:00
|
|
|
return webhookParams{
|
2023-01-01 16:23:15 +01:00
|
|
|
Type: webhook_module.MSTEAMS,
|
2022-08-11 17:48:23 +02:00
|
|
|
URL: form.PayloadURL,
|
|
|
|
ContentType: webhook.ContentTypeJSON,
|
|
|
|
WebhookForm: form.WebhookForm,
|
2022-08-23 08:52:35 +02:00
|
|
|
}
|
2019-04-19 16:18:06 +02:00
|
|
|
}
|
|
|
|
|
2022-08-23 08:52:35 +02:00
|
|
|
// SlackHooksNewPost response for creating Slack webhook
|
2021-01-26 16:36:53 +01:00
|
|
|
func SlackHooksNewPost(ctx *context.Context) {
|
2022-08-23 08:52:35 +02:00
|
|
|
createWebhook(ctx, slackHookParams(ctx))
|
|
|
|
}
|
|
|
|
|
|
|
|
// SlackHooksEditPost response for editing Slack webhook
|
|
|
|
func SlackHooksEditPost(ctx *context.Context) {
|
|
|
|
editWebhook(ctx, slackHookParams(ctx))
|
|
|
|
}
|
|
|
|
|
|
|
|
func slackHookParams(ctx *context.Context) webhookParams {
|
2021-04-06 21:44:05 +02:00
|
|
|
form := web.GetForm(ctx).(*forms.NewSlackHookForm)
|
2015-12-05 19:24:13 +01:00
|
|
|
|
2022-08-23 08:52:35 +02:00
|
|
|
return webhookParams{
|
2023-01-01 16:23:15 +01:00
|
|
|
Type: webhook_module.SLACK,
|
2022-08-11 17:48:23 +02:00
|
|
|
URL: form.PayloadURL,
|
|
|
|
ContentType: webhook.ContentTypeJSON,
|
|
|
|
WebhookForm: form.WebhookForm,
|
|
|
|
Meta: &webhook_service.SlackMeta{
|
|
|
|
Channel: strings.TrimSpace(form.Channel),
|
|
|
|
Username: form.Username,
|
|
|
|
IconURL: form.IconURL,
|
|
|
|
Color: form.Color,
|
|
|
|
},
|
2022-08-23 08:52:35 +02:00
|
|
|
}
|
2015-12-05 19:24:13 +01:00
|
|
|
}
|
|
|
|
|
2022-08-23 08:52:35 +02:00
|
|
|
// FeishuHooksNewPost response for creating Feishu webhook
|
2021-01-26 16:36:53 +01:00
|
|
|
func FeishuHooksNewPost(ctx *context.Context) {
|
2022-08-23 08:52:35 +02:00
|
|
|
createWebhook(ctx, feishuHookParams(ctx))
|
|
|
|
}
|
|
|
|
|
|
|
|
// FeishuHooksEditPost response for editing Feishu webhook
|
|
|
|
func FeishuHooksEditPost(ctx *context.Context) {
|
|
|
|
editWebhook(ctx, feishuHookParams(ctx))
|
|
|
|
}
|
|
|
|
|
|
|
|
func feishuHookParams(ctx *context.Context) webhookParams {
|
2021-04-06 21:44:05 +02:00
|
|
|
form := web.GetForm(ctx).(*forms.NewFeishuHookForm)
|
2020-02-12 09:48:28 +01:00
|
|
|
|
2022-08-23 08:52:35 +02:00
|
|
|
return webhookParams{
|
2023-01-01 16:23:15 +01:00
|
|
|
Type: webhook_module.FEISHU,
|
2022-08-11 17:48:23 +02:00
|
|
|
URL: form.PayloadURL,
|
|
|
|
ContentType: webhook.ContentTypeJSON,
|
|
|
|
WebhookForm: form.WebhookForm,
|
2022-08-23 08:52:35 +02:00
|
|
|
}
|
2020-02-12 09:48:28 +01:00
|
|
|
}
|
|
|
|
|
2022-08-23 08:52:35 +02:00
|
|
|
// WechatworkHooksNewPost response for creating Wechatwork webhook
|
2021-07-23 06:41:27 +02:00
|
|
|
func WechatworkHooksNewPost(ctx *context.Context) {
|
2022-08-23 08:52:35 +02:00
|
|
|
createWebhook(ctx, wechatworkHookParams(ctx))
|
|
|
|
}
|
|
|
|
|
|
|
|
// WechatworkHooksEditPost response for editing Wechatwork webhook
|
|
|
|
func WechatworkHooksEditPost(ctx *context.Context) {
|
|
|
|
editWebhook(ctx, wechatworkHookParams(ctx))
|
|
|
|
}
|
|
|
|
|
|
|
|
func wechatworkHookParams(ctx *context.Context) webhookParams {
|
2021-07-23 06:41:27 +02:00
|
|
|
form := web.GetForm(ctx).(*forms.NewWechatWorkHookForm)
|
|
|
|
|
2022-08-23 08:52:35 +02:00
|
|
|
return webhookParams{
|
2023-01-01 16:23:15 +01:00
|
|
|
Type: webhook_module.WECHATWORK,
|
2022-08-11 17:48:23 +02:00
|
|
|
URL: form.PayloadURL,
|
|
|
|
ContentType: webhook.ContentTypeJSON,
|
|
|
|
WebhookForm: form.WebhookForm,
|
2022-08-23 08:52:35 +02:00
|
|
|
}
|
2021-07-23 06:41:27 +02:00
|
|
|
}
|
|
|
|
|
2022-08-23 08:52:35 +02:00
|
|
|
// PackagistHooksNewPost response for creating Packagist webhook
|
2022-01-23 14:46:30 +01:00
|
|
|
func PackagistHooksNewPost(ctx *context.Context) {
|
2022-08-23 08:52:35 +02:00
|
|
|
createWebhook(ctx, packagistHookParams(ctx))
|
|
|
|
}
|
|
|
|
|
|
|
|
// PackagistHooksEditPost response for editing Packagist webhook
|
|
|
|
func PackagistHooksEditPost(ctx *context.Context) {
|
|
|
|
editWebhook(ctx, packagistHookParams(ctx))
|
|
|
|
}
|
|
|
|
|
|
|
|
func packagistHookParams(ctx *context.Context) webhookParams {
|
2022-01-23 14:46:30 +01:00
|
|
|
form := web.GetForm(ctx).(*forms.NewPackagistHookForm)
|
|
|
|
|
2022-08-23 08:52:35 +02:00
|
|
|
return webhookParams{
|
2023-01-01 16:23:15 +01:00
|
|
|
Type: webhook_module.PACKAGIST,
|
2022-08-11 17:48:23 +02:00
|
|
|
URL: fmt.Sprintf("https://packagist.org/api/update-package?username=%s&apiToken=%s", url.QueryEscape(form.Username), url.QueryEscape(form.APIToken)),
|
|
|
|
ContentType: webhook.ContentTypeJSON,
|
|
|
|
WebhookForm: form.WebhookForm,
|
|
|
|
Meta: &webhook_service.PackagistMeta{
|
|
|
|
Username: form.Username,
|
|
|
|
APIToken: form.APIToken,
|
|
|
|
PackageURL: form.PackageURL,
|
|
|
|
},
|
2022-08-23 08:52:35 +02:00
|
|
|
}
|
2022-01-23 14:46:30 +01:00
|
|
|
}
|
|
|
|
|
2023-03-10 15:28:32 +01:00
|
|
|
func checkWebhook(ctx *context.Context) (*ownerRepoCtx, *webhook.Webhook) {
|
|
|
|
orCtx, err := getOwnerRepoCtx(ctx)
|
2015-12-05 19:24:13 +01:00
|
|
|
if err != nil {
|
2023-03-10 15:28:32 +01:00
|
|
|
ctx.ServerError("getOwnerRepoCtx", err)
|
2015-12-05 19:24:13 +01:00
|
|
|
return nil, nil
|
|
|
|
}
|
|
|
|
ctx.Data["BaseLink"] = orCtx.Link
|
2024-03-14 02:37:15 +01:00
|
|
|
ctx.Data["BaseLinkNew"] = orCtx.LinkNew
|
2015-12-05 19:24:13 +01:00
|
|
|
|
2021-11-10 06:13:16 +01:00
|
|
|
var w *webhook.Webhook
|
2016-07-15 19:02:55 +02:00
|
|
|
if orCtx.RepoID > 0 {
|
2023-10-14 10:37:24 +02:00
|
|
|
w, err = webhook.GetWebhookByRepoID(ctx, orCtx.RepoID, ctx.ParamsInt64(":id"))
|
2023-03-10 15:28:32 +01:00
|
|
|
} else if orCtx.OwnerID > 0 {
|
2023-10-14 10:37:24 +02:00
|
|
|
w, err = webhook.GetWebhookByOwnerID(ctx, orCtx.OwnerID, ctx.ParamsInt64(":id"))
|
2021-01-15 00:24:03 +01:00
|
|
|
} else if orCtx.IsAdmin {
|
2023-01-28 19:12:10 +01:00
|
|
|
w, err = webhook.GetSystemOrDefaultWebhook(ctx, ctx.ParamsInt64(":id"))
|
2016-07-15 19:02:55 +02:00
|
|
|
}
|
2021-01-15 00:24:03 +01:00
|
|
|
if err != nil || w == nil {
|
2021-11-10 06:13:16 +01:00
|
|
|
if webhook.IsErrWebhookNotExist(err) {
|
2018-01-10 22:34:17 +01:00
|
|
|
ctx.NotFound("GetWebhookByID", nil)
|
2015-12-05 19:24:13 +01:00
|
|
|
} else {
|
2018-01-10 22:34:17 +01:00
|
|
|
ctx.ServerError("GetWebhookByID", err)
|
2015-12-05 19:24:13 +01:00
|
|
|
}
|
|
|
|
return nil, nil
|
|
|
|
}
|
|
|
|
|
2020-12-09 18:20:13 +01:00
|
|
|
ctx.Data["HookType"] = w.Type
|
2024-03-20 15:44:01 +01:00
|
|
|
|
|
|
|
if handler := webhook_service.GetWebhookHandler(w.Type); handler != nil {
|
|
|
|
ctx.Data["HookMetadata"] = handler.Metadata(w)
|
2015-12-05 19:24:13 +01:00
|
|
|
}
|
|
|
|
|
2023-10-14 10:37:24 +02:00
|
|
|
ctx.Data["History"], err = w.History(ctx, 1)
|
2015-12-05 19:24:13 +01:00
|
|
|
if err != nil {
|
2018-01-10 22:34:17 +01:00
|
|
|
ctx.ServerError("History", err)
|
2015-12-05 19:24:13 +01:00
|
|
|
}
|
|
|
|
return orCtx, w
|
|
|
|
}
|
|
|
|
|
2016-11-24 08:04:31 +01:00
|
|
|
// WebHooksEdit render editing web hook page
|
2016-03-11 17:56:52 +01:00
|
|
|
func WebHooksEdit(ctx *context.Context) {
|
2015-12-05 19:24:13 +01:00
|
|
|
ctx.Data["Title"] = ctx.Tr("repo.settings.update_webhook")
|
|
|
|
ctx.Data["PageIsSettingsHooks"] = true
|
|
|
|
ctx.Data["PageIsSettingsHooksEdit"] = true
|
|
|
|
|
|
|
|
orCtx, w := checkWebhook(ctx)
|
|
|
|
if ctx.Written() {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
ctx.Data["Webhook"] = w
|
|
|
|
|
2021-04-05 17:30:52 +02:00
|
|
|
ctx.HTML(http.StatusOK, orCtx.NewTemplate)
|
2015-12-05 19:24:13 +01:00
|
|
|
}
|
|
|
|
|
2016-11-24 08:04:31 +01:00
|
|
|
// TestWebhook test if web hook is work fine
|
2016-03-11 17:56:52 +01:00
|
|
|
func TestWebhook(ctx *context.Context) {
|
2017-08-29 16:55:24 +02:00
|
|
|
hookID := ctx.ParamsInt64(":id")
|
2023-10-14 10:37:24 +02:00
|
|
|
w, err := webhook.GetWebhookByRepoID(ctx, ctx.Repo.Repository.ID, hookID)
|
2017-08-29 16:55:24 +02:00
|
|
|
if err != nil {
|
2022-10-21 18:21:56 +02:00
|
|
|
ctx.Flash.Error("GetWebhookByRepoID: " + err.Error())
|
2022-03-23 05:54:07 +01:00
|
|
|
ctx.Status(http.StatusInternalServerError)
|
2017-08-29 16:55:24 +02:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2016-08-15 14:53:47 +02:00
|
|
|
// Grab latest commit or fake one if it's empty repository.
|
|
|
|
commit := ctx.Repo.Commit
|
|
|
|
if commit == nil {
|
2021-11-24 10:49:20 +01:00
|
|
|
ghost := user_model.NewGhostUser()
|
2024-03-10 22:30:36 +01:00
|
|
|
objectFormat := git.ObjectFormatFromName(ctx.Repo.Repository.ObjectFormatName)
|
2016-08-15 14:53:47 +02:00
|
|
|
commit = &git.Commit{
|
2023-12-17 12:56:08 +01:00
|
|
|
ID: objectFormat.EmptyObjectID(),
|
2016-08-15 14:53:47 +02:00
|
|
|
Author: ghost.NewGitSig(),
|
|
|
|
Committer: ghost.NewGitSig(),
|
|
|
|
CommitMessage: "This is a fake commit",
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
Add context cache as a request level cache (#22294)
To avoid duplicated load of the same data in an HTTP request, we can set
a context cache to do that. i.e. Some pages may load a user from a
database with the same id in different areas on the same page. But the
code is hidden in two different deep logic. How should we share the
user? As a result of this PR, now if both entry functions accept
`context.Context` as the first parameter and we just need to refactor
`GetUserByID` to reuse the user from the context cache. Then it will not
be loaded twice on an HTTP request.
But of course, sometimes we would like to reload an object from the
database, that's why `RemoveContextData` is also exposed.
The core context cache is here. It defines a new context
```go
type cacheContext struct {
ctx context.Context
data map[any]map[any]any
lock sync.RWMutex
}
var cacheContextKey = struct{}{}
func WithCacheContext(ctx context.Context) context.Context {
return context.WithValue(ctx, cacheContextKey, &cacheContext{
ctx: ctx,
data: make(map[any]map[any]any),
})
}
```
Then you can use the below 4 methods to read/write/del the data within
the same context.
```go
func GetContextData(ctx context.Context, tp, key any) any
func SetContextData(ctx context.Context, tp, key, value any)
func RemoveContextData(ctx context.Context, tp, key any)
func GetWithContextCache[T any](ctx context.Context, cacheGroupKey string, cacheTargetID any, f func() (T, error)) (T, error)
```
Then let's take a look at how `system.GetString` implement it.
```go
func GetSetting(ctx context.Context, key string) (string, error) {
return cache.GetWithContextCache(ctx, contextCacheKey, key, func() (string, error) {
return cache.GetString(genSettingCacheKey(key), func() (string, error) {
res, err := GetSettingNoCache(ctx, key)
if err != nil {
return "", err
}
return res.SettingValue, nil
})
})
}
```
First, it will check if context data include the setting object with the
key. If not, it will query from the global cache which may be memory or
a Redis cache. If not, it will get the object from the database. In the
end, if the object gets from the global cache or database, it will be
set into the context cache.
An object stored in the context cache will only be destroyed after the
context disappeared.
2023-02-15 14:37:34 +01:00
|
|
|
apiUser := convert.ToUserWithAccessMode(ctx, ctx.Doer, perm.AccessModeNone)
|
2021-06-29 15:34:03 +02:00
|
|
|
|
|
|
|
apiCommit := &api.PayloadCommit{
|
|
|
|
ID: commit.ID.String(),
|
|
|
|
Message: commit.Message(),
|
2021-11-16 19:18:25 +01:00
|
|
|
URL: ctx.Repo.Repository.HTMLURL() + "/commit/" + url.PathEscape(commit.ID.String()),
|
2021-06-29 15:34:03 +02:00
|
|
|
Author: &api.PayloadUser{
|
|
|
|
Name: commit.Author.Name,
|
|
|
|
Email: commit.Author.Email,
|
|
|
|
},
|
|
|
|
Committer: &api.PayloadUser{
|
|
|
|
Name: commit.Committer.Name,
|
|
|
|
Email: commit.Committer.Email,
|
2015-12-05 19:24:13 +01:00
|
|
|
},
|
2021-06-29 15:34:03 +02:00
|
|
|
}
|
|
|
|
|
2022-09-04 11:18:07 +02:00
|
|
|
commitID := commit.ID.String()
|
2021-06-29 15:34:03 +02:00
|
|
|
p := &api.PushPayload{
|
2022-10-16 18:22:34 +02:00
|
|
|
Ref: git.BranchPrefix + ctx.Repo.Repository.DefaultBranch,
|
|
|
|
Before: commitID,
|
|
|
|
After: commitID,
|
|
|
|
CompareURL: setting.AppURL + ctx.Repo.Repository.ComposeCompareURL(commitID, commitID),
|
|
|
|
Commits: []*api.PayloadCommit{apiCommit},
|
|
|
|
TotalCommits: 1,
|
|
|
|
HeadCommit: apiCommit,
|
2023-06-22 15:08:08 +02:00
|
|
|
Repo: convert.ToRepo(ctx, ctx.Repo.Repository, access_model.Permission{AccessMode: perm.AccessModeNone}),
|
2022-10-16 18:22:34 +02:00
|
|
|
Pusher: apiUser,
|
|
|
|
Sender: apiUser,
|
2015-12-05 19:24:13 +01:00
|
|
|
}
|
2023-01-01 16:23:15 +01:00
|
|
|
if err := webhook_service.PrepareWebhook(ctx, w, webhook_module.HookEventPush, p); err != nil {
|
2017-08-29 16:55:24 +02:00
|
|
|
ctx.Flash.Error("PrepareWebhook: " + err.Error())
|
2022-03-23 05:54:07 +01:00
|
|
|
ctx.Status(http.StatusInternalServerError)
|
2015-12-05 19:24:13 +01:00
|
|
|
} else {
|
2022-01-05 22:00:20 +01:00
|
|
|
ctx.Flash.Info(ctx.Tr("repo.settings.webhook.delivery.success"))
|
2022-03-23 05:54:07 +01:00
|
|
|
ctx.Status(http.StatusOK)
|
2015-12-05 19:24:13 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-01-05 22:00:20 +01:00
|
|
|
// ReplayWebhook replays a webhook
|
|
|
|
func ReplayWebhook(ctx *context.Context) {
|
|
|
|
hookTaskUUID := ctx.Params(":uuid")
|
|
|
|
|
|
|
|
orCtx, w := checkWebhook(ctx)
|
|
|
|
if ctx.Written() {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2022-10-21 18:21:56 +02:00
|
|
|
if err := webhook_service.ReplayHookTask(ctx, w, hookTaskUUID); err != nil {
|
2022-01-05 22:00:20 +01:00
|
|
|
if webhook.IsErrHookTaskNotExist(err) {
|
|
|
|
ctx.NotFound("ReplayHookTask", nil)
|
|
|
|
} else {
|
|
|
|
ctx.ServerError("ReplayHookTask", err)
|
|
|
|
}
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx.Flash.Success(ctx.Tr("repo.settings.webhook.delivery.success"))
|
|
|
|
ctx.Redirect(fmt.Sprintf("%s/%d", orCtx.Link, w.ID))
|
|
|
|
}
|
|
|
|
|
2016-11-24 08:04:31 +01:00
|
|
|
// DeleteWebhook delete a webhook
|
2016-03-11 17:56:52 +01:00
|
|
|
func DeleteWebhook(ctx *context.Context) {
|
2023-10-14 10:37:24 +02:00
|
|
|
if err := webhook.DeleteWebhookByRepoID(ctx, ctx.Repo.Repository.ID, ctx.FormInt64("id")); err != nil {
|
2016-07-17 02:33:59 +02:00
|
|
|
ctx.Flash.Error("DeleteWebhookByRepoID: " + err.Error())
|
2015-12-05 19:24:13 +01:00
|
|
|
} else {
|
|
|
|
ctx.Flash.Success(ctx.Tr("repo.settings.webhook_deletion_success"))
|
|
|
|
}
|
|
|
|
|
2023-07-26 08:04:01 +02:00
|
|
|
ctx.JSONRedirect(ctx.Repo.RepoLink + "/settings/hooks")
|
2015-12-05 19:24:13 +01:00
|
|
|
}
|