clean code

diff --git a/modules/middleware/context.go b/modules/middleware/context.go
index dccd3351c735693e0f19724a2cf2071f4624043a..7a1dba3d65c70704b5ca9f3b854febb46077212d 100644 (file)
--- a/modules/middleware/context.go
+++ b/modules/middleware/context.go
@@ -58,10 +58,11 @@ func InitContext() martini.Handler {
                ctx := &Context{
                        c: c,
                        // p:      p,
-                       Req:    r,
-                       Res:    res,
-                       Data:   data,
-                       Render: rd,
+                       Req:     r,
+                       Res:     res,
+                       Session: session,
+                       Data:    data,
+                       Render:  rd,
                }
 
                // Get user from session if logined.

diff --git a/routers/dashboard.go b/routers/dashboard.go
index de9378b0fa73118283529380bdff8c06f5c5a25a..cab1662fc3a8b0b3c57f332bd44d9941012073fb 100644 (file)
--- a/routers/dashboard.go
+++ b/routers/dashboard.go
@@ -5,20 +5,15 @@
 package routers
 
 import (
-       "github.com/martini-contrib/render"
-       "github.com/martini-contrib/sessions"
-
-       "github.com/gogits/gogs/modules/auth"
-       "github.com/gogits/gogs/modules/base"
        "github.com/gogits/gogs/modules/middleware"
        "github.com/gogits/gogs/routers/user"
 )
 
-func Home(ctx *middleware.Context, r render.Render, data base.TmplData, session sessions.Session) {
-       if auth.IsSignedIn(session) {
+func Home(ctx *middleware.Context) {
+       if ctx.IsSigned {
                user.Dashboard(ctx)
                return
        }
-       data["PageIsHome"] = true
-       r.HTML(200, "home", data)
+       ctx.Data["PageIsHome"] = true
+       ctx.Render.HTML(200, "home", ctx.Data)
 }

diff --git a/routers/repo/single.go b/routers/repo/single.go
index 605eb231f32a42b85dbf47d209c01db4721a9f41..036bc218306b5782704f7a267ea449920e92ec1a 100644 (file)
--- a/routers/repo/single.go
+++ b/routers/repo/single.go
@@ -1,17 +1,16 @@
 package repo
 
 import (
-       "github.com/codegangsta/martini"
-       "github.com/martini-contrib/render"
        "strings"
 
+       "github.com/codegangsta/martini"
+
        "github.com/gogits/gogs/models"
-       "github.com/gogits/gogs/modules/base"
        "github.com/gogits/gogs/modules/middleware"
 )
 
-func Single(params martini.Params, ctx *middleware.Context, r render.Render, data base.TmplData) {
-       if !data["IsRepositoryValid"].(bool) {
+func Single(ctx *middleware.Context, params martini.Params) {
+       if !ctx.Data["IsRepositoryValid"].(bool) {
                return
        }
        if params["branchname"] == "" {
@@ -24,9 +23,9 @@ func Single(params martini.Params, ctx *middleware.Context, r render.Render, dat
                ctx.Handle(200, "repo.Single", err)
                return
        }
-       data["Username"] = params["username"]
-       data["Reponame"] = params["reponame"]
-       data["Branchname"] = params["branchname"]
+       ctx.Data["Username"] = params["username"]
+       ctx.Data["Reponame"] = params["reponame"]
+       ctx.Data["Branchname"] = params["branchname"]
 
        var treenames []string
        Paths := make([]string, 0)
@@ -38,21 +37,21 @@ func Single(params martini.Params, ctx *middleware.Context, r render.Render, dat
                }
        }
 
-       data["Paths"] = Paths
-       data["Treenames"] = treenames
-       data["IsRepoToolbarSource"] = true
-       data["Files"] = files
+       ctx.Data["Paths"] = Paths
+       ctx.Data["Treenames"] = treenames
+       ctx.Data["IsRepoToolbarSource"] = true
+       ctx.Data["Files"] = files
 
-       r.HTML(200, "repo/single", data)
+       ctx.Render.HTML(200, "repo/single", ctx.Data)
 }
 
-func Setting(r render.Render, data base.TmplData) {
-       if !data["IsRepositoryValid"].(bool) {
+func Setting(ctx *middleware.Context) {
+       if !ctx.Data["IsRepositoryValid"].(bool) {
                return
        }
 
-       data["Title"] = data["Title"].(string) + " - settings"
-       data["IsRepoToolbarSetting"] = true
+       ctx.Data["Title"] = ctx.Data["Title"].(string) + " - settings"
+       ctx.Data["IsRepoToolbarSetting"] = true
 
-       r.HTML(200, "repo/setting", data)
+       ctx.Render.HTML(200, "repo/setting", ctx.Data)
 }

diff --git a/routers/user/setting.go b/routers/user/setting.go
index 347aec4e0305d74f0f06ca10d6db1b6d10118c99..f38f2c14291cc02e375bad32c21c3e0959070619 100644 (file)
--- a/routers/user/setting.go
+++ b/routers/user/setting.go
@@ -5,12 +5,8 @@
 package user
 
 import (
-       "net/http"
        "strconv"
 
-       "github.com/martini-contrib/render"
-       "github.com/martini-contrib/sessions"
-
        "github.com/gogits/gogs/models"
        "github.com/gogits/gogs/modules/auth"
        "github.com/gogits/gogs/modules/base"
@@ -18,20 +14,20 @@ import (
        "github.com/gogits/gogs/modules/middleware"
 )
 
-func Setting(form auth.UpdateProfileForm, ctx *middleware.Context, r render.Render, data base.TmplData, req *http.Request, session sessions.Session) {
-       data["Title"] = "Setting"
-       data["PageIsUserSetting"] = true
+func Setting(ctx *middleware.Context, form auth.UpdateProfileForm) {
+       ctx.Data["Title"] = "Setting"
+       ctx.Data["PageIsUserSetting"] = true
 
-       user := auth.SignedInUser(session)
-       data["Owner"] = user
+       user := ctx.User
+       ctx.Data["Owner"] = user
 
-       if req.Method == "GET" {
-               r.HTML(200, "user/setting", data)
+       if ctx.Req.Method == "GET" {
+               ctx.Render.HTML(200, "user/setting", ctx.Data)
                return
        }
 
-       if hasErr, ok := data["HasError"]; ok && hasErr.(bool) {
-               r.HTML(200, "user/setting", data)
+       if hasErr, ok := ctx.Data["HasError"]; ok && hasErr.(bool) {
+               ctx.Render.HTML(200, "user/setting", ctx.Data)
                return
        }
 
@@ -45,20 +41,20 @@ func Setting(form auth.UpdateProfileForm, ctx *middleware.Context, r render.Rend
                return
        }
 
-       data["IsSuccess"] = true
-       r.HTML(200, "user/setting", data)
+       ctx.Data["IsSuccess"] = true
+       ctx.Render.HTML(200, "user/setting", ctx.Data)
 }
 
-func SettingPassword(form auth.UpdatePasswdForm, ctx *middleware.Context, r render.Render, data base.TmplData, session sessions.Session, req *http.Request) {
-       data["Title"] = "Password"
-       data["PageIsUserSetting"] = true
+func SettingPassword(ctx *middleware.Context, form auth.UpdatePasswdForm) {
+       ctx.Data["Title"] = "Password"
+       ctx.Data["PageIsUserSetting"] = true
 
-       if req.Method == "GET" {
-               r.HTML(200, "user/password", data)
+       if ctx.Req.Method == "GET" {
+               ctx.Render.HTML(200, "user/password", ctx.Data)
                return
        }
 
-       user := auth.SignedInUser(session)
+       user := ctx.User
        newUser := &models.User{Passwd: form.NewPasswd}
        if err := newUser.EncodePasswd(); err != nil {
                ctx.Handle(200, "setting.SettingPassword", err)
@@ -66,35 +62,34 @@ func SettingPassword(form auth.UpdatePasswdForm, ctx *middleware.Context, r rend
        }
 
        if user.Passwd != newUser.Passwd {
-               data["HasError"] = true
-               data["ErrorMsg"] = "Old password is not correct"
+               ctx.Data["HasError"] = true
+               ctx.Data["ErrorMsg"] = "Old password is not correct"
        } else if form.NewPasswd != form.RetypePasswd {
-               data["HasError"] = true
-               data["ErrorMsg"] = "New password and re-type password are not same"
+               ctx.Data["HasError"] = true
+               ctx.Data["ErrorMsg"] = "New password and re-type password are not same"
        } else {
                user.Passwd = newUser.Passwd
                if err := models.UpdateUser(user); err != nil {
                        ctx.Handle(200, "setting.SettingPassword", err)
                        return
                }
-               data["IsSuccess"] = true
+               ctx.Data["IsSuccess"] = true
        }
 
-       data["Owner"] = user
-       r.HTML(200, "user/password", data)
+       ctx.Data["Owner"] = user
+       ctx.Render.HTML(200, "user/password", ctx.Data)
 }
 
-func SettingSSHKeys(form auth.AddSSHKeyForm, r render.Render, data base.TmplData, req *http.Request, session sessions.Session) {
-       data["Title"] = "SSH Keys"
+func SettingSSHKeys(ctx *middleware.Context, form auth.AddSSHKeyForm) {
+       ctx.Data["Title"] = "SSH Keys"
 
        // Delete SSH key.
-       if req.Method == "DELETE" || req.FormValue("_method") == "DELETE" {
-               println(1)
-               id, err := strconv.ParseInt(req.FormValue("id"), 10, 64)
+       if ctx.Req.Method == "DELETE" || ctx.Query("_method") == "DELETE" {
+               id, err := strconv.ParseInt(ctx.Query("id"), 10, 64)
                if err != nil {
-                       data["ErrorMsg"] = err
+                       ctx.Data["ErrorMsg"] = err
                        log.Error("ssh.DelPublicKey: %v", err)
-                       r.JSON(200, map[string]interface{}{
+                       ctx.Render.JSON(200, map[string]interface{}{
                                "ok":  false,
                                "err": err.Error(),
                        })
@@ -102,18 +97,18 @@ func SettingSSHKeys(form auth.AddSSHKeyForm, r render.Render, data base.TmplData
                }
                k := &models.PublicKey{
                        Id:      id,
-                       OwnerId: auth.SignedInId(session),
+                       OwnerId: ctx.User.Id,
                }
 
                if err = models.DeletePublicKey(k); err != nil {
-                       data["ErrorMsg"] = err
+                       ctx.Data["ErrorMsg"] = err
                        log.Error("ssh.DelPublicKey: %v", err)
-                       r.JSON(200, map[string]interface{}{
+                       ctx.Render.JSON(200, map[string]interface{}{
                                "ok":  false,
                                "err": err.Error(),
                        })
                } else {
-                       r.JSON(200, map[string]interface{}{
+                       ctx.Render.JSON(200, map[string]interface{}{
                                "ok": true,
                        })
                }
@@ -121,51 +116,51 @@ func SettingSSHKeys(form auth.AddSSHKeyForm, r render.Render, data base.TmplData
        }
 
        // Add new SSH key.
-       if req.Method == "POST" {
-               if hasErr, ok := data["HasError"]; ok && hasErr.(bool) {
-                       r.HTML(200, "user/publickey", data)
+       if ctx.Req.Method == "POST" {
+               if hasErr, ok := ctx.Data["HasError"]; ok && hasErr.(bool) {
+                       ctx.Render.HTML(200, "user/publickey", ctx.Data)
                        return
                }
 
-               k := &models.PublicKey{OwnerId: auth.SignedInId(session),
+               k := &models.PublicKey{OwnerId: ctx.User.Id,
                        Name:    form.KeyName,
                        Content: form.KeyContent,
                }
 
                if err := models.AddPublicKey(k); err != nil {
-                       data["ErrorMsg"] = err
+                       ctx.Data["ErrorMsg"] = err
                        log.Error("ssh.AddPublicKey: %v", err)
-                       r.HTML(200, "base/error", data)
+                       ctx.Render.HTML(200, "base/error", ctx.Data)
                        return
                } else {
-                       data["AddSSHKeySuccess"] = true
+                       ctx.Data["AddSSHKeySuccess"] = true
                }
        }
 
        // List existed SSH keys.
-       keys, err := models.ListPublicKey(auth.SignedInId(session))
+       keys, err := models.ListPublicKey(ctx.User.Id)
        if err != nil {
-               data["ErrorMsg"] = err
+               ctx.Data["ErrorMsg"] = err
                log.Error("ssh.ListPublicKey: %v", err)
-               r.HTML(200, "base/error", data)
+               ctx.Render.HTML(200, "base/error", ctx.Data)
                return
        }
 
-       data["PageIsUserSetting"] = true
-       data["Keys"] = keys
-       r.HTML(200, "user/publickey", data)
+       ctx.Data["PageIsUserSetting"] = true
+       ctx.Data["Keys"] = keys
+       ctx.Render.HTML(200, "user/publickey", ctx.Data)
 }
 
-func SettingNotification(r render.Render, data base.TmplData) {
+func SettingNotification(ctx *middleware.Context) {
        // todo user setting notification
-       data["Title"] = "Notification"
-       data["PageIsUserSetting"] = true
-       r.HTML(200, "user/notification", data)
+       ctx.Data["Title"] = "Notification"
+       ctx.Data["PageIsUserSetting"] = true
+       ctx.Render.HTML(200, "user/notification", ctx.Data)
 }
 
-func SettingSecurity(r render.Render, data base.TmplData) {
+func SettingSecurity(ctx *middleware.Context) {
        // todo user setting security
-       data["Title"] = "Security"
-       data["PageIsUserSetting"] = true
-       r.HTML(200, "user/security", data)
+       ctx.Data["Title"] = "Security"
+       ctx.Data["PageIsUserSetting"] = true
+       ctx.Render.HTML(200, "user/security", ctx.Data)
 }

diff --git a/routers/user/user.go b/routers/user/user.go
index 9dbcb2a19003f76706901f8d45794d889396c84d..50b991830837a8c607c8ce3828382158ac77c752 100644 (file)
--- a/routers/user/user.go
+++ b/routers/user/user.go
@@ -6,7 +6,6 @@ package user
 
 import (
        "fmt"
-       "net/http"
 
        "github.com/codegangsta/martini"
        "github.com/martini-contrib/render"
@@ -67,7 +66,7 @@ func Profile(ctx *middleware.Context, params martini.Params) {
        ctx.Render.HTML(200, "user/profile", ctx.Data)
 }
 
-func SignIn(form auth.LogInForm, ctx *middleware.Context, r render.Render, session sessions.Session) {
+func SignIn(ctx *middleware.Context, form auth.LogInForm) {
        ctx.Data["Title"] = "Log In"
 
        if ctx.Req.Method == "GET" {
@@ -94,9 +93,9 @@ func SignIn(form auth.LogInForm, ctx *middleware.Context, r render.Render, sessi
                return
        }
 
-       session.Set("userId", user.Id)
-       session.Set("userName", user.Name)
-       r.Redirect("/")
+       ctx.Session.Set("userId", user.Id)
+       ctx.Session.Set("userName", user.Name)
+       ctx.Render.Redirect("/")
 }
 
 func SignOut(r render.Render, session sessions.Session) {
@@ -105,25 +104,25 @@ func SignOut(r render.Render, session sessions.Session) {
        r.Redirect("/")
 }
 
-func SignUp(form auth.RegisterForm, ctx *middleware.Context, data base.TmplData, req *http.Request, r render.Render) {
-       data["Title"] = "Sign Up"
-       data["PageIsSignUp"] = true
+func SignUp(ctx *middleware.Context, form auth.RegisterForm) {
+       ctx.Data["Title"] = "Sign Up"
+       ctx.Data["PageIsSignUp"] = true
 
-       if req.Method == "GET" {
-               r.HTML(200, "user/signup", data)
+       if ctx.Req.Method == "GET" {
+               ctx.Render.HTML(200, "user/signup", ctx.Data)
                return
        }
 
        if form.Password != form.RetypePasswd {
-               data["HasError"] = true
-               data["Err_Password"] = true
-               data["Err_RetypePasswd"] = true
-               data["ErrorMsg"] = "Password and re-type password are not same"
-               auth.AssignForm(form, data)
+               ctx.Data["HasError"] = true
+               ctx.Data["Err_Password"] = true
+               ctx.Data["Err_RetypePasswd"] = true
+               ctx.Data["ErrorMsg"] = "Password and re-type password are not same"
+               auth.AssignForm(form, ctx.Data)
        }
 
-       if hasErr, ok := data["HasError"]; ok && hasErr.(bool) {
-               r.HTML(200, "user/signup", data)
+       if hasErr, ok := ctx.Data["HasError"]; ok && hasErr.(bool) {
+               ctx.Render.HTML(200, "user/signup", ctx.Data)
                return
        }
 
@@ -134,49 +133,47 @@ func SignUp(form auth.RegisterForm, ctx *middleware.Context, data base.TmplData,
        }
 
        if err := models.RegisterUser(u); err != nil {
-               data["HasError"] = true
-               auth.AssignForm(form, data)
+               ctx.Data["HasError"] = true
+               auth.AssignForm(form, ctx.Data)
 
                switch err.Error() {
                case models.ErrUserAlreadyExist.Error():
-                       data["Err_Username"] = true
-                       data["ErrorMsg"] = "Username has been already taken"
-                       r.HTML(200, "user/signup", data)
+                       ctx.Data["Err_Username"] = true
+                       ctx.Data["ErrorMsg"] = "Username has been already taken"
+                       ctx.Render.HTML(200, "user/signup", ctx.Data)
                case models.ErrEmailAlreadyUsed.Error():
-                       data["Err_Email"] = true
-                       data["ErrorMsg"] = "E-mail address has been already used"
-                       r.HTML(200, "user/signup", data)
+                       ctx.Data["Err_Email"] = true
+                       ctx.Data["ErrorMsg"] = "E-mail address has been already used"
+                       ctx.Render.HTML(200, "user/signup", ctx.Data)
                default:
                        ctx.Handle(200, "user.SignUp", err)
                }
                return
        }
 
-       r.Redirect("/user/login")
+       ctx.Render.Redirect("/user/login")
 }
 
-func Delete(data base.TmplData, ctx *middleware.Context, req *http.Request, session sessions.Session, r render.Render) {
-       data["Title"] = "Delete Account"
+func Delete(ctx *middleware.Context) {
+       ctx.Data["Title"] = "Delete Account"
 
-       if req.Method == "GET" {
-               r.HTML(200, "user/delete", data)
+       if ctx.Req.Method == "GET" {
+               ctx.Render.HTML(200, "user/delete", ctx.Data)
                return
        }
 
-       id := auth.SignedInId(session)
-       u := &models.User{Id: id}
-       if err := models.DeleteUser(u); err != nil {
-               data["HasError"] = true
+       if err := models.DeleteUser(ctx.User); err != nil {
+               ctx.Data["HasError"] = true
                switch err.Error() {
                case models.ErrUserOwnRepos.Error():
-                       data["ErrorMsg"] = "Your account still have ownership of repository, you have to delete or transfer them first."
+                       ctx.Data["ErrorMsg"] = "Your account still have ownership of repository, you have to delete or transfer them first."
                default:
                        ctx.Handle(200, "user.Delete", err)
                        return
                }
        }
 
-       r.HTML(200, "user/delete", data)
+       ctx.Render.HTML(200, "user/delete", ctx.Data)
 }
 
 const (
@@ -184,10 +181,10 @@ const (
                         <div class="info"><span class="meta">%s</span><br>%s</div>`
 )
 
-func Feeds(form auth.FeedsForm, r render.Render) {
+func Feeds(ctx *middleware.Context, form auth.FeedsForm) {
        actions, err := models.GetFeeds(form.UserId, form.Page*20, false)
        if err != nil {
-               r.JSON(500, err)
+               ctx.Render.JSON(500, err)
        }
 
        feeds := make([]string, len(actions))
@@ -195,5 +192,5 @@ func Feeds(form auth.FeedsForm, r render.Render) {
                feeds[i] = fmt.Sprintf(feedTpl, base.ActionIcon(actions[i].OpType),
                        base.TimeSince(actions[i].Created), base.ActionDesc(actions[i]))
        }
-       r.JSON(200, &feeds)
+       ctx.Render.JSON(200, &feeds)
 }