patch

type ByPatchNameStatusesMergeQueuePaginatedOptions struct {
	Author         *string
	IncludeHidden  *bool
	Limit          int
	OnlyMergeQueue *bool
	Page           int
	PatchName      string
	Project        *string
	Requesters     []string
	Statuses       []string
}

type CLIIntentParams struct {
	User                               string
	Path                               string
	Project                            string
	BaseGitHash                        string
	Module                             string
	PatchContent                       string
	Description                        string
	Finalize                           bool
	GitInfo                            *GitMetadata
	Parameters                         []Parameter
	Variants                           []string
	Tasks                              []string
	RegexVariants                      []string
	RegexTasks                         []string
	RegexTestSelectionVariants         []string
	RegexTestSelectionExcludedVariants []string
	RegexTestSelectionTasks            []string
	RegexTestSelectionExcludedTasks    []string
	Alias                              string
	TriggerAliases                     []string
	RepeatDefinition                   bool
	RepeatFailed                       bool
	RepeatPatchId                      string
	LocalModuleIncludes                []LocalModuleInclude
}

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"`
	LocalBranch string `bson:"local_branch,omitempty" json:"local_branch,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(ctx context.Context) error

	// SetProcessed should be called by an amboy queue after creating a patch from an intent.
	SetProcessed(ctx context.Context) 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 LocalModuleInclude struct {
	FileName string `yaml:"filename,omitempty" bson:"filename,omitempty" json:"filename,omitempty"`
	Module   string `yaml:"module,omitempty" bson:"module,omitempty" json:"module,omitempty"`

	// FileContent is only used for local module includes for CLI patches
	FileContent []byte `yaml:"file_content,omitempty" bson:"file_content,omitempty" json:"file_content,omitempty"`
}

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

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"`
	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"`
	RegexTestSelectionBuildVariants         []string         `bson:"regex_test_selection_build_variants,omitempty"`
	RegexTestSelectionExcludedBuildVariants []string         `bson:"regex_test_selection_excluded_build_variants,omitempty"`
	Tasks                                   []string         `bson:"tasks"`
	RegexTestSelectionTasks                 []string         `bson:"regex_test_selection_tasks,omitempty"`
	RegexTestSelectionExcludedTasks         []string         `bson:"regex_test_selection_excluded_tasks,omitempty"`
	RegexTasks                              []string         `bson:"regex_tasks"`
	VariantsTasks                           []VariantTasks   `bson:"variants_tasks"`
	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"`
	// IsReconfigured indicates whether this patch was finalized with an initial
	// set of tasks, then later reconfigured to add more tasks to run.
	// This doesn't take into account if existing tasks were
	// scheduled/unscheduled, it's only considered reconfigured if new tasks
	// were created after the patch was finalized.
	IsReconfigured bool `bson:"is_reconfigured,omitempty"`
	// Project contains the project ID for the patch. The bson tag here is `branch` due to legacy usage.
	Project string `bson:"branch"`
	// Branch contains the branch that the project tracks. The tag `branch_name` is
	// used to avoid conflict with legacy usage of the Project field.
	Branch string `bson:"branch_name" json:"branch_name,omitempty"`
	// 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"`
	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"`
	// LocalModuleIncludes is only used for CLI patches to store local module changes.
	LocalModuleIncludes []LocalModuleInclude `bson:"local_module_includes,omitempty"`
	// ReferenceManifestID stores the ID of the manifest that this patch is based on.
	// It is used to determine the module revisions for this patch during creation.
	// This could potentially reference an invalid manifest, and should not error
	// when the manifest is not found.
	// Not stored in the database since it is only needed during patch creation.
	ReferenceManifestID string `bson:"-"`
}

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"`
	// The revision to base the downstream patch off of
	DownstreamRevision string `bson:"downstream_revision,omitempty" json:"downstream_revision,omitempty"`
}

type PatchesByCreateTime []Patch

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"`
	DownstreamRevision   string      `bson:"downstream_revision,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"`
	// The revision to base the downstream patch off of
	DownstreamRevision string `bson:"downstream_revision"`

	Processed bool `bson:"processed"`
}

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

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