update user api error handling

cmd/dashboard/controller/user.go

@@ -151,6 +151,6 @@ func batchDeleteUser(c *gin.Context) (any, error) {
 		return nil, singleton.Localizer.ErrorT("can't delete yourself")
 	}
 
-	singleton.OnUserDelete(ids)
+	err := singleton.OnUserDelete(ids, newGormError)
-	return nil, singleton.DB.Where("id IN (?)", ids).Delete(&model.User{}).Error
+	return nil, err
 }

service/singleton/user.go

@@ -39,50 +39,65 @@ func OnUserUpdate(u *model.User) {
 	AgentSecretToUserId[u.AgentSecret] = u.ID
 }
 
-func OnUserDelete(id []uint64) {
+func OnUserDelete(id []uint64, errorFunc func(string, ...interface{}) error) error {
 	UserLock.Lock()
 	defer UserLock.Unlock()
 
 	if len(id) < 1 {
-		return
+		return Localizer.ErrorT("user id not specified")
 	}
 
 	var (
-		cron   bool
+		cron, server   bool
-		server bool
+		crons, servers []uint64
 	)
 
 	for _, uid := range id {
-		secret := UserIdToAgentSecret[uid]
+		err := DB.Transaction(func(tx *gorm.DB) error {
-		delete(AgentSecretToUserId, secret)
+			CronLock.RLock()
-		delete(UserIdToAgentSecret, uid)
+			crons = model.FindUserID(CronList, uid)
+			CronLock.RUnlock()
 
-		CronLock.RLock()
+			cron = len(crons) > 0
-		crons := model.FindUserID(CronList, uid)
+			if cron {
-		CronLock.RUnlock()
+				if err := tx.Unscoped().Delete(&model.Cron{}, "id in (?)", crons).Error; err != nil {
+					return err
+				}
+			}
 
-		cron = len(crons) > 0
+			SortedServerLock.RLock()
-		if cron {
+			servers = model.FindUserID(SortedServerList, uid)
-			DB.Unscoped().Delete(&model.Cron{}, "id in (?)", crons)
+			SortedServerLock.RUnlock()
-			OnDeleteCron(crons)
-		}
 
-		SortedServerLock.RLock()
+			server = len(servers) > 0
-		servers := model.FindUserID(SortedServerList, uid)
+			if server {
-		SortedServerLock.RUnlock()
-
-		server = len(servers) > 0
-		if server {
-			DB.Transaction(func(tx *gorm.DB) error {
 				if err := tx.Unscoped().Delete(&model.Server{}, "id in (?)", servers).Error; err != nil {
 					return err
 				}
 				if err := tx.Unscoped().Delete(&model.ServerGroupServer{}, "server_id in (?)", servers).Error; err != nil {
 					return err
 				}
-				return nil
+			}
-			})
 
+			if err := tx.Unscoped().Delete(&model.Transfer{}, "server_id in (?)", servers).Error; err != nil {
+				return err
+			}
+
+			if err := tx.Where("id IN (?)", id).Delete(&model.User{}).Error; err != nil {
+				return err
+			}
+			return nil
+		})
+
+		if err != nil {
+			return errorFunc("%v", err)
+		}
+
+		if cron {
+			OnDeleteCron(crons)
+		}
+
+		if server {
 			AlertsLock.Lock()
 			for _, sid := range servers {
 				for _, alert := range Alerts {
@@ -93,10 +108,13 @@ func OnUserDelete(id []uint64) {
 					}
 				}
 			}
-			DB.Unscoped().Delete(&model.Transfer{}, "server_id in (?)", servers)
 			AlertsLock.Unlock()
 			OnServerDelete(servers)
 		}
+
+		secret := UserIdToAgentSecret[uid]
+		delete(AgentSecretToUserId, secret)
+		delete(UserIdToAgentSecret, uid)
 	}
 
 	if cron {
@@ -106,4 +124,6 @@ func OnUserDelete(id []uint64) {
 	if server {
 		ReSortServer()
 	}
+
+	return nil
 }