2018-08-05 23:43:22 -05:00
// Copyright 2018 The Gitea Authors. All rights reserved.
// Use of this source code is governed by a MIT-style
// license that can be found in the LICENSE file.
package models
import (
2019-11-13 21:57:36 -05:00
"strings"
2018-08-05 23:43:22 -05:00
2019-08-15 09:46:21 -05:00
"code.gitea.io/gitea/modules/timeutil"
2018-08-05 23:43:22 -05:00
2019-06-23 10:22:43 -05:00
"xorm.io/builder"
2018-08-05 23:43:22 -05:00
)
// ReviewType defines the sort of feedback a review gives
type ReviewType int
// ReviewTypeUnknown unknown review type
const ReviewTypeUnknown ReviewType = - 1
const (
// ReviewTypePending is a review which is not published yet
ReviewTypePending ReviewType = iota
// ReviewTypeApprove approves changes
ReviewTypeApprove
// ReviewTypeComment gives general feedback
ReviewTypeComment
// ReviewTypeReject gives feedback blocking merge
ReviewTypeReject
)
// Icon returns the corresponding icon for the review type
func ( rt ReviewType ) Icon ( ) string {
switch rt {
case ReviewTypeApprove :
return "eye"
case ReviewTypeReject :
return "x"
2018-10-19 08:36:41 -05:00
case ReviewTypeComment , ReviewTypeUnknown :
return "comment"
2018-08-05 23:43:22 -05:00
default :
return "comment"
}
}
// Review represents collection of code comments giving feedback for a PR
type Review struct {
ID int64 ` xorm:"pk autoincr" `
Type ReviewType
Reviewer * User ` xorm:"-" `
ReviewerID int64 ` xorm:"index" `
Issue * Issue ` xorm:"-" `
IssueID int64 ` xorm:"index" `
2019-12-02 13:32:40 -05:00
Content string ` xorm:"TEXT" `
2019-12-03 20:08:56 -05:00
// Official is a review made by an assigned approver (counts towards approval)
Official bool ` xorm:"NOT NULL DEFAULT false" `
2018-08-05 23:43:22 -05:00
2019-08-15 09:46:21 -05:00
CreatedUnix timeutil . TimeStamp ` xorm:"INDEX created" `
UpdatedUnix timeutil . TimeStamp ` xorm:"INDEX updated" `
2018-08-05 23:43:22 -05:00
// CodeComments are the initial code comments of the review
CodeComments CodeComments ` xorm:"-" `
}
func ( r * Review ) loadCodeComments ( e Engine ) ( err error ) {
2019-11-15 07:59:21 -05:00
if r . CodeComments == nil {
r . CodeComments , err = fetchCodeCommentsByReview ( e , r . Issue , nil , r )
}
2018-08-05 23:43:22 -05:00
return
}
// LoadCodeComments loads CodeComments
func ( r * Review ) LoadCodeComments ( ) error {
return r . loadCodeComments ( x )
}
func ( r * Review ) loadIssue ( e Engine ) ( err error ) {
r . Issue , err = getIssueByID ( e , r . IssueID )
return
}
func ( r * Review ) loadReviewer ( e Engine ) ( err error ) {
if r . ReviewerID == 0 {
return nil
}
r . Reviewer , err = getUserByID ( e , r . ReviewerID )
return
}
2019-11-13 21:57:36 -05:00
// LoadReviewer loads reviewer
func ( r * Review ) LoadReviewer ( ) error {
return r . loadReviewer ( x )
}
2018-08-05 23:43:22 -05:00
func ( r * Review ) loadAttributes ( e Engine ) ( err error ) {
if err = r . loadReviewer ( e ) ; err != nil {
return
}
if err = r . loadIssue ( e ) ; err != nil {
return
}
return
}
// LoadAttributes loads all attributes except CodeComments
func ( r * Review ) LoadAttributes ( ) error {
return r . loadAttributes ( x )
}
func getReviewByID ( e Engine , id int64 ) ( * Review , error ) {
review := new ( Review )
if has , err := e . ID ( id ) . Get ( review ) ; err != nil {
return nil , err
} else if ! has {
return nil , ErrReviewNotExist { ID : id }
} else {
return review , nil
}
}
// GetReviewByID returns the review by the given ID
func GetReviewByID ( id int64 ) ( * Review , error ) {
return getReviewByID ( x , id )
}
// FindReviewOptions represent possible filters to find reviews
type FindReviewOptions struct {
Type ReviewType
IssueID int64
ReviewerID int64
}
func ( opts * FindReviewOptions ) toCond ( ) builder . Cond {
var cond = builder . NewCond ( )
if opts . IssueID > 0 {
cond = cond . And ( builder . Eq { "issue_id" : opts . IssueID } )
}
if opts . ReviewerID > 0 {
cond = cond . And ( builder . Eq { "reviewer_id" : opts . ReviewerID } )
}
if opts . Type != ReviewTypeUnknown {
cond = cond . And ( builder . Eq { "type" : opts . Type } )
}
return cond
}
func findReviews ( e Engine , opts FindReviewOptions ) ( [ ] * Review , error ) {
reviews := make ( [ ] * Review , 0 , 10 )
sess := e . Where ( opts . toCond ( ) )
return reviews , sess .
Asc ( "created_unix" ) .
Asc ( "id" ) .
Find ( & reviews )
}
// FindReviews returns reviews passing FindReviewOptions
func FindReviews ( opts FindReviewOptions ) ( [ ] * Review , error ) {
return findReviews ( x , opts )
}
// CreateReviewOptions represent the options to create a review. Type, Issue and Reviewer are required.
type CreateReviewOptions struct {
Content string
Type ReviewType
Issue * Issue
Reviewer * User
2019-12-03 20:08:56 -05:00
Official bool
}
// IsOfficialReviewer check if reviewer can make official reviews in issue (counts towards required approvals)
func IsOfficialReviewer ( issue * Issue , reviewer * User ) ( bool , error ) {
return isOfficialReviewer ( x , issue , reviewer )
}
func isOfficialReviewer ( e Engine , issue * Issue , reviewer * User ) ( bool , error ) {
pr , err := getPullRequestByIssueID ( e , issue . ID )
if err != nil {
return false , err
}
if err = pr . loadProtectedBranch ( e ) ; err != nil {
return false , err
}
if pr . ProtectedBranch == nil {
return false , nil
}
return pr . ProtectedBranch . isUserOfficialReviewer ( e , reviewer )
2018-08-05 23:43:22 -05:00
}
func createReview ( e Engine , opts CreateReviewOptions ) ( * Review , error ) {
review := & Review {
Type : opts . Type ,
Issue : opts . Issue ,
IssueID : opts . Issue . ID ,
Reviewer : opts . Reviewer ,
ReviewerID : opts . Reviewer . ID ,
Content : opts . Content ,
2019-12-03 20:08:56 -05:00
Official : opts . Official ,
2018-08-05 23:43:22 -05:00
}
if _ , err := e . Insert ( review ) ; err != nil {
return nil , err
}
2018-12-27 13:04:30 -05:00
2018-08-05 23:43:22 -05:00
return review , nil
}
// CreateReview creates a new review based on opts
func CreateReview ( opts CreateReviewOptions ) ( * Review , error ) {
return createReview ( x , opts )
}
func getCurrentReview ( e Engine , reviewer * User , issue * Issue ) ( * Review , error ) {
if reviewer == nil {
return nil , nil
}
reviews , err := findReviews ( e , FindReviewOptions {
Type : ReviewTypePending ,
IssueID : issue . ID ,
ReviewerID : reviewer . ID ,
} )
if err != nil {
return nil , err
}
if len ( reviews ) == 0 {
return nil , ErrReviewNotExist { }
}
2018-10-18 06:23:05 -05:00
reviews [ 0 ] . Reviewer = reviewer
reviews [ 0 ] . Issue = issue
2018-08-05 23:43:22 -05:00
return reviews [ 0 ] , nil
}
2019-11-24 00:46:16 -05:00
// ReviewExists returns whether a review exists for a particular line of code in the PR
func ReviewExists ( issue * Issue , treePath string , line int64 ) ( bool , error ) {
return x . Cols ( "id" ) . Exist ( & Comment { IssueID : issue . ID , TreePath : treePath , Line : line , Type : CommentTypeCode } )
}
2018-08-05 23:43:22 -05:00
// GetCurrentReview returns the current pending review of reviewer for given issue
func GetCurrentReview ( reviewer * User , issue * Issue ) ( * Review , error ) {
return getCurrentReview ( x , reviewer , issue )
}
2019-11-13 21:57:36 -05:00
// ContentEmptyErr represents an content empty error
type ContentEmptyErr struct {
}
func ( ContentEmptyErr ) Error ( ) string {
return "Review content is empty"
}
// IsContentEmptyErr returns true if err is a ContentEmptyErr
func IsContentEmptyErr ( err error ) bool {
_ , ok := err . ( ContentEmptyErr )
return ok
}
// SubmitReview creates a review out of the existing pending review or creates a new one if no pending review exist
func SubmitReview ( doer * User , issue * Issue , reviewType ReviewType , content string ) ( * Review , * Comment , error ) {
sess := x . NewSession ( )
defer sess . Close ( )
if err := sess . Begin ( ) ; err != nil {
return nil , nil , err
}
2019-12-03 20:08:56 -05:00
var official = false
2019-11-13 21:57:36 -05:00
review , err := getCurrentReview ( sess , doer , issue )
if err != nil {
if ! IsErrReviewNotExist ( err ) {
return nil , nil , err
}
2019-11-14 15:58:01 -05:00
if reviewType != ReviewTypeApprove && len ( strings . TrimSpace ( content ) ) == 0 {
2019-11-13 21:57:36 -05:00
return nil , nil , ContentEmptyErr { }
}
2019-12-03 20:08:56 -05:00
if reviewType == ReviewTypeApprove || reviewType == ReviewTypeReject {
// Only reviewers latest review of type approve and reject shall count as "official", so existing reviews needs to be cleared
if _ , err := sess . Exec ( "UPDATE `review` SET official=? WHERE issue_id=? AND reviewer_id=?" , false , issue . ID , doer . ID ) ; err != nil {
return nil , nil , err
}
official , err = isOfficialReviewer ( sess , issue , doer )
if err != nil {
return nil , nil , err
}
}
2019-11-13 21:57:36 -05:00
// No current review. Create a new one!
review , err = createReview ( sess , CreateReviewOptions {
Type : reviewType ,
Issue : issue ,
Reviewer : doer ,
Content : content ,
2019-12-03 20:08:56 -05:00
Official : official ,
2019-11-13 21:57:36 -05:00
} )
if err != nil {
return nil , nil , err
}
} else {
if err := review . loadCodeComments ( sess ) ; err != nil {
return nil , nil , err
}
2019-11-14 15:58:01 -05:00
if reviewType != ReviewTypeApprove && len ( review . CodeComments ) == 0 && len ( strings . TrimSpace ( content ) ) == 0 {
2019-11-13 21:57:36 -05:00
return nil , nil , ContentEmptyErr { }
}
2019-12-03 20:08:56 -05:00
if reviewType == ReviewTypeApprove || reviewType == ReviewTypeReject {
// Only reviewers latest review of type approve and reject shall count as "official", so existing reviews needs to be cleared
if _ , err := sess . Exec ( "UPDATE `review` SET official=? WHERE issue_id=? AND reviewer_id=?" , false , issue . ID , doer . ID ) ; err != nil {
return nil , nil , err
}
official , err = isOfficialReviewer ( sess , issue , doer )
if err != nil {
return nil , nil , err
}
}
review . Official = official
2019-11-13 21:57:36 -05:00
review . Issue = issue
review . Content = content
review . Type = reviewType
2019-12-03 20:08:56 -05:00
if _ , err := sess . ID ( review . ID ) . Cols ( "content, type, official" ) . Update ( review ) ; err != nil {
2019-11-13 21:57:36 -05:00
return nil , nil , err
}
2018-08-05 23:43:22 -05:00
}
2019-11-13 21:57:36 -05:00
2019-11-30 21:44:39 -05:00
comm , err := createCommentWithNoAction ( sess , & CreateCommentOptions {
2019-11-13 21:57:36 -05:00
Type : CommentTypeReview ,
Doer : doer ,
Content : review . Content ,
Issue : issue ,
Repo : issue . Repo ,
ReviewID : review . ID ,
} )
if err != nil || comm == nil {
return nil , nil , err
}
comm . Review = review
return review , comm , sess . Commit ( )
2018-08-05 23:43:22 -05:00
}
2018-11-22 08:17:36 -05:00
2019-12-03 20:08:56 -05:00
// GetReviewersByIssueID gets the latest review of each reviewer for a pull request
func GetReviewersByIssueID ( issueID int64 ) ( reviews [ ] * Review , err error ) {
reviewsUnfiltered := [ ] * Review { }
2018-11-22 08:17:36 -05:00
2019-12-03 20:08:56 -05:00
sess := x . NewSession ( )
defer sess . Close ( )
if err := sess . Begin ( ) ; err != nil {
return nil , err
2018-12-10 20:09:46 -05:00
}
2018-11-22 08:17:36 -05:00
2019-12-03 20:08:56 -05:00
// Get latest review of each reviwer, sorted in order they were made
if err := sess . SQL ( "SELECT * FROM review WHERE id IN (SELECT max(id) as id FROM review WHERE issue_id = ? AND type in (?, ?) GROUP BY issue_id, reviewer_id) ORDER BY review.updated_unix ASC" ,
issueID , ReviewTypeApprove , ReviewTypeReject ) .
Find ( & reviewsUnfiltered ) ; err != nil {
return nil , err
}
// Load reviewer and skip if user is deleted
for _ , review := range reviewsUnfiltered {
if err := review . loadReviewer ( sess ) ; err != nil {
if ! IsErrUserNotExist ( err ) {
return nil , err
}
} else {
reviews = append ( reviews , review )
2018-11-22 08:17:36 -05:00
}
}
2019-12-03 20:08:56 -05:00
return reviews , nil
2018-11-22 08:17:36 -05:00
}