2014-02-14 18:16:54 -05:00
// Copyright 2014 The Gogs Authors. All rights reserved.
2017-08-26 09:57:41 -04: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 20:48:58 -04:00
"fmt"
2014-02-14 09:20:57 -05:00
"os"
2014-03-29 22:18:36 -04:00
"path"
2019-04-22 16:40:51 -04:00
"strconv"
2014-02-14 09:20:57 -05:00
"strings"
2021-09-22 01:38:34 -04:00
"unicode/utf8"
2014-02-14 09:20:57 -05:00
2021-11-17 07:34:35 -05:00
_ "image/jpeg" // Needed for jpeg support
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 07:49:59 -04:00
"code.gitea.io/gitea/models/db"
2022-04-08 05:11:15 -04:00
issues_model "code.gitea.io/gitea/models/issues"
2022-03-29 02:29:02 -04:00
"code.gitea.io/gitea/models/organization"
2021-11-28 06:58:28 -05:00
"code.gitea.io/gitea/models/perm"
2022-05-11 06:09:36 -04:00
access_model "code.gitea.io/gitea/models/perm/access"
2022-03-29 10:16:31 -04: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"
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 18:25:57 -04:00
"code.gitea.io/gitea/modules/lfs"
2016-11-10 11:24:48 -05:00
"code.gitea.io/gitea/modules/log"
"code.gitea.io/gitea/modules/setting"
2020-08-18 00:23:45 -04:00
"code.gitea.io/gitea/modules/storage"
2019-05-11 06:21:34 -04:00
api "code.gitea.io/gitea/modules/structs"
2019-11-10 16:33:47 -05:00
"code.gitea.io/gitea/modules/util"
2017-01-01 13:15:09 -05:00
2020-06-13 07:35:59 -04:00
"xorm.io/builder"
2014-02-14 09:20:57 -05:00
)
2022-03-29 03:23:45 -04:00
// ItemsPerPage maximum items per page in forks, watchers and stars of a repo
var ItemsPerPage = 40
2014-03-17 11:56:50 -04:00
2016-11-28 12:27:55 -05:00
// NewRepoContext creates a new repository context
2014-03-21 01:48:10 -04:00
func NewRepoContext ( ) {
2021-11-09 14:57:58 -05:00
unit . LoadUnitConfig ( )
2014-03-11 01:32:36 -04:00
}
2021-12-09 20:27:50 -05:00
// CheckRepoUnitUser check whether user could visit the unit of this repository
func CheckRepoUnitUser ( repo * repo_model . Repository , user * user_model . User , unitType unit . Type ) bool {
return checkRepoUnitUser ( db . DefaultContext , repo , user , unitType )
2016-08-14 06:32:24 -04:00
}
2021-12-09 20:27:50 -05:00
func checkRepoUnitUser ( ctx context . Context , repo * repo_model . Repository , user * user_model . User , unitType unit . Type ) bool {
2022-05-05 23:54:22 -04:00
if user != nil && user . IsAdmin {
2018-11-28 06:26:14 -05:00
return true
2017-06-14 22:50:12 -04:00
}
2022-05-11 06:09:36 -04:00
perm , err := access_model . GetUserRepoPermission ( ctx , repo , user )
2018-11-28 06:26:14 -05:00
if err != nil {
2022-04-28 07:48:48 -04:00
log . Error ( "GetUserRepoPermission(): %v" , err )
2018-11-28 06:26:14 -05:00
return false
2017-05-18 10:54:24 -04:00
}
2018-11-28 06:26:14 -05:00
return perm . CanRead ( unitType )
2017-02-04 10:53:46 -05:00
}
2021-12-09 20:27:50 -05:00
func getRepoAssignees ( ctx context . Context , repo * repo_model . Repository ) ( _ [ ] * user_model . User , err error ) {
if err = repo . GetOwner ( ctx ) ; err != nil {
2015-08-10 09:47:23 -04:00
return nil , err
}
2021-12-09 20:27:50 -05:00
e := db . GetEngine ( ctx )
2022-02-23 17:07:05 -05:00
userIDs := make ( [ ] int64 , 0 , 10 )
if err = e . Table ( "access" ) .
2021-11-28 06:58:28 -05:00
Where ( "repo_id = ? AND mode >= ?" , repo . ID , perm . AccessModeWrite ) .
2022-03-04 13:29:12 -05:00
Select ( "user_id" ) .
2022-02-23 17:07:05 -05:00
Find ( & userIDs ) ; err != nil {
2015-08-10 09:47:23 -04:00
return nil , err
}
2022-02-23 17:07:05 -05:00
additionalUserIDs := make ( [ ] int64 , 0 , 10 )
if err = e . Table ( "team_user" ) .
Join ( "INNER" , "team_repo" , "`team_repo`.team_id = `team_user`.team_id" ) .
Join ( "INNER" , "team_unit" , "`team_unit`.team_id = `team_user`.team_id" ) .
Where ( "`team_repo`.repo_id = ? AND `team_unit`.access_mode >= ?" , repo . ID , perm . AccessModeWrite ) .
Distinct ( "`team_user`.uid" ) .
Select ( "`team_user`.uid" ) .
Find ( & additionalUserIDs ) ; err != nil {
return nil , err
}
uidMap := map [ int64 ] bool { }
i := 0
for _ , uid := range userIDs {
if uidMap [ uid ] {
continue
2016-08-15 21:48:20 -04:00
}
2022-02-23 17:07:05 -05:00
uidMap [ uid ] = true
userIDs [ i ] = uid
i ++
}
userIDs = userIDs [ : i ]
userIDs = append ( userIDs , additionalUserIDs ... )
2016-08-15 21:48:20 -04:00
2022-02-23 17:07:05 -05:00
for _ , uid := range additionalUserIDs {
if uidMap [ uid ] {
continue
}
userIDs [ i ] = uid
i ++
}
userIDs = userIDs [ : i ]
// Leave a seat for owner itself to append later, but if owner is an organization
// and just waste 1 unit is cheaper than re-allocate memory once.
users := make ( [ ] * user_model . User , 0 , len ( userIDs ) + 1 )
if len ( userIDs ) > 0 {
2016-08-15 21:48:20 -04:00
if err = e . In ( "id" , userIDs ) . Find ( & users ) ; err != nil {
return nil , err
}
2016-08-15 21:40:32 -04:00
}
2022-02-23 17:07:05 -05:00
if ! repo . Owner . IsOrganization ( ) && ! uidMap [ repo . OwnerID ] {
2015-08-10 09:47:23 -04:00
users = append ( users , repo . Owner )
}
return users , nil
}
2021-12-09 20:27:50 -05:00
// GetRepoAssignees returns all users that have write access and can be assigned to issues
2016-08-15 21:40:32 -04:00
// of the repository,
2021-12-09 20:27:50 -05:00
func GetRepoAssignees ( repo * repo_model . Repository ) ( _ [ ] * user_model . User , err error ) {
return getRepoAssignees ( db . DefaultContext , repo )
2016-08-15 21:40:32 -04:00
}
2021-12-09 20:27:50 -05:00
func getReviewers ( ctx context . Context , repo * repo_model . Repository , doerID , posterID int64 ) ( [ ] * user_model . User , error ) {
2020-10-12 15:55:13 -04:00
// Get the owner of the repository - this often already pre-cached and if so saves complexity for the following queries
2021-12-09 20:27:50 -05:00
if err := repo . GetOwner ( ctx ) ; err != nil {
2020-04-06 12:33:34 -04:00
return nil , err
}
2022-03-10 13:12:10 -05:00
cond := builder . And ( builder . Neq { "`user`.id" : posterID } )
2020-04-06 12:33:34 -04:00
2021-06-26 15:53:14 -04:00
if repo . IsPrivate || repo . Owner . Visibility == api . VisibleTypePrivate {
2020-10-12 15:55:13 -04:00
// This a private repository:
// Anyone who can read the repository is a requestable reviewer
2022-03-10 13:12:10 -05:00
cond = cond . And ( builder . In ( "`user`.id" ,
builder . Select ( "user_id" ) . From ( "access" ) . Where (
builder . Eq { "repo_id" : repo . ID } .
And ( builder . Gte { "mode" : perm . AccessModeRead } ) ,
) ,
) )
2020-04-06 12:33:34 -04:00
2022-03-08 16:48:47 -05:00
if repo . Owner . Type == user_model . UserTypeIndividual && repo . Owner . ID != posterID {
// as private *user* repos don't generate an entry in the `access` table,
// the owner of a private repo needs to be explicitly added.
2022-03-10 13:12:10 -05:00
cond = cond . Or ( builder . Eq { "`user`.id" : repo . Owner . ID } )
2022-03-08 16:48:47 -05:00
}
2022-03-10 13:12:10 -05:00
} else {
// This is a "public" repository:
// Any user that has read access, is a watcher or organization member can be requested to review
cond = cond . And ( builder . And ( builder . In ( "`user`.id" ,
builder . Select ( "user_id" ) . From ( "access" ) .
Where ( builder . Eq { "repo_id" : repo . ID } .
And ( builder . Gte { "mode" : perm . AccessModeRead } ) ) ,
) . Or ( builder . In ( "`user`.id" ,
builder . Select ( "user_id" ) . From ( "watch" ) .
Where ( builder . Eq { "repo_id" : repo . ID } .
And ( builder . In ( "mode" , repo_model . WatchModeNormal , repo_model . WatchModeAuto ) ) ) ,
) . Or ( builder . In ( "`user`.id" ,
builder . Select ( "uid" ) . From ( "org_user" ) .
Where ( builder . Eq { "org_id" : repo . OwnerID } ) ,
) ) ) ) )
2020-10-12 15:55:13 -04:00
}
2020-04-06 12:33:34 -04:00
2022-03-10 13:12:10 -05:00
users := make ( [ ] * user_model . User , 0 , 8 )
return users , db . GetEngine ( ctx ) . Where ( cond ) . OrderBy ( "name" ) . Find ( & users )
2020-04-06 12:33:34 -04:00
}
2020-10-12 15:55:13 -04:00
// GetReviewers get all users can be requested to review:
// * for private repositories this returns all users that have read access or higher to the repository.
2021-02-28 13:24:00 -05:00
// * for public repositories this returns all users that have read access or higher to the repository,
// all repo watchers and all organization members.
2021-02-18 10:39:04 -05:00
// TODO: may be we should have a busy choice for users to block review request to them.
2021-12-09 20:27:50 -05:00
func GetReviewers ( repo * repo_model . Repository , doerID , posterID int64 ) ( [ ] * user_model . User , error ) {
return getReviewers ( db . DefaultContext , repo , doerID , posterID )
2020-10-12 15:55:13 -04:00
}
// GetReviewerTeams get all teams can be requested to review
2022-03-29 02:29:02 -04:00
func GetReviewerTeams ( repo * repo_model . Repository ) ( [ ] * organization . Team , error ) {
2021-12-09 20:27:50 -05:00
if err := repo . GetOwner ( db . DefaultContext ) ; err != nil {
2020-04-06 12:33:34 -04:00
return nil , err
}
2020-10-12 15:55:13 -04:00
if ! repo . Owner . IsOrganization ( ) {
return nil , nil
}
2020-04-06 12:33:34 -04:00
2022-04-28 07:48:48 -04:00
teams , err := organization . GetTeamsWithAccessToRepo ( db . DefaultContext , repo . OwnerID , repo . ID , perm . AccessModeRead )
2020-10-12 15:55:13 -04:00
if err != nil {
return nil , err
2020-04-06 12:33:34 -04:00
}
2020-10-12 15:55:13 -04:00
return teams , err
2020-04-06 12:33:34 -04:00
}
2022-05-20 10:08:52 -04:00
// UpdateRepoSize updates the repository size, calculating it using util.GetDirectorySize
func UpdateRepoSize ( ctx context . Context , repo * repo_model . Repository ) error {
2020-01-12 04:36:21 -05:00
size , err := util . GetDirectorySize ( repo . RepoPath ( ) )
2017-04-11 09:30:15 -04:00
if err != nil {
2020-01-12 07:11:17 -05:00
return fmt . Errorf ( "updateSize: %v" , err )
2017-04-11 09:30:15 -04:00
}
2022-05-20 10:08:52 -04:00
lfsSize , err := db . GetEngine ( ctx ) . Where ( "repository_id = ?" , repo . ID ) . SumInt ( new ( LFSMetaObject ) , "size" )
2020-05-31 00:51:19 -04:00
if err != nil {
return fmt . Errorf ( "updateSize: GetLFSMetaObjects: %v" , err )
}
2021-03-27 23:56:28 -04:00
repo . Size = size + lfsSize
2022-05-20 10:08:52 -04:00
_ , err = db . GetEngine ( ctx ) . ID ( repo . ID ) . Cols ( "size" ) . NoAutoTime ( ) . Update ( repo )
2017-04-11 09:30:15 -04:00
return err
}
2021-11-22 10:21:55 -05:00
// CanUserForkRepo returns true if specified user can fork repository.
2021-12-09 20:27:50 -05:00
func CanUserForkRepo ( user * user_model . User , repo * repo_model . Repository ) ( bool , error ) {
2017-10-15 11:06:07 -04:00
if user == nil {
return false , nil
}
2021-12-12 10:48:20 -05:00
if repo . OwnerID != user . ID && ! repo_model . HasForkedRepo ( user . ID , repo . ID ) {
2017-10-15 11:06:07 -04:00
return true , nil
}
2022-03-29 02:29:02 -04:00
ownedOrgs , err := organization . GetOrgsCanCreateRepoByUserID ( user . ID )
2021-11-22 10:21:55 -05:00
if err != nil {
2017-10-15 11:06:07 -04:00
return false , err
}
2021-11-22 10:21:55 -05:00
for _ , org := range ownedOrgs {
2021-12-12 10:48:20 -05:00
if repo . OwnerID != org . ID && ! repo_model . HasForkedRepo ( org . ID , repo . ID ) {
2017-10-15 11:06:07 -04:00
return true , nil
}
}
return false , nil
}
2021-12-30 00:03:40 -05:00
// FindUserOrgForks returns the forked repositories for one user from a repository
2022-03-29 15:13:41 -04:00
func FindUserOrgForks ( ctx context . Context , repoID , userID int64 ) ( [ ] * repo_model . Repository , error ) {
cond := builder . And (
2021-12-30 00:03:40 -05:00
builder . Eq { "fork_id" : repoID } ,
builder . In ( "owner_id" ,
builder . Select ( "org_id" ) .
From ( "org_user" ) .
Where ( builder . Eq { "uid" : userID } ) ,
) ,
)
var repos [ ] * repo_model . Repository
2022-03-29 15:13:41 -04:00
return repos , db . GetEngine ( ctx ) . Table ( "repository" ) . Where ( cond ) . Find ( & repos )
2021-12-30 00:03:40 -05:00
}
2021-12-12 20:59:09 -05:00
// GetForksByUserAndOrgs return forked repos of the user and owned orgs
2022-03-29 15:13:41 -04:00
func GetForksByUserAndOrgs ( ctx context . Context , user * user_model . User , repo * repo_model . Repository ) ( [ ] * repo_model . Repository , error ) {
2021-12-12 20:59:09 -05:00
var repoList [ ] * repo_model . Repository
if user == nil {
return repoList , nil
}
2022-03-29 15:13:41 -04:00
forkedRepo , err := repo_model . GetUserFork ( ctx , repo . ID , user . ID )
2021-12-12 20:59:09 -05:00
if err != nil {
return repoList , err
}
if forkedRepo != nil {
repoList = append ( repoList , forkedRepo )
}
2022-03-29 15:13:41 -04:00
orgForks , err := FindUserOrgForks ( ctx , repo . ID , user . ID )
2021-12-12 20:59:09 -05:00
if err != nil {
2021-12-30 00:03:40 -05:00
return nil , err
2021-12-12 20:59:09 -05:00
}
2021-12-30 00:03:40 -05:00
repoList = append ( repoList , orgForks ... )
2021-12-12 20:59:09 -05:00
return repoList , nil
}
2019-10-26 02:54:11 -04:00
// CanUserDelete returns true if user could delete the repository
2021-12-09 20:27:50 -05:00
func CanUserDelete ( repo * repo_model . Repository , user * user_model . User ) ( bool , error ) {
2019-10-26 02:54:11 -04:00
if user . IsAdmin || user . ID == repo . OwnerID {
return true , nil
}
2021-12-09 20:27:50 -05:00
if err := repo . GetOwner ( db . DefaultContext ) ; err != nil {
2019-10-26 02:54:11 -04:00
return false , err
}
if repo . Owner . IsOrganization ( ) {
2022-03-29 02:29:02 -04:00
isOwner , err := organization . OrgFromUser ( repo . Owner ) . IsOwnedBy ( user . ID )
2019-10-26 02:54:11 -04:00
if err != nil {
return false , err
} else if isOwner {
return true , nil
}
}
return false , nil
}
2016-11-28 12:27:55 -05:00
// CreateRepoOptions contains the create repository options
2015-08-28 06:33:09 -04:00
type CreateRepoOptions struct {
2020-01-10 10:35:17 -05:00
Name string
Description string
OriginalURL string
2020-01-20 15:01:19 -05:00
GitServiceType api . GitServiceType
2020-01-10 10:35:17 -05:00
Gitignores string
IssueLabels string
License string
Readme string
2020-03-26 15:14:51 -04:00
DefaultBranch string
2020-01-10 10:35:17 -05:00
IsPrivate bool
IsMirror bool
2020-09-25 01:18:37 -04:00
IsTemplate bool
2020-01-10 10:35:17 -05:00
AutoInit bool
2021-12-09 20:27:50 -05:00
Status repo_model . RepositoryStatus
TrustModel repo_model . TrustModelType
2021-01-02 18:47:47 -05:00
MirrorInterval string
2015-08-28 06:33:09 -04:00
}
2020-01-12 07:11:17 -05:00
// CreateRepository creates a repository for the user/organization.
2021-12-09 20:27:50 -05:00
func CreateRepository ( ctx context . Context , doer , u * user_model . User , repo * repo_model . Repository , overwriteOrAdopt bool ) ( err error ) {
2021-12-12 10:48:20 -05:00
if err = repo_model . IsUsableRepoName ( repo . Name ) ; err != nil {
2015-08-08 05:10:34 -04:00
return err
2014-06-19 01:08:03 -04:00
}
2022-05-20 10:08:52 -04:00
has , err := repo_model . IsRepositoryExist ( ctx , u , repo . Name )
2015-03-26 17:11:47 -04:00
if err != nil {
2015-08-08 05:10:34 -04:00
return fmt . Errorf ( "IsRepositoryExist: %v" , err )
2015-03-26 17:11:47 -04:00
} else if has {
2021-12-12 10:48:20 -05:00
return repo_model . ErrRepoAlreadyExist {
Uname : u . Name ,
Name : repo . Name ,
}
2014-06-19 01:08:03 -04:00
}
2021-12-09 20:27:50 -05:00
repoPath := repo_model . RepoPath ( u . Name , repo . Name )
2020-11-27 21:42:08 -05:00
isExist , err := util . IsExist ( repoPath )
if err != nil {
log . Error ( "Unable to check if %s exists. Error: %v" , repoPath , err )
return err
}
if ! overwriteOrAdopt && isExist {
2020-09-25 00:09:23 -04:00
log . Error ( "Files already exist in %s and we are not going to adopt or delete." , repoPath )
2021-12-12 10:48:20 -05:00
return repo_model . ErrRepoFilesAlreadyExist {
2020-09-25 00:09:23 -04:00
Uname : u . Name ,
Name : repo . Name ,
}
}
2021-12-09 20:27:50 -05:00
if err = db . Insert ( ctx , repo ) ; err != nil {
2015-08-08 05:10:34 -04:00
return err
2015-08-29 13:13:24 -04:00
}
2021-12-12 10:48:20 -05:00
if err = repo_model . DeleteRedirect ( ctx , u . ID , repo . Name ) ; err != nil {
2017-02-05 09:35:03 -05:00
return err
}
2015-08-29 13:13:24 -04:00
2017-02-04 10:53:46 -05:00
// insert units for repo
2021-12-09 20:27:50 -05:00
units := make ( [ ] repo_model . RepoUnit , 0 , len ( unit . DefaultRepoUnits ) )
2021-11-09 14:57:58 -05:00
for _ , tp := range unit . DefaultRepoUnits {
if tp == unit . TypeIssues {
2021-12-09 20:27:50 -05:00
units = append ( units , repo_model . RepoUnit {
2017-09-12 02:48:13 -04:00
RepoID : repo . ID ,
Type : tp ,
2021-12-09 20:27:50 -05:00
Config : & repo_model . IssuesConfig {
2018-07-17 17:23:58 -04:00
EnableTimetracker : setting . Service . DefaultEnableTimetracking ,
AllowOnlyContributorsToTrackTime : setting . Service . DefaultAllowOnlyContributorsToTrackTime ,
EnableDependencies : setting . Service . DefaultEnableDependencies ,
} ,
2017-09-12 02:48:13 -04:00
} )
2021-11-09 14:57:58 -05:00
} else if tp == unit . TypePullRequests {
2021-12-09 20:27:50 -05:00
units = append ( units , repo_model . RepoUnit {
2018-07-04 23:02:54 -04:00
RepoID : repo . ID ,
Type : tp ,
2022-06-02 23:45:54 -04:00
Config : & repo_model . PullRequestsConfig { AllowMerge : true , AllowRebase : true , AllowRebaseMerge : true , AllowSquash : true , DefaultMergeStyle : repo_model . MergeStyle ( setting . Repository . PullRequest . DefaultMergeStyle ) , AllowRebaseUpdate : true } ,
2018-07-04 23:02:54 -04:00
} )
2017-09-12 02:48:13 -04:00
} else {
2021-12-09 20:27:50 -05:00
units = append ( units , repo_model . RepoUnit {
2017-09-12 02:48:13 -04:00
RepoID : repo . ID ,
Type : tp ,
} )
}
2017-02-04 10:53:46 -05:00
}
2021-12-09 20:27:50 -05:00
if err = db . Insert ( ctx , units ) ; err != nil {
2017-02-04 10:53:46 -05:00
return err
}
2015-08-29 13:13:24 -04:00
// Remember visibility preference.
u . LastRepoVisibility = repo . IsPrivate
2022-05-20 10:08:52 -04:00
if err = user_model . UpdateUserCols ( ctx , u , "last_repo_visibility" ) ; err != nil {
2015-08-29 13:13:24 -04:00
return fmt . Errorf ( "updateUser: %v" , err )
2015-08-08 05:10:34 -04:00
}
2021-11-24 04:49:20 -05:00
if _ , err = db . GetEngine ( ctx ) . Incr ( "num_repos" ) . ID ( u . ID ) . Update ( new ( user_model . User ) ) ; err != nil {
2019-07-17 13:34:13 -04:00
return fmt . Errorf ( "increment user total_repos: %v" , err )
}
u . NumRepos ++
2019-11-06 04:37:14 -05:00
// Give access to all members in teams with access to all repositories.
2015-08-08 05:10:34 -04:00
if u . IsOrganization ( ) {
2022-03-29 02:29:02 -04:00
teams , err := organization . FindOrgTeams ( ctx , u . ID )
2021-11-19 06:41:40 -05:00
if err != nil {
2021-08-12 08:43:08 -04:00
return fmt . Errorf ( "loadTeams: %v" , err )
2019-10-26 02:54:11 -04:00
}
2021-11-19 06:41:40 -05:00
for _ , t := range teams {
2019-11-06 04:37:14 -05:00
if t . IncludesAllRepositories {
2022-03-29 02:29:02 -04:00
if err := addRepository ( ctx , t , repo ) ; err != nil {
2019-11-06 04:37:14 -05:00
return fmt . Errorf ( "addRepository: %v" , err )
}
}
2015-08-08 05:10:34 -04:00
}
2019-11-20 06:27:49 -05:00
2022-05-20 10:08:52 -04:00
if isAdmin , err := access_model . IsUserRepoAdmin ( ctx , repo , doer ) ; err != nil {
2022-05-03 15:46:28 -04:00
return fmt . Errorf ( "IsUserRepoAdminCtx: %v" , err )
2019-11-20 06:27:49 -05:00
} else if ! isAdmin {
2022-01-10 04:32:37 -05:00
// Make creator repo admin if it wasn't assigned automatically
2021-12-09 20:27:50 -05:00
if err = addCollaborator ( ctx , repo , doer ) ; err != nil {
2019-11-20 06:27:49 -05:00
return fmt . Errorf ( "AddCollaborator: %v" , err )
}
2022-05-11 06:09:36 -04:00
if err = repo_model . ChangeCollaborationAccessModeCtx ( ctx , repo , doer . ID , perm . AccessModeAdmin ) ; err != nil {
2019-11-20 06:27:49 -05:00
return fmt . Errorf ( "ChangeCollaborationAccessMode: %v" , err )
}
}
2022-05-11 06:09:36 -04:00
} else if err = access_model . RecalculateAccesses ( ctx , repo ) ; err != nil {
2015-08-08 05:10:34 -04:00
// Organization automatically called this in addRepository method.
2019-06-12 15:41:28 -04:00
return fmt . Errorf ( "recalculateAccesses: %v" , err )
2015-08-08 05:10:34 -04:00
}
2019-01-27 04:25:21 -05:00
if setting . Service . AutoWatchNewRepos {
2022-05-20 10:08:52 -04:00
if err = repo_model . WatchRepo ( ctx , doer . ID , repo . ID , true ) ; err != nil {
2019-01-27 04:25:21 -05:00
return fmt . Errorf ( "watchRepo: %v" , err )
}
}
2015-08-08 05:10:34 -04:00
2021-11-10 00:13:16 -05:00
if err = webhook . CopyDefaultWebhooksToRepo ( ctx , repo . ID ) ; err != nil {
2019-03-18 22:33:20 -04:00
return fmt . Errorf ( "copyDefaultWebhooksToRepo: %v" , err )
}
2015-08-08 05:10:34 -04:00
return nil
}
2021-10-13 15:47:02 -04:00
// CheckDaemonExportOK creates/removes git-daemon-export-ok for git-daemon...
2021-12-09 20:27:50 -05:00
func CheckDaemonExportOK ( ctx context . Context , repo * repo_model . Repository ) error {
if err := repo . GetOwner ( ctx ) ; err != nil {
2021-10-13 15:47:02 -04:00
return err
}
// Create/Remove git-daemon-export-ok for git-daemon...
daemonExportFile := path . Join ( repo . RepoPath ( ) , ` git-daemon-export-ok ` )
isExist , err := util . IsExist ( daemonExportFile )
if err != nil {
log . Error ( "Unable to check if %s exists. Error: %v" , daemonExportFile , err )
return err
}
isPublic := ! repo . IsPrivate && repo . Owner . Visibility == api . VisibleTypePublic
if ! isPublic && isExist {
if err = util . Remove ( daemonExportFile ) ; err != nil {
log . Error ( "Failed to remove %s: %v" , daemonExportFile , err )
}
} else if isPublic && ! isExist {
if f , err := os . Create ( daemonExportFile ) ; err != nil {
log . Error ( "Failed to create %s: %v" , daemonExportFile , err )
} else {
f . Close ( )
}
}
return nil
}
2020-01-12 07:11:17 -05:00
// IncrementRepoForkNum increment repository fork number
2021-09-23 11:45:36 -04:00
func IncrementRepoForkNum ( ctx context . Context , repoID int64 ) error {
_ , err := db . GetEngine ( ctx ) . Exec ( "UPDATE `repository` SET num_forks=num_forks+1 WHERE id=?" , repoID )
2020-01-12 07:11:17 -05:00
return err
}
2021-09-14 13:07:08 -04:00
// DecrementRepoForkNum decrement repository fork number
2021-09-23 11:45:36 -04:00
func DecrementRepoForkNum ( ctx context . Context , repoID int64 ) error {
_ , err := db . GetEngine ( ctx ) . Exec ( "UPDATE `repository` SET num_forks=num_forks-1 WHERE id=?" , repoID )
2021-09-14 13:07:08 -04:00
return err
}
2022-05-08 12:46:32 -04:00
// UpdateRepositoryCtx updates a repository with db context
func UpdateRepositoryCtx ( ctx context . Context , repo * repo_model . Repository , visibilityChanged bool ) ( err error ) {
2014-04-03 15:50:55 -04:00
repo . LowerName = strings . ToLower ( repo . Name )
2020-07-07 17:35:52 -04:00
if utf8 . RuneCountInString ( repo . Description ) > 255 {
repo . Description = string ( [ ] rune ( repo . Description ) [ : 255 ] )
2014-03-22 16:00:46 -04:00
}
2020-07-07 17:35:52 -04:00
if utf8 . RuneCountInString ( repo . Website ) > 255 {
repo . Website = string ( [ ] rune ( repo . Website ) [ : 255 ] )
2014-03-22 16:00:46 -04:00
}
2015-03-16 04:52:11 -04:00
2021-12-09 20:27:50 -05:00
e := db . GetEngine ( ctx )
2017-10-05 00:43:04 -04:00
if _ , err = e . ID ( repo . ID ) . AllCols ( ) . Update ( repo ) ; err != nil {
2015-03-16 04:52:11 -04:00
return fmt . Errorf ( "update: %v" , err )
}
2022-05-20 10:08:52 -04:00
if err = UpdateRepoSize ( ctx , repo ) ; err != nil {
2020-11-06 23:44:08 -05:00
log . Error ( "Failed to update size for repository: %v" , err )
}
2015-03-16 04:52:11 -04:00
if visibilityChanged {
2021-12-09 20:27:50 -05:00
if err = repo . GetOwner ( ctx ) ; err != nil {
2015-03-16 04:52:11 -04:00
return fmt . Errorf ( "getOwner: %v" , err )
}
2015-10-08 22:38:42 -04:00
if repo . Owner . IsOrganization ( ) {
2017-01-04 19:50:34 -05:00
// Organization repository need to recalculate access table when visibility is changed.
2022-05-11 06:09:36 -04:00
if err = access_model . RecalculateTeamAccesses ( ctx , repo , 0 ) ; err != nil {
2015-10-08 22:38:42 -04:00
return fmt . Errorf ( "recalculateTeamAccesses: %v" , err )
}
2015-03-16 04:52:11 -04:00
}
2015-09-01 11:43:53 -04:00
2017-02-11 05:57:57 -05:00
// If repo has become private, we need to set its actions to private.
if repo . IsPrivate {
_ , err = e . Where ( "repo_id = ?" , repo . ID ) . Cols ( "is_private" ) . Update ( & Action {
IsPrivate : true ,
} )
if err != nil {
return err
}
}
2016-08-10 23:08:09 -04:00
// Create/Remove git-daemon-export-ok for git-daemon...
2022-05-20 10:08:52 -04:00
if err := CheckDaemonExportOK ( ctx , repo ) ; err != nil {
2020-11-27 21:42:08 -05:00
return err
}
2016-08-10 23:08:09 -04:00
2021-12-12 10:48:20 -05:00
forkRepos , err := repo_model . GetRepositoriesByForkID ( ctx , repo . ID )
2015-09-01 11:43:53 -04:00
if err != nil {
2022-05-20 10:08:52 -04:00
return fmt . Errorf ( "GetRepositoriesByForkID: %v" , err )
2015-09-01 11:43:53 -04:00
}
for i := range forkRepos {
2020-06-06 20:45:12 -04:00
forkRepos [ i ] . IsPrivate = repo . IsPrivate || repo . Owner . Visibility == api . VisibleTypePrivate
2022-05-08 12:46:32 -04:00
if err = UpdateRepositoryCtx ( ctx , forkRepos [ i ] , true ) ; err != nil {
2015-09-01 11:43:53 -04:00
return fmt . Errorf ( "updateRepository[%d]: %v" , forkRepos [ i ] . ID , err )
}
}
2015-03-16 04:52:11 -04:00
}
return nil
2014-03-22 04:44:57 -04:00
}
2016-11-28 12:27:55 -05:00
// UpdateRepository updates a repository
2021-12-09 20:27:50 -05:00
func UpdateRepository ( repo * repo_model . Repository , visibilityChanged bool ) ( err error ) {
2021-11-21 10:41:00 -05:00
ctx , committer , err := db . TxContext ( )
if err != nil {
2015-03-16 04:52:11 -04:00
return err
}
2021-11-21 10:41:00 -05:00
defer committer . Close ( )
2015-03-16 04:52:11 -04:00
2022-05-08 12:46:32 -04:00
if err = UpdateRepositoryCtx ( ctx , repo , visibilityChanged ) ; err != nil {
2015-03-16 04:52:11 -04:00
return fmt . Errorf ( "updateRepository: %v" , err )
}
2021-11-21 10:41:00 -05:00
return committer . Commit ( )
2015-02-13 00:58:46 -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 04:39:36 -04:00
// In case is a organization.
2022-05-20 10:08:52 -04:00
org , err := user_model . GetUserByIDCtx ( ctx , uid )
2014-08-27 04:39:36 -04: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 04:39:36 -04:00
if org . IsOrganization ( ) {
2022-03-29 02:29:02 -04: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 06:09:36 -04:00
if ! organization . HasTeamRepo ( ctx , t . OrgID , t . ID , repoID ) {
2014-08-27 04:39:36 -04:00
continue
2022-03-29 02:29:02 -04:00
} else if err = removeRepository ( ctx , t , repo , false ) ; err != nil {
2014-08-27 04:39:36 -04: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-18 00:23:45 -04:00
releaseAttachments = append ( releaseAttachments , attachments [ i ] . RelativePath ( ) )
2019-12-12 00:31:05 -05:00
}
2022-05-20 10:08:52 -04: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 15:16:34 -04:00
return err
}
2022-02-17 03:37:48 -05:00
if err := db . DeleteBeans ( ctx ,
2022-05-11 06:09:36 -04:00
& access_model . Access { RepoID : repo . ID } ,
2015-11-30 20:45:55 -05:00
& Action { RepoID : repo . ID } ,
2022-05-11 06:09:36 -04:00
& repo_model . Collaboration { RepoID : repoID } ,
2021-04-30 15:10:39 -04:00
& Comment { RefRepoID : repoID } ,
& CommitStatus { RepoID : repoID } ,
& DeletedBranch { RepoID : repoID } ,
2021-11-10 00:13:16 -05:00
& webhook . HookTask { RepoID : repoID } ,
2021-04-30 15:10:39 -04:00
& LFSLock { RepoID : repoID } ,
2021-12-09 20:27:50 -05:00
& repo_model . LanguageStat { RepoID : repoID } ,
2022-04-08 05:11:15 -04:00
& issues_model . Milestone { RepoID : repoID } ,
2021-12-09 20:27:50 -05:00
& repo_model . Mirror { RepoID : repoID } ,
2018-12-10 15:01:01 -05:00
& Notification { RepoID : repoID } ,
2021-04-30 15:10:39 -04:00
& ProtectedBranch { RepoID : repoID } ,
2021-06-25 10:28:55 -04:00
& ProtectedTag { RepoID : repoID } ,
2021-12-09 20:27:50 -05:00
& repo_model . PushMirror { RepoID : repoID } ,
2021-04-30 15:10:39 -04:00
& 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 } ,
2019-10-13 09:23:14 -04:00
& 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 13:04:57 -04:00
}
2021-03-19 15:01:24 -04:00
// Delete Labels and related objects
2022-05-20 10:08:52 -04:00
if err := deleteLabelsByRepoID ( ctx , repoID ) ; err != nil {
2021-03-19 15:01:24 -04:00
return err
}
2022-05-08 09:46:34 -04:00
// Delete Pulls and related objects
2022-05-20 10:08:52 -04:00
if err := deletePullsByBaseRepoID ( ctx , repoID ) ; err != nil {
2022-05-08 09:46:34 -04:00
return err
}
2020-05-29 09:24:15 -04:00
// Delete Issues and related objects
var attachmentPaths [ ] string
2022-05-20 10:08:52 -04:00
if attachmentPaths , err = deleteIssuesByRepoID ( ctx , repoID ) ; err != nil {
2018-11-30 07:59:12 -05:00
return err
2014-05-14 09:23:33 -04:00
}
2014-10-19 01:35:24 -04:00
2021-06-13 22:22:55 -04:00
// Delete issue index
2022-05-20 10:08:52 -04:00
if err := db . DeleteResouceIndex ( ctx , "issue_index" , repoID ) ; err != nil {
2021-06-13 22:22:55 -04:00
return err
}
2014-10-13 15:23:30 -04:00
if repo . IsFork {
2022-05-20 10:08:52 -04:00
if _ , err := db . Exec ( ctx , "UPDATE `repository` SET num_forks=num_forks-1 WHERE id=?" , repo . ForkID ) ; err != nil {
2015-09-01 11:43:53 -04:00
return fmt . Errorf ( "decrease fork count: %v" , err )
2014-10-19 01:35:24 -04:00
}
2014-10-13 15:23:30 -04:00
}
2014-04-12 20:35:35 -04:00
2022-05-20 10:08:52 -04:00
if _ , err := db . Exec ( ctx , "UPDATE `user` SET num_repos=num_repos-1 WHERE id=?" , uid ) ; err != nil {
2014-04-12 20:35:35 -04:00
return err
}
2014-10-08 18:29:18 -04: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-05-20 10:08:52 -04:00
projects , _ , err := project_model . GetProjects ( ctx , project_model . SearchOptions {
2020-08-16 23:07:38 -04:00
RepoID : repoID ,
} )
if err != nil {
return fmt . Errorf ( "get projects: %v" , err )
}
for i := range projects {
2022-03-29 10:16:31 -04:00
if err := project_model . DeleteProjectByIDCtx ( ctx , projects [ i ] . ID ) ; err != nil {
2020-08-16 23:07:38 -04:00
return fmt . Errorf ( "delete project [%d]: %v" , projects [ i ] . ID , err )
}
}
2016-12-25 20:16:37 -05:00
// Remove LFS objects
var lfsObjects [ ] * LFSMetaObject
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-05-20 10:08:52 -04:00
count , err := db . CountByBean ( ctx , & 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 11:19:30 -04:00
lfsPaths = append ( lfsPaths , v . RelativePath ( ) )
2016-12-25 20:16:37 -05:00
}
2022-05-20 10:08:52 -04:00
if _ , err := db . DeleteByBean ( ctx , & LFSMetaObject { RepositoryID : repoID } ) ; err != nil {
2016-12-25 20:16:37 -05:00
return err
}
2021-06-23 17:12:38 -04:00
// Remove archives
2021-12-06 02:19:28 -05:00
var archives [ ] * repo_model . RepoArchiver
2021-06-23 17:12:38 -04: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 17:12:38 -04:00
for _ , v := range archives {
p , _ := v . RelativePath ( )
2021-09-08 11:19:30 -04:00
archivePaths = append ( archivePaths , p )
2021-06-23 17:12:38 -04:00
}
2022-05-20 10:08:52 -04:00
if _ , err := db . DeleteByBean ( ctx , & repo_model . RepoArchiver { RepoID : repoID } ) ; err != nil {
2021-06-23 17:12:38 -04:00
return err
}
2015-09-01 11:43:53 -04: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 03:48:31 -04:00
log . Error ( "reset 'fork_id' and 'is_fork': %v" , err )
2016-07-09 01:42:05 -04:00
}
2015-09-01 11:43:53 -04:00
}
2021-09-08 11:19:30 -04: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 11:19:30 -04: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 11:19:30 -04: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 11:19:30 -04: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 07:38:13 -04: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 11:19:30 -04:00
// Remove repository files.
repoPath := repo . RepoPath ( )
2021-11-18 12:42:27 -05:00
admin_model . RemoveAllWithNotice ( db . DefaultContext , "Delete repository files" , repoPath )
2021-09-08 11:19:30 -04:00
// Remove wiki files
if repo . HasWiki ( ) {
2021-11-18 12:42:27 -05:00
admin_model . RemoveAllWithNotice ( db . DefaultContext , "Delete repository wiki" , repo . WikiPath ( ) )
2021-09-08 11:19:30 -04:00
}
// Remove archives
2022-03-03 06:51:13 -05:00
for _ , archive := range archivePaths {
admin_model . RemoveStorageWithNotice ( db . DefaultContext , storage . RepoArchives , "Delete repo archive file" , archive )
2021-09-08 11:19:30 -04:00
}
// Remove lfs objects
2022-03-03 06:51:13 -05:00
for _ , lfsObj := range lfsPaths {
admin_model . RemoveStorageWithNotice ( db . DefaultContext , storage . LFS , "Delete orphaned LFS file" , lfsObj )
2021-09-08 11:19:30 -04: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 {
admin_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 {
admin_model . RemoveStorageWithNotice ( db . DefaultContext , storage . Attachments , "Delete release attachment" , releaseAttachment )
2019-12-12 00:31:05 -05:00
}
2021-09-08 11:19:30 -04:00
// Remove attachment with no issue_id and release_id.
2022-03-03 06:51:13 -05:00
for _ , newAttachment := range newAttachmentPaths {
admin_model . RemoveStorageWithNotice ( db . DefaultContext , storage . Attachments , "Delete issue attachment" , newAttachment )
2021-09-08 11:19:30 -04:00
}
2019-05-29 22:22:26 -04:00
if len ( repo . Avatar ) > 0 {
2020-10-14 09:07:51 -04:00
if err := storage . RepoAvatars . Delete ( repo . CustomAvatarRelativePath ( ) ) ; err != nil {
return fmt . Errorf ( "Failed to remove %s: %v" , repo . Avatar , err )
2019-05-29 22:22:26 -04:00
}
}
2015-09-01 11:43:53 -04:00
return nil
2014-03-20 16:04:56 -04:00
}
2015-09-01 11:43:53 -04: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 11:43:53 -04:00
}
2015-08-17 16:03:11 -04: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 16:03:11 -04:00
if err != nil {
2019-04-02 03:48:31 -04:00
log . Error ( "Select %s: %v" , checker . desc , err )
2015-08-17 16:03:11 -04:00
return
}
2015-09-01 11:43:53 -04: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 11:43:53 -04: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 16:03:11 -04:00
if err != nil {
2019-04-02 03:48:31 -04:00
log . Error ( "Update %s[%d]: %v" , checker . desc , id , err )
2015-08-17 16:03:11 -04:00
}
}
2015-09-01 11:43:53 -04:00
}
2015-08-17 16:03:11 -04: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 05:11:15 -04: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 {
return repoStatsCorrectNumClosed ( ctx , id , false , "num_closed_issues" )
}
func repoStatsCorrectNumClosedPulls ( ctx context . Context , id int64 ) error {
return repoStatsCorrectNumClosed ( ctx , id , true , "num_closed_pulls" )
}
func repoStatsCorrectNumClosed ( 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_closed=? AND is_pull=?) WHERE id=?" , id , true , isPull , id )
return err
}
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 19:31:38 -04:00
func CheckRepoStats ( ctx context . Context ) error {
2015-09-01 11:43:53 -04:00
log . Trace ( "Doing: CheckRepoStats" )
2015-08-29 13:13:24 -04:00
2015-09-01 11:43:53 -04: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 11:43:53 -04: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 11:43:53 -04:00
"repository count 'num_stars'" ,
} ,
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'" ,
} ,
// Repository.NumClosedPulls
{
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 , true ) ,
repoStatsCorrectNumClosedPulls ,
"repository count 'num_closed_pulls'" ,
} ,
2015-09-01 11:43:53 -04: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 11:43:53 -04: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 05:11:15 -04:00
issues_model . UpdateMilestoneCounters ,
2022-01-17 13:31:58 -05:00
"milestone count 'num_closed_issues' and 'num_issues'" ,
} ,
2015-09-01 11:43:53 -04: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 11:43:53 -04:00
"user count 'num_repos'" ,
} ,
2015-10-29 20:40:57 -04: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 20:40:57 -04:00
"issue count 'num_comments'" ,
} ,
2015-09-01 11:43:53 -04:00
}
2020-05-16 19:31:38 -04:00
for _ , checker := range checkers {
2019-12-15 04:51:28 -05:00
select {
case <- ctx . Done ( ) :
2020-05-16 19:31:38 -04: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 19:31:38 -04:00
repoStatsCheck ( ctx , checker )
2019-12-15 04:51:28 -05:00
}
2015-09-01 11:43:53 -04:00
}
2016-05-27 21:23:39 -04:00
// FIXME: use checker when stop supporting old fork repo format.
2015-09-01 11:43:53 -04: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 13:13:24 -04:00
if err != nil {
2019-04-02 03:48:31 -04:00
log . Error ( "Select repository count 'num_forks': %v" , err )
2015-09-01 11:43:53 -04: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 19:31:38 -04: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 11:43:53 -04: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 11:43:53 -04:00
if err != nil {
2021-12-09 20:27:50 -05:00
log . Error ( "repo_model.GetRepositoryByID[%d]: %v" , id , err )
2015-09-01 11:43:53 -04:00
continue
}
2021-09-23 11:45:36 -04:00
rawResult , err := db . GetEngine ( db . DefaultContext ) . Query ( "SELECT COUNT(*) FROM `repository` WHERE fork_id=?" , repo . ID )
2015-09-01 11:43:53 -04:00
if err != nil {
2019-04-02 03:48:31 -04:00
log . Error ( "Select count of forks[%d]: %v" , repo . ID , err )
2015-09-01 11:43:53 -04:00
continue
}
repo . NumForks = int ( parseCountResult ( rawResult ) )
if err = UpdateRepository ( repo , false ) ; err != nil {
2019-04-02 03:48:31 -04:00
log . Error ( "UpdateRepository[%d]: %v" , id , err )
2015-09-01 11:43:53 -04:00
continue
}
2015-08-29 13:13:24 -04:00
}
}
2015-09-01 11:43:53 -04:00
// ***** END: Repository.NumForks *****
2020-05-16 19:31:38 -04:00
return nil
2015-03-21 08:55:00 -04: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 15:16:34 -04: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 15:16:34 -04:00
return
}
if len ( users ) == 0 {
break
}
2021-11-21 10:41:00 -05:00
if err = updateUserStarNumbers ( users ) ; err != nil {
2020-07-07 15:16:34 -04:00
return
}
}
log . Debug ( "recalculate Stars number for all user finished" )
return
}
2020-10-14 09:07:51 -04:00
2021-11-19 08:39:57 -05:00
// LinkedRepository returns the linked repo if any
2021-12-09 20:27:50 -05:00
func LinkedRepository ( a * repo_model . Attachment ) ( * repo_model . Repository , unit . Type , error ) {
2021-11-19 08:39:57 -05:00
if a . IssueID != 0 {
iss , err := GetIssueByID ( a . IssueID )
if err != nil {
return nil , unit . TypeIssues , err
}
2021-12-09 20:27:50 -05:00
repo , err := repo_model . GetRepositoryByID ( iss . RepoID )
2021-11-19 08:39:57 -05:00
unitType := unit . TypeIssues
if iss . IsPull {
unitType = unit . TypePullRequests
}
return repo , unitType , err
} else if a . ReleaseID != 0 {
2022-06-03 02:13:58 -04:00
rel , err := GetReleaseByID ( db . DefaultContext , a . ReleaseID )
2021-11-19 08:39:57 -05:00
if err != nil {
return nil , unit . TypeReleases , err
}
2021-12-09 20:27:50 -05:00
repo , err := repo_model . GetRepositoryByID ( rel . RepoID )
2021-11-19 08:39:57 -05:00
return repo , unit . TypeReleases , err
}
return nil , - 1 , nil
}
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 )
}
sess := db . GetEngine ( ctx )
// 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 10:08:52 -04: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" ,
}
}
}
if _ , err = sess . ID ( key . ID ) . Delete ( new ( asymkey_model . DeployKey ) ) ; err != nil {
return fmt . Errorf ( "delete deploy key [%d]: %v" , key . ID , err )
}
// Check if this is the last reference to same key content.
has , err := sess .
Where ( "key_id = ?" , key . KeyID ) .
Get ( new ( asymkey_model . DeployKey ) )
if err != nil {
return err
} else if ! has {
if err = asymkey_model . DeletePublicKeys ( ctx , key . KeyID ) ; err != nil {
return err
}
}
return nil
}