repo_list.go 10 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333
  1. // Copyright 2017 The Gitea Authors. All rights reserved.
  2. // Use of this source code is governed by a MIT-style
  3. // license that can be found in the LICENSE file.
  4. package models
  5. import (
  6. "fmt"
  7. "strings"
  8. "code.gitea.io/gitea/modules/structs"
  9. "code.gitea.io/gitea/modules/util"
  10. "github.com/go-xorm/builder"
  11. )
  12. // RepositoryListDefaultPageSize is the default number of repositories
  13. // to load in memory when running administrative tasks on all (or almost
  14. // all) of them.
  15. // The number should be low enough to avoid filling up all RAM with
  16. // repository data...
  17. const RepositoryListDefaultPageSize = 64
  18. // RepositoryList contains a list of repositories
  19. type RepositoryList []*Repository
  20. func (repos RepositoryList) Len() int {
  21. return len(repos)
  22. }
  23. func (repos RepositoryList) Less(i, j int) bool {
  24. return repos[i].FullName() < repos[j].FullName()
  25. }
  26. func (repos RepositoryList) Swap(i, j int) {
  27. repos[i], repos[j] = repos[j], repos[i]
  28. }
  29. // RepositoryListOfMap make list from values of map
  30. func RepositoryListOfMap(repoMap map[int64]*Repository) RepositoryList {
  31. return RepositoryList(valuesRepository(repoMap))
  32. }
  33. func (repos RepositoryList) loadAttributes(e Engine) error {
  34. if len(repos) == 0 {
  35. return nil
  36. }
  37. // Load owners.
  38. set := make(map[int64]struct{})
  39. for i := range repos {
  40. set[repos[i].OwnerID] = struct{}{}
  41. }
  42. users := make(map[int64]*User, len(set))
  43. if err := e.
  44. Where("id > 0").
  45. In("id", keysInt64(set)).
  46. Find(&users); err != nil {
  47. return fmt.Errorf("find users: %v", err)
  48. }
  49. for i := range repos {
  50. repos[i].Owner = users[repos[i].OwnerID]
  51. }
  52. return nil
  53. }
  54. // LoadAttributes loads the attributes for the given RepositoryList
  55. func (repos RepositoryList) LoadAttributes() error {
  56. return repos.loadAttributes(x)
  57. }
  58. // MirrorRepositoryList contains the mirror repositories
  59. type MirrorRepositoryList []*Repository
  60. func (repos MirrorRepositoryList) loadAttributes(e Engine) error {
  61. if len(repos) == 0 {
  62. return nil
  63. }
  64. // Load mirrors.
  65. repoIDs := make([]int64, 0, len(repos))
  66. for i := range repos {
  67. if !repos[i].IsMirror {
  68. continue
  69. }
  70. repoIDs = append(repoIDs, repos[i].ID)
  71. }
  72. mirrors := make([]*Mirror, 0, len(repoIDs))
  73. if err := e.
  74. Where("id > 0").
  75. In("repo_id", repoIDs).
  76. Find(&mirrors); err != nil {
  77. return fmt.Errorf("find mirrors: %v", err)
  78. }
  79. set := make(map[int64]*Mirror)
  80. for i := range mirrors {
  81. set[mirrors[i].RepoID] = mirrors[i]
  82. }
  83. for i := range repos {
  84. repos[i].Mirror = set[repos[i].ID]
  85. }
  86. return nil
  87. }
  88. // LoadAttributes loads the attributes for the given MirrorRepositoryList
  89. func (repos MirrorRepositoryList) LoadAttributes() error {
  90. return repos.loadAttributes(x)
  91. }
  92. // SearchRepoOptions holds the search options
  93. type SearchRepoOptions struct {
  94. UserID int64
  95. UserIsAdmin bool
  96. Keyword string
  97. OwnerID int64
  98. OrderBy SearchOrderBy
  99. Private bool // Include private repositories in results
  100. StarredByID int64
  101. Page int
  102. IsProfile bool
  103. AllPublic bool // Include also all public repositories
  104. PageSize int // Can be smaller than or equal to setting.ExplorePagingNum
  105. // None -> include collaborative AND non-collaborative
  106. // True -> include just collaborative
  107. // False -> incude just non-collaborative
  108. Collaborate util.OptionalBool
  109. // None -> include forks AND non-forks
  110. // True -> include just forks
  111. // False -> include just non-forks
  112. Fork util.OptionalBool
  113. // None -> include mirrors AND non-mirrors
  114. // True -> include just mirrors
  115. // False -> include just non-mirrors
  116. Mirror util.OptionalBool
  117. // only search topic name
  118. TopicOnly bool
  119. }
  120. //SearchOrderBy is used to sort the result
  121. type SearchOrderBy string
  122. func (s SearchOrderBy) String() string {
  123. return string(s)
  124. }
  125. // Strings for sorting result
  126. const (
  127. SearchOrderByAlphabetically SearchOrderBy = "name ASC"
  128. SearchOrderByAlphabeticallyReverse = "name DESC"
  129. SearchOrderByLeastUpdated = "updated_unix ASC"
  130. SearchOrderByRecentUpdated = "updated_unix DESC"
  131. SearchOrderByOldest = "created_unix ASC"
  132. SearchOrderByNewest = "created_unix DESC"
  133. SearchOrderBySize = "size ASC"
  134. SearchOrderBySizeReverse = "size DESC"
  135. SearchOrderByID = "id ASC"
  136. SearchOrderByIDReverse = "id DESC"
  137. SearchOrderByStars = "num_stars ASC"
  138. SearchOrderByStarsReverse = "num_stars DESC"
  139. SearchOrderByForks = "num_forks ASC"
  140. SearchOrderByForksReverse = "num_forks DESC"
  141. )
  142. // SearchRepositoryByName takes keyword and part of repository name to search,
  143. // it returns results in given range and number of total results.
  144. func SearchRepositoryByName(opts *SearchRepoOptions) (RepositoryList, int64, error) {
  145. if opts.Page <= 0 {
  146. opts.Page = 1
  147. }
  148. var cond = builder.NewCond()
  149. if opts.Private {
  150. if !opts.UserIsAdmin && opts.UserID != 0 && opts.UserID != opts.OwnerID {
  151. // OK we're in the context of a User
  152. // We should be Either
  153. cond = cond.And(builder.Or(
  154. // 1. Be able to see all non-private repositories that either:
  155. cond.And(
  156. builder.Eq{"is_private": false},
  157. builder.Or(
  158. // A. Aren't in organisations __OR__
  159. builder.NotIn("owner_id", builder.Select("id").From("`user`").Where(builder.Eq{"type": UserTypeOrganization})),
  160. // B. Isn't a private organisation. (Limited is OK because we're logged in)
  161. builder.NotIn("owner_id", builder.Select("id").From("`user`").Where(builder.Eq{"visibility": structs.VisibleTypePrivate}))),
  162. ),
  163. // 2. Be able to see all repositories that we have access to
  164. builder.In("id", builder.Select("repo_id").
  165. From("`access`").
  166. Where(builder.And(
  167. builder.Eq{"user_id": opts.UserID},
  168. builder.Gt{"mode": int(AccessModeNone)}))),
  169. // 3. Be able to see all repositories that we are in a team
  170. builder.In("id", builder.Select("`team_repo`.repo_id").
  171. From("team_repo").
  172. Where(builder.Eq{"`team_user`.uid": opts.UserID}).
  173. Join("INNER", "team_user", "`team_user`.team_id = `team_repo`.team_id"))))
  174. }
  175. } else {
  176. // Not looking at private organisations
  177. // We should be able to see all non-private repositories that either:
  178. cond = cond.And(builder.Eq{"is_private": false})
  179. accessCond := builder.Or(
  180. // A. Aren't in organisations __OR__
  181. builder.NotIn("owner_id", builder.Select("id").From("`user`").Where(builder.Eq{"type": UserTypeOrganization})),
  182. // B. Isn't a private or limited organisation.
  183. builder.NotIn("owner_id", builder.Select("id").From("`user`").Where(builder.Or(builder.Eq{"visibility": structs.VisibleTypeLimited}, builder.Eq{"visibility": structs.VisibleTypePrivate}))))
  184. cond = cond.And(accessCond)
  185. }
  186. // Restrict to starred repositories
  187. if opts.StarredByID > 0 {
  188. cond = cond.And(builder.In("id", builder.Select("repo_id").From("star").Where(builder.Eq{"uid": opts.StarredByID})))
  189. }
  190. // Restrict repositories to those the OwnerID owns or contributes to as per opts.Collaborate
  191. if opts.OwnerID > 0 {
  192. var accessCond = builder.NewCond()
  193. if opts.Collaborate != util.OptionalBoolTrue {
  194. accessCond = builder.Eq{"owner_id": opts.OwnerID}
  195. }
  196. if opts.Collaborate != util.OptionalBoolFalse {
  197. collaborateCond := builder.And(
  198. builder.Or(
  199. builder.Expr("repository.id IN (SELECT repo_id FROM `access` WHERE access.user_id = ?)", opts.OwnerID),
  200. builder.In("id", builder.Select("`team_repo`.repo_id").
  201. From("team_repo").
  202. Where(builder.Eq{"`team_user`.uid": opts.OwnerID}).
  203. Join("INNER", "team_user", "`team_user`.team_id = `team_repo`.team_id"))),
  204. builder.Neq{"owner_id": opts.OwnerID})
  205. if !opts.Private {
  206. 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))
  207. }
  208. accessCond = accessCond.Or(collaborateCond)
  209. }
  210. if opts.AllPublic {
  211. accessCond = accessCond.Or(builder.Eq{"is_private": false})
  212. }
  213. cond = cond.And(accessCond)
  214. }
  215. if opts.Keyword != "" {
  216. // separate keyword
  217. var subQueryCond = builder.NewCond()
  218. for _, v := range strings.Split(opts.Keyword, ",") {
  219. subQueryCond = subQueryCond.Or(builder.Like{"topic.name", strings.ToLower(v)})
  220. }
  221. subQuery := builder.Select("repo_topic.repo_id").From("repo_topic").
  222. Join("INNER", "topic", "topic.id = repo_topic.topic_id").
  223. Where(subQueryCond).
  224. GroupBy("repo_topic.repo_id")
  225. var keywordCond = builder.In("id", subQuery)
  226. if !opts.TopicOnly {
  227. var likes = builder.NewCond()
  228. for _, v := range strings.Split(opts.Keyword, ",") {
  229. likes = likes.Or(builder.Like{"lower_name", strings.ToLower(v)})
  230. }
  231. keywordCond = keywordCond.Or(likes)
  232. }
  233. cond = cond.And(keywordCond)
  234. }
  235. if opts.Fork != util.OptionalBoolNone {
  236. cond = cond.And(builder.Eq{"is_fork": opts.Fork == util.OptionalBoolTrue})
  237. }
  238. if opts.Mirror != util.OptionalBoolNone {
  239. cond = cond.And(builder.Eq{"is_mirror": opts.Mirror == util.OptionalBoolTrue})
  240. }
  241. if len(opts.OrderBy) == 0 {
  242. opts.OrderBy = SearchOrderByAlphabetically
  243. }
  244. sess := x.NewSession()
  245. defer sess.Close()
  246. count, err := sess.
  247. Where(cond).
  248. Count(new(Repository))
  249. if err != nil {
  250. return nil, 0, fmt.Errorf("Count: %v", err)
  251. }
  252. repos := make(RepositoryList, 0, opts.PageSize)
  253. if err = sess.
  254. Where(cond).
  255. OrderBy(opts.OrderBy.String()).
  256. Limit(opts.PageSize, (opts.Page-1)*opts.PageSize).
  257. Find(&repos); err != nil {
  258. return nil, 0, fmt.Errorf("Repo: %v", err)
  259. }
  260. if !opts.IsProfile {
  261. if err = repos.loadAttributes(sess); err != nil {
  262. return nil, 0, fmt.Errorf("LoadAttributes: %v", err)
  263. }
  264. }
  265. return repos, count, nil
  266. }
  267. // FindUserAccessibleRepoIDs find all accessible repositories' ID by user's id
  268. func FindUserAccessibleRepoIDs(userID int64) ([]int64, error) {
  269. var accessCond builder.Cond = builder.Eq{"is_private": false}
  270. if userID > 0 {
  271. accessCond = accessCond.Or(
  272. builder.Eq{"owner_id": userID},
  273. builder.And(
  274. builder.Expr("id IN (SELECT repo_id FROM `access` WHERE access.user_id = ?)", userID),
  275. builder.Neq{"owner_id": userID},
  276. ),
  277. )
  278. }
  279. repoIDs := make([]int64, 0, 10)
  280. if err := x.
  281. Table("repository").
  282. Cols("id").
  283. Where(accessCond).
  284. Find(&repoIDs); err != nil {
  285. return nil, fmt.Errorf("FindUserAccesibleRepoIDs: %v", err)
  286. }
  287. return repoIDs, nil
  288. }