patch

type BackportInfo struct {
	PatchID string `bson:"patch_id,omitempty" json:"patch_id,omitempty"`
	SHA     string `bson:"sha,omitempty" json:"sha,omitempty"`
}

type ByPatchNameStatusesCommitQueuePaginatedOptions struct {
	Author             *string
	Project            *string
	PatchName          string
	Statuses           []string
	Page               int
	Limit              int
	IncludeCommitQueue *bool
	IncludeHidden      *bool
	OnlyCommitQueue    *bool
}

type CLIIntentParams struct {
	User             string
	Path             string
	Project          string
	BaseGitHash      string
	Module           string
	PatchContent     string
	Description      string
	Finalize         bool
	BackportOf       BackportInfo
	GitInfo          *GitMetadata
	Parameters       []Parameter
	Variants         []string
	Tasks            []string
	RegexVariants    []string
	RegexTasks       []string
	Alias            string
	TriggerAliases   []string
	RepeatDefinition bool
	RepeatFailed     bool
	RepeatPatchId    string
	SyncParams       SyncAtEndOptions
}

type DisplayTask struct {
	Name      string   `yaml:"name,omitempty" bson:"name,omitempty"`
	ExecTasks []string `yaml:"execution_tasks,omitempty" bson:"execution_tasks,omitempty"`
}

type GitMetadata struct {
	Username   string `bson:"username" json:"username"`
	Email      string `bson:"email" json:"email"`
	GitVersion string `bson:"git_version,omitempty" json:"git_version,omitempty"`
}

type Intent interface {
	// ID returns a unique identifier for the patch. Should
	// correspond to the _id for the patch in database.
	ID() string

	// Insert inserts a patch intent in the database.
	Insert() error

	// SetProcessed should be called by an amboy queue after creating a patch from an intent.
	SetProcessed() error

	// IsProcessed returns whether a patch exists for this intent.
	IsProcessed() bool

	// GetType returns the patch intent, e.g., GithubIntentType.
	GetType() string

	// NewPatch creates a patch from the intent
	NewPatch() *Patch

	// Finalize indicates whether or not the patch created from this
	// intent should be finalized
	ShouldFinalizePatch() bool

	// RepeatPreviousPatchDefinition returns true if we should use the same tasks/variants as a previous patch.
	// Returns patch ID if specified, otherwise we use the latest patch.
	RepeatPreviousPatchDefinition() (string, bool)

	// RepeatFailedTasksAndVariants returns true if we should use the failed tasks/variants from a previous patch.
	// Returns patch ID if specified, otherwise we use the latest patch.
	RepeatFailedTasksAndVariants() (string, bool)

	// GetAlias defines the variants and tasks this intent should run on.
	GetAlias() string

	// RequesterIdentity supplies a valid requester type, that is recorded
	// in patches, versions, builds, and tasks to denote the origin of the
	// patch
	RequesterIdentity() string

	// GetCalledBy indicates whether the intent was created automatically
	// by Evergreen or manually by the user.
	GetCalledBy() string
}

type ModulePatch struct {
	ModuleName string   `bson:"name"`
	Githash    string   `bson:"githash"`
	PatchSet   PatchSet `bson:"patch_set"`
	IsMbox     bool     `bson:"is_mbox"`
}

type Parameter struct {
	Key   string `yaml:"key" bson:"key"`
	Value string `yaml:"value" bson:"value"`
}

type Patch struct {
	Id                 mgobson.ObjectId `bson:"_id,omitempty"`
	Description        string           `bson:"desc"`
	Path               string           `bson:"path,omitempty"`
	Project            string           `bson:"branch"`
	Githash            string           `bson:"githash"`
	Hidden             bool             `bson:"hidden"`
	PatchNumber        int              `bson:"patch_number"`
	Author             string           `bson:"author"`
	Version            string           `bson:"version"`
	Status             string           `bson:"status"`
	CreateTime         time.Time        `bson:"create_time"`
	StartTime          time.Time        `bson:"start_time"`
	FinishTime         time.Time        `bson:"finish_time"`
	BuildVariants      []string         `bson:"build_variants"`
	RegexBuildVariants []string         `bson:"regex_build_variants"`
	Tasks              []string         `bson:"tasks"`
	RegexTasks         []string         `bson:"regex_tasks"`
	VariantsTasks      []VariantTasks   `bson:"variants_tasks"`
	SyncAtEndOpts      SyncAtEndOptions `bson:"sync_at_end_opts,omitempty"`
	Patches            []ModulePatch    `bson:"patches"`
	Parameters         []Parameter      `bson:"parameters,omitempty"`
	// Activated indicates whether or not the patch is finalized (i.e.
	// tasks/variants are now scheduled to run). If true, the patch has been
	// finalized.
	Activated bool `bson:"activated"`
	// ProjectStorageMethod describes how the parser project is stored for this
	// patch before it's finalized. This field is only set while the patch is
	// unfinalized and is cleared once the patch has been finalized.
	ProjectStorageMethod evergreen.ParserProjectStorageMethod `bson:"project_storage_method,omitempty"`
	PatchedProjectConfig string                               `bson:"patched_project_config"`
	Alias                string                               `bson:"alias"`
	Triggers             TriggerInfo                          `bson:"triggers"`
	BackportOf           BackportInfo                         `bson:"backport_of,omitempty"`
	MergePatch           string                               `bson:"merge_patch"`
	GithubPatchData      thirdparty.GithubPatch               `bson:"github_patch_data,omitempty"`
	GithubMergeData      thirdparty.GithubMergeGroup          `bson:"github_merge_data,omitempty"`
	GitInfo              *GitMetadata                         `bson:"git_info,omitempty"`
	// DisplayNewUI is only used when roundtripping the patch via the CLI
	DisplayNewUI bool `bson:"display_new_ui,omitempty"`
	// MergeStatus is only used in gitServePatch to send the status of this
	// patch on the commit queue to the agent
	MergeStatus string `json:"merge_status"`
	// MergedFrom is populated with the patch id of the existing patch
	// the merged patch is based off of, if applicable.
	MergedFrom string `bson:"merged_from,omitempty"`
}

type PatchSet struct {
	Patch          string               `bson:"patch,omitempty"`
	PatchFileId    string               `bson:"patch_file_id,omitempty"`
	CommitMessages []string             `bson:"commit_messages,omitempty"`
	Summary        []thirdparty.Summary `bson:"summary"`
}

type PatchTriggerDefinition struct {
	Alias          string          `bson:"alias" json:"alias"`
	ChildProject   string          `bson:"child_project" json:"child_project"`
	TaskSpecifiers []TaskSpecifier `bson:"task_specifiers" json:"task_specifiers"`
	// the parent status that the child patch should run on: failure, success, or *
	Status         string `bson:"status,omitempty" json:"status,omitempty"`
	ParentAsModule string `bson:"parent_as_module,omitempty" json:"parent_as_module,omitempty"`
}

type PatchesByCreateTime []Patch

type SyncAtEndOptions struct {
	// BuildVariants filters which variants will sync.
	BuildVariants []string `bson:"build_variants,omitempty"`
	// Tasks filters which tasks will sync.
	Tasks []string `bson:"tasks,omitempty"`
	// VariantsTasks are the resolved pairs of build variants and tasks that
	// this patch can actually run task sync for.
	VariantsTasks []VariantTasks `bson:"variants_tasks,omitempty"`
	Statuses      []string       `bson:"statuses,omitempty"`
	Timeout       time.Duration  `bson:"timeout,omitempty"`
}

type TaskSpecifier struct {
	PatchAlias   string `bson:"patch_alias,omitempty" json:"patch_alias,omitempty"`
	TaskRegex    string `bson:"task_regex,omitempty" json:"task_regex,omitempty"`
	VariantRegex string `bson:"variant_regex,omitempty" json:"variant_regex,omitempty"`
}

type TriggerInfo struct {
	Aliases              []string    `bson:"aliases,omitempty"`
	ParentPatch          string      `bson:"parent_patch,omitempty"`
	ParentProjectID      string      `bson:"parent_project_id,omitempty"`
	SameBranchAsParent   bool        `bson:"same_branch_as_parent"`
	ChildPatches         []string    `bson:"child_patches,omitempty"`
	DownstreamParameters []Parameter `bson:"downstream_parameters,omitempty"`
}

type TriggerIntent struct {
	Id              string `bson:"_id"`
	Requester       string `bson:"requester"`
	Author          string `bson:"author"`
	ProjectID       string `bson:"project_id"`
	ParentID        string `bson:"parent_id"`
	ParentProjectID string `bson:"parent_project"`
	ParentAsModule  string `bson:"parent_as_module"`
	// the parent status that the child patch should run on
	ParentStatus string                   `bson:"parent_status"`
	Definitions  []PatchTriggerDefinition `bson:"definitions"`

	Processed bool `bson:"processed"`
}

type TriggerIntentOptions struct {
	Requester       string
	Author          string
	ProjectID       string
	ParentID        string
	ParentProjectID string
	ParentAsModule  string
	ParentStatus    string
	Definitions     []PatchTriggerDefinition
}

type VariantTasks struct {
	Variant      string        `bson:"variant"`
	Tasks        []string      `bson:"tasks"`
	DisplayTasks []DisplayTask `bson:"displaytasks"`
}