db

package
v0.53.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Mar 20, 2026 License: MPL-2.0 Imports: 37 Imported by: 0

Documentation

Overview

Package db encapsulates all the logic needed to access information from the DB.

Index

Constants

This section is empty.

Variables

View Source 
var (
	// ErrOptimisticLockError is used for optimistic lock exceptions
	ErrOptimisticLockError = te.New(
		"resource version does not match specified version",
		te.WithErrorCode(te.EOptimisticLock),
	)
	// ErrInvalidID is used for invalid resource UUIDs
	ErrInvalidID = te.New(
		"invalid id: the id must be a valid uuid",
		te.WithErrorCode(te.EInvalid),
	)
)

Functions

func WithRetryOnOLEAttempts added in v0.42.0 

func WithRetryOnOLEAttempts(attempts uint) func(*retryOnOLEOptions)

WithRetryOnOLEAttempts sets the number of attempts to retry on optimistic lock error

Types

type ActivityEventFilter 

type ActivityEventFilter struct {
	TimeRangeEnd          *time.Time
	UserID                *string
	ServiceAccountID      *string
	OrganizationID        *string
	ProjectID             *string
	ReleaseTargetID       *string
	TimeRangeStart        *time.Time
	MembershipRequirement *ActivityEventMembershipRequirement
	Actions               []models.ActivityEventAction
	TargetTypes           []models.ActivityEventTargetType
}

ActivityEventFilter contains the supported fields for filtering activity event resources

type ActivityEventMembershipRequirement 

type ActivityEventMembershipRequirement struct {
	UserID           *string
	ServiceAccountID *string
}

ActivityEventMembershipRequirement represents a requirement for querying activity events for a user or service account.

type ActivityEventSortableField 

type ActivityEventSortableField string

ActivityEventSortableField represents a sortable field for activity events. 

const (
	ActivityEventSortableFieldCreatedAtAsc  ActivityEventSortableField = "CREATED_AT_ASC"
	ActivityEventSortableFieldCreatedAtDesc ActivityEventSortableField = "CREATED_AT_DESC"
	ActivityEventSortableFieldActionAsc     ActivityEventSortableField = "ACTION_ASC"
	ActivityEventSortableFieldActionDesc    ActivityEventSortableField = "ACTION_DESC"
)

ActivityEventSortableField values.

type ActivityEvents 

type ActivityEvents interface {
	GetActivityEventByID(ctx context.Context, id string) (*models.ActivityEvent, error)
	GetActivityEvents(ctx context.Context, input *GetActivityEventsInput) (*ActivityEventsResult, error)
	CreateActivityEvent(ctx context.Context, input *models.ActivityEvent) (*models.ActivityEvent, error)
}

ActivityEvents encapsulates the logic for interfacing with the activity events database.

func NewActivityEvents 

func NewActivityEvents(dbClient *Client) ActivityEvents

NewActivityEvents creates a new activity events database client.

type ActivityEventsResult 

type ActivityEventsResult struct {
	PageInfo       *pagination.PageInfo
	ActivityEvents []models.ActivityEvent
}

ActivityEventsResult contains the response data and page information

type AddWorkItemToQueueInput added in v0.52.0 

type AddWorkItemToQueueInput struct {
	Type        WorkItemType
	Payload     any
	AvailableAt *time.Time
}

AddWorkItemToQueueInput is the input for creating a work item and its information in a payload.

type AgentFilter 

type AgentFilter struct {
	OrganizationID *string
	AgentName      *string
	AgentID        *string
	AgentType      *models.AgentType
	Enabled        *bool
	AgentIDs       []string
}

AgentFilter contains the supported fields for filtering Agent resources

type AgentSessionEventData added in v0.7.0 

type AgentSessionEventData struct {
	ID      string `json:"id"`
	AgentID string `json:"agent_id"`
}

AgentSessionEventData contains the event response data for a row from the agent_sessions table.

type AgentSessionFilter 

type AgentSessionFilter struct {
	AgentID         *string
	AgentSessionIDs []string
}

AgentSessionFilter contains the supported fields for filtering AgentSession resources

type AgentSessionSortableField 

type AgentSessionSortableField string

AgentSessionSortableField represents the fields that sessions can be sorted by 

const (
	AgentSessionSortableFieldCreatedAtAsc        AgentSessionSortableField = "CREATED_AT_ASC"
	AgentSessionSortableFieldCreatedAtDesc       AgentSessionSortableField = "CREATED_AT_DESC"
	AgentSessionSortableFieldLastContactedAtAsc  AgentSessionSortableField = "LAST_CONTACTED_AT_ASC"
	AgentSessionSortableFieldLastContactedAtDesc AgentSessionSortableField = "LAST_CONTACTED_AT_DESC"
)

AgentSessionSortableField constants

type AgentSessions 

type AgentSessions interface {
	GetAgentSessionByID(ctx context.Context, id string) (*models.AgentSession, error)
	GetAgentSessionByPRN(ctx context.Context, prn string) (*models.AgentSession, error)
	GetAgentSessions(ctx context.Context, input *GetAgentSessionsInput) (*AgentSessionsResult, error)
	CreateAgentSession(ctx context.Context, session *models.AgentSession) (*models.AgentSession, error)
	UpdateAgentSession(ctx context.Context, session *models.AgentSession) (*models.AgentSession, error)
	DeleteAgentSession(ctx context.Context, session *models.AgentSession) error
}

AgentSessions encapsulates the logic to access sessions from the database

func NewAgentSessions 

func NewAgentSessions(dbClient *Client) AgentSessions

NewAgentSessions returns an instance of the AgentSessions interface

type AgentSessionsResult 

type AgentSessionsResult struct {
	PageInfo      *pagination.PageInfo
	AgentSessions []models.AgentSession
}

AgentSessionsResult contains the response data and page information

type AgentSortableField 

type AgentSortableField string

AgentSortableField represents the fields that agents can be sorted by 

const (
	AgentSortableFieldUpdatedAtAsc  AgentSortableField = "UPDATED_AT_ASC"
	AgentSortableFieldUpdatedAtDesc AgentSortableField = "UPDATED_AT_DESC"
)

AgentSortableField constants

type Agents 

type Agents interface {
	GetAgentByID(ctx context.Context, id string) (*models.Agent, error)
	GetAgentByPRN(ctx context.Context, prn string) (*models.Agent, error)
	GetAgents(ctx context.Context, input *GetAgentsInput) (*AgentsResult, error)
	CreateAgent(ctx context.Context, agent *models.Agent) (*models.Agent, error)
	UpdateAgent(ctx context.Context, agent *models.Agent) (*models.Agent, error)
	DeleteAgent(ctx context.Context, agent *models.Agent) error
}

Agents encapsulates the logic to access agents from the database

func NewAgents 

func NewAgents(dbClient *Client) Agents

NewAgents returns an instance of the Agents interface

type AgentsResult 

type AgentsResult struct {
	PageInfo *pagination.PageInfo
	Agents   []models.Agent
}

AgentsResult contains the response data and page information

type AggregatedMetric 

type AggregatedMetric struct {
	Bucket time.Time
	Stats  MetricStatistics
}

AggregatedMetric represents the aggregated metric statistics

type AnnouncementFilter added in v0.39.0 

type AnnouncementFilter struct {
	Active *bool
}

AnnouncementFilter contains the supported fields for filtering Announcement resources

type AnnouncementSortableField added in v0.39.0 

type AnnouncementSortableField string

AnnouncementSortableField represents the fields that announcements can be sorted by 

const (
	AnnouncementSortableFieldCreatedAtAsc  AnnouncementSortableField = "CREATED_AT_ASC"
	AnnouncementSortableFieldCreatedAtDesc AnnouncementSortableField = "CREATED_AT_DESC"
	AnnouncementSortableFieldStartTimeAsc  AnnouncementSortableField = "START_TIME_ASC"
	AnnouncementSortableFieldStartTimeDesc AnnouncementSortableField = "START_TIME_DESC"
)

AnnouncementSortableField constants

type Announcements added in v0.39.0 

type Announcements interface {
	GetAnnouncementByID(ctx context.Context, id string) (*models.Announcement, error)
	GetAnnouncementByPRN(ctx context.Context, prn string) (*models.Announcement, error)
	GetAnnouncements(ctx context.Context, input *GetAnnouncementsInput) (*AnnouncementsResult, error)
	CreateAnnouncement(ctx context.Context, announcement *models.Announcement) (*models.Announcement, error)
	UpdateAnnouncement(ctx context.Context, announcement *models.Announcement) (*models.Announcement, error)
	DeleteAnnouncement(ctx context.Context, announcement *models.Announcement) error
}

Announcements encapsulates the logic to access announcements from the database

func NewAnnouncements added in v0.39.0 

func NewAnnouncements(dbClient *Client) Announcements

NewAnnouncements returns an instance of the Announcements interface

type AnnouncementsResult added in v0.39.0 

type AnnouncementsResult struct {
	PageInfo      *pagination.PageInfo
	Announcements []models.Announcement
}

AnnouncementsResult contains the response data and page information

type ApprovalRuleFilter 

type ApprovalRuleFilter struct {
	OrgID              *string
	ProjectID          *string
	ApprovalRuleScopes []models.ScopeType
	ApprovalRuleIDs    []string
}

ApprovalRuleFilter contains the supported fields for filtering ApprovalRule resources

type ApprovalRuleSortableField 

type ApprovalRuleSortableField string

ApprovalRuleSortableField represents the fields that an organization can be sorted by 

const (
	ApprovalRuleSortableFieldUpdatedAtAsc  ApprovalRuleSortableField = "UPDATED_AT_ASC"
	ApprovalRuleSortableFieldUpdatedAtDesc ApprovalRuleSortableField = "UPDATED_AT_DESC"
)

ApprovalRuleSortableField constants

type ApprovalRules 

type ApprovalRules interface {
	GetApprovalRuleByPRN(ctx context.Context, prn string) (*models.ApprovalRule, error)
	GetApprovalRuleByID(ctx context.Context, id string) (*models.ApprovalRule, error)
	CreateApprovalRule(ctx context.Context, req *models.ApprovalRule) (*models.ApprovalRule, error)
	UpdateApprovalRule(ctx context.Context, rule *models.ApprovalRule) (*models.ApprovalRule, error)
	GetApprovalRules(ctx context.Context, input *GetApprovalRulesInput) (*ApprovalRulesResult, error)
	DeleteApprovalRule(ctx context.Context, rule *models.ApprovalRule) error
}

ApprovalRules encapsulates the logic to access state version reqs from the database

func NewApprovalRules 

func NewApprovalRules(dbClient *Client) ApprovalRules

NewApprovalRules returns an instance of the ApprovalRules interface

type ApprovalRulesResult 

type ApprovalRulesResult struct {
	PageInfo      *pagination.PageInfo
	ApprovalRules []*models.ApprovalRule
}

ApprovalRulesResult contains the response data and page information

type AsymSigningKeyFilter added in v0.39.0 

type AsymSigningKeyFilter struct {
	Status []models.AsymSigningKeyStatus
}

AsymSigningKeyFilter contains the supported fields for filtering AsymSigningKey resources

type AsymSigningKeySortableField added in v0.39.0 

type AsymSigningKeySortableField string

AsymSigningKeySortableField represents the fields that asymmetric signing keys can be sorted by 

const (
	AsymSigningKeySortableFieldCreatedAtAsc  AsymSigningKeySortableField = "CREATED_AT_ASC"
	AsymSigningKeySortableFieldCreatedAtDesc AsymSigningKeySortableField = "CREATED_AT_DESC"
)

AsymSigningKeySortableField constants

type AsymSigningKeys added in v0.39.0 

type AsymSigningKeys interface {
	GetAsymSigningKeyByID(ctx context.Context, id string) (*models.AsymSigningKey, error)
	GetAsymSigningKeyByPRN(ctx context.Context, prn string) (*models.AsymSigningKey, error)
	GetAsymSigningKeys(ctx context.Context, input *GetAsymSigningKeysInput) (*AsymSigningKeysResult, error)
	CreateAsymSigningKey(ctx context.Context, asymSigningKey *models.AsymSigningKey) (*models.AsymSigningKey, error)
	UpdateAsymSigningKey(ctx context.Context, asymSigningKey *models.AsymSigningKey) (*models.AsymSigningKey, error)
	DeleteAsymSigningKey(ctx context.Context, asymSigningKey *models.AsymSigningKey) error
}

AsymSigningKeys encapsulates the logic to access asymmetric signing keys from the database

func NewAsymSigningKeys added in v0.39.0 

func NewAsymSigningKeys(dbClient *Client) AsymSigningKeys

NewAsymSigningKeys returns an instance of the AsymSigningKeys interface

type AsymSigningKeysResult added in v0.39.0 

type AsymSigningKeysResult struct {
	PageInfo        *pagination.PageInfo
	AsymSigningKeys []models.AsymSigningKey
}

AsymSigningKeysResult contains the response data and page information

type ClaimWorkItemsInput added in v0.52.0 

type ClaimWorkItemsInput struct {
	// Limit limit the number of returned results.
	Limit uint
	// Type filters by the work item type.
	Type WorkItemType
}

ClaimWorkItemsInput is the input for listing queued workItems

type Client 

type Client struct {
	Events                  Events
	WorkItemsQueue          WorkItemsQueue
	Users                   Users
	UserSessions            UserSessions
	Roles                   Roles
	Organizations           Organizations
	Memberships             Memberships
	Transactions            Transactions
	ResourceLimits          ResourceLimits
	Projects                Projects
	ProjectVariableSets     ProjectVariableSets
	ProjectVariables        ProjectVariables
	LogStreams              LogStreams
	Teams                   Teams
	TeamMembers             TeamMembers
	SCIMTokens              SCIMTokens
	PipelineTemplates       PipelineTemplates
	Pipelines               Pipelines
	PipelineActionOutputs   PipelineActionOutputs
	PipelineOutputs         PipelineOutputs
	PipelineApprovals       PipelineApprovals
	Jobs                    Jobs
	Agents                  Agents
	AgentSessions           AgentSessions
	Environments            Environments
	ServiceAccounts         ServiceAccounts
	ApprovalRules           ApprovalRules
	LifecycleTemplates      LifecycleTemplates
	ReleaseLifecycles       ReleaseLifecycles
	Releases                Releases
	ReleaseVariables        ReleaseVariables
	ActivityEvents          ActivityEvents
	Comments                Comments
	Plugins                 Plugins
	PluginVersions          PluginVersions
	PluginPlatforms         PluginPlatforms
	ToDoItems               ToDoItems
	VCSProviders            VCSProviders
	Threads                 Threads
	Metrics                 Metrics
	EnvironmentRules        EnvironmentRules
	SchemaMigrations        SchemaMigrations
	MaintenanceModes        MaintenanceModes
	Announcements           Announcements
	AsymSigningKeys         AsymSigningKeys
	NotificationPreferences NotificationPreferences
	// contains filtered or unexported fields
}

Client acts as a facade for the database

func NewClient 

func NewClient(
	ctx context.Context,
	dbHost string,
	dbPort int,
	dbName string,
	dbSslMode string,
	dbUsername string,
	dbPassword string,
	dbMaxConnections int,
	dbAutoMigrateEnabled bool,
	logger logger.Logger,
) (*Client, error)

NewClient creates a new Client

func (*Client) Close 

func (db *Client) Close(_ context.Context)

Close will close the database connections

func (*Client) RetryOnOLE 

func (db *Client) RetryOnOLE(ctx context.Context, fn func() error, options ...RetryOnOLEOption) error

RetryOnOLE will retry the given function if an optimistic lock error occurs

type CommentEventData added in v0.7.0 

type CommentEventData struct {
	ID       string `json:"id"`
	ThreadID string `json:"thread_id"`
}

CommentEventData contains the event response data for a row from the comments table.

type CommentFilter 

type CommentFilter struct {
	ThreadID   *string
	Search     *string
	CommentIDs []string
}

CommentFilter contains the supported fields for filtering Comment resources

type CommentSortableField 

type CommentSortableField string

CommentSortableField represents the fields that a comment can be sorted by 

const (
	CommentSortableFieldCreatedAtAsc  CommentSortableField = "CREATED_AT_ASC"
	CommentSortableFieldCreatedAtDesc CommentSortableField = "CREATED_AT_DESC"
	CommentSortableFieldUpdatedAtAsc  CommentSortableField = "UPDATED_AT_ASC"
	CommentSortableFieldUpdatedAtDesc CommentSortableField = "UPDATED_AT_DESC"
)

CommentSortableField constants

type Comments 

type Comments interface {
	GetCommentByID(ctx context.Context, id string) (*models.Comment, error)
	GetCommentByPRN(ctx context.Context, prn string) (*models.Comment, error)
	GetComments(ctx context.Context, input *GetCommentsInput) (*CommentsResult, error)
	CreateComment(ctx context.Context, comment *models.Comment) (*models.Comment, error)
	UpdateComment(ctx context.Context, comment *models.Comment) (*models.Comment, error)
	DeleteComment(ctx context.Context, comment *models.Comment) error
}

Comments encapsulates the logic to access Comments from the database

func NewComments 

func NewComments(dbClient *Client) Comments

NewComments returns an instance of the Comments interface

type CommentsResult 

type CommentsResult struct {
	PageInfo *pagination.PageInfo
	Comments []models.Comment
}

CommentsResult contains the response data and page information

type DeletePipelineOutputsInput added in v0.51.0 

type DeletePipelineOutputsInput struct {
	PipelineID string
	NodePath   string
}

DeletePipelineOutputsInput specifies the criteria for deleting pipeline outputs.

type EnvironmentFilter 

type EnvironmentFilter struct {
	OrganizationID  *string
	ProjectID       *string
	EnvironmentName *string
	EnvironmentIDs  []string
}

EnvironmentFilter contains the supported fields for filtering Environment resources

type EnvironmentRuleFilter 

type EnvironmentRuleFilter struct {
	OrgID                 *string
	ProjectID             *string
	EnvironmentName       *string
	EnvironmentRuleScopes []models.ScopeType
	EnvironmentRuleIDs    []string
}

EnvironmentRuleFilter contains the supported fields for filtering EnvironmentRule resources

type EnvironmentRuleSortableField 

type EnvironmentRuleSortableField string

EnvironmentRuleSortableField represents the fields that an organization can be sorted by 

const (
	EnvironmentRuleSortableFieldCreatedAtAsc        EnvironmentRuleSortableField = "CREATED_AT_ASC"
	EnvironmentRuleSortableFieldCreatedAtDesc       EnvironmentRuleSortableField = "CREATED_AT_DESC"
	EnvironmentRuleSortableFieldUpdatedAtAsc        EnvironmentRuleSortableField = "UPDATED_AT_ASC"
	EnvironmentRuleSortableFieldUpdatedAtDesc       EnvironmentRuleSortableField = "UPDATED_AT_DESC"
	EnvironmentRuleSortableFieldEnvironmentNameAsc  EnvironmentRuleSortableField = "ENVIRONMENT_NAME_ASC"
	EnvironmentRuleSortableFieldEnvironmentNameDesc EnvironmentRuleSortableField = "ENVIRONMENT_NAME_DESC"
)

EnvironmentRuleSortableField constants

type EnvironmentRules 

type EnvironmentRules interface {
	GetEnvironmentRuleByPRN(ctx context.Context, prn string) (*models.EnvironmentRule, error)
	GetEnvironmentRuleByID(ctx context.Context, id string) (*models.EnvironmentRule, error)
	CreateEnvironmentRule(ctx context.Context, req *models.EnvironmentRule) (*models.EnvironmentRule, error)
	UpdateEnvironmentRule(ctx context.Context, rule *models.EnvironmentRule) (*models.EnvironmentRule, error)
	GetEnvironmentRules(ctx context.Context, input *GetEnvironmentRulesInput) (*EnvironmentRulesResult, error)
	DeleteEnvironmentRule(ctx context.Context, rule *models.EnvironmentRule) error
}

EnvironmentRules encapsulates the logic to access state version reqs from the database

func NewEnvironmentRules 

func NewEnvironmentRules(dbClient *Client) EnvironmentRules

NewEnvironmentRules returns an instance of the EnvironmentRules interface

type EnvironmentRulesResult 

type EnvironmentRulesResult struct {
	PageInfo         *pagination.PageInfo
	EnvironmentRules []*models.EnvironmentRule
}

EnvironmentRulesResult contains the response data and page information

type EnvironmentSortableField 

type EnvironmentSortableField string

EnvironmentSortableField represents the fields that environments can be sorted by 

const (
	EnvironmentSortableFieldUpdatedAtAsc  EnvironmentSortableField = "UPDATED_AT_ASC"
	EnvironmentSortableFieldUpdatedAtDesc EnvironmentSortableField = "UPDATED_AT_DESC"
	EnvironmentSortableFieldNameAsc       EnvironmentSortableField = "NAME_ASC"
	EnvironmentSortableFieldNameDesc      EnvironmentSortableField = "NAME_DESC"
)

EnvironmentSortableField constants

type Environments 

type Environments interface {
	GetEnvironmentByID(ctx context.Context, id string) (*models.Environment, error)
	GetEnvironmentByPRN(ctx context.Context, prn string) (*models.Environment, error)
	GetEnvironments(ctx context.Context, input *GetEnvironmentsInput) (*EnvironmentsResult, error)
	CreateEnvironment(ctx context.Context, environment *models.Environment) (*models.Environment, error)
	UpdateEnvironment(ctx context.Context, environment *models.Environment) (*models.Environment, error)
	DeleteEnvironment(ctx context.Context, environment *models.Environment) error
}

Environments encapsulates the logic to access environments from the database

func NewEnvironments 

func NewEnvironments(dbClient *Client) Environments

NewEnvironments returns an instance of the Environments interface

type EnvironmentsResult 

type EnvironmentsResult struct {
	PageInfo     *pagination.PageInfo
	Environments []models.Environment
}

EnvironmentsResult contains the response data and page information

type Event 

type Event struct {
	Table  string          `json:"table"`
	Action string          `json:"action"`
	ID     string          `json:"id"`
	Data   json.RawMessage `json:"data"`
}

Event contains processed information related to the database row that was changed The ID field is needed for triage independent of the type of the event data.

func (*Event) ToAgentSessionEventData added in v0.7.0 

func (e *Event) ToAgentSessionEventData() (*AgentSessionEventData, error)

ToAgentSessionEventData is a shorthand method to return type-checked event data.

func (*Event) ToCommentEventData added in v0.7.0 

func (e *Event) ToCommentEventData() (*CommentEventData, error)

ToCommentEventData is a shorthand method to return type-checked event data.

func (*Event) ToJobEventData added in v0.7.0 

func (e *Event) ToJobEventData() (*JobEventData, error)

ToJobEventData is a shorthand method to return type-checked event data.

func (*Event) ToLogStreamEventData added in v0.7.0 

func (e *Event) ToLogStreamEventData() (*LogStreamEventData, error)

ToLogStreamEventData is a shorthand method to return type-checked event data.

func (*Event) ToPipelineEventData added in v0.7.0 

func (e *Event) ToPipelineEventData() (*PipelineEventData, error)

ToPipelineEventData is a shorthand method to return type-checked event data.

func (*Event) ToWorkItemEventData added in v0.52.0 

func (e *Event) ToWorkItemEventData() (*WorkItemEventData, error)

ToWorkItemEventData is a shorthand method to return type-checked event data.

type EventTimestamp added in v0.52.0 

type EventTimestamp struct {
	time.Time
}

EventTimestamp is a custom time type that handles PostgreSQL timestamp format in JSON. PostgreSQL NOTIFY sends timestamps without timezone info, but Go's time.Time expects RFC3339 format with timezone.

func (*EventTimestamp) UnmarshalJSON added in v0.52.0 

func (t *EventTimestamp) UnmarshalJSON(data []byte) error

UnmarshalJSON implements json.Unmarshaler for PostgreSQL timestamp format.

type Events 

type Events interface {
	// Listen for async events from the database
	Listen(ctx context.Context) (<-chan Event, <-chan error)
}

Events provides the ability to listen for async events from the database

func NewEvents 

func NewEvents(dbClient *Client) Events

NewEvents returns an instance of the Events interface

type GetActivityEventsInput 

type GetActivityEventsInput struct {
	// Sort specifies the field to sort on and direction
	Sort *ActivityEventSortableField
	// PaginationOptions supports cursor based pagination
	PaginationOptions *pagination.Options
	// Filter contains the supported fields for filtering ActivityEvent resources
	Filter *ActivityEventFilter
}

GetActivityEventsInput is the input for listing activity events.

type GetAgentSessionsInput 

type GetAgentSessionsInput struct {
	// Sort specifies the field to sort on and direction
	Sort *AgentSessionSortableField
	// PaginationOptions supports cursor based pagination
	PaginationOptions *pagination.Options
	// Filter is used to filter the results
	Filter *AgentSessionFilter
}

GetAgentSessionsInput is the input for listing sessions

type GetAgentsInput 

type GetAgentsInput struct {
	// Sort specifies the field to sort on and direction
	Sort *AgentSortableField
	// PaginationOptions supports cursor based pagination
	PaginationOptions *pagination.Options
	// Filter is used to filter the results
	Filter *AgentFilter
}

GetAgentsInput is the input for listing agents

type GetAggregatedMetricsInput 

type GetAggregatedMetricsInput struct {
	// Filter is used to filter the results
	Filter *MetricFilter
	// BucketPeriod is the period to aggregate the metrics by
	BucketPeriod MetricBucketPeriod
	// BucketCount is the number of buckets to return
	BucketCount int
}

GetAggregatedMetricsInput is the input for querying aggregated metrics

type GetAnnouncementsInput added in v0.39.0 

type GetAnnouncementsInput struct {
	// Sort specifies the field to sort on and direction
	Sort *AnnouncementSortableField
	// PaginationOptions supports cursor based pagination
	PaginationOptions *pagination.Options
	// Filter is used to filter the results
	Filter *AnnouncementFilter
}

GetAnnouncementsInput is the input for listing announcements

type GetApprovalRulesInput 

type GetApprovalRulesInput struct {
	// Sort specifies the field to sort on and direction
	Sort *ApprovalRuleSortableField
	// PaginationOptions supports cursor based pagination
	PaginationOptions *pagination.Options
	// Filter is used to filter the results
	Filter *ApprovalRuleFilter
}

GetApprovalRulesInput is the input for listing organizations

type GetAsymSigningKeysInput added in v0.39.0 

type GetAsymSigningKeysInput struct {
	// Sort specifies the field to sort on and direction
	Sort *AsymSigningKeySortableField
	// PaginationOptions supports cursor based pagination
	PaginationOptions *pagination.Options
	// Filter is used to filter the results
	Filter *AsymSigningKeyFilter
}

GetAsymSigningKeysInput is the input for listing asymmetric signing keys

type GetCommentsInput 

type GetCommentsInput struct {
	// Sort specifies the field to sort on and direction
	Sort *CommentSortableField
	// PaginationOptions supports cursor based pagination
	PaginationOptions *pagination.Options
	// Filter is used to filter the results
	Filter *CommentFilter
}

GetCommentsInput is the input for listing comments

type GetEnvironmentRulesInput 

type GetEnvironmentRulesInput struct {
	// Sort specifies the field to sort on and direction
	Sort *EnvironmentRuleSortableField
	// PaginationOptions supports cursor based pagination
	PaginationOptions *pagination.Options
	// Filter is used to filter the results
	Filter *EnvironmentRuleFilter
}

GetEnvironmentRulesInput is the input for listing organizations

type GetEnvironmentsInput 

type GetEnvironmentsInput struct {
	// Sort specifies the field to sort on and direction
	Sort *EnvironmentSortableField
	// PaginationOptions supports cursor based pagination
	PaginationOptions *pagination.Options
	// Filter is used to filter the results
	Filter *EnvironmentFilter
}

GetEnvironmentsInput is the input for listing environments

type GetJobsInput 

type GetJobsInput struct {
	// Sort specifies the field to sort on and direction
	Sort *JobSortableField
	// PaginationOptions supports cursor based pagination
	PaginationOptions *pagination.Options
	// Filter is used to filter the results
	Filter *JobFilter
}

GetJobsInput is the input for listing jobs

type GetLifecycleTemplatesInput 

type GetLifecycleTemplatesInput struct {
	// Sort specifies the field to sort on and direction
	Sort *LifecycleTemplateSortableField
	// PaginationOptions supports cursor based pagination
	PaginationOptions *pagination.Options
	// Filter is used to filter the results
	Filter *LifecycleTemplateFilter
}

GetLifecycleTemplatesInput is the input for listing lifecycle templates

type GetLogStreamsInput 

type GetLogStreamsInput struct {
	// Sort specifies the field to sort on and direction
	Sort *LogStreamSortableField
	// PaginationOptions supports cursor based pagination
	PaginationOptions *pagination.Options
	// Filter is used to filter the results
	Filter *LogStreamFilter
}

GetLogStreamsInput is the input for listing log streams

type GetMembershipsInput 

type GetMembershipsInput struct {
	// Sort specifies the field to sort on and direction
	Sort *MembershipSortableField
	// PaginationOptions supports cursor based pagination
	PaginationOptions *pagination.Options
	// Filter is used to filter the results
	Filter *MembershipFilter
}

GetMembershipsInput is the input for listing memberships

type GetMetricsInput 

type GetMetricsInput struct {
	// Sort specifies the field to sort on and direction
	Sort *MetricSortableField
	// PaginationOptions supports cursor based pagination
	PaginationOptions *pagination.Options
	// Filter is used to filter the results
	Filter *MetricFilter
}

GetMetricsInput is the input for listing metrics

type GetNotificationPreferencesInput added in v0.46.0 

type GetNotificationPreferencesInput struct {
	// Sort specifies the field to sort on and direction
	Sort *NotificationPreferenceSortableField
	// PaginationOptions supports cursor based pagination
	PaginationOptions *pagination.Options
	// Filter is used to filter the results
	Filter *NotificationPreferenceFilter
}

GetNotificationPreferencesInput is the input for querying a list of notification preferences

type GetOrganizationsInput 

type GetOrganizationsInput struct {
	// Sort specifies the field to sort on and direction
	Sort *OrganizationSortableField
	// PaginationOptions supports cursor based pagination
	PaginationOptions *pagination.Options
	// Filter is used to filter the results
	Filter *OrganizationFilter
}

GetOrganizationsInput is the input for listing organizations

type GetPipelineApprovalsInput 

type GetPipelineApprovalsInput struct {
	// Sort specifies the field to sort on and direction
	Sort *PipelineApprovalSortableField
	// PaginationOptions supports cursor based pagination
	PaginationOptions *pagination.Options
	// Filter is used to filter the results
	Filter *PipelineApprovalFilter
}

GetPipelineApprovalsInput is the input for listing pipeline approvals

type GetPipelineTemplatesInput 

type GetPipelineTemplatesInput struct {
	// Sort specifies the field to sort on and direction
	Sort *PipelineTemplateSortableField
	// PaginationOptions supports cursor based pagination
	PaginationOptions *pagination.Options
	// Filter is used to filter the results
	Filter *PipelineTemplateFilter
}

GetPipelineTemplatesInput is the input for listing pipeline templates

type GetPipelinesInput 

type GetPipelinesInput struct {
	// Sort specifies the field to sort on and direction
	Sort *PipelineSortableField
	// PaginationOptions supports cursor based pagination
	PaginationOptions *pagination.Options
	// Filter is used to filter the results
	Filter *PipelineFilter
}

GetPipelinesInput is the input for listing pipelines

type GetPluginPlatformsInput 

type GetPluginPlatformsInput struct {
	// Sort specifies the field to sort on and direction
	Sort *PluginPlatformSortableField
	// PaginationOptions supports cursor based pagination
	PaginationOptions *pagination.Options
	// Filter is used to filter the results
	Filter *PluginPlatformFilter
}

GetPluginPlatformsInput represents the input for the GetPluginPlatforms method.

type GetPluginVersionsInput 

type GetPluginVersionsInput struct {
	// Sort specifies the field to sort on and direction
	Sort *PluginVersionSortableField
	// PaginationOptions supports cursor based pagination
	PaginationOptions *pagination.Options
	// Filter is used to filter the results
	Filter *PluginVersionFilter
}

GetPluginVersionsInput is the input for the GetPluginVersions method.

type GetPluginsInput 

type GetPluginsInput struct {
	// Sort specifies the field to sort on and direction
	Sort *PluginSortableField
	// PaginationOptions supports cursor-based pagination.
	PaginationOptions *pagination.Options
	// Filter is the list of filters for the query.
	Filter *PluginFilter
}

GetPluginsInput represents the input of the GetPlugins method.

type GetProjectVariableSetsInput 

type GetProjectVariableSetsInput struct {
	// Sort specifies the field to sort on and direction
	Sort *ProjectVariableSetSortableField
	// PaginationOptions supports cursor based pagination
	PaginationOptions *pagination.Options
	// Filter is used to filter the results
	Filter *ProjectVariableSetFilter
}

GetProjectVariableSetsInput is the input for listing projectVariableSets

type GetProjectVariablesInput 

type GetProjectVariablesInput struct {
	// Sort specifies the field to sort on and direction
	Sort *ProjectVariableSortableField
	// PaginationOptions supports cursor based pagination
	PaginationOptions *pagination.Options
	// Filter is used to filter the results
	Filter *ProjectVariableFilter
}

GetProjectVariablesInput is the input for listing projectVariables

type GetProjectsInput 

type GetProjectsInput struct {
	// Sort specifies the field to sort on and direction
	Sort *ProjectSortableField
	// PaginationOptions supports cursor based pagination
	PaginationOptions *pagination.Options
	// Filter is used to filter the results
	Filter *ProjectFilter
}

GetProjectsInput is the input for listing projects

type GetReleaseLifecyclesInput 

type GetReleaseLifecyclesInput struct {
	// Sort specifies the field to sort on and direction
	Sort *ReleaseLifecycleSortableField
	// PaginationOptions supports cursor based pagination
	PaginationOptions *pagination.Options
	// Filter is used to filter the results
	Filter *ReleaseLifecycleFilter
}

GetReleaseLifecyclesInput is the input for listing release lifecycles

type GetReleaseVariablesInput added in v0.53.0 

type GetReleaseVariablesInput struct {
	// Sort specifies the field to sort on and direction
	Sort *ReleaseVariableSortableField
	// PaginationOptions supports cursor based pagination
	PaginationOptions *pagination.Options
	// Filter is used to filter the results
	Filter *ReleaseVariableFilter
}

GetReleaseVariablesInput is the input for listing releaseVariables

type GetReleasesInput 

type GetReleasesInput struct {
	// Sort specifies the field to sort on and direction
	Sort *ReleaseSortableField
	// PaginationOptions supports cursor based pagination
	PaginationOptions *pagination.Options
	// Filter is used to filter the results
	Filter *ReleaseFilter
}

GetReleasesInput is the input for listing releases

type GetRolesInput 

type GetRolesInput struct {
	// Sort specifies the field to sort on and direction
	Sort *RoleSortableField
	// PaginationOptions supports cursor based pagination
	PaginationOptions *pagination.Options
	// Filter is used to filter the results
	Filter *RoleFilter
}

GetRolesInput is the input for listing roles

type GetServiceAccountsInput 

type GetServiceAccountsInput struct {
	// Sort specifies the field to sort on and direction
	Sort *ServiceAccountSortableField
	// PaginationOptions supports cursor based pagination
	PaginationOptions *pagination.Options
	// Filter is used to filter the results
	Filter *ServiceAccountFilter
}

GetServiceAccountsInput is the input for listing service accounts

type GetTeamMembersInput 

type GetTeamMembersInput struct {
	// Sort specifies the field to sort on and direction
	Sort *TeamMemberSortableField
	// PaginationOptions supports cursor based pagination
	PaginationOptions *pagination.Options
	// Filter is used to filter the results
	Filter *TeamMemberFilter
}

GetTeamMembersInput is the input for listing team members

type GetTeamsInput 

type GetTeamsInput struct {
	// Sort specifies the field to sort on and direction
	Sort *TeamSortableField
	// PaginationOptions supports cursor based pagination
	PaginationOptions *pagination.Options
	// Filter is used to filter the results
	Filter *TeamFilter
}

GetTeamsInput is the input for listing teams

type GetThreadsInput 

type GetThreadsInput struct {
	// Sort specifies the field to sort on and direction
	Sort *ThreadSortableField
	// PaginationOptions supports cursor based pagination
	PaginationOptions *pagination.Options
	// Filter is used to filter the results
	Filter *ThreadFilter
}

GetThreadsInput is the input for listing Threads.

type GetToDoItemsInput 

type GetToDoItemsInput struct {
	// Sort specifies the field to sort on and direction
	Sort *ToDoItemSortableField
	// PaginationOptions supports cursor based pagination
	PaginationOptions *pagination.Options
	// Filter contains the supported fields for filtering the result set
	Filter *ToDoItemFilter
}

GetToDoItemsInput represents the input for the GetToDoItems method.

type GetUserSessionsInput added in v0.42.0 

type GetUserSessionsInput struct {
	// Sort specifies the field to sort on and direction
	Sort *UserSessionSortableField
	// PaginationOptions supports cursor based pagination
	PaginationOptions *pagination.Options
	// Filter is used to filter the results
	Filter *UserSessionFilter
}

GetUserSessionsInput is the input for listing user sessions

type GetUsersInput 

type GetUsersInput struct {
	// Sort specifies the field to sort on and direction
	Sort *UserSortableField
	// PaginationOptions supports cursor based pagination
	PaginationOptions *pagination.Options
	// Filter is used to filter the results
	Filter *UserFilter
}

GetUsersInput is the input for listing users

type GetVCSProvidersInput 

type GetVCSProvidersInput struct {
	// Sort specifies the field to sort on and direction
	Sort *VCSProviderSortableField
	// PaginationOptions supports cursor based pagination
	PaginationOptions *pagination.Options
	// Filter is used to filter the results
	Filter *VCSProviderFilter
}

GetVCSProvidersInput is the input for listing VCS providers.

type JobEventData added in v0.7.0 

type JobEventData struct {
	AgentID   *string          `json:"agent_id"`
	ID        string           `json:"id"`
	Type      models.JobType   `json:"type"`
	ProjectID string           `json:"project_id"`
	Data      JobEventTaskData `json:"data"`
}

JobEventData contains the event response data for a row from the jobs table.

type JobEventTaskData added in v0.7.0 

type JobEventTaskData struct {
	PipelineID string `json:"pipelineId"`
	TaskPath   string `json:"taskPath"`
}

JobEventTaskData is the data for a job of type task. See models.JobTaskData.

type JobFilter 

type JobFilter struct {
	ProjectID        *string
	OrgID            *string
	PipelineID       *string
	PipelineTaskPath *string
	JobType          *models.JobType
	AgentID          *string
	TagFilter        *JobTagFilter
	JobStatuses      []models.JobStatus
	JobIDs           []string
}

JobFilter contains the supported fields for filtering Job resources

type JobSortableField 

type JobSortableField string

JobSortableField represents the fields that a job can be sorted by 

const (
	JobSortableFieldCreatedAtAsc          JobSortableField = "CREATED_AT_ASC"
	JobSortableFieldCreatedAtDesc         JobSortableField = "CREATED_AT_DESC"
	JobSortableFieldUpdatedAtAsc          JobSortableField = "UPDATED_AT_ASC"
	JobSortableFieldUpdatedAtDesc         JobSortableField = "UPDATED_AT_DESC"
	JobSortableFieldCancelRequestedAtDesc JobSortableField = "CANCEL_REQUESTED_AT_DESC"
)

GroupSortableField constants

type JobTagFilter 

type JobTagFilter struct {
	ExcludeUntaggedJobs *bool
	TagSuperset         []string
}

JobTagFilter is a filter condition for job tags

type Jobs 

type Jobs interface {
	GetJobByID(ctx context.Context, id string) (*models.Job, error)
	GetJobByPRN(ctx context.Context, prn string) (*models.Job, error)
	GetJobs(ctx context.Context, input *GetJobsInput) (*JobsResult, error)
	UpdateJob(ctx context.Context, job *models.Job) (*models.Job, error)
	CreateJob(ctx context.Context, job *models.Job) (*models.Job, error)
	GetJobCountForAgent(ctx context.Context, agentID string) (int, error)
	AddJobToPipelineTask(ctx context.Context, pipelineID string, taskPath string, job *models.Job) error
}

Jobs encapsulates the logic to access jobs from the database

func NewJobs 

func NewJobs(dbClient *Client) Jobs

NewJobs returns an instance of the Jobs interface

type JobsResult 

type JobsResult struct {
	PageInfo *pagination.PageInfo
	Jobs     []models.Job
}

JobsResult contains the response data and page information

type LifecycleTemplateFilter 

type LifecycleTemplateFilter struct {
	TimeRangeStart          *time.Time
	OrganizationID          *string
	ProjectID               *string
	LifecycleTemplateScopes []models.ScopeType
	LifecycleTemplateIDs    []string
}

LifecycleTemplateFilter contains the supported fields for filtering LifecycleTemplate resources

type LifecycleTemplateSortableField 

type LifecycleTemplateSortableField string

LifecycleTemplateSortableField represents the fields that a lifecycle template can be sorted by 

const (
	LifecycleTemplateSortableFieldUpdatedAtAsc  LifecycleTemplateSortableField = "UPDATED_AT_ASC"
	LifecycleTemplateSortableFieldUpdatedAtDesc LifecycleTemplateSortableField = "UPDATED_AT_DESC"
)

LifecycleTemplateSortableField constants

type LifecycleTemplates 

type LifecycleTemplates interface {
	GetLifecycleTemplateByID(ctx context.Context, id string) (*models.LifecycleTemplate, error)
	GetLifecycleTemplateByPRN(ctx context.Context, prn string) (*models.LifecycleTemplate, error)
	GetLifecycleTemplates(ctx context.Context, input *GetLifecycleTemplatesInput) (*LifecycleTemplatesResult, error)
	CreateLifecycleTemplate(ctx context.Context, lifecycleTemplate *models.LifecycleTemplate) (*models.LifecycleTemplate, error)
	UpdateLifecycleTemplate(ctx context.Context, releaseLifecycleTemplate *models.LifecycleTemplate) (*models.LifecycleTemplate, error)
}

LifecycleTemplates encapsulates the logic to access LifecycleTemplates from the database

func NewLifecycleTemplates 

func NewLifecycleTemplates(dbClient *Client) LifecycleTemplates

NewLifecycleTemplates returns an instance of the LifecycleTemplates interface

type LifecycleTemplatesResult 

type LifecycleTemplatesResult struct {
	PageInfo           *pagination.PageInfo
	LifecycleTemplates []*models.LifecycleTemplate
}

LifecycleTemplatesResult contains the response data and page information

type LogStreamEventData added in v0.7.0 

type LogStreamEventData struct {
	Size      int  `json:"size"`
	Completed bool `json:"completed"`
}

LogStreamEventData contains the event response data for a row from the log_streams table.

type LogStreamFilter 

type LogStreamFilter struct {
	AgentSessionIDs []string
	JobIDs          []string
}

LogStreamFilter contains the supported fields for filtering log stream resources

type LogStreamSortableField 

type LogStreamSortableField string

LogStreamSortableField represents the fields that a log stream can be sorted by 

const (
	LogStreamSortableFieldUpdatedAtAsc  LogStreamSortableField = "UPDATED_AT_ASC"
	LogStreamSortableFieldUpdatedAtDesc LogStreamSortableField = "UPDATED_AT_DESC"
)

GroupSortableField constants

type LogStreams 

type LogStreams interface {
	GetLogStreamByID(ctx context.Context, id string) (*models.LogStream, error)
	GetLogStreamByJobID(ctx context.Context, jobID string) (*models.LogStream, error)
	GetLogStreamByAgentSessionID(ctx context.Context, sessionID string) (*models.LogStream, error)
	GetLogStreams(ctx context.Context, input *GetLogStreamsInput) (*LogStreamsResult, error)
	CreateLogStream(ctx context.Context, logStream *models.LogStream) (*models.LogStream, error)
	UpdateLogStream(ctx context.Context, logStream *models.LogStream) (*models.LogStream, error)
}

LogStreams encapsulates the logic to access LogStreams from the database

func NewLogStreams 

func NewLogStreams(dbClient *Client) LogStreams

NewLogStreams returns an instance of the LogStreams interface

type LogStreamsResult 

type LogStreamsResult struct {
	PageInfo   *pagination.PageInfo
	LogStreams []models.LogStream
}

LogStreamsResult contains the response data and page information

type MaintenanceModes added in v0.39.0 

type MaintenanceModes interface {
	GetMaintenanceMode(ctx context.Context) (*models.MaintenanceMode, error)
	CreateMaintenanceMode(ctx context.Context, mode *models.MaintenanceMode) (*models.MaintenanceMode, error)
	DeleteMaintenanceMode(ctx context.Context, mode *models.MaintenanceMode) error
}

MaintenanceModes encapsulates the logic to access maintenance modes from the database

func NewMaintenanceModes added in v0.39.0 

func NewMaintenanceModes(dbClient *Client) MaintenanceModes

NewMaintenanceModes returns an instance of the MaintenanceModes interface.

type MembershipFilter 

type MembershipFilter struct {
	UserID           *string
	TeamID           *string
	ServiceAccountID *string
	OrganizationID   *string
	ProjectID        *string
	RoleID           *string
	MembershipScopes []models.ScopeType
	MembershipIDs    []string
}

MembershipFilter contains the supported fields for filtering Membership resources

type MembershipSortableField 

type MembershipSortableField string

MembershipSortableField represents the fields that a membership can be sorted by 

const (
	MembershipSortableFieldUpdatedAtAsc  MembershipSortableField = "UPDATED_AT_ASC"
	MembershipSortableFieldUpdatedAtDesc MembershipSortableField = "UPDATED_AT_DESC"
)

MembershipSortableField constants

type Memberships 

type Memberships interface {
	GetMembershipByID(ctx context.Context, id string) (*models.Membership, error)
	GetMembershipByPRN(ctx context.Context, prn string) (*models.Membership, error)
	GetMemberships(ctx context.Context, input *GetMembershipsInput) (*MembershipsResult, error)
	CreateMembership(ctx context.Context, input *models.Membership) (*models.Membership, error)
	UpdateMembership(ctx context.Context, membership *models.Membership) (*models.Membership, error)
	DeleteMembership(ctx context.Context, membership *models.Membership) error
}

Memberships encapsulates the logic to access memberships from the database

func NewMemberships 

func NewMemberships(dbClient *Client) Memberships

NewMemberships returns an instance of the Memberships interface

type MembershipsResult 

type MembershipsResult struct {
	PageInfo    *pagination.PageInfo
	Memberships []models.Membership
}

MembershipsResult contains the response data and page information

type MetricBucketPeriod 

type MetricBucketPeriod string

MetricBucketPeriod represents the period to aggregate the metrics by 

const (
	MetricBucketPeriodHour  MetricBucketPeriod = "hour"
	MetricBucketPeriodDay   MetricBucketPeriod = "day"
	MetricBucketPeriodMonth MetricBucketPeriod = "month"
)

MetricBucketPeriodField constants

type MetricFilter 

type MetricFilter struct {
	TimeRangeStart  *time.Time
	TimeRangeEnd    *time.Time
	OrganizationID  *string
	ProjectID       *string
	ReleaseID       *string
	PipelineID      *string
	EnvironmentName *string
	MetricName      *models.MetricName
	Tags            map[models.MetricTagName]string
}

MetricFilter is the filter to apply when querying metrics.

type MetricSortableField 

type MetricSortableField string

MetricSortableField represents the fields that a metric can be sorted by 

const (
	MetricSortableFieldCreatedAtAsc  MetricSortableField = "CREATED_AT_ASC"
	MetricSortableFieldCreatedAtDesc MetricSortableField = "CREATED_AT_DESC"
)

MetricSortableField constants

type MetricStatistics 

type MetricStatistics struct {
	Minimum float64
	Maximum float64
	Average float64
	Sum     float64
}

MetricStatistics represents the statistics for a metric.

type Metrics 

type Metrics interface {
	GetMetrics(ctx context.Context, input *GetMetricsInput) (*MetricsResult, error)
	GetMetricStatistics(ctx context.Context, input *MetricFilter) (*MetricStatistics, error)
	GetAggregatedMetricStatistics(ctx context.Context, input *GetAggregatedMetricsInput) ([]*AggregatedMetric, error)
	CreateMetric(ctx context.Context, metric *models.Metric) (*models.Metric, error)
}

Metrics encapsulates the logic to access metrics from the DB.

func NewMetrics 

func NewMetrics(dbClient *Client) Metrics

NewMetrics returns an instance of Metrics interface.

type MetricsResult 

type MetricsResult struct {
	PageInfo *pagination.PageInfo
	Metrics  []*models.Metric
}

MetricsResult contains the response data and page information

type MockActivityEvents 

type MockActivityEvents struct {
	mock.Mock
}

MockActivityEvents is an autogenerated mock type for the ActivityEvents type

func NewMockActivityEvents 

func NewMockActivityEvents(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockActivityEvents

NewMockActivityEvents creates a new instance of MockActivityEvents. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockActivityEvents) CreateActivityEvent 

func (_m *MockActivityEvents) CreateActivityEvent(ctx context.Context, input *models.ActivityEvent) (*models.ActivityEvent, error)

CreateActivityEvent provides a mock function with given fields: ctx, input

func (*MockActivityEvents) GetActivityEventByID 

func (_m *MockActivityEvents) GetActivityEventByID(ctx context.Context, id string) (*models.ActivityEvent, error)

GetActivityEventByID provides a mock function with given fields: ctx, id

func (*MockActivityEvents) GetActivityEvents 

func (_m *MockActivityEvents) GetActivityEvents(ctx context.Context, input *GetActivityEventsInput) (*ActivityEventsResult, error)

GetActivityEvents provides a mock function with given fields: ctx, input

type MockAgentSessions 

type MockAgentSessions struct {
	mock.Mock
}

MockAgentSessions is an autogenerated mock type for the AgentSessions type

func NewMockAgentSessions 

func NewMockAgentSessions(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockAgentSessions

NewMockAgentSessions creates a new instance of MockAgentSessions. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockAgentSessions) CreateAgentSession 

func (_m *MockAgentSessions) CreateAgentSession(ctx context.Context, session *models.AgentSession) (*models.AgentSession, error)

CreateAgentSession provides a mock function with given fields: ctx, session

func (*MockAgentSessions) DeleteAgentSession 

func (_m *MockAgentSessions) DeleteAgentSession(ctx context.Context, session *models.AgentSession) error

DeleteAgentSession provides a mock function with given fields: ctx, session

func (*MockAgentSessions) GetAgentSessionByID 

func (_m *MockAgentSessions) GetAgentSessionByID(ctx context.Context, id string) (*models.AgentSession, error)

GetAgentSessionByID provides a mock function with given fields: ctx, id

func (*MockAgentSessions) GetAgentSessionByPRN 

func (_m *MockAgentSessions) GetAgentSessionByPRN(ctx context.Context, prn string) (*models.AgentSession, error)

GetAgentSessionByPRN provides a mock function with given fields: ctx, prn

func (*MockAgentSessions) GetAgentSessions 

func (_m *MockAgentSessions) GetAgentSessions(ctx context.Context, input *GetAgentSessionsInput) (*AgentSessionsResult, error)

GetAgentSessions provides a mock function with given fields: ctx, input

func (*MockAgentSessions) UpdateAgentSession 

func (_m *MockAgentSessions) UpdateAgentSession(ctx context.Context, session *models.AgentSession) (*models.AgentSession, error)

UpdateAgentSession provides a mock function with given fields: ctx, session

type MockAgents 

type MockAgents struct {
	mock.Mock
}

MockAgents is an autogenerated mock type for the Agents type

func NewMockAgents 

func NewMockAgents(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockAgents

NewMockAgents creates a new instance of MockAgents. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockAgents) CreateAgent 

func (_m *MockAgents) CreateAgent(ctx context.Context, agent *models.Agent) (*models.Agent, error)

CreateAgent provides a mock function with given fields: ctx, agent

func (*MockAgents) DeleteAgent 

func (_m *MockAgents) DeleteAgent(ctx context.Context, agent *models.Agent) error

DeleteAgent provides a mock function with given fields: ctx, agent

func (*MockAgents) GetAgentByID 

func (_m *MockAgents) GetAgentByID(ctx context.Context, id string) (*models.Agent, error)

GetAgentByID provides a mock function with given fields: ctx, id

func (*MockAgents) GetAgentByPRN 

func (_m *MockAgents) GetAgentByPRN(ctx context.Context, prn string) (*models.Agent, error)

GetAgentByPRN provides a mock function with given fields: ctx, prn

func (*MockAgents) GetAgents 

func (_m *MockAgents) GetAgents(ctx context.Context, input *GetAgentsInput) (*AgentsResult, error)

GetAgents provides a mock function with given fields: ctx, input

func (*MockAgents) UpdateAgent 

func (_m *MockAgents) UpdateAgent(ctx context.Context, agent *models.Agent) (*models.Agent, error)

UpdateAgent provides a mock function with given fields: ctx, agent

type MockAnnouncements added in v0.39.0 

type MockAnnouncements struct {
	mock.Mock
}

MockAnnouncements is an autogenerated mock type for the Announcements type

func NewMockAnnouncements added in v0.39.0 

func NewMockAnnouncements(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockAnnouncements

NewMockAnnouncements creates a new instance of MockAnnouncements. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockAnnouncements) CreateAnnouncement added in v0.39.0 

func (_m *MockAnnouncements) CreateAnnouncement(ctx context.Context, announcement *models.Announcement) (*models.Announcement, error)

CreateAnnouncement provides a mock function with given fields: ctx, announcement

func (*MockAnnouncements) DeleteAnnouncement added in v0.39.0 

func (_m *MockAnnouncements) DeleteAnnouncement(ctx context.Context, announcement *models.Announcement) error

DeleteAnnouncement provides a mock function with given fields: ctx, announcement

func (*MockAnnouncements) GetAnnouncementByID added in v0.39.0 

func (_m *MockAnnouncements) GetAnnouncementByID(ctx context.Context, id string) (*models.Announcement, error)

GetAnnouncementByID provides a mock function with given fields: ctx, id

func (*MockAnnouncements) GetAnnouncementByPRN added in v0.39.0 

func (_m *MockAnnouncements) GetAnnouncementByPRN(ctx context.Context, prn string) (*models.Announcement, error)

GetAnnouncementByPRN provides a mock function with given fields: ctx, prn

func (*MockAnnouncements) GetAnnouncements added in v0.39.0 

func (_m *MockAnnouncements) GetAnnouncements(ctx context.Context, input *GetAnnouncementsInput) (*AnnouncementsResult, error)

GetAnnouncements provides a mock function with given fields: ctx, input

func (*MockAnnouncements) UpdateAnnouncement added in v0.39.0 

func (_m *MockAnnouncements) UpdateAnnouncement(ctx context.Context, announcement *models.Announcement) (*models.Announcement, error)

UpdateAnnouncement provides a mock function with given fields: ctx, announcement

type MockApprovalRules 

type MockApprovalRules struct {
	mock.Mock
}

MockApprovalRules is an autogenerated mock type for the ApprovalRules type

func NewMockApprovalRules 

func NewMockApprovalRules(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockApprovalRules

NewMockApprovalRules creates a new instance of MockApprovalRules. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockApprovalRules) CreateApprovalRule 

func (_m *MockApprovalRules) CreateApprovalRule(ctx context.Context, req *models.ApprovalRule) (*models.ApprovalRule, error)

CreateApprovalRule provides a mock function with given fields: ctx, req

func (*MockApprovalRules) DeleteApprovalRule 

func (_m *MockApprovalRules) DeleteApprovalRule(ctx context.Context, rule *models.ApprovalRule) error

DeleteApprovalRule provides a mock function with given fields: ctx, rule

func (*MockApprovalRules) GetApprovalRuleByID 

func (_m *MockApprovalRules) GetApprovalRuleByID(ctx context.Context, id string) (*models.ApprovalRule, error)

GetApprovalRuleByID provides a mock function with given fields: ctx, id

func (*MockApprovalRules) GetApprovalRuleByPRN 

func (_m *MockApprovalRules) GetApprovalRuleByPRN(ctx context.Context, prn string) (*models.ApprovalRule, error)

GetApprovalRuleByPRN provides a mock function with given fields: ctx, prn

func (*MockApprovalRules) GetApprovalRules 

func (_m *MockApprovalRules) GetApprovalRules(ctx context.Context, input *GetApprovalRulesInput) (*ApprovalRulesResult, error)

GetApprovalRules provides a mock function with given fields: ctx, input

func (*MockApprovalRules) UpdateApprovalRule 

func (_m *MockApprovalRules) UpdateApprovalRule(ctx context.Context, rule *models.ApprovalRule) (*models.ApprovalRule, error)

UpdateApprovalRule provides a mock function with given fields: ctx, rule

type MockAsymSigningKeys added in v0.41.0 

type MockAsymSigningKeys struct {
	mock.Mock
}

MockAsymSigningKeys is an autogenerated mock type for the AsymSigningKeys type

func NewMockAsymSigningKeys added in v0.41.0 

func NewMockAsymSigningKeys(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockAsymSigningKeys

NewMockAsymSigningKeys creates a new instance of MockAsymSigningKeys. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockAsymSigningKeys) CreateAsymSigningKey added in v0.41.0 

func (_m *MockAsymSigningKeys) CreateAsymSigningKey(ctx context.Context, asymSigningKey *models.AsymSigningKey) (*models.AsymSigningKey, error)

CreateAsymSigningKey provides a mock function with given fields: ctx, asymSigningKey

func (*MockAsymSigningKeys) DeleteAsymSigningKey added in v0.41.0 

func (_m *MockAsymSigningKeys) DeleteAsymSigningKey(ctx context.Context, asymSigningKey *models.AsymSigningKey) error

DeleteAsymSigningKey provides a mock function with given fields: ctx, asymSigningKey

func (*MockAsymSigningKeys) GetAsymSigningKeyByID added in v0.41.0 

func (_m *MockAsymSigningKeys) GetAsymSigningKeyByID(ctx context.Context, id string) (*models.AsymSigningKey, error)

GetAsymSigningKeyByID provides a mock function with given fields: ctx, id

func (*MockAsymSigningKeys) GetAsymSigningKeyByPRN added in v0.41.0 

func (_m *MockAsymSigningKeys) GetAsymSigningKeyByPRN(ctx context.Context, prn string) (*models.AsymSigningKey, error)

GetAsymSigningKeyByPRN provides a mock function with given fields: ctx, prn

func (*MockAsymSigningKeys) GetAsymSigningKeys added in v0.41.0 

func (_m *MockAsymSigningKeys) GetAsymSigningKeys(ctx context.Context, input *GetAsymSigningKeysInput) (*AsymSigningKeysResult, error)

GetAsymSigningKeys provides a mock function with given fields: ctx, input

func (*MockAsymSigningKeys) UpdateAsymSigningKey added in v0.41.0 

func (_m *MockAsymSigningKeys) UpdateAsymSigningKey(ctx context.Context, asymSigningKey *models.AsymSigningKey) (*models.AsymSigningKey, error)

UpdateAsymSigningKey provides a mock function with given fields: ctx, asymSigningKey

type MockComments 

type MockComments struct {
	mock.Mock
}

MockComments is an autogenerated mock type for the Comments type

func NewMockComments 

func NewMockComments(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockComments

NewMockComments creates a new instance of MockComments. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockComments) CreateComment 

func (_m *MockComments) CreateComment(ctx context.Context, comment *models.Comment) (*models.Comment, error)

CreateComment provides a mock function with given fields: ctx, comment

func (*MockComments) DeleteComment 

func (_m *MockComments) DeleteComment(ctx context.Context, comment *models.Comment) error

DeleteComment provides a mock function with given fields: ctx, comment

func (*MockComments) GetCommentByID 

func (_m *MockComments) GetCommentByID(ctx context.Context, id string) (*models.Comment, error)

GetCommentByID provides a mock function with given fields: ctx, id

func (*MockComments) GetCommentByPRN 

func (_m *MockComments) GetCommentByPRN(ctx context.Context, prn string) (*models.Comment, error)

GetCommentByPRN provides a mock function with given fields: ctx, prn

func (*MockComments) GetComments 

func (_m *MockComments) GetComments(ctx context.Context, input *GetCommentsInput) (*CommentsResult, error)

GetComments provides a mock function with given fields: ctx, input

func (*MockComments) UpdateComment 

func (_m *MockComments) UpdateComment(ctx context.Context, comment *models.Comment) (*models.Comment, error)

UpdateComment provides a mock function with given fields: ctx, comment

type MockEnvironmentRules 

type MockEnvironmentRules struct {
	mock.Mock
}

MockEnvironmentRules is an autogenerated mock type for the EnvironmentRules type

func NewMockEnvironmentRules 

func NewMockEnvironmentRules(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockEnvironmentRules

NewMockEnvironmentRules creates a new instance of MockEnvironmentRules. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockEnvironmentRules) CreateEnvironmentRule 

func (_m *MockEnvironmentRules) CreateEnvironmentRule(ctx context.Context, req *models.EnvironmentRule) (*models.EnvironmentRule, error)

CreateEnvironmentRule provides a mock function with given fields: ctx, req

func (*MockEnvironmentRules) DeleteEnvironmentRule 

func (_m *MockEnvironmentRules) DeleteEnvironmentRule(ctx context.Context, rule *models.EnvironmentRule) error

DeleteEnvironmentRule provides a mock function with given fields: ctx, rule

func (*MockEnvironmentRules) GetEnvironmentRuleByID 

func (_m *MockEnvironmentRules) GetEnvironmentRuleByID(ctx context.Context, id string) (*models.EnvironmentRule, error)

GetEnvironmentRuleByID provides a mock function with given fields: ctx, id

func (*MockEnvironmentRules) GetEnvironmentRuleByPRN 

func (_m *MockEnvironmentRules) GetEnvironmentRuleByPRN(ctx context.Context, prn string) (*models.EnvironmentRule, error)

GetEnvironmentRuleByPRN provides a mock function with given fields: ctx, prn

func (*MockEnvironmentRules) GetEnvironmentRules 

func (_m *MockEnvironmentRules) GetEnvironmentRules(ctx context.Context, input *GetEnvironmentRulesInput) (*EnvironmentRulesResult, error)

GetEnvironmentRules provides a mock function with given fields: ctx, input

func (*MockEnvironmentRules) UpdateEnvironmentRule 

func (_m *MockEnvironmentRules) UpdateEnvironmentRule(ctx context.Context, rule *models.EnvironmentRule) (*models.EnvironmentRule, error)

UpdateEnvironmentRule provides a mock function with given fields: ctx, rule

type MockEnvironments 

type MockEnvironments struct {
	mock.Mock
}

MockEnvironments is an autogenerated mock type for the Environments type

func NewMockEnvironments 

func NewMockEnvironments(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockEnvironments

NewMockEnvironments creates a new instance of MockEnvironments. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockEnvironments) CreateEnvironment 

func (_m *MockEnvironments) CreateEnvironment(ctx context.Context, environment *models.Environment) (*models.Environment, error)

CreateEnvironment provides a mock function with given fields: ctx, environment

func (*MockEnvironments) DeleteEnvironment 

func (_m *MockEnvironments) DeleteEnvironment(ctx context.Context, environment *models.Environment) error

DeleteEnvironment provides a mock function with given fields: ctx, environment

func (*MockEnvironments) GetEnvironmentByID 

func (_m *MockEnvironments) GetEnvironmentByID(ctx context.Context, id string) (*models.Environment, error)

GetEnvironmentByID provides a mock function with given fields: ctx, id

func (*MockEnvironments) GetEnvironmentByPRN 

func (_m *MockEnvironments) GetEnvironmentByPRN(ctx context.Context, prn string) (*models.Environment, error)

GetEnvironmentByPRN provides a mock function with given fields: ctx, prn

func (*MockEnvironments) GetEnvironments 

func (_m *MockEnvironments) GetEnvironments(ctx context.Context, input *GetEnvironmentsInput) (*EnvironmentsResult, error)

GetEnvironments provides a mock function with given fields: ctx, input

func (*MockEnvironments) UpdateEnvironment 

func (_m *MockEnvironments) UpdateEnvironment(ctx context.Context, environment *models.Environment) (*models.Environment, error)

UpdateEnvironment provides a mock function with given fields: ctx, environment

type MockEvents 

type MockEvents struct {
	mock.Mock
}

MockEvents is an autogenerated mock type for the Events type

func NewMockEvents 

func NewMockEvents(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockEvents

NewMockEvents creates a new instance of MockEvents. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockEvents) Listen 

func (_m *MockEvents) Listen(ctx context.Context) (<-chan Event, <-chan error)

Listen provides a mock function with given fields: ctx

type MockJobs 

type MockJobs struct {
	mock.Mock
}

MockJobs is an autogenerated mock type for the Jobs type

func NewMockJobs 

func NewMockJobs(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockJobs

NewMockJobs creates a new instance of MockJobs. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockJobs) AddJobToPipelineTask 

func (_m *MockJobs) AddJobToPipelineTask(ctx context.Context, pipelineID string, taskPath string, job *models.Job) error

AddJobToPipelineTask provides a mock function with given fields: ctx, pipelineID, taskPath, job

func (*MockJobs) CreateJob 

func (_m *MockJobs) CreateJob(ctx context.Context, job *models.Job) (*models.Job, error)

CreateJob provides a mock function with given fields: ctx, job

func (*MockJobs) GetJobByID 

func (_m *MockJobs) GetJobByID(ctx context.Context, id string) (*models.Job, error)

GetJobByID provides a mock function with given fields: ctx, id

func (*MockJobs) GetJobByPRN 

func (_m *MockJobs) GetJobByPRN(ctx context.Context, prn string) (*models.Job, error)

GetJobByPRN provides a mock function with given fields: ctx, prn

func (*MockJobs) GetJobCountForAgent 

func (_m *MockJobs) GetJobCountForAgent(ctx context.Context, agentID string) (int, error)

GetJobCountForAgent provides a mock function with given fields: ctx, agentID

func (*MockJobs) GetJobs 

func (_m *MockJobs) GetJobs(ctx context.Context, input *GetJobsInput) (*JobsResult, error)

GetJobs provides a mock function with given fields: ctx, input

func (*MockJobs) UpdateJob 

func (_m *MockJobs) UpdateJob(ctx context.Context, job *models.Job) (*models.Job, error)

UpdateJob provides a mock function with given fields: ctx, job

type MockLifecycleTemplates 

type MockLifecycleTemplates struct {
	mock.Mock
}

MockLifecycleTemplates is an autogenerated mock type for the LifecycleTemplates type

func NewMockLifecycleTemplates 

func NewMockLifecycleTemplates(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockLifecycleTemplates

NewMockLifecycleTemplates creates a new instance of MockLifecycleTemplates. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockLifecycleTemplates) CreateLifecycleTemplate 

func (_m *MockLifecycleTemplates) CreateLifecycleTemplate(ctx context.Context, lifecycleTemplate *models.LifecycleTemplate) (*models.LifecycleTemplate, error)

CreateLifecycleTemplate provides a mock function with given fields: ctx, lifecycleTemplate

func (*MockLifecycleTemplates) GetLifecycleTemplateByID 

func (_m *MockLifecycleTemplates) GetLifecycleTemplateByID(ctx context.Context, id string) (*models.LifecycleTemplate, error)

GetLifecycleTemplateByID provides a mock function with given fields: ctx, id

func (*MockLifecycleTemplates) GetLifecycleTemplateByPRN 

func (_m *MockLifecycleTemplates) GetLifecycleTemplateByPRN(ctx context.Context, prn string) (*models.LifecycleTemplate, error)

GetLifecycleTemplateByPRN provides a mock function with given fields: ctx, prn

func (*MockLifecycleTemplates) GetLifecycleTemplates 

func (_m *MockLifecycleTemplates) GetLifecycleTemplates(ctx context.Context, input *GetLifecycleTemplatesInput) (*LifecycleTemplatesResult, error)

GetLifecycleTemplates provides a mock function with given fields: ctx, input

func (*MockLifecycleTemplates) UpdateLifecycleTemplate 

func (_m *MockLifecycleTemplates) UpdateLifecycleTemplate(ctx context.Context, releaseLifecycleTemplate *models.LifecycleTemplate) (*models.LifecycleTemplate, error)

UpdateLifecycleTemplate provides a mock function with given fields: ctx, releaseLifecycleTemplate

type MockLogStreams 

type MockLogStreams struct {
	mock.Mock
}

MockLogStreams is an autogenerated mock type for the LogStreams type

func NewMockLogStreams 

func NewMockLogStreams(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockLogStreams

NewMockLogStreams creates a new instance of MockLogStreams. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockLogStreams) CreateLogStream 

func (_m *MockLogStreams) CreateLogStream(ctx context.Context, logStream *models.LogStream) (*models.LogStream, error)

CreateLogStream provides a mock function with given fields: ctx, logStream

func (*MockLogStreams) GetLogStreamByAgentSessionID 

func (_m *MockLogStreams) GetLogStreamByAgentSessionID(ctx context.Context, sessionID string) (*models.LogStream, error)

GetLogStreamByAgentSessionID provides a mock function with given fields: ctx, sessionID

func (*MockLogStreams) GetLogStreamByID 

func (_m *MockLogStreams) GetLogStreamByID(ctx context.Context, id string) (*models.LogStream, error)

GetLogStreamByID provides a mock function with given fields: ctx, id

func (*MockLogStreams) GetLogStreamByJobID 

func (_m *MockLogStreams) GetLogStreamByJobID(ctx context.Context, jobID string) (*models.LogStream, error)

GetLogStreamByJobID provides a mock function with given fields: ctx, jobID

func (*MockLogStreams) GetLogStreams 

func (_m *MockLogStreams) GetLogStreams(ctx context.Context, input *GetLogStreamsInput) (*LogStreamsResult, error)

GetLogStreams provides a mock function with given fields: ctx, input

func (*MockLogStreams) UpdateLogStream 

func (_m *MockLogStreams) UpdateLogStream(ctx context.Context, logStream *models.LogStream) (*models.LogStream, error)

UpdateLogStream provides a mock function with given fields: ctx, logStream

type MockMaintenanceModes added in v0.39.0 

type MockMaintenanceModes struct {
	mock.Mock
}

MockMaintenanceModes is an autogenerated mock type for the MaintenanceModes type

func NewMockMaintenanceModes added in v0.39.0 

func NewMockMaintenanceModes(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockMaintenanceModes

NewMockMaintenanceModes creates a new instance of MockMaintenanceModes. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockMaintenanceModes) CreateMaintenanceMode added in v0.39.0 

func (_m *MockMaintenanceModes) CreateMaintenanceMode(ctx context.Context, mode *models.MaintenanceMode) (*models.MaintenanceMode, error)

CreateMaintenanceMode provides a mock function with given fields: ctx, mode

func (*MockMaintenanceModes) DeleteMaintenanceMode added in v0.39.0 

func (_m *MockMaintenanceModes) DeleteMaintenanceMode(ctx context.Context, mode *models.MaintenanceMode) error

DeleteMaintenanceMode provides a mock function with given fields: ctx, mode

func (*MockMaintenanceModes) GetMaintenanceMode added in v0.39.0 

func (_m *MockMaintenanceModes) GetMaintenanceMode(ctx context.Context) (*models.MaintenanceMode, error)

GetMaintenanceMode provides a mock function with given fields: ctx

type MockMemberships 

type MockMemberships struct {
	mock.Mock
}

MockMemberships is an autogenerated mock type for the Memberships type

func NewMockMemberships 

func NewMockMemberships(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockMemberships

NewMockMemberships creates a new instance of MockMemberships. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockMemberships) CreateMembership 

func (_m *MockMemberships) CreateMembership(ctx context.Context, input *models.Membership) (*models.Membership, error)

CreateMembership provides a mock function with given fields: ctx, input

func (*MockMemberships) DeleteMembership 

func (_m *MockMemberships) DeleteMembership(ctx context.Context, membership *models.Membership) error

DeleteMembership provides a mock function with given fields: ctx, membership

func (*MockMemberships) GetMembershipByID 

func (_m *MockMemberships) GetMembershipByID(ctx context.Context, id string) (*models.Membership, error)

GetMembershipByID provides a mock function with given fields: ctx, id

func (*MockMemberships) GetMembershipByPRN 

func (_m *MockMemberships) GetMembershipByPRN(ctx context.Context, prn string) (*models.Membership, error)

GetMembershipByPRN provides a mock function with given fields: ctx, prn

func (*MockMemberships) GetMemberships 

func (_m *MockMemberships) GetMemberships(ctx context.Context, input *GetMembershipsInput) (*MembershipsResult, error)

GetMemberships provides a mock function with given fields: ctx, input

func (*MockMemberships) UpdateMembership 

func (_m *MockMemberships) UpdateMembership(ctx context.Context, membership *models.Membership) (*models.Membership, error)

UpdateMembership provides a mock function with given fields: ctx, membership

type MockMetrics 

type MockMetrics struct {
	mock.Mock
}

MockMetrics is an autogenerated mock type for the Metrics type

func NewMockMetrics 

func NewMockMetrics(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockMetrics

NewMockMetrics creates a new instance of MockMetrics. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockMetrics) CreateMetric 

func (_m *MockMetrics) CreateMetric(ctx context.Context, metric *models.Metric) (*models.Metric, error)

CreateMetric provides a mock function with given fields: ctx, metric

func (*MockMetrics) GetAggregatedMetricStatistics 

func (_m *MockMetrics) GetAggregatedMetricStatistics(ctx context.Context, input *GetAggregatedMetricsInput) ([]*AggregatedMetric, error)

GetAggregatedMetricStatistics provides a mock function with given fields: ctx, input

func (*MockMetrics) GetMetricStatistics 

func (_m *MockMetrics) GetMetricStatistics(ctx context.Context, input *MetricFilter) (*MetricStatistics, error)

GetMetricStatistics provides a mock function with given fields: ctx, input

func (*MockMetrics) GetMetrics 

func (_m *MockMetrics) GetMetrics(ctx context.Context, input *GetMetricsInput) (*MetricsResult, error)

GetMetrics provides a mock function with given fields: ctx, input

type MockNotificationPreferences added in v0.46.0 

type MockNotificationPreferences struct {
	mock.Mock
}

MockNotificationPreferences is an autogenerated mock type for the NotificationPreferences type

func NewMockNotificationPreferences added in v0.46.0 

func NewMockNotificationPreferences(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockNotificationPreferences

NewMockNotificationPreferences creates a new instance of MockNotificationPreferences. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockNotificationPreferences) CreateNotificationPreference added in v0.46.0 

func (_m *MockNotificationPreferences) CreateNotificationPreference(ctx context.Context, preference *models.NotificationPreference) (*models.NotificationPreference, error)

CreateNotificationPreference provides a mock function with given fields: ctx, preference

func (*MockNotificationPreferences) DeleteNotificationPreference added in v0.46.0 

func (_m *MockNotificationPreferences) DeleteNotificationPreference(ctx context.Context, preference *models.NotificationPreference) error

DeleteNotificationPreference provides a mock function with given fields: ctx, preference

func (*MockNotificationPreferences) GetNotificationPreferences added in v0.46.0 

func (_m *MockNotificationPreferences) GetNotificationPreferences(ctx context.Context, input *GetNotificationPreferencesInput) (*NotificationPreferencesResult, error)

GetNotificationPreferences provides a mock function with given fields: ctx, input

func (*MockNotificationPreferences) UpdateNotificationPreference added in v0.46.0 

func (_m *MockNotificationPreferences) UpdateNotificationPreference(ctx context.Context, preference *models.NotificationPreference) (*models.NotificationPreference, error)

UpdateNotificationPreference provides a mock function with given fields: ctx, preference

type MockOrganizations 

type MockOrganizations struct {
	mock.Mock
}

MockOrganizations is an autogenerated mock type for the Organizations type

func NewMockOrganizations 

func NewMockOrganizations(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockOrganizations

NewMockOrganizations creates a new instance of MockOrganizations. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockOrganizations) CreateOrganization 

func (_m *MockOrganizations) CreateOrganization(ctx context.Context, org *models.Organization) (*models.Organization, error)

CreateOrganization provides a mock function with given fields: ctx, org

func (*MockOrganizations) DeleteOrganization 

func (_m *MockOrganizations) DeleteOrganization(ctx context.Context, org *models.Organization) error

DeleteOrganization provides a mock function with given fields: ctx, org

func (*MockOrganizations) GetOrganizationByID 

func (_m *MockOrganizations) GetOrganizationByID(ctx context.Context, id string) (*models.Organization, error)

GetOrganizationByID provides a mock function with given fields: ctx, id

func (*MockOrganizations) GetOrganizationByName 

func (_m *MockOrganizations) GetOrganizationByName(ctx context.Context, name string) (*models.Organization, error)

GetOrganizationByName provides a mock function with given fields: ctx, name

func (*MockOrganizations) GetOrganizationByPRN 

func (_m *MockOrganizations) GetOrganizationByPRN(ctx context.Context, prn string) (*models.Organization, error)

GetOrganizationByPRN provides a mock function with given fields: ctx, prn

func (*MockOrganizations) GetOrganizations 

func (_m *MockOrganizations) GetOrganizations(ctx context.Context, input *GetOrganizationsInput) (*OrganizationsResult, error)

GetOrganizations provides a mock function with given fields: ctx, input

func (*MockOrganizations) UpdateOrganization 

func (_m *MockOrganizations) UpdateOrganization(ctx context.Context, org *models.Organization) (*models.Organization, error)

UpdateOrganization provides a mock function with given fields: ctx, org

type MockPipelineActionOutputs added in v0.3.0 

type MockPipelineActionOutputs struct {
	mock.Mock
}

MockPipelineActionOutputs is an autogenerated mock type for the PipelineActionOutputs type

func NewMockPipelineActionOutputs added in v0.3.0 

func NewMockPipelineActionOutputs(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockPipelineActionOutputs

NewMockPipelineActionOutputs creates a new instance of MockPipelineActionOutputs. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockPipelineActionOutputs) CreatePipelineActionOutput added in v0.3.0 

func (_m *MockPipelineActionOutputs) CreatePipelineActionOutput(ctx context.Context, output *models.PipelineActionOutput) (*models.PipelineActionOutput, error)

CreatePipelineActionOutput provides a mock function with given fields: ctx, output

func (*MockPipelineActionOutputs) DeletePipelineActionOutput added in v0.3.0 

func (_m *MockPipelineActionOutputs) DeletePipelineActionOutput(ctx context.Context, output *models.PipelineActionOutput) error

DeletePipelineActionOutput provides a mock function with given fields: ctx, output

func (*MockPipelineActionOutputs) GetPipelineActionOutputs added in v0.3.0 

func (_m *MockPipelineActionOutputs) GetPipelineActionOutputs(ctx context.Context, pipelineID string, actions []string) ([]*models.PipelineActionOutput, error)

GetPipelineActionOutputs provides a mock function with given fields: ctx, pipelineID, actions

type MockPipelineApprovals 

type MockPipelineApprovals struct {
	mock.Mock
}

MockPipelineApprovals is an autogenerated mock type for the PipelineApprovals type

func NewMockPipelineApprovals 

func NewMockPipelineApprovals(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockPipelineApprovals

NewMockPipelineApprovals creates a new instance of MockPipelineApprovals. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockPipelineApprovals) CreatePipelineApproval 

func (_m *MockPipelineApprovals) CreatePipelineApproval(ctx context.Context, req *models.PipelineApproval) (*models.PipelineApproval, error)

CreatePipelineApproval provides a mock function with given fields: ctx, req

func (*MockPipelineApprovals) DeletePipelineApproval 

func (_m *MockPipelineApprovals) DeletePipelineApproval(ctx context.Context, req *models.PipelineApproval) error

DeletePipelineApproval provides a mock function with given fields: ctx, req

func (*MockPipelineApprovals) GetPipelineApprovals 

func (_m *MockPipelineApprovals) GetPipelineApprovals(ctx context.Context, input *GetPipelineApprovalsInput) (*PipelineApprovalsResult, error)

GetPipelineApprovals provides a mock function with given fields: ctx, input

type MockPipelineOutputs added in v0.51.0 

type MockPipelineOutputs struct {
	mock.Mock
}

MockPipelineOutputs is an autogenerated mock type for the PipelineOutputs type

func NewMockPipelineOutputs added in v0.51.0 

func NewMockPipelineOutputs(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockPipelineOutputs

NewMockPipelineOutputs creates a new instance of MockPipelineOutputs. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockPipelineOutputs) CreatePipelineOutput added in v0.51.0 

func (_m *MockPipelineOutputs) CreatePipelineOutput(ctx context.Context, output *models.PipelineOutput) (*models.PipelineOutput, error)

CreatePipelineOutput provides a mock function with given fields: ctx, output

func (*MockPipelineOutputs) DeletePipelineOutputs added in v0.51.0 

func (_m *MockPipelineOutputs) DeletePipelineOutputs(ctx context.Context, input *DeletePipelineOutputsInput) error

DeletePipelineOutputs provides a mock function with given fields: ctx, input

func (*MockPipelineOutputs) GetPipelineOutputs added in v0.51.0 

func (_m *MockPipelineOutputs) GetPipelineOutputs(ctx context.Context, pipelineID string, nodePaths []string) ([]*models.PipelineOutput, error)

GetPipelineOutputs provides a mock function with given fields: ctx, pipelineID, nodePaths

type MockPipelineTemplates 

type MockPipelineTemplates struct {
	mock.Mock
}

MockPipelineTemplates is an autogenerated mock type for the PipelineTemplates type

func NewMockPipelineTemplates 

func NewMockPipelineTemplates(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockPipelineTemplates

NewMockPipelineTemplates creates a new instance of MockPipelineTemplates. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockPipelineTemplates) CreatePipelineTemplate 

func (_m *MockPipelineTemplates) CreatePipelineTemplate(ctx context.Context, pipelineTemplate *models.PipelineTemplate) (*models.PipelineTemplate, error)

CreatePipelineTemplate provides a mock function with given fields: ctx, pipelineTemplate

func (*MockPipelineTemplates) DeletePipelineTemplate 

func (_m *MockPipelineTemplates) DeletePipelineTemplate(ctx context.Context, pipelineTemplate *models.PipelineTemplate) error

DeletePipelineTemplate provides a mock function with given fields: ctx, pipelineTemplate

func (*MockPipelineTemplates) DeletePipelineTemplates added in v0.42.0 

func (_m *MockPipelineTemplates) DeletePipelineTemplates(ctx context.Context, projectID string, name string) error

DeletePipelineTemplates provides a mock function with given fields: ctx, projectID, name

func (*MockPipelineTemplates) GetPipelineTemplateByID 

func (_m *MockPipelineTemplates) GetPipelineTemplateByID(ctx context.Context, id string) (*models.PipelineTemplate, error)

GetPipelineTemplateByID provides a mock function with given fields: ctx, id

func (*MockPipelineTemplates) GetPipelineTemplateByPRN 

func (_m *MockPipelineTemplates) GetPipelineTemplateByPRN(ctx context.Context, prn string) (*models.PipelineTemplate, error)

GetPipelineTemplateByPRN provides a mock function with given fields: ctx, prn

func (*MockPipelineTemplates) GetPipelineTemplates 

func (_m *MockPipelineTemplates) GetPipelineTemplates(ctx context.Context, input *GetPipelineTemplatesInput) (*PipelineTemplatesResult, error)

GetPipelineTemplates provides a mock function with given fields: ctx, input

func (*MockPipelineTemplates) UpdatePipelineTemplate 

func (_m *MockPipelineTemplates) UpdatePipelineTemplate(ctx context.Context, pipelineTemplate *models.PipelineTemplate) (*models.PipelineTemplate, error)

UpdatePipelineTemplate provides a mock function with given fields: ctx, pipelineTemplate

type MockPipelines 

type MockPipelines struct {
	mock.Mock
}

MockPipelines is an autogenerated mock type for the Pipelines type

func NewMockPipelines 

func NewMockPipelines(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockPipelines

NewMockPipelines creates a new instance of MockPipelines. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockPipelines) CreatePipeline 

func (_m *MockPipelines) CreatePipeline(ctx context.Context, pipeline *models.Pipeline) (*models.Pipeline, error)

CreatePipeline provides a mock function with given fields: ctx, pipeline

func (*MockPipelines) GetPipelineByID 

func (_m *MockPipelines) GetPipelineByID(ctx context.Context, id string) (*models.Pipeline, error)

GetPipelineByID provides a mock function with given fields: ctx, id

func (*MockPipelines) GetPipelineByPRN 

func (_m *MockPipelines) GetPipelineByPRN(ctx context.Context, prn string) (*models.Pipeline, error)

GetPipelineByPRN provides a mock function with given fields: ctx, prn

func (*MockPipelines) GetPipelineByReleaseID 

func (_m *MockPipelines) GetPipelineByReleaseID(ctx context.Context, releaseID string) (*models.Pipeline, error)

GetPipelineByReleaseID provides a mock function with given fields: ctx, releaseID

func (*MockPipelines) GetPipelineNode added in v0.47.0 

func (_m *MockPipelines) GetPipelineNode(ctx context.Context, pipelineID string, nodePath string) (models.PipelineNode, error)

GetPipelineNode provides a mock function with given fields: ctx, pipelineID, nodePath

func (*MockPipelines) GetPipelineProjectID added in v0.47.0 

func (_m *MockPipelines) GetPipelineProjectID(ctx context.Context, pipelineID string) (*string, error)

GetPipelineProjectID provides a mock function with given fields: ctx, pipelineID

func (*MockPipelines) GetPipelines 

func (_m *MockPipelines) GetPipelines(ctx context.Context, input *GetPipelinesInput) (*PipelinesResult, error)

GetPipelines provides a mock function with given fields: ctx, input

func (*MockPipelines) UpdatePipeline 

func (_m *MockPipelines) UpdatePipeline(ctx context.Context, pipeline *models.Pipeline, nodePath ...string) (*models.Pipeline, error)

UpdatePipeline provides a mock function with given fields: ctx, pipeline, nodePath

type MockPluginPlatforms 

type MockPluginPlatforms struct {
	mock.Mock
}

MockPluginPlatforms is an autogenerated mock type for the PluginPlatforms type

func NewMockPluginPlatforms 

func NewMockPluginPlatforms(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockPluginPlatforms

NewMockPluginPlatforms creates a new instance of MockPluginPlatforms. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockPluginPlatforms) CreatePluginPlatform 

func (_m *MockPluginPlatforms) CreatePluginPlatform(ctx context.Context, pluginPlatform *models.PluginPlatform) (*models.PluginPlatform, error)

CreatePluginPlatform provides a mock function with given fields: ctx, pluginPlatform

func (*MockPluginPlatforms) DeletePluginPlatform 

func (_m *MockPluginPlatforms) DeletePluginPlatform(ctx context.Context, pluginPlatform *models.PluginPlatform) error

DeletePluginPlatform provides a mock function with given fields: ctx, pluginPlatform

func (*MockPluginPlatforms) GetPluginPlatformByID 

func (_m *MockPluginPlatforms) GetPluginPlatformByID(ctx context.Context, id string) (*models.PluginPlatform, error)

GetPluginPlatformByID provides a mock function with given fields: ctx, id

func (*MockPluginPlatforms) GetPluginPlatformByPRN 

func (_m *MockPluginPlatforms) GetPluginPlatformByPRN(ctx context.Context, prn string) (*models.PluginPlatform, error)

GetPluginPlatformByPRN provides a mock function with given fields: ctx, prn

func (*MockPluginPlatforms) GetPluginPlatforms 

func (_m *MockPluginPlatforms) GetPluginPlatforms(ctx context.Context, input *GetPluginPlatformsInput) (*PluginPlatformsResult, error)

GetPluginPlatforms provides a mock function with given fields: ctx, input

func (*MockPluginPlatforms) UpdatePluginPlatform 

func (_m *MockPluginPlatforms) UpdatePluginPlatform(ctx context.Context, pluginPlatform *models.PluginPlatform) (*models.PluginPlatform, error)

UpdatePluginPlatform provides a mock function with given fields: ctx, pluginPlatform

type MockPluginVersions 

type MockPluginVersions struct {
	mock.Mock
}

MockPluginVersions is an autogenerated mock type for the PluginVersions type

func NewMockPluginVersions 

func NewMockPluginVersions(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockPluginVersions

NewMockPluginVersions creates a new instance of MockPluginVersions. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockPluginVersions) CreatePluginVersion 

func (_m *MockPluginVersions) CreatePluginVersion(ctx context.Context, pluginVersion *models.PluginVersion) (*models.PluginVersion, error)

CreatePluginVersion provides a mock function with given fields: ctx, pluginVersion

func (*MockPluginVersions) DeletePluginVersion 

func (_m *MockPluginVersions) DeletePluginVersion(ctx context.Context, pluginVersion *models.PluginVersion) error

DeletePluginVersion provides a mock function with given fields: ctx, pluginVersion

func (*MockPluginVersions) GetPluginVersionByID 

func (_m *MockPluginVersions) GetPluginVersionByID(ctx context.Context, id string) (*models.PluginVersion, error)

GetPluginVersionByID provides a mock function with given fields: ctx, id

func (*MockPluginVersions) GetPluginVersionByPRN 

func (_m *MockPluginVersions) GetPluginVersionByPRN(ctx context.Context, prn string) (*models.PluginVersion, error)

GetPluginVersionByPRN provides a mock function with given fields: ctx, prn

func (*MockPluginVersions) GetPluginVersions 

func (_m *MockPluginVersions) GetPluginVersions(ctx context.Context, input *GetPluginVersionsInput) (*PluginVersionsResult, error)

GetPluginVersions provides a mock function with given fields: ctx, input

func (*MockPluginVersions) UpdatePluginVersion 

func (_m *MockPluginVersions) UpdatePluginVersion(ctx context.Context, pluginVersion *models.PluginVersion) (*models.PluginVersion, error)

UpdatePluginVersion provides a mock function with given fields: ctx, pluginVersion

type MockPlugins 

type MockPlugins struct {
	mock.Mock
}

MockPlugins is an autogenerated mock type for the Plugins type

func NewMockPlugins 

func NewMockPlugins(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockPlugins

NewMockPlugins creates a new instance of MockPlugins. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockPlugins) CreatePlugin 

func (_m *MockPlugins) CreatePlugin(ctx context.Context, plugin *models.Plugin) (*models.Plugin, error)

CreatePlugin provides a mock function with given fields: ctx, plugin

func (*MockPlugins) DeletePlugin 

func (_m *MockPlugins) DeletePlugin(ctx context.Context, plugin *models.Plugin) error

DeletePlugin provides a mock function with given fields: ctx, plugin

func (*MockPlugins) GetPluginByID 

func (_m *MockPlugins) GetPluginByID(ctx context.Context, id string) (*models.Plugin, error)

GetPluginByID provides a mock function with given fields: ctx, id

func (*MockPlugins) GetPluginByPRN 

func (_m *MockPlugins) GetPluginByPRN(ctx context.Context, prn string) (*models.Plugin, error)

GetPluginByPRN provides a mock function with given fields: ctx, prn

func (*MockPlugins) GetPlugins 

func (_m *MockPlugins) GetPlugins(ctx context.Context, input *GetPluginsInput) (*PluginsResult, error)

GetPlugins provides a mock function with given fields: ctx, input

func (*MockPlugins) UpdatePlugin 

func (_m *MockPlugins) UpdatePlugin(ctx context.Context, plugin *models.Plugin) (*models.Plugin, error)

UpdatePlugin provides a mock function with given fields: ctx, plugin

type MockProjectVariableSets 

type MockProjectVariableSets struct {
	mock.Mock
}

MockProjectVariableSets is an autogenerated mock type for the ProjectVariableSets type

func NewMockProjectVariableSets 

func NewMockProjectVariableSets(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockProjectVariableSets

NewMockProjectVariableSets creates a new instance of MockProjectVariableSets. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockProjectVariableSets) AddProjectVariablesToSet 

func (_m *MockProjectVariableSets) AddProjectVariablesToSet(ctx context.Context, variableSet *models.ProjectVariableSet, variables []*models.ProjectVariable) error

AddProjectVariablesToSet provides a mock function with given fields: ctx, variableSet, variables

func (*MockProjectVariableSets) CreateProjectVariableSet 

func (_m *MockProjectVariableSets) CreateProjectVariableSet(ctx context.Context, variableSet *models.ProjectVariableSet) (*models.ProjectVariableSet, error)

CreateProjectVariableSet provides a mock function with given fields: ctx, variableSet

func (*MockProjectVariableSets) DeleteProjectVariableSet 

func (_m *MockProjectVariableSets) DeleteProjectVariableSet(ctx context.Context, variableSet *models.ProjectVariableSet) error

DeleteProjectVariableSet provides a mock function with given fields: ctx, variableSet

func (*MockProjectVariableSets) GetProjectVariableSetByID 

func (_m *MockProjectVariableSets) GetProjectVariableSetByID(ctx context.Context, id string) (*models.ProjectVariableSet, error)

GetProjectVariableSetByID provides a mock function with given fields: ctx, id

func (*MockProjectVariableSets) GetProjectVariableSetByPRN 

func (_m *MockProjectVariableSets) GetProjectVariableSetByPRN(ctx context.Context, prn string) (*models.ProjectVariableSet, error)

GetProjectVariableSetByPRN provides a mock function with given fields: ctx, prn

func (*MockProjectVariableSets) GetProjectVariableSets 

func (_m *MockProjectVariableSets) GetProjectVariableSets(ctx context.Context, input *GetProjectVariableSetsInput) (*ProjectVariableSetsResult, error)

GetProjectVariableSets provides a mock function with given fields: ctx, input

func (*MockProjectVariableSets) UpdateProjectVariableSet 

func (_m *MockProjectVariableSets) UpdateProjectVariableSet(ctx context.Context, variableSet *models.ProjectVariableSet) (*models.ProjectVariableSet, error)

UpdateProjectVariableSet provides a mock function with given fields: ctx, variableSet

type MockProjectVariables 

type MockProjectVariables struct {
	mock.Mock
}

MockProjectVariables is an autogenerated mock type for the ProjectVariables type

func NewMockProjectVariables 

func NewMockProjectVariables(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockProjectVariables

NewMockProjectVariables creates a new instance of MockProjectVariables. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockProjectVariables) CreateProjectVariable 

func (_m *MockProjectVariables) CreateProjectVariable(ctx context.Context, variable *models.ProjectVariable) (*models.ProjectVariable, error)

CreateProjectVariable provides a mock function with given fields: ctx, variable

func (*MockProjectVariables) DeleteProjectVariable 

func (_m *MockProjectVariables) DeleteProjectVariable(ctx context.Context, variable *models.ProjectVariable) error

DeleteProjectVariable provides a mock function with given fields: ctx, variable

func (*MockProjectVariables) GetProjectVariableByID 

func (_m *MockProjectVariables) GetProjectVariableByID(ctx context.Context, id string) (*models.ProjectVariable, error)

GetProjectVariableByID provides a mock function with given fields: ctx, id

func (*MockProjectVariables) GetProjectVariableByPRN 

func (_m *MockProjectVariables) GetProjectVariableByPRN(ctx context.Context, prn string) (*models.ProjectVariable, error)

GetProjectVariableByPRN provides a mock function with given fields: ctx, prn

func (*MockProjectVariables) GetProjectVariables 

func (_m *MockProjectVariables) GetProjectVariables(ctx context.Context, input *GetProjectVariablesInput) (*ProjectVariablesResult, error)

GetProjectVariables provides a mock function with given fields: ctx, input

type MockProjects 

type MockProjects struct {
	mock.Mock
}

MockProjects is an autogenerated mock type for the Projects type

func NewMockProjects 

func NewMockProjects(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockProjects

NewMockProjects creates a new instance of MockProjects. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockProjects) CreateProject 

func (_m *MockProjects) CreateProject(ctx context.Context, proj *models.Project) (*models.Project, error)

CreateProject provides a mock function with given fields: ctx, proj

func (*MockProjects) DeleteProject 

func (_m *MockProjects) DeleteProject(ctx context.Context, proj *models.Project) error

DeleteProject provides a mock function with given fields: ctx, proj

func (*MockProjects) GetProjectByID 

func (_m *MockProjects) GetProjectByID(ctx context.Context, id string) (*models.Project, error)

GetProjectByID provides a mock function with given fields: ctx, id

func (*MockProjects) GetProjectByPRN 

func (_m *MockProjects) GetProjectByPRN(ctx context.Context, prn string) (*models.Project, error)

GetProjectByPRN provides a mock function with given fields: ctx, prn

func (*MockProjects) GetProjects 

func (_m *MockProjects) GetProjects(ctx context.Context, input *GetProjectsInput) (*ProjectsResult, error)

GetProjects provides a mock function with given fields: ctx, input

func (*MockProjects) UpdateProject 

func (_m *MockProjects) UpdateProject(ctx context.Context, proj *models.Project) (*models.Project, error)

UpdateProject provides a mock function with given fields: ctx, proj

type MockReleaseLifecycles 

type MockReleaseLifecycles struct {
	mock.Mock
}

MockReleaseLifecycles is an autogenerated mock type for the ReleaseLifecycles type

func NewMockReleaseLifecycles 

func NewMockReleaseLifecycles(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockReleaseLifecycles

NewMockReleaseLifecycles creates a new instance of MockReleaseLifecycles. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockReleaseLifecycles) CreateReleaseLifecycle 

func (_m *MockReleaseLifecycles) CreateReleaseLifecycle(ctx context.Context, releaseLifecycle *models.ReleaseLifecycle) (*models.ReleaseLifecycle, error)

CreateReleaseLifecycle provides a mock function with given fields: ctx, releaseLifecycle

func (*MockReleaseLifecycles) DeleteReleaseLifecycle 

func (_m *MockReleaseLifecycles) DeleteReleaseLifecycle(ctx context.Context, releaseLifecycle *models.ReleaseLifecycle) error

DeleteReleaseLifecycle provides a mock function with given fields: ctx, releaseLifecycle

func (*MockReleaseLifecycles) GetReleaseLifecycleByID 

func (_m *MockReleaseLifecycles) GetReleaseLifecycleByID(ctx context.Context, id string) (*models.ReleaseLifecycle, error)

GetReleaseLifecycleByID provides a mock function with given fields: ctx, id

func (*MockReleaseLifecycles) GetReleaseLifecycleByPRN 

func (_m *MockReleaseLifecycles) GetReleaseLifecycleByPRN(ctx context.Context, prn string) (*models.ReleaseLifecycle, error)

GetReleaseLifecycleByPRN provides a mock function with given fields: ctx, prn

func (*MockReleaseLifecycles) GetReleaseLifecycles 

func (_m *MockReleaseLifecycles) GetReleaseLifecycles(ctx context.Context, input *GetReleaseLifecyclesInput) (*ReleaseLifecyclesResult, error)

GetReleaseLifecycles provides a mock function with given fields: ctx, input

func (*MockReleaseLifecycles) UpdateReleaseLifecycle 

func (_m *MockReleaseLifecycles) UpdateReleaseLifecycle(ctx context.Context, releaseLifecycle *models.ReleaseLifecycle) (*models.ReleaseLifecycle, error)

UpdateReleaseLifecycle provides a mock function with given fields: ctx, releaseLifecycle

type MockReleaseVariables added in v0.53.0 

type MockReleaseVariables struct {
	mock.Mock
}

MockReleaseVariables is an autogenerated mock type for the ReleaseVariables type

func NewMockReleaseVariables added in v0.53.0 

func NewMockReleaseVariables(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockReleaseVariables

NewMockReleaseVariables creates a new instance of MockReleaseVariables. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockReleaseVariables) CreateReleaseVariables added in v0.53.0 

func (_m *MockReleaseVariables) CreateReleaseVariables(ctx context.Context, variables []*models.ReleaseVariable) error

CreateReleaseVariables provides a mock function with given fields: ctx, variables

func (*MockReleaseVariables) DeleteReleaseVariable added in v0.53.0 

func (_m *MockReleaseVariables) DeleteReleaseVariable(ctx context.Context, variable *models.ReleaseVariable) error

DeleteReleaseVariable provides a mock function with given fields: ctx, variable

func (*MockReleaseVariables) GetReleaseVariableByID added in v0.53.0 

func (_m *MockReleaseVariables) GetReleaseVariableByID(ctx context.Context, id string) (*models.ReleaseVariable, error)

GetReleaseVariableByID provides a mock function with given fields: ctx, id

func (*MockReleaseVariables) GetReleaseVariables added in v0.53.0 

func (_m *MockReleaseVariables) GetReleaseVariables(ctx context.Context, input *GetReleaseVariablesInput) (*ReleaseVariablesResult, error)

GetReleaseVariables provides a mock function with given fields: ctx, input

type MockReleases 

type MockReleases struct {
	mock.Mock
}

MockReleases is an autogenerated mock type for the Releases type

func NewMockReleases 

func NewMockReleases(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockReleases

NewMockReleases creates a new instance of MockReleases. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockReleases) CreateRelease 

func (_m *MockReleases) CreateRelease(ctx context.Context, release *models.Release) (*models.Release, error)

CreateRelease provides a mock function with given fields: ctx, release

func (*MockReleases) DeleteRelease 

func (_m *MockReleases) DeleteRelease(ctx context.Context, release *models.Release) error

DeleteRelease provides a mock function with given fields: ctx, release

func (*MockReleases) GetReleaseByID 

func (_m *MockReleases) GetReleaseByID(ctx context.Context, id string) (*models.Release, error)

GetReleaseByID provides a mock function with given fields: ctx, id

func (*MockReleases) GetReleaseByPRN 

func (_m *MockReleases) GetReleaseByPRN(ctx context.Context, prn string) (*models.Release, error)

GetReleaseByPRN provides a mock function with given fields: ctx, prn

func (*MockReleases) GetReleases 

func (_m *MockReleases) GetReleases(ctx context.Context, input *GetReleasesInput) (*ReleasesResult, error)

GetReleases provides a mock function with given fields: ctx, input

func (*MockReleases) UpdateRelease 

func (_m *MockReleases) UpdateRelease(ctx context.Context, release *models.Release) (*models.Release, error)

UpdateRelease provides a mock function with given fields: ctx, release

type MockResourceLimits 

type MockResourceLimits struct {
	mock.Mock
}

MockResourceLimits is an autogenerated mock type for the ResourceLimits type

func NewMockResourceLimits 

func NewMockResourceLimits(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockResourceLimits

NewMockResourceLimits creates a new instance of MockResourceLimits. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockResourceLimits) GetResourceLimit 

func (_m *MockResourceLimits) GetResourceLimit(ctx context.Context, name string) (*models.ResourceLimit, error)

GetResourceLimit provides a mock function with given fields: ctx, name

func (*MockResourceLimits) GetResourceLimits 

func (_m *MockResourceLimits) GetResourceLimits(ctx context.Context) ([]models.ResourceLimit, error)

GetResourceLimits provides a mock function with given fields: ctx

func (*MockResourceLimits) UpdateResourceLimit 

func (_m *MockResourceLimits) UpdateResourceLimit(ctx context.Context, resourceLimit *models.ResourceLimit) (*models.ResourceLimit, error)

UpdateResourceLimit provides a mock function with given fields: ctx, resourceLimit

type MockRoles 

type MockRoles struct {
	mock.Mock
}

MockRoles is an autogenerated mock type for the Roles type

func NewMockRoles 

func NewMockRoles(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockRoles

NewMockRoles creates a new instance of MockRoles. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockRoles) CreateRole 

func (_m *MockRoles) CreateRole(ctx context.Context, role *models.Role) (*models.Role, error)

CreateRole provides a mock function with given fields: ctx, role

func (*MockRoles) DeleteRole 

func (_m *MockRoles) DeleteRole(ctx context.Context, role *models.Role) error

DeleteRole provides a mock function with given fields: ctx, role

func (*MockRoles) GetRoleByID 

func (_m *MockRoles) GetRoleByID(ctx context.Context, id string) (*models.Role, error)

GetRoleByID provides a mock function with given fields: ctx, id

func (*MockRoles) GetRoleByName 

func (_m *MockRoles) GetRoleByName(ctx context.Context, name string) (*models.Role, error)

GetRoleByName provides a mock function with given fields: ctx, name

func (*MockRoles) GetRoleByPRN 

func (_m *MockRoles) GetRoleByPRN(ctx context.Context, prn string) (*models.Role, error)

GetRoleByPRN provides a mock function with given fields: ctx, prn

func (*MockRoles) GetRoles 

func (_m *MockRoles) GetRoles(ctx context.Context, input *GetRolesInput) (*RolesResult, error)

GetRoles provides a mock function with given fields: ctx, input

func (*MockRoles) UpdateRole 

func (_m *MockRoles) UpdateRole(ctx context.Context, role *models.Role) (*models.Role, error)

UpdateRole provides a mock function with given fields: ctx, role

type MockSCIMTokens 

type MockSCIMTokens struct {
	mock.Mock
}

MockSCIMTokens is an autogenerated mock type for the SCIMTokens type

func NewMockSCIMTokens 

func NewMockSCIMTokens(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockSCIMTokens

NewMockSCIMTokens creates a new instance of MockSCIMTokens. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockSCIMTokens) CreateToken 

func (_m *MockSCIMTokens) CreateToken(ctx context.Context, token *models.SCIMToken) (*models.SCIMToken, error)

CreateToken provides a mock function with given fields: ctx, token

func (*MockSCIMTokens) DeleteToken 

func (_m *MockSCIMTokens) DeleteToken(ctx context.Context, token *models.SCIMToken) error

DeleteToken provides a mock function with given fields: ctx, token

func (*MockSCIMTokens) GetTokenByNonce 

func (_m *MockSCIMTokens) GetTokenByNonce(ctx context.Context, nonce string) (*models.SCIMToken, error)

GetTokenByNonce provides a mock function with given fields: ctx, nonce

func (*MockSCIMTokens) GetTokens 

func (_m *MockSCIMTokens) GetTokens(ctx context.Context) ([]models.SCIMToken, error)

GetTokens provides a mock function with given fields: ctx

type MockSchemaMigrations added in v0.9.0 

type MockSchemaMigrations struct {
	mock.Mock
}

MockSchemaMigrations is an autogenerated mock type for the SchemaMigrations type

func NewMockSchemaMigrations added in v0.9.0 

func NewMockSchemaMigrations(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockSchemaMigrations

NewMockSchemaMigrations creates a new instance of MockSchemaMigrations. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockSchemaMigrations) GetCurrentMigration added in v0.9.0 

func (_m *MockSchemaMigrations) GetCurrentMigration(ctx context.Context) (*SchemaMigration, error)

GetCurrentMigration provides a mock function with given fields: ctx

type MockServiceAccounts 

type MockServiceAccounts struct {
	mock.Mock
}

MockServiceAccounts is an autogenerated mock type for the ServiceAccounts type

func NewMockServiceAccounts 

func NewMockServiceAccounts(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockServiceAccounts

NewMockServiceAccounts creates a new instance of MockServiceAccounts. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockServiceAccounts) AssignServiceAccountToAgent 

func (_m *MockServiceAccounts) AssignServiceAccountToAgent(ctx context.Context, serviceAccountID string, agentID string) error

AssignServiceAccountToAgent provides a mock function with given fields: ctx, serviceAccountID, agentID

func (*MockServiceAccounts) CreateServiceAccount 

func (_m *MockServiceAccounts) CreateServiceAccount(ctx context.Context, serviceAccount *models.ServiceAccount) (*models.ServiceAccount, error)

CreateServiceAccount provides a mock function with given fields: ctx, serviceAccount

func (*MockServiceAccounts) DeleteServiceAccount 

func (_m *MockServiceAccounts) DeleteServiceAccount(ctx context.Context, serviceAccount *models.ServiceAccount) error

DeleteServiceAccount provides a mock function with given fields: ctx, serviceAccount

func (*MockServiceAccounts) GetServiceAccountByID 

func (_m *MockServiceAccounts) GetServiceAccountByID(ctx context.Context, id string) (*models.ServiceAccount, error)

GetServiceAccountByID provides a mock function with given fields: ctx, id

func (*MockServiceAccounts) GetServiceAccountByPRN 

func (_m *MockServiceAccounts) GetServiceAccountByPRN(ctx context.Context, prn string) (*models.ServiceAccount, error)

GetServiceAccountByPRN provides a mock function with given fields: ctx, prn

func (*MockServiceAccounts) GetServiceAccounts 

func (_m *MockServiceAccounts) GetServiceAccounts(ctx context.Context, input *GetServiceAccountsInput) (*ServiceAccountsResult, error)

GetServiceAccounts provides a mock function with given fields: ctx, input

func (*MockServiceAccounts) UnassignServiceAccountFromAgent 

func (_m *MockServiceAccounts) UnassignServiceAccountFromAgent(ctx context.Context, serviceAccountID string, agentID string) error

UnassignServiceAccountFromAgent provides a mock function with given fields: ctx, serviceAccountID, agentID

func (*MockServiceAccounts) UpdateServiceAccount 

func (_m *MockServiceAccounts) UpdateServiceAccount(ctx context.Context, serviceAccount *models.ServiceAccount) (*models.ServiceAccount, error)

UpdateServiceAccount provides a mock function with given fields: ctx, serviceAccount

type MockTeamMembers 

type MockTeamMembers struct {
	mock.Mock
}

MockTeamMembers is an autogenerated mock type for the TeamMembers type

func NewMockTeamMembers 

func NewMockTeamMembers(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockTeamMembers

NewMockTeamMembers creates a new instance of MockTeamMembers. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockTeamMembers) AddUserToTeam 

func (_m *MockTeamMembers) AddUserToTeam(ctx context.Context, teamMember *models.TeamMember) (*models.TeamMember, error)

AddUserToTeam provides a mock function with given fields: ctx, teamMember

func (*MockTeamMembers) GetTeamMember 

func (_m *MockTeamMembers) GetTeamMember(ctx context.Context, userID string, teamID string) (*models.TeamMember, error)

GetTeamMember provides a mock function with given fields: ctx, userID, teamID

func (*MockTeamMembers) GetTeamMembers 

func (_m *MockTeamMembers) GetTeamMembers(ctx context.Context, input *GetTeamMembersInput) (*TeamMembersResult, error)

GetTeamMembers provides a mock function with given fields: ctx, input

func (*MockTeamMembers) RemoveUserFromTeam 

func (_m *MockTeamMembers) RemoveUserFromTeam(ctx context.Context, teamMember *models.TeamMember) error

RemoveUserFromTeam provides a mock function with given fields: ctx, teamMember

func (*MockTeamMembers) UpdateTeamMember 

func (_m *MockTeamMembers) UpdateTeamMember(ctx context.Context, teamMember *models.TeamMember) (*models.TeamMember, error)

UpdateTeamMember provides a mock function with given fields: ctx, teamMember

type MockTeams 

type MockTeams struct {
	mock.Mock
}

MockTeams is an autogenerated mock type for the Teams type

func NewMockTeams 

func NewMockTeams(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockTeams

NewMockTeams creates a new instance of MockTeams. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockTeams) CreateTeam 

func (_m *MockTeams) CreateTeam(ctx context.Context, team *models.Team) (*models.Team, error)

CreateTeam provides a mock function with given fields: ctx, team

func (*MockTeams) DeleteTeam 

func (_m *MockTeams) DeleteTeam(ctx context.Context, team *models.Team) error

DeleteTeam provides a mock function with given fields: ctx, team

func (*MockTeams) GetTeamByID 

func (_m *MockTeams) GetTeamByID(ctx context.Context, id string) (*models.Team, error)

GetTeamByID provides a mock function with given fields: ctx, id

func (*MockTeams) GetTeamByPRN 

func (_m *MockTeams) GetTeamByPRN(ctx context.Context, prn string) (*models.Team, error)

GetTeamByPRN provides a mock function with given fields: ctx, prn

func (*MockTeams) GetTeamBySCIMExternalID 

func (_m *MockTeams) GetTeamBySCIMExternalID(ctx context.Context, scimExternalID string) (*models.Team, error)

GetTeamBySCIMExternalID provides a mock function with given fields: ctx, scimExternalID

func (*MockTeams) GetTeams 

func (_m *MockTeams) GetTeams(ctx context.Context, input *GetTeamsInput) (*TeamsResult, error)

GetTeams provides a mock function with given fields: ctx, input

func (*MockTeams) UpdateTeam 

func (_m *MockTeams) UpdateTeam(ctx context.Context, team *models.Team) (*models.Team, error)

UpdateTeam provides a mock function with given fields: ctx, team

type MockThreads 

type MockThreads struct {
	mock.Mock
}

MockThreads is an autogenerated mock type for the Threads type

func NewMockThreads 

func NewMockThreads(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockThreads

NewMockThreads creates a new instance of MockThreads. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockThreads) CreateThread 

func (_m *MockThreads) CreateThread(ctx context.Context, thread *models.Thread) (*models.Thread, error)

CreateThread provides a mock function with given fields: ctx, thread

func (*MockThreads) DeleteThread 

func (_m *MockThreads) DeleteThread(ctx context.Context, thread *models.Thread) error

DeleteThread provides a mock function with given fields: ctx, thread

func (*MockThreads) GetThreadByID 

func (_m *MockThreads) GetThreadByID(ctx context.Context, id string) (*models.Thread, error)

GetThreadByID provides a mock function with given fields: ctx, id

func (*MockThreads) GetThreadByPRN 

func (_m *MockThreads) GetThreadByPRN(ctx context.Context, prn string) (*models.Thread, error)

GetThreadByPRN provides a mock function with given fields: ctx, prn

func (*MockThreads) GetThreads 

func (_m *MockThreads) GetThreads(ctx context.Context, input *GetThreadsInput) (*ThreadsResult, error)

GetThreads provides a mock function with given fields: ctx, input

type MockToDoItems 

type MockToDoItems struct {
	mock.Mock
}

MockToDoItems is an autogenerated mock type for the ToDoItems type

func NewMockToDoItems 

func NewMockToDoItems(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockToDoItems

NewMockToDoItems creates a new instance of MockToDoItems. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockToDoItems) CreateToDoItem 

func (_m *MockToDoItems) CreateToDoItem(ctx context.Context, item *models.ToDoItem) (*models.ToDoItem, error)

CreateToDoItem provides a mock function with given fields: ctx, item

func (*MockToDoItems) GetToDoItemByPRN 

func (_m *MockToDoItems) GetToDoItemByPRN(ctx context.Context, prn string) (*models.ToDoItem, error)

GetToDoItemByPRN provides a mock function with given fields: ctx, prn

func (*MockToDoItems) GetToDoItems 

func (_m *MockToDoItems) GetToDoItems(ctx context.Context, input *GetToDoItemsInput) (*ToDoItemsResult, error)

GetToDoItems provides a mock function with given fields: ctx, input

func (*MockToDoItems) UpdateToDoItem 

func (_m *MockToDoItems) UpdateToDoItem(ctx context.Context, item *models.ToDoItem) (*models.ToDoItem, error)

UpdateToDoItem provides a mock function with given fields: ctx, item

type MockTransactions 

type MockTransactions struct {
	mock.Mock
}

MockTransactions is an autogenerated mock type for the Transactions type

func NewMockTransactions 

func NewMockTransactions(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockTransactions

NewMockTransactions creates a new instance of MockTransactions. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockTransactions) BeginTx 

func (_m *MockTransactions) BeginTx(ctx context.Context) (context.Context, error)

BeginTx provides a mock function with given fields: ctx

func (*MockTransactions) CommitTx 

func (_m *MockTransactions) CommitTx(ctx context.Context) error

CommitTx provides a mock function with given fields: ctx

func (*MockTransactions) RollbackTx 

func (_m *MockTransactions) RollbackTx(ctx context.Context) error

RollbackTx provides a mock function with given fields: ctx

type MockUserSessions added in v0.42.0 

type MockUserSessions struct {
	mock.Mock
}

MockUserSessions is an autogenerated mock type for the UserSessions type

func NewMockUserSessions added in v0.42.0 

func NewMockUserSessions(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockUserSessions

NewMockUserSessions creates a new instance of MockUserSessions. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockUserSessions) CreateUserSession added in v0.42.0 

func (_m *MockUserSessions) CreateUserSession(ctx context.Context, session *models.UserSession) (*models.UserSession, error)

CreateUserSession provides a mock function with given fields: ctx, session

func (*MockUserSessions) DeleteUserSession added in v0.42.0 

func (_m *MockUserSessions) DeleteUserSession(ctx context.Context, session *models.UserSession) error

DeleteUserSession provides a mock function with given fields: ctx, session

func (*MockUserSessions) GetUserSessionByID added in v0.42.0 

func (_m *MockUserSessions) GetUserSessionByID(ctx context.Context, id string) (*models.UserSession, error)

GetUserSessionByID provides a mock function with given fields: ctx, id

func (*MockUserSessions) GetUserSessionByPRN added in v0.42.0 

func (_m *MockUserSessions) GetUserSessionByPRN(ctx context.Context, prn string) (*models.UserSession, error)

GetUserSessionByPRN provides a mock function with given fields: ctx, prn

func (*MockUserSessions) GetUserSessions added in v0.42.0 

func (_m *MockUserSessions) GetUserSessions(ctx context.Context, input *GetUserSessionsInput) (*UserSessionsResult, error)

GetUserSessions provides a mock function with given fields: ctx, input

func (*MockUserSessions) UpdateUserSession added in v0.42.0 

func (_m *MockUserSessions) UpdateUserSession(ctx context.Context, session *models.UserSession) (*models.UserSession, error)

UpdateUserSession provides a mock function with given fields: ctx, session

type MockUsers 

type MockUsers struct {
	mock.Mock
}

MockUsers is an autogenerated mock type for the Users type

func NewMockUsers 

func NewMockUsers(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockUsers

NewMockUsers creates a new instance of MockUsers. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockUsers) CreateUser 

func (_m *MockUsers) CreateUser(ctx context.Context, user *models.User) (*models.User, error)

CreateUser provides a mock function with given fields: ctx, user

func (*MockUsers) DeleteUser 

func (_m *MockUsers) DeleteUser(ctx context.Context, user *models.User) error

DeleteUser provides a mock function with given fields: ctx, user

func (*MockUsers) GetUserByEmail 

func (_m *MockUsers) GetUserByEmail(ctx context.Context, email string) (*models.User, error)

GetUserByEmail provides a mock function with given fields: ctx, email

func (*MockUsers) GetUserByExternalID 

func (_m *MockUsers) GetUserByExternalID(ctx context.Context, issuer string, externalID string) (*models.User, error)

GetUserByExternalID provides a mock function with given fields: ctx, issuer, externalID

func (*MockUsers) GetUserByID 

func (_m *MockUsers) GetUserByID(ctx context.Context, id string) (*models.User, error)

GetUserByID provides a mock function with given fields: ctx, id

func (*MockUsers) GetUserByPRN 

func (_m *MockUsers) GetUserByPRN(ctx context.Context, prn string) (*models.User, error)

GetUserByPRN provides a mock function with given fields: ctx, prn

func (*MockUsers) GetUserBySCIMExternalID 

func (_m *MockUsers) GetUserBySCIMExternalID(ctx context.Context, scimExternalID string) (*models.User, error)

GetUserBySCIMExternalID provides a mock function with given fields: ctx, scimExternalID

func (*MockUsers) GetUsers 

func (_m *MockUsers) GetUsers(ctx context.Context, input *GetUsersInput) (*UsersResult, error)

GetUsers provides a mock function with given fields: ctx, input

func (*MockUsers) LinkUserWithExternalID 

func (_m *MockUsers) LinkUserWithExternalID(ctx context.Context, issuer string, externalID string, userID string) error

LinkUserWithExternalID provides a mock function with given fields: ctx, issuer, externalID, userID

func (*MockUsers) UnlinkUserExternalID added in v0.51.0 

func (_m *MockUsers) UnlinkUserExternalID(ctx context.Context, issuer string, externalID string) error

UnlinkUserExternalID provides a mock function with given fields: ctx, issuer, externalID

func (*MockUsers) UpdateUser 

func (_m *MockUsers) UpdateUser(ctx context.Context, user *models.User) (*models.User, error)

UpdateUser provides a mock function with given fields: ctx, user

type MockVCSProviders 

type MockVCSProviders struct {
	mock.Mock
}

MockVCSProviders is an autogenerated mock type for the VCSProviders type

func NewMockVCSProviders 

func NewMockVCSProviders(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockVCSProviders

NewMockVCSProviders creates a new instance of MockVCSProviders. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockVCSProviders) CreateProvider 

func (_m *MockVCSProviders) CreateProvider(ctx context.Context, provider *models.VCSProvider) (*models.VCSProvider, error)

CreateProvider provides a mock function with given fields: ctx, provider

func (*MockVCSProviders) DeleteProvider 

func (_m *MockVCSProviders) DeleteProvider(ctx context.Context, provider *models.VCSProvider) error

DeleteProvider provides a mock function with given fields: ctx, provider

func (*MockVCSProviders) GetProviderByID 

func (_m *MockVCSProviders) GetProviderByID(ctx context.Context, id string) (*models.VCSProvider, error)

GetProviderByID provides a mock function with given fields: ctx, id

func (*MockVCSProviders) GetProviderByOAuthState 

func (_m *MockVCSProviders) GetProviderByOAuthState(ctx context.Context, state string) (*models.VCSProvider, error)

GetProviderByOAuthState provides a mock function with given fields: ctx, state

func (*MockVCSProviders) GetProviderByPRN 

func (_m *MockVCSProviders) GetProviderByPRN(ctx context.Context, prn string) (*models.VCSProvider, error)

GetProviderByPRN provides a mock function with given fields: ctx, prn

func (*MockVCSProviders) GetProviders 

func (_m *MockVCSProviders) GetProviders(ctx context.Context, input *GetVCSProvidersInput) (*VCSProvidersResult, error)

GetProviders provides a mock function with given fields: ctx, input

func (*MockVCSProviders) UpdateProvider 

func (_m *MockVCSProviders) UpdateProvider(ctx context.Context, provider *models.VCSProvider) (*models.VCSProvider, error)

UpdateProvider provides a mock function with given fields: ctx, provider

type MockWorkItemsQueue added in v0.52.0 

type MockWorkItemsQueue struct {
	mock.Mock
}

MockWorkItemsQueue is an autogenerated mock type for the WorkItemsQueue type

func NewMockWorkItemsQueue added in v0.52.0 

func NewMockWorkItemsQueue(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockWorkItemsQueue

NewMockWorkItemsQueue creates a new instance of MockWorkItemsQueue. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockWorkItemsQueue) AcknowledgeWorkItem added in v0.52.0 

func (_m *MockWorkItemsQueue) AcknowledgeWorkItem(ctx context.Context, workItemID string) error

AcknowledgeWorkItem provides a mock function with given fields: ctx, workItemID

func (*MockWorkItemsQueue) AddWorkItemToQueue added in v0.52.0 

func (_m *MockWorkItemsQueue) AddWorkItemToQueue(ctx context.Context, item *AddWorkItemToQueueInput) (*WorkItem, error)

AddWorkItemToQueue provides a mock function with given fields: ctx, item

func (*MockWorkItemsQueue) ClaimWorkItems added in v0.52.0 

func (_m *MockWorkItemsQueue) ClaimWorkItems(ctx context.Context, input *ClaimWorkItemsInput) ([]WorkItem, error)

ClaimWorkItems provides a mock function with given fields: ctx, input

type NotificationPreferenceFilter added in v0.46.0 

type NotificationPreferenceFilter struct {
	NotificationPreferenceIDs []string
	UserIDs                   []string
	OrganizationID            *string
	ProjectID                 *string
	Global                    *bool
}

NotificationPreferenceFilter contains the supported fields for filtering NotificationPreference resources

type NotificationPreferenceSortableField added in v0.46.0 

type NotificationPreferenceSortableField string

NotificationPreferenceSortableField represents the fields that a notification preference can be sorted by 

const (
	NotificationPreferenceSortableFieldCreatedAtAsc  NotificationPreferenceSortableField = "CREATED_AT_ASC"
	NotificationPreferenceSortableFieldCreatedAtDesc NotificationPreferenceSortableField = "CREATED_AT_DESC"
	NotificationPreferenceSortableFieldUpdatedAtAsc  NotificationPreferenceSortableField = "UPDATED_AT_ASC"
	NotificationPreferenceSortableFieldUpdatedAtDesc NotificationPreferenceSortableField = "UPDATED_AT_DESC"
)

GroupSortableField constants

type NotificationPreferences added in v0.46.0 

type NotificationPreferences interface {
	GetNotificationPreferences(ctx context.Context, input *GetNotificationPreferencesInput) (*NotificationPreferencesResult, error)
	UpdateNotificationPreference(ctx context.Context, preference *models.NotificationPreference) (*models.NotificationPreference, error)
	CreateNotificationPreference(ctx context.Context, preference *models.NotificationPreference) (*models.NotificationPreference, error)
	DeleteNotificationPreference(ctx context.Context, preference *models.NotificationPreference) error
}

NotificationPreferences encapsulates the logic to access notification preferences from the database

func NewNotificationPreferences added in v0.46.0 

func NewNotificationPreferences(dbClient *Client) NotificationPreferences

NewNotificationPreferences returns an instance of the NotificationPreferences interface

type NotificationPreferencesResult added in v0.46.0 

type NotificationPreferencesResult struct {
	PageInfo                *pagination.PageInfo
	NotificationPreferences []models.NotificationPreference
}

NotificationPreferencesResult contains the response data and page information

type OrganizationFilter 

type OrganizationFilter struct {
	UserMemberID           *string
	ServiceAccountMemberID *string
	Search                 *string
	OrganizationIDs        []string
}

OrganizationFilter contains the supported fields for filtering Organization resources

type OrganizationSortableField 

type OrganizationSortableField string

OrganizationSortableField represents the fields that an organization can be sorted by 

const (
	OrganizationSortableFieldUpdatedAtAsc  OrganizationSortableField = "UPDATED_AT_ASC"
	OrganizationSortableFieldUpdatedAtDesc OrganizationSortableField = "UPDATED_AT_DESC"
)

OrganizationSortableField constants

type Organizations 

type Organizations interface {
	GetOrganizationByID(ctx context.Context, id string) (*models.Organization, error)
	GetOrganizationByName(ctx context.Context, name string) (*models.Organization, error)
	GetOrganizationByPRN(ctx context.Context, prn string) (*models.Organization, error)
	GetOrganizations(ctx context.Context, input *GetOrganizationsInput) (*OrganizationsResult, error)
	CreateOrganization(ctx context.Context, org *models.Organization) (*models.Organization, error)
	UpdateOrganization(ctx context.Context, org *models.Organization) (*models.Organization, error)
	DeleteOrganization(ctx context.Context, org *models.Organization) error
}

Organizations encapsulates the logic to access Organizations from the database

func NewOrganizations 

func NewOrganizations(dbClient *Client) Organizations

NewOrganizations returns an instance of the Organizations interface

type OrganizationsResult 

type OrganizationsResult struct {
	PageInfo      *pagination.PageInfo
	Organizations []models.Organization
}

OrganizationsResult contains the response data and page information

type PipelineActionOutputs 

type PipelineActionOutputs interface {
	CreatePipelineActionOutput(ctx context.Context, output *models.PipelineActionOutput) (*models.PipelineActionOutput, error)
	GetPipelineActionOutputs(ctx context.Context, pipelineID string, actions []string) ([]*models.PipelineActionOutput, error)
	DeletePipelineActionOutput(ctx context.Context, output *models.PipelineActionOutput) error
}

PipelineActionOutputs encapsulates the logic to access state version outputs from the database

func NewPipelineActionOutputs 

func NewPipelineActionOutputs(dbClient *Client) PipelineActionOutputs

NewPipelineActionOutputs returns an instance of the PipelineActionOutput interface

type PipelineApprovalFilter 

type PipelineApprovalFilter struct {
	PipelineID       *string
	TaskPath         *string
	UserID           *string
	ServiceAccountID *string
	Type             *models.PipelineApprovalType
}

PipelineApprovalFilter contains the supported fields for filtering PipelineApproval resources

type PipelineApprovalSortableField 

type PipelineApprovalSortableField string

PipelineApprovalSortableField represents the fields that a pipeline approval can be sorted by 

const (
	PipelineApprovalSortableFieldUpdatedAtAsc  PipelineApprovalSortableField = "UPDATED_AT_ASC"
	PipelineApprovalSortableFieldUpdatedAtDesc PipelineApprovalSortableField = "UPDATED_AT_DESC"
)

PipelineApprovalSortableField constants

type PipelineApprovals 

type PipelineApprovals interface {
	CreatePipelineApproval(ctx context.Context, req *models.PipelineApproval) (*models.PipelineApproval, error)
	DeletePipelineApproval(ctx context.Context, req *models.PipelineApproval) error
	GetPipelineApprovals(ctx context.Context, input *GetPipelineApprovalsInput) (*PipelineApprovalsResult, error)
}

PipelineApprovals encapsulates the logic to access pipeline approvals from the DB.

func NewPipelineApprovals 

func NewPipelineApprovals(dbClient *Client) PipelineApprovals

NewPipelineApprovals returns an instance of the PipelineApprovals interface

type PipelineApprovalsResult 

type PipelineApprovalsResult struct {
	PageInfo          *pagination.PageInfo
	PipelineApprovals []*models.PipelineApproval
}

PipelineApprovalsResult contains the response data and page information

type PipelineEventData added in v0.7.0 

type PipelineEventData struct {
	ProjectID string `json:"project_id"`
}

PipelineEventData contains the event response data for a row from the pipelines table.

type PipelineFilter 

type PipelineFilter struct {
	TimeRangeStart               *time.Time
	Completed                    *bool
	ParentPipelineID             *string
	ParentNestedPipelineNodePath *string
	ProjectID                    *string
	Started                      *bool
	Superseded                   *bool
	EnvironmentName              *string
	ReleaseID                    *string
	PipelineTemplateIDs          []string
	PipelineIDs                  []string
	PipelineStatuses             []statemachine.NodeStatus
	NodeTypes                    []statemachine.NodeType
	NodeStatuses                 []statemachine.NodeStatus
	PipelineTypes                []models.PipelineType
}

PipelineFilter contains the supported fields for filtering Pipeline resources.

type PipelineOutputs added in v0.51.0 

type PipelineOutputs interface {
	CreatePipelineOutput(ctx context.Context, output *models.PipelineOutput) (*models.PipelineOutput, error)
	GetPipelineOutputs(ctx context.Context, pipelineID string, nodePaths []string) ([]*models.PipelineOutput, error)
	DeletePipelineOutputs(ctx context.Context, input *DeletePipelineOutputsInput) error
}

PipelineOutputs encapsulates the logic to access pipeline outputs in the database

func NewPipelineOutputs added in v0.51.0 

func NewPipelineOutputs(dbClient *Client) PipelineOutputs

NewPipelineOutputs returns an instance of the PipelineOutput interface

type PipelineSortableField 

type PipelineSortableField string

PipelineSortableField represents the fields that a pipeline can be sorted by 

const (
	PipelineSortableFieldCreatedAtAsc    PipelineSortableField = "CREATED_AT_ASC"
	PipelineSortableFieldCreatedAtDesc   PipelineSortableField = "CREATED_AT_DESC"
	PipelineSortableFieldUpdatedAtAsc    PipelineSortableField = "UPDATED_AT_ASC"
	PipelineSortableFieldUpdatedAtDesc   PipelineSortableField = "UPDATED_AT_DESC"
	PipelineSortableFieldCompletedAtAsc  PipelineSortableField = "COMPLETED_AT_ASC"
	PipelineSortableFieldCompletedAtDesc PipelineSortableField = "COMPLETED_AT_DESC"
	PipelineSortableFieldStartedAtAsc    PipelineSortableField = "STARTED_AT_ASC"
	PipelineSortableFieldStartedAtDesc   PipelineSortableField = "STARTED_AT_DESC"
)

PipelineSortableField constants

type PipelineTemplateFilter 

type PipelineTemplateFilter struct {
	TimeRangeStart        *time.Time
	Versioned             *bool
	Archived              *bool
	Latest                *bool
	Name                  *string
	Search                *string
	PipelineTemplateIDs   []string
	ProjectID             *string
	OrganizationID        *string
	ProjectName           *string
	OrganizationName      *string
	MembershipRequirement *PipelineTemplateMembershipRequirement
	Visibilities          []models.Visibility
	// ORFilters are OR'd together for flexible composition
	ORFilters []*PipelineTemplateFilter
}

PipelineTemplateFilter contains the supported fields for filtering PipelineTemplate resources

type PipelineTemplateMembershipRequirement added in v0.42.0 

type PipelineTemplateMembershipRequirement struct {
	UserID           *string
	ServiceAccountID *string
}

PipelineTemplateMembershipRequirement represents a requirement for querying pipeline templates for a user or service account.

type PipelineTemplateSortableField 

type PipelineTemplateSortableField string

PipelineTemplateSortableField represents the fields that a pipeline template can be sorted by 

const (
	PipelineTemplateSortableFieldCreatedAtAsc  PipelineTemplateSortableField = "CREATED_AT_ASC"
	PipelineTemplateSortableFieldCreatedAtDesc PipelineTemplateSortableField = "CREATED_AT_DESC"
	PipelineTemplateSortableFieldUpdatedAtAsc  PipelineTemplateSortableField = "UPDATED_AT_ASC"
	PipelineTemplateSortableFieldUpdatedAtDesc PipelineTemplateSortableField = "UPDATED_AT_DESC"
)

PipelineTemplateSortableField constants

type PipelineTemplates 

type PipelineTemplates interface {
	GetPipelineTemplateByID(ctx context.Context, id string) (*models.PipelineTemplate, error)
	GetPipelineTemplateByPRN(ctx context.Context, prn string) (*models.PipelineTemplate, error)
	GetPipelineTemplates(ctx context.Context, input *GetPipelineTemplatesInput) (*PipelineTemplatesResult, error)
	CreatePipelineTemplate(ctx context.Context, pipelineTemplate *models.PipelineTemplate) (*models.PipelineTemplate, error)
	UpdatePipelineTemplate(ctx context.Context, pipelineTemplate *models.PipelineTemplate) (*models.PipelineTemplate, error)
	DeletePipelineTemplate(ctx context.Context, pipelineTemplate *models.PipelineTemplate) error
	DeletePipelineTemplates(ctx context.Context, projectID, name string) error
}

PipelineTemplates encapsulates the logic to access PipelineTemplates from the database

func NewPipelineTemplates 

func NewPipelineTemplates(dbClient *Client) PipelineTemplates

NewPipelineTemplates returns an instance of the PipelineTemplates interface

type PipelineTemplatesResult 

type PipelineTemplatesResult struct {
	PageInfo          *pagination.PageInfo
	PipelineTemplates []models.PipelineTemplate
}

PipelineTemplatesResult contains the response data and page information

type Pipelines 

type Pipelines interface {
	GetPipelineByID(ctx context.Context, id string) (*models.Pipeline, error)
	GetPipelineByReleaseID(ctx context.Context, releaseID string) (*models.Pipeline, error)
	GetPipelineNode(ctx context.Context, pipelineID, nodePath string) (models.PipelineNode, error)
	GetPipelineByPRN(ctx context.Context, prn string) (*models.Pipeline, error)
	GetPipelines(ctx context.Context, input *GetPipelinesInput) (*PipelinesResult, error)
	CreatePipeline(ctx context.Context, pipeline *models.Pipeline) (*models.Pipeline, error)
	UpdatePipeline(ctx context.Context, pipeline *models.Pipeline, nodePath ...string) (*models.Pipeline, error)
	GetPipelineProjectID(ctx context.Context, pipelineID string) (*string, error)
}

Pipelines encapsulates the logic to access Pipelines from the database

func NewPipelines 

func NewPipelines(dbClient *Client) Pipelines

NewPipelines returns an instance of the Pipelines interface

type PipelinesResult 

type PipelinesResult struct {
	PageInfo  *pagination.PageInfo
	Pipelines []models.Pipeline
}

PipelinesResult contains the response data and page information

type PluginFilter 

type PluginFilter struct {
	Search           *string
	OrganizationID   *string
	UserID           *string
	ServiceAccountID *string
	HasVersions      *bool
	PluginIDs        []string
}

PluginFilter represents a filter for the Plugin entity.

type PluginPlatformFilter 

type PluginPlatformFilter struct {
	PluginID        *string
	PluginVersionID *string
	BinaryUploaded  *bool
	OperatingSystem *string
	Architecture    *string
}

PluginPlatformFilter represents the filters that can be used to filter a collection of plugin_platforms.

type PluginPlatformSortableField 

type PluginPlatformSortableField string

PluginPlatformSortableField represents the fields that can be used to sort a collection of plugin_platforms. 

const (
	PluginPlatformSortableFieldUpdatedAtAsc  PluginPlatformSortableField = "UPDATED_AT_ASC"
	PluginPlatformSortableFieldUpdatedAtDesc PluginPlatformSortableField = "UPDATED_AT_DESC"
)

PluginPlatformSortableField constants

type PluginPlatforms 

type PluginPlatforms interface {
	GetPluginPlatformByID(ctx context.Context, id string) (*models.PluginPlatform, error)
	GetPluginPlatformByPRN(ctx context.Context, prn string) (*models.PluginPlatform, error)
	GetPluginPlatforms(ctx context.Context, input *GetPluginPlatformsInput) (*PluginPlatformsResult, error)
	CreatePluginPlatform(ctx context.Context, pluginPlatform *models.PluginPlatform) (*models.PluginPlatform, error)
	UpdatePluginPlatform(ctx context.Context, pluginPlatform *models.PluginPlatform) (*models.PluginPlatform, error)
	DeletePluginPlatform(ctx context.Context, pluginPlatform *models.PluginPlatform) error
}

PluginPlatforms is an interface that represents the db plugin_platforms table.

func NewPluginPlatforms 

func NewPluginPlatforms(dbClient *Client) PluginPlatforms

NewPluginPlatforms returns a new instance of PluginPlatforms.

type PluginPlatformsResult 

type PluginPlatformsResult struct {
	PageInfo        *pagination.PageInfo
	PluginPlatforms []models.PluginPlatform
}

PluginPlatformsResult represents the result from the GetPluginPlatforms method.

type PluginSortableField 

type PluginSortableField string

PluginSortableField represents a sortable field for the Plugin entity. 

const (
	PluginSortableFieldNameAsc       PluginSortableField = "NAME_ASC"
	PluginSortableFieldNameDesc      PluginSortableField = "NAME_DESC"
	PluginSortableFieldCreatedAtAsc  PluginSortableField = "CREATED_AT_ASC"
	PluginSortableFieldCreatedAtDesc PluginSortableField = "CREATED_AT_DESC"
	PluginSortableFieldUpdatedAtAsc  PluginSortableField = "UPDATED_AT_ASC"
	PluginSortableFieldUpdatedAtDesc PluginSortableField = "UPDATED_AT_DESC"
)

PluginSortableField constants.

type PluginVersionFilter 

type PluginVersionFilter struct {
	PluginID         *string
	SemanticVersion  *string
	SHASumsUploaded  *bool
	Latest           *bool
	PluginVersionIDs []string
}

PluginVersionFilter is a filter on the PluginVersion object.

type PluginVersionSortableField 

type PluginVersionSortableField string

PluginVersionSortableField is a field on the PluginVersion object that can be sorted. 

const (
	PluginVersionSortableFieldUpdatedAtAsc  PluginVersionSortableField = "UPDATED_AT_ASC"
	PluginVersionSortableFieldUpdatedAtDesc PluginVersionSortableField = "UPDATED_AT_DESC"
	PluginVersionSortableFieldCreatedAtAsc  PluginVersionSortableField = "CREATED_AT_ASC"
	PluginVersionSortableFieldCreatedAtDesc PluginVersionSortableField = "CREATED_AT_DESC"
)

PluginVersionSortableFields constants.

type PluginVersions 

type PluginVersions interface {
	GetPluginVersionByID(ctx context.Context, id string) (*models.PluginVersion, error)
	GetPluginVersionByPRN(ctx context.Context, prn string) (*models.PluginVersion, error)
	GetPluginVersions(ctx context.Context, input *GetPluginVersionsInput) (*PluginVersionsResult, error)
	CreatePluginVersion(ctx context.Context, pluginVersion *models.PluginVersion) (*models.PluginVersion, error)
	UpdatePluginVersion(ctx context.Context, pluginVersion *models.PluginVersion) (*models.PluginVersion, error)
	DeletePluginVersion(ctx context.Context, pluginVersion *models.PluginVersion) error
}

PluginVersions encapsulates the data for a plugin version.

func NewPluginVersions 

func NewPluginVersions(dbClient *Client) PluginVersions

NewPluginVersions returns a new PluginVersions instance.

type PluginVersionsResult 

type PluginVersionsResult struct {
	PageInfo       *pagination.PageInfo
	PluginVersions []models.PluginVersion
}

PluginVersionsResult is the result of the GetPluginVersions method.

type Plugins 

type Plugins interface {
	GetPluginByID(ctx context.Context, id string) (*models.Plugin, error)
	GetPluginByPRN(ctx context.Context, prn string) (*models.Plugin, error)
	GetPlugins(ctx context.Context, input *GetPluginsInput) (*PluginsResult, error)
	CreatePlugin(ctx context.Context, plugin *models.Plugin) (*models.Plugin, error)
	UpdatePlugin(ctx context.Context, plugin *models.Plugin) (*models.Plugin, error)
	DeletePlugin(ctx context.Context, plugin *models.Plugin) error
}

Plugins encapsulates the logic to access the plugins from the database.

func NewPlugins 

func NewPlugins(dbClient *Client) Plugins

NewPlugins returns a new Plugins.

type PluginsResult 

type PluginsResult struct {
	PageInfo *pagination.PageInfo
	Plugins  []models.Plugin
}

PluginsResult is the result of the GetPlugins method.

type ProjectFilter 

type ProjectFilter struct {
	UserMemberID           *string
	ServiceAccountMemberID *string
	OrgID                  *string
	Search                 *string
	ProjectIDs             []string
}

ProjectFilter contains the supported fields for filtering Project resources

type ProjectSortableField 

type ProjectSortableField string

ProjectSortableField represents the fields that a project can be sorted by 

const (
	ProjectSortableFieldUpdatedAtAsc  ProjectSortableField = "UPDATED_AT_ASC"
	ProjectSortableFieldUpdatedAtDesc ProjectSortableField = "UPDATED_AT_DESC"
	ProjectSortableFieldCreatedAtAsc  ProjectSortableField = "CREATED_AT_ASC"
	ProjectSortableFieldCreatedAtDesc ProjectSortableField = "CREATED_AT_DESC"
)

ProjectSortableField constants

type ProjectVariableFilter 

type ProjectVariableFilter struct {
	ProjectVariableSetID      *string
	ProjectID                 *string
	PipelineType              *models.PipelineType
	VariableKey               *string
	CreatedAtTimeRangeEnd     *time.Time
	Search                    *string
	ProjectVariableIDs        []string
	EnvironmentScopes         []string
	ExcludeProjectVariableIDs []string
}

ProjectVariableFilter contains the supported fields for filtering ProjectVariable resources

type ProjectVariableSetFilter 

type ProjectVariableSetFilter struct {
	ProjectID                 *string
	Latest                    *bool
	VariableID                *string
	VariableSetRevisionSearch *string
	VariableSetIDs            []string
}

ProjectVariableSetFilter contains the supported fields for filtering ProjectVariableSet resources

type ProjectVariableSetSortableField 

type ProjectVariableSetSortableField string

ProjectVariableSetSortableField represents the fields that a project can be sorted by 

const (
	ProjectVariableSetSortableFieldCreatedAtAsc  ProjectVariableSetSortableField = "CREATED_AT_ASC"
	ProjectVariableSetSortableFieldCreatedAtDesc ProjectVariableSetSortableField = "CREATED_AT_DESC"
)

ProjectVariableSetSortableField constants

type ProjectVariableSets 

type ProjectVariableSets interface {
	GetProjectVariableSetByID(ctx context.Context, id string) (*models.ProjectVariableSet, error)
	GetProjectVariableSetByPRN(ctx context.Context, prn string) (*models.ProjectVariableSet, error)
	GetProjectVariableSets(ctx context.Context, input *GetProjectVariableSetsInput) (*ProjectVariableSetsResult, error)
	CreateProjectVariableSet(ctx context.Context, variableSet *models.ProjectVariableSet) (*models.ProjectVariableSet, error)
	UpdateProjectVariableSet(ctx context.Context, variableSet *models.ProjectVariableSet) (*models.ProjectVariableSet, error)
	DeleteProjectVariableSet(ctx context.Context, variableSet *models.ProjectVariableSet) error
	AddProjectVariablesToSet(ctx context.Context, variableSet *models.ProjectVariableSet, variables []*models.ProjectVariable) error
}

ProjectVariableSets encapsulates the logic to access ProjectVariableSets from the database

func NewProjectVariableSets 

func NewProjectVariableSets(dbClient *Client) ProjectVariableSets

NewProjectVariableSets returns an instance of the ProjectVariableSets interface

type ProjectVariableSetsResult 

type ProjectVariableSetsResult struct {
	PageInfo            *pagination.PageInfo
	ProjectVariableSets []*models.ProjectVariableSet
}

ProjectVariableSetsResult contains the response data and page information

type ProjectVariableSortableField 

type ProjectVariableSortableField string

ProjectVariableSortableField represents the fields that a project can be sorted by 

const (
	ProjectVariableSortableFieldCreatedAtAsc  ProjectVariableSortableField = "CREATED_AT_ASC"
	ProjectVariableSortableFieldCreatedAtDesc ProjectVariableSortableField = "CREATED_AT_DESC"
	ProjectVariableSortableFieldKeyAsc        ProjectVariableSortableField = "KEY_ASC"
	ProjectVariableSortableFieldKeyDesc       ProjectVariableSortableField = "KEY_DESC"
)

ProjectVariableSortableField constants

type ProjectVariables 

type ProjectVariables interface {
	GetProjectVariableByID(ctx context.Context, id string) (*models.ProjectVariable, error)
	GetProjectVariableByPRN(ctx context.Context, prn string) (*models.ProjectVariable, error)
	GetProjectVariables(ctx context.Context, input *GetProjectVariablesInput) (*ProjectVariablesResult, error)
	CreateProjectVariable(ctx context.Context, variable *models.ProjectVariable) (*models.ProjectVariable, error)
	DeleteProjectVariable(ctx context.Context, variable *models.ProjectVariable) error
}

ProjectVariables encapsulates the logic to access ProjectVariables from the database

func NewProjectVariables 

func NewProjectVariables(dbClient *Client) ProjectVariables

NewProjectVariables returns an instance of the ProjectVariables interface

type ProjectVariablesResult 

type ProjectVariablesResult struct {
	PageInfo         *pagination.PageInfo
	ProjectVariables []*models.ProjectVariable
}

ProjectVariablesResult contains the response data and page information

type Projects 

type Projects interface {
	GetProjectByID(ctx context.Context, id string) (*models.Project, error)
	GetProjectByPRN(ctx context.Context, prn string) (*models.Project, error)
	GetProjects(ctx context.Context, input *GetProjectsInput) (*ProjectsResult, error)
	CreateProject(ctx context.Context, proj *models.Project) (*models.Project, error)
	UpdateProject(ctx context.Context, proj *models.Project) (*models.Project, error)
	DeleteProject(ctx context.Context, proj *models.Project) error
}

Projects encapsulates the logic to access Projects from the database

func NewProjects 

func NewProjects(dbClient *Client) Projects

NewProjects returns an instance of the Projects interface

type ProjectsResult 

type ProjectsResult struct {
	PageInfo *pagination.PageInfo
	Projects []models.Project
}

ProjectsResult contains the response data and page information

type ReleaseFilter 

type ReleaseFilter struct {
	TimeRangeStart         *time.Time
	ProjectID              *string
	UserParticipantID      *string
	UserMemberID           *string
	ServiceAccountMemberID *string
	Latest                 *bool
	ReleaseIDs             []string
}

ReleaseFilter contains the supported fields for filtering Release resources

type ReleaseLifecycleFilter 

type ReleaseLifecycleFilter struct {
	OrganizationID         *string
	ProjectID              *string
	ReleaseLifecycleScopes []models.ScopeType
	Search                 *string
	ReleaseLifecycleIDs    []string
}

ReleaseLifecycleFilter contains the supported fields for filtering ReleaseLifecycle resources

type ReleaseLifecycleSortableField 

type ReleaseLifecycleSortableField string

ReleaseLifecycleSortableField represents the fields that a release lifecycle can be sorted by 

const (
	ReleaseLifecycleSortableFieldUpdatedAtAsc  ReleaseLifecycleSortableField = "UPDATED_AT_ASC"
	ReleaseLifecycleSortableFieldUpdatedAtDesc ReleaseLifecycleSortableField = "UPDATED_AT_DESC"
)

ReleaseLifecycleSortableField constants

type ReleaseLifecycles 

type ReleaseLifecycles interface {
	GetReleaseLifecycleByID(ctx context.Context, id string) (*models.ReleaseLifecycle, error)
	GetReleaseLifecycleByPRN(ctx context.Context, prn string) (*models.ReleaseLifecycle, error)
	GetReleaseLifecycles(ctx context.Context, input *GetReleaseLifecyclesInput) (*ReleaseLifecyclesResult, error)
	CreateReleaseLifecycle(ctx context.Context, releaseLifecycle *models.ReleaseLifecycle) (*models.ReleaseLifecycle, error)
	UpdateReleaseLifecycle(ctx context.Context, releaseLifecycle *models.ReleaseLifecycle) (*models.ReleaseLifecycle, error)
	DeleteReleaseLifecycle(ctx context.Context, releaseLifecycle *models.ReleaseLifecycle) error
}

ReleaseLifecycles encapsulates the logic to access ReleaseLifecycles from the database

func NewReleaseLifecycles 

func NewReleaseLifecycles(dbClient *Client) ReleaseLifecycles

NewReleaseLifecycles returns an instance of the ReleaseLifecycles interface

type ReleaseLifecyclesResult 

type ReleaseLifecyclesResult struct {
	PageInfo          *pagination.PageInfo
	ReleaseLifecycles []*models.ReleaseLifecycle
}

ReleaseLifecyclesResult contains the response data and page information

type ReleaseSortableField 

type ReleaseSortableField string

ReleaseSortableField represents the fields that a release can be sorted by 

const (
	ReleaseSortableFieldUpdatedAtAsc  ReleaseSortableField = "UPDATED_AT_ASC"
	ReleaseSortableFieldUpdatedAtDesc ReleaseSortableField = "UPDATED_AT_DESC"
	ReleaseSortableFieldCreatedAtAsc  ReleaseSortableField = "CREATED_AT_ASC"
	ReleaseSortableFieldCreatedAtDesc ReleaseSortableField = "CREATED_AT_DESC"
)

ReleaseSortableField constants

type ReleaseVariableFilter added in v0.53.0 

type ReleaseVariableFilter struct {
	ReleaseID          *string
	VariableKey        *string
	EnvironmentName    *string
	ReleaseVariableIDs []string
}

ReleaseVariableFilter contains the supported fields for filtering ReleaseVariable resources

type ReleaseVariableSortableField added in v0.53.0 

type ReleaseVariableSortableField string

ReleaseVariableSortableField represents the fields that a release variable can be sorted by 

const (
	ReleaseVariableSortableFieldCreatedAtAsc  ReleaseVariableSortableField = "CREATED_AT_ASC"
	ReleaseVariableSortableFieldCreatedAtDesc ReleaseVariableSortableField = "CREATED_AT_DESC"
	ReleaseVariableSortableFieldKeyAsc        ReleaseVariableSortableField = "KEY_ASC"
	ReleaseVariableSortableFieldKeyDesc       ReleaseVariableSortableField = "KEY_DESC"
)

ReleaseVariableSortableField constants

type ReleaseVariables added in v0.53.0 

type ReleaseVariables interface {
	GetReleaseVariableByID(ctx context.Context, id string) (*models.ReleaseVariable, error)
	GetReleaseVariables(ctx context.Context, input *GetReleaseVariablesInput) (*ReleaseVariablesResult, error)
	CreateReleaseVariables(ctx context.Context, variables []*models.ReleaseVariable) error
	DeleteReleaseVariable(ctx context.Context, variable *models.ReleaseVariable) error
}

ReleaseVariables encapsulates the logic to access ReleaseVariables from the database

func NewReleaseVariables added in v0.53.0 

func NewReleaseVariables(dbClient *Client) ReleaseVariables

NewReleaseVariables returns an instance of the ReleaseVariables interface

type ReleaseVariablesResult added in v0.53.0 

type ReleaseVariablesResult struct {
	PageInfo         *pagination.PageInfo
	ReleaseVariables []*models.ReleaseVariable
}

ReleaseVariablesResult contains the response data and page information

type Releases 

type Releases interface {
	GetReleaseByID(ctx context.Context, id string) (*models.Release, error)
	GetReleaseByPRN(ctx context.Context, prn string) (*models.Release, error)
	GetReleases(ctx context.Context, input *GetReleasesInput) (*ReleasesResult, error)
	CreateRelease(ctx context.Context, release *models.Release) (*models.Release, error)
	UpdateRelease(ctx context.Context, release *models.Release) (*models.Release, error)
	DeleteRelease(ctx context.Context, release *models.Release) error
}

Releases is the interface for interacting with the releases table.

func NewReleases 

func NewReleases(dbClient *Client) Releases

NewReleases returns a new Releases instance.

type ReleasesResult 

type ReleasesResult struct {
	PageInfo *pagination.PageInfo
	Releases []*models.Release
}

ReleasesResult contains the response data and page information

type ResourceLimits 

type ResourceLimits interface {
	GetResourceLimit(ctx context.Context, name string) (*models.ResourceLimit, error)
	GetResourceLimits(ctx context.Context) ([]models.ResourceLimit, error)
	UpdateResourceLimit(ctx context.Context, resourceLimit *models.ResourceLimit) (*models.ResourceLimit, error)
}

ResourceLimits encapsulates the logic to access resource-limits from the database Because resource limits are all created via the schema, there is no need for a create method or a delete method.

func NewResourceLimits 

func NewResourceLimits(dbClient *Client) ResourceLimits

NewResourceLimits returns an instance of the ResourceLimits interface

type RetryOnOLEOption added in v0.42.0 

type RetryOnOLEOption func(*retryOnOLEOptions)

RetryOnOLEOption is used to configure the retry on optimistic lock error behavior

type RoleFilter 

type RoleFilter struct {
	Search  *string
	RoleIDs []string
}

RoleFilter contains the supported fields for filtering Role resources

type RoleSortableField 

type RoleSortableField string

RoleSortableField represents the fields that a role can be sorted by 

const (
	RoleSortableFieldNameAsc       RoleSortableField = "NAME_ASC"
	RoleSortableFieldNameDesc      RoleSortableField = "NAME_DESC"
	RoleSortableFieldUpdatedAtAsc  RoleSortableField = "UPDATED_AT_ASC"
	RoleSortableFieldUpdatedAtDesc RoleSortableField = "UPDATED_AT_DESC"
)

RoleSortableField constants

type Roles 

type Roles interface {
	GetRoleByName(ctx context.Context, name string) (*models.Role, error)
	GetRoleByPRN(ctx context.Context, prn string) (*models.Role, error)
	GetRoleByID(ctx context.Context, id string) (*models.Role, error)
	GetRoles(ctx context.Context, input *GetRolesInput) (*RolesResult, error)
	CreateRole(ctx context.Context, role *models.Role) (*models.Role, error)
	UpdateRole(ctx context.Context, role *models.Role) (*models.Role, error)
	DeleteRole(ctx context.Context, role *models.Role) error
}

Roles encapsulates the logic to access Phobos roles from the database.

func NewRoles 

func NewRoles(dbClient *Client) Roles

NewRoles returns an instance of the Roles interface.

type RolesResult 

type RolesResult struct {
	PageInfo *pagination.PageInfo
	Roles    []models.Role
}

RolesResult contains the response data and page information

type SCIMTokens 

type SCIMTokens interface {
	GetTokenByNonce(ctx context.Context, nonce string) (*models.SCIMToken, error)
	GetTokens(ctx context.Context) ([]models.SCIMToken, error)
	CreateToken(ctx context.Context, token *models.SCIMToken) (*models.SCIMToken, error)
	DeleteToken(ctx context.Context, token *models.SCIMToken) error
}

SCIMTokens encapsulates the logic to access SCIM tokens from the database

func NewSCIMTokens 

func NewSCIMTokens(dbClient *Client) SCIMTokens

NewSCIMTokens returns an instance of the SCIMTokens interface.

type SchemaMigration added in v0.9.0 

type SchemaMigration struct {
	Version int
	Dirty   bool
}

SchemaMigration is a struct that represents a schema migration

type SchemaMigrations added in v0.9.0 

type SchemaMigrations interface {
	GetCurrentMigration(ctx context.Context) (*SchemaMigration, error)
}

SchemaMigrations is an interface for managing schema migrations

func NewSchemaMigrations added in v0.9.0 

func NewSchemaMigrations(dbClient *Client) SchemaMigrations

NewSchemaMigrations creates a new SchemaMigrations struct

type ServiceAccountFilter 

type ServiceAccountFilter struct {
	Search               *string
	AgentID              *string
	OrganizationID       *string
	ProjectID            *string
	ServiceAccountScopes []models.ScopeType
	ServiceAccountIDs    []string
}

ServiceAccountFilter contains the supported fields for filtering ServiceAccount resources

type ServiceAccountSortableField 

type ServiceAccountSortableField string

ServiceAccountSortableField represents the fields that a service account can be sorted by 

const (
	ServiceAccountSortableFieldCreatedAtAsc  ServiceAccountSortableField = "CREATED_AT_ASC"
	ServiceAccountSortableFieldCreatedAtDesc ServiceAccountSortableField = "CREATED_AT_DESC"
	ServiceAccountSortableFieldUpdatedAtAsc  ServiceAccountSortableField = "UPDATED_AT_ASC"
	ServiceAccountSortableFieldUpdatedAtDesc ServiceAccountSortableField = "UPDATED_AT_DESC"
)

ServiceAccountSortableField constants

type ServiceAccounts 

type ServiceAccounts interface {
	GetServiceAccountByID(ctx context.Context, id string) (*models.ServiceAccount, error)
	GetServiceAccountByPRN(ctx context.Context, prn string) (*models.ServiceAccount, error)
	GetServiceAccounts(ctx context.Context, input *GetServiceAccountsInput) (*ServiceAccountsResult, error)
	CreateServiceAccount(ctx context.Context, serviceAccount *models.ServiceAccount) (*models.ServiceAccount, error)
	UpdateServiceAccount(ctx context.Context, serviceAccount *models.ServiceAccount) (*models.ServiceAccount, error)
	DeleteServiceAccount(ctx context.Context, serviceAccount *models.ServiceAccount) error
	AssignServiceAccountToAgent(ctx context.Context, serviceAccountID string, agentID string) error
	UnassignServiceAccountFromAgent(ctx context.Context, serviceAccountID string, agentID string) error
}

ServiceAccounts encapsulates the logic to access service accounts from the database

func NewServiceAccounts 

func NewServiceAccounts(dbClient *Client) ServiceAccounts

NewServiceAccounts returns an instance of the ServiceAccount interface

type ServiceAccountsResult 

type ServiceAccountsResult struct {
	PageInfo        *pagination.PageInfo
	ServiceAccounts []*models.ServiceAccount
}

ServiceAccountsResult contains the response data and page information

type StartDeploymentPayload added in v0.52.0 

type StartDeploymentPayload struct {
	PipelineID string `json:"pipelineId"`
}

StartDeploymentPayload represents the payload for a StartDeployment work item.

type TeamFilter 

type TeamFilter struct {
	Search         *string
	UserID         *string
	TeamIDs        []string
	TeamNames      []string
	SCIMExternalID bool
}

TeamFilter contains the supported fields for filtering Team resources

type TeamMemberFilter 

type TeamMemberFilter struct {
	UserID         *string
	TeamIDs        []string
	MaintainerOnly bool
}

TeamMemberFilter contains the supported fields for filtering TeamMember resources

type TeamMemberSortableField 

type TeamMemberSortableField string

TeamMemberSortableField represents the fields that a team member can be sorted by 

const (
	UsernameAsc  TeamMemberSortableField = "USERNAME_ASC"
	UsernameDesc TeamMemberSortableField = "USERNAME_DESC"
)

TeamMemberSortableField constants

type TeamMembers 

type TeamMembers interface {
	GetTeamMember(ctx context.Context, userID, teamID string) (*models.TeamMember, error)
	GetTeamMembers(ctx context.Context, input *GetTeamMembersInput) (*TeamMembersResult, error)
	AddUserToTeam(ctx context.Context, teamMember *models.TeamMember) (*models.TeamMember, error)
	UpdateTeamMember(ctx context.Context, teamMember *models.TeamMember) (*models.TeamMember, error)
	RemoveUserFromTeam(ctx context.Context, teamMember *models.TeamMember) error
}

TeamMembers encapsulates the logic to access team members from the database

func NewTeamMembers 

func NewTeamMembers(dbClient *Client) TeamMembers

NewTeamMembers returns an instance of the TeamMembers interface

type TeamMembersResult 

type TeamMembersResult struct {
	PageInfo    *pagination.PageInfo
	TeamMembers []models.TeamMember
}

TeamMembersResult contains the response data and page information

type TeamSortableField 

type TeamSortableField string

TeamSortableField represents the fields that a team can be sorted by 

const (
	TeamSortableFieldNameAsc       TeamSortableField = "NAME_ASC"
	TeamSortableFieldNameDesc      TeamSortableField = "NAME_DESC"
	TeamSortableFieldUpdatedAtAsc  TeamSortableField = "UPDATED_AT_ASC"
	TeamSortableFieldUpdatedAtDesc TeamSortableField = "UPDATED_AT_DESC"
)

TeamSortableField constants

type Teams 

type Teams interface {
	GetTeamBySCIMExternalID(ctx context.Context, scimExternalID string) (*models.Team, error)
	GetTeamByID(ctx context.Context, id string) (*models.Team, error)
	GetTeamByPRN(ctx context.Context, prn string) (*models.Team, error)
	GetTeams(ctx context.Context, input *GetTeamsInput) (*TeamsResult, error)
	CreateTeam(ctx context.Context, team *models.Team) (*models.Team, error)
	UpdateTeam(ctx context.Context, team *models.Team) (*models.Team, error)
	DeleteTeam(ctx context.Context, team *models.Team) error
}

Teams encapsulates the logic to access teams from the database

func NewTeams 

func NewTeams(dbClient *Client) Teams

NewTeams returns an instance of the Teams interface

type TeamsResult 

type TeamsResult struct {
	PageInfo *pagination.PageInfo
	Teams    []models.Team
}

TeamsResult contains the response data and page information

type ThreadFilter 

type ThreadFilter struct {
	PipelineID *string
	ReleaseID  *string
	ThreadIDs  []string
}

ThreadFilter contains the supported fields for filtering Thread resources.

type ThreadSortableField 

type ThreadSortableField string

ThreadSortableField represents the fields that a Thread can be sorted by. 

const (
	ThreadSortableFieldCreatedAtAsc  ThreadSortableField = "CREATED_AT_ASC"
	ThreadSortableFieldCreatedAtDesc ThreadSortableField = "CREATED_AT_DESC"
)

ThreadSortableField constants.

type Threads 

type Threads interface {
	GetThreadByID(ctx context.Context, id string) (*models.Thread, error)
	GetThreadByPRN(ctx context.Context, prn string) (*models.Thread, error)
	GetThreads(ctx context.Context, input *GetThreadsInput) (*ThreadsResult, error)
	CreateThread(ctx context.Context, thread *models.Thread) (*models.Thread, error)
	DeleteThread(ctx context.Context, thread *models.Thread) error
}

Threads encapsulates the logic to access Thread resources from the DB.

func NewThreads 

func NewThreads(dbClient *Client) Threads

NewThreads returns an instance of Threads interface.

type ThreadsResult 

type ThreadsResult struct {
	PageInfo *pagination.PageInfo
	Threads  []models.Thread
}

ThreadsResult contains the response data and page information.

type ToDoItemFilter 

type ToDoItemFilter struct {
	UserID                *string
	OrganizationID        *string
	ProjectID             *string
	PipelineTargetID      *string
	Resolved              *bool
	MembershipRequirement *ToDoItemMembershipRequirement
	PayloadFilter         *ToDoItemPayloadFilter
	TargetTypes           []models.ToDoItemTargetType
	ToDoItemIDs           []string
}

ToDoItemFilter represents a filter for a ToDo item.

type ToDoItemMembershipRequirement 

type ToDoItemMembershipRequirement struct {
	UserID *string
}

ToDoItemMembershipRequirement represents the membership requirement for a ToDo item.

type ToDoItemPayloadFilter 

type ToDoItemPayloadFilter struct {
	PipelineTaskPath *string
}

ToDoItemPayloadFilter filters for specific fields on a payload.

type ToDoItemSortableField 

type ToDoItemSortableField string

ToDoItemSortableField represents a sortable field for a ToDo item. 

const (
	ToDoItemSortableFieldCreatedAtAsc  ToDoItemSortableField = "CREATED_AT_ASC"
	ToDoItemSortableFieldCreatedAtDesc ToDoItemSortableField = "CREATED_AT_DESC"
	ToDoItemSortableFieldUpdatedAtAsc  ToDoItemSortableField = "UPDATED_AT_ASC"
	ToDoItemSortableFieldUpdatedAtDesc ToDoItemSortableField = "UPDATED_AT_DESC"
)

ToDoSortableField constants.

type ToDoItems 

type ToDoItems interface {
	GetToDoItemByPRN(ctx context.Context, prn string) (*models.ToDoItem, error)
	GetToDoItems(ctx context.Context, input *GetToDoItemsInput) (*ToDoItemsResult, error)
	CreateToDoItem(ctx context.Context, item *models.ToDoItem) (*models.ToDoItem, error)
	UpdateToDoItem(ctx context.Context, item *models.ToDoItem) (*models.ToDoItem, error)
}

ToDoItems encapsulates the logic to access todo items from the data source.

func NewToDoItems 

func NewToDoItems(dbClient *Client) ToDoItems

NewToDoItems returns a new ToDoItems instance.

type ToDoItemsResult 

type ToDoItemsResult struct {
	PageInfo  *pagination.PageInfo
	ToDoItems []*models.ToDoItem
}

ToDoItemsResult contains the response data and page information

type Transactions 

type Transactions interface {
	BeginTx(ctx context.Context) (context.Context, error)
	CommitTx(ctx context.Context) error
	RollbackTx(ctx context.Context) error
}

Transactions exposes DB transaction support

func NewTransactions 

func NewTransactions(dbClient *Client) Transactions

NewTransactions returns an instance of the Transactions interface

type UserFilter 

type UserFilter struct {
	Search         *string
	UsernamePrefix *string
	UserIDs        []string
	Usernames      []string
	SCIMExternalID bool
	Admin          *bool
	Active         bool
}

UserFilter contains the supported fields for filtering User resources

type UserSessionFilter added in v0.42.0 

type UserSessionFilter struct {
	UserID         *string
	UserSessionIDs []string
	RefreshTokenID *string
	OAuthCode      *string
}

UserSessionFilter contains the supported fields for filtering UserSession resources

type UserSessionSortableField added in v0.42.0 

type UserSessionSortableField string

UserSessionSortableField represents the fields that user sessions can be sorted by 

const (
	UserSessionSortableFieldCreatedAtAsc   UserSessionSortableField = "CREATED_AT_ASC"
	UserSessionSortableFieldCreatedAtDesc  UserSessionSortableField = "CREATED_AT_DESC"
	UserSessionSortableFieldExpirationAsc  UserSessionSortableField = "EXPIRATION_ASC"
	UserSessionSortableFieldExpirationDesc UserSessionSortableField = "EXPIRATION_DESC"
)

UserSessionSortableField constants

type UserSessions added in v0.42.0 

type UserSessions interface {
	GetUserSessionByID(ctx context.Context, id string) (*models.UserSession, error)
	GetUserSessionByPRN(ctx context.Context, prn string) (*models.UserSession, error)
	GetUserSessions(ctx context.Context, input *GetUserSessionsInput) (*UserSessionsResult, error)
	CreateUserSession(ctx context.Context, session *models.UserSession) (*models.UserSession, error)
	UpdateUserSession(ctx context.Context, session *models.UserSession) (*models.UserSession, error)
	DeleteUserSession(ctx context.Context, session *models.UserSession) error
}

UserSessions encapsulates the logic to access user sessions from the database

func NewUserSessions added in v0.42.0 

func NewUserSessions(dbClient *Client) UserSessions

NewUserSessions returns an instance of the UserSessions interface

type UserSessionsResult added in v0.42.0 

type UserSessionsResult struct {
	PageInfo     *pagination.PageInfo
	UserSessions []models.UserSession
}

UserSessionsResult contains the response data and page information

type UserSortableField 

type UserSortableField string

UserSortableField represents the fields that a user can be sorted by 

const (
	UserSortableFieldUpdatedAtAsc  UserSortableField = "UPDATED_AT_ASC"
	UserSortableFieldUpdatedAtDesc UserSortableField = "UPDATED_AT_DESC"
)

UserSortableField constants

type Users 

type Users interface {
	GetUserBySCIMExternalID(ctx context.Context, scimExternalID string) (*models.User, error)
	GetUserByExternalID(ctx context.Context, issuer string, externalID string) (*models.User, error)
	LinkUserWithExternalID(ctx context.Context, issuer string, externalID string, userID string) error
	UnlinkUserExternalID(ctx context.Context, issuer string, externalID string) error
	GetUserByID(ctx context.Context, id string) (*models.User, error)
	GetUserByPRN(ctx context.Context, prn string) (*models.User, error)
	GetUserByEmail(ctx context.Context, email string) (*models.User, error)
	GetUsers(ctx context.Context, input *GetUsersInput) (*UsersResult, error)
	UpdateUser(ctx context.Context, user *models.User) (*models.User, error)
	CreateUser(ctx context.Context, user *models.User) (*models.User, error)
	DeleteUser(ctx context.Context, user *models.User) error
}

Users encapsulates the logic to access users from the database

func NewUsers 

func NewUsers(dbClient *Client) Users

NewUsers returns an instance of the Users interface

type UsersResult 

type UsersResult struct {
	PageInfo *pagination.PageInfo
	Users    []models.User
}

UsersResult contains the response data and page information

type VCSProviderFilter 

type VCSProviderFilter struct {
	Search            *string
	OrganizationID    *string
	ProjectID         *string
	VCSProviderScopes []models.ScopeType
	VCSProviderIDs    []string
}

VCSProviderFilter contains the supported fields for filtering VCSProvider resources.

type VCSProviderSortableField 

type VCSProviderSortableField string

VCSProviderSortableField represents the field that a VCS provider can be sorted by. 

const (
	VCSProviderSortableFieldCreatedAtAsc  VCSProviderSortableField = "CREATED_AT_ASC"
	VCSProviderSortableFieldCreatedAtDesc VCSProviderSortableField = "CREATED_AT_DESC"
	VCSProviderSortableFieldUpdatedAtAsc  VCSProviderSortableField = "UPDATED_AT_ASC"
	VCSProviderSortableFieldUpdatedAtDesc VCSProviderSortableField = "UPDATED_AT_DESC"
)

VCSProviderSortableField constants

type VCSProviders 

type VCSProviders interface {
	GetProviderByID(ctx context.Context, id string) (*models.VCSProvider, error)
	GetProviderByPRN(ctx context.Context, prn string) (*models.VCSProvider, error)
	GetProviderByOAuthState(ctx context.Context, state string) (*models.VCSProvider, error)
	GetProviders(ctx context.Context, input *GetVCSProvidersInput) (*VCSProvidersResult, error)
	CreateProvider(ctx context.Context, provider *models.VCSProvider) (*models.VCSProvider, error)
	UpdateProvider(ctx context.Context, provider *models.VCSProvider) (*models.VCSProvider, error)
	DeleteProvider(ctx context.Context, provider *models.VCSProvider) error
}

VCSProviders encapsulates the logic to access VCS providers from the database.

func NewVCSProviders 

func NewVCSProviders(dbClient *Client) VCSProviders

NewVCSProviders returns an instance of the VCSProviders interface.

type VCSProvidersResult 

type VCSProvidersResult struct {
	PageInfo     *pagination.PageInfo
	VCSProviders []models.VCSProvider
}

VCSProvidersResult contains the response data and page information.

type WorkItem added in v0.52.0 

type WorkItem struct {
	ID                 string
	CreationTimestamp  *time.Time
	AvailableTimestamp *time.Time
	ClaimCount         int
	Type               WorkItemType
	Payload            any
}

WorkItem represents the unit of work inside of the queue.

func (*WorkItem) ToStartDeploymentPayload added in v0.52.0 

func (w *WorkItem) ToStartDeploymentPayload() (*StartDeploymentPayload, bool)

ToStartDeploymentPayload returns the payload as a StartDeploymentPayload struct.

type WorkItemEventData added in v0.52.0 

type WorkItemEventData struct {
	ID                 string          `json:"id"`
	AvailableTimestamp *EventTimestamp `json:"available_at"`
	Type               WorkItemType    `json:"type"`
}

WorkItemEventData contains the event response data for a row from the work_items_queue table.

type WorkItemType added in v0.52.0 

type WorkItemType string

WorkItemType represents the work item type. 

const (
	StartDeploymentWorkItemType WorkItemType = "START_DEPLOYMENT"
)

WorkItemType constants.

type WorkItemsQueue added in v0.52.0 

type WorkItemsQueue interface {
	ClaimWorkItems(ctx context.Context, input *ClaimWorkItemsInput) ([]WorkItem, error)
	AcknowledgeWorkItem(ctx context.Context, workItemID string) error
	AddWorkItemToQueue(ctx context.Context, item *AddWorkItemToQueueInput) (*WorkItem, error)
}

WorkItemsQueue provides an interface to add any unit of work into a queue.

func NewWorkItemQueue added in v0.52.0 

func NewWorkItemQueue(dbClient *Client) WorkItemsQueue

NewWorkItemQueue returns a new WorkItemsQueue instance.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.