2015-10-18 23:30:39 +00:00
// Copyright 2015 The Gogs Authors. All rights reserved.
2019-04-19 12:17:27 +00:00
// Copyright 2019 The Gitea Authors. All rights reserved.
2015-10-18 23:30:39 +00:00
// Use of this source code is governed by a MIT-style
// license that can be found in the LICENSE file.
2022-06-13 09:37:59 +00:00
package issues
2015-10-18 23:30:39 +00:00
import (
2021-12-10 01:27:50 +00:00
"context"
2015-10-18 23:30:39 +00:00
"fmt"
2019-12-30 23:34:11 +00:00
"io"
2023-02-13 03:17:36 +00:00
"strconv"
2015-10-18 23:30:39 +00:00
"strings"
2021-09-19 11:49:59 +00:00
"code.gitea.io/gitea/models/db"
2022-06-12 15:51:54 +00:00
git_model "code.gitea.io/gitea/models/git"
2022-05-08 13:46:34 +00:00
pull_model "code.gitea.io/gitea/models/pull"
2021-12-10 01:27:50 +00:00
repo_model "code.gitea.io/gitea/models/repo"
2021-11-24 09:49:20 +00:00
user_model "code.gitea.io/gitea/models/user"
2021-12-02 07:28:08 +00:00
"code.gitea.io/gitea/modules/git"
2016-11-10 16:24:48 +00:00
"code.gitea.io/gitea/modules/log"
"code.gitea.io/gitea/modules/setting"
2019-08-15 14:46:21 +00:00
"code.gitea.io/gitea/modules/timeutil"
2021-02-18 02:45:49 +00:00
"code.gitea.io/gitea/modules/util"
2022-05-07 17:05:52 +00:00
"xorm.io/builder"
2015-10-18 23:30:39 +00:00
)
2022-06-13 09:37:59 +00:00
// 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 )
}
2022-10-18 05:50:37 +00:00
func ( err ErrPullRequestNotExist ) Unwrap ( ) error {
return util . ErrNotExist
}
2022-06-13 09:37:59 +00:00
// ErrPullRequestAlreadyExists represents a "PullRequestAlreadyExists"-error
type 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 :D
func ( 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 )
}
2022-10-18 05:50:37 +00:00
func ( err ErrPullRequestAlreadyExists ) Unwrap ( ) error {
return util . ErrAlreadyExist
}
2022-06-13 09:37:59 +00:00
// ErrPullRequestHeadRepoMissing represents a "ErrPullRequestHeadRepoMissing" error
type ErrPullRequestHeadRepoMissing struct {
ID int64
HeadRepoID int64
}
// IsErrErrPullRequestHeadRepoMissing checks if an error is a ErrPullRequestHeadRepoMissing.
func IsErrErrPullRequestHeadRepoMissing ( err error ) bool {
_ , ok := err . ( ErrPullRequestHeadRepoMissing )
return ok
}
// Error does pretty-printing :D
func ( err ErrPullRequestHeadRepoMissing ) Error ( ) string {
return fmt . Sprintf ( "pull request head repo missing [id: %d, head_repo_id: %d]" ,
err . ID , err . HeadRepoID )
}
// ErrPullWasClosed is used close a closed pull request
type 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 )
}
2016-11-28 15:31:06 +00:00
// PullRequestType defines pull request type
2015-10-18 23:30:39 +00:00
type PullRequestType int
2016-11-28 15:31:06 +00:00
// Enumerate all the pull request types
2015-10-18 23:30:39 +00:00
const (
2016-11-07 15:37:32 +00:00
PullRequestGitea PullRequestType = iota
PullRequestGit
2015-10-18 23:30:39 +00:00
)
2016-11-28 15:31:06 +00:00
// PullRequestStatus defines pull request status
2015-10-18 23:30:39 +00:00
type PullRequestStatus int
2016-11-28 15:31:06 +00:00
// Enumerate all the pull request status
2015-10-18 23:30:39 +00:00
const (
2016-11-07 15:37:32 +00:00
PullRequestStatusConflict PullRequestStatus = iota
PullRequestStatusChecking
PullRequestStatusMergeable
2017-02-05 13:07:44 +00:00
PullRequestStatusManuallyMerged
2020-01-10 00:14:14 +00:00
PullRequestStatusError
2021-03-04 03:41:23 +00:00
PullRequestStatusEmpty
2022-07-13 08:22:51 +00:00
PullRequestStatusAncestor
2015-10-18 23:30:39 +00:00
)
2023-02-13 03:17:36 +00:00
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 ) )
}
}
2021-07-28 09:42:56 +00:00
// PullRequestFlow the flow of pull request
type 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
)
2015-10-18 23:30:39 +00:00
// PullRequest represents relation between pull request and repositories.
type PullRequest struct {
2019-02-05 11:54:49 +00:00
ID int64 ` xorm:"pk autoincr" `
Type PullRequestType
Status PullRequestStatus
ConflictedFiles [ ] string ` xorm:"TEXT JSON" `
2020-04-14 13:53:34 +00:00
CommitsAhead int
CommitsBehind int
2015-10-18 23:30:39 +00:00
2020-10-13 18:50:57 +00:00
ChangedProtectedFiles [ ] string ` xorm:"TEXT JSON" `
2015-10-18 23:30:39 +00:00
IssueID int64 ` xorm:"INDEX" `
Issue * Issue ` xorm:"-" `
Index int64
2022-04-28 15:45:33 +00:00
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
2022-06-12 15:51:54 +00:00
ProtectedBranch * git_model . ProtectedBranch ` xorm:"-" `
MergeBase string ` xorm:"VARCHAR(40)" `
AllowMaintainerEdit bool ` xorm:"NOT NULL DEFAULT false" `
2015-10-18 23:30:39 +00:00
2019-08-15 14:46:21 +00:00
HasMerged bool ` xorm:"INDEX" `
MergedCommitID string ` xorm:"VARCHAR(40)" `
MergerID int64 ` xorm:"INDEX" `
2021-11-24 09:49:20 +00:00
Merger * user_model . User ` xorm:"-" `
2019-08-15 14:46:21 +00:00
MergedUnix timeutil . TimeStamp ` xorm:"updated INDEX" `
2020-03-02 22:31:55 +00:00
isHeadRepoLoaded bool ` xorm:"-" `
2021-07-28 09:42:56 +00:00
Flow PullRequestFlow ` xorm:"NOT NULL DEFAULT 0" `
2015-10-18 23:30:39 +00:00
}
2021-09-19 11:49:59 +00:00
func init ( ) {
db . RegisterModel ( new ( PullRequest ) )
}
2022-06-13 09:37:59 +00:00
// DeletePullsByBaseRepoID deletes all pull requests by the base repository ID
func DeletePullsByBaseRepoID ( ctx context . Context , repoID int64 ) error {
2022-05-08 13:46:34 +00:00
deleteCond := builder . Select ( "id" ) . From ( "pull_request" ) . Where ( builder . Eq { "pull_request.base_repo_id" : repoID } )
// Delete scheduled auto merges
2022-05-20 14:08:52 +00:00
if _ , err := db . GetEngine ( ctx ) . In ( "pull_id" , deleteCond ) .
2022-05-08 13:46:34 +00:00
Delete ( & pull_model . AutoMerge { } ) ; err != nil {
return err
}
// Delete review states
2022-05-20 14:08:52 +00:00
if _ , err := db . GetEngine ( ctx ) . In ( "pull_id" , deleteCond ) .
2022-05-08 13:46:34 +00:00
Delete ( & pull_model . ReviewState { } ) ; err != nil {
return err
}
2022-05-20 14:08:52 +00:00
_ , err := db . DeleteByBean ( ctx , & PullRequest { BaseRepoID : repoID } )
2022-05-08 13:46:34 +00:00
return err
}
2023-02-13 03:17:36 +00:00
// ColorFormat writes a colored string to identify this struct
func ( pr * PullRequest ) ColorFormat ( s fmt . State ) {
if pr == nil {
log . ColorFprintf ( s , "PR[%d]%s#%d[%s...%s:%s]" ,
log . NewColoredIDValue ( 0 ) ,
log . NewColoredValue ( "<nil>/<nil>" ) ,
log . NewColoredIDValue ( 0 ) ,
log . NewColoredValue ( "<nil>" ) ,
log . NewColoredValue ( "<nil>/<nil>" ) ,
log . NewColoredValue ( "<nil>" ) ,
)
return
}
log . ColorFprintf ( s , "PR[%d]" , log . NewColoredIDValue ( pr . ID ) )
if pr . BaseRepo != nil {
log . ColorFprintf ( s , "%s#%d[%s..." , log . NewColoredValue ( pr . BaseRepo . FullName ( ) ) ,
log . NewColoredIDValue ( pr . Index ) , log . NewColoredValue ( pr . BaseBranch ) )
} else {
log . ColorFprintf ( s , "Repo[%d]#%d[%s..." , log . NewColoredIDValue ( pr . BaseRepoID ) ,
log . NewColoredIDValue ( pr . Index ) , log . NewColoredValue ( pr . BaseBranch ) )
}
if pr . HeadRepoID == pr . BaseRepoID {
log . ColorFprintf ( s , "%s]" , log . NewColoredValue ( pr . HeadBranch ) )
} else if pr . HeadRepo != nil {
log . ColorFprintf ( s , "%s:%s]" , log . NewColoredValue ( pr . HeadRepo . FullName ( ) ) , log . NewColoredValue ( pr . HeadBranch ) )
} else {
log . ColorFprintf ( s , "Repo[%d]:%s]" , log . NewColoredIDValue ( pr . HeadRepoID ) , log . NewColoredValue ( pr . HeadBranch ) )
}
}
// String represents the pr as a simple string
func ( pr * PullRequest ) String ( ) string {
return log . ColorFormatAsString ( pr )
}
2019-10-18 11:13:31 +00:00
// MustHeadUserName returns the HeadRepo's username if failed return blank
func ( pr * PullRequest ) MustHeadUserName ( ) string {
if err := pr . LoadHeadRepo ( ) ; err != nil {
2021-12-10 01:27:50 +00:00
if ! repo_model . IsErrRepoNotExist ( err ) {
2020-01-25 02:48:22 +00:00
log . Error ( "LoadHeadRepo: %v" , err )
} else {
log . Warn ( "LoadHeadRepo %d but repository does not exist: %v" , pr . HeadRepoID , err )
}
2019-10-18 11:13:31 +00:00
return ""
}
2020-03-02 22:31:55 +00:00
if pr . HeadRepo == nil {
return ""
}
2020-01-12 09:36:21 +00:00
return pr . HeadRepo . OwnerName
2019-10-18 11:13:31 +00:00
}
2016-08-14 10:32:24 +00:00
// Note: don't try to get Issue because will end up recursive querying.
2022-05-20 14:08:52 +00:00
func ( pr * PullRequest ) loadAttributes ( ctx context . Context ) ( err error ) {
2016-08-14 10:32:24 +00:00
if pr . HasMerged && pr . Merger == nil {
2022-05-20 14:08:52 +00:00
pr . Merger , err = user_model . GetUserByIDCtx ( ctx , pr . MergerID )
2021-11-24 09:49:20 +00:00
if user_model . IsErrUserNotExist ( err ) {
2016-08-14 10:32:24 +00:00
pr . MergerID = - 1
2021-11-24 09:49:20 +00:00
pr . Merger = user_model . NewGhostUser ( )
2016-08-14 10:32:24 +00:00
} else if err != nil {
2022-10-24 19:29:17 +00:00
return fmt . Errorf ( "getUserByID [%d]: %w" , pr . MergerID , err )
2016-08-14 10:32:24 +00:00
}
}
return nil
}
2016-11-28 15:31:06 +00:00
// LoadAttributes loads pull request attributes from database
2016-08-14 10:32:24 +00:00
func ( pr * PullRequest ) LoadAttributes ( ) error {
2022-05-20 14:08:52 +00:00
return pr . loadAttributes ( db . DefaultContext )
2016-08-14 10:32:24 +00:00
}
2022-04-28 11:48:48 +00:00
// LoadHeadRepoCtx loads the head repository
func ( pr * PullRequest ) LoadHeadRepoCtx ( ctx context . Context ) ( err error ) {
2020-03-02 22:31:55 +00:00
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
}
2019-10-18 11:13:31 +00:00
}
2020-03-02 22:31:55 +00:00
2021-12-10 01:27:50 +00:00
pr . HeadRepo , err = repo_model . GetRepositoryByIDCtx ( ctx , pr . HeadRepoID )
if err != nil && ! repo_model . IsErrRepoNotExist ( err ) { // Head repo maybe deleted, but it should still work
2023-02-13 03:17:36 +00:00
return fmt . Errorf ( "pr[%d].LoadHeadRepo[%d]: %w" , pr . ID , pr . HeadRepoID , err )
2019-09-18 05:39:45 +00:00
}
2020-03-02 22:31:55 +00:00
pr . isHeadRepoLoaded = true
2019-09-18 05:39:45 +00:00
}
return nil
}
2020-03-02 22:31:55 +00:00
// LoadHeadRepo loads the head repository
2019-10-18 11:13:31 +00:00
func ( pr * PullRequest ) LoadHeadRepo ( ) error {
2022-04-28 11:48:48 +00:00
return pr . LoadHeadRepoCtx ( db . DefaultContext )
2020-03-02 22:31:55 +00:00
}
// LoadBaseRepo loads the target repository
func ( pr * PullRequest ) LoadBaseRepo ( ) error {
2022-04-28 11:48:48 +00:00
return pr . LoadBaseRepoCtx ( db . DefaultContext )
2020-03-02 22:31:55 +00:00
}
2022-04-28 11:48:48 +00:00
// LoadBaseRepoCtx loads the target repository
func ( pr * PullRequest ) LoadBaseRepoCtx ( ctx context . Context ) ( err error ) {
2020-03-02 22:31:55 +00:00
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
}
2021-12-10 01:27:50 +00:00
pr . BaseRepo , err = repo_model . GetRepositoryByIDCtx ( ctx , pr . BaseRepoID )
2020-03-02 22:31:55 +00:00
if err != nil {
2023-02-13 03:17:36 +00:00
return fmt . Errorf ( "pr[%d].LoadBaseRepo[%d]: %w" , pr . ID , pr . BaseRepoID , err )
2019-10-18 11:13:31 +00:00
}
return nil
}
2016-11-28 15:31:06 +00:00
// LoadIssue loads issue information from database
2016-08-14 10:32:24 +00:00
func ( pr * PullRequest ) LoadIssue ( ) ( err error ) {
2022-04-28 11:48:48 +00:00
return pr . LoadIssueCtx ( db . DefaultContext )
2017-02-27 00:42:55 +00:00
}
2022-04-28 11:48:48 +00:00
// LoadIssueCtx loads issue information from database
func ( pr * PullRequest ) LoadIssueCtx ( ctx context . Context ) ( err error ) {
2016-08-16 17:19:09 +00:00
if pr . Issue != nil {
return nil
}
2022-06-13 09:37:59 +00:00
pr . Issue , err = GetIssueByID ( ctx , pr . IssueID )
2019-11-21 17:08:42 +00:00
if err == nil {
pr . Issue . PullRequest = pr
}
2016-08-14 10:32:24 +00:00
return err
}
2018-12-11 11:28:37 +00:00
// LoadProtectedBranch loads the protected branch of the base branch
func ( pr * PullRequest ) LoadProtectedBranch ( ) ( err error ) {
2022-04-28 11:48:48 +00:00
return pr . LoadProtectedBranchCtx ( db . DefaultContext )
2019-12-04 01:08:56 +00:00
}
2022-04-28 11:48:48 +00:00
// LoadProtectedBranchCtx loads the protected branch of the base branch
func ( pr * PullRequest ) LoadProtectedBranchCtx ( ctx context . Context ) ( err error ) {
2020-01-15 08:32:57 +00:00
if pr . ProtectedBranch == nil {
if pr . BaseRepo == nil {
if pr . BaseRepoID == 0 {
return nil
}
2021-12-10 01:27:50 +00:00
pr . BaseRepo , err = repo_model . GetRepositoryByIDCtx ( ctx , pr . BaseRepoID )
2020-01-15 08:32:57 +00:00
if err != nil {
return
}
2018-12-17 17:35:21 +00:00
}
2022-06-12 15:51:54 +00:00
pr . ProtectedBranch , err = git_model . GetProtectedBranchBy ( ctx , pr . BaseRepo . ID , pr . BaseBranch )
2018-12-17 17:35:21 +00:00
}
2022-06-20 10:02:49 +00:00
return err
2018-12-11 11:28:37 +00:00
}
2020-03-06 03:44:06 +00:00
// ReviewCount represents a count of Reviews
type 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 counts
2022-05-20 14:08:52 +00:00
func ( pr * PullRequest ) GetApprovalCounts ( ctx context . Context ) ( [ ] * ReviewCount , error ) {
2020-03-06 03:44:06 +00:00
rCounts := make ( [ ] * ReviewCount , 0 , 6 )
2022-05-20 14:08:52 +00:00
sess := db . GetEngine ( ctx ) . Where ( "issue_id = ?" , pr . IssueID )
2021-02-11 17:32:25 +00:00
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 )
2020-03-06 03:44:06 +00:00
}
2019-12-30 23:34:11 +00:00
// 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
}
2021-11-21 15:41:00 +00:00
ctx , committer , err := db . TxContext ( )
if err != nil {
2019-12-30 23:34:11 +00:00
return err
}
2021-11-21 15:41:00 +00:00
defer committer . Close ( )
2019-12-30 23:34:11 +00:00
// Note: This doesn't page as we only expect a very limited number of reviews
2022-05-20 14:08:52 +00:00
reviews , err := FindReviews ( ctx , FindReviewOptions {
2019-12-30 23:34:11 +00:00
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
}
2022-05-20 14:08:52 +00:00
if err := review . loadReviewer ( ctx ) ; err != nil && ! user_model . IsErrUserNotExist ( err ) {
2019-12-30 23:34:11 +00:00
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 ++
}
2021-11-21 15:41:00 +00:00
return committer . Commit ( )
2019-12-30 23:34:11 +00:00
}
2018-01-19 06:18:51 +00:00
// GetGitRefName returns git ref for hidden pull request branch
func ( pr * PullRequest ) GetGitRefName ( ) string {
2021-12-02 19:36:50 +00:00
return fmt . Sprintf ( "%s%d/head" , git . PullPrefix , pr . Index )
2018-01-19 06:18:51 +00:00
}
2015-10-24 07:36:47 +00:00
// IsChecking returns true if this pull request is still checking conflict.
func ( pr * PullRequest ) IsChecking ( ) bool {
2016-11-07 15:37:32 +00:00
return pr . Status == PullRequestStatusChecking
2015-10-24 07:36:47 +00:00
}
2015-10-18 23:30:39 +00:00
// CanAutoMerge returns true if this pull request can be merged automatically.
func ( pr * PullRequest ) CanAutoMerge ( ) bool {
2016-11-07 15:37:32 +00:00
return pr . Status == PullRequestStatusMergeable
2015-10-18 23:30:39 +00:00
}
2021-03-04 03:41:23 +00:00
// IsEmpty returns true if this pull request is empty.
func ( pr * PullRequest ) IsEmpty ( ) bool {
return pr . Status == PullRequestStatusEmpty
}
2022-07-13 08:22:51 +00:00
// IsAncestor returns true if the Head Commit of this PR is an ancestor of the Base Commit
func ( pr * PullRequest ) IsAncestor ( ) bool {
return pr . Status == PullRequestStatusAncestor
}
2019-06-22 17:35:34 +00:00
// SetMerged sets a pull request to merged and closes the corresponding issue
2022-05-03 19:46:28 +00:00
func ( pr * PullRequest ) SetMerged ( ctx context . Context ) ( bool , error ) {
2017-02-05 13:07:44 +00:00
if pr . HasMerged {
2020-02-09 23:09:31 +00:00
return false , fmt . Errorf ( "PullRequest[%d] already merged" , pr . Index )
2017-02-05 13:07:44 +00:00
}
2017-12-11 04:37:04 +00:00
if pr . MergedCommitID == "" || pr . MergedUnix == 0 || pr . Merger == nil {
2020-02-09 23:09:31 +00:00
return false , fmt . Errorf ( "Unable to merge PullRequest[%d], some required fields are empty" , pr . Index )
2017-02-05 13:07:44 +00:00
}
pr . HasMerged = true
2021-11-19 13:39:57 +00:00
sess := db . GetEngine ( ctx )
2017-02-05 13:07:44 +00:00
2020-02-09 23:09:31 +00:00
if _ , err := sess . Exec ( "UPDATE `issue` SET `repo_id` = `repo_id` WHERE `id` = ?" , pr . IssueID ) ; err != nil {
return false , err
2017-02-05 13:07:44 +00:00
}
2020-02-09 23:09:31 +00:00
if _ , err := sess . Exec ( "UPDATE `pull_request` SET `issue_id` = `issue_id` WHERE `id` = ?" , pr . ID ) ; err != nil {
return false , err
2017-02-27 00:42:55 +00:00
}
2020-02-09 23:09:31 +00:00
pr . Issue = nil
2022-04-28 11:48:48 +00:00
if err := pr . LoadIssueCtx ( ctx ) ; err != nil {
2020-02-09 23:09:31 +00:00
return false , err
2017-02-05 13:07:44 +00:00
}
2022-05-20 14:08:52 +00:00
if tmpPr , err := GetPullRequestByID ( ctx , pr . ID ) ; err != nil {
2020-02-09 23:09:31 +00:00
return false , err
} else if tmpPr . HasMerged {
if pr . Issue . IsClosed {
return false , nil
}
return false , fmt . Errorf ( "PullRequest[%d] already merged but it's associated issue [%d] is not closed" , pr . Index , pr . IssueID )
} else if pr . Issue . IsClosed {
return false , fmt . Errorf ( "PullRequest[%d] already closed" , pr . Index )
2017-02-05 13:07:44 +00:00
}
2020-02-09 23:09:31 +00:00
2022-04-08 09:11:15 +00:00
if err := pr . Issue . LoadRepo ( ctx ) ; err != nil {
2020-02-09 23:09:31 +00:00
return false , err
2017-02-05 13:07:44 +00:00
}
2021-12-10 01:27:50 +00:00
if err := pr . Issue . Repo . GetOwner ( ctx ) ; err != nil {
2020-02-09 23:09:31 +00:00
return false , err
2017-02-05 13:07:44 +00:00
}
2020-02-09 23:09:31 +00:00
2022-03-29 14:57:33 +00:00
if _ , err := changeIssueStatus ( ctx , pr . Issue , pr . Merger , true , true ) ; err != nil {
2022-10-24 19:29:17 +00:00
return false , fmt . Errorf ( "Issue.changeStatus: %w" , err )
2020-02-09 23:09:31 +00:00
}
2022-03-29 16:42:34 +00:00
// reset the conflicted files as there cannot be any if we're merged
pr . ConflictedFiles = [ ] string { }
2021-04-10 08:27:29 +00:00
// We need to save all of the data used to compute this merge as it may have already been changed by TestPatch. FIXME: need to set some state to prevent TestPatch from running whilst we are merging.
2022-03-29 16:42:34 +00:00
if _ , err := sess . Where ( "id = ?" , pr . ID ) . Cols ( "has_merged, status, merge_base, merged_commit_id, merger_id, merged_unix, conflicted_files" ) . Update ( pr ) ; err != nil {
2022-10-24 19:29:17 +00:00
return false , fmt . Errorf ( "Failed to update pr[%d]: %w" , pr . ID , err )
2020-02-09 23:09:31 +00:00
}
return true , nil
2017-02-05 13:07:44 +00:00
}
2015-10-18 23:30:39 +00:00
// NewPullRequest creates new pull request with labels for repository.
2022-01-19 23:26:57 +00:00
func NewPullRequest ( outerCtx context . Context , repo * repo_model . Repository , issue * Issue , labelIDs [ ] int64 , uuids [ ] string , pr * PullRequest ) ( err error ) {
2021-11-19 13:39:57 +00:00
ctx , committer , err := db . TxContext ( )
if err != nil {
2015-10-18 23:30:39 +00:00
return err
}
2021-11-19 13:39:57 +00:00
defer committer . Close ( )
2022-01-19 23:26:57 +00:00
ctx . WithContext ( outerCtx )
2015-10-18 23:30:39 +00:00
2022-10-16 10:44:16 +00:00
idx , err := db . GetNextResourceIndex ( ctx , "issue_index" , repo . ID )
if err != nil {
2022-10-24 19:29:17 +00:00
return fmt . Errorf ( "generate pull request index failed: %w" , err )
2022-10-16 10:44:16 +00:00
}
issue . Index = idx
2022-06-13 09:37:59 +00:00
if err = NewIssueWithIndex ( ctx , issue . Poster , NewIssueOptions {
2016-08-16 01:40:32 +00:00
Repo : repo ,
2021-06-14 02:22:55 +00:00
Issue : issue ,
2017-03-01 01:08:45 +00:00
LabelIDs : labelIDs ,
2016-08-16 01:40:32 +00:00
Attachments : uuids ,
IsPull : true ,
} ) ; err != nil {
2022-06-13 09:37:59 +00:00
if repo_model . IsErrUserDoesNotHaveAccessToRepo ( err ) || IsErrNewIssueInsert ( err ) {
2018-05-09 16:29:04 +00:00
return err
}
2022-10-24 19:29:17 +00:00
return fmt . Errorf ( "newIssue: %w" , err )
2015-10-18 23:30:39 +00:00
}
2021-06-14 02:22:55 +00:00
pr . Index = issue . Index
2015-10-24 07:36:47 +00:00
pr . BaseRepo = repo
2021-06-14 02:22:55 +00:00
pr . IssueID = issue . ID
2021-11-19 13:39:57 +00:00
if err = db . Insert ( ctx , pr ) ; err != nil {
2022-10-24 19:29:17 +00:00
return fmt . Errorf ( "insert pull repo: %w" , err )
2015-10-18 23:30:39 +00:00
}
2021-11-19 13:39:57 +00:00
if err = committer . Commit ( ) ; err != nil {
2022-10-24 19:29:17 +00:00
return fmt . Errorf ( "Commit: %w" , err )
2016-07-15 16:36:39 +00:00
}
return nil
2015-10-18 23:30:39 +00:00
}
2017-01-05 00:50:34 +00:00
// GetUnmergedPullRequest returns a pull request that is open and has not been merged
2015-10-18 23:30:39 +00:00
// by given head/base and repo/branch.
2021-07-28 09:42:56 +00:00
func GetUnmergedPullRequest ( headRepoID , baseRepoID int64 , headBranch , baseBranch string , flow PullRequestFlow ) ( * PullRequest , error ) {
2015-10-18 23:30:39 +00:00
pr := new ( PullRequest )
2021-09-23 15:45:36 +00:00
has , err := db . GetEngine ( db . DefaultContext ) .
2021-07-28 09:42:56 +00:00
Where ( "head_repo_id=? AND head_branch=? AND base_repo_id=? AND base_branch=? AND has_merged=? AND flow = ? AND issue.is_closed=?" ,
headRepoID , headBranch , baseRepoID , baseBranch , false , flow , false ) .
2016-11-10 15:16:32 +00:00
Join ( "INNER" , "issue" , "issue.id=pull_request.issue_id" ) .
Get ( pr )
2015-10-18 23:30:39 +00: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 14:15:30 +00: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 )
2021-09-23 15:45:36 +00:00
has , err := db . GetEngine ( db . DefaultContext ) .
2021-07-28 09:42:56 +00:00
Where ( "head_repo_id = ? AND head_branch = ? AND flow = ?" , repoID , branch , PullRequestFlowGithub ) .
2019-06-27 14:15:30 +00:00
OrderBy ( "id DESC" ) .
Get ( pr )
if ! has {
return nil , err
}
return pr , err
}
2016-12-02 11:10:39 +00:00
// GetPullRequestByIndex returns a pull request by the given index
2022-05-20 14:08:52 +00:00
func GetPullRequestByIndex ( ctx context . Context , repoID , index int64 ) ( * PullRequest , error ) {
2021-10-05 14:41:48 +00:00
if index < 1 {
return nil , ErrPullRequestNotExist { }
}
2016-12-02 11:10:39 +00:00
pr := & PullRequest {
BaseRepoID : repoID ,
Index : index ,
}
2022-04-28 11:48:48 +00:00
has , err := db . GetEngine ( ctx ) . Get ( pr )
2016-12-02 11:10:39 +00:00
if err != nil {
return nil , err
} else if ! has {
2017-01-01 18:15:09 +00:00
return nil , ErrPullRequestNotExist { 0 , 0 , 0 , repoID , "" , "" }
2016-12-02 11:10:39 +00:00
}
2022-05-20 14:08:52 +00:00
if err = pr . loadAttributes ( ctx ) ; err != nil {
2016-12-05 11:17:39 +00:00
return nil , err
}
2022-04-28 11:48:48 +00:00
if err = pr . LoadIssueCtx ( ctx ) ; err != nil {
2016-12-05 11:17:39 +00:00
return nil , err
}
2016-12-02 11:10:39 +00:00
return pr , nil
}
2022-05-20 14:08:52 +00:00
// GetPullRequestByID returns a pull request by given ID.
func GetPullRequestByID ( ctx context . Context , id int64 ) ( * PullRequest , error ) {
2015-10-24 07:36:47 +00:00
pr := new ( PullRequest )
2022-05-20 14:08:52 +00:00
has , err := db . GetEngine ( ctx ) . ID ( id ) . Get ( pr )
2015-10-24 07:36:47 +00:00
if err != nil {
return nil , err
} else if ! has {
return nil , ErrPullRequestNotExist { id , 0 , 0 , 0 , "" , "" }
}
2022-05-20 14:08:52 +00:00
return pr , pr . loadAttributes ( ctx )
2016-08-14 10:32:24 +00:00
}
2020-01-23 17:28:15 +00:00
// GetPullRequestByIssueIDWithNoAttributes returns pull request with no attributes loaded by given issue ID.
func GetPullRequestByIssueIDWithNoAttributes ( issueID int64 ) ( * PullRequest , error ) {
var pr PullRequest
2021-09-23 15:45:36 +00:00
has , err := db . GetEngine ( db . DefaultContext ) . Where ( "issue_id = ?" , issueID ) . Get ( & pr )
2020-01-23 17:28:15 +00:00
if err != nil {
return nil , err
}
if ! has {
return nil , ErrPullRequestNotExist { 0 , issueID , 0 , 0 , "" , "" }
}
return & pr , nil
}
2022-05-20 14:08:52 +00:00
// GetPullRequestByIssueID returns pull request by given issue ID.
func GetPullRequestByIssueID ( ctx context . Context , issueID int64 ) ( * PullRequest , error ) {
2015-10-22 18:47:24 +00:00
pr := & PullRequest {
IssueID : issueID ,
}
2022-05-20 14:08:52 +00:00
has , err := db . GetByBean ( ctx , pr )
2015-10-18 23:30:39 +00:00
if err != nil {
return nil , err
} else if ! has {
2015-10-22 18:47:24 +00:00
return nil , ErrPullRequestNotExist { 0 , issueID , 0 , 0 , "" , "" }
2015-10-18 23:30:39 +00:00
}
2022-05-20 14:08:52 +00:00
return pr , pr . loadAttributes ( ctx )
2016-08-14 10:32:24 +00:00
}
2021-07-28 09:42:56 +00:00
// GetAllUnmergedAgitPullRequestByPoster get all unmerged agit flow pull request
// By poster id.
func GetAllUnmergedAgitPullRequestByPoster ( uid int64 ) ( [ ] * PullRequest , error ) {
pulls := make ( [ ] * PullRequest , 0 , 10 )
2021-09-23 15:45:36 +00:00
err := db . GetEngine ( db . DefaultContext ) .
2021-07-28 09:42:56 +00:00
Where ( "has_merged=? AND flow = ? AND issue.is_closed=? AND issue.poster_id=?" ,
false , PullRequestFlowAGit , false , uid ) .
Join ( "INNER" , "issue" , "issue.id=pull_request.issue_id" ) .
Find ( & pulls )
return pulls , err
}
2015-10-24 07:36:47 +00:00
// Update updates all fields of pull request.
func ( pr * PullRequest ) Update ( ) error {
2021-09-23 15:45:36 +00:00
_ , err := db . GetEngine ( db . DefaultContext ) . ID ( pr . ID ) . AllCols ( ) . Update ( pr )
2015-10-24 07:36:47 +00:00
return err
}
2016-11-28 15:31:06 +00:00
// UpdateCols updates specific fields of pull request.
2015-10-24 07:36:47 +00:00
func ( pr * PullRequest ) UpdateCols ( cols ... string ) error {
2021-09-23 15:45:36 +00:00
_ , err := db . GetEngine ( db . DefaultContext ) . ID ( pr . ID ) . Cols ( cols ... ) . Update ( pr )
2015-10-24 07:36:47 +00:00
return err
2020-02-09 23:09:31 +00:00
}
// UpdateColsIfNotMerged updates specific fields of a pull request if it has not been merged
func ( pr * PullRequest ) UpdateColsIfNotMerged ( cols ... string ) error {
2021-09-23 15:45:36 +00:00
_ , err := db . GetEngine ( db . DefaultContext ) . Where ( "id = ? AND has_merged = ?" , pr . ID , false ) . Cols ( cols ... ) . Update ( pr )
2020-02-09 23:09:31 +00:00
return err
2015-10-24 07:36:47 +00:00
}
2018-08-13 19:04:39 +00: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 07:48:31 +00:00
log . Error ( "LoadIssue: %v" , err )
2018-08-13 19:04:39 +00:00
return false
}
2021-06-23 04:14:22 +00:00
return HasWorkInProgressPrefix ( pr . Issue . Title )
}
2018-08-13 19:04:39 +00:00
2021-06-23 04:14:22 +00:00
// HasWorkInProgressPrefix determines if the given PR title has a Work In Progress prefix
func HasWorkInProgressPrefix ( title string ) bool {
2018-08-13 19:04:39 +00:00
for _ , prefix := range setting . Repository . PullRequest . WorkInProgressPrefixes {
Make WIP prefixes case insensitive, e.g. allow `Draft` as a WIP prefix (#19780)
The issue was that only the actual title was converted to uppercase, but
not the prefix as specified in `WORK_IN_PROGRESS_PREFIXES`. As a result,
the following did not work:
WORK_IN_PROGRESS_PREFIXES=Draft:,[Draft],WIP:,[WIP]
One possible workaround was:
WORK_IN_PROGRESS_PREFIXES=DRAFT:,[DRAFT],WIP:,[WIP]
Then indeed one could use `Draft` (as well as `DRAFT`) in the title.
However, the link `Start the title with DRAFT: to prevent the pull request
from being merged accidentally.` showed the suggestion in uppercase; so
it is not possible to show it as `Draft`. This PR fixes it, and allows
to use `Draft` in `WORK_IN_PROGRESS_PREFIXES`.
Fixes #19779.
Co-authored-by: zeripath <art27@cantab.net>
2022-05-26 09:19:24 +00:00
if strings . HasPrefix ( strings . ToUpper ( title ) , strings . ToUpper ( prefix ) ) {
2018-08-13 19:04:39 +00:00
return true
}
}
return false
}
2019-02-05 11:54:49 +00: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 19:04:39 +00: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 07:48:31 +00:00
log . Error ( "LoadIssue: %v" , err )
2018-08-13 19:04:39 +00:00
return ""
}
for _ , prefix := range setting . Repository . PullRequest . WorkInProgressPrefixes {
Make WIP prefixes case insensitive, e.g. allow `Draft` as a WIP prefix (#19780)
The issue was that only the actual title was converted to uppercase, but
not the prefix as specified in `WORK_IN_PROGRESS_PREFIXES`. As a result,
the following did not work:
WORK_IN_PROGRESS_PREFIXES=Draft:,[Draft],WIP:,[WIP]
One possible workaround was:
WORK_IN_PROGRESS_PREFIXES=DRAFT:,[DRAFT],WIP:,[WIP]
Then indeed one could use `Draft` (as well as `DRAFT`) in the title.
However, the link `Start the title with DRAFT: to prevent the pull request
from being merged accidentally.` showed the suggestion in uppercase; so
it is not possible to show it as `Draft`. This PR fixes it, and allows
to use `Draft` in `WORK_IN_PROGRESS_PREFIXES`.
Fixes #19779.
Co-authored-by: zeripath <art27@cantab.net>
2022-05-26 09:19:24 +00:00
if strings . HasPrefix ( strings . ToUpper ( pr . Issue . Title ) , strings . ToUpper ( prefix ) ) {
2018-08-13 19:04:39 +00:00
return pr . Issue . Title [ 0 : len ( prefix ) ]
}
}
return ""
}
2019-12-16 06:20:25 +00:00
2020-04-14 13:53:34 +00:00
// UpdateCommitDivergence update Divergence of a pull request
2022-05-20 14:08:52 +00:00
func ( pr * PullRequest ) UpdateCommitDivergence ( ctx context . Context , ahead , behind int ) error {
2020-04-14 13:53:34 +00:00
if pr . ID == 0 {
return fmt . Errorf ( "pull ID is 0" )
}
pr . CommitsAhead = ahead
pr . CommitsBehind = behind
2022-05-20 14:08:52 +00:00
_ , err := db . GetEngine ( ctx ) . ID ( pr . ID ) . Cols ( "commits_ahead" , "commits_behind" ) . Update ( pr )
2020-04-14 13:53:34 +00:00
return err
}
2020-01-17 06:03:40 +00:00
// IsSameRepo returns true if base repo and head repo is the same
func ( pr * PullRequest ) IsSameRepo ( ) bool {
return pr . BaseRepoID == pr . HeadRepoID
}
2021-02-18 02:45:49 +00:00
2022-05-07 17:05:52 +00:00
// GetPullRequestsByHeadBranch returns all prs by head branch
// Since there could be multiple prs with the same head branch, this function returns a slice of prs
func GetPullRequestsByHeadBranch ( ctx context . Context , headBranch string , headRepoID int64 ) ( [ ] * PullRequest , error ) {
log . Trace ( "GetPullRequestsByHeadBranch: headBranch: '%s', headRepoID: '%d'" , headBranch , headRepoID )
prs := make ( [ ] * PullRequest , 0 , 2 )
if err := db . GetEngine ( ctx ) . Where ( builder . Eq { "head_branch" : headBranch , "head_repo_id" : headRepoID } ) .
Find ( & prs ) ; err != nil {
return nil , err
}
return prs , nil
}
2021-02-18 02:45:49 +00:00
// GetBaseBranchHTMLURL returns the HTML URL of the base branch
func ( pr * PullRequest ) GetBaseBranchHTMLURL ( ) string {
if err := pr . LoadBaseRepo ( ) ; err != nil {
log . Error ( "LoadBaseRepo: %v" , err )
return ""
}
if pr . BaseRepo == nil {
return ""
}
return pr . BaseRepo . HTMLURL ( ) + "/src/branch/" + util . PathEscapeSegments ( pr . BaseBranch )
}
// GetHeadBranchHTMLURL returns the HTML URL of the head branch
func ( pr * PullRequest ) GetHeadBranchHTMLURL ( ) string {
2021-07-28 09:42:56 +00:00
if pr . Flow == PullRequestFlowAGit {
return ""
}
2021-02-18 02:45:49 +00:00
if err := pr . LoadHeadRepo ( ) ; err != nil {
log . Error ( "LoadHeadRepo: %v" , err )
return ""
}
if pr . HeadRepo == nil {
return ""
}
return pr . HeadRepo . HTMLURL ( ) + "/src/branch/" + util . PathEscapeSegments ( pr . HeadBranch )
}
2022-04-21 21:55:45 +00:00
2022-04-28 15:45:33 +00:00
// UpdateAllowEdits update if PR can be edited from maintainers
func UpdateAllowEdits ( ctx context . Context , pr * PullRequest ) error {
if _ , err := db . GetEngine ( ctx ) . ID ( pr . ID ) . Cols ( "allow_maintainer_edit" ) . Update ( pr ) ; err != nil {
return err
}
return nil
}
2022-04-21 21:55:45 +00:00
// Mergeable returns if the pullrequest is mergeable.
func ( pr * PullRequest ) Mergeable ( ) bool {
// If a pull request isn't mergable if it's:
// - Being conflict checked.
// - Has a conflict.
// - Received a error while being conflict checked.
// - Is a work-in-progress pull request.
return pr . Status != PullRequestStatusChecking && pr . Status != PullRequestStatusConflict &&
pr . Status != PullRequestStatusError && ! pr . IsWorkInProgress ( )
}
2022-06-13 09:37:59 +00:00
// HasEnoughApprovals returns true if pr has enough granted approvals.
func HasEnoughApprovals ( ctx context . Context , protectBranch * git_model . ProtectedBranch , pr * PullRequest ) bool {
if protectBranch . RequiredApprovals == 0 {
return true
}
return GetGrantedApprovalsCount ( ctx , protectBranch , pr ) >= protectBranch . RequiredApprovals
}
// GetGrantedApprovalsCount returns the number of granted approvals for pr. A granted approval must be authored by a user in an approval whitelist.
func GetGrantedApprovalsCount ( ctx context . Context , protectBranch * git_model . ProtectedBranch , pr * PullRequest ) int64 {
sess := db . GetEngine ( ctx ) . Where ( "issue_id = ?" , pr . IssueID ) .
And ( "type = ?" , ReviewTypeApprove ) .
And ( "official = ?" , true ) .
And ( "dismissed = ?" , false )
if protectBranch . DismissStaleApprovals {
sess = sess . And ( "stale = ?" , false )
}
approvals , err := sess . Count ( new ( Review ) )
if err != nil {
log . Error ( "GetGrantedApprovalsCount: %v" , err )
return 0
}
return approvals
}
// MergeBlockedByRejectedReview returns true if merge is blocked by rejected reviews
func MergeBlockedByRejectedReview ( ctx context . Context , protectBranch * git_model . ProtectedBranch , pr * PullRequest ) bool {
if ! protectBranch . BlockOnRejectedReviews {
return false
}
rejectExist , err := db . GetEngine ( ctx ) . Where ( "issue_id = ?" , pr . IssueID ) .
And ( "type = ?" , ReviewTypeReject ) .
And ( "official = ?" , true ) .
And ( "dismissed = ?" , false ) .
Exist ( new ( Review ) )
if err != nil {
log . Error ( "MergeBlockedByRejectedReview: %v" , err )
return true
}
return rejectExist
}
// MergeBlockedByOfficialReviewRequests block merge because of some review request to official reviewer
// of from official review
func MergeBlockedByOfficialReviewRequests ( ctx context . Context , protectBranch * git_model . ProtectedBranch , pr * PullRequest ) bool {
if ! protectBranch . BlockOnOfficialReviewRequests {
return false
}
has , err := db . GetEngine ( ctx ) . Where ( "issue_id = ?" , pr . IssueID ) .
And ( "type = ?" , ReviewTypeRequest ) .
And ( "official = ?" , true ) .
Exist ( new ( Review ) )
if err != nil {
log . Error ( "MergeBlockedByOfficialReviewRequests: %v" , err )
return true
}
return has
}
// MergeBlockedByOutdatedBranch returns true if merge is blocked by an outdated head branch
func MergeBlockedByOutdatedBranch ( protectBranch * git_model . ProtectedBranch , pr * PullRequest ) bool {
return protectBranch . BlockOnOutdatedBranch && pr . CommitsBehind > 0
}