feat: return most backend API errors to frontend (#1836)

* feat: return most backend API errros to frontend Signed-off-by: yehong <239859435@qq.com> * refactor: reduce int type change Signed-off-by: yehong <239859435@qq.com> * feat: return err backend in token.go Signed-off-by: yehong <239859435@qq.com> --------- Signed-off-by: yehong <239859435@qq.com>
2025-07-02 19:40:19 +08:00 · 2023-05-30 15:49:39 +08:00
parent 34151c0095
commit 02e692a300
105 changed files with 3788 additions and 1734 deletions
--- a/object/user.go
+++ b/object/user.go
@ -191,217 +191,206 @@ type ManagedAccount struct {
 	SigninUrl   string `xorm:"varchar(200)" json:"signinUrl"`
 }

-func GetGlobalUserCount(field, value string) int {
+func GetGlobalUserCount(field, value string) (int64, error) {
 	session := GetSession("", -1, -1, field, value, "", "")
-	count, err := session.Count(&User{})
-	if err != nil {
-		panic(err)
-	}
-
-	return int(count)
+	return session.Count(&User{})
 }

-func GetGlobalUsers() []*User {
+func GetGlobalUsers() ([]*User, error) {
 	users := []*User{}
 	err := adapter.Engine.Desc("created_time").Find(&users)
 	if err != nil {
-		panic(err)
+		return nil, err
 	}

-	return users
+	return users, nil
 }

-func GetPaginationGlobalUsers(offset, limit int, field, value, sortField, sortOrder string) []*User {
+func GetPaginationGlobalUsers(offset, limit int, field, value, sortField, sortOrder string) ([]*User, error) {
 	users := []*User{}
 	session := GetSession("", offset, limit, field, value, sortField, sortOrder)
 	err := session.Find(&users)
 	if err != nil {
-		panic(err)
+		return nil, err
 	}

-	return users
+	return users, nil
 }

-func GetUserCount(owner, field, value string) int {
+func GetUserCount(owner, field, value string) (int64, error) {
 	session := GetSession(owner, -1, -1, field, value, "", "")
-	count, err := session.Count(&User{})
-	if err != nil {
-		panic(err)
-	}
-
-	return int(count)
+	return session.Count(&User{})
 }

-func GetOnlineUserCount(owner string, isOnline int) int {
-	count, err := adapter.Engine.Where("is_online = ?", isOnline).Count(&User{Owner: owner})
-	if err != nil {
-		panic(err)
-	}
-
-	return int(count)
+func GetOnlineUserCount(owner string, isOnline int) (int64, error) {
+	return adapter.Engine.Where("is_online = ?", isOnline).Count(&User{Owner: owner})
 }

-func GetUsers(owner string) []*User {
+func GetUsers(owner string) ([]*User, error) {
 	users := []*User{}
 	err := adapter.Engine.Desc("created_time").Find(&users, &User{Owner: owner})
 	if err != nil {
-		panic(err)
+		return nil, err
 	}

-	return users
+	return users, nil
 }

-func GetUsersByTag(owner string, tag string) []*User {
+func GetUsersByTag(owner string, tag string) ([]*User, error) {
 	users := []*User{}
 	err := adapter.Engine.Desc("created_time").Find(&users, &User{Owner: owner, Tag: tag})
 	if err != nil {
-		panic(err)
+		return nil, err
 	}

-	return users
+	return users, nil
 }

-func GetSortedUsers(owner string, sorter string, limit int) []*User {
+func GetSortedUsers(owner string, sorter string, limit int) ([]*User, error) {
 	users := []*User{}
 	err := adapter.Engine.Desc(sorter).Limit(limit, 0).Find(&users, &User{Owner: owner})
 	if err != nil {
-		panic(err)
+		return nil, err
 	}

-	return users
+	return users, nil
 }

-func GetPaginationUsers(owner string, offset, limit int, field, value, sortField, sortOrder string) []*User {
+func GetPaginationUsers(owner string, offset, limit int, field, value, sortField, sortOrder string) ([]*User, error) {
 	users := []*User{}
 	session := GetSession(owner, offset, limit, field, value, sortField, sortOrder)
 	err := session.Find(&users)
 	if err != nil {
-		panic(err)
+		return nil, err
 	}

-	return users
+	return users, nil
 }

-func getUser(owner string, name string) *User {
+func getUser(owner string, name string) (*User, error) {
 	if owner == "" || name == "" {
-		return nil
+		return nil, nil
 	}

 	user := User{Owner: owner, Name: name}
 	existed, err := adapter.Engine.Get(&user)
 	if err != nil {
-		panic(err)
+		return nil, err
 	}

 	if existed {
-		return &user
+		return &user, nil
 	} else {
-		return nil
+		return nil, nil
 	}
 }

-func getUserById(owner string, id string) *User {
+func getUserById(owner string, id string) (*User, error) {
 	if owner == "" || id == "" {
-		return nil
+		return nil, nil
 	}

 	user := User{Owner: owner, Id: id}
 	existed, err := adapter.Engine.Get(&user)
 	if err != nil {
-		panic(err)
+		return nil, err
 	}

 	if existed {
-		return &user
+		return &user, nil
 	} else {
-		return nil
+		return nil, nil
 	}
 }

-func getUserByWechatId(wechatOpenId string, wechatUnionId string) *User {
+func getUserByWechatId(wechatOpenId string, wechatUnionId string) (*User, error) {
 	if wechatUnionId == "" {
 		wechatUnionId = wechatOpenId
 	}
 	user := &User{}
 	existed, err := adapter.Engine.Where("wechat = ? OR wechat = ?", wechatOpenId, wechatUnionId).Get(user)
 	if err != nil {
-		panic(err)
+		return nil, err
 	}

 	if existed {
-		return user
+		return user, nil
 	} else {
-		return nil
+		return nil, nil
 	}
 }

-func GetUserByEmail(owner string, email string) *User {
+func GetUserByEmail(owner string, email string) (*User, error) {
 	if owner == "" || email == "" {
-		return nil
+		return nil, nil
 	}

 	user := User{Owner: owner, Email: email}
 	existed, err := adapter.Engine.Get(&user)
 	if err != nil {
-		panic(err)
+		return nil, err
 	}

 	if existed {
-		return &user
+		return &user, nil
 	} else {
-		return nil
+		return nil, nil
 	}
 }

-func GetUserByPhone(owner string, phone string) *User {
+func GetUserByPhone(owner string, phone string) (*User, error) {
 	if owner == "" || phone == "" {
-		return nil
+		return nil, nil
 	}

 	user := User{Owner: owner, Phone: phone}
 	existed, err := adapter.Engine.Get(&user)
 	if err != nil {
-		panic(err)
+		return nil, err
 	}

 	if existed {
-		return &user
+		return &user, nil
 	} else {
-		return nil
+		return nil, nil
 	}
 }

-func GetUserByUserId(owner string, userId string) *User {
+func GetUserByUserId(owner string, userId string) (*User, error) {
 	if owner == "" || userId == "" {
-		return nil
+		return nil, nil
 	}

 	user := User{Owner: owner, Id: userId}
 	existed, err := adapter.Engine.Get(&user)
 	if err != nil {
-		panic(err)
+		return nil, err
 	}

 	if existed {
-		return &user
+		return &user, nil
 	} else {
-		return nil
+		return nil, nil
 	}
 }

-func GetUser(id string) *User {
+func GetUser(id string) (*User, error) {
 	owner, name := util.GetOwnerAndNameFromId(id)
 	return getUser(owner, name)
 }

-func GetUserNoCheck(id string) *User {
+func GetUserNoCheck(id string) (*User, error) {
 	owner, name := util.GetOwnerAndNameFromIdNoCheck(id)
 	return getUser(owner, name)
 }

-func GetMaskedUser(user *User) *User {
+func GetMaskedUser(user *User, errs ...error) (*User, error) {
+	if len(errs) > 0 && errs[0] != nil {
+		return nil, errs[0]
+	}
+
 	if user == nil {
-		return nil
+		return nil, nil
 	}

 	if user.Password != "" {
@ -419,51 +408,69 @@ func GetMaskedUser(user *User) *User {
 			user.MultiFactorAuths[i] = GetMaskedProps(props)
 		}
 	}
-	return user
+	return user, nil
 }

-func GetMaskedUsers(users []*User) []*User {
-	for _, user := range users {
-		user = GetMaskedUser(user)
+func GetMaskedUsers(users []*User, errs ...error) ([]*User, error) {
+	if len(errs) > 0 && errs[0] != nil {
+		return nil, errs[0]
 	}
-	return users
+
+	var err error
+	for _, user := range users {
+		user, err = GetMaskedUser(user)
+		if err != nil {
+			return nil, err
+		}
+	}
+	return users, nil
 }

-func GetLastUser(owner string) *User {
+func GetLastUser(owner string) (*User, error) {
 	user := User{Owner: owner}
 	existed, err := adapter.Engine.Desc("created_time", "id").Get(&user)
 	if err != nil {
-		panic(err)
+		return nil, err
 	}

 	if existed {
-		return &user
+		return &user, nil
 	}

-	return nil
+	return nil, nil
 }

-func UpdateUser(id string, user *User, columns []string, isAdmin bool) bool {
+func UpdateUser(id string, user *User, columns []string, isAdmin bool) (bool, error) {
+	var err error
 	owner, name := util.GetOwnerAndNameFromIdNoCheck(id)
-	oldUser := getUser(owner, name)
+	oldUser, err := getUser(owner, name)
+	if err != nil {
+		return false, err
+	}
 	if oldUser == nil {
-		return false
+		return false, nil
 	}

 	if name != user.Name {
 		err := userChangeTrigger(name, user.Name)
 		if err != nil {
-			return false
+			return false, nil
 		}
 	}

 	if user.Password == "***" {
 		user.Password = oldUser.Password
 	}
-	user.UpdateUserHash()
+	err = user.UpdateUserHash()
+	if err != nil {
+		panic(err)
+	}

 	if user.Avatar != oldUser.Avatar && user.Avatar != "" && user.PermanentAvatar != "*" {
-		user.PermanentAvatar = getPermanentAvatarUrl(user.Owner, user.Name, user.Avatar, false)
+		user.PermanentAvatar, err = getPermanentAvatarUrl(user.Owner, user.Name, user.Avatar, false)
+		if err != nil {
+			return false, err
+		}
 	}

 	if len(columns) == 0 {
@ -487,77 +494,105 @@ func UpdateUser(id string, user *User, columns []string, isAdmin bool) bool {

 	affected, err := adapter.Engine.ID(core.PK{owner, name}).Cols(columns...).Update(user)
 	if err != nil {
-		panic(err)
+		return false, err
 	}

-	return affected != 0
+	return affected != 0, nil
 }

-func UpdateUserForAllFields(id string, user *User) bool {
+func UpdateUserForAllFields(id string, user *User) (bool, error) {
+	var err error
 	owner, name := util.GetOwnerAndNameFromId(id)
-	oldUser := getUser(owner, name)
+	oldUser, err := getUser(owner, name)
+	if err != nil {
+		return false, err
+	}
+
 	if oldUser == nil {
-		return false
+		return false, nil
 	}

 	if name != user.Name {
 		err := userChangeTrigger(name, user.Name)
 		if err != nil {
-			return false
+			return false, nil
 		}
 	}

-	user.UpdateUserHash()
+	err = user.UpdateUserHash()
+	if err != nil {
+		return false, err
+	}

 	if user.Avatar != oldUser.Avatar && user.Avatar != "" {
-		user.PermanentAvatar = getPermanentAvatarUrl(user.Owner, user.Name, user.Avatar, false)
+		user.PermanentAvatar, err = getPermanentAvatarUrl(user.Owner, user.Name, user.Avatar, false)
+		if err != nil {
+			return false, err
+		}
 	}

 	affected, err := adapter.Engine.ID(core.PK{owner, name}).AllCols().Update(user)
 	if err != nil {
-		panic(err)
+		return false, err
 	}

-	return affected != 0
+	return affected != 0, nil
 }

-func AddUser(user *User) bool {
+func AddUser(user *User) (bool, error) {
+	var err error
 	if user.Id == "" {
 		user.Id = util.GenerateId()
 	}

 	if user.Owner == "" || user.Name == "" {
-		return false
+		return false, nil
 	}

-	organization := GetOrganizationByUser(user)
+	organization, _ := GetOrganizationByUser(user)
 	if organization == nil {
-		return false
+		return false, nil
 	}

 	user.UpdateUserPassword(organization)

-	user.UpdateUserHash()
-	user.PreHash = user.Hash
-
-	updated := user.refreshAvatar()
-	if updated && user.PermanentAvatar != "*" {
-		user.PermanentAvatar = getPermanentAvatarUrl(user.Owner, user.Name, user.Avatar, false)
+	err = user.UpdateUserHash()
+	if err != nil {
+		return false, err
 	}

-	user.Ranking = GetUserCount(user.Owner, "", "") + 1
+	user.PreHash = user.Hash
+
+	updated, err := user.refreshAvatar()
+	if err != nil {
+		return false, err
+	}
+
+	if updated && user.PermanentAvatar != "*" {
+		user.PermanentAvatar, err = getPermanentAvatarUrl(user.Owner, user.Name, user.Avatar, false)
+		if err != nil {
+			return false, err
+		}
+	}
+
+	count, err := GetUserCount(user.Owner, "", "")
+	if err != nil {
+		return false, err
+	}
+	user.Ranking = int(count + 1)

 	affected, err := adapter.Engine.Insert(user)
 	if err != nil {
-		panic(err)
+		return false, err
 	}

-	return affected != 0
+	return affected != 0, nil
 }

-func AddUsers(users []*User) bool {
+func AddUsers(users []*User) (bool, error) {
+	var err error
 	if len(users) == 0 {
-		return false
+		return false, nil
 	}

 	// organization := GetOrganizationByUser(users[0])
@ -565,27 +600,34 @@ func AddUsers(users []*User) bool {
 		// this function is only used for syncer or batch upload, so no need to encrypt the password
 		// user.UpdateUserPassword(organization)

-		user.UpdateUserHash()
+		err = user.UpdateUserHash()
+		if err != nil {
+			return false, err
+		}
+
 		user.PreHash = user.Hash

-		user.PermanentAvatar = getPermanentAvatarUrl(user.Owner, user.Name, user.Avatar, true)
+		user.PermanentAvatar, err = getPermanentAvatarUrl(user.Owner, user.Name, user.Avatar, true)
+		if err != nil {
+			return false, err
+		}
 	}

 	affected, err := adapter.Engine.Insert(users)
 	if err != nil {
 		if !strings.Contains(err.Error(), "Duplicate entry") {
-			panic(err)
+			return false, err
 		}
 	}

-	return affected != 0
+	return affected != 0, nil
 }

-func AddUsersInBatch(users []*User) bool {
+func AddUsersInBatch(users []*User) (bool, error) {
 	batchSize := conf.GetConfigBatchSize()

 	if len(users) == 0 {
-		return false
+		return false, nil
 	}

 	affected := false
@ -599,24 +641,29 @@ func AddUsersInBatch(users []*User) bool {
 		tmp := users[start:end]
 		// TODO: save to log instead of standard output
 		// fmt.Printf("Add users: [%d - %d].\n", start, end)
-		if AddUsers(tmp) {
+		if ok, err := AddUsers(tmp); err != nil {
+			return false, err
+		} else if ok {
 			affected = true
 		}
 	}

-	return affected
+	return affected, nil
 }

-func DeleteUser(user *User) bool {
+func DeleteUser(user *User) (bool, error) {
 	// Forced offline the user first
-	DeleteSession(util.GetSessionId(user.Owner, user.Name, CasdoorApplication))
+	_, err := DeleteSession(util.GetSessionId(user.Owner, user.Name, CasdoorApplication))
+	if err != nil {
+		return false, err
+	}

 	affected, err := adapter.Engine.ID(core.PK{user.Owner, user.Name}).Delete(&User{})
 	if err != nil {
-		panic(err)
+		return false, err
 	}

-	return affected != 0
+	return affected != 0, nil
 }

 func GetUserInfo(user *User, scope string, aud string, host string) *Userinfo {
@ -644,7 +691,7 @@ func GetUserInfo(user *User, scope string, aud string, host string) *Userinfo {
 	return &resp
 }

-func LinkUserAccount(user *User, field string, value string) bool {
+func LinkUserAccount(user *User, field string, value string) (bool, error) {
 	return SetUserField(user, field, value)
 }

@ -656,13 +703,18 @@ func isUserIdGlobalAdmin(userId string) bool {
 	return strings.HasPrefix(userId, "built-in/")
 }

-func ExtendUserWithRolesAndPermissions(user *User) {
+func ExtendUserWithRolesAndPermissions(user *User) (err error) {
 	if user == nil {
 		return
 	}

-	user.Roles = GetRolesByUser(user.GetId())
-	user.Permissions = GetPermissionsByUser(user.GetId())
+	user.Roles, err = GetRolesByUser(user.GetId())
+	if err != nil {
+		return
+	}
+
+	user.Permissions, err = GetPermissionsByUser(user.GetId())
+	return
 }

 func userChangeTrigger(oldName string, newName string) error {
@ -679,6 +731,7 @@ func userChangeTrigger(oldName string, newName string) error {
 	if err != nil {
 		return err
 	}
+
 	for _, role := range roles {
 		for j, u := range role.Users {
 			// u = organization/username
@ -722,7 +775,7 @@ func userChangeTrigger(oldName string, newName string) error {
 	return session.Commit()
 }

-func (user *User) refreshAvatar() bool {
+func (user *User) refreshAvatar() (bool, error) {
 	var err error
 	var fileBuffer *bytes.Buffer
 	var ext string
@ -732,13 +785,13 @@ func (user *User) refreshAvatar() bool {
 		client := proxy.ProxyHttpClient
 		has, err := hasGravatar(client, user.Email)
 		if err != nil {
-			panic(err)
+			return false, err
 		}

 		if has {
 			fileBuffer, ext, err = getGravatarFileBuffer(client, user.Email)
 			if err != nil {
-				panic(err)
+				return false, err
 			}
 		}
 	}
@ -746,17 +799,20 @@ func (user *User) refreshAvatar() bool {
 	if fileBuffer == nil && strings.Contains(user.Avatar, "Identicon") {
 		fileBuffer, ext, err = getIdenticonFileBuffer(user.Name)
 		if err != nil {
-			panic(err)
+			return false, err
 		}
 	}

 	if fileBuffer != nil {
-		avatarUrl := getPermanentAvatarUrlFromBuffer(user.Owner, user.Name, fileBuffer, ext, true)
+		avatarUrl, err := getPermanentAvatarUrlFromBuffer(user.Owner, user.Name, fileBuffer, ext, true)
+		if err != nil {
+			return false, err
+		}
 		user.Avatar = avatarUrl
-		return true
+		return true, nil
 	}

-	return false
+	return false, nil
 }

 func (user *User) IsMfaEnabled() bool {