events_repository_vulnerability_alert.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

// THIS FILE IS GENERATED - DO NOT EDIT DIRECTLY
// make edits in gen/generate.go

import (
	"fmt"
	"github.com/google/go-github/v59/github"
	"golang.org/x/sync/errgroup"
)

// Actions are used to identify registered callbacks.
const (
	// RepositoryVulnerabilityAlertEvent is the event name of github.RepositoryVulnerabilityAlertEvent's
	RepositoryVulnerabilityAlertEvent = "repository_vulnerability_alert"

	// RepositoryVulnerabilityAlertEventAnyAction is used to identify callbacks
	// listening to all events of type github.RepositoryVulnerabilityAlertEvent
	RepositoryVulnerabilityAlertEventAnyAction = "*"

	// RepositoryVulnerabilityAlertEventCreateAction is used to identify callbacks
	// listening to events of type github.RepositoryVulnerabilityAlertEvent and action "create"
	RepositoryVulnerabilityAlertEventCreateAction = "create"

	// RepositoryVulnerabilityAlertEventDismissAction is used to identify callbacks
	// listening to events of type github.RepositoryVulnerabilityAlertEvent and action "dismiss"
	RepositoryVulnerabilityAlertEventDismissAction = "dismiss"

	// RepositoryVulnerabilityAlertEventResolveAction is used to identify callbacks
	// listening to events of type github.RepositoryVulnerabilityAlertEvent and action "resolve"
	RepositoryVulnerabilityAlertEventResolveAction = "resolve"
)

// RepositoryVulnerabilityAlertEventHandleFunc represents a callback function triggered on github.RepositoryVulnerabilityAlertEvent's.
// 'deliveryID' (type: string) is the unique webhook delivery ID.
// 'eventName' (type: string) is the name of the event.
// 'event' (type: *github.RepositoryVulnerabilityAlertEvent) is the webhook payload.
type RepositoryVulnerabilityAlertEventHandleFunc func(deliveryID string, eventName string, event *github.RepositoryVulnerabilityAlertEvent) error

// OnRepositoryVulnerabilityAlertEventCreate registers callbacks listening to events of type github.RepositoryVulnerabilityAlertEvent and action 'create'.
//
// This function appends the callbacks passed as arguments to already existing ones.
// If already existing callbacks are to be overwritten, SetOnRepositoryVulnerabilityAlertEventCreate 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#repository_vulnerability_alert
func (g *EventHandler) OnRepositoryVulnerabilityAlertEventCreate(callbacks ...RepositoryVulnerabilityAlertEventHandleFunc) {
	g.mu.Lock()
	defer g.mu.Unlock()
	if callbacks == nil || len(callbacks) == 0 {
		panic("callbacks is nil or empty")
	}
	if g.onRepositoryVulnerabilityAlertEvent == nil {
		g.onRepositoryVulnerabilityAlertEvent = make(map[string][]RepositoryVulnerabilityAlertEventHandleFunc)
	}
	g.onRepositoryVulnerabilityAlertEvent[RepositoryVulnerabilityAlertEventCreateAction] = append(
		g.onRepositoryVulnerabilityAlertEvent[RepositoryVulnerabilityAlertEventCreateAction],
		callbacks...,
	)
}

// SetOnRepositoryVulnerabilityAlertEventCreate registers callbacks listening to events of type github.RepositoryVulnerabilityAlertEvent and action 'create'
// and overwrites already registered callbacks.
//
// This function overwrites all previously registered callbacks.
// If already registered callbacks are not to be overwritten, OnRepositoryVulnerabilityAlertEventCreateAny 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#repository_vulnerability_alert
func (g *EventHandler) SetOnRepositoryVulnerabilityAlertEventCreate(callbacks ...RepositoryVulnerabilityAlertEventHandleFunc) {
	g.mu.Lock()
	defer g.mu.Unlock()
	if callbacks == nil || len(callbacks) == 0 {
		panic("callbacks is nil or empty")
	}
	if g.onRepositoryVulnerabilityAlertEvent == nil {
		g.onRepositoryVulnerabilityAlertEvent = make(map[string][]RepositoryVulnerabilityAlertEventHandleFunc)
	}
	g.onRepositoryVulnerabilityAlertEvent[RepositoryVulnerabilityAlertEventCreateAction] = callbacks
}

func (g *EventHandler) handleRepositoryVulnerabilityAlertEventCreate(deliveryID string, eventName string, event *github.RepositoryVulnerabilityAlertEvent) error {
	if event == nil || event.Action == nil || *event.Action == "" {
		return fmt.Errorf("event action was empty or nil")
	}
	if RepositoryVulnerabilityAlertEventCreateAction != *event.Action {
		return fmt.Errorf(
			"handleRepositoryVulnerabilityAlertEventCreate() called with wrong action, want %s, got %s",
			RepositoryVulnerabilityAlertEventCreateAction,
			*event.Action,
		)
	}
	eg := new(errgroup.Group)
	for _, action := range []string{
		RepositoryVulnerabilityAlertEventCreateAction,
		RepositoryVulnerabilityAlertEventAnyAction,
	} {
		if _, ok := g.onRepositoryVulnerabilityAlertEvent[action]; ok {
			for _, h := range g.onRepositoryVulnerabilityAlertEvent[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
}

// OnRepositoryVulnerabilityAlertEventDismiss registers callbacks listening to events of type github.RepositoryVulnerabilityAlertEvent and action 'dismiss'.
//
// This function appends the callbacks passed as arguments to already existing ones.
// If already existing callbacks are to be overwritten, SetOnRepositoryVulnerabilityAlertEventDismiss 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#repository_vulnerability_alert
func (g *EventHandler) OnRepositoryVulnerabilityAlertEventDismiss(callbacks ...RepositoryVulnerabilityAlertEventHandleFunc) {
	g.mu.Lock()
	defer g.mu.Unlock()
	if callbacks == nil || len(callbacks) == 0 {
		panic("callbacks is nil or empty")
	}
	if g.onRepositoryVulnerabilityAlertEvent == nil {
		g.onRepositoryVulnerabilityAlertEvent = make(map[string][]RepositoryVulnerabilityAlertEventHandleFunc)
	}
	g.onRepositoryVulnerabilityAlertEvent[RepositoryVulnerabilityAlertEventDismissAction] = append(
		g.onRepositoryVulnerabilityAlertEvent[RepositoryVulnerabilityAlertEventDismissAction],
		callbacks...,
	)
}

// SetOnRepositoryVulnerabilityAlertEventDismiss registers callbacks listening to events of type github.RepositoryVulnerabilityAlertEvent and action 'dismiss'
// and overwrites already registered callbacks.
//
// This function overwrites all previously registered callbacks.
// If already registered callbacks are not to be overwritten, OnRepositoryVulnerabilityAlertEventDismissAny 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#repository_vulnerability_alert
func (g *EventHandler) SetOnRepositoryVulnerabilityAlertEventDismiss(callbacks ...RepositoryVulnerabilityAlertEventHandleFunc) {
	g.mu.Lock()
	defer g.mu.Unlock()
	if callbacks == nil || len(callbacks) == 0 {
		panic("callbacks is nil or empty")
	}
	if g.onRepositoryVulnerabilityAlertEvent == nil {
		g.onRepositoryVulnerabilityAlertEvent = make(map[string][]RepositoryVulnerabilityAlertEventHandleFunc)
	}
	g.onRepositoryVulnerabilityAlertEvent[RepositoryVulnerabilityAlertEventDismissAction] = callbacks
}

func (g *EventHandler) handleRepositoryVulnerabilityAlertEventDismiss(deliveryID string, eventName string, event *github.RepositoryVulnerabilityAlertEvent) error {
	if event == nil || event.Action == nil || *event.Action == "" {
		return fmt.Errorf("event action was empty or nil")
	}
	if RepositoryVulnerabilityAlertEventDismissAction != *event.Action {
		return fmt.Errorf(
			"handleRepositoryVulnerabilityAlertEventDismiss() called with wrong action, want %s, got %s",
			RepositoryVulnerabilityAlertEventDismissAction,
			*event.Action,
		)
	}
	eg := new(errgroup.Group)
	for _, action := range []string{
		RepositoryVulnerabilityAlertEventDismissAction,
		RepositoryVulnerabilityAlertEventAnyAction,
	} {
		if _, ok := g.onRepositoryVulnerabilityAlertEvent[action]; ok {
			for _, h := range g.onRepositoryVulnerabilityAlertEvent[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
}

// OnRepositoryVulnerabilityAlertEventResolve registers callbacks listening to events of type github.RepositoryVulnerabilityAlertEvent and action 'resolve'.
//
// This function appends the callbacks passed as arguments to already existing ones.
// If already existing callbacks are to be overwritten, SetOnRepositoryVulnerabilityAlertEventResolve 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#repository_vulnerability_alert
func (g *EventHandler) OnRepositoryVulnerabilityAlertEventResolve(callbacks ...RepositoryVulnerabilityAlertEventHandleFunc) {
	g.mu.Lock()
	defer g.mu.Unlock()
	if callbacks == nil || len(callbacks) == 0 {
		panic("callbacks is nil or empty")
	}
	if g.onRepositoryVulnerabilityAlertEvent == nil {
		g.onRepositoryVulnerabilityAlertEvent = make(map[string][]RepositoryVulnerabilityAlertEventHandleFunc)
	}
	g.onRepositoryVulnerabilityAlertEvent[RepositoryVulnerabilityAlertEventResolveAction] = append(
		g.onRepositoryVulnerabilityAlertEvent[RepositoryVulnerabilityAlertEventResolveAction],
		callbacks...,
	)
}

// SetOnRepositoryVulnerabilityAlertEventResolve registers callbacks listening to events of type github.RepositoryVulnerabilityAlertEvent and action 'resolve'
// and overwrites already registered callbacks.
//
// This function overwrites all previously registered callbacks.
// If already registered callbacks are not to be overwritten, OnRepositoryVulnerabilityAlertEventResolveAny 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#repository_vulnerability_alert
func (g *EventHandler) SetOnRepositoryVulnerabilityAlertEventResolve(callbacks ...RepositoryVulnerabilityAlertEventHandleFunc) {
	g.mu.Lock()
	defer g.mu.Unlock()
	if callbacks == nil || len(callbacks) == 0 {
		panic("callbacks is nil or empty")
	}
	if g.onRepositoryVulnerabilityAlertEvent == nil {
		g.onRepositoryVulnerabilityAlertEvent = make(map[string][]RepositoryVulnerabilityAlertEventHandleFunc)
	}
	g.onRepositoryVulnerabilityAlertEvent[RepositoryVulnerabilityAlertEventResolveAction] = callbacks
}

func (g *EventHandler) handleRepositoryVulnerabilityAlertEventResolve(deliveryID string, eventName string, event *github.RepositoryVulnerabilityAlertEvent) error {
	if event == nil || event.Action == nil || *event.Action == "" {
		return fmt.Errorf("event action was empty or nil")
	}
	if RepositoryVulnerabilityAlertEventResolveAction != *event.Action {
		return fmt.Errorf(
			"handleRepositoryVulnerabilityAlertEventResolve() called with wrong action, want %s, got %s",
			RepositoryVulnerabilityAlertEventResolveAction,
			*event.Action,
		)
	}
	eg := new(errgroup.Group)
	for _, action := range []string{
		RepositoryVulnerabilityAlertEventResolveAction,
		RepositoryVulnerabilityAlertEventAnyAction,
	} {
		if _, ok := g.onRepositoryVulnerabilityAlertEvent[action]; ok {
			for _, h := range g.onRepositoryVulnerabilityAlertEvent[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
}

// OnRepositoryVulnerabilityAlertEventAny registers callbacks listening to any events of type github.RepositoryVulnerabilityAlertEvent
//
// This function appends the callbacks passed as arguments to already existing ones.
// If already existing callbacks are to be overwritten, SetOnRepositoryVulnerabilityAlertEventAny 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#repository_vulnerability_alert
func (g *EventHandler) OnRepositoryVulnerabilityAlertEventAny(callbacks ...RepositoryVulnerabilityAlertEventHandleFunc) {
	g.mu.Lock()
	defer g.mu.Unlock()
	if callbacks == nil || len(callbacks) == 0 {
		panic("callbacks is nil or empty")
	}
	if g.onRepositoryVulnerabilityAlertEvent == nil {
		g.onRepositoryVulnerabilityAlertEvent = make(map[string][]RepositoryVulnerabilityAlertEventHandleFunc)
	}
	g.onRepositoryVulnerabilityAlertEvent[RepositoryVulnerabilityAlertEventAnyAction] = append(
		g.onRepositoryVulnerabilityAlertEvent[RepositoryVulnerabilityAlertEventAnyAction],
		callbacks...,
	)
}

// SetOnRepositoryVulnerabilityAlertEventAny registers callbacks listening to any events of type github.RepositoryVulnerabilityAlertEvent
// and overwrites already registered callbacks.
//
// This function overwrites all previously registered callbacks.
// If already registered callbacks are not to be overwritten, OnRepositoryVulnerabilityAlertEventAny 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#repository_vulnerability_alert
func (g *EventHandler) SetOnRepositoryVulnerabilityAlertEventAny(callbacks ...RepositoryVulnerabilityAlertEventHandleFunc) {
	g.mu.Lock()
	defer g.mu.Unlock()
	if callbacks == nil || len(callbacks) == 0 {
		panic("callbacks is nil or empty")
	}
	if g.onRepositoryVulnerabilityAlertEvent == nil {
		g.onRepositoryVulnerabilityAlertEvent = make(map[string][]RepositoryVulnerabilityAlertEventHandleFunc)
	}
	g.onRepositoryVulnerabilityAlertEvent[RepositoryVulnerabilityAlertEventAnyAction] = callbacks
}

func (g *EventHandler) handleRepositoryVulnerabilityAlertEventAny(deliveryID string, eventName string, event *github.RepositoryVulnerabilityAlertEvent) error {
	if event == nil {
		return fmt.Errorf("event was empty or nil")
	}
	if _, ok := g.onRepositoryVulnerabilityAlertEvent[RepositoryVulnerabilityAlertEventAnyAction]; !ok {
		return nil
	}
	eg := new(errgroup.Group)
	for _, h := range g.onRepositoryVulnerabilityAlertEvent[RepositoryVulnerabilityAlertEventAnyAction] {
		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
}

// RepositoryVulnerabilityAlertEvent handles github.RepositoryVulnerabilityAlertEvent.
//
// Callbacks are executed in the following order:
//
// 1) All callbacks registered with OnBeforeAny are executed in parallel.
// 2) All callbacks registered with OnRepositoryVulnerabilityAlertEvent... are executed in parallel in case the Event has actions.
// 3) All callbacks registered with OnAfterAny are executed in parallel.
//
// on any error all callbacks registered with OnError are executed in parallel.
func (g *EventHandler) RepositoryVulnerabilityAlertEvent(deliveryID string, eventName string, event *github.RepositoryVulnerabilityAlertEvent) error {

	if event == nil || event.Action == nil || *event.Action == "" {
		return fmt.Errorf("event action was empty or nil")
	}
	action := *event.Action

	err := g.handleBeforeAny(deliveryID, eventName, event)
	if err != nil {
		return g.handleError(deliveryID, eventName, event, err)
	}

	switch action {

	case RepositoryVulnerabilityAlertEventCreateAction:
		err := g.handleRepositoryVulnerabilityAlertEventCreate(deliveryID, eventName, event)
		if err != nil {
			return g.handleError(deliveryID, eventName, event, err)
		}

	case RepositoryVulnerabilityAlertEventDismissAction:
		err := g.handleRepositoryVulnerabilityAlertEventDismiss(deliveryID, eventName, event)
		if err != nil {
			return g.handleError(deliveryID, eventName, event, err)
		}

	case RepositoryVulnerabilityAlertEventResolveAction:
		err := g.handleRepositoryVulnerabilityAlertEventResolve(deliveryID, eventName, event)
		if err != nil {
			return g.handleError(deliveryID, eventName, event, err)
		}

	default:
		err := g.handleRepositoryVulnerabilityAlertEventAny(deliveryID, eventName, event)
		if err != nil {
			return g.handleError(deliveryID, eventName, event, err)
		}
	}

	err = g.handleAfterAny(deliveryID, eventName, event)
	if err != nil {
		return g.handleError(deliveryID, eventName, event, err)
	}
	return nil
}