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 (
2021-12-09 20:27:50 -05:00
"context"
2015-10-18 19:30:39 -04:00
"fmt"
2019-12-30 18:34:11 -05:00
"io"
2015-10-18 19:30:39 -04:00
"strings"
2021-09-19 07:49:59 -04:00
"code.gitea.io/gitea/models/db"
2021-12-09 20:27:50 -05:00
repo_model "code.gitea.io/gitea/models/repo"
2021-11-09 14:57:58 -05:00
"code.gitea.io/gitea/models/unit"
2021-11-24 04:49:20 -05:00
user_model "code.gitea.io/gitea/models/user"
2021-12-02 02:28:08 -05: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"
2021-02-17 21:45:49 -05:00
"code.gitea.io/gitea/modules/util"
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
2021-03-03 22:41:23 -05:00
PullRequestStatusEmpty
2015-10-18 19:30:39 -04:00
)
2021-07-28 05:42:56 -04: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 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" `
2020-04-14 09:53:34 -04:00
CommitsAhead int
CommitsBehind int
2015-10-18 19:30:39 -04:00
2020-10-13 14:50:57 -04:00
ChangedProtectedFiles [ ] string ` xorm:"TEXT JSON" `
2015-10-18 19:30:39 -04:00
IssueID int64 ` xorm:"INDEX" `
Issue * Issue ` xorm:"-" `
Index int64
2021-12-09 20:27:50 -05:00
HeadRepoID int64 ` xorm:"INDEX" `
HeadRepo * repo_model . Repository ` xorm:"-" `
BaseRepoID int64 ` xorm:"INDEX" `
BaseRepo * repo_model . Repository ` xorm:"-" `
2018-12-11 06:28:37 -05:00
HeadBranch string
2021-07-28 05:42:56 -04:00
HeadCommitID string ` xorm:"-" `
2018-12-11 06:28:37 -05:00
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" `
2021-11-24 04:49:20 -05:00
Merger * user_model . User ` xorm:"-" `
2019-08-15 10:46:21 -04:00
MergedUnix timeutil . TimeStamp ` xorm:"updated INDEX" `
2020-03-02 17:31:55 -05:00
isHeadRepoLoaded bool ` xorm:"-" `
2021-07-28 05:42:56 -04:00
Flow PullRequestFlow ` xorm:"NOT NULL DEFAULT 0" `
2015-10-18 19:30:39 -04:00
}
2021-09-19 07:49:59 -04:00
func init ( ) {
db . RegisterModel ( new ( PullRequest ) )
}
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 {
2021-12-09 20:27:50 -05:00
if ! repo_model . IsErrRepoNotExist ( err ) {
2020-01-24 21:48:22 -05:00
log . Error ( "LoadHeadRepo: %v" , err )
} else {
log . Warn ( "LoadHeadRepo %d but repository does not exist: %v" , pr . HeadRepoID , err )
}
2019-10-18 07:13:31 -04:00
return ""
}
2020-03-02 17:31:55 -05:00
if pr . HeadRepo == nil {
return ""
}
2020-01-12 04:36:21 -05:00
return pr . HeadRepo . OwnerName
2019-10-18 07:13:31 -04:00
}
2016-08-14 06:32:24 -04:00
// Note: don't try to get Issue because will end up recursive querying.
2021-09-19 07:49:59 -04:00
func ( pr * PullRequest ) loadAttributes ( e db . Engine ) ( err error ) {
2016-08-14 06:32:24 -04:00
if pr . HasMerged && pr . Merger == nil {
2021-11-24 04:49:20 -05:00
pr . Merger , err = user_model . GetUserByIDEngine ( e , pr . MergerID )
if user_model . IsErrUserNotExist ( err ) {
2016-08-14 06:32:24 -04:00
pr . MergerID = - 1
2021-11-24 04:49:20 -05:00
pr . Merger = user_model . NewGhostUser ( )
2016-08-14 06:32:24 -04:00
} 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 {
2021-09-23 11:45:36 -04:00
return pr . loadAttributes ( db . GetEngine ( db . DefaultContext ) )
2016-08-14 06:32:24 -04:00
}
2021-12-09 20:27:50 -05:00
func ( pr * PullRequest ) loadHeadRepo ( ctx context . Context ) ( err error ) {
2020-03-02 17:31:55 -05: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 07:13:31 -04:00
}
2020-03-02 17:31:55 -05:00
2021-12-09 20:27:50 -05: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
2020-03-02 17:31:55 -05:00
return fmt . Errorf ( "getRepositoryByID(head): %v" , err )
2019-09-18 01:39:45 -04:00
}
2020-03-02 17:31:55 -05:00
pr . isHeadRepoLoaded = true
2019-09-18 01:39:45 -04:00
}
return nil
}
2020-03-02 17:31:55 -05:00
// LoadHeadRepo loads the head repository
2019-10-18 07:13:31 -04:00
func ( pr * PullRequest ) LoadHeadRepo ( ) error {
2021-12-09 20:27:50 -05:00
return pr . loadHeadRepo ( db . DefaultContext )
2020-03-02 17:31:55 -05:00
}
// LoadBaseRepo loads the target repository
func ( pr * PullRequest ) LoadBaseRepo ( ) error {
2021-12-09 20:27:50 -05:00
return pr . loadBaseRepo ( db . DefaultContext )
2020-03-02 17:31:55 -05:00
}
2021-12-09 20:27:50 -05:00
func ( pr * PullRequest ) loadBaseRepo ( ctx context . Context ) ( err error ) {
2020-03-02 17:31:55 -05: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-09 20:27:50 -05:00
pr . BaseRepo , err = repo_model . GetRepositoryByIDCtx ( ctx , pr . BaseRepoID )
2020-03-02 17:31:55 -05:00
if err != nil {
2021-12-09 20:27:50 -05:00
return fmt . Errorf ( "repo_model.GetRepositoryByID(base): %v" , err )
2019-10-18 07:13:31 -04:00
}
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 ) {
2021-09-23 11:45:36 -04:00
return pr . loadIssue ( db . GetEngine ( db . DefaultContext ) )
2017-02-26 19:42:55 -05:00
}
2021-09-19 07:49:59 -04:00
func ( pr * PullRequest ) loadIssue ( e db . 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 ) {
2021-12-09 20:27:50 -05:00
return pr . loadProtectedBranch ( db . DefaultContext )
2019-12-03 20:08:56 -05:00
}
2021-12-09 20:27:50 -05:00
func ( pr * PullRequest ) loadProtectedBranch ( ctx context . Context ) ( err error ) {
2020-01-15 03:32:57 -05:00
if pr . ProtectedBranch == nil {
if pr . BaseRepo == nil {
if pr . BaseRepoID == 0 {
return nil
}
2021-12-09 20:27:50 -05:00
pr . BaseRepo , err = repo_model . GetRepositoryByIDCtx ( ctx , pr . BaseRepoID )
2020-01-15 03:32:57 -05:00
if err != nil {
return
}
2018-12-17 12:35:21 -05:00
}
2021-12-09 20:27:50 -05:00
pr . ProtectedBranch , err = getProtectedBranchBy ( db . GetEngine ( ctx ) , pr . BaseRepo . ID , pr . BaseBranch )
2018-12-17 12:35:21 -05:00
}
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
2022-03-31 10:53:08 -04:00
func ( pr * PullRequest ) GetDefaultMergeMessage ( ) ( string , error ) {
2018-01-05 13:56:50 -05:00
if pr . HeadRepo == nil {
var err error
2021-12-09 20:27:50 -05:00
pr . HeadRepo , err = repo_model . GetRepositoryByID ( pr . HeadRepoID )
2018-01-05 13:56:50 -05:00
if err != nil {
2022-03-31 10:53:08 -04:00
return "" , fmt . Errorf ( "GetRepositoryById[%d]: %v" , pr . HeadRepoID , err )
2018-01-05 13:56:50 -05:00
}
}
2020-01-08 06:53:07 -05:00
if err := pr . LoadIssue ( ) ; err != nil {
2022-03-31 10:53:08 -04:00
return "" , fmt . Errorf ( "Cannot load issue %d for PR id %d: Error: %v" , pr . IssueID , pr . ID , err )
2020-01-08 06:53:07 -05:00
}
2021-05-08 15:19:42 -04:00
if err := pr . LoadBaseRepo ( ) ; err != nil {
2022-03-31 10:53:08 -04:00
return "" , fmt . Errorf ( "LoadBaseRepo: %v" , err )
2021-05-08 15:19:42 -04:00
}
issueReference := "#"
2021-11-09 14:57:58 -05:00
if pr . BaseRepo . UnitEnabled ( unit . TypeExternalTracker ) {
2021-05-08 15:19:42 -04:00
issueReference = "!"
}
2020-01-28 03:29:30 -05:00
if pr . BaseRepoID == pr . HeadRepoID {
2022-03-31 10:53:08 -04:00
return fmt . Sprintf ( "Merge pull request '%s' (%s%d) from %s into %s" , pr . Issue . Title , issueReference , pr . Issue . Index , pr . HeadBranch , pr . BaseBranch ) , nil
2020-01-28 03:29:30 -05:00
}
2022-03-31 10:53:08 -04:00
return fmt . Sprintf ( "Merge pull request '%s' (%s%d) from %s:%s into %s" , pr . Issue . Title , issueReference , pr . Issue . Index , pr . HeadRepo . FullName ( ) , pr . HeadBranch , pr . BaseBranch ) , nil
2018-01-05 13:56:50 -05:00
}
2020-03-05 22:44:06 -05:00
// ReviewCount represents a count of Reviews
type ReviewCount struct {
IssueID int64
Type ReviewType
C ount int64
}
// GetApprovalCounts returns the approval counts by type
// FIXME: Only returns official counts due to double counting of non-official counts
func ( pr * PullRequest ) GetApprovalCounts ( ) ( [ ] * ReviewCount , error ) {
2021-09-23 11:45:36 -04:00
return pr . getApprovalCounts ( db . GetEngine ( db . DefaultContext ) )
2020-03-05 22:44:06 -05:00
}
2021-09-19 07:49:59 -04:00
func ( pr * PullRequest ) getApprovalCounts ( e db . Engine ) ( [ ] * ReviewCount , error ) {
2020-03-05 22:44:06 -05:00
rCounts := make ( [ ] * ReviewCount , 0 , 6 )
sess := e . Where ( "issue_id = ?" , pr . IssueID )
2021-02-11 12:32:25 -05: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-05 22:44:06 -05:00
}
2019-12-30 18:34:11 -05: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 10:41:00 -05:00
ctx , committer , err := db . TxContext ( )
if err != nil {
2019-12-30 18:34:11 -05:00
return err
}
2021-11-21 10:41:00 -05:00
defer committer . Close ( )
sess := db . GetEngine ( ctx )
2019-12-30 18:34:11 -05:00
// 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
}
2021-11-24 04:49:20 -05:00
if err := review . loadReviewer ( sess ) ; err != nil && ! user_model . IsErrUserNotExist ( err ) {
2019-12-30 18:34:11 -05: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 10:41:00 -05:00
return committer . Commit ( )
2019-12-30 18:34:11 -05:00
}
2018-01-05 13:56:50 -05:00
// GetDefaultSquashMessage returns default message used when squash and merging pull request
2022-03-31 10:53:08 -04:00
func ( pr * PullRequest ) GetDefaultSquashMessage ( ) ( string , error ) {
2018-01-05 13:56:50 -05:00
if err := pr . LoadIssue ( ) ; err != nil {
2022-03-31 10:53:08 -04:00
return "" , fmt . Errorf ( "LoadIssue: %v" , err )
2018-01-05 13:56:50 -05:00
}
2020-01-17 23:40:43 -05:00
if err := pr . LoadBaseRepo ( ) ; err != nil {
2022-03-31 10:53:08 -04:00
return "" , fmt . Errorf ( "LoadBaseRepo: %v" , err )
2020-01-17 23:40:43 -05:00
}
2021-11-09 14:57:58 -05:00
if pr . BaseRepo . UnitEnabled ( unit . TypeExternalTracker ) {
2022-03-31 10:53:08 -04:00
return fmt . Sprintf ( "%s (!%d)" , pr . Issue . Title , pr . Issue . Index ) , nil
2020-01-17 23:40:43 -05:00
}
2022-03-31 10:53:08 -04:00
return fmt . Sprintf ( "%s (#%d)" , pr . Issue . Title , pr . Issue . Index ) , nil
2018-01-05 13:56:50 -05:00
}
2018-01-19 01:18:51 -05:00
// GetGitRefName returns git ref for hidden pull request branch
func ( pr * PullRequest ) GetGitRefName ( ) string {
2021-12-02 14:36:50 -05:00
return fmt . Sprintf ( "%s%d/head" , git . PullPrefix , pr . Index )
2018-01-19 01:18:51 -05:00
}
2015-10-24 03:36:47 -04:00
// 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
}
2021-03-03 22:41:23 -05:00
// IsEmpty returns true if this pull request is empty.
func ( pr * PullRequest ) IsEmpty ( ) bool {
return pr . Status == PullRequestStatusEmpty
}
2019-06-22 13:35:34 -04:00
// SetMerged sets a pull request to merged and closes the corresponding issue
2020-02-09 18:09:31 -05:00
func ( pr * PullRequest ) SetMerged ( ) ( bool , error ) {
2017-02-05 08:07:44 -05:00
if pr . HasMerged {
2020-02-09 18:09:31 -05:00
return false , fmt . Errorf ( "PullRequest[%d] already merged" , pr . Index )
2017-02-05 08:07:44 -05:00
}
2017-12-10 23:37:04 -05:00
if pr . MergedCommitID == "" || pr . MergedUnix == 0 || pr . Merger == nil {
2020-02-09 18:09:31 -05:00
return false , fmt . Errorf ( "Unable to merge PullRequest[%d], some required fields are empty" , pr . Index )
2017-02-05 08:07:44 -05:00
}
pr . HasMerged = true
2021-11-19 08:39:57 -05:00
ctx , committer , err := db . TxContext ( )
if err != nil {
2020-02-09 18:09:31 -05:00
return false , err
2017-02-05 08:07:44 -05:00
}
2021-11-19 08:39:57 -05:00
defer committer . Close ( )
sess := db . GetEngine ( ctx )
2017-02-05 08:07:44 -05:00
2020-02-09 18:09:31 -05:00
if _ , err := sess . Exec ( "UPDATE `issue` SET `repo_id` = `repo_id` WHERE `id` = ?" , pr . IssueID ) ; err != nil {
return false , err
2017-02-05 08:07:44 -05:00
}
2020-02-09 18:09:31 -05:00
if _ , err := sess . Exec ( "UPDATE `pull_request` SET `issue_id` = `issue_id` WHERE `id` = ?" , pr . ID ) ; err != nil {
return false , err
2017-02-26 19:42:55 -05:00
}
2020-02-09 18:09:31 -05:00
pr . Issue = nil
if err := pr . loadIssue ( sess ) ; err != nil {
return false , err
2017-02-05 08:07:44 -05:00
}
2020-02-09 18:09:31 -05:00
if tmpPr , err := getPullRequestByID ( sess , pr . ID ) ; err != nil {
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 08:07:44 -05:00
}
2020-02-09 18:09:31 -05:00
2021-12-09 20:27:50 -05:00
if err := pr . Issue . loadRepo ( ctx ) ; err != nil {
2020-02-09 18:09:31 -05:00
return false , err
2017-02-05 08:07:44 -05:00
}
2021-12-09 20:27:50 -05:00
if err := pr . Issue . Repo . GetOwner ( ctx ) ; err != nil {
2020-02-09 18:09:31 -05:00
return false , err
2017-02-05 08:07:44 -05:00
}
2020-02-09 18:09:31 -05:00
2022-03-29 10:57:33 -04:00
if _ , err := changeIssueStatus ( ctx , pr . Issue , pr . Merger , true , true ) ; err != nil {
2020-02-09 18:09:31 -05:00
return false , fmt . Errorf ( "Issue.changeStatus: %v" , err )
}
2022-03-29 12:42:34 -04:00
// reset the conflicted files as there cannot be any if we're merged
pr . ConflictedFiles = [ ] string { }
2021-04-10 04:27:29 -04: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 12:42:34 -04: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 {
2020-02-09 18:09:31 -05:00
return false , fmt . Errorf ( "Failed to update pr[%d]: %v" , pr . ID , err )
}
2021-11-19 08:39:57 -05:00
if err := committer . Commit ( ) ; err != nil {
2020-02-09 18:09:31 -05:00
return false , fmt . Errorf ( "Commit: %v" , err )
}
return true , nil
2017-02-05 08:07:44 -05:00
}
2015-10-18 19:30:39 -04:00
// NewPullRequest creates new pull request with labels for repository.
2022-01-19 18:26:57 -05:00
func NewPullRequest ( outerCtx context . Context , repo * repo_model . Repository , issue * Issue , labelIDs [ ] int64 , uuids [ ] string , pr * PullRequest ) ( err error ) {
2021-09-19 07:49:59 -04:00
idx , err := db . GetNextResourceIndex ( "issue_index" , repo . ID )
2021-06-13 22:22:55 -04:00
if err != nil {
2021-09-23 06:50:06 -04:00
return fmt . Errorf ( "generate pull request index failed: %v" , err )
2019-10-02 18:28:30 -04:00
}
2021-06-13 22:22:55 -04:00
issue . Index = idx
2021-11-19 08:39:57 -05:00
ctx , committer , err := db . TxContext ( )
if err != nil {
2015-10-18 19:30:39 -04:00
return err
}
2021-11-19 08:39:57 -05:00
defer committer . Close ( )
2022-01-19 18:26:57 -05:00
ctx . WithContext ( outerCtx )
2015-10-18 19:30:39 -04:00
2021-11-19 08:39:57 -05:00
if err = newIssue ( ctx , issue . Poster , NewIssueOptions {
2016-08-15 21:40:32 -04:00
Repo : repo ,
2021-06-13 22:22:55 -04:00
Issue : issue ,
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 )
}
2021-06-13 22:22:55 -04:00
pr . Index = issue . Index
2015-10-24 03:36:47 -04:00
pr . BaseRepo = repo
2021-06-13 22:22:55 -04:00
pr . IssueID = issue . ID
2021-11-19 08:39:57 -05:00
if err = db . Insert ( ctx , pr ) ; err != nil {
2015-10-18 19:30:39 -04:00
return fmt . Errorf ( "insert pull repo: %v" , err )
}
2021-11-19 08:39:57 -05:00
if err = committer . Commit ( ) ; err != nil {
2016-07-15 12:36:39 -04:00
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.
2021-07-28 05:42:56 -04:00
func GetUnmergedPullRequest ( headRepoID , baseRepoID int64 , headBranch , baseBranch string , flow PullRequestFlow ) ( * PullRequest , error ) {
2015-10-18 19:30:39 -04:00
pr := new ( PullRequest )
2021-09-23 11:45:36 -04:00
has , err := db . GetEngine ( db . DefaultContext ) .
2021-07-28 05:42:56 -04: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 10:16:32 -05:00
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 )
2021-09-23 11:45:36 -04:00
has , err := db . GetEngine ( db . DefaultContext ) .
2021-07-28 05:42:56 -04:00
Where ( "head_repo_id = ? AND head_branch = ? AND flow = ?" , repoID , branch , PullRequestFlowGithub ) .
2019-06-27 10:15:30 -04:00
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
2021-03-14 14:52:12 -04:00
func GetPullRequestByIndex ( repoID , index int64 ) ( * PullRequest , error ) {
2021-10-05 10:41:48 -04:00
if index < 1 {
return nil , ErrPullRequestNotExist { }
}
2016-12-02 06:10:39 -05:00
pr := & PullRequest {
BaseRepoID : repoID ,
Index : index ,
}
2021-09-23 11:45:36 -04:00
has , err := db . GetEngine ( db . DefaultContext ) . Get ( pr )
2016-12-02 06:10:39 -05:00
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
}
2021-09-19 07:49:59 -04:00
func getPullRequestByID ( e db . 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 ) {
2021-09-23 11:45:36 -04:00
return getPullRequestByID ( db . GetEngine ( db . DefaultContext ) , id )
2016-08-14 06:32:24 -04:00
}
2020-01-23 12:28:15 -05: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 11:45:36 -04:00
has , err := db . GetEngine ( db . DefaultContext ) . Where ( "issue_id = ?" , issueID ) . Get ( & pr )
2020-01-23 12:28:15 -05:00
if err != nil {
return nil , err
}
if ! has {
return nil , ErrPullRequestNotExist { 0 , issueID , 0 , 0 , "" , "" }
}
return & pr , nil
}
2021-09-19 07:49:59 -04:00
func getPullRequestByIssueID ( e db . 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 )
}
2021-07-28 05:42:56 -04: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 11:45:36 -04:00
err := db . GetEngine ( db . DefaultContext ) .
2021-07-28 05:42:56 -04: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
}
2016-08-14 06:32:24 -04:00
// GetPullRequestByIssueID returns pull request by given issue ID.
func GetPullRequestByIssueID ( issueID int64 ) ( * PullRequest , error ) {
2021-09-23 11:45:36 -04:00
return getPullRequestByIssueID ( db . GetEngine ( db . DefaultContext ) , 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 {
2021-09-23 11:45:36 -04:00
_ , err := db . GetEngine ( db . DefaultContext ) . 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 {
2021-09-23 11:45:36 -04:00
_ , err := db . GetEngine ( db . DefaultContext ) . ID ( pr . ID ) . Cols ( cols ... ) . Update ( pr )
2015-10-24 03:36:47 -04:00
return err
2020-02-09 18:09:31 -05: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 11:45:36 -04:00
_ , err := db . GetEngine ( db . DefaultContext ) . Where ( "id = ? AND has_merged = ?" , pr . ID , false ) . Cols ( cols ... ) . Update ( pr )
2020-02-09 18:09:31 -05:00
return err
2015-10-24 03:36:47 -04:00
}
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
}
2021-06-23 00:14:22 -04:00
return HasWorkInProgressPrefix ( pr . Issue . Title )
}
2018-08-13 15:04:39 -04:00
2021-06-23 00:14:22 -04:00
// HasWorkInProgressPrefix determines if the given PR title has a Work In Progress prefix
func HasWorkInProgressPrefix ( title string ) bool {
2018-08-13 15:04:39 -04:00
for _ , prefix := range setting . Repository . PullRequest . WorkInProgressPrefixes {
2021-06-23 00:14:22 -04:00
if strings . HasPrefix ( strings . ToUpper ( title ) , prefix ) {
2018-08-13 15:04:39 -04:00
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
2020-04-14 09:53:34 -04:00
// UpdateCommitDivergence update Divergence of a pull request
func ( pr * PullRequest ) UpdateCommitDivergence ( ahead , behind int ) error {
2021-09-23 11:45:36 -04:00
return pr . updateCommitDivergence ( db . GetEngine ( db . DefaultContext ) , ahead , behind )
2020-04-14 09:53:34 -04:00
}
2021-09-19 07:49:59 -04:00
func ( pr * PullRequest ) updateCommitDivergence ( e db . Engine , ahead , behind int ) error {
2020-04-14 09:53:34 -04:00
if pr . ID == 0 {
return fmt . Errorf ( "pull ID is 0" )
}
pr . CommitsAhead = ahead
pr . CommitsBehind = behind
_ , err := e . ID ( pr . ID ) . Cols ( "commits_ahead" , "commits_behind" ) . Update ( pr )
return err
}
2020-01-17 01:03:40 -05: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-17 21:45:49 -05: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 05:42:56 -04:00
if pr . Flow == PullRequestFlowAGit {
return ""
}
2021-02-17 21:45:49 -05: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 )
}