2014-05-05 19:52:25 -05:00
|
|
|
// Copyright 2014 The Gogs Authors. All rights reserved.
|
2017-05-29 02:17:15 -05:00
|
|
|
// Copyright 2017 The Gitea Authors. All rights reserved.
|
2022-11-27 13:20:29 -05:00
|
|
|
// SPDX-License-Identifier: MIT
|
2014-05-05 19:52:25 -05:00
|
|
|
|
2021-11-10 00:13:16 -05:00
|
|
|
package webhook
|
2014-05-05 19:52:25 -05:00
|
|
|
|
|
|
|
import (
|
2021-01-26 16:02:42 -05:00
|
|
|
"context"
|
2015-08-27 10:06:14 -05:00
|
|
|
"fmt"
|
2020-12-11 11:04:04 -05:00
|
|
|
"strings"
|
2014-05-05 19:52:25 -05:00
|
|
|
|
2021-09-19 06:49:59 -05:00
|
|
|
"code.gitea.io/gitea/models/db"
|
2021-07-24 11:03:58 -05:00
|
|
|
"code.gitea.io/gitea/modules/json"
|
2016-11-10 11:24:48 -05:00
|
|
|
"code.gitea.io/gitea/modules/log"
|
2022-11-03 13:23:20 -05:00
|
|
|
"code.gitea.io/gitea/modules/secret"
|
|
|
|
"code.gitea.io/gitea/modules/setting"
|
2019-08-15 09:46:21 -05:00
|
|
|
"code.gitea.io/gitea/modules/timeutil"
|
2021-08-12 07:43:08 -05:00
|
|
|
"code.gitea.io/gitea/modules/util"
|
2023-01-01 10:23:15 -05:00
|
|
|
webhook_module "code.gitea.io/gitea/modules/webhook"
|
2019-08-15 09:46:21 -05:00
|
|
|
|
2021-08-12 07:43:08 -05:00
|
|
|
"xorm.io/builder"
|
2014-05-05 19:52:25 -05:00
|
|
|
)
|
|
|
|
|
2021-11-10 00:13:16 -05:00
|
|
|
// ErrWebhookNotExist represents a "WebhookNotExist" kind of error.
|
|
|
|
type ErrWebhookNotExist struct {
|
|
|
|
ID int64
|
|
|
|
}
|
|
|
|
|
|
|
|
// IsErrWebhookNotExist checks if an error is a ErrWebhookNotExist.
|
|
|
|
func IsErrWebhookNotExist(err error) bool {
|
|
|
|
_, ok := err.(ErrWebhookNotExist)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrWebhookNotExist) Error() string {
|
|
|
|
return fmt.Sprintf("webhook does not exist [id: %d]", err.ID)
|
|
|
|
}
|
|
|
|
|
2022-10-18 00:50:37 -05:00
|
|
|
func (err ErrWebhookNotExist) Unwrap() error {
|
|
|
|
return util.ErrNotExist
|
|
|
|
}
|
|
|
|
|
2022-01-05 16:00:20 -05:00
|
|
|
// ErrHookTaskNotExist represents a "HookTaskNotExist" kind of error.
|
|
|
|
type ErrHookTaskNotExist struct {
|
2022-10-21 11:21:56 -05:00
|
|
|
TaskID int64
|
2022-01-05 16:00:20 -05:00
|
|
|
HookID int64
|
|
|
|
UUID string
|
|
|
|
}
|
|
|
|
|
2023-01-01 10:23:15 -05:00
|
|
|
// IsErrHookTaskNotExist checks if an error is a ErrHookTaskNotExist.
|
2022-01-05 16:00:20 -05:00
|
|
|
func IsErrHookTaskNotExist(err error) bool {
|
|
|
|
_, ok := err.(ErrHookTaskNotExist)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrHookTaskNotExist) Error() string {
|
2022-10-21 11:21:56 -05:00
|
|
|
return fmt.Sprintf("hook task does not exist [task: %d, hook: %d, uuid: %s]", err.TaskID, err.HookID, err.UUID)
|
2022-01-05 16:00:20 -05:00
|
|
|
}
|
|
|
|
|
2022-10-18 00:50:37 -05:00
|
|
|
func (err ErrHookTaskNotExist) Unwrap() error {
|
|
|
|
return util.ErrNotExist
|
|
|
|
}
|
|
|
|
|
2016-11-22 01:42:52 -05:00
|
|
|
// HookContentType is the content type of a web hook
|
2014-06-08 03:45:34 -05:00
|
|
|
type HookContentType int
|
|
|
|
|
2014-05-05 19:52:25 -05:00
|
|
|
const (
|
2016-11-22 01:42:52 -05:00
|
|
|
// ContentTypeJSON is a JSON payload for web hooks
|
2016-11-07 15:58:22 -05:00
|
|
|
ContentTypeJSON HookContentType = iota + 1
|
2016-11-22 01:42:52 -05:00
|
|
|
// ContentTypeForm is an url-encoded form payload for web hook
|
2016-11-07 11:53:22 -05:00
|
|
|
ContentTypeForm
|
2014-05-05 19:52:25 -05:00
|
|
|
)
|
|
|
|
|
2014-11-13 12:57:00 -05:00
|
|
|
var hookContentTypes = map[string]HookContentType{
|
2016-11-07 15:58:22 -05:00
|
|
|
"json": ContentTypeJSON,
|
2016-11-07 11:53:22 -05:00
|
|
|
"form": ContentTypeForm,
|
2014-11-13 12:57:00 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
// ToHookContentType returns HookContentType by given name.
|
|
|
|
func ToHookContentType(name string) HookContentType {
|
|
|
|
return hookContentTypes[name]
|
|
|
|
}
|
|
|
|
|
2021-01-26 16:02:42 -05:00
|
|
|
// HookTaskCleanupType is the type of cleanup to perform on hook_task
|
|
|
|
type HookTaskCleanupType int
|
|
|
|
|
|
|
|
const (
|
|
|
|
// OlderThan hook_task rows will be cleaned up by the age of the row
|
|
|
|
OlderThan HookTaskCleanupType = iota
|
|
|
|
// PerWebhook hook_task rows will be cleaned up by leaving the most recent deliveries for each webhook
|
|
|
|
PerWebhook
|
|
|
|
)
|
|
|
|
|
|
|
|
var hookTaskCleanupTypes = map[string]HookTaskCleanupType{
|
|
|
|
"OlderThan": OlderThan,
|
|
|
|
"PerWebhook": PerWebhook,
|
|
|
|
}
|
|
|
|
|
|
|
|
// ToHookTaskCleanupType returns HookTaskCleanupType by given name.
|
|
|
|
func ToHookTaskCleanupType(name string) HookTaskCleanupType {
|
|
|
|
return hookTaskCleanupTypes[name]
|
|
|
|
}
|
|
|
|
|
2016-11-22 01:42:52 -05:00
|
|
|
// Name returns the name of a given web hook's content type
|
2014-11-13 02:32:18 -05:00
|
|
|
func (t HookContentType) Name() string {
|
|
|
|
switch t {
|
2016-11-07 15:58:22 -05:00
|
|
|
case ContentTypeJSON:
|
2014-11-13 02:32:18 -05:00
|
|
|
return "json"
|
2016-11-07 11:53:22 -05:00
|
|
|
case ContentTypeForm:
|
2014-11-13 02:32:18 -05:00
|
|
|
return "form"
|
|
|
|
}
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
|
2014-11-13 12:57:00 -05:00
|
|
|
// IsValidHookContentType returns true if given name is a valid hook content type.
|
|
|
|
func IsValidHookContentType(name string) bool {
|
|
|
|
_, ok := hookContentTypes[name]
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
2014-06-08 03:45:34 -05:00
|
|
|
// Webhook represents a web hook object.
|
2014-05-05 19:52:25 -05:00
|
|
|
type Webhook struct {
|
2023-01-01 10:23:15 -05:00
|
|
|
ID int64 `xorm:"pk autoincr"`
|
|
|
|
RepoID int64 `xorm:"INDEX"` // An ID of 0 indicates either a default or system webhook
|
2023-03-10 09:28:32 -05:00
|
|
|
OwnerID int64 `xorm:"INDEX"`
|
2023-01-01 10:23:15 -05:00
|
|
|
IsSystemWebhook bool
|
|
|
|
URL string `xorm:"url TEXT"`
|
|
|
|
HTTPMethod string `xorm:"http_method"`
|
|
|
|
ContentType HookContentType
|
|
|
|
Secret string `xorm:"TEXT"`
|
|
|
|
Events string `xorm:"TEXT"`
|
|
|
|
*webhook_module.HookEvent `xorm:"-"`
|
|
|
|
IsActive bool `xorm:"INDEX"`
|
|
|
|
Type webhook_module.HookType `xorm:"VARCHAR(16) 'type'"`
|
|
|
|
Meta string `xorm:"TEXT"` // store hook-specific attributes
|
|
|
|
LastStatus webhook_module.HookStatus // Last delivery status
|
2016-03-09 19:53:30 -05:00
|
|
|
|
2022-11-03 13:23:20 -05:00
|
|
|
// HeaderAuthorizationEncrypted should be accessed using HeaderAuthorization() and SetHeaderAuthorization()
|
|
|
|
HeaderAuthorizationEncrypted string `xorm:"TEXT"`
|
|
|
|
|
2019-08-15 09:46:21 -05:00
|
|
|
CreatedUnix timeutil.TimeStamp `xorm:"INDEX created"`
|
|
|
|
UpdatedUnix timeutil.TimeStamp `xorm:"INDEX updated"`
|
2014-05-05 19:52:25 -05:00
|
|
|
}
|
|
|
|
|
2021-09-19 06:49:59 -05:00
|
|
|
func init() {
|
|
|
|
db.RegisterModel(new(Webhook))
|
|
|
|
}
|
|
|
|
|
2017-10-01 11:52:35 -05:00
|
|
|
// AfterLoad updates the webhook object upon setting a column
|
|
|
|
func (w *Webhook) AfterLoad() {
|
2023-01-01 10:23:15 -05:00
|
|
|
w.HookEvent = &webhook_module.HookEvent{}
|
2017-10-01 11:52:35 -05:00
|
|
|
if err := json.Unmarshal([]byte(w.Events), w.HookEvent); err != nil {
|
2019-04-02 02:48:31 -05:00
|
|
|
log.Error("Unmarshal[%d]: %v", w.ID, err)
|
2014-05-05 19:52:25 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-08-27 10:06:14 -05:00
|
|
|
// History returns history of webhook by given conditions.
|
2023-10-14 03:37:24 -05:00
|
|
|
func (w *Webhook) History(ctx context.Context, page int) ([]*HookTask, error) {
|
|
|
|
return HookTasks(ctx, w.ID, page)
|
2015-08-27 10:06:14 -05:00
|
|
|
}
|
|
|
|
|
2014-06-08 03:54:52 -05:00
|
|
|
// UpdateEvent handles conversion from HookEvent to Events.
|
2014-06-08 03:45:34 -05:00
|
|
|
func (w *Webhook) UpdateEvent() error {
|
2014-05-05 20:36:08 -05:00
|
|
|
data, err := json.Marshal(w.HookEvent)
|
2014-05-05 19:52:25 -05:00
|
|
|
w.Events = string(data)
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2015-08-28 10:36:13 -05:00
|
|
|
// HasCreateEvent returns true if hook enabled create event.
|
|
|
|
func (w *Webhook) HasCreateEvent() bool {
|
|
|
|
return w.SendEverything ||
|
|
|
|
(w.ChooseEvents && w.HookEvents.Create)
|
|
|
|
}
|
|
|
|
|
2018-05-16 09:01:55 -05:00
|
|
|
// HasDeleteEvent returns true if hook enabled delete event.
|
|
|
|
func (w *Webhook) HasDeleteEvent() bool {
|
|
|
|
return w.SendEverything ||
|
|
|
|
(w.ChooseEvents && w.HookEvents.Delete)
|
|
|
|
}
|
|
|
|
|
|
|
|
// HasForkEvent returns true if hook enabled fork event.
|
|
|
|
func (w *Webhook) HasForkEvent() bool {
|
|
|
|
return w.SendEverything ||
|
|
|
|
(w.ChooseEvents && w.HookEvents.Fork)
|
|
|
|
}
|
|
|
|
|
|
|
|
// HasIssuesEvent returns true if hook enabled issues event.
|
|
|
|
func (w *Webhook) HasIssuesEvent() bool {
|
|
|
|
return w.SendEverything ||
|
|
|
|
(w.ChooseEvents && w.HookEvents.Issues)
|
|
|
|
}
|
|
|
|
|
2020-03-06 00:10:48 -05:00
|
|
|
// HasIssuesAssignEvent returns true if hook enabled issues assign event.
|
|
|
|
func (w *Webhook) HasIssuesAssignEvent() bool {
|
|
|
|
return w.SendEverything ||
|
|
|
|
(w.ChooseEvents && w.HookEvents.IssueAssign)
|
|
|
|
}
|
|
|
|
|
|
|
|
// HasIssuesLabelEvent returns true if hook enabled issues label event.
|
|
|
|
func (w *Webhook) HasIssuesLabelEvent() bool {
|
|
|
|
return w.SendEverything ||
|
|
|
|
(w.ChooseEvents && w.HookEvents.IssueLabel)
|
|
|
|
}
|
|
|
|
|
|
|
|
// HasIssuesMilestoneEvent returns true if hook enabled issues milestone event.
|
|
|
|
func (w *Webhook) HasIssuesMilestoneEvent() bool {
|
|
|
|
return w.SendEverything ||
|
|
|
|
(w.ChooseEvents && w.HookEvents.IssueMilestone)
|
|
|
|
}
|
|
|
|
|
2018-05-16 09:01:55 -05:00
|
|
|
// HasIssueCommentEvent returns true if hook enabled issue_comment event.
|
|
|
|
func (w *Webhook) HasIssueCommentEvent() bool {
|
|
|
|
return w.SendEverything ||
|
|
|
|
(w.ChooseEvents && w.HookEvents.IssueComment)
|
|
|
|
}
|
|
|
|
|
2014-12-06 20:22:48 -05:00
|
|
|
// HasPushEvent returns true if hook enabled push event.
|
2014-05-06 10:50:31 -05:00
|
|
|
func (w *Webhook) HasPushEvent() bool {
|
2015-08-28 10:36:13 -05:00
|
|
|
return w.PushOnly || w.SendEverything ||
|
|
|
|
(w.ChooseEvents && w.HookEvents.Push)
|
2014-05-06 10:50:31 -05:00
|
|
|
}
|
|
|
|
|
2016-08-14 05:32:24 -05:00
|
|
|
// HasPullRequestEvent returns true if hook enabled pull request event.
|
|
|
|
func (w *Webhook) HasPullRequestEvent() bool {
|
|
|
|
return w.SendEverything ||
|
|
|
|
(w.ChooseEvents && w.HookEvents.PullRequest)
|
|
|
|
}
|
|
|
|
|
2020-03-06 00:10:48 -05:00
|
|
|
// HasPullRequestAssignEvent returns true if hook enabled pull request assign event.
|
|
|
|
func (w *Webhook) HasPullRequestAssignEvent() bool {
|
|
|
|
return w.SendEverything ||
|
|
|
|
(w.ChooseEvents && w.HookEvents.PullRequestAssign)
|
|
|
|
}
|
|
|
|
|
|
|
|
// HasPullRequestLabelEvent returns true if hook enabled pull request label event.
|
|
|
|
func (w *Webhook) HasPullRequestLabelEvent() bool {
|
|
|
|
return w.SendEverything ||
|
|
|
|
(w.ChooseEvents && w.HookEvents.PullRequestLabel)
|
|
|
|
}
|
|
|
|
|
|
|
|
// HasPullRequestMilestoneEvent returns true if hook enabled pull request milestone event.
|
|
|
|
func (w *Webhook) HasPullRequestMilestoneEvent() bool {
|
|
|
|
return w.SendEverything ||
|
|
|
|
(w.ChooseEvents && w.HookEvents.PullRequestMilestone)
|
|
|
|
}
|
|
|
|
|
|
|
|
// HasPullRequestCommentEvent returns true if hook enabled pull_request_comment event.
|
|
|
|
func (w *Webhook) HasPullRequestCommentEvent() bool {
|
|
|
|
return w.SendEverything ||
|
|
|
|
(w.ChooseEvents && w.HookEvents.PullRequestComment)
|
|
|
|
}
|
|
|
|
|
|
|
|
// HasPullRequestApprovedEvent returns true if hook enabled pull request review event.
|
|
|
|
func (w *Webhook) HasPullRequestApprovedEvent() bool {
|
|
|
|
return w.SendEverything ||
|
|
|
|
(w.ChooseEvents && w.HookEvents.PullRequestReview)
|
|
|
|
}
|
|
|
|
|
|
|
|
// HasPullRequestRejectedEvent returns true if hook enabled pull request review event.
|
|
|
|
func (w *Webhook) HasPullRequestRejectedEvent() bool {
|
|
|
|
return w.SendEverything ||
|
|
|
|
(w.ChooseEvents && w.HookEvents.PullRequestReview)
|
|
|
|
}
|
|
|
|
|
|
|
|
// HasPullRequestReviewCommentEvent returns true if hook enabled pull request review event.
|
|
|
|
func (w *Webhook) HasPullRequestReviewCommentEvent() bool {
|
|
|
|
return w.SendEverything ||
|
|
|
|
(w.ChooseEvents && w.HookEvents.PullRequestReview)
|
|
|
|
}
|
|
|
|
|
|
|
|
// HasPullRequestSyncEvent returns true if hook enabled pull request sync event.
|
|
|
|
func (w *Webhook) HasPullRequestSyncEvent() bool {
|
|
|
|
return w.SendEverything ||
|
|
|
|
(w.ChooseEvents && w.HookEvents.PullRequestSync)
|
|
|
|
}
|
|
|
|
|
2022-09-04 14:54:23 -05:00
|
|
|
// HasWikiEvent returns true if hook enabled wiki event.
|
|
|
|
func (w *Webhook) HasWikiEvent() bool {
|
|
|
|
return w.SendEverything ||
|
|
|
|
(w.ChooseEvents && w.HookEvent.Wiki)
|
|
|
|
}
|
|
|
|
|
2018-05-16 09:01:55 -05:00
|
|
|
// HasReleaseEvent returns if hook enabled release event.
|
|
|
|
func (w *Webhook) HasReleaseEvent() bool {
|
|
|
|
return w.SendEverything ||
|
|
|
|
(w.ChooseEvents && w.HookEvents.Release)
|
|
|
|
}
|
|
|
|
|
2017-09-03 03:20:24 -05:00
|
|
|
// HasRepositoryEvent returns if hook enabled repository event.
|
|
|
|
func (w *Webhook) HasRepositoryEvent() bool {
|
|
|
|
return w.SendEverything ||
|
|
|
|
(w.ChooseEvents && w.HookEvents.Repository)
|
|
|
|
}
|
|
|
|
|
2022-03-30 03:42:47 -05:00
|
|
|
// HasPackageEvent returns if hook enabled package event.
|
|
|
|
func (w *Webhook) HasPackageEvent() bool {
|
|
|
|
return w.SendEverything ||
|
|
|
|
(w.ChooseEvents && w.HookEvents.Package)
|
|
|
|
}
|
|
|
|
|
2023-05-24 21:06:27 -05:00
|
|
|
// HasPullRequestReviewRequestEvent returns true if hook enabled pull request review request event.
|
|
|
|
func (w *Webhook) HasPullRequestReviewRequestEvent() bool {
|
|
|
|
return w.SendEverything ||
|
|
|
|
(w.ChooseEvents && w.HookEvents.PullRequestReviewRequest)
|
|
|
|
}
|
|
|
|
|
2019-11-01 17:51:22 -05:00
|
|
|
// EventCheckers returns event checkers
|
|
|
|
func (w *Webhook) EventCheckers() []struct {
|
|
|
|
Has func() bool
|
2023-01-01 10:23:15 -05:00
|
|
|
Type webhook_module.HookEventType
|
2018-05-16 09:01:55 -05:00
|
|
|
} {
|
|
|
|
return []struct {
|
2019-11-01 17:51:22 -05:00
|
|
|
Has func() bool
|
2023-01-01 10:23:15 -05:00
|
|
|
Type webhook_module.HookEventType
|
2018-05-16 09:01:55 -05:00
|
|
|
}{
|
2023-01-01 10:23:15 -05:00
|
|
|
{w.HasCreateEvent, webhook_module.HookEventCreate},
|
|
|
|
{w.HasDeleteEvent, webhook_module.HookEventDelete},
|
|
|
|
{w.HasForkEvent, webhook_module.HookEventFork},
|
|
|
|
{w.HasPushEvent, webhook_module.HookEventPush},
|
|
|
|
{w.HasIssuesEvent, webhook_module.HookEventIssues},
|
|
|
|
{w.HasIssuesAssignEvent, webhook_module.HookEventIssueAssign},
|
|
|
|
{w.HasIssuesLabelEvent, webhook_module.HookEventIssueLabel},
|
|
|
|
{w.HasIssuesMilestoneEvent, webhook_module.HookEventIssueMilestone},
|
|
|
|
{w.HasIssueCommentEvent, webhook_module.HookEventIssueComment},
|
|
|
|
{w.HasPullRequestEvent, webhook_module.HookEventPullRequest},
|
|
|
|
{w.HasPullRequestAssignEvent, webhook_module.HookEventPullRequestAssign},
|
|
|
|
{w.HasPullRequestLabelEvent, webhook_module.HookEventPullRequestLabel},
|
|
|
|
{w.HasPullRequestMilestoneEvent, webhook_module.HookEventPullRequestMilestone},
|
|
|
|
{w.HasPullRequestCommentEvent, webhook_module.HookEventPullRequestComment},
|
|
|
|
{w.HasPullRequestApprovedEvent, webhook_module.HookEventPullRequestReviewApproved},
|
|
|
|
{w.HasPullRequestRejectedEvent, webhook_module.HookEventPullRequestReviewRejected},
|
|
|
|
{w.HasPullRequestCommentEvent, webhook_module.HookEventPullRequestReviewComment},
|
|
|
|
{w.HasPullRequestSyncEvent, webhook_module.HookEventPullRequestSync},
|
|
|
|
{w.HasWikiEvent, webhook_module.HookEventWiki},
|
|
|
|
{w.HasRepositoryEvent, webhook_module.HookEventRepository},
|
|
|
|
{w.HasReleaseEvent, webhook_module.HookEventRelease},
|
|
|
|
{w.HasPackageEvent, webhook_module.HookEventPackage},
|
2023-05-24 21:06:27 -05:00
|
|
|
{w.HasPullRequestReviewRequestEvent, webhook_module.HookEventPullRequestReviewRequest},
|
2018-05-16 09:01:55 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-11-22 01:42:52 -05:00
|
|
|
// EventsArray returns an array of hook events
|
2015-08-28 22:49:59 -05:00
|
|
|
func (w *Webhook) EventsArray() []string {
|
2018-05-16 09:01:55 -05:00
|
|
|
events := make([]string, 0, 7)
|
|
|
|
|
2019-11-01 17:51:22 -05:00
|
|
|
for _, c := range w.EventCheckers() {
|
|
|
|
if c.Has() {
|
|
|
|
events = append(events, string(c.Type))
|
2018-05-16 09:01:55 -05:00
|
|
|
}
|
2016-08-24 22:44:58 -05:00
|
|
|
}
|
2015-08-28 22:49:59 -05:00
|
|
|
return events
|
|
|
|
}
|
|
|
|
|
2022-11-03 13:23:20 -05:00
|
|
|
// HeaderAuthorization returns the decrypted Authorization header.
|
|
|
|
// Not on the reference (*w), to be accessible on WebhooksNew.
|
|
|
|
func (w Webhook) HeaderAuthorization() (string, error) {
|
|
|
|
if w.HeaderAuthorizationEncrypted == "" {
|
|
|
|
return "", nil
|
|
|
|
}
|
|
|
|
return secret.DecryptSecret(setting.SecretKey, w.HeaderAuthorizationEncrypted)
|
|
|
|
}
|
|
|
|
|
|
|
|
// SetHeaderAuthorization encrypts and sets the Authorization header.
|
|
|
|
func (w *Webhook) SetHeaderAuthorization(cleartext string) error {
|
|
|
|
if cleartext == "" {
|
|
|
|
w.HeaderAuthorizationEncrypted = ""
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
ciphertext, err := secret.EncryptSecret(setting.SecretKey, cleartext)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
w.HeaderAuthorizationEncrypted = ciphertext
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2014-06-08 03:45:34 -05:00
|
|
|
// CreateWebhook creates a new web hook.
|
2021-11-10 00:13:16 -05:00
|
|
|
func CreateWebhook(ctx context.Context, w *Webhook) error {
|
2020-12-11 11:04:04 -05:00
|
|
|
w.Type = strings.TrimSpace(w.Type)
|
2021-11-10 00:13:16 -05:00
|
|
|
return db.Insert(ctx, w)
|
2014-05-05 19:52:25 -05:00
|
|
|
}
|
|
|
|
|
2022-06-06 03:01:49 -05:00
|
|
|
// CreateWebhooks creates multiple web hooks
|
|
|
|
func CreateWebhooks(ctx context.Context, ws []*Webhook) error {
|
2022-08-03 23:22:50 -05:00
|
|
|
// xorm returns err "no element on slice when insert" for empty slices.
|
|
|
|
if len(ws) == 0 {
|
|
|
|
return nil
|
|
|
|
}
|
2022-06-06 03:01:49 -05:00
|
|
|
for i := 0; i < len(ws); i++ {
|
|
|
|
ws[i].Type = strings.TrimSpace(ws[i].Type)
|
|
|
|
}
|
|
|
|
return db.Insert(ctx, ws)
|
|
|
|
}
|
|
|
|
|
2023-11-25 12:21:21 -05:00
|
|
|
// GetWebhookByID returns webhook of repository by given ID.
|
|
|
|
func GetWebhookByID(ctx context.Context, id int64) (*Webhook, error) {
|
|
|
|
bean := new(Webhook)
|
|
|
|
has, err := db.GetEngine(ctx).ID(id).Get(bean)
|
2014-05-05 20:36:08 -05:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
} else if !has {
|
2023-11-25 12:21:21 -05:00
|
|
|
return nil, ErrWebhookNotExist{ID: id}
|
2014-05-05 20:36:08 -05:00
|
|
|
}
|
2016-07-16 19:33:59 -05:00
|
|
|
return bean, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// GetWebhookByRepoID returns webhook of repository by given ID.
|
2023-10-14 03:37:24 -05:00
|
|
|
func GetWebhookByRepoID(ctx context.Context, repoID, id int64) (*Webhook, error) {
|
2023-11-25 12:21:21 -05:00
|
|
|
webhook := new(Webhook)
|
|
|
|
has, err := db.GetEngine(ctx).Where("id=? AND repo_id=?", id, repoID).Get(webhook)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
} else if !has {
|
|
|
|
return nil, ErrWebhookNotExist{ID: id}
|
|
|
|
}
|
|
|
|
return webhook, nil
|
2014-05-05 20:36:08 -05:00
|
|
|
}
|
|
|
|
|
2023-03-10 09:28:32 -05:00
|
|
|
// GetWebhookByOwnerID returns webhook of a user or organization by given ID.
|
2023-10-14 03:37:24 -05:00
|
|
|
func GetWebhookByOwnerID(ctx context.Context, ownerID, id int64) (*Webhook, error) {
|
2023-11-25 12:21:21 -05:00
|
|
|
webhook := new(Webhook)
|
|
|
|
has, err := db.GetEngine(ctx).Where("id=? AND owner_id=?", id, ownerID).Get(webhook)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
} else if !has {
|
|
|
|
return nil, ErrWebhookNotExist{ID: id}
|
|
|
|
}
|
|
|
|
return webhook, nil
|
2016-07-15 12:02:55 -05:00
|
|
|
}
|
|
|
|
|
2021-08-12 07:43:08 -05:00
|
|
|
// ListWebhookOptions are options to filter webhooks on ListWebhooksByOpts
|
|
|
|
type ListWebhookOptions struct {
|
2021-09-24 06:32:56 -05:00
|
|
|
db.ListOptions
|
2021-08-12 07:43:08 -05:00
|
|
|
RepoID int64
|
2023-03-10 09:28:32 -05:00
|
|
|
OwnerID int64
|
2021-08-12 07:43:08 -05:00
|
|
|
IsActive util.OptionalBool
|
2017-09-03 03:20:24 -05:00
|
|
|
}
|
|
|
|
|
2023-11-23 22:49:41 -05:00
|
|
|
func (opts ListWebhookOptions) ToConds() builder.Cond {
|
2021-08-12 07:43:08 -05:00
|
|
|
cond := builder.NewCond()
|
|
|
|
if opts.RepoID != 0 {
|
|
|
|
cond = cond.And(builder.Eq{"webhook.repo_id": opts.RepoID})
|
|
|
|
}
|
2023-03-10 09:28:32 -05:00
|
|
|
if opts.OwnerID != 0 {
|
|
|
|
cond = cond.And(builder.Eq{"webhook.owner_id": opts.OwnerID})
|
2021-08-12 07:43:08 -05:00
|
|
|
}
|
|
|
|
if !opts.IsActive.IsNone() {
|
|
|
|
cond = cond.And(builder.Eq{"webhook.is_active": opts.IsActive.IsTrue()})
|
2020-01-24 14:00:29 -05:00
|
|
|
}
|
2021-08-12 07:43:08 -05:00
|
|
|
return cond
|
|
|
|
}
|
2020-01-24 14:00:29 -05:00
|
|
|
|
2014-06-08 03:45:34 -05:00
|
|
|
// UpdateWebhook updates information of webhook.
|
2023-10-14 03:37:24 -05:00
|
|
|
func UpdateWebhook(ctx context.Context, w *Webhook) error {
|
|
|
|
_, err := db.GetEngine(ctx).ID(w.ID).AllCols().Update(w)
|
2014-06-08 03:45:34 -05:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2017-08-30 00:36:52 -05:00
|
|
|
// UpdateWebhookLastStatus updates last status of webhook.
|
2023-10-14 03:37:24 -05:00
|
|
|
func UpdateWebhookLastStatus(ctx context.Context, w *Webhook) error {
|
|
|
|
_, err := db.GetEngine(ctx).ID(w.ID).Cols("last_status").Update(w)
|
2017-08-30 00:36:52 -05:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2023-11-25 12:21:21 -05:00
|
|
|
// DeleteWebhookByID uses argument bean as query condition,
|
2016-07-16 19:33:59 -05:00
|
|
|
// ID must be specified and do not assign unnecessary fields.
|
2023-11-25 12:21:21 -05:00
|
|
|
func DeleteWebhookByID(ctx context.Context, id int64) (err error) {
|
2023-10-14 03:37:24 -05:00
|
|
|
ctx, committer, err := db.TxContext(ctx)
|
2021-11-21 10:41:00 -05:00
|
|
|
if err != nil {
|
2015-08-26 08:45:51 -05:00
|
|
|
return err
|
|
|
|
}
|
2021-11-21 10:41:00 -05:00
|
|
|
defer committer.Close()
|
2015-08-26 08:45:51 -05:00
|
|
|
|
2023-11-25 12:21:21 -05:00
|
|
|
if count, err := db.DeleteByID(ctx, id, new(Webhook)); err != nil {
|
2015-08-26 08:45:51 -05:00
|
|
|
return err
|
2017-01-13 21:14:48 -05:00
|
|
|
} else if count == 0 {
|
2023-11-25 12:21:21 -05:00
|
|
|
return ErrWebhookNotExist{ID: id}
|
|
|
|
} else if _, err = db.DeleteByBean(ctx, &HookTask{HookID: id}); err != nil {
|
2015-08-26 08:45:51 -05:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2021-11-21 10:41:00 -05:00
|
|
|
return committer.Commit()
|
2014-05-05 20:36:08 -05:00
|
|
|
}
|
2014-06-08 03:45:34 -05:00
|
|
|
|
2016-07-16 19:33:59 -05:00
|
|
|
// DeleteWebhookByRepoID deletes webhook of repository by given ID.
|
2023-10-14 03:37:24 -05:00
|
|
|
func DeleteWebhookByRepoID(ctx context.Context, repoID, id int64) error {
|
2023-11-25 12:21:21 -05:00
|
|
|
if _, err := GetWebhookByRepoID(ctx, repoID, id); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
return DeleteWebhookByID(ctx, id)
|
2016-07-16 19:33:59 -05:00
|
|
|
}
|
|
|
|
|
2023-03-10 09:28:32 -05:00
|
|
|
// DeleteWebhookByOwnerID deletes webhook of a user or organization by given ID.
|
2023-10-14 03:37:24 -05:00
|
|
|
func DeleteWebhookByOwnerID(ctx context.Context, ownerID, id int64) error {
|
2023-11-25 12:21:21 -05:00
|
|
|
if _, err := GetWebhookByOwnerID(ctx, ownerID, id); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
return DeleteWebhookByID(ctx, id)
|
2016-07-16 19:33:59 -05:00
|
|
|
}
|