2017-02-27 00:45:03 +00: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 (
"fmt"
"strings"
2019-02-18 16:00:27 +00:00
"code.gitea.io/gitea/modules/structs"
2017-10-26 21:16:13 +00:00
"code.gitea.io/gitea/modules/util"
2019-06-23 15:22:43 +00:00
"xorm.io/builder"
2021-03-29 17:12:21 +00:00
"xorm.io/xorm"
2017-02-27 00:45:03 +00:00
)
2017-12-31 14:45:46 +00:00
// RepositoryListDefaultPageSize is the default number of repositories
// to load in memory when running administrative tasks on all (or almost
// all) of them.
// The number should be low enough to avoid filling up all RAM with
// repository data...
const RepositoryListDefaultPageSize = 64
2017-02-27 00:45:03 +00:00
// RepositoryList contains a list of repositories
type RepositoryList [ ] * Repository
2017-12-04 04:39:01 +00:00
func ( repos RepositoryList ) Len ( ) int {
return len ( repos )
}
func ( repos RepositoryList ) Less ( i , j int ) bool {
return repos [ i ] . FullName ( ) < repos [ j ] . FullName ( )
}
func ( repos RepositoryList ) Swap ( i , j int ) {
repos [ i ] , repos [ j ] = repos [ j ] , repos [ i ]
}
2017-08-03 05:09:16 +00:00
// RepositoryListOfMap make list from values of map
func RepositoryListOfMap ( repoMap map [ int64 ] * Repository ) RepositoryList {
return RepositoryList ( valuesRepository ( repoMap ) )
}
2017-02-27 00:45:03 +00:00
func ( repos RepositoryList ) loadAttributes ( e Engine ) error {
if len ( repos ) == 0 {
return nil
}
2017-03-11 08:50:12 +00:00
set := make ( map [ int64 ] struct { } )
2020-02-11 09:34:17 +00:00
repoIDs := make ( [ ] int64 , len ( repos ) )
2017-02-27 00:45:03 +00:00
for i := range repos {
2017-03-11 08:50:12 +00:00
set [ repos [ i ] . OwnerID ] = struct { } { }
2020-02-11 09:34:17 +00:00
repoIDs [ i ] = repos [ i ] . ID
2017-02-27 00:45:03 +00:00
}
2020-02-11 09:34:17 +00:00
// Load owners.
2017-03-11 08:50:12 +00:00
users := make ( map [ int64 ] * User , len ( set ) )
2017-02-27 00:45:03 +00:00
if err := e .
Where ( "id > 0" ) .
2017-03-11 08:50:12 +00:00
In ( "id" , keysInt64 ( set ) ) .
2017-02-27 00:45:03 +00:00
Find ( & users ) ; err != nil {
return fmt . Errorf ( "find users: %v" , err )
}
for i := range repos {
2017-03-11 08:50:12 +00:00
repos [ i ] . Owner = users [ repos [ i ] . OwnerID ]
2017-02-27 00:45:03 +00:00
}
2020-02-11 09:34:17 +00:00
// Load primary language.
stats := make ( LanguageStatList , 0 , len ( repos ) )
if err := e .
Where ( "`is_primary` = ? AND `language` != ?" , true , "other" ) .
In ( "`repo_id`" , repoIDs ) .
Find ( & stats ) ; err != nil {
return fmt . Errorf ( "find primary languages: %v" , err )
}
stats . loadAttributes ( )
for i := range repos {
for _ , st := range stats {
if st . RepoID == repos [ i ] . ID {
repos [ i ] . PrimaryLanguage = st
break
}
}
}
2017-02-27 00:45:03 +00:00
return nil
}
// LoadAttributes loads the attributes for the given RepositoryList
func ( repos RepositoryList ) LoadAttributes ( ) error {
return repos . loadAttributes ( x )
}
// MirrorRepositoryList contains the mirror repositories
type MirrorRepositoryList [ ] * Repository
func ( repos MirrorRepositoryList ) loadAttributes ( e Engine ) error {
if len ( repos ) == 0 {
return nil
}
// Load mirrors.
repoIDs := make ( [ ] int64 , 0 , len ( repos ) )
for i := range repos {
if ! repos [ i ] . IsMirror {
continue
}
repoIDs = append ( repoIDs , repos [ i ] . ID )
}
mirrors := make ( [ ] * Mirror , 0 , len ( repoIDs ) )
if err := e .
Where ( "id > 0" ) .
In ( "repo_id" , repoIDs ) .
Find ( & mirrors ) ; err != nil {
return fmt . Errorf ( "find mirrors: %v" , err )
}
set := make ( map [ int64 ] * Mirror )
for i := range mirrors {
set [ mirrors [ i ] . RepoID ] = mirrors [ i ]
}
for i := range repos {
repos [ i ] . Mirror = set [ repos [ i ] . ID ]
}
return nil
}
// LoadAttributes loads the attributes for the given MirrorRepositoryList
func ( repos MirrorRepositoryList ) LoadAttributes ( ) error {
return repos . loadAttributes ( x )
}
// SearchRepoOptions holds the search options
type SearchRepoOptions struct {
2020-01-24 19:00:29 +00:00
ListOptions
2020-01-13 17:33:46 +00:00
Actor * User
2019-11-11 15:15:29 +00:00
Keyword string
OwnerID int64
PriorityOwnerID int64
2020-12-27 19:58:03 +00:00
TeamID int64
2019-11-11 15:15:29 +00:00
OrderBy SearchOrderBy
Private bool // Include private repositories in results
StarredByID int64
2021-04-15 16:53:57 +00:00
WatchedByID int64
2020-01-05 18:48:47 +00:00
AllPublic bool // Include also all public repositories of users and public organisations
AllLimited bool // Include also all public repositories of limited organisations
2020-05-21 01:15:30 +00:00
// None -> include public and private
// True -> include just private
2021-07-08 11:38:13 +00:00
// False -> include just public
2020-05-21 01:15:30 +00:00
IsPrivate util . OptionalBool
2017-10-26 21:16:13 +00:00
// None -> include collaborative AND non-collaborative
// True -> include just collaborative
2021-07-08 11:38:13 +00:00
// False -> include just non-collaborative
2017-10-26 21:16:13 +00:00
Collaborate util . OptionalBool
// None -> include forks AND non-forks
// True -> include just forks
// False -> include just non-forks
Fork util . OptionalBool
2019-11-11 15:15:29 +00:00
// None -> include templates AND non-templates
// True -> include just templates
// False -> include just non-templates
Template util . OptionalBool
2017-10-26 21:16:13 +00:00
// None -> include mirrors AND non-mirrors
// True -> include just mirrors
// False -> include just non-mirrors
Mirror util . OptionalBool
2020-05-16 20:07:01 +00:00
// None -> include archived AND non-archived
// True -> include just archived
// False -> include just non-archived
Archived util . OptionalBool
2018-09-13 02:33:48 +00:00
// only search topic name
TopicOnly bool
2019-08-25 17:06:36 +00:00
// include description in keyword search
IncludeDescription bool
2020-03-31 07:47:00 +00:00
// None -> include has milestones AND has no milestone
// True -> include just has milestones
// False -> include just has no milestone
HasMilestones util . OptionalBool
2020-09-25 04:09:23 +00:00
// LowerNames represents valid lower names to restrict to
LowerNames [ ] string
2017-02-27 00:45:03 +00:00
}
2021-03-14 18:52:12 +00:00
// SearchOrderBy is used to sort the result
2017-09-22 12:53:21 +00:00
type SearchOrderBy string
func ( s SearchOrderBy ) String ( ) string {
return string ( s )
}
// Strings for sorting result
const (
SearchOrderByAlphabetically SearchOrderBy = "name ASC"
2019-06-12 19:41:28 +00:00
SearchOrderByAlphabeticallyReverse SearchOrderBy = "name DESC"
SearchOrderByLeastUpdated SearchOrderBy = "updated_unix ASC"
SearchOrderByRecentUpdated SearchOrderBy = "updated_unix DESC"
SearchOrderByOldest SearchOrderBy = "created_unix ASC"
SearchOrderByNewest SearchOrderBy = "created_unix DESC"
SearchOrderBySize SearchOrderBy = "size ASC"
SearchOrderBySizeReverse SearchOrderBy = "size DESC"
SearchOrderByID SearchOrderBy = "id ASC"
SearchOrderByIDReverse SearchOrderBy = "id DESC"
SearchOrderByStars SearchOrderBy = "num_stars ASC"
SearchOrderByStarsReverse SearchOrderBy = "num_stars DESC"
SearchOrderByForks SearchOrderBy = "num_forks ASC"
SearchOrderByForksReverse SearchOrderBy = "num_forks DESC"
2017-09-22 12:53:21 +00:00
)
2020-03-29 05:27:06 +00:00
// SearchRepositoryCondition creates a query condition according search repository options
func SearchRepositoryCondition ( opts * SearchRepoOptions ) builder . Cond {
2021-03-14 18:52:12 +00:00
cond := builder . NewCond ( )
2017-08-24 14:01:03 +00:00
2019-05-15 15:24:39 +00:00
if opts . Private {
2020-01-13 17:33:46 +00:00
if opts . Actor != nil && ! opts . Actor . IsAdmin && opts . Actor . ID != opts . OwnerID {
2019-05-15 15:24:39 +00:00
// OK we're in the context of a User
2020-01-13 17:33:46 +00:00
cond = cond . And ( accessibleRepositoryCondition ( opts . Actor ) )
2019-05-15 15:24:39 +00:00
}
} else {
// Not looking at private organisations
2020-05-16 20:07:01 +00:00
// We should be able to see all non-private repositories that
// isn't in a private or limited organisation.
cond = cond . And (
builder . Eq { "is_private" : false } ,
builder . NotIn ( "owner_id" , builder . Select ( "id" ) . From ( "`user`" ) . Where (
builder . And (
builder . Eq { "type" : UserTypeOrganization } ,
builder . Or ( builder . Eq { "visibility" : structs . VisibleTypeLimited } , builder . Eq { "visibility" : structs . VisibleTypePrivate } ) ,
) ) ) )
}
2020-05-21 01:15:30 +00:00
if opts . IsPrivate != util . OptionalBoolNone {
cond = cond . And ( builder . Eq { "is_private" : opts . IsPrivate . IsTrue ( ) } )
2017-10-17 15:20:22 +00:00
}
2017-08-24 14:01:03 +00:00
2019-11-11 15:15:29 +00:00
if opts . Template != util . OptionalBoolNone {
cond = cond . And ( builder . Eq { "is_template" : opts . Template == util . OptionalBoolTrue } )
}
2019-05-15 15:24:39 +00:00
// Restrict to starred repositories
if opts . StarredByID > 0 {
cond = cond . And ( builder . In ( "id" , builder . Select ( "repo_id" ) . From ( "star" ) . Where ( builder . Eq { "uid" : opts . StarredByID } ) ) )
}
2021-04-15 16:53:57 +00:00
// Restrict to watched repositories
if opts . WatchedByID > 0 {
cond = cond . And ( builder . In ( "id" , builder . Select ( "repo_id" ) . From ( "watch" ) . Where ( builder . Eq { "user_id" : opts . WatchedByID } ) ) )
}
2019-05-15 15:24:39 +00:00
// Restrict repositories to those the OwnerID owns or contributes to as per opts.Collaborate
2017-10-17 15:20:22 +00:00
if opts . OwnerID > 0 {
2021-03-14 18:52:12 +00:00
accessCond := builder . NewCond ( )
2019-05-15 15:24:39 +00:00
if opts . Collaborate != util . OptionalBoolTrue {
accessCond = builder . Eq { "owner_id" : opts . OwnerID }
}
2017-08-24 14:01:03 +00:00
2019-05-15 15:24:39 +00:00
if opts . Collaborate != util . OptionalBoolFalse {
2020-05-17 23:27:54 +00:00
// A Collaboration is:
2019-05-15 15:24:39 +00:00
collaborateCond := builder . And (
2020-05-17 23:27:54 +00:00
// 1. Repository we don't own
builder . Neq { "owner_id" : opts . OwnerID } ,
// 2. But we can see because of:
2019-05-15 15:24:39 +00:00
builder . Or (
2020-05-17 23:27:54 +00:00
// A. We have access
builder . In ( "`repository`.id" ,
builder . Select ( "`access`.repo_id" ) .
From ( "access" ) .
Where ( builder . Eq { "`access`.user_id" : opts . OwnerID } ) ) ,
// B. We are in a team for
builder . In ( "`repository`.id" , builder . Select ( "`team_repo`.repo_id" ) .
2019-05-15 15:24:39 +00:00
From ( "team_repo" ) .
Where ( builder . Eq { "`team_user`.uid" : opts . OwnerID } ) .
2020-05-17 23:27:54 +00:00
Join ( "INNER" , "team_user" , "`team_user`.team_id = `team_repo`.team_id" ) ) ,
// C. Public repositories in private organizations that we are member of
builder . And (
builder . Eq { "`repository`.is_private" : false } ,
builder . In ( "`repository`.owner_id" ,
builder . Select ( "`org_user`.org_id" ) .
From ( "org_user" ) .
Join ( "INNER" , "`user`" , "`user`.id = `org_user`.org_id" ) .
Where ( builder . Eq {
"`org_user`.uid" : opts . OwnerID ,
"`user`.type" : UserTypeOrganization ,
"`user`.visibility" : structs . VisibleTypePrivate ,
} ) ) ) ) ,
)
2019-05-15 15:24:39 +00:00
if ! opts . Private {
collaborateCond = collaborateCond . And ( builder . Expr ( "owner_id NOT IN (SELECT org_id FROM org_user WHERE org_user.uid = ? AND org_user.is_public = ?)" , opts . OwnerID , false ) )
2017-08-24 14:01:03 +00:00
}
2019-05-15 15:24:39 +00:00
accessCond = accessCond . Or ( collaborateCond )
}
2017-10-26 21:16:13 +00:00
2019-05-15 15:24:39 +00:00
if opts . AllPublic {
2020-01-05 18:48:47 +00:00
accessCond = accessCond . Or ( builder . Eq { "is_private" : false } . And ( builder . In ( "owner_id" , builder . Select ( "`user`.id" ) . From ( "`user`" ) . Where ( builder . Eq { "`user`.visibility" : structs . VisibleTypePublic } ) ) ) )
}
if opts . AllLimited {
accessCond = accessCond . Or ( builder . Eq { "is_private" : false } . And ( builder . In ( "owner_id" , builder . Select ( "`user`.id" ) . From ( "`user`" ) . Where ( builder . Eq { "`user`.visibility" : structs . VisibleTypeLimited } ) ) ) )
2017-10-17 15:20:22 +00:00
}
2019-05-15 15:24:39 +00:00
cond = cond . And ( accessCond )
2017-02-27 00:45:03 +00:00
}
2020-12-27 19:58:03 +00:00
if opts . TeamID > 0 {
cond = cond . And ( builder . In ( "`repository`.id" , builder . Select ( "`team_repo`.repo_id" ) . From ( "team_repo" ) . Where ( builder . Eq { "`team_repo`.team_id" : opts . TeamID } ) ) )
}
2017-10-10 20:37:18 +00:00
if opts . Keyword != "" {
2018-10-18 03:14:28 +00:00
// separate keyword
2021-03-14 18:52:12 +00:00
subQueryCond := builder . NewCond ( )
2018-10-18 03:14:28 +00:00
for _ , v := range strings . Split ( opts . Keyword , "," ) {
2019-08-23 02:37:35 +00:00
if opts . TopicOnly {
subQueryCond = subQueryCond . Or ( builder . Eq { "topic.name" : strings . ToLower ( v ) } )
} else {
subQueryCond = subQueryCond . Or ( builder . Like { "topic.name" , strings . ToLower ( v ) } )
}
2018-10-30 21:48:37 +00:00
}
subQuery := builder . Select ( "repo_topic.repo_id" ) . From ( "repo_topic" ) .
Join ( "INNER" , "topic" , "topic.id = repo_topic.topic_id" ) .
Where ( subQueryCond ) .
GroupBy ( "repo_topic.repo_id" )
2021-03-14 18:52:12 +00:00
keywordCond := builder . In ( "id" , subQuery )
2018-10-30 21:48:37 +00:00
if ! opts . TopicOnly {
2021-03-14 18:52:12 +00:00
likes := builder . NewCond ( )
2018-10-30 21:48:37 +00:00
for _ , v := range strings . Split ( opts . Keyword , "," ) {
likes = likes . Or ( builder . Like { "lower_name" , strings . ToLower ( v ) } )
2019-08-25 17:06:36 +00:00
if opts . IncludeDescription {
likes = likes . Or ( builder . Like { "LOWER(description)" , strings . ToLower ( v ) } )
}
2018-10-18 03:14:28 +00:00
}
2018-10-30 21:48:37 +00:00
keywordCond = keywordCond . Or ( likes )
2018-09-13 02:33:48 +00:00
}
cond = cond . And ( keywordCond )
2017-10-10 20:37:18 +00:00
}
2017-10-26 21:16:13 +00:00
if opts . Fork != util . OptionalBoolNone {
cond = cond . And ( builder . Eq { "is_fork" : opts . Fork == util . OptionalBoolTrue } )
}
if opts . Mirror != util . OptionalBoolNone {
cond = cond . And ( builder . Eq { "is_mirror" : opts . Mirror == util . OptionalBoolTrue } )
}
2020-01-13 17:33:46 +00:00
if opts . Actor != nil && opts . Actor . IsRestricted {
cond = cond . And ( accessibleRepositoryCondition ( opts . Actor ) )
}
2020-03-31 07:47:00 +00:00
2020-05-16 20:07:01 +00:00
if opts . Archived != util . OptionalBoolNone {
cond = cond . And ( builder . Eq { "is_archived" : opts . Archived == util . OptionalBoolTrue } )
}
2020-03-31 07:47:00 +00:00
switch opts . HasMilestones {
case util . OptionalBoolTrue :
cond = cond . And ( builder . Gt { "num_milestones" : 0 } )
case util . OptionalBoolFalse :
cond = cond . And ( builder . Eq { "num_milestones" : 0 } . Or ( builder . IsNull { "num_milestones" } ) )
}
2020-03-29 05:27:06 +00:00
return cond
}
// SearchRepository returns repositories based on search options,
// it returns results in given range and number of total results.
func SearchRepository ( opts * SearchRepoOptions ) ( RepositoryList , int64 , error ) {
cond := SearchRepositoryCondition ( opts )
2020-03-31 07:47:00 +00:00
return SearchRepositoryByCondition ( opts , cond , true )
}
2020-03-29 05:27:06 +00:00
2020-03-31 07:47:00 +00:00
// SearchRepositoryByCondition search repositories by condition
func SearchRepositoryByCondition ( opts * SearchRepoOptions , cond builder . Cond , loadAttributes bool ) ( RepositoryList , int64 , error ) {
2021-03-29 17:12:21 +00:00
sess , count , err := searchRepositoryByCondition ( opts , cond )
if err != nil {
return nil , 0 , err
}
defer sess . Close ( )
defaultSize := 50
if opts . PageSize > 0 {
defaultSize = opts . PageSize
}
repos := make ( RepositoryList , 0 , defaultSize )
if err := sess . Find ( & repos ) ; err != nil {
return nil , 0 , fmt . Errorf ( "Repo: %v" , err )
}
if opts . PageSize <= 0 {
count = int64 ( len ( repos ) )
}
if loadAttributes {
if err := repos . loadAttributes ( sess ) ; err != nil {
return nil , 0 , fmt . Errorf ( "LoadAttributes: %v" , err )
}
}
return repos , count , nil
}
func searchRepositoryByCondition ( opts * SearchRepoOptions , cond builder . Cond ) ( * xorm . Session , int64 , error ) {
2020-03-29 05:27:06 +00:00
if opts . Page <= 0 {
opts . Page = 1
}
2020-01-13 17:33:46 +00:00
2017-02-27 00:45:03 +00:00
if len ( opts . OrderBy ) == 0 {
2017-09-22 12:53:21 +00:00
opts . OrderBy = SearchOrderByAlphabetically
2017-02-27 00:45:03 +00:00
}
2019-11-11 15:15:29 +00:00
if opts . PriorityOwnerID > 0 {
opts . OrderBy = SearchOrderBy ( fmt . Sprintf ( "CASE WHEN owner_id = %d THEN 0 ELSE owner_id END, %s" , opts . PriorityOwnerID , opts . OrderBy ) )
}
2017-08-23 01:30:54 +00:00
sess := x . NewSession ( )
2021-03-29 17:12:21 +00:00
var count int64
if opts . PageSize > 0 {
var err error
count , err = sess .
Where ( cond ) .
Count ( new ( Repository ) )
if err != nil {
_ = sess . Close ( )
return nil , 0 , fmt . Errorf ( "Count: %v" , err )
}
2017-10-17 15:20:22 +00:00
}
2020-03-31 07:47:00 +00:00
sess . Where ( cond ) . OrderBy ( opts . OrderBy . String ( ) )
if opts . PageSize > 0 {
sess . Limit ( opts . PageSize , ( opts . Page - 1 ) * opts . PageSize )
}
2021-03-29 17:12:21 +00:00
return sess , count , nil
2017-02-27 00:45:03 +00:00
}
2018-03-16 14:04:33 +00:00
2019-10-28 18:31:55 +00:00
// accessibleRepositoryCondition takes a user a returns a condition for checking if a repository is accessible
2020-01-13 17:33:46 +00:00
func accessibleRepositoryCondition ( user * User ) builder . Cond {
2021-03-14 18:52:12 +00:00
cond := builder . NewCond ( )
2020-01-13 17:33:46 +00:00
2020-01-28 11:39:37 +00:00
if user == nil || ! user . IsRestricted || user . ID <= 0 {
2020-01-13 17:33:46 +00:00
orgVisibilityLimit := [ ] structs . VisibleType { structs . VisibleTypePrivate }
2020-01-28 11:39:37 +00:00
if user == nil || user . ID <= 0 {
2020-01-13 17:33:46 +00:00
orgVisibilityLimit = append ( orgVisibilityLimit , structs . VisibleTypeLimited )
}
2019-10-28 18:31:55 +00:00
// 1. Be able to see all non-private repositories that either:
2020-01-13 17:33:46 +00:00
cond = cond . Or ( builder . And (
2019-10-28 18:31:55 +00:00
builder . Eq { "`repository`.is_private" : false } ,
2020-03-29 14:31:10 +00:00
// 2. Aren't in an private organisation or limited organisation if we're not logged in
builder . NotIn ( "`repository`.owner_id" , builder . Select ( "id" ) . From ( "`user`" ) . Where (
builder . And (
builder . Eq { "type" : UserTypeOrganization } ,
builder . In ( "visibility" , orgVisibilityLimit ) ) ,
) ) ) )
2020-01-13 17:33:46 +00:00
}
if user != nil {
2020-05-17 08:22:17 +00:00
cond = cond . Or (
// 2. Be able to see all repositories that we have access to
2019-11-11 15:15:29 +00:00
builder . In ( "`repository`.id" , builder . Select ( "repo_id" ) .
From ( "`access`" ) .
Where ( builder . And (
2020-01-13 17:33:46 +00:00
builder . Eq { "user_id" : user . ID } ,
2019-11-11 15:15:29 +00:00
builder . Gt { "mode" : int ( AccessModeNone ) } ) ) ) ,
2020-05-17 08:22:17 +00:00
// 3. Repositories that we directly own
builder . Eq { "`repository`.owner_id" : user . ID } ,
// 4. Be able to see all repositories that we are in a team
builder . In ( "`repository`.id" , builder . Select ( "`team_repo`.repo_id" ) .
From ( "team_repo" ) .
Where ( builder . Eq { "`team_user`.uid" : user . ID } ) .
Join ( "INNER" , "team_user" , "`team_user`.team_id = `team_repo`.team_id" ) ) ,
// 5. Be able to see all public repos in private organizations that we are an org_user of
builder . And ( builder . Eq { "`repository`.is_private" : false } ,
builder . In ( "`repository`.owner_id" ,
builder . Select ( "`org_user`.org_id" ) .
From ( "org_user" ) .
Where ( builder . Eq { "`org_user`.uid" : user . ID } ) ) ) )
2020-01-13 17:33:46 +00:00
}
return cond
2019-10-28 18:31:55 +00:00
}
2019-08-25 17:06:36 +00:00
// SearchRepositoryByName takes keyword and part of repository name to search,
// it returns results in given range and number of total results.
func SearchRepositoryByName ( opts * SearchRepoOptions ) ( RepositoryList , int64 , error ) {
opts . IncludeDescription = false
return SearchRepository ( opts )
}
2021-03-29 17:12:21 +00:00
// SearchRepositoryIDs takes keyword and part of repository name to search,
// it returns results in given range and number of total results.
func SearchRepositoryIDs ( opts * SearchRepoOptions ) ( [ ] int64 , int64 , error ) {
opts . IncludeDescription = false
cond := SearchRepositoryCondition ( opts )
sess , count , err := searchRepositoryByCondition ( opts , cond )
if err != nil {
return nil , 0 , err
}
defer sess . Close ( )
defaultSize := 50
if opts . PageSize > 0 {
defaultSize = opts . PageSize
}
ids := make ( [ ] int64 , 0 , defaultSize )
err = sess . Select ( "id" ) . Table ( "repository" ) . Find ( & ids )
if opts . PageSize <= 0 {
count = int64 ( len ( ids ) )
}
return ids , count , err
}
2020-01-13 17:33:46 +00:00
// AccessibleRepoIDsQuery queries accessible repository ids. Usable as a subquery wherever repo ids need to be filtered.
2020-01-28 11:39:37 +00:00
func AccessibleRepoIDsQuery ( user * User ) * builder . Builder {
// NB: Please note this code needs to still work if user is nil
2020-01-13 17:33:46 +00:00
return builder . Select ( "id" ) . From ( "repository" ) . Where ( accessibleRepositoryCondition ( user ) )
}
2018-03-16 14:04:33 +00:00
2020-01-13 17:33:46 +00:00
// FindUserAccessibleRepoIDs find all accessible repositories' ID by user's id
func FindUserAccessibleRepoIDs ( user * User ) ( [ ] int64 , error ) {
2018-03-16 14:04:33 +00:00
repoIDs := make ( [ ] int64 , 0 , 10 )
if err := x .
Table ( "repository" ) .
Cols ( "id" ) .
2020-01-13 17:33:46 +00:00
Where ( accessibleRepositoryCondition ( user ) ) .
2018-03-16 14:04:33 +00:00
Find ( & repoIDs ) ; err != nil {
return nil , fmt . Errorf ( "FindUserAccesibleRepoIDs: %v" , err )
}
return repoIDs , nil
}