repo_branch.go 7.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257
  1. // Copyright 2016 The Gogs 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. "github.com/Unknwon/com"
  9. "github.com/gogits/git-module"
  10. "github.com/gogits/gogs/pkg/tool"
  11. )
  12. type Branch struct {
  13. RepoPath string
  14. Name string
  15. IsProtected bool
  16. Commit *git.Commit
  17. }
  18. func GetBranchesByPath(path string) ([]*Branch, error) {
  19. gitRepo, err := git.OpenRepository(path)
  20. if err != nil {
  21. return nil, err
  22. }
  23. brs, err := gitRepo.GetBranches()
  24. if err != nil {
  25. return nil, err
  26. }
  27. branches := make([]*Branch, len(brs))
  28. for i := range brs {
  29. branches[i] = &Branch{
  30. RepoPath: path,
  31. Name: brs[i],
  32. }
  33. }
  34. return branches, nil
  35. }
  36. func (repo *Repository) GetBranch(br string) (*Branch, error) {
  37. if !git.IsBranchExist(repo.RepoPath(), br) {
  38. return nil, ErrBranchNotExist{br}
  39. }
  40. return &Branch{
  41. RepoPath: repo.RepoPath(),
  42. Name: br,
  43. }, nil
  44. }
  45. func (repo *Repository) GetBranches() ([]*Branch, error) {
  46. return GetBranchesByPath(repo.RepoPath())
  47. }
  48. func (br *Branch) GetCommit() (*git.Commit, error) {
  49. gitRepo, err := git.OpenRepository(br.RepoPath)
  50. if err != nil {
  51. return nil, err
  52. }
  53. return gitRepo.GetBranchCommit(br.Name)
  54. }
  55. type ProtectBranchWhitelist struct {
  56. ID int64
  57. ProtectBranchID int64
  58. RepoID int64 `xorm:"UNIQUE(protect_branch_whitelist)"`
  59. Name string `xorm:"UNIQUE(protect_branch_whitelist)"`
  60. UserID int64 `xorm:"UNIQUE(protect_branch_whitelist)"`
  61. }
  62. // IsUserInProtectBranchWhitelist returns true if given user is in the whitelist of a branch in a repository.
  63. func IsUserInProtectBranchWhitelist(repoID, userID int64, branch string) bool {
  64. has, err := x.Where("repo_id = ?", repoID).And("user_id = ?", userID).And("name = ?", branch).Get(new(ProtectBranchWhitelist))
  65. return has && err == nil
  66. }
  67. // ProtectBranch contains options of a protected branch.
  68. type ProtectBranch struct {
  69. ID int64
  70. RepoID int64 `xorm:"UNIQUE(protect_branch)"`
  71. Name string `xorm:"UNIQUE(protect_branch)"`
  72. Protected bool
  73. RequirePullRequest bool
  74. EnableWhitelist bool
  75. WhitelistUserIDs string `xorm:"TEXT"`
  76. WhitelistTeamIDs string `xorm:"TEXT"`
  77. }
  78. // GetProtectBranchOfRepoByName returns *ProtectBranch by branch name in given repostiory.
  79. func GetProtectBranchOfRepoByName(repoID int64, name string) (*ProtectBranch, error) {
  80. protectBranch := &ProtectBranch{
  81. RepoID: repoID,
  82. Name: name,
  83. }
  84. has, err := x.Get(protectBranch)
  85. if err != nil {
  86. return nil, err
  87. } else if !has {
  88. return nil, ErrBranchNotExist{name}
  89. }
  90. return protectBranch, nil
  91. }
  92. // IsBranchOfRepoRequirePullRequest returns true if branch requires pull request in given repository.
  93. func IsBranchOfRepoRequirePullRequest(repoID int64, name string) bool {
  94. protectBranch, err := GetProtectBranchOfRepoByName(repoID, name)
  95. if err != nil {
  96. return false
  97. }
  98. return protectBranch.Protected && protectBranch.RequirePullRequest
  99. }
  100. // UpdateProtectBranch saves branch protection options.
  101. // If ID is 0, it creates a new record. Otherwise, updates existing record.
  102. func UpdateProtectBranch(protectBranch *ProtectBranch) (err error) {
  103. sess := x.NewSession()
  104. defer sess.Close()
  105. if err = sess.Begin(); err != nil {
  106. return err
  107. }
  108. if protectBranch.ID == 0 {
  109. if _, err = sess.Insert(protectBranch); err != nil {
  110. return fmt.Errorf("Insert: %v", err)
  111. }
  112. }
  113. if _, err = sess.Id(protectBranch.ID).AllCols().Update(protectBranch); err != nil {
  114. return fmt.Errorf("Update: %v", err)
  115. }
  116. return sess.Commit()
  117. }
  118. // UpdateOrgProtectBranch saves branch protection options of organizational repository.
  119. // If ID is 0, it creates a new record. Otherwise, updates existing record.
  120. // This function also performs check if whitelist user and team's IDs have been changed
  121. // to avoid unnecessary whitelist delete and regenerate.
  122. func UpdateOrgProtectBranch(repo *Repository, protectBranch *ProtectBranch, whitelistUserIDs, whitelistTeamIDs string) (err error) {
  123. if err = repo.GetOwner(); err != nil {
  124. return fmt.Errorf("GetOwner: %v", err)
  125. } else if !repo.Owner.IsOrganization() {
  126. return fmt.Errorf("expect repository owner to be an organization")
  127. }
  128. hasUsersChanged := false
  129. validUserIDs := tool.StringsToInt64s(strings.Split(protectBranch.WhitelistUserIDs, ","))
  130. if protectBranch.WhitelistUserIDs != whitelistUserIDs {
  131. hasUsersChanged = true
  132. userIDs := tool.StringsToInt64s(strings.Split(whitelistUserIDs, ","))
  133. validUserIDs = make([]int64, 0, len(userIDs))
  134. for _, userID := range userIDs {
  135. has, err := HasAccess(userID, repo, ACCESS_MODE_WRITE)
  136. if err != nil {
  137. return fmt.Errorf("HasAccess [user_id: %d, repo_id: %d]: %v", userID, protectBranch.RepoID, err)
  138. } else if !has {
  139. continue // Drop invalid user ID
  140. }
  141. validUserIDs = append(validUserIDs, userID)
  142. }
  143. protectBranch.WhitelistUserIDs = strings.Join(tool.Int64sToStrings(validUserIDs), ",")
  144. }
  145. hasTeamsChanged := false
  146. validTeamIDs := tool.StringsToInt64s(strings.Split(protectBranch.WhitelistTeamIDs, ","))
  147. if protectBranch.WhitelistTeamIDs != whitelistTeamIDs {
  148. hasTeamsChanged = true
  149. teamIDs := tool.StringsToInt64s(strings.Split(whitelistTeamIDs, ","))
  150. teams, err := GetTeamsHaveAccessToRepo(repo.OwnerID, repo.ID, ACCESS_MODE_WRITE)
  151. if err != nil {
  152. return fmt.Errorf("GetTeamsHaveAccessToRepo [org_id: %d, repo_id: %d]: %v", repo.OwnerID, repo.ID, err)
  153. }
  154. validTeamIDs = make([]int64, 0, len(teams))
  155. for i := range teams {
  156. if teams[i].HasWriteAccess() && com.IsSliceContainsInt64(teamIDs, teams[i].ID) {
  157. validTeamIDs = append(validTeamIDs, teams[i].ID)
  158. }
  159. }
  160. protectBranch.WhitelistTeamIDs = strings.Join(tool.Int64sToStrings(validTeamIDs), ",")
  161. }
  162. // Make sure protectBranch.ID is not 0 for whitelists
  163. if protectBranch.ID == 0 {
  164. if _, err = x.Insert(protectBranch); err != nil {
  165. return fmt.Errorf("Insert: %v", err)
  166. }
  167. }
  168. // Merge users and members of teams
  169. var whitelists []*ProtectBranchWhitelist
  170. if hasUsersChanged || hasTeamsChanged {
  171. mergedUserIDs := make(map[int64]bool)
  172. for _, userID := range validUserIDs {
  173. // Empty whitelist users can cause an ID with 0
  174. if userID != 0 {
  175. mergedUserIDs[userID] = true
  176. }
  177. }
  178. for _, teamID := range validTeamIDs {
  179. members, err := GetTeamMembers(teamID)
  180. if err != nil {
  181. return fmt.Errorf("GetTeamMembers [team_id: %d]: %v", teamID, err)
  182. }
  183. for i := range members {
  184. mergedUserIDs[members[i].ID] = true
  185. }
  186. }
  187. whitelists = make([]*ProtectBranchWhitelist, 0, len(mergedUserIDs))
  188. for userID := range mergedUserIDs {
  189. whitelists = append(whitelists, &ProtectBranchWhitelist{
  190. ProtectBranchID: protectBranch.ID,
  191. RepoID: repo.ID,
  192. Name: protectBranch.Name,
  193. UserID: userID,
  194. })
  195. }
  196. }
  197. sess := x.NewSession()
  198. defer sess.Close()
  199. if err = sess.Begin(); err != nil {
  200. return err
  201. }
  202. if _, err = sess.Id(protectBranch.ID).AllCols().Update(protectBranch); err != nil {
  203. return fmt.Errorf("Update: %v", err)
  204. }
  205. // Refresh whitelists
  206. if hasUsersChanged || hasTeamsChanged {
  207. if _, err = sess.Delete(&ProtectBranchWhitelist{ProtectBranchID: protectBranch.ID}); err != nil {
  208. return fmt.Errorf("delete old protect branch whitelists: %v", err)
  209. } else if _, err = sess.Insert(whitelists); err != nil {
  210. return fmt.Errorf("insert new protect branch whitelists: %v", err)
  211. }
  212. }
  213. return sess.Commit()
  214. }
  215. // GetProtectBranchesByRepoID returns a list of *ProtectBranch in given repostiory.
  216. func GetProtectBranchesByRepoID(repoID int64) ([]*ProtectBranch, error) {
  217. protectBranches := make([]*ProtectBranch, 0, 2)
  218. return protectBranches, x.Where("repo_id = ? and protected=true", repoID).Asc("name").Find(&protectBranches)
  219. }