USEFULL
/
gogs
mirror of https://github.com/gogs/gogs.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

refactor: unify error handling in routing layer

pull/5989/head
ᴜɴᴋɴᴡᴏɴ 2020-03-16 01:22:27 +08:00
parent 82ff0c5852
commit 9e9ca66467
No known key found for this signature in database
GPG Key ID: B43718D76E30A238
95 changed files with 1438 additions and 1417 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
conf/locale/locale_en-US.ini
View File

@ -43,6 +43,10 @@ issues = Issues
cancel = Cancel
[status]
page_not_found = Page Not Found
internal_server_error = Internal Server Error
[install]
install = Installation
title = Install Steps For First-time Run

68
internal/assets/conf/conf_gen.go
View File

File diff suppressed because one or more lines are too long

15
internal/auth/auth.go
View File

@ -15,7 +15,6 @@ import (
"gogs.io/gogs/internal/conf"
"gogs.io/gogs/internal/db"
"gogs.io/gogs/internal/db/errors"
"gogs.io/gogs/internal/tool"
)
@ -70,8 +69,8 @@ func SignedInID(c *macaron.Context, sess session.Store) (_ int64, isTokenAuth bo
}
if id, ok := uid.(int64); ok {
if _, err := db.GetUserByID(id); err != nil {
if !errors.IsUserNotExist(err) {
log.Error("GetUserByID: %v", err)
if !db.IsErrUserNotExist(err) {
log.Error("Failed to get user by ID: %v", err)
}
return 0, false
}
@ -95,8 +94,8 @@ func SignedInUser(ctx *macaron.Context, sess session.Store) (_ *db.User, isBasic
if len(webAuthUser) > 0 {
u, err := db.GetUserByName(webAuthUser)
if err != nil {
if !errors.IsUserNotExist(err) {
log.Error("GetUserByName: %v", err)
if !db.IsErrUserNotExist(err) {
log.Error("Failed to get user by name: %v", err)
return nil, false, false
}
@ -110,7 +109,7 @@ func SignedInUser(ctx *macaron.Context, sess session.Store) (_ *db.User, isBasic
}
if err = db.CreateUser(u); err != nil {
// FIXME: should I create a system notice?
log.Error("CreateUser: %v", err)
log.Error("Failed to create user: %v", err)
return nil, false, false
} else {
return u, false, false
@ -130,8 +129,8 @@ func SignedInUser(ctx *macaron.Context, sess session.Store) (_ *db.User, isBasic
u, err := db.UserLogin(uname, passwd, -1)
if err != nil {
if !errors.IsUserNotExist(err) {
log.Error("UserLogin: %v", err)
if !db.IsErrUserNotExist(err) {
log.Error("Failed to authenticate user: %v", err)
}
return nil, false, false
}

3
internal/cmd/hook.go
View File

@ -23,7 +23,6 @@ import (
"gogs.io/gogs/internal/conf"
"gogs.io/gogs/internal/db"
"gogs.io/gogs/internal/db/errors"
"gogs.io/gogs/internal/email"
"gogs.io/gogs/internal/httplib"
)
@ -93,7 +92,7 @@ func runHookPreReceive(c *cli.Context) error {
repoID := com.StrTo(os.Getenv(db.ENV_REPO_ID)).MustInt64()
protectBranch, err := db.GetProtectBranchOfRepoByName(repoID, branchName)
if err != nil {
if errors.IsErrBranchNotExist(err) {
if db.IsErrBranchNotExist(err) {
continue
}
fail("Internal error", "GetProtectBranchOfRepoByName [repo_id: %d, branch: %s]: %v", repoID, branchName, err)

5
internal/cmd/serv.go
View File

@ -18,7 +18,6 @@ import (
"gogs.io/gogs/internal/conf"
"gogs.io/gogs/internal/db"
"gogs.io/gogs/internal/db/errors"
)
const (
@ -164,7 +163,7 @@ func runServ(c *cli.Context) error {
owner, err := db.GetUserByName(ownerName)
if err != nil {
if errors.IsUserNotExist(err) {
if db.IsErrUserNotExist(err) {
fail("Repository owner does not exist", "Unregistered owner: %s", ownerName)
}
fail("Internal error", "Failed to get repository owner '%s': %v", ownerName, err)
@ -172,7 +171,7 @@ func runServ(c *cli.Context) error {
repo, err := db.GetRepositoryByName(owner.ID, repoName)
if err != nil {
if errors.IsRepoNotExist(err) {
if db.IsErrRepoNotExist(err) {
fail(_ACCESS_DENIED_MESSAGE, "Repository does not exist: %s/%s", owner.Name, repoName)
}
fail("Internal error", "Failed to get repository: %v", err)

6
internal/cmd/web.go
View File

@ -318,7 +318,7 @@ func runWeb(c *cli.Context) error {
m.Get("/attachments/:uuid", func(c *context.Context) {
attach, err := db.GetAttachmentByUUID(c.Params(":uuid"))
if err != nil {
c.NotFoundOrServerError("GetAttachmentByUUID", db.IsErrAttachmentNotExist, err)
c.NotFoundOrError(err, "get attachment by UUID")
return
} else if !com.IsFile(attach.LocalPath()) {
c.NotFound()
@ -327,7 +327,7 @@ func runWeb(c *cli.Context) error {
fr, err := os.Open(attach.LocalPath())
if err != nil {
c.ServerError("open attachment file", err)
c.Error(err, "open attachment file")
return
}
defer fr.Close()
@ -336,7 +336,7 @@ func runWeb(c *cli.Context) error {
c.Header().Set("Content-Disposition", fmt.Sprintf(`inline; filename="%s"`, attach.Name))
if _, err = io.Copy(c.Resp, fr); err != nil {
c.ServerError("copy from file to response", err)
c.Error(err, "copy from file to response")
return
}
})

46
internal/context/api.go
View File

@ -14,6 +14,7 @@ import (
log "unknwon.dev/clog/v2"
"gogs.io/gogs/internal/conf"
"gogs.io/gogs/internal/errutil"
)
type APIContext struct {
@ -28,26 +29,6 @@ type APIContext struct {
// FIXME: move this constant to github.com/gogs/go-gogs-client
const DocURL = "https://github.com/gogs/docs-api"
// Error responses error message to client with given message.
// If status is 500, also it prints error to log.
func (c *APIContext) Error(status int, title string, obj interface{}) {
var message string
if err, ok := obj.(error); ok {
message = err.Error()
} else {
message = obj.(string)
}
if status == http.StatusInternalServerError {
log.ErrorDepth(5, "%s: %s", title, message)
}
c.JSON(status, map[string]string{
"message": message,
"url": DocURL,
})
}
// NoContent renders the 204 response.
func (c *APIContext) NoContent() {
c.Status(http.StatusNoContent)
@ -58,25 +39,34 @@ func (c *APIContext) NotFound() {
c.Status(http.StatusNotFound)
}
// ServerError renders the 500 response.
func (c *APIContext) ServerError(title string, err error) {
c.Error(http.StatusInternalServerError, title, err)
// ErrorStatus renders error with given status code.
func (c *APIContext) ErrorStatus(status int, err error) {
c.JSON(status, map[string]string{
"message": err.Error(),
"url": DocURL,
})
}
// Error renders the 500 response.
func (c *APIContext) Error(err error, msg string) {
log.ErrorDepth(5, "%s: %v", msg, err)
c.ErrorStatus(http.StatusInternalServerError, err)
}
// Errorf renders the 500 response with formatted message.
func (c *APIContext) Errorf(err error, format string, args ...interface{}) {
c.Error(http.StatusInternalServerError, fmt.Sprintf(format, args...), err)
c.Error(err, fmt.Sprintf(format, args...))
}
// NotFoundOrServerError use error check function to determine if the error
// NotFoundOrError use error check function to determine if the error
// is about not found. It responses with 404 status code for not found error,
// or error context description for logging purpose of 500 server error.
func (c *APIContext) NotFoundOrServerError(title string, errck func(error) bool, err error) {
if errck(err) {
func (c *APIContext) NotFoundOrError(err error, msg string) {
if errutil.IsNotFound(err) {
c.NotFound()
return
}
c.ServerError(title, err)
c.Error(err, msg)
}
// SetLinkHeader sets pagination link header by given total number and page size.

26
internal/context/auth.go
View File

@ -28,26 +28,26 @@ func Toggle(options *ToggleOptions) macaron.Handler {
return func(c *Context) {
// Cannot view any page before installation.
if !conf.Security.InstallLock {
c.Redirect(conf.Server.Subpath + "/install")
c.RedirectSubpath("/install")
return
}
// Check prohibit login users.
if c.IsLogged && c.User.ProhibitLogin {
c.Data["Title"] = c.Tr("auth.prohibit_login")
c.HTML(200, "user/auth/prohibit_login")
c.Success( "user/auth/prohibit_login")
return
}
// Check non-logged users landing page.
if !c.IsLogged && c.Req.RequestURI == "/" && conf.Server.LandingURL != "/" {
c.SubURLRedirect(conf.Server.LandingURL)
c.RedirectSubpath(conf.Server.LandingURL)
return
}
// Redirect to dashboard if user tries to visit any non-login page.
if options.SignOutRequired && c.IsLogged && c.Req.RequestURI != "/" {
c.Redirect(conf.Server.Subpath + "/")
c.RedirectSubpath("/")
return
}
@ -62,18 +62,18 @@ func Toggle(options *ToggleOptions) macaron.Handler {
if !c.IsLogged {
// Restrict API calls with error message.
if auth.IsAPIPath(c.Req.URL.Path) {
c.JSON(403, map[string]string{
"message": "Only signed in user is allowed to call APIs.",
c.JSON(http.StatusForbidden, map[string]string{
"message": "Only authenticated user is allowed to call APIs.",
})
return
}
c.SetCookie("redirect_to", url.QueryEscape(conf.Server.Subpath+c.Req.RequestURI), 0, conf.Server.Subpath)
c.Redirect(conf.Server.Subpath + "/user/login")
c.RedirectSubpath("/user/login")
return
} else if !c.User.IsActive && conf.Auth.RequireEmailConfirmation {
c.Data["Title"] = c.Tr("auth.active_your_account")
c.HTML(200, "user/auth/activate")
c.Title("auth.active_your_account")
c.Success("user/auth/activate")
return
}
}
@ -82,21 +82,21 @@ func Toggle(options *ToggleOptions) macaron.Handler {
if !options.SignOutRequired && !c.IsLogged && !auth.IsAPIPath(c.Req.URL.Path) &&
len(c.GetCookie(conf.Security.CookieUsername)) > 0 {
c.SetCookie("redirect_to", url.QueryEscape(conf.Server.Subpath+c.Req.RequestURI), 0, conf.Server.Subpath)
c.Redirect(conf.Server.Subpath + "/user/login")
c.RedirectSubpath("/user/login")
return
}
if options.AdminRequired {
if !c.User.IsAdmin {
c.Error(403)
c.Status(http.StatusForbidden)
return
}
c.Data["PageIsAdmin"] = true
c.PageIs("Admin")
}
}
}
// RequireBasicAuth verifies HTTP Basic Authentication header with given credentials
// RequireBasicAuth verifies HTTP Basic Authentication header with given credentials.
func (c *Context) RequireBasicAuth(username, password string) {
fields := strings.Fields(c.Req.Header.Get("Authorization"))
if len(fields) != 2 || fields[0] != "Basic" {

74
internal/context/context.go
View File

@ -23,7 +23,7 @@ import (
"gogs.io/gogs/internal/auth"
"gogs.io/gogs/internal/conf"
"gogs.io/gogs/internal/db"
"gogs.io/gogs/internal/db/errors"
"gogs.io/gogs/internal/errutil"
"gogs.io/gogs/internal/form"
"gogs.io/gogs/internal/template"
)
@ -149,15 +149,15 @@ func (c *Context) RawRedirect(location string, status ...int) {
c.Context.Redirect(location, status...)
}
// Redirect responses redirection wtih given location and status.
// Redirect responses redirection with given location and status.
// It escapes special characters in the location string.
func (c *Context) Redirect(location string, status ...int) {
c.Context.Redirect(template.EscapePound(location), status...)
}
// SubURLRedirect responses redirection wtih given location and status.
// RedirectSubpath responses redirection with given location and status.
// It prepends setting.Server.Subpath to the location string.
func (c *Context) SubURLRedirect(location string, status ...int) {
func (c *Context) RedirectSubpath(location string, status ...int) {
c.Redirect(conf.Server.Subpath+location, status...)
}
@ -171,44 +171,46 @@ func (c *Context) RenderWithErr(msg, tpl string, f interface{}) {
c.HTML(http.StatusOK, tpl)
}
// Handle handles and logs error by given status.
func (c *Context) Handle(status int, msg string, err error) {
switch status {
case http.StatusNotFound:
c.Data["Title"] = "Page Not Found"
case http.StatusInternalServerError:
c.Data["Title"] = "Internal Server Error"
log.ErrorDepth(5, "%s: %v", msg, err)
if !conf.IsProdMode() || (c.IsLogged && c.User.IsAdmin) {
c.Data["ErrorMsg"] = err
}
}
c.HTML(status, fmt.Sprintf("status/%d", status))
}
// NotFound renders the 404 page.
func (c *Context) NotFound() {
c.Handle(http.StatusNotFound, "", nil)
c.Title("status.page_not_found")
c.HTML(http.StatusNotFound, fmt.Sprintf("status/%d", http.StatusNotFound))
}
// ServerError renders the 500 page.
func (c *Context) ServerError(msg string, err error) {
c.Handle(http.StatusInternalServerError, msg, err)
// Error renders the 500 page.
func (c *Context) Error(err error, msg string) {
log.ErrorDepth(5, "%s: %v", msg, err)
c.Title("status.internal_server_error")
// Only in non-production mode or admin can see the actual error message.
if !conf.IsProdMode() || (c.IsLogged && c.User.IsAdmin) {
c.Data["ErrorMsg"] = err
}
c.HTML(http.StatusInternalServerError, fmt.Sprintf("status/%d", http.StatusInternalServerError))
}
// NotFoundOrServerError use error check function to determine if the error
// is about not found. It responses with 404 status code for not found error,
// or error context description for logging purpose of 500 server error.
func (c *Context) NotFoundOrServerError(msg string, errck func(error) bool, err error) {
if errck(err) {
// Errorf renders the 500 response with formatted message.
func (c *Context) Errorf(err error, format string, args ...interface{}) {
c.Error(err, fmt.Sprintf(format, args...))
}
// NotFoundOrError responses with 404 page for not found error and 500 page otherwise.
func (c *Context) NotFoundOrError(err error, msg string) {
if errutil.IsNotFound(err) {
c.NotFound()
return
}
c.ServerError(msg, err)
c.Error(err, msg)
}
func (c *Context) HandleText(status int, msg string) {
c.PlainText(status, []byte(msg))
// NotFoundOrErrorf is same as NotFoundOrError but with formatted message.
func (c *Context) NotFoundOrErrorf(err error, format string, args ...interface{}) {
c.NotFoundOrError(err, fmt.Sprintf(format, args...))
}
func (c *Context) PlainText(status int, msg string) {
c.Render.PlainText(status, []byte(msg))
}
func (c *Context) ServeContent(name string, r io.ReadSeeker, params ...interface{}) {
@ -259,7 +261,7 @@ func Contexter() macaron.Handler {
owner, err := db.GetUserByName(ownerName)
if err != nil {
c.NotFoundOrServerError("GetUserByName", errors.IsUserNotExist, err)
c.NotFoundOrError(err, "get user by name")
return
}
@ -273,7 +275,7 @@ func Contexter() macaron.Handler {
if !strings.HasPrefix(conf.Server.ExternalURL, "https://") {
insecureFlag = "--insecure "
}
c.PlainText(http.StatusOK, []byte(com.Expand(`<!doctype html>
c.PlainText(http.StatusOK, com.Expand(`<!doctype html>
<html>
<head>
<meta name="go-import" content="{GoGetImport} git {CloneLink}">
@ -284,12 +286,12 @@ func Contexter() macaron.Handler {
</body>
</html>
`, map[string]string{
"GoGetImport": path.Join(conf.Server.URL.Host, conf.Server.Subpath, repo.FullName()),
"GoGetImport": path.Join(conf.Server.URL.Host, conf.Server.Subpath, ownerName, repoName),
"CloneLink": db.ComposeHTTPSCloneURL(ownerName, repoName),
"GoDocDirectory": prefix + "{/dir}",
"GoDocFile": prefix + "{/dir}/{file}#L{line}",
"InsecureFlag": insecureFlag,
})))
}))
return
}
@ -318,7 +320,7 @@ func Contexter() macaron.Handler {
// If request sends files, parse them here otherwise the Query() can't be parsed and the CsrfToken will be invalid.
if c.Req.Method == "POST" && strings.Contains(c.Req.Header.Get("Content-Type"), "multipart/form-data") {
if err := c.Req.ParseMultipartForm(conf.Attachment.MaxSize << 20); err != nil && !strings.Contains(err.Error(), "EOF") { // 32MB max size
c.ServerError("ParseMultipartForm", err)
c.Error(err, "parse multipart form")
return
}
}

15
internal/context/org.go
View File

@ -11,7 +11,6 @@ import (
"gogs.io/gogs/internal/conf"
"gogs.io/gogs/internal/db"
"gogs.io/gogs/internal/db/errors"
)
type Organization struct {
@ -50,7 +49,7 @@ func HandleOrgAssignment(c *Context, args ...bool) {
var err error
c.Org.Organization, err = db.GetUserByName(orgName)
if err != nil {
c.NotFoundOrServerError("GetUserByName", errors.IsUserNotExist, err)
c.NotFoundOrError(err, "get organization by name")
return
}
org := c.Org.Organization
@ -85,7 +84,7 @@ func HandleOrgAssignment(c *Context, args ...bool) {
}
if (requireMember && !c.Org.IsMember) ||
(requireOwner && !c.Org.IsOwner) {
c.Handle(404, "OrgAssignment", err)
c.NotFound()
return
}
c.Data["IsOrganizationOwner"] = c.Org.IsOwner
@ -98,13 +97,13 @@ func HandleOrgAssignment(c *Context, args ...bool) {
if c.Org.IsMember {
if c.Org.IsOwner {
if err := org.GetTeams(); err != nil {
c.Handle(500, "GetTeams", err)
c.Error(err, "get teams")
return
}
} else {
org.Teams, err = org.GetUserTeams(c.User.ID)
if err != nil {
c.Handle(500, "GetUserTeams", err)
c.Error(err, "get user teams")
return
}
}
@ -124,20 +123,20 @@ func HandleOrgAssignment(c *Context, args ...bool) {
}
if !teamExists {
c.Handle(404, "OrgAssignment", err)
c.NotFound()
return
}
c.Data["IsTeamMember"] = c.Org.IsTeamMember
if requireTeamMember && !c.Org.IsTeamMember {
c.Handle(404, "OrgAssignment", err)
c.NotFound()
return
}
c.Org.IsTeamAdmin = c.Org.Team.IsOwnerTeam() || c.Org.Team.Authorize >= db.ACCESS_MODE_ADMIN
c.Data["IsTeamAdmin"] = c.Org.IsTeamAdmin
if requireTeamAdmin && !c.Org.IsTeamAdmin {
c.Handle(404, "OrgAssignment", err)
c.NotFound()
return
}
}

27
internal/context/repo.go
View File

@ -18,7 +18,6 @@ import (
"gogs.io/gogs/internal/conf"
"gogs.io/gogs/internal/db"
dberrors "gogs.io/gogs/internal/db/errors"
)
type PullRequest struct {
@ -147,7 +146,7 @@ func RepoAssignment(pages ...bool) macaron.Handler {
} else {
owner, err = db.GetUserByName(ownerName)
if err != nil {
c.NotFoundOrServerError("GetUserByName", dberrors.IsUserNotExist, err)
c.NotFoundOrError(err, "get user by name")
return
}
}
@ -156,7 +155,7 @@ func RepoAssignment(pages ...bool) macaron.Handler {
repo, err := db.GetRepositoryByName(owner.ID, repoName)
if err != nil {
c.NotFoundOrServerError("GetRepositoryByName", dberrors.IsRepoNotExist, err)
c.NotFoundOrError(err, "get repository by name")
return
}
@ -173,7 +172,7 @@ func RepoAssignment(pages ...bool) macaron.Handler {
} else {
mode, err := db.UserAccessMode(c.UserID(), repo)
if err != nil {
c.ServerError("UserAccessMode", err)
c.Error(err, "get user access mode")
return
}
c.Repo.AccessMode = mode
@ -212,7 +211,7 @@ func RepoAssignment(pages ...bool) macaron.Handler {
if repo.IsMirror {
c.Repo.Mirror, err = db.GetMirrorByRepoID(repo.ID)
if err != nil {
c.ServerError("GetMirror", err)
c.Error(err, "get mirror by repository ID")
return
}
c.Data["MirrorEnablePrune"] = c.Repo.Mirror.EnablePrune
@ -222,14 +221,14 @@ func RepoAssignment(pages ...bool) macaron.Handler {
gitRepo, err := git.Open(db.RepoPath(ownerName, repoName))
if err != nil {
c.ServerError("open repository", err)
c.Error(err, "open repository")
return
}
c.Repo.GitRepo = gitRepo
tags, err := c.Repo.GitRepo.Tags()
if err != nil {
c.ServerError("get tags", err)
c.Error(err, "get tags")
return
}
c.Data["Tags"] = tags
@ -260,7 +259,7 @@ func RepoAssignment(pages ...bool) macaron.Handler {
c.Data["TagName"] = c.Repo.TagName
branches, err := c.Repo.GitRepo.Branches()
if err != nil {
c.ServerError("get branches", err)
c.Error(err, "get branches")
return
}
c.Data["Branches"] = branches
@ -300,7 +299,7 @@ func RepoRef() macaron.Handler {
repoPath := db.RepoPath(c.Repo.Owner.Name, c.Repo.Repository.Name)
c.Repo.GitRepo, err = git.Open(repoPath)
if err != nil {
c.Handle(500, "RepoRef Invalid repo "+repoPath, err)
c.Error(err, "open repository")
return
}
}
@ -311,14 +310,14 @@ func RepoRef() macaron.Handler {
if !c.Repo.GitRepo.HasBranch(refName) {
branches, err := c.Repo.GitRepo.Branches()
if err != nil {
c.ServerError("get branches", err)
c.Error(err, "get branches")
return
}
refName = branches[0]
}
c.Repo.Commit, err = c.Repo.GitRepo.BranchCommit(refName)
if err != nil {
c.ServerError("get branch commit", err)
c.Error(err, "get branch commit")
return
}
c.Repo.CommitID = c.Repo.Commit.ID.String()
@ -349,7 +348,7 @@ func RepoRef() macaron.Handler {
c.Repo.Commit, err = c.Repo.GitRepo.BranchCommit(refName)
if err != nil {
c.ServerError("get branch commit", err)
c.Error(err, "get branch commit")
return
}
c.Repo.CommitID = c.Repo.Commit.ID.String()
@ -358,7 +357,7 @@ func RepoRef() macaron.Handler {
c.Repo.IsViewTag = true
c.Repo.Commit, err = c.Repo.GitRepo.TagCommit(refName)
if err != nil {
c.ServerError("get tag commit", err)
c.Error(err, "get tag commit")
return
}
c.Repo.CommitID = c.Repo.Commit.ID.String()
@ -372,7 +371,7 @@ func RepoRef() macaron.Handler {
return
}
} else {
c.Handle(404, "RepoRef invalid repo", fmt.Errorf("branch or tag not exist: %s", refName))
c.NotFound()
return
}
}

3
internal/context/user.go
View File

@ -8,7 +8,6 @@ import (
"gopkg.in/macaron.v1"
"gogs.io/gogs/internal/db"
"gogs.io/gogs/internal/db/errors"
)
// ParamsUser is the wrapper type of the target user defined by URL parameter, namely ':username'.
@ -22,7 +21,7 @@ func InjectParamsUser() macaron.Handler {
return func(c *Context) {
user, err := db.GetUserByName(c.Params(":username"))
if err != nil {
c.NotFoundOrServerError("GetUserByName", errors.IsUserNotExist, err)
c.NotFoundOrError(err, "get user by name")
return
}
c.Map(&ParamsUser{user})

6
internal/db/access.go
View File

@ -8,8 +8,6 @@ import (
"fmt"
log "unknwon.dev/clog/v2"
"gogs.io/gogs/internal/db/errors"
)
type AccessMode int
@ -110,8 +108,8 @@ func (u *User) GetRepositoryAccesses() (map[*Repository]AccessMode, error) {
for _, access := range accesses {
repo, err := GetRepositoryByID(access.RepoID)
if err != nil {
if errors.IsRepoNotExist(err) {
log.Error("GetRepositoryByID: %v", err)
if IsErrRepoNotExist(err) {
log.Error("Failed to get repository by ID: %v", err)
continue
}
return nil, err

19
internal/db/action.go
View File

@ -20,7 +20,6 @@ import (
api "github.com/gogs/go-gogs-client"
"gogs.io/gogs/internal/conf"
"gogs.io/gogs/internal/db/errors"
"gogs.io/gogs/internal/lazyregexp"
"gogs.io/gogs/internal/tool"
)
@ -256,16 +255,16 @@ func (pc *PushCommits) ToApiPayloadCommits(repoPath, repoURL string) ([]*api.Pay
author, err := GetUserByEmail(commit.AuthorEmail)
if err == nil {
authorUsername = author.Name
} else if !errors.IsUserNotExist(err) {
return nil, fmt.Errorf("GetUserByEmail: %v", err)
} else if !IsErrUserNotExist(err) {
return nil, fmt.Errorf("get user by email: %v", err)
}
committerUsername := ""
committer, err := GetUserByEmail(commit.CommitterEmail)
if err == nil {
committerUsername = committer.Name
} else if !errors.IsUserNotExist(err) {
return nil, fmt.Errorf("GetUserByEmail: %v", err)
} else if !IsErrUserNotExist(err) {
return nil, fmt.Errorf("get user by email: %v", err)
}
nameStatus, err := git.RepoShowNameStatus(repoPath, commit.Sha1)
@ -304,8 +303,8 @@ func (pcs *PushCommits) AvatarLink(email string) string {
u, err := GetUserByEmail(email)
if err != nil {
pcs.avatars[email] = tool.AvatarLink(email)
if !errors.IsUserNotExist(err) {
log.Error("GetUserByEmail: %v", err)
if !IsErrUserNotExist(err) {
log.Error("get user by email: %v", err)
}
} else {
pcs.avatars[email] = u.RelAvatarLink()
@ -341,7 +340,7 @@ func UpdateIssuesCommit(doer *User, repo *Repository, commits []*PushCommit) err
issue, err := GetIssueByRef(ref)
if err != nil {
if errors.IsIssueNotExist(err) {
if IsErrIssueNotExist(err) {
continue
}
return err
@ -383,7 +382,7 @@ func UpdateIssuesCommit(doer *User, repo *Repository, commits []*PushCommit) err
issue, err := GetIssueByRef(ref)
if err != nil {
if errors.IsIssueNotExist(err) {
if IsErrIssueNotExist(err) {
continue
}
return err
@ -423,7 +422,7 @@ func UpdateIssuesCommit(doer *User, repo *Repository, commits []*PushCommit) err
issue, err := GetIssueByRef(ref)
if err != nil {
if errors.IsIssueNotExist(err) {
if IsErrIssueNotExist(err) {
continue
}
return err

24
internal/db/attachment.go
View File

@ -16,6 +16,7 @@ import (
"xorm.io/xorm"
"gogs.io/gogs/internal/conf"
"gogs.io/gogs/internal/errutil"
)
// Attachment represent a attachment of issue/comment/release.
@ -83,13 +84,32 @@ func NewAttachment(name string, buf []byte, file multipart.File) (_ *Attachment,
return attach, nil
}
var _ errutil.NotFound = (*ErrAttachmentNotExist)(nil)
type ErrAttachmentNotExist struct {
args map[string]interface{}
}
func IsErrAttachmentNotExist(err error) bool {
_, ok := err.(ErrAttachmentNotExist)
return ok
}
func (err ErrAttachmentNotExist) Error() string {
return fmt.Sprintf("attachment does not exist: %v", err.args)
}
func (ErrAttachmentNotExist) NotFound() bool {
return true
}
func getAttachmentByUUID(e Engine, uuid string) (*Attachment, error) {
attach := &Attachment{UUID: uuid}
has, err := x.Get(attach)
has, err := e.Get(attach)
if err != nil {
return nil, err
} else if !has {
return nil, ErrAttachmentNotExist{0, uuid}
return nil, ErrAttachmentNotExist{args: map[string]interface{}{"uuid": uuid}}
}
return attach, nil
}

25
internal/db/comment.go
View File

@ -15,7 +15,7 @@ import (
api "github.com/gogs/go-gogs-client"
"gogs.io/gogs/internal/db/errors"
"gogs.io/gogs/internal/errutil"
"gogs.io/gogs/internal/markup"
)
@ -96,7 +96,7 @@ func (c *Comment) loadAttributes(e Engine) (err error) {
if c.Poster == nil {
c.Poster, err = GetUserByID(c.PosterID)
if err != nil {
if errors.IsUserNotExist(err) {
if IsErrUserNotExist(err) {
c.PosterID = -1
c.Poster = NewGhostUser()
} else {
@ -391,6 +391,25 @@ func CreateRefComment(doer *User, repo *Repository, issue *Issue, content, commi
return err
}
var _ errutil.NotFound = (*ErrCommentNotExist)(nil)
type ErrCommentNotExist struct {
args map[string]interface{}
}
func IsErrCommentNotExist(err error) bool {
_, ok := err.(ErrCommentNotExist)
return ok
}
func (err ErrCommentNotExist) Error() string {
return fmt.Sprintf("comment does not exist: %v", err.args)
}
func (ErrCommentNotExist) NotFound() bool {
return true
}
// GetCommentByID returns the comment by given ID.
func GetCommentByID(id int64) (*Comment, error) {
c := new(Comment)
@ -398,7 +417,7 @@ func GetCommentByID(id int64) (*Comment, error) {
if err != nil {
return nil, err
} else if !has {
return nil, ErrCommentNotExist{id, 0}
return nil, ErrCommentNotExist{args: map[string]interface{}{"commentID": id}}
}
return c, c.LoadAttributes()
}

139
internal/db/error.go
View File

@ -190,21 +190,6 @@ func (err ErrKeyAccessDenied) Error() string {
err.UserID, err.KeyID, err.Note)
}
type ErrDeployKeyNotExist struct {
ID int64
KeyID int64
RepoID int64
}
func IsErrDeployKeyNotExist(err error) bool {
_, ok := err.(ErrDeployKeyNotExist)
return ok
}
func (err ErrDeployKeyNotExist) Error() string {
return fmt.Sprintf("Deploy key does not exist [id: %d, key_id: %d, repo_id: %d]", err.ID, err.KeyID, err.RepoID)
}
type ErrDeployKeyAlreadyExist struct {
KeyID int64
RepoID int64
@ -348,20 +333,6 @@ func (err ErrReleaseAlreadyExist) Error() string {
return fmt.Sprintf("release tag already exist [tag_name: %s]", err.TagName)
}
type ErrReleaseNotExist struct {
ID int64
TagName string
}
func IsErrReleaseNotExist(err error) bool {
_, ok := err.(ErrReleaseNotExist)
return ok
}
func (err ErrReleaseNotExist) Error() string {
return fmt.Sprintf("release tag does not exist [id: %d, tag_name: %s]", err.ID, err.TagName)
}
type ErrInvalidTagName struct {
TagName string
}
@ -388,116 +359,6 @@ func (err ErrRepoFileAlreadyExist) Error() string {
return fmt.Sprintf("repository file already exists [file_name: %s]", err.FileName)
}
// __________ .__ .__ __________ __
// \______ \__ __| | | |\______ \ ____ ________ __ ____ _______/ |_
// | ___/ | \ | | | | _// __ \/ ____/ | \_/ __ \ / ___/\ __\
// | | | | / |_| |_| | \ ___< <_| | | /\ ___/ \___ \ | |
// |____| |____/|____/____/____|_ /\___ >__ |____/ \___ >____ > |__|
// \/ \/ |__| \/ \/
type ErrPullRequestNotExist struct {
ID int64
IssueID int64
HeadRepoID int64
BaseRepoID int64
HeadBarcnh string
BaseBranch string
}
func IsErrPullRequestNotExist(err error) bool {
_, ok := err.(ErrPullRequestNotExist)
return ok
}
func (err ErrPullRequestNotExist) Error() string {
return fmt.Sprintf("pull request does not exist [id: %d, issue_id: %d, head_repo_id: %d, base_repo_id: %d, head_branch: %s, base_branch: %s]",
err.ID, err.IssueID, err.HeadRepoID, err.BaseRepoID, err.HeadBarcnh, err.BaseBranch)
}
// _________ __
// \_ ___ \ ____ _____ _____ ____ _____/ |_
// / \ \/ / _ \ / \ / \_/ __ \ / \ __\
// \ \___( <_> ) Y Y \ Y Y \ ___/| | \ |
// \______ /\____/|__|_| /__|_| /\___ >___| /__|
// \/ \/ \/ \/ \/
type ErrCommentNotExist struct {
ID int64
IssueID int64
}
func IsErrCommentNotExist(err error) bool {
_, ok := err.(ErrCommentNotExist)
return ok
}
func (err ErrCommentNotExist) Error() string {
return fmt.Sprintf("comment does not exist [id: %d, issue_id: %d]", err.ID, err.IssueID)
}
// .____ ___. .__
// | | _____ \_ |__ ____ | |
// | | \__ \ | __ \_/ __ \| |
// | |___ / __ \| \_\ \ ___/| |__
// |_______ (____ /___ /\___ >____/
// \/ \/ \/ \/
type ErrLabelNotExist struct {
LabelID int64
RepoID int64
}
func IsErrLabelNotExist(err error) bool {
_, ok := err.(ErrLabelNotExist)
return ok
}
func (err ErrLabelNotExist) Error() string {
return fmt.Sprintf("label does not exist [label_id: %d, repo_id: %d]", err.LabelID, err.RepoID)
}
// _____ .__.__ __
// / \ |__| | ____ _______/ |_ ____ ____ ____
// / \ / \| | | _/ __ \ / ___/\ __\/ _ \ / \_/ __ \
// / Y \ | |_\ ___/ \___ \ | | ( <_> ) | \ ___/
// \____|__ /__|____/\___ >____ > |__| \____/|___| /\___ >
// \/ \/ \/ \/ \/
type ErrMilestoneNotExist struct {
ID int64
RepoID int64
}
func IsErrMilestoneNotExist(err error) bool {
_, ok := err.(ErrMilestoneNotExist)
return ok
}
func (err ErrMilestoneNotExist) Error() string {
return fmt.Sprintf("milestone does not exist [id: %d, repo_id: %d]", err.ID, err.RepoID)
}
// _____ __ __ .__ __
// / _ \_/ |__/ |______ ____ | |__ _____ ____ _____/ |_
// / /_\ \ __\ __\__ \ _/ ___\| | \ / \_/ __ \ / \ __\
// / | \ | | | / __ \\ \___| Y \ Y Y \ ___/| | \ |
// \____|__ /__| |__| (____ /\___ >___| /__|_| /\___ >___| /__|
// \/ \/ \/ \/ \/ \/ \/
type ErrAttachmentNotExist struct {
ID int64
UUID string
}
func IsErrAttachmentNotExist(err error) bool {
_, ok := err.(ErrAttachmentNotExist)
return ok
}
func (err ErrAttachmentNotExist) Error() string {
return fmt.Sprintf("attachment does not exist [id: %d, uuid: %s]", err.ID, err.UUID)
}
// .____ .__ _________
// | | ____ ____ |__| ____ / _____/ ____ __ _________ ____ ____
// | | / _ \ / ___\| |/ \ \_____ \ / _ \| | \_ __ \_/ ___\/ __ \

15
internal/db/errors/issue.go
View File

@ -6,21 +6,6 @@ package errors
import "fmt"
type IssueNotExist struct {
ID int64
RepoID int64
Index int64
}
func IsIssueNotExist(err error) bool {
_, ok := err.(IssueNotExist)
return ok
}
func (err IssueNotExist) Error() string {
return fmt.Sprintf("issue does not exist [id: %d, repo_id: %d, index: %d]", err.ID, err.RepoID, err.Index)
}
type InvalidIssueReference struct {
Ref string
}

21
internal/db/errors/org.go
View File

@ -1,21 +0,0 @@
// Copyright 2018 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 errors
import "fmt"
type TeamNotExist struct {
TeamID int64
Name string
}
func IsTeamNotExist(err error) bool {
_, ok := err.(TeamNotExist)
return ok
}
func (err TeamNotExist) Error() string {
return fmt.Sprintf("team does not exist [team_id: %d, name: %s]", err.TeamID, err.Name)
}

45
internal/db/errors/repo.go
View File

@ -4,35 +4,9 @@
package errors
import "fmt"
type RepoNotExist struct {
ID int64
UserID int64
Name string
}
func IsRepoNotExist(err error) bool {
_, ok := err.(RepoNotExist)
return ok
}
func (err RepoNotExist) Error() string {
return fmt.Sprintf("repository does not exist [id: %d, user_id: %d, name: %s]", err.ID, err.UserID, err.Name)
}
type ReachLimitOfRepo struct {
Limit int
}
func IsReachLimitOfRepo(err error) bool {
_, ok := err.(ReachLimitOfRepo)
return ok
}
func (err ReachLimitOfRepo) Error() string {
return fmt.Sprintf("user has reached maximum limit of repositories [limit: %d]", err.Limit)
}
import (
"fmt"
)
type InvalidRepoReference struct {
Ref string
@ -72,16 +46,3 @@ func IsBranchAlreadyExists(err error) bool {
func (err BranchAlreadyExists) Error() string {
return fmt.Sprintf("branch already exists [name: %s]", err.Name)
}
type ErrBranchNotExist struct {
Name string
}
func IsErrBranchNotExist(err error) bool {
_, ok := err.(ErrBranchNotExist)
return ok
}
func (err ErrBranchNotExist) Error() string {
return fmt.Sprintf("branch does not exist [name: %s]", err.Name)
}

18
internal/db/errors/user.go
View File

@ -4,7 +4,9 @@
package errors
import "fmt"
import (
"fmt"
)
type EmptyName struct{}
@ -17,20 +19,6 @@ func (err EmptyName) Error() string {
return "empty name"
}
type UserNotExist struct {
UserID int64
Name string
}
func IsUserNotExist(err error) bool {
_, ok := err.(UserNotExist)
return ok
}
func (err UserNotExist) Error() string {
return fmt.Sprintf("user does not exist [user_id: %d, name: %s]", err.UserID, err.Name)
}
type UserNotKeyOwner struct {
KeyID int64
}

34
internal/db/errors/webhook.go
View File

@ -1,34 +0,0 @@
// Copyright 2017 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 errors
import "fmt"
type WebhookNotExist struct {
ID int64
}
func IsWebhookNotExist(err error) bool {
_, ok := err.(WebhookNotExist)
return ok
}
func (err WebhookNotExist) Error() string {
return fmt.Sprintf("webhook does not exist [id: %d]", err.ID)
}
type HookTaskNotExist struct {
HookID int64
UUID string
}
func IsHookTaskNotExist(err error) bool {
_, ok := err.(HookTaskNotExist)
return ok
}
func (err HookTaskNotExist) Error() string {
return fmt.Sprintf("hook task does not exist [hook_id: %d, uuid: %s]", err.HookID, err.UUID)
}

38
internal/db/issue.go
View File

@ -17,6 +17,7 @@ import (
"gogs.io/gogs/internal/conf"
"gogs.io/gogs/internal/db/errors"
"gogs.io/gogs/internal/errutil"
"gogs.io/gogs/internal/tool"
)
@ -90,7 +91,7 @@ func (issue *Issue) loadAttributes(e Engine) (err error) {
if issue.Poster == nil {
issue.Poster, err = getUserByID(e, issue.PosterID)
if err != nil {
if errors.IsUserNotExist(err) {
if IsErrUserNotExist(err) {
issue.PosterID = -1
issue.Poster = NewGhostUser()
} else {
@ -395,7 +396,7 @@ func (issue *Issue) GetAssignee() (err error) {
}
issue.Assignee, err = GetUserByID(issue.AssigneeID)
if errors.IsUserNotExist(err) {
if IsErrUserNotExist(err) {
return nil
}
return err
@ -600,8 +601,8 @@ func (issue *Issue) ChangeAssignee(doer *User, assigneeID int64) (err error) {
}
issue.Assignee, err = GetUserByID(issue.AssigneeID)
if err != nil && !errors.IsUserNotExist(err) {
log.Error("GetUserByID [assignee_id: %v]: %v", issue.AssigneeID, err)
if err != nil && !IsErrUserNotExist(err) {
log.Error("Failed to get user by ID: %v", err)
return nil
}
@ -673,8 +674,8 @@ func newIssue(e *xorm.Session, opts NewIssueOptions) (err error) {
if opts.Issue.AssigneeID > 0 {
assignee, err := getUserByID(e, opts.Issue.AssigneeID)
if err != nil && !errors.IsUserNotExist(err) {
return fmt.Errorf("getUserByID: %v", err)
if err != nil && !IsErrUserNotExist(err) {
return fmt.Errorf("get user by ID: %v", err)
}
// Assume assignee is invalid and drop silently.
@ -796,6 +797,25 @@ func NewIssue(repo *Repository, issue *Issue, labelIDs []int64, uuids []string)
return nil
}
var _ errutil.NotFound = (*ErrIssueNotExist)(nil)
type ErrIssueNotExist struct {
args map[string]interface{}
}
func IsErrIssueNotExist(err error) bool {
_, ok := err.(ErrIssueNotExist)
return ok
}
func (err ErrIssueNotExist) Error() string {
return fmt.Sprintf("issue does not exist: %v", err.args)
}
func (ErrIssueNotExist) NotFound() bool {
return true
}
// GetIssueByRef returns an Issue specified by a GFM reference.
// See https://help.github.com/articles/writing-on-github#references for more information on the syntax.
func GetIssueByRef(ref string) (*Issue, error) {
@ -806,7 +826,7 @@ func GetIssueByRef(ref string) (*Issue, error) {
index := com.StrTo(ref[n+1:]).MustInt64()
if index == 0 {
return nil, errors.IssueNotExist{}
return nil, ErrIssueNotExist{args: map[string]interface{}{"ref": ref}}
}
repo, err := GetRepositoryByRef(ref[:n])
@ -832,7 +852,7 @@ func GetRawIssueByIndex(repoID, index int64) (*Issue, error) {
if err != nil {
return nil, err
} else if !has {
return nil, errors.IssueNotExist{RepoID: repoID, Index: index}
return nil, ErrIssueNotExist{args: map[string]interface{}{"repoID": repoID, "index": index}}
}
return issue, nil
}
@ -852,7 +872,7 @@ func getRawIssueByID(e Engine, id int64) (*Issue, error) {
if err != nil {
return nil, err
} else if !has {
return nil, errors.IssueNotExist{ID: id}
return nil, ErrIssueNotExist{args: map[string]interface{}{"issueID": id}}
}
return issue, nil
}

32
internal/db/issue_label.go
View File

@ -14,6 +14,7 @@ import (
api "github.com/gogs/go-gogs-client"
"gogs.io/gogs/internal/errutil"
"gogs.io/gogs/internal/lazyregexp"
"gogs.io/gogs/internal/tool"
)
@ -103,23 +104,42 @@ func NewLabels(labels ...*Label) error {
return err
}
var _ errutil.NotFound = (*ErrLabelNotExist)(nil)
type ErrLabelNotExist struct {
args map[string]interface{}
}
func IsErrLabelNotExist(err error) bool {
_, ok := err.(ErrLabelNotExist)
return ok
}
func (err ErrLabelNotExist) Error() string {
return fmt.Sprintf("label does not exist: %v", err.args)
}
func (ErrLabelNotExist) NotFound() bool {
return true
}
// getLabelOfRepoByName returns a label by Name in given repository.
// If pass repoID as 0, then ORM will ignore limitation of repository
// and can return arbitrary label with any valid ID.
func getLabelOfRepoByName(e Engine, repoID int64, labelName string) (*Label, error) {
if len(labelName) <= 0 {
return nil, ErrLabelNotExist{0, repoID}
return nil, ErrLabelNotExist{args: map[string]interface{}{"repoID": repoID}}
}
l := &Label{
Name: labelName,
RepoID: repoID,
}
has, err := x.Get(l)
has, err := e.Get(l)
if err != nil {
return nil, err
} else if !has {
return nil, ErrLabelNotExist{0, l.RepoID}
return nil, ErrLabelNotExist{args: map[string]interface{}{"repoID": repoID}}
}
return l, nil
}
@ -129,18 +149,18 @@ func getLabelOfRepoByName(e Engine, repoID int64, labelName string) (*Label, err
// and can return arbitrary label with any valid ID.
func getLabelOfRepoByID(e Engine, repoID, labelID int64) (*Label, error) {
if labelID <= 0 {
return nil, ErrLabelNotExist{labelID, repoID}
return nil, ErrLabelNotExist{args: map[string]interface{}{"repoID": repoID, "labelID": labelID}}
}
l := &Label{
ID: labelID,
RepoID: repoID,
}
has, err := x.Get(l)
has, err := e.Get(l)
if err != nil {
return nil, err
} else if !has {
return nil, ErrLabelNotExist{l.ID, l.RepoID}
return nil, ErrLabelNotExist{args: map[string]interface{}{"repoID": repoID, "labelID": labelID}}
}
return l, nil
}

16
internal/db/login_source.go
View File

@ -556,7 +556,7 @@ func LoginViaLDAP(user *User, login, password string, source *LoginSource, autoR
username, fn, sn, mail, isAdmin, succeed := source.Cfg.(*LDAPConfig).SearchEntry(login, password, source.Type == LOGIN_DLDAP)
if !succeed {
// User not in LDAP, do nothing
return nil, errors.UserNotExist{Name: login}
return nil, ErrUserNotExist{args: map[string]interface{}{"login": login}}
}
if !autoRegister {
@ -674,9 +674,9 @@ func LoginViaSMTP(user *User, login, password string, sourceID int64, cfg *SMTPC
if len(cfg.AllowedDomains) > 0 {
idx := strings.Index(login, "@")
if idx == -1 {
return nil, errors.UserNotExist{Name: login}
return nil, ErrUserNotExist{args: map[string]interface{}{"login": login}}
} else if !com.IsSliceContainsStr(strings.Split(cfg.AllowedDomains, ","), login[idx+1:]) {
return nil, errors.UserNotExist{Name: login}
return nil, ErrUserNotExist{args: map[string]interface{}{"login": login}}
}
}
@ -695,7 +695,7 @@ func LoginViaSMTP(user *User, login, password string, sourceID int64, cfg *SMTPC
tperr, ok := err.(*textproto.Error)
if (ok && tperr.Code == 535) ||
strings.Contains(err.Error(), "Username and Password not accepted") {
return nil, errors.UserNotExist{Name: login}
return nil, ErrUserNotExist{args: map[string]interface{}{"login": login}}
}
return nil, err
}
@ -735,7 +735,7 @@ func LoginViaSMTP(user *User, login, password string, sourceID int64, cfg *SMTPC
func LoginViaPAM(user *User, login, password string, sourceID int64, cfg *PAMConfig, autoRegister bool) (*User, error) {
if err := pam.PAMAuth(cfg.ServiceName, login, password); err != nil {
if strings.Contains(err.Error(), "Authentication failure") {
return nil, errors.UserNotExist{Name: login}
return nil, ErrUserNotExist{args: map[string]interface{}{"login": login}}
}
return nil, err
}
@ -768,7 +768,7 @@ func LoginViaGitHub(user *User, login, password string, sourceID int64, cfg *Git
fullname, email, url, location, err := github.Authenticate(cfg.APIEndpoint, login, password)
if err != nil {
if strings.Contains(err.Error(), "401") {
return nil, errors.UserNotExist{Name: login}
return nil, ErrUserNotExist{args: map[string]interface{}{"login": login}}
}
return nil, err
}
@ -840,7 +840,7 @@ func UserLogin(username, password string, loginSourceID int64) (*User, error) {
return user, nil
}
return nil, errors.UserNotExist{UserID: user.ID, Name: user.Name}
return nil, ErrUserNotExist{args: map[string]interface{}{"userID": user.ID, "name": user.Name}}
}
// Remote login to the login source the user is associated with
@ -854,7 +854,7 @@ func UserLogin(username, password string, loginSourceID int64) (*User, error) {
// Non-local login source is always greater than 0
if loginSourceID <= 0 {
return nil, errors.UserNotExist{UserID: -1, Name: username}
return nil, ErrUserNotExist{args: map[string]interface{}{"name": username}}
}
source, err := GetLoginSourceByID(loginSourceID)

22
internal/db/milestone.go
View File

@ -14,6 +14,7 @@ import (
api "github.com/gogs/go-gogs-client"
"gogs.io/gogs/internal/conf"
"gogs.io/gogs/internal/errutil"
)
// Milestone represents a milestone of repository.
@ -130,6 +131,25 @@ func NewMilestone(m *Milestone) (err error) {
return sess.Commit()
}
var _ errutil.NotFound = (*ErrMilestoneNotExist)(nil)
type ErrMilestoneNotExist struct {
args map[string]interface{}
}
func IsErrMilestoneNotExist(err error) bool {
_, ok := err.(ErrMilestoneNotExist)
return ok
}
func (err ErrMilestoneNotExist) Error() string {
return fmt.Sprintf("milestone does not exist: %v", err.args)
}
func (ErrMilestoneNotExist) NotFound() bool {
return true
}
func getMilestoneByRepoID(e Engine, repoID, id int64) (*Milestone, error) {
m := &Milestone{
ID: id,
@ -139,7 +159,7 @@ func getMilestoneByRepoID(e Engine, repoID, id int64) (*Milestone, error) {
if err != nil {
return nil, err
} else if !has {
return nil, ErrMilestoneNotExist{id, repoID}
return nil, ErrMilestoneNotExist{args: map[string]interface{}{"repoID": repoID, "milestoneID": id}}
}
return m, nil
}

24
internal/db/org_team.go
View File

@ -11,6 +11,7 @@ import (
"xorm.io/xorm"
"gogs.io/gogs/internal/db/errors"
"gogs.io/gogs/internal/errutil"
)
const OWNER_TEAM = "Owners"
@ -266,6 +267,25 @@ func NewTeam(t *Team) error {
return sess.Commit()
}
var _ errutil.NotFound = (*ErrTeamNotExist)(nil)
type ErrTeamNotExist struct {
args map[string]interface{}
}
func IsErrTeamNotExist(err error) bool {
_, ok := err.(ErrTeamNotExist)
return ok
}
func (err ErrTeamNotExist) Error() string {
return fmt.Sprintf("team does not exist: %v", err.args)
}
func (ErrTeamNotExist) NotFound() bool {
return true
}
func getTeamOfOrgByName(e Engine, orgID int64, name string) (*Team, error) {
t := &Team{
OrgID: orgID,
@ -275,7 +295,7 @@ func getTeamOfOrgByName(e Engine, orgID int64, name string) (*Team, error) {
if err != nil {
return nil, err
} else if !has {
return nil, errors.TeamNotExist{Name: name}
return nil, ErrTeamNotExist{args: map[string]interface{}{"orgID": orgID, "name": name}}
}
return t, nil
}
@ -291,7 +311,7 @@ func getTeamByID(e Engine, teamID int64) (*Team, error) {
if err != nil {
return nil, err
} else if !has {
return nil, errors.TeamNotExist{TeamID: teamID}
return nil, ErrTeamNotExist{args: map[string]interface{}{"teamID": teamID}}
}
return t, nil
}

42
internal/db/pull.go
View File

@ -19,7 +19,7 @@ import (
api "github.com/gogs/go-gogs-client"
"gogs.io/gogs/internal/conf"
"gogs.io/gogs/internal/db/errors"
"gogs.io/gogs/internal/errutil"
"gogs.io/gogs/internal/osutil"
"gogs.io/gogs/internal/process"
"gogs.io/gogs/internal/sync"
@ -89,25 +89,25 @@ func (pr *PullRequest) AfterSet(colName string, _ xorm.Cell) {
func (pr *PullRequest) loadAttributes(e Engine) (err error) {
if pr.HeadRepo == nil {
pr.HeadRepo, err = getRepositoryByID(e, pr.HeadRepoID)
if err != nil && !errors.IsRepoNotExist(err) {
return fmt.Errorf("getRepositoryByID.(HeadRepo) [%d]: %v", pr.HeadRepoID, err)
if err != nil && !IsErrRepoNotExist(err) {
return fmt.Errorf("get head repository by ID: %v", err)
}
}
if pr.BaseRepo == nil {
pr.BaseRepo, err = getRepositoryByID(e, pr.BaseRepoID)
if err != nil {
return fmt.Errorf("getRepositoryByID.(BaseRepo) [%d]: %v", pr.BaseRepoID, err)
return fmt.Errorf("get base repository by ID: %v", err)
}
}
if pr.HasMerged && pr.Merger == nil {
pr.Merger, err = getUserByID(e, pr.MergerID)
if errors.IsUserNotExist(err) {
if IsErrUserNotExist(err) {
pr.MergerID = -1
pr.Merger = NewGhostUser()
} else if err != nil {
return fmt.Errorf("getUserByID [%d]: %v", pr.MergerID, err)
return fmt.Errorf("get merger by ID: %v", err)
}
}
@ -521,7 +521,12 @@ func GetUnmergedPullRequest(headRepoID, baseRepoID int64, headBranch, baseBranch
if err != nil {
return nil, err
} else if !has {
return nil, ErrPullRequestNotExist{0, 0, headRepoID, baseRepoID, headBranch, baseBranch}
return nil, ErrPullRequestNotExist{args: map[string]interface{}{
"headRepoID": headRepoID,
"baseRepoID": baseRepoID,
"headBranch": headBranch,
"baseBranch": baseBranch,
}}
}
return pr, nil
@ -545,13 +550,32 @@ func GetUnmergedPullRequestsByBaseInfo(repoID int64, branch string) ([]*PullRequ
Join("INNER", "issue", "issue.id=pull_request.issue_id").Find(&prs)
}
var _ errutil.NotFound = (*ErrPullRequestNotExist)(nil)
type ErrPullRequestNotExist struct {
args map[string]interface{}
}
func IsErrPullRequestNotExist(err error) bool {
_, ok := err.(ErrPullRequestNotExist)
return ok
}
func (err ErrPullRequestNotExist) Error() string {
return fmt.Sprintf("pull request does not exist: %v", err.args)
}
func (ErrPullRequestNotExist) NotFound() bool {
return true
}
func getPullRequestByID(e Engine, id int64) (*PullRequest, error) {
pr := new(PullRequest)
has, err := e.ID(id).Get(pr)
if err != nil {
return nil, err
} else if !has {
return nil, ErrPullRequestNotExist{id, 0, 0, 0, "", ""}
return nil, ErrPullRequestNotExist{args: map[string]interface{}{"pullRequestID": id}}
}
return pr, pr.loadAttributes(e)
}
@ -569,7 +593,7 @@ func getPullRequestByIssueID(e Engine, issueID int64) (*PullRequest, error) {
if err != nil {
return nil, err
} else if !has {
return nil, ErrPullRequestNotExist{0, issueID, 0, 0, "", ""}
return nil, ErrPullRequestNotExist{args: map[string]interface{}{"issueID": issueID}}
}
return pr, pr.loadAttributes(e)
}

27
internal/db/release.go
View File

@ -16,7 +16,7 @@ import (
"github.com/gogs/git-module"
api "github.com/gogs/go-gogs-client"
"gogs.io/gogs/internal/db/errors"
"gogs.io/gogs/internal/errutil"
"gogs.io/gogs/internal/process"
)
@ -68,7 +68,7 @@ func (r *Release) loadAttributes(e Engine) (err error) {
if r.Publisher == nil {
r.Publisher, err = getUserByID(e, r.PublisherID)
if err != nil {
if errors.IsUserNotExist(err) {
if IsErrUserNotExist(err) {
r.PublisherID = -1
r.Publisher = NewGhostUser()
} else {
@ -206,13 +206,32 @@ func NewRelease(gitRepo *git.Repository, r *Release, uuids []string) error {
return nil
}
var _ errutil.NotFound = (*ErrReleaseNotExist)(nil)
type ErrReleaseNotExist struct {
args map[string]interface{}
}
func IsErrReleaseNotExist(err error) bool {
_, ok := err.(ErrReleaseNotExist)
return ok
}
func (err ErrReleaseNotExist) Error() string {
return fmt.Sprintf("release does not exist: %v", err.args)
}
func (ErrReleaseNotExist) NotFound() bool {
return true
}
// GetRelease returns release by given ID.
func GetRelease(repoID int64, tagName string) (*Release, error) {
isExist, err := IsReleaseExist(repoID, tagName)
if err != nil {
return nil, err
} else if !isExist {
return nil, ErrReleaseNotExist{0, tagName}
return nil, ErrReleaseNotExist{args: map[string]interface{}{"tag": tagName}}
}
r := &Release{RepoID: repoID, LowerTagName: strings.ToLower(tagName)}
@ -230,7 +249,7 @@ func GetReleaseByID(id int64) (*Release, error) {
if err != nil {
return nil, err
} else if !has {
return nil, ErrReleaseNotExist{id, ""}
return nil, ErrReleaseNotExist{args: map[string]interface{}{"releaseID": id}}
}
return r, r.LoadAttributes()

55
internal/db/repo.go
View File

@ -33,6 +33,7 @@ import (
"gogs.io/gogs/internal/avatar"
"gogs.io/gogs/internal/conf"
"gogs.io/gogs/internal/db/errors"
"gogs.io/gogs/internal/errutil"
"gogs.io/gogs/internal/markup"
"gogs.io/gogs/internal/osutil"
"gogs.io/gogs/internal/process"
@ -248,11 +249,11 @@ func (repo *Repository) loadAttributes(e Engine) (err error) {
if repo.IsFork && repo.BaseRepo == nil {
repo.BaseRepo, err = getRepositoryByID(e, repo.ForkID)
if err != nil {
if errors.IsRepoNotExist(err) {
if IsErrRepoNotExist(err) {
repo.IsFork = false
repo.ForkID = 0
} else {
return fmt.Errorf("getRepositoryByID [%d]: %v", repo.ForkID, err)
return fmt.Errorf("get fork repository by ID: %v", err)
}
}
}
@ -1104,10 +1105,23 @@ func createRepository(e *xorm.Session, doer, owner *User, repo *Repository) (err
return repo.loadAttributes(e)
}
type ErrReachLimitOfRepo struct {
Limit int
}
func IsErrReachLimitOfRepo(err error) bool {
_, ok := err.(ErrReachLimitOfRepo)
return ok
}
func (err ErrReachLimitOfRepo) Error() string {
return fmt.Sprintf("user has reached maximum limit of repositories [limit: %d]", err.Limit)
}
// CreateRepository creates a repository for given user or organization.
func CreateRepository(doer, owner *User, opts CreateRepoOptions) (_ *Repository, err error) {
if !owner.CanCreateRepo() {
return nil, errors.ReachLimitOfRepo{Limit: owner.RepoCreationNum()}
return nil, ErrReachLimitOfRepo{Limit: owner.RepoCreationNum()}
}
repo := &Repository{
@ -1481,17 +1495,17 @@ func UpdateRepository(repo *Repository, visibilityChanged bool) (err error) {
}
// DeleteRepository deletes a repository for a user or organization.
func DeleteRepository(uid, repoID int64) error {
repo := &Repository{ID: repoID, OwnerID: uid}
func DeleteRepository(ownerID, repoID int64) error {
repo := &Repository{ID: repoID, OwnerID: ownerID}
has, err := x.Get(repo)
if err != nil {
return err
} else if !has {
return errors.RepoNotExist{ID: repoID, UserID: uid}
return ErrRepoNotExist{args: map[string]interface{}{"ownerID": ownerID, "repoID": repoID}}
}
// In case is a organization.
org, err := GetUserByID(uid)
org, err := GetUserByID(ownerID)
if err != nil {
return err
}
@ -1571,7 +1585,7 @@ func DeleteRepository(uid, repoID int64) error {
}
}
if _, err = sess.Exec("UPDATE `user` SET num_repos=num_repos-1 WHERE id=?", uid); err != nil {
if _, err = sess.Exec("UPDATE `user` SET num_repos=num_repos-1 WHERE id=?", ownerID); err != nil {
return err
}
@ -1616,6 +1630,25 @@ func GetRepositoryByRef(ref string) (*Repository, error) {
return GetRepositoryByName(user.ID, repoName)
}
var _ errutil.NotFound = (*ErrRepoNotExist)(nil)
type ErrRepoNotExist struct {
args map[string]interface{}
}
func IsErrRepoNotExist(err error) bool {
_, ok := err.(ErrRepoNotExist)
return ok
}
func (err ErrRepoNotExist) Error() string {
return fmt.Sprintf("repository does not exist: %v", err.args)
}
func (ErrRepoNotExist) NotFound() bool {
return true
}
// GetRepositoryByName returns the repository by given name under user if exists.
func GetRepositoryByName(ownerID int64, name string) (*Repository, error) {
repo := &Repository{
@ -1626,7 +1659,7 @@ func GetRepositoryByName(ownerID int64, name string) (*Repository, error) {
if err != nil {
return nil, err
} else if !has {
return nil, errors.RepoNotExist{UserID: ownerID, Name: name}
return nil, ErrRepoNotExist{args: map[string]interface{}{"ownerID": ownerID, "name": name}}
}
return repo, repo.LoadAttributes()
}
@ -1637,7 +1670,7 @@ func getRepositoryByID(e Engine, id int64) (*Repository, error) {
if err != nil {
return nil, err
} else if !has {
return nil, errors.RepoNotExist{ID: id}
return nil, ErrRepoNotExist{args: map[string]interface{}{"repoID": id}}
}
return repo, repo.loadAttributes(e)
}
@ -2361,7 +2394,7 @@ func HasForkedRepo(ownerID, repoID int64) (*Repository, bool, error) {
// ForkRepository creates a fork of target repository under another user domain.
func ForkRepository(doer, owner *User, baseRepo *Repository, name, desc string) (_ *Repository, err error) {
if !owner.CanCreateRepo() {
return nil, errors.ReachLimitOfRepo{Limit: owner.RepoCreationNum()}
return nil, ErrReachLimitOfRepo{Limit: owner.RepoCreationNum()}
}
repo := &Repository{

25
internal/db/repo_branch.go
View File

@ -11,7 +11,7 @@ import (
"github.com/gogs/git-module"
"github.com/unknwon/com"
"gogs.io/gogs/internal/db/errors"
"gogs.io/gogs/internal/errutil"
"gogs.io/gogs/internal/tool"
)
@ -44,9 +44,28 @@ func GetBranchesByPath(path string) ([]*Branch, error) {
return branches, nil
}
var _ errutil.NotFound = (*ErrBranchNotExist)(nil)
type ErrBranchNotExist struct {
args map[string]interface{}
}
func IsErrBranchNotExist(err error) bool {
_, ok := err.(ErrBranchNotExist)
return ok
}
func (err ErrBranchNotExist) Error() string {
return fmt.Sprintf("branch does not exist: %v", err.args)
}
func (ErrBranchNotExist) NotFound() bool {
return true
}
func (repo *Repository) GetBranch(name string) (*Branch, error) {
if !git.RepoHasBranch(repo.RepoPath(), name) {
return nil, errors.ErrBranchNotExist{Name: name}
return nil, ErrBranchNotExist{args: map[string]interface{}{"name": name}}
}
return &Branch{
RepoPath: repo.RepoPath(),
@ -102,7 +121,7 @@ func GetProtectBranchOfRepoByName(repoID int64, name string) (*ProtectBranch, er
if err != nil {
return nil, err
} else if !has {
return nil, errors.ErrBranchNotExist{Name: name}
return nil, ErrBranchNotExist{args: map[string]interface{}{"name": name}}
}
return protectBranch, nil
}

24
internal/db/ssh_key.go
View File

@ -24,6 +24,7 @@ import (
"xorm.io/xorm"
"gogs.io/gogs/internal/conf"
"gogs.io/gogs/internal/errutil"
"gogs.io/gogs/internal/process"
)
@ -684,6 +685,25 @@ func AddDeployKey(repoID int64, name, content string) (*DeployKey, error) {
return key, sess.Commit()
}
var _ errutil.NotFound = (*ErrDeployKeyNotExist)(nil)
type ErrDeployKeyNotExist struct {
args map[string]interface{}
}
func IsErrDeployKeyNotExist(err error) bool {
_, ok := err.(ErrDeployKeyNotExist)
return ok
}
func (err ErrDeployKeyNotExist) Error() string {
return fmt.Sprintf("deploy key does not exist: %v", err.args)
}
func (ErrDeployKeyNotExist) NotFound() bool {
return true
}
// GetDeployKeyByID returns deploy key by given ID.
func GetDeployKeyByID(id int64) (*DeployKey, error) {
key := new(DeployKey)
@ -691,7 +711,7 @@ func GetDeployKeyByID(id int64) (*DeployKey, error) {
if err != nil {
return nil, err
} else if !has {
return nil, ErrDeployKeyNotExist{id, 0, 0}
return nil, ErrDeployKeyNotExist{args: map[string]interface{}{"deployKeyID": id}}
}
return key, nil
}
@ -706,7 +726,7 @@ func GetDeployKeyByRepo(keyID, repoID int64) (*DeployKey, error) {
if err != nil {
return nil, err
} else if !has {
return nil, ErrDeployKeyNotExist{0, keyID, repoID}
return nil, ErrDeployKeyNotExist{args: map[string]interface{}{"keyID": keyID, "repoID": repoID}}
}
return key, nil
}

36
internal/db/user.go
View File

@ -31,6 +31,7 @@ import (
"gogs.io/gogs/internal/avatar"
"gogs.io/gogs/internal/conf"
"gogs.io/gogs/internal/db/errors"
"gogs.io/gogs/internal/errutil"
"gogs.io/gogs/internal/tool"
)
@ -606,8 +607,8 @@ func parseUserFromCode(code string) (user *User) {
if b, err := hex.DecodeString(hexStr); err == nil {
if user, err = GetUserByName(string(b)); user != nil {
return user
} else if !errors.IsUserNotExist(err) {
log.Error("GetUserByName: %v", err)
} else if !IsErrUserNotExist(err) {
log.Error("Failed to get user by name %q: %v", string(b), err)
}
}
@ -890,13 +891,32 @@ func GetUserByKeyID(keyID int64) (*User, error) {
return user, nil
}
var _ errutil.NotFound = (*ErrUserNotExist)(nil)
type ErrUserNotExist struct {
args map[string]interface{}
}
func IsErrUserNotExist(err error) bool {
_, ok := err.(ErrUserNotExist)
return ok
}
func (err ErrUserNotExist) Error() string {
return fmt.Sprintf("user does not exist: %v", err.args)
}
func (ErrUserNotExist) NotFound() bool {
return true
}
func getUserByID(e Engine, id int64) (*User, error) {
u := new(User)
has, err := e.ID(id).Get(u)
if err != nil {
return nil, err
} else if !has {
return nil, errors.UserNotExist{UserID: id}
return nil, ErrUserNotExist{args: map[string]interface{}{"userID": id}}
}
return u, nil
}
@ -912,7 +932,7 @@ func GetAssigneeByID(repo *Repository, userID int64) (*User, error) {
if err != nil {
return nil, err
} else if !has {
return nil, errors.UserNotExist{UserID: userID}
return nil, ErrUserNotExist{args: map[string]interface{}{"userID": userID}}
}
return GetUserByID(userID)
}
@ -920,14 +940,14 @@ func GetAssigneeByID(repo *Repository, userID int64) (*User, error) {
// GetUserByName returns a user by given name.
func GetUserByName(name string) (*User, error) {
if len(name) == 0 {
return nil, errors.UserNotExist{Name: name}
return nil, ErrUserNotExist{args: map[string]interface{}{"name": name}}
}
u := &User{LowerName: strings.ToLower(name)}
has, err := x.Get(u)
if err != nil {
return nil, err
} else if !has {
return nil, errors.UserNotExist{Name: name}
return nil, ErrUserNotExist{args: map[string]interface{}{"name": name}}
}
return u, nil
}
@ -999,7 +1019,7 @@ func ValidateCommitsWithEmails(oldCommits []*git.Commit) []*UserCommit {
// GetUserByEmail returns the user object by given e-mail if exists.
func GetUserByEmail(email string) (*User, error) {
if len(email) == 0 {
return nil, errors.UserNotExist{Name: "email"}
return nil, ErrUserNotExist{args: map[string]interface{}{"email": email}}
}
email = strings.ToLower(email)
@ -1023,7 +1043,7 @@ func GetUserByEmail(email string) (*User, error) {
return GetUserByID(emailAddress.UID)
}
return nil, errors.UserNotExist{Name: email}
return nil, ErrUserNotExist{args: map[string]interface{}{"email": email}}
}
type SearchUserOptions struct {

2
internal/db/user_mail.go
View File

@ -181,7 +181,7 @@ func MakeEmailPrimary(userID int64, email *EmailAddress) error {
if err != nil {
return err
} else if !has {
return errors.UserNotExist{UserID: email.UID}
return ErrUserNotExist{args: map[string]interface{}{"userID": email.UID}}
}
// Make sure the former primary email doesn't disappear.

44
internal/db/webhook.go
View File

@ -22,7 +22,7 @@ import (
api "github.com/gogs/go-gogs-client"
"gogs.io/gogs/internal/conf"
"gogs.io/gogs/internal/db/errors"
"gogs.io/gogs/internal/errutil"
"gogs.io/gogs/internal/httplib"
"gogs.io/gogs/internal/sync"
)
@ -235,6 +235,25 @@ func CreateWebhook(w *Webhook) error {
return err
}
var _ errutil.NotFound = (*ErrWebhookNotExist)(nil)
type ErrWebhookNotExist struct {
args map[string]interface{}
}
func IsErrWebhookNotExist(err error) bool {
_, ok := err.(ErrWebhookNotExist)
return ok
}
func (err ErrWebhookNotExist) Error() string {
return fmt.Sprintf("webhook does not exist: %v", err.args)
}
func (ErrWebhookNotExist) NotFound() bool {
return true
}
// getWebhook uses argument bean as query condition,
// ID must be specified and do not assign unnecessary fields.
func getWebhook(bean *Webhook) (*Webhook, error) {
@ -242,7 +261,7 @@ func getWebhook(bean *Webhook) (*Webhook, error) {
if err != nil {
return nil, err
} else if !has {
return nil, errors.WebhookNotExist{ID: bean.ID}
return nil, ErrWebhookNotExist{args: map[string]interface{}{"webhookID": bean.ID}}
}
return bean, nil
}
@ -499,6 +518,25 @@ func createHookTask(e Engine, t *HookTask) error {
return err
}
var _ errutil.NotFound = (*ErrHookTaskNotExist)(nil)
type ErrHookTaskNotExist struct {
args map[string]interface{}
}
func IsHookTaskNotExist(err error) bool {
_, ok := err.(ErrHookTaskNotExist)
return ok
}
func (err ErrHookTaskNotExist) Error() string {
return fmt.Sprintf("hook task does not exist: %v", err.args)
}
func (ErrHookTaskNotExist) NotFound() bool {
return true
}
// GetHookTaskOfWebhookByUUID returns hook task of given webhook by UUID.
func GetHookTaskOfWebhookByUUID(webhookID int64, uuid string) (*HookTask, error) {
hookTask := &HookTask{
@ -509,7 +547,7 @@ func GetHookTaskOfWebhookByUUID(webhookID int64, uuid string) (*HookTask, error)
if err != nil {
return nil, err
} else if !has {
return nil, errors.HookTaskNotExist{HookID: webhookID, UUID: uuid}
return nil, ErrHookTaskNotExist{args: map[string]interface{}{"webhookID": webhookID, "uuid": uuid}}
}
return hookTask, nil
}

16
internal/errutil/errutil.go Normal file
View File

@ -0,0 +1,16 @@
// Copyright 2020 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 errutil
// NotFound represents a not found error.
type NotFound interface {
NotFound() bool
}
// IsNotFound returns true if the error is a not found error.
func IsNotFound(err error) bool {
e, ok := err.(NotFound)
return ok && e.NotFound()
}

30
internal/gitutil/error.go
View File

@ -6,8 +6,33 @@ package gitutil
import (
"github.com/gogs/git-module"
"gogs.io/gogs/internal/errutil"
)
var _ errutil.NotFound = (*Error)(nil)
// Error is a wrapper of a Git error, which handles not found.
type Error struct {
error
}
func (e Error) NotFound() bool {
return IsErrSubmoduleNotExist(e.error) ||
IsErrRevisionNotExist(e.error)
}
// NewError wraps given error.
func NewError(err error) error {
return Error{error: err}
}
// IsErrSubmoduleNotExist returns true if the error is git.ErrSubmoduleNotExist.
func IsErrSubmoduleNotExist(err error) bool {
return err == git.ErrSubmoduleNotExist
}
// IsErrRevisionNotExist returns true if the error is git.ErrRevisionNotExist.
func IsErrRevisionNotExist(err error) bool {
return err == git.ErrRevisionNotExist
@ -17,8 +42,3 @@ func IsErrRevisionNotExist(err error) bool {
func IsErrNoMergeBase(err error) bool {
return err == git.ErrNoMergeBase
}
// IsErrSubmoduleNotExist returns true if the error is git.ErrSubmoduleNotExist.
func IsErrSubmoduleNotExist(err error) bool {
return err == git.ErrSubmoduleNotExist
}

27
internal/osutil/error.go Normal file
View File

@ -0,0 +1,27 @@
// Copyright 2020 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 osutil
import (
"os"
"gogs.io/gogs/internal/errutil"
)
var _ errutil.NotFound = (*Error)(nil)
// Error is a wrapper of an OS error, which handles not found.
type Error struct {
error
}
func (e Error) NotFound() bool {
return e.error == os.ErrNotExist
}
// NewError wraps given error.
func NewError(err error) error {
return Error{error: err}
}

4
internal/route/admin/admin.go
View File

@ -163,7 +163,7 @@ func Dashboard(c *context.Context) {
} else {
c.Flash.Success(success)
}
c.SubURLRedirect("/admin")
c.RedirectSubpath("/admin")
return
}
@ -239,5 +239,5 @@ func Monitor(c *context.Context) {
c.Data["PageIsAdminMonitor"] = true
c.Data["Processes"] = process.Processes
c.Data["Entries"] = cron.ListTasks()
c.HTML(200, MONITOR)
c.Success( MONITOR)
}

16
internal/route/admin/auths.go
View File

@ -34,7 +34,7 @@ func Authentications(c *context.Context) {
var err error
c.Data["Sources"], err = db.LoginSources()
if err != nil {
c.ServerError("LoginSources", err)
c.Error(err, "list login sources")
return
}
@ -146,7 +146,7 @@ func NewAuthSourcePost(c *context.Context, f form.Authentication) {
APIEndpoint: strings.TrimSuffix(f.GitHubAPIEndpoint, "/") + "/",
}
default:
c.Error(http.StatusBadRequest)
c.Status(http.StatusBadRequest)
return
}
c.Data["HasTLS"] = hasTLS
@ -167,7 +167,7 @@ func NewAuthSourcePost(c *context.Context, f form.Authentication) {
c.FormErr("Name")
c.RenderWithErr(c.Tr("admin.auths.login_source_exist", err.(db.ErrLoginSourceAlreadyExist).Name), AUTH_NEW, f)
} else {
c.ServerError("CreateSource", err)
c.Error(err, "create login source")
}
return
}
@ -188,7 +188,7 @@ func EditAuthSource(c *context.Context) {
source, err := db.GetLoginSourceByID(c.ParamsInt64(":authid"))
if err != nil {
c.ServerError("GetLoginSourceByID", err)
c.Error(err, "get login source by ID")
return
}
c.Data["Source"] = source
@ -206,7 +206,7 @@ func EditAuthSourcePost(c *context.Context, f form.Authentication) {
source, err := db.GetLoginSourceByID(c.ParamsInt64(":authid"))
if err != nil {
c.ServerError("GetLoginSourceByID", err)
c.Error(err, "get login source by ID")
return
}
c.Data["Source"] = source
@ -232,7 +232,7 @@ func EditAuthSourcePost(c *context.Context, f form.Authentication) {
APIEndpoint: strings.TrimSuffix(f.GitHubAPIEndpoint, "/") + "/",
}
default:
c.Error(http.StatusBadRequest)
c.Status(http.StatusBadRequest)
return
}
@ -241,7 +241,7 @@ func EditAuthSourcePost(c *context.Context, f form.Authentication) {
source.IsDefault = f.IsDefault
source.Cfg = config
if err := db.UpdateLoginSource(source); err != nil {
c.ServerError("UpdateLoginSource", err)
c.Error(err, "update login source")
return
}
@ -254,7 +254,7 @@ func EditAuthSourcePost(c *context.Context, f form.Authentication) {
func DeleteAuthSource(c *context.Context) {
source, err := db.GetLoginSourceByID(c.ParamsInt64(":authid"))
if err != nil {
c.ServerError("GetLoginSourceByID", err)
c.Error(err, "get login source by ID")
return
}

14
internal/route/admin/notice.go
View File

@ -5,6 +5,8 @@
package admin
import (
"net/http"
"github.com/unknwon/com"
"github.com/unknwon/paginater"
log "unknwon.dev/clog/v2"
@ -19,7 +21,7 @@ const (
)
func Notices(c *context.Context) {
c.Data["Title"] = c.Tr("admin.notices")
c.Title("admin.notices")
c.Data["PageIsAdmin"] = true
c.Data["PageIsAdminNotices"] = true
@ -32,13 +34,13 @@ func Notices(c *context.Context) {
notices, err := db.Notices(page, conf.UI.Admin.NoticePagingNum)
if err != nil {
c.Handle(500, "Notices", err)
c.Error(err, "list notices")
return
}
c.Data["Notices"] = notices
c.Data["Total"] = total
c.HTML(200, NOTICES)
c.Success(NOTICES)
}
func DeleteNotices(c *context.Context) {
@ -53,16 +55,16 @@ func DeleteNotices(c *context.Context) {
if err := db.DeleteNoticesByIDs(ids); err != nil {
c.Flash.Error("DeleteNoticesByIDs: " + err.Error())
c.Status(500)
c.Status(http.StatusInternalServerError)
} else {
c.Flash.Success(c.Tr("admin.notices.delete_success"))
c.Status(200)
c.Status(http.StatusOK)
}
}
func EmptyNotices(c *context.Context) {
if err := db.DeleteNotices(0, 0); err != nil {
c.Handle(500, "DeleteNotices", err)
c.Error(err,"delete notices")
return
}

14
internal/route/admin/repos.go
View File

@ -37,7 +37,7 @@ func Repos(c *context.Context) {
if len(keyword) == 0 {
repos, err = db.Repositories(page, conf.UI.Admin.RepoPagingNum)
if err != nil {
c.Handle(500, "Repositories", err)
c.Error(err, "list repositories")
return
}
count = db.CountRepositories(true)
@ -50,7 +50,7 @@ func Repos(c *context.Context) {
PageSize: conf.UI.Admin.RepoPagingNum,
})
if err != nil {
c.Handle(500, "SearchRepositoryByName", err)
c.Error(err, "search repository by name")
return
}
}
@ -59,29 +59,29 @@ func Repos(c *context.Context) {
c.Data["Page"] = paginater.New(int(count), conf.UI.Admin.RepoPagingNum, page, 5)
if err = db.RepositoryList(repos).LoadAttributes(); err != nil {
c.Handle(500, "LoadAttributes", err)
c.Error(err, "load attributes")
return
}
c.Data["Repos"] = repos
c.HTML(200, REPOS)
c.Success(REPOS)
}
func DeleteRepo(c *context.Context) {
repo, err := db.GetRepositoryByID(c.QueryInt64("id"))
if err != nil {
c.Handle(500, "GetRepositoryByID", err)
c.Error(err, "get repository by ID")
return
}
if err := db.DeleteRepository(repo.MustOwner().ID, repo.ID); err != nil {
c.Handle(500, "DeleteRepository", err)
c.Error(err, "delete repository")
return
}
log.Trace("Repository deleted: %s/%s", repo.MustOwner().Name, repo.Name)
c.Flash.Success(c.Tr("repo.settings.deletion_success"))
c.JSON(200, map[string]interface{}{
c.JSONSuccess(map[string]interface{}{
"redirect": conf.Server.Subpath + "/admin/repos?page=" + c.Query("page"),
})
}

34
internal/route/admin/users.go
View File

@ -48,13 +48,13 @@ func NewUser(c *context.Context) {
sources, err := db.LoginSources()
if err != nil {
c.Handle(500, "LoginSources", err)
c.Error(err, "list login sources")
return
}
c.Data["Sources"] = sources
c.Data["CanSendEmail"] = conf.Email.Enabled
c.HTML(200, USER_NEW)
c.Success(USER_NEW)
}
func NewUserPost(c *context.Context, f form.AdminCrateUser) {
@ -64,7 +64,7 @@ func NewUserPost(c *context.Context, f form.AdminCrateUser) {
sources, err := db.LoginSources()
if err != nil {
c.Handle(500, "LoginSources", err)
c.Error(err, "list login sources")
return
}
c.Data["Sources"] = sources
@ -72,7 +72,7 @@ func NewUserPost(c *context.Context, f form.AdminCrateUser) {
c.Data["CanSendEmail"] = conf.Email.Enabled
if c.HasError() {
c.HTML(200, USER_NEW)
c.Success(USER_NEW)
return
}
@ -108,7 +108,7 @@ func NewUserPost(c *context.Context, f form.AdminCrateUser) {
c.Data["Err_UserName"] = true
c.RenderWithErr(c.Tr("user.form.name_pattern_not_allowed", err.(db.ErrNamePatternNotAllowed).Pattern), USER_NEW, &f)
default:
c.Handle(500, "CreateUser", err)
c.Error(err, "create user")
}
return
}
@ -126,7 +126,7 @@ func NewUserPost(c *context.Context, f form.AdminCrateUser) {
func prepareUserInfo(c *context.Context) *db.User {
u, err := db.GetUserByID(c.ParamsInt64(":userid"))
if err != nil {
c.Handle(500, "GetUserByID", err)
c.Error(err, "get user by ID")
return nil
}
c.Data["User"] = u
@ -134,7 +134,7 @@ func prepareUserInfo(c *context.Context) *db.User {
if u.LoginSource > 0 {
c.Data["LoginSource"], err = db.GetLoginSourceByID(u.LoginSource)
if err != nil {
c.Handle(500, "GetLoginSourceByID", err)
c.Error(err, "get login source by ID")
return nil
}
} else {
@ -143,7 +143,7 @@ func prepareUserInfo(c *context.Context) *db.User {
sources, err := db.LoginSources()
if err != nil {
c.Handle(500, "LoginSources", err)
c.Error(err, "list login sources")
return nil
}
c.Data["Sources"] = sources
@ -162,7 +162,7 @@ func EditUser(c *context.Context) {
return
}
c.HTML(200, USER_EDIT)
c.Success(USER_EDIT)
}
func EditUserPost(c *context.Context, f form.AdminEditUser) {
@ -177,7 +177,7 @@ func EditUserPost(c *context.Context, f form.AdminEditUser) {
}
if c.HasError() {
c.HTML(200, USER_EDIT)
c.Success(USER_EDIT)
return
}
@ -196,7 +196,7 @@ func EditUserPost(c *context.Context, f form.AdminEditUser) {
u.Passwd = f.Password
var err error
if u.Salt, err = db.GetUserSalt(); err != nil {
c.Handle(500, "UpdateUser", err)
c.Error(err, "get user salt")
return
}
u.EncodePasswd()
@ -219,7 +219,7 @@ func EditUserPost(c *context.Context, f form.AdminEditUser) {
c.Data["Err_Email"] = true
c.RenderWithErr(c.Tr("form.email_been_used"), USER_EDIT, &f)
} else {
c.Handle(500, "UpdateUser", err)
c.Error(err, "update user")
}
return
}
@ -232,7 +232,7 @@ func EditUserPost(c *context.Context, f form.AdminEditUser) {
func DeleteUser(c *context.Context) {
u, err := db.GetUserByID(c.ParamsInt64(":userid"))
if err != nil {
c.Handle(500, "GetUserByID", err)
c.Error(err, "get user by ID")
return
}
@ -240,23 +240,23 @@ func DeleteUser(c *context.Context) {
switch {
case db.IsErrUserOwnRepos(err):
c.Flash.Error(c.Tr("admin.users.still_own_repo"))
c.JSON(200, map[string]interface{}{
c.JSONSuccess(map[string]interface{}{
"redirect": conf.Server.Subpath + "/admin/users/" + c.Params(":userid"),
})
case db.IsErrUserHasOrgs(err):
c.Flash.Error(c.Tr("admin.users.still_has_org"))
c.JSON(200, map[string]interface{}{
c.JSONSuccess(map[string]interface{}{
"redirect": conf.Server.Subpath + "/admin/users/" + c.Params(":userid"),
})
default:
c.Handle(500, "DeleteUser", err)
c.Error(err, "delete user")
}
return
}
log.Trace("Account deleted by admin (%s): %s", c.User.Name, u.Name)
c.Flash.Success(c.Tr("admin.users.deletion_success"))
c.JSON(200, map[string]interface{}{
c.JSONSuccess(map[string]interface{}{
"redirect": conf.Server.Subpath + "/admin/users",
})
}

6
internal/route/api/v1/admin/org.go
View File

@ -6,12 +6,12 @@ package admin
import (
api "github.com/gogs/go-gogs-client"
org2 "gogs.io/gogs/internal/route/api/v1/org"
user2 "gogs.io/gogs/internal/route/api/v1/user"
"gogs.io/gogs/internal/context"
"gogs.io/gogs/internal/route/api/v1/org"
"gogs.io/gogs/internal/route/api/v1/user"
)
func CreateOrg(c *context.APIContext, form api.CreateOrgOption) {
org2.CreateOrgForUser(c, form, user2.GetUserByParams(c))
org.CreateOrgForUser(c, form, user.GetUserByParams(c))
}

7
internal/route/api/v1/admin/org_repo.go
View File

@ -7,13 +7,12 @@ package admin
import (
"gogs.io/gogs/internal/context"
"gogs.io/gogs/internal/db"
"gogs.io/gogs/internal/db/errors"
)
func GetRepositoryByParams(c *context.APIContext) *db.Repository {
repo, err := db.GetRepositoryByName(c.Org.Team.OrgID, c.Params(":reponame"))
if err != nil {
c.NotFoundOrServerError("GetRepositoryByName", errors.IsRepoNotExist, err)
c.NotFoundOrError(err, "get repository by name")
return nil
}
return repo
@ -25,7 +24,7 @@ func AddTeamRepository(c *context.APIContext) {
return
}
if err := c.Org.Team.AddRepository(repo); err != nil {
c.ServerError("AddRepository", err)
c.Error(err, "add repository")
return
}
@ -38,7 +37,7 @@ func RemoveTeamRepository(c *context.APIContext) {
return
}
if err := c.Org.Team.RemoveRepository(repo.ID); err != nil {
c.ServerError("RemoveRepository", err)
c.Error(err, "remove repository")
return
}

18
internal/route/api/v1/admin/org_team.go
View File

@ -5,14 +5,14 @@
package admin
import (
convert2 "gogs.io/gogs/internal/route/api/v1/convert"
user2 "gogs.io/gogs/internal/route/api/v1/user"
"net/http"
api "github.com/gogs/go-gogs-client"
"gogs.io/gogs/internal/context"
"gogs.io/gogs/internal/db"
"gogs.io/gogs/internal/route/api/v1/convert"
"gogs.io/gogs/internal/route/api/v1/user"
)
func CreateTeam(c *context.APIContext, form api.CreateTeamOption) {
@ -24,23 +24,23 @@ func CreateTeam(c *context.APIContext, form api.CreateTeamOption) {
}
if err := db.NewTeam(team); err != nil {
if db.IsErrTeamAlreadyExist(err) {
c.Error(http.StatusUnprocessableEntity, "", err)
c.ErrorStatus(http.StatusUnprocessableEntity, err)
} else {
c.ServerError("NewTeam", err)
c.Error(err, "new team")
}
return
}
c.JSON(http.StatusCreated, convert2.ToTeam(team))
c.JSON(http.StatusCreated, convert.ToTeam(team))
}
func AddTeamMember(c *context.APIContext) {
u := user2.GetUserByParams(c)
u := user.GetUserByParams(c)
if c.Written() {
return
}
if err := c.Org.Team.AddMember(u.ID); err != nil {
c.ServerError("AddMember", err)
c.Error(err, "add member")
return
}
@ -48,13 +48,13 @@ func AddTeamMember(c *context.APIContext) {
}
func RemoveTeamMember(c *context.APIContext) {
u := user2.GetUserByParams(c)
u := user.GetUserByParams(c)
if c.Written() {
return
}
if err := c.Org.Team.RemoveMember(u.ID); err != nil {
c.ServerError("RemoveMember", err)
c.Error(err, "remove member")
return
}

8
internal/route/api/v1/admin/repo.go
View File

@ -6,17 +6,17 @@ package admin
import (
api "github.com/gogs/go-gogs-client"
repo2 "gogs.io/gogs/internal/route/api/v1/repo"
user2 "gogs.io/gogs/internal/route/api/v1/user"
"gogs.io/gogs/internal/context"
"gogs.io/gogs/internal/route/api/v1/repo"
"gogs.io/gogs/internal/route/api/v1/user"
)
func CreateRepo(c *context.APIContext, form api.CreateRepoOption) {
owner := user2.GetUserByParams(c)
owner := user.GetUserByParams(c)
if c.Written() {
return
}
repo2.CreateUserRepo(c, owner, form)
repo.CreateUserRepo(c, owner, form)
}

21
internal/route/api/v1/admin/user.go
View File

@ -7,9 +7,8 @@ package admin
import (
"net/http"
log "unknwon.dev/clog/v2"
api "github.com/gogs/go-gogs-client"
log "unknwon.dev/clog/v2"
"gogs.io/gogs/internal/conf"
"gogs.io/gogs/internal/context"
@ -27,9 +26,9 @@ func parseLoginSource(c *context.APIContext, u *db.User, sourceID int64, loginNa
source, err := db.GetLoginSourceByID(sourceID)
if err != nil {
if errors.IsLoginSourceNotExist(err) {
c.Error(http.StatusUnprocessableEntity, "", err)
c.ErrorStatus(http.StatusUnprocessableEntity, err)
} else {
c.ServerError("GetLoginSourceByID", err)
c.Error(err, "get login source by ID")
}
return
}
@ -59,9 +58,9 @@ func CreateUser(c *context.APIContext, form api.CreateUserOption) {
db.IsErrEmailAlreadyUsed(err) ||
db.IsErrNameReserved(err) ||
db.IsErrNamePatternNotAllowed(err) {
c.Error(http.StatusUnprocessableEntity, "", err)
c.ErrorStatus(http.StatusUnprocessableEntity, err)
} else {
c.ServerError("CreateUser", err)
c.Error(err, "create user")
}
return
}
@ -90,7 +89,7 @@ func EditUser(c *context.APIContext, form api.EditUserOption) {
u.Passwd = form.Password
var err error
if u.Salt, err = db.GetUserSalt(); err != nil {
c.ServerError("GetUserSalt", err)
c.Error(err, "get user salt")
return
}
u.EncodePasswd()
@ -119,9 +118,9 @@ func EditUser(c *context.APIContext, form api.EditUserOption) {
if err := db.UpdateUser(u); err != nil {
if db.IsErrEmailAlreadyUsed(err) {
c.Error(http.StatusUnprocessableEntity, "", err)
c.ErrorStatus(http.StatusUnprocessableEntity, err)
} else {
c.ServerError("UpdateUser", err)
c.Error(err, "update user")
}
return
}
@ -139,9 +138,9 @@ func DeleteUser(c *context.APIContext) {
if err := db.DeleteUser(u); err != nil {
if db.IsErrUserOwnRepos(err) ||
db.IsErrUserHasOrgs(err) {
c.Error(http.StatusUnprocessableEntity, "", err)
c.ErrorStatus(http.StatusUnprocessableEntity, err)
} else {
c.ServerError("DeleteUser", err)
c.Error(err, "delete user")
}
return
}

23
internal/route/api/v1/api.go
View File

@ -15,7 +15,6 @@ import (
"gogs.io/gogs/internal/context"
"gogs.io/gogs/internal/db"
"gogs.io/gogs/internal/db/errors"
"gogs.io/gogs/internal/form"
"gogs.io/gogs/internal/route/api/v1/admin"
"gogs.io/gogs/internal/route/api/v1/misc"
@ -40,7 +39,7 @@ func repoAssignment() macaron.Handler {
} else {
owner, err = db.GetUserByName(username)
if err != nil {
c.NotFoundOrServerError("GetUserByName", errors.IsUserNotExist, err)
c.NotFoundOrError(err, "get user by name")
return
}
}
@ -48,10 +47,10 @@ func repoAssignment() macaron.Handler {
r, err := db.GetRepositoryByName(owner.ID, reponame)
if err != nil {
c.NotFoundOrServerError("GetRepositoryByName", errors.IsRepoNotExist, err)
c.NotFoundOrError(err, "get repository by name")
return
} else if err = r.GetOwner(); err != nil {
c.ServerError("GetOwner", err)
c.Error(err, "get owner")
return
}
@ -60,7 +59,7 @@ func repoAssignment() macaron.Handler {
} else {
mode, err := db.UserAccessMode(c.UserID(), r)
if err != nil {
c.ServerError("UserAccessMode", err)
c.Error(err, "get user access mode")
return
}
c.Repo.AccessMode = mode
@ -94,7 +93,7 @@ func orgAssignment(args ...bool) macaron.Handler {
if assignOrg {
c.Org.Organization, err = db.GetUserByName(c.Params(":orgname"))
if err != nil {
c.NotFoundOrServerError("GetUserByName", errors.IsUserNotExist, err)
c.NotFoundOrError(err, "get organization by name")
return
}
}
@ -102,7 +101,7 @@ func orgAssignment(args ...bool) macaron.Handler {
if assignTeam {
c.Org.Team, err = db.GetTeamByID(c.ParamsInt64(":teamid"))
if err != nil {
c.NotFoundOrServerError("GetTeamByID", errors.IsTeamNotExist, err)
c.NotFoundOrError(err, "get team by ID")
return
}
}
@ -113,7 +112,7 @@ func orgAssignment(args ...bool) macaron.Handler {
func reqToken() macaron.Handler {
return func(c *context.Context) {
if !c.IsTokenAuth {
c.Error(http.StatusUnauthorized)
c.Status(http.StatusUnauthorized)
return
}
}
@ -123,7 +122,7 @@ func reqToken() macaron.Handler {
func reqBasicAuth() macaron.Handler {
return func(c *context.Context) {
if !c.IsBasicAuth {
c.Error(http.StatusUnauthorized)
c.Status(http.StatusUnauthorized)
return
}
}
@ -133,7 +132,7 @@ func reqBasicAuth() macaron.Handler {
func reqAdmin() macaron.Handler {
return func(c *context.Context) {
if !c.IsLogged || !c.User.IsAdmin {
c.Error(http.StatusForbidden)
c.Status(http.StatusForbidden)
return
}
}
@ -143,7 +142,7 @@ func reqAdmin() macaron.Handler {
func reqRepoWriter() macaron.Handler {
return func(c *context.Context) {
if !c.Repo.IsWriter() {
c.Error(http.StatusForbidden)
c.Status(http.StatusForbidden)
return
}
}
@ -153,7 +152,7 @@ func reqRepoWriter() macaron.Handler {
func reqRepoAdmin() macaron.Handler {
return func(c *context.Context) {
if !c.Repo.IsAdmin() {
c.Error(http.StatusForbidden)
c.Status(http.StatusForbidden)
return
}
}

9
internal/route/api/v1/misc/markdown.go
View File

@ -5,8 +5,6 @@
package misc
import (
"net/http"
api "github.com/gogs/go-gogs-client"
"gogs.io/gogs/internal/context"
@ -14,11 +12,6 @@ import (
)
func Markdown(c *context.APIContext, form api.MarkdownOption) {
if c.HasApiError() {
c.Error(http.StatusUnprocessableEntity, "", c.GetErrMsg())
return
}
if len(form.Text) == 0 {
_, _ = c.Write([]byte(""))
return
@ -30,7 +23,7 @@ func Markdown(c *context.APIContext, form api.MarkdownOption) {
func MarkdownRaw(c *context.APIContext) {
body, err := c.Req.Body().Bytes()
if err != nil {
c.Error(http.StatusUnprocessableEntity, "", err)
c.Error(err, "read body")
return
}
_, _ = c.Write(markup.SanitizeBytes(markup.RawMarkdown(body, "")))

22
internal/route/api/v1/org/org.go
View File

@ -5,14 +5,14 @@
package org
import (
convert2 "gogs.io/gogs/internal/route/api/v1/convert"
user2 "gogs.io/gogs/internal/route/api/v1/user"
"net/http"
api "github.com/gogs/go-gogs-client"
"gogs.io/gogs/internal/context"
"gogs.io/gogs/internal/db"
"gogs.io/gogs/internal/route/api/v1/convert"
"gogs.io/gogs/internal/route/api/v1/user"
)
func CreateOrgForUser(c *context.APIContext, apiForm api.CreateOrgOption, user *db.User) {
@ -33,25 +33,25 @@ func CreateOrgForUser(c *context.APIContext, apiForm api.CreateOrgOption, user *
if db.IsErrUserAlreadyExist(err) ||
db.IsErrNameReserved(err) ||
db.IsErrNamePatternNotAllowed(err) {
c.Error(http.StatusUnprocessableEntity, "", err)
c.ErrorStatus(http.StatusUnprocessableEntity, err)
} else {
c.ServerError("CreateOrganization", err)
c.Error(err, "create organization")
}
return
}
c.JSON(201, convert2.ToOrganization(org))
c.JSON(201, convert.ToOrganization(org))
}
func listUserOrgs(c *context.APIContext, u *db.User, all bool) {
if err := u.GetOrganizations(all); err != nil {
c.ServerError("GetOrganizations", err)
c.Error(err, "get organization")
return
}
apiOrgs := make([]*api.Organization, len(u.Orgs))
for i := range u.Orgs {
apiOrgs[i] = convert2.ToOrganization(u.Orgs[i])
apiOrgs[i] = convert.ToOrganization(u.Orgs[i])
}
c.JSONSuccess(&apiOrgs)
}
@ -65,7 +65,7 @@ func CreateMyOrg(c *context.APIContext, apiForm api.CreateOrgOption) {
}
func ListUserOrgs(c *context.APIContext) {
u := user2.GetUserByParams(c)
u := user.GetUserByParams(c)
if c.Written() {
return
}
@ -73,7 +73,7 @@ func ListUserOrgs(c *context.APIContext) {
}
func Get(c *context.APIContext) {
c.JSONSuccess(convert2.ToOrganization(c.Org.Organization))
c.JSONSuccess(convert.ToOrganization(c.Org.Organization))
}
func Edit(c *context.APIContext, form api.EditOrgOption) {
@ -88,9 +88,9 @@ func Edit(c *context.APIContext, form api.EditOrgOption) {
org.Website = form.Website
org.Location = form.Location
if err := db.UpdateUser(org); err != nil {
c.ServerError("UpdateUser", err)
c.Error(err, "update user")
return
}
c.JSONSuccess(convert2.ToOrganization(org))
c.JSONSuccess(convert.ToOrganization(org))
}

8
internal/route/api/v1/org/team.go
View File

@ -6,21 +6,21 @@ package org
import (
api "github.com/gogs/go-gogs-client"
convert2 "gogs.io/gogs/internal/route/api/v1/convert"
"gogs.io/gogs/internal/context"
"gogs.io/gogs/internal/route/api/v1/convert"
)
func ListTeams(c *context.APIContext) {
org := c.Org.Organization
if err := org.GetTeams(); err != nil {
c.Error(500, "GetTeams", err)
c.Error(err, "get teams")
return
}
apiTeams := make([]*api.Team, len(org.Teams))
for i := range org.Teams {
apiTeams[i] = convert2.ToTeam(org.Teams[i])
apiTeams[i] = convert.ToTeam(org.Teams[i])
}
c.JSON(200, apiTeams)
c.JSONSuccess(apiTeams)
}

21
internal/route/api/v1/repo/branch.go
View File

@ -6,38 +6,33 @@ package repo
import (
api "github.com/gogs/go-gogs-client"
convert2 "gogs.io/gogs/internal/route/api/v1/convert"
"gogs.io/gogs/internal/context"
"gogs.io/gogs/internal/db/errors"
"gogs.io/gogs/internal/route/api/v1/convert"
)
// https://github.com/gogs/go-gogs-client/wiki/Repositories#get-branch
func GetBranch(c *context.APIContext) {
branch, err := c.Repo.Repository.GetBranch(c.Params("*"))
if err != nil {
if errors.IsErrBranchNotExist(err) {
c.Error(404, "GetBranch", err)
} else {
c.Error(500, "GetBranch", err)
}
c.NotFoundOrError(err, "get branch")
return
}
commit, err := branch.GetCommit()
if err != nil {
c.Error(500, "GetCommit", err)
c.Error(err, "get commit")
return
}
c.JSON(200, convert2.ToBranch(branch, commit))
c.JSONSuccess( convert.ToBranch(branch, commit))
}
// https://github.com/gogs/go-gogs-client/wiki/Repositories#list-branches
func ListBranches(c *context.APIContext) {
branches, err := c.Repo.Repository.GetBranches()
if err != nil {
c.Error(500, "GetBranches", err)
c.Error(err, "get branches")
return
}
@ -45,11 +40,11 @@ func ListBranches(c *context.APIContext) {
for i := range branches {
commit, err := branches[i].GetCommit()
if err != nil {
c.Error(500, "GetCommit", err)
c.Error(err, "get commit")
return
}
apiBranches[i] = convert2.ToBranch(branches[i], commit)
apiBranches[i] = convert.ToBranch(branches[i], commit)
}
c.JSON(200, &apiBranches)
c.JSONSuccess( &apiBranches)
}

37
internal/route/api/v1/repo/collaborators.go
View File

@ -5,17 +5,18 @@
package repo
import (
"net/http"
api "github.com/gogs/go-gogs-client"
"gogs.io/gogs/internal/context"
"gogs.io/gogs/internal/db"
"gogs.io/gogs/internal/db/errors"
)
func ListCollaborators(c *context.APIContext) {
collaborators, err := c.Repo.Repository.GetCollaborators()
if err != nil {
c.ServerError("GetCollaborators", err)
c.Error(err, "get collaborators")
return
}
@ -29,62 +30,62 @@ func ListCollaborators(c *context.APIContext) {
func AddCollaborator(c *context.APIContext, form api.AddCollaboratorOption) {
collaborator, err := db.GetUserByName(c.Params(":collaborator"))
if err != nil {
if errors.IsUserNotExist(err) {
c.Error(422, "", err)
if db.IsErrUserNotExist(err) {
c.Status(http.StatusUnprocessableEntity)
} else {
c.Error(500, "GetUserByName", err)
c.Error(err, "get user by name")
}
return
}
if err := c.Repo.Repository.AddCollaborator(collaborator); err != nil {
c.Error(500, "AddCollaborator", err)
c.Error(err, "add collaborator")
return
}
if form.Permission != nil {
if err := c.Repo.Repository.ChangeCollaborationAccessMode(collaborator.ID, db.ParseAccessMode(*form.Permission)); err != nil {
c.Error(500, "ChangeCollaborationAccessMode", err)
c.Error(err, "change collaboration access mode")
return
}
}
c.Status(204)
c.NoContent()
}
func IsCollaborator(c *context.APIContext) {
collaborator, err := db.GetUserByName(c.Params(":collaborator"))
if err != nil {
if errors.IsUserNotExist(err) {
c.Error(422, "", err)
if db.IsErrUserNotExist(err) {
c.Status(http.StatusUnprocessableEntity)
} else {
c.Error(500, "GetUserByName", err)
c.Error(err, "get user by name")
}
return
}
if !c.Repo.Repository.IsCollaborator(collaborator.ID) {
c.Status(404)
c.NotFound()
} else {
c.Status(204)
c.NoContent()
}
}
func DeleteCollaborator(c *context.APIContext) {
collaborator, err := db.GetUserByName(c.Params(":collaborator"))
if err != nil {
if errors.IsUserNotExist(err) {
c.Error(422, "", err)
if db.IsErrUserNotExist(err) {
c.Status(http.StatusUnprocessableEntity)
} else {
c.Error(500, "GetUserByName", err)
c.Error(err, "get user by name")
}
return
}
if err := c.Repo.Repository.DeleteCollaboration(collaborator.ID); err != nil {
c.Error(500, "DeleteCollaboration", err)
c.Error(err, "delete collaboration")
return
}
c.Status(204)
c.NoContent()
}

19
internal/route/api/v1/repo/commits.go
View File

@ -15,7 +15,6 @@ import (
"gogs.io/gogs/internal/conf"
"gogs.io/gogs/internal/context"
"gogs.io/gogs/internal/db"
"gogs.io/gogs/internal/db/errors"
"gogs.io/gogs/internal/gitutil"
)
@ -28,20 +27,20 @@ func GetSingleCommit(c *context.APIContext) {
gitRepo, err := git.Open(c.Repo.Repository.RepoPath())
if err != nil {
c.ServerError("open repository", err)
c.Error(err, "open repository")
return
}
commit, err := gitRepo.CatFileCommit(c.Params(":sha"))
if err != nil {
c.NotFoundOrServerError("get commit", gitutil.IsErrRevisionNotExist, err)
c.NotFoundOrError(gitutil.NewError(err), "get commit")
return
}
// Retrieve author and committer information
var apiAuthor, apiCommitter *api.User
author, err := db.GetUserByEmail(commit.Author.Email)
if err != nil && !errors.IsUserNotExist(err) {
c.ServerError("Get user by author email", err)
if err != nil && !db.IsErrUserNotExist(err) {
c.Error(err, "get user by author email")
return
} else if err == nil {
apiAuthor = author.APIFormat()
@ -51,8 +50,8 @@ func GetSingleCommit(c *context.APIContext) {
apiCommitter = apiAuthor
} else {
committer, err := db.GetUserByEmail(commit.Committer.Email)
if err != nil && !errors.IsUserNotExist(err) {
c.ServerError("Get user by committer email", err)
if err != nil && !db.IsErrUserNotExist(err) {
c.Error(err, "get user by committer email")
return
} else if err == nil {
apiCommitter = committer.APIFormat()
@ -102,7 +101,7 @@ func GetSingleCommit(c *context.APIContext) {
func GetReferenceSHA(c *context.APIContext) {
gitRepo, err := git.Open(c.Repo.Repository.RepoPath())
if err != nil {
c.ServerError("open repository", err)
c.Error(err, "open repository")
return
}
@ -132,8 +131,8 @@ func GetReferenceSHA(c *context.APIContext) {
sha, err = gitRepo.TagCommitID(ref)
}
if err != nil {
c.NotFoundOrServerError("get reference commit ID", gitutil.IsErrRevisionNotExist, err)
c.NotFoundOrError(gitutil.NewError(err), "get reference commit ID")
return
}
c.PlainText(http.StatusOK, []byte(sha))
c.PlainText(http.StatusOK, sha)
}

10
internal/route/api/v1/repo/contents.go
View File

@ -19,7 +19,7 @@ import (
func GetContents(c *context.APIContext) {
gitRepo, err := git.Open(c.Repo.Repository.RepoPath())
if err != nil {
c.ServerError("open repository", err)
c.Error(err, "open repository")
return
}
@ -30,14 +30,14 @@ func GetContents(c *context.APIContext) {
commit, err := gitRepo.CatFileCommit(ref)
if err != nil {
c.NotFoundOrServerError("get commit", gitutil.IsErrRevisionNotExist, err)
c.NotFoundOrError(gitutil.NewError(err), "get commit")
return
}
treePath := c.Params("*")
entry, err := commit.TreeEntry(treePath)
if err != nil {
c.NotFoundOrServerError("get tree entry", gitutil.IsErrRevisionNotExist, err)
c.NotFoundOrError(gitutil.NewError(err), "get tree entry")
return
}
@ -137,13 +137,13 @@ func GetContents(c *context.APIContext) {
// The entry is a directory
dir, err := gitRepo.LsTree(entry.ID().String())
if err != nil {
c.NotFoundOrServerError("get tree", gitutil.IsErrRevisionNotExist, err)
c.NotFoundOrError(gitutil.NewError(err), "get tree")
return
}
entries, err := dir.Entries()
if err != nil {
c.NotFoundOrServerError("list entries", gitutil.IsErrRevisionNotExist, err)
c.NotFoundOrError(gitutil.NewError(err), "list entries")
return
}

10
internal/route/api/v1/repo/file.go
View File

@ -26,11 +26,11 @@ func GetRawFile(c *context.APIContext) {
blob, err := c.Repo.Commit.Blob(c.Repo.TreePath)
if err != nil {
c.NotFoundOrServerError("get blob", gitutil.IsErrRevisionNotExist, err)
c.NotFoundOrError(gitutil.NewError(err), "get blob")
return
}
if err = repo.ServeBlob(c.Context, blob); err != nil {
c.ServerError("ServeBlob", err)
c.Error(err, "serve blob")
}
}
@ -38,7 +38,7 @@ func GetArchive(c *context.APIContext) {
repoPath := db.RepoPath(c.Params(":username"), c.Params(":reponame"))
gitRepo, err := git.Open(repoPath)
if err != nil {
c.ServerError("open repository", err)
c.Error(err, "open repository")
return
}
c.Repo.GitRepo = gitRepo
@ -49,14 +49,14 @@ func GetArchive(c *context.APIContext) {
func GetEditorconfig(c *context.APIContext) {
ec, err := c.Repo.Editorconfig()
if err != nil {
c.NotFoundOrServerError("get .editorconfig", gitutil.IsErrRevisionNotExist, err)
c.NotFoundOrError(gitutil.NewError(err), "get .editorconfig")
return
}
fileName := c.Params("filename")
def, err := ec.GetDefinitionForFilename(fileName)
if err != nil {
c.ServerError("get definition for filename", err)
c.Error(err, "get definition for filename")
return
}
if def == nil {

51
internal/route/api/v1/repo/hook.go
View File

@ -5,46 +5,47 @@
package repo
import (
"github.com/json-iterator/go"
"github.com/unknwon/com"
convert2 "gogs.io/gogs/internal/route/api/v1/convert"
"net/http"
api "github.com/gogs/go-gogs-client"
"github.com/json-iterator/go"
"github.com/pkg/errors"
"github.com/unknwon/com"
"gogs.io/gogs/internal/context"
"gogs.io/gogs/internal/db"
"gogs.io/gogs/internal/db/errors"
"gogs.io/gogs/internal/route/api/v1/convert"
)
// https://github.com/gogs/go-gogs-client/wiki/Repositories#list-hooks
func ListHooks(c *context.APIContext) {
hooks, err := db.GetWebhooksByRepoID(c.Repo.Repository.ID)
if err != nil {
c.Error(500, "GetWebhooksByRepoID", err)
c.Errorf(err, "get webhooks by repository ID")
return
}
apiHooks := make([]*api.Hook, len(hooks))
for i := range hooks {
apiHooks[i] = convert2.ToHook(c.Repo.RepoLink, hooks[i])
apiHooks[i] = convert.ToHook(c.Repo.RepoLink, hooks[i])
}
c.JSON(200, &apiHooks)
c.JSONSuccess(&apiHooks)
}
// https://github.com/gogs/go-gogs-client/wiki/Repositories#create-a-hook
func CreateHook(c *context.APIContext, form api.CreateHookOption) {
if !db.IsValidHookTaskType(form.Type) {
c.Error(422, "", "Invalid hook type")
c.ErrorStatus(http.StatusUnprocessableEntity, errors.New("Invalid hook type."))
return
}
for _, name := range []string{"url", "content_type"} {
if _, ok := form.Config[name]; !ok {
c.Error(422, "", "Missing config option: "+name)
c.ErrorStatus(http.StatusUnprocessableEntity, errors.New("Missing config option: "+name))
return
}
}
if !db.IsValidHookContentType(form.Config["content_type"]) {
c.Error(422, "", "Invalid content type")
c.ErrorStatus(http.StatusUnprocessableEntity, errors.New("Invalid content type."))
return
}
@ -75,7 +76,7 @@ func CreateHook(c *context.APIContext, form api.CreateHookOption) {
if w.HookTaskType == db.SLACK {
channel, ok := form.Config["channel"]
if !ok {
c.Error(422, "", "Missing config option: channel")
c.ErrorStatus(http.StatusUnprocessableEntity, errors.New("Missing config option: channel"))
return
}
meta, err := jsoniter.Marshal(&db.SlackMeta{
@ -85,32 +86,28 @@ func CreateHook(c *context.APIContext, form api.CreateHookOption) {
Color: form.Config["color"],
})
if err != nil {
c.Error(500, "slack: JSON marshal failed", err)
c.Errorf(err, "marshal JSON")
return
}
w.Meta = string(meta)
}
if err := w.UpdateEvent(); err != nil {
c.Error(500, "UpdateEvent", err)
c.Errorf(err, "update event")
return
} else if err := db.CreateWebhook(w); err != nil {
c.Error(500, "CreateWebhook", err)
c.Errorf(err, "create webhook")
return
}
c.JSON(201, convert2.ToHook(c.Repo.RepoLink, w))
c.JSON(http.StatusCreated, convert.ToHook(c.Repo.RepoLink, w))
}
// https://github.com/gogs/go-gogs-client/wiki/Repositories#edit-a-hook
func EditHook(c *context.APIContext, form api.EditHookOption) {
w, err := db.GetWebhookOfRepoByID(c.Repo.Repository.ID, c.ParamsInt64(":id"))
if err != nil {
if errors.IsWebhookNotExist(err) {
c.Status(404)
} else {
c.Error(500, "GetWebhookOfRepoByID", err)
}
c.NotFoundOrError(err, "get webhook of repository by ID")
return
}
@ -120,7 +117,7 @@ func EditHook(c *context.APIContext, form api.EditHookOption) {
}
if ct, ok := form.Config["content_type"]; ok {
if !db.IsValidHookContentType(ct) {
c.Error(422, "", "Invalid content type")
c.ErrorStatus(http.StatusUnprocessableEntity, errors.New("Invalid content type."))
return
}
w.ContentType = db.ToHookContentType(ct)
@ -135,7 +132,7 @@ func EditHook(c *context.APIContext, form api.EditHookOption) {
Color: form.Config["color"],
})
if err != nil {
c.Error(500, "slack: JSON marshal failed", err)
c.Errorf(err, "marshal JSON")
return
}
w.Meta = string(meta)
@ -159,7 +156,7 @@ func EditHook(c *context.APIContext, form api.EditHookOption) {
w.PullRequest = com.IsSliceContainsStr(form.Events, string(db.HOOK_EVENT_PULL_REQUEST))
w.Release = com.IsSliceContainsStr(form.Events, string(db.HOOK_EVENT_RELEASE))
if err = w.UpdateEvent(); err != nil {
c.Error(500, "UpdateEvent", err)
c.Errorf(err, "update event")
return
}
@ -168,18 +165,18 @@ func EditHook(c *context.APIContext, form api.EditHookOption) {
}
if err := db.UpdateWebhook(w); err != nil {
c.Error(500, "UpdateWebhook", err)
c.Errorf(err, "update webhook")
return
}
c.JSON(200, convert2.ToHook(c.Repo.RepoLink, w))
c.JSONSuccess(convert.ToHook(c.Repo.RepoLink, w))
}
func DeleteHook(c *context.APIContext) {
if err := db.DeleteWebhookOfRepoByID(c.Repo.Repository.ID, c.ParamsInt64(":id")); err != nil {
c.Error(500, "DeleteWebhookByRepoID", err)
c.Errorf(err, "delete webhook of repository by ID")
return
}
c.Status(204)
c.NoContent()
}

41
internal/route/api/v1/repo/issue.go
View File

@ -11,22 +11,21 @@ import (
api "github.com/gogs/go-gogs-client"
"gogs.io/gogs/internal/conf"
"gogs.io/gogs/internal/context"
"gogs.io/gogs/internal/db"
"gogs.io/gogs/internal/db/errors"
"gogs.io/gogs/internal/conf"
)
func listIssues(c *context.APIContext, opts *db.IssuesOptions) {
issues, err := db.Issues(opts)
if err != nil {
c.ServerError("Issues", err)
c.Error(err, "list issues")
return
}
count, err := db.IssuesCount(opts)
if err != nil {
c.ServerError("IssuesCount", err)
c.Error(err, "count issues")
return
}
@ -34,7 +33,7 @@ func listIssues(c *context.APIContext, opts *db.IssuesOptions) {
apiIssues := make([]*api.Issue, len(issues))
for i := range issues {
if err = issues[i].LoadAttributes(); err != nil {
c.ServerError("LoadAttributes", err)
c.Error(err, "load attributes")
return
}
apiIssues[i] = issues[i].APIFormat()
@ -67,7 +66,7 @@ func ListIssues(c *context.APIContext) {
func GetIssue(c *context.APIContext) {
issue, err := db.GetIssueByIndex(c.Repo.Repository.ID, c.ParamsInt64(":index"))
if err != nil {
c.NotFoundOrServerError("GetIssueByIndex", errors.IsIssueNotExist, err)
c.NotFoundOrError(err, "get issue by index")
return
}
c.JSONSuccess(issue.APIFormat())
@ -86,10 +85,10 @@ func CreateIssue(c *context.APIContext, form api.CreateIssueOption) {
if len(form.Assignee) > 0 {
assignee, err := db.GetUserByName(form.Assignee)
if err != nil {
if errors.IsUserNotExist(err) {
c.Error(http.StatusUnprocessableEntity, "", fmt.Sprintf("assignee does not exist: [name: %s]", form.Assignee))
if db.IsErrUserNotExist(err) {
c.ErrorStatus(http.StatusUnprocessableEntity, fmt.Errorf("assignee does not exist: [name: %s]", form.Assignee))
} else {
c.ServerError("GetUserByName", err)
c.Error(err, "get user by name")
}
return
}
@ -101,13 +100,13 @@ func CreateIssue(c *context.APIContext, form api.CreateIssueOption) {
}
if err := db.NewIssue(c.Repo.Repository, issue, form.Labels, nil); err != nil {
c.ServerError("NewIssue", err)
c.Error(err, "new issue")
return
}
if form.Closed {
if err := issue.ChangeStatus(c.User, c.Repo.Repository, true); err != nil {
c.ServerError("ChangeStatus", err)
c.Error(err, "change status to closed")
return
}
}
@ -116,7 +115,7 @@ func CreateIssue(c *context.APIContext, form api.CreateIssueOption) {
var err error
issue, err = db.GetIssueByID(issue.ID)
if err != nil {
c.ServerError("GetIssueByID", err)
c.Error(err, "get issue by ID")
return
}
c.JSON(http.StatusCreated, issue.APIFormat())
@ -125,7 +124,7 @@ func CreateIssue(c *context.APIContext, form api.CreateIssueOption) {
func EditIssue(c *context.APIContext, form api.EditIssueOption) {
issue, err := db.GetIssueByIndex(c.Repo.Repository.ID, c.ParamsInt64(":index"))
if err != nil {
c.NotFoundOrServerError("GetIssueByIndex", errors.IsIssueNotExist, err)
c.NotFoundOrError(err, "get issue by index")
return
}
@ -148,10 +147,10 @@ func EditIssue(c *context.APIContext, form api.EditIssueOption) {
} else {
assignee, err := db.GetUserByName(*form.Assignee)
if err != nil {
if errors.IsUserNotExist(err) {
c.Error(http.StatusUnprocessableEntity, "", fmt.Sprintf("assignee does not exist: [name: %s]", *form.Assignee))
if db.IsErrUserNotExist(err) {
c.ErrorStatus(http.StatusUnprocessableEntity, fmt.Errorf("assignee does not exist: [name: %s]", *form.Assignee))
} else {
c.ServerError("GetUserByName", err)
c.Error(err, "get user by name")
}
return
}
@ -159,7 +158,7 @@ func EditIssue(c *context.APIContext, form api.EditIssueOption) {
}
if err = db.UpdateIssueUserByAssignee(issue); err != nil {
c.ServerError("UpdateIssueUserByAssignee", err)
c.Error(err, "update issue user by assignee")
return
}
}
@ -168,18 +167,18 @@ func EditIssue(c *context.APIContext, form api.EditIssueOption) {
oldMilestoneID := issue.MilestoneID
issue.MilestoneID = *form.Milestone
if err = db.ChangeMilestoneAssign(c.User, issue, oldMilestoneID); err != nil {
c.ServerError("ChangeMilestoneAssign", err)
c.Error(err, "change milestone assign")
return
}
}
if err = db.UpdateIssue(issue); err != nil {
c.ServerError("UpdateIssue", err)
c.Error(err, "update issue")
return
}
if form.State != nil {
if err = issue.ChangeStatus(c.User, c.Repo.Repository, api.STATE_CLOSED == api.StateType(*form.State)); err != nil {
c.ServerError("ChangeStatus", err)
c.Error(err, "change status")
return
}
}
@ -187,7 +186,7 @@ func EditIssue(c *context.APIContext, form api.EditIssueOption) {
// Refetch from database to assign some automatic values
issue, err = db.GetIssueByID(issue.ID)
if err != nil {
c.ServerError("GetIssueByID", err)
c.Error(err, "get issue by ID")
return
}
c.JSON(http.StatusCreated, issue.APIFormat())

22
internal/route/api/v1/repo/issue_comment.go
View File

@ -19,7 +19,7 @@ func ListIssueComments(c *context.APIContext) {
var err error
since, err = time.Parse(time.RFC3339, c.Query("since"))
if err != nil {
c.Error(http.StatusUnprocessableEntity, "", err)
c.ErrorStatus(http.StatusUnprocessableEntity, err)
return
}
}
@ -27,13 +27,13 @@ func ListIssueComments(c *context.APIContext) {
// comments,err:=db.GetCommentsByIssueIDSince(, since)
issue, err := db.GetRawIssueByIndex(c.Repo.Repository.ID, c.ParamsInt64(":index"))
if err != nil {
c.ServerError("GetRawIssueByIndex", err)
c.Error(err, "get raw issue by index")
return
}
comments, err := db.GetCommentsByIssueIDSince(issue.ID, since.Unix())
if err != nil {
c.ServerError("GetCommentsByIssueIDSince", err)
c.Error(err, "get comments by issue ID")
return
}
@ -50,14 +50,14 @@ func ListRepoIssueComments(c *context.APIContext) {
var err error
since, err = time.Parse(time.RFC3339, c.Query("since"))
if err != nil {
c.Error(http.StatusUnprocessableEntity, "", err)
c.ErrorStatus(http.StatusUnprocessableEntity, err)
return
}
}
comments, err := db.GetCommentsByRepoIDSince(c.Repo.Repository.ID, since.Unix())
if err != nil {
c.ServerError("GetCommentsByRepoIDSince", err)
c.Error(err, "get comments by repository ID")
return
}
@ -71,13 +71,13 @@ func ListRepoIssueComments(c *context.APIContext) {
func CreateIssueComment(c *context.APIContext, form api.CreateIssueCommentOption) {
issue, err := db.GetIssueByIndex(c.Repo.Repository.ID, c.ParamsInt64(":index"))
if err != nil {
c.ServerError("GetIssueByIndex", err)
c.Error(err, "get issue by index")
return
}
comment, err := db.CreateIssueComment(c.User, c.Repo.Repository, issue, form.Body, nil)
if err != nil {
c.ServerError("CreateIssueComment", err)
c.Error(err, "create issue comment")
return
}
@ -87,7 +87,7 @@ func CreateIssueComment(c *context.APIContext, form api.CreateIssueCommentOption
func EditIssueComment(c *context.APIContext, form api.EditIssueCommentOption) {
comment, err := db.GetCommentByID(c.ParamsInt64(":id"))
if err != nil {
c.NotFoundOrServerError("GetCommentByID", db.IsErrCommentNotExist, err)
c.NotFoundOrError(err, "get comment by ID")
return
}
@ -102,7 +102,7 @@ func EditIssueComment(c *context.APIContext, form api.EditIssueCommentOption) {
oldContent := comment.Content
comment.Content = form.Body
if err := db.UpdateComment(c.User, comment, oldContent); err != nil {
c.ServerError("UpdateComment", err)
c.Error(err, "update comment")
return
}
c.JSONSuccess(comment.APIFormat())
@ -111,7 +111,7 @@ func EditIssueComment(c *context.APIContext, form api.EditIssueCommentOption) {
func DeleteIssueComment(c *context.APIContext) {
comment, err := db.GetCommentByID(c.ParamsInt64(":id"))
if err != nil {
c.NotFoundOrServerError("GetCommentByID", db.IsErrCommentNotExist, err)
c.NotFoundOrError(err, "get comment by ID")
return
}
@ -124,7 +124,7 @@ func DeleteIssueComment(c *context.APIContext) {
}
if err = db.DeleteCommentByID(c.User, comment.ID); err != nil {
c.ServerError("DeleteCommentByID", err)
c.Error(err, "delete comment by ID")
return
}
c.NoContent()

31
internal/route/api/v1/repo/issue_label.go
View File

@ -11,13 +11,12 @@ import (
"gogs.io/gogs/internal/context"
"gogs.io/gogs/internal/db"
"gogs.io/gogs/internal/db/errors"
)
func ListIssueLabels(c *context.APIContext) {
issue, err := db.GetIssueByIndex(c.Repo.Repository.ID, c.ParamsInt64(":index"))
if err != nil {
c.NotFoundOrServerError("GetIssueByIndex", errors.IsIssueNotExist, err)
c.NotFoundOrError(err, "get issue by index")
return
}
@ -31,24 +30,24 @@ func ListIssueLabels(c *context.APIContext) {
func AddIssueLabels(c *context.APIContext, form api.IssueLabelsOption) {
issue, err := db.GetIssueByIndex(c.Repo.Repository.ID, c.ParamsInt64(":index"))
if err != nil {
c.NotFoundOrServerError("GetIssueByIndex", errors.IsIssueNotExist, err)
c.NotFoundOrError(err, "get issue by index")
return
}
labels, err := db.GetLabelsInRepoByIDs(c.Repo.Repository.ID, form.Labels)
if err != nil {
c.ServerError("GetLabelsInRepoByIDs", err)
c.Error(err, "get labels in repository by IDs")
return
}
if err = issue.AddLabels(c.User, labels); err != nil {
c.ServerError("AddLabels", err)
c.Error(err, "add labels")
return
}
labels, err = db.GetLabelsByIssueID(issue.ID)
if err != nil {
c.ServerError("GetLabelsByIssueID", err)
c.Error(err, "get labels by issue ID")
return
}
@ -62,22 +61,22 @@ func AddIssueLabels(c *context.APIContext, form api.IssueLabelsOption) {
func DeleteIssueLabel(c *context.APIContext) {
issue, err := db.GetIssueByIndex(c.Repo.Repository.ID, c.ParamsInt64(":index"))
if err != nil {
c.NotFoundOrServerError("GetIssueByIndex", errors.IsIssueNotExist, err)
c.NotFoundOrError(err, "get issue by index")
return
}
label, err := db.GetLabelOfRepoByID(c.Repo.Repository.ID, c.ParamsInt64(":id"))
if err != nil {
if db.IsErrLabelNotExist(err) {
c.Error(http.StatusUnprocessableEntity, "", err)
c.ErrorStatus(http.StatusUnprocessableEntity, err)
} else {
c.ServerError("GetLabelInRepoByID", err)
c.Error(err, "get label of repository by ID")
}
return
}
if err := db.DeleteIssueLabel(issue, label); err != nil {
c.ServerError("DeleteIssueLabel", err)
c.Error(err, "delete issue label")
return
}
@ -87,24 +86,24 @@ func DeleteIssueLabel(c *context.APIContext) {
func ReplaceIssueLabels(c *context.APIContext, form api.IssueLabelsOption) {
issue, err := db.GetIssueByIndex(c.Repo.Repository.ID, c.ParamsInt64(":index"))
if err != nil {
c.NotFoundOrServerError("GetIssueByIndex", errors.IsIssueNotExist, err)
c.NotFoundOrError(err, "get issue by index")
return
}
labels, err := db.GetLabelsInRepoByIDs(c.Repo.Repository.ID, form.Labels)
if err != nil {
c.ServerError("GetLabelsInRepoByIDs", err)
c.Error(err, "get labels in repository by IDs")
return
}
if err := issue.ReplaceLabels(labels); err != nil {
c.ServerError("ReplaceLabels", err)
c.Error(err, "replace labels")
return
}
labels, err = db.GetLabelsByIssueID(issue.ID)
if err != nil {
c.ServerError("GetLabelsByIssueID", err)
c.Error(err, "get labels by issue ID")
return
}
@ -118,12 +117,12 @@ func ReplaceIssueLabels(c *context.APIContext, form api.IssueLabelsOption) {
func ClearIssueLabels(c *context.APIContext) {
issue, err := db.GetIssueByIndex(c.Repo.Repository.ID, c.ParamsInt64(":index"))
if err != nil {
c.NotFoundOrServerError("GetIssueByIndex", errors.IsIssueNotExist, err)
c.NotFoundOrError(err, "get issue by index")
return
}
if err := issue.ClearLabels(c.User); err != nil {
c.ServerError("ClearLabels", err)
c.Error(err, "clear labels")
return
}

41
internal/route/api/v1/repo/key.go
View File

@ -5,14 +5,15 @@
package repo
import (
"fmt"
convert2 "gogs.io/gogs/internal/route/api/v1/convert"
"net/http"
api "github.com/gogs/go-gogs-client"
"github.com/pkg/errors"
"gogs.io/gogs/internal/conf"
"gogs.io/gogs/internal/context"
"gogs.io/gogs/internal/db"
"gogs.io/gogs/internal/route/api/v1/convert"
)
func composeDeployKeysAPILink(repoPath string) string {
@ -23,7 +24,7 @@ func composeDeployKeysAPILink(repoPath string) string {
func ListDeployKeys(c *context.APIContext) {
keys, err := db.ListDeployKeys(c.Repo.Repository.ID)
if err != nil {
c.Error(500, "ListDeployKeys", err)
c.Error(err, "list deploy keys")
return
}
@ -31,52 +32,48 @@ func ListDeployKeys(c *context.APIContext) {
apiKeys := make([]*api.DeployKey, len(keys))
for i := range keys {
if err = keys[i].GetContent(); err != nil {
c.Error(500, "GetContent", err)
c.Error(err, "get content")
return
}
apiKeys[i] = convert2.ToDeployKey(apiLink, keys[i])
apiKeys[i] = convert.ToDeployKey(apiLink, keys[i])
}
c.JSON(200, &apiKeys)
c.JSONSuccess(&apiKeys)
}
// https://github.com/gogs/go-gogs-client/wiki/Repositories-Deploy-Keys#get-a-deploy-key
func GetDeployKey(c *context.APIContext) {
key, err := db.GetDeployKeyByID(c.ParamsInt64(":id"))
if err != nil {
if db.IsErrDeployKeyNotExist(err) {
c.Status(404)
} else {
c.Error(500, "GetDeployKeyByID", err)
}
c.NotFoundOrError(err, "get deploy key by ID")
return
}
if err = key.GetContent(); err != nil {
c.Error(500, "GetContent", err)
c.Error(err, "get content")
return
}
apiLink := composeDeployKeysAPILink(c.Repo.Owner.Name + "/" + c.Repo.Repository.Name)
c.JSON(200, convert2.ToDeployKey(apiLink, key))
c.JSONSuccess(convert.ToDeployKey(apiLink, key))
}
func HandleCheckKeyStringError(c *context.APIContext, err error) {
if db.IsErrKeyUnableVerify(err) {
c.Error(422, "", "Unable to verify key content")
c.ErrorStatus(http.StatusUnprocessableEntity, errors.New("Unable to verify key content"))
} else {
c.Error(422, "", fmt.Errorf("Invalid key content: %v", err))
c.ErrorStatus(http.StatusUnprocessableEntity, errors.Wrap(err, "Invalid key content: %v"))
}
}
func HandleAddKeyError(c *context.APIContext, err error) {
switch {
case db.IsErrKeyAlreadyExist(err):
c.Error(422, "", "Key content has been used as non-deploy key")
c.ErrorStatus(http.StatusUnprocessableEntity, errors.New("Key content has been used as non-deploy key"))
case db.IsErrKeyNameAlreadyUsed(err):
c.Error(422, "", "Key title has been used")
c.ErrorStatus(http.StatusUnprocessableEntity, errors.New("Key title has been used"))
default:
c.Error(500, "AddKey", err)
c.Error(err, "add key")
}
}
@ -96,19 +93,19 @@ func CreateDeployKey(c *context.APIContext, form api.CreateKeyOption) {
key.Content = content
apiLink := composeDeployKeysAPILink(c.Repo.Owner.Name + "/" + c.Repo.Repository.Name)
c.JSON(201, convert2.ToDeployKey(apiLink, key))
c.JSON(http.StatusCreated, convert.ToDeployKey(apiLink, key))
}
// https://github.com/gogs/go-gogs-client/wiki/Repositories-Deploy-Keys#remove-a-deploy-key
func DeleteDeploykey(c *context.APIContext) {
if err := db.DeleteDeployKey(c.User, c.ParamsInt64(":id")); err != nil {
if db.IsErrKeyAccessDenied(err) {
c.Error(403, "", "You do not have access to this key")
c.ErrorStatus(http.StatusForbidden, errors.New("You do not have access to this key"))
} else {
c.Error(500, "DeleteDeployKey", err)
c.Error(err, "delete deploy key")
}
return
}
c.Status(204)
c.NoContent()
}

15
internal/route/api/v1/repo/label.go
View File

@ -7,9 +7,8 @@ package repo
import (
"net/http"
"github.com/unknwon/com"
api "github.com/gogs/go-gogs-client"
"github.com/unknwon/com"
"gogs.io/gogs/internal/context"
"gogs.io/gogs/internal/db"
@ -18,7 +17,7 @@ import (
func ListLabels(c *context.APIContext) {
labels, err := db.GetLabelsByRepoID(c.Repo.Repository.ID)
if err != nil {
c.ServerError("GetLabelsByRepoID", err)
c.Error(err, "get labels by repository ID")
return
}
@ -39,7 +38,7 @@ func GetLabel(c *context.APIContext) {
label, err = db.GetLabelOfRepoByName(c.Repo.Repository.ID, idStr)
}
if err != nil {
c.NotFoundOrServerError("GetLabel", db.IsErrLabelNotExist, err)
c.NotFoundOrError(err, "get label")
return
}
@ -53,7 +52,7 @@ func CreateLabel(c *context.APIContext, form api.CreateLabelOption) {
RepoID: c.Repo.Repository.ID,
}
if err := db.NewLabels(label); err != nil {
c.ServerError("NewLabel", err)
c.Error(err, "new labels")
return
}
c.JSON(http.StatusCreated, label.APIFormat())
@ -62,7 +61,7 @@ func CreateLabel(c *context.APIContext, form api.CreateLabelOption) {
func EditLabel(c *context.APIContext, form api.EditLabelOption) {
label, err := db.GetLabelOfRepoByID(c.Repo.Repository.ID, c.ParamsInt64(":id"))
if err != nil {
c.NotFoundOrServerError("GetLabelOfRepoByID", db.IsErrLabelNotExist, err)
c.NotFoundOrError(err, "get label of repository by ID")
return
}
@ -73,7 +72,7 @@ func EditLabel(c *context.APIContext, form api.EditLabelOption) {
label.Color = *form.Color
}
if err := db.UpdateLabel(label); err != nil {
c.ServerError("UpdateLabel", err)
c.Error(err, "update label")
return
}
c.JSONSuccess(label.APIFormat())
@ -81,7 +80,7 @@ func EditLabel(c *context.APIContext, form api.EditLabelOption) {
func DeleteLabel(c *context.APIContext) {
if err := db.DeleteLabel(c.Repo.Repository.ID, c.ParamsInt64(":id")); err != nil {
c.ServerError("DeleteLabel", err)
c.Error(err, "delete label")
return
}

14
internal/route/api/v1/repo/milestone.go
View File

@ -17,7 +17,7 @@ import (
func ListMilestones(c *context.APIContext) {
milestones, err := db.GetMilestonesByRepoID(c.Repo.Repository.ID)
if err != nil {
c.ServerError("GetMilestonesByRepoID", err)
c.Error(err, "get milestones by repository ID")
return
}
@ -31,7 +31,7 @@ func ListMilestones(c *context.APIContext) {
func GetMilestone(c *context.APIContext) {
milestone, err := db.GetMilestoneByRepoID(c.Repo.Repository.ID, c.ParamsInt64(":id"))
if err != nil {
c.NotFoundOrServerError("GetMilestoneByRepoID", db.IsErrMilestoneNotExist, err)
c.NotFoundOrError(err, "get milestone by repository ID")
return
}
c.JSONSuccess(milestone.APIFormat())
@ -51,7 +51,7 @@ func CreateMilestone(c *context.APIContext, form api.CreateMilestoneOption) {
}
if err := db.NewMilestone(milestone); err != nil {
c.ServerError("NewMilestone", err)
c.Error(err, "new milestone")
return
}
c.JSON(http.StatusCreated, milestone.APIFormat())
@ -60,7 +60,7 @@ func CreateMilestone(c *context.APIContext, form api.CreateMilestoneOption) {
func EditMilestone(c *context.APIContext, form api.EditMilestoneOption) {
milestone, err := db.GetMilestoneByRepoID(c.Repo.Repository.ID, c.ParamsInt64(":id"))
if err != nil {
c.NotFoundOrServerError("GetMilestoneByRepoID", db.IsErrMilestoneNotExist, err)
c.NotFoundOrError(err, "get milestone by repository ID")
return
}
@ -76,11 +76,11 @@ func EditMilestone(c *context.APIContext, form api.EditMilestoneOption) {
if form.State != nil {
if err = milestone.ChangeStatus(api.STATE_CLOSED == api.StateType(*form.State)); err != nil {
c.ServerError("ChangeStatus", err)
c.Error(err, "change status")
return
}
} else if err = db.UpdateMilestone(milestone); err != nil {
c.ServerError("UpdateMilestone", err)
c.Error(err, "update milestone")
return
}
@ -89,7 +89,7 @@ func EditMilestone(c *context.APIContext, form api.EditMilestoneOption) {
func DeleteMilestone(c *context.APIContext) {
if err := db.DeleteMilestoneOfRepoByID(c.Repo.Repository.ID, c.ParamsInt64(":id")); err != nil {
c.ServerError("DeleteMilestoneByRepoID", err)
c.Error(err, "delete milestone of repository by ID")
return
}
c.NoContent()

72
internal/route/api/v1/repo/repo.go
View File

@ -5,18 +5,16 @@
package repo
import (
"fmt"
"net/http"
"path"
log "unknwon.dev/clog/v2"
api "github.com/gogs/go-gogs-client"
"github.com/pkg/errors"
log "unknwon.dev/clog/v2"
"gogs.io/gogs/internal/conf"
"gogs.io/gogs/internal/context"
"gogs.io/gogs/internal/db"
"gogs.io/gogs/internal/db/errors"
"gogs.io/gogs/internal/form"
"gogs.io/gogs/internal/route/api/v1/convert"
)
@ -81,7 +79,7 @@ func Search(c *context.APIContext) {
func listUserRepositories(c *context.APIContext, username string) {
user, err := db.GetUserByName(username)
if err != nil {
c.NotFoundOrServerError("GetUserByName", errors.IsUserNotExist, err)
c.NotFoundOrError(err, "get user by name")
return
}
@ -99,12 +97,12 @@ func listUserRepositories(c *context.APIContext, username string) {
})
}
if err != nil {
c.ServerError("GetUserRepositories", err)
c.Error(err, "get user repositories")
return
}
if err = db.RepositoryList(ownRepos).LoadAttributes(); err != nil {
c.ServerError("LoadAttributes(ownRepos)", err)
c.Error(err, "load attributes")
return
}
@ -120,7 +118,7 @@ func listUserRepositories(c *context.APIContext, username string) {
accessibleRepos, err := user.GetRepositoryAccesses()
if err != nil {
c.ServerError("GetRepositoryAccesses", err)
c.Error(err, "get repositories accesses")
return
}
@ -169,14 +167,14 @@ func CreateUserRepo(c *context.APIContext, owner *db.User, opt api.CreateRepoOpt
if db.IsErrRepoAlreadyExist(err) ||
db.IsErrNameReserved(err) ||
db.IsErrNamePatternNotAllowed(err) {
c.Error(http.StatusUnprocessableEntity, "", err)
c.ErrorStatus(http.StatusUnprocessableEntity, err)
} else {
if repo != nil {
if err = db.DeleteRepository(c.User.ID, repo.ID); err != nil {
log.Error("DeleteRepository: %v", err)
log.Error("Failed to delete repository: %v", err)
}
}
c.ServerError("CreateRepository", err)
c.Error(err, "create repository")
}
return
}
@ -187,7 +185,7 @@ func CreateUserRepo(c *context.APIContext, owner *db.User, opt api.CreateRepoOpt
func Create(c *context.APIContext, opt api.CreateRepoOption) {
// Shouldn't reach this condition, but just in case.
if c.User.IsOrganization() {
c.Error(http.StatusUnprocessableEntity, "", "not allowed creating repository for organization")
c.ErrorStatus(http.StatusUnprocessableEntity, errors.New("Not allowed to create repository for organization."))
return
}
CreateUserRepo(c, c.User, opt)
@ -196,12 +194,12 @@ func Create(c *context.APIContext, opt api.CreateRepoOption) {
func CreateOrgRepo(c *context.APIContext, opt api.CreateRepoOption) {
org, err := db.GetOrgByName(c.Params(":org"))
if err != nil {
c.NotFoundOrServerError("GetOrgByName", errors.IsUserNotExist, err)
c.NotFoundOrError(err, "get organization by name")
return
}
if !org.IsOwnedBy(c.User.ID) {
c.Error(http.StatusForbidden, "", "given user is not owner of organization")
c.ErrorStatus(http.StatusForbidden, errors.New("Given user is not owner of organization."))
return
}
CreateUserRepo(c, org, opt)
@ -214,28 +212,28 @@ func Migrate(c *context.APIContext, f form.MigrateRepo) {
if f.Uid != ctxUser.ID {
org, err := db.GetUserByID(f.Uid)
if err != nil {
if errors.IsUserNotExist(err) {
c.Error(http.StatusUnprocessableEntity, "", err)
if db.IsErrUserNotExist(err) {
c.ErrorStatus(http.StatusUnprocessableEntity, err)
} else {
c.Error(http.StatusInternalServerError, "GetUserByID", err)
c.Error(err, "get user by ID")
}
return
} else if !org.IsOrganization() && !c.User.IsAdmin {
c.Error(http.StatusForbidden, "", "given user is not an organization")
c.ErrorStatus(http.StatusForbidden, errors.New("Given user is not an organization."))
return
}
ctxUser = org
}
if c.HasError() {
c.Error(http.StatusUnprocessableEntity, "", c.GetErrMsg())
c.ErrorStatus(http.StatusUnprocessableEntity, errors.New(c.GetErrMsg()))
return
}
if ctxUser.IsOrganization() && !c.User.IsAdmin {
// Check ownership of organization.
if !ctxUser.IsOwnedBy(c.User.ID) {
c.Error(http.StatusForbidden, "", "Given user is not owner of organization")
c.ErrorStatus(http.StatusForbidden, errors.New("Given user is not owner of organization."))
return
}
}
@ -246,16 +244,16 @@ func Migrate(c *context.APIContext, f form.MigrateRepo) {
addrErr := err.(db.ErrInvalidCloneAddr)
switch {
case addrErr.IsURLError:
c.Error(http.StatusUnprocessableEntity, "", err)
c.ErrorStatus(http.StatusUnprocessableEntity, err)
case addrErr.IsPermissionDenied:
c.Error(http.StatusUnprocessableEntity, "", "you are not allowed to import local repositories")
c.ErrorStatus(http.StatusUnprocessableEntity, errors.New("You are not allowed to import local repositories."))
case addrErr.IsInvalidPath:
c.Error(http.StatusUnprocessableEntity, "", "invalid local path, it does not exist or not a directory")
c.ErrorStatus(http.StatusUnprocessableEntity, errors.New("Invalid local path, it does not exist or not a directory."))
default:
c.ServerError("ParseRemoteAddr", fmt.Errorf("unknown error type (ErrInvalidCloneAddr): %v", err))
c.Error(err, "unexpected error")
}
} else {
c.ServerError("ParseRemoteAddr", err)
c.Error(err, "parse remote address")
}
return
}
@ -274,10 +272,10 @@ func Migrate(c *context.APIContext, f form.MigrateRepo) {
}
}
if errors.IsReachLimitOfRepo(err) {
c.Error(http.StatusUnprocessableEntity, "", err)
if db.IsErrReachLimitOfRepo(err) {
c.ErrorStatus(http.StatusUnprocessableEntity, err)
} else {
c.ServerError("MigrateRepository", errors.New(db.HandleMirrorCredentials(err.Error(), true)))
c.Error(errors.New(db.HandleMirrorCredentials(err.Error(), true)), "migrate repository")
}
return
}
@ -290,17 +288,17 @@ func Migrate(c *context.APIContext, f form.MigrateRepo) {
func parseOwnerAndRepo(c *context.APIContext) (*db.User, *db.Repository) {
owner, err := db.GetUserByName(c.Params(":username"))
if err != nil {
if errors.IsUserNotExist(err) {
c.Error(http.StatusUnprocessableEntity, "", err)
if db.IsErrUserNotExist(err) {
c.ErrorStatus(http.StatusUnprocessableEntity, err)
} else {
c.ServerError("GetUserByName", err)
c.Error(err, "get user by name")
}
return nil, nil
}
repo, err := db.GetRepositoryByName(owner.ID, c.Params(":reponame"))
if err != nil {
c.NotFoundOrServerError("GetRepositoryByName", errors.IsRepoNotExist, err)
c.NotFoundOrError(err, "get repository by name")
return nil, nil
}
@ -327,12 +325,12 @@ func Delete(c *context.APIContext) {
}
if owner.IsOrganization() && !owner.IsOwnedBy(c.User.ID) {
c.Error(http.StatusForbidden, "", "given user is not owner of organization")
c.ErrorStatus(http.StatusForbidden, errors.New("Given user is not owner of organization."))
return
}
if err := db.DeleteRepository(owner.ID, repo.ID); err != nil {
c.ServerError("DeleteRepository", err)
c.Error(err, "delete repository")
return
}
@ -343,14 +341,14 @@ func Delete(c *context.APIContext) {
func ListForks(c *context.APIContext) {
forks, err := c.Repo.Repository.GetForks()
if err != nil {
c.ServerError("GetForks", err)
c.Error(err, "get forks")
return
}
apiForks := make([]*api.Repository, len(forks))
for i := range forks {
if err := forks[i].GetOwner(); err != nil {
c.ServerError("GetOwner", err)
c.Error(err, "get owner")
return
}
apiForks[i] = forks[i].APIFormat(&api.Permission{
@ -386,7 +384,7 @@ func IssueTracker(c *context.APIContext, form api.EditIssueTrackerOption) {
}
if err := db.UpdateRepository(repo, false); err != nil {
c.ServerError("UpdateRepository", err)
c.Error(err, "update repository")
return
}

6
internal/route/api/v1/repo/tree.go
View File

@ -16,20 +16,20 @@ import (
func GetRepoGitTree(c *context.APIContext) {
gitRepo, err := git.Open(c.Repo.Repository.RepoPath())
if err != nil {
c.ServerError("open repository", err)
c.Error(err, "open repository")
return
}
sha := c.Params(":sha")
tree, err := gitRepo.LsTree(sha)
if err != nil {
c.NotFoundOrServerError("get tree", gitutil.IsErrRevisionNotExist, err)
c.NotFoundOrError(gitutil.NewError(err), "get tree")
return
}
entries, err := tree.Entries()
if err != nil {
c.ServerError("list entries", err)
c.Error(err, "list entries")
return
}

6
internal/route/api/v1/user/app.go
View File

@ -17,7 +17,7 @@ import (
func ListAccessTokens(c *context.APIContext) {
tokens, err := db.ListAccessTokens(c.User.ID)
if err != nil {
c.ServerError("ListAccessTokens", err)
c.Error(err, "list access tokens")
return
}
@ -35,9 +35,9 @@ func CreateAccessToken(c *context.APIContext, form api.CreateAccessTokenOption)
}
if err := db.NewAccessToken(t); err != nil {
if errors.IsAccessTokenNameAlreadyExist(err) {
c.Error(http.StatusUnprocessableEntity, "", err)
c.ErrorStatus(http.StatusUnprocessableEntity, err)
} else {
c.ServerError("NewAccessToken", err)
c.Error(err, "new access token")
}
return
}

15
internal/route/api/v1/user/email.go
View File

@ -5,25 +5,26 @@
package user
import (
convert2 "gogs.io/gogs/internal/route/api/v1/convert"
"net/http"
api "github.com/gogs/go-gogs-client"
"github.com/pkg/errors"
"gogs.io/gogs/internal/conf"
"gogs.io/gogs/internal/context"
"gogs.io/gogs/internal/db"
"gogs.io/gogs/internal/route/api/v1/convert"
)
func ListEmails(c *context.APIContext) {
emails, err := db.GetEmailAddresses(c.User.ID)
if err != nil {
c.ServerError("GetEmailAddresses", err)
c.Error(err, "get email addresses")
return
}
apiEmails := make([]*api.Email, len(emails))
for i := range emails {
apiEmails[i] = convert2.ToEmail(emails[i])
apiEmails[i] = convert.ToEmail(emails[i])
}
c.JSONSuccess(&apiEmails)
}
@ -45,16 +46,16 @@ func AddEmail(c *context.APIContext, form api.CreateEmailOption) {
if err := db.AddEmailAddresses(emails); err != nil {
if db.IsErrEmailAlreadyUsed(err) {
c.Error(http.StatusUnprocessableEntity, "", "email address has been used: "+err.(db.ErrEmailAlreadyUsed).Email)
c.ErrorStatus(http.StatusUnprocessableEntity, errors.New("email address has been used: "+err.(db.ErrEmailAlreadyUsed).Email))
} else {
c.Error(http.StatusInternalServerError, "AddEmailAddresses", err)
c.Error(err, "add email addresses")
}
return
}
apiEmails := make([]*api.Email, len(emails))
for i := range emails {
apiEmails[i] = convert2.ToEmail(emails[i])
apiEmails[i] = convert.ToEmail(emails[i])
}
c.JSON(http.StatusCreated, &apiEmails)
}
@ -74,7 +75,7 @@ func DeleteEmail(c *context.APIContext, form api.CreateEmailOption) {
}
if err := db.DeleteEmailAddresses(emails); err != nil {
c.Error(http.StatusInternalServerError, "DeleteEmailAddresses", err)
c.Error(err, "delete email addresses")
return
}
c.NoContent()

8
internal/route/api/v1/user/follower.go
View File

@ -22,7 +22,7 @@ func responseApiUsers(c *context.APIContext, users []*db.User) {
func listUserFollowers(c *context.APIContext, u *db.User) {
users, err := u.GetFollowers(c.QueryInt("page"))
if err != nil {
c.ServerError("GetUserFollowers", err)
c.Error(err, "get followers")
return
}
responseApiUsers(c, users)
@ -43,7 +43,7 @@ func ListFollowers(c *context.APIContext) {
func listUserFollowing(c *context.APIContext, u *db.User) {
users, err := u.GetFollowing(c.QueryInt("page"))
if err != nil {
c.ServerError("GetFollowing", err)
c.Error(err, "get following")
return
}
responseApiUsers(c, users)
@ -95,7 +95,7 @@ func Follow(c *context.APIContext) {
return
}
if err := db.FollowUser(c.User.ID, target.ID); err != nil {
c.ServerError("FollowUser", err)
c.Error(err, "follow user")
return
}
c.NoContent()
@ -107,7 +107,7 @@ func Unfollow(c *context.APIContext) {
return
}
if err := db.UnfollowUser(c.User.ID, target.ID); err != nil {
c.ServerError("UnfollowUser", err)
c.Error(err, "unfollow user")
return
}
c.NoContent()

29
internal/route/api/v1/user/key.go
View File

@ -5,21 +5,22 @@
package user
import (
api "github.com/gogs/go-gogs-client"
convert2 "gogs.io/gogs/internal/route/api/v1/convert"
repo2 "gogs.io/gogs/internal/route/api/v1/repo"
"net/http"
api "github.com/gogs/go-gogs-client"
"github.com/pkg/errors"
"gogs.io/gogs/internal/conf"
"gogs.io/gogs/internal/context"
"gogs.io/gogs/internal/db"
"gogs.io/gogs/internal/db/errors"
"gogs.io/gogs/internal/route/api/v1/convert"
"gogs.io/gogs/internal/route/api/v1/repo"
)
func GetUserByParamsName(c *context.APIContext, name string) *db.User {
user, err := db.GetUserByName(c.Params(name))
if err != nil {
c.NotFoundOrServerError("GetUserByName", errors.IsUserNotExist, err)
c.NotFoundOrError(err, "get user by name")
return nil
}
return user
@ -37,14 +38,14 @@ func composePublicKeysAPILink() string {
func listPublicKeys(c *context.APIContext, uid int64) {
keys, err := db.ListPublicKeys(uid)
if err != nil {
c.ServerError("ListPublicKeys", err)
c.Error(err, "list public keys")
return
}
apiLink := composePublicKeysAPILink()
apiKeys := make([]*api.PublicKey, len(keys))
for i := range keys {
apiKeys[i] = convert2.ToPublicKey(apiLink, keys[i])
apiKeys[i] = convert.ToPublicKey(apiLink, keys[i])
}
c.JSONSuccess(&apiKeys)
@ -65,29 +66,29 @@ func ListPublicKeys(c *context.APIContext) {
func GetPublicKey(c *context.APIContext) {
key, err := db.GetPublicKeyByID(c.ParamsInt64(":id"))
if err != nil {
c.NotFoundOrServerError("GetPublicKeyByID", db.IsErrKeyNotExist, err)
c.NotFoundOrError(err, "get public key by ID")
return
}
apiLink := composePublicKeysAPILink()
c.JSONSuccess(convert2.ToPublicKey(apiLink, key))
c.JSONSuccess(convert.ToPublicKey(apiLink, key))
}
// CreateUserPublicKey creates new public key to given user by ID.
func CreateUserPublicKey(c *context.APIContext, form api.CreateKeyOption, uid int64) {
content, err := db.CheckPublicKeyString(form.Key)
if err != nil {
repo2.HandleCheckKeyStringError(c, err)
repo.HandleCheckKeyStringError(c, err)
return
}
key, err := db.AddPublicKey(uid, form.Title, content)
if err != nil {
repo2.HandleAddKeyError(c, err)
repo.HandleAddKeyError(c, err)
return
}
apiLink := composePublicKeysAPILink()
c.JSON(http.StatusCreated, convert2.ToPublicKey(apiLink, key))
c.JSON(http.StatusCreated, convert.ToPublicKey(apiLink, key))
}
func CreatePublicKey(c *context.APIContext, form api.CreateKeyOption) {
@ -97,9 +98,9 @@ func CreatePublicKey(c *context.APIContext, form api.CreateKeyOption) {
func DeletePublicKey(c *context.APIContext) {
if err := db.DeletePublicKey(c.User, c.ParamsInt64(":id")); err != nil {
if db.IsErrKeyAccessDenied(err) {
c.Error(http.StatusForbidden, "", "you do not have access to this key")
c.ErrorStatus(http.StatusForbidden, errors.New("You do not have access to this key."))
} else {
c.Error(http.StatusInternalServerError, "DeletePublicKey", err)
c.Error(err, "delete public key")
}
return
}

3
internal/route/api/v1/user/user.go
View File

@ -13,7 +13,6 @@ import (
"gogs.io/gogs/internal/context"
"gogs.io/gogs/internal/db"
"gogs.io/gogs/internal/db/errors"
"gogs.io/gogs/internal/markup"
)
@ -58,7 +57,7 @@ func Search(c *context.APIContext) {
func GetInfo(c *context.APIContext) {
u, err := db.GetUserByName(c.Params(":username"))
if err != nil {
c.NotFoundOrServerError("GetUserByName", errors.IsUserNotExist, err)
c.NotFoundOrError(err, "get user by name")
return
}

2
internal/route/dev/template.go
View File

@ -20,5 +20,5 @@ func TemplatePreview(c *context.Context) {
c.Data["ResetPwdCodeLives"] = conf.Auth.ResetPasswordCodeLives / 60
c.Data["CurDbValue"] = ""
c.HTML(200, (c.Params("*")))
c.Success( (c.Params("*")))
}

14
internal/route/home.go
View File

@ -6,11 +6,11 @@ package route
import (
"github.com/unknwon/paginater"
user2 "gogs.io/gogs/internal/route/user"
"gogs.io/gogs/internal/conf"
"gogs.io/gogs/internal/context"
"gogs.io/gogs/internal/db"
"gogs.io/gogs/internal/route/user"
)
const (
@ -24,9 +24,9 @@ func Home(c *context.Context) {
if c.IsLogged {
if !c.User.IsActive && conf.Auth.RequireEmailConfirmation {
c.Data["Title"] = c.Tr("auth.active_your_account")
c.Success(user2.ACTIVATE)
c.Success(user.ACTIVATE)
} else {
user2.Dashboard(c)
user.Dashboard(c)
}
return
}
@ -61,7 +61,7 @@ func ExploreRepos(c *context.Context) {
PageSize: conf.UI.ExplorePagingNum,
})
if err != nil {
c.ServerError("SearchRepositoryByName", err)
c.Error(err, "search repository by name")
return
}
c.Data["Keyword"] = keyword
@ -69,7 +69,7 @@ func ExploreRepos(c *context.Context) {
c.Data["Page"] = paginater.New(int(count), conf.UI.ExplorePagingNum, page, 5)
if err = db.RepositoryList(repos).LoadAttributes(); err != nil {
c.ServerError("RepositoryList.LoadAttributes", err)
c.Error(err, "load attributes")
return
}
c.Data["Repos"] = repos
@ -102,7 +102,7 @@ func RenderUserSearch(c *context.Context, opts *UserSearchOptions) {
if len(keyword) == 0 {
users, err = opts.Ranger(page, opts.PageSize)
if err != nil {
c.ServerError("Ranger", err)
c.Error(err, "ranger")
return
}
count = opts.Counter()
@ -115,7 +115,7 @@ func RenderUserSearch(c *context.Context, opts *UserSearchOptions) {
PageSize: opts.PageSize,
})
if err != nil {
c.ServerError("SearchUserByName", err)
c.Error(err, "search user by name")
return
}
}

21
internal/route/org/members.go
View File

@ -11,7 +11,6 @@ import (
"gogs.io/gogs/internal/conf"
"gogs.io/gogs/internal/context"
"gogs.io/gogs/internal/db"
"gogs.io/gogs/internal/db/errors"
)
const (
@ -25,12 +24,12 @@ func Members(c *context.Context) {
c.Data["PageIsOrgMembers"] = true
if err := org.GetMembers(); err != nil {
c.Handle(500, "GetMembers", err)
c.Error(err, "get members")
return
}
c.Data["Members"] = org.Members
c.HTML(200, MEMBERS)
c.Success(MEMBERS)
}
func MembersAction(c *context.Context) {
@ -45,19 +44,19 @@ func MembersAction(c *context.Context) {
switch c.Params(":action") {
case "private":
if c.User.ID != uid && !c.Org.IsOwner {
c.Error(404)
c.NotFound()
return
}
err = db.ChangeOrgUserStatus(org.ID, uid, false)
case "public":
if c.User.ID != uid && !c.Org.IsOwner {
c.Error(404)
c.NotFound()
return
}
err = db.ChangeOrgUserStatus(org.ID, uid, true)
case "remove":
if !c.Org.IsOwner {
c.Error(404)
c.NotFound()
return
}
err = org.RemoveMember(uid)
@ -77,7 +76,7 @@ func MembersAction(c *context.Context) {
if err != nil {
log.Error("Action(%s): %v", c.Params(":action"), err)
c.JSON(200, map[string]interface{}{
c.JSONSuccess( map[string]interface{}{
"ok": false,
"err": err.Error(),
})
@ -100,17 +99,17 @@ func Invitation(c *context.Context) {
uname := c.Query("uname")
u, err := db.GetUserByName(uname)
if err != nil {
if errors.IsUserNotExist(err) {
if db.IsErrUserNotExist(err) {
c.Flash.Error(c.Tr("form.user_not_exist"))
c.Redirect(c.Org.OrgLink + "/invitations/new")
} else {
c.Handle(500, " GetUserByName", err)
c.Error(err, "get user by name")
}
return
}
if err = org.AddMember(u.ID); err != nil {
c.Handle(500, " AddMember", err)
c.Error(err, "add member")
return
}
@ -119,5 +118,5 @@ func Invitation(c *context.Context) {
return
}
c.HTML(200, MEMBER_INVITE)
c.Success(MEMBER_INVITE)
}

13
internal/route/org/org.go
View File

@ -7,7 +7,6 @@ package org
import (
log "unknwon.dev/clog/v2"
"gogs.io/gogs/internal/conf"
"gogs.io/gogs/internal/context"
"gogs.io/gogs/internal/db"
"gogs.io/gogs/internal/form"
@ -18,15 +17,15 @@ const (
)
func Create(c *context.Context) {
c.Data["Title"] = c.Tr("new_org")
c.HTML(200, CREATE)
c.Title("new_org")
c.Success(CREATE)
}
func CreatePost(c *context.Context, f form.CreateOrg) {
c.Data["Title"] = c.Tr("new_org")
c.Title("new_org")
if c.HasError() {
c.HTML(200, CREATE)
c.Success(CREATE)
return
}
@ -46,11 +45,11 @@ func CreatePost(c *context.Context, f form.CreateOrg) {
case db.IsErrNamePatternNotAllowed(err):
c.RenderWithErr(c.Tr("org.form.name_pattern_not_allowed", err.(db.ErrNamePatternNotAllowed).Pattern), CREATE, &f)
default:
c.Handle(500, "CreateOrganization", err)
c.Error(err, "create organization")
}
return
}
log.Trace("Organization created: %s", org.Name)
c.Redirect(conf.Server.Subpath + "/org/" + f.OrgName + "/dashboard")
c.RedirectSubpath("/org/" + f.OrgName + "/dashboard")
}

29
internal/route/org/setting.go
View File

@ -12,7 +12,6 @@ import (
"gogs.io/gogs/internal/conf"
"gogs.io/gogs/internal/context"
"gogs.io/gogs/internal/db"
"gogs.io/gogs/internal/db/errors"
"gogs.io/gogs/internal/form"
"gogs.io/gogs/internal/route/user"
)
@ -24,17 +23,17 @@ const (
)
func Settings(c *context.Context) {
c.Data["Title"] = c.Tr("org.settings")
c.Title("org.settings")
c.Data["PageIsSettingsOptions"] = true
c.HTML(200, SETTINGS_OPTIONS)
c.Success(SETTINGS_OPTIONS)
}
func SettingsPost(c *context.Context, f form.UpdateOrgSetting) {
c.Data["Title"] = c.Tr("org.settings")
c.Title("org.settings")
c.Data["PageIsSettingsOptions"] = true
if c.HasError() {
c.HTML(200, SETTINGS_OPTIONS)
c.Success(SETTINGS_OPTIONS)
return
}
@ -44,7 +43,7 @@ func SettingsPost(c *context.Context, f form.UpdateOrgSetting) {
if org.LowerName != strings.ToLower(f.Name) {
isExist, err := db.IsUserExist(org.ID, f.Name)
if err != nil {
c.Handle(500, "IsUserExist", err)
c.Error(err, "check if user exists")
return
} else if isExist {
c.Data["OrgName"] = true
@ -58,7 +57,7 @@ func SettingsPost(c *context.Context, f form.UpdateOrgSetting) {
case db.IsErrNamePatternNotAllowed(err):
c.RenderWithErr(c.Tr("user.form.name_pattern_not_allowed"), SETTINGS_OPTIONS, &f)
default:
c.Handle(500, "ChangeUserName", err)
c.Error(err, "change user name")
}
return
}
@ -79,7 +78,7 @@ func SettingsPost(c *context.Context, f form.UpdateOrgSetting) {
org.Website = f.Website
org.Location = f.Location
if err := db.UpdateUser(org); err != nil {
c.Handle(500, "UpdateUser", err)
c.Error(err, "update user")
return
}
log.Trace("Organization setting updated: %s", org.Name)
@ -113,10 +112,10 @@ func SettingsDelete(c *context.Context) {
org := c.Org.Organization
if c.Req.Method == "POST" {
if _, err := db.UserLogin(c.User.Name, c.Query("password"), c.User.LoginSource); err != nil {
if errors.IsUserNotExist(err) {
if db.IsErrUserNotExist(err) {
c.RenderWithErr(c.Tr("form.enterred_invalid_password"), SETTINGS_DELETE, nil)
} else {
c.ServerError("UserLogin", err)
c.Error(err, "authenticate user")
}
return
}
@ -126,7 +125,7 @@ func SettingsDelete(c *context.Context) {
c.Flash.Error(c.Tr("form.org_still_own_repo"))
c.Redirect(c.Org.OrgLink + "/settings/delete")
} else {
c.ServerError("DeleteOrganization", err)
c.Error(err, "delete organization")
}
} else {
log.Trace("Organization deleted: %s", org.Name)
@ -139,7 +138,7 @@ func SettingsDelete(c *context.Context) {
}
func Webhooks(c *context.Context) {
c.Data["Title"] = c.Tr("org.settings")
c.Title("org.settings")
c.Data["PageIsSettingsHooks"] = true
c.Data["BaseLink"] = c.Org.OrgLink
c.Data["Description"] = c.Tr("org.settings.hooks_desc")
@ -147,12 +146,12 @@ func Webhooks(c *context.Context) {
ws, err := db.GetWebhooksByOrgID(c.Org.Organization.ID)
if err != nil {
c.Handle(500, "GetWebhooksByOrgId", err)
c.Error(err, "get webhooks by organization ID")
return
}
c.Data["Webhooks"] = ws
c.HTML(200, SETTINGS_WEBHOOKS)
c.Success(SETTINGS_WEBHOOKS)
}
func DeleteWebhook(c *context.Context) {
@ -162,7 +161,7 @@ func DeleteWebhook(c *context.Context) {
c.Flash.Success(c.Tr("repo.settings.webhook_deletion_success"))
}
c.JSON(200, map[string]interface{}{
c.JSONSuccess( map[string]interface{}{
"redirect": c.Org.OrgLink + "/settings/hooks",
})
}

52
internal/route/org/teams.go
View File

@ -5,6 +5,7 @@
package org
import (
"net/http"
"path"
"github.com/unknwon/com"
@ -12,7 +13,6 @@ import (
"gogs.io/gogs/internal/context"
"gogs.io/gogs/internal/db"
"gogs.io/gogs/internal/db/errors"
"gogs.io/gogs/internal/form"
)
@ -30,13 +30,13 @@ func Teams(c *context.Context) {
for _, t := range org.Teams {
if err := t.GetMembers(); err != nil {
c.Handle(500, "GetMembers", err)
c.Error(err, "get members")
return
}
}
c.Data["Teams"] = org.Teams
c.HTML(200, TEAMS)
c.Success(TEAMS)
}
func TeamsAction(c *context.Context) {
@ -51,7 +51,7 @@ func TeamsAction(c *context.Context) {
switch c.Params(":action") {
case "join":
if !c.Org.IsOwner {
c.Error(404)
c.NotFound()
return
}
err = c.Org.Team.AddMember(c.User.ID)
@ -59,25 +59,25 @@ func TeamsAction(c *context.Context) {
err = c.Org.Team.RemoveMember(c.User.ID)
case "remove":
if !c.Org.IsOwner {
c.Error(404)
c.NotFound()
return
}
err = c.Org.Team.RemoveMember(uid)
page = "team"
case "add":
if !c.Org.IsOwner {
c.Error(404)
c.NotFound()
return
}
uname := c.Query("uname")
var u *db.User
u, err = db.GetUserByName(uname)
if err != nil {
if errors.IsUserNotExist(err) {
if db.IsErrUserNotExist(err) {
c.Flash.Error(c.Tr("form.user_not_exist"))
c.Redirect(c.Org.OrgLink + "/teams/" + c.Org.Team.LowerName)
} else {
c.Handle(500, " GetUserByName", err)
c.Error(err, "get user by name")
}
return
}
@ -91,7 +91,7 @@ func TeamsAction(c *context.Context) {
c.Flash.Error(c.Tr("form.last_org_owner"))
} else {
log.Error("Action(%s): %v", c.Params(":action"), err)
c.JSON(200, map[string]interface{}{
c.JSONSuccess(map[string]interface{}{
"ok": false,
"err": err.Error(),
})
@ -109,7 +109,7 @@ func TeamsAction(c *context.Context) {
func TeamsRepoAction(c *context.Context) {
if !c.Org.IsOwner {
c.Error(404)
c.NotFound()
return
}
@ -120,12 +120,13 @@ func TeamsRepoAction(c *context.Context) {
var repo *db.Repository
repo, err = db.GetRepositoryByName(c.Org.Organization.ID, repoName)
if err != nil {
if errors.IsRepoNotExist(err) {
if db.IsErrRepoNotExist(err) {
c.Flash.Error(c.Tr("org.teams.add_nonexistent_repo"))
c.Redirect(c.Org.OrgLink + "/teams/" + c.Org.Team.LowerName + "/repositories")
return
}
c.Handle(500, "GetRepositoryByName", err)
c.Error(err, "get repository by name")
return
}
err = c.Org.Team.AddRepository(repo)
@ -134,8 +135,7 @@ func TeamsRepoAction(c *context.Context) {
}
if err != nil {
log.Error("Action(%s): '%s' %v", c.Params(":action"), c.Org.Team.Name, err)
c.Handle(500, "TeamsRepoAction", err)
c.Errorf(err, "action %q", c.Params(":action"))
return
}
c.Redirect(c.Org.OrgLink + "/teams/" + c.Org.Team.LowerName + "/repositories")
@ -146,7 +146,7 @@ func NewTeam(c *context.Context) {
c.Data["PageIsOrgTeams"] = true
c.Data["PageIsOrgTeamsNew"] = true
c.Data["Team"] = &db.Team{}
c.HTML(200, TEAM_NEW)
c.Success(TEAM_NEW)
}
func NewTeamPost(c *context.Context, f form.CreateTeam) {
@ -163,7 +163,7 @@ func NewTeamPost(c *context.Context, f form.CreateTeam) {
c.Data["Team"] = t
if c.HasError() {
c.HTML(200, TEAM_NEW)
c.Success(TEAM_NEW)
return
}
@ -175,7 +175,7 @@ func NewTeamPost(c *context.Context, f form.CreateTeam) {
case db.IsErrNameReserved(err):
c.RenderWithErr(c.Tr("org.form.team_name_reserved", err.(db.ErrNameReserved).Name), TEAM_NEW, &f)
default:
c.Handle(500, "NewTeam", err)
c.Error(err, "new team")
}
return
}
@ -187,20 +187,20 @@ func TeamMembers(c *context.Context) {
c.Data["Title"] = c.Org.Team.Name
c.Data["PageIsOrgTeams"] = true
if err := c.Org.Team.GetMembers(); err != nil {
c.Handle(500, "GetMembers", err)
c.Error(err, "get members")
return
}
c.HTML(200, TEAM_MEMBERS)
c.Success(TEAM_MEMBERS)
}
func TeamRepositories(c *context.Context) {
c.Data["Title"] = c.Org.Team.Name
c.Data["PageIsOrgTeams"] = true
if err := c.Org.Team.GetRepositories(); err != nil {
c.Handle(500, "GetRepositories", err)
c.Error(err, "get repositories")
return
}
c.HTML(200, TEAM_REPOSITORIES)
c.Success(TEAM_REPOSITORIES)
}
func EditTeam(c *context.Context) {
@ -208,7 +208,7 @@ func EditTeam(c *context.Context) {
c.Data["PageIsOrgTeams"] = true
c.Data["team_name"] = c.Org.Team.Name
c.Data["desc"] = c.Org.Team.Description
c.HTML(200, TEAM_NEW)
c.Success(TEAM_NEW)
}
func EditTeamPost(c *context.Context, f form.CreateTeam) {
@ -218,7 +218,7 @@ func EditTeamPost(c *context.Context, f form.CreateTeam) {
c.Data["Team"] = t
if c.HasError() {
c.HTML(200, TEAM_NEW)
c.Success(TEAM_NEW)
return
}
@ -234,7 +234,7 @@ func EditTeamPost(c *context.Context, f form.CreateTeam) {
case "admin":
auth = db.ACCESS_MODE_ADMIN
default:
c.Error(401)
c.Status(http.StatusUnauthorized)
return
}
@ -251,7 +251,7 @@ func EditTeamPost(c *context.Context, f form.CreateTeam) {
case db.IsErrTeamAlreadyExist(err):
c.RenderWithErr(c.Tr("form.team_name_been_taken"), TEAM_NEW, &f)
default:
c.Handle(500, "UpdateTeam", err)
c.Error(err, "update team")
}
return
}
@ -265,7 +265,7 @@ func DeleteTeam(c *context.Context) {
c.Flash.Success(c.Tr("org.teams.delete_team_success"))
}
c.JSON(200, map[string]interface{}{
c.JSONSuccess(map[string]interface{}{
"redirect": c.Org.OrgLink + "/teams",
})
}

10
internal/route/repo/branch.go
View File

@ -31,13 +31,13 @@ type Branch struct {
func loadBranches(c *context.Context) []*Branch {
rawBranches, err := c.Repo.Repository.GetBranches()
if err != nil {
c.Handle(500, "GetBranches", err)
c.Error(err, "get branches")
return nil
}
protectBranches, err := db.GetProtectBranchesByRepoID(c.Repo.Repository.ID)
if err != nil {
c.Handle(500, "GetProtectBranchesByRepoID", err)
c.Error(err, "get protect branches by repository ID")
return nil
}
@ -45,7 +45,7 @@ func loadBranches(c *context.Context) []*Branch {
for i := range rawBranches {
commit, err := rawBranches[i].GetCommit()
if err != nil {
c.Handle(500, "GetCommit", err)
c.Error(err, "get commit")
return nil
}
@ -91,7 +91,7 @@ func Branches(c *context.Context) {
c.Data["ActiveBranches"] = activeBranches
c.Data["StaleBranches"] = staleBranches
c.HTML(200, BRANCHES_OVERVIEW)
c.Success( BRANCHES_OVERVIEW)
}
func AllBranches(c *context.Context) {
@ -104,7 +104,7 @@ func AllBranches(c *context.Context) {
}
c.Data["Branches"] = branches
c.HTML(200, BRANCHES_ALL)
c.Success( BRANCHES_ALL)
}
func DeleteBranchPost(c *context.Context) {

22
internal/route/repo/commit.go
View File

@ -54,7 +54,7 @@ func renderCommits(c *context.Context, filename string) {
commits, err := c.Repo.Commit.CommitsByPage(page, pageSize, git.CommitsByPageOptions{Path: filename})
if err != nil {
c.ServerError("paging commits", err)
c.Error(err, "paging commits")
return
}
@ -73,7 +73,7 @@ func renderCommits(c *context.Context, filename string) {
c.Data["Username"] = c.Repo.Owner.Name
c.Data["Reponame"] = c.Repo.Repository.Name
c.HTML(200, COMMITS)
c.Success(COMMITS)
}
func Commits(c *context.Context) {
@ -91,7 +91,7 @@ func SearchCommits(c *context.Context) {
commits, err := c.Repo.Commit.SearchCommits(keyword)
if err != nil {
c.ServerError("SearchCommits", err)
c.Error(err, "search commits")
return
}
@ -102,7 +102,7 @@ func SearchCommits(c *context.Context) {
c.Data["Username"] = c.Repo.Owner.Name
c.Data["Reponame"] = c.Repo.Repository.Name
c.Data["Branch"] = c.Repo.BranchName
c.HTML(200, COMMITS)
c.Success(COMMITS)
}
func FileHistory(c *context.Context) {
@ -119,7 +119,7 @@ func Diff(c *context.Context) {
commit, err := c.Repo.GitRepo.CatFileCommit(commitID)
if err != nil {
c.NotFoundOrServerError("get commit by ID", gitutil.IsErrRevisionNotExist, err)
c.NotFoundOrError(gitutil.NewError(err), "get commit by ID")
return
}
@ -127,7 +127,7 @@ func Diff(c *context.Context) {
commitID, conf.Git.MaxDiffFiles, conf.Git.MaxDiffLines, conf.Git.MaxDiffLineChars,
)
if err != nil {
c.NotFoundOrServerError("get diff", gitutil.IsErrRevisionNotExist, err)
c.NotFoundOrError(gitutil.NewError(err), "get diff")
return
}
@ -171,7 +171,7 @@ func RawDiff(c *context.Context) {
git.RawDiffFormat(c.Params(":ext")),
c.Resp,
); err != nil {
c.NotFoundOrServerError("get raw diff", gitutil.IsErrRevisionNotExist, err)
c.NotFoundOrError(gitutil.NewError(err), "get raw diff")
return
}
}
@ -185,7 +185,7 @@ func CompareDiff(c *context.Context) {
commit, err := c.Repo.GitRepo.CatFileCommit(afterCommitID)
if err != nil {
c.Handle(404, "GetCommit", err)
c.NotFoundOrError(gitutil.NewError(err), "get head commit")
return
}
@ -194,13 +194,13 @@ func CompareDiff(c *context.Context) {
git.DiffOptions{Base: beforeCommitID},
)
if err != nil {
c.ServerError("get diff", err)
c.NotFoundOrError(gitutil.NewError(err), "get diff")
return
}
commits, err := commit.CommitsAfter(beforeCommitID)
if err != nil {
c.ServerError("get commits after", err)
c.NotFoundOrError(gitutil.NewError(err), "get commits after")
return
}
@ -220,5 +220,5 @@ func CompareDiff(c *context.Context) {
c.Data["SourcePath"] = conf.Server.Subpath + "/" + path.Join(userName, repoName, "src", afterCommitID)
c.Data["BeforeSourcePath"] = conf.Server.Subpath + "/" + path.Join(userName, repoName, "src", beforeCommitID)
c.Data["RawPath"] = conf.Server.Subpath + "/" + path.Join(userName, repoName, "raw", afterCommitID)
c.HTML(200, DIFF)
c.Success(DIFF)
}

4
internal/route/repo/download.go
View File

@ -51,12 +51,12 @@ func ServeBlob(c *context.Context, blob *git.Blob) error {
func SingleDownload(c *context.Context) {
blob, err := c.Repo.Commit.Blob(c.Repo.TreePath)
if err != nil {
c.NotFoundOrServerError("get blob", gitutil.IsErrRevisionNotExist, err)
c.NotFoundOrError(gitutil.NewError(err), "get blob")
return
}
if err = ServeBlob(c, blob); err != nil {
c.ServerError("serve blob", err)
c.Error(err, "serve blob")
return
}
}

36
internal/route/repo/editor.go
View File

@ -56,7 +56,7 @@ func editFile(c *context.Context, isNewFile bool) {
if !isNewFile {
entry, err := c.Repo.Commit.TreeEntry(c.Repo.TreePath)
if err != nil {
c.NotFoundOrServerError("get tree entry", gitutil.IsErrRevisionNotExist, err)
c.NotFoundOrError(gitutil.NewError(err), "get tree entry")
return
}
@ -69,7 +69,7 @@ func editFile(c *context.Context, isNewFile bool) {
blob := entry.Blob()
p, err := blob.Bytes()
if err != nil {
c.ServerError("blob.Data", err)
c.Error(err, "get blob data")
return
}
@ -182,7 +182,7 @@ func editFilePost(c *context.Context, f form.EditRepoFile, isNewFile bool) {
break
}
c.ServerError("Repo.Commit.GetTreeEntryByPath", err)
c.Error(err, "get tree entry")
return
}
if index != len(treeNames)-1 {
@ -211,14 +211,14 @@ func editFilePost(c *context.Context, f form.EditRepoFile, isNewFile bool) {
c.FormErr("TreePath")
c.RenderWithErr(c.Tr("repo.editor.file_editing_no_longer_exists", oldTreePath), EDIT_FILE, &f)
} else {
c.ServerError("GetTreeEntryByPath", err)
c.Error(err, "get tree entry")
}
return
}
if lastCommit != c.Repo.CommitID {
files, err := c.Repo.Commit.FilesChangedAfter(lastCommit)
if err != nil {
c.ServerError("GetFilesChangedSinceCommit", err)
c.Error(err, "get changed files")
return
}
@ -236,7 +236,7 @@ func editFilePost(c *context.Context, f form.EditRepoFile, isNewFile bool) {
entry, err := c.Repo.Commit.TreeEntry(f.TreePath)
if err != nil {
if !gitutil.IsErrRevisionNotExist(err) {
c.ServerError("GetTreeEntryByPath", err)
c.Error(err, "get tree entry")
return
}
}
@ -297,26 +297,26 @@ func DiffPreviewPost(c *context.Context, f form.EditPreviewDiff) {
entry, err := c.Repo.Commit.TreeEntry(treePath)
if err != nil {
c.Error(500, "GetTreeEntryByPath: "+err.Error())
c.Error(err, "get tree entry")
return
} else if entry.IsTree() {
c.Error(422)
c.Status(http.StatusUnprocessableEntity)
return
}
diff, err := c.Repo.Repository.GetDiffPreview(c.Repo.BranchName, treePath, f.Content)
if err != nil {
c.Error(500, "GetDiffPreview: "+err.Error())
c.Error(err, "get diff preview")
return
}
if diff.NumFiles() == 0 {
c.PlainText(200, []byte(c.Tr("repo.editor.no_changes_to_show")))
c.PlainText(http.StatusOK, c.Tr("repo.editor.no_changes_to_show"))
return
}
c.Data["File"] = diff.Files[0]
c.HTML(200, EDIT_DIFF_PREVIEW)
c.Success(EDIT_DIFF_PREVIEW)
}
func DeleteFile(c *context.Context) {
@ -468,7 +468,7 @@ func UploadFilePost(c *context.Context, f form.UploadRepoFile) {
break
}
c.ServerError("GetTreeEntryByPath", err)
c.Error(err, "get tree entry")
return
}
@ -514,7 +514,7 @@ func UploadFilePost(c *context.Context, f form.UploadRepoFile) {
func UploadFileToServer(c *context.Context) {
file, header, err := c.Req.FormFile("file")
if err != nil {
c.Error(http.StatusInternalServerError, fmt.Sprintf("FormFile: %v", err))
c.Error(err, "get file")
return
}
defer file.Close()
@ -537,14 +537,14 @@ func UploadFileToServer(c *context.Context) {
}
if !allowed {
c.Error(http.StatusBadRequest, ErrFileTypeForbidden.Error())
c.PlainText(http.StatusBadRequest, ErrFileTypeForbidden.Error())
return
}
}
upload, err := db.NewUpload(header.Filename, buf, file)
if err != nil {
c.Error(http.StatusInternalServerError, fmt.Sprintf("NewUpload: %v", err))
c.Error(err, "new upload")
return
}
@ -556,15 +556,15 @@ func UploadFileToServer(c *context.Context) {
func RemoveUploadFileFromServer(c *context.Context, f form.RemoveUploadFile) {
if len(f.File) == 0 {
c.Status(204)
c.Status(http.StatusNoContent)
return
}
if err := db.DeleteUploadByUUID(f.File); err != nil {
c.Error(500, fmt.Sprintf("DeleteUploadByUUID: %v", err))
c.Error(err, "delete upload by UUID")
return
}
log.Trace("Upload file removed: %s", f.File)
c.Status(204)
c.Status(http.StatusNoContent)
}

21
internal/route/repo/http.go
View File

@ -22,7 +22,6 @@ import (
"gogs.io/gogs/internal/conf"
"gogs.io/gogs/internal/context"
"gogs.io/gogs/internal/db"
"gogs.io/gogs/internal/db/errors"
"gogs.io/gogs/internal/lazyregexp"
"gogs.io/gogs/internal/tool"
)
@ -39,7 +38,7 @@ type HTTPContext struct {
// askCredentials responses HTTP header and status which informs client to provide credentials.
func askCredentials(c *context.Context, status int, text string) {
c.Resp.Header().Set("WWW-Authenticate", "Basic realm=\".\"")
c.HandleText(status, text)
c.PlainText(status, text)
}
func HTTPContexter() macaron.Handler {
@ -66,13 +65,13 @@ func HTTPContexter() macaron.Handler {
owner, err := db.GetUserByName(ownerName)
if err != nil {
c.NotFoundOrServerError("GetUserByName", errors.IsUserNotExist, err)
c.NotFoundOrError(err, "get user by name")
return
}
repo, err := db.GetRepositoryByName(owner.ID, repoName)
if err != nil {
c.NotFoundOrServerError("GetRepositoryByName", errors.IsRepoNotExist, err)
c.NotFoundOrError(err, "get repository by name")
return
}
@ -113,8 +112,8 @@ func HTTPContexter() macaron.Handler {
}
authUser, err := db.UserLogin(authUsername, authPassword, -1)
if err != nil && !errors.IsUserNotExist(err) {
c.Handle(http.StatusInternalServerError, "UserLogin", err)
if err != nil && !db.IsErrUserNotExist(err) {
c.Error(err, "authenticate user")
return
}
@ -125,7 +124,7 @@ func HTTPContexter() macaron.Handler {
if db.IsErrAccessTokenEmpty(err) || db.IsErrAccessTokenNotExist(err) {
askCredentials(c, http.StatusUnauthorized, "")
} else {
c.Handle(http.StatusInternalServerError, "GetAccessTokenBySHA", err)
c.Error(err, "get access token by SHA")
}
return
}
@ -136,7 +135,7 @@ func HTTPContexter() macaron.Handler {
if err != nil {
// Once we found token, we're supposed to find its related user,
// thus any error is unexpected.
c.Handle(http.StatusInternalServerError, "GetUserByID", err)
c.Error(err, "get user by ID")
return
}
} else if authUser.IsEnabledTwoFactor() {
@ -153,7 +152,7 @@ Please create and use personal access token on user settings page`)
}
has, err := db.HasAccess(authUser.ID, repo, mode)
if err != nil {
c.Handle(http.StatusInternalServerError, "HasAccess", err)
c.Error(err, "check access")
return
} else if !has {
askCredentials(c, http.StatusForbidden, "User permission denied")
@ -161,7 +160,7 @@ Please create and use personal access token on user settings page`)
}
if !isPull && repo.IsMirror {
c.HandleText(http.StatusForbidden, "Mirror repository is read-only")
c.PlainText(http.StatusForbidden, "Mirror repository is read-only")
return
}
@ -388,7 +387,7 @@ func HTTP(c *HTTPContext) {
// but we only want to output this message only if user is really trying to access
// Git HTTP endpoints.
if conf.Repository.DisableHTTPGit {
c.HandleText(http.StatusForbidden, "Interacting with repositories by HTTP protocol is not disabled")
c.PlainText(http.StatusForbidden, "Interacting with repositories by HTTP protocol is disabled")
return
}

179
internal/route/repo/issue.go
View File

@ -51,7 +51,7 @@ var (
func MustEnableIssues(c *context.Context) {
if !c.Repo.Repository.EnableIssues {
c.Handle(404, "MustEnableIssues", nil)
c.NotFound()
return
}
@ -63,7 +63,7 @@ func MustEnableIssues(c *context.Context) {
func MustAllowPulls(c *context.Context) {
if !c.Repo.Repository.AllowsPulls() {
c.Handle(404, "MustAllowPulls", nil)
c.NotFound()
return
}
@ -77,7 +77,7 @@ func MustAllowPulls(c *context.Context) {
func RetrieveLabels(c *context.Context) {
labels, err := db.GetLabelsByRepoID(c.Repo.Repository.ID)
if err != nil {
c.Handle(500, "RetrieveLabels.GetLabels", err)
c.Error(err, "get labels by repository ID")
return
}
for _, l := range labels {
@ -182,14 +182,14 @@ func issues(c *context.Context, isPullList bool) {
SortType: sortType,
})
if err != nil {
c.Handle(500, "Issues", err)
c.Error(err, "list issues")
return
}
// Get issue-user relations.
pairs, err := db.GetIssueUsers(repo.ID, posterID, isShowClosed)
if err != nil {
c.Handle(500, "GetIssueUsers", err)
c.Error(err, "get issue-user relations")
return
}
@ -213,14 +213,14 @@ func issues(c *context.Context, isPullList bool) {
// Get milestones.
c.Data["Milestones"], err = db.GetMilestonesByRepoID(repo.ID)
if err != nil {
c.Handle(500, "GetAllRepoMilestones", err)
c.Error(err, "get milestone by repository ID")
return
}
// Get assignees.
c.Data["Assignees"], err = repo.GetAssignees()
if err != nil {
c.Handle(500, "GetAssignees", err)
c.Error(err, "get assignees")
return
}
@ -241,7 +241,7 @@ func issues(c *context.Context, isPullList bool) {
c.Data["State"] = "open"
}
c.HTML(200, ISSUES)
c.Success(ISSUES)
}
func Issues(c *context.Context) {
@ -264,18 +264,18 @@ func RetrieveRepoMilestonesAndAssignees(c *context.Context, repo *db.Repository)
var err error
c.Data["OpenMilestones"], err = db.GetMilestones(repo.ID, -1, false)
if err != nil {
c.Handle(500, "GetMilestones", err)
c.Error(err, "get open milestones")
return
}
c.Data["ClosedMilestones"], err = db.GetMilestones(repo.ID, -1, true)
if err != nil {
c.Handle(500, "GetMilestones", err)
c.Error(err, "get closed milestones")
return
}
c.Data["Assignees"], err = repo.GetAssignees()
if err != nil {
c.Handle(500, "GetAssignees", err)
c.Error(err, "get assignees")
return
}
}
@ -287,7 +287,7 @@ func RetrieveRepoMetas(c *context.Context, repo *db.Repository) []*db.Label {
labels, err := db.GetLabelsByRepoID(repo.ID)
if err != nil {
c.Handle(500, "GetLabelsByRepoID", err)
c.Error(err, "get labels by repository ID")
return nil
}
c.Data["Labels"] = labels
@ -345,7 +345,7 @@ func NewIssue(c *context.Context) {
return
}
c.HTML(200, ISSUE_NEW)
c.Success(ISSUE_NEW)
}
func ValidateRepoMetas(c *context.Context, f form.NewIssue) ([]int64, int64, int64) {
@ -382,7 +382,7 @@ func ValidateRepoMetas(c *context.Context, f form.NewIssue) ([]int64, int64, int
if milestoneID > 0 {
c.Data["Milestone"], err = repo.GetMilestoneByID(milestoneID)
if err != nil {
c.Handle(500, "GetMilestoneByID", err)
c.Error(err, "get milestone by ID")
return nil, 0, 0
}
c.Data["milestone_id"] = milestoneID
@ -393,7 +393,7 @@ func ValidateRepoMetas(c *context.Context, f form.NewIssue) ([]int64, int64, int
if assigneeID > 0 {
c.Data["Assignee"], err = repo.GetAssigneeByID(assigneeID)
if err != nil {
c.Handle(500, "GetAssigneeByID", err)
c.Error(err, "get assignee by ID")
return nil, 0, 0
}
c.Data["assignee_id"] = assigneeID
@ -415,7 +415,7 @@ func NewIssuePost(c *context.Context, f form.NewIssue) {
}
if c.HasError() {
c.HTML(200, ISSUE_NEW)
c.Success(ISSUE_NEW)
return
}
@ -434,7 +434,7 @@ func NewIssuePost(c *context.Context, f form.NewIssue) {
Content: f.Content,
}
if err := db.NewIssue(c.Repo.Repository, issue, labelIDs, attachments); err != nil {
c.Handle(500, "NewIssue", err)
c.Error(err, "new issue")
return
}
@ -445,7 +445,7 @@ func NewIssuePost(c *context.Context, f form.NewIssue) {
func uploadAttachment(c *context.Context, allowedTypes []string) {
file, header, err := c.Req.FormFile("file")
if err != nil {
c.Error(500, fmt.Sprintf("FormFile: %v", err))
c.Error(err, "get file")
return
}
defer file.Close()
@ -467,18 +467,18 @@ func uploadAttachment(c *context.Context, allowedTypes []string) {
}
if !allowed {
c.Error(400, ErrFileTypeForbidden.Error())
c.PlainText(http.StatusBadRequest, ErrFileTypeForbidden.Error())
return
}
attach, err := db.NewAttachment(header.Filename, buf, file)
if err != nil {
c.Error(500, fmt.Sprintf("NewAttachment: %v", err))
c.Error(err, "new attachment")
return
}
log.Trace("New attachment uploaded: %s", attach.UUID)
c.JSON(200, map[string]string{
c.JSONSuccess(map[string]string{
"uuid": attach.UUID,
})
}
@ -505,7 +505,7 @@ func viewIssue(c *context.Context, isPullList bool) {
issue, err := db.GetIssueByIndex(c.Repo.Repository.ID, index)
if err != nil {
c.NotFoundOrServerError("GetIssueByIndex", errors.IsIssueNotExist, err)
c.NotFoundOrError(err, "get issue by index")
return
}
c.Data["Title"] = issue.Title
@ -559,7 +559,7 @@ func viewIssue(c *context.Context, isPullList bool) {
}
labels, err := db.GetLabelsByRepoID(repo.ID)
if err != nil {
c.Handle(500, "GetLabelsByRepoID", err)
c.Error(err, "get labels by repository ID")
return
}
hasSelected := false
@ -583,7 +583,7 @@ func viewIssue(c *context.Context, isPullList bool) {
if c.IsLogged {
// Update issue-user.
if err = issue.ReadBy(c.User.ID); err != nil {
c.Handle(500, "ReadBy", err)
c.Error(err, "mark read by")
return
}
}
@ -638,8 +638,8 @@ func viewIssue(c *context.Context, isPullList bool) {
branchProtected := false
protectBranch, err := db.GetProtectBranchOfRepoByName(pull.BaseRepoID, pull.HeadBranch)
if err != nil {
if !errors.IsErrBranchNotExist(err) {
c.ServerError("GetProtectBranchOfRepoByName", err)
if !db.IsErrBranchNotExist(err) {
c.Error(err, "get protect branch of repository by name")
return
}
} else {
@ -661,7 +661,7 @@ func viewIssue(c *context.Context, isPullList bool) {
c.Data["Issue"] = issue
c.Data["IsIssueOwner"] = c.Repo.IsWriter() || (c.IsLogged && issue.IsPoster(c.User.ID))
c.Data["SignInLink"] = conf.Server.Subpath + "/user/login?redirect_to=" + c.Data["Link"].(string)
c.HTML(200, ISSUE_VIEW)
c.Success(ISSUE_VIEW)
}
func ViewIssue(c *context.Context) {
@ -675,7 +675,7 @@ func ViewPull(c *context.Context) {
func getActionIssue(c *context.Context) *db.Issue {
issue, err := db.GetIssueByIndex(c.Repo.Repository.ID, c.ParamsInt64(":index"))
if err != nil {
c.NotFoundOrServerError("GetIssueByIndex", errors.IsIssueNotExist, err)
c.NotFoundOrError(err, "get issue by index")
return nil
}
@ -695,22 +695,22 @@ func UpdateIssueTitle(c *context.Context) {
}
if !c.IsLogged || (!issue.IsPoster(c.User.ID) && !c.Repo.IsWriter()) {
c.Error(403)
c.Status(http.StatusForbidden)
return
}
title := c.QueryTrim("title")
if len(title) == 0 {
c.Error(204)
c.Status(http.StatusNoContent)
return
}
if err := issue.ChangeTitle(c.User, title); err != nil {
c.Handle(500, "ChangeTitle", err)
c.Error(err, "change title")
return
}
c.JSON(200, map[string]interface{}{
c.JSONSuccess(map[string]interface{}{
"title": issue.Title,
})
}
@ -722,17 +722,17 @@ func UpdateIssueContent(c *context.Context) {
}
if !c.IsLogged || (c.User.ID != issue.PosterID && !c.Repo.IsWriter()) {
c.Error(403)
c.Status(http.StatusForbidden)
return
}
content := c.Query("content")
if err := issue.ChangeContent(c.User, content); err != nil {
c.Handle(500, "ChangeContent", err)
c.Error(err, "change content")
return
}
c.JSON(200, map[string]string{
c.JSONSuccess(map[string]string{
"content": string(markup.Markdown(issue.Content, c.Query("context"), c.Repo.Repository.ComposeMetas())),
})
}
@ -745,35 +745,31 @@ func UpdateIssueLabel(c *context.Context) {
if c.Query("action") == "clear" {
if err := issue.ClearLabels(c.User); err != nil {
c.Handle(500, "ClearLabels", err)
c.Error(err, "clear labels")
return
}
} else {
isAttach := c.Query("action") == "attach"
label, err := db.GetLabelOfRepoByID(c.Repo.Repository.ID, c.QueryInt64("id"))
if err != nil {
if db.IsErrLabelNotExist(err) {
c.Error(404, "GetLabelByID")
} else {
c.Handle(500, "GetLabelByID", err)
}
c.NotFoundOrError(err, "get label by ID")
return
}
if isAttach && !issue.HasLabel(label.ID) {
if err = issue.AddLabel(c.User, label); err != nil {
c.Handle(500, "AddLabel", err)
c.Error(err, "add label")
return
}
} else if !isAttach && issue.HasLabel(label.ID) {
if err = issue.RemoveLabel(c.User, label); err != nil {
c.Handle(500, "RemoveLabel", err)
c.Error(err, "remove label")
return
}
}
}
c.JSON(200, map[string]interface{}{
c.JSONSuccess(map[string]interface{}{
"ok": true,
})
}
@ -787,7 +783,7 @@ func UpdateIssueMilestone(c *context.Context) {
oldMilestoneID := issue.MilestoneID
milestoneID := c.QueryInt64("id")
if oldMilestoneID == milestoneID {
c.JSON(200, map[string]interface{}{
c.JSONSuccess(map[string]interface{}{
"ok": true,
})
return
@ -796,11 +792,11 @@ func UpdateIssueMilestone(c *context.Context) {
// Not check for invalid milestone id and give responsibility to owners.
issue.MilestoneID = milestoneID
if err := db.ChangeMilestoneAssign(c.User, issue, oldMilestoneID); err != nil {
c.Handle(500, "ChangeMilestoneAssign", err)
c.Error(err, "change milestone assign")
return
}
c.JSON(200, map[string]interface{}{
c.JSONSuccess(map[string]interface{}{
"ok": true,
})
}
@ -813,18 +809,18 @@ func UpdateIssueAssignee(c *context.Context) {
assigneeID := c.QueryInt64("id")
if issue.AssigneeID == assigneeID {
c.JSON(200, map[string]interface{}{
c.JSONSuccess(map[string]interface{}{
"ok": true,
})
return
}
if err := issue.ChangeAssignee(c.User, assigneeID); err != nil {
c.Handle(500, "ChangeAssignee", err)
c.Error(err, "change assignee")
return
}
c.JSON(200, map[string]interface{}{
c.JSONSuccess(map[string]interface{}{
"ok": true,
})
}
@ -862,7 +858,7 @@ func NewComment(c *context.Context, f form.CreateComment) {
pr, err = db.GetUnmergedPullRequest(pull.HeadRepoID, pull.BaseRepoID, pull.HeadBranch, pull.BaseBranch)
if err != nil {
if !db.IsErrPullRequestNotExist(err) {
c.ServerError("GetUnmergedPullRequest", err)
c.Error(err, "get unmerged pull request")
return
}
}
@ -870,7 +866,7 @@ func NewComment(c *context.Context, f form.CreateComment) {
// Regenerate patch and test conflict.
if pr == nil {
if err = issue.PullRequest.UpdatePatch(); err != nil {
c.ServerError("UpdatePatch", err)
c.Error(err, "update patch")
return
}
@ -913,7 +909,7 @@ func NewComment(c *context.Context, f form.CreateComment) {
comment, err = db.CreateIssueComment(c.User, c.Repo.Repository, issue, f.Content, attachments)
if err != nil {
c.ServerError("CreateIssueComment", err)
c.Error(err, "create issue comment")
return
}
@ -923,32 +919,32 @@ func NewComment(c *context.Context, f form.CreateComment) {
func UpdateCommentContent(c *context.Context) {
comment, err := db.GetCommentByID(c.ParamsInt64(":id"))
if err != nil {
c.NotFoundOrServerError("GetCommentByID", db.IsErrCommentNotExist, err)
c.NotFoundOrError(err, "get comment by ID")
return
}
if c.UserID() != comment.PosterID && !c.Repo.IsAdmin() {
c.Error(404)
c.NotFound()
return
} else if comment.Type != db.COMMENT_TYPE_COMMENT {
c.Error(204)
c.Status(http.StatusNoContent)
return
}
oldContent := comment.Content
comment.Content = c.Query("content")
if len(comment.Content) == 0 {
c.JSON(200, map[string]interface{}{
c.JSONSuccess(map[string]interface{}{
"content": "",
})
return
}
if err = db.UpdateComment(c.User, comment, oldContent); err != nil {
c.Handle(500, "UpdateComment", err)
c.Error(err, "update comment")
return
}
c.JSON(200, map[string]string{
c.JSONSuccess(map[string]string{
"content": string(markup.Markdown(comment.Content, c.Query("context"), c.Repo.Repository.ComposeMetas())),
})
}
@ -956,24 +952,24 @@ func UpdateCommentContent(c *context.Context) {
func DeleteComment(c *context.Context) {
comment, err := db.GetCommentByID(c.ParamsInt64(":id"))
if err != nil {
c.NotFoundOrServerError("GetCommentByID", db.IsErrCommentNotExist, err)
c.NotFoundOrError(err, "get comment by ID")
return
}
if c.UserID() != comment.PosterID && !c.Repo.IsAdmin() {
c.Error(404)
c.NotFound()
return
} else if comment.Type != db.COMMENT_TYPE_COMMENT {
c.Error(204)
c.Status(http.StatusNoContent)
return
}
if err = db.DeleteCommentByID(c.User, comment.ID); err != nil {
c.Handle(500, "DeleteCommentByID", err)
c.Error(err, "delete comment by ID")
return
}
c.Status(200)
c.Status(http.StatusOK)
}
func Labels(c *context.Context) {
@ -982,7 +978,7 @@ func Labels(c *context.Context) {
c.Data["PageIsLabels"] = true
c.Data["RequireMinicolors"] = true
c.Data["LabelTemplates"] = db.LabelTemplates
c.HTML(200, LABELS)
c.Success(LABELS)
}
func InitializeLabels(c *context.Context, f form.InitializeLabels) {
@ -1006,7 +1002,7 @@ func InitializeLabels(c *context.Context, f form.InitializeLabels) {
}
}
if err := db.NewLabels(labels...); err != nil {
c.Handle(500, "NewLabels", err)
c.Error(err, "new labels")
return
}
c.RawRedirect(c.Repo.MakeURL("labels"))
@ -1028,7 +1024,7 @@ func NewLabel(c *context.Context, f form.CreateLabel) {
Color: f.Color,
}
if err := db.NewLabels(l); err != nil {
c.Handle(500, "NewLabel", err)
c.Error(err, "new labels")
return
}
c.RawRedirect(c.Repo.MakeURL("labels"))
@ -1037,19 +1033,14 @@ func NewLabel(c *context.Context, f form.CreateLabel) {
func UpdateLabel(c *context.Context, f form.CreateLabel) {
l, err := db.GetLabelByID(f.ID)
if err != nil {
switch {
case db.IsErrLabelNotExist(err):
c.Error(404)
default:
c.Handle(500, "UpdateLabel", err)
}
c.NotFoundOrError(err, "get label by ID")
return
}
l.Name = f.Title
l.Color = f.Color
if err := db.UpdateLabel(l); err != nil {
c.Handle(500, "UpdateLabel", err)
c.Error(err, "update label")
return
}
c.RawRedirect(c.Repo.MakeURL("labels"))
@ -1092,7 +1083,7 @@ func Milestones(c *context.Context) {
miles, err := db.GetMilestones(c.Repo.Repository.ID, page, isShowClosed)
if err != nil {
c.Handle(500, "GetMilestones", err)
c.Error(err, "get milestones")
return
}
for _, m := range miles {
@ -1112,7 +1103,7 @@ func Milestones(c *context.Context) {
}
c.Data["IsShowClosed"] = isShowClosed
c.HTML(200, MILESTONE)
c.Success(MILESTONE)
}
func NewMilestone(c *context.Context) {
@ -1121,7 +1112,7 @@ func NewMilestone(c *context.Context) {
c.Data["PageIsMilestones"] = true
c.Data["RequireDatetimepicker"] = true
c.Data["DateLang"] = conf.I18n.DateLang(c.Locale.Language())
c.HTML(200, MILESTONE_NEW)
c.Success(MILESTONE_NEW)
}
func NewMilestonePost(c *context.Context, f form.CreateMilestone) {
@ -1132,7 +1123,7 @@ func NewMilestonePost(c *context.Context, f form.CreateMilestone) {
c.Data["DateLang"] = conf.I18n.DateLang(c.Locale.Language())
if c.HasError() {
c.HTML(200, MILESTONE_NEW)
c.Success(MILESTONE_NEW)
return
}
@ -1152,7 +1143,7 @@ func NewMilestonePost(c *context.Context, f form.CreateMilestone) {
Content: f.Content,
Deadline: deadline,
}); err != nil {
c.Handle(500, "NewMilestone", err)
c.Error(err, "new milestone")
return
}
@ -1169,11 +1160,7 @@ func EditMilestone(c *context.Context) {
m, err := db.GetMilestoneByRepoID(c.Repo.Repository.ID, c.ParamsInt64(":id"))
if err != nil {
if db.IsErrMilestoneNotExist(err) {
c.Handle(404, "", nil)
} else {
c.Handle(500, "GetMilestoneByRepoID", err)
}
c.NotFoundOrError(err, "get milestone by repository ID")
return
}
c.Data["title"] = m.Name
@ -1181,7 +1168,7 @@ func EditMilestone(c *context.Context) {
if len(m.DeadlineString) > 0 {
c.Data["deadline"] = m.DeadlineString
}
c.HTML(200, MILESTONE_NEW)
c.Success(MILESTONE_NEW)
}
func EditMilestonePost(c *context.Context, f form.CreateMilestone) {
@ -1192,7 +1179,7 @@ func EditMilestonePost(c *context.Context, f form.CreateMilestone) {
c.Data["DateLang"] = conf.I18n.DateLang(c.Locale.Language())
if c.HasError() {
c.HTML(200, MILESTONE_NEW)
c.Success(MILESTONE_NEW)
return
}
@ -1208,18 +1195,14 @@ func EditMilestonePost(c *context.Context, f form.CreateMilestone) {
m, err := db.GetMilestoneByRepoID(c.Repo.Repository.ID, c.ParamsInt64(":id"))
if err != nil {
if db.IsErrMilestoneNotExist(err) {
c.Handle(404, "", nil)
} else {
c.Handle(500, "GetMilestoneByRepoID", err)
}
c.NotFoundOrError(err, "get milestone by repository ID")
return
}
m.Name = f.Title
m.Content = f.Content
m.Deadline = deadline
if err = db.UpdateMilestone(m); err != nil {
c.Handle(500, "UpdateMilestone", err)
c.Error(err, "update milestone")
return
}
@ -1230,11 +1213,7 @@ func EditMilestonePost(c *context.Context, f form.CreateMilestone) {
func ChangeMilestonStatus(c *context.Context) {
m, err := db.GetMilestoneByRepoID(c.Repo.Repository.ID, c.ParamsInt64(":id"))
if err != nil {
if db.IsErrMilestoneNotExist(err) {
c.Handle(404, "", err)
} else {
c.Handle(500, "GetMilestoneByRepoID", err)
}
c.NotFoundOrError(err, "get milestone by repository ID")
return
}
@ -1246,7 +1225,7 @@ func ChangeMilestonStatus(c *context.Context) {
case "open":
if m.IsClosed {
if err = db.ChangeMilestoneStatus(m, false); err != nil {
c.Handle(500, "ChangeMilestoneStatus", err)
c.Error(err, "change milestone status to open")
return
}
}
@ -1255,7 +1234,7 @@ func ChangeMilestonStatus(c *context.Context) {
if !m.IsClosed {
m.ClosedDate = time.Now()
if err = db.ChangeMilestoneStatus(m, true); err != nil {
c.Handle(500, "ChangeMilestoneStatus", err)
c.Error(err, "change milestone status to closed")
return
}
}
@ -1272,7 +1251,7 @@ func DeleteMilestone(c *context.Context) {
c.Flash.Success(c.Tr("repo.milestones.deletion_success"))
}
c.JSON(200, map[string]interface{}{
c.JSONSuccess(map[string]interface{}{
"redirect": c.Repo.MakeURL("milestones"),
})
}

84
internal/route/repo/pull.go
View File

@ -5,6 +5,7 @@
package repo
import (
"net/http"
"path"
"strings"
@ -16,7 +17,6 @@ import (
"gogs.io/gogs/internal/conf"
"gogs.io/gogs/internal/context"
"gogs.io/gogs/internal/db"
"gogs.io/gogs/internal/db/errors"
"gogs.io/gogs/internal/form"
"gogs.io/gogs/internal/gitutil"
"gogs.io/gogs/internal/tool"
@ -49,7 +49,7 @@ var (
func parseBaseRepository(c *context.Context) *db.Repository {
baseRepo, err := db.GetRepositoryByID(c.ParamsInt64(":repoid"))
if err != nil {
c.NotFoundOrServerError("GetRepositoryByID", errors.IsRepoNotExist, err)
c.NotFoundOrError(err, "get repository by ID")
return nil
}
@ -63,13 +63,13 @@ func parseBaseRepository(c *context.Context) *db.Repository {
c.Data["IsPrivate"] = baseRepo.IsPrivate
if err = baseRepo.GetOwner(); err != nil {
c.ServerError("GetOwner", err)
c.Error(err, "get owner")
return nil
}
c.Data["ForkFrom"] = baseRepo.Owner.Name + "/" + baseRepo.Name
if err := c.User.GetOrganizations(true); err != nil {
c.ServerError("GetOrganizations", err)
c.Error(err, "get organizations")
return nil
}
c.Data["Orgs"] = c.User.Orgs
@ -110,7 +110,7 @@ func ForkPost(c *context.Context, f form.CreateRepo) {
repo, has, err := db.HasForkedRepo(ctxUser.ID, baseRepo.ID)
if err != nil {
c.ServerError("HasForkedRepo", err)
c.Error(err, "check forked repository")
return
} else if has {
c.Redirect(repo.Link())
@ -119,7 +119,7 @@ func ForkPost(c *context.Context, f form.CreateRepo) {
// Check ownership of organization.
if ctxUser.IsOrganization() && !ctxUser.IsOwnedBy(c.User.ID) {
c.Error(403)
c.Status(http.StatusForbidden)
return
}
@ -133,7 +133,7 @@ func ForkPost(c *context.Context, f form.CreateRepo) {
if err != nil {
c.Data["Err_RepoName"] = true
switch {
case errors.IsReachLimitOfRepo(err):
case db.IsErrReachLimitOfRepo(err):
c.RenderWithErr(c.Tr("repo.form.reach_limit_of_creation", c.User.RepoCreationNum()), FORK, &f)
case db.IsErrRepoAlreadyExist(err):
c.RenderWithErr(c.Tr("repo.settings.new_owner_has_same_repo"), FORK, &f)
@ -142,7 +142,7 @@ func ForkPost(c *context.Context, f form.CreateRepo) {
case db.IsErrNamePatternNotAllowed(err):
c.RenderWithErr(c.Tr("repo.form.name_pattern_not_allowed", err.(db.ErrNamePatternNotAllowed).Pattern), FORK, &f)
default:
c.ServerError("ForkPost", err)
c.Error(err, "fork repository")
}
return
}
@ -154,21 +154,21 @@ func ForkPost(c *context.Context, f form.CreateRepo) {
func checkPullInfo(c *context.Context) *db.Issue {
issue, err := db.GetIssueByIndex(c.Repo.Repository.ID, c.ParamsInt64(":index"))
if err != nil {
c.NotFoundOrServerError("GetIssueByIndex", errors.IsIssueNotExist, err)
c.NotFoundOrError(err, "get issue by index")
return nil
}
c.Data["Title"] = issue.Title
c.Data["Issue"] = issue
if !issue.IsPull {
c.Handle(404, "ViewPullCommits", nil)
c.NotFound()
return nil
}
if c.IsLogged {
// Update issue-user.
if err = issue.ReadBy(c.User.ID); err != nil {
c.ServerError("ReadBy", err)
c.Error(err, "mark read by")
return nil
}
}
@ -185,14 +185,14 @@ func PrepareMergedViewPullInfo(c *context.Context, issue *db.Issue) {
var err error
c.Data["NumCommits"], err = c.Repo.GitRepo.RevListCount([]string{pull.MergeBase + "..." + pull.MergedCommitID})
if err != nil {
c.ServerError("Repo.GitRepo.CommitsCountBetween", err)
c.Error(err, "count commits")
return
}
names, err := c.Repo.GitRepo.DiffNameOnly(pull.MergeBase, pull.MergedCommitID, git.DiffNameOnlyOptions{NeedsMergeBase: true})
c.Data["NumFiles"] = len(names)
if err != nil {
c.ServerError("Repo.GitRepo.FilesCountBetween", err)
c.Error(err, "get changed files")
return
}
}
@ -212,7 +212,7 @@ func PrepareViewPullInfo(c *context.Context, issue *db.Issue) *gitutil.PullReque
if pull.HeadRepo != nil {
headGitRepo, err = git.Open(pull.HeadRepo.RepoPath())
if err != nil {
c.ServerError("open repository", err)
c.Error(err, "open repository")
return nil
}
}
@ -236,7 +236,7 @@ func PrepareViewPullInfo(c *context.Context, issue *db.Issue) *gitutil.PullReque
return nil
}
c.ServerError("GetPullRequestInfo", err)
c.Error(err, "get pull request meta")
return nil
}
c.Data["NumCommits"] = len(prMeta.Commits)
@ -267,17 +267,17 @@ func ViewPullCommits(c *context.Context) {
}
startCommit, err := c.Repo.GitRepo.CatFileCommit(pull.MergeBase)
if err != nil {
c.ServerError("get commit of merge base", err)
c.Error(err, "get commit of merge base")
return
}
endCommit, err := c.Repo.GitRepo.CatFileCommit(pull.MergedCommitID)
if err != nil {
c.ServerError("get merged commit", err)
c.Error(err, "get merged commit")
return
}
commits, err = c.Repo.GitRepo.RevList([]string{startCommit.ID.String() + "..." + endCommit.ID.String()})
if err != nil {
c.ServerError("list commits", err)
c.Error(err, "list commits")
return
}
@ -330,7 +330,7 @@ func ViewPullFiles(c *context.Context) {
if c.Written() {
return
} else if prInfo == nil {
c.Handle(404, "ViewPullFiles", nil)
c.NotFound()
return
}
@ -338,13 +338,13 @@ func ViewPullFiles(c *context.Context) {
headGitRepo, err := git.Open(headRepoPath)
if err != nil {
c.ServerError("open repository", err)
c.Error(err, "open repository")
return
}
headCommitID, err := headGitRepo.BranchCommitID(pull.HeadBranch)
if err != nil {
c.ServerError("get head branch commit ID", err)
c.Error(err, "get head branch commit ID")
return
}
@ -359,7 +359,7 @@ func ViewPullFiles(c *context.Context) {
git.DiffOptions{Base: startCommitID},
)
if err != nil {
c.ServerError("get diff", err)
c.Error(err, "get diff")
return
}
c.Data["Diff"] = diff
@ -367,7 +367,7 @@ func ViewPullFiles(c *context.Context) {
commit, err := gitRepo.CatFileCommit(endCommitID)
if err != nil {
c.ServerError("get commit", err)
c.Error(err, "get commit")
return
}
@ -406,7 +406,7 @@ func MergePullRequest(c *context.Context) {
pr, err := db.GetPullRequestByIssueID(issue.ID)
if err != nil {
c.NotFoundOrServerError("GetPullRequestByIssueID", db.IsErrPullRequestNotExist, err)
c.NotFoundOrError(err, "get pull request by issue ID")
return
}
@ -418,7 +418,7 @@ func MergePullRequest(c *context.Context) {
pr.Issue = issue
pr.Issue.Repo = c.Repo.Repository
if err = pr.Merge(c.User, c.Repo.GitRepo, db.MergeStyle(c.Query("merge_style")), c.Query("commit_description")); err != nil {
c.ServerError("Merge", err)
c.Error(err, "merge")
return
}
@ -460,7 +460,7 @@ func ParseCompareInfo(c *context.Context) (*db.User, *db.Repository, *git.Reposi
} else if len(headInfos) == 2 {
headUser, err = db.GetUserByName(headInfos[0])
if err != nil {
c.NotFoundOrServerError("GetUserByName", errors.IsUserNotExist, err)
c.NotFoundOrError(err, "get user by name")
return nil, nil, nil, nil, "", ""
}
headBranch = headInfos[1]
@ -491,7 +491,7 @@ func ParseCompareInfo(c *context.Context) (*db.User, *db.Repository, *git.Reposi
var has bool
headRepo, has, err = db.HasForkedRepo(headUser.ID, baseRepo.ID)
if err != nil {
c.ServerError("HasForkedRepo", err)
c.Error(err, "get forked repository")
return nil, nil, nil, nil, "", ""
} else if !has {
log.Trace("ParseCompareInfo [base_repo_id: %d]: does not have fork or in same repository", baseRepo.ID)
@ -501,7 +501,7 @@ func ParseCompareInfo(c *context.Context) (*db.User, *db.Repository, *git.Reposi
headGitRepo, err = git.Open(db.RepoPath(headUser.Name, headRepo.Name))
if err != nil {
c.ServerError("open repository", err)
c.Error(err, "open repository")
return nil, nil, nil, nil, "", ""
}
} else {
@ -523,7 +523,7 @@ func ParseCompareInfo(c *context.Context) (*db.User, *db.Repository, *git.Reposi
headBranches, err := headGitRepo.Branches()
if err != nil {
c.ServerError("get branches", err)
c.Error(err, "get branches")
return nil, nil, nil, nil, "", ""
}
c.Data["HeadBranches"] = headBranches
@ -535,7 +535,7 @@ func ParseCompareInfo(c *context.Context) (*db.User, *db.Repository, *git.Reposi
c.Data["IsNoMergeBase"] = true
c.Success(COMPARE_PULL)
} else {
c.ServerError("get pull request meta", err)
c.Error(err, "get pull request meta")
}
return nil, nil, nil, nil, "", ""
}
@ -563,7 +563,7 @@ func PrepareCompareDiff(
headCommitID, err := headGitRepo.BranchCommitID(headBranch)
if err != nil {
c.ServerError("get head branch commit ID", err)
c.Error(err, "get head branch commit ID")
return false
}
c.Data["AfterCommitID"] = headCommitID
@ -578,7 +578,7 @@ func PrepareCompareDiff(
git.DiffOptions{Base: meta.MergeBase},
)
if err != nil {
c.ServerError("get repository diff", err)
c.Error(err, "get repository diff")
return false
}
c.Data["Diff"] = diff
@ -586,7 +586,7 @@ func PrepareCompareDiff(
headCommit, err := headGitRepo.CatFileCommit(headCommitID)
if err != nil {
c.ServerError("get head commit", err)
c.Error(err, "get head commit")
return false
}
@ -619,7 +619,7 @@ func CompareAndPullRequest(c *context.Context) {
pr, err := db.GetUnmergedPullRequest(headRepo.ID, c.Repo.Repository.ID, headBranch, baseBranch)
if err != nil {
if !db.IsErrPullRequestNotExist(err) {
c.ServerError("GetUnmergedPullRequest", err)
c.Error(err, "get unmerged pull request")
return
}
} else {
@ -701,7 +701,7 @@ func CompareAndPullRequestPost(c *context.Context, f form.NewIssue) {
patch, err := headGitRepo.DiffBinary(meta.MergeBase, headBranch)
if err != nil {
c.ServerError("get patch", err)
c.Error(err, "get patch")
return
}
@ -730,10 +730,10 @@ func CompareAndPullRequestPost(c *context.Context, f form.NewIssue) {
// FIXME: check error in the case two people send pull request at almost same time, give nice error prompt
// instead of 500.
if err := db.NewPullRequest(repo, pullIssue, labelIDs, attachments, pullRequest, patch); err != nil {
c.ServerError("NewPullRequest", err)
c.Error(err, "new pull request")
return
} else if err := pullRequest.PushToBaseRepo(); err != nil {
c.ServerError("PushToBaseRepo", err)
c.Error(err, "push to base repository")
return
}
@ -744,13 +744,13 @@ func CompareAndPullRequestPost(c *context.Context, f form.NewIssue) {
func parseOwnerAndRepo(c *context.Context) (*db.User, *db.Repository) {
owner, err := db.GetUserByName(c.Params(":username"))
if err != nil {
c.NotFoundOrServerError("GetUserByName", errors.IsUserNotExist, err)
c.NotFoundOrError(err, "get user by name")
return nil, nil
}
repo, err := db.GetRepositoryByName(owner.ID, c.Params(":reponame"))
if err != nil {
c.NotFoundOrServerError("GetRepositoryByName", errors.IsRepoNotExist, err)
c.NotFoundOrError(err, "get repository by name")
return nil, nil
}
@ -762,7 +762,7 @@ func TriggerTask(c *context.Context) {
branch := c.Query("branch")
secret := c.Query("secret")
if len(branch) == 0 || len(secret) == 0 || pusherID <= 0 {
c.Error(404)
c.NotFound()
log.Trace("TriggerTask: branch or secret is empty, or pusher ID is not valid")
return
}
@ -771,14 +771,14 @@ func TriggerTask(c *context.Context) {
return
}
if secret != tool.MD5(owner.Salt) {
c.Error(404)
c.NotFound()
log.Trace("TriggerTask [%s/%s]: invalid secret", owner.Name, repo.Name)
return
}
pusher, err := db.GetUserByID(pusherID)
if err != nil {
c.NotFoundOrServerError("GetUserByID", errors.IsUserNotExist, err)
c.NotFoundOrError(err, "get user by ID")
return
}

50
internal/route/repo/release.go
View File

@ -53,13 +53,13 @@ func Releases(c *context.Context) {
tagsPage, err := gitutil.Module.ListTagsAfter(c.Repo.GitRepo.Path(), c.Query("after"), 10)
if err != nil {
c.ServerError("get tags", err)
c.Error(err, "get tags")
return
}
releases, err := db.GetPublishedReleasesByRepoID(c.Repo.Repository.ID, tagsPage.Tags...)
if err != nil {
c.Handle(500, "GetPublishedReleasesByRepoID", err)
c.Error(err, "get published releases by repository ID")
return
}
@ -75,12 +75,12 @@ func Releases(c *context.Context) {
releases[j] = nil // Mark as used.
if err = r.LoadAttributes(); err != nil {
c.Handle(500, "LoadAttributes", err)
c.Error(err, "load attributes")
return
}
if err := calReleaseNumCommitsBehind(c.Repo, r, countCache); err != nil {
c.Handle(500, "calReleaseNumCommitsBehind", err)
c.Error(err, "calculate number of commits after release")
return
}
@ -93,7 +93,7 @@ func Releases(c *context.Context) {
if results[i] == nil {
commit, err := c.Repo.GitRepo.TagCommit(rawTag)
if err != nil {
c.Handle(500, "get tag commit", err)
c.Error(err, "get tag commit")
return
}
@ -105,7 +105,7 @@ func Releases(c *context.Context) {
results[i].NumCommits, err = commit.CommitsCount()
if err != nil {
c.ServerError("count commits", err)
c.Error(err, "count commits")
return
}
results[i].NumCommitsBehind = c.Repo.CommitsCount - results[i].NumCommits
@ -118,18 +118,18 @@ func Releases(c *context.Context) {
if tagsPage.HasLatest {
drafts, err = db.GetDraftReleasesByRepoID(c.Repo.Repository.ID)
if err != nil {
c.Handle(500, "GetDraftReleasesByRepoID", err)
c.Error(err, "get draft releases by repository ID")
return
}
for _, r := range drafts {
if err = r.LoadAttributes(); err != nil {
c.Handle(500, "LoadAttributes", err)
c.Error(err, "load attributes")
return
}
if err := calReleaseNumCommitsBehind(c.Repo, r, countCache); err != nil {
c.Handle(500, "calReleaseNumCommitsBehind", err)
c.Error(err, "calculate number of commits after release")
return
}
@ -148,7 +148,7 @@ func Releases(c *context.Context) {
if len(results) > 0 {
c.Data["NextAfter"] = results[len(results)-1].TagName
}
c.HTML(200, RELEASES)
c.Success(RELEASES)
}
func renderReleaseAttachmentSettings(c *context.Context) {
@ -164,7 +164,7 @@ func NewRelease(c *context.Context) {
c.Data["PageIsReleaseList"] = true
c.Data["tag_target"] = c.Repo.Repository.DefaultBranch
renderReleaseAttachmentSettings(c)
c.HTML(200, RELEASE_NEW)
c.Success(RELEASE_NEW)
}
func NewReleasePost(c *context.Context, f form.NewRelease) {
@ -173,7 +173,7 @@ func NewReleasePost(c *context.Context, f form.NewRelease) {
renderReleaseAttachmentSettings(c)
if c.HasError() {
c.HTML(200, RELEASE_NEW)
c.Success(RELEASE_NEW)
return
}
@ -194,13 +194,13 @@ func NewReleasePost(c *context.Context, f form.NewRelease) {
commit, err := c.Repo.GitRepo.BranchCommit(f.Target)
if err != nil {
c.ServerError("get branch commit", err)
c.Error(err, "get branch commit")
return
}
commitsCount, err := commit.CommitsCount()
if err != nil {
c.ServerError("count commits", err)
c.Error(err, "count commits")
return
}
@ -230,7 +230,7 @@ func NewReleasePost(c *context.Context, f form.NewRelease) {
case db.IsErrInvalidTagName(err):
c.RenderWithErr(c.Tr("repo.release.tag_name_invalid"), RELEASE_NEW, &f)
default:
c.Handle(500, "NewRelease", err)
c.Error(err, "new release")
}
return
}
@ -248,11 +248,7 @@ func EditRelease(c *context.Context) {
tagName := c.Params("*")
rel, err := db.GetRelease(c.Repo.Repository.ID, tagName)
if err != nil {
if db.IsErrReleaseNotExist(err) {
c.Handle(404, "GetRelease", err)
} else {
c.Handle(500, "GetRelease", err)
}
c.NotFoundOrError(err, "get release")
return
}
c.Data["ID"] = rel.ID
@ -264,7 +260,7 @@ func EditRelease(c *context.Context) {
c.Data["prerelease"] = rel.IsPrerelease
c.Data["IsDraft"] = rel.IsDraft
c.HTML(200, RELEASE_NEW)
c.Success(RELEASE_NEW)
}
func EditReleasePost(c *context.Context, f form.EditRelease) {
@ -276,11 +272,7 @@ func EditReleasePost(c *context.Context, f form.EditRelease) {
tagName := c.Params("*")
rel, err := db.GetRelease(c.Repo.Repository.ID, tagName)
if err != nil {
if db.IsErrReleaseNotExist(err) {
c.Handle(404, "GetRelease", err)
} else {
c.Handle(500, "GetRelease", err)
}
c.NotFoundOrError(err, "get release")
return
}
c.Data["tag_name"] = rel.TagName
@ -292,7 +284,7 @@ func EditReleasePost(c *context.Context, f form.EditRelease) {
c.Data["IsDraft"] = rel.IsDraft
if c.HasError() {
c.HTML(200, RELEASE_NEW)
c.Success(RELEASE_NEW)
return
}
@ -307,7 +299,7 @@ func EditReleasePost(c *context.Context, f form.EditRelease) {
rel.IsDraft = len(f.Draft) > 0
rel.IsPrerelease = f.Prerelease
if err = db.UpdateRelease(c.User, c.Repo.GitRepo, rel, isPublish, attachments); err != nil {
c.Handle(500, "UpdateRelease", err)
c.Error(err, "update release")
return
}
c.Redirect(c.Repo.RepoLink + "/releases")
@ -328,7 +320,7 @@ func DeleteRelease(c *context.Context) {
c.Flash.Success(c.Tr("repo.release.deletion_success"))
}
c.JSON(200, map[string]interface{}{
c.JSONSuccess( map[string]interface{}{
"redirect": c.Repo.RepoLink + "/releases",
})
}

41
internal/route/repo/repo.go
View File

@ -5,7 +5,7 @@
package repo
import (
"fmt"
"net/http"
"os"
"path"
"path/filepath"
@ -19,7 +19,6 @@ import (
"gogs.io/gogs/internal/conf"
"gogs.io/gogs/internal/context"
"gogs.io/gogs/internal/db"
"gogs.io/gogs/internal/db/errors"
"gogs.io/gogs/internal/form"
"gogs.io/gogs/internal/tool"
)
@ -31,14 +30,14 @@ const (
func MustBeNotBare(c *context.Context) {
if c.Repo.Repository.IsBare {
c.Handle(404, "MustBeNotBare", nil)
c.NotFound()
}
}
func checkContextUser(c *context.Context, uid int64) *db.User {
orgs, err := db.GetOwnedOrgsByUserIDDesc(c.User.ID, "updated_unix")
if err != nil {
c.Handle(500, "GetOwnedOrgsByUserIDDesc", err)
c.Error(err, "get owned organization by user ID")
return nil
}
c.Data["Orgs"] = orgs
@ -49,18 +48,18 @@ func checkContextUser(c *context.Context, uid int64) *db.User {
}
org, err := db.GetUserByID(uid)
if errors.IsUserNotExist(err) {
if db.IsErrUserNotExist(err) {
return c.User
}
if err != nil {
c.Handle(500, "GetUserByID", fmt.Errorf("[%d]: %v", uid, err))
c.Error(err, "get user by ID")
return nil
}
// Check ownership of organization.
if !org.IsOrganization() || !(c.User.IsAdmin || org.IsOwnedBy(c.User.ID)) {
c.Error(403)
c.Status(http.StatusForbidden)
return nil
}
return org
@ -84,12 +83,12 @@ func Create(c *context.Context) {
}
c.Data["ContextUser"] = ctxUser
c.HTML(200, CREATE)
c.Success(CREATE)
}
func handleCreateError(c *context.Context, owner *db.User, err error, name, tpl string, form interface{}) {
switch {
case errors.IsReachLimitOfRepo(err):
case db.IsErrReachLimitOfRepo(err):
c.RenderWithErr(c.Tr("repo.form.reach_limit_of_creation", owner.RepoCreationNum()), tpl, form)
case db.IsErrRepoAlreadyExist(err):
c.Data["Err_RepoName"] = true
@ -101,7 +100,7 @@ func handleCreateError(c *context.Context, owner *db.User, err error, name, tpl
c.Data["Err_RepoName"] = true
c.RenderWithErr(c.Tr("repo.form.name_pattern_not_allowed", err.(db.ErrNamePatternNotAllowed).Pattern), tpl, form)
default:
c.Handle(500, name, err)
c.Error(err, name)
}
}
@ -119,7 +118,7 @@ func CreatePost(c *context.Context, f form.CreateRepo) {
c.Data["ContextUser"] = ctxUser
if c.HasError() {
c.HTML(200, CREATE)
c.Success(CREATE)
return
}
@ -159,7 +158,7 @@ func Migrate(c *context.Context) {
}
c.Data["ContextUser"] = ctxUser
c.HTML(200, MIGRATE)
c.Success(MIGRATE)
}
func MigratePost(c *context.Context, f form.MigrateRepo) {
@ -172,7 +171,7 @@ func MigratePost(c *context.Context, f form.MigrateRepo) {
c.Data["ContextUser"] = ctxUser
if c.HasError() {
c.HTML(200, MIGRATE)
c.Success(MIGRATE)
return
}
@ -189,10 +188,10 @@ func MigratePost(c *context.Context, f form.MigrateRepo) {
case addrErr.IsInvalidPath:
c.RenderWithErr(c.Tr("repo.migrate.invalid_local_path"), MIGRATE, &f)
default:
c.Handle(500, "Unknown error", err)
c.Error(err, "unexpected error")
}
} else {
c.Handle(500, "ParseRemoteAddr", err)
c.Error(err, "parse remote address")
}
return
}
@ -259,7 +258,7 @@ func Action(c *context.Context) {
}
if err != nil {
c.ServerError(fmt.Sprintf("Action (%s)", c.Params(":action")), err)
c.Errorf(err, "action %q", c.Params(":action"))
return
}
@ -290,14 +289,14 @@ func Download(c *context.Context) {
archiveFormat = git.ArchiveTarGz
default:
log.Trace("Unknown format: %s", uri)
c.Error(404)
c.NotFound()
return
}
refName = strings.TrimSuffix(uri, ext)
if !com.IsDir(archivePath) {
if err := os.MkdirAll(archivePath, os.ModePerm); err != nil {
c.Handle(500, "Download -> os.MkdirAll(archivePath)", err)
c.Error(err, "create archive directory")
return
}
}
@ -311,13 +310,13 @@ func Download(c *context.Context) {
if gitRepo.HasBranch(refName) {
commit, err = gitRepo.BranchCommit(refName)
if err != nil {
c.ServerError("get branch commit", err)
c.Error(err, "get branch commit")
return
}
} else if gitRepo.HasTag(refName) {
commit, err = gitRepo.TagCommit(refName)
if err != nil {
c.ServerError("get tag commit", err)
c.Error(err, "get tag commit")
return
}
} else if len(refName) >= 7 && len(refName) <= 40 {
@ -334,7 +333,7 @@ func Download(c *context.Context) {
archivePath = path.Join(archivePath, tool.ShortSHA1(commit.ID.String())+ext)
if !com.IsFile(archivePath) {
if err := commit.CreateArchive(archiveFormat, archivePath); err != nil {
c.ServerError("creates archive", err)
c.Error(err, "creates archive")
return
}
}

96
internal/route/repo/setting.go
View File

@ -7,7 +7,6 @@ package repo
import (
"fmt"
"io/ioutil"
"os"
"strings"
"time"
@ -21,6 +20,7 @@ import (
"gogs.io/gogs/internal/db/errors"
"gogs.io/gogs/internal/email"
"gogs.io/gogs/internal/form"
"gogs.io/gogs/internal/osutil"
"gogs.io/gogs/internal/tool"
)
@ -72,7 +72,7 @@ func SettingsPost(c *context.Context, f form.RepoSetting) {
case db.IsErrNamePatternNotAllowed(err):
c.RenderWithErr(c.Tr("repo.form.name_pattern_not_allowed", err.(db.ErrNamePatternNotAllowed).Pattern), SETTINGS_OPTIONS, &f)
default:
c.ServerError("ChangeRepositoryName", err)
c.Error(err, "change repository name")
}
return
}
@ -94,7 +94,7 @@ func SettingsPost(c *context.Context, f form.RepoSetting) {
visibilityChanged := repo.IsPrivate != f.Private
repo.IsPrivate = f.Private
if err := db.UpdateRepository(repo, visibilityChanged); err != nil {
c.ServerError("UpdateRepository", err)
c.Error(err, "update repository")
return
}
log.Trace("Repository basic settings updated: %s/%s", c.Repo.Owner.Name, repo.Name)
@ -119,12 +119,12 @@ func SettingsPost(c *context.Context, f form.RepoSetting) {
c.Repo.Mirror.Interval = f.Interval
c.Repo.Mirror.NextSync = time.Now().Add(time.Duration(f.Interval) * time.Hour)
if err := db.UpdateMirror(c.Repo.Mirror); err != nil {
c.ServerError("UpdateMirror", err)
c.Error(err, "update mirror")
return
}
}
if err := c.Repo.Mirror.SaveAddress(f.MirrorAddress); err != nil {
c.ServerError("SaveAddress", err)
c.Error(err, "save address")
return
}
@ -157,7 +157,7 @@ func SettingsPost(c *context.Context, f form.RepoSetting) {
repo.PullsAllowRebase = f.PullsAllowRebase
if err := db.UpdateRepository(repo, false); err != nil {
c.ServerError("UpdateRepository", err)
c.Error(err, "update repository")
return
}
log.Trace("Repository advanced settings updated: %s/%s", c.Repo.Owner.Name, repo.Name)
@ -189,10 +189,10 @@ func SettingsPost(c *context.Context, f form.RepoSetting) {
repo.IsMirror = false
if _, err := db.CleanUpMigrateInfo(repo); err != nil {
c.ServerError("CleanUpMigrateInfo", err)
c.Error(err, "clean up migrate info")
return
} else if err = db.DeleteMirrorByRepoID(c.Repo.Repository.ID); err != nil {
c.ServerError("DeleteMirrorByRepoID", err)
c.Error(err, "delete mirror by repository ID")
return
}
log.Trace("Repository converted from mirror to regular: %s/%s", c.Repo.Owner.Name, repo.Name)
@ -219,7 +219,7 @@ func SettingsPost(c *context.Context, f form.RepoSetting) {
newOwner := c.Query("new_owner_name")
isExist, err := db.IsUserExist(0, newOwner)
if err != nil {
c.ServerError("IsUserExist", err)
c.Error(err, "check if user exists")
return
} else if !isExist {
c.RenderWithErr(c.Tr("form.enterred_invalid_owner_name"), SETTINGS_OPTIONS, nil)
@ -230,7 +230,7 @@ func SettingsPost(c *context.Context, f form.RepoSetting) {
if db.IsErrRepoAlreadyExist(err) {
c.RenderWithErr(c.Tr("repo.settings.new_owner_has_same_repo"), SETTINGS_OPTIONS, nil)
} else {
c.ServerError("TransferOwnership", err)
c.Error(err, "transfer ownership")
}
return
}
@ -256,7 +256,7 @@ func SettingsPost(c *context.Context, f form.RepoSetting) {
}
if err := db.DeleteRepository(c.Repo.Owner.ID, repo.ID); err != nil {
c.ServerError("DeleteRepository", err)
c.Error(err, "delete repository")
return
}
log.Trace("Repository deleted: %s/%s", c.Repo.Owner.Name, repo.Name)
@ -286,7 +286,7 @@ func SettingsPost(c *context.Context, f form.RepoSetting) {
repo.EnableWiki = false
if err := db.UpdateRepository(repo, false); err != nil {
c.ServerError("UpdateRepository", err)
c.Error(err, "update repository")
return
}
@ -311,14 +311,14 @@ func SettingsAvatarPost(c *context.Context, f form.Avatar) {
} else {
c.Flash.Success(c.Tr("settings.update_avatar_success"))
}
c.SubURLRedirect(c.Repo.RepoLink + "/settings")
c.RedirectSubpath(c.Repo.RepoLink + "/settings")
}
func SettingsDeleteAvatar(c *context.Context) {
if err := c.Repo.Repository.DeleteAvatar(); err != nil {
c.Flash.Error(fmt.Sprintf("Failed to delete avatar: %v", err))
}
c.SubURLRedirect(c.Repo.RepoLink + "/settings")
c.RedirectSubpath(c.Repo.RepoLink + "/settings")
}
// FIXME: limit upload size
@ -361,12 +361,12 @@ func SettingsCollaboration(c *context.Context) {
users, err := c.Repo.Repository.GetCollaborators()
if err != nil {
c.Handle(500, "GetCollaborators", err)
c.Error(err, "get collaborators")
return
}
c.Data["Collaborators"] = users
c.HTML(200, SETTINGS_COLLABORATION)
c.Success(SETTINGS_COLLABORATION)
}
func SettingsCollaborationPost(c *context.Context) {
@ -378,11 +378,11 @@ func SettingsCollaborationPost(c *context.Context) {
u, err := db.GetUserByName(name)
if err != nil {
if errors.IsUserNotExist(err) {
if db.IsErrUserNotExist(err) {
c.Flash.Error(c.Tr("form.user_not_exist"))
c.Redirect(conf.Server.Subpath + c.Req.URL.Path)
} else {
c.Handle(500, "GetUserByName", err)
c.Error(err, "get user by name")
}
return
}
@ -395,7 +395,7 @@ func SettingsCollaborationPost(c *context.Context) {
}
if err = c.Repo.Repository.AddCollaborator(u); err != nil {
c.Handle(500, "AddCollaborator", err)
c.Error(err, "add collaborator")
return
}
@ -425,7 +425,7 @@ func DeleteCollaboration(c *context.Context) {
c.Flash.Success(c.Tr("repo.settings.remove_collaborator_success"))
}
c.JSON(200, map[string]interface{}{
c.JSONSuccess( map[string]interface{}{
"redirect": c.Repo.RepoLink + "/settings/collaboration",
})
}
@ -436,13 +436,13 @@ func SettingsBranches(c *context.Context) {
if c.Repo.Repository.IsBare {
c.Flash.Info(c.Tr("repo.settings.branches_bare"), true)
c.HTML(200, SETTINGS_BRANCHES)
c.Success(SETTINGS_BRANCHES)
return
}
protectBranches, err := db.GetProtectBranchesByRepoID(c.Repo.Repository.ID)
if err != nil {
c.Handle(500, "GetProtectBranchesByRepoID", err)
c.Error(err, "get protect branch by repository ID")
return
}
@ -455,7 +455,7 @@ func SettingsBranches(c *context.Context) {
}
c.Data["ProtectBranches"] = branches
c.HTML(200, SETTINGS_BRANCHES)
c.Success(SETTINGS_BRANCHES)
}
func UpdateDefaultBranch(c *context.Context) {
@ -473,7 +473,7 @@ func UpdateDefaultBranch(c *context.Context) {
}
if err := db.UpdateRepository(c.Repo.Repository, false); err != nil {
c.Handle(500, "UpdateRepository", err)
c.Error(err, "update repository")
return
}
@ -493,8 +493,8 @@ func SettingsProtectedBranch(c *context.Context) {
protectBranch, err := db.GetProtectBranchOfRepoByName(c.Repo.Repository.ID, branch)
if err != nil {
if !errors.IsErrBranchNotExist(err) {
c.Handle(500, "GetProtectBranchOfRepoByName", err)
if !db.IsErrBranchNotExist(err) {
c.Error(err, "get protect branch of repository by name")
return
}
@ -507,7 +507,7 @@ func SettingsProtectedBranch(c *context.Context) {
if c.Repo.Owner.IsOrganization() {
users, err := c.Repo.Repository.GetWriters()
if err != nil {
c.Handle(500, "Repo.Repository.GetPushers", err)
c.Error(err, "get writers")
return
}
c.Data["Users"] = users
@ -515,7 +515,7 @@ func SettingsProtectedBranch(c *context.Context) {
teams, err := c.Repo.Owner.TeamsHaveAccessToRepo(c.Repo.Repository.ID, db.ACCESS_MODE_WRITE)
if err != nil {
c.Handle(500, "Repo.Owner.TeamsHaveAccessToRepo", err)
c.Error(err, "get teams have access to the repository")
return
}
c.Data["Teams"] = teams
@ -523,7 +523,7 @@ func SettingsProtectedBranch(c *context.Context) {
}
c.Data["Branch"] = protectBranch
c.HTML(200, SETTINGS_PROTECTED_BRANCH)
c.Success(SETTINGS_PROTECTED_BRANCH)
}
func SettingsProtectedBranchPost(c *context.Context, f form.ProtectBranch) {
@ -535,8 +535,8 @@ func SettingsProtectedBranchPost(c *context.Context, f form.ProtectBranch) {
protectBranch, err := db.GetProtectBranchOfRepoByName(c.Repo.Repository.ID, branch)
if err != nil {
if !errors.IsErrBranchNotExist(err) {
c.Handle(500, "GetProtectBranchOfRepoByName", err)
if !db.IsErrBranchNotExist(err) {
c.Error(err, "get protect branch of repository by name")
return
}
@ -556,7 +556,7 @@ func SettingsProtectedBranchPost(c *context.Context, f form.ProtectBranch) {
err = db.UpdateProtectBranch(protectBranch)
}
if err != nil {
c.Handle(500, "UpdateOrgProtectBranch/UpdateProtectBranch", err)
c.Error(err, "update protect branch")
return
}
@ -570,12 +570,12 @@ func SettingsGitHooks(c *context.Context) {
hooks, err := c.Repo.GitRepo.Hooks("custom_hooks")
if err != nil {
c.Handle(500, "Hooks", err)
c.Error(err, "get hooks")
return
}
c.Data["Hooks"] = hooks
c.HTML(200, SETTINGS_GITHOOKS)
c.Success(SETTINGS_GITHOOKS)
}
func SettingsGitHooksEdit(c *context.Context) {
@ -586,30 +586,22 @@ func SettingsGitHooksEdit(c *context.Context) {
name := c.Params(":name")
hook, err := c.Repo.GitRepo.Hook("custom_hooks", git.HookName(name))
if err != nil {
if err == os.ErrNotExist {
c.Handle(404, "GetHook", err)
} else {
c.Handle(500, "GetHook", err)
}
c.NotFoundOrError(osutil.NewError(err), "get hook")
return
}
c.Data["Hook"] = hook
c.HTML(200, SETTINGS_GITHOOK_EDIT)
c.Success(SETTINGS_GITHOOK_EDIT)
}
func SettingsGitHooksEditPost(c *context.Context) {
name := c.Params(":name")
hook, err := c.Repo.GitRepo.Hook("custom_hooks", git.HookName(name))
if err != nil {
if err == os.ErrNotExist {
c.Handle(404, "GetHook", err)
} else {
c.Handle(500, "GetHook", err)
}
c.NotFoundOrError(osutil.NewError(err), "get hook")
return
}
if err = hook.Update(c.Query("content")); err != nil {
c.Handle(500, "hook.Update", err)
c.Error(err, "update hook")
return
}
c.Redirect(c.Data["Link"].(string))
@ -621,12 +613,12 @@ func SettingsDeployKeys(c *context.Context) {
keys, err := db.ListDeployKeys(c.Repo.Repository.ID)
if err != nil {
c.Handle(500, "ListDeployKeys", err)
c.Error(err, "list deploy keys")
return
}
c.Data["Deploykeys"] = keys
c.HTML(200, SETTINGS_DEPLOY_KEYS)
c.Success(SETTINGS_DEPLOY_KEYS)
}
func SettingsDeployKeysPost(c *context.Context, f form.AddSSHKey) {
@ -635,13 +627,13 @@ func SettingsDeployKeysPost(c *context.Context, f form.AddSSHKey) {
keys, err := db.ListDeployKeys(c.Repo.Repository.ID)
if err != nil {
c.Handle(500, "ListDeployKeys", err)
c.Error(err, "list deploy keys")
return
}
c.Data["Deploykeys"] = keys
if c.HasError() {
c.HTML(200, SETTINGS_DEPLOY_KEYS)
c.Success(SETTINGS_DEPLOY_KEYS)
return
}
@ -669,7 +661,7 @@ func SettingsDeployKeysPost(c *context.Context, f form.AddSSHKey) {
c.Data["Err_Title"] = true
c.RenderWithErr(c.Tr("repo.settings.key_name_used"), SETTINGS_DEPLOY_KEYS, &f)
default:
c.Handle(500, "AddDeployKey", err)
c.Error(err, "add deploy key")
}
return
}
@ -686,7 +678,7 @@ func DeleteDeployKey(c *context.Context) {
c.Flash.Success(c.Tr("repo.settings.deploy_key_deletion_success"))
}
c.JSON(200, map[string]interface{}{
c.JSONSuccess( map[string]interface{}{
"redirect": c.Repo.RepoLink + "/settings/keys",
})
}

30
internal/route/repo/view.go
View File

@ -37,13 +37,13 @@ const (
func renderDirectory(c *context.Context, treeLink string) {
tree, err := c.Repo.Commit.Subtree(c.Repo.TreePath)
if err != nil {
c.NotFoundOrServerError("get subtree", gitutil.IsErrRevisionNotExist, err)
c.NotFoundOrError(gitutil.NewError(err), "get subtree")
return
}
entries, err := tree.Entries()
if err != nil {
c.ServerError("list entries", err)
c.Error(err, "list entries")
return
}
entries.Sort()
@ -54,7 +54,7 @@ func renderDirectory(c *context.Context, treeLink string) {
Timeout: 5 * time.Minute,
})
if err != nil {
c.ServerError("get commits info", err)
c.Error(err, "get commits info")
return
}
@ -76,7 +76,7 @@ func renderDirectory(c *context.Context, treeLink string) {
p, err := readmeFile.Bytes()
if err != nil {
c.ServerError("readmeFile.Data", err)
c.Error(err, "read file")
return
}
@ -107,7 +107,7 @@ func renderDirectory(c *context.Context, treeLink string) {
if len(c.Repo.TreePath) > 0 {
latestCommit, err = c.Repo.Commit.CommitByPath(git.CommitByRevisionOptions{Path: c.Repo.TreePath})
if err != nil {
c.ServerError("get commit by path", err)
c.Error(err, "get commit by path")
return
}
}
@ -126,7 +126,7 @@ func renderFile(c *context.Context, entry *git.TreeEntry, treeLink, rawLink stri
blob := entry.Blob()
p, err := blob.Bytes()
if err != nil {
c.Handle(500, "Data", err)
c.Error(err, "read blob")
return
}
@ -232,7 +232,7 @@ func Home(c *context.Context) {
c.Data["PageIsViewFiles"] = true
if c.Repo.Repository.IsBare {
c.HTML(200, BARE)
c.Success(BARE)
return
}
@ -260,7 +260,7 @@ func Home(c *context.Context) {
var err error
c.Repo.CommitsCount, err = c.Repo.Commit.CommitsCount()
if err != nil {
c.Handle(500, "CommitsCount", err)
c.Error(err, "count commits")
return
}
c.Data["CommitsCount"] = c.Repo.CommitsCount
@ -270,7 +270,7 @@ func Home(c *context.Context) {
// Get current entry user currently looking at.
entry, err := c.Repo.Commit.TreeEntry(c.Repo.TreePath)
if err != nil {
c.NotFoundOrServerError("get tree entry", gitutil.IsErrRevisionNotExist, err)
c.NotFoundOrError(gitutil.NewError(err), "get tree entry")
return
}
@ -306,7 +306,7 @@ func Home(c *context.Context) {
c.Data["TreeLink"] = treeLink
c.Data["TreeNames"] = treeNames
c.Data["BranchLink"] = branchLink
c.HTML(200, HOME)
c.Success(HOME)
}
func RenderUserCards(c *context.Context, total int, getter func(page int) ([]*db.User, error), tpl string) {
@ -319,12 +319,12 @@ func RenderUserCards(c *context.Context, total int, getter func(page int) ([]*db
items, err := getter(pager.Current())
if err != nil {
c.Handle(500, "getter", err)
c.Error(err, "getter")
return
}
c.Data["Cards"] = items
c.HTML(200, tpl)
c.Success(tpl)
}
func Watchers(c *context.Context) {
@ -346,17 +346,17 @@ func Forks(c *context.Context) {
forks, err := c.Repo.Repository.GetForks()
if err != nil {
c.Handle(500, "GetForks", err)
c.Error(err, "get forks")
return
}
for _, fork := range forks {
if err = fork.GetOwner(); err != nil {
c.Handle(500, "GetOwner", err)
c.Error(err, "get owner")
return
}
}
c.Data["Forks"] = forks
c.HTML(200, FORKS)
c.Success(FORKS)
}

120
internal/route/repo/webhook.go
View File

@ -6,6 +6,7 @@ package repo
import (
"fmt"
"net/http"
"strings"
jsoniter "github.com/json-iterator/go"
@ -36,12 +37,12 @@ func Webhooks(c *context.Context) {
ws, err := db.GetWebhooksByRepoID(c.Repo.Repository.ID)
if err != nil {
c.Handle(500, "GetWebhooksByRepoID", err)
c.Error(err, "get webhooks by repository ID")
return
}
c.Data["Webhooks"] = ws
c.HTML(200, WEBHOOKS)
c.Success(WEBHOOKS)
}
type OrgRepoCtx struct {
@ -77,7 +78,7 @@ func getOrgRepoCtx(c *context.Context) (*OrgRepoCtx, error) {
func checkHookType(c *context.Context) string {
hookType := strings.ToLower(c.Params(":type"))
if !com.IsSliceContainsStr(conf.Webhook.Types, hookType) {
c.Handle(404, "checkHookType", nil)
c.NotFound()
return ""
}
return hookType
@ -91,7 +92,7 @@ func WebhooksNew(c *context.Context) {
orCtx, err := getOrgRepoCtx(c)
if err != nil {
c.Handle(500, "getOrgRepoCtx", err)
c.Error(err, "get organization repository context")
return
}
@ -101,7 +102,7 @@ func WebhooksNew(c *context.Context) {
}
c.Data["BaseLink"] = orCtx.Link
c.HTML(200, orCtx.NewTemplate)
c.Success(orCtx.NewTemplate)
}
func ParseHookEvent(f form.Webhook) *db.HookEvent {
@ -131,13 +132,13 @@ func WebHooksNewPost(c *context.Context, f form.NewWebhook) {
orCtx, err := getOrgRepoCtx(c)
if err != nil {
c.Handle(500, "getOrgRepoCtx", err)
c.Error(err, "get organization repository context")
return
}
c.Data["BaseLink"] = orCtx.Link
if c.HasError() {
c.HTML(200, orCtx.NewTemplate)
c.Success(orCtx.NewTemplate)
return
}
@ -157,10 +158,10 @@ func WebHooksNewPost(c *context.Context, f form.NewWebhook) {
OrgID: orCtx.OrgID,
}
if err := w.UpdateEvent(); err != nil {
c.Handle(500, "UpdateEvent", err)
c.Error(err, "update event")
return
} else if err := db.CreateWebhook(w); err != nil {
c.Handle(500, "CreateWebhook", err)
c.Error(err, "create webhook")
return
}
@ -176,12 +177,12 @@ func SlackHooksNewPost(c *context.Context, f form.NewSlackHook) {
orCtx, err := getOrgRepoCtx(c)
if err != nil {
c.Handle(500, "getOrgRepoCtx", err)
c.Error(err, "get organization repository context")
return
}
if c.HasError() {
c.HTML(200, orCtx.NewTemplate)
c.Success(orCtx.NewTemplate)
return
}
@ -192,7 +193,7 @@ func SlackHooksNewPost(c *context.Context, f form.NewSlackHook) {
Color: f.Color,
})
if err != nil {
c.Handle(500, "Marshal", err)
c.Error(err, "marshal JSON")
return
}
@ -207,10 +208,10 @@ func SlackHooksNewPost(c *context.Context, f form.NewSlackHook) {
OrgID: orCtx.OrgID,
}
if err := w.UpdateEvent(); err != nil {
c.Handle(500, "UpdateEvent", err)
c.Error(err, "update event")
return
} else if err := db.CreateWebhook(w); err != nil {
c.Handle(500, "CreateWebhook", err)
c.Error(err, "create webhook")
return
}
@ -227,12 +228,12 @@ func DiscordHooksNewPost(c *context.Context, f form.NewDiscordHook) {
orCtx, err := getOrgRepoCtx(c)
if err != nil {
c.Handle(500, "getOrgRepoCtx", err)
c.Error(err, "get organization repository context")
return
}
if c.HasError() {
c.HTML(200, orCtx.NewTemplate)
c.Success(orCtx.NewTemplate)
return
}
@ -242,7 +243,7 @@ func DiscordHooksNewPost(c *context.Context, f form.NewDiscordHook) {
Color: f.Color,
})
if err != nil {
c.Handle(500, "Marshal", err)
c.Error(err, "marshal JSON")
return
}
@ -257,10 +258,10 @@ func DiscordHooksNewPost(c *context.Context, f form.NewDiscordHook) {
OrgID: orCtx.OrgID,
}
if err := w.UpdateEvent(); err != nil {
c.Handle(500, "UpdateEvent", err)
c.Error(err, "update event")
return
} else if err := db.CreateWebhook(w); err != nil {
c.Handle(500, "CreateWebhook", err)
c.Error(err, "create webhook")
return
}
@ -276,12 +277,12 @@ func DingtalkHooksNewPost(c *context.Context, f form.NewDingtalkHook) {
orCtx, err := getOrgRepoCtx(c)
if err != nil {
c.Handle(500, "getOrgRepoCtx", err)
c.Error(err, "get organization repository context")
return
}
if c.HasError() {
c.HTML(200, orCtx.NewTemplate)
c.Success(orCtx.NewTemplate)
return
}
@ -295,10 +296,10 @@ func DingtalkHooksNewPost(c *context.Context, f form.NewDingtalkHook) {
OrgID: orCtx.OrgID,
}
if err := w.UpdateEvent(); err != nil {
c.Handle(500, "UpdateEvent", err)
c.Error(err, "update event")
return
} else if err := db.CreateWebhook(w); err != nil {
c.Handle(500, "CreateWebhook", err)
c.Error(err, "create webhook")
return
}
@ -311,7 +312,7 @@ func checkWebhook(c *context.Context) (*OrgRepoCtx, *db.Webhook) {
orCtx, err := getOrgRepoCtx(c)
if err != nil {
c.Handle(500, "getOrgRepoCtx", err)
c.Error(err, "get organization repository context")
return nil, nil
}
c.Data["BaseLink"] = orCtx.Link
@ -323,7 +324,7 @@ func checkWebhook(c *context.Context) (*OrgRepoCtx, *db.Webhook) {
w, err = db.GetWebhookByOrgID(c.Org.Organization.ID, c.ParamsInt64(":id"))
}
if err != nil {
c.NotFoundOrServerError("GetWebhookOfRepoByID/GetWebhookByOrgID", errors.IsWebhookNotExist, err)
c.NotFoundOrError(err, "get webhook")
return nil, nil
}
@ -342,7 +343,8 @@ func checkWebhook(c *context.Context) (*OrgRepoCtx, *db.Webhook) {
c.Data["History"], err = w.History(1)
if err != nil {
c.Handle(500, "History", err)
c.Error(err, "get history")
return nil, nil
}
return orCtx, w
}
@ -358,7 +360,7 @@ func WebHooksEdit(c *context.Context) {
}
c.Data["Webhook"] = w
c.HTML(200, orCtx.NewTemplate)
c.Success(orCtx.NewTemplate)
}
func WebHooksEditPost(c *context.Context, f form.NewWebhook) {
@ -373,7 +375,7 @@ func WebHooksEditPost(c *context.Context, f form.NewWebhook) {
c.Data["Webhook"] = w
if c.HasError() {
c.HTML(200, orCtx.NewTemplate)
c.Success(orCtx.NewTemplate)
return
}
@ -388,10 +390,10 @@ func WebHooksEditPost(c *context.Context, f form.NewWebhook) {
w.HookEvent = ParseHookEvent(f.Webhook)
w.IsActive = f.Active
if err := w.UpdateEvent(); err != nil {
c.Handle(500, "UpdateEvent", err)
c.Error(err, "update event")
return
} else if err := db.UpdateWebhook(w); err != nil {
c.Handle(500, "WebHooksEditPost", err)
c.Error(err, "update webhook")
return
}
@ -411,7 +413,7 @@ func SlackHooksEditPost(c *context.Context, f form.NewSlackHook) {
c.Data["Webhook"] = w
if c.HasError() {
c.HTML(200, orCtx.NewTemplate)
c.Success(orCtx.NewTemplate)
return
}
@ -422,7 +424,7 @@ func SlackHooksEditPost(c *context.Context, f form.NewSlackHook) {
Color: f.Color,
})
if err != nil {
c.Handle(500, "Marshal", err)
c.Error(err, "marshal JSON")
return
}
@ -431,10 +433,10 @@ func SlackHooksEditPost(c *context.Context, f form.NewSlackHook) {
w.HookEvent = ParseHookEvent(f.Webhook)
w.IsActive = f.Active
if err := w.UpdateEvent(); err != nil {
c.Handle(500, "UpdateEvent", err)
c.Error(err, "update event")
return
} else if err := db.UpdateWebhook(w); err != nil {
c.Handle(500, "UpdateWebhook", err)
c.Error(err, "update webhook")
return
}
@ -455,7 +457,7 @@ func DiscordHooksEditPost(c *context.Context, f form.NewDiscordHook) {
c.Data["Webhook"] = w
if c.HasError() {
c.HTML(200, orCtx.NewTemplate)
c.Success(orCtx.NewTemplate)
return
}
@ -465,7 +467,7 @@ func DiscordHooksEditPost(c *context.Context, f form.NewDiscordHook) {
Color: f.Color,
})
if err != nil {
c.Handle(500, "Marshal", err)
c.Error(err, "marshal JSON")
return
}
@ -474,10 +476,10 @@ func DiscordHooksEditPost(c *context.Context, f form.NewDiscordHook) {
w.HookEvent = ParseHookEvent(f.Webhook)
w.IsActive = f.Active
if err := w.UpdateEvent(); err != nil {
c.Handle(500, "UpdateEvent", err)
c.Error(err, "update event")
return
} else if err := db.UpdateWebhook(w); err != nil {
c.Handle(500, "UpdateWebhook", err)
c.Error(err, "update webhook")
return
}
@ -497,7 +499,7 @@ func DingtalkHooksEditPost(c *context.Context, f form.NewDingtalkHook) {
c.Data["Webhook"] = w
if c.HasError() {
c.HTML(200, orCtx.NewTemplate)
c.Success(orCtx.NewTemplate)
return
}
@ -505,10 +507,10 @@ func DingtalkHooksEditPost(c *context.Context, f form.NewDingtalkHook) {
w.HookEvent = ParseHookEvent(f.Webhook)
w.IsActive = f.Active
if err := w.UpdateEvent(); err != nil {
c.Handle(500, "UpdateEvent", err)
c.Error(err, "update event")
return
} else if err := db.UpdateWebhook(w); err != nil {
c.Handle(500, "UpdateWebhook", err)
c.Error(err, "update webhook")
return
}
@ -550,22 +552,22 @@ func TestWebhook(c *context.Context) {
author, err := db.GetUserByEmail(c.Repo.Commit.Author.Email)
if err == nil {
authorUsername = author.Name
} else if !errors.IsUserNotExist(err) {
c.Handle(500, "GetUserByEmail.(author)", err)
} else if !db.IsErrUserNotExist(err) {
c.Error(err, "get user by email")
return
}
user, err := db.GetUserByEmail(c.Repo.Commit.Committer.Email)
if err == nil {
committerUsername = user.Name
} else if !errors.IsUserNotExist(err) {
c.Handle(500, "GetUserByEmail.(committer)", err)
} else if !db.IsErrUserNotExist(err) {
c.Error(err, "get user by email")
return
}
nameStatus, err = c.Repo.Commit.ShowNameStatus()
if err != nil {
c.Handle(500, "FileStatus", err)
c.Error(err, "get changed files")
return
}
}
@ -600,34 +602,36 @@ func TestWebhook(c *context.Context) {
Sender: apiUser,
}
if err := db.TestWebhook(c.Repo.Repository, db.HOOK_EVENT_PUSH, p, c.ParamsInt64("id")); err != nil {
c.Handle(500, "TestWebhook", err)
} else {
c.Flash.Info(c.Tr("repo.settings.webhook.test_delivery_success"))
c.Status(200)
c.Error(err, "test webhook")
return
}
c.Flash.Info(c.Tr("repo.settings.webhook.test_delivery_success"))
c.Status(http.StatusOK)
}
func RedeliveryWebhook(c *context.Context) {
webhook, err := db.GetWebhookOfRepoByID(c.Repo.Repository.ID, c.ParamsInt64(":id"))
if err != nil {
c.NotFoundOrServerError("GetWebhookOfRepoByID/GetWebhookByOrgID", errors.IsWebhookNotExist, err)
c.NotFoundOrError(err, "get webhook")
return
}
hookTask, err := db.GetHookTaskOfWebhookByUUID(webhook.ID, c.Query("uuid"))
if err != nil {
c.NotFoundOrServerError("GetHookTaskOfWebhookByUUID/GetWebhookByOrgID", errors.IsHookTaskNotExist, err)
c.NotFoundOrError(err, "get hook task by UUID")
return
}
hookTask.IsDelivered = false
if err = db.UpdateHookTask(hookTask); err != nil {
c.Handle(500, "UpdateHookTask", err)
} else {
go db.HookQueue.Add(c.Repo.Repository.ID)
c.Flash.Info(c.Tr("repo.settings.webhook.redelivery_success", hookTask.UUID))
c.Status(200)
c.Error(err, "update hook task")
return
}
go db.HookQueue.Add(c.Repo.Repository.ID)
c.Flash.Info(c.Tr("repo.settings.webhook.redelivery_success", hookTask.UUID))
c.Status(http.StatusOK)
}
func DeleteWebhook(c *context.Context) {
@ -637,7 +641,7 @@ func DeleteWebhook(c *context.Context) {
c.Flash.Success(c.Tr("repo.settings.webhook_deletion_success"))
}
c.JSON(200, map[string]interface{}{
c.JSONSuccess(map[string]interface{}{
"redirect": c.Repo.RepoLink + "/settings/hooks",
})
}

44
internal/route/repo/wiki.go
View File

@ -26,7 +26,7 @@ const (
func MustEnableWiki(c *context.Context) {
if !c.Repo.Repository.EnableWiki {
c.Handle(404, "MustEnableWiki", nil)
c.NotFound()
return
}
@ -45,12 +45,12 @@ type PageMeta struct {
func renderWikiPage(c *context.Context, isViewPage bool) (*git.Repository, string) {
wikiRepo, err := git.Open(c.Repo.Repository.WikiPath())
if err != nil {
c.ServerError("open repository", err)
c.Error(err, "open repository")
return nil, ""
}
commit, err := wikiRepo.BranchCommit("master")
if err != nil {
c.ServerError("get branch commit", err)
c.Error(err, "get branch commit")
return nil, ""
}
@ -58,7 +58,7 @@ func renderWikiPage(c *context.Context, isViewPage bool) (*git.Repository, strin
if isViewPage {
entries, err := commit.Entries()
if err != nil {
c.ServerError("list entries", err)
c.Error(err, "list entries")
return nil, ""
}
pages := make([]PageMeta, 0, len(entries))
@ -91,13 +91,13 @@ func renderWikiPage(c *context.Context, isViewPage bool) (*git.Repository, strin
if gitutil.IsErrRevisionNotExist(err) {
c.Redirect(c.Repo.RepoLink + "/wiki/_pages")
} else {
c.ServerError("GetBlobByPath", err)
c.Error(err, "get blob")
}
return nil, ""
}
p, err := blob.Bytes()
if err != nil {
c.ServerError("Data", err)
c.Error(err, "read blob")
return nil, ""
}
if isViewPage {
@ -114,7 +114,7 @@ func Wiki(c *context.Context) {
if !c.Repo.Repository.HasWiki() {
c.Data["Title"] = c.Tr("repo.wiki")
c.HTML(200, WIKI_START)
c.Success(WIKI_START)
return
}
@ -126,12 +126,12 @@ func Wiki(c *context.Context) {
// Get last change information.
commits, err := wikiRepo.Log(git.RefsHeads+"master", git.LogOptions{Path: pageName + ".md"})
if err != nil {
c.ServerError("get commits by path", err)
c.Error(err, "get commits by path")
return
}
c.Data["Author"] = commits[0].Author
c.HTML(200, WIKI_VIEW)
c.Success(WIKI_VIEW)
}
func WikiPages(c *context.Context) {
@ -145,18 +145,18 @@ func WikiPages(c *context.Context) {
wikiRepo, err := git.Open(c.Repo.Repository.WikiPath())
if err != nil {
c.ServerError("open repository", err)
c.Error(err, "open repository")
return
}
commit, err := wikiRepo.BranchCommit("master")
if err != nil {
c.ServerError("get branch commit", err)
c.Error(err, "get branch commit")
return
}
entries, err := commit.Entries()
if err != nil {
c.ServerError("list entries", err)
c.Error(err, "list entries")
return
}
pages := make([]PageMeta, 0, len(entries))
@ -164,7 +164,7 @@ func WikiPages(c *context.Context) {
if entries[i].Type() == git.ObjectBlob && strings.HasSuffix(entries[i].Name(), ".md") {
commits, err := wikiRepo.Log(git.RefsHeads+"master", git.LogOptions{Path: entries[i].Name()})
if err != nil {
c.ServerError("get commits by path", err)
c.Error(err, "get commits by path")
return
}
name := strings.TrimSuffix(entries[i].Name(), ".md")
@ -177,7 +177,7 @@ func WikiPages(c *context.Context) {
}
c.Data["Pages"] = pages
c.HTML(200, WIKI_PAGES)
c.Success(WIKI_PAGES)
}
func NewWiki(c *context.Context) {
@ -189,7 +189,7 @@ func NewWiki(c *context.Context) {
c.Data["title"] = "Home"
}
c.HTML(200, WIKI_NEW)
c.Success(WIKI_NEW)
}
func NewWikiPost(c *context.Context, f form.NewWiki) {
@ -198,7 +198,7 @@ func NewWikiPost(c *context.Context, f form.NewWiki) {
c.Data["RequireSimpleMDE"] = true
if c.HasError() {
c.HTML(200, WIKI_NEW)
c.Success(WIKI_NEW)
return
}
@ -207,7 +207,7 @@ func NewWikiPost(c *context.Context, f form.NewWiki) {
c.Data["Err_Title"] = true
c.RenderWithErr(c.Tr("repo.wiki.page_already_exists"), WIKI_NEW, &f)
} else {
c.ServerError("AddWikiPage", err)
c.Error(err, "add wiki page")
}
return
}
@ -230,7 +230,7 @@ func EditWiki(c *context.Context) {
return
}
c.HTML(200, WIKI_NEW)
c.Success(WIKI_NEW)
}
func EditWikiPost(c *context.Context, f form.NewWiki) {
@ -239,12 +239,12 @@ func EditWikiPost(c *context.Context, f form.NewWiki) {
c.Data["RequireSimpleMDE"] = true
if c.HasError() {
c.HTML(200, WIKI_NEW)
c.Success(WIKI_NEW)
return
}
if err := c.Repo.Repository.EditWikiPage(c.User, f.OldTitle, f.Title, f.Content, f.Message); err != nil {
c.ServerError("EditWikiPage", err)
c.Error(err, "edit wiki page")
return
}
@ -259,11 +259,11 @@ func DeleteWikiPagePost(c *context.Context) {
pageName := db.ToWikiPageName(pageURL)
if err := c.Repo.Repository.DeleteWikiPage(c.User, pageName); err != nil {
c.ServerError("DeleteWikiPage", err)
c.Error(err, "delete wiki page")
return
}
c.JSON(200, map[string]interface{}{
c.JSONSuccess(map[string]interface{}{
"redirect": c.Repo.RepoLink + "/wiki/",
})
}

68
internal/route/user/auth.go
View File

@ -53,8 +53,8 @@ func AutoLogin(c *context.Context) (bool, error) {
u, err := db.GetUserByName(uname)
if err != nil {
if !errors.IsUserNotExist(err) {
return false, fmt.Errorf("GetUserByName: %v", err)
if !db.IsErrUserNotExist(err) {
return false, fmt.Errorf("get user by name: %v", err)
}
return false, nil
}
@ -79,7 +79,7 @@ func Login(c *context.Context) {
// Check auto-login
isSucceed, err := AutoLogin(c)
if err != nil {
c.ServerError("AutoLogin", err)
c.Error(err, "auto login")
return
}
@ -94,7 +94,7 @@ func Login(c *context.Context) {
if tool.IsSameSiteURLPath(redirectTo) {
c.Redirect(redirectTo)
} else {
c.SubURLRedirect("/")
c.RedirectSubpath("/")
}
c.SetCookie("redirect_to", "", -1, conf.Server.Subpath)
return
@ -103,7 +103,7 @@ func Login(c *context.Context) {
// Display normal login page
loginSources, err := db.ActivatedLoginSources()
if err != nil {
c.ServerError("ActivatedLoginSources", err)
c.Error(err, "list activated login sources")
return
}
c.Data["LoginSources"] = loginSources
@ -142,7 +142,7 @@ func afterLogin(c *context.Context, u *db.User, remember bool) {
return
}
c.SubURLRedirect("/")
c.RedirectSubpath("/")
}
func LoginPost(c *context.Context, f form.SignIn) {
@ -150,7 +150,7 @@ func LoginPost(c *context.Context, f form.SignIn) {
loginSources, err := db.ActivatedLoginSources()
if err != nil {
c.ServerError("ActivatedLoginSources", err)
c.Error(err, "list activated login sources")
return
}
c.Data["LoginSources"] = loginSources
@ -163,7 +163,7 @@ func LoginPost(c *context.Context, f form.SignIn) {
u, err := db.UserLogin(f.UserName, f.Password, f.LoginSource)
if err != nil {
switch err.(type) {
case errors.UserNotExist:
case db.ErrUserNotExist:
c.FormErr("UserName", "Password")
c.RenderWithErr(c.Tr("form.username_password_incorrect"), LOGIN, &f)
case errors.LoginSourceMismatch:
@ -171,7 +171,7 @@ func LoginPost(c *context.Context, f form.SignIn) {
c.RenderWithErr(c.Tr("form.auth_source_mismatch"), LOGIN, &f)
default:
c.ServerError("UserLogin", err)
c.Error(err, "authenticate user")
}
for i := range loginSources {
if loginSources[i].IsDefault {
@ -189,7 +189,7 @@ func LoginPost(c *context.Context, f form.SignIn) {
c.Session.Set("twoFactorRemember", f.Remember)
c.Session.Set("twoFactorUserID", u.ID)
c.SubURLRedirect("/user/login/two_factor")
c.RedirectSubpath("/user/login/two_factor")
}
func LoginTwoFactor(c *context.Context) {
@ -211,31 +211,31 @@ func LoginTwoFactorPost(c *context.Context) {
t, err := db.GetTwoFactorByUserID(userID)
if err != nil {
c.ServerError("GetTwoFactorByUserID", err)
c.Error(err, "get two factor by user ID")
return
}
passcode := c.Query("passcode")
valid, err := t.ValidateTOTP(passcode)
if err != nil {
c.ServerError("ValidateTOTP", err)
c.Error(err, "validate TOTP")
return
} else if !valid {
c.Flash.Error(c.Tr("settings.two_factor_invalid_passcode"))
c.SubURLRedirect("/user/login/two_factor")
c.RedirectSubpath("/user/login/two_factor")
return
}
u, err := db.GetUserByID(userID)
if err != nil {
c.ServerError("GetUserByID", err)
c.Error(err, "get user by ID")
return
}
// Prevent same passcode from being reused
if c.Cache.IsExist(u.TwoFactorCacheKey(passcode)) {
c.Flash.Error(c.Tr("settings.two_factor_reused_passcode"))
c.SubURLRedirect("/user/login/two_factor")
c.RedirectSubpath("/user/login/two_factor")
return
}
if err = c.Cache.Put(u.TwoFactorCacheKey(passcode), 1, 60); err != nil {
@ -265,16 +265,16 @@ func LoginTwoFactorRecoveryCodePost(c *context.Context) {
if err := db.UseRecoveryCode(userID, c.Query("recovery_code")); err != nil {
if errors.IsTwoFactorRecoveryCodeNotFound(err) {
c.Flash.Error(c.Tr("auth.login_two_factor_invalid_recovery_code"))
c.SubURLRedirect("/user/login/two_factor_recovery_code")
c.RedirectSubpath("/user/login/two_factor_recovery_code")
} else {
c.ServerError("UseRecoveryCode", err)
c.Error(err, "use recovery code")
}
return
}
u, err := db.GetUserByID(userID)
if err != nil {
c.ServerError("GetUserByID", err)
c.Error(err, "get user by ID")
return
}
afterLogin(c, u, c.Session.Get("twoFactorRemember").(bool))
@ -286,7 +286,7 @@ func SignOut(c *context.Context) {
c.SetCookie(conf.Security.CookieUsername, "", -1, conf.Server.Subpath)
c.SetCookie(conf.Security.CookieRememberName, "", -1, conf.Server.Subpath)
c.SetCookie(conf.Session.CSRFCookieName, "", -1, conf.Server.Subpath)
c.SubURLRedirect("/")
c.RedirectSubpath("/")
}
func SignUp(c *context.Context) {
@ -351,7 +351,7 @@ func SignUpPost(c *context.Context, cpt *captcha.Captcha, f form.Register) {
c.FormErr("UserName")
c.RenderWithErr(c.Tr("user.form.name_pattern_not_allowed", err.(db.ErrNamePatternNotAllowed).Pattern), SIGNUP, &f)
default:
c.ServerError("CreateUser", err)
c.Error(err, "create user")
}
return
}
@ -362,7 +362,7 @@ func SignUpPost(c *context.Context, cpt *captcha.Captcha, f form.Register) {
u.IsAdmin = true
u.IsActive = true
if err := db.UpdateUser(u); err != nil {
c.ServerError("UpdateUser", err)
c.Error(err, "update user")
return
}
}
@ -381,7 +381,7 @@ func SignUpPost(c *context.Context, cpt *captcha.Captcha, f form.Register) {
return
}
c.SubURLRedirect("/user/login")
c.RedirectSubpath("/user/login")
}
func Activate(c *context.Context) {
@ -416,11 +416,11 @@ func Activate(c *context.Context) {
user.IsActive = true
var err error
if user.Rands, err = db.GetUserSalt(); err != nil {
c.ServerError("GetUserSalt", err)
c.Error(err, "get user salt")
return
}
if err := db.UpdateUser(user); err != nil {
c.ServerError("UpdateUser", err)
c.Error(err, "update user")
return
}
@ -428,7 +428,7 @@ func Activate(c *context.Context) {
c.Session.Set("uid", user.ID)
c.Session.Set("uname", user.Name)
c.SubURLRedirect("/")
c.RedirectSubpath("/")
return
}
@ -443,14 +443,14 @@ func ActivateEmail(c *context.Context) {
// Verify code.
if email := db.VerifyActiveEmailCode(code, emailAddr); email != nil {
if err := email.Activate(); err != nil {
c.ServerError("ActivateEmail", err)
c.Error(err, "activate email")
}
log.Trace("Email activated: %s", email.Email)
c.Flash.Success(c.Tr("settings.add_email_success"))
}
c.SubURLRedirect("/user/settings/email")
c.RedirectSubpath("/user/settings/email")
}
func ForgotPasswd(c *context.Context) {
@ -480,14 +480,14 @@ func ForgotPasswdPost(c *context.Context) {
u, err := db.GetUserByEmail(emailAddr)
if err != nil {
if errors.IsUserNotExist(err) {
if db.IsErrUserNotExist(err) {
c.Data["Hours"] = conf.Auth.ActivateCodeLives / 60
c.Data["IsResetSent"] = true
c.Success(FORGOT_PASSWORD)
return
} else {
c.ServerError("GetUserByEmail", err)
}
c.Error(err, "get user by email")
return
}
@ -549,21 +549,21 @@ func ResetPasswdPost(c *context.Context) {
u.Passwd = passwd
var err error
if u.Rands, err = db.GetUserSalt(); err != nil {
c.ServerError("GetUserSalt", err)
c.Error(err, "get user salt")
return
}
if u.Salt, err = db.GetUserSalt(); err != nil {
c.ServerError("GetUserSalt", err)
c.Error(err, "get user salt")
return
}
u.EncodePasswd()
if err := db.UpdateUser(u); err != nil {
c.ServerError("UpdateUser", err)
c.Error(err, "update user")
return
}
log.Trace("User password reset: %s", u.Name)
c.SubURLRedirect("/user/login")
c.RedirectSubpath("/user/login")
return
}

62
internal/route/user/home.go
View File

@ -7,6 +7,7 @@ package user
import (
"bytes"
"fmt"
"net/http"
"github.com/unknwon/com"
"github.com/unknwon/paginater"
@ -14,7 +15,6 @@ import (
"gogs.io/gogs/internal/conf"
"gogs.io/gogs/internal/context"
"gogs.io/gogs/internal/db"
"gogs.io/gogs/internal/db/errors"
)
const (
@ -33,7 +33,7 @@ func getDashboardContextUser(c *context.Context) *db.User {
// Organization.
org, err := db.GetUserByName(orgName)
if err != nil {
c.NotFoundOrServerError("GetUserByName", errors.IsUserNotExist, err)
c.NotFoundOrError(err, "get user by name")
return nil
}
ctxUser = org
@ -41,7 +41,7 @@ func getDashboardContextUser(c *context.Context) *db.User {
c.Data["ContextUser"] = ctxUser
if err := c.User.GetOrganizations(true); err != nil {
c.Handle(500, "GetOrganizations", err)
c.Error(err, "get organizations")
return nil
}
c.Data["Orgs"] = c.User.Orgs
@ -55,7 +55,7 @@ func getDashboardContextUser(c *context.Context) *db.User {
func retrieveFeeds(c *context.Context, ctxUser *db.User, userID int64, isProfile bool) {
actions, err := db.GetFeeds(ctxUser, userID, c.QueryInt64("after_id"), isProfile)
if err != nil {
c.Handle(500, "GetFeeds", err)
c.Error(err, "get feeds")
return
}
@ -68,10 +68,10 @@ func retrieveFeeds(c *context.Context, ctxUser *db.User, userID int64, isProfile
if !ok {
u, err := db.GetUserByName(act.ActUserName)
if err != nil {
if errors.IsUserNotExist(err) {
if db.IsErrUserNotExist(err) {
continue
}
c.Handle(500, "GetUserByName", err)
c.Error(err, "get user by name")
return
}
unameAvatars[act.ActUserName] = u.RelAvatarLink()
@ -100,7 +100,7 @@ func Dashboard(c *context.Context) {
}
if c.Req.Header.Get("X-AJAX") == "true" {
c.HTML(200, NEWS_FEED)
c.Success(NEWS_FEED)
return
}
@ -112,10 +112,10 @@ func Dashboard(c *context.Context) {
if !ctxUser.IsOrganization() {
collaborateRepos, err := c.User.GetAccessibleRepositories(conf.UI.User.RepoPagingNum)
if err != nil {
c.Handle(500, "GetAccessibleRepositories", err)
c.Error(err, "get accessible repositories")
return
} else if err = db.RepositoryList(collaborateRepos).LoadAttributes(); err != nil {
c.Handle(500, "RepositoryList.LoadAttributes", err)
c.Error(err, "load attributes")
return
}
c.Data["CollaborativeRepos"] = collaborateRepos
@ -127,18 +127,18 @@ func Dashboard(c *context.Context) {
if ctxUser.IsOrganization() {
repos, repoCount, err = ctxUser.GetUserRepositories(c.User.ID, 1, conf.UI.User.RepoPagingNum)
if err != nil {
c.Handle(500, "GetUserRepositories", err)
c.Error(err, "get user repositories")
return
}
mirrors, err = ctxUser.GetUserMirrorRepositories(c.User.ID)
if err != nil {
c.Handle(500, "GetUserMirrorRepositories", err)
c.Error(err, "get user mirror repositories")
return
}
} else {
if err = ctxUser.GetRepositories(1, conf.UI.User.RepoPagingNum); err != nil {
c.Handle(500, "GetRepositories", err)
c.Error(err, "get repositories")
return
}
repos = ctxUser.Repos
@ -146,7 +146,7 @@ func Dashboard(c *context.Context) {
mirrors, err = ctxUser.GetMirrorRepositories()
if err != nil {
c.Handle(500, "GetMirrorRepositories", err)
c.Error(err, "get mirror repositories")
return
}
}
@ -155,13 +155,13 @@ func Dashboard(c *context.Context) {
c.Data["MaxShowRepoNum"] = conf.UI.User.RepoPagingNum
if err := db.MirrorRepositoryList(mirrors).LoadAttributes(); err != nil {
c.Handle(500, "MirrorRepositoryList.LoadAttributes", err)
c.Error(err, "load attributes")
return
}
c.Data["MirrorCount"] = len(mirrors)
c.Data["Mirrors"] = mirrors
c.HTML(200, DASHBOARD)
c.Success(DASHBOARD)
}
func Issues(c *context.Context) {
@ -216,12 +216,12 @@ func Issues(c *context.Context) {
if ctxUser.IsOrganization() {
repos, _, err = ctxUser.GetUserRepositories(c.User.ID, 1, ctxUser.NumRepos)
if err != nil {
c.Handle(500, "GetRepositories", err)
c.Error(err, "get repositories")
return
}
} else {
if err := ctxUser.GetRepositories(1, c.User.NumRepos); err != nil {
c.Handle(500, "GetRepositories", err)
c.Error(err, "get repositories")
return
}
repos = ctxUser.Repos
@ -255,7 +255,7 @@ func Issues(c *context.Context) {
if !isPullList {
userRepoIDs, err = db.FilterRepositoryWithIssues(userRepoIDs)
if err != nil {
c.Handle(500, "FilterRepositoryWithIssues", err)
c.Error(err, "filter repositories with issues")
return
}
}
@ -287,32 +287,32 @@ func Issues(c *context.Context) {
issues, err := db.Issues(issueOptions)
if err != nil {
c.Handle(500, "Issues", err)
c.Error(err, "list issues")
return
}
if repoID > 0 {
repo, err := db.GetRepositoryByID(repoID)
if err != nil {
c.Handle(500, "GetRepositoryByID", fmt.Errorf("[#%d] %v", repoID, err))
c.Error(err, "get repository by ID")
return
}
if err = repo.GetOwner(); err != nil {
c.Handle(500, "GetOwner", fmt.Errorf("[#%d] %v", repoID, err))
c.Error(err, "get owner")
return
}
// Check if user has access to given repository.
if !repo.IsOwnedBy(ctxUser.ID) && !repo.HasAccess(ctxUser.ID) {
c.Handle(404, "Issues", fmt.Errorf("#%d", repoID))
c.NotFound()
return
}
}
for _, issue := range issues {
if err = issue.Repo.GetOwner(); err != nil {
c.Handle(500, "GetOwner", fmt.Errorf("[#%d] %v", issue.RepoID, err))
c.Error(err, "get owner")
return
}
}
@ -341,13 +341,13 @@ func Issues(c *context.Context) {
c.Data["State"] = "open"
}
c.HTML(200, ISSUES)
c.Success(ISSUES)
}
func ShowSSHKeys(c *context.Context, uid int64) {
keys, err := db.ListPublicKeys(uid)
if err != nil {
c.Handle(500, "ListPublicKeys", err)
c.Error(err, "list public keys")
return
}
@ -356,7 +356,7 @@ func ShowSSHKeys(c *context.Context, uid int64) {
buf.WriteString(keys[i].OmitEmail())
buf.WriteString("\n")
}
c.PlainText(200, buf.Bytes())
c.PlainText(http.StatusOK, buf.String())
}
func showOrgProfile(c *context.Context) {
@ -382,7 +382,7 @@ func showOrgProfile(c *context.Context) {
if c.IsLogged && !c.User.IsAdmin {
repos, count, err = org.GetUserRepositories(c.User.ID, page, conf.UI.User.RepoPagingNum)
if err != nil {
c.Handle(500, "GetUserRepositories", err)
c.Error(err, "get user repositories")
return
}
c.Data["Repos"] = repos
@ -395,7 +395,7 @@ func showOrgProfile(c *context.Context) {
PageSize: conf.UI.User.RepoPagingNum,
})
if err != nil {
c.Handle(500, "GetRepositories", err)
c.Error(err, "get user repositories")
return
}
c.Data["Repos"] = repos
@ -404,20 +404,20 @@ func showOrgProfile(c *context.Context) {
c.Data["Page"] = paginater.New(int(count), conf.UI.User.RepoPagingNum, page, 5)
if err := org.GetMembers(); err != nil {
c.Handle(500, "GetMembers", err)
c.Error(err, "get members")
return
}
c.Data["Members"] = org.Members
c.Data["Teams"] = org.Teams
c.HTML(200, ORG_HOME)
c.Success(ORG_HOME)
}
func Email2User(c *context.Context) {
u, err := db.GetUserByEmail(c.Query("email"))
if err != nil {
c.NotFoundOrServerError("GetUserByEmail", errors.IsUserNotExist, err)
c.NotFoundOrError(err, "get user by email")
return
}
c.Redirect(conf.Server.Subpath + "/user/" + u.Name)

15
internal/route/user/profile.go
View File

@ -5,15 +5,14 @@
package user
import (
"fmt"
repo2 "gogs.io/gogs/internal/route/repo"
"strings"
"github.com/unknwon/paginater"
"gogs.io/gogs/internal/conf"
"gogs.io/gogs/internal/context"
"gogs.io/gogs/internal/db"
"gogs.io/gogs/internal/conf"
"gogs.io/gogs/internal/route/repo"
"gogs.io/gogs/internal/tool"
)
@ -45,7 +44,7 @@ func Profile(c *context.Context, puser *context.ParamsUser) {
orgs, err := db.GetOrgsByUserID(puser.ID, c.IsLogged && (c.User.IsAdmin || c.User.ID == puser.ID))
if err != nil {
c.ServerError("GetOrgsByUserIDDesc", err)
c.Error(err, "get organizations by user ID")
return
}
@ -73,7 +72,7 @@ func Profile(c *context.Context, puser *context.ParamsUser) {
PageSize: conf.UI.User.RepoPagingNum,
})
if err != nil {
c.ServerError("GetRepositories", err)
c.Error(err, "get user repositories")
return
}
@ -89,7 +88,7 @@ func Followers(c *context.Context, puser *context.ParamsUser) {
c.PageIs("Followers")
c.Data["CardsTitle"] = c.Tr("user.followers")
c.Data["Owner"] = puser
repo2.RenderUserCards(c, puser.NumFollowers, puser.GetFollowers, FOLLOWERS)
repo.RenderUserCards(c, puser.NumFollowers, puser.GetFollowers, FOLLOWERS)
}
func Following(c *context.Context, puser *context.ParamsUser) {
@ -97,7 +96,7 @@ func Following(c *context.Context, puser *context.ParamsUser) {
c.PageIs("Following")
c.Data["CardsTitle"] = c.Tr("user.following")
c.Data["Owner"] = puser
repo2.RenderUserCards(c, puser.NumFollowing, puser.GetFollowing, FOLLOWERS)
repo.RenderUserCards(c, puser.NumFollowing, puser.GetFollowing, FOLLOWERS)
}
func Stars(c *context.Context) {
@ -114,7 +113,7 @@ func Action(c *context.Context, puser *context.ParamsUser) {
}
if err != nil {
c.ServerError(fmt.Sprintf("Action (%s)", c.Params(":action")), err)
c.Errorf(err, "action %q", c.Params(":action"))
return
}

88
internal/route/user/setting.go
View File

@ -80,7 +80,7 @@ func SettingsPost(c *context.Context, f form.UpdateProfile) {
case db.IsErrNamePatternNotAllowed(err):
msg = c.Tr("form.name_pattern_not_allowed")
default:
c.ServerError("ChangeUserName", err)
c.Error(err, "change user name")
return
}
@ -106,12 +106,12 @@ func SettingsPost(c *context.Context, f form.UpdateProfile) {
c.RenderWithErr(msg, SETTINGS_PROFILE, &f)
return
}
c.ServerError("UpdateUser", err)
c.Errorf(err, "update user")
return
}
c.Flash.Success(c.Tr("settings.update_profile_success"))
c.SubURLRedirect("/user/settings")
c.RedirectSubpath("/user/settings")
}
// FIXME: limit upload size
@ -169,7 +169,7 @@ func SettingsAvatarPost(c *context.Context, f form.Avatar) {
c.Flash.Success(c.Tr("settings.update_avatar_success"))
}
c.SubURLRedirect("/user/settings/avatar")
c.RedirectSubpath("/user/settings/avatar")
}
func SettingsDeleteAvatar(c *context.Context) {
@ -177,7 +177,7 @@ func SettingsDeleteAvatar(c *context.Context) {
c.Flash.Error(fmt.Sprintf("Failed to delete avatar: %v", err))
}
c.SubURLRedirect("/user/settings/avatar")
c.RedirectSubpath("/user/settings/avatar")
}
func SettingsPassword(c *context.Context) {
@ -203,18 +203,18 @@ func SettingsPasswordPost(c *context.Context, f form.ChangePassword) {
c.User.Passwd = f.Password
var err error
if c.User.Salt, err = db.GetUserSalt(); err != nil {
c.ServerError("GetUserSalt", err)
c.Errorf(err, "get user salt")
return
}
c.User.EncodePasswd()
if err := db.UpdateUser(c.User); err != nil {
c.ServerError("UpdateUser", err)
c.Errorf(err, "update user")
return
}
c.Flash.Success(c.Tr("settings.change_password_success"))
}
c.SubURLRedirect("/user/settings/password")
c.RedirectSubpath("/user/settings/password")
}
func SettingsEmails(c *context.Context) {
@ -223,7 +223,7 @@ func SettingsEmails(c *context.Context) {
emails, err := db.GetEmailAddresses(c.User.ID)
if err != nil {
c.ServerError("GetEmailAddresses", err)
c.Errorf(err, "get email addresses")
return
}
c.Data["Emails"] = emails
@ -238,18 +238,18 @@ func SettingsEmailPost(c *context.Context, f form.AddEmail) {
// Make emailaddress primary.
if c.Query("_method") == "PRIMARY" {
if err := db.MakeEmailPrimary(c.UserID(), &db.EmailAddress{ID: c.QueryInt64("id")}); err != nil {
c.ServerError("MakeEmailPrimary", err)
c.Errorf(err, "make email primary")
return
}
c.SubURLRedirect("/user/settings/email")
c.RedirectSubpath("/user/settings/email")
return
}
// Add Email address.
emails, err := db.GetEmailAddresses(c.User.ID)
if err != nil {
c.ServerError("GetEmailAddresses", err)
c.Errorf(err, "get email addresses")
return
}
c.Data["Emails"] = emails
@ -268,7 +268,7 @@ func SettingsEmailPost(c *context.Context, f form.AddEmail) {
if db.IsErrEmailAlreadyUsed(err) {
c.RenderWithErr(c.Tr("form.email_been_used"), SETTINGS_EMAILS, &f)
} else {
c.ServerError("AddEmailAddress", err)
c.Errorf(err, "add email address")
}
return
}
@ -285,7 +285,7 @@ func SettingsEmailPost(c *context.Context, f form.AddEmail) {
c.Flash.Success(c.Tr("settings.add_email_success"))
}
c.SubURLRedirect("/user/settings/email")
c.RedirectSubpath("/user/settings/email")
}
func DeleteEmail(c *context.Context) {
@ -293,7 +293,7 @@ func DeleteEmail(c *context.Context) {
ID: c.QueryInt64("id"),
UID: c.User.ID,
}); err != nil {
c.ServerError("DeleteEmailAddress", err)
c.Errorf(err, "delete email address")
return
}
@ -309,7 +309,7 @@ func SettingsSSHKeys(c *context.Context) {
keys, err := db.ListPublicKeys(c.User.ID)
if err != nil {
c.ServerError("ListPublicKeys", err)
c.Errorf(err, "list public keys")
return
}
c.Data["Keys"] = keys
@ -323,7 +323,7 @@ func SettingsSSHKeysPost(c *context.Context, f form.AddSSHKey) {
keys, err := db.ListPublicKeys(c.User.ID)
if err != nil {
c.ServerError("ListPublicKeys", err)
c.Errorf(err, "list public keys")
return
}
c.Data["Keys"] = keys
@ -339,7 +339,7 @@ func SettingsSSHKeysPost(c *context.Context, f form.AddSSHKey) {
c.Flash.Info(c.Tr("form.unable_verify_ssh_key"))
} else {
c.Flash.Error(c.Tr("form.invalid_ssh_key", err.Error()))
c.SubURLRedirect("/user/settings/ssh")
c.RedirectSubpath("/user/settings/ssh")
return
}
}
@ -354,13 +354,13 @@ func SettingsSSHKeysPost(c *context.Context, f form.AddSSHKey) {
c.FormErr("Title")
c.RenderWithErr(c.Tr("settings.ssh_key_name_used"), SETTINGS_SSH_KEYS, &f)
default:
c.ServerError("AddPublicKey", err)
c.Errorf(err, "add public key")
}
return
}
c.Flash.Success(c.Tr("settings.add_key_success", f.Title))
c.SubURLRedirect("/user/settings/ssh")
c.RedirectSubpath("/user/settings/ssh")
}
func DeleteSSHKey(c *context.Context) {
@ -381,7 +381,7 @@ func SettingsSecurity(c *context.Context) {
t, err := db.GetTwoFactorByUserID(c.UserID())
if err != nil && !errors.IsTwoFactorNotFound(err) {
c.ServerError("GetTwoFactorByUserID", err)
c.Errorf(err, "get two factor by user ID")
return
}
c.Data["TwoFactor"] = t
@ -410,7 +410,7 @@ func SettingsTwoFactorEnable(c *context.Context) {
AccountName: c.User.Email,
})
if err != nil {
c.ServerError("Generate", err)
c.Errorf(err, "generate TOTP")
return
}
}
@ -418,13 +418,13 @@ func SettingsTwoFactorEnable(c *context.Context) {
img, err := key.Image(240, 240)
if err != nil {
c.ServerError("Image", err)
c.Errorf(err, "generate image")
return
}
var buf bytes.Buffer
if err = png.Encode(&buf, img); err != nil {
c.ServerError("Encode", err)
c.Errorf(err, "encode image")
return
}
c.Data["QRCode"] = template.URL("data:image/png;base64," + base64.StdEncoding.EncodeToString(buf.Bytes()))
@ -443,20 +443,20 @@ func SettingsTwoFactorEnablePost(c *context.Context) {
if !totp.Validate(c.Query("passcode"), secret) {
c.Flash.Error(c.Tr("settings.two_factor_invalid_passcode"))
c.SubURLRedirect("/user/settings/security/two_factor_enable")
c.RedirectSubpath("/user/settings/security/two_factor_enable")
return
}
if err := db.NewTwoFactor(c.UserID(), secret); err != nil {
c.Flash.Error(c.Tr("settings.two_factor_enable_error", err))
c.SubURLRedirect("/user/settings/security/two_factor_enable")
c.RedirectSubpath("/user/settings/security/two_factor_enable")
return
}
c.Session.Delete("twoFactorSecret")
c.Session.Delete("twoFactorURL")
c.Flash.Success(c.Tr("settings.two_factor_enable_success"))
c.SubURLRedirect("/user/settings/security/two_factor_recovery_codes")
c.RedirectSubpath("/user/settings/security/two_factor_recovery_codes")
}
func SettingsTwoFactorRecoveryCodes(c *context.Context) {
@ -470,7 +470,7 @@ func SettingsTwoFactorRecoveryCodes(c *context.Context) {
recoveryCodes, err := db.GetRecoveryCodesByUserID(c.UserID())
if err != nil {
c.ServerError("GetRecoveryCodesByUserID", err)
c.Errorf(err, "get recovery codes by user ID")
return
}
c.Data["RecoveryCodes"] = recoveryCodes
@ -490,7 +490,7 @@ func SettingsTwoFactorRecoveryCodesPost(c *context.Context) {
c.Flash.Success(c.Tr("settings.two_factor_regenerate_recovery_codes_success"))
}
c.SubURLRedirect("/user/settings/security/two_factor_recovery_codes")
c.RedirectSubpath("/user/settings/security/two_factor_recovery_codes")
}
func SettingsTwoFactorDisable(c *context.Context) {
@ -500,7 +500,7 @@ func SettingsTwoFactorDisable(c *context.Context) {
}
if err := db.DeleteTwoFactor(c.UserID()); err != nil {
c.ServerError("DeleteTwoFactor", err)
c.Errorf(err, "delete two factor")
return
}
@ -516,11 +516,11 @@ func SettingsRepos(c *context.Context) {
repos, err := db.GetUserAndCollaborativeRepositories(c.User.ID)
if err != nil {
c.ServerError("GetUserAndCollaborativeRepositories", err)
c.Errorf(err, "get user and collaborative repositories")
return
}
if err = db.RepositoryList(repos).LoadAttributes(); err != nil {
c.ServerError("LoadAttributes", err)
c.Errorf(err, "load attributes")
return
}
c.Data["Repos"] = repos
@ -531,12 +531,12 @@ func SettingsRepos(c *context.Context) {
func SettingsLeaveRepo(c *context.Context) {
repo, err := db.GetRepositoryByID(c.QueryInt64("id"))
if err != nil {
c.NotFoundOrServerError("GetRepositoryByID", errors.IsRepoNotExist, err)
c.NotFoundOrError(err, "get repository by ID")
return
}
if err = repo.DeleteCollaboration(c.User.ID); err != nil {
c.ServerError("DeleteCollaboration", err)
c.Errorf(err, "delete collaboration")
return
}
@ -552,7 +552,7 @@ func SettingsOrganizations(c *context.Context) {
orgs, err := db.GetOrgsByUserID(c.User.ID, true)
if err != nil {
c.ServerError("GetOrgsByUserID", err)
c.Errorf(err, "get organizations by user ID")
return
}
c.Data["Orgs"] = orgs
@ -565,7 +565,7 @@ func SettingsLeaveOrganization(c *context.Context) {
if db.IsErrLastOrgOwner(err) {
c.Flash.Error(c.Tr("form.last_org_owner"))
} else {
c.ServerError("RemoveOrgUser", err)
c.Errorf(err, "remove organization user")
return
}
}
@ -581,7 +581,7 @@ func SettingsApplications(c *context.Context) {
tokens, err := db.ListAccessTokens(c.User.ID)
if err != nil {
c.ServerError("ListAccessTokens", err)
c.Errorf(err, "list access tokens")
return
}
c.Data["Tokens"] = tokens
@ -596,7 +596,7 @@ func SettingsApplicationsPost(c *context.Context, f form.NewAccessToken) {
if c.HasError() {
tokens, err := db.ListAccessTokens(c.User.ID)
if err != nil {
c.ServerError("ListAccessTokens", err)
c.Errorf(err, "list access tokens")
return
}
@ -612,16 +612,16 @@ func SettingsApplicationsPost(c *context.Context, f form.NewAccessToken) {
if err := db.NewAccessToken(t); err != nil {
if errors.IsAccessTokenNameAlreadyExist(err) {
c.Flash.Error(c.Tr("settings.token_name_exists"))
c.SubURLRedirect("/user/settings/applications")
c.RedirectSubpath("/user/settings/applications")
} else {
c.ServerError("NewAccessToken", err)
c.Errorf(err, "new access token")
}
return
}
c.Flash.Success(c.Tr("settings.generate_token_succees"))
c.Flash.Info(t.Sha1)
c.SubURLRedirect("/user/settings/applications")
c.RedirectSubpath("/user/settings/applications")
}
func SettingsDeleteApplication(c *context.Context) {
@ -642,10 +642,10 @@ func SettingsDelete(c *context.Context) {
if c.Req.Method == "POST" {
if _, err := db.UserLogin(c.User.Name, c.Query("password"), c.User.LoginSource); err != nil {
if errors.IsUserNotExist(err) {
if db.IsErrUserNotExist(err) {
c.RenderWithErr(c.Tr("form.enterred_invalid_password"), SETTINGS_DELETE, nil)
} else {
c.ServerError("UserLogin", err)
c.Errorf(err, "authenticate user")
}
return
}
@ -659,7 +659,7 @@ func SettingsDelete(c *context.Context) {
c.Flash.Error(c.Tr("form.still_has_org"))
c.Redirect(conf.Server.Subpath + "/user/settings/delete")
default:
c.ServerError("DeleteUser", err)
c.Errorf(err, "delete user")
}
} else {
log.Trace("Account deleted: %s", c.User.Name)

1
internal/template/template.go
View File

@ -256,6 +256,7 @@ func ActionContent2Commits(act Actioner) *db.PushCommits {
return push
}
// TODO(unknwon): Use url.Escape.
func EscapePound(str string) string {
return strings.NewReplacer("%", "%25", "#", "%23", " ", "%20", "?", "%3F").Replace(str)
}