You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

org_team.go 24KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982
  1. // Copyright 2018 The Gitea Authors. All rights reserved.
  2. // Copyright 2016 The Gogs Authors. All rights reserved.
  3. // Use of this source code is governed by a MIT-style
  4. // license that can be found in the LICENSE file.
  5. package models
  6. import (
  7. "errors"
  8. "fmt"
  9. "sort"
  10. "strings"
  11. "code.gitea.io/gitea/modules/log"
  12. "code.gitea.io/gitea/modules/setting"
  13. "xorm.io/builder"
  14. "xorm.io/xorm"
  15. )
  16. const ownerTeamName = "Owners"
  17. // Team represents a organization team.
  18. type Team struct {
  19. ID int64 `xorm:"pk autoincr"`
  20. OrgID int64 `xorm:"INDEX"`
  21. LowerName string
  22. Name string
  23. Description string
  24. Authorize AccessMode
  25. Repos []*Repository `xorm:"-"`
  26. Members []*User `xorm:"-"`
  27. NumRepos int
  28. NumMembers int
  29. Units []*TeamUnit `xorm:"-"`
  30. IncludesAllRepositories bool `xorm:"NOT NULL DEFAULT false"`
  31. }
  32. // SearchTeamOptions holds the search options
  33. type SearchTeamOptions struct {
  34. UserID int64
  35. Keyword string
  36. OrgID int64
  37. IncludeDesc bool
  38. PageSize int
  39. Page int
  40. }
  41. // SearchTeam search for teams. Caller is responsible to check permissions.
  42. func SearchTeam(opts *SearchTeamOptions) ([]*Team, int64, error) {
  43. if opts.Page <= 0 {
  44. opts.Page = 1
  45. }
  46. if opts.PageSize == 0 {
  47. // Default limit
  48. opts.PageSize = 10
  49. }
  50. var cond = builder.NewCond()
  51. if len(opts.Keyword) > 0 {
  52. lowerKeyword := strings.ToLower(opts.Keyword)
  53. var keywordCond builder.Cond = builder.Like{"lower_name", lowerKeyword}
  54. if opts.IncludeDesc {
  55. keywordCond = keywordCond.Or(builder.Like{"LOWER(description)", lowerKeyword})
  56. }
  57. cond = cond.And(keywordCond)
  58. }
  59. cond = cond.And(builder.Eq{"org_id": opts.OrgID})
  60. sess := x.NewSession()
  61. defer sess.Close()
  62. count, err := sess.
  63. Where(cond).
  64. Count(new(Team))
  65. if err != nil {
  66. return nil, 0, err
  67. }
  68. sess = sess.Where(cond)
  69. if opts.PageSize == -1 {
  70. opts.PageSize = int(count)
  71. } else {
  72. sess = sess.Limit(opts.PageSize, (opts.Page-1)*opts.PageSize)
  73. }
  74. teams := make([]*Team, 0, opts.PageSize)
  75. if err = sess.
  76. OrderBy("lower_name").
  77. Find(&teams); err != nil {
  78. return nil, 0, err
  79. }
  80. return teams, count, nil
  81. }
  82. // ColorFormat provides a basic color format for a Team
  83. func (t *Team) ColorFormat(s fmt.State) {
  84. log.ColorFprintf(s, "%d:%s (OrgID: %d) %-v",
  85. log.NewColoredIDValue(t.ID),
  86. t.Name,
  87. log.NewColoredIDValue(t.OrgID),
  88. t.Authorize)
  89. }
  90. // GetUnits return a list of available units for a team
  91. func (t *Team) GetUnits() error {
  92. return t.getUnits(x)
  93. }
  94. func (t *Team) getUnits(e Engine) (err error) {
  95. if t.Units != nil {
  96. return nil
  97. }
  98. t.Units, err = getUnitsByTeamID(e, t.ID)
  99. return err
  100. }
  101. // GetUnitNames returns the team units names
  102. func (t *Team) GetUnitNames() (res []string) {
  103. for _, u := range t.Units {
  104. res = append(res, Units[u.Type].NameKey)
  105. }
  106. return
  107. }
  108. // HasWriteAccess returns true if team has at least write level access mode.
  109. func (t *Team) HasWriteAccess() bool {
  110. return t.Authorize >= AccessModeWrite
  111. }
  112. // IsOwnerTeam returns true if team is owner team.
  113. func (t *Team) IsOwnerTeam() bool {
  114. return t.Name == ownerTeamName
  115. }
  116. // IsMember returns true if given user is a member of team.
  117. func (t *Team) IsMember(userID int64) bool {
  118. isMember, err := IsTeamMember(t.OrgID, t.ID, userID)
  119. if err != nil {
  120. log.Error("IsMember: %v", err)
  121. return false
  122. }
  123. return isMember
  124. }
  125. func (t *Team) getRepositories(e Engine) error {
  126. if t.Repos != nil {
  127. return nil
  128. }
  129. return e.Join("INNER", "team_repo", "repository.id = team_repo.repo_id").
  130. Where("team_repo.team_id=?", t.ID).
  131. OrderBy("repository.name").
  132. Find(&t.Repos)
  133. }
  134. // GetRepositories returns all repositories in team of organization.
  135. func (t *Team) GetRepositories() error {
  136. return t.getRepositories(x)
  137. }
  138. func (t *Team) getMembers(e Engine) (err error) {
  139. t.Members, err = getTeamMembers(e, t.ID)
  140. return err
  141. }
  142. // GetMembers returns all members in team of organization.
  143. func (t *Team) GetMembers() (err error) {
  144. return t.getMembers(x)
  145. }
  146. // AddMember adds new membership of the team to the organization,
  147. // the user will have membership to the organization automatically when needed.
  148. func (t *Team) AddMember(userID int64) error {
  149. return AddTeamMember(t, userID)
  150. }
  151. // RemoveMember removes member from team of organization.
  152. func (t *Team) RemoveMember(userID int64) error {
  153. return RemoveTeamMember(t, userID)
  154. }
  155. func (t *Team) hasRepository(e Engine, repoID int64) bool {
  156. return hasTeamRepo(e, t.OrgID, t.ID, repoID)
  157. }
  158. // HasRepository returns true if given repository belong to team.
  159. func (t *Team) HasRepository(repoID int64) bool {
  160. return t.hasRepository(x, repoID)
  161. }
  162. func (t *Team) addRepository(e Engine, repo *Repository) (err error) {
  163. if err = addTeamRepo(e, t.OrgID, t.ID, repo.ID); err != nil {
  164. return err
  165. }
  166. if _, err = e.Incr("num_repos").ID(t.ID).Update(new(Team)); err != nil {
  167. return fmt.Errorf("update team: %v", err)
  168. }
  169. t.NumRepos++
  170. if err = repo.recalculateTeamAccesses(e, 0); err != nil {
  171. return fmt.Errorf("recalculateAccesses: %v", err)
  172. }
  173. // Make all team members watch this repo if enabled in global settings
  174. if setting.Service.AutoWatchNewRepos {
  175. if err = t.getMembers(e); err != nil {
  176. return fmt.Errorf("getMembers: %v", err)
  177. }
  178. for _, u := range t.Members {
  179. if err = watchRepo(e, u.ID, repo.ID, true); err != nil {
  180. return fmt.Errorf("watchRepo: %v", err)
  181. }
  182. }
  183. }
  184. return nil
  185. }
  186. // addAllRepositories adds all repositories to the team.
  187. // If the team already has some repositories they will be left unchanged.
  188. func (t *Team) addAllRepositories(e Engine) error {
  189. var orgRepos []Repository
  190. if err := e.Where("owner_id = ?", t.OrgID).Find(&orgRepos); err != nil {
  191. return fmt.Errorf("get org repos: %v", err)
  192. }
  193. for _, repo := range orgRepos {
  194. if !t.hasRepository(e, repo.ID) {
  195. if err := t.addRepository(e, &repo); err != nil {
  196. return fmt.Errorf("addRepository: %v", err)
  197. }
  198. }
  199. }
  200. return nil
  201. }
  202. // AddRepository adds new repository to team of organization.
  203. func (t *Team) AddRepository(repo *Repository) (err error) {
  204. if repo.OwnerID != t.OrgID {
  205. return errors.New("Repository does not belong to organization")
  206. } else if t.HasRepository(repo.ID) {
  207. return nil
  208. }
  209. sess := x.NewSession()
  210. defer sess.Close()
  211. if err = sess.Begin(); err != nil {
  212. return err
  213. }
  214. if err = t.addRepository(sess, repo); err != nil {
  215. return err
  216. }
  217. return sess.Commit()
  218. }
  219. // removeRepository removes a repository from a team and recalculates access
  220. // Note: Repository shall not be removed from team if it includes all repositories (unless the repository is deleted)
  221. func (t *Team) removeRepository(e Engine, repo *Repository, recalculate bool) (err error) {
  222. if err = removeTeamRepo(e, t.ID, repo.ID); err != nil {
  223. return err
  224. }
  225. t.NumRepos--
  226. if _, err = e.ID(t.ID).Cols("num_repos").Update(t); err != nil {
  227. return err
  228. }
  229. // Don't need to recalculate when delete a repository from organization.
  230. if recalculate {
  231. if err = repo.recalculateTeamAccesses(e, t.ID); err != nil {
  232. return err
  233. }
  234. }
  235. teamUsers, err := getTeamUsersByTeamID(e, t.ID)
  236. if err != nil {
  237. return fmt.Errorf("getTeamUsersByTeamID: %v", err)
  238. }
  239. for _, teamUser := range teamUsers {
  240. has, err := hasAccess(e, teamUser.UID, repo)
  241. if err != nil {
  242. return err
  243. } else if has {
  244. continue
  245. }
  246. if err = watchRepo(e, teamUser.UID, repo.ID, false); err != nil {
  247. return err
  248. }
  249. // Remove all IssueWatches a user has subscribed to in the repositories
  250. if err := removeIssueWatchersByRepoID(e, teamUser.UID, repo.ID); err != nil {
  251. return err
  252. }
  253. }
  254. return nil
  255. }
  256. // RemoveRepository removes repository from team of organization.
  257. // If the team shall include all repositories the request is ignored.
  258. func (t *Team) RemoveRepository(repoID int64) error {
  259. if !t.HasRepository(repoID) {
  260. return nil
  261. }
  262. if t.IncludesAllRepositories {
  263. return nil
  264. }
  265. repo, err := GetRepositoryByID(repoID)
  266. if err != nil {
  267. return err
  268. }
  269. sess := x.NewSession()
  270. defer sess.Close()
  271. if err = sess.Begin(); err != nil {
  272. return err
  273. }
  274. if err = t.removeRepository(sess, repo, true); err != nil {
  275. return err
  276. }
  277. return sess.Commit()
  278. }
  279. // UnitEnabled returns if the team has the given unit type enabled
  280. func (t *Team) UnitEnabled(tp UnitType) bool {
  281. return t.unitEnabled(x, tp)
  282. }
  283. func (t *Team) unitEnabled(e Engine, tp UnitType) bool {
  284. if err := t.getUnits(e); err != nil {
  285. log.Warn("Error loading team (ID: %d) units: %s", t.ID, err.Error())
  286. }
  287. for _, unit := range t.Units {
  288. if unit.Type == tp {
  289. return true
  290. }
  291. }
  292. return false
  293. }
  294. // IsUsableTeamName tests if a name could be as team name
  295. func IsUsableTeamName(name string) error {
  296. switch name {
  297. case "new":
  298. return ErrNameReserved{name}
  299. default:
  300. return nil
  301. }
  302. }
  303. // NewTeam creates a record of new team.
  304. // It's caller's responsibility to assign organization ID.
  305. func NewTeam(t *Team) (err error) {
  306. if len(t.Name) == 0 {
  307. return errors.New("empty team name")
  308. }
  309. if err = IsUsableTeamName(t.Name); err != nil {
  310. return err
  311. }
  312. has, err := x.ID(t.OrgID).Get(new(User))
  313. if err != nil {
  314. return err
  315. }
  316. if !has {
  317. return ErrOrgNotExist{t.OrgID, ""}
  318. }
  319. t.LowerName = strings.ToLower(t.Name)
  320. has, err = x.
  321. Where("org_id=?", t.OrgID).
  322. And("lower_name=?", t.LowerName).
  323. Get(new(Team))
  324. if err != nil {
  325. return err
  326. }
  327. if has {
  328. return ErrTeamAlreadyExist{t.OrgID, t.LowerName}
  329. }
  330. sess := x.NewSession()
  331. defer sess.Close()
  332. if err = sess.Begin(); err != nil {
  333. return err
  334. }
  335. if _, err = sess.Insert(t); err != nil {
  336. errRollback := sess.Rollback()
  337. if errRollback != nil {
  338. log.Error("NewTeam sess.Rollback: %v", errRollback)
  339. }
  340. return err
  341. }
  342. // insert units for team
  343. if len(t.Units) > 0 {
  344. for _, unit := range t.Units {
  345. unit.TeamID = t.ID
  346. }
  347. if _, err = sess.Insert(&t.Units); err != nil {
  348. errRollback := sess.Rollback()
  349. if errRollback != nil {
  350. log.Error("NewTeam sess.Rollback: %v", errRollback)
  351. }
  352. return err
  353. }
  354. }
  355. // Add all repositories to the team if it has access to all of them.
  356. if t.IncludesAllRepositories {
  357. err = t.addAllRepositories(sess)
  358. if err != nil {
  359. return fmt.Errorf("addAllRepositories: %v", err)
  360. }
  361. }
  362. // Update organization number of teams.
  363. if _, err = sess.Exec("UPDATE `user` SET num_teams=num_teams+1 WHERE id = ?", t.OrgID); err != nil {
  364. errRollback := sess.Rollback()
  365. if errRollback != nil {
  366. log.Error("NewTeam sess.Rollback: %v", errRollback)
  367. }
  368. return err
  369. }
  370. return sess.Commit()
  371. }
  372. func getTeam(e Engine, orgID int64, name string) (*Team, error) {
  373. t := &Team{
  374. OrgID: orgID,
  375. LowerName: strings.ToLower(name),
  376. }
  377. has, err := e.Get(t)
  378. if err != nil {
  379. return nil, err
  380. } else if !has {
  381. return nil, ErrTeamNotExist{orgID, 0, name}
  382. }
  383. return t, nil
  384. }
  385. // GetTeam returns team by given team name and organization.
  386. func GetTeam(orgID int64, name string) (*Team, error) {
  387. return getTeam(x, orgID, name)
  388. }
  389. // getOwnerTeam returns team by given team name and organization.
  390. func getOwnerTeam(e Engine, orgID int64) (*Team, error) {
  391. return getTeam(e, orgID, ownerTeamName)
  392. }
  393. func getTeamByID(e Engine, teamID int64) (*Team, error) {
  394. t := new(Team)
  395. has, err := e.ID(teamID).Get(t)
  396. if err != nil {
  397. return nil, err
  398. } else if !has {
  399. return nil, ErrTeamNotExist{0, teamID, ""}
  400. }
  401. return t, nil
  402. }
  403. // GetTeamByID returns team by given ID.
  404. func GetTeamByID(teamID int64) (*Team, error) {
  405. return getTeamByID(x, teamID)
  406. }
  407. // UpdateTeam updates information of team.
  408. func UpdateTeam(t *Team, authChanged bool, includeAllChanged bool) (err error) {
  409. if len(t.Name) == 0 {
  410. return errors.New("empty team name")
  411. }
  412. if len(t.Description) > 255 {
  413. t.Description = t.Description[:255]
  414. }
  415. sess := x.NewSession()
  416. defer sess.Close()
  417. if err = sess.Begin(); err != nil {
  418. return err
  419. }
  420. t.LowerName = strings.ToLower(t.Name)
  421. has, err := sess.
  422. Where("org_id=?", t.OrgID).
  423. And("lower_name=?", t.LowerName).
  424. And("id!=?", t.ID).
  425. Get(new(Team))
  426. if err != nil {
  427. return err
  428. } else if has {
  429. return ErrTeamAlreadyExist{t.OrgID, t.LowerName}
  430. }
  431. if _, err = sess.ID(t.ID).AllCols().Update(t); err != nil {
  432. return fmt.Errorf("update: %v", err)
  433. }
  434. // update units for team
  435. if len(t.Units) > 0 {
  436. for _, unit := range t.Units {
  437. unit.TeamID = t.ID
  438. }
  439. // Delete team-unit.
  440. if _, err := sess.
  441. Where("team_id=?", t.ID).
  442. Delete(new(TeamUnit)); err != nil {
  443. return err
  444. }
  445. if _, err = sess.Insert(&t.Units); err != nil {
  446. errRollback := sess.Rollback()
  447. if errRollback != nil {
  448. log.Error("UpdateTeam sess.Rollback: %v", errRollback)
  449. }
  450. return err
  451. }
  452. }
  453. // Update access for team members if needed.
  454. if authChanged {
  455. if err = t.getRepositories(sess); err != nil {
  456. return fmt.Errorf("getRepositories: %v", err)
  457. }
  458. for _, repo := range t.Repos {
  459. if err = repo.recalculateTeamAccesses(sess, 0); err != nil {
  460. return fmt.Errorf("recalculateTeamAccesses: %v", err)
  461. }
  462. }
  463. }
  464. // Add all repositories to the team if it has access to all of them.
  465. if includeAllChanged && t.IncludesAllRepositories {
  466. err = t.addAllRepositories(sess)
  467. if err != nil {
  468. return fmt.Errorf("addAllRepositories: %v", err)
  469. }
  470. }
  471. return sess.Commit()
  472. }
  473. // DeleteTeam deletes given team.
  474. // It's caller's responsibility to assign organization ID.
  475. func DeleteTeam(t *Team) error {
  476. if err := t.GetRepositories(); err != nil {
  477. return err
  478. }
  479. sess := x.NewSession()
  480. defer sess.Close()
  481. if err := sess.Begin(); err != nil {
  482. return err
  483. }
  484. if err := t.getMembers(sess); err != nil {
  485. return err
  486. }
  487. // Delete all accesses.
  488. for _, repo := range t.Repos {
  489. if err := repo.recalculateTeamAccesses(sess, t.ID); err != nil {
  490. return err
  491. }
  492. // Remove watches from all users and now unaccessible repos
  493. for _, user := range t.Members {
  494. has, err := hasAccess(sess, user.ID, repo)
  495. if err != nil {
  496. return err
  497. } else if has {
  498. continue
  499. }
  500. if err = watchRepo(sess, user.ID, repo.ID, false); err != nil {
  501. return err
  502. }
  503. // Remove all IssueWatches a user has subscribed to in the repositories
  504. if err = removeIssueWatchersByRepoID(sess, user.ID, repo.ID); err != nil {
  505. return err
  506. }
  507. }
  508. }
  509. // Delete team-repo
  510. if _, err := sess.
  511. Where("team_id=?", t.ID).
  512. Delete(new(TeamRepo)); err != nil {
  513. return err
  514. }
  515. // Delete team-user.
  516. if _, err := sess.
  517. Where("org_id=?", t.OrgID).
  518. Where("team_id=?", t.ID).
  519. Delete(new(TeamUser)); err != nil {
  520. return err
  521. }
  522. // Delete team-unit.
  523. if _, err := sess.
  524. Where("team_id=?", t.ID).
  525. Delete(new(TeamUnit)); err != nil {
  526. return err
  527. }
  528. // Delete team.
  529. if _, err := sess.ID(t.ID).Delete(new(Team)); err != nil {
  530. return err
  531. }
  532. // Update organization number of teams.
  533. if _, err := sess.Exec("UPDATE `user` SET num_teams=num_teams-1 WHERE id=?", t.OrgID); err != nil {
  534. return err
  535. }
  536. return sess.Commit()
  537. }
  538. // ___________ ____ ___
  539. // \__ ___/___ _____ _____ | | \______ ___________
  540. // | |_/ __ \\__ \ / \| | / ___// __ \_ __ \
  541. // | |\ ___/ / __ \| Y Y \ | /\___ \\ ___/| | \/
  542. // |____| \___ >____ /__|_| /______//____ >\___ >__|
  543. // \/ \/ \/ \/ \/
  544. // TeamUser represents an team-user relation.
  545. type TeamUser struct {
  546. ID int64 `xorm:"pk autoincr"`
  547. OrgID int64 `xorm:"INDEX"`
  548. TeamID int64 `xorm:"UNIQUE(s)"`
  549. UID int64 `xorm:"UNIQUE(s)"`
  550. }
  551. func isTeamMember(e Engine, orgID, teamID, userID int64) (bool, error) {
  552. return e.
  553. Where("org_id=?", orgID).
  554. And("team_id=?", teamID).
  555. And("uid=?", userID).
  556. Table("team_user").
  557. Exist()
  558. }
  559. // IsTeamMember returns true if given user is a member of team.
  560. func IsTeamMember(orgID, teamID, userID int64) (bool, error) {
  561. return isTeamMember(x, orgID, teamID, userID)
  562. }
  563. func getTeamUsersByTeamID(e Engine, teamID int64) ([]*TeamUser, error) {
  564. teamUsers := make([]*TeamUser, 0, 10)
  565. return teamUsers, e.
  566. Where("team_id=?", teamID).
  567. Find(&teamUsers)
  568. }
  569. func getTeamMembers(e Engine, teamID int64) (_ []*User, err error) {
  570. teamUsers, err := getTeamUsersByTeamID(e, teamID)
  571. if err != nil {
  572. return nil, fmt.Errorf("get team-users: %v", err)
  573. }
  574. members := make([]*User, len(teamUsers))
  575. for i, teamUser := range teamUsers {
  576. member, err := getUserByID(e, teamUser.UID)
  577. if err != nil {
  578. return nil, fmt.Errorf("get user '%d': %v", teamUser.UID, err)
  579. }
  580. members[i] = member
  581. }
  582. sort.Slice(members, func(i, j int) bool {
  583. return members[i].DisplayName() < members[j].DisplayName()
  584. })
  585. return members, nil
  586. }
  587. // GetTeamMembers returns all members in given team of organization.
  588. func GetTeamMembers(teamID int64) ([]*User, error) {
  589. return getTeamMembers(x, teamID)
  590. }
  591. func getUserTeams(e Engine, userID int64) (teams []*Team, err error) {
  592. return teams, e.
  593. Join("INNER", "team_user", "team_user.team_id = team.id").
  594. Where("team_user.uid=?", userID).
  595. Find(&teams)
  596. }
  597. func getUserOrgTeams(e Engine, orgID, userID int64) (teams []*Team, err error) {
  598. return teams, e.
  599. Join("INNER", "team_user", "team_user.team_id = team.id").
  600. Where("team.org_id = ?", orgID).
  601. And("team_user.uid=?", userID).
  602. Find(&teams)
  603. }
  604. func getUserRepoTeams(e Engine, orgID, userID, repoID int64) (teams []*Team, err error) {
  605. return teams, e.
  606. Join("INNER", "team_user", "team_user.team_id = team.id").
  607. Join("INNER", "team_repo", "team_repo.team_id = team.id").
  608. Where("team.org_id = ?", orgID).
  609. And("team_user.uid=?", userID).
  610. And("team_repo.repo_id=?", repoID).
  611. Find(&teams)
  612. }
  613. // GetUserOrgTeams returns all teams that user belongs to in given organization.
  614. func GetUserOrgTeams(orgID, userID int64) ([]*Team, error) {
  615. return getUserOrgTeams(x, orgID, userID)
  616. }
  617. // GetUserTeams returns all teams that user belongs across all organizations.
  618. func GetUserTeams(userID int64) ([]*Team, error) {
  619. return getUserTeams(x, userID)
  620. }
  621. // AddTeamMember adds new membership of given team to given organization,
  622. // the user will have membership to given organization automatically when needed.
  623. func AddTeamMember(team *Team, userID int64) error {
  624. isAlreadyMember, err := IsTeamMember(team.OrgID, team.ID, userID)
  625. if err != nil || isAlreadyMember {
  626. return err
  627. }
  628. if err := AddOrgUser(team.OrgID, userID); err != nil {
  629. return err
  630. }
  631. // Get team and its repositories.
  632. if err := team.GetRepositories(); err != nil {
  633. return err
  634. }
  635. sess := x.NewSession()
  636. defer sess.Close()
  637. if err := sess.Begin(); err != nil {
  638. return err
  639. }
  640. if _, err := sess.Insert(&TeamUser{
  641. UID: userID,
  642. OrgID: team.OrgID,
  643. TeamID: team.ID,
  644. }); err != nil {
  645. return err
  646. } else if _, err := sess.Incr("num_members").ID(team.ID).Update(new(Team)); err != nil {
  647. return err
  648. }
  649. team.NumMembers++
  650. // Give access to team repositories.
  651. for _, repo := range team.Repos {
  652. if err := repo.recalculateUserAccess(sess, userID); err != nil {
  653. return err
  654. }
  655. if setting.Service.AutoWatchNewRepos {
  656. if err = watchRepo(sess, userID, repo.ID, true); err != nil {
  657. return err
  658. }
  659. }
  660. }
  661. return sess.Commit()
  662. }
  663. func removeTeamMember(e *xorm.Session, team *Team, userID int64) error {
  664. isMember, err := isTeamMember(e, team.OrgID, team.ID, userID)
  665. if err != nil || !isMember {
  666. return err
  667. }
  668. // Check if the user to delete is the last member in owner team.
  669. if team.IsOwnerTeam() && team.NumMembers == 1 {
  670. return ErrLastOrgOwner{UID: userID}
  671. }
  672. team.NumMembers--
  673. if err := team.getRepositories(e); err != nil {
  674. return err
  675. }
  676. if _, err := e.Delete(&TeamUser{
  677. UID: userID,
  678. OrgID: team.OrgID,
  679. TeamID: team.ID,
  680. }); err != nil {
  681. return err
  682. } else if _, err = e.
  683. ID(team.ID).
  684. Cols("num_members").
  685. Update(team); err != nil {
  686. return err
  687. }
  688. // Delete access to team repositories.
  689. for _, repo := range team.Repos {
  690. if err := repo.recalculateUserAccess(e, userID); err != nil {
  691. return err
  692. }
  693. // Remove watches from now unaccessible
  694. has, err := hasAccess(e, userID, repo)
  695. if err != nil {
  696. return err
  697. } else if has {
  698. continue
  699. }
  700. if err = watchRepo(e, userID, repo.ID, false); err != nil {
  701. return err
  702. }
  703. // Remove all IssueWatches a user has subscribed to in the repositories
  704. if err := removeIssueWatchersByRepoID(e, userID, repo.ID); err != nil {
  705. return err
  706. }
  707. }
  708. // Check if the user is a member of any team in the organization.
  709. if count, err := e.Count(&TeamUser{
  710. UID: userID,
  711. OrgID: team.OrgID,
  712. }); err != nil {
  713. return err
  714. } else if count == 0 {
  715. return removeOrgUser(e, team.OrgID, userID)
  716. }
  717. return nil
  718. }
  719. // RemoveTeamMember removes member from given team of given organization.
  720. func RemoveTeamMember(team *Team, userID int64) error {
  721. sess := x.NewSession()
  722. defer sess.Close()
  723. if err := sess.Begin(); err != nil {
  724. return err
  725. }
  726. if err := removeTeamMember(sess, team, userID); err != nil {
  727. return err
  728. }
  729. return sess.Commit()
  730. }
  731. // IsUserInTeams returns if a user in some teams
  732. func IsUserInTeams(userID int64, teamIDs []int64) (bool, error) {
  733. return x.Where("uid=?", userID).In("team_id", teamIDs).Exist(new(TeamUser))
  734. }
  735. // UsersInTeamsCount counts the number of users which are in userIDs and teamIDs
  736. func UsersInTeamsCount(userIDs []int64, teamIDs []int64) (int64, error) {
  737. var ids []int64
  738. if err := x.In("uid", userIDs).In("team_id", teamIDs).
  739. Table("team_user").
  740. Cols("uid").GroupBy("uid").Find(&ids); err != nil {
  741. return 0, err
  742. }
  743. return int64(len(ids)), nil
  744. }
  745. // ___________ __________
  746. // \__ ___/___ _____ _____\______ \ ____ ______ ____
  747. // | |_/ __ \\__ \ / \| _// __ \\____ \ / _ \
  748. // | |\ ___/ / __ \| Y Y \ | \ ___/| |_> > <_> )
  749. // |____| \___ >____ /__|_| /____|_ /\___ > __/ \____/
  750. // \/ \/ \/ \/ \/|__|
  751. // TeamRepo represents an team-repository relation.
  752. type TeamRepo struct {
  753. ID int64 `xorm:"pk autoincr"`
  754. OrgID int64 `xorm:"INDEX"`
  755. TeamID int64 `xorm:"UNIQUE(s)"`
  756. RepoID int64 `xorm:"UNIQUE(s)"`
  757. }
  758. func hasTeamRepo(e Engine, orgID, teamID, repoID int64) bool {
  759. has, _ := e.
  760. Where("org_id=?", orgID).
  761. And("team_id=?", teamID).
  762. And("repo_id=?", repoID).
  763. Get(new(TeamRepo))
  764. return has
  765. }
  766. // HasTeamRepo returns true if given repository belongs to team.
  767. func HasTeamRepo(orgID, teamID, repoID int64) bool {
  768. return hasTeamRepo(x, orgID, teamID, repoID)
  769. }
  770. func addTeamRepo(e Engine, orgID, teamID, repoID int64) error {
  771. _, err := e.InsertOne(&TeamRepo{
  772. OrgID: orgID,
  773. TeamID: teamID,
  774. RepoID: repoID,
  775. })
  776. return err
  777. }
  778. func removeTeamRepo(e Engine, teamID, repoID int64) error {
  779. _, err := e.Delete(&TeamRepo{
  780. TeamID: teamID,
  781. RepoID: repoID,
  782. })
  783. return err
  784. }
  785. // GetTeamsWithAccessToRepo returns all teams in an organization that have given access level to the repository.
  786. func GetTeamsWithAccessToRepo(orgID, repoID int64, mode AccessMode) ([]*Team, error) {
  787. teams := make([]*Team, 0, 5)
  788. return teams, x.Where("team.authorize >= ?", mode).
  789. Join("INNER", "team_repo", "team_repo.team_id = team.id").
  790. And("team_repo.org_id = ?", orgID).
  791. And("team_repo.repo_id = ?", repoID).
  792. Find(&teams)
  793. }
  794. // ___________ ____ ___ .__ __
  795. // \__ ___/___ _____ _____ | | \____ |__|/ |_
  796. // | |_/ __ \\__ \ / \| | / \| \ __\
  797. // | |\ ___/ / __ \| Y Y \ | / | \ || |
  798. // |____| \___ >____ /__|_| /______/|___| /__||__|
  799. // \/ \/ \/ \/
  800. // TeamUnit describes all units of a repository
  801. type TeamUnit struct {
  802. ID int64 `xorm:"pk autoincr"`
  803. OrgID int64 `xorm:"INDEX"`
  804. TeamID int64 `xorm:"UNIQUE(s)"`
  805. Type UnitType `xorm:"UNIQUE(s)"`
  806. }
  807. // Unit returns Unit
  808. func (t *TeamUnit) Unit() Unit {
  809. return Units[t.Type]
  810. }
  811. func getUnitsByTeamID(e Engine, teamID int64) (units []*TeamUnit, err error) {
  812. return units, e.Where("team_id = ?", teamID).Find(&units)
  813. }
  814. // UpdateTeamUnits updates a teams's units
  815. func UpdateTeamUnits(team *Team, units []TeamUnit) (err error) {
  816. sess := x.NewSession()
  817. defer sess.Close()
  818. if err = sess.Begin(); err != nil {
  819. return err
  820. }
  821. if _, err = sess.Where("team_id = ?", team.ID).Delete(new(TeamUnit)); err != nil {
  822. return err
  823. }
  824. if _, err = sess.Insert(units); err != nil {
  825. errRollback := sess.Rollback()
  826. if errRollback != nil {
  827. log.Error("UpdateTeamUnits sess.Rollback: %v", errRollback)
  828. }
  829. return err
  830. }
  831. return sess.Commit()
  832. }