2014-02-14 18:16:54 -05:00
// Copyright 2014 The Gogs Authors. All rights reserved.
2017-08-26 08:57:41 -05:00
// Copyright 2017 The Gitea Authors. All rights reserved.
2014-02-14 18:16:54 -05:00
// Use of this source code is governed by a MIT-style
// license that can be found in the LICENSE file.
2014-02-14 09:20:57 -05:00
package models
import (
2019-12-15 04:51:28 -05:00
"context"
2014-03-10 19:48:58 -05:00
"fmt"
2019-04-22 15:40:51 -05:00
"strconv"
2014-02-14 09:20:57 -05:00
2021-11-17 07:34:35 -05:00
_ "image/jpeg" // Needed for jpeg support
2022-08-24 21:31:57 -05:00
activities_model "code.gitea.io/gitea/models/activities"
2021-11-18 00:58:42 -05:00
admin_model "code.gitea.io/gitea/models/admin"
2021-12-10 03:14:24 -05:00
asymkey_model "code.gitea.io/gitea/models/asymkey"
2021-09-19 06:49:59 -05:00
"code.gitea.io/gitea/models/db"
2022-06-12 10:51:54 -05:00
git_model "code.gitea.io/gitea/models/git"
2022-04-08 04:11:15 -05:00
issues_model "code.gitea.io/gitea/models/issues"
2022-03-29 01:29:02 -05:00
"code.gitea.io/gitea/models/organization"
2022-05-11 05:09:36 -05:00
access_model "code.gitea.io/gitea/models/perm/access"
2022-03-29 09:16:31 -05:00
project_model "code.gitea.io/gitea/models/project"
2021-11-19 08:39:57 -05:00
repo_model "code.gitea.io/gitea/models/repo"
2022-10-16 18:29:26 -05:00
system_model "code.gitea.io/gitea/models/system"
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-11-10 00:13:16 -05:00
"code.gitea.io/gitea/models/webhook"
2021-04-08 17:25:57 -05:00
"code.gitea.io/gitea/modules/lfs"
2016-11-10 11:24:48 -05:00
"code.gitea.io/gitea/modules/log"
2020-08-17 23:23:45 -05:00
"code.gitea.io/gitea/modules/storage"
2017-01-01 13:15:09 -05:00
2020-06-13 06:35:59 -05:00
"xorm.io/builder"
2014-02-14 09:20:57 -05:00
)
2022-10-16 18:29:26 -05:00
// ItemsPerPage maximum items per page in forks, watchers and stars of a repo
var ItemsPerPage = 40
// Init initialize model
func Init ( ) error {
2021-11-09 14:57:58 -05:00
unit . LoadUnitConfig ( )
2022-10-16 18:29:26 -05:00
return system_model . Init ( )
2014-03-11 00:32:36 -05:00
}
2014-12-06 20:22:48 -05:00
// DeleteRepository deletes a repository for a user or organization.
2021-01-18 15:00:50 -05:00
// make sure if you call this func to close open sessions (sqlite will otherwise get a deadlock)
2021-11-24 04:49:20 -05:00
func DeleteRepository ( doer * user_model . User , uid , repoID int64 ) error {
2021-11-21 10:41:00 -05:00
ctx , committer , err := db . TxContext ( )
if err != nil {
2021-01-18 15:00:50 -05:00
return err
}
2021-11-21 10:41:00 -05:00
defer committer . Close ( )
sess := db . GetEngine ( ctx )
2021-01-18 15:00:50 -05:00
2014-08-27 03:39:36 -05:00
// In case is a organization.
2022-05-20 09:08:52 -05:00
org , err := user_model . GetUserByIDCtx ( ctx , uid )
2014-08-27 03:39:36 -05:00
if err != nil {
return err
}
2021-12-09 20:27:50 -05:00
repo := & repo_model . Repository { OwnerID : uid }
2021-01-18 15:00:50 -05:00
has , err := sess . ID ( repoID ) . Get ( repo )
2017-02-28 23:05:45 -05:00
if err != nil {
return err
} else if ! has {
2021-12-09 20:27:50 -05:00
return repo_model . ErrRepoNotExist {
ID : repoID ,
UID : uid ,
OwnerName : "" ,
Name : "" ,
}
2017-02-28 23:05:45 -05:00
}
2019-02-03 18:56:53 -05:00
// Delete Deploy Keys
2021-12-10 03:14:24 -05:00
deployKeys , err := asymkey_model . ListDeployKeys ( ctx , & asymkey_model . ListDeployKeysOptions { RepoID : repoID } )
2019-02-03 18:56:53 -05:00
if err != nil {
return fmt . Errorf ( "listDeployKeys: %v" , err )
}
2022-01-20 12:46:10 -05:00
needRewriteKeysFile := len ( deployKeys ) > 0
2019-02-03 18:56:53 -05:00
for _ , dKey := range deployKeys {
2021-12-10 03:14:24 -05:00
if err := DeleteDeployKey ( ctx , doer , dKey . ID ) ; err != nil {
2019-02-03 18:56:53 -05:00
return fmt . Errorf ( "deleteDeployKeys: %v" , err )
}
}
2021-12-09 20:27:50 -05:00
if cnt , err := sess . ID ( repoID ) . Delete ( & repo_model . Repository { } ) ; err != nil {
2017-02-28 23:05:45 -05:00
return err
} else if cnt != 1 {
2021-12-09 20:27:50 -05:00
return repo_model . ErrRepoNotExist {
ID : repoID ,
UID : uid ,
OwnerName : "" ,
Name : "" ,
}
2017-02-28 23:05:45 -05:00
}
2014-08-27 03:39:36 -05:00
if org . IsOrganization ( ) {
2022-03-29 01:29:02 -05:00
teams , err := organization . FindOrgTeams ( ctx , org . ID )
2021-11-19 06:41:40 -05:00
if err != nil {
return err
}
for _ , t := range teams {
2022-05-11 05:09:36 -05:00
if ! organization . HasTeamRepo ( ctx , t . OrgID , t . ID , repoID ) {
2014-08-27 03:39:36 -05:00
continue
2022-03-29 01:29:02 -05:00
} else if err = removeRepository ( ctx , t , repo , false ) ; err != nil {
2014-08-27 03:39:36 -05:00
return err
}
}
}
2021-11-19 08:39:57 -05:00
attachments := make ( [ ] * repo_model . Attachment , 0 , 20 )
2019-12-12 00:31:05 -05:00
if err = sess . Join ( "INNER" , "`release`" , "`release`.id = `attachment`.release_id" ) .
Where ( "`release`.repo_id = ?" , repoID ) .
Find ( & attachments ) ; err != nil {
return err
}
releaseAttachments := make ( [ ] string , 0 , len ( attachments ) )
for i := 0 ; i < len ( attachments ) ; i ++ {
2020-08-17 23:23:45 -05:00
releaseAttachments = append ( releaseAttachments , attachments [ i ] . RelativePath ( ) )
2019-12-12 00:31:05 -05:00
}
2022-05-20 09:08:52 -05:00
if _ , err := db . Exec ( ctx , "UPDATE `user` SET num_stars=num_stars-1 WHERE id IN (SELECT `uid` FROM `star` WHERE repo_id = ?)" , repo . ID ) ; err != nil {
2020-07-07 14:16:34 -05:00
return err
}
2022-02-17 03:37:48 -05:00
if err := db . DeleteBeans ( ctx ,
2022-05-11 05:09:36 -05:00
& access_model . Access { RepoID : repo . ID } ,
2022-08-24 21:31:57 -05:00
& activities_model . Action { RepoID : repo . ID } ,
2022-05-11 05:09:36 -05:00
& repo_model . Collaboration { RepoID : repoID } ,
2022-06-13 04:37:59 -05:00
& issues_model . Comment { RefRepoID : repoID } ,
2022-06-12 10:51:54 -05:00
& git_model . CommitStatus { RepoID : repoID } ,
& git_model . DeletedBranch { RepoID : repoID } ,
2021-11-10 00:13:16 -05:00
& webhook . HookTask { RepoID : repoID } ,
2022-06-12 10:51:54 -05:00
& git_model . LFSLock { RepoID : repoID } ,
2021-12-09 20:27:50 -05:00
& repo_model . LanguageStat { RepoID : repoID } ,
2022-04-08 04:11:15 -05:00
& issues_model . Milestone { RepoID : repoID } ,
2021-12-09 20:27:50 -05:00
& repo_model . Mirror { RepoID : repoID } ,
2022-08-24 21:31:57 -05:00
& activities_model . Notification { RepoID : repoID } ,
2022-06-12 10:51:54 -05:00
& git_model . ProtectedBranch { RepoID : repoID } ,
& git_model . ProtectedTag { RepoID : repoID } ,
2021-12-09 20:27:50 -05:00
& repo_model . PushMirror { RepoID : repoID } ,
2022-08-24 21:31:57 -05:00
& repo_model . Release { RepoID : repoID } ,
2021-12-09 20:27:50 -05:00
& repo_model . RepoIndexerStatus { RepoID : repoID } ,
2021-12-12 10:48:20 -05:00
& repo_model . Redirect { RedirectRepoID : repoID } ,
2021-12-09 20:27:50 -05:00
& repo_model . RepoUnit { RepoID : repoID } ,
2021-12-12 10:48:20 -05:00
& repo_model . Star { RepoID : repoID } ,
2022-08-24 21:31:57 -05:00
& admin_model . Task { RepoID : repoID } ,
2021-12-12 10:48:20 -05:00
& repo_model . Watch { RepoID : repoID } ,
2021-11-10 00:13:16 -05:00
& webhook . Webhook { RepoID : repoID } ,
2015-11-30 20:45:55 -05:00
) ; err != nil {
return fmt . Errorf ( "deleteBeans: %v" , err )
2014-05-14 12:04:57 -05:00
}
2021-03-19 14:01:24 -05:00
// Delete Labels and related objects
2022-06-13 04:37:59 -05:00
if err := issues_model . DeleteLabelsByRepoID ( ctx , repoID ) ; err != nil {
2021-03-19 14:01:24 -05:00
return err
}
2022-05-08 08:46:34 -05:00
// Delete Pulls and related objects
2022-06-13 04:37:59 -05:00
if err := issues_model . DeletePullsByBaseRepoID ( ctx , repoID ) ; err != nil {
2022-05-08 08:46:34 -05:00
return err
}
2020-05-29 08:24:15 -05:00
// Delete Issues and related objects
var attachmentPaths [ ] string
2022-06-13 04:37:59 -05:00
if attachmentPaths , err = issues_model . DeleteIssuesByRepoID ( ctx , repoID ) ; err != nil {
2018-11-30 07:59:12 -05:00
return err
2014-05-14 08:23:33 -05:00
}
2014-10-19 00:35:24 -05:00
2021-06-13 21:22:55 -05:00
// Delete issue index
2022-10-16 05:44:16 -05:00
if err := db . DeleteResourceIndex ( ctx , "issue_index" , repoID ) ; err != nil {
2021-06-13 21:22:55 -05:00
return err
}
2014-10-13 14:23:30 -05:00
if repo . IsFork {
2022-05-20 09:08:52 -05:00
if _ , err := db . Exec ( ctx , "UPDATE `repository` SET num_forks=num_forks-1 WHERE id=?" , repo . ForkID ) ; err != nil {
2015-09-01 10:43:53 -05:00
return fmt . Errorf ( "decrease fork count: %v" , err )
2014-10-19 00:35:24 -05:00
}
2014-10-13 14:23:30 -05:00
}
2014-04-12 19:35:35 -05:00
2022-05-20 09:08:52 -05:00
if _ , err := db . Exec ( ctx , "UPDATE `user` SET num_repos=num_repos-1 WHERE id=?" , uid ) ; err != nil {
2014-04-12 19:35:35 -05:00
return err
}
2014-10-08 17:29:18 -05:00
2020-01-31 01:57:19 -05:00
if len ( repo . Topics ) > 0 {
2021-12-12 10:48:20 -05:00
if err := repo_model . RemoveTopicsFromRepo ( ctx , repo . ID ) ; err != nil {
2020-01-31 01:57:19 -05:00
return err
}
}
2022-07-14 02:22:09 -05:00
if err := project_model . DeleteProjectByRepoIDCtx ( ctx , repoID ) ; err != nil {
return fmt . Errorf ( "unable to delete projects for repo[%d]: %v" , repoID , err )
2020-08-16 22:07:38 -05:00
}
2016-12-25 20:16:37 -05:00
// Remove LFS objects
2022-06-12 10:51:54 -05:00
var lfsObjects [ ] * git_model . LFSMetaObject
2016-12-25 20:16:37 -05:00
if err = sess . Where ( "repository_id=?" , repoID ) . Find ( & lfsObjects ) ; err != nil {
return err
}
2022-01-20 12:46:10 -05:00
lfsPaths := make ( [ ] string , 0 , len ( lfsObjects ) )
2016-12-25 20:16:37 -05:00
for _ , v := range lfsObjects {
2022-06-12 10:51:54 -05:00
count , err := db . CountByBean ( ctx , & git_model . LFSMetaObject { Pointer : lfs . Pointer { Oid : v . Oid } } )
2016-12-25 20:16:37 -05:00
if err != nil {
return err
}
if count > 1 {
continue
}
2021-09-08 10:19:30 -05:00
lfsPaths = append ( lfsPaths , v . RelativePath ( ) )
2016-12-25 20:16:37 -05:00
}
2022-06-12 10:51:54 -05:00
if _ , err := db . DeleteByBean ( ctx , & git_model . LFSMetaObject { RepositoryID : repoID } ) ; err != nil {
2016-12-25 20:16:37 -05:00
return err
}
2021-06-23 16:12:38 -05:00
// Remove archives
2021-12-06 02:19:28 -05:00
var archives [ ] * repo_model . RepoArchiver
2021-06-23 16:12:38 -05:00
if err = sess . Where ( "repo_id=?" , repoID ) . Find ( & archives ) ; err != nil {
return err
}
2022-01-20 12:46:10 -05:00
archivePaths := make ( [ ] string , 0 , len ( archives ) )
2021-06-23 16:12:38 -05:00
for _ , v := range archives {
2022-08-29 04:45:20 -05:00
archivePaths = append ( archivePaths , v . RelativePath ( ) )
2021-06-23 16:12:38 -05:00
}
2022-05-20 09:08:52 -05:00
if _ , err := db . DeleteByBean ( ctx , & repo_model . RepoArchiver { RepoID : repoID } ) ; err != nil {
2021-06-23 16:12:38 -05:00
return err
}
2015-09-01 10:43:53 -05:00
if repo . NumForks > 0 {
2017-01-27 11:11:41 -05:00
if _ , err = sess . Exec ( "UPDATE `repository` SET fork_id=0,is_fork=? WHERE fork_id=?" , false , repo . ID ) ; err != nil {
2019-04-02 02:48:31 -05:00
log . Error ( "reset 'fork_id' and 'is_fork': %v" , err )
2016-07-09 00:42:05 -05:00
}
2015-09-01 10:43:53 -05:00
}
2021-09-08 10:19:30 -05:00
// Get all attachments with both issue_id and release_id are zero
2021-11-19 08:39:57 -05:00
var newAttachments [ ] * repo_model . Attachment
2021-09-08 10:19:30 -05:00
if err := sess . Where ( builder . Eq {
"repo_id" : repo . ID ,
"issue_id" : 0 ,
"release_id" : 0 ,
} ) . Find ( & newAttachments ) ; err != nil {
return err
}
2022-01-20 12:46:10 -05:00
newAttachmentPaths := make ( [ ] string , 0 , len ( newAttachments ) )
2021-09-08 10:19:30 -05:00
for _ , attach := range newAttachments {
newAttachmentPaths = append ( newAttachmentPaths , attach . RelativePath ( ) )
}
2021-11-19 08:39:57 -05:00
if _ , err := sess . Where ( "repo_id=?" , repo . ID ) . Delete ( new ( repo_model . Attachment ) ) ; err != nil {
2021-09-08 10:19:30 -05:00
return err
}
2021-11-21 10:41:00 -05:00
if err = committer . Commit ( ) ; err != nil {
2021-01-18 15:00:50 -05:00
return err
2017-01-27 11:11:41 -05:00
}
2021-11-21 10:41:00 -05:00
committer . Close ( )
2019-12-12 00:31:05 -05:00
2021-12-10 03:14:24 -05:00
if needRewriteKeysFile {
if err := asymkey_model . RewriteAllPublicKeys ( ) ; err != nil {
log . Error ( "RewriteAllPublicKeys failed: %v" , err )
}
}
2019-12-12 00:31:05 -05:00
// We should always delete the files after the database transaction succeed. If
2021-07-08 06:38:13 -05:00
// we delete the file but the database rollback, the repository will be broken.
2019-12-12 00:31:05 -05:00
2021-09-08 10:19:30 -05:00
// Remove repository files.
repoPath := repo . RepoPath ( )
2022-10-16 18:29:26 -05:00
system_model . RemoveAllWithNotice ( db . DefaultContext , "Delete repository files" , repoPath )
2021-09-08 10:19:30 -05:00
// Remove wiki files
if repo . HasWiki ( ) {
2022-10-16 18:29:26 -05:00
system_model . RemoveAllWithNotice ( db . DefaultContext , "Delete repository wiki" , repo . WikiPath ( ) )
2021-09-08 10:19:30 -05:00
}
// Remove archives
2022-03-03 06:51:13 -05:00
for _ , archive := range archivePaths {
2022-10-16 18:29:26 -05:00
system_model . RemoveStorageWithNotice ( db . DefaultContext , storage . RepoArchives , "Delete repo archive file" , archive )
2021-09-08 10:19:30 -05:00
}
// Remove lfs objects
2022-03-03 06:51:13 -05:00
for _ , lfsObj := range lfsPaths {
2022-10-16 18:29:26 -05:00
system_model . RemoveStorageWithNotice ( db . DefaultContext , storage . LFS , "Delete orphaned LFS file" , lfsObj )
2021-09-08 10:19:30 -05:00
}
2019-12-12 00:31:05 -05:00
// Remove issue attachment files.
2022-03-03 06:51:13 -05:00
for _ , attachment := range attachmentPaths {
2022-10-16 18:29:26 -05:00
system_model . RemoveStorageWithNotice ( db . DefaultContext , storage . Attachments , "Delete issue attachment" , attachment )
2019-12-12 00:31:05 -05:00
}
// Remove release attachment files.
2022-03-03 06:51:13 -05:00
for _ , releaseAttachment := range releaseAttachments {
2022-10-16 18:29:26 -05:00
system_model . RemoveStorageWithNotice ( db . DefaultContext , storage . Attachments , "Delete release attachment" , releaseAttachment )
2019-12-12 00:31:05 -05:00
}
2021-09-08 10:19:30 -05:00
// Remove attachment with no issue_id and release_id.
2022-03-03 06:51:13 -05:00
for _ , newAttachment := range newAttachmentPaths {
2022-10-16 18:29:26 -05:00
system_model . RemoveStorageWithNotice ( db . DefaultContext , storage . Attachments , "Delete issue attachment" , newAttachment )
2021-09-08 10:19:30 -05:00
}
2019-05-29 21:22:26 -05:00
if len ( repo . Avatar ) > 0 {
2020-10-14 08:07:51 -05:00
if err := storage . RepoAvatars . Delete ( repo . CustomAvatarRelativePath ( ) ) ; err != nil {
return fmt . Errorf ( "Failed to remove %s: %v" , repo . Avatar , err )
2019-05-29 21:22:26 -05:00
}
}
2015-09-01 10:43:53 -05:00
return nil
2014-03-20 15:04:56 -05:00
}
2015-09-01 10:43:53 -05:00
type repoChecker struct {
2022-01-17 13:31:58 -05:00
querySQL func ( ctx context . Context ) ( [ ] map [ string ] [ ] byte , error )
correctSQL func ( ctx context . Context , id int64 ) error
desc string
2015-09-01 10:43:53 -05:00
}
2015-08-17 15:03:11 -05:00
2019-12-15 04:51:28 -05:00
func repoStatsCheck ( ctx context . Context , checker * repoChecker ) {
2022-01-17 13:31:58 -05:00
results , err := checker . querySQL ( ctx )
2015-08-17 15:03:11 -05:00
if err != nil {
2019-04-02 02:48:31 -05:00
log . Error ( "Select %s: %v" , checker . desc , err )
2015-08-17 15:03:11 -05:00
return
}
2015-09-01 10:43:53 -05:00
for _ , result := range results {
2020-12-25 04:59:32 -05:00
id , _ := strconv . ParseInt ( string ( result [ "id" ] ) , 10 , 64 )
2019-12-15 04:51:28 -05:00
select {
case <- ctx . Done ( ) :
2022-01-17 13:31:58 -05:00
log . Warn ( "CheckRepoStats: Cancelled before checking %s for with id=%d" , checker . desc , id )
2019-12-15 04:51:28 -05:00
return
default :
}
2015-09-01 10:43:53 -05:00
log . Trace ( "Updating %s: %d" , checker . desc , id )
2022-01-17 13:31:58 -05:00
err = checker . correctSQL ( ctx , id )
2015-08-17 15:03:11 -05:00
if err != nil {
2019-04-02 02:48:31 -05:00
log . Error ( "Update %s[%d]: %v" , checker . desc , id , err )
2015-08-17 15:03:11 -05:00
}
}
2015-09-01 10:43:53 -05:00
}
2015-08-17 15:03:11 -05:00
2022-01-17 13:31:58 -05:00
func StatsCorrectSQL ( ctx context . Context , sql string , id int64 ) error {
_ , err := db . GetEngine ( ctx ) . Exec ( sql , id , id )
return err
}
func repoStatsCorrectNumWatches ( ctx context . Context , id int64 ) error {
return StatsCorrectSQL ( ctx , "UPDATE `repository` SET num_watches=(SELECT COUNT(*) FROM `watch` WHERE repo_id=? AND mode<>2) WHERE id=?" , id )
}
func repoStatsCorrectNumStars ( ctx context . Context , id int64 ) error {
return StatsCorrectSQL ( ctx , "UPDATE `repository` SET num_stars=(SELECT COUNT(*) FROM `star` WHERE repo_id=?) WHERE id=?" , id )
}
func labelStatsCorrectNumIssues ( ctx context . Context , id int64 ) error {
return StatsCorrectSQL ( ctx , "UPDATE `label` SET num_issues=(SELECT COUNT(*) FROM `issue_label` WHERE label_id=?) WHERE id=?" , id )
}
func labelStatsCorrectNumIssuesRepo ( ctx context . Context , id int64 ) error {
_ , err := db . GetEngine ( ctx ) . Exec ( "UPDATE `label` SET num_issues=(SELECT COUNT(*) FROM `issue_label` WHERE label_id=id) WHERE repo_id=?" , id )
return err
}
func labelStatsCorrectNumClosedIssues ( ctx context . Context , id int64 ) error {
_ , err := db . GetEngine ( ctx ) . Exec ( "UPDATE `label` SET num_closed_issues=(SELECT COUNT(*) FROM `issue_label`,`issue` WHERE `issue_label`.label_id=`label`.id AND `issue_label`.issue_id=`issue`.id AND `issue`.is_closed=?) WHERE `label`.id=?" , true , id )
return err
}
func labelStatsCorrectNumClosedIssuesRepo ( ctx context . Context , id int64 ) error {
_ , err := db . GetEngine ( ctx ) . Exec ( "UPDATE `label` SET num_closed_issues=(SELECT COUNT(*) FROM `issue_label`,`issue` WHERE `issue_label`.label_id=`label`.id AND `issue_label`.issue_id=`issue`.id AND `issue`.is_closed=?) WHERE `label`.repo_id=?" , true , id )
return err
}
var milestoneStatsQueryNumIssues = "SELECT `milestone`.id FROM `milestone` WHERE `milestone`.num_closed_issues!=(SELECT COUNT(*) FROM `issue` WHERE `issue`.milestone_id=`milestone`.id AND `issue`.is_closed=?) OR `milestone`.num_issues!=(SELECT COUNT(*) FROM `issue` WHERE `issue`.milestone_id=`milestone`.id)"
func milestoneStatsCorrectNumIssuesRepo ( ctx context . Context , id int64 ) error {
e := db . GetEngine ( ctx )
results , err := e . Query ( milestoneStatsQueryNumIssues + " AND `milestone`.repo_id = ?" , true , id )
if err != nil {
return err
}
for _ , result := range results {
id , _ := strconv . ParseInt ( string ( result [ "id" ] ) , 10 , 64 )
2022-04-08 04:11:15 -05:00
err = issues_model . UpdateMilestoneCounters ( ctx , id )
2022-01-17 13:31:58 -05:00
if err != nil {
return err
}
}
return nil
}
func userStatsCorrectNumRepos ( ctx context . Context , id int64 ) error {
return StatsCorrectSQL ( ctx , "UPDATE `user` SET num_repos=(SELECT COUNT(*) FROM `repository` WHERE owner_id=?) WHERE id=?" , id )
}
func repoStatsCorrectIssueNumComments ( ctx context . Context , id int64 ) error {
return StatsCorrectSQL ( ctx , "UPDATE `issue` SET num_comments=(SELECT COUNT(*) FROM `comment` WHERE issue_id=? AND type=0) WHERE id=?" , id )
}
func repoStatsCorrectNumIssues ( ctx context . Context , id int64 ) error {
return repoStatsCorrectNum ( ctx , id , false , "num_issues" )
}
func repoStatsCorrectNumPulls ( ctx context . Context , id int64 ) error {
return repoStatsCorrectNum ( ctx , id , true , "num_pulls" )
}
func repoStatsCorrectNum ( ctx context . Context , id int64 , isPull bool , field string ) error {
_ , err := db . GetEngine ( ctx ) . Exec ( "UPDATE `repository` SET " + field + "=(SELECT COUNT(*) FROM `issue` WHERE repo_id=? AND is_pull=?) WHERE id=?" , id , isPull , id )
return err
}
func repoStatsCorrectNumClosedIssues ( ctx context . Context , id int64 ) error {
2022-06-13 04:37:59 -05:00
return repo_model . StatsCorrectNumClosed ( ctx , id , false , "num_closed_issues" )
2022-01-17 13:31:58 -05:00
}
func repoStatsCorrectNumClosedPulls ( ctx context . Context , id int64 ) error {
2022-06-13 04:37:59 -05:00
return repo_model . StatsCorrectNumClosed ( ctx , id , true , "num_closed_pulls" )
2022-01-17 13:31:58 -05:00
}
func statsQuery ( args ... interface { } ) func ( context . Context ) ( [ ] map [ string ] [ ] byte , error ) {
return func ( ctx context . Context ) ( [ ] map [ string ] [ ] byte , error ) {
return db . GetEngine ( ctx ) . Query ( args ... )
}
}
2016-11-28 12:27:55 -05:00
// CheckRepoStats checks the repository stats
2020-05-16 18:31:38 -05:00
func CheckRepoStats ( ctx context . Context ) error {
2015-09-01 10:43:53 -05:00
log . Trace ( "Doing: CheckRepoStats" )
2015-08-29 12:13:24 -05:00
2015-09-01 10:43:53 -05:00
checkers := [ ] * repoChecker {
// Repository.NumWatches
{
2022-01-17 13:31:58 -05:00
statsQuery ( "SELECT repo.id FROM `repository` repo WHERE repo.num_watches!=(SELECT COUNT(*) FROM `watch` WHERE repo_id=repo.id AND mode<>2)" ) ,
repoStatsCorrectNumWatches ,
2015-09-01 10:43:53 -05:00
"repository count 'num_watches'" ,
} ,
// Repository.NumStars
{
2022-01-17 13:31:58 -05:00
statsQuery ( "SELECT repo.id FROM `repository` repo WHERE repo.num_stars!=(SELECT COUNT(*) FROM `star` WHERE repo_id=repo.id)" ) ,
repoStatsCorrectNumStars ,
2015-09-01 10:43:53 -05:00
"repository count 'num_stars'" ,
} ,
2022-10-11 01:41:39 -05:00
// Repository.NumIssues
{
statsQuery ( "SELECT repo.id FROM `repository` repo WHERE repo.num_issues!=(SELECT COUNT(*) FROM `issue` WHERE repo_id=repo.id AND is_closed=? AND is_pull=?)" , false , false ) ,
repoStatsCorrectNumIssues ,
"repository count 'num_issues'" ,
} ,
2022-01-17 13:31:58 -05:00
// Repository.NumClosedIssues
{
statsQuery ( "SELECT repo.id FROM `repository` repo WHERE repo.num_closed_issues!=(SELECT COUNT(*) FROM `issue` WHERE repo_id=repo.id AND is_closed=? AND is_pull=?)" , true , false ) ,
repoStatsCorrectNumClosedIssues ,
"repository count 'num_closed_issues'" ,
} ,
2022-10-11 01:41:39 -05:00
// Repository.NumPulls
{
statsQuery ( "SELECT repo.id FROM `repository` repo WHERE repo.num_pulls!=(SELECT COUNT(*) FROM `issue` WHERE repo_id=repo.id AND is_closed=? AND is_pull=?)" , false , true ) ,
repoStatsCorrectNumPulls ,
"repository count 'num_pulls'" ,
} ,
2022-01-17 13:31:58 -05:00
// Repository.NumClosedPulls
{
2022-10-11 01:41:39 -05:00
statsQuery ( "SELECT repo.id FROM `repository` repo WHERE repo.num_closed_pulls!=(SELECT COUNT(*) FROM `issue` WHERE repo_id=repo.id AND is_closed=? AND is_pull=?)" , true , true ) ,
2022-01-17 13:31:58 -05:00
repoStatsCorrectNumClosedPulls ,
"repository count 'num_closed_pulls'" ,
} ,
2015-09-01 10:43:53 -05:00
// Label.NumIssues
{
2022-01-17 13:31:58 -05:00
statsQuery ( "SELECT label.id FROM `label` WHERE label.num_issues!=(SELECT COUNT(*) FROM `issue_label` WHERE label_id=label.id)" ) ,
labelStatsCorrectNumIssues ,
2015-09-01 10:43:53 -05:00
"label count 'num_issues'" ,
} ,
2022-01-17 13:31:58 -05:00
// Label.NumClosedIssues
{
statsQuery ( "SELECT `label`.id FROM `label` WHERE `label`.num_closed_issues!=(SELECT COUNT(*) FROM `issue_label`,`issue` WHERE `issue_label`.label_id=`label`.id AND `issue_label`.issue_id=`issue`.id AND `issue`.is_closed=?)" , true ) ,
labelStatsCorrectNumClosedIssues ,
"label count 'num_closed_issues'" ,
} ,
// Milestone.Num{,Closed}Issues
{
statsQuery ( milestoneStatsQueryNumIssues , true ) ,
2022-04-08 04:11:15 -05:00
issues_model . UpdateMilestoneCounters ,
2022-01-17 13:31:58 -05:00
"milestone count 'num_closed_issues' and 'num_issues'" ,
} ,
2015-09-01 10:43:53 -05:00
// User.NumRepos
{
2022-01-17 13:31:58 -05:00
statsQuery ( "SELECT `user`.id FROM `user` WHERE `user`.num_repos!=(SELECT COUNT(*) FROM `repository` WHERE owner_id=`user`.id)" ) ,
userStatsCorrectNumRepos ,
2015-09-01 10:43:53 -05:00
"user count 'num_repos'" ,
} ,
2015-10-29 19:40:57 -05:00
// Issue.NumComments
{
2022-01-17 13:31:58 -05:00
statsQuery ( "SELECT `issue`.id FROM `issue` WHERE `issue`.num_comments!=(SELECT COUNT(*) FROM `comment` WHERE issue_id=`issue`.id AND type=0)" ) ,
repoStatsCorrectIssueNumComments ,
2015-10-29 19:40:57 -05:00
"issue count 'num_comments'" ,
} ,
2015-09-01 10:43:53 -05:00
}
2020-05-16 18:31:38 -05:00
for _ , checker := range checkers {
2019-12-15 04:51:28 -05:00
select {
case <- ctx . Done ( ) :
2020-05-16 18:31:38 -05:00
log . Warn ( "CheckRepoStats: Cancelled before %s" , checker . desc )
2021-11-10 00:13:16 -05:00
return db . ErrCancelledf ( "before checking %s" , checker . desc )
2019-12-15 04:51:28 -05:00
default :
2020-05-16 18:31:38 -05:00
repoStatsCheck ( ctx , checker )
2019-12-15 04:51:28 -05:00
}
2015-09-01 10:43:53 -05:00
}
2016-05-27 20:23:39 -05:00
// FIXME: use checker when stop supporting old fork repo format.
2015-09-01 10:43:53 -05:00
// ***** START: Repository.NumForks *****
2022-01-17 13:31:58 -05:00
e := db . GetEngine ( ctx )
results , err := e . Query ( "SELECT repo.id FROM `repository` repo WHERE repo.num_forks!=(SELECT COUNT(*) FROM `repository` WHERE fork_id=repo.id)" )
2015-08-29 12:13:24 -05:00
if err != nil {
2019-04-02 02:48:31 -05:00
log . Error ( "Select repository count 'num_forks': %v" , err )
2015-09-01 10:43:53 -05:00
} else {
for _ , result := range results {
2020-12-25 04:59:32 -05:00
id , _ := strconv . ParseInt ( string ( result [ "id" ] ) , 10 , 64 )
2019-12-15 04:51:28 -05:00
select {
case <- ctx . Done ( ) :
2020-05-16 18:31:38 -05:00
log . Warn ( "CheckRepoStats: Cancelled" )
2022-01-17 13:31:58 -05:00
return db . ErrCancelledf ( "during repository count 'num_fork' for repo ID %d" , id )
2019-12-15 04:51:28 -05:00
default :
}
2015-09-01 10:43:53 -05:00
log . Trace ( "Updating repository count 'num_forks': %d" , id )
2021-12-09 20:27:50 -05:00
repo , err := repo_model . GetRepositoryByID ( id )
2015-09-01 10:43:53 -05:00
if err != nil {
2021-12-09 20:27:50 -05:00
log . Error ( "repo_model.GetRepositoryByID[%d]: %v" , id , err )
2015-09-01 10:43:53 -05:00
continue
}
2022-06-13 04:37:59 -05:00
_ , err = e . SQL ( "SELECT COUNT(*) FROM `repository` WHERE fork_id=?" , repo . ID ) . Get ( & repo . NumForks )
2015-09-01 10:43:53 -05:00
if err != nil {
2019-04-02 02:48:31 -05:00
log . Error ( "Select count of forks[%d]: %v" , repo . ID , err )
2015-09-01 10:43:53 -05:00
continue
}
2022-06-06 03:01:49 -05:00
if _ , err = e . ID ( repo . ID ) . Cols ( "num_forks" ) . Update ( repo ) ; err != nil {
2019-04-02 02:48:31 -05:00
log . Error ( "UpdateRepository[%d]: %v" , id , err )
2015-09-01 10:43:53 -05:00
continue
}
2015-08-29 12:13:24 -05:00
}
}
2015-09-01 10:43:53 -05:00
// ***** END: Repository.NumForks *****
2020-05-16 18:31:38 -05:00
return nil
2015-03-21 07:55:00 -05:00
}
2022-01-17 13:31:58 -05:00
func UpdateRepoStats ( ctx context . Context , id int64 ) error {
var err error
for _ , f := range [ ] func ( ctx context . Context , id int64 ) error {
repoStatsCorrectNumWatches ,
repoStatsCorrectNumStars ,
repoStatsCorrectNumIssues ,
repoStatsCorrectNumPulls ,
repoStatsCorrectNumClosedIssues ,
repoStatsCorrectNumClosedPulls ,
labelStatsCorrectNumIssuesRepo ,
labelStatsCorrectNumClosedIssuesRepo ,
milestoneStatsCorrectNumIssuesRepo ,
} {
err = f ( ctx , id )
if err != nil {
return err
}
}
return nil
}
2021-11-24 04:49:20 -05:00
func updateUserStarNumbers ( users [ ] user_model . User ) error {
2021-11-21 10:41:00 -05:00
ctx , committer , err := db . TxContext ( )
if err != nil {
return err
}
defer committer . Close ( )
for _ , user := range users {
if _ , err = db . Exec ( ctx , "UPDATE `user` SET num_stars=(SELECT COUNT(*) FROM `star` WHERE uid=?) WHERE id=?" , user . ID , user . ID ) ; err != nil {
return err
}
}
return committer . Commit ( )
}
2020-07-07 14:16:34 -05:00
// DoctorUserStarNum recalculate Stars number for all user
func DoctorUserStarNum ( ) ( err error ) {
const batchSize = 100
for start := 0 ; ; start += batchSize {
2021-11-24 04:49:20 -05:00
users := make ( [ ] user_model . User , 0 , batchSize )
2021-11-21 10:41:00 -05:00
if err = db . GetEngine ( db . DefaultContext ) . Limit ( batchSize , start ) . Where ( "type = ?" , 0 ) . Cols ( "id" ) . Find ( & users ) ; err != nil {
2020-07-07 14:16:34 -05:00
return
}
if len ( users ) == 0 {
break
}
2021-11-21 10:41:00 -05:00
if err = updateUserStarNumbers ( users ) ; err != nil {
2020-07-07 14:16:34 -05:00
return
}
}
log . Debug ( "recalculate Stars number for all user finished" )
2022-06-20 05:02:49 -05:00
return err
2020-07-07 14:16:34 -05:00
}
2020-10-14 08:07:51 -05:00
2021-12-10 03:14:24 -05:00
// DeleteDeployKey delete deploy keys
func DeleteDeployKey ( ctx context . Context , doer * user_model . User , id int64 ) error {
key , err := asymkey_model . GetDeployKeyByID ( ctx , id )
if err != nil {
if asymkey_model . IsErrDeployKeyNotExist ( err ) {
return nil
}
return fmt . Errorf ( "GetDeployKeyByID: %v" , err )
}
// Check if user has access to delete this key.
if ! doer . IsAdmin {
repo , err := repo_model . GetRepositoryByIDCtx ( ctx , key . RepoID )
if err != nil {
return fmt . Errorf ( "GetRepositoryByID: %v" , err )
}
2022-05-20 09:08:52 -05:00
has , err := access_model . IsUserRepoAdmin ( ctx , repo , doer )
2021-12-10 03:14:24 -05:00
if err != nil {
return fmt . Errorf ( "GetUserRepoPermission: %v" , err )
} else if ! has {
return asymkey_model . ErrKeyAccessDenied {
UserID : doer . ID ,
KeyID : key . ID ,
Note : "deploy" ,
}
}
}
2022-06-06 03:01:49 -05:00
if _ , err := db . DeleteByBean ( ctx , & asymkey_model . DeployKey {
ID : key . ID ,
} ) ; err != nil {
2021-12-10 03:14:24 -05:00
return fmt . Errorf ( "delete deploy key [%d]: %v" , key . ID , err )
}
// Check if this is the last reference to same key content.
2022-06-06 03:01:49 -05:00
has , err := asymkey_model . IsDeployKeyExistByKeyID ( ctx , key . KeyID )
2021-12-10 03:14:24 -05:00
if err != nil {
return err
} else if ! has {
if err = asymkey_model . DeletePublicKeys ( ctx , key . KeyID ) ; err != nil {
return err
}
}
return nil
}