git_webhook_spec.go

// Code generated by go-swagger; DO NOT EDIT.

package models

// This file was generated by the swagger tool.
// Editing this file might prove futile when you re-run the swagger generate command

import (
	"bytes"
	"context"
	"encoding/json"
	"io"
	"strconv"

	"github.com/go-openapi/errors"
	"github.com/go-openapi/runtime"
	"github.com/go-openapi/strfmt"
	"github.com/go-openapi/swag"
	"github.com/go-openapi/validate"
)

// GitWebhookSpec GitWebhookSpec
//
// Git Webhook specification.
//
// swagger:discriminator GitWebhookSpec Git Webhook specification.
type GitWebhookSpec interface {
	runtime.Validatable
	runtime.ContextValidatable

	// Branch name for which the webhook has been configured.
	// Example: master
	BranchName() string
	SetBranchName(string)

	// Delay time after which the pipeline execution is triggered.
	// Example: 2
	DelayTimeInMins() int32
	SetDelayTimeInMins(int32)

	// A human-friendly description.
	// Required: true
	Description() *string
	SetDescription(*string)

	// Git endpoint.
	// Example: GitHub-SaaS
	Endpoint() string
	SetEndpoint(string)

	// Git event type.
	// Example: PUSH
	EventCategory() string
	SetEventCategory(string)

	// Provide file exclusions as conditions for the trigger.
	// Example: [{"type":"PLAIN","value":"example.txt"}]
	Exclusions() []*GitWebhookFileFilter
	SetExclusions([]*GitWebhookFileFilter)

	// Git webhook listener link.
	// Example: codestream/api/git-webhook-listeners/173f5ed5-2197-4975-b782-a8679b2e4cd3
	ExternalListenerLink() string
	SetExternalListenerLink(string)

	// Provide file inclusions as conditions for the trigger.
	// Example: [{"type":"PLAIN","value":"example.txt"}]
	Inclusions() []*GitWebhookFileFilter
	SetInclusions([]*GitWebhookFileFilter)

	// Pipeline Execution input properties.
	// Example: {"test":{"description":"test-value","mandatory":false}}
	Input() interface{}
	SetInput(interface{})

	// verify SSL certificates when delivering payloads
	// Example: true
	InsecureSsl() bool
	SetInsecureSsl(bool)

	// A human-friendly name used as an identifier in APIs that support this option
	// Example: My-Name
	// Required: true
	Name() *string
	SetName(*string)

	// Pipeline name which is meant to be triggered when a git event occur.
	// Example: CICD-Pipeline
	Pipeline() string
	SetPipeline(string)

	// Prioritize Exclusion ensures that pipelines are not triggered even if any of the files in a commit match the specified files in the exclusion paths or regex.
	// Example: true
	PrioritizeExclusion() bool
	SetPrioritizeExclusion(bool)

	// The project this entity belongs to.
	// Example: My-Project
	Project() string
	SetProject(string)

	// Codestream API token.
	// Example: I5FLA8iQhlZwoos6OL3goKciAF5e
	RefreshToken() string
	SetRefreshToken(string)

	// Repo name for which the webhook has been configured.
	// Example: Codestream
	RepoName() string
	SetRepoName(string)

	// Secret token to validate received payloads.
	// Example: DSkUyJJ8KA8rOSk=Ci
	SecretToken() string
	SetSecretToken(string)

	// Git Server Type.
	// Example: GITHUB/GITLAB/BITBUCKET
	ServerType() string
	SetServerType(string)

	// Git webhook id.
	// Example: serverWebhookId\": \"12678345
	ServerWebhookID() string
	SetServerWebhookID(string)

	// AdditionalProperties in base type shoud be handled just like regular properties
	// At this moment, the base type property is pushed down to the subtype
}

type gitWebhookSpec struct {
	branchNameField string

	delayTimeInMinsField int32

	descriptionField *string

	endpointField string

	eventCategoryField string

	exclusionsField []*GitWebhookFileFilter

	externalListenerLinkField string

	inclusionsField []*GitWebhookFileFilter

	inputField interface{}

	insecureSslField bool

	nameField *string

	pipelineField string

	prioritizeExclusionField bool

	projectField string

	refreshTokenField string

	repoNameField string

	secretTokenField string

	serverTypeField string

	serverWebhookIdField string
}

// BranchName gets the branch name of this polymorphic type
func (m *gitWebhookSpec) BranchName() string {
	return m.branchNameField
}

// SetBranchName sets the branch name of this polymorphic type
func (m *gitWebhookSpec) SetBranchName(val string) {
	m.branchNameField = val
}

// DelayTimeInMins gets the delay time in mins of this polymorphic type
func (m *gitWebhookSpec) DelayTimeInMins() int32 {
	return m.delayTimeInMinsField
}

// SetDelayTimeInMins sets the delay time in mins of this polymorphic type
func (m *gitWebhookSpec) SetDelayTimeInMins(val int32) {
	m.delayTimeInMinsField = val
}

// Description gets the description of this polymorphic type
func (m *gitWebhookSpec) Description() *string {
	return m.descriptionField
}

// SetDescription sets the description of this polymorphic type
func (m *gitWebhookSpec) SetDescription(val *string) {
	m.descriptionField = val
}

// Endpoint gets the endpoint of this polymorphic type
func (m *gitWebhookSpec) Endpoint() string {
	return m.endpointField
}

// SetEndpoint sets the endpoint of this polymorphic type
func (m *gitWebhookSpec) SetEndpoint(val string) {
	m.endpointField = val
}

// EventCategory gets the event category of this polymorphic type
func (m *gitWebhookSpec) EventCategory() string {
	return m.eventCategoryField
}

// SetEventCategory sets the event category of this polymorphic type
func (m *gitWebhookSpec) SetEventCategory(val string) {
	m.eventCategoryField = val
}

// Exclusions gets the exclusions of this polymorphic type
func (m *gitWebhookSpec) Exclusions() []*GitWebhookFileFilter {
	return m.exclusionsField
}

// SetExclusions sets the exclusions of this polymorphic type
func (m *gitWebhookSpec) SetExclusions(val []*GitWebhookFileFilter) {
	m.exclusionsField = val
}

// ExternalListenerLink gets the external listener link of this polymorphic type
func (m *gitWebhookSpec) ExternalListenerLink() string {
	return m.externalListenerLinkField
}

// SetExternalListenerLink sets the external listener link of this polymorphic type
func (m *gitWebhookSpec) SetExternalListenerLink(val string) {
	m.externalListenerLinkField = val
}

// Inclusions gets the inclusions of this polymorphic type
func (m *gitWebhookSpec) Inclusions() []*GitWebhookFileFilter {
	return m.inclusionsField
}

// SetInclusions sets the inclusions of this polymorphic type
func (m *gitWebhookSpec) SetInclusions(val []*GitWebhookFileFilter) {
	m.inclusionsField = val
}

// Input gets the input of this polymorphic type
func (m *gitWebhookSpec) Input() interface{} {
	return m.inputField
}

// SetInput sets the input of this polymorphic type
func (m *gitWebhookSpec) SetInput(val interface{}) {
	m.inputField = val
}

// InsecureSsl gets the insecure ssl of this polymorphic type
func (m *gitWebhookSpec) InsecureSsl() bool {
	return m.insecureSslField
}

// SetInsecureSsl sets the insecure ssl of this polymorphic type
func (m *gitWebhookSpec) SetInsecureSsl(val bool) {
	m.insecureSslField = val
}

// Name gets the name of this polymorphic type
func (m *gitWebhookSpec) Name() *string {
	return m.nameField
}

// SetName sets the name of this polymorphic type
func (m *gitWebhookSpec) SetName(val *string) {
	m.nameField = val
}

// Pipeline gets the pipeline of this polymorphic type
func (m *gitWebhookSpec) Pipeline() string {
	return m.pipelineField
}

// SetPipeline sets the pipeline of this polymorphic type
func (m *gitWebhookSpec) SetPipeline(val string) {
	m.pipelineField = val
}

// PrioritizeExclusion gets the prioritize exclusion of this polymorphic type
func (m *gitWebhookSpec) PrioritizeExclusion() bool {
	return m.prioritizeExclusionField
}

// SetPrioritizeExclusion sets the prioritize exclusion of this polymorphic type
func (m *gitWebhookSpec) SetPrioritizeExclusion(val bool) {
	m.prioritizeExclusionField = val
}

// Project gets the project of this polymorphic type
func (m *gitWebhookSpec) Project() string {
	return m.projectField
}

// SetProject sets the project of this polymorphic type
func (m *gitWebhookSpec) SetProject(val string) {
	m.projectField = val
}

// RefreshToken gets the refresh token of this polymorphic type
func (m *gitWebhookSpec) RefreshToken() string {
	return m.refreshTokenField
}

// SetRefreshToken sets the refresh token of this polymorphic type
func (m *gitWebhookSpec) SetRefreshToken(val string) {
	m.refreshTokenField = val
}

// RepoName gets the repo name of this polymorphic type
func (m *gitWebhookSpec) RepoName() string {
	return m.repoNameField
}

// SetRepoName sets the repo name of this polymorphic type
func (m *gitWebhookSpec) SetRepoName(val string) {
	m.repoNameField = val
}

// SecretToken gets the secret token of this polymorphic type
func (m *gitWebhookSpec) SecretToken() string {
	return m.secretTokenField
}

// SetSecretToken sets the secret token of this polymorphic type
func (m *gitWebhookSpec) SetSecretToken(val string) {
	m.secretTokenField = val
}

// ServerType gets the server type of this polymorphic type
func (m *gitWebhookSpec) ServerType() string {
	return m.serverTypeField
}

// SetServerType sets the server type of this polymorphic type
func (m *gitWebhookSpec) SetServerType(val string) {
	m.serverTypeField = val
}

// ServerWebhookID gets the server webhook Id of this polymorphic type
func (m *gitWebhookSpec) ServerWebhookID() string {
	return m.serverWebhookIdField
}

// SetServerWebhookID sets the server webhook Id of this polymorphic type
func (m *gitWebhookSpec) SetServerWebhookID(val string) {
	m.serverWebhookIdField = val
}

// UnmarshalGitWebhookSpecSlice unmarshals polymorphic slices of GitWebhookSpec
func UnmarshalGitWebhookSpecSlice(reader io.Reader, consumer runtime.Consumer) ([]GitWebhookSpec, error) {
	var elements []json.RawMessage
	if err := consumer.Consume(reader, &elements); err != nil {
		return nil, err
	}

	var result []GitWebhookSpec
	for _, element := range elements {
		obj, err := unmarshalGitWebhookSpec(element, consumer)
		if err != nil {
			return nil, err
		}
		result = append(result, obj)
	}
	return result, nil
}

// UnmarshalGitWebhookSpec unmarshals polymorphic GitWebhookSpec
func UnmarshalGitWebhookSpec(reader io.Reader, consumer runtime.Consumer) (GitWebhookSpec, error) {
	// we need to read this twice, so first into a buffer
	data, err := io.ReadAll(reader)
	if err != nil {
		return nil, err
	}
	return unmarshalGitWebhookSpec(data, consumer)
}

func unmarshalGitWebhookSpec(data []byte, consumer runtime.Consumer) (GitWebhookSpec, error) {
	buf := bytes.NewBuffer(data)
	buf2 := bytes.NewBuffer(data)

	// the first time this is read is to fetch the value of the Git Webhook specification. property.
	var getType struct {
		GitWebhookSpecification string `json:"Git Webhook specification."`
	}
	if err := consumer.Consume(buf, &getType); err != nil {
		return nil, err
	}

	if err := validate.RequiredString("Git Webhook specification.", "body", getType.GitWebhookSpecification); err != nil {
		return nil, err
	}

	// The value of Git Webhook specification. is used to determine which type to create and unmarshal the data into
	switch getType.GitWebhookSpecification {
	case "GitWebhookSpec":
		var result gitWebhookSpec
		if err := consumer.Consume(buf2, &result); err != nil {
			return nil, err
		}
		return &result, nil
	}
	return nil, errors.New(422, "invalid Git Webhook specification. value: %q", getType.GitWebhookSpecification)
}

// Validate validates this git webhook spec
func (m *gitWebhookSpec) Validate(formats strfmt.Registry) error {
	var res []error

	if err := m.validateDescription(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateExclusions(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateInclusions(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateName(formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

func (m *gitWebhookSpec) validateDescription(formats strfmt.Registry) error {

	if err := validate.Required("description", "body", m.Description()); err != nil {
		return err
	}

	return nil
}

func (m *gitWebhookSpec) validateExclusions(formats strfmt.Registry) error {
	if swag.IsZero(m.Exclusions()) { // not required
		return nil
	}

	for i := 0; i < len(m.Exclusions()); i++ {
		if swag.IsZero(m.exclusionsField[i]) { // not required
			continue
		}

		if m.exclusionsField[i] != nil {
			if err := m.exclusionsField[i].Validate(formats); err != nil {
				if ve, ok := err.(*errors.Validation); ok {
					return ve.ValidateName("exclusions" + "." + strconv.Itoa(i))
				} else if ce, ok := err.(*errors.CompositeError); ok {
					return ce.ValidateName("exclusions" + "." + strconv.Itoa(i))
				}
				return err
			}
		}

	}

	return nil
}

func (m *gitWebhookSpec) validateInclusions(formats strfmt.Registry) error {
	if swag.IsZero(m.Inclusions()) { // not required
		return nil
	}

	for i := 0; i < len(m.Inclusions()); i++ {
		if swag.IsZero(m.inclusionsField[i]) { // not required
			continue
		}

		if m.inclusionsField[i] != nil {
			if err := m.inclusionsField[i].Validate(formats); err != nil {
				if ve, ok := err.(*errors.Validation); ok {
					return ve.ValidateName("inclusions" + "." + strconv.Itoa(i))
				} else if ce, ok := err.(*errors.CompositeError); ok {
					return ce.ValidateName("inclusions" + "." + strconv.Itoa(i))
				}
				return err
			}
		}

	}

	return nil
}

func (m *gitWebhookSpec) validateName(formats strfmt.Registry) error {

	if err := validate.Required("name", "body", m.Name()); err != nil {
		return err
	}

	return nil
}

// ContextValidate validate this git webhook spec based on the context it is used
func (m *gitWebhookSpec) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	var res []error

	if err := m.contextValidateExclusions(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateInclusions(ctx, formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

func (m *gitWebhookSpec) contextValidateExclusions(ctx context.Context, formats strfmt.Registry) error {

	for i := 0; i < len(m.Exclusions()); i++ {

		if m.exclusionsField[i] != nil {
			if err := m.exclusionsField[i].ContextValidate(ctx, formats); err != nil {
				if ve, ok := err.(*errors.Validation); ok {
					return ve.ValidateName("exclusions" + "." + strconv.Itoa(i))
				} else if ce, ok := err.(*errors.CompositeError); ok {
					return ce.ValidateName("exclusions" + "." + strconv.Itoa(i))
				}
				return err
			}
		}

	}

	return nil
}

func (m *gitWebhookSpec) contextValidateInclusions(ctx context.Context, formats strfmt.Registry) error {

	for i := 0; i < len(m.Inclusions()); i++ {

		if m.inclusionsField[i] != nil {
			if err := m.inclusionsField[i].ContextValidate(ctx, formats); err != nil {
				if ve, ok := err.(*errors.Validation); ok {
					return ve.ValidateName("inclusions" + "." + strconv.Itoa(i))
				} else if ce, ok := err.(*errors.CompositeError); ok {
					return ce.ValidateName("inclusions" + "." + strconv.Itoa(i))
				}
				return err
			}
		}

	}

	return nil
}