// Copyright 2015 The Gogs Authors. All rights reserved.// Copyright 2019 The Gitea Authors. All rights reserved.// SPDX-License-Identifier: MIT package issues import (	"context"	"fmt"	"io"	"regexp"	"strconv"	"strings" 	"forgejo.org/models/db"	git_model "forgejo.org/models/git"	org_model "forgejo.org/models/organization"	pull_model "forgejo.org/models/pull"	repo_model "forgejo.org/models/repo"	user_model "forgejo.org/models/user"	"forgejo.org/modules/git"	"forgejo.org/modules/log"	"forgejo.org/modules/setting"	"forgejo.org/modules/timeutil"	"forgejo.org/modules/util" 	"xorm.io/builder") // ErrPullRequestNotExist represents a "PullRequestNotExist" kind of error.type ErrPullRequestNotExist struct {	ID         int64	IssueID    int64	HeadRepoID int64	BaseRepoID int64	HeadBranch string	BaseBranch string} // IsErrPullRequestNotExist checks if an error is a ErrPullRequestNotExist.func IsErrPullRequestNotExist(err error) bool {	_, ok := err.(ErrPullRequestNotExist)	return ok} func (err ErrPullRequestNotExist) Error() string {	return fmt.Sprintf("pull request does not exist [id: %d, issue_id: %d, head_repo_id: %d, base_repo_id: %d, head_branch: %s, base_branch: %s]",		err.ID, err.IssueID, err.HeadRepoID, err.BaseRepoID, err.HeadBranch, err.BaseBranch)} func (err ErrPullRequestNotExist) Unwrap() error {	return util.ErrNotExist} // ErrPullRequestAlreadyExists represents a "PullRequestAlreadyExists"-errortype ErrPullRequestAlreadyExists struct {	ID         int64	IssueID    int64	HeadRepoID int64	BaseRepoID int64	HeadBranch string	BaseBranch string} // IsErrPullRequestAlreadyExists checks if an error is a ErrPullRequestAlreadyExists.func IsErrPullRequestAlreadyExists(err error) bool {	_, ok := err.(ErrPullRequestAlreadyExists)	return ok} // Error does pretty-printing :Dfunc (err ErrPullRequestAlreadyExists) Error() string {	return fmt.Sprintf("pull request already exists for these targets [id: %d, issue_id: %d, head_repo_id: %d, base_repo_id: %d, head_branch: %s, base_branch: %s]",		err.ID, err.IssueID, err.HeadRepoID, err.BaseRepoID, err.HeadBranch, err.BaseBranch)} func (err ErrPullRequestAlreadyExists) Unwrap() error {	return util.ErrAlreadyExist} // ErrPullWasClosed is used close a closed pull requesttype ErrPullWasClosed struct {	ID    int64	Index int64} // IsErrPullWasClosed checks if an error is a ErrErrPullWasClosed.func IsErrPullWasClosed(err error) bool {	_, ok := err.(ErrPullWasClosed)	return ok} func (err ErrPullWasClosed) Error() string {	return fmt.Sprintf("Pull request [%d] %d was already closed", err.ID, err.Index)} // PullRequestType defines pull request typetype PullRequestType int // Enumerate all the pull request typesconst (	PullRequestGitea PullRequestType = iota	PullRequestGit) // PullRequestStatus defines pull request statustype PullRequestStatus int // Enumerate all the pull request statusconst (	PullRequestStatusConflict PullRequestStatus = iota	PullRequestStatusChecking	PullRequestStatusMergeable	PullRequestStatusManuallyMerged	PullRequestStatusError	PullRequestStatusEmpty	PullRequestStatusAncestor) func (status PullRequestStatus) String() string {	switch status {	case PullRequestStatusConflict:		return "CONFLICT"	case PullRequestStatusChecking:		return "CHECKING"	case PullRequestStatusMergeable:		return "MERGEABLE"	case PullRequestStatusManuallyMerged:		return "MANUALLY_MERGED"	case PullRequestStatusError:		return "ERROR"	case PullRequestStatusEmpty:		return "EMPTY"	case PullRequestStatusAncestor:		return "ANCESTOR"	default:		return strconv.Itoa(int(status))	}} // PullRequestFlow the flow of pull requesttype PullRequestFlow int const (	// PullRequestFlowGithub github flow from head branch to base branch	PullRequestFlowGithub PullRequestFlow = iota	// PullRequestFlowAGit Agit flow pull request, head branch is not exist	PullRequestFlowAGit) // PullRequest represents relation between pull request and repositories.type PullRequest struct {	ID              int64 `xorm:"pk autoincr"`	Type            PullRequestType	Status          PullRequestStatus	ConflictedFiles []string `xorm:"TEXT JSON"`	CommitsAhead    int	CommitsBehind   int 	ChangedProtectedFiles []string `xorm:"TEXT JSON"` 	IssueID                    int64  `xorm:"INDEX"`	Issue                      *Issue `xorm:"-"`	Index                      int64	RequestedReviewers         []*user_model.User `xorm:"-"`	RequestedReviewersTeams    []*org_model.Team  `xorm:"-"`	isRequestedReviewersLoaded bool               `xorm:"-"` 	HeadRepoID          int64                  `xorm:"INDEX"`	HeadRepo            *repo_model.Repository `xorm:"-"`	BaseRepoID          int64                  `xorm:"INDEX"`	BaseRepo            *repo_model.Repository `xorm:"-"`	HeadBranch          string	HeadCommitID        string `xorm:"-"`	BaseBranch          string	MergeBase           string `xorm:"VARCHAR(64)"`	AllowMaintainerEdit bool   `xorm:"NOT NULL DEFAULT false"` 	HasMerged      bool               `xorm:"INDEX"`	MergedCommitID string             `xorm:"VARCHAR(64)"`	MergerID       int64              `xorm:"INDEX"`	Merger         *user_model.User   `xorm:"-"`	MergedUnix     timeutil.TimeStamp `xorm:"updated INDEX"` 	isHeadRepoLoaded bool `xorm:"-"` 	Flow PullRequestFlow `xorm:"NOT NULL DEFAULT 0"`} func init() {	db.RegisterModel(new(PullRequest))} // DeletePullsByBaseRepoID deletes all pull requests by the base repository IDfunc DeletePullsByBaseRepoID(ctx context.Context, repoID int64) error {	deleteCond := builder.Select("id").From("pull_request").Where(builder.Eq{"pull_request.base_repo_id": repoID}) 	// Delete scheduled auto merges	if _, err := db.GetEngine(ctx).In("pull_id", deleteCond).		Delete(&pull_model.AutoMerge{}); err != nil {		return err	} 	// Delete review states	if _, err := db.GetEngine(ctx).In("pull_id", deleteCond).		Delete(&pull_model.ReviewState{}); err != nil {		return err	} 	_, err := db.DeleteByBean(ctx, &PullRequest{BaseRepoID: repoID})	return err} func (pr *PullRequest) String() string {	if pr == nil {		return "<PullRequest nil>"	} 	s := new(strings.Builder)	fmt.Fprintf(s, "<PullRequest [%d]", pr.ID)	if pr.BaseRepo != nil {		fmt.Fprintf(s, "%s#%d[%s...", pr.BaseRepo.FullName(), pr.Index, pr.BaseBranch)	} else {		fmt.Fprintf(s, "Repo[%d]#%d[%s...", pr.BaseRepoID, pr.Index, pr.BaseBranch)	}	if pr.HeadRepoID == pr.BaseRepoID {		fmt.Fprintf(s, "%s]", pr.HeadBranch)	} else if pr.HeadRepo != nil {		fmt.Fprintf(s, "%s:%s]", pr.HeadRepo.FullName(), pr.HeadBranch)	} else {		fmt.Fprintf(s, "Repo[%d]:%s]", pr.HeadRepoID, pr.HeadBranch)	}	s.WriteByte('>')	return s.String()} // MustHeadUserName returns the HeadRepo's username if failed return blankfunc (pr *PullRequest) MustHeadUserName(ctx context.Context) string {	if err := pr.LoadHeadRepo(ctx); err != nil {		if !repo_model.IsErrRepoNotExist(err) {			log.Error("LoadHeadRepo: %v", err)		} else {			log.Warn("LoadHeadRepo %d but repository does not exist: %v", pr.HeadRepoID, err)		}		return ""	}	if pr.HeadRepo == nil {		return ""	}	return pr.HeadRepo.OwnerName} // LoadAttributes loads pull request attributes from database// Note: don't try to get Issue because will end up recursive querying.func (pr *PullRequest) LoadAttributes(ctx context.Context) (err error) {	if pr.HasMerged && pr.Merger == nil {		pr.Merger, err = user_model.GetUserByID(ctx, pr.MergerID)		if user_model.IsErrUserNotExist(err) {			pr.MergerID = user_model.GhostUserID			pr.Merger = user_model.NewGhostUser()		} else if err != nil {			return fmt.Errorf("getUserByID [%d]: %w", pr.MergerID, err)		}	} 	return nil} // LoadHeadRepo loads the head repository, pr.HeadRepo will remain nil if it does not exist// and thus ErrRepoNotExist will never be returnedfunc (pr *PullRequest) LoadHeadRepo(ctx context.Context) (err error) {	if !pr.isHeadRepoLoaded && pr.HeadRepo == nil && pr.HeadRepoID > 0 {		if pr.HeadRepoID == pr.BaseRepoID {			if pr.BaseRepo != nil {				pr.HeadRepo = pr.BaseRepo				return nil			} else if pr.Issue != nil && pr.Issue.Repo != nil {				pr.HeadRepo = pr.Issue.Repo				return nil			}		} 		pr.HeadRepo, err = repo_model.GetRepositoryByID(ctx, pr.HeadRepoID)		if err != nil && !repo_model.IsErrRepoNotExist(err) { // Head repo maybe deleted, but it should still work			return fmt.Errorf("pr[%d].LoadHeadRepo[%d]: %w", pr.ID, pr.HeadRepoID, err)		}		pr.isHeadRepoLoaded = true	}	return nil} // LoadRequestedReviewers loads the requested reviewers.func (pr *PullRequest) LoadRequestedReviewers(ctx context.Context) error {	if pr.isRequestedReviewersLoaded || len(pr.RequestedReviewers) > 0 {		return nil	} 	reviews, err := GetReviewsByIssueID(ctx, pr.Issue.ID)	if err != nil {		return err	}	if err = reviews.LoadReviewers(ctx); err != nil {		return err	}	pr.isRequestedReviewersLoaded = true	for _, review := range reviews {		if review.ReviewerID != 0 {			pr.RequestedReviewers = append(pr.RequestedReviewers, review.Reviewer)		}	} 	return nil} // LoadRequestedReviewersTeams loads the requested reviewers teams.func (pr *PullRequest) LoadRequestedReviewersTeams(ctx context.Context) error {	reviews, err := GetReviewsByIssueID(ctx, pr.Issue.ID)	if err != nil {		return err	}	if err = reviews.LoadReviewersTeams(ctx); err != nil {		return err	} 	for _, review := range reviews {		if review.ReviewerTeamID != 0 {			pr.RequestedReviewersTeams = append(pr.RequestedReviewersTeams, review.ReviewerTeam)		}	} 	return nil} // LoadBaseRepo loads the target repository. ErrRepoNotExist may be returned.func (pr *PullRequest) LoadBaseRepo(ctx context.Context) (err error) {	if pr.BaseRepo != nil {		return nil	} 	if pr.HeadRepoID == pr.BaseRepoID && pr.HeadRepo != nil {		pr.BaseRepo = pr.HeadRepo		return nil	} 	if pr.Issue != nil && pr.Issue.Repo != nil {		pr.BaseRepo = pr.Issue.Repo		return nil	} 	pr.BaseRepo, err = repo_model.GetRepositoryByID(ctx, pr.BaseRepoID)	if err != nil {		return fmt.Errorf("pr[%d].LoadBaseRepo[%d]: %w", pr.ID, pr.BaseRepoID, err)	}	return nil} // LoadIssue loads issue information from databasefunc (pr *PullRequest) LoadIssue(ctx context.Context) (err error) {	if pr.Issue != nil {		return nil	} 	pr.Issue, err = GetIssueByID(ctx, pr.IssueID)	if err == nil {		pr.Issue.PullRequest = pr	}	return err} // ReviewCount represents a count of Reviewstype ReviewCount struct {	IssueID int64	Type    ReviewType	Count   int64} // GetApprovalCounts returns the approval counts by type// FIXME: Only returns official counts due to double counting of non-official countsfunc (pr *PullRequest) GetApprovalCounts(ctx context.Context) ([]*ReviewCount, error) {	rCounts := make([]*ReviewCount, 0, 6)	sess := db.GetEngine(ctx).Where("issue_id = ?", pr.IssueID)	return rCounts, sess.Select("issue_id, type, count(id) as `count`").Where("official = ? AND dismissed = ?", true, false).GroupBy("issue_id, type").Table("review").Find(&rCounts)} // GetApprovers returns the approvers of the pull requestfunc (pr *PullRequest) GetApprovers(ctx context.Context) string {	stringBuilder := strings.Builder{}	if err := pr.getReviewedByLines(ctx, &stringBuilder); err != nil {		log.Error("Unable to getReviewedByLines: Error: %v", err)		return ""	} 	return stringBuilder.String()} func (pr *PullRequest) getReviewedByLines(ctx context.Context, writer io.Writer) error {	maxReviewers := setting.Repository.PullRequest.DefaultMergeMessageMaxApprovers 	if maxReviewers == 0 {		return nil	} 	ctx, committer, err := db.TxContext(ctx)	if err != nil {		return err	}	defer committer.Close() 	// Note: This doesn't page as we only expect a very limited number of reviews	reviews, err := FindLatestReviews(ctx, FindReviewOptions{		Types:        []ReviewType{ReviewTypeApprove},		IssueID:      pr.IssueID,		OfficialOnly: setting.Repository.PullRequest.DefaultMergeMessageOfficialApproversOnly,	})	if err != nil {		log.Error("Unable to FindReviews for PR ID %d: %v", pr.ID, err)		return err	} 	reviewersWritten := 0 	for _, review := range reviews {		if maxReviewers > 0 && reviewersWritten > maxReviewers {			break		} 		if err := review.LoadReviewer(ctx); err != nil && !user_model.IsErrUserNotExist(err) {			log.Error("Unable to LoadReviewer[%d] for PR ID %d : %v", review.ReviewerID, pr.ID, err)			return err		} else if review.Reviewer == nil {			continue		}		if _, err := writer.Write([]byte("Reviewed-by: ")); err != nil {			return err		}		if _, err := writer.Write([]byte(review.Reviewer.NewGitSig().String())); err != nil {			return err		}		if _, err := writer.Write([]byte{'\n'}); err != nil {			return err		}		reviewersWritten++	}	return committer.Commit()} // GetGitRefName returns git ref for hidden pull request branchfunc (pr *PullRequest) GetGitRefName() string {	return fmt.Sprintf("%s%d/head", git.PullPrefix, pr.Index)} func (pr *PullRequest) GetGitHeadBranchRefName() string {	return fmt.Sprintf("%s%s", git.BranchPrefix, pr.HeadBranch)} // GetReviewCommentsCount returns the number of review comments made on the diff of a PR review (not including comments on commits or issues in a PR)func (pr *PullRequest) GetReviewCommentsCount(ctx context.Context) int {	opts := FindCommentsOptions{		Type:    CommentTypeReview,		IssueID: pr.IssueID,	}	conds := opts.ToConds() 	count, err := db.GetEngine(ctx).Where(conds).Count(new(Comment))	if err != nil {		return 0	}	return int(count)} // IsChecking returns true if this pull request is still checking conflict.func (pr *PullRequest) IsChecking() bool {	return pr.Status == PullRequestStatusChecking} // CanAutoMerge returns true if this pull request can be merged automatically.func (pr *PullRequest) CanAutoMerge() bool {	return pr.Status == PullRequestStatusMergeable} // IsEmpty returns true if this pull request is empty.func (pr *PullRequest) IsEmpty() bool {	return pr.Status == PullRequestStatusEmpty} // IsAncestor returns true if the Head Commit of this PR is an ancestor of the Base Commitfunc (pr *PullRequest) IsAncestor() bool {	return pr.Status == PullRequestStatusAncestor} // IsFromFork return true if this PR is from a fork.func (pr *PullRequest) IsFromFork() bool {	return pr.HeadRepoID != pr.BaseRepoID} // SetMerged sets a pull request to merged and closes the corresponding issuefunc (pr *PullRequest) SetMerged(ctx context.Context) (bool, error) {	if pr.HasMerged {		return false, fmt.Errorf("PullRequest[%d] already merged", pr.Index)	}

Lines 1–500 of 1106. Load more