2015-10-18 19:30:39 -04:00
|
|
|
// Copyright 2015 The Gogs Authors. All rights reserved.
|
2019-04-19 08:17:27 -04:00
|
|
|
// Copyright 2019 The Gitea Authors. All rights reserved.
|
2015-10-18 19:30:39 -04:00
|
|
|
// Use of this source code is governed by a MIT-style
|
|
|
|
// license that can be found in the LICENSE file.
|
|
|
|
|
|
|
|
package models
|
|
|
|
|
|
|
|
import (
|
|
|
|
"fmt"
|
2019-12-30 18:34:11 -05:00
|
|
|
"io"
|
2015-10-18 19:30:39 -04:00
|
|
|
"strings"
|
|
|
|
|
2019-03-27 05:33:00 -04:00
|
|
|
"code.gitea.io/gitea/modules/git"
|
2016-11-10 11:24:48 -05:00
|
|
|
"code.gitea.io/gitea/modules/log"
|
|
|
|
"code.gitea.io/gitea/modules/setting"
|
2019-08-15 10:46:21 -04:00
|
|
|
"code.gitea.io/gitea/modules/timeutil"
|
2015-10-18 19:30:39 -04:00
|
|
|
)
|
|
|
|
|
2016-11-28 10:31:06 -05:00
|
|
|
// PullRequestType defines pull request type
|
2015-10-18 19:30:39 -04:00
|
|
|
type PullRequestType int
|
|
|
|
|
2016-11-28 10:31:06 -05:00
|
|
|
// Enumerate all the pull request types
|
2015-10-18 19:30:39 -04:00
|
|
|
const (
|
2016-11-07 10:37:32 -05:00
|
|
|
PullRequestGitea PullRequestType = iota
|
|
|
|
PullRequestGit
|
2015-10-18 19:30:39 -04:00
|
|
|
)
|
|
|
|
|
2016-11-28 10:31:06 -05:00
|
|
|
// PullRequestStatus defines pull request status
|
2015-10-18 19:30:39 -04:00
|
|
|
type PullRequestStatus int
|
|
|
|
|
2016-11-28 10:31:06 -05:00
|
|
|
// Enumerate all the pull request status
|
2015-10-18 19:30:39 -04:00
|
|
|
const (
|
2016-11-07 10:37:32 -05:00
|
|
|
PullRequestStatusConflict PullRequestStatus = iota
|
|
|
|
PullRequestStatusChecking
|
|
|
|
PullRequestStatusMergeable
|
2017-02-05 08:07:44 -05:00
|
|
|
PullRequestStatusManuallyMerged
|
2020-01-09 19:14:14 -05:00
|
|
|
PullRequestStatusError
|
2015-10-18 19:30:39 -04:00
|
|
|
)
|
|
|
|
|
|
|
|
// PullRequest represents relation between pull request and repositories.
|
|
|
|
type PullRequest struct {
|
2019-02-05 06:54:49 -05:00
|
|
|
ID int64 `xorm:"pk autoincr"`
|
|
|
|
Type PullRequestType
|
|
|
|
Status PullRequestStatus
|
|
|
|
ConflictedFiles []string `xorm:"TEXT JSON"`
|
2015-10-18 19:30:39 -04:00
|
|
|
|
|
|
|
IssueID int64 `xorm:"INDEX"`
|
|
|
|
Issue *Issue `xorm:"-"`
|
|
|
|
Index int64
|
|
|
|
|
2018-12-11 06:28:37 -05:00
|
|
|
HeadRepoID int64 `xorm:"INDEX"`
|
|
|
|
HeadRepo *Repository `xorm:"-"`
|
|
|
|
BaseRepoID int64 `xorm:"INDEX"`
|
|
|
|
BaseRepo *Repository `xorm:"-"`
|
|
|
|
HeadBranch string
|
|
|
|
BaseBranch string
|
|
|
|
ProtectedBranch *ProtectedBranch `xorm:"-"`
|
|
|
|
MergeBase string `xorm:"VARCHAR(40)"`
|
2015-10-18 19:30:39 -04:00
|
|
|
|
2019-08-15 10:46:21 -04:00
|
|
|
HasMerged bool `xorm:"INDEX"`
|
|
|
|
MergedCommitID string `xorm:"VARCHAR(40)"`
|
|
|
|
MergerID int64 `xorm:"INDEX"`
|
|
|
|
Merger *User `xorm:"-"`
|
|
|
|
MergedUnix timeutil.TimeStamp `xorm:"updated INDEX"`
|
2015-10-18 19:30:39 -04:00
|
|
|
}
|
|
|
|
|
2019-10-18 07:13:31 -04:00
|
|
|
// MustHeadUserName returns the HeadRepo's username if failed return blank
|
|
|
|
func (pr *PullRequest) MustHeadUserName() string {
|
|
|
|
if err := pr.LoadHeadRepo(); err != nil {
|
|
|
|
log.Error("LoadHeadRepo: %v", err)
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
return pr.HeadRepo.MustOwnerName()
|
|
|
|
}
|
|
|
|
|
2016-08-14 06:32:24 -04:00
|
|
|
// Note: don't try to get Issue because will end up recursive querying.
|
|
|
|
func (pr *PullRequest) loadAttributes(e Engine) (err error) {
|
|
|
|
if pr.HasMerged && pr.Merger == nil {
|
|
|
|
pr.Merger, err = getUserByID(e, pr.MergerID)
|
|
|
|
if IsErrUserNotExist(err) {
|
|
|
|
pr.MergerID = -1
|
|
|
|
pr.Merger = NewGhostUser()
|
|
|
|
} else if err != nil {
|
|
|
|
return fmt.Errorf("getUserByID [%d]: %v", pr.MergerID, err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2016-11-28 10:31:06 -05:00
|
|
|
// LoadAttributes loads pull request attributes from database
|
2016-08-14 06:32:24 -04:00
|
|
|
func (pr *PullRequest) LoadAttributes() error {
|
|
|
|
return pr.loadAttributes(x)
|
|
|
|
}
|
|
|
|
|
2019-09-18 01:39:45 -04:00
|
|
|
// LoadBaseRepo loads pull request base repository from database
|
|
|
|
func (pr *PullRequest) LoadBaseRepo() error {
|
|
|
|
if pr.BaseRepo == nil {
|
2019-10-18 07:13:31 -04:00
|
|
|
if pr.HeadRepoID == pr.BaseRepoID && pr.HeadRepo != nil {
|
|
|
|
pr.BaseRepo = pr.HeadRepo
|
|
|
|
return nil
|
|
|
|
}
|
2019-09-18 01:39:45 -04:00
|
|
|
var repo Repository
|
|
|
|
if has, err := x.ID(pr.BaseRepoID).Get(&repo); err != nil {
|
|
|
|
return err
|
|
|
|
} else if !has {
|
|
|
|
return ErrRepoNotExist{ID: pr.BaseRepoID}
|
|
|
|
}
|
|
|
|
pr.BaseRepo = &repo
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-10-18 07:13:31 -04:00
|
|
|
// LoadHeadRepo loads pull request head repository from database
|
|
|
|
func (pr *PullRequest) LoadHeadRepo() error {
|
|
|
|
if pr.HeadRepo == nil {
|
|
|
|
if pr.HeadRepoID == pr.BaseRepoID && pr.BaseRepo != nil {
|
|
|
|
pr.HeadRepo = pr.BaseRepo
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
var repo Repository
|
|
|
|
if has, err := x.ID(pr.HeadRepoID).Get(&repo); err != nil {
|
|
|
|
return err
|
|
|
|
} else if !has {
|
2020-01-07 12:06:14 -05:00
|
|
|
return ErrRepoNotExist{ID: pr.HeadRepoID}
|
2019-10-18 07:13:31 -04:00
|
|
|
}
|
|
|
|
pr.HeadRepo = &repo
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2016-11-28 10:31:06 -05:00
|
|
|
// LoadIssue loads issue information from database
|
2016-08-14 06:32:24 -04:00
|
|
|
func (pr *PullRequest) LoadIssue() (err error) {
|
2017-02-26 19:42:55 -05:00
|
|
|
return pr.loadIssue(x)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (pr *PullRequest) loadIssue(e Engine) (err error) {
|
2016-08-16 13:19:09 -04:00
|
|
|
if pr.Issue != nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-26 19:42:55 -05:00
|
|
|
pr.Issue, err = getIssueByID(e, pr.IssueID)
|
2019-11-21 12:08:42 -05:00
|
|
|
if err == nil {
|
|
|
|
pr.Issue.PullRequest = pr
|
|
|
|
}
|
2016-08-14 06:32:24 -04:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2018-12-11 06:28:37 -05:00
|
|
|
// LoadProtectedBranch loads the protected branch of the base branch
|
|
|
|
func (pr *PullRequest) LoadProtectedBranch() (err error) {
|
2019-12-03 20:08:56 -05:00
|
|
|
return pr.loadProtectedBranch(x)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (pr *PullRequest) loadProtectedBranch(e Engine) (err error) {
|
2018-12-17 12:35:21 -05:00
|
|
|
if pr.BaseRepo == nil {
|
|
|
|
if pr.BaseRepoID == 0 {
|
|
|
|
return nil
|
|
|
|
}
|
2019-12-03 20:08:56 -05:00
|
|
|
pr.BaseRepo, err = getRepositoryByID(e, pr.BaseRepoID)
|
2018-12-17 12:35:21 -05:00
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
2019-12-03 20:08:56 -05:00
|
|
|
pr.ProtectedBranch, err = getProtectedBranchBy(e, pr.BaseRepo.ID, pr.BaseBranch)
|
2018-12-11 06:28:37 -05:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2018-01-05 13:56:50 -05:00
|
|
|
// GetDefaultMergeMessage returns default message used when merging pull request
|
|
|
|
func (pr *PullRequest) GetDefaultMergeMessage() string {
|
|
|
|
if pr.HeadRepo == nil {
|
|
|
|
var err error
|
|
|
|
pr.HeadRepo, err = GetRepositoryByID(pr.HeadRepoID)
|
|
|
|
if err != nil {
|
2019-04-02 03:48:31 -04:00
|
|
|
log.Error("GetRepositoryById[%d]: %v", pr.HeadRepoID, err)
|
2018-01-05 13:56:50 -05:00
|
|
|
return ""
|
|
|
|
}
|
|
|
|
}
|
2020-01-08 06:53:07 -05:00
|
|
|
if err := pr.LoadIssue(); err != nil {
|
|
|
|
log.Error("Cannot load issue %d for PR id %d: Error: %v", pr.IssueID, pr.ID, err)
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
return fmt.Sprintf("Merge pull request '%s' (#%d) from %s/%s into %s", pr.Issue.Title, pr.Issue.Index, pr.MustHeadUserName(), pr.HeadBranch, pr.BaseBranch)
|
2018-01-05 13:56:50 -05:00
|
|
|
}
|
|
|
|
|
2019-12-30 18:34:11 -05:00
|
|
|
// GetCommitMessages returns the commit messages between head and merge base (if there is one)
|
|
|
|
func (pr *PullRequest) GetCommitMessages() string {
|
|
|
|
if err := pr.LoadIssue(); err != nil {
|
|
|
|
log.Error("Cannot load issue %d for PR id %d: Error: %v", pr.IssueID, pr.ID, err)
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
|
|
|
|
if err := pr.Issue.LoadPoster(); err != nil {
|
|
|
|
log.Error("Cannot load poster %d for pr id %d, index %d Error: %v", pr.Issue.PosterID, pr.ID, pr.Index, err)
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
|
|
|
|
if pr.HeadRepo == nil {
|
|
|
|
var err error
|
|
|
|
pr.HeadRepo, err = GetRepositoryByID(pr.HeadRepoID)
|
|
|
|
if err != nil {
|
|
|
|
log.Error("GetRepositoryById[%d]: %v", pr.HeadRepoID, err)
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
gitRepo, err := git.OpenRepository(pr.HeadRepo.RepoPath())
|
|
|
|
if err != nil {
|
|
|
|
log.Error("Unable to open head repository: Error: %v", err)
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
defer gitRepo.Close()
|
|
|
|
|
|
|
|
headCommit, err := gitRepo.GetBranchCommit(pr.HeadBranch)
|
|
|
|
if err != nil {
|
|
|
|
log.Error("Unable to get head commit: %s Error: %v", pr.HeadBranch, err)
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
|
|
|
|
mergeBase, err := gitRepo.GetCommit(pr.MergeBase)
|
|
|
|
if err != nil {
|
|
|
|
log.Error("Unable to get merge base commit: %s Error: %v", pr.MergeBase, err)
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
|
|
|
|
limit := setting.Repository.PullRequest.DefaultMergeMessageCommitsLimit
|
|
|
|
|
|
|
|
list, err := gitRepo.CommitsBetweenLimit(headCommit, mergeBase, limit, 0)
|
|
|
|
if err != nil {
|
|
|
|
log.Error("Unable to get commits between: %s %s Error: %v", pr.HeadBranch, pr.MergeBase, err)
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
|
|
|
|
maxSize := setting.Repository.PullRequest.DefaultMergeMessageSize
|
|
|
|
|
|
|
|
posterSig := pr.Issue.Poster.NewGitSig().String()
|
|
|
|
|
|
|
|
authorsMap := map[string]bool{}
|
|
|
|
authors := make([]string, 0, list.Len())
|
|
|
|
stringBuilder := strings.Builder{}
|
|
|
|
element := list.Front()
|
|
|
|
for element != nil {
|
|
|
|
commit := element.Value.(*git.Commit)
|
|
|
|
|
|
|
|
if maxSize < 0 || stringBuilder.Len() < maxSize {
|
|
|
|
toWrite := []byte(commit.CommitMessage)
|
|
|
|
if len(toWrite) > maxSize-stringBuilder.Len() && maxSize > -1 {
|
|
|
|
toWrite = append(toWrite[:maxSize-stringBuilder.Len()], "..."...)
|
|
|
|
}
|
|
|
|
if _, err := stringBuilder.Write(toWrite); err != nil {
|
|
|
|
log.Error("Unable to write commit message Error: %v", err)
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
|
|
|
|
if _, err := stringBuilder.WriteRune('\n'); err != nil {
|
|
|
|
log.Error("Unable to write commit message Error: %v", err)
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
authorString := commit.Author.String()
|
|
|
|
if !authorsMap[authorString] && authorString != posterSig {
|
|
|
|
authors = append(authors, authorString)
|
|
|
|
authorsMap[authorString] = true
|
|
|
|
}
|
|
|
|
element = element.Next()
|
|
|
|
}
|
|
|
|
|
|
|
|
// Consider collecting the remaining authors
|
|
|
|
if limit >= 0 && setting.Repository.PullRequest.DefaultMergeMessageAllAuthors {
|
|
|
|
skip := limit
|
|
|
|
limit = 30
|
|
|
|
for {
|
|
|
|
list, err := gitRepo.CommitsBetweenLimit(headCommit, mergeBase, limit, skip)
|
|
|
|
if err != nil {
|
|
|
|
log.Error("Unable to get commits between: %s %s Error: %v", pr.HeadBranch, pr.MergeBase, err)
|
|
|
|
return ""
|
|
|
|
|
|
|
|
}
|
|
|
|
if list.Len() == 0 {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
element := list.Front()
|
|
|
|
for element != nil {
|
|
|
|
commit := element.Value.(*git.Commit)
|
|
|
|
|
|
|
|
authorString := commit.Author.String()
|
|
|
|
if !authorsMap[authorString] && authorString != posterSig {
|
|
|
|
authors = append(authors, authorString)
|
|
|
|
authorsMap[authorString] = true
|
|
|
|
}
|
|
|
|
element = element.Next()
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if len(authors) > 0 {
|
|
|
|
if _, err := stringBuilder.WriteRune('\n'); err != nil {
|
|
|
|
log.Error("Unable to write to string builder Error: %v", err)
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, author := range authors {
|
|
|
|
if _, err := stringBuilder.Write([]byte("Co-authored-by: ")); err != nil {
|
|
|
|
log.Error("Unable to write to string builder Error: %v", err)
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
if _, err := stringBuilder.Write([]byte(author)); err != nil {
|
|
|
|
log.Error("Unable to write to string builder Error: %v", err)
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
if _, err := stringBuilder.WriteRune('\n'); err != nil {
|
|
|
|
log.Error("Unable to write to string builder Error: %v", err)
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return stringBuilder.String()
|
|
|
|
}
|
|
|
|
|
|
|
|
// GetApprovers returns the approvers of the pull request
|
|
|
|
func (pr *PullRequest) GetApprovers() string {
|
|
|
|
|
|
|
|
stringBuilder := strings.Builder{}
|
|
|
|
if err := pr.getReviewedByLines(&stringBuilder); err != nil {
|
|
|
|
log.Error("Unable to getReviewedByLines: Error: %v", err)
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
|
|
|
|
return stringBuilder.String()
|
|
|
|
}
|
|
|
|
|
|
|
|
func (pr *PullRequest) getReviewedByLines(writer io.Writer) error {
|
|
|
|
maxReviewers := setting.Repository.PullRequest.DefaultMergeMessageMaxApprovers
|
|
|
|
|
|
|
|
if maxReviewers == 0 {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
sess := x.NewSession()
|
|
|
|
defer sess.Close()
|
|
|
|
if err := sess.Begin(); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
// Note: This doesn't page as we only expect a very limited number of reviews
|
|
|
|
reviews, err := findReviews(sess, FindReviewOptions{
|
|
|
|
Type: 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(sess); err != nil && !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 sess.Commit()
|
|
|
|
}
|
|
|
|
|
2018-01-05 13:56:50 -05:00
|
|
|
// GetDefaultSquashMessage returns default message used when squash and merging pull request
|
|
|
|
func (pr *PullRequest) GetDefaultSquashMessage() string {
|
|
|
|
if err := pr.LoadIssue(); err != nil {
|
2019-04-02 03:48:31 -04:00
|
|
|
log.Error("LoadIssue: %v", err)
|
2018-01-05 13:56:50 -05:00
|
|
|
return ""
|
|
|
|
}
|
|
|
|
return fmt.Sprintf("%s (#%d)", pr.Issue.Title, pr.Issue.Index)
|
|
|
|
}
|
|
|
|
|
2018-01-19 01:18:51 -05:00
|
|
|
// GetGitRefName returns git ref for hidden pull request branch
|
|
|
|
func (pr *PullRequest) GetGitRefName() string {
|
|
|
|
return fmt.Sprintf("refs/pull/%d/head", pr.Index)
|
|
|
|
}
|
|
|
|
|
2015-10-25 18:35:27 -04:00
|
|
|
func (pr *PullRequest) getHeadRepo(e Engine) (err error) {
|
|
|
|
pr.HeadRepo, err = getRepositoryByID(e, pr.HeadRepoID)
|
2015-10-24 03:36:47 -04:00
|
|
|
if err != nil && !IsErrRepoNotExist(err) {
|
2015-10-26 09:16:24 -04:00
|
|
|
return fmt.Errorf("getRepositoryByID(head): %v", err)
|
2015-10-24 03:36:47 -04:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2016-11-28 10:31:06 -05:00
|
|
|
// GetHeadRepo loads the head repository
|
2016-08-14 06:32:24 -04:00
|
|
|
func (pr *PullRequest) GetHeadRepo() error {
|
2015-10-25 18:35:27 -04:00
|
|
|
return pr.getHeadRepo(x)
|
|
|
|
}
|
|
|
|
|
2016-11-28 10:31:06 -05:00
|
|
|
// GetBaseRepo loads the target repository
|
2015-10-24 03:36:47 -04:00
|
|
|
func (pr *PullRequest) GetBaseRepo() (err error) {
|
|
|
|
if pr.BaseRepo != nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
pr.BaseRepo, err = GetRepositoryByID(pr.BaseRepoID)
|
|
|
|
if err != nil {
|
2015-10-26 09:16:24 -04:00
|
|
|
return fmt.Errorf("GetRepositoryByID(base): %v", err)
|
2015-10-24 03:36:47 -04:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// IsChecking returns true if this pull request is still checking conflict.
|
|
|
|
func (pr *PullRequest) IsChecking() bool {
|
2016-11-07 10:37:32 -05:00
|
|
|
return pr.Status == PullRequestStatusChecking
|
2015-10-24 03:36:47 -04:00
|
|
|
}
|
|
|
|
|
2015-10-18 19:30:39 -04:00
|
|
|
// CanAutoMerge returns true if this pull request can be merged automatically.
|
|
|
|
func (pr *PullRequest) CanAutoMerge() bool {
|
2016-11-07 10:37:32 -05:00
|
|
|
return pr.Status == PullRequestStatusMergeable
|
2015-10-18 19:30:39 -04:00
|
|
|
}
|
|
|
|
|
2019-04-02 15:54:29 -04:00
|
|
|
// GetLastCommitStatus returns the last commit status for this pull request.
|
|
|
|
func (pr *PullRequest) GetLastCommitStatus() (status *CommitStatus, err error) {
|
|
|
|
if err = pr.GetHeadRepo(); err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
2019-04-25 23:03:39 -04:00
|
|
|
if pr.HeadRepo == nil {
|
|
|
|
return nil, ErrPullRequestHeadRepoMissing{pr.ID, pr.HeadRepoID}
|
|
|
|
}
|
|
|
|
|
2019-04-02 15:54:29 -04:00
|
|
|
headGitRepo, err := git.OpenRepository(pr.HeadRepo.RepoPath())
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
2019-11-13 02:01:19 -05:00
|
|
|
defer headGitRepo.Close()
|
2019-04-02 15:54:29 -04:00
|
|
|
|
|
|
|
lastCommitID, err := headGitRepo.GetBranchCommitID(pr.HeadBranch)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
2019-09-29 21:07:43 -04:00
|
|
|
err = pr.LoadBaseRepo()
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
statusList, err := GetLatestCommitStatus(pr.BaseRepo, lastCommitID, 0)
|
2019-04-02 15:54:29 -04:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
return CalcCommitStatus(statusList), nil
|
|
|
|
}
|
|
|
|
|
2018-01-05 13:56:50 -05:00
|
|
|
// MergeStyle represents the approach to merge commits into base branch.
|
|
|
|
type MergeStyle string
|
|
|
|
|
|
|
|
const (
|
|
|
|
// MergeStyleMerge create merge commit
|
|
|
|
MergeStyleMerge MergeStyle = "merge"
|
|
|
|
// MergeStyleRebase rebase before merging
|
|
|
|
MergeStyleRebase MergeStyle = "rebase"
|
2018-12-27 05:27:08 -05:00
|
|
|
// MergeStyleRebaseMerge rebase before merging with merge commit (--no-ff)
|
|
|
|
MergeStyleRebaseMerge MergeStyle = "rebase-merge"
|
2018-01-05 13:56:50 -05:00
|
|
|
// MergeStyleSquash squash commits into single commit before merging
|
|
|
|
MergeStyleSquash MergeStyle = "squash"
|
|
|
|
)
|
|
|
|
|
2018-03-12 23:46:14 -04:00
|
|
|
// CheckUserAllowedToMerge checks whether the user is allowed to merge
|
|
|
|
func (pr *PullRequest) CheckUserAllowedToMerge(doer *User) (err error) {
|
|
|
|
if doer == nil {
|
|
|
|
return ErrNotAllowedToMerge{
|
|
|
|
"Not signed in",
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if pr.BaseRepo == nil {
|
|
|
|
if err = pr.GetBaseRepo(); err != nil {
|
|
|
|
return fmt.Errorf("GetBaseRepo: %v", err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-12-11 06:28:37 -05:00
|
|
|
if protected, err := pr.BaseRepo.IsProtectedBranchForMerging(pr, pr.BaseBranch, doer); err != nil {
|
2018-03-12 23:46:14 -04:00
|
|
|
return fmt.Errorf("IsProtectedBranch: %v", err)
|
|
|
|
} else if protected {
|
|
|
|
return ErrNotAllowedToMerge{
|
|
|
|
"The branch is protected",
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-06-22 13:35:34 -04:00
|
|
|
// SetMerged sets a pull request to merged and closes the corresponding issue
|
|
|
|
func (pr *PullRequest) SetMerged() (err error) {
|
2017-02-05 08:07:44 -05:00
|
|
|
if pr.HasMerged {
|
|
|
|
return fmt.Errorf("PullRequest[%d] already merged", pr.Index)
|
|
|
|
}
|
2017-12-10 23:37:04 -05:00
|
|
|
if pr.MergedCommitID == "" || pr.MergedUnix == 0 || pr.Merger == nil {
|
2017-02-05 08:07:44 -05:00
|
|
|
return fmt.Errorf("Unable to merge PullRequest[%d], some required fields are empty", pr.Index)
|
|
|
|
}
|
|
|
|
|
|
|
|
pr.HasMerged = true
|
|
|
|
|
|
|
|
sess := x.NewSession()
|
2017-06-20 20:57:05 -04:00
|
|
|
defer sess.Close()
|
2017-02-05 08:07:44 -05:00
|
|
|
if err = sess.Begin(); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2017-02-26 19:42:55 -05:00
|
|
|
if err = pr.loadIssue(sess); err != nil {
|
2017-02-05 08:07:44 -05:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2017-02-26 19:42:55 -05:00
|
|
|
if err = pr.Issue.loadRepo(sess); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
if err = pr.Issue.Repo.getOwner(sess); err != nil {
|
|
|
|
return err
|
2017-02-05 08:07:44 -05:00
|
|
|
}
|
|
|
|
|
2019-12-15 16:57:34 -05:00
|
|
|
if _, err = pr.Issue.changeStatus(sess, pr.Merger, true); err != nil {
|
2017-02-05 08:07:44 -05:00
|
|
|
return fmt.Errorf("Issue.changeStatus: %v", err)
|
|
|
|
}
|
2017-10-05 17:25:40 -04:00
|
|
|
if _, err = sess.ID(pr.ID).Cols("has_merged, status, merged_commit_id, merger_id, merged_unix").Update(pr); err != nil {
|
2017-02-05 08:07:44 -05:00
|
|
|
return fmt.Errorf("update pull request: %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
if err = sess.Commit(); err != nil {
|
|
|
|
return fmt.Errorf("Commit: %v", err)
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2015-10-18 19:30:39 -04:00
|
|
|
// NewPullRequest creates new pull request with labels for repository.
|
2019-12-13 17:21:06 -05:00
|
|
|
func NewPullRequest(repo *Repository, pull *Issue, labelIDs []int64, uuids []string, pr *PullRequest) (err error) {
|
2019-10-02 18:28:30 -04:00
|
|
|
// Retry several times in case INSERT fails due to duplicate key for (repo_id, index); see #7887
|
|
|
|
i := 0
|
|
|
|
for {
|
2019-12-13 17:21:06 -05:00
|
|
|
if err = newPullRequestAttempt(repo, pull, labelIDs, uuids, pr); err == nil {
|
2019-10-02 18:28:30 -04:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
if !IsErrNewIssueInsert(err) {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
if i++; i == issueMaxDupIndexAttempts {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
log.Error("NewPullRequest: error attempting to insert the new issue; will retry. Original error: %v", err)
|
|
|
|
}
|
|
|
|
return fmt.Errorf("NewPullRequest: too many errors attempting to insert the new issue. Last error was: %v", err)
|
|
|
|
}
|
|
|
|
|
2019-12-13 17:21:06 -05:00
|
|
|
func newPullRequestAttempt(repo *Repository, pull *Issue, labelIDs []int64, uuids []string, pr *PullRequest) (err error) {
|
2015-10-18 19:30:39 -04:00
|
|
|
sess := x.NewSession()
|
2017-06-20 20:57:05 -04:00
|
|
|
defer sess.Close()
|
2015-10-18 19:30:39 -04:00
|
|
|
if err = sess.Begin(); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2017-01-31 21:36:08 -05:00
|
|
|
if err = newIssue(sess, pull.Poster, NewIssueOptions{
|
2016-08-15 21:40:32 -04:00
|
|
|
Repo: repo,
|
|
|
|
Issue: pull,
|
2017-02-28 20:08:45 -05:00
|
|
|
LabelIDs: labelIDs,
|
2016-08-15 21:40:32 -04:00
|
|
|
Attachments: uuids,
|
|
|
|
IsPull: true,
|
|
|
|
}); err != nil {
|
2019-10-02 18:28:30 -04:00
|
|
|
if IsErrUserDoesNotHaveAccessToRepo(err) || IsErrNewIssueInsert(err) {
|
2018-05-09 12:29:04 -04:00
|
|
|
return err
|
|
|
|
}
|
2015-10-18 19:30:39 -04:00
|
|
|
return fmt.Errorf("newIssue: %v", err)
|
|
|
|
}
|
|
|
|
|
2015-10-24 14:48:11 -04:00
|
|
|
pr.Index = pull.Index
|
2015-10-24 03:36:47 -04:00
|
|
|
pr.BaseRepo = repo
|
2015-10-18 19:30:39 -04:00
|
|
|
|
|
|
|
pr.IssueID = pull.ID
|
|
|
|
if _, err = sess.Insert(pr); err != nil {
|
|
|
|
return fmt.Errorf("insert pull repo: %v", err)
|
|
|
|
}
|
|
|
|
|
2016-07-15 12:36:39 -04:00
|
|
|
if err = sess.Commit(); err != nil {
|
|
|
|
return fmt.Errorf("Commit: %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
2015-10-18 19:30:39 -04:00
|
|
|
}
|
|
|
|
|
2017-01-04 19:50:34 -05:00
|
|
|
// GetUnmergedPullRequest returns a pull request that is open and has not been merged
|
2015-10-18 19:30:39 -04:00
|
|
|
// by given head/base and repo/branch.
|
|
|
|
func GetUnmergedPullRequest(headRepoID, baseRepoID int64, headBranch, baseBranch string) (*PullRequest, error) {
|
|
|
|
pr := new(PullRequest)
|
2016-11-10 10:16:32 -05:00
|
|
|
has, err := x.
|
|
|
|
Where("head_repo_id=? AND head_branch=? AND base_repo_id=? AND base_branch=? AND has_merged=? AND issue.is_closed=?",
|
|
|
|
headRepoID, headBranch, baseRepoID, baseBranch, false, false).
|
|
|
|
Join("INNER", "issue", "issue.id=pull_request.issue_id").
|
|
|
|
Get(pr)
|
2015-10-18 19:30:39 -04:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
} else if !has {
|
|
|
|
return nil, ErrPullRequestNotExist{0, 0, headRepoID, baseRepoID, headBranch, baseBranch}
|
|
|
|
}
|
|
|
|
|
|
|
|
return pr, nil
|
|
|
|
}
|
|
|
|
|
2019-06-27 10:15:30 -04:00
|
|
|
// GetLatestPullRequestByHeadInfo returns the latest pull request (regardless of its status)
|
|
|
|
// by given head information (repo and branch).
|
|
|
|
func GetLatestPullRequestByHeadInfo(repoID int64, branch string) (*PullRequest, error) {
|
|
|
|
pr := new(PullRequest)
|
|
|
|
has, err := x.
|
|
|
|
Where("head_repo_id = ? AND head_branch = ?", repoID, branch).
|
|
|
|
OrderBy("id DESC").
|
|
|
|
Get(pr)
|
|
|
|
if !has {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
return pr, err
|
|
|
|
}
|
|
|
|
|
2016-12-02 06:10:39 -05:00
|
|
|
// GetPullRequestByIndex returns a pull request by the given index
|
|
|
|
func GetPullRequestByIndex(repoID int64, index int64) (*PullRequest, error) {
|
|
|
|
pr := &PullRequest{
|
|
|
|
BaseRepoID: repoID,
|
|
|
|
Index: index,
|
|
|
|
}
|
|
|
|
|
|
|
|
has, err := x.Get(pr)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
} else if !has {
|
2017-01-01 13:15:09 -05:00
|
|
|
return nil, ErrPullRequestNotExist{0, 0, 0, repoID, "", ""}
|
2016-12-02 06:10:39 -05:00
|
|
|
}
|
|
|
|
|
2016-12-05 06:17:39 -05:00
|
|
|
if err = pr.LoadAttributes(); err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
if err = pr.LoadIssue(); err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
2016-12-02 06:10:39 -05:00
|
|
|
|
|
|
|
return pr, nil
|
|
|
|
}
|
|
|
|
|
2016-08-14 06:32:24 -04:00
|
|
|
func getPullRequestByID(e Engine, id int64) (*PullRequest, error) {
|
2015-10-24 03:36:47 -04:00
|
|
|
pr := new(PullRequest)
|
2017-10-05 00:43:04 -04:00
|
|
|
has, err := e.ID(id).Get(pr)
|
2015-10-24 03:36:47 -04:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
} else if !has {
|
|
|
|
return nil, ErrPullRequestNotExist{id, 0, 0, 0, "", ""}
|
|
|
|
}
|
2016-08-14 06:32:24 -04:00
|
|
|
return pr, pr.loadAttributes(e)
|
2015-10-24 03:36:47 -04:00
|
|
|
}
|
|
|
|
|
2016-08-14 06:32:24 -04:00
|
|
|
// GetPullRequestByID returns a pull request by given ID.
|
|
|
|
func GetPullRequestByID(id int64) (*PullRequest, error) {
|
|
|
|
return getPullRequestByID(x, id)
|
|
|
|
}
|
|
|
|
|
|
|
|
func getPullRequestByIssueID(e Engine, issueID int64) (*PullRequest, error) {
|
2015-10-22 14:47:24 -04:00
|
|
|
pr := &PullRequest{
|
|
|
|
IssueID: issueID,
|
|
|
|
}
|
2016-08-14 06:32:24 -04:00
|
|
|
has, err := e.Get(pr)
|
2015-10-18 19:30:39 -04:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
} else if !has {
|
2015-10-22 14:47:24 -04:00
|
|
|
return nil, ErrPullRequestNotExist{0, issueID, 0, 0, "", ""}
|
2015-10-18 19:30:39 -04:00
|
|
|
}
|
2016-08-14 06:32:24 -04:00
|
|
|
return pr, pr.loadAttributes(e)
|
|
|
|
}
|
|
|
|
|
|
|
|
// GetPullRequestByIssueID returns pull request by given issue ID.
|
|
|
|
func GetPullRequestByIssueID(issueID int64) (*PullRequest, error) {
|
|
|
|
return getPullRequestByIssueID(x, issueID)
|
2015-10-18 19:30:39 -04:00
|
|
|
}
|
2015-10-24 03:36:47 -04:00
|
|
|
|
|
|
|
// Update updates all fields of pull request.
|
|
|
|
func (pr *PullRequest) Update() error {
|
2017-10-05 00:43:04 -04:00
|
|
|
_, err := x.ID(pr.ID).AllCols().Update(pr)
|
2015-10-24 03:36:47 -04:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2016-11-28 10:31:06 -05:00
|
|
|
// UpdateCols updates specific fields of pull request.
|
2015-10-24 03:36:47 -04:00
|
|
|
func (pr *PullRequest) UpdateCols(cols ...string) error {
|
2017-10-05 00:43:04 -04:00
|
|
|
_, err := x.ID(pr.ID).Cols(cols...).Update(pr)
|
2015-10-24 03:36:47 -04:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2018-08-13 15:04:39 -04:00
|
|
|
// IsWorkInProgress determine if the Pull Request is a Work In Progress by its title
|
|
|
|
func (pr *PullRequest) IsWorkInProgress() bool {
|
|
|
|
if err := pr.LoadIssue(); err != nil {
|
2019-04-02 03:48:31 -04:00
|
|
|
log.Error("LoadIssue: %v", err)
|
2018-08-13 15:04:39 -04:00
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, prefix := range setting.Repository.PullRequest.WorkInProgressPrefixes {
|
|
|
|
if strings.HasPrefix(strings.ToUpper(pr.Issue.Title), prefix) {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2019-02-05 06:54:49 -05:00
|
|
|
// IsFilesConflicted determines if the Pull Request has changes conflicting with the target branch.
|
|
|
|
func (pr *PullRequest) IsFilesConflicted() bool {
|
|
|
|
return len(pr.ConflictedFiles) > 0
|
|
|
|
}
|
|
|
|
|
2018-08-13 15:04:39 -04:00
|
|
|
// GetWorkInProgressPrefix returns the prefix used to mark the pull request as a work in progress.
|
|
|
|
// It returns an empty string when none were found
|
|
|
|
func (pr *PullRequest) GetWorkInProgressPrefix() string {
|
|
|
|
if err := pr.LoadIssue(); err != nil {
|
2019-04-02 03:48:31 -04:00
|
|
|
log.Error("LoadIssue: %v", err)
|
2018-08-13 15:04:39 -04:00
|
|
|
return ""
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, prefix := range setting.Repository.PullRequest.WorkInProgressPrefixes {
|
|
|
|
if strings.HasPrefix(strings.ToUpper(pr.Issue.Title), prefix) {
|
|
|
|
return pr.Issue.Title[0:len(prefix)]
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return ""
|
|
|
|
}
|
2019-12-16 01:20:25 -05:00
|
|
|
|
|
|
|
// IsHeadEqualWithBranch returns if the commits of branchName are available in pull request head
|
|
|
|
func (pr *PullRequest) IsHeadEqualWithBranch(branchName string) (bool, error) {
|
|
|
|
var err error
|
|
|
|
if err = pr.GetBaseRepo(); err != nil {
|
|
|
|
return false, err
|
|
|
|
}
|
|
|
|
baseGitRepo, err := git.OpenRepository(pr.BaseRepo.RepoPath())
|
|
|
|
if err != nil {
|
|
|
|
return false, err
|
|
|
|
}
|
|
|
|
baseCommit, err := baseGitRepo.GetBranchCommit(branchName)
|
|
|
|
if err != nil {
|
|
|
|
return false, err
|
|
|
|
}
|
|
|
|
|
|
|
|
if err = pr.GetHeadRepo(); err != nil {
|
|
|
|
return false, err
|
|
|
|
}
|
|
|
|
headGitRepo, err := git.OpenRepository(pr.HeadRepo.RepoPath())
|
|
|
|
if err != nil {
|
|
|
|
return false, err
|
|
|
|
}
|
|
|
|
headCommit, err := headGitRepo.GetBranchCommit(pr.HeadBranch)
|
|
|
|
if err != nil {
|
|
|
|
return false, err
|
|
|
|
}
|
|
|
|
return baseCommit.HasPreviousCommit(headCommit.ID)
|
|
|
|
}
|