2017-02-09 01:39:26 -05:00
// Copyright 2017 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 (
2021-11-19 08:39:57 -05:00
"context"
2018-05-16 10:01:55 -04:00
"fmt"
2020-01-27 11:23:21 -05:00
"strings"
2020-09-05 13:38:54 -04:00
"time"
2018-05-16 10:01:55 -04:00
2021-09-19 07:49:59 -04:00
"code.gitea.io/gitea/models/db"
2017-02-09 01:39:26 -05:00
"code.gitea.io/gitea/modules/setting"
2019-05-11 06:21:34 -04:00
api "code.gitea.io/gitea/modules/structs"
2019-08-15 10:46:21 -04:00
"code.gitea.io/gitea/modules/timeutil"
2019-12-27 15:30:58 -05:00
"xorm.io/builder"
2017-02-09 01:39:26 -05:00
)
// Milestone represents a milestone of repository.
type Milestone struct {
2019-12-15 09:20:08 -05:00
ID int64 ` xorm:"pk autoincr" `
RepoID int64 ` xorm:"INDEX" `
Repo * Repository ` xorm:"-" `
2017-02-09 01:39:26 -05:00
Name string
Content string ` xorm:"TEXT" `
RenderedContent string ` xorm:"-" `
IsClosed bool
NumIssues int
NumClosedIssues int
NumOpenIssues int ` xorm:"-" `
Completeness int // Percentage(1-100).
2018-05-07 05:50:27 -04:00
IsOverdue bool ` xorm:"-" `
2017-02-09 01:39:26 -05:00
2020-09-05 13:38:54 -04:00
CreatedUnix timeutil . TimeStamp ` xorm:"INDEX created" `
UpdatedUnix timeutil . TimeStamp ` xorm:"INDEX updated" `
2019-08-15 10:46:21 -04:00
DeadlineUnix timeutil . TimeStamp
ClosedDateUnix timeutil . TimeStamp
2020-09-05 13:38:54 -04:00
DeadlineString string ` xorm:"-" `
2018-04-29 01:58:47 -04:00
TotalTrackedTime int64 ` xorm:"-" `
2020-09-05 13:38:54 -04:00
TimeSinceUpdate int64 ` xorm:"-" `
2017-02-09 01:39:26 -05:00
}
2021-09-19 07:49:59 -04:00
func init ( ) {
db . RegisterModel ( new ( Milestone ) )
}
2017-02-09 01:39:26 -05:00
// BeforeUpdate is invoked from XORM before updating this object.
func ( m * Milestone ) BeforeUpdate ( ) {
if m . NumIssues > 0 {
m . Completeness = m . NumClosedIssues * 100 / m . NumIssues
} else {
m . Completeness = 0
}
}
2017-10-01 12:52:35 -04:00
// AfterLoad is invoked from XORM after setting the value of a field of
2017-02-09 01:39:26 -05:00
// this object.
2017-10-01 12:52:35 -04:00
func ( m * Milestone ) AfterLoad ( ) {
2020-09-05 13:38:54 -04:00
if ! m . UpdatedUnix . IsZero ( ) {
m . TimeSinceUpdate = time . Now ( ) . Unix ( ) - m . UpdatedUnix . AsTime ( ) . Unix ( )
}
2017-10-01 12:52:35 -04:00
m . NumOpenIssues = m . NumIssues - m . NumClosedIssues
2017-12-10 23:37:04 -05:00
if m . DeadlineUnix . Year ( ) == 9999 {
2017-10-01 12:52:35 -04:00
return
}
2017-02-09 01:39:26 -05:00
2017-12-10 23:37:04 -05:00
m . DeadlineString = m . DeadlineUnix . Format ( "2006-01-02" )
2021-03-07 20:55:57 -05:00
if m . IsClosed {
m . IsOverdue = m . ClosedDateUnix >= m . DeadlineUnix
} else {
m . IsOverdue = timeutil . TimeStampNow ( ) >= m . DeadlineUnix
2017-02-09 01:39:26 -05:00
}
}
// State returns string representation of milestone status.
func ( m * Milestone ) State ( ) api . StateType {
if m . IsClosed {
return api . StateClosed
}
return api . StateOpen
}
// NewMilestone creates new milestone of repository.
func NewMilestone ( m * Milestone ) ( err error ) {
2021-09-23 11:45:36 -04:00
sess := db . NewSession ( db . DefaultContext )
2017-06-20 20:57:05 -04:00
defer sess . Close ( )
2017-02-09 01:39:26 -05:00
if err = sess . Begin ( ) ; err != nil {
return err
}
2020-01-27 11:23:21 -05:00
m . Name = strings . TrimSpace ( m . Name )
2017-02-09 01:39:26 -05:00
if _ , err = sess . Insert ( m ) ; err != nil {
return err
}
if _ , err = sess . Exec ( "UPDATE `repository` SET num_milestones = num_milestones + 1 WHERE id = ?" , m . RepoID ) ; err != nil {
return err
}
return sess . Commit ( )
}
2021-09-19 07:49:59 -04:00
func getMilestoneByRepoID ( e db . Engine , repoID , id int64 ) ( * Milestone , error ) {
2020-04-30 00:15:39 -04:00
m := new ( Milestone )
has , err := e . ID ( id ) . Where ( "repo_id=?" , repoID ) . Get ( m )
2017-02-09 01:39:26 -05:00
if err != nil {
return nil , err
} else if ! has {
2020-04-30 00:15:39 -04:00
return nil , ErrMilestoneNotExist { ID : id , RepoID : repoID }
2017-02-09 01:39:26 -05:00
}
return m , nil
}
// GetMilestoneByRepoID returns the milestone in a repository.
func GetMilestoneByRepoID ( repoID , id int64 ) ( * Milestone , error ) {
2021-09-23 11:45:36 -04:00
return getMilestoneByRepoID ( db . GetEngine ( db . DefaultContext ) , repoID , id )
2017-02-09 01:39:26 -05:00
}
2020-04-30 00:15:39 -04:00
// GetMilestoneByRepoIDANDName return a milestone if one exist by name and repo
func GetMilestoneByRepoIDANDName ( repoID int64 , name string ) ( * Milestone , error ) {
var mile Milestone
2021-09-23 11:45:36 -04:00
has , err := db . GetEngine ( db . DefaultContext ) . Where ( "repo_id=? AND name=?" , repoID , name ) . Get ( & mile )
2020-04-30 00:15:39 -04:00
if err != nil {
return nil , err
}
if ! has {
return nil , ErrMilestoneNotExist { Name : name , RepoID : repoID }
}
return & mile , nil
}
2018-11-28 20:46:30 -05:00
// GetMilestoneByID returns the milestone via id .
func GetMilestoneByID ( id int64 ) ( * Milestone , error ) {
2021-09-23 11:45:36 -04:00
return getMilestoneByID ( db . GetEngine ( db . DefaultContext ) , id )
2021-06-21 14:34:58 -04:00
}
2021-09-19 07:49:59 -04:00
func getMilestoneByID ( e db . Engine , id int64 ) ( * Milestone , error ) {
2018-11-28 20:46:30 -05:00
var m Milestone
2021-06-21 14:34:58 -04:00
has , err := e . ID ( id ) . Get ( & m )
2018-11-28 20:46:30 -05:00
if err != nil {
return nil , err
} else if ! has {
2020-04-30 00:15:39 -04:00
return nil , ErrMilestoneNotExist { ID : id , RepoID : 0 }
2018-11-28 20:46:30 -05:00
}
return & m , nil
}
2017-02-09 01:39:26 -05:00
// UpdateMilestone updates information of given milestone.
2020-01-29 01:36:32 -05:00
func UpdateMilestone ( m * Milestone , oldIsClosed bool ) error {
2021-09-23 11:45:36 -04:00
sess := db . NewSession ( db . DefaultContext )
2020-01-29 01:36:32 -05:00
defer sess . Close ( )
if err := sess . Begin ( ) ; err != nil {
return err
}
if m . IsClosed && ! oldIsClosed {
m . ClosedDateUnix = timeutil . TimeStampNow ( )
}
if err := updateMilestone ( sess , m ) ; err != nil {
2019-10-07 17:44:58 -04:00
return err
}
2020-01-29 01:36:32 -05:00
// if IsClosed changed, update milestone numbers of repository
if oldIsClosed != m . IsClosed {
if err := updateRepoMilestoneNum ( sess , m . RepoID ) ; err != nil {
return err
}
}
return sess . Commit ( )
2019-10-07 17:44:58 -04:00
}
2021-09-19 07:49:59 -04:00
func updateMilestone ( e db . Engine , m * Milestone ) error {
2020-05-12 17:54:35 -04:00
m . Name = strings . TrimSpace ( m . Name )
2021-06-21 14:34:58 -04:00
_ , err := e . ID ( m . ID ) . AllCols ( ) . Update ( m )
if err != nil {
return err
}
return updateMilestoneCounters ( e , m . ID )
}
// updateMilestoneCounters calculates NumIssues, NumClosesIssues and Completeness
2021-09-19 07:49:59 -04:00
func updateMilestoneCounters ( e db . Engine , id int64 ) error {
2021-06-21 14:34:58 -04:00
_ , err := e . ID ( id ) .
2020-05-12 17:54:35 -04:00
SetExpr ( "num_issues" , builder . Select ( "count(*)" ) . From ( "issue" ) . Where (
2021-06-21 14:34:58 -04:00
builder . Eq { "milestone_id" : id } ,
2020-05-12 17:54:35 -04:00
) ) .
SetExpr ( "num_closed_issues" , builder . Select ( "count(*)" ) . From ( "issue" ) . Where (
builder . Eq {
2021-06-21 14:34:58 -04:00
"milestone_id" : id ,
2020-05-12 17:54:35 -04:00
"is_closed" : true ,
} ,
) ) .
2021-06-21 14:34:58 -04:00
Update ( & Milestone { } )
if err != nil {
return err
}
_ , err = e . Exec ( "UPDATE `milestone` SET completeness=100*num_closed_issues/(CASE WHEN num_issues > 0 THEN num_issues ELSE 1 END) WHERE id=?" ,
id ,
2019-10-07 17:44:58 -04:00
)
return err
2017-02-09 01:39:26 -05:00
}
2020-08-16 23:07:38 -04:00
// ChangeMilestoneStatusByRepoIDAndID changes a milestone open/closed status if the milestone ID is in the repo.
func ChangeMilestoneStatusByRepoIDAndID ( repoID , milestoneID int64 , isClosed bool ) error {
2021-09-23 11:45:36 -04:00
sess := db . NewSession ( db . DefaultContext )
2020-08-16 23:07:38 -04:00
defer sess . Close ( )
if err := sess . Begin ( ) ; err != nil {
return err
}
m := & Milestone {
ID : milestoneID ,
RepoID : repoID ,
}
has , err := sess . ID ( milestoneID ) . Where ( "repo_id = ?" , repoID ) . Get ( m )
if err != nil {
return err
} else if ! has {
return ErrMilestoneNotExist { ID : milestoneID , RepoID : repoID }
}
if err := changeMilestoneStatus ( sess , m , isClosed ) ; err != nil {
return err
}
return sess . Commit ( )
}
2017-02-09 01:39:26 -05:00
// ChangeMilestoneStatus changes the milestone open/closed status.
func ChangeMilestoneStatus ( m * Milestone , isClosed bool ) ( err error ) {
2021-09-23 11:45:36 -04:00
sess := db . NewSession ( db . DefaultContext )
2017-06-20 20:57:05 -04:00
defer sess . Close ( )
2017-02-09 01:39:26 -05:00
if err = sess . Begin ( ) ; err != nil {
return err
}
2020-08-16 23:07:38 -04:00
if err := changeMilestoneStatus ( sess , m , isClosed ) ; err != nil {
return err
}
return sess . Commit ( )
}
2021-09-19 07:49:59 -04:00
func changeMilestoneStatus ( e db . Engine , m * Milestone , isClosed bool ) error {
2017-02-09 01:39:26 -05:00
m . IsClosed = isClosed
2019-10-28 22:35:50 -04:00
if isClosed {
m . ClosedDateUnix = timeutil . TimeStampNow ( )
}
2020-08-16 23:07:38 -04:00
count , err := e . ID ( m . ID ) . Where ( "repo_id = ? AND is_closed = ?" , m . RepoID , ! isClosed ) . Cols ( "is_closed" , "closed_date_unix" ) . Update ( m )
if err != nil {
2017-02-09 01:39:26 -05:00
return err
}
2020-08-16 23:07:38 -04:00
if count < 1 {
return nil
2017-12-18 09:06:51 -05:00
}
2020-08-16 23:07:38 -04:00
return updateRepoMilestoneNum ( e , m . RepoID )
2017-02-09 01:39:26 -05:00
}
2021-11-19 08:39:57 -05:00
func changeMilestoneAssign ( ctx context . Context , doer * User , issue * Issue , oldMilestoneID int64 ) error {
e := db . GetEngine ( ctx )
2019-10-06 17:26:19 -04:00
if err := updateIssueCols ( e , issue , "milestone_id" ) ; err != nil {
return err
}
2017-02-09 01:39:26 -05:00
if oldMilestoneID > 0 {
2021-06-21 14:34:58 -04:00
if err := updateMilestoneCounters ( e , oldMilestoneID ) ; err != nil {
2017-02-09 01:39:26 -05:00
return err
}
}
if issue . MilestoneID > 0 {
2021-06-21 14:34:58 -04:00
if err := updateMilestoneCounters ( e , issue . MilestoneID ) ; err != nil {
2017-02-09 01:39:26 -05:00
return err
}
2019-10-06 17:26:19 -04:00
}
2017-02-09 01:39:26 -05:00
2019-10-06 17:26:19 -04:00
if oldMilestoneID > 0 || issue . MilestoneID > 0 {
if err := issue . loadRepo ( e ) ; err != nil {
2017-02-09 01:39:26 -05:00
return err
}
2021-03-14 14:52:12 -04:00
opts := & CreateCommentOptions {
2019-11-30 21:44:39 -05:00
Type : CommentTypeMilestone ,
Doer : doer ,
Repo : issue . Repo ,
Issue : issue ,
OldMilestoneID : oldMilestoneID ,
MilestoneID : issue . MilestoneID ,
}
2021-11-19 08:39:57 -05:00
if _ , err := createComment ( ctx , opts ) ; err != nil {
2017-02-09 01:39:26 -05:00
return err
}
}
2019-10-06 17:26:19 -04:00
return nil
2017-02-09 01:39:26 -05:00
}
// ChangeMilestoneAssign changes assignment of milestone for issue.
func ChangeMilestoneAssign ( issue * Issue , doer * User , oldMilestoneID int64 ) ( err error ) {
2021-11-19 08:39:57 -05:00
ctx , committer , err := db . TxContext ( )
if err != nil {
2017-02-09 01:39:26 -05:00
return err
}
2021-11-19 08:39:57 -05:00
defer committer . Close ( )
2017-02-09 01:39:26 -05:00
2021-11-19 08:39:57 -05:00
if err = changeMilestoneAssign ( ctx , doer , issue , oldMilestoneID ) ; err != nil {
2017-02-09 01:39:26 -05:00
return err
}
2018-05-16 10:01:55 -04:00
2021-11-19 08:39:57 -05:00
if err = committer . Commit ( ) ; err != nil {
2018-05-16 10:01:55 -04:00
return fmt . Errorf ( "Commit: %v" , err )
}
return nil
2017-02-09 01:39:26 -05:00
}
// DeleteMilestoneByRepoID deletes a milestone from a repository.
func DeleteMilestoneByRepoID ( repoID , id int64 ) error {
m , err := GetMilestoneByRepoID ( repoID , id )
if err != nil {
if IsErrMilestoneNotExist ( err ) {
return nil
}
return err
}
repo , err := GetRepositoryByID ( m . RepoID )
if err != nil {
return err
}
2021-09-23 11:45:36 -04:00
sess := db . NewSession ( db . DefaultContext )
2017-06-20 20:57:05 -04:00
defer sess . Close ( )
2017-02-09 01:39:26 -05:00
if err = sess . Begin ( ) ; err != nil {
return err
}
2017-10-05 00:43:04 -04:00
if _ , err = sess . ID ( m . ID ) . Delete ( new ( Milestone ) ) ; err != nil {
2017-02-09 01:39:26 -05:00
return err
}
2017-12-18 09:06:51 -05:00
numMilestones , err := countRepoMilestones ( sess , repo . ID )
if err != nil {
return err
}
numClosedMilestones , err := countRepoClosedMilestones ( sess , repo . ID )
if err != nil {
return err
}
repo . NumMilestones = int ( numMilestones )
repo . NumClosedMilestones = int ( numClosedMilestones )
2017-10-05 00:43:04 -04:00
if _ , err = sess . ID ( repo . ID ) . Cols ( "num_milestones, num_closed_milestones" ) . Update ( repo ) ; err != nil {
2017-02-09 01:39:26 -05:00
return err
}
if _ , err = sess . Exec ( "UPDATE `issue` SET milestone_id = 0 WHERE milestone_id = ?" , m . ID ) ; err != nil {
return err
}
return sess . Commit ( )
}
2019-12-15 09:20:08 -05:00
2020-05-12 17:54:35 -04:00
// MilestoneList is a list of milestones offering additional functionality
type MilestoneList [ ] * Milestone
func ( milestones MilestoneList ) getMilestoneIDs ( ) [ ] int64 {
2021-03-14 14:52:12 -04:00
ids := make ( [ ] int64 , 0 , len ( milestones ) )
2020-05-12 17:54:35 -04:00
for _ , ms := range milestones {
ids = append ( ids , ms . ID )
2020-03-31 03:47:00 -04:00
}
2020-05-12 17:54:35 -04:00
return ids
}
2019-12-15 09:20:08 -05:00
2020-07-28 07:30:40 -04:00
// GetMilestonesOption contain options to get milestones
type GetMilestonesOption struct {
2021-09-24 07:32:56 -04:00
db . ListOptions
2020-07-28 07:30:40 -04:00
RepoID int64
State api . StateType
Name string
SortType string
}
2021-08-12 08:43:08 -04:00
func ( opts GetMilestonesOption ) toCond ( ) builder . Cond {
cond := builder . NewCond ( )
if opts . RepoID != 0 {
cond = cond . And ( builder . Eq { "repo_id" : opts . RepoID } )
}
2020-05-12 17:54:35 -04:00
2020-07-28 07:30:40 -04:00
switch opts . State {
2020-05-12 17:54:35 -04:00
case api . StateClosed :
2021-08-12 08:43:08 -04:00
cond = cond . And ( builder . Eq { "is_closed" : true } )
2020-05-12 17:54:35 -04:00
case api . StateAll :
break
2020-07-28 07:30:40 -04:00
// api.StateOpen:
2020-05-12 17:54:35 -04:00
default :
2021-08-12 08:43:08 -04:00
cond = cond . And ( builder . Eq { "is_closed" : false } )
2019-12-15 09:20:08 -05:00
}
2020-07-28 07:30:40 -04:00
if len ( opts . Name ) != 0 {
2021-08-12 08:43:08 -04:00
cond = cond . And ( builder . Like { "name" , opts . Name } )
2019-12-15 09:20:08 -05:00
}
2020-05-12 17:54:35 -04:00
2021-08-12 08:43:08 -04:00
return cond
}
// GetMilestones returns milestones filtered by GetMilestonesOption's
func GetMilestones ( opts GetMilestonesOption ) ( MilestoneList , int64 , error ) {
2021-09-23 11:45:36 -04:00
sess := db . GetEngine ( db . DefaultContext ) . Where ( opts . toCond ( ) )
2021-08-12 08:43:08 -04:00
2020-07-28 07:30:40 -04:00
if opts . Page != 0 {
2021-09-24 07:32:56 -04:00
sess = db . SetSessionPagination ( sess , & opts )
2020-05-12 17:54:35 -04:00
}
2020-07-28 07:30:40 -04:00
switch opts . SortType {
2020-05-12 17:54:35 -04:00
case "furthestduedate" :
sess . Desc ( "deadline_unix" )
case "leastcomplete" :
sess . Asc ( "completeness" )
case "mostcomplete" :
sess . Desc ( "completeness" )
case "leastissues" :
sess . Asc ( "num_issues" )
case "mostissues" :
sess . Desc ( "num_issues" )
2020-07-28 07:30:40 -04:00
case "id" :
sess . Asc ( "id" )
2020-05-12 17:54:35 -04:00
default :
2020-07-28 07:30:40 -04:00
sess . Asc ( "deadline_unix" ) . Asc ( "id" )
2020-05-12 17:54:35 -04:00
}
2020-07-28 07:30:40 -04:00
miles := make ( [ ] * Milestone , 0 , opts . PageSize )
2021-08-12 08:43:08 -04:00
total , err := sess . FindAndCount ( & miles )
return miles , total , err
2020-03-31 03:47:00 -04:00
}
// SearchMilestones search milestones
2021-04-08 07:53:59 -04:00
func SearchMilestones ( repoCond builder . Cond , page int , isClosed bool , sortType string , keyword string ) ( MilestoneList , error ) {
2019-12-15 09:20:08 -05:00
miles := make ( [ ] * Milestone , 0 , setting . UI . IssuePagingNum )
2021-09-23 11:45:36 -04:00
sess := db . GetEngine ( db . DefaultContext ) . Where ( "is_closed = ?" , isClosed )
2021-04-08 07:53:59 -04:00
if len ( keyword ) > 0 {
sess = sess . And ( builder . Like { "UPPER(name)" , strings . ToUpper ( keyword ) } )
}
2020-03-31 03:47:00 -04:00
if repoCond . IsValid ( ) {
sess . In ( "repo_id" , builder . Select ( "id" ) . From ( "repository" ) . Where ( repoCond ) )
}
2019-12-15 09:20:08 -05:00
if page > 0 {
sess = sess . Limit ( setting . UI . IssuePagingNum , ( page - 1 ) * setting . UI . IssuePagingNum )
}
switch sortType {
case "furthestduedate" :
sess . Desc ( "deadline_unix" )
case "leastcomplete" :
sess . Asc ( "completeness" )
case "mostcomplete" :
sess . Desc ( "completeness" )
case "leastissues" :
sess . Asc ( "num_issues" )
case "mostissues" :
sess . Desc ( "num_issues" )
default :
sess . Asc ( "deadline_unix" )
}
return miles , sess . Find ( & miles )
}
2020-03-31 03:47:00 -04:00
// GetMilestonesByRepoIDs returns a list of milestones of given repositories and status.
func GetMilestonesByRepoIDs ( repoIDs [ ] int64 , page int , isClosed bool , sortType string ) ( MilestoneList , error ) {
return SearchMilestones (
builder . In ( "repo_id" , repoIDs ) ,
page ,
isClosed ,
sortType ,
2021-04-08 07:53:59 -04:00
"" ,
2020-03-31 03:47:00 -04:00
)
}
2020-05-12 17:54:35 -04:00
// ____ _ _
// / ___|| |_ __ _| |_ ___
// \___ \| __/ _` | __/ __|
// ___) | || (_| | |_\__ \
// |____/ \__\__,_|\__|___/
//
2019-12-15 09:20:08 -05:00
// MilestonesStats represents milestone statistic information.
type MilestonesStats struct {
OpenCount , ClosedCount int64
}
2020-03-31 03:47:00 -04:00
// Total returns the total counts of milestones
func ( m MilestonesStats ) Total ( ) int64 {
return m . OpenCount + m . ClosedCount
}
2020-05-12 17:54:35 -04:00
// GetMilestonesStatsByRepoCond returns milestone statistic information for dashboard by given conditions.
func GetMilestonesStatsByRepoCond ( repoCond builder . Cond ) ( * MilestonesStats , error ) {
2019-12-15 09:20:08 -05:00
var err error
stats := & MilestonesStats { }
2021-09-23 11:45:36 -04:00
sess := db . GetEngine ( db . DefaultContext ) . Where ( "is_closed = ?" , false )
2020-03-31 03:47:00 -04:00
if repoCond . IsValid ( ) {
sess . And ( builder . In ( "repo_id" , builder . Select ( "id" ) . From ( "repository" ) . Where ( repoCond ) ) )
}
stats . OpenCount , err = sess . Count ( new ( Milestone ) )
2019-12-15 09:20:08 -05:00
if err != nil {
return nil , err
}
2020-03-31 03:47:00 -04:00
2021-09-23 11:45:36 -04:00
sess = db . GetEngine ( db . DefaultContext ) . Where ( "is_closed = ?" , true )
2020-03-31 03:47:00 -04:00
if repoCond . IsValid ( ) {
sess . And ( builder . In ( "repo_id" , builder . Select ( "id" ) . From ( "repository" ) . Where ( repoCond ) ) )
}
stats . ClosedCount , err = sess . Count ( new ( Milestone ) )
2019-12-15 09:20:08 -05:00
if err != nil {
return nil , err
}
return stats , nil
}
2020-05-12 17:54:35 -04:00
2021-04-08 07:53:59 -04:00
// GetMilestonesStatsByRepoCondAndKw returns milestone statistic information for dashboard by given repo conditions and name keyword.
func GetMilestonesStatsByRepoCondAndKw ( repoCond builder . Cond , keyword string ) ( * MilestonesStats , error ) {
var err error
stats := & MilestonesStats { }
2021-09-23 11:45:36 -04:00
sess := db . GetEngine ( db . DefaultContext ) . Where ( "is_closed = ?" , false )
2021-04-08 07:53:59 -04:00
if len ( keyword ) > 0 {
sess = sess . And ( builder . Like { "UPPER(name)" , strings . ToUpper ( keyword ) } )
}
if repoCond . IsValid ( ) {
sess . And ( builder . In ( "repo_id" , builder . Select ( "id" ) . From ( "repository" ) . Where ( repoCond ) ) )
}
stats . OpenCount , err = sess . Count ( new ( Milestone ) )
if err != nil {
return nil , err
}
2021-09-23 11:45:36 -04:00
sess = db . GetEngine ( db . DefaultContext ) . Where ( "is_closed = ?" , true )
2021-04-08 07:53:59 -04:00
if len ( keyword ) > 0 {
sess = sess . And ( builder . Like { "UPPER(name)" , strings . ToUpper ( keyword ) } )
}
if repoCond . IsValid ( ) {
sess . And ( builder . In ( "repo_id" , builder . Select ( "id" ) . From ( "repository" ) . Where ( repoCond ) ) )
}
stats . ClosedCount , err = sess . Count ( new ( Milestone ) )
if err != nil {
return nil , err
}
return stats , nil
}
2021-09-19 07:49:59 -04:00
func countRepoMilestones ( e db . Engine , repoID int64 ) ( int64 , error ) {
2020-05-12 17:54:35 -04:00
return e .
Where ( "repo_id=?" , repoID ) .
Count ( new ( Milestone ) )
}
2021-09-19 07:49:59 -04:00
func countRepoClosedMilestones ( e db . Engine , repoID int64 ) ( int64 , error ) {
2020-05-12 17:54:35 -04:00
return e .
Where ( "repo_id=? AND is_closed=?" , repoID , true ) .
Count ( new ( Milestone ) )
}
// CountRepoClosedMilestones returns number of closed milestones in given repository.
func CountRepoClosedMilestones ( repoID int64 ) ( int64 , error ) {
2021-09-23 11:45:36 -04:00
return countRepoClosedMilestones ( db . GetEngine ( db . DefaultContext ) , repoID )
2020-05-12 17:54:35 -04:00
}
// CountMilestonesByRepoCond map from repo conditions to number of milestones matching the options`
func CountMilestonesByRepoCond ( repoCond builder . Cond , isClosed bool ) ( map [ int64 ] int64 , error ) {
2021-09-23 11:45:36 -04:00
sess := db . GetEngine ( db . DefaultContext ) . Where ( "is_closed = ?" , isClosed )
2020-05-12 17:54:35 -04:00
if repoCond . IsValid ( ) {
sess . In ( "repo_id" , builder . Select ( "id" ) . From ( "repository" ) . Where ( repoCond ) )
}
countsSlice := make ( [ ] * struct {
RepoID int64
Count int64
} , 0 , 10 )
if err := sess . GroupBy ( "repo_id" ) .
Select ( "repo_id AS repo_id, COUNT(*) AS count" ) .
Table ( "milestone" ) .
Find ( & countsSlice ) ; err != nil {
return nil , err
}
countMap := make ( map [ int64 ] int64 , len ( countsSlice ) )
for _ , c := range countsSlice {
countMap [ c . RepoID ] = c . Count
}
return countMap , nil
}
2021-04-08 07:53:59 -04:00
// CountMilestonesByRepoCondAndKw map from repo conditions and the keyword of milestones' name to number of milestones matching the options`
func CountMilestonesByRepoCondAndKw ( repoCond builder . Cond , keyword string , isClosed bool ) ( map [ int64 ] int64 , error ) {
2021-09-23 11:45:36 -04:00
sess := db . GetEngine ( db . DefaultContext ) . Where ( "is_closed = ?" , isClosed )
2021-04-08 07:53:59 -04:00
if len ( keyword ) > 0 {
sess = sess . And ( builder . Like { "UPPER(name)" , strings . ToUpper ( keyword ) } )
}
if repoCond . IsValid ( ) {
sess . In ( "repo_id" , builder . Select ( "id" ) . From ( "repository" ) . Where ( repoCond ) )
}
countsSlice := make ( [ ] * struct {
RepoID int64
Count int64
} , 0 , 10 )
if err := sess . GroupBy ( "repo_id" ) .
Select ( "repo_id AS repo_id, COUNT(*) AS count" ) .
Table ( "milestone" ) .
Find ( & countsSlice ) ; err != nil {
return nil , err
}
countMap := make ( map [ int64 ] int64 , len ( countsSlice ) )
for _ , c := range countsSlice {
countMap [ c . RepoID ] = c . Count
}
return countMap , nil
}
2021-09-19 07:49:59 -04:00
func updateRepoMilestoneNum ( e db . Engine , repoID int64 ) error {
2020-05-12 17:54:35 -04:00
_ , err := e . Exec ( "UPDATE `repository` SET num_milestones=(SELECT count(*) FROM milestone WHERE repo_id=?),num_closed_milestones=(SELECT count(*) FROM milestone WHERE repo_id=? AND is_closed=?) WHERE id=?" ,
repoID ,
repoID ,
true ,
repoID ,
)
return err
}
// _____ _ _ _____ _
// |_ _| __ __ _ ___| | _____ __| |_ _(_)_ __ ___ ___ ___
// | || '__/ _` |/ __| |/ / _ \/ _` | | | | | '_ ` _ \ / _ \/ __|
// | || | | (_| | (__| < __/ (_| | | | | | | | | | | __/\__ \
// |_||_| \__,_|\___|_|\_\___|\__,_| |_| |_|_| |_| |_|\___||___/
//
2021-09-19 07:49:59 -04:00
func ( milestones MilestoneList ) loadTotalTrackedTimes ( e db . Engine ) error {
2020-05-12 17:54:35 -04:00
type totalTimesByMilestone struct {
MilestoneID int64
Time int64
}
if len ( milestones ) == 0 {
return nil
}
2021-03-14 14:52:12 -04:00
trackedTimes := make ( map [ int64 ] int64 , len ( milestones ) )
2020-05-12 17:54:35 -04:00
// Get total tracked time by milestone_id
rows , err := e . Table ( "issue" ) .
Join ( "INNER" , "milestone" , "issue.milestone_id = milestone.id" ) .
Join ( "LEFT" , "tracked_time" , "tracked_time.issue_id = issue.id" ) .
Where ( "tracked_time.deleted = ?" , false ) .
Select ( "milestone_id, sum(time) as time" ) .
In ( "milestone_id" , milestones . getMilestoneIDs ( ) ) .
GroupBy ( "milestone_id" ) .
Rows ( new ( totalTimesByMilestone ) )
if err != nil {
return err
}
defer rows . Close ( )
for rows . Next ( ) {
var totalTime totalTimesByMilestone
err = rows . Scan ( & totalTime )
if err != nil {
return err
}
trackedTimes [ totalTime . MilestoneID ] = totalTime . Time
}
for _ , milestone := range milestones {
milestone . TotalTrackedTime = trackedTimes [ milestone . ID ]
}
return nil
}
2021-09-19 07:49:59 -04:00
func ( m * Milestone ) loadTotalTrackedTime ( e db . Engine ) error {
2020-05-12 17:54:35 -04:00
type totalTimesByMilestone struct {
MilestoneID int64
Time int64
}
totalTime := & totalTimesByMilestone { MilestoneID : m . ID }
has , err := e . Table ( "issue" ) .
Join ( "INNER" , "milestone" , "issue.milestone_id = milestone.id" ) .
Join ( "LEFT" , "tracked_time" , "tracked_time.issue_id = issue.id" ) .
Where ( "tracked_time.deleted = ?" , false ) .
Select ( "milestone_id, sum(time) as time" ) .
Where ( "milestone_id = ?" , m . ID ) .
GroupBy ( "milestone_id" ) .
Get ( totalTime )
if err != nil {
return err
} else if ! has {
return nil
}
m . TotalTrackedTime = totalTime . Time
return nil
}
// LoadTotalTrackedTimes loads for every milestone in the list the TotalTrackedTime by a batch request
func ( milestones MilestoneList ) LoadTotalTrackedTimes ( ) error {
2021-09-23 11:45:36 -04:00
return milestones . loadTotalTrackedTimes ( db . GetEngine ( db . DefaultContext ) )
2020-05-12 17:54:35 -04:00
}
// LoadTotalTrackedTime loads the tracked time for the milestone
func ( m * Milestone ) LoadTotalTrackedTime ( ) error {
2021-09-23 11:45:36 -04:00
return m . loadTotalTrackedTime ( db . GetEngine ( db . DefaultContext ) )
2020-05-12 17:54:35 -04:00
}