#1070 Clearer error message for illegal characters

conf/locale/locale_en-US.ini

 team_name_been_taken = Team name has been already taken.
 email_been_used = E-mail address has been already used.
 ssh_key_been_used = Public key name or content has been used.
-illegal_username = Your username contains illegal characters.
-illegal_repo_name = Repository name contains illegal characters.
-illegal_org_name = Organization name contains illegal characters.
 illegal_team_name = Team name contains illegal characters.
 username_password_incorrect = Username or password is not correct.
 enterred_invalid_repo_name = Please make sure that the repository name you entered is correct.
 starred = Starred
 following = Following
 
+form.name_reserved = Username '%s' is reserved.
+form.name_pattern_not_allowed = Username pattern '%s' is not allowed.
+
 [settings]
 profile = Profile
 password = Password
 default_branch = Default Branch
 mirror_interval = Mirror Interval (hour)
 
+form.name_reserved = Repository name '%s' is reserved.
+form.name_pattern_not_allowed = Repository name pattern '%s' is not allowed.
+
 need_auth = Need Authorization
 migrate_type = Migration Type
 migrate_type_helper = This repository will be a <span class="label label-blue label-radius">mirror</span>
 team_desc_helper = What is this team all about?
 team_permission_desc = What permission level should this team have?
 
+form.name_reserved = Organization name '%s' is reserved.
+form.name_pattern_not_allowed = Organization name pattern '%s' is not allowed.
+
 settings = Settings
 settings.options = Options
 settings.full_name = Full Name
 settings.change_orgname = Organization Name Changed
 settings.change_orgname_desc = Organization name has been changed. This will affect how links relate to the organization. Do you want to continue?
 settings.update_setting_success = Organization settings were successfully updated.
- settings.delete = Delete Organization
+settings.delete = Delete Organization
 settings.delete_account = Delete This Organization
 settings.delete_prompt = The organization will be permanently removed, and this <strong>CANNOT</strong> be undone!
 settings.confirm_delete_account = Confirm Deletion

models/error.go

 	"fmt"
 )
 
+type ErrNameReserved struct {
+	Name string
+}
+
+func IsErrNameReserved(err error) bool {
+	_, ok := err.(ErrNameReserved)
+	return ok
+}
+
+func (err ErrNameReserved) Error() string {
+	return fmt.Sprintf("name is reserved: [name: %s]", err.Name)
+}
+
+type ErrNamePatternNotAllowed struct {
+	Pattern string
+}
+
+func IsErrNamePatternNotAllowed(err error) bool {
+	_, ok := err.(ErrNamePatternNotAllowed)
+	return ok
+}
+
+func (err ErrNamePatternNotAllowed) Error() string {
+	return fmt.Sprintf("name pattern is not allowed: [pattern: %s]", err.Pattern)
+}
+
 //  ____ ___
 // |    |   \______ ___________
 // |    |   /  ___// __ \_  __ \
 // |______//____  >\___  >__|
 //              \/     \/
 
+type ErrUserAlreadyExist struct {
+	Name string
+}
+
+func IsErrUserAlreadyExist(err error) bool {
+	_, ok := err.(ErrUserAlreadyExist)
+	return ok
+}
+
+func (err ErrUserAlreadyExist) Error() string {
+	return fmt.Sprintf("user already exists: [name: %s]", err.Name)
+}
+
+type ErrEmailAlreadyUsed struct {
+	Email string
+}
+
+func IsErrEmailAlreadyUsed(err error) bool {
+	_, ok := err.(ErrEmailAlreadyUsed)
+	return ok
+}
+
+func (err ErrEmailAlreadyUsed) Error() string {
+	return fmt.Sprintf("e-mail has been used: [email: %s]", err.Email)
+}
+
 type ErrUserOwnRepos struct {
 	UID int64
 }

models/org.go

 }
 
 // CreateOrganization creates record of a new organization.
-func CreateOrganization(org, owner *User) (*User, error) {
-	if !IsLegalName(org.Name) {
-		return nil, ErrUserNameIllegal
+func CreateOrganization(org, owner *User) (err error) {
+	if err = IsUsableName(org.Name); err != nil {
+		return err
 	}
 
 	isExist, err := IsUserExist(0, org.Name)
 	if err != nil {
-		return nil, err
+		return err
 	} else if isExist {
-		return nil, ErrUserAlreadyExist
+		return ErrUserAlreadyExist{org.Name}
 	}
 
 	isExist, err = IsOrgEmailUsed(org.Email)
 	if err != nil {
-		return nil, err
+		return err
 	} else if isExist {
-		return nil, ErrEmailAlreadyUsed
+		return ErrEmailAlreadyUsed{org.Email}
 	}
 
 	org.LowerName = strings.ToLower(org.Name)
 	sess := x.NewSession()
 	defer sessionRelease(sess)
 	if err = sess.Begin(); err != nil {
-		return nil, err
+		return err
 	}
 
 	if _, err = sess.Insert(org); err != nil {
-		return nil, err
+		return fmt.Errorf("insert organization: %v", err)
 	}
 
 	// Create default owner team.
 		NumMembers: 1,
 	}
 	if _, err = sess.Insert(t); err != nil {
-		return nil, err
+		return fmt.Errorf("insert owner team: %v", err)
 	}
 
 	// Add initial creator to organization and owner team.
 		NumTeams: 1,
 	}
 	if _, err = sess.Insert(ou); err != nil {
-		return nil, err
+		return fmt.Errorf("insert org-user relation: %v", err)
 	}
 
 	tu := &TeamUser{
 		TeamID: t.ID,
 	}
 	if _, err = sess.Insert(tu); err != nil {
-		return nil, err
+		return fmt.Errorf("insert team-user relation: %v", err)
 	}
 
 	if err = os.MkdirAll(UserPath(org.Name), os.ModePerm); err != nil {
-		return nil, err
+		return fmt.Errorf("create directory: %v", err)
 	}
 
-	return org, sess.Commit()
+	return sess.Commit()
 }
 
 // GetOrgByName returns organization by given name.
 
 // NewTeam creates a record of new team.
 // It's caller's responsibility to assign organization ID.
-func NewTeam(t *Team) error {
-	if !IsLegalName(t.Name) {
-		return ErrTeamNameIllegal
+func NewTeam(t *Team) (err error) {
+	if err = IsUsableName(t.Name); err != nil {
+		return err
 	}
 
 	has, err := x.Id(t.OrgID).Get(new(User))
 
 // UpdateTeam updates information of team.
 func UpdateTeam(t *Team, authChanged bool) (err error) {
-	if !IsLegalName(t.Name) {
-		return ErrTeamNameIllegal
+	if err = IsUsableName(t.Name); err != nil {
+		return err
 	}
 
 	if len(t.Description) > 255 {

models/repo.go

 var (
 	ErrRepoAlreadyExist  = errors.New("Repository already exist")
 	ErrRepoFileNotExist  = errors.New("Repository file does not exist")
-	ErrRepoNameIllegal   = errors.New("Repository name contains illegal characters")
 	ErrRepoFileNotLoaded = errors.New("Repository file not loaded")
 	ErrMirrorNotExist    = errors.New("Mirror does not exist")
 	ErrInvalidReference  = errors.New("Invalid reference specified")
 }
 
 // IsRepositoryExist returns true if the repository with given name under user has already existed.
-func IsRepositoryExist(u *User, repoName string) bool {
-	has, _ := x.Get(&Repository{
+func IsRepositoryExist(u *User, repoName string) (bool, error) {
+	has, err := x.Get(&Repository{
 		OwnerId:   u.Id,
 		LowerName: strings.ToLower(repoName),
 	})
-	return has && com.IsDir(RepoPath(u.Name, repoName))
+	return has && com.IsDir(RepoPath(u.Name, repoName)), err
 }
 
 // CloneLink represents different types of clone URLs of repository.
 }
 
 var (
-	illegalEquals  = []string{"debug", "raw", "install", "api", "avatar", "user", "org", "help", "stars", "issues", "pulls", "commits", "repo", "template", "admin", "new"}
-	illegalSuffixs = []string{".git", ".keys"}
+	reservedNames    = []string{"debug", "raw", "install", "api", "avatar", "user", "org", "help", "stars", "issues", "pulls", "commits", "repo", "template", "admin", "new"}
+	reservedPatterns = []string{"*.git", "*.keys"}
 )
 
-// IsLegalName returns false if name contains illegal characters.
-func IsLegalName(repoName string) bool {
-	repoName = strings.ToLower(repoName)
-	for _, char := range illegalEquals {
-		if repoName == char {
-			return false
+// IsUsableName checks if name is reserved or pattern of name is not allowed.
+func IsUsableName(name string) error {
+	name = strings.ToLower(name)
+	for i := range reservedNames {
+		if name == reservedNames[i] {
+			return ErrNameReserved{name}
 		}
 	}
-	for _, char := range illegalSuffixs {
-		if strings.HasSuffix(repoName, char) {
-			return false
+
+	for _, pat := range reservedPatterns {
+		if pat[0] == '*' && strings.HasSuffix(name, pat[1:]) ||
+			(pat[len(pat)-1] == '*' && strings.HasPrefix(name, pat[:len(pat)-1])) {
+			return ErrNamePatternNotAllowed{pat}
 		}
 	}
-	return true
+
+	return nil
 }
 
 // Mirror represents a mirror information of repository.
 
 // CreateRepository creates a repository for given user or organization.
 func CreateRepository(u *User, name, desc, lang, license string, isPrivate, isMirror, initReadme bool) (_ *Repository, err error) {
-	if !IsLegalName(name) {
-		return nil, ErrRepoNameIllegal
+	if err = IsUsableName(name); err != nil {
+		return nil, err
 	}
 
-	if IsRepositoryExist(u, name) {
+	has, err := IsRepositoryExist(u, name)
+	if err != nil {
+		return nil, fmt.Errorf("IsRepositoryExist: %v", err)
+	} else if has {
 		return nil, ErrRepoAlreadyExist
 	}
 
 	}
 
 	// Check if new owner has repository with same name.
-	if IsRepositoryExist(newOwner, repo.Name) {
+	has, err := IsRepositoryExist(newOwner, repo.Name)
+	if err != nil {
+		return fmt.Errorf("IsRepositoryExist: %v", err)
+	} else if has {
 		return ErrRepoAlreadyExist
 	}
 
 }
 
 // ChangeRepositoryName changes all corresponding setting from old repository name to new one.
-func ChangeRepositoryName(userName, oldRepoName, newRepoName string) (err error) {
-	userName = strings.ToLower(userName)
+func ChangeRepositoryName(u *User, oldRepoName, newRepoName string) (err error) {
 	oldRepoName = strings.ToLower(oldRepoName)
 	newRepoName = strings.ToLower(newRepoName)
-	if !IsLegalName(newRepoName) {
-		return ErrRepoNameIllegal
+	if err = IsUsableName(newRepoName); err != nil {
+		return err
+	}
+
+	has, err := IsRepositoryExist(u, newRepoName)
+	if err != nil {
+		return fmt.Errorf("IsRepositoryExist: %v", err)
+	} else if has {
+		return ErrRepoAlreadyExist
 	}
 
 	// Change repository directory name.
-	return os.Rename(RepoPath(userName, oldRepoName), RepoPath(userName, newRepoName))
+	return os.Rename(RepoPath(u.LowerName, oldRepoName), RepoPath(u.LowerName, newRepoName))
 }
 
 func updateRepository(e Engine, repo *Repository, visibilityChanged bool) (err error) {
 //      \/                   \/
 
 func ForkRepository(u *User, oldRepo *Repository, name, desc string) (_ *Repository, err error) {
-	if IsRepositoryExist(u, name) {
+	has, err := IsRepositoryExist(u, name)
+	if err != nil {
+		return nil, fmt.Errorf("IsRepositoryExist: %v", err)
+	} else if has {
 		return nil, ErrRepoAlreadyExist
 	}
 

models/user.go

 )
 
 var (
-	ErrUserAlreadyExist      = errors.New("User already exist")
 	ErrUserNotExist          = errors.New("User does not exist")
 	ErrUserNotKeyOwner       = errors.New("User does not the owner of public key")
-	ErrEmailAlreadyUsed      = errors.New("E-mail already used")
 	ErrEmailNotExist         = errors.New("E-mail does not exist")
 	ErrEmailNotActivated     = errors.New("E-mail address has not been activated")
 	ErrUserNameIllegal       = errors.New("User name contains illegal characters")
 }
 
 // CreateUser creates record of a new user.
-func CreateUser(u *User) error {
-	if !IsLegalName(u.Name) {
-		return ErrUserNameIllegal
+func CreateUser(u *User) (err error) {
+	if err = IsUsableName(u.Name); err != nil {
+		return err
 	}
 
 	isExist, err := IsUserExist(0, u.Name)
 	if err != nil {
 		return err
 	} else if isExist {
-		return ErrUserAlreadyExist
+		return ErrUserAlreadyExist{u.Name}
 	}
 
 	isExist, err = IsEmailUsed(u.Email)
 	if err != nil {
 		return err
 	} else if isExist {
-		return ErrEmailAlreadyUsed
+		return ErrEmailAlreadyUsed{u.Email}
 	}
 
 	u.LowerName = strings.ToLower(u.Name)
 
 // ChangeUserName changes all corresponding setting from old user name to new one.
 func ChangeUserName(u *User, newUserName string) (err error) {
-	if !IsLegalName(newUserName) {
-		return ErrUserNameIllegal
+	if err = IsUsableName(newUserName); err != nil {
+		return err
+	}
+
+	isExist, err := IsUserExist(0, newUserName)
+	if err != nil {
+		return err
+	} else if isExist {
+		return ErrUserAlreadyExist{newUserName}
 	}
 
 	return os.Rename(UserPath(u.LowerName), UserPath(newUserName))
 	if err != nil {
 		return err
 	} else if has {
-		return ErrEmailAlreadyUsed
+		return ErrEmailAlreadyUsed{u.Email}
 	}
 
 	u.LowerName = strings.ToLower(u.Name)
 	if err != nil {
 		return err
 	} else if used {
-		return ErrEmailAlreadyUsed
+		return ErrEmailAlreadyUsed{email.Email}
 	}
 
 	_, err = x.Insert(email)

routers/admin/users.go

 	}
 
 	if err := models.CreateUser(u); err != nil {
-		switch err {
-		case models.ErrUserAlreadyExist:
+		switch {
+		case models.IsErrUserAlreadyExist(err):
 			ctx.Data["Err_UserName"] = true
 			ctx.RenderWithErr(ctx.Tr("form.username_been_taken"), USER_NEW, &form)
-		case models.ErrEmailAlreadyUsed:
+		case models.IsErrEmailAlreadyUsed(err):
 			ctx.Data["Err_Email"] = true
 			ctx.RenderWithErr(ctx.Tr("form.email_been_used"), USER_NEW, &form)
-		case models.ErrUserNameIllegal:
+		case models.IsErrNameReserved(err):
+			ctx.Data["Err_UserName"] = true
+			ctx.RenderWithErr(ctx.Tr("user.form.name_reserved", err.(models.ErrNameReserved).Name), USER_NEW, &form)
+		case models.IsErrNamePatternNotAllowed(err):
 			ctx.Data["Err_UserName"] = true
-			ctx.RenderWithErr(ctx.Tr("form.illegal_username"), USER_NEW, &form)
+			ctx.RenderWithErr(ctx.Tr("user.form.name_pattern_not_allowed", err.(models.ErrNamePatternNotAllowed).Pattern), USER_NEW, &form)
 		default:
 			ctx.Handle(500, "CreateUser", err)
 		}
 	u.AllowGitHook = form.AllowGitHook
 
 	if err := models.UpdateUser(u); err != nil {
-		if err == models.ErrEmailAlreadyUsed {
+		if models.IsErrEmailAlreadyUsed(err) {
 			ctx.Data["Err_Email"] = true
 			ctx.RenderWithErr(ctx.Tr("form.email_been_used"), USER_EDIT, &form)
 		} else {

routers/api/v1/repo.go

 		opt.Gitignore, opt.License, opt.Private, false, opt.AutoInit)
 	if err != nil {
 		if err == models.ErrRepoAlreadyExist ||
-			err == models.ErrRepoNameIllegal {
+			models.IsErrNameReserved(err) ||
+			models.IsErrNamePatternNotAllowed(err) {
 			ctx.JSON(422, &base.ApiJsonErr{err.Error(), base.DOC_URL})
 		} else {
 			log.Error(4, "CreateRepository: %v", err)

routers/install.go

 	// Create admin account.
 	if err := models.CreateUser(&models.User{Name: form.AdminName, Email: form.AdminEmail, Passwd: form.AdminPasswd,
 		IsAdmin: true, IsActive: true}); err != nil {
-		if err != models.ErrUserAlreadyExist {
+		if !models.IsErrUserAlreadyExist(err) {
 			setting.InstallLock = false
 			ctx.Data["Err_AdminName"] = true
 			ctx.Data["Err_AdminEmail"] = true

routers/org/org.go

 	}
 
 	var err error
-	if org, err = models.CreateOrganization(org, ctx.User); err != nil {
-		switch err {
-		case models.ErrUserAlreadyExist:
+	if err = models.CreateOrganization(org, ctx.User); err != nil {
+		switch {
+		case models.IsErrUserAlreadyExist(err):
 			ctx.Data["Err_OrgName"] = true
 			ctx.RenderWithErr(ctx.Tr("form.org_name_been_taken"), CREATE, &form)
-		case models.ErrEmailAlreadyUsed:
+		case models.IsErrEmailAlreadyUsed(err):
 			ctx.Data["Err_Email"] = true
 			ctx.RenderWithErr(ctx.Tr("form.email_been_used"), CREATE, &form)
-		case models.ErrUserNameIllegal:
+		case models.IsErrNameReserved(err):
 			ctx.Data["Err_OrgName"] = true
-			ctx.RenderWithErr(ctx.Tr("form.illegal_org_name"), CREATE, &form)
+			ctx.RenderWithErr(ctx.Tr("org.form.name_reserved", err.(models.ErrNameReserved).Name), CREATE, &form)
+		case models.IsErrNamePatternNotAllowed(err):
+			ctx.Data["Err_OrgName"] = true
+			ctx.RenderWithErr(ctx.Tr("org.form.name_pattern_not_allowed", err.(models.ErrNamePatternNotAllowed).Pattern), CREATE, &form)
 		default:
-			ctx.Handle(500, "CreateUser", err)
+			ctx.Handle(500, "CreateOrganization", err)
 		}
 		return
 	}

routers/org/setting.go

 	org.Avatar = base.EncodeMd5(form.Avatar)
 	org.AvatarEmail = form.Avatar
 	if err := models.UpdateUser(org); err != nil {
-		if err == models.ErrEmailAlreadyUsed {
+		if models.IsErrEmailAlreadyUsed(err) {
 			ctx.Data["Err_Email"] = true
 			ctx.RenderWithErr(ctx.Tr("form.email_been_used"), SETTINGS_OPTIONS, &form)
 		} else {

routers/repo/repo.go

 		log.Trace("Repository created: %s/%s", ctxUser.Name, repo.Name)
 		ctx.Redirect(setting.AppSubUrl + "/" + ctxUser.Name + "/" + repo.Name)
 		return
-	} else if err == models.ErrRepoAlreadyExist {
-		ctx.Data["Err_RepoName"] = true
-		ctx.RenderWithErr(ctx.Tr("form.repo_name_been_taken"), CREATE, &form)
-		return
-	} else if err == models.ErrRepoNameIllegal {
-		ctx.Data["Err_RepoName"] = true
-		ctx.RenderWithErr(ctx.Tr("form.illegal_repo_name"), CREATE, &form)
-		return
 	}
 
 	if repo != nil {
 			log.Error(4, "DeleteRepository: %v", errDelete)
 		}
 	}
-	ctx.Handle(500, "CreatePost", err)
+
+	switch {
+	case err == models.ErrRepoAlreadyExist:
+		ctx.Data["Err_RepoName"] = true
+		ctx.RenderWithErr(ctx.Tr("form.repo_name_been_taken"), CREATE, &form)
+	case models.IsErrNameReserved(err):
+		ctx.Data["Err_RepoName"] = true
+		ctx.RenderWithErr(ctx.Tr("repo.form.name_reserved", err.(models.ErrNameReserved).Name), CREATE, &form)
+	case models.IsErrNamePatternNotAllowed(err):
+		ctx.Data["Err_RepoName"] = true
+		ctx.RenderWithErr(ctx.Tr("repo.form.name_pattern_not_allowed", err.(models.ErrNamePatternNotAllowed).Pattern), CREATE, &form)
+	default:
+		ctx.Handle(500, "CreatePost", err)
+	}
 }
 
 func Migrate(ctx *middleware.Context) {
 		log.Trace("Repository migrated: %s/%s", ctxUser.Name, form.RepoName)
 		ctx.Redirect(setting.AppSubUrl + "/" + ctxUser.Name + "/" + form.RepoName)
 		return
-	} else if err == models.ErrRepoAlreadyExist {
-		ctx.Data["Err_RepoName"] = true
-		ctx.RenderWithErr(ctx.Tr("form.repo_name_been_taken"), MIGRATE, &form)
-		return
-	} else if err == models.ErrRepoNameIllegal {
-		ctx.Data["Err_RepoName"] = true
-		ctx.RenderWithErr(ctx.Tr("form.illegal_repo_name"), MIGRATE, &form)
-		return
 	}
 
 	if repo != nil {
 		ctx.RenderWithErr(ctx.Tr("form.auth_failed", err), MIGRATE, &form)
 		return
 	}
-	ctx.Handle(500, "MigratePost", err)
+
+	switch {
+	case err == models.ErrRepoAlreadyExist:
+		ctx.Data["Err_RepoName"] = true
+		ctx.RenderWithErr(ctx.Tr("form.repo_name_been_taken"), MIGRATE, &form)
+	case models.IsErrNameReserved(err):
+		ctx.Data["Err_RepoName"] = true
+		ctx.RenderWithErr(ctx.Tr("repo.form.name_reserved", err.(models.ErrNameReserved).Name), MIGRATE, &form)
+	case models.IsErrNamePatternNotAllowed(err):
+		ctx.Data["Err_RepoName"] = true
+		ctx.RenderWithErr(ctx.Tr("repo.form.name_pattern_not_allowed", err.(models.ErrNamePatternNotAllowed).Pattern), MIGRATE, &form)
+	default:
+		ctx.Handle(500, "MigratePost", err)
+	}
 }
 
 func getForkRepository(ctx *middleware.Context) (*models.Repository, error) {
 		log.Trace("Repository forked: %s/%s", ctxUser.Name, repo.Name)
 		ctx.Redirect(setting.AppSubUrl + "/" + ctxUser.Name + "/" + repo.Name)
 		return
-	} else if err == models.ErrRepoAlreadyExist {
-		ctx.Data["Err_RepoName"] = true
-		ctx.RenderWithErr(ctx.Tr("form.repo_name_been_taken"), FORK, &form)
-		return
-	} else if err == models.ErrRepoNameIllegal {
-		ctx.Data["Err_RepoName"] = true
-		ctx.RenderWithErr(ctx.Tr("form.illegal_repo_name"), CREATE, &form)
-		return
 	}
 
 	if repo != nil {
 			log.Error(4, "DeleteRepository: %v", errDelete)
 		}
 	}
-	ctx.Handle(500, "ForkPost", err)
+
+	// FIXME: merge this with other 2 error handling in to one.
+	switch {
+	case err == models.ErrRepoAlreadyExist:
+		ctx.Data["Err_RepoName"] = true
+		ctx.RenderWithErr(ctx.Tr("form.repo_name_been_taken"), FORK, &form)
+	case models.IsErrNameReserved(err):
+		ctx.Data["Err_RepoName"] = true
+		ctx.RenderWithErr(ctx.Tr("repo.form.name_reserved", err.(models.ErrNameReserved).Name), FORK, &form)
+	case models.IsErrNamePatternNotAllowed(err):
+		ctx.Data["Err_RepoName"] = true
+		ctx.RenderWithErr(ctx.Tr("repo.form.name_pattern_not_allowed", err.(models.ErrNamePatternNotAllowed).Pattern), FORK, &form)
+	default:
+		ctx.Handle(500, "ForkPost", err)
+	}
 }
 
 func Action(ctx *middleware.Context) {

routers/repo/setting.go

 		newRepoName := form.RepoName
 		// Check if repository name has been changed.
 		if ctx.Repo.Repository.Name != newRepoName {
-			if models.IsRepositoryExist(ctx.Repo.Owner, newRepoName) {
-				ctx.Data["Err_RepoName"] = true
-				ctx.RenderWithErr(ctx.Tr("form.repo_name_been_taken"), SETTINGS_OPTIONS, nil)
-				return
-			} else if err := models.ChangeRepositoryName(ctx.Repo.Owner.Name, ctx.Repo.Repository.Name, newRepoName); err != nil {
-				if err == models.ErrRepoNameIllegal {
+			if err := models.ChangeRepositoryName(ctx.Repo.Owner, ctx.Repo.Repository.Name, newRepoName); err != nil {
+				switch {
+				case err == models.ErrRepoAlreadyExist:
+					ctx.Data["Err_RepoName"] = true
+					ctx.RenderWithErr(ctx.Tr("form.repo_name_been_taken"), SETTINGS_OPTIONS, &form)
+				case models.IsErrNameReserved(err):
+					ctx.Data["Err_RepoName"] = true
+					ctx.RenderWithErr(ctx.Tr("repo.form.name_reserved", err.(models.ErrNameReserved).Name), SETTINGS_OPTIONS, &form)
+				case models.IsErrNamePatternNotAllowed(err):
 					ctx.Data["Err_RepoName"] = true
-					ctx.RenderWithErr(ctx.Tr("form.illegal_repo_name"), SETTINGS_OPTIONS, nil)
-				} else {
+					ctx.RenderWithErr(ctx.Tr("repo.form.name_pattern_not_allowed", err.(models.ErrNamePatternNotAllowed).Pattern), SETTINGS_OPTIONS, &form)
+				default:
 					ctx.Handle(500, "ChangeRepositoryName", err)
 				}
 				return

routers/user/auth.go

 	}
 
 	if err := models.CreateUser(u); err != nil {
-		switch err {
-		case models.ErrUserAlreadyExist:
+		switch {
+		case models.IsErrUserAlreadyExist(err):
 			ctx.Data["Err_UserName"] = true
 			ctx.RenderWithErr(ctx.Tr("form.username_been_taken"), SIGNUP, &form)
-		case models.ErrEmailAlreadyUsed:
+		case models.IsErrEmailAlreadyUsed(err):
 			ctx.Data["Err_Email"] = true
 			ctx.RenderWithErr(ctx.Tr("form.email_been_used"), SIGNUP, &form)
-		case models.ErrUserNameIllegal:
+		case models.IsErrNameReserved(err):
 			ctx.Data["Err_UserName"] = true
-			ctx.RenderWithErr(ctx.Tr("form.illegal_username"), SIGNUP, &form)
+			ctx.RenderWithErr(ctx.Tr("user.form.name_reserved", err.(models.ErrNameReserved).Name), SIGNUP, &form)
+		case models.IsErrNamePatternNotAllowed(err):
+			ctx.Data["Err_UserName"] = true
+			ctx.RenderWithErr(ctx.Tr("user.form.name_pattern_not_allowed", err.(models.ErrNamePatternNotAllowed).Pattern), SIGNUP, &form)
 		default:
 			ctx.Handle(500, "CreateUser", err)
 		}

routers/user/setting.go

 
 	// Check if user name has been changed.
 	if ctx.User.Name != form.UserName {
-		isExist, err := models.IsUserExist(ctx.User.Id, form.UserName)
-		if err != nil {
-			ctx.Handle(500, "IsUserExist", err)
-			return
-		} else if isExist {
-			ctx.RenderWithErr(ctx.Tr("form.username_been_taken"), SETTINGS_PROFILE, &form)
-			return
-		} else if err = models.ChangeUserName(ctx.User, form.UserName); err != nil {
-			switch err {
-			case models.ErrUserNameIllegal:
-				ctx.Flash.Error(ctx.Tr("form.illegal_username"))
+		if err := models.ChangeUserName(ctx.User, form.UserName); err != nil {
+			switch {
+			case models.IsErrUserAlreadyExist(err):
+				ctx.Flash.Error(ctx.Tr("form.username_been_taken"))
 				ctx.Redirect(setting.AppSubUrl + "/user/settings")
-			case models.ErrEmailAlreadyUsed:
+			case models.IsErrEmailAlreadyUsed(err):
 				ctx.Flash.Error(ctx.Tr("form.email_been_used"))
 				ctx.Redirect(setting.AppSubUrl + "/user/settings")
+			case models.IsErrNameReserved(err):
+				ctx.Flash.Error(ctx.Tr("user.form.name_reserved"))
+				ctx.Redirect(setting.AppSubUrl + "/user/settings")
+			case models.IsErrNamePatternNotAllowed(err):
+				ctx.Flash.Error(ctx.Tr("user.form.name_pattern_not_allowed"))
+				ctx.Redirect(setting.AppSubUrl + "/user/settings")
 			default:
 				ctx.Handle(500, "ChangeUserName", err)
 			}
 	}
 
 	if err := models.AddEmailAddress(e); err != nil {
-		if err == models.ErrEmailAlreadyUsed {
+		if models.IsErrEmailAlreadyUsed(err) {
 			ctx.RenderWithErr(ctx.Tr("form.email_been_used"), SETTINGS_EMAILS, &form)
 			return
 		}