tdsds.com/gitea
1
1
Fork 0
mirror of https://github.com/go-gitea/gitea synced 2025-08-13 04:58:19 +00:00
Code Releases Activity

New UI merge in progress

Browse Source
This commit is contained in:
Unknwon
2014-07-26 00:24:27 -04:00
parent 0a739cf9ac
commit 8dd07c0ddd
199 changed files with 15030 additions and 9325 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
routers/repo/branch.go
View File

@@ -5,8 +5,6 @@
package repo
import (
"github.com/go-martini/martini"
"github.com/gogits/gogs/modules/base"
"github.com/gogits/gogs/modules/middleware"
)
@@ -15,7 +13,7 @@ const (
BRANCH base.TplName = "repo/branch"
)
func Branches(ctx *middleware.Context, params martini.Params) {
func Branches(ctx *middleware.Context) {
ctx.Data["Title"] = "Branches"
ctx.Data["IsRepoToolbarBranches"] = true

376
routers/repo/commit.go
View File

@@ -4,222 +4,224 @@
package repo
import (
"path"
// import (
// "path"
"github.com/go-martini/martini"
// "github.com/Unknwon/com"
// "github.com/go-martini/martini"
"github.com/gogits/gogs/models"
"github.com/gogits/gogs/modules/base"
"github.com/gogits/gogs/modules/middleware"
)
// "github.com/gogits/gogs/models"
// "github.com/gogits/gogs/modules/base"
// "github.com/gogits/gogs/modules/middleware"
// )
const (
COMMITS base.TplName = "repo/commits"
DIFF base.TplName = "repo/diff"
)
// const (
// COMMITS base.TplName = "repo/commits"
// DIFF base.TplName = "repo/diff"
// )
func Commits(ctx *middleware.Context, params martini.Params) {
ctx.Data["IsRepoToolbarCommits"] = true
// func Commits(ctx *middleware.Context, params martini.Params) {
// ctx.Data["IsRepoToolbarCommits"] = true
userName := ctx.Repo.Owner.Name
repoName := ctx.Repo.Repository.Name
// userName := ctx.Repo.Owner.Name
// repoName := ctx.Repo.Repository.Name
brs, err := ctx.Repo.GitRepo.GetBranches()
if err != nil {
ctx.Handle(500, "repo.Commits(GetBranches)", err)
return
} else if len(brs) == 0 {
ctx.Handle(404, "repo.Commits(GetBranches)", nil)
return
}
// brs, err := ctx.Repo.GitRepo.GetBranches()
// if err != nil {
// ctx.Handle(500, "repo.Commits(GetBranches)", err)
// return
// } else if len(brs) == 0 {
// ctx.Handle(404, "repo.Commits(GetBranches)", nil)
// return
// }
commitsCount, err := ctx.Repo.Commit.CommitsCount()
if err != nil {
ctx.Handle(500, "repo.Commits(GetCommitsCount)", err)
return
}
// commitsCount, err := ctx.Repo.Commit.CommitsCount()
// if err != nil {
// ctx.Handle(500, "repo.Commits(GetCommitsCount)", err)
// return
// }
// Calculate and validate page number.
page, _ := base.StrTo(ctx.Query("p")).Int()
if page < 1 {
page = 1
}
lastPage := page - 1
if lastPage < 0 {
lastPage = 0
}
nextPage := page + 1
if nextPage*50 > commitsCount {
nextPage = 0
}
// // Calculate and validate page number.
// page, _ := com.StrTo(ctx.Query("p")).Int()
// if page < 1 {
// page = 1
// }
// lastPage := page - 1
// if lastPage < 0 {
// lastPage = 0
// }
// nextPage := page + 1
// if nextPage*50 > commitsCount {
// nextPage = 0
// }
// Both `git log branchName` and `git log commitId` work.
ctx.Data["Commits"], err = ctx.Repo.Commit.CommitsByRange(page)
if err != nil {
ctx.Handle(500, "repo.Commits(CommitsByRange)", err)
return
}
// // Both `git log branchName` and `git log commitId` work.
// // ctx.Data["Commits"], err = ctx.Repo.Commit.CommitsByRange(page)
// // if err != nil {
// // ctx.Handle(500, "repo.Commits(CommitsByRange)", err)
// // return
// // }
ctx.Data["Username"] = userName
ctx.Data["Reponame"] = repoName
ctx.Data["CommitCount"] = commitsCount
ctx.Data["LastPageNum"] = lastPage
ctx.Data["NextPageNum"] = nextPage
ctx.HTML(200, COMMITS)
}
// ctx.Data["Username"] = userName
// ctx.Data["Reponame"] = repoName
// ctx.Data["CommitCount"] = commitsCount
// ctx.Data["LastPageNum"] = lastPage
// ctx.Data["NextPageNum"] = nextPage
// ctx.HTML(200, COMMITS)
// }
func SearchCommits(ctx *middleware.Context, params martini.Params) {
ctx.Data["IsSearchPage"] = true
ctx.Data["IsRepoToolbarCommits"] = true
// func SearchCommits(ctx *middleware.Context, params martini.Params) {
// ctx.Data["IsSearchPage"] = true
// ctx.Data["IsRepoToolbarCommits"] = true
keyword := ctx.Query("q")
if len(keyword) == 0 {
ctx.Redirect(ctx.Repo.RepoLink + "/commits/" + ctx.Repo.BranchName)
return
}
// keyword := ctx.Query("q")
// if len(keyword) == 0 {
// ctx.Redirect(ctx.Repo.RepoLink + "/commits/" + ctx.Repo.BranchName)
// return
// }
userName := params["username"]
repoName := params["reponame"]
// userName := params["username"]
// repoName := params["reponame"]
brs, err := ctx.Repo.GitRepo.GetBranches()
if err != nil {
ctx.Handle(500, "repo.SearchCommits(GetBranches)", err)
return
} else if len(brs) == 0 {
ctx.Handle(404, "repo.SearchCommits(GetBranches)", nil)
return
}
// brs, err := ctx.Repo.GitRepo.GetBranches()
// if err != nil {
// ctx.Handle(500, "repo.SearchCommits(GetBranches)", err)
// return
// } else if len(brs) == 0 {
// ctx.Handle(404, "repo.SearchCommits(GetBranches)", nil)
// return
// }
commits, err := ctx.Repo.Commit.SearchCommits(keyword)
if err != nil {
ctx.Handle(500, "repo.SearchCommits(SearchCommits)", err)
return
}
// // commits, err := ctx.Repo.Commit.SearchCommits(keyword)
// // if err != nil {
// // ctx.Handle(500, "repo.SearchCommits(SearchCommits)", err)
// // return
// // }
ctx.Data["Keyword"] = keyword
ctx.Data["Username"] = userName
ctx.Data["Reponame"] = repoName
ctx.Data["CommitCount"] = commits.Len()
ctx.Data["Commits"] = commits
ctx.HTML(200, COMMITS)
}
// ctx.Data["Keyword"] = keyword
// ctx.Data["Username"] = userName
// ctx.Data["Reponame"] = repoName
// // ctx.Data["CommitCount"] = commits.Len()
// // ctx.Data["Commits"] = commits
// ctx.HTML(200, COMMITS)
// }
func Diff(ctx *middleware.Context, params martini.Params) {
ctx.Data["IsRepoToolbarCommits"] = true
// func Diff(ctx *middleware.Context, params martini.Params) {
// ctx.Data["IsRepoToolbarCommits"] = true
userName := ctx.Repo.Owner.Name
repoName := ctx.Repo.Repository.Name
commitId := ctx.Repo.CommitId
// userName := ctx.Repo.Owner.Name
// repoName := ctx.Repo.Repository.Name
// commitId := ctx.Repo.CommitId
commit := ctx.Repo.Commit
// commit := ctx.Repo.Commit
diff, err := models.GetDiff(models.RepoPath(userName, repoName), commitId)
if err != nil {
ctx.Handle(404, "repo.Diff(GetDiff)", err)
return
}
// diff, err := models.GetDiff(models.RepoPath(userName, repoName), commitId)
// if err != nil {
// ctx.Handle(404, "repo.Diff(GetDiff)", err)
// return
// }
isImageFile := func(name string) bool {
blob, err := ctx.Repo.Commit.GetBlobByPath(name)
if err != nil {
return false
}
// isImageFile := func(name string) bool {
// // blob, err := ctx.Repo.Commit.GetBlobByPath(name)
// // if err != nil {
// // return false
// // }
dataRc, err := blob.Data()
if err != nil {
return false
}
buf := make([]byte, 1024)
n, _ := dataRc.Read(buf)
if n > 0 {
buf = buf[:n]
}
dataRc.Close()
_, isImage := base.IsImageFile(buf)
return isImage
}
// // dataRc, err := blob.Data()
// // if err != nil {
// // return false
// // }
// // buf := make([]byte, 1024)
// // n, _ := dataRc.Read(buf)
// // if n > 0 {
// // buf = buf[:n]
// // }
// // dataRc.Close()
// // _, isImage := base.IsImageFile(buf)
// // return isImage
// return false
// }
parents := make([]string, commit.ParentCount())
for i := 0; i < commit.ParentCount(); i++ {
sha, err := commit.ParentId(i)
parents[i] = sha.String()
if err != nil {
ctx.Handle(404, "repo.Diff", err)
return
}
}
// parents := make([]string, commit.ParentCount())
// for i := 0; i < commit.ParentCount(); i++ {
// sha, err := commit.ParentId(i)
// parents[i] = sha.String()
// if err != nil {
// ctx.Handle(404, "repo.Diff", err)
// return
// }
// }
ctx.Data["Username"] = userName
ctx.Data["Reponame"] = repoName
ctx.Data["IsImageFile"] = isImageFile
ctx.Data["Title"] = commit.Summary() + " · " + base.ShortSha(commitId)
ctx.Data["Commit"] = commit
ctx.Data["Diff"] = diff
ctx.Data["Parents"] = parents
ctx.Data["DiffNotAvailable"] = diff.NumFiles() == 0
ctx.Data["SourcePath"] = "/" + path.Join(userName, repoName, "src", commitId)
ctx.Data["RawPath"] = "/" + path.Join(userName, repoName, "raw", commitId)
ctx.HTML(200, DIFF)
}
// ctx.Data["Username"] = userName
// ctx.Data["Reponame"] = repoName
// ctx.Data["IsImageFile"] = isImageFile
// ctx.Data["Title"] = commit.Summary() + " · " + base.ShortSha(commitId)
// ctx.Data["Commit"] = commit
// ctx.Data["Diff"] = diff
// ctx.Data["Parents"] = parents
// ctx.Data["DiffNotAvailable"] = diff.NumFiles() == 0
// ctx.Data["SourcePath"] = "/" + path.Join(userName, repoName, "src", commitId)
// ctx.Data["RawPath"] = "/" + path.Join(userName, repoName, "raw", commitId)
// ctx.HTML(200, DIFF)
// }
func FileHistory(ctx *middleware.Context, params martini.Params) {
ctx.Data["IsRepoToolbarCommits"] = true
// func FileHistory(ctx *middleware.Context, params martini.Params) {
// ctx.Data["IsRepoToolbarCommits"] = true
fileName := params["_1"]
if len(fileName) == 0 {
Commits(ctx, params)
return
}
// fileName := params["_1"]
// if len(fileName) == 0 {
// Commits(ctx, params)
// return
// }
userName := ctx.Repo.Owner.Name
repoName := ctx.Repo.Repository.Name
branchName := params["branchname"]
// userName := ctx.Repo.Owner.Name
// repoName := ctx.Repo.Repository.Name
// branchName := params["branchname"]
brs, err := ctx.Repo.GitRepo.GetBranches()
if err != nil {
ctx.Handle(500, "repo.FileHistory", err)
return
} else if len(brs) == 0 {
ctx.Handle(404, "repo.FileHistory", nil)
return
}
// brs, err := ctx.Repo.GitRepo.GetBranches()
// if err != nil {
// ctx.Handle(500, "repo.FileHistory", err)
// return
// } else if len(brs) == 0 {
// ctx.Handle(404, "repo.FileHistory", nil)
// return
// }
commitsCount, err := ctx.Repo.GitRepo.FileCommitsCount(branchName, fileName)
if err != nil {
ctx.Handle(500, "repo.FileHistory(GetCommitsCount)", err)
return
} else if commitsCount == 0 {
ctx.Handle(404, "repo.FileHistory", nil)
return
}
// // commitsCount, err := ctx.Repo.GitRepo.FileCommitsCount(branchName, fileName)
// // if err != nil {
// // ctx.Handle(500, "repo.FileHistory(GetCommitsCount)", err)
// // return
// // } else if commitsCount == 0 {
// // ctx.Handle(404, "repo.FileHistory", nil)
// // return
// // }
// Calculate and validate page number.
page, _ := base.StrTo(ctx.Query("p")).Int()
if page < 1 {
page = 1
}
lastPage := page - 1
if lastPage < 0 {
lastPage = 0
}
nextPage := page + 1
if nextPage*50 > commitsCount {
nextPage = 0
}
// // Calculate and validate page number.
// // page, _ := base.StrTo(ctx.Query("p")).Int()
// // if page < 1 {
// // page = 1
// // }
// // lastPage := page - 1
// // if lastPage < 0 {
// // lastPage = 0
// // }
// // nextPage := page + 1
// // if nextPage*50 > commitsCount {
// // nextPage = 0
// // }
ctx.Data["Commits"], err = ctx.Repo.GitRepo.CommitsByFileAndRange(
branchName, fileName, page)
if err != nil {
ctx.Handle(500, "repo.FileHistory(CommitsByRange)", err)
return
}
// // ctx.Data["Commits"], err = ctx.Repo.GitRepo.CommitsByFileAndRange(
// // branchName, fileName, page)
// // if err != nil {
// // ctx.Handle(500, "repo.FileHistory(CommitsByRange)", err)
// // return
// // }
ctx.Data["Username"] = userName
ctx.Data["Reponame"] = repoName
ctx.Data["FileName"] = fileName
ctx.Data["CommitCount"] = commitsCount
ctx.Data["LastPageNum"] = lastPage
ctx.Data["NextPageNum"] = nextPage
ctx.HTML(200, COMMITS)
}
// ctx.Data["Username"] = userName
// ctx.Data["Reponame"] = repoName
// ctx.Data["FileName"] = fileName
// // ctx.Data["CommitCount"] = commitsCount
// // ctx.Data["LastPageNum"] = lastPage
// // ctx.Data["NextPageNum"] = nextPage
// ctx.HTML(200, COMMITS)
// }

121
routers/repo/download.go
View File

@@ -5,101 +5,50 @@
package repo
import (
"io"
"os"
"path/filepath"
// "io"
// "os"
// "path/filepath"
"github.com/Unknwon/com"
"github.com/go-martini/martini"
// "github.com/Unknwon/com"
"github.com/gogits/git"
// "github.com/gogits/git"
"github.com/gogits/gogs/modules/base"
// "github.com/gogits/gogs/modules/base"
"github.com/gogits/gogs/modules/middleware"
)
func SingleDownload(ctx *middleware.Context, params martini.Params) {
treename := params["_1"]
func SingleDownload(ctx *middleware.Context) {
// treename := params["_1"]
blob, err := ctx.Repo.Commit.GetBlobByPath(treename)
if err != nil {
ctx.Handle(500, "repo.SingleDownload(GetBlobByPath)", err)
return
}
// blob, err := ctx.Repo.Commit.GetBlobByPath(treename)
// if err != nil {
// ctx.Handle(500, "repo.SingleDownload(GetBlobByPath)", err)
// return
// }
dataRc, err := blob.Data()
if err != nil {
ctx.Handle(500, "repo.SingleDownload(Data)", err)
return
}
// dataRc, err := blob.Data()
// if err != nil {
// ctx.Handle(500, "repo.SingleDownload(Data)", err)
// return
// }
buf := make([]byte, 1024)
n, _ := dataRc.Read(buf)
if n > 0 {
buf = buf[:n]
}
// buf := make([]byte, 1024)
// n, _ := dataRc.Read(buf)
// if n > 0 {
// buf = buf[:n]
// }
defer func() {
dataRc.Close()
}()
// defer func() {
// dataRc.Close()
// }()
contentType, isTextFile := base.IsTextFile(buf)
_, isImageFile := base.IsImageFile(buf)
ctx.Res.Header().Set("Content-Type", contentType)
if !isTextFile && !isImageFile {
ctx.Res.Header().Set("Content-Disposition", "attachment; filename="+filepath.Base(treename))
ctx.Res.Header().Set("Content-Transfer-Encoding", "binary")
}
ctx.Res.Write(buf)
io.Copy(ctx.Res, dataRc)
}
func ZipDownload(ctx *middleware.Context, params martini.Params) {
commitId := ctx.Repo.CommitId
archivesPath := filepath.Join(ctx.Repo.GitRepo.Path, "archives/zip")
if !com.IsDir(archivesPath) {
if err := os.MkdirAll(archivesPath, 0755); err != nil {
ctx.Handle(500, "ZipDownload -> os.Mkdir(archivesPath)", err)
return
}
}
archivePath := filepath.Join(archivesPath, commitId+".zip")
if com.IsFile(archivePath) {
ctx.ServeFile(archivePath, ctx.Repo.Repository.Name+".zip")
return
}
if err := ctx.Repo.Commit.CreateArchive(archivePath, git.AT_ZIP); err != nil {
ctx.Handle(500, "ZipDownload -> CreateArchive "+archivePath, err)
return
}
ctx.ServeFile(archivePath, ctx.Repo.Repository.Name+".zip")
}
func TarGzDownload(ctx *middleware.Context, params martini.Params) {
commitId := ctx.Repo.CommitId
archivesPath := filepath.Join(ctx.Repo.GitRepo.Path, "archives/targz")
if !com.IsDir(archivesPath) {
if err := os.MkdirAll(archivesPath, 0755); err != nil {
ctx.Handle(500, "TarGzDownload -> os.Mkdir(archivesPath)", err)
return
}
}
archivePath := filepath.Join(archivesPath, commitId+".tar.gz")
if com.IsFile(archivePath) {
ctx.ServeFile(archivePath, ctx.Repo.Repository.Name+".tar.gz")
return
}
if err := ctx.Repo.Commit.CreateArchive(archivePath, git.AT_TARGZ); err != nil {
ctx.Handle(500, "TarGzDownload -> CreateArchive "+archivePath, err)
return
}
ctx.ServeFile(archivePath, ctx.Repo.Repository.Name+".tar.gz")
// contentType, isTextFile := base.IsTextFile(buf)
// _, isImageFile := base.IsImageFile(buf)
// ctx.Res.Header().Set("Content-Type", contentType)
// if !isTextFile && !isImageFile {
// ctx.Res.Header().Set("Content-Disposition", "attachment; filename="+filepath.Base(treename))
// ctx.Res.Header().Set("Content-Transfer-Encoding", "binary")
// }
// ctx.Res.Write(buf)
// io.Copy(ctx.Res, dataRc)
}

55
routers/repo/http.go
View File

@@ -6,6 +6,8 @@ package repo
import (
"bytes"
"encoding/base64"
"errors"
"fmt"
"io"
"io/ioutil"
@@ -19,16 +21,43 @@ import (
"strings"
"time"
"github.com/go-martini/martini"
"github.com/gogits/gogs/models"
"github.com/gogits/gogs/modules/base"
"github.com/gogits/gogs/modules/log"
"github.com/gogits/gogs/modules/middleware"
"github.com/gogits/gogs/modules/setting"
)
func Http(ctx *middleware.Context, params martini.Params) {
username := params["username"]
reponame := params["reponame"]
func basicEncode(username, password string) string {
auth := username + ":" + password
return base64.StdEncoding.EncodeToString([]byte(auth))
}
func basicDecode(encoded string) (user string, name string, err error) {
var s []byte
s, err = base64.StdEncoding.DecodeString(encoded)
if err != nil {
return user, name, err
}
a := strings.Split(string(s), ":")
if len(a) == 2 {
user, name = a[0], a[1]
} else {
err = errors.New("decode failed")
}
return user, name, err
}
func authRequired(ctx *middleware.Context) {
ctx.Resp.Header().Set("WWW-Authenticate", "Basic realm=\".\"")
ctx.Data["ErrorMsg"] = "no basic auth and digit auth"
ctx.HTML(401, base.TplName("status/401"))
}
func Http(ctx *middleware.Context) {
username := ctx.Params(":username")
reponame := ctx.Params(":reponame")
if strings.HasSuffix(reponame, ".git") {
reponame = reponame[:len(reponame)-4]
}
@@ -50,7 +79,7 @@ func Http(ctx *middleware.Context, params martini.Params) {
if err == models.ErrUserNotExist {
ctx.Handle(404, "repo.Http(GetUserByName)", nil)
} else {
ctx.Handle(500, "repo.Http(GetUserByName)", nil)
ctx.Handle(500, "repo.Http(GetUserByName)", err)
}
return
}
@@ -60,7 +89,7 @@ func Http(ctx *middleware.Context, params martini.Params) {
if err == models.ErrRepoNotExist {
ctx.Handle(404, "repo.Http(GetRepositoryByName)", nil)
} else {
ctx.Handle(500, "repo.Http(GetRepositoryByName)", nil)
ctx.Handle(500, "repo.Http(GetRepositoryByName)", err)
}
return
}
@@ -75,7 +104,6 @@ func Http(ctx *middleware.Context, params martini.Params) {
if askAuth {
baHead := ctx.Req.Header.Get("Authorization")
if baHead == "" {
// ask auth
authRequired(ctx)
return
}
@@ -142,7 +170,7 @@ func Http(ctx *middleware.Context, params martini.Params) {
if head[0] == '0' && head[1] == '0' {
size, err := strconv.ParseInt(string(input[lastLine+2:lastLine+4]), 16, 32)
if err != nil {
log.Error("%v", err)
log.Error(4, "%v", err)
return
}
@@ -166,7 +194,6 @@ func Http(ctx *middleware.Context, params martini.Params) {
}
lastLine = lastLine + size
} else {
//fmt.Println("ddddddddddd")
break
}
}
@@ -176,7 +203,7 @@ func Http(ctx *middleware.Context, params martini.Params) {
config := Config{setting.RepoRootPath, "git", true, true, f}
handler := HttpBackend(&config)
handler(ctx.ResponseWriter, ctx.Req)
handler(ctx.Resp, ctx.Req)
}
type route struct {
@@ -229,7 +256,7 @@ func HttpBackend(config *Config) http.HandlerFunc {
dir, err := getGitDir(config, m[1])
if err != nil {
log.GitLogger.Error(err.Error())
log.GitLogger.Error(4, err.Error())
renderNotFound(w)
return
}
@@ -283,7 +310,7 @@ func serviceRpc(rpc string, hr handler) {
err := cmd.Run()
if err != nil {
log.GitLogger.Error(err.Error())
log.GitLogger.Error(4, err.Error())
return
}
@@ -366,7 +393,7 @@ func getGitDir(config *Config, fPath string) (string, error) {
cwd, err := os.Getwd()
if err != nil {
log.GitLogger.Error(err.Error())
log.GitLogger.Error(4, err.Error())
return "", err
}
@@ -443,7 +470,7 @@ func gitCommand(gitBinPath, dir string, args ...string) []byte {
out, err := command.Output()
if err != nil {
log.GitLogger.Error(err.Error())
log.GitLogger.Error(4, err.Error())
}
return out

2222
routers/repo/issue.go
View File

File diff suppressed because it is too large Load Diff

4
routers/repo/pull.go
View File

@@ -5,8 +5,6 @@
package repo
import (
"github.com/go-martini/martini"
"github.com/gogits/gogs/modules/base"
"github.com/gogits/gogs/modules/middleware"
)
@@ -15,7 +13,7 @@ const (
PULLS base.TplName = "repo/pulls"
)
func Pulls(ctx *middleware.Context, params martini.Params) {
func Pulls(ctx *middleware.Context) {
ctx.Data["IsRepoToolbarPulls"] = true
ctx.HTML(200, PULLS)
}

382
routers/repo/release.go
View File

@@ -5,13 +5,13 @@
package repo
import (
"github.com/go-martini/martini"
// "github.com/go-martini/martini"
"github.com/gogits/gogs/models"
"github.com/gogits/gogs/modules/auth"
// "github.com/gogits/gogs/models"
// "github.com/gogits/gogs/modules/auth"
"github.com/gogits/gogs/modules/base"
"github.com/gogits/gogs/modules/log"
"github.com/gogits/gogs/modules/middleware"
// "github.com/gogits/gogs/modules/log"
// "github.com/gogits/gogs/modules/middleware"
)
const (
@@ -20,215 +20,215 @@ const (
RELEASE_EDIT base.TplName = "repo/release/edit"
)
func Releases(ctx *middleware.Context) {
ctx.Data["Title"] = "Releases"
ctx.Data["IsRepoToolbarReleases"] = true
ctx.Data["IsRepoReleaseNew"] = false
rawTags, err := ctx.Repo.GitRepo.GetTags()
if err != nil {
ctx.Handle(500, "release.Releases(GetTags)", err)
return
}
// func Releases(ctx *middleware.Context) {
// ctx.Data["Title"] = "Releases"
// ctx.Data["IsRepoToolbarReleases"] = true
// ctx.Data["IsRepoReleaseNew"] = false
// rawTags, err := ctx.Repo.GitRepo.GetTags()
// if err != nil {
// ctx.Handle(500, "release.Releases(GetTags)", err)
// return
// }
rels, err := models.GetReleasesByRepoId(ctx.Repo.Repository.Id)
if err != nil {
ctx.Handle(500, "release.Releases(GetReleasesByRepoId)", err)
return
}
// rels, err := models.GetReleasesByRepoId(ctx.Repo.Repository.Id)
// if err != nil {
// ctx.Handle(500, "release.Releases(GetReleasesByRepoId)", err)
// return
// }
commitsCount, err := ctx.Repo.Commit.CommitsCount()
if err != nil {
ctx.Handle(500, "release.Releases(CommitsCount)", err)
return
}
// commitsCount, err := ctx.Repo.Commit.CommitsCount()
// if err != nil {
// ctx.Handle(500, "release.Releases(CommitsCount)", err)
// return
// }
// Temproray cache commits count of used branches to speed up.
countCache := make(map[string]int)
// // Temproray cache commits count of used branches to speed up.
// countCache := make(map[string]int)
tags := make([]*models.Release, len(rawTags))
for i, rawTag := range rawTags {
for _, rel := range rels {
if rel.IsDraft && !ctx.Repo.IsOwner {
continue
}
if rel.TagName == rawTag {
rel.Publisher, err = models.GetUserById(rel.PublisherId)
if err != nil {
ctx.Handle(500, "release.Releases(GetUserById)", err)
return
}
// Get corresponding target if it's not the current branch.
if ctx.Repo.BranchName != rel.Target {
// Get count if not exists.
if _, ok := countCache[rel.Target]; !ok {
commit, err := ctx.Repo.GitRepo.GetCommitOfTag(rel.TagName)
if err != nil {
ctx.Handle(500, "release.Releases(GetCommitOfTag)", err)
return
}
countCache[rel.Target], err = commit.CommitsCount()
if err != nil {
ctx.Handle(500, "release.Releases(CommitsCount2)", err)
return
}
}
rel.NumCommitsBehind = countCache[rel.Target] - rel.NumCommits
} else {
rel.NumCommitsBehind = commitsCount - rel.NumCommits
}
// tags := make([]*models.Release, len(rawTags))
// for i, rawTag := range rawTags {
// for _, rel := range rels {
// if rel.IsDraft && !ctx.Repo.IsOwner {
// continue
// }
// if rel.TagName == rawTag {
// rel.Publisher, err = models.GetUserById(rel.PublisherId)
// if err != nil {
// ctx.Handle(500, "release.Releases(GetUserById)", err)
// return
// }
// // Get corresponding target if it's not the current branch.
// if ctx.Repo.BranchName != rel.Target {
// // Get count if not exists.
// if _, ok := countCache[rel.Target]; !ok {
// commit, err := ctx.Repo.GitRepo.GetCommitOfTag(rel.TagName)
// if err != nil {
// ctx.Handle(500, "release.Releases(GetCommitOfTag)", err)
// return
// }
// countCache[rel.Target], err = commit.CommitsCount()
// if err != nil {
// ctx.Handle(500, "release.Releases(CommitsCount2)", err)
// return
// }
// }
// rel.NumCommitsBehind = countCache[rel.Target] - rel.NumCommits
// } else {
// rel.NumCommitsBehind = commitsCount - rel.NumCommits
// }
rel.Note = base.RenderMarkdownString(rel.Note, ctx.Repo.RepoLink)
tags[i] = rel
break
}
}
// rel.Note = base.RenderMarkdownString(rel.Note, ctx.Repo.RepoLink)
// tags[i] = rel
// break
// }
// }
if tags[i] == nil {
commit, err := ctx.Repo.GitRepo.GetCommitOfTag(rawTag)
if err != nil {
ctx.Handle(500, "release.Releases(GetCommitOfTag2)", err)
return
}
// if tags[i] == nil {
// commit, err := ctx.Repo.GitRepo.GetCommitOfTag(rawTag)
// if err != nil {
// ctx.Handle(500, "release.Releases(GetCommitOfTag2)", err)
// return
// }
tags[i] = &models.Release{
Title: rawTag,
TagName: rawTag,
Sha1: commit.Id.String(),
}
// tags[i] = &models.Release{
// Title: rawTag,
// TagName: rawTag,
// Sha1: commit.Id.String(),
// }
tags[i].NumCommits, err = ctx.Repo.GitRepo.CommitsCount(commit.Id.String())
if err != nil {
ctx.Handle(500, "release.Releases(CommitsCount)", err)
return
}
tags[i].NumCommitsBehind = commitsCount - tags[i].NumCommits
}
}
models.SortReleases(tags)
ctx.Data["Releases"] = tags
ctx.HTML(200, RELEASES)
}
// tags[i].NumCommits, err = ctx.Repo.GitRepo.CommitsCount(commit.Id.String())
// if err != nil {
// ctx.Handle(500, "release.Releases(CommitsCount)", err)
// return
// }
// tags[i].NumCommitsBehind = commitsCount - tags[i].NumCommits
// }
// }
// models.SortReleases(tags)
// ctx.Data["Releases"] = tags
// ctx.HTML(200, RELEASES)
// }
func NewRelease(ctx *middleware.Context) {
if !ctx.Repo.IsOwner {
ctx.Handle(403, "release.ReleasesNew", nil)
return
}
// func NewRelease(ctx *middleware.Context) {
// if !ctx.Repo.IsOwner {
// ctx.Handle(403, "release.ReleasesNew", nil)
// return
// }
ctx.Data["Title"] = "New Release"
ctx.Data["IsRepoToolbarReleases"] = true
ctx.Data["IsRepoReleaseNew"] = true
ctx.HTML(200, RELEASE_NEW)
}
// ctx.Data["Title"] = "New Release"
// ctx.Data["IsRepoToolbarReleases"] = true
// ctx.Data["IsRepoReleaseNew"] = true
// ctx.HTML(200, RELEASE_NEW)
// }
func NewReleasePost(ctx *middleware.Context, form auth.NewReleaseForm) {
if !ctx.Repo.IsOwner {
ctx.Handle(403, "release.ReleasesNew", nil)
return
}
// func NewReleasePost(ctx *middleware.Context, form auth.NewReleaseForm) {
// if !ctx.Repo.IsOwner {
// ctx.Handle(403, "release.ReleasesNew", nil)
// return
// }
ctx.Data["Title"] = "New Release"
ctx.Data["IsRepoToolbarReleases"] = true
ctx.Data["IsRepoReleaseNew"] = true
// ctx.Data["Title"] = "New Release"
// ctx.Data["IsRepoToolbarReleases"] = true
// ctx.Data["IsRepoReleaseNew"] = true
if ctx.HasError() {
ctx.HTML(200, RELEASE_NEW)
return
}
// if ctx.HasError() {
// ctx.HTML(200, RELEASE_NEW)
// return
// }
commitsCount, err := ctx.Repo.Commit.CommitsCount()
if err != nil {
ctx.Handle(500, "release.ReleasesNewPost(CommitsCount)", err)
return
}
// commitsCount, err := ctx.Repo.Commit.CommitsCount()
// if err != nil {
// ctx.Handle(500, "release.ReleasesNewPost(CommitsCount)", err)
// return
// }
if !ctx.Repo.GitRepo.IsBranchExist(form.Target) {
ctx.RenderWithErr("Target branch does not exist", "release/new", &form)
return
}
// if !ctx.Repo.GitRepo.IsBranchExist(form.Target) {
// ctx.RenderWithErr("Target branch does not exist", "release/new", &form)
// return
// }
rel := &models.Release{
RepoId: ctx.Repo.Repository.Id,
PublisherId: ctx.User.Id,
Title: form.Title,
TagName: form.TagName,
Target: form.Target,
Sha1: ctx.Repo.Commit.Id.String(),
NumCommits: commitsCount,
Note: form.Content,
IsDraft: len(form.Draft) > 0,
IsPrerelease: form.Prerelease,
}
// rel := &models.Release{
// RepoId: ctx.Repo.Repository.Id,
// PublisherId: ctx.User.Id,
// Title: form.Title,
// TagName: form.TagName,
// Target: form.Target,
// Sha1: ctx.Repo.Commit.Id.String(),
// NumCommits: commitsCount,
// Note: form.Content,
// IsDraft: len(form.Draft) > 0,
// IsPrerelease: form.Prerelease,
// }
if err = models.CreateRelease(ctx.Repo.GitRepo, rel); err != nil {
if err == models.ErrReleaseAlreadyExist {
ctx.RenderWithErr("Release with this tag name has already existed", "release/new", &form)
} else {
ctx.Handle(500, "release.ReleasesNewPost(IsReleaseExist)", err)
}
return
}
log.Trace("%s Release created: %s/%s:%s", ctx.Req.RequestURI, ctx.User.LowerName, ctx.Repo.Repository.Name, form.TagName)
// if err = models.CreateRelease(ctx.Repo.GitRepo, rel); err != nil {
// if err == models.ErrReleaseAlreadyExist {
// ctx.RenderWithErr("Release with this tag name has already existed", "release/new", &form)
// } else {
// ctx.Handle(500, "release.ReleasesNewPost(IsReleaseExist)", err)
// }
// return
// }
// log.Trace("%s Release created: %s/%s:%s", ctx.Req.RequestURI, ctx.User.LowerName, ctx.Repo.Repository.Name, form.TagName)
ctx.Redirect(ctx.Repo.RepoLink + "/releases")
}
// ctx.Redirect(ctx.Repo.RepoLink + "/releases")
// }
func EditRelease(ctx *middleware.Context, params martini.Params) {
if !ctx.Repo.IsOwner {
ctx.Handle(403, "release.ReleasesEdit", nil)
return
}
// func EditRelease(ctx *middleware.Context, params martini.Params) {
// if !ctx.Repo.IsOwner {
// ctx.Handle(403, "release.ReleasesEdit", nil)
// return
// }
tagName := params["tagname"]
rel, err := models.GetRelease(ctx.Repo.Repository.Id, tagName)
if err != nil {
if err == models.ErrReleaseNotExist {
ctx.Handle(404, "release.ReleasesEdit(GetRelease)", err)
} else {
ctx.Handle(500, "release.ReleasesEdit(GetRelease)", err)
}
return
}
ctx.Data["Release"] = rel
// tagName := params["tagname"]
// rel, err := models.GetRelease(ctx.Repo.Repository.Id, tagName)
// if err != nil {
// if err == models.ErrReleaseNotExist {
// ctx.Handle(404, "release.ReleasesEdit(GetRelease)", err)
// } else {
// ctx.Handle(500, "release.ReleasesEdit(GetRelease)", err)
// }
// return
// }
// ctx.Data["Release"] = rel
ctx.Data["Title"] = "Edit Release"
ctx.Data["IsRepoToolbarReleases"] = true
ctx.HTML(200, RELEASE_EDIT)
}
// ctx.Data["Title"] = "Edit Release"
// ctx.Data["IsRepoToolbarReleases"] = true
// ctx.HTML(200, RELEASE_EDIT)
// }
func EditReleasePost(ctx *middleware.Context, params martini.Params, form auth.EditReleaseForm) {
if !ctx.Repo.IsOwner {
ctx.Handle(403, "release.EditReleasePost", nil)
return
}
// func EditReleasePost(ctx *middleware.Context, params martini.Params, form auth.EditReleaseForm) {
// if !ctx.Repo.IsOwner {
// ctx.Handle(403, "release.EditReleasePost", nil)
// return
// }
tagName := params["tagname"]
rel, err := models.GetRelease(ctx.Repo.Repository.Id, tagName)
if err != nil {
if err == models.ErrReleaseNotExist {
ctx.Handle(404, "release.EditReleasePost(GetRelease)", err)
} else {
ctx.Handle(500, "release.EditReleasePost(GetRelease)", err)
}
return
}
ctx.Data["Release"] = rel
// tagName := params["tagname"]
// rel, err := models.GetRelease(ctx.Repo.Repository.Id, tagName)
// if err != nil {
// if err == models.ErrReleaseNotExist {
// ctx.Handle(404, "release.EditReleasePost(GetRelease)", err)
// } else {
// ctx.Handle(500, "release.EditReleasePost(GetRelease)", err)
// }
// return
// }
// ctx.Data["Release"] = rel
if ctx.HasError() {
ctx.HTML(200, RELEASE_EDIT)
return
}
// if ctx.HasError() {
// ctx.HTML(200, RELEASE_EDIT)
// return
// }
ctx.Data["Title"] = "Edit Release"
ctx.Data["IsRepoToolbarReleases"] = true
// ctx.Data["Title"] = "Edit Release"
// ctx.Data["IsRepoToolbarReleases"] = true
rel.Title = form.Title
rel.Note = form.Content
rel.IsDraft = len(form.Draft) > 0
rel.IsPrerelease = form.Prerelease
if err = models.UpdateRelease(ctx.Repo.GitRepo, rel); err != nil {
ctx.Handle(500, "release.EditReleasePost(UpdateRelease)", err)
return
}
ctx.Redirect(ctx.Repo.RepoLink + "/releases")
}
// rel.Title = form.Title
// rel.Note = form.Content
// rel.IsDraft = len(form.Draft) > 0
// rel.IsPrerelease = form.Prerelease
// if err = models.UpdateRelease(ctx.Repo.GitRepo, rel); err != nil {
// ctx.Handle(500, "release.EditReleasePost(UpdateRelease)", err)
// return
// }
// ctx.Redirect(ctx.Repo.RepoLink + "/releases")
// }

507
routers/repo/repo.go
View File

@@ -5,22 +5,15 @@
package repo
import (
"bytes"
"encoding/base64"
"errors"
"fmt"
"io/ioutil"
"os"
"path"
"path/filepath"
"strings"
"github.com/go-martini/martini"
"github.com/gogits/git"
"github.com/Unknwon/com"
"github.com/gogits/gogs/models"
"github.com/gogits/gogs/modules/auth"
"github.com/gogits/gogs/modules/base"
"github.com/gogits/gogs/modules/git"
"github.com/gogits/gogs/modules/log"
"github.com/gogits/gogs/modules/middleware"
)
@@ -28,47 +21,63 @@ import (
const (
CREATE base.TplName = "repo/create"
MIGRATE base.TplName = "repo/migrate"
SINGLE base.TplName = "repo/single"
)
func Create(ctx *middleware.Context) {
ctx.Data["Title"] = "Create repository"
ctx.Data["PageIsNewRepo"] = true
ctx.Data["LanguageIgns"] = models.LanguageIgns
ctx.Data["Title"] = ctx.Tr("new_repo")
ctx.Data["PageIsRepoCreate"] = true
// Give default value for template to render.
ctx.Data["gitignore"] = "0"
ctx.Data["license"] = "0"
ctx.Data["Gitignores"] = models.Gitignores
ctx.Data["Licenses"] = models.Licenses
ctxUser := ctx.User
orgId, _ := base.StrTo(ctx.Query("org")).Int64()
if orgId > 0 {
org, err := models.GetUserById(orgId)
if err != nil && err != models.ErrUserNotExist {
ctx.Handle(500, "home.Dashboard(GetUserById)", err)
return
}
ctxUser = org
}
// orgId := com.StrTo(ctx.Query("org")).MustInt64()
// if orgId > 0 {
// org, err := models.GetUserById(orgId)
// if err != nil && err != models.ErrUserNotExist {
// ctx.Handle(500, "home.Dashboard(GetUserById)", err)
// return
// }
// ctxUser = org
// }
ctx.Data["ContextUser"] = ctxUser
if err := ctx.User.GetOrganizations(); err != nil {
ctx.Handle(500, "home.Dashboard(GetOrganizations)", err)
return
}
ctx.Data["AllUsers"] = append([]*models.User{ctx.User}, ctx.User.Orgs...)
// if err := ctx.User.GetOrganizations(); err != nil {
// ctx.Handle(500, "home.Dashboard(GetOrganizations)", err)
// return
// }
// ctx.Data["AllUsers"] = append([]*models.User{ctx.User}, ctx.User.Orgs...)
ctx.HTML(200, CREATE)
}
func CreatePost(ctx *middleware.Context, form auth.CreateRepoForm) {
ctx.Data["Title"] = "Create repository"
ctx.Data["PageIsNewRepo"] = true
ctx.Data["LanguageIgns"] = models.LanguageIgns
ctx.Data["Title"] = ctx.Tr("new_repo")
ctx.Data["PageIsRepoCreate"] = true
ctx.Data["Gitignores"] = models.Gitignores
ctx.Data["Licenses"] = models.Licenses
if err := ctx.User.GetOrganizations(); err != nil {
ctx.Handle(500, "home.CreatePost(GetOrganizations)", err)
return
}
ctx.Data["Orgs"] = ctx.User.Orgs
ctxUser := ctx.User
// orgId := com.StrTo(ctx.Query("org")).MustInt64()
// if orgId > 0 {
// org, err := models.GetUserById(orgId)
// if err != nil && err != models.ErrUserNotExist {
// ctx.Handle(500, "home.Dashboard(GetUserById)", err)
// return
// }
// ctxUser = org
// }
ctx.Data["ContextUser"] = ctxUser
// if err := ctx.User.GetOrganizations(); err != nil {
// ctx.Handle(500, "home.CreatePost(GetOrganizations)", err)
// return
// }
// ctx.Data["Orgs"] = ctx.User.Orgs
if ctx.HasError() {
ctx.HTML(200, CREATE)
@@ -97,337 +106,159 @@ func CreatePost(ctx *middleware.Context, form auth.CreateRepoForm) {
}
repo, err := models.CreateRepository(u, form.RepoName, form.Description,
form.Language, form.License, form.Private, false, form.InitReadme)
form.Gitignore, form.License, form.Private, false, form.InitReadme)
if err == nil {
log.Trace("%s Repository created: %s/%s", ctx.Req.RequestURI, u.LowerName, form.RepoName)
log.Trace("Repository created: %s/%s", u.Name, form.RepoName)
ctx.Redirect("/" + u.Name + "/" + form.RepoName)
return
} else if err == models.ErrRepoAlreadyExist {
ctx.RenderWithErr("Repository name has already been used", CREATE, &form)
ctx.RenderWithErr(ctx.Tr("form.repo_name_been_taken"), CREATE, &form)
return
} else if err == models.ErrRepoNameIllegal {
ctx.RenderWithErr(models.ErrRepoNameIllegal.Error(), CREATE, &form)
ctx.RenderWithErr(ctx.Tr("form.illegal_repo_name"), CREATE, &form)
return
}
if repo != nil {
if errDelete := models.DeleteRepository(u.Id, repo.Id, u.Name); errDelete != nil {
log.Error("repo.CreatePost(DeleteRepository): %v", errDelete)
log.Error(4, "DeleteRepository: %v", errDelete)
}
}
ctx.Handle(500, "repo.CreatePost(CreateRepository)", err)
ctx.Handle(500, "CreateRepository", err)
}
func Migrate(ctx *middleware.Context) {
ctx.Data["Title"] = "Migrate repository"
ctx.Data["PageIsNewRepo"] = true
// func Migrate(ctx *middleware.Context) {
// ctx.Data["Title"] = "Migrate repository"
// ctx.Data["PageIsNewRepo"] = true
if err := ctx.User.GetOrganizations(); err != nil {
ctx.Handle(500, "home.Migrate(GetOrganizations)", err)
return
}
ctx.Data["Orgs"] = ctx.User.Orgs
// if err := ctx.User.GetOrganizations(); err != nil {
// ctx.Handle(500, "home.Migrate(GetOrganizations)", err)
// return
// }
// ctx.Data["Orgs"] = ctx.User.Orgs
ctx.HTML(200, MIGRATE)
}
// ctx.HTML(200, MIGRATE)
// }
func MigratePost(ctx *middleware.Context, form auth.MigrateRepoForm) {
ctx.Data["Title"] = "Migrate repository"
ctx.Data["PageIsNewRepo"] = true
// func MigratePost(ctx *middleware.Context, form auth.MigrateRepoForm) {
// ctx.Data["Title"] = "Migrate repository"
// ctx.Data["PageIsNewRepo"] = true
if err := ctx.User.GetOrganizations(); err != nil {
ctx.Handle(500, "home.MigratePost(GetOrganizations)", err)
return
}
ctx.Data["Orgs"] = ctx.User.Orgs
// if err := ctx.User.GetOrganizations(); err != nil {
// ctx.Handle(500, "home.MigratePost(GetOrganizations)", err)
// return
// }
// ctx.Data["Orgs"] = ctx.User.Orgs
if ctx.HasError() {
ctx.HTML(200, MIGRATE)
// if ctx.HasError() {
// ctx.HTML(200, MIGRATE)
// return
// }
// u := ctx.User
// // Not equal means current user is an organization.
// if u.Id != form.Uid {
// var err error
// u, err = models.GetUserById(form.Uid)
// if err != nil {
// if err == models.ErrUserNotExist {
// ctx.Handle(404, "home.MigratePost(GetUserById)", err)
// } else {
// ctx.Handle(500, "home.MigratePost(GetUserById)", err)
// }
// return
// }
// }
// authStr := strings.Replace(fmt.Sprintf("://%s:%s",
// form.AuthUserName, form.AuthPasswd), "@", "%40", -1)
// url := strings.Replace(form.Url, "://", authStr+"@", 1)
// repo, err := models.MigrateRepository(u, form.RepoName, form.Description, form.Private,
// form.Mirror, url)
// if err == nil {
// log.Trace("%s Repository migrated: %s/%s", ctx.Req.RequestURI, u.LowerName, form.RepoName)
// ctx.Redirect("/" + u.Name + "/" + form.RepoName)
// return
// } else if err == models.ErrRepoAlreadyExist {
// ctx.RenderWithErr("Repository name has already been used", MIGRATE, &form)
// return
// } else if err == models.ErrRepoNameIllegal {
// ctx.RenderWithErr(models.ErrRepoNameIllegal.Error(), MIGRATE, &form)
// return
// }
// if repo != nil {
// if errDelete := models.DeleteRepository(u.Id, repo.Id, u.Name); errDelete != nil {
// log.Error("repo.MigratePost(DeleteRepository): %v", errDelete)
// }
// }
// if strings.Contains(err.Error(), "Authentication failed") {
// ctx.RenderWithErr(err.Error(), MIGRATE, &form)
// return
// }
// ctx.Handle(500, "repo.Migrate(MigrateRepository)", err)
// }
// func Action(ctx *middleware.Context, params martini.Params) {
// var err error
// switch params["action"] {
// case "watch":
// err = models.WatchRepo(ctx.User.Id, ctx.Repo.Repository.Id, true)
// case "unwatch":
// err = models.WatchRepo(ctx.User.Id, ctx.Repo.Repository.Id, false)
// case "desc":
// if !ctx.Repo.IsOwner {
// ctx.Error(404)
// return
// }
// ctx.Repo.Repository.Description = ctx.Query("desc")
// ctx.Repo.Repository.Website = ctx.Query("site")
// err = models.UpdateRepository(ctx.Repo.Repository)
// }
// if err != nil {
// log.Error("repo.Action(%s): %v", params["action"], err)
// ctx.JSON(200, map[string]interface{}{
// "ok": false,
// "err": err.Error(),
// })
// return
// }
// ctx.JSON(200, map[string]interface{}{
// "ok": true,
// })
// }
func Download(ctx *middleware.Context) {
ext := "." + ctx.Params(":ext")
var archivePath string
switch ext {
case ".zip":
archivePath = path.Join(ctx.Repo.GitRepo.Path, "archives/zip")
case ".tar.gz":
archivePath = path.Join(ctx.Repo.GitRepo.Path, "archives/targz")
default:
ctx.Error(404)
return
}
u := ctx.User
// Not equal means current user is an organization.
if u.Id != form.Uid {
var err error
u, err = models.GetUserById(form.Uid)
if err != nil {
if err == models.ErrUserNotExist {
ctx.Handle(404, "home.MigratePost(GetUserById)", err)
} else {
ctx.Handle(500, "home.MigratePost(GetUserById)", err)
}
if !com.IsDir(archivePath) {
if err := os.MkdirAll(archivePath, os.ModePerm); err != nil {
ctx.Handle(500, "Download -> os.MkdirAll(archivePath)", err)
return
}
}
authStr := strings.Replace(fmt.Sprintf("://%s:%s",
form.AuthUserName, form.AuthPasswd), "@", "%40", -1)
url := strings.Replace(form.Url, "://", authStr+"@", 1)
repo, err := models.MigrateRepository(u, form.RepoName, form.Description, form.Private,
form.Mirror, url)
if err == nil {
log.Trace("%s Repository migrated: %s/%s", ctx.Req.RequestURI, u.LowerName, form.RepoName)
ctx.Redirect("/" + u.Name + "/" + form.RepoName)
return
} else if err == models.ErrRepoAlreadyExist {
ctx.RenderWithErr("Repository name has already been used", MIGRATE, &form)
return
} else if err == models.ErrRepoNameIllegal {
ctx.RenderWithErr(models.ErrRepoNameIllegal.Error(), MIGRATE, &form)
return
}
if repo != nil {
if errDelete := models.DeleteRepository(u.Id, repo.Id, u.Name); errDelete != nil {
log.Error("repo.MigratePost(DeleteRepository): %v", errDelete)
}
}
if strings.Contains(err.Error(), "Authentication failed") {
ctx.RenderWithErr(err.Error(), MIGRATE, &form)
return
}
ctx.Handle(500, "repo.Migrate(MigrateRepository)", err)
}
func Single(ctx *middleware.Context, params martini.Params) {
branchName := ctx.Repo.BranchName
userName := ctx.Repo.Owner.Name
repoName := ctx.Repo.Repository.Name
repoLink := ctx.Repo.RepoLink
branchLink := ctx.Repo.RepoLink + "/src/" + branchName
rawLink := ctx.Repo.RepoLink + "/raw/" + branchName
// Get tree path
treename := params["_1"]
if len(treename) > 0 && treename[len(treename)-1] == '/' {
ctx.Redirect(repoLink + "/src/" + branchName + "/" + treename[:len(treename)-1])
return
}
ctx.Data["IsRepoToolbarSource"] = true
isViewBranch := ctx.Repo.IsBranch
ctx.Data["IsViewBranch"] = isViewBranch
treePath := treename
if len(treePath) != 0 {
treePath = treePath + "/"
}
entry, err := ctx.Repo.Commit.GetTreeEntryByPath(treename)
if err != nil && err != git.ErrNotExist {
ctx.Handle(404, "repo.Single(GetTreeEntryByPath)", err)
return
}
if len(treename) != 0 && entry == nil {
ctx.Handle(404, "repo.Single", nil)
return
}
if entry != nil && !entry.IsDir() {
blob := entry.Blob()
if dataRc, err := blob.Data(); err != nil {
ctx.Handle(404, "repo.Single(blob.Data)", err)
} else {
ctx.Data["FileSize"] = blob.Size()
ctx.Data["IsFile"] = true
ctx.Data["FileName"] = blob.Name()
ext := path.Ext(blob.Name())
if len(ext) > 0 {
ext = ext[1:]
}
ctx.Data["FileExt"] = ext
ctx.Data["FileLink"] = rawLink + "/" + treename
buf := make([]byte, 1024)
n, _ := dataRc.Read(buf)
if n > 0 {
buf = buf[:n]
}
defer func() {
dataRc.Close()
}()
_, isTextFile := base.IsTextFile(buf)
_, isImageFile := base.IsImageFile(buf)
ctx.Data["FileIsText"] = isTextFile
switch {
case isImageFile:
ctx.Data["IsImageFile"] = true
case isTextFile:
d, _ := ioutil.ReadAll(dataRc)
buf = append(buf, d...)
readmeExist := base.IsMarkdownFile(blob.Name()) || base.IsReadmeFile(blob.Name())
ctx.Data["ReadmeExist"] = readmeExist
if readmeExist {
ctx.Data["FileContent"] = string(base.RenderMarkdown(buf, ""))
} else {
ctx.Data["FileContent"] = string(buf)
}
}
}
} else {
// Directory and file list.
tree, err := ctx.Repo.Commit.SubTree(treename)
if err != nil {
ctx.Handle(404, "repo.Single(SubTree)", err)
archivePath = path.Join(archivePath, ctx.Repo.CommitId+ext)
if !com.IsFile(archivePath) {
if err := ctx.Repo.Commit.CreateArchive(archivePath, git.ZIP); err != nil {
ctx.Handle(500, "Download -> CreateArchive "+archivePath, err)
return
}
entries := tree.ListEntries()
entries.Sort()
files := make([][]interface{}, 0, len(entries))
for _, te := range entries {
c, err := ctx.Repo.Commit.GetCommitOfRelPath(filepath.Join(treePath, te.Name()))
if err != nil {
ctx.Handle(404, "repo.Single(SubTree)", err)
return
}
files = append(files, []interface{}{te, c})
}
ctx.Data["Files"] = files
var readmeFile *git.Blob
for _, f := range entries {
if f.IsDir() || !base.IsReadmeFile(f.Name()) {
continue
} else {
readmeFile = f.Blob()
break
}
}
if readmeFile != nil {
ctx.Data["ReadmeInSingle"] = true
ctx.Data["ReadmeExist"] = true
if dataRc, err := readmeFile.Data(); err != nil {
ctx.Handle(404, "repo.Single(readmeFile.LookupBlob)", err)
return
} else {
buf := make([]byte, 1024)
n, _ := dataRc.Read(buf)
if n > 0 {
buf = buf[:n]
}
defer func() {
dataRc.Close()
}()
ctx.Data["FileSize"] = readmeFile.Size
ctx.Data["FileLink"] = rawLink + "/" + treename
_, isTextFile := base.IsTextFile(buf)
ctx.Data["FileIsText"] = isTextFile
ctx.Data["FileName"] = readmeFile.Name()
if isTextFile {
d, _ := ioutil.ReadAll(dataRc)
buf = append(buf, d...)
switch {
case base.IsMarkdownFile(readmeFile.Name()):
buf = base.RenderMarkdown(buf, branchLink)
default:
buf = bytes.Replace(buf, []byte("\n"), []byte(`<br>`), -1)
}
ctx.Data["FileContent"] = string(buf)
}
}
}
}
ctx.Data["Username"] = userName
ctx.Data["Reponame"] = repoName
var treenames []string
Paths := make([]string, 0)
if len(treename) > 0 {
treenames = strings.Split(treename, "/")
for i, _ := range treenames {
Paths = append(Paths, strings.Join(treenames[0:i+1], "/"))
}
ctx.Data["HasParentPath"] = true
if len(Paths)-2 >= 0 {
ctx.Data["ParentPath"] = "/" + Paths[len(Paths)-2]
}
}
ctx.Data["LastCommit"] = ctx.Repo.Commit
ctx.Data["Paths"] = Paths
ctx.Data["TreeName"] = treename
ctx.Data["Treenames"] = treenames
ctx.Data["TreePath"] = treePath
ctx.Data["BranchLink"] = branchLink
ctx.HTML(200, SINGLE)
}
func basicEncode(username, password string) string {
auth := username + ":" + password
return base64.StdEncoding.EncodeToString([]byte(auth))
}
func basicDecode(encoded string) (user string, name string, err error) {
var s []byte
s, err = base64.StdEncoding.DecodeString(encoded)
if err != nil {
return
}
a := strings.Split(string(s), ":")
if len(a) == 2 {
user, name = a[0], a[1]
} else {
err = errors.New("decode failed")
}
return
}
func authRequired(ctx *middleware.Context) {
ctx.ResponseWriter.Header().Set("WWW-Authenticate", "Basic realm=\".\"")
ctx.Data["ErrorMsg"] = "no basic auth and digit auth"
ctx.HTML(401, base.TplName("status/401"))
}
func Action(ctx *middleware.Context, params martini.Params) {
var err error
switch params["action"] {
case "watch":
err = models.WatchRepo(ctx.User.Id, ctx.Repo.Repository.Id, true)
case "unwatch":
err = models.WatchRepo(ctx.User.Id, ctx.Repo.Repository.Id, false)
case "desc":
if !ctx.Repo.IsOwner {
ctx.Error(404)
return
}
ctx.Repo.Repository.Description = ctx.Query("desc")
ctx.Repo.Repository.Website = ctx.Query("site")
err = models.UpdateRepository(ctx.Repo.Repository)
}
if err != nil {
log.Error("repo.Action(%s): %v", params["action"], err)
ctx.JSON(200, map[string]interface{}{
"ok": false,
"err": err.Error(),
})
return
}
ctx.JSON(200, map[string]interface{}{
"ok": true,
})
ctx.ServeFile(archivePath, ctx.Repo.Repository.Name+"-"+base.ShortSha(ctx.Repo.CommitId)+ext)
}

620
routers/repo/setting.go
View File

@@ -4,362 +4,362 @@
package repo
import (
"fmt"
"strings"
"time"
// import (
// "fmt"
// "strings"
// "time"
"github.com/go-martini/martini"
// "github.com/go-martini/martini"
"github.com/gogits/gogs/models"
"github.com/gogits/gogs/modules/auth"
"github.com/gogits/gogs/modules/base"
"github.com/gogits/gogs/modules/log"
"github.com/gogits/gogs/modules/mailer"
"github.com/gogits/gogs/modules/middleware"
"github.com/gogits/gogs/modules/setting"
)
// "github.com/gogits/gogs-ng/models"
// "github.com/gogits/gogs/modules/auth"
// "github.com/gogits/gogs/modules/base"
// "github.com/gogits/gogs/modules/log"
// "github.com/gogits/gogs/modules/mailer"
// "github.com/gogits/gogs/modules/middleware"
// "github.com/gogits/gogs/modules/setting"
// )
const (
SETTING base.TplName = "repo/setting"
COLLABORATION base.TplName = "repo/collaboration"
// const (
// SETTING base.TplName = "repo/setting"
// COLLABORATION base.TplName = "repo/collaboration"
HOOKS base.TplName = "repo/hooks"
HOOK_ADD base.TplName = "repo/hook_add"
HOOK_EDIT base.TplName = "repo/hook_edit"
)
// HOOKS base.TplName = "repo/hooks"
// HOOK_ADD base.TplName = "repo/hook_add"
// HOOK_EDIT base.TplName = "repo/hook_edit"
// )
func Setting(ctx *middleware.Context) {
ctx.Data["IsRepoToolbarSetting"] = true
ctx.Data["Title"] = strings.TrimPrefix(ctx.Repo.RepoLink, "/") + " - settings"
ctx.HTML(200, SETTING)
}
// func Setting(ctx *middleware.Context) {
// ctx.Data["IsRepoToolbarSetting"] = true
// ctx.Data["Title"] = strings.TrimPrefix(ctx.Repo.RepoLink, "/") + " - settings"
// ctx.HTML(200, SETTING)
// }
func SettingPost(ctx *middleware.Context, form auth.RepoSettingForm) {
ctx.Data["IsRepoToolbarSetting"] = true
// func SettingPost(ctx *middleware.Context, form auth.RepoSettingForm) {
// ctx.Data["IsRepoToolbarSetting"] = true
switch ctx.Query("action") {
case "update":
if ctx.HasError() {
ctx.HTML(200, SETTING)
return
}
// switch ctx.Query("action") {
// case "update":
// if ctx.HasError() {
// ctx.HTML(200, SETTING)
// return
// }
newRepoName := form.RepoName
// Check if repository name has been changed.
if ctx.Repo.Repository.Name != newRepoName {
isExist, err := models.IsRepositoryExist(ctx.Repo.Owner, newRepoName)
if err != nil {
ctx.Handle(500, "setting.SettingPost(update: check existence)", err)
return
} else if isExist {
ctx.RenderWithErr("Repository name has been taken in your repositories.", SETTING, nil)
return
} else if err = models.ChangeRepositoryName(ctx.Repo.Owner.Name, ctx.Repo.Repository.Name, newRepoName); err != nil {
ctx.Handle(500, "setting.SettingPost(change repository name)", err)
return
}
log.Trace("%s Repository name changed: %s/%s -> %s", ctx.Req.RequestURI, ctx.User.Name, ctx.Repo.Repository.Name, newRepoName)
// newRepoName := form.RepoName
// // Check if repository name has been changed.
// if ctx.Repo.Repository.Name != newRepoName {
// isExist, err := models.IsRepositoryExist(ctx.Repo.Owner, newRepoName)
// if err != nil {
// ctx.Handle(500, "setting.SettingPost(update: check existence)", err)
// return
// } else if isExist {
// ctx.RenderWithErr("Repository name has been taken in your repositories.", SETTING, nil)
// return
// } else if err = models.ChangeRepositoryName(ctx.Repo.Owner.Name, ctx.Repo.Repository.Name, newRepoName); err != nil {
// ctx.Handle(500, "setting.SettingPost(change repository name)", err)
// return
// }
// log.Trace("%s Repository name changed: %s/%s -> %s", ctx.Req.RequestURI, ctx.User.Name, ctx.Repo.Repository.Name, newRepoName)
ctx.Repo.Repository.Name = newRepoName
}
// ctx.Repo.Repository.Name = newRepoName
// }
br := form.Branch
// br := form.Branch
if ctx.Repo.GitRepo.IsBranchExist(br) {
ctx.Repo.Repository.DefaultBranch = br
}
ctx.Repo.Repository.Description = form.Description
ctx.Repo.Repository.Website = form.Website
ctx.Repo.Repository.IsPrivate = form.Private
ctx.Repo.Repository.IsGoget = form.GoGet
if err := models.UpdateRepository(ctx.Repo.Repository); err != nil {
ctx.Handle(404, "setting.SettingPost(update)", err)
return
}
log.Trace("%s Repository updated: %s/%s", ctx.Req.RequestURI, ctx.Repo.Owner.Name, ctx.Repo.Repository.Name)
// if ctx.Repo.GitRepo.IsBranchExist(br) {
// ctx.Repo.Repository.DefaultBranch = br
// }
// ctx.Repo.Repository.Description = form.Description
// ctx.Repo.Repository.Website = form.Website
// ctx.Repo.Repository.IsPrivate = form.Private
// ctx.Repo.Repository.IsGoget = form.GoGet
// if err := models.UpdateRepository(ctx.Repo.Repository); err != nil {
// ctx.Handle(404, "setting.SettingPost(update)", err)
// return
// }
// log.Trace("%s Repository updated: %s/%s", ctx.Req.RequestURI, ctx.Repo.Owner.Name, ctx.Repo.Repository.Name)
if ctx.Repo.Repository.IsMirror {
if form.Interval > 0 {
ctx.Repo.Mirror.Interval = form.Interval
ctx.Repo.Mirror.NextUpdate = time.Now().Add(time.Duration(form.Interval) * time.Hour)
if err := models.UpdateMirror(ctx.Repo.Mirror); err != nil {
log.Error("setting.SettingPost(UpdateMirror): %v", err)
}
}
}
// if ctx.Repo.Repository.IsMirror {
// if form.Interval > 0 {
// ctx.Repo.Mirror.Interval = form.Interval
// ctx.Repo.Mirror.NextUpdate = time.Now().Add(time.Duration(form.Interval) * time.Hour)
// if err := models.UpdateMirror(ctx.Repo.Mirror); err != nil {
// log.Error("setting.SettingPost(UpdateMirror): %v", err)
// }
// }
// }
ctx.Flash.Success("Repository options has been successfully updated.")
ctx.Redirect(fmt.Sprintf("/%s/%s/settings", ctx.Repo.Owner.Name, ctx.Repo.Repository.Name))
case "transfer":
if len(ctx.Repo.Repository.Name) == 0 || ctx.Repo.Repository.Name != ctx.Query("repository") {
ctx.RenderWithErr("Please make sure you entered repository name is correct.", SETTING, nil)
return
} else if ctx.Repo.Repository.IsMirror {
ctx.Error(404)
return
}
// ctx.Flash.Success("Repository options has been successfully updated.")
// ctx.Redirect(fmt.Sprintf("/%s/%s/settings", ctx.Repo.Owner.Name, ctx.Repo.Repository.Name))
// case "transfer":
// if len(ctx.Repo.Repository.Name) == 0 || ctx.Repo.Repository.Name != ctx.Query("repository") {
// ctx.RenderWithErr("Please make sure you entered repository name is correct.", SETTING, nil)
// return
// } else if ctx.Repo.Repository.IsMirror {
// ctx.Error(404)
// return
// }
newOwner := ctx.Query("owner")
// Check if new owner exists.
isExist, err := models.IsUserExist(newOwner)
if err != nil {
ctx.Handle(500, "setting.SettingPost(transfer: check existence)", err)
return
} else if !isExist {
ctx.RenderWithErr("Please make sure you entered owner name is correct.", SETTING, nil)
return
} else if err = models.TransferOwnership(ctx.Repo.Owner, newOwner, ctx.Repo.Repository); err != nil {
ctx.Handle(500, "setting.SettingPost(transfer repository)", err)
return
}
log.Trace("%s Repository transfered: %s/%s -> %s", ctx.Req.RequestURI, ctx.User.Name, ctx.Repo.Repository.Name, newOwner)
// newOwner := ctx.Query("owner")
// // Check if new owner exists.
// isExist, err := models.IsUserExist(newOwner)
// if err != nil {
// ctx.Handle(500, "setting.SettingPost(transfer: check existence)", err)
// return
// } else if !isExist {
// ctx.RenderWithErr("Please make sure you entered owner name is correct.", SETTING, nil)
// return
// } else if err = models.TransferOwnership(ctx.Repo.Owner, newOwner, ctx.Repo.Repository); err != nil {
// ctx.Handle(500, "setting.SettingPost(transfer repository)", err)
// return
// }
// log.Trace("%s Repository transfered: %s/%s -> %s", ctx.Req.RequestURI, ctx.User.Name, ctx.Repo.Repository.Name, newOwner)
ctx.Redirect("/")
case "delete":
if len(ctx.Repo.Repository.Name) == 0 || ctx.Repo.Repository.Name != ctx.Query("repository") {
ctx.RenderWithErr("Please make sure you entered repository name is correct.", SETTING, nil)
return
}
// ctx.Redirect("/")
// case "delete":
// if len(ctx.Repo.Repository.Name) == 0 || ctx.Repo.Repository.Name != ctx.Query("repository") {
// ctx.RenderWithErr("Please make sure you entered repository name is correct.", SETTING, nil)
// return
// }
if ctx.Repo.Owner.IsOrganization() &&
!ctx.Repo.Owner.IsOrgOwner(ctx.User.Id) {
ctx.Error(403)
return
}
// if ctx.Repo.Owner.IsOrganization() &&
// !ctx.Repo.Owner.IsOrgOwner(ctx.User.Id) {
// ctx.Error(403)
// return
// }
if err := models.DeleteRepository(ctx.Repo.Owner.Id, ctx.Repo.Repository.Id, ctx.Repo.Owner.Name); err != nil {
ctx.Handle(500, "setting.Delete(DeleteRepository)", err)
return
}
log.Trace("%s Repository deleted: %s/%s", ctx.Req.RequestURI, ctx.Repo.Owner.LowerName, ctx.Repo.Repository.LowerName)
// if err := models.DeleteRepository(ctx.Repo.Owner.Id, ctx.Repo.Repository.Id, ctx.Repo.Owner.Name); err != nil {
// ctx.Handle(500, "setting.Delete(DeleteRepository)", err)
// return
// }
// log.Trace("%s Repository deleted: %s/%s", ctx.Req.RequestURI, ctx.Repo.Owner.LowerName, ctx.Repo.Repository.LowerName)
if ctx.Repo.Owner.IsOrganization() {
ctx.Redirect("/org/" + ctx.Repo.Owner.Name + "/dashboard")
} else {
ctx.Redirect("/")
}
}
}
// if ctx.Repo.Owner.IsOrganization() {
// ctx.Redirect("/org/" + ctx.Repo.Owner.Name + "/dashboard")
// } else {
// ctx.Redirect("/")
// }
// }
// }
func Collaboration(ctx *middleware.Context) {
repoLink := strings.TrimPrefix(ctx.Repo.RepoLink, "/")
ctx.Data["IsRepoToolbarCollaboration"] = true
ctx.Data["Title"] = repoLink + " - collaboration"
// func Collaboration(ctx *middleware.Context) {
// repoLink := strings.TrimPrefix(ctx.Repo.RepoLink, "/")
// ctx.Data["IsRepoToolbarCollaboration"] = true
// ctx.Data["Title"] = repoLink + " - collaboration"
// Delete collaborator.
remove := strings.ToLower(ctx.Query("remove"))
if len(remove) > 0 && remove != ctx.Repo.Owner.LowerName {
if err := models.DeleteAccess(&models.Access{UserName: remove, RepoName: repoLink}); err != nil {
ctx.Handle(500, "setting.Collaboration(DeleteAccess)", err)
return
}
ctx.Flash.Success("Collaborator has been removed.")
ctx.Redirect(ctx.Repo.RepoLink + "/settings/collaboration")
return
}
// // Delete collaborator.
// remove := strings.ToLower(ctx.Query("remove"))
// if len(remove) > 0 && remove != ctx.Repo.Owner.LowerName {
// if err := models.DeleteAccess(&models.Access{UserName: remove, RepoName: repoLink}); err != nil {
// ctx.Handle(500, "setting.Collaboration(DeleteAccess)", err)
// return
// }
// ctx.Flash.Success("Collaborator has been removed.")
// ctx.Redirect(ctx.Repo.RepoLink + "/settings/collaboration")
// return
// }
names, err := models.GetCollaboratorNames(repoLink)
if err != nil {
ctx.Handle(500, "setting.Collaboration(GetCollaborators)", err)
return
}
// names, err := models.GetCollaboratorNames(repoLink)
// if err != nil {
// ctx.Handle(500, "setting.Collaboration(GetCollaborators)", err)
// return
// }
us := make([]*models.User, len(names))
for i, name := range names {
us[i], err = models.GetUserByName(name)
if err != nil {
ctx.Handle(500, "setting.Collaboration(GetUserByName)", err)
return
}
}
// us := make([]*models.User, len(names))
// for i, name := range names {
// us[i], err = models.GetUserByName(name)
// if err != nil {
// ctx.Handle(500, "setting.Collaboration(GetUserByName)", err)
// return
// }
// }
ctx.Data["Collaborators"] = us
ctx.HTML(200, COLLABORATION)
}
// ctx.Data["Collaborators"] = us
// ctx.HTML(200, COLLABORATION)
// }
func CollaborationPost(ctx *middleware.Context) {
repoLink := strings.TrimPrefix(ctx.Repo.RepoLink, "/")
name := strings.ToLower(ctx.Query("collaborator"))
if len(name) == 0 || ctx.Repo.Owner.LowerName == name {
ctx.Redirect(ctx.Req.RequestURI)
return
}
has, err := models.HasAccess(name, repoLink, models.WRITABLE)
if err != nil {
ctx.Handle(500, "setting.CollaborationPost(HasAccess)", err)
return
} else if has {
ctx.Redirect(ctx.Req.RequestURI)
return
}
// func CollaborationPost(ctx *middleware.Context) {
// repoLink := strings.TrimPrefix(ctx.Repo.RepoLink, "/")
// name := strings.ToLower(ctx.Query("collaborator"))
// if len(name) == 0 || ctx.Repo.Owner.LowerName == name {
// ctx.Redirect(ctx.Req.RequestURI)
// return
// }
// has, err := models.HasAccess(name, repoLink, models.WRITABLE)
// if err != nil {
// ctx.Handle(500, "setting.CollaborationPost(HasAccess)", err)
// return
// } else if has {
// ctx.Redirect(ctx.Req.RequestURI)
// return
// }
u, err := models.GetUserByName(name)
if err != nil {
if err == models.ErrUserNotExist {
ctx.Flash.Error("Given user does not exist.")
ctx.Redirect(ctx.Req.RequestURI)
} else {
ctx.Handle(500, "setting.CollaborationPost(GetUserByName)", err)
}
return
}
// u, err := models.GetUserByName(name)
// if err != nil {
// if err == models.ErrUserNotExist {
// ctx.Flash.Error("Given user does not exist.")
// ctx.Redirect(ctx.Req.RequestURI)
// } else {
// ctx.Handle(500, "setting.CollaborationPost(GetUserByName)", err)
// }
// return
// }
if err = models.AddAccess(&models.Access{UserName: name, RepoName: repoLink,
Mode: models.WRITABLE}); err != nil {
ctx.Handle(500, "setting.CollaborationPost(AddAccess)", err)
return
}
// if err = models.AddAccess(&models.Access{UserName: name, RepoName: repoLink,
// Mode: models.WRITABLE}); err != nil {
// ctx.Handle(500, "setting.CollaborationPost(AddAccess)", err)
// return
// }
if setting.Service.EnableNotifyMail {
if err = mailer.SendCollaboratorMail(ctx.Render, u, ctx.User, ctx.Repo.Repository); err != nil {
ctx.Handle(500, "setting.CollaborationPost(SendCollaboratorMail)", err)
return
}
}
// if setting.Service.EnableNotifyMail {
// if err = mailer.SendCollaboratorMail(ctx.Render, u, ctx.User, ctx.Repo.Repository); err != nil {
// ctx.Handle(500, "setting.CollaborationPost(SendCollaboratorMail)", err)
// return
// }
// }
ctx.Flash.Success("New collaborator has been added.")
ctx.Redirect(ctx.Req.RequestURI)
}
// ctx.Flash.Success("New collaborator has been added.")
// ctx.Redirect(ctx.Req.RequestURI)
// }
func WebHooks(ctx *middleware.Context) {
ctx.Data["IsRepoToolbarWebHooks"] = true
ctx.Data["Title"] = strings.TrimPrefix(ctx.Repo.RepoLink, "/") + " - Webhooks"
// func WebHooks(ctx *middleware.Context) {
// ctx.Data["IsRepoToolbarWebHooks"] = true
// ctx.Data["Title"] = strings.TrimPrefix(ctx.Repo.RepoLink, "/") + " - Webhooks"
// Delete webhook.
remove, _ := base.StrTo(ctx.Query("remove")).Int64()
if remove > 0 {
if err := models.DeleteWebhook(remove); err != nil {
ctx.Handle(500, "setting.WebHooks(DeleteWebhook)", err)
return
}
ctx.Flash.Success("Webhook has been removed.")
ctx.Redirect(ctx.Repo.RepoLink + "/settings/hooks")
return
}
// // Delete webhook.
// remove, _ := base.StrTo(ctx.Query("remove")).Int64()
// if remove > 0 {
// if err := models.DeleteWebhook(remove); err != nil {
// ctx.Handle(500, "setting.WebHooks(DeleteWebhook)", err)
// return
// }
// ctx.Flash.Success("Webhook has been removed.")
// ctx.Redirect(ctx.Repo.RepoLink + "/settings/hooks")
// return
// }
ws, err := models.GetWebhooksByRepoId(ctx.Repo.Repository.Id)
if err != nil {
ctx.Handle(500, "setting.WebHooks(GetWebhooksByRepoId)", err)
return
}
// ws, err := models.GetWebhooksByRepoId(ctx.Repo.Repository.Id)
// if err != nil {
// ctx.Handle(500, "setting.WebHooks(GetWebhooksByRepoId)", err)
// return
// }
ctx.Data["Webhooks"] = ws
ctx.HTML(200, HOOKS)
}
// ctx.Data["Webhooks"] = ws
// ctx.HTML(200, HOOKS)
// }
func WebHooksAdd(ctx *middleware.Context) {
ctx.Data["IsRepoToolbarWebHooks"] = true
ctx.Data["Title"] = strings.TrimPrefix(ctx.Repo.RepoLink, "/") + " - Add Webhook"
ctx.HTML(200, HOOK_ADD)
}
// func WebHooksAdd(ctx *middleware.Context) {
// ctx.Data["IsRepoToolbarWebHooks"] = true
// ctx.Data["Title"] = strings.TrimPrefix(ctx.Repo.RepoLink, "/") + " - Add Webhook"
// ctx.HTML(200, HOOK_ADD)
// }
func WebHooksAddPost(ctx *middleware.Context, form auth.NewWebhookForm) {
ctx.Data["IsRepoToolbarWebHooks"] = true
ctx.Data["Title"] = strings.TrimPrefix(ctx.Repo.RepoLink, "/") + " - Add Webhook"
// func WebHooksAddPost(ctx *middleware.Context, form auth.NewWebhookForm) {
// ctx.Data["IsRepoToolbarWebHooks"] = true
// ctx.Data["Title"] = strings.TrimPrefix(ctx.Repo.RepoLink, "/") + " - Add Webhook"
if ctx.HasError() {
ctx.HTML(200, HOOK_ADD)
return
}
// if ctx.HasError() {
// ctx.HTML(200, HOOK_ADD)
// return
// }
ct := models.JSON
if form.ContentType == "2" {
ct = models.FORM
}
// ct := models.JSON
// if form.ContentType == "2" {
// ct = models.FORM
// }
w := &models.Webhook{
RepoId: ctx.Repo.Repository.Id,
Url: form.Url,
ContentType: ct,
Secret: form.Secret,
HookEvent: &models.HookEvent{
PushOnly: form.PushOnly,
},
IsActive: form.Active,
}
if err := w.UpdateEvent(); err != nil {
ctx.Handle(500, "setting.WebHooksAddPost(UpdateEvent)", err)
return
} else if err := models.CreateWebhook(w); err != nil {
ctx.Handle(500, "setting.WebHooksAddPost(CreateWebhook)", err)
return
}
// w := &models.Webhook{
// RepoId: ctx.Repo.Repository.Id,
// Url: form.Url,
// ContentType: ct,
// Secret: form.Secret,
// HookEvent: &models.HookEvent{
// PushOnly: form.PushOnly,
// },
// IsActive: form.Active,
// }
// if err := w.UpdateEvent(); err != nil {
// ctx.Handle(500, "setting.WebHooksAddPost(UpdateEvent)", err)
// return
// } else if err := models.CreateWebhook(w); err != nil {
// ctx.Handle(500, "setting.WebHooksAddPost(CreateWebhook)", err)
// return
// }
ctx.Flash.Success("New webhook has been added.")
ctx.Redirect(ctx.Repo.RepoLink + "/settings/hooks")
}
// ctx.Flash.Success("New webhook has been added.")
// ctx.Redirect(ctx.Repo.RepoLink + "/settings/hooks")
// }
func WebHooksEdit(ctx *middleware.Context, params martini.Params) {
ctx.Data["IsRepoToolbarWebHooks"] = true
ctx.Data["Title"] = strings.TrimPrefix(ctx.Repo.RepoLink, "/") + " - Webhook"
// func WebHooksEdit(ctx *middleware.Context, params martini.Params) {
// ctx.Data["IsRepoToolbarWebHooks"] = true
// ctx.Data["Title"] = strings.TrimPrefix(ctx.Repo.RepoLink, "/") + " - Webhook"
hookId, _ := base.StrTo(params["id"]).Int64()
if hookId == 0 {
ctx.Handle(404, "setting.WebHooksEdit", nil)
return
}
// hookId, _ := base.StrTo(params["id"]).Int64()
// if hookId == 0 {
// ctx.Handle(404, "setting.WebHooksEdit", nil)
// return
// }
w, err := models.GetWebhookById(hookId)
if err != nil {
if err == models.ErrWebhookNotExist {
ctx.Handle(404, "setting.WebHooksEdit(GetWebhookById)", nil)
} else {
ctx.Handle(500, "setting.WebHooksEdit(GetWebhookById)", err)
}
return
}
// w, err := models.GetWebhookById(hookId)
// if err != nil {
// if err == models.ErrWebhookNotExist {
// ctx.Handle(404, "setting.WebHooksEdit(GetWebhookById)", nil)
// } else {
// ctx.Handle(500, "setting.WebHooksEdit(GetWebhookById)", err)
// }
// return
// }
w.GetEvent()
ctx.Data["Webhook"] = w
ctx.HTML(200, HOOK_EDIT)
}
// w.GetEvent()
// ctx.Data["Webhook"] = w
// ctx.HTML(200, HOOK_EDIT)
// }
func WebHooksEditPost(ctx *middleware.Context, params martini.Params, form auth.NewWebhookForm) {
ctx.Data["IsRepoToolbarWebHooks"] = true
ctx.Data["Title"] = strings.TrimPrefix(ctx.Repo.RepoLink, "/") + " - Webhook"
// func WebHooksEditPost(ctx *middleware.Context, params martini.Params, form auth.NewWebhookForm) {
// ctx.Data["IsRepoToolbarWebHooks"] = true
// ctx.Data["Title"] = strings.TrimPrefix(ctx.Repo.RepoLink, "/") + " - Webhook"
hookId, _ := base.StrTo(params["id"]).Int64()
if hookId == 0 {
ctx.Handle(404, "setting.WebHooksEditPost", nil)
return
}
// hookId, _ := base.StrTo(params["id"]).Int64()
// if hookId == 0 {
// ctx.Handle(404, "setting.WebHooksEditPost", nil)
// return
// }
w, err := models.GetWebhookById(hookId)
if err != nil {
if err == models.ErrWebhookNotExist {
ctx.Handle(404, "setting.WebHooksEditPost(GetWebhookById)", nil)
} else {
ctx.Handle(500, "setting.WebHooksEditPost(GetWebhookById)", err)
}
return
}
// w, err := models.GetWebhookById(hookId)
// if err != nil {
// if err == models.ErrWebhookNotExist {
// ctx.Handle(404, "setting.WebHooksEditPost(GetWebhookById)", nil)
// } else {
// ctx.Handle(500, "setting.WebHooksEditPost(GetWebhookById)", err)
// }
// return
// }
if ctx.HasError() {
ctx.HTML(200, HOOK_EDIT)
return
}
// if ctx.HasError() {
// ctx.HTML(200, HOOK_EDIT)
// return
// }
ct := models.JSON
if form.ContentType == "2" {
ct = models.FORM
}
// ct := models.JSON
// if form.ContentType == "2" {
// ct = models.FORM
// }
w.Url = form.Url
w.ContentType = ct
w.Secret = form.Secret
w.HookEvent = &models.HookEvent{
PushOnly: form.PushOnly,
}
w.IsActive = form.Active
if err := w.UpdateEvent(); err != nil {
ctx.Handle(500, "setting.WebHooksEditPost(UpdateEvent)", err)
return
} else if err := models.UpdateWebhook(w); err != nil {
ctx.Handle(500, "setting.WebHooksEditPost(WebHooksEditPost)", err)
return
}
// w.Url = form.Url
// w.ContentType = ct
// w.Secret = form.Secret
// w.HookEvent = &models.HookEvent{
// PushOnly: form.PushOnly,
// }
// w.IsActive = form.Active
// if err := w.UpdateEvent(); err != nil {
// ctx.Handle(500, "setting.WebHooksEditPost(UpdateEvent)", err)
// return
// } else if err := models.UpdateWebhook(w); err != nil {
// ctx.Handle(500, "setting.WebHooksEditPost(WebHooksEditPost)", err)
// return
// }
ctx.Flash.Success("Webhook has been updated.")
ctx.Redirect(fmt.Sprintf("%s/settings/hooks/%d", ctx.Repo.RepoLink, hookId))
}
// ctx.Flash.Success("Webhook has been updated.")
// ctx.Redirect(fmt.Sprintf("%s/settings/hooks/%d", ctx.Repo.RepoLink, hookId))
// }

203
routers/repo/view.go Normal file
View File

@@ -0,0 +1,203 @@
// Copyright 2014 The Gogs 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 repo
import (
"bytes"
"io/ioutil"
"path"
"path/filepath"
"strings"
"github.com/gogits/gogs/modules/base"
"github.com/gogits/gogs/modules/git"
"github.com/gogits/gogs/modules/middleware"
)
const (
HOME base.TplName = "repo/home"
)
func Home(ctx *middleware.Context) {
ctx.Data["Title"] = ctx.Repo.Repository.Name
branchName := ctx.Repo.BranchName
userName := ctx.Repo.Owner.Name
repoName := ctx.Repo.Repository.Name
repoLink := ctx.Repo.RepoLink
branchLink := ctx.Repo.RepoLink + "/src/" + branchName
rawLink := ctx.Repo.RepoLink + "/raw/" + branchName
// Get tree path
treename := ctx.Params("*")
if len(treename) > 0 && treename[len(treename)-1] == '/' {
ctx.Redirect(repoLink + "/src/" + branchName + "/" + treename[:len(treename)-1])
return
}
ctx.Data["IsRepoToolbarSource"] = true
isViewBranch := ctx.Repo.IsBranch
ctx.Data["IsViewBranch"] = isViewBranch
treePath := treename
if len(treePath) != 0 {
treePath = treePath + "/"
}
entry, err := ctx.Repo.Commit.GetTreeEntryByPath(treename)
if err != nil && err != git.ErrNotExist {
ctx.Handle(404, "GetTreeEntryByPath", err)
return
}
if len(treename) != 0 && entry == nil {
ctx.Handle(404, "repo.Home", nil)
return
}
if entry != nil && !entry.IsDir() {
blob := entry.Blob()
if dataRc, err := blob.Data(); err != nil {
ctx.Handle(404, "blob.Data", err)
return
} else {
ctx.Data["FileSize"] = blob.Size()
ctx.Data["IsFile"] = true
ctx.Data["FileName"] = blob.Name()
ext := path.Ext(blob.Name())
if len(ext) > 0 {
ext = ext[1:]
}
ctx.Data["FileExt"] = ext
ctx.Data["FileLink"] = rawLink + "/" + treename
buf := make([]byte, 1024)
n, _ := dataRc.Read(buf)
if n > 0 {
buf = buf[:n]
}
_, isTextFile := base.IsTextFile(buf)
_, isImageFile := base.IsImageFile(buf)
ctx.Data["IsFileText"] = isTextFile
switch {
case isImageFile:
ctx.Data["IsImageFile"] = true
case isTextFile:
d, _ := ioutil.ReadAll(dataRc)
buf = append(buf, d...)
readmeExist := base.IsMarkdownFile(blob.Name()) || base.IsReadmeFile(blob.Name())
ctx.Data["ReadmeExist"] = readmeExist
if readmeExist {
ctx.Data["FileContent"] = string(base.RenderMarkdown(buf, ""))
} else {
ctx.Data["FileContent"] = string(buf)
}
}
}
} else {
// Directory and file list.
tree, err := ctx.Repo.Commit.SubTree(treename)
if err != nil {
ctx.Handle(404, "SubTree", err)
return
}
entries, err := tree.ListEntries(treename)
if err != nil {
ctx.Handle(500, "ListEntries", err)
return
}
entries.Sort()
files := make([][]interface{}, 0, len(entries))
for _, te := range entries {
c, err := ctx.Repo.Commit.GetCommitOfRelPath(filepath.Join(treePath, te.Name()))
if err != nil {
ctx.Handle(404, "GetCommitOfRelPath", err)
return
}
files = append(files, []interface{}{te, c})
}
ctx.Data["Files"] = files
var readmeFile *git.Blob
for _, f := range entries {
if f.IsDir() || !base.IsReadmeFile(f.Name()) {
continue
} else {
readmeFile = f.Blob()
break
}
}
if readmeFile != nil {
ctx.Data["ReadmeInHome"] = true
ctx.Data["ReadmeExist"] = true
if dataRc, err := readmeFile.Data(); err != nil {
ctx.Handle(404, "repo.SinglereadmeFile.LookupBlob", err)
return
} else {
buf := make([]byte, 1024)
n, _ := dataRc.Read(buf)
if n > 0 {
buf = buf[:n]
}
ctx.Data["FileSize"] = readmeFile.Size()
ctx.Data["FileLink"] = rawLink + "/" + treename
_, isTextFile := base.IsTextFile(buf)
ctx.Data["FileIsText"] = isTextFile
ctx.Data["FileName"] = readmeFile.Name()
if isTextFile {
d, _ := ioutil.ReadAll(dataRc)
buf = append(buf, d...)
switch {
case base.IsMarkdownFile(readmeFile.Name()):
buf = base.RenderMarkdown(buf, branchLink)
default:
buf = bytes.Replace(buf, []byte("\n"), []byte(`<br>`), -1)
}
ctx.Data["FileContent"] = string(buf)
}
}
}
}
ctx.Data["Username"] = userName
ctx.Data["Reponame"] = repoName
var treenames []string
Paths := make([]string, 0)
if len(treename) > 0 {
treenames = strings.Split(treename, "/")
for i, _ := range treenames {
Paths = append(Paths, strings.Join(treenames[0:i+1], "/"))
}
ctx.Data["HasParentPath"] = true
if len(Paths)-2 >= 0 {
ctx.Data["ParentPath"] = "/" + Paths[len(Paths)-2]
}
}
ctx.Data["LastCommit"] = ctx.Repo.Commit
ctx.Data["Paths"] = Paths
ctx.Data["TreeName"] = treename
ctx.Data["Treenames"] = treenames
ctx.Data["TreePath"] = treePath
ctx.Data["BranchLink"] = branchLink
ctx.HTML(200, HOME)
}