New UI merge in progress

5 files changed, 639 insertions, 687 deletions

diff --git a/routers/user/auth.go b/routers/user/auth.go
new file mode 100644
index 0000000000..163df34a4a
--- /dev/null
+++ b/routers/user/auth.go
@@ -0,0 +1,442 @@
+// Copyright 2014 The Gogs Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package user
+
+import (
+	"net/url"
+	"strings"
+
+	"github.com/gogits/gogs/models"
+	"github.com/gogits/gogs/modules/auth"
+	"github.com/gogits/gogs/modules/base"
+	"github.com/gogits/gogs/modules/captcha"
+	"github.com/gogits/gogs/modules/log"
+	// "github.com/gogits/gogs/modules/mailer"
+	"github.com/gogits/gogs/modules/middleware"
+	"github.com/gogits/gogs/modules/setting"
+)
+
+const (
+	SIGNIN          base.TplName = "user/signin"
+	SIGNUP          base.TplName = "user/signup"
+	DELETE          base.TplName = "user/delete"
+	ACTIVATE        base.TplName = "user/activate"
+	FORGOT_PASSWORD base.TplName = "user/forgot_passwd"
+	RESET_PASSWORD  base.TplName = "user/reset_passwd"
+)
+
+func SignIn(ctx *middleware.Context) {
+	ctx.Data["Title"] = ctx.Tr("sign_in")
+
+	// if _, ok := ctx.Session.Get("socialId").(int64); ok {
+	// 		ctx.Data["IsSocialLogin"] = true
+	// 		ctx.HTML(200, SIGNIN)
+	// 		return
+	// 	}
+
+	// if setting.OauthService != nil {
+	// 	ctx.Data["OauthEnabled"] = true
+	// 	ctx.Data["OauthService"] = setting.OauthService
+	// }
+
+	// Check auto-login.
+	uname := ctx.GetCookie(setting.CookieUserName)
+	if len(uname) == 0 {
+		ctx.HTML(200, SIGNIN)
+		return
+	}
+
+	isSucceed := false
+	defer func() {
+		if !isSucceed {
+			log.Trace("auto-login cookie cleared: %s", uname)
+			ctx.SetCookie(setting.CookieUserName, "", -1)
+			ctx.SetCookie(setting.CookieRememberName, "", -1)
+			return
+		}
+	}()
+
+	u, err := models.GetUserByName(uname)
+	if err != nil {
+		if err != models.ErrUserNotExist {
+			ctx.Handle(500, "GetUserByName", err)
+		}
+		return
+	}
+
+	if val, _ := ctx.GetSuperSecureCookie(
+		base.EncodeMd5(u.Rands+u.Passwd), setting.CookieRememberName); val != u.Name {
+		ctx.HTML(200, SIGNIN)
+		return
+	}
+
+	isSucceed = true
+
+	ctx.Session.Set("uid", u.Id)
+	ctx.Session.Set("uname", u.Name)
+	if redirectTo, _ := url.QueryUnescape(ctx.GetCookie("redirect_to")); len(redirectTo) > 0 {
+		ctx.SetCookie("redirect_to", "", -1)
+		ctx.Redirect(redirectTo)
+		return
+	}
+
+	ctx.Redirect("/")
+}
+
+func SignInPost(ctx *middleware.Context, form auth.SignInForm) {
+	ctx.Data["Title"] = ctx.Tr("sign_in")
+
+	// sid, isOauth := ctx.Session.Get("socialId").(int64)
+	// if isOauth {
+	// 	ctx.Data["IsSocialLogin"] = true
+	// } else if setting.OauthService != nil {
+	// 	ctx.Data["OauthEnabled"] = true
+	// 	ctx.Data["OauthService"] = setting.OauthService
+	// }
+
+	if ctx.HasError() {
+		ctx.HTML(200, SIGNIN)
+		return
+	}
+
+	u, err := models.UserSignIn(form.UserName, form.Password)
+	if err != nil {
+		if err == models.ErrUserNotExist {
+			ctx.RenderWithErr(ctx.Tr("form.username_password_incorrect"), SIGNIN, &form)
+			return
+		}
+
+		ctx.Handle(500, "UserSignIn", err)
+		return
+	}
+
+	if form.Remember {
+		days := 86400 * setting.LogInRememberDays
+		ctx.SetCookie(setting.CookieUserName, u.Name, days)
+		ctx.SetSuperSecureCookie(base.EncodeMd5(u.Rands+u.Passwd),
+			setting.CookieRememberName, u.Name, days)
+	}
+
+	// Bind with social account.
+	// if isOauth {
+	// 	if err = models.BindUserOauth2(user.Id, sid); err != nil {
+	// 		if err == models.ErrOauth2RecordNotExist {
+	// 			ctx.Handle(404, "user.SignInPost(GetOauth2ById)", err)
+	// 		} else {
+	// 			ctx.Handle(500, "user.SignInPost(GetOauth2ById)", err)
+	// 		}
+	// 		return
+	// 	}
+	// 	ctx.Session.Delete("socialId")
+	// 	log.Trace("%s OAuth binded: %s -> %d", ctx.Req.RequestURI, form.UserName, sid)
+	// }
+
+	ctx.Session.Set("uid", u.Id)
+	ctx.Session.Set("uname", u.Name)
+	if redirectTo, _ := url.QueryUnescape(ctx.GetCookie("redirect_to")); len(redirectTo) > 0 {
+		ctx.SetCookie("redirect_to", "", -1)
+		ctx.Redirect(redirectTo)
+		return
+	}
+
+	ctx.Redirect("/")
+}
+
+func SignOut(ctx *middleware.Context) {
+	ctx.Session.Delete("uid")
+	ctx.Session.Delete("uname")
+	// ctx.Session.Delete("socialId")
+	// ctx.Session.Delete("socialName")
+	// ctx.Session.Delete("socialEmail")
+	ctx.SetCookie(setting.CookieUserName, "", -1)
+	ctx.SetCookie(setting.CookieRememberName, "", -1)
+	ctx.Redirect("/")
+}
+
+func SignUp(ctx *middleware.Context) {
+	ctx.Data["Title"] = ctx.Tr("sign_up")
+
+	if setting.Service.DisableRegistration {
+		ctx.Data["DisableRegistration"] = true
+		ctx.HTML(200, SIGNUP)
+		return
+	}
+
+	// if sid, ok := ctx.Session.Get("socialId").(int64); ok {
+	// 	oauthSignUp(ctx, sid)
+	// 	return
+	// }
+
+	ctx.HTML(200, SIGNUP)
+}
+
+// func oauthSignUp(ctx *middleware.Context, sid int64) {
+// 	ctx.Data["Title"] = "OAuth Sign Up"
+// 	ctx.Data["PageIsSignUp"] = true
+
+// 	if _, err := models.GetOauth2ById(sid); err != nil {
+// 		if err == models.ErrOauth2RecordNotExist {
+// 			ctx.Handle(404, "user.oauthSignUp(GetOauth2ById)", err)
+// 		} else {
+// 			ctx.Handle(500, "user.oauthSignUp(GetOauth2ById)", err)
+// 		}
+// 		return
+// 	}
+
+// 	ctx.Data["IsSocialLogin"] = true
+// 	ctx.Data["username"] = strings.Replace(ctx.Session.Get("socialName").(string), " ", "", -1)
+// 	ctx.Data["email"] = ctx.Session.Get("socialEmail")
+// 	log.Trace("user.oauthSignUp(social ID): %v", ctx.Session.Get("socialId"))
+// 	ctx.HTML(200, SIGNUP)
+// }
+
+func SignUpPost(ctx *middleware.Context, cpt *captcha.Captcha, form auth.RegisterForm) {
+	ctx.Data["Title"] = ctx.Tr("sign_up")
+
+	if setting.Service.DisableRegistration {
+		ctx.Error(403)
+		return
+	}
+
+	isOauth := false
+	// sid, isOauth := ctx.Session.Get("socialId").(int64)
+	// if isOauth {
+	// 	ctx.Data["IsSocialLogin"] = true
+	// }
+
+	// May redirect from home page.
+	if ctx.Query("from") == "home" {
+		// Clear input error box.
+		ctx.Data["Err_UserName"] = false
+		ctx.Data["Err_Email"] = false
+
+		// Make the best guess.
+		uname := ctx.Query("uname")
+		i := strings.Index(uname, "@")
+		if i > -1 {
+			ctx.Data["email"] = uname
+			ctx.Data["uname"] = uname[:i]
+		} else {
+			ctx.Data["uname"] = uname
+		}
+		ctx.Data["password"] = ctx.Query("password")
+		ctx.HTML(200, SIGNUP)
+		return
+	}
+
+	if ctx.HasError() {
+		ctx.HTML(200, SIGNUP)
+		return
+	}
+
+	if !cpt.VerifyReq(ctx.Req) {
+		ctx.Data["Err_Captcha"] = true
+		ctx.RenderWithErr(ctx.Tr("form.captcha_incorrect"), SIGNUP, &form)
+		return
+	} else if form.Password != form.Retype {
+		ctx.Data["Err_Password"] = true
+		ctx.RenderWithErr(ctx.Tr("form.password_not_match"), SIGNUP, &form)
+		return
+	}
+
+	u := &models.User{
+		Name:     form.UserName,
+		Email:    form.Email,
+		Passwd:   form.Password,
+		IsActive: !setting.Service.RegisterEmailConfirm || isOauth,
+	}
+
+	if err := models.CreateUser(u); err != nil {
+		switch err {
+		case models.ErrUserAlreadyExist:
+			ctx.Data["Err_UserName"] = true
+			ctx.RenderWithErr(ctx.Tr("form.username_been_taken"), SIGNUP, &form)
+		case models.ErrEmailAlreadyUsed:
+			ctx.Data["Err_Email"] = true
+			ctx.RenderWithErr(ctx.Tr("form.email_been_used"), SIGNUP, &form)
+		case models.ErrUserNameIllegal:
+			ctx.Data["Err_UserName"] = true
+			ctx.RenderWithErr(ctx.Tr("form.illegal_username"), SIGNUP, &form)
+		default:
+			ctx.Handle(500, "CreateUser", err)
+		}
+		return
+	}
+	log.Trace("Account created: %s", u.Name)
+
+	// Bind social account.
+	// if isOauth {
+	// 	if err = models.BindUserOauth2(u.Id, sid); err != nil {
+	// 		ctx.Handle(500, "user.SignUp(BindUserOauth2)", err)
+	// 		return
+	// 	}
+	// 	ctx.Session.Delete("socialId")
+	// 	log.Trace("%s OAuth binded: %s -> %d", ctx.Req.RequestURI, form.UserName, sid)
+	// }
+
+	// Send confirmation e-mail, no need for social account.
+	// if !isOauth && setting.Service.RegisterEmailConfirm && u.Id > 1 {
+	// 	mailer.SendRegisterMail(ctx.Render, u)
+	// 	ctx.Data["IsSendRegisterMail"] = true
+	// 	ctx.Data["Email"] = u.Email
+	// 	ctx.Data["Hours"] = setting.Service.ActiveCodeLives / 60
+	// 	ctx.HTML(200, "user/activate")
+
+	// 	if err = ctx.Cache.Put("MailResendLimit_"+u.LowerName, u.LowerName, 180); err != nil {
+	// 		log.Error("Set cache(MailResendLimit) fail: %v", err)
+	// 	}
+	// 	return
+	// }
+
+	ctx.Redirect("/user/login")
+}
+
+func Activate(ctx *middleware.Context) {
+	// code := ctx.Query("code")
+	// if len(code) == 0 {
+	// 	ctx.Data["IsActivatePage"] = true
+	// 	if ctx.User.IsActive {
+	// 		ctx.Handle(404, "user.Activate", nil)
+	// 		return
+	// 	}
+	// 	// Resend confirmation e-mail.
+	// 	if setting.Service.RegisterEmailConfirm {
+	// 		if ctx.Cache.IsExist("MailResendLimit_" + ctx.User.LowerName) {
+	// 			ctx.Data["ResendLimited"] = true
+	// 		} else {
+	// 			ctx.Data["Hours"] = setting.Service.ActiveCodeLives / 60
+	// 			mailer.SendActiveMail(ctx.Render, ctx.User)
+
+	// 			if err := ctx.Cache.Put("MailResendLimit_"+ctx.User.LowerName, ctx.User.LowerName, 180); err != nil {
+	// 				log.Error("Set cache(MailResendLimit) fail: %v", err)
+	// 			}
+	// 		}
+	// 	} else {
+	// 		ctx.Data["ServiceNotEnabled"] = true
+	// 	}
+	// 	ctx.HTML(200, ACTIVATE)
+	// 	return
+	// }
+
+	// // Verify code.
+	// if user := models.VerifyUserActiveCode(code); user != nil {
+	// 	user.IsActive = true
+	// 	user.Rands = models.GetUserSalt()
+	// 	if err := models.UpdateUser(user); err != nil {
+	// 		ctx.Handle(404, "user.Activate", err)
+	// 		return
+	// 	}
+
+	// 	log.Trace("%s User activated: %s", ctx.Req.RequestURI, user.Name)
+
+	// 	ctx.Session.Set("userId", user.Id)
+	// 	ctx.Session.Set("userName", user.Name)
+	// 	ctx.Redirect("/")
+	// 	return
+	// }
+
+	// ctx.Data["IsActivateFailed"] = true
+	// ctx.HTML(200, ACTIVATE)
+}
+
+func ForgotPasswd(ctx *middleware.Context) {
+	ctx.Data["Title"] = "Forgot Password"
+
+	if setting.MailService == nil {
+		ctx.Data["IsResetDisable"] = true
+		ctx.HTML(200, FORGOT_PASSWORD)
+		return
+	}
+
+	ctx.Data["IsResetRequest"] = true
+	ctx.HTML(200, FORGOT_PASSWORD)
+}
+
+func ForgotPasswdPost(ctx *middleware.Context) {
+	// ctx.Data["Title"] = "Forgot Password"
+
+	// if setting.MailService == nil {
+	// 	ctx.Handle(403, "user.ForgotPasswdPost", nil)
+	// 	return
+	// }
+	// ctx.Data["IsResetRequest"] = true
+
+	// email := ctx.Query("email")
+	// u, err := models.GetUserByEmail(email)
+	// if err != nil {
+	// 	if err == models.ErrUserNotExist {
+	// 		ctx.RenderWithErr("This e-mail address does not associate to any account.", "user/forgot_passwd", nil)
+	// 	} else {
+	// 		ctx.Handle(500, "user.ResetPasswd(check existence)", err)
+	// 	}
+	// 	return
+	// }
+
+	// if ctx.Cache.IsExist("MailResendLimit_" + u.LowerName) {
+	// 	ctx.Data["ResendLimited"] = true
+	// 	ctx.HTML(200, FORGOT_PASSWORD)
+	// 	return
+	// }
+
+	// mailer.SendResetPasswdMail(ctx.Render, u)
+	// if err = ctx.Cache.Put("MailResendLimit_"+u.LowerName, u.LowerName, 180); err != nil {
+	// 	log.Error("Set cache(MailResendLimit) fail: %v", err)
+	// }
+
+	// ctx.Data["Email"] = email
+	// ctx.Data["Hours"] = setting.Service.ActiveCodeLives / 60
+	// ctx.Data["IsResetSent"] = true
+	// ctx.HTML(200, FORGOT_PASSWORD)
+}
+
+func ResetPasswd(ctx *middleware.Context) {
+	ctx.Data["Title"] = "Reset Password"
+
+	code := ctx.Query("code")
+	if len(code) == 0 {
+		ctx.Error(404)
+		return
+	}
+	ctx.Data["Code"] = code
+	ctx.Data["IsResetForm"] = true
+	ctx.HTML(200, RESET_PASSWORD)
+}
+
+func ResetPasswdPost(ctx *middleware.Context) {
+	// ctx.Data["Title"] = "Reset Password"
+
+	// code := ctx.Query("code")
+	// if len(code) == 0 {
+	// 	ctx.Error(404)
+	// 	return
+	// }
+	// ctx.Data["Code"] = code
+
+	// if u := models.VerifyUserActiveCode(code); u != nil {
+	// 	// Validate password length.
+	// 	passwd := ctx.Query("passwd")
+	// 	if len(passwd) < 6 || len(passwd) > 30 {
+	// 		ctx.Data["IsResetForm"] = true
+	// 		ctx.RenderWithErr("Password length should be in 6 and 30.", "user/reset_passwd", nil)
+	// 		return
+	// 	}
+
+	// 	u.Passwd = passwd
+	// 	u.Rands = models.GetUserSalt()
+	// 	u.Salt = models.GetUserSalt()
+	// 	u.EncodePasswd()
+	// 	if err := models.UpdateUser(u); err != nil {
+	// 		ctx.Handle(500, "user.ResetPasswd(UpdateUser)", err)
+	// 		return
+	// 	}
+
+	// 	log.Trace("%s User password reset: %s", ctx.Req.RequestURI, u.Name)
+	// 	ctx.Redirect("/user/login")
+	// 	return
+	// }
+
+	// ctx.Data["IsResetFailed"] = true
+	// ctx.HTML(200, RESET_PASSWORD)
+}
diff --git a/routers/user/home.go b/routers/user/home.go
index 02dc1de154..16e88a9427 100644
--- a/routers/user/home.go
+++ b/routers/user/home.go
@@ -8,50 +8,49 @@ import (
 	"fmt"
 
 	"github.com/Unknwon/com"
-	"github.com/go-martini/martini"
 
 	"github.com/gogits/gogs/models"
-	"github.com/gogits/gogs/modules/auth"
 	"github.com/gogits/gogs/modules/base"
 	"github.com/gogits/gogs/modules/log"
 	"github.com/gogits/gogs/modules/middleware"
 )
 
 const (
-	DASHBOARD base.TplName = "user/dashboard"
-	PROFILE   base.TplName = "user/profile"
+	DASHBOARD base.TplName = "user/dashboard/dashboard"
 	ISSUES    base.TplName = "user/issues"
 	PULLS     base.TplName = "user/pulls"
 	STARS     base.TplName = "user/stars"
+	PROFILE   base.TplName = "user/profile"
 )
 
 func Dashboard(ctx *middleware.Context) {
-	ctx.Data["Title"] = "Dashboard"
-	ctx.Data["PageIsUserDashboard"] = true
-
-	if err := ctx.User.GetOrganizations(); err != nil {
-		ctx.Handle(500, "home.Dashboard(GetOrganizations)", err)
-		return
-	}
-	ctx.Data["Orgs"] = ctx.User.Orgs
+	ctx.Data["Title"] = ctx.Tr("dashboard")
+	ctx.Data["PageIsDashboard"] = true
+	ctx.Data["PageIsNews"] = true
+
+	// if err := ctx.User.GetOrganizations(); err != nil {
+	// 	ctx.Handle(500, "home.Dashboard(GetOrganizations)", err)
+	// 	return
+	// }
+	// ctx.Data["Orgs"] = ctx.User.Orgs
 	ctx.Data["ContextUser"] = ctx.User
 
-	var err error
-	ctx.Data["MyRepos"], err = models.GetRepositories(ctx.User.Id, true)
+	repos, err := models.GetRepositories(ctx.User.Id, true)
 	if err != nil {
-		ctx.Handle(500, "home.Dashboard(GetRepositories)", err)
+		ctx.Handle(500, "GetRepositories", err)
 		return
 	}
+	ctx.Data["Repos"] = repos
 
-	ctx.Data["CollaborativeRepos"], err = models.GetCollaborativeRepos(ctx.User.Name)
-	if err != nil {
-		ctx.Handle(500, "home.Dashboard(GetCollaborativeRepos)", err)
-		return
-	}
+	// ctx.Data["CollaborativeRepos"], err = models.GetCollaborativeRepos(ctx.User.Name)
+	// if err != nil {
+	// 	ctx.Handle(500, "home.Dashboard(GetCollaborativeRepos)", err)
+	// 	return
+	// }
 
-	actions, err := models.GetFeeds(ctx.User.Id, 0, false)
+	actions, err := models.GetFeeds(ctx.User.Id, 0, true)
 	if err != nil {
-		ctx.Handle(500, "home.Dashboard(GetFeeds)", err)
+		ctx.Handle(500, "GetFeeds", err)
 		return
 	}
 
@@ -70,11 +69,11 @@ func Dashboard(ctx *middleware.Context) {
 	ctx.HTML(200, DASHBOARD)
 }
 
-func Profile(ctx *middleware.Context, params martini.Params) {
+func Profile(ctx *middleware.Context) {
 	ctx.Data["Title"] = "Profile"
 	ctx.Data["PageIsUserProfile"] = true
 
-	u, err := models.GetUserByName(params["username"])
+	u, err := models.GetUserByName(ctx.Params(":username"))
 	if err != nil {
 		if err == models.ErrUserNotExist {
 			ctx.Handle(404, "user.Profile(GetUserByName)", err)
@@ -133,26 +132,26 @@ const (
                         <div class="info"><span class="meta">%s</span><br>%s</div>`
 )
 
-func Feeds(ctx *middleware.Context, form auth.FeedsForm) {
-	actions, err := models.GetFeeds(form.UserId, form.Page*20, false)
-	if err != nil {
-		ctx.JSON(500, err)
-		return
-	}
-
-	feeds := make([]string, 0, len(actions))
-	for _, act := range actions {
-		if act.IsPrivate {
-			if has, _ := models.HasAccess(ctx.User.Name, act.RepoUserName+"/"+act.RepoName,
-				models.READABLE); !has {
-				continue
-			}
-		}
-		feeds = append(feeds, fmt.Sprintf(TPL_FEED, base.ActionIcon(act.OpType),
-			base.TimeSince(act.Created), base.ActionDesc(act)))
-	}
-	ctx.JSON(200, &feeds)
-}
+// func Feeds(ctx *middleware.Context, form auth.FeedsForm) {
+// 	actions, err := models.GetFeeds(form.UserId, form.Page*20, false)
+// 	if err != nil {
+// 		ctx.JSON(500, err)
+// 		return
+// 	}
+
+// 	feeds := make([]string, 0, len(actions))
+// 	for _, act := range actions {
+// 		if act.IsPrivate {
+// 			if has, _ := models.HasAccess(ctx.User.Name, act.RepoUserName+"/"+act.RepoName,
+// 				models.READABLE); !has {
+// 				continue
+// 			}
+// 		}
+// 		feeds = append(feeds, fmt.Sprintf(TPL_FEED, base.ActionIcon(act.OpType),
+// 			base.TimeSince(act.Created), base.ActionDesc(act)))
+// 	}
+// 	ctx.JSON(200, &feeds)
+// }
 
 func Issues(ctx *middleware.Context) {
 	ctx.Data["Title"] = "Your Issues"
@@ -173,7 +172,7 @@ func Issues(ctx *middleware.Context) {
 		filterMode = models.FM_CREATE
 	}
 
-	repoId, _ := base.StrTo(ctx.Query("repoid")).Int64()
+	repoId, _ := com.StrTo(ctx.Query("repoid")).Int64()
 	issueStats := models.GetUserIssueStats(ctx.User.Id, filterMode)
 
 	// Get all repositories.
@@ -215,7 +214,7 @@ func Issues(ctx *middleware.Context) {
 		repoIds = []int64{repoId}
 	}
 
-	page, _ := base.StrTo(ctx.Query("page")).Int()
+	page, _ := com.StrTo(ctx.Query("page")).Int()
 
 	// Get all issues.
 	var ius []*models.IssueUser
diff --git a/routers/user/setting.go b/routers/user/setting.go
index c38b4cb577..e4d6ff9ce7 100644
--- a/routers/user/setting.go
+++ b/routers/user/setting.go
@@ -5,76 +5,62 @@
 package user
 
 import (
-	"errors"
-	"fmt"
-	"io/ioutil"
-	"os"
-	"strconv"
-	"strings"
+	"github.com/Unknwon/com"
 
 	"github.com/gogits/gogs/models"
 	"github.com/gogits/gogs/modules/auth"
 	"github.com/gogits/gogs/modules/base"
 	"github.com/gogits/gogs/modules/log"
 	"github.com/gogits/gogs/modules/middleware"
-	"github.com/gogits/gogs/modules/process"
 )
 
 const (
-	SETTING      base.TplName = "user/setting"
-	SOCIAL       base.TplName = "user/social"
-	PASSWORD     base.TplName = "user/password"
-	PUBLICKEY    base.TplName = "user/publickey"
-	NOTIFICATION base.TplName = "user/notification"
-	SECURITY     base.TplName = "user/security"
+	SETTINGS_PROFILE  base.TplName = "user/settings/profile"
+	SETTINGS_PASSWORD base.TplName = "user/settings/password"
+	SETTINGS_SSH_KEYS base.TplName = "user/settings/sshkeys"
+	SETTINGS_SOCIAL   base.TplName = "user/settings/social"
+	SETTINGS_DELETE   base.TplName = "user/settings/delete"
+	NOTIFICATION      base.TplName = "user/notification"
+	SECURITY          base.TplName = "user/security"
 )
 
-var (
-	MinimumKeySize = map[string]int{
-		"(ED25519)": 256,
-		"(ECDSA)":   256,
-		"(NTRU)":    1087,
-		"(MCE)":     1702,
-		"(McE)":     1702,
-		"(RSA)":     2048,
-	}
-)
-
-func Setting(ctx *middleware.Context) {
-	ctx.Data["Title"] = "Setting"
-	ctx.Data["PageIsUserSetting"] = true
-	ctx.Data["IsUserPageSetting"] = true
-	ctx.Data["Owner"] = ctx.User
-	ctx.HTML(200, SETTING)
+func Settings(ctx *middleware.Context) {
+	ctx.Data["Title"] = ctx.Tr("settings")
+	ctx.Data["PageIsUserSettings"] = true
+	ctx.Data["PageIsSettingsProfile"] = true
+	ctx.HTML(200, SETTINGS_PROFILE)
 }
 
-func SettingPost(ctx *middleware.Context, form auth.UpdateProfileForm) {
-	ctx.Data["Title"] = "Setting"
-	ctx.Data["PageIsUserSetting"] = true
-	ctx.Data["IsUserPageSetting"] = true
+func SettingsPost(ctx *middleware.Context, form auth.UpdateProfileForm) {
+	ctx.Data["Title"] = ctx.Tr("settings")
+	ctx.Data["PageIsUserSettings"] = true
+	ctx.Data["PageIsSettingsProfile"] = true
 
 	if ctx.HasError() {
-		ctx.HTML(200, SETTING)
+		ctx.HTML(200, SETTINGS_PROFILE)
 		return
 	}
 
-	ctx.Data["Owner"] = ctx.User
-
 	// Check if user name has been changed.
 	if ctx.User.Name != form.UserName {
 		isExist, err := models.IsUserExist(form.UserName)
 		if err != nil {
-			ctx.Handle(500, "user.SettingPost(update: check existence)", err)
+			ctx.Handle(500, "IsUserExist", err)
 			return
 		} else if isExist {
-			ctx.RenderWithErr("User name has been taken.", SETTING, &form)
+			ctx.RenderWithErr(ctx.Tr("form.username_been_taken"), SETTINGS_PROFILE, &form)
 			return
 		} else if err = models.ChangeUserName(ctx.User, form.UserName); err != nil {
-			ctx.Handle(500, "user.SettingPost(change user name)", err)
+			if err == models.ErrUserNameIllegal {
+				ctx.Flash.Error(ctx.Tr("form.illegal_username"))
+				ctx.Redirect("/user/settings")
+				return
+			} else {
+				ctx.Handle(500, "ChangeUserName", err)
+			}
 			return
 		}
-		log.Trace("%s User name changed: %s -> %s", ctx.Req.RequestURI, ctx.User.Name, form.UserName)
-
+		log.Trace("User name changed: %s -> %s", ctx.User.Name, form.UserName)
 		ctx.User.Name = form.UserName
 	}
 
@@ -85,213 +71,197 @@ func SettingPost(ctx *middleware.Context, form auth.UpdateProfileForm) {
 	ctx.User.Avatar = base.EncodeMd5(form.Avatar)
 	ctx.User.AvatarEmail = form.Avatar
 	if err := models.UpdateUser(ctx.User); err != nil {
-		ctx.Handle(500, "setting.SettingPost(UpdateUser)", err)
+		ctx.Handle(500, "UpdateUser", err)
 		return
 	}
-	log.Trace("%s User setting updated: %s", ctx.Req.RequestURI, ctx.User.LowerName)
-	ctx.Flash.Success("Your profile has been successfully updated.")
+	log.Trace("User setting updated: %s", ctx.User.Name)
+	ctx.Flash.Success(ctx.Tr("settings.update_profile_success"))
 	ctx.Redirect("/user/settings")
 }
 
-func SettingSocial(ctx *middleware.Context) {
-	ctx.Data["Title"] = "Social Account"
-	ctx.Data["PageIsUserSetting"] = true
-	ctx.Data["IsUserPageSettingSocial"] = true
-
-	// Unbind social account.
-	remove, _ := base.StrTo(ctx.Query("remove")).Int64()
-	if remove > 0 {
-		if err := models.DeleteOauth2ById(remove); err != nil {
-			ctx.Handle(500, "user.SettingSocial(DeleteOauth2ById)", err)
-			return
-		}
-		ctx.Flash.Success("OAuth2 has been unbinded.")
-		ctx.Redirect("/user/settings/social")
-		return
-	}
-
-	var err error
-	ctx.Data["Socials"], err = models.GetOauthByUserId(ctx.User.Id)
-	if err != nil {
-		ctx.Handle(500, "user.SettingSocial(GetOauthByUserId)", err)
-		return
-	}
-	ctx.HTML(200, SOCIAL)
-}
-
-func SettingPassword(ctx *middleware.Context) {
-	ctx.Data["Title"] = "Password"
-	ctx.Data["PageIsUserSetting"] = true
-	ctx.Data["IsUserPageSettingPasswd"] = true
-	ctx.HTML(200, PASSWORD)
+func SettingsPassword(ctx *middleware.Context) {
+	ctx.Data["Title"] = ctx.Tr("settings")
+	ctx.Data["PageIsUserSettings"] = true
+	ctx.Data["PageIsSettingsPassword"] = true
+	ctx.HTML(200, SETTINGS_PASSWORD)
 }
 
-func SettingPasswordPost(ctx *middleware.Context, form auth.UpdatePasswdForm) {
-	ctx.Data["Title"] = "Password"
-	ctx.Data["PageIsUserSetting"] = true
-	ctx.Data["IsUserPageSettingPasswd"] = true
+func SettingsPasswordPost(ctx *middleware.Context, form auth.ChangePasswordForm) {
+	ctx.Data["Title"] = ctx.Tr("settings")
+	ctx.Data["PageIsUserSettings"] = true
+	ctx.Data["PageIsSettingsPassword"] = true
 
 	if ctx.HasError() {
-		ctx.HTML(200, PASSWORD)
+		ctx.HTML(200, SETTINGS_PASSWORD)
 		return
 	}
 
 	tmpUser := &models.User{
-		Passwd: form.OldPasswd,
+		Passwd: form.OldPassword,
 		Salt:   ctx.User.Salt,
 	}
 	tmpUser.EncodePasswd()
 	if ctx.User.Passwd != tmpUser.Passwd {
-		ctx.Flash.Error("Old password is not correct.")
-	} else if form.NewPasswd != form.RetypePasswd {
-		ctx.Flash.Error("New password and re-type password are not same.")
+		ctx.Flash.Error(ctx.Tr("settings.password_incorrect"))
+	} else if form.Password != form.Retype {
+		ctx.Flash.Error(ctx.Tr("form.password_not_match"))
 	} else {
-		ctx.User.Passwd = form.NewPasswd
+		ctx.User.Passwd = form.Password
 		ctx.User.Salt = models.GetUserSalt()
 		ctx.User.EncodePasswd()
 		if err := models.UpdateUser(ctx.User); err != nil {
-			ctx.Handle(200, "setting.SettingPassword", err)
+			ctx.Handle(500, "UpdateUser", err)
 			return
 		}
-		log.Trace("%s User password updated: %s", ctx.Req.RequestURI, ctx.User.LowerName)
-		ctx.Flash.Success("Password is changed successfully. You can now sign in via new password.")
+		log.Trace("User password updated: %s", ctx.User.Name)
+		ctx.Flash.Success(ctx.Tr("settings.change_password_success"))
 	}
+
 	ctx.Redirect("/user/settings/password")
 }
 
-// Checks if the given public key string is recognized by SSH.
-func CheckPublicKeyString(keyContent string) (ok bool, err error) {
-	if strings.ContainsAny(keyContent, "\n\r") {
-		return false, errors.New("Only a single line with a single key please")
-	}
-
-	// write the key to a file…
-	tmpFile, err := ioutil.TempFile(os.TempDir(), "keytest")
-	if err != nil {
-		return false, err
-	}
-	tmpPath := tmpFile.Name()
-	defer os.Remove(tmpPath)
-	tmpFile.WriteString(keyContent)
-	tmpFile.Close()
+func SettingsSSHKeys(ctx *middleware.Context) {
+	ctx.Data["Title"] = ctx.Tr("settings")
+	ctx.Data["PageIsUserSettings"] = true
+	ctx.Data["PageIsSettingsSSHKeys"] = true
 
-	// … see if ssh-keygen recognizes its contents
-	stdout, stderr, err := process.Exec("CheckPublicKeyString", "ssh-keygen", "-l", "-f", tmpPath)
-	if err != nil {
-		return false, errors.New("ssh-keygen -l -f: " + stderr)
-	} else if len(stdout) < 2 {
-		return false, errors.New("ssh-keygen returned not enough output to evaluate the key")
-	}
-	sshKeygenOutput := strings.Split(stdout, " ")
-	if len(sshKeygenOutput) < 4 {
-		return false, errors.New("Not enough fields returned by ssh-keygen -l -f")
-	}
-	keySize, err := strconv.Atoi(sshKeygenOutput[0])
+	var err error
+	ctx.Data["Keys"], err = models.ListPublicKey(ctx.User.Id)
 	if err != nil {
-		return false, errors.New("Cannot get key size of the given key")
-	}
-	keyType := strings.TrimSpace(sshKeygenOutput[len(sshKeygenOutput)-1])
-
-	if minimumKeySize := MinimumKeySize[keyType]; minimumKeySize == 0 {
-		return false, errors.New("Sorry, unrecognized public key type")
-	} else {
-		if keySize < minimumKeySize {
-			return false, fmt.Errorf("The minimum accepted size of a public key %s is %d", keyType, minimumKeySize)
-		}
+		ctx.Handle(500, "ssh.ListPublicKey", err)
+		return
 	}
 
-	return true, nil
+	ctx.HTML(200, SETTINGS_SSH_KEYS)
 }
 
-func SettingSSHKeys(ctx *middleware.Context, form auth.AddSSHKeyForm) {
-	ctx.Data["Title"] = "SSH Keys"
-	ctx.Data["PageIsUserSetting"] = true
-	ctx.Data["IsUserPageSettingSSH"] = true
+func SettingsSSHKeysPost(ctx *middleware.Context, form auth.AddSSHKeyForm) {
+	ctx.Data["Title"] = ctx.Tr("settings")
+	ctx.Data["PageIsUserSettings"] = true
+	ctx.Data["PageIsSettingsSSHKeys"] = true
+
+	var err error
+	ctx.Data["Keys"], err = models.ListPublicKey(ctx.User.Id)
+	if err != nil {
+		ctx.Handle(500, "ssh.ListPublicKey", err)
+		return
+	}
 
 	// Delete SSH key.
-	if ctx.Req.Method == "DELETE" || ctx.Query("_method") == "DELETE" {
-		id, err := base.StrTo(ctx.Query("id")).Int64()
-		if err != nil {
-			log.Error("ssh.DelPublicKey: %v", err)
-			ctx.JSON(200, map[string]interface{}{
-				"ok":  false,
-				"err": err.Error(),
-			})
+	if ctx.Query("_method") == "DELETE" {
+		id := com.StrTo(ctx.Query("id")).MustInt64()
+		if id <= 0 {
 			return
 		}
 
 		if err = models.DeletePublicKey(&models.PublicKey{Id: id}); err != nil {
-			log.Error("ssh.DelPublicKey: %v", err)
-			ctx.JSON(200, map[string]interface{}{
-				"ok":  false,
-				"err": err.Error(),
-			})
+			ctx.Handle(500, "DeletePublicKey", err)
 		} else {
-			log.Trace("%s User SSH key deleted: %s", ctx.Req.RequestURI, ctx.User.LowerName)
-			ctx.JSON(200, map[string]interface{}{
-				"ok": true,
-			})
+			log.Trace("SSH key deleted: %s", ctx.User.Name)
+			ctx.Redirect("/user/settings/ssh")
 		}
 		return
 	}
 
-	var err error
-	// List existed SSH keys.
-	ctx.Data["Keys"], err = models.ListPublicKey(ctx.User.Id)
-	if err != nil {
-		ctx.Handle(500, "ssh.ListPublicKey", err)
-		return
-	}
-
 	// Add new SSH key.
 	if ctx.Req.Method == "POST" {
 		if ctx.HasError() {
-			ctx.HTML(200, "user/publickey")
+			ctx.HTML(200, SETTINGS_SSH_KEYS)
 			return
 		}
 
-		if ok, err := CheckPublicKeyString(form.KeyContent); !ok {
-			ctx.Flash.Error(err.Error())
+		if ok, err := models.CheckPublicKeyString(form.Content); !ok {
+			ctx.Flash.Error(ctx.Tr("form.invalid_ssh_key", err.Error()))
 			ctx.Redirect("/user/settings/ssh")
 			return
 		}
 
 		k := &models.PublicKey{
 			OwnerId: ctx.User.Id,
-			Name:    form.KeyName,
-			Content: form.KeyContent,
+			Name:    form.SSHTitle,
+			Content: form.Content,
 		}
-
 		if err := models.AddPublicKey(k); err != nil {
-			if err.Error() == models.ErrKeyAlreadyExist.Error() {
-				ctx.RenderWithErr("Public key name has been used", "user/publickey", &form)
+			if err == models.ErrKeyAlreadyExist {
+				ctx.RenderWithErr(ctx.Tr("form.ssh_key_been_used"), SETTINGS_SSH_KEYS, &form)
 				return
 			}
 			ctx.Handle(500, "ssh.AddPublicKey", err)
 			return
 		} else {
-			log.Trace("%s User SSH key added: %s", ctx.Req.RequestURI, ctx.User.LowerName)
-			ctx.Flash.Success("New SSH Key has been added!")
+			log.Trace("SSH key added: %s", ctx.User.Name)
+			ctx.Flash.Success(ctx.Tr("settings.add_key_success"))
 			ctx.Redirect("/user/settings/ssh")
 			return
 		}
 	}
 
-	ctx.HTML(200, PUBLICKEY)
+	ctx.HTML(200, SETTINGS_SSH_KEYS)
 }
 
-func SettingNotification(ctx *middleware.Context) {
-	// TODO: user setting notification
-	ctx.Data["Title"] = "Notification"
-	ctx.Data["PageIsUserSetting"] = true
-	ctx.Data["IsUserPageSettingNotify"] = true
-	ctx.HTML(200, NOTIFICATION)
+// func SettingSocial(ctx *middleware.Context) {
+// 	ctx.Data["Title"] = "Social Account"
+// 	ctx.Data["PageIsUserSetting"] = true
+// 	ctx.Data["IsUserPageSettingSocial"] = true
+
+// 	// Unbind social account.
+// 	remove, _ := base.StrTo(ctx.Query("remove")).Int64()
+// 	if remove > 0 {
+// 		if err := models.DeleteOauth2ById(remove); err != nil {
+// 			ctx.Handle(500, "user.SettingSocial(DeleteOauth2ById)", err)
+// 			return
+// 		}
+// 		ctx.Flash.Success("OAuth2 has been unbinded.")
+// 		ctx.Redirect("/user/settings/social")
+// 		return
+// 	}
+
+// 	var err error
+// 	ctx.Data["Socials"], err = models.GetOauthByUserId(ctx.User.Id)
+// 	if err != nil {
+// 		ctx.Handle(500, "user.SettingSocial(GetOauthByUserId)", err)
+// 		return
+// 	}
+// 	ctx.HTML(200, SOCIAL)
+// }
+
+func SettingsSocial(ctx *middleware.Context) {
+	ctx.Data["Title"] = ctx.Tr("settings")
+	ctx.Data["PageIsUserSettings"] = true
+	ctx.Data["PageIsSettingsSocial"] = true
+	ctx.HTML(200, SETTINGS_SOCIAL)
 }
 
-func SettingSecurity(ctx *middleware.Context) {
-	// TODO: user setting security
-	ctx.Data["Title"] = "Security"
-	ctx.Data["PageIsUserSetting"] = true
-	ctx.Data["IsUserPageSettingSecurity"] = true
-	ctx.HTML(200, SECURITY)
+func SettingsDelete(ctx *middleware.Context) {
+	ctx.Data["Title"] = ctx.Tr("settings")
+	ctx.Data["PageIsUserSettings"] = true
+	ctx.Data["PageIsSettingsDelete"] = true
+
+	if ctx.Req.Method == "POST" {
+		// tmpUser := models.User{
+		// 	Passwd: ctx.Query("password"),
+		// 	Salt:   ctx.User.Salt,
+		// }
+		// tmpUser.EncodePasswd()
+		// if tmpUser.Passwd != ctx.User.Passwd {
+		// 	ctx.Flash.Error("Password is not correct. Make sure you are owner of this account.")
+		// } else {
+		if err := models.DeleteUser(ctx.User); err != nil {
+			switch err {
+			case models.ErrUserOwnRepos:
+				ctx.Flash.Error(ctx.Tr("form.still_own_repo"))
+				ctx.Redirect("/user/settings/delete")
+				return
+			default:
+				ctx.Handle(500, "DeleteUser", err)
+				return
+			}
+		} else {
+			log.Trace("Account deleted: %s", ctx.User.Name)
+			ctx.Redirect("/")
+			return
+		}
+	}
+
+	ctx.HTML(200, SETTINGS_DELETE)
 }
diff --git a/routers/user/social.go b/routers/user/social.go
index 9a56415fd4..ef83cd5b42 100644
--- a/routers/user/social.go
+++ b/routers/user/social.go
@@ -11,8 +11,6 @@ import (
 	"net/url"
 	"strings"
 
-	"github.com/go-martini/martini"
-
 	"github.com/gogits/gogs/models"
 	"github.com/gogits/gogs/modules/log"
 	"github.com/gogits/gogs/modules/middleware"
@@ -28,14 +26,14 @@ func extractPath(next string) string {
 	return n.Path
 }
 
-func SocialSignIn(ctx *middleware.Context, params martini.Params) {
+func SocialSignIn(ctx *middleware.Context) {
 	if setting.OauthService == nil {
 		ctx.Handle(404, "social.SocialSignIn(oauth service not enabled)", nil)
 		return
 	}
 
 	next := extractPath(ctx.Query("next"))
-	name := params["name"]
+	name := ctx.Params(":name")
 	connect, ok := social.SocialMap[name]
 	if !ok {
 		ctx.Handle(404, "social.SocialSignIn(social login not enabled)", errors.New(name))
@@ -81,7 +79,7 @@ func SocialSignIn(ctx *middleware.Context, params martini.Params) {
 		}
 		log.Trace("social.SocialSignIn(oa): %v", oa)
 		if err = models.AddOauth2(oa); err != nil {
-			log.Error("social.SocialSignIn(add oauth2): %v", err) // 501
+			log.Error(4, "social.SocialSignIn(add oauth2): %v", err) // 501
 			return
 		}
 	case models.ErrOauth2NotAssociated:
diff --git a/routers/user/user.go b/routers/user/user.go
deleted file mode 100644
index 561fe1c111..0000000000
--- a/routers/user/user.go
+++ /dev/null
@@ -1,457 +0,0 @@
-// Copyright 2014 The Gogs Authors. All rights reserved.
-// Use of this source code is governed by a MIT-style
-// license that can be found in the LICENSE file.
-
-package user
-
-import (
-	"net/url"
-	"strings"
-
-	"github.com/gogits/gogs/models"
-	"github.com/gogits/gogs/modules/auth"
-	"github.com/gogits/gogs/modules/base"
-	"github.com/gogits/gogs/modules/log"
-	"github.com/gogits/gogs/modules/mailer"
-	"github.com/gogits/gogs/modules/middleware"
-	"github.com/gogits/gogs/modules/setting"
-)
-
-const (
-	SIGNIN          base.TplName = "user/signin"
-	SIGNUP          base.TplName = "user/signup"
-	DELETE          base.TplName = "user/delete"
-	ACTIVATE        base.TplName = "user/activate"
-	FORGOT_PASSWORD base.TplName = "user/forgot_passwd"
-	RESET_PASSWORD  base.TplName = "user/reset_passwd"
-)
-
-func SignIn(ctx *middleware.Context) {
-	ctx.Data["Title"] = "Log In"
-
-	if _, ok := ctx.Session.Get("socialId").(int64); ok {
-		ctx.Data["IsSocialLogin"] = true
-		ctx.HTML(200, SIGNIN)
-		return
-	}
-
-	if setting.OauthService != nil {
-		ctx.Data["OauthEnabled"] = true
-		ctx.Data["OauthService"] = setting.OauthService
-	}
-
-	// Check auto-login.
-	uname := ctx.GetCookie(setting.CookieUserName)
-	if len(uname) == 0 {
-		ctx.HTML(200, SIGNIN)
-		return
-	}
-
-	isSucceed := false
-	defer func() {
-		if !isSucceed {
-			log.Trace("user.SignIn(auto-login cookie cleared): %s", uname)
-			ctx.SetCookie(setting.CookieUserName, "", -1)
-			ctx.SetCookie(setting.CookieRememberName, "", -1)
-			return
-		}
-	}()
-
-	user, err := models.GetUserByName(uname)
-	if err != nil {
-		ctx.Handle(500, "user.SignIn(GetUserByName)", err)
-		return
-	}
-
-	secret := base.EncodeMd5(user.Rands + user.Passwd)
-	value, _ := ctx.GetSecureCookie(secret, setting.CookieRememberName)
-	if value != user.Name {
-		ctx.HTML(200, SIGNIN)
-		return
-	}
-
-	isSucceed = true
-
-	ctx.Session.Set("userId", user.Id)
-	ctx.Session.Set("userName", user.Name)
-	if redirectTo, _ := url.QueryUnescape(ctx.GetCookie("redirect_to")); len(redirectTo) > 0 {
-		ctx.SetCookie("redirect_to", "", -1)
-		ctx.Redirect(redirectTo)
-		return
-	}
-
-	ctx.Redirect("/")
-}
-
-func SignInPost(ctx *middleware.Context, form auth.LogInForm) {
-	ctx.Data["Title"] = "Log In"
-
-	sid, isOauth := ctx.Session.Get("socialId").(int64)
-	if isOauth {
-		ctx.Data["IsSocialLogin"] = true
-	} else if setting.OauthService != nil {
-		ctx.Data["OauthEnabled"] = true
-		ctx.Data["OauthService"] = setting.OauthService
-	}
-
-	if ctx.HasError() {
-		ctx.HTML(200, SIGNIN)
-		return
-	}
-
-	user, err := models.UserSignIn(form.UserName, form.Password)
-	if err != nil {
-		if err == models.ErrUserNotExist {
-			log.Trace("%s Log in failed: %s", ctx.Req.RequestURI, form.UserName)
-			ctx.RenderWithErr("Username or password is not correct", SIGNIN, &form)
-			return
-		}
-
-		ctx.Handle(500, "user.SignInPost(UserSignIn)", err)
-		return
-	}
-
-	if form.Remember {
-		secret := base.EncodeMd5(user.Rands + user.Passwd)
-		days := 86400 * setting.LogInRememberDays
-		ctx.SetCookie(setting.CookieUserName, user.Name, days)
-		ctx.SetSecureCookie(secret, setting.CookieRememberName, user.Name, days)
-	}
-
-	// Bind with social account.
-	if isOauth {
-		if err = models.BindUserOauth2(user.Id, sid); err != nil {
-			if err == models.ErrOauth2RecordNotExist {
-				ctx.Handle(404, "user.SignInPost(GetOauth2ById)", err)
-			} else {
-				ctx.Handle(500, "user.SignInPost(GetOauth2ById)", err)
-			}
-			return
-		}
-		ctx.Session.Delete("socialId")
-		log.Trace("%s OAuth binded: %s -> %d", ctx.Req.RequestURI, form.UserName, sid)
-	}
-
-	ctx.Session.Set("userId", user.Id)
-	ctx.Session.Set("userName", user.Name)
-	if redirectTo, _ := url.QueryUnescape(ctx.GetCookie("redirect_to")); len(redirectTo) > 0 {
-		ctx.SetCookie("redirect_to", "", -1)
-		ctx.Redirect(redirectTo)
-		return
-	}
-
-	ctx.Redirect("/")
-}
-
-func SignOut(ctx *middleware.Context) {
-	ctx.Session.Delete("userId")
-	ctx.Session.Delete("userName")
-	ctx.Session.Delete("socialId")
-	ctx.Session.Delete("socialName")
-	ctx.Session.Delete("socialEmail")
-	ctx.SetCookie(setting.CookieUserName, "", -1)
-	ctx.SetCookie(setting.CookieRememberName, "", -1)
-	ctx.Redirect("/")
-}
-
-func SignUp(ctx *middleware.Context) {
-	ctx.Data["Title"] = "Sign Up"
-	ctx.Data["PageIsSignUp"] = true
-
-	if setting.Service.DisableRegistration {
-		ctx.Data["DisableRegistration"] = true
-		ctx.HTML(200, SIGNUP)
-		return
-	}
-
-	if sid, ok := ctx.Session.Get("socialId").(int64); ok {
-		oauthSignUp(ctx, sid)
-		return
-	}
-
-	ctx.HTML(200, SIGNUP)
-}
-
-func oauthSignUp(ctx *middleware.Context, sid int64) {
-	ctx.Data["Title"] = "OAuth Sign Up"
-	ctx.Data["PageIsSignUp"] = true
-
-	if _, err := models.GetOauth2ById(sid); err != nil {
-		if err == models.ErrOauth2RecordNotExist {
-			ctx.Handle(404, "user.oauthSignUp(GetOauth2ById)", err)
-		} else {
-			ctx.Handle(500, "user.oauthSignUp(GetOauth2ById)", err)
-		}
-		return
-	}
-
-	ctx.Data["IsSocialLogin"] = true
-	ctx.Data["username"] = strings.Replace(ctx.Session.Get("socialName").(string), " ", "", -1)
-	ctx.Data["email"] = ctx.Session.Get("socialEmail")
-	log.Trace("user.oauthSignUp(social ID): %v", ctx.Session.Get("socialId"))
-	ctx.HTML(200, SIGNUP)
-}
-
-func SignUpPost(ctx *middleware.Context, form auth.RegisterForm) {
-	ctx.Data["Title"] = "Sign Up"
-	ctx.Data["PageIsSignUp"] = true
-
-	if setting.Service.DisableRegistration {
-		ctx.Handle(403, "user.SignUpPost", nil)
-		return
-	}
-
-	sid, isOauth := ctx.Session.Get("socialId").(int64)
-	if isOauth {
-		ctx.Data["IsSocialLogin"] = true
-	}
-
-	if ctx.HasError() {
-		ctx.HTML(200, SIGNUP)
-		return
-	}
-
-	if form.Password != form.RetypePasswd {
-		ctx.Data["Err_Password"] = true
-		ctx.Data["Err_RetypePasswd"] = true
-		ctx.RenderWithErr("Password and re-type password are not same.", SIGNUP, &form)
-		return
-	}
-
-	u := &models.User{
-		Name:     form.UserName,
-		Email:    form.Email,
-		Passwd:   form.Password,
-		IsActive: !setting.Service.RegisterEmailConfirm || isOauth,
-	}
-
-	var err error
-	if u, err = models.CreateUser(u); err != nil {
-		switch err {
-		case models.ErrUserAlreadyExist:
-			ctx.Data["Err_UserName"] = true
-			ctx.RenderWithErr("Username has been already taken", SIGNUP, &form)
-		case models.ErrEmailAlreadyUsed:
-			ctx.Data["Err_Email"] = true
-			ctx.RenderWithErr("E-mail address has been already used", SIGNUP, &form)
-		case models.ErrUserNameIllegal:
-			ctx.Data["Err_UserName"] = true
-			ctx.RenderWithErr(models.ErrRepoNameIllegal.Error(), SIGNUP, &form)
-		default:
-			ctx.Handle(500, "user.SignUpPost(CreateUser)", err)
-		}
-		return
-	}
-	log.Trace("%s User created: %s", ctx.Req.RequestURI, u.Name)
-
-	// Bind social account.
-	if isOauth {
-		if err = models.BindUserOauth2(u.Id, sid); err != nil {
-			ctx.Handle(500, "user.SignUp(BindUserOauth2)", err)
-			return
-		}
-		ctx.Session.Delete("socialId")
-		log.Trace("%s OAuth binded: %s -> %d", ctx.Req.RequestURI, form.UserName, sid)
-	}
-
-	// Send confirmation e-mail, no need for social account.
-	if !isOauth && setting.Service.RegisterEmailConfirm && u.Id > 1 {
-		mailer.SendRegisterMail(ctx.Render, u)
-		ctx.Data["IsSendRegisterMail"] = true
-		ctx.Data["Email"] = u.Email
-		ctx.Data["Hours"] = setting.Service.ActiveCodeLives / 60
-		ctx.HTML(200, "user/activate")
-
-		if err = ctx.Cache.Put("MailResendLimit_"+u.LowerName, u.LowerName, 180); err != nil {
-			log.Error("Set cache(MailResendLimit) fail: %v", err)
-		}
-		return
-	}
-
-	ctx.Redirect("/user/login")
-}
-
-func Delete(ctx *middleware.Context) {
-	ctx.Data["Title"] = "Delete Account"
-	ctx.Data["PageIsUserSetting"] = true
-	ctx.Data["IsUserPageSettingDelete"] = true
-	ctx.HTML(200, DELETE)
-}
-
-func DeletePost(ctx *middleware.Context) {
-	ctx.Data["Title"] = "Delete Account"
-	ctx.Data["PageIsUserSetting"] = true
-	ctx.Data["IsUserPageSettingDelete"] = true
-
-	tmpUser := models.User{
-		Passwd: ctx.Query("password"),
-		Salt:   ctx.User.Salt,
-	}
-	tmpUser.EncodePasswd()
-	if tmpUser.Passwd != ctx.User.Passwd {
-		ctx.Flash.Error("Password is not correct. Make sure you are owner of this account.")
-	} else {
-		if err := models.DeleteUser(ctx.User); err != nil {
-			switch err {
-			case models.ErrUserOwnRepos:
-				ctx.Flash.Error("Your account still have ownership of repository, you have to delete or transfer them first.")
-			default:
-				ctx.Handle(500, "user.DeletePost(DeleteUser)", err)
-				return
-			}
-		} else {
-			ctx.Redirect("/")
-			return
-		}
-	}
-
-	ctx.Redirect("/user/delete")
-}
-
-func Activate(ctx *middleware.Context) {
-	code := ctx.Query("code")
-	if len(code) == 0 {
-		ctx.Data["IsActivatePage"] = true
-		if ctx.User.IsActive {
-			ctx.Handle(404, "user.Activate", nil)
-			return
-		}
-		// Resend confirmation e-mail.
-		if setting.Service.RegisterEmailConfirm {
-			if ctx.Cache.IsExist("MailResendLimit_" + ctx.User.LowerName) {
-				ctx.Data["ResendLimited"] = true
-			} else {
-				ctx.Data["Hours"] = setting.Service.ActiveCodeLives / 60
-				mailer.SendActiveMail(ctx.Render, ctx.User)
-
-				if err := ctx.Cache.Put("MailResendLimit_"+ctx.User.LowerName, ctx.User.LowerName, 180); err != nil {
-					log.Error("Set cache(MailResendLimit) fail: %v", err)
-				}
-			}
-		} else {
-			ctx.Data["ServiceNotEnabled"] = true
-		}
-		ctx.HTML(200, ACTIVATE)
-		return
-	}
-
-	// Verify code.
-	if user := models.VerifyUserActiveCode(code); user != nil {
-		user.IsActive = true
-		user.Rands = models.GetUserSalt()
-		if err := models.UpdateUser(user); err != nil {
-			ctx.Handle(404, "user.Activate", err)
-			return
-		}
-
-		log.Trace("%s User activated: %s", ctx.Req.RequestURI, user.Name)
-
-		ctx.Session.Set("userId", user.Id)
-		ctx.Session.Set("userName", user.Name)
-		ctx.Redirect("/")
-		return
-	}
-
-	ctx.Data["IsActivateFailed"] = true
-	ctx.HTML(200, ACTIVATE)
-}
-
-func ForgotPasswd(ctx *middleware.Context) {
-	ctx.Data["Title"] = "Forgot Password"
-
-	if setting.MailService == nil {
-		ctx.Data["IsResetDisable"] = true
-		ctx.HTML(200, FORGOT_PASSWORD)
-		return
-	}
-
-	ctx.Data["IsResetRequest"] = true
-	ctx.HTML(200, FORGOT_PASSWORD)
-}
-
-func ForgotPasswdPost(ctx *middleware.Context) {
-	ctx.Data["Title"] = "Forgot Password"
-
-	if setting.MailService == nil {
-		ctx.Handle(403, "user.ForgotPasswdPost", nil)
-		return
-	}
-	ctx.Data["IsResetRequest"] = true
-
-	email := ctx.Query("email")
-	u, err := models.GetUserByEmail(email)
-	if err != nil {
-		if err == models.ErrUserNotExist {
-			ctx.RenderWithErr("This e-mail address does not associate to any account.", "user/forgot_passwd", nil)
-		} else {
-			ctx.Handle(500, "user.ResetPasswd(check existence)", err)
-		}
-		return
-	}
-
-	if ctx.Cache.IsExist("MailResendLimit_" + u.LowerName) {
-		ctx.Data["ResendLimited"] = true
-		ctx.HTML(200, FORGOT_PASSWORD)
-		return
-	}
-
-	mailer.SendResetPasswdMail(ctx.Render, u)
-	if err = ctx.Cache.Put("MailResendLimit_"+u.LowerName, u.LowerName, 180); err != nil {
-		log.Error("Set cache(MailResendLimit) fail: %v", err)
-	}
-
-	ctx.Data["Email"] = email
-	ctx.Data["Hours"] = setting.Service.ActiveCodeLives / 60
-	ctx.Data["IsResetSent"] = true
-	ctx.HTML(200, FORGOT_PASSWORD)
-}
-
-func ResetPasswd(ctx *middleware.Context) {
-	ctx.Data["Title"] = "Reset Password"
-
-	code := ctx.Query("code")
-	if len(code) == 0 {
-		ctx.Error(404)
-		return
-	}
-	ctx.Data["Code"] = code
-	ctx.Data["IsResetForm"] = true
-	ctx.HTML(200, RESET_PASSWORD)
-}
-
-func ResetPasswdPost(ctx *middleware.Context) {
-	ctx.Data["Title"] = "Reset Password"
-
-	code := ctx.Query("code")
-	if len(code) == 0 {
-		ctx.Error(404)
-		return
-	}
-	ctx.Data["Code"] = code
-
-	if u := models.VerifyUserActiveCode(code); u != nil {
-		// Validate password length.
-		passwd := ctx.Query("passwd")
-		if len(passwd) < 6 || len(passwd) > 30 {
-			ctx.Data["IsResetForm"] = true
-			ctx.RenderWithErr("Password length should be in 6 and 30.", "user/reset_passwd", nil)
-			return
-		}
-
-		u.Passwd = passwd
-		u.Rands = models.GetUserSalt()
-		u.Salt = models.GetUserSalt()
-		u.EncodePasswd()
-		if err := models.UpdateUser(u); err != nil {
-			ctx.Handle(500, "user.ResetPasswd(UpdateUser)", err)
-			return
-		}
-
-		log.Trace("%s User password reset: %s", ctx.Req.RequestURI, u.Name)
-		ctx.Redirect("/user/login")
-		return
-	}
-
-	ctx.Data["IsResetFailed"] = true
-	ctx.HTML(200, RESET_PASSWORD)
-}