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.

repo.go 21KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708
  1. // Copyright 2014 The Gogs Authors. All rights reserved.
  2. // Copyright 2017 The Gitea 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 context
  6. import (
  7. "fmt"
  8. "io/ioutil"
  9. "net/url"
  10. "path"
  11. "strings"
  12. "code.gitea.io/gitea/models"
  13. "code.gitea.io/gitea/modules/cache"
  14. "code.gitea.io/gitea/modules/git"
  15. "code.gitea.io/gitea/modules/log"
  16. "code.gitea.io/gitea/modules/setting"
  17. "gitea.com/macaron/macaron"
  18. "github.com/unknwon/com"
  19. "gopkg.in/editorconfig/editorconfig-core-go.v1"
  20. )
  21. // PullRequest contains informations to make a pull request
  22. type PullRequest struct {
  23. BaseRepo *models.Repository
  24. Allowed bool
  25. SameRepo bool
  26. HeadInfo string // [<user>:]<branch>
  27. }
  28. // Repository contains information to operate a repository
  29. type Repository struct {
  30. models.Permission
  31. IsWatching bool
  32. IsViewBranch bool
  33. IsViewTag bool
  34. IsViewCommit bool
  35. Repository *models.Repository
  36. Owner *models.User
  37. Commit *git.Commit
  38. Tag *git.Tag
  39. GitRepo *git.Repository
  40. BranchName string
  41. TagName string
  42. TreePath string
  43. CommitID string
  44. RepoLink string
  45. CloneLink models.CloneLink
  46. CommitsCount int64
  47. Mirror *models.Mirror
  48. PullRequest *PullRequest
  49. }
  50. // CanEnableEditor returns true if repository is editable and user has proper access level.
  51. func (r *Repository) CanEnableEditor() bool {
  52. return r.Permission.CanWrite(models.UnitTypeCode) && r.Repository.CanEnableEditor() && r.IsViewBranch && !r.Repository.IsArchived
  53. }
  54. // CanCreateBranch returns true if repository is editable and user has proper access level.
  55. func (r *Repository) CanCreateBranch() bool {
  56. return r.Permission.CanWrite(models.UnitTypeCode) && r.Repository.CanCreateBranch()
  57. }
  58. // RepoMustNotBeArchived checks if a repo is archived
  59. func RepoMustNotBeArchived() macaron.Handler {
  60. return func(ctx *Context) {
  61. if ctx.Repo.Repository.IsArchived {
  62. ctx.NotFound("IsArchived", fmt.Errorf(ctx.Tr("repo.archive.title")))
  63. }
  64. }
  65. }
  66. // CanCommitToBranch returns true if repository is editable and user has proper access level
  67. // and branch is not protected for push
  68. func (r *Repository) CanCommitToBranch(doer *models.User) (bool, error) {
  69. protectedBranch, err := r.Repository.IsProtectedBranchForPush(r.BranchName, doer)
  70. if err != nil {
  71. return false, err
  72. }
  73. return r.CanEnableEditor() && !protectedBranch, nil
  74. }
  75. // CanUseTimetracker returns whether or not a user can use the timetracker.
  76. func (r *Repository) CanUseTimetracker(issue *models.Issue, user *models.User) bool {
  77. // Checking for following:
  78. // 1. Is timetracker enabled
  79. // 2. Is the user a contributor, admin, poster or assignee and do the repository policies require this?
  80. isAssigned, _ := models.IsUserAssignedToIssue(issue, user)
  81. return r.Repository.IsTimetrackerEnabled() && (!r.Repository.AllowOnlyContributorsToTrackTime() ||
  82. r.Permission.CanWrite(models.UnitTypeIssues) || issue.IsPoster(user.ID) || isAssigned)
  83. }
  84. // CanCreateIssueDependencies returns whether or not a user can create dependencies.
  85. func (r *Repository) CanCreateIssueDependencies(user *models.User) bool {
  86. return r.Permission.CanWrite(models.UnitTypeIssues) && r.Repository.IsDependenciesEnabled()
  87. }
  88. // GetCommitsCount returns cached commit count for current view
  89. func (r *Repository) GetCommitsCount() (int64, error) {
  90. var contextName string
  91. if r.IsViewBranch {
  92. contextName = r.BranchName
  93. } else if r.IsViewTag {
  94. contextName = r.TagName
  95. } else {
  96. contextName = r.CommitID
  97. }
  98. return cache.GetInt64(r.Repository.GetCommitsCountCacheKey(contextName, r.IsViewBranch || r.IsViewTag), func() (int64, error) {
  99. return r.Commit.CommitsCount()
  100. })
  101. }
  102. // BranchNameSubURL sub-URL for the BranchName field
  103. func (r *Repository) BranchNameSubURL() string {
  104. switch {
  105. case r.IsViewBranch:
  106. return "branch/" + r.BranchName
  107. case r.IsViewTag:
  108. return "tag/" + r.BranchName
  109. case r.IsViewCommit:
  110. return "commit/" + r.BranchName
  111. }
  112. log.Error("Unknown view type for repo: %v", r)
  113. return ""
  114. }
  115. // FileExists returns true if a file exists in the given repo branch
  116. func (r *Repository) FileExists(path string, branch string) (bool, error) {
  117. if branch == "" {
  118. branch = r.Repository.DefaultBranch
  119. }
  120. commit, err := r.GitRepo.GetBranchCommit(branch)
  121. if err != nil {
  122. return false, err
  123. }
  124. if _, err := commit.GetTreeEntryByPath(path); err != nil {
  125. return false, err
  126. }
  127. return true, nil
  128. }
  129. // GetEditorconfig returns the .editorconfig definition if found in the
  130. // HEAD of the default repo branch.
  131. func (r *Repository) GetEditorconfig() (*editorconfig.Editorconfig, error) {
  132. if r.GitRepo == nil {
  133. return nil, nil
  134. }
  135. commit, err := r.GitRepo.GetBranchCommit(r.Repository.DefaultBranch)
  136. if err != nil {
  137. return nil, err
  138. }
  139. treeEntry, err := commit.GetTreeEntryByPath(".editorconfig")
  140. if err != nil {
  141. return nil, err
  142. }
  143. if treeEntry.Blob().Size() >= setting.UI.MaxDisplayFileSize {
  144. return nil, git.ErrNotExist{ID: "", RelPath: ".editorconfig"}
  145. }
  146. reader, err := treeEntry.Blob().DataAsync()
  147. if err != nil {
  148. return nil, err
  149. }
  150. defer reader.Close()
  151. data, err := ioutil.ReadAll(reader)
  152. if err != nil {
  153. return nil, err
  154. }
  155. return editorconfig.ParseBytes(data)
  156. }
  157. // RetrieveBaseRepo retrieves base repository
  158. func RetrieveBaseRepo(ctx *Context, repo *models.Repository) {
  159. // Non-fork repository will not return error in this method.
  160. if err := repo.GetBaseRepo(); err != nil {
  161. if models.IsErrRepoNotExist(err) {
  162. repo.IsFork = false
  163. repo.ForkID = 0
  164. return
  165. }
  166. ctx.ServerError("GetBaseRepo", err)
  167. return
  168. } else if err = repo.BaseRepo.GetOwner(); err != nil {
  169. ctx.ServerError("BaseRepo.GetOwner", err)
  170. return
  171. }
  172. }
  173. // ComposeGoGetImport returns go-get-import meta content.
  174. func ComposeGoGetImport(owner, repo string) string {
  175. /// setting.AppUrl is guaranteed to be parse as url
  176. appURL, _ := url.Parse(setting.AppURL)
  177. return path.Join(appURL.Host, setting.AppSubURL, url.PathEscape(owner), url.PathEscape(repo))
  178. }
  179. // EarlyResponseForGoGetMeta responses appropriate go-get meta with status 200
  180. // if user does not have actual access to the requested repository,
  181. // or the owner or repository does not exist at all.
  182. // This is particular a workaround for "go get" command which does not respect
  183. // .netrc file.
  184. func EarlyResponseForGoGetMeta(ctx *Context) {
  185. username := ctx.Params(":username")
  186. reponame := strings.TrimSuffix(ctx.Params(":reponame"), ".git")
  187. if username == "" || reponame == "" {
  188. ctx.PlainText(400, []byte("invalid repository path"))
  189. return
  190. }
  191. ctx.PlainText(200, []byte(com.Expand(`<meta name="go-import" content="{GoGetImport} git {CloneLink}">`,
  192. map[string]string{
  193. "GoGetImport": ComposeGoGetImport(username, reponame),
  194. "CloneLink": models.ComposeHTTPSCloneURL(username, reponame),
  195. })))
  196. }
  197. // RedirectToRepo redirect to a differently-named repository
  198. func RedirectToRepo(ctx *Context, redirectRepoID int64) {
  199. ownerName := ctx.Params(":username")
  200. previousRepoName := ctx.Params(":reponame")
  201. repo, err := models.GetRepositoryByID(redirectRepoID)
  202. if err != nil {
  203. ctx.ServerError("GetRepositoryByID", err)
  204. return
  205. }
  206. redirectPath := strings.Replace(
  207. ctx.Req.URL.Path,
  208. fmt.Sprintf("%s/%s", ownerName, previousRepoName),
  209. fmt.Sprintf("%s/%s", repo.MustOwnerName(), repo.Name),
  210. 1,
  211. )
  212. if ctx.Req.URL.RawQuery != "" {
  213. redirectPath += "?" + ctx.Req.URL.RawQuery
  214. }
  215. ctx.Redirect(path.Join(setting.AppSubURL, redirectPath))
  216. }
  217. func repoAssignment(ctx *Context, repo *models.Repository) {
  218. var err error
  219. if err = repo.GetOwner(); err != nil {
  220. ctx.ServerError("GetOwner", err)
  221. return
  222. }
  223. ctx.Repo.Permission, err = models.GetUserRepoPermission(repo, ctx.User)
  224. if err != nil {
  225. ctx.ServerError("GetUserRepoPermission", err)
  226. return
  227. }
  228. // Check access.
  229. if ctx.Repo.Permission.AccessMode == models.AccessModeNone {
  230. if ctx.Query("go-get") == "1" {
  231. EarlyResponseForGoGetMeta(ctx)
  232. return
  233. }
  234. ctx.NotFound("no access right", nil)
  235. return
  236. }
  237. ctx.Data["HasAccess"] = true
  238. ctx.Data["Permission"] = &ctx.Repo.Permission
  239. if repo.IsMirror {
  240. var err error
  241. ctx.Repo.Mirror, err = models.GetMirrorByRepoID(repo.ID)
  242. if err != nil {
  243. ctx.ServerError("GetMirror", err)
  244. return
  245. }
  246. ctx.Data["MirrorEnablePrune"] = ctx.Repo.Mirror.EnablePrune
  247. ctx.Data["MirrorInterval"] = ctx.Repo.Mirror.Interval
  248. ctx.Data["Mirror"] = ctx.Repo.Mirror
  249. }
  250. ctx.Repo.Repository = repo
  251. ctx.Data["RepoName"] = ctx.Repo.Repository.Name
  252. ctx.Data["IsEmptyRepo"] = ctx.Repo.Repository.IsEmpty
  253. }
  254. // RepoIDAssignment returns a macaron handler which assigns the repo to the context.
  255. func RepoIDAssignment() macaron.Handler {
  256. return func(ctx *Context) {
  257. repoID := ctx.ParamsInt64(":repoid")
  258. // Get repository.
  259. repo, err := models.GetRepositoryByID(repoID)
  260. if err != nil {
  261. if models.IsErrRepoNotExist(err) {
  262. ctx.NotFound("GetRepositoryByID", nil)
  263. } else {
  264. ctx.ServerError("GetRepositoryByID", err)
  265. }
  266. return
  267. }
  268. repoAssignment(ctx, repo)
  269. }
  270. }
  271. // RepoAssignment returns a macaron to handle repository assignment
  272. func RepoAssignment() macaron.Handler {
  273. return func(ctx *Context) {
  274. var (
  275. owner *models.User
  276. err error
  277. )
  278. userName := ctx.Params(":username")
  279. repoName := ctx.Params(":reponame")
  280. // Check if the user is the same as the repository owner
  281. if ctx.IsSigned && ctx.User.LowerName == strings.ToLower(userName) {
  282. owner = ctx.User
  283. } else {
  284. owner, err = models.GetUserByName(userName)
  285. if err != nil {
  286. if models.IsErrUserNotExist(err) {
  287. if ctx.Query("go-get") == "1" {
  288. EarlyResponseForGoGetMeta(ctx)
  289. return
  290. }
  291. ctx.NotFound("GetUserByName", nil)
  292. } else {
  293. ctx.ServerError("GetUserByName", err)
  294. }
  295. return
  296. }
  297. }
  298. ctx.Repo.Owner = owner
  299. ctx.Data["Username"] = ctx.Repo.Owner.Name
  300. // Get repository.
  301. repo, err := models.GetRepositoryByName(owner.ID, repoName)
  302. if err != nil {
  303. if models.IsErrRepoNotExist(err) {
  304. redirectRepoID, err := models.LookupRepoRedirect(owner.ID, repoName)
  305. if err == nil {
  306. RedirectToRepo(ctx, redirectRepoID)
  307. } else if models.IsErrRepoRedirectNotExist(err) {
  308. if ctx.Query("go-get") == "1" {
  309. EarlyResponseForGoGetMeta(ctx)
  310. return
  311. }
  312. ctx.NotFound("GetRepositoryByName", nil)
  313. } else {
  314. ctx.ServerError("LookupRepoRedirect", err)
  315. }
  316. } else {
  317. ctx.ServerError("GetRepositoryByName", err)
  318. }
  319. return
  320. }
  321. repo.Owner = owner
  322. repoAssignment(ctx, repo)
  323. if ctx.Written() {
  324. return
  325. }
  326. ctx.Repo.RepoLink = repo.Link()
  327. ctx.Data["RepoLink"] = ctx.Repo.RepoLink
  328. ctx.Data["RepoRelPath"] = ctx.Repo.Owner.Name + "/" + ctx.Repo.Repository.Name
  329. unit, err := ctx.Repo.Repository.GetUnit(models.UnitTypeExternalTracker)
  330. if err == nil {
  331. ctx.Data["RepoExternalIssuesLink"] = unit.ExternalTrackerConfig().ExternalTrackerURL
  332. }
  333. count, err := models.GetReleaseCountByRepoID(ctx.Repo.Repository.ID, models.FindReleasesOptions{
  334. IncludeDrafts: false,
  335. IncludeTags: true,
  336. })
  337. if err != nil {
  338. ctx.ServerError("GetReleaseCountByRepoID", err)
  339. return
  340. }
  341. ctx.Repo.Repository.NumReleases = int(count)
  342. ctx.Data["Title"] = owner.Name + "/" + repo.Name
  343. ctx.Data["Repository"] = repo
  344. ctx.Data["Owner"] = ctx.Repo.Repository.Owner
  345. ctx.Data["IsRepositoryOwner"] = ctx.Repo.IsOwner()
  346. ctx.Data["IsRepositoryAdmin"] = ctx.Repo.IsAdmin()
  347. ctx.Data["RepoOwnerIsOrganization"] = repo.Owner.IsOrganization()
  348. ctx.Data["CanWriteCode"] = ctx.Repo.CanWrite(models.UnitTypeCode)
  349. ctx.Data["CanWriteIssues"] = ctx.Repo.CanWrite(models.UnitTypeIssues)
  350. ctx.Data["CanWritePulls"] = ctx.Repo.CanWrite(models.UnitTypePullRequests)
  351. if ctx.Data["CanSignedUserFork"], err = ctx.Repo.Repository.CanUserFork(ctx.User); err != nil {
  352. ctx.ServerError("CanUserFork", err)
  353. return
  354. }
  355. ctx.Data["DisableSSH"] = setting.SSH.Disabled
  356. ctx.Data["ExposeAnonSSH"] = setting.SSH.ExposeAnonymous
  357. ctx.Data["DisableHTTP"] = setting.Repository.DisableHTTPGit
  358. ctx.Data["RepoSearchEnabled"] = setting.Indexer.RepoIndexerEnabled
  359. ctx.Data["CloneLink"] = repo.CloneLink()
  360. ctx.Data["WikiCloneLink"] = repo.WikiCloneLink()
  361. if ctx.IsSigned {
  362. ctx.Data["IsWatchingRepo"] = models.IsWatching(ctx.User.ID, repo.ID)
  363. ctx.Data["IsStaringRepo"] = models.IsStaring(ctx.User.ID, repo.ID)
  364. }
  365. if repo.IsFork {
  366. RetrieveBaseRepo(ctx, repo)
  367. if ctx.Written() {
  368. return
  369. }
  370. }
  371. // Disable everything when the repo is being created
  372. if ctx.Repo.Repository.IsBeingCreated() {
  373. ctx.Data["BranchName"] = ctx.Repo.Repository.DefaultBranch
  374. return
  375. }
  376. gitRepo, err := git.OpenRepository(models.RepoPath(userName, repoName))
  377. if err != nil {
  378. ctx.ServerError("RepoAssignment Invalid repo "+models.RepoPath(userName, repoName), err)
  379. return
  380. }
  381. ctx.Repo.GitRepo = gitRepo
  382. // Stop at this point when the repo is empty.
  383. if ctx.Repo.Repository.IsEmpty {
  384. ctx.Data["BranchName"] = ctx.Repo.Repository.DefaultBranch
  385. return
  386. }
  387. tags, err := ctx.Repo.GitRepo.GetTags()
  388. if err != nil {
  389. ctx.ServerError("GetTags", err)
  390. return
  391. }
  392. ctx.Data["Tags"] = tags
  393. brs, err := ctx.Repo.GitRepo.GetBranches()
  394. if err != nil {
  395. ctx.ServerError("GetBranches", err)
  396. return
  397. }
  398. ctx.Data["Branches"] = brs
  399. ctx.Data["BranchesCount"] = len(brs)
  400. ctx.Data["TagName"] = ctx.Repo.TagName
  401. // If not branch selected, try default one.
  402. // If default branch doesn't exists, fall back to some other branch.
  403. if len(ctx.Repo.BranchName) == 0 {
  404. if len(ctx.Repo.Repository.DefaultBranch) > 0 && gitRepo.IsBranchExist(ctx.Repo.Repository.DefaultBranch) {
  405. ctx.Repo.BranchName = ctx.Repo.Repository.DefaultBranch
  406. } else if len(brs) > 0 {
  407. ctx.Repo.BranchName = brs[0]
  408. }
  409. }
  410. ctx.Data["BranchName"] = ctx.Repo.BranchName
  411. ctx.Data["CommitID"] = ctx.Repo.CommitID
  412. // People who have push access or have forked repository can propose a new pull request.
  413. if ctx.Repo.CanWrite(models.UnitTypeCode) || (ctx.IsSigned && ctx.User.HasForkedRepo(ctx.Repo.Repository.ID)) {
  414. // Pull request is allowed if this is a fork repository
  415. // and base repository accepts pull requests.
  416. if repo.BaseRepo != nil && repo.BaseRepo.AllowsPulls() {
  417. ctx.Data["BaseRepo"] = repo.BaseRepo
  418. ctx.Repo.PullRequest.BaseRepo = repo.BaseRepo
  419. ctx.Repo.PullRequest.Allowed = true
  420. ctx.Repo.PullRequest.HeadInfo = ctx.Repo.Owner.Name + ":" + ctx.Repo.BranchName
  421. } else if repo.AllowsPulls() {
  422. // Or, this is repository accepts pull requests between branches.
  423. ctx.Data["BaseRepo"] = repo
  424. ctx.Repo.PullRequest.BaseRepo = repo
  425. ctx.Repo.PullRequest.Allowed = true
  426. ctx.Repo.PullRequest.SameRepo = true
  427. ctx.Repo.PullRequest.HeadInfo = ctx.Repo.BranchName
  428. }
  429. }
  430. ctx.Data["PullRequestCtx"] = ctx.Repo.PullRequest
  431. if ctx.Query("go-get") == "1" {
  432. ctx.Data["GoGetImport"] = ComposeGoGetImport(owner.Name, repo.Name)
  433. prefix := setting.AppURL + path.Join(owner.Name, repo.Name, "src", "branch", ctx.Repo.BranchName)
  434. ctx.Data["GoDocDirectory"] = prefix + "{/dir}"
  435. ctx.Data["GoDocFile"] = prefix + "{/dir}/{file}#L{line}"
  436. }
  437. }
  438. }
  439. // RepoRefType type of repo reference
  440. type RepoRefType int
  441. const (
  442. // RepoRefLegacy unknown type, make educated guess and redirect.
  443. // for backward compatibility with previous URL scheme
  444. RepoRefLegacy RepoRefType = iota
  445. // RepoRefAny is for usage where educated guess is needed
  446. // but redirect can not be made
  447. RepoRefAny
  448. // RepoRefBranch branch
  449. RepoRefBranch
  450. // RepoRefTag tag
  451. RepoRefTag
  452. // RepoRefCommit commit
  453. RepoRefCommit
  454. // RepoRefBlob blob
  455. RepoRefBlob
  456. )
  457. // RepoRef handles repository reference names when the ref name is not
  458. // explicitly given
  459. func RepoRef() macaron.Handler {
  460. // since no ref name is explicitly specified, ok to just use branch
  461. return RepoRefByType(RepoRefBranch)
  462. }
  463. func getRefNameFromPath(ctx *Context, path string, isExist func(string) bool) string {
  464. refName := ""
  465. parts := strings.Split(path, "/")
  466. for i, part := range parts {
  467. refName = strings.TrimPrefix(refName+"/"+part, "/")
  468. if isExist(refName) {
  469. ctx.Repo.TreePath = strings.Join(parts[i+1:], "/")
  470. return refName
  471. }
  472. }
  473. return ""
  474. }
  475. func getRefName(ctx *Context, pathType RepoRefType) string {
  476. path := ctx.Params("*")
  477. switch pathType {
  478. case RepoRefLegacy, RepoRefAny:
  479. if refName := getRefName(ctx, RepoRefBranch); len(refName) > 0 {
  480. return refName
  481. }
  482. if refName := getRefName(ctx, RepoRefTag); len(refName) > 0 {
  483. return refName
  484. }
  485. if refName := getRefName(ctx, RepoRefCommit); len(refName) > 0 {
  486. return refName
  487. }
  488. if refName := getRefName(ctx, RepoRefBlob); len(refName) > 0 {
  489. return refName
  490. }
  491. ctx.Repo.TreePath = path
  492. return ctx.Repo.Repository.DefaultBranch
  493. case RepoRefBranch:
  494. return getRefNameFromPath(ctx, path, ctx.Repo.GitRepo.IsBranchExist)
  495. case RepoRefTag:
  496. return getRefNameFromPath(ctx, path, ctx.Repo.GitRepo.IsTagExist)
  497. case RepoRefCommit:
  498. parts := strings.Split(path, "/")
  499. if len(parts) > 0 && len(parts[0]) == 40 {
  500. ctx.Repo.TreePath = strings.Join(parts[1:], "/")
  501. return parts[0]
  502. }
  503. case RepoRefBlob:
  504. _, err := ctx.Repo.GitRepo.GetBlob(path)
  505. if err != nil {
  506. return ""
  507. }
  508. return path
  509. default:
  510. log.Error("Unrecognized path type: %v", path)
  511. }
  512. return ""
  513. }
  514. // RepoRefByType handles repository reference name for a specific type
  515. // of repository reference
  516. func RepoRefByType(refType RepoRefType) macaron.Handler {
  517. return func(ctx *Context) {
  518. // Empty repository does not have reference information.
  519. if ctx.Repo.Repository.IsEmpty {
  520. return
  521. }
  522. var (
  523. refName string
  524. err error
  525. )
  526. // For API calls.
  527. if ctx.Repo.GitRepo == nil {
  528. repoPath := models.RepoPath(ctx.Repo.Owner.Name, ctx.Repo.Repository.Name)
  529. ctx.Repo.GitRepo, err = git.OpenRepository(repoPath)
  530. if err != nil {
  531. ctx.ServerError("RepoRef Invalid repo "+repoPath, err)
  532. return
  533. }
  534. }
  535. // Get default branch.
  536. if len(ctx.Params("*")) == 0 {
  537. refName = ctx.Repo.Repository.DefaultBranch
  538. ctx.Repo.BranchName = refName
  539. if !ctx.Repo.GitRepo.IsBranchExist(refName) {
  540. brs, err := ctx.Repo.GitRepo.GetBranches()
  541. if err != nil {
  542. ctx.ServerError("GetBranches", err)
  543. return
  544. } else if len(brs) == 0 {
  545. err = fmt.Errorf("No branches in non-empty repository %s",
  546. ctx.Repo.GitRepo.Path)
  547. ctx.ServerError("GetBranches", err)
  548. return
  549. }
  550. refName = brs[0]
  551. }
  552. ctx.Repo.Commit, err = ctx.Repo.GitRepo.GetBranchCommit(refName)
  553. if err != nil {
  554. ctx.ServerError("GetBranchCommit", err)
  555. return
  556. }
  557. ctx.Repo.CommitID = ctx.Repo.Commit.ID.String()
  558. ctx.Repo.IsViewBranch = true
  559. } else {
  560. refName = getRefName(ctx, refType)
  561. ctx.Repo.BranchName = refName
  562. if ctx.Repo.GitRepo.IsBranchExist(refName) {
  563. ctx.Repo.IsViewBranch = true
  564. ctx.Repo.Commit, err = ctx.Repo.GitRepo.GetBranchCommit(refName)
  565. if err != nil {
  566. ctx.ServerError("GetBranchCommit", err)
  567. return
  568. }
  569. ctx.Repo.CommitID = ctx.Repo.Commit.ID.String()
  570. } else if ctx.Repo.GitRepo.IsTagExist(refName) {
  571. ctx.Repo.IsViewTag = true
  572. ctx.Repo.Commit, err = ctx.Repo.GitRepo.GetTagCommit(refName)
  573. if err != nil {
  574. ctx.ServerError("GetTagCommit", err)
  575. return
  576. }
  577. ctx.Repo.CommitID = ctx.Repo.Commit.ID.String()
  578. } else if len(refName) == 40 {
  579. ctx.Repo.IsViewCommit = true
  580. ctx.Repo.CommitID = refName
  581. ctx.Repo.Commit, err = ctx.Repo.GitRepo.GetCommit(refName)
  582. if err != nil {
  583. ctx.NotFound("GetCommit", nil)
  584. return
  585. }
  586. } else {
  587. ctx.NotFound("RepoRef invalid repo", fmt.Errorf("branch or tag not exist: %s", refName))
  588. return
  589. }
  590. if refType == RepoRefLegacy {
  591. // redirect from old URL scheme to new URL scheme
  592. ctx.Redirect(path.Join(
  593. setting.AppSubURL,
  594. strings.TrimSuffix(ctx.Req.URL.Path, ctx.Params("*")),
  595. ctx.Repo.BranchNameSubURL(),
  596. ctx.Repo.TreePath))
  597. return
  598. }
  599. }
  600. ctx.Data["BranchName"] = ctx.Repo.BranchName
  601. ctx.Data["BranchNameSubURL"] = ctx.Repo.BranchNameSubURL()
  602. ctx.Data["CommitID"] = ctx.Repo.CommitID
  603. ctx.Data["TreePath"] = ctx.Repo.TreePath
  604. ctx.Data["IsViewBranch"] = ctx.Repo.IsViewBranch
  605. ctx.Data["IsViewTag"] = ctx.Repo.IsViewTag
  606. ctx.Data["IsViewCommit"] = ctx.Repo.IsViewCommit
  607. ctx.Data["CanCreateBranch"] = ctx.Repo.CanCreateBranch()
  608. ctx.Repo.CommitsCount, err = ctx.Repo.GetCommitsCount()
  609. if err != nil {
  610. ctx.ServerError("GetCommitsCount", err)
  611. return
  612. }
  613. ctx.Data["CommitsCount"] = ctx.Repo.CommitsCount
  614. }
  615. }
  616. // GitHookService checks if repository Git hooks service has been enabled.
  617. func GitHookService() macaron.Handler {
  618. return func(ctx *Context) {
  619. if !ctx.User.CanEditGitHook() {
  620. ctx.NotFound("GitHookService", nil)
  621. return
  622. }
  623. }
  624. }
  625. // UnitTypes returns a macaron middleware to set unit types to context variables.
  626. func UnitTypes() macaron.Handler {
  627. return func(ctx *Context) {
  628. ctx.Data["UnitTypeCode"] = models.UnitTypeCode
  629. ctx.Data["UnitTypeIssues"] = models.UnitTypeIssues
  630. ctx.Data["UnitTypePullRequests"] = models.UnitTypePullRequests
  631. ctx.Data["UnitTypeReleases"] = models.UnitTypeReleases
  632. ctx.Data["UnitTypeWiki"] = models.UnitTypeWiki
  633. ctx.Data["UnitTypeExternalWiki"] = models.UnitTypeExternalWiki
  634. ctx.Data["UnitTypeExternalTracker"] = models.UnitTypeExternalTracker
  635. }
  636. }