// Code generated by gen/generate.go. DO NOT EDIT.

// make edits in gen/generate.go

// Copyright 2022 The GithubEvents Authors. All rights reserved.

// Use of this source code is governed by the MIT License

// that can be found in the LICENSE file.

package githubevents

import (

"fmt"

"github.com/google/go-github/v69/github"

"golang.org/x/sync/errgroup"

)

// Actions are used to identify registered callbacks.

const (

// PullRequestEvent is the event name of github.PullRequestEvent's

PullRequestEvent = "pull_request"

// PullRequestEventAnyAction is used to identify callbacks

// listening to all events of type github.PullRequestEvent

PullRequestEventAnyAction = "*"

// PullRequestEventAssignedAction is used to identify callbacks

// listening to events of type github.PullRequestEvent and action "assigned"

PullRequestEventAssignedAction = "assigned"

// PullRequestEventAutoMergeDisabledAction is used to identify callbacks

// listening to events of type github.PullRequestEvent and action "auto_merge_disabled"

PullRequestEventAutoMergeDisabledAction = "auto_merge_disabled"

// PullRequestEventAutoMergeEnabledAction is used to identify callbacks

// listening to events of type github.PullRequestEvent and action "auto_merge_enabled"

PullRequestEventAutoMergeEnabledAction = "auto_merge_enabled"

// PullRequestEventClosedAction is used to identify callbacks

// listening to events of type github.PullRequestEvent and action "closed"

PullRequestEventClosedAction = "closed"

// PullRequestEventConvertedToDraftAction is used to identify callbacks

// listening to events of type github.PullRequestEvent and action "converted_to_draft"

PullRequestEventConvertedToDraftAction = "converted_to_draft"

// PullRequestEventEditedAction is used to identify callbacks

// listening to events of type github.PullRequestEvent and action "edited"

PullRequestEventEditedAction = "edited"

// PullRequestEventLabeledAction is used to identify callbacks

// listening to events of type github.PullRequestEvent and action "labeled"

PullRequestEventLabeledAction = "labeled"

// PullRequestEventLockedAction is used to identify callbacks

// listening to events of type github.PullRequestEvent and action "locked"

PullRequestEventLockedAction = "locked"

// PullRequestEventOpenedAction is used to identify callbacks

// listening to events of type github.PullRequestEvent and action "opened"

PullRequestEventOpenedAction = "opened"

// PullRequestEventReadyForReviewAction is used to identify callbacks

// listening to events of type github.PullRequestEvent and action "ready_for_review"

PullRequestEventReadyForReviewAction = "ready_for_review"

// PullRequestEventReopenedAction is used to identify callbacks

// listening to events of type github.PullRequestEvent and action "reopened"

PullRequestEventReopenedAction = "reopened"

// PullRequestEventReviewRequestRemovedAction is used to identify callbacks

// listening to events of type github.PullRequestEvent and action "review_request_removed"

PullRequestEventReviewRequestRemovedAction = "review_request_removed"

// PullRequestEventReviewRequestedAction is used to identify callbacks

// listening to events of type github.PullRequestEvent and action "review_requested"

PullRequestEventReviewRequestedAction = "review_requested"

// PullRequestEventSynchronizeAction is used to identify callbacks

// listening to events of type github.PullRequestEvent and action "synchronize"

PullRequestEventSynchronizeAction = "synchronize"

// PullRequestEventUnassignedAction is used to identify callbacks

// listening to events of type github.PullRequestEvent and action "unassigned"

PullRequestEventUnassignedAction = "unassigned"

// PullRequestEventUnlabeledAction is used to identify callbacks

// listening to events of type github.PullRequestEvent and action "unlabeled"

PullRequestEventUnlabeledAction = "unlabeled"

// PullRequestEventUnlockedAction is used to identify callbacks

// listening to events of type github.PullRequestEvent and action "unlocked"

PullRequestEventUnlockedAction = "unlocked"

)

// PullRequestEventHandleFunc represents a callback function triggered on github.PullRequestEvent's.

// 'deliveryID' (type: string) is the unique webhook delivery ID.

// 'eventName' (type: string) is the name of the event.

// 'event' (type: *github.PullRequestEvent) is the webhook payload.

type PullRequestEventHandleFunc func(deliveryID string, eventName string, event *github.PullRequestEvent) error

// OnPullRequestEventAssigned registers callbacks listening to events of type github.PullRequestEvent and action 'assigned'.

//

// This function appends the callbacks passed as arguments to already existing ones.

// If already existing callbacks are to be overwritten, SetOnPullRequestEventAssigned must be used.

//

// Callbacks are executed in parallel. This function blocks until all callbacks executed in parallel have returned,

// then returns the first non-nil error (if any) from them. If OnError callbacks have been set, they will be called when an error occurs.

//

// Reference: https://docs.github.com/en/developers/webhooks-and-events/webhooks/webhook-events-and-payloads#pull_request

func (g *EventHandler) OnPullRequestEventAssigned(callbacks ...PullRequestEventHandleFunc) {

g.mu.Lock()

defer g.mu.Unlock()

if callbacks == nil || len(callbacks) == 0 {

panic("callbacks is nil or empty")

}

if g.onPullRequestEvent == nil {

g.onPullRequestEvent = make(map[string][]PullRequestEventHandleFunc)

}

g.onPullRequestEvent[PullRequestEventAssignedAction] = append(

g.onPullRequestEvent[PullRequestEventAssignedAction],

callbacks...,

)

}

// SetOnPullRequestEventAssigned registers callbacks listening to events of type github.PullRequestEvent and action 'assigned'

// and overwrites already registered callbacks.

//

// This function overwrites all previously registered callbacks.

// If already registered callbacks are not to be overwritten, OnPullRequestEventAssignedAny must be used.

//

// Callbacks are executed in parallel. This function blocks until all callbacks executed in parallel have returned,

// then returns the first non-nil error (if any) from them. If OnError callbacks have been set, they will be called when an error occurs.

//

// Reference: https://docs.github.com/en/developers/webhooks-and-events/webhooks/webhook-events-and-payloads#pull_request

func (g *EventHandler) SetOnPullRequestEventAssigned(callbacks ...PullRequestEventHandleFunc) {

g.mu.Lock()

defer g.mu.Unlock()

if callbacks == nil || len(callbacks) == 0 {

panic("callbacks is nil or empty")

}

if g.onPullRequestEvent == nil {

g.onPullRequestEvent = make(map[string][]PullRequestEventHandleFunc)

}

g.onPullRequestEvent[PullRequestEventAssignedAction] = callbacks

}

func (g *EventHandler) handlePullRequestEventAssigned(deliveryID string, eventName string, event *github.PullRequestEvent) error {

if event == nil || event.Action == nil || *event.Action == "" {

return fmt.Errorf("event action was empty or nil")

}

if PullRequestEventAssignedAction != *event.Action {

return fmt.Errorf(

"handlePullRequestEventAssigned() called with wrong action, want %s, got %s",

PullRequestEventAssignedAction,

*event.Action,

)

}

eg := new(errgroup.Group)

for _, action := range []string{

PullRequestEventAssignedAction,

PullRequestEventAnyAction,

} {

if _, ok := g.onPullRequestEvent[action]; ok {

for _, h := range g.onPullRequestEvent[action] {

handle := h

eg.Go(func() error {

err := handle(deliveryID, eventName, event)

if err != nil {

return err

}

return nil

})

}

}

}

if err := eg.Wait(); err != nil {

return err

}

return nil

}

// OnPullRequestEventAutoMergeDisabled registers callbacks listening to events of type github.PullRequestEvent and action 'auto_merge_disabled'.

//

// This function appends the callbacks passed as arguments to already existing ones.

// If already existing callbacks are to be overwritten, SetOnPullRequestEventAutoMergeDisabled must be used.

//

// Callbacks are executed in parallel. This function blocks until all callbacks executed in parallel have returned,

// then returns the first non-nil error (if any) from them. If OnError callbacks have been set, they will be called when an error occurs.

//

// Reference: https://docs.github.com/en/developers/webhooks-and-events/webhooks/webhook-events-and-payloads#pull_request

func (g *EventHandler) OnPullRequestEventAutoMergeDisabled(callbacks ...PullRequestEventHandleFunc) {

g.mu.Lock()

defer g.mu.Unlock()

if callbacks == nil || len(callbacks) == 0 {

panic("callbacks is nil or empty")

}

if g.onPullRequestEvent == nil {

g.onPullRequestEvent = make(map[string][]PullRequestEventHandleFunc)

}

g.onPullRequestEvent[PullRequestEventAutoMergeDisabledAction] = append(

g.onPullRequestEvent[PullRequestEventAutoMergeDisabledAction],

callbacks...,

)

}

// SetOnPullRequestEventAutoMergeDisabled registers callbacks listening to events of type github.PullRequestEvent and action 'auto_merge_disabled'

// and overwrites already registered callbacks.

//

// This function overwrites all previously registered callbacks.

// If already registered callbacks are not to be overwritten, OnPullRequestEventAutoMergeDisabledAny must be used.

//

// Callbacks are executed in parallel. This function blocks until all callbacks executed in parallel have returned,

// then returns the first non-nil error (if any) from them. If OnError callbacks have been set, they will be called when an error occurs.

//

// Reference: https://docs.github.com/en/developers/webhooks-and-events/webhooks/webhook-events-and-payloads#pull_request

func (g *EventHandler) SetOnPullRequestEventAutoMergeDisabled(callbacks ...PullRequestEventHandleFunc) {

g.mu.Lock()

defer g.mu.Unlock()

if callbacks == nil || len(callbacks) == 0 {

panic("callbacks is nil or empty")

}

if g.onPullRequestEvent == nil {

g.onPullRequestEvent = make(map[string][]PullRequestEventHandleFunc)

}

g.onPullRequestEvent[PullRequestEventAutoMergeDisabledAction] = callbacks

}

func (g *EventHandler) handlePullRequestEventAutoMergeDisabled(deliveryID string, eventName string, event *github.PullRequestEvent) error {

if event == nil || event.Action == nil || *event.Action == "" {

return fmt.Errorf("event action was empty or nil")

}

if PullRequestEventAutoMergeDisabledAction != *event.Action {

return fmt.Errorf(

"handlePullRequestEventAutoMergeDisabled() called with wrong action, want %s, got %s",

PullRequestEventAutoMergeDisabledAction,

*event.Action,

)

}

eg := new(errgroup.Group)

for _, action := range []string{

PullRequestEventAutoMergeDisabledAction,

PullRequestEventAnyAction,

} {

if _, ok := g.onPullRequestEvent[action]; ok {

for _, h := range g.onPullRequestEvent[action] {

handle := h

eg.Go(func() error {

err := handle(deliveryID, eventName, event)

if err != nil {

return err

}

return nil

})

}

}

}

if err := eg.Wait(); err != nil {

return err

}

return nil

}

// OnPullRequestEventAutoMergeEnabled registers callbacks listening to events of type github.PullRequestEvent and action 'auto_merge_enabled'.

//

// This function appends the callbacks passed as arguments to already existing ones.

// If already existing callbacks are to be overwritten, SetOnPullRequestEventAutoMergeEnabled must be used.

//

// Callbacks are executed in parallel. This function blocks until all callbacks executed in parallel have returned,

// then returns the first non-nil error (if any) from them. If OnError callbacks have been set, they will be called when an error occurs.

//

// Reference: https://docs.github.com/en/developers/webhooks-and-events/webhooks/webhook-events-and-payloads#pull_request

func (g *EventHandler) OnPullRequestEventAutoMergeEnabled(callbacks ...PullRequestEventHandleFunc) {

g.mu.Lock()

defer g.mu.Unlock()

if callbacks == nil || len(callbacks) == 0 {

panic("callbacks is nil or empty")

}

if g.onPullRequestEvent == nil {

g.onPullRequestEvent = make(map[string][]PullRequestEventHandleFunc)

}

g.onPullRequestEvent[PullRequestEventAutoMergeEnabledAction] = append(

g.onPullRequestEvent[PullRequestEventAutoMergeEnabledAction],

callbacks...,

)

}

// SetOnPullRequestEventAutoMergeEnabled registers callbacks listening to events of type github.PullRequestEvent and action 'auto_merge_enabled'

// and overwrites already registered callbacks.

//

// This function overwrites all previously registered callbacks.

// If already registered callbacks are not to be overwritten, OnPullRequestEventAutoMergeEnabledAny must be used.

//

// Callbacks are executed in parallel. This function blocks until all callbacks executed in parallel have returned,

// then returns the first non-nil error (if any) from them. If OnError callbacks have been set, they will be called when an error occurs.

//

// Reference: https://docs.github.com/en/developers/webhooks-and-events/webhooks/webhook-events-and-payloads#pull_request

func (g *EventHandler) SetOnPullRequestEventAutoMergeEnabled(callbacks ...PullRequestEventHandleFunc) {

g.mu.Lock()

defer g.mu.Unlock()

if callbacks == nil || len(callbacks) == 0 {

panic("callbacks is nil or empty")

}

if g.onPullRequestEvent == nil {

g.onPullRequestEvent = make(map[string][]PullRequestEventHandleFunc)

}

g.onPullRequestEvent[PullRequestEventAutoMergeEnabledAction] = callbacks

}

func (g *EventHandler) handlePullRequestEventAutoMergeEnabled(deliveryID string, eventName string, event *github.PullRequestEvent) error {

if event == nil || event.Action == nil || *event.Action == "" {

return fmt.Errorf("event action was empty or nil")

}

if PullRequestEventAutoMergeEnabledAction != *event.Action {

return fmt.Errorf(

"handlePullRequestEventAutoMergeEnabled() called with wrong action, want %s, got %s",

PullRequestEventAutoMergeEnabledAction,

*event.Action,

)

}

eg := new(errgroup.Group)

for _, action := range []string{

PullRequestEventAutoMergeEnabledAction,

PullRequestEventAnyAction,

} {

if _, ok := g.onPullRequestEvent[action]; ok {

for _, h := range g.onPullRequestEvent[action] {

handle := h

eg.Go(func() error {

err := handle(deliveryID, eventName, event)

if err != nil {

return err

}

return nil

})

}

}

}

if err := eg.Wait(); err != nil {

return err

}

return nil

}

// OnPullRequestEventClosed registers callbacks listening to events of type github.PullRequestEvent and action 'closed'.

//

// This function appends the callbacks passed as arguments to already existing ones.

// If already existing callbacks are to be overwritten, SetOnPullRequestEventClosed must be used.

//

// Callbacks are executed in parallel. This function blocks until all callbacks executed in parallel have returned,

// then returns the first non-nil error (if any) from them. If OnError callbacks have been set, they will be called when an error occurs.

//

// Reference: https://docs.github.com/en/developers/webhooks-and-events/webhooks/webhook-events-and-payloads#pull_request

func (g *EventHandler) OnPullRequestEventClosed(callbacks ...PullRequestEventHandleFunc) {

g.mu.Lock()

defer g.mu.Unlock()

if callbacks == nil || len(callbacks) == 0 {

panic("callbacks is nil or empty")

}

if g.onPullRequestEvent == nil {

g.onPullRequestEvent = make(map[string][]PullRequestEventHandleFunc)

}

g.onPullRequestEvent[PullRequestEventClosedAction] = append(

g.onPullRequestEvent[PullRequestEventClosedAction],

callbacks...,

)

}

// SetOnPullRequestEventClosed registers callbacks listening to events of type github.PullRequestEvent and action 'closed'

// and overwrites already registered callbacks.

//

// This function overwrites all previously registered callbacks.

// If already registered callbacks are not to be overwritten, OnPullRequestEventClosedAny must be used.

//

// Callbacks are executed in parallel. This function blocks until all callbacks executed in parallel have returned,

// then returns the first non-nil error (if any) from them. If OnError callbacks have been set, they will be called when an error occurs.

//

// Reference: https://docs.github.com/en/developers/webhooks-and-events/webhooks/webhook-events-and-payloads#pull_request

func (g *EventHandler) SetOnPullRequestEventClosed(callbacks ...PullRequestEventHandleFunc) {

g.mu.Lock()

defer g.mu.Unlock()

if callbacks == nil || len(callbacks) == 0 {

panic("callbacks is nil or empty")

}

if g.onPullRequestEvent == nil {

g.onPullRequestEvent = make(map[string][]PullRequestEventHandleFunc)

}

g.onPullRequestEvent[PullRequestEventClosedAction] = callbacks

}

func (g *EventHandler) handlePullRequestEventClosed(deliveryID string, eventName string, event *github.PullRequestEvent) error {

if event == nil || event.Action == nil || *event.Action == "" {

return fmt.Errorf("event action was empty or nil")

}

if PullRequestEventClosedAction != *event.Action {

return fmt.Errorf(

"handlePullRequestEventClosed() called with wrong action, want %s, got %s",

PullRequestEventClosedAction,

*event.Action,

)

}

eg := new(errgroup.Group)

for _, action := range []string{

PullRequestEventClosedAction,

PullRequestEventAnyAction,

} {

if _, ok := g.onPullRequestEvent[action]; ok {

for _, h := range g.onPullRequestEvent[action] {

handle := h

eg.Go(func() error {

err := handle(deliveryID, eventName, event)

if err != nil {

return err

}

return nil

})

}

}

}

if err := eg.Wait(); err != nil {

return err

}

return nil

}

// OnPullRequestEventConvertedToDraft registers callbacks listening to events of type github.PullRequestEvent and action 'converted_to_draft'.

//

// This function appends the callbacks passed as arguments to already existing ones.

// If already existing callbacks are to be overwritten, SetOnPullRequestEventConvertedToDraft must be used.

//

// Callbacks are executed in parallel. This function blocks until all callbacks executed in parallel have returned,

// then returns the first non-nil error (if any) from them. If OnError callbacks have been set, they will be called when an error occurs.

//

// Reference: https://docs.github.com/en/developers/webhooks-and-events/webhooks/webhook-events-and-payloads#pull_request

func (g *EventHandler) OnPullRequestEventConvertedToDraft(callbacks ...PullRequestEventHandleFunc) {

g.mu.Lock()

defer g.mu.Unlock()

if callbacks == nil || len(callbacks) == 0 {

panic("callbacks is nil or empty")

}

if g.onPullRequestEvent == nil {

g.onPullRequestEvent = make(map[string][]PullRequestEventHandleFunc)

}

g.onPullRequestEvent[PullRequestEventConvertedToDraftAction] = append(

g.onPullRequestEvent[PullRequestEventConvertedToDraftAction],

callbacks...,

)

}

// SetOnPullRequestEventConvertedToDraft registers callbacks listening to events of type github.PullRequestEvent and action 'converted_to_draft'

// and overwrites already registered callbacks.

//

// This function overwrites all previously registered callbacks.

// If already registered callbacks are not to be overwritten, OnPullRequestEventConvertedToDraftAny must be used.

//

// Callbacks are executed in parallel. This function blocks until all callbacks executed in parallel have returned,

// then returns the first non-nil error (if any) from them. If OnError callbacks have been set, they will be called when an error occurs.

//

// Reference: https://docs.github.com/en/developers/webhooks-and-events/webhooks/webhook-events-and-payloads#pull_request

func (g *EventHandler) SetOnPullRequestEventConvertedToDraft(callbacks ...PullRequestEventHandleFunc) {

g.mu.Lock()

defer g.mu.Unlock()

if callbacks == nil || len(callbacks) == 0 {

panic("callbacks is nil or empty")

}

if g.onPullRequestEvent == nil {

g.onPullRequestEvent = make(map[string][]PullRequestEventHandleFunc)

}

g.onPullRequestEvent[PullRequestEventConvertedToDraftAction] = callbacks

}

func (g *EventHandler) handlePullRequestEventConvertedToDraft(deliveryID string, eventName string, event *github.PullRequestEvent) error {

if event == nil || event.Action == nil || *event.Action == "" {

return fmt.Errorf("event action was empty or nil")

}

if PullRequestEventConvertedToDraftAction != *event.Action {

return fmt.Errorf(

"handlePullRequestEventConvertedToDraft() called with wrong action, want %s, got %s",

PullRequestEventConvertedToDraftAction,

*event.Action,

)

}

eg := new(errgroup.Group)

for _, action := range []string{

PullRequestEventConvertedToDraftAction,

PullRequestEventAnyAction,

} {

if _, ok := g.onPullRequestEvent[action]; ok {

for _, h := range g.onPullRequestEvent[action] {

handle := h

eg.Go(func() error {

err := handle(deliveryID, eventName, event)

if err != nil {

return err

}

return nil

})

}

}

}

if err := eg.Wait(); err != nil {

return err

}

return nil

}

// OnPullRequestEventEdited registers callbacks listening to events of type github.PullRequestEvent and action 'edited'.

//

// This function appends the callbacks passed as arguments to already existing ones.

// If already existing callbacks are to be overwritten, SetOnPullRequestEventEdited must be used.

//

// Callbacks are executed in parallel. This function blocks until all callbacks executed in parallel have returned,

// then returns the first non-nil error (if any) from them. If OnError callbacks have been set, they will be called when an error occurs.

//

// Reference: https://docs.github.com/en/developers/webhooks-and-events/webhooks/webhook-events-and-payloads#pull_request

func (g *EventHandler) OnPullRequestEventEdited(callbacks ...PullRequestEventHandleFunc) {

g.mu.Lock()

defer g.mu.Unlock()

if callbacks == nil || len(callbacks) == 0 {

panic("callbacks is nil or empty")

}

if g.onPullRequestEvent == nil {

g.onPullRequestEvent = make(map[string][]PullRequestEventHandleFunc)

}

g.onPullRequestEvent[PullRequestEventEditedAction] = append(

g.onPullRequestEvent[PullRequestEventEditedAction],

callbacks...,

)

}

// SetOnPullRequestEventEdited registers callbacks listening to events of type github.PullRequestEvent and action 'edited'

// and overwrites already registered callbacks.

//

// This function overwrites all previously registered callbacks.

// If already registered callbacks are not to be overwritten, OnPullRequestEventEditedAny must be used.

//

// Callbacks are executed in parallel. This function blocks until all callbacks executed in parallel have returned,

// then returns the first non-nil error (if any) from them. If OnError callbacks have been set, they will be called when an error occurs.

//

// Reference: https://docs.github.com/en/developers/webhooks-and-events/webhooks/webhook-events-and-payloads#pull_request

func (g *EventHandler) SetOnPullRequestEventEdited(callbacks ...PullRequestEventHandleFunc) {

g.mu.Lock()

defer g.mu.Unlock()

if callbacks == nil || len(callbacks) == 0 {

panic("callbacks is nil or empty")

}

if g.onPullRequestEvent == nil {

g.onPullRequestEvent = make(map[string][]PullRequestEventHandleFunc)

}

g.onPullRequestEvent[PullRequestEventEditedAction] = callbacks

}

func (g *EventHandler) handlePullRequestEventEdited(deliveryID string, eventName string, event *github.PullRequestEvent) error {

if event == nil || event.Action == nil || *event.Action == "" {

return fmt.Errorf("event action was empty or nil")

}

if PullRequestEventEditedAction != *event.Action {

return fmt.Errorf(

"handlePullRequestEventEdited() called with wrong action, want %s, got %s",

PullRequestEventEditedAction,

*event.Action,

)

}

eg := new(errgroup.Group)

for _, action := range []string{

PullRequestEventEditedAction,

PullRequestEventAnyAction,

} {

if _, ok := g.onPullRequestEvent[action]; ok {

for _, h := range g.onPullRequestEvent[action] {

handle := h

eg.Go(func() error {

err := handle(deliveryID, eventName, event)

if err != nil {

return err

}

return nil

})

}

}

}

if err := eg.Wait(); err != nil {

return err

}

return nil

}

// OnPullRequestEventLabeled registers callbacks listening to events of type github.PullRequestEvent and action 'labeled'.

//

// This function appends the callbacks passed as arguments to already existing ones.

// If already existing callbacks are to be overwritten, SetOnPullRequestEventLabeled must be used.

//

// Callbacks are executed in parallel. This function blocks until all callbacks executed in parallel have returned,

// then returns the first non-nil error (if any) from them. If OnError callbacks have been set, they will be called when an error occurs.

//

// Reference: https://docs.github.com/en/developers/webhooks-and-events/webhooks/webhook-events-and-payloads#pull_request

func (g *EventHandler) OnPullRequestEventLabeled(callbacks ...PullRequestEventHandleFunc) {

g.mu.Lock()

defer g.mu.Unlock()

if callbacks == nil || len(callbacks) == 0 {

panic("callbacks is nil or empty")

}

if g.onPullRequestEvent == nil {

g.onPullRequestEvent = make(map[string][]PullRequestEventHandleFunc)

}

g.onPullRequestEvent[PullRequestEventLabeledAction] = append(

g.onPullRequestEvent[PullRequestEventLabeledAction],

callbacks...,

)

}

// SetOnPullRequestEventLabeled registers callbacks listening to events of type github.PullRequestEvent and action 'labeled'

// and overwrites already registered callbacks.

//

// This function overwrites all previously registered callbacks.

// If already registered callbacks are not to be overwritten, OnPullRequestEventLabeledAny must be used.

//

// Callbacks are executed in parallel. This function blocks until all callbacks executed in parallel have returned,

// then returns the first non-nil error (if any) from them. If OnError callbacks have been set, they will be called when an error occurs.

//

// Reference: https://docs.github.com/en/developers/webhooks-and-events/webhooks/webhook-events-and-payloads#pull_request

func (g *EventHandler) SetOnPullRequestEventLabeled(callbacks ...PullRequestEventHandleFunc) {

g.mu.Lock()

defer g.mu.Unlock()

if callbacks == nil || len(callbacks) == 0 {

panic("callbacks is nil or empty")

}

if g.onPullRequestEvent == nil {

g.onPullRequestEvent = make(map[string][]PullRequestEventHandleFunc)

}

g.onPullRequestEvent[PullRequestEventLabeledAction] = callbacks

}

func (g *EventHandler) handlePullRequestEventLabeled(deliveryID string, eventName string, event *github.PullRequestEvent) error {

if event == nil || event.Action == nil || *event.Action == "" {

return fmt.Errorf("event action was empty or nil")

}

if PullRequestEventLabeledAction != *event.Action {

return fmt.Errorf(

"handlePullRequestEventLabeled() called with wrong action, want %s, got %s",

PullRequestEventLabeledAction,

*event.Action,

)

}

eg := new(errgroup.Group)

for _, action := range []string{

PullRequestEventLabeledAction,

PullRequestEventAnyAction,

} {

if _, ok := g.onPullRequestEvent[action]; ok {

for _, h := range g.onPullRequestEvent[action] {

handle := h

eg.Go(func() error {

err := handle(deliveryID, eventName, event)

if err != nil {

return err

}

return nil

})

}

}

}

if err := eg.Wait(); err != nil {

return err

}

return nil

}

// OnPullRequestEventLocked registers callbacks listening to events of type github.PullRequestEvent and action 'locked'.

//

// This function appends the callbacks passed as arguments to already existing ones.

// If already existing callbacks are to be overwritten, SetOnPullRequestEventLocked must be used.

//

// Callbacks are executed in parallel. This function blocks until all callbacks executed in parallel have returned,

// then returns the first non-nil error (if any) from them. If OnError callbacks have been set, they will be called when an error occurs.

//

// Reference: https://docs.github.com/en/developers/webhooks-and-events/webhooks/webhook-events-and-payloads#pull_request

func (g *EventHandler) OnPullRequestEventLocked(callbacks ...PullRequestEventHandleFunc) {

g.mu.Lock()

defer g.mu.Unlock()

if callbacks == nil || len(callbacks) == 0 {

panic("callbacks is nil or empty")

}

if g.onPullRequestEvent == nil {

g.onPullRequestEvent = make(map[string][]PullRequestEventHandleFunc)

}

g.onPullRequestEvent[PullRequestEventLockedAction] = append(

g.onPullRequestEvent[PullRequestEventLockedAction],

callbacks...,

)

}

// SetOnPullRequestEventLocked registers callbacks listening to events of type github.PullRequestEvent and action 'locked'

// and overwrites already registered callbacks.

//

// This function overwrites all previously registered callbacks.

// If already registered callbacks are not to be overwritten, OnPullRequestEventLockedAny must be used.

//

// Callbacks are executed in parallel. This function blocks until all callbacks executed in parallel have returned,

// then returns the first non-nil error (if any) from them. If OnError callbacks have been set, they will be called when an error occurs.

//

// Reference: https://docs.github.com/en/developers/webhooks-and-events/webhooks/webhook-events-and-payloads#pull_request

func (g *EventHandler) SetOnPullRequestEventLocked(callbacks ...PullRequestEventHandleFunc) {

g.mu.Lock()

defer g.mu.Unlock()

if callbacks == nil || len(callbacks) == 0 {

panic("callbacks is nil or empty")

}

if g.onPullRequestEvent == nil {

g.onPullRequestEvent = make(map[string][]PullRequestEventHandleFunc)

}

g.onPullRequestEvent[PullRequestEventLockedAction] = callbacks

}

func (g *EventHandler) handlePullRequestEventLocked(deliveryID string, eventName string, event *github.PullRequestEvent) error {

if event == nil || event.Action == nil || *event.Action == "" {

return fmt.Errorf("event action was empty or nil")

}

if PullRequestEventLockedAction != *event.Action {

return fmt.Errorf(

"handlePullRequestEventLocked() called with wrong action, want %s, got %s",

PullRequestEventLockedAction,

*event.Action,

)

}

eg := new(errgroup.Group)

for _, action := range []string{

PullRequestEventLockedAction,

PullRequestEventAnyAction,

} {

if _, ok := g.onPullRequestEvent[action]; ok {

for _, h := range g.onPullRequestEvent[action] {

handle := h

eg.Go(func() error {

err := handle(deliveryID, eventName, event)

if err != nil {

return err

}

return nil

})

}

}

}

if err := eg.Wait(); err != nil {

return err

}

return nil

}

// OnPullRequestEventOpened registers callbacks listening to events of type github.PullRequestEvent and action 'opened'.

//

// This function appends the callbacks passed as arguments to already existing ones.

// If already existing callbacks are to be overwritten, SetOnPullRequestEventOpened must be used.

//

// Callbacks are executed in parallel. This function blocks until all callbacks executed in parallel have returned,

// then returns the first non-nil error (if any) from them. If OnError callbacks have been set, they will be called when an error occurs.

//

// Reference: https://docs.github.com/en/developers/webhooks-and-events/webhooks/webhook-events-and-payloads#pull_request

func (g *EventHandler) OnPullRequestEventOpened(callbacks ...PullRequestEventHandleFunc) {

g.mu.Lock()

defer g.mu.Unlock()

if callbacks == nil || len(callbacks) == 0 {

panic("callbacks is nil or empty")

}

if g.onPullRequestEvent == nil {

g.onPullRequestEvent = make(map[string][]PullRequestEventHandleFunc)

}

g.onPullRequestEvent[PullRequestEventOpenedAction] = append(

g.onPullRequestEvent[PullRequestEventOpenedAction],

callbacks...,

)

}

// SetOnPullRequestEventOpened registers callbacks listening to events of type github.PullRequestEvent and action 'opened'

// and overwrites already registered callbacks.

//

// This function overwrites all previously registered callbacks.

// If already registered callbacks are not to be overwritten, OnPullRequestEventOpenedAny must be used.

//

// Callbacks are executed in parallel. This function blocks until all callbacks executed in parallel have returned,

// then returns the first non-nil error (if any) from them. If OnError callbacks have been set, they will be called when an error occurs.

//

// Reference: https://docs.github.com/en/developers/webhooks-and-events/webhooks/webhook-events-and-payloads#pull_request

func (g *EventHandler) SetOnPullRequestEventOpened(callbacks ...PullRequestEventHandleFunc) {

g.mu.Lock()

defer g.mu.Unlock()

if callbacks == nil || len(callbacks) == 0 {

panic("callbacks is nil or empty")

}

if g.onPullRequestEvent == nil {

g.onPullRequestEvent = make(map[string][]PullRequestEventHandleFunc)

}

g.onPullRequestEvent[PullRequestEventOpenedAction] = callbacks

}

func (g *EventHandler) handlePullRequestEventOpened(deliveryID string, eventName string, event *github.PullRequestEvent) error {

if event == nil || event.Action == nil || *event.Action == "" {

return fmt.Errorf("event action was empty or nil")

}

if PullRequestEventOpenedAction != *event.Action {

return fmt.Errorf(

"handlePullRequestEventOpened() called with wrong action, want %s, got %s",

PullRequestEventOpenedAction,

*event.Action,

)

}

eg := new(errgroup.Group)

for _, action := range []string{

PullRequestEventOpenedAction,

PullRequestEventAnyAction,

} {

if _, ok := g.onPullRequestEvent[action]; ok {

for _, h := range g.onPullRequestEvent[action] {

handle := h

eg.Go(func() error {

err := handle(deliveryID, eventName, event)

if err != nil {

return err

}

return nil

})

}

}

}

if err := eg.Wait(); err != nil {

return err

}

return nil

}

// OnPullRequestEventReadyForReview registers callbacks listening to events of type github.PullRequestEvent and action 'ready_for_review'.

//

// This function appends the callbacks passed as arguments to already existing ones.

// If already existing callbacks are to be overwritten, SetOnPullRequestEventReadyForReview must be used.

//

// Callbacks are executed in parallel. This function blocks until all callbacks executed in parallel have returned,

// then returns the first non-nil error (if any) from them. If OnError callbacks have been set, they will be called when an error occurs.

//

// Reference: https://docs.github.com/en/developers/webhooks-and-events/webhooks/webhook-events-and-payloads#pull_request

func (g *EventHandler) OnPullRequestEventReadyForReview(callbacks ...PullRequestEventHandleFunc) {

g.mu.Lock()

defer g.mu.Unlock()

if callbacks == nil || len(callbacks) == 0 {

panic("callbacks is nil or empty")

}

if g.onPullRequestEvent == nil {

g.onPullRequestEvent = make(map[string][]PullRequestEventHandleFunc)

}

g.onPullRequestEvent[PullRequestEventReadyForReviewAction] = append(

g.onPullRequestEvent[PullRequestEventReadyForReviewAction],

callbacks...,

)

}

// SetOnPullRequestEventReadyForReview registers callbacks listening to events of type github.PullRequestEvent and action 'ready_for_review'

// and overwrites already registered callbacks.

//

// This function overwrites all previously registered callbacks.

// If already registered callbacks are not to be overwritten, OnPullRequestEventReadyForReviewAny must be used.

//

// Callbacks are executed in parallel. This function blocks until all callbacks executed in parallel have returned,

// then returns the first non-nil error (if any) from them. If OnError callbacks have been set, they will be called when an error occurs.

//

// Reference: https://docs.github.com/en/developers/webhooks-and-events/webhooks/webhook-events-and-payloads#pull_request

func (g *EventHandler) SetOnPullRequestEventReadyForReview(callbacks ...PullRequestEventHandleFunc) {

g.mu.Lock()

defer g.mu.Unlock()

if callbacks == nil || len(callbacks) == 0 {

panic("callbacks is nil or empty")

}

if g.onPullRequestEvent == nil {

g.onPullRequestEvent = make(map[string][]PullRequestEventHandleFunc)

}

g.onPullRequestEvent[PullRequestEventReadyForReviewAction] = callbacks

}

func (g *EventHandler) handlePullRequestEventReadyForReview(deliveryID string, eventName string, event *github.PullRequestEvent) error {

if event == nil || event.Action == nil || *event.Action == "" {

return fmt.Errorf("event action was empty or nil")

}

if PullRequestEventReadyForReviewAction != *event.Action {

return fmt.Errorf(

"handlePullRequestEventReadyForReview() called with wrong action, want %s, got %s",

PullRequestEventReadyForReviewAction,

*event.Action,

)

}

eg := new(errgroup.Group)

for _, action := range []string{

PullRequestEventReadyForReviewAction,

PullRequestEventAnyAction,

} {

if _, ok := g.onPullRequestEvent[action]; ok {

for _, h := range g.onPullRequestEvent[action] {

handle := h

eg.Go(func() error {

err := handle(deliveryID, eventName, event)

if err != nil {

return err

}

return nil

})

}

}

}

if err := eg.Wait(); err != nil {

return err

}

return nil

}

// OnPullRequestEventReopened registers callbacks listening to events of type github.PullRequestEvent and action 'reopened'.

//

// This function appends the callbacks passed as arguments to already existing ones.

// If already existing callbacks are to be overwritten, SetOnPullRequestEventReopened must be used.

//

// Callbacks are executed in parallel. This function blocks until all callbacks executed in parallel have returned,

// then returns the first non-nil error (if any) from them. If OnError callbacks have been set, they will be called when an error occurs.

//

// Reference: https://docs.github.com/en/developers/webhooks-and-events/webhooks/webhook-events-and-payloads#pull_request

func (g *EventHandler) OnPullRequestEventReopened(callbacks ...PullRequestEventHandleFunc) {

g.mu.Lock()

defer g.mu.Unlock()

if callbacks == nil || len(callbacks) == 0 {

panic("callbacks is nil or empty")

}

if g.onPullRequestEvent == nil {

g.onPullRequestEvent = make(map[string][]PullRequestEventHandleFunc)

}

g.onPullRequestEvent[PullRequestEventReopenedAction] = append(

g.onPullRequestEvent[PullRequestEventReopenedAction],

callbacks...,

)

}

// SetOnPullRequestEventReopened registers callbacks listening to events of type github.PullRequestEvent and action 'reopened'

// and overwrites already registered callbacks.

//

// This function overwrites all previously registered callbacks.

// If already registered callbacks are not to be overwritten, OnPullRequestEventReopenedAny must be used.

//

// Callbacks are executed in parallel. This function blocks until all callbacks executed in parallel have returned,

// then returns the first non-nil error (if any) from them. If OnError callbacks have been set, they will be called when an error occurs.

//

// Reference: https://docs.github.com/en/developers/webhooks-and-events/webhooks/webhook-events-and-payloads#pull_request

func (g *EventHandler) SetOnPullRequestEventReopened(callbacks ...PullRequestEventHandleFunc) {

g.mu.Lock()

defer g.mu.Unlock()

if callbacks == nil || len(callbacks) == 0 {

panic("callbacks is nil or empty")

}

if g.onPullRequestEvent == nil {

g.onPullRequestEvent = make(map[string][]PullRequestEventHandleFunc)

}

g.onPullRequestEvent[PullRequestEventReopenedAction] = callbacks

}

func (g *EventHandler) handlePullRequestEventReopened(deliveryID string, eventName string, event *github.PullRequestEvent) error {

if event == nil || event.Action == nil || *event.Action == "" {

return fmt.Errorf("event action was empty or nil")

}

if PullRequestEventReopenedAction != *event.Action {

return fmt.Errorf(

"handlePullRequestEventReopened() called with wrong action, want %s, got %s",

PullRequestEventReopenedAction,

*event.Action,

)

}

eg := new(errgroup.Group)

for _, action := range []string{

PullRequestEventReopenedAction,

PullRequestEventAnyAction,

} {

if _, ok := g.onPullRequestEvent[action]; ok {

for _, h := range g.onPullRequestEvent[action] {

handle := h

eg.Go(func() error {

err := handle(deliveryID, eventName, event)

if err != nil {

return err

}

return nil

})

}

}

}

if err := eg.Wait(); err != nil {

return err

}

return nil

}

// OnPullRequestEventReviewRequestRemoved registers callbacks listening to events of type github.PullRequestEvent and action 'review_request_removed'.

//

// This function appends the callbacks passed as arguments to already existing ones.

// If already existing callbacks are to be overwritten, SetOnPullRequestEventReviewRequestRemoved must be used.

//

// Callbacks are executed in parallel. This function blocks until all callbacks executed in parallel have returned,

// then returns the first non-nil error (if any) from them. If OnError callbacks have been set, they will be called when an error occurs.

//

// Reference: https://docs.github.com/en/developers/webhooks-and-events/webhooks/webhook-events-and-payloads#pull_request

func (g *EventHandler) OnPullRequestEventReviewRequestRemoved(callbacks ...PullRequestEventHandleFunc) {